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 2 — Do LED Aceso ao Efeito que Impressiona

Capítulo 2 — Do LED Aceso ao Efeito que Impressiona

EDs Endereçáveis: Como Criar Efeitos Animados (e Por Que Suas Cores Parecem Erradas) Eyebrow: Capítulo 2 — O LED acendeu. Agora ele vai fazer algo bonito.

Tamanho do texto

O erro que 90% dos iniciantes cometem no segundo dia

No Capítulo 1 você acendeu a fita inteira de vermelho. Funcionou. Então você tentou fazer um arco-íris e a fita começou a piscar de forma estranha, ou ficou lenta, ou as cores saíram lavadas e sem graça.

Não é bug. É que existem três coisas que a maioria dos tutoriais não explica: como o show() se comporta em fitas longas, por que o delay() destrói animações, e o que é gamma correction. Este capítulo resolve as três.

Como uma animação realmente funciona

Uma animação em LED endereçável é uma sequência de quadros (frames). Cada quadro é um estado completo da fita — cor de cada LED naquele instante. A animação é você trocando de quadro dezenas de vezes por segundo.

Pense num flipbook. Você não desenha movimento; você desenha 30 desenhos parados e o olho inventa o movimento. Com LED é igual: 30 quadros por segundo e o cérebro vê fluidez.

O problema é que o código do Capítulo 1 usava delay(). E delay() congela o processador inteiro — durante o delay, seu Arduino não lê botão, não responde a nada. Numa animação, delay() significa que você perde o controle do tempo.

A solução é trocar delay() por millis(), que só consulta o relógio interno e devolve o controle imediatamente.

<code>

#include <Adafruit_NeoPixel.h>


#define PINO_DADOS 6

#define QTD_LEDS   60


Adafruit_NeoPixel fita(QTD_LEDS, PINO_DADOS, NEO_GRB + NEO_KHZ800);


unsigned long ultimoQuadro = 0;

const int INTERVALO = 33;   // 33ms ≈ 30 quadros por segundo

int posicao = 0;


void setup() {

  fita.begin();

  fita.show();

  fita.setBrightness(80);

}


void loop() {

  // Só atualiza se já passaram 33ms desde o último quadro

  if (millis() - ultimoQuadro >= INTERVALO) {

    ultimoQuadro = millis();


    fita.clear();

    // Acende 3 LEDs na posição atual — o "cometa"

    for (int i = 0; i < 3; i++) {

      int idx = (posicao + i) % QTD_LEDS;

      fita.setPixelColor(idx, fita.Color(0, 100, 255));

    }

    fita.show();


    posicao = (posicao + 1) % QTD_LEDS;  // avança e volta ao início

  }

}

</code>

O que você deve ver: um pequeno cometa azul de 3 LEDs correndo pela fita, dando a volta continuamente, com movimento suave.

A diferença essencial: o loop() roda milhares de vezes por segundo, mas a fita só atualiza quando o relógio marca 33ms. Isso libera o processador para fazer outras coisas — e é a base de todo projeto profissional com LEDs.

👉 Atalho: 33ms = 30fps, 20ms = 50fps, 16ms = 60fps. Para fitas de até 300 LEDs, 30fps é o ponto ideal entre fluidez e carga no processador.

Por que suas cores parecem lavadas (e como corrigir)

Aqui está a dica que separa amador de profissional.

O LED WS2812B não emite luz de forma linear. Se você manda o valor 128 (metade de 255), ele não emite metade da luz — emite cerca de 20%. O resultado é que degradês ficam com bandas visíveis e cores parecem "sujas" ou "lavadas", principalmente nos tons escuros.

A correção se chama gamma correction: você aplica uma curva matemática ao valor antes de enviar, compensando a resposta não-linear do LED.

A biblioteca FastLED faz isso em uma linha. É por isso que profissionais preferem FastLED ao NeoPixel.

<code>

#include <FastLED.h>

#define PINO_DADOS 6

#define QTD_LEDS   60

CRGB leds[QTD_LEDS];

void setup() {

  FastLED.addLeds<WS2812B, PINO_DADOS, GRB>(leds, QTD_LEDS);

  FastLED.setBrightness(80);

}

void loop() {

  // Preenche com um degradê de matiz ao longo da fita

  for (int i = 0; i < QTD_LEDS; i++) {

    uint8_t matiz = map(i, 0, QTD_LEDS - 1, 0, 255);

    leds[i] = CHSV(matiz, 255, 255);   // matiz, saturação, brilho

  }

  FastLED.show();

  delay(20);

}

</code>

O que você deve ver: um arco-íris completo e contínuo ao longo da fita, sem bandas, com transições suaves.

⚠️ Atenção ao detalhe que quebra projetos: CHSV trabalha em HSV (matiz, saturação, brilho), não em RGB. Matiz 0 = vermelho, 85 = verde, 170 = azul, 255 = volta ao vermelho. É muito mais intuitivo para animações — você anima só o matiz e o degradê se monta sozinho.

E o FastLED.show() já aplica gamma correction por padrão. É a diferença visual que você percebe imediatamente ao comparar os dois códigos lado a lado.

Controlando 300 LEDs sem travar o processador

Este é o limite prático que ninguém avisa: cada chamada de show() leva tempo proporcional ao número de LEDs.

O protocolo WS2812B roda a 800kHz e cada LED consome 24 bits. Então:

Tempo de envio (s) == número de LEDsx24/800.000

Para 60 LEDs: 1,8ms. Para 300 LEDs: 9ms. Para 1.000 LEDs: 30ms.

Isso significa que com 1.000 LEDs você não consegue passar de 33fps, porque só o envio consome todo o orçamento de tempo do quadro. E o pior: durante o show(), o processador fica bloqueado — interrupções são desabilitadas e nada mais roda.

Três estratégias reais para contornar:

Reduza a taxa de atualização onde não importa. Um efeito de respiração lenta não precisa de 60fps. 15fps é indistinguível.

Divida a fita em segmentos independentes. Se você tem 4 fitas de 250 LEDs em pinos diferentes, atualize uma por quadro em rodízio. O olho não percebe.

Migre para APA102 em projetos grandes. O APA102 usa SPI com clock separado, permitindo taxas na casa de MHz em vez de kHz. É a razão pela qual instalações de palco abandonaram o WS2812B acima de certo tamanho.

👉 Regra prática para decidir: até 300 LEDs, WS2812B com FastLED resolve tudo. Entre 300 e 800, reduza fps e otimize. Acima de 800, considere APA102 ou múltiplos controladores.

O efeito que faz as pessoas filmarem: fogo

Nada impressiona mais em vídeo do que um efeito de fogo realista. E ele é surpreendentemente simples — usa ruído, não aleatoriedade pura.

<code>
#include <FastLED.h>

#define PINO_DADOS 6

#define QTD_LEDS   60

CRGB leds[QTD_LEDS];


void setup() {

  FastLED.addLeds<WS2812B, PINO_DADOS, GRB>(leds, QTD_LEDS);

  FastLED.setBrightness(120);

}

void loop() {

  // Camada 1: base de calor que varia suavemente

  for (int i = 0; i < QTD_LEDS; i++) {

    uint8_t calor = inoise8(i * 40, millis() / 8);

    leds[i] = HeatColor(calor);

  }

  // Camada 2: "fagulhas" aleatórias por cima

  if (random8() < 40) {

    leds[random16(QTD_LEDS)] = CRGB(255, 255, 200);

  }

  FastLED.show();

  delay(20);

}

</code>

O que você deve ver: um fogo vivo, com zonas quentes que se movem devagar e faíscas brancas ocasionais. A diferença para um fogo falso é o inoise8 — ele gera ruído contínuo (Perlin), então o calor se move suavemente em vez de piscar caoticamente.

Se você trocar inoise8 por random8, o resultado vira um estroboscópio feio. Esse é o segredo que quase nenhum tutorial conta.

Os 3 erros do Capítulo 2

1. Usar delay() em animação. Congela tudo. Sempre millis() ou a estrutura de tempo do FastLED.

2. Ignorar gamma correction. As cores vão parecer lavadas e o degradê vai mostrar bandas. FastLED resolve por padrão; NeoPixel não.

3. Chamar show() várias vezes por quadro. Cada show() envia a fita inteira. Se você chama dentro de um for, está enviando a fita 60 vezes — e a animação fica 60x mais lenta. Monte o quadro inteiro na memória e chame show() uma vez.

O que vem no Capítulo 3

Agora você tem efeitos. O próximo problema é alimentação: como ligar 5 metros de fita sem que a última ponta fique amarelada, por que a fita reinicia quando você liga o secador de cabelo, e como calcular a fonte certa para qualquer projeto. É o capítulo que evita incêndio — literalmente.


Resumindo

  • Animação é sequência de quadros; millis() substitui delay() para não congelar o processador.
  • Gamma correction é o que separa cor lavada de cor profissional — FastLED aplica por padrão.
  • Cada show() custa tempo proporcional ao número de LEDs: 60 LEDs ≈ 1,8ms, 1.000 LEDs ≈ 30ms.
  • Efeito de fogo realista usa ruído Perlin (inoise8), não aleatoriedade pura.
  • Chame show() uma única vez por quadro, nunca dentro de um loop de LEDs.

Se quiser, posso:

  • Escrever o Capítulo 3 completo (alimentação, injeção de energia, cálculo de fonte e queda de tensão)
  • Montar o briefing de SEO deste capítulo (keyword principal, meta description, links internos para os pilares)
  • Criar o Capítulo 4 (controle por app/Wi-Fi com ESP32)
← Anterior Próximo →

voltar

HAZTECH - Todos os direitos reservados -