Como montar capacete do Daft Punk com microcontroladores e Arduino


#1

Fala moçada, interessante esse forum, estou tentando montar o circuito do capacete do DAFT PUNK do Thomas que tem um painel de led programável de mensagem na frente e estou precisando de ajuda. Não tenho nenhum conhecimento de microcontroladores, mas sou sou curioso.

Estou pretendendo usar 4 dessa placa que vi no ML “[http://goo.gl/1lQezE][1]” junto com arduino… como o painel é vazado para poder ver o outro lado vou ter que soldar os leds e montar uma grade.
Vou retirar os leds das placas e plugar as placas uma nas outras no encaixe de cada lado e unir ao grade de led.
Quero sabe como faço isso, se alguem tem um esquema completo e se tem como programar de maneira fácil o arduino para passar o texto que quiser, se há algum programa. Quero saber se vai funcionar como no modelo aqui.

Programa que achei para programar arduino,(funciona)???

http://www.electronics123.com/Accessories/Programmable-5-x-7-Modular-LED-Matrix-Display.html


#2

Acho que você precisaria de uma matriz de LED’s flexível e não esta que achou. Tente verificar esta: http://www.seeedstudio.com/depot/8x32-RGB-LED-Matrix-w-WS2812B-DC-5V-p-2012.html?cPath=34


#3

Essa não dá pq a grade de led vai ser inserida em um visor… precisar ver do outro lado… Obriago pela dica… se tiver algo mais me contacte…


#4

Então, por esse motivo, a que você mostrou também não dá, porque também é opaca e pior, é rígida. A melhor opção para poder fazer com que o usuário enxergue também, é a do vídeo. A matriz de LED’s foi montada manualmente com CI’s drivers para direcionar os arrays, possívelmente um CI MAXIM 7219 ou 7221.


#5

Não sei se vai ajudar mas na Adafruit eles fizeram este capacete que ficou bem massa: https://www.youtube.com/watch?v=2v-N7TR1_og


#6

Interessante… vlw zotequi…


#7

Eu acho que nessa solução a visão fica obstruída também, só perceber que a luz dos LED’s passa com extrema dificuldade, mas é um projeto rápido e até que funcional, se desconsiderarmos o fato que você vai dançar a noite toda distribuindo socos nas gatas.

Pelo que pesquisei, o melhor capacete que fizeram, usaram uma placa plástica transparente para fixar a matriz e outra placa plástica sobre esta, pintada com o mesmo pigmento utilizado para fazer películas, tira um tempinho para ver o trabalho que dá para chegar a uma qualidade de réplica… mas pelo menos o cara vende detalhes dos projetos dele incluindo o molde do capacete.

Mesmo assim, ele foi bem claro: A visão fica obstruída quando os LED’s estão ligados, mas quando desligados dá para andar normalmente enxergando pela grade, com uma visão limitada, devo mencionar também, que no projeto eletrônico foi necessário adicionar duas ventoinhas porque ninguém aguenta o calor que um negócio desses gera na cabeçola sem ventilação. “Human After All…”


#8

Bacana… eu já fiz os 2 capacetes… o meu tem entradas de ar… conseguir evoluir na base da raça… motei a grade ta funfando só falta um SKETCH arduino com animação de texto nas matrix de 32x8…
Tenho o Arduino Leonardo, não sei nada de código, o que achei é esse com 3 abas. Só ta dando erro na aba “animation.h” mostra que “uint8_t animation[][16] = {” ta errado
S e alguém fraga o código me da um help.

################### aba: Led Matrix Shifted #######################

#include <TimerOne.h>

#include “Shifting.h”
#include “animation.h”

#define PWM_LEVELS 4

int clockPin = 2;
int latchPin = 4;
int dataPin = 8;

int timerDelay = 1400;
byte pwmCounter = 0;
byte brightnesses[64];

void iProcess() {
int rowOn, colsOn, c;
for(int r=0; r<8; ++r) {
rowOn = ~(1<<r);
colsOn = 0;
for(c=0; c<8; ++c) {
colsOn |= (pwmCounter < brightnesses[r * 8 + c])<<c;
}

shiftOutByte(dataPin, clockPin, MSBFIRST, rowOn);
shiftOutByte(dataPin, clockPin, MSBFIRST, colsOn);
bitOut(latchPin, LOW);
bitOut(latchPin, HIGH);

if(++pwmCounter > PWM_LEVELS) pwmCounter = 0;

}
}

void setup() {
pinMode(clockPin, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);

Timer1.initialize(timerDelay);
Timer1.attachInterrupt(iProcess);
}

unsigned long nextImage = 0;
int animationIndex = -1;

void loop() {
if(millis() > nextImage) {
if(++animationIndex >= animationFrames) animationIndex = 0;
nextImage = millis() + animationDelays[animationIndex];
for(int i=0; i<(88); ++i) {
brightnesses[i] = (animation[animationIndex][i/4] >> (i%4
2)) & B00000011;
}
}
}

################### Aba: Shifiting #######################
#ifndef SHIFTING_H
#define SHIFTING_H

#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))

#define sbipin(pin) sbi((pin)<8 ? PORTD:PORTB, (pin) - ((pin)<8 ? 0:8))
#define cbipin(pin) cbi((pin)<8 ? PORTD:PORTB, (pin) - ((pin)<8 ? 0:8))

#define bitOut(pin, val) {
if ((val) == LOW) cbipin(pin);
else sbipin(pin);
}

#define shiftOutBit(dataPin, clockPin, val, bit) {
bitOut(dataPin, ((val) & (1 << (bit))) ? HIGH:LOW);
bitOut(clockPin, HIGH);
bitOut(clockPin, LOW);
}

#define shiftOutByte(dataPin, clockPin, bitOrder, val) {
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?0:7);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?1:6);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?2:5);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?3:4);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?4:3);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?5:2);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?6:1);
shiftOutBit(dataPin, clockPin, val, (bitOrder) == LSBFIRST ?7:0);
}

#endif

################### Aba: Animation #######################
int animationFrames = 28;

int animationDelays[] = { 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 2000 };

// Animation is designed for 8x8 pixels
uint8_t animation[][16] = {
{ 0x3, 0x0, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0, 0x3, 0x0 },
{ 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0, 0xf, 0x0 },
{ 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0, 0x3f, 0x0 },
{ 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0 },
{ 0xff, 0x3, 0xff, 0x3, 0xff, 0x3, 0xff, 0x3, 0xff, 0x3, 0xff, 0x3, 0xff, 0x3, 0xff, 0x3 },
{ 0xff, 0xf, 0xff, 0xf, 0xff, 0xf, 0xff, 0xf, 0xff, 0xf, 0xff, 0xf, 0xff, 0xf, 0xff, 0xf },
{ 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f },
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
{ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa },
{ 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 },
{ 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x45, 0x51 },
{ 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x45, 0x51, 0x0, 0x0 },
{ 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x45, 0x51, 0x0, 0x0, 0x0, 0x0 },
{ 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x45, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x55, 0x55, 0x55, 0x55, 0x45, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x55, 0x55, 0x45, 0x51, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x40, 0x0, 0x40, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x80, 0x0, 0x40, 0x0, 0x40, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0xc0, 0x0, 0x80, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0xc0, 0x0, 0xf0, 0x3, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0xc0, 0x0, 0x10, 0x1, 0xcc, 0xc, 0x10, 0x1, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x60, 0x2, 0x8, 0x8, 0x4, 0x4, 0x8, 0x8, 0x60, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 },
{ 0x4, 0x4, 0x1, 0x10, 0x0, 0x0, 0x1, 0x10, 0x4, 0x4, 0x10, 0x1, 0x0, 0x0, 0x0, 0x0 },
{ 0x1, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x0, 0x0, 0x0, 0x0 },
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }
};