Capítulo 5 — Matrizes, Múltiplas Fitas LEDs e o Level Shifter
Matriz de LED Endereçável e Múltiplas Fitas: Como Controlar 8x8, 4 Fitas Independentes e Resolver o 3,3V vs 5V Eyebrow: Capítulo 5 — Você já sabe tudo. Então por que a fita parou de funcionar?
O sintoma que humilha quem já sabe
Você migrou do Arduino para o ESP32. Ligou a fita. Funcionou perfeitamente em bancada. Montou no painel, com 4 fitas em pinos diferentes, e metade das fitas começou a piscar cores aleatórias — ou simplesmente não acendeu.
Você revisou o código dez vezes. Está correto. O problema não está no código.
Está em dois detalhes de hardware que ninguém documenta junto: o ESP32 fala 3,3V e o WS2812B espera 5V no sinal de dados, e cada fita consome um tempo de envio que precisa caber no orçamento de quadros. Este capítulo resolve os dois, mais a matriz 8x8 que é onde todo mundo trava.
O level shifter: por que 3,3V não é suficiente
O WS2812B especifica nível lógico alto (VIH) em 0,7 × VCC, ou seja, 3,5V para uma alimentação de 5V. O ESP32 entrega 3,3V nos pinos.
Ou seja: você está 0,2V abaixo do mínimo especificado. Funciona na bancada porque o primeiro LED da fita tolera um pouco de folga. Falha em campo porque:
- Fitas longas aumentam a capacitância e "amolecem" a borda do sinal
- Ruído elétrico dos LEDs embaralha a transição
- Lotes diferentes de chip têm tolerâncias diferentes
- Cabos longos entre ESP32 e fita degradam o sinal
👉 Regra prática: com ESP32, sempre use level shifter. Custa R$ 3 e elimina uma categoria inteira de bugs intermitentes que você vai passar semanas caçando.
As três opções, em ordem de qualidade:
74HCT245 — o padrão da comunidade. Octal buffer, aceita entrada de 3,3V e entrega 5V na saída. Um chip serve até 8 fitas. É o que você deve usar.
74AHCT125 — versão menor, 4 canais. Bom para 2 a 4 fitas. Mais fácil de soldar em protoboard.
Conversor lógico bidirecional (BSS138) — funciona, mas é lento demais para o protocolo de 800kHz em fitas longas. Evite para WS2812B.
A ligação do 74HCT245 é direta: VCC no 5V, GND comum, pino DIR no 5V (direção A→B), e cada pino do ESP32 entra em um A e sai no B correspondente para a fita.
⚠️ O erro que anula o level shifter: se o GND do lado de 3,3V e o GND do lado de 5V não estiverem ligados entre si, o chip não funciona. Terra comum sempre.
Múltiplas fitas: o orçamento de tempo
Aqui está a matemática que separa projeto de bancada de instalação real.
Você aprendeu no Capítulo 2 que cada show() custa tempo proporcional ao número de LEDs. Mas com múltiplas fitas, existe uma armadilha: no FastLED, FastLED.show() envia todas as fitas em sequência, uma após a outra. O tempo total é a soma.
Com 4 fitas de 150 LEDs cada:
T de envio = (150x4)x24/800.000 = 18 ms
Isso significa que você não consegue passar de 55fps, e na prática fica em torno de 40fps com o processamento dos efeitos. Aceitável. Mas se você dobrar para 8 fitas de 300 LEDs, chega a 72ms — ou seja, 14fps. A animação fica visivelmente travada.
A solução é não atualizar tudo em todo quadro. Três estratégias reais:
Rodízio de fitas. Atualize 2 fitas por quadro, alternando. O olho não percebe que metade da instalação está um quadro atrasada.
Efeitos com taxa própria. Uma fita de "respiração lenta" não precisa de 30fps. Dê a ela 10fps e libere orçamento para as fitas que precisam de fluidez.
Paralelismo por controlador. Um segundo ESP32 custa R$ 40. Divida 8 fitas em dois controladores sincronizados por rede. É o que instalações profissionais fazem.
O código: 4 fitas independentes
<code>
#include <FastLED.h>
#define QTD_FITAS 4
#define LEDS_POR_FITA 150
// Pinos do ESP32 (todos passam pelo level shifter!)
const uint8_t PINOS[QTD_FITAS] = {5, 18, 19, 21};
CRGB fitas[QTD_FITAS][LEDS_POR_FITA];
unsigned long ultimoQuadro = 0;
void setup() {
// Registra cada fita com seu pino
FastLED.addLeds<WS2812B, 5, GRB>(fitas[0], LEDS_POR_FITA);
FastLED.addLeds<WS2812B, 18, GRB>(fitas[1], LEDS_POR_FITA);
FastLED.addLeds<WS2812B, 19, GRB>(fitas[2], LEDS_POR_FITA);
FastLED.addLeds<WS2812B, 21, GRB>(fitas[3], LEDS_POR_FITA);
FastLED.setBrightness(100);
FastLED.setMaxPowerInVoltsAndMilliamps(5, 30000);
}
void loop() {
if (millis() - ultimoQuadro >= 25) { // 40fps
ultimoQuadro = millis();
// Cada fita tem seu próprio efeito e fase
for (int f = 0; f < QTD_FITAS; f++) {
for (int i = 0; i < LEDS_POR_FITA; i++) {
// Fase diferente por fita = efeito de onda entre painéis
uint8_t matiz = (i * 2 + millis() / 20 + f * 64) % 256;
fitas[f][i] = CHSV(matiz, 255, 255);
}
}
FastLED.show(); // envia todas as fitas de uma vez
}
}
</code>
O que você deve ver: quatro fitas com ondas de cor correndo, cada uma defasada em 90° da anterior. O conjunto parece uma única instalação sincronizada, não quatro fitas separadas.
👉 O detalhe que muda o resultado visual: o f * 64 no cálculo do matiz. Sem ele, as quatro fitas mostram exatamente a mesma cor no mesmo instante — o que parece bonito mas é previsível. Com o offset de fase, o conjunto ganha movimento próprio. É o truque que faz instalação de quatro fitas parecer uma só peça de design.
A matriz 8x8: onde todo mundo trava
Uma matriz 8x8 tem 64 LEDs. Mas o mapeamento não é linear — e é aí que 90% dos projetos param.
O problema: a fita física faz serpentina (vai da esquerda para a direita na primeira linha, depois volta da direita para a esquerda na segunda). Se você tratar como linear, o desenho sai espelhado nas linhas ímpares.
A solução é uma função de conversão de coordenadas:
<code>
#include <FastLED.h>
#define LARGURA 8
#define ALTURA 8
#define QTD_LEDS (LARGURA * ALTURA)
#define PINO_DADOS 5
CRGB leds[QTD_LEDS];
// Converte (x, y) para o índice real na fita em serpentina
int xy(int x, int y) {
if (y % 2 == 0) {
// Linha par: esquerda → direita
return y * LARGURA + x;
} else {
// Linha ímpar: direita → esquerda (invertido)
return y * LARGURA + (LARGURA - 1 - x);
}
}
void setup() {
FastLED.addLeds<WS2812B, PINO_DADOS, GRB>(leds, QTD_LEDS);
FastLED.setBrightness(80);
}
void loop() {
// Limpa a matriz
fill_solid(leds, QTD_LEDS, CRGB::Black);
// Desenha um quadrado se movendo na diagonal
int pos = (millis() / 300) % LARGURA;
for (int dx = 0; dx < 2; dx++) {
for (int dy = 0; dy < 2; dy++) {
int px = pos + dx;
int py = pos + dy;
if (px < LARGURA && py < ALTURA) {
leds[xy(px, py)] = CRGB::Cyan;
}
}
}
FastLED.show();
}
</code>
O que você deve ver: um bloco 2x2 ciano descendo na diagonal, atravessando a matriz de canto a canto, com o desenho correto — sem espelhamento nas linhas ímpares.
Se você remover o if (y % 2 == 0) e usar y * LARGURA + x direto, o bloco vai aparecer espelhado nas linhas 1, 3, 5 e 7. Esse é o bug clássico.
⚠️ Atenção ao sentido da serpentina: algumas matrizes começam pela direita, não pela esquerda. Se o seu desenho sair invertido na horizontal, troque LARGURA - 1 - x por x dentro do else. Teste com um único LED aceso antes de desenhar qualquer coisa complexa.
Texto na matriz (o efeito que impressiona)
Com a função xy() pronta, exibir texto vira uma questão de ter um mapa de bits de fonte. O FastLED tem uma biblioteca auxiliar, a LEDMatrix, que já traz fontes prontas:
<code>
#include <FastLED.h>
#include <LEDMatrix.h>
#define LARGURA 8
#define ALTURA 8
#define PINO_DADOS 5
cLEDMatrix<LARGURA, ALTURA, HORIZONTAL_ZIGZAG_MATRIX> matriz;
CRGB leds[(LARGURA * ALTURA)];
void setup() {
FastLED.addLeds<WS2812B, PINO_DADOS, GRB>(leds, LARGURA * ALTURA);
FastLED.setBrightness(60);
}
void loop() {
matriz.ShiftLeft(); // rola o conteúdo para a esquerda
matriz.DrawText(0, 0, "HAZTECH", CRGB::Orange);
FastLED.show();
delay(60);
}
</code
O que você deve ver: o texto "HAZTECH" rolando continuamente pela matriz, em laranja.
O HORIZONTAL_ZIGZAG_MATRIX na declaração já resolve a serpentina automaticamente — você não precisa da função xy() quando usa essa biblioteca. Mas entender o xy() importa: quando você quiser desenhar gráficos customizados, vai precisar dele.
👉 A dica de produção: rolagem de texto em matriz 8x8 fica ilegível abaixo de 50ms por passo e enjoativa acima de 100ms. 60ms é o ponto ideal. E nunca use fonte de largura 6+ pixels em matriz de 8 colunas — o caractere sai cortado.
Os 3 erros do Capítulo 5
1. Ligar ESP32 direto no WS2812B sem level shifter. Funciona na bancada e falha em campo, de forma intermitente. Você vai culpar o código, a fita, a fonte — e nunca vai achar, porque o problema é 0,2V de tensão.
2. Usar y * LARGURA + x em matriz serpentina. Metade das linhas sai espelhada. Sempre teste com um LED único em cada canto antes de desenhar.
3. Ignorar o orçamento de tempo com múltiplas fitas. FastLED.show() envia todas as fitas em sequência. Acima de 600 LEDs totais, você precisa de rodízio, taxas diferentes ou um segundo controlador.
O que vem no Capítulo 6
Você agora tem controle total de hardware e software. O próximo passo é o que transforma isso em produto vendável: gabinete, difusor, acabamento e impermeabilização. No Capítulo 6 você vai aprender por que o mesmo LED parece barato num painel e premium em outro — e a resposta está no difusor, não no LED.
Resumindo
- ESP32 é 3,3V e o WS2812B exige 3,5V no sinal: sem level shifter (74HCT245 ou 74AHCT125), a falha é intermitente e quase impossível de diagnosticar.
- FastLED.show() envia todas as fitas em sequência — o tempo total é a soma. Acima de 600 LEDs, use rodízio ou segundo controlador.
- Matrizes são serpentina: use a função de conversão xy() ou declare HORIZONTAL_ZIGZAG_MATRIX na LEDMatrix.
- Offset de fase entre fitas (f * 64 no matiz) faz múltiplas fitas parecerem uma instalação única em vez de peças separadas.
- Rolagem de texto em 8x8 fica ideal em 60ms por passo; abaixo de 50ms é ilegível.