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 5 — Matrizes, Múltiplas Fitas LEDs e o Level Shifter

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?

Tamanho do texto

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.



← Anterior Próximo →

voltar

HAZTECH - Todos os direitos reservados -