Plataforma de driver de LED Rainbowduino - ATmega328
![]() | ![]() |
|---|
A placa Rainbowduino é uma placa controladora compatível com Arduino com capacidade profissional de acionamento de LED. Ela irá controlar uma matriz de LED RGB 8x8 (ânodo comum).
-
Nenhum circuito externo necessário, conecte e brilhe!
-
24 canais de corrente constante de 120mA cada
-
8 canais de driver de fonte de 500mA cada
-
Ampla adaptação de tensão de saída de 6,5V-12VDC
-
GPIO e ADC dedicados
-
Comunicação UART e I2C por hardware
-
Cascateamento fácil
-
Formato pequeno e peso leve
Modo autônomo (plug and shine)
Hardware necessário:
-
1 x Rainbowduino
-
1 x Matriz de LED RGB
O modo de trabalho mais simples, nenhum sistema externo é necessário (apenas um adaptador serial TTL para enviar o firmware). O conteúdo da matriz de LED é gerado pelo próprio Rainbowduino.
Caso de uso:
-
Animações simples em tempo real calculadas pelo Rainbowduino
-
Exibir animações pré-armazenadas, limitado devido à ROM de 32kb do Rainbowduino
Modo UART
Hardware necessário:
-
1x Rainbowduino
-
1x Matriz de LED RGB
-
1x Conversor de nível TTL
-
1x unidade transmissora UART (Arduino, PC...)
Envie dados (conteúdo da matriz de LED) do seu computador para um Rainbowduino. Como o Rainbowduino não possui um conector USB, mas sim uma conexão serial TTL, você precisa de um conversor de nível serial TTL (BusPirate, UartSBee, Arduino...).
Caso de uso:
Quadros gerados por PC ou Arduino exibidos em UMA matriz de LED
Modo I2C
Hardware necessário:
-
1..n x Rainbowduino
-
1..n x Matriz de LED RGB
-
1 x dispositivo mestre I2C (por exemplo, um Arduino)
-
Alguns cabos
Envie dados (conteúdo da matriz de LED) do seu computador para múltiplos Rainbowduinos. Uma observação se você usar um Arduino com um adaptador FTDI USB para Serial (Duemillanove, Diecimila...) - há uma latência de ~16ms para enviar dados do seu computador para o Arduino. O novo Arduino UNO tem uma latência muito menor, ~4ms.
Caso de uso:
Quadros gerados por PC ou Arduino exibidos em múltiplas matrizes de LED

Cascateamento I2C
O Rainbowduino é projetado para fácil cascateamento. Depois de conectado fisicamente, a alimentação é repassada e você pode controlar a cadeia por I2C. Observe que cada Rainbowduino deve receber um endereço exclusivo para comunicação I2C.
Prepare a conexão de alimentação:

Rainbowduino em cascata:

Especificação
-
Microprocessador: Atmega 328
-
Tamanho da PCB: 60mm 60mm 1,6mm
-
Indicadores: Reset, Power, LED do pino 13
-
Fonte de alimentação: 6,5-12 VDC (9 VDC recomendado)
-
Conector de alimentação: blocos terminais JST de 2 pinos, conectores DC de 3mm
-
Conector de alimentação para cascateamento: blocos terminais
-
Interface de programação: UART / ISP
-
Soquetes de matriz de pontos de LED: 32
-
Soquete de expansão: par de pinos angulados de 2,54mm
-
Protocolos de comunicação: I2C / UART
-
RHOS: Sim
-
Tensão de entrada: 6,5~12V
-
Consumo global de corrente: 600~2000mA
-
Canais de corrente constante (cátodo): 24
-
Corrente constante por canal (cátodo): 20~120mA
-
Corrente do driver de fonte por canal (ânodo comum): 500mA
-
Tensão do driver de fonte por canal (ânodo comum): 9~12V
-
Canais de driver de fonte: 8
-
Quantidade de LEDs acionados: 192
-
Tempo de resposta do circuito: 10ns
-
Resolução de cor da matriz de LED RGB por ponto: 4096: Taxa de baud Uart: 115200baud
Compatibilidade de dispositivos LED
Antes de conectar diretamente nos cabeçalhos de pinos fêmeas, verifique se a matriz de pontos RGB é comprovadamente compatível. A preocupação é principalmente com o pinout, onde LEDs da mesma cor estão em grupo; aqui anexamos o esquema e a demonstração em foto. A sequência de cores pode mudar, já que a lógica de controle é open source e facilmente reprogramável.

A potência do Rainbowduino vai muito além de acionar uma matriz de pontos RGB. Com 192 saídas e até 120mA de capacidade de corrente constante, você pode facilmente montar configurações massivas de LED.
A corrente de saída de cada canal (IOUT) é definida por um resistor externo, Rext. A relação entre Iout e Rext é mostrada na figura a seguir. Consulte o datasheet do MBI5168 para mais detalhes. Ajuste o potenciômetro de 1k no sentido horário para reduzir a corrente de saída (mínimo padrão de 20mA para matriz de pontos RGB), girando no sentido anti-horário para aumentar a corrente de saída. Os potenciômetros são de um único giro, observe que força excessiva irá quebrá-los em rotação ilimitada, então você precisará de um multímetro para ajustar. :)
Isso significa que você pode construir sua própria matriz de LED sem quaisquer resistores adicionais.

Demonstração
Requisitos
-
Placa Rainbowduino
-
Uma matriz RGB de ânodo comum
-
Uma placa Arduino (opcional)

Conecte a matriz de LED RGB ao Rainbowduino e conecte o "Pino 1" ao bloco de conexão vermelho. O Pino 1 é marcado por um ponto de solda quadrado, enquanto os outros pinos usam um ponto de solda redondo.
Enviar firmware- Envie um trecho de código para o Arduino primeiro: Para usar o Arduino para enviar o firmware para o Rainbowduino, certifique-se de que o Arduino esteja limpo - precisamos enviar um sketch de firmware vazio como mostrado abaixo.
void setup() {}
void loop() {}
- Enviar firmware para o Rainbowduino
Abra o firmware do Rainbowduino, selecione a placa correta (Tools-->board--> Arduino Duemilanove or Nano w/ ATmega328) e envie o firmware. Pelo menos essa é a teoria ;)
For your viewing pleasure, here is the connection scheme:

Usamos uma fonte de alimentação externa, porém você também pode usar os 5V do Arduino.
NOTA: Se você possui uma placa Rainbowduino v1, precisa selecionar "Arduino Diecimila, Duemilanove, or Nano w/ ATmega168"!
| Arduino | Rainbowduino | RESET | DTR | GND | GND | RX | RX | TX | TX |
|---|
- Use UartSB para enviar firmware
Essas capturas de tela mostram como conectar o UartSBee ao Rainbowduino:
![]() | ![]() |
|---|
Se você conectar o UartSBee à porta USB, ele deverá registrar uma nova porta serial. Agora basta enviar seu firmware usando a nova porta serial.
- Use um Buspirate para enviar firmware / bootloader
Vou explicar três métodos de programação (todos usando o buspirate):
- programação através do ISP.
- programação usando avrdude e reset manual (sem necessidade de patch)
- programação através do avrdude com um pequeno patch.
DESCONECTE O RAINBOWDUINO DO DISPLAY E DA ALIMENTAÇÃO.
PASSO 1: Para usar o Buspirate você precisa de uma nova versão do avrdude [1]. Estou usando a versão 5.10 e ela reconhece a opção de programador '-c buspirate'. Você pode testar isso com
./avrdude -c buspirate -C ./avrdude.conf
Se isso reclamar sobre o programador, então você precisa de uma versão mais recente do buspirate.
PASSO 2: conecte o buspirate ao conector ISP do rainbowduino desta forma:
| Buspirate | ISP | ISP pin |
|---|---|---|
| GND | GND | 6 |
| +5V | Vcc | 2 |
| CS | RESET | 5 |
| MOSI | MOSI | 4 |
| MISO | MISO | 1 |
| SCL/CLK | SCK | 3 |
PASSO 3: encontre o bootloader correto (estou usando o tiny optiboot firmware). Copie este arquivo para o diretório recém-compilado do avrdude.
PASSO 4: programe o atmega 328p com
./avrdude -v -c buspirate -p m328p -C ./avrdude.conf -P /dev/ttyUSB0 -U flash:w:optiboot_atmega328.hex
Isso leva muito tempo...
Comecei enviando firmwares sem o bootloader e isso funciona bem. O truque é obter os arquivos HEX da IDE do Arduino. Na versão 0.22-Linux eles são armazenados em /tmp/buildXXXXXXXXXXXX e NÃO no diretório de sketches. Basta acionar o comando 'Upload' sem nenhum programador conectado (pressione <shift> enquanto pressiona o botão 'upload' para obter muitas informações de depuração da IDE do Arduino).
Depois que você tiver o bootloader no rainbowduino, poderá usar a interface serial transparente do buspirate. Defina a taxa de baud para 115200 e insira o macro '(3)' para ativar o modo transparente. O buspirate agora atua como um conversor USB-serial (qualquer outro conversor USB-serial tipo FTDI poderia ser usado). O problema com o buspirate é que não há DTR para resetar o arduino. Agora você precisa cronometrar o reset e o envio manualmente. Pressionar reset após iniciar o envio parece funcionar melhor.
HiZ>m
1. HiZ
2. 1-WIRE
3. UART
4. I2C
5. SPI
6. JTAG
7. RAW2WIRE
8. RAW3WIRE
9. PC KEYBOARD
10. LCD
(1) >3
Mode selected
Set serial port speed: (bps)
1. 300
2. 1200
3. 2400
4. 4800
5. 9600
6. 19200
7. 38400
8. 57600
9. 115200
10. 31250 (MIDI)
(1) >9
Data bits and parity:
1. 8, NONE *default
2. 8, EVEN
3. 8, ODD
4. 9, NONE
(1) >
Stop bits:
1. 1 *default
2. 2
(1) >
Receive polarity:
1. Idle 1 *default
2. Idle 0
(1) >
Select output type:
1. Open drain (H=Hi-Z, L=GND)
2. Normal (H=3.3V, L=GND)
(1) >2
READY
UART>(3)
UART bridge. Space continues, anything else exits.
Reset to exit.
Depois disso, você pode programar o Arduino com o bootloader:
./avrdude -v -c stk500v1 -p m328p -b 115200 -F -C ./avrdude.conf -P /dev/ttyUSB0 -U flash:w:Rainbow_Plasma.cpp.hex
Um passo adiante é aplicar um patch no avrdude no arquivo 'arduino.c'. O buspirate envia o sinal 'rts' com a polaridade errada para o Arduino, mas trocando 1 por 0 e 0 por 1 isso é corrigido. A partir de então você deve escolher 'arduino' como programador em vez de 'stk500v1'.
static int arduino_open(PROGRAMMER * pgm, char * port)
{
fprintf(stderr, "arduino_open...\n");
strcpy(pgm->port, port);
serial_open(port, pgm->baudrate? pgm->baudrate: 115200, &pgm->fd);
/* Clear DTR and RTS to unload the RESET capacitor
* (for example in Arduino) */
serial_set_dtr_rts(&pgm->fd, 1);
usleep(50*1000);
/* Set DTR and RTS back to high */
serial_set_dtr_rts(&pgm->fd, 0);
usleep(50*1000);
/*
* drain any extraneous input
*/
stk500_drain(pgm, 0);
if (stk500_getsync(pgm) < 0)
return -1;
return 0;
}
Observação: altere o tipo de programador usado pela IDE do Arduino no arquivo 'boards.txt'.
Fonte: buspirate-avr-programming [2], Bus_Pirate_AVR_Programming [3], Optiboot [4]
Firmware Rainbowdunio
Firmware NeorainbowduinoEste pacote de firmware vem com dois firmwares (um para um Arduino, outro para o Rainbowduino) e uma biblioteca Processing. Você pode enviar dados de qualquer aplicação via linha serial para o Arduino - o Arduino então envia as imagens para o dispositivo Rainbowduino correspondente. Eu criei uma biblioteca Processing fácil de usar para começar.
Fonte: http://code.google.com/p/neorainbowduino/
Recursos:
-
Firmware habilitado para I2C (suporta múltiplos Rainbowduinos)
-
Biblioteca Processing, para que você possa controlar facilmente seu Rainbowduino a partir do Processing!
-
Envie quadros completos do Processing para o Rainbowduino
-
Envie quadros do Processing para sua matriz RGB, cada quadro tem um tamanho de 8x8 pixels, resolução de cor de 12 bits (4096 cores). A conversão de cores é tratada pela biblioteca
-
Biblioteca Processing otimizada - envie quadros para o Rainbowduino apenas quando necessário (economize ~50% do tráfego - claro que depende dos seus quadros)
-
Troca de buffer corrigida (sem mais cintilação)
-
Adicionado scanner de barramento I2C, encontre seus Rainbowduinos se você esquecer seus endereços
Modos de trabalho suportados: I2C
RequisitosEste firmware permite que você use o Processing para controlar o Rainbowduino, então é óbvio que você precisa de:
- Software Processing, obtenha em http://processing.org/
Como o firmware neorainbowduino envia quadros completos via I2C (92 bytes), precisamos aplicar um patch no tamanho do buffer I2C para o Arduino (para otimizar a velocidade de transferência). Espero que o Arduino suporte tamanho de buffer variável em um futuro próximo. Certifique-se de que sua IDE do Arduino esteja fechada ao aplicar os patches nos arquivos!
Arquivo a ser modificado: Java/libraries/Wire/utility/twi.h
Motivo: Aumentar a velocidade I2C de 100kHz para 400kHz, aumentar o tamanho do buffer I2C de 32 bytes para 98 bytes
Arquivo original#ifndef TWI_FREQ
#define TWI_FREQ 100000L
#endif
#ifndef TWI_BUFFER_LENGTH
#define TWI_BUFFER_LENGTH 32
#endif
#ifndef TWI_FREQ
#define TWI_FREQ **400000L**
#endif
#ifndef TWI_BUFFER_LENGTH
#define TWI_BUFFER_LENGTH **98**
#endif
x
Arquivo a ser modificado: Java/libraries/Wire/Wire.h
Motivo: Aumentar o tamanho do buffer Serial de 32 bytes para 98 bytes
| Arquivo original | Arquivo modificado |
|---|---|
#define BUFFER_LENGTH 32
#define BUFFER_LENGTH 98Carregar firmware para o Rainbowduino
Carregue o firmware (veja Upload Firmware), o arquivo de firmware de que você precisa é rainbowduinoFw/Rainbow_V2_71/Rainbow_V2_71.pde.
Observação: Este firmware usa o protocolo I2C para se comunicar - cada Rainbowduino precisa de um endereço I2C exclusivo. O endereço pode ser configurado editando o arquivo Rainbowduino.h (#define I2C_DEVICE_ADDRESS 0x06). Portanto, não se esqueça de alterar o endereço se você carregar este firmware em mais de um Rainbowduino!
Desconecte as linhas RX/TX entre o Rainbowduino e o Arduino. Carregue o firmware Arduino arduinoFw/neoLed/neoLed.pde no Arduino.
Interagir com o RainbowduinoEste capítulo mostrará uma maneira simples de se comunicar com seu Rainbowduino. Você precisa de um Arduino (funcionando como um gateway serial para I2C) e um Rainbowduino com um endereço I2C de 0x06.
A conexão entre o Rainbowduino e o Arduino deve ser assim:

Usamos uma fonte de alimentação externa, porém você também pode usar os 5V do Arduino.
| Arduino | Rainbowduino |
|---|---|
| RESET | DTR |
| GND | GND |
| Analog IN 4 | SDA |
| Analog IN 5 | SDL |
Depois de instalar o software Processing, você precisará instalar a biblioteca neorainbowduino. Você pode encontrar a biblioteca Processing no diretório processingLib\distribution\neorainbowduino-x.y\download. Descompacte o arquivo zip na sua pasta inicial do Processing (há um arquivo README.TXT dentro com instruções detalhadas de como instalar).
Quando você iniciar o Processing, deverá conseguir importar a biblioteca neorainbowduino):

Exemplo simples
Aqui está um sketch Processing bem simples para enviar alguns retângulos aleatórios para o Rainbowduino.
import processing.serial.*;
import com.neophob.lib.rainbowduino.test.*;
import com.neophob.lib.rainbowduino.*;
static final int SIZE = 400;
Rainbowduino r;
void setup() {
frameRate(15);
background(0);
size(SIZE, SIZE);
//initialize rainbowduino
List<Integer> list = new ArrayList<Integer>();
list.add(6); //use rainbowduino with slave id 6
try {
r = new Rainbowduino(this, list);
System.out.println("ping: "+r.ping());
} catch (Exception e) {
println("FAILED to open serial port!!");
e.printStackTrace();
}
smooth();
noStroke();
}
void draw() {
//draw some simple stuff on screen
color c1 = color(128+(int)random(64), 128, (int)random(255));
fill(c1);
int size = 80+(int)random(80);
int x = (int)random(SIZE);
int y = (int)random(SIZE);
rect(x, y, size, size);<br>
//send PApplet to the Rainbowduino lib - and send it to slave id 6
r.sendRgbFrame((byte)6, this);
}
TODO adicionar algumas capturas de tela
Como funciona o redimensionamento de imagem
A imagem será redimensionada usando um Filtro de Média de Área (Area Averaging Filter). Portanto, é importante saber que a imagem deve estar corretamente alinhada. Alinhada significa que o resultado fica bom se a imagem puder ser dividida por 8. Aqui está um exemplo bom e ruim:
| Bom exemplo (alinhado) | Exemplo ruim (não alinhado) |
|---|---|
![]() | ![]() |
![]() | ![]() |
Firmware mtXcontrol
Fonte: http://www.rngtng.com/mtxcontrol/
Recursos:
- mtXcontrol é um editor escrito em Processing para criar facilmente sequências de imagens para vários dispositivos de saída contendo matriz de LEDs multicoloridos.
Modos de trabalho suportados: ???
Firmware 3
Fonte: http://code.google.com/p/rainbowduino-firmware/
Recursos:
-
dupla armazenagem em buffer sincronizada com a taxa de atualização
-
4 buffers auxiliares
-
conjunto de instruções de alto nível
-
múltiplos hardwares controlados
-
protocolo de comunicação I2C
-
armazenamento permanente de dados em EEPROM
Modos de trabalho suportados: I2C
RainbowDashboard
Fonte: http://code.google.com/p/rainbowdash/
Recursos:
-
Base de código limpa e de fácil manutenção.
-
Compatível com o firmware padrão.
-
Suporta modo UART (nenhum host Arduino é necessário - comunicação direta com o Rainbowduino).
-
Operações gráficas com dupla armazenagem em buffer.
-
Relógio de tempo real por software.
-
Animação controlada pelo próprio Rainbowduino.
-
Conjunto de caracteres Windows ANSI completo (CP1252).
-
Conjunto de comandos de alto nível.
Modos de trabalho suportados: UART
Pode ser facilmente alterado para usar I2C; apenas um arquivo (RainbowDash.pde) precisa ser modificado.
rainbowduino-rs
Observação:
rainbowduino-rsé um projeto de firmware independente, desenvolvido pela comunidade e criado por jecaro para o Rainbowduino v2.0. Ele não é mantido nem suportado oficialmente pela Seeed Studio. Os usuários devem verificar a compatibilidade de hardware antes de gravar o firmware e usá-lo por sua própria conta e risco.

Fonte: https://github.com/jecaro/rainbowduino-rs
Recursos:
-
Firmware escrito em Rust
-
Recebe um framebuffer completo via I2C e o exibe continuamente
-
16 níveis de brilho (4 bits) por cor
-
Biblioteca mestre para controlar várias placas em cadeia como um único display, em qualquer arranjo (por exemplo, uma faixa 32x8 ou um quadrado 16x16, com placas de cabeça para baixo)
-
Firmware mestre de exemplo para um Arduino Uno
Modos de trabalho suportados: I2C
Como o firmware funciona
Microprocessador - Atmega 168/328
| PORTD | PORTB | PORTC |
|---|---|---|
| pin02 / PD0 / RXD | pin14 / PB0 / INT0 | pin23 / PC0 / SDI |
| pin03 / PD1 / TXD | pin15 / PB1 / INT1 | pin24 / PC1 / CLK |
| pin04 / PD2 / INT0 | pin16 / PB2 / INT2 | pin25 / PC2 / LE |
| pin05 / PD3 / INT19 | pin17 / PB3 / INT3 | pin26 / PC3 / OE |
| pin06 / PD4 / INT20 | pin18 / PB4 / INT4 | pin27 / PC4 / SDA |
| pin11 / PD5 / INT21 | pin19 / PB5 / INT5/SCK | pin28 / PC5 / SDL |
| pin12 / PD6 / INT22 | ||
| pin13 / PD7 / INT23 |
PORTB mapeia para os pinos digitais 8 a 13 do Arduino. Os dois bits mais altos (6 e 7) mapeiam para os pinos do cristal e não são utilizáveis.
PORTC mapeia para os pinos analógicos 0 a 5 do Arduino. Os pinos 6 e 7 são acessíveis apenas no Arduino Mini.
PORTD mapeia para os pinos digitais 0 a 7 do Arduino.
Driver de LED de corrente constanteEste driver usa o MBI5168. O MBI5168 é um shift register de 8 bits. Ele converte os dados seriais em dados paralelos. Todos os 3 MBI5168 compartilham as entradas LE, CLK e OE.

| Name | Desc |
|---|---|
| OE | Saída habilitada, quando em nível baixo (ativo), os drivers de saída são habilitados; quando em nível alto, todos os drivers de saída são desligados (em branco). |
| LE | Terminal de entrada de estrobe de dados. Os dados seriais são transferidos para o respectivo latch quando LE está em nível alto. Os dados são travados quando LE vai para nível baixo. |
| SDI | Entrada de dados seriais para o shift register. |
| SDO | Saída de dados seriais para o SDI seguinte do próximo CI driver. |
| R-EXT | Terminal de entrada usado para conectar um resistor externo para configurar a corrente de saída para todos os canais de saída. |
| CLK | Terminal de entrada de clock para deslocamento de dados na borda de subida |

Para exibir um quadro completo na matriz de LEDs, o método de interrupção do Rainbowduino precisa ser chamado 128 vezes. Existem 8 linhas e 16 níveis de brilho. Cada vez que o método displayNextLine() é chamado, uma linha é atualizada com o nível de brilho atual. Depois que todas as 8 linhas são atualizadas, o nível de brilho é atualizado. É por isso que essa função precisa de 128 ciclos até que um quadro completo seja preenchido na matriz de LEDs.
Abaixo você vê a matriz de LEDs após 32, 64, 96 e 128 ciclos. Você percebe como o brilho é aumentado.

O firmware original (e a maioria dos firmwares de terceiros) suporta resolução de cor de 12 bits. É possível aumentar isso:
| Color Resolution | Payload | Brightness Level |
|---|---|---|
| 12 bit (4bit por cor), 4096 cores | 96 bytes (12bit*64=768bit) | 16 |
| 15 bit (5bit por cor), 32768 cores | 120 bytes (15bit*64=960bit) | 32 |
O benefício de usar 4 bits por cor é o armazenamento de dados: um byte contém 2 valores de cor – assim, é fácil obter a cor de um buffer de bytes. Usar 5 bits por cor exige mais poder de CPU ou mais espaço de buffer (usar 2 bytes para 3 valores de cor – desperdiçando 1 bit por cor).
Para alcançar resolução de cor de 15 bits, o firmware precisa de duas alterações:
-
fazer loop sobre 32 em vez de 16 níveis de brilho
-
alterar a função de deslocamento de saída
Recursos
Suporte técnico e discussão sobre o produto
Obrigado por escolher nossos produtos! Estamos aqui para oferecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.








