Capítulo 8: LED para Maker Intermediário
Domine LEDs Endereçáveis: Protocolo, Alimentação e Performance para Quem Já Sabe o BásicVocê já faz a fita acender. Agora vamos entender o que acontece dentro do fio.
O ponto de virada
Na Trilha 1 você aprendeu a fazer funcionar. Aqui a pergunta muda: por que funciona — e onde exatamente quebra.
Isso importa por uma razão prática. Projetos intermediários falham por motivos que o iniciante nunca vê: um efeito que trava quando a fita passa de 400 LEDs, uma cor que sai errada em apenas um trecho, uma fita que funciona no Arduino e não no ESP32. Nenhum desses problemas se resolve mexendo no código. Todos se resolvem entendendo o protocolo.
Este capítulo é o alicerce dos próximos. Vamos abrir o sinal de dados, medir o que realmente acontece no fio, e estabelecer o modelo mental que você vai usar para diagnosticar qualquer falha daqui para frente.
O que realmente viaja no fio de dados
O WS2812B não usa I²C, SPI ou UART. Ele usa um protocolo proprietário de um fio só, com codificação por largura de pulso (PWM codificado em tempo).
O sinal é uma sequência de pulsos. Um bit 0 e um bit 1 têm o mesmo período total (1,25µs), mas larguras de pulso alto diferentes:
| Bit | Pulso alto (T0H / T1H) | Pulso baixo | Período total |
|---|---|---|---|
| 0 | 0,4µs (±150ns) | 0,85µs | 1,25µs |
| 1 | 0,8µs (±150ns) | 0,45µs | 1,25µs |
Cada LED consome 24 bits (8 para verde, 8 para vermelho, 8 para azul, nessa ordem — GRB, não RGB). Depois de receber seus 24 bits, o chip trava a cor, regenera o sinal e repassa os bits seguintes ao próximo LED.
👉 A consequência prática: o protocolo não tem endereço. O "endereço" de cada LED é simplesmente a posição dele na cadeia. É por isso que a ordem física importa e por que um LED queimado no meio da fita não interrompe os seguintes — ele regenera o sinal.
⚠️ A tolerância é apertada. ±150ns em 800kHz significa que o timing precisa ser preciso em cerca de 12% do período. Isso explica boa parte dos problemas de compatibilidade que você vai encontrar.
Por que o reset precisa de silêncio
Para o chip entender que um quadro terminou e outro começou, o fio precisa ficar em nível baixo por um tempo mínimo — o chamado reset time ou latch.
Aqui está o detalhe que quase ninguém documenta: o valor mínimo varia entre lotes de fabricante. A especificação original diz 50µs. Na prática:
- Lotes antigos: aceitam 50µs
- Lotes novos (2020+): alguns exigem 280µs
- WS2813 e WS2815: 300µs recomendado
Se o seu código gera 50µs de silêncio e a fita é de um lote que exige 280µs, o resultado é o sintoma clássico: o primeiro LED fica com a cor do quadro anterior ou a fita mostra cores deslocadas em uma posição.
Quadro 1: [LED0][LED1][LED2]...[LEDn] → silêncio → Quadro 2
↑
se curto demais, o chip
não reconhece o fim do quadro
Na prática, use sempre 300µs de silêncio. Custa nada e elimina a categoria inteira desse bug. FastLED e NeoPixel já fazem isso por padrão nas versões recentes — mas se você está escrevendo driver próprio, esse é o primeiro lugar onde o projeto quebra.
O modelo mental: buffers, não pixels
Aqui está a mudança conceitual mais importante deste capítulo.
Quando você chama fita.setPixelColor(5, vermelho), nada acontece na fita. Você está escrevendo em um buffer de memória no microcontrolador — um array de 3 bytes por LED.
Só quando você chama show() esse buffer inteiro é serializado em pulsos e enviado pelo fio. A fita nunca sabe o que é "LED 5"; ela recebe uma corrente de bits e cada chip pega os 24 primeiros que vê.
Isso tem três consequências que definem como você programa daqui para frente:
Você pode montar o quadro inteiro antes de enviar. Desenhe todos os LEDs, depois um único show(). Nunca chame show() dentro de um loop de LEDs — você estaria enviando a fita inteira N vezes.
O buffer é seu único estado. Não existe "ler a cor atual da fita". O WS2812B não tem leitura. Se você perder o buffer, perdeu o estado — não há como recuperar da fita.
O custo é memória. 3 bytes por LED. 1.000 LEDs = 3KB de RAM. No Arduino Uno (2KB de RAM total), isso é impossível — o limite prático é cerca de 500 LEDs, e olhe lá. No ESP32 (520KB), 10.000 LEDs não é problema.
👉 Atalho de diagnóstico: se seu projeto reinicia sozinho ou mostra cores aleatórias com fitas grandes, suspeite de falta de RAM antes de suspeitar de hardware. É a causa mais comum e a menos óbvia.
Medindo o sinal de verdade
Você não precisa acreditar em mim. Dá para ver o protocolo com um osciloscópio de R$ 200 (ou um analisador lógico de R$ 80).
O que verificar:
Ponto 1 — largura do pulso alto. Deve ser ~0,4µs para bit 0 e ~0,8µs para bit 1. Se estiver fora, seu driver está errado ou o clock do microcontrolador está descalibrado.
Ponto 2 — nível de tensão. Deve chegar a 5V no primeiro LED. Se chegar a 3,3V (ESP32 sem level shifter), você está no limite da especificação — e é aqui que aparecem as falhas intermitentes.
Ponto 3 — silêncio entre quadros. Deve ser ≥280µs. Se estiver curto, o latch falha.
Ponto 4 — integridade da borda. Em fitas longas ou com cabo longo entre controlador e fita, a borda do pulso "amolece" (ringing). Se a borda estiver muito degradada, adicione um resistor de 33Ω a 100Ω em série no fio de dados, próximo ao controlador.
⚠️ Não tem osciloscópio? Use um analisador lógico barato com software livre. Você não precisa de precisão de 1ns — precisa ver se o pulso está em 0,4µs ou em 2µs. Isso já resolve 90% dos diagnósticos.
O código: driver mínimo sem biblioteca
Entender o protocolo de verdade significa conseguir escrevê-lo. Este é um driver didático — não use em produção, mas leia cada linha.
<code>
// Driver mínimo WS2812B — didático, sem biblioteca
#define PINO_DADOS 6
#define QTD_LEDS 8
uint8_t buffer[QTD_LEDS * 3]; // GRB por LED
// Envia um byte, MSB primeiro
void enviarByte(uint8_t b) {
for (int i = 7; i >= 0; i--) {
if (b & (1 << i)) {
// Bit 1: alto 0,8µs, baixo 0,45µs
digitalWrite(PINO_DADOS, HIGH);
delayMicroseconds(1); // aproximado
digitalWrite(PINO_DADOS, LOW);
// o próprio custo das chamadas completa o timing
} else {
// Bit 0: alto 0,4µs, baixo 0,85µs
digitalWrite(PINO_DADOS, HIGH);
// sem delay — a instrução já consome ~0,4µs
digitalWrite(PINO_DADOS, LOW);
delayMicroseconds(1);
}
}
}
void mostrar() {
noInterrupts(); // timing não pode ser interrompido
for (int i = 0; i < QTD_LEDS * 3; i++) {
enviarByte(buffer[i]);
}
interrupts();
delayMicroseconds(300); // latch: silêncio de 300µs
}
void setup() {
pinMode(PINO_DADOS, OUTPUT);
digitalWrite(PINO_DADOS, LOW);
memset(buffer, 0, sizeof(buffer));
}
void loop() {
// LED 0 vermelho
buffer[0] = 0; // G
buffer[1] = 255; // R
buffer[2] = 0; // B
mostrar();
delay(500);
memset(buffer, 0, sizeof(buffer));
mostrar();
delay(500);
}
</code>
O que este código ensina (e por que você não deve usá-lo em produção):
noInterrupts() é obrigatório. Se uma interrupção (timer, Serial, Wi-Fi) acontecer no meio do envio, o timing quebra e a fita mostra cores erradas. É exatamente por isso que o Wi-Fi do ESP32 e o WS2812B brigam — e por que o FastLED tem tratamento especial para isso.
O delayMicroseconds(1) é impreciso. A resolução real é de ~1µs, e o protocolo precisa de 0,4µs. Por isso o driver funciona "na sorte" em alguns Arduinos e falha em outros. Bibliotecas sérias usam assembly ou periféricos de hardware (RMT no ESP32, SPI no APA102).
👉 O que isso prova: se você entendeu este código, entendeu o protocolo. Agora as bibliotecas deixam de ser caixa-preta — e você consegue diagnosticar quando elas falham.
Os 3 erros do Capítulo 8 da Trilha 2
1. Achar que setPixelColor muda a fita. Ele muda o buffer. Só show() envia. Chamar show() dentro de loops é a causa nº 1 de animação lenta.
2. Ignorar o reset time. Lotes novos exigem 280µs a 300µs de silêncio. Se você escreve driver próprio com 50µs, o primeiro LED vai errar a cor de forma aparentemente aleatória.
3. Não checar RAM em fitas grandes. 3 bytes por LED. Arduino Uno (2KB) não passa de ~500 LEDs. ESP32 (520KB) aguenta muito mais. Reinício espontâneo com fita grande quase sempre é memória, não fonte.
O que vem no Capítulo 9
Agora que você entende o protocolo, o próximo passo é o que mais gera dúvida no nível intermediário: FastLED vs. WLED vs. Adafruit NeoPixel. Não como comparação de features, mas como decisão de arquitetura — qual delas resolve qual problema, e por que escolher errado custa semanas de retrabalho.
Resumindo
- O WS2812B usa protocolo de 1 fio com codificação por largura de pulso: bit 0 = 0,4µs alto, bit 1 = 0,8µs alto, período de 1,25µs, 24 bits por LED em ordem GRB.
- Não existe endereço no protocolo — o "endereço" é a posição na cadeia. Cada chip regenera o sinal e repassa adiante.
- O reset entre quadros precisa de 280µs a 300µs de silêncio; lotes novos não aceitam os 50µs da especificação original.
- setPixelColor escreve em buffer de RAM, não na fita. 3 bytes por LED — falta de RAM causa reinício espontâneo em fitas grandes.
- noInterrupts() durante o envio é obrigatório; é por isso que Wi-Fi e WS2812B brigam no ESP32.