Haztech

Peças, acessórios,
manutenção e projetos
de máquinas e equipamentos
para a indústria.

Divisão
Capa do artigo Capítulo 8: LED para Maker Intermediário

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.

Tamanho do texto

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.
← Anterior Próximo →

voltar

HAZTECH - Todos os direitos reservados -