Luzes LED para árvore de Natal com Arduino: neve e arco-íris com WS2812B

Usar um Arduino e uma fita LED WS2812B em um projeto de árvore de Natal é o jeito mais divertido de ir além dos poucos modos fixos dos pisca-piscas prontos. Como você controla a cor e o brilho de cada LED individualmente, dá para criar flocos de neve descendo do topo, um arco-íris girando pelos galhos ou estrelas vermelhas, verdes e douradas piscando ao acaso. Para tudo isso, basta um único fio de dados, um botão e uma fonte de 5 V bem escolhida.

Neste guia, vamos começar pela lista de materiais e avançar passo a passo: o cálculo da fonte de alimentação de acordo com o comprimento da fita, a ligação correta entre a fonte, a placa e a fita, um programa completo para Arduino Uno (FastLED) que troca os efeitos com um botão, e as versões do mesmo projeto para ESP32 (Adafruit NeoPixel) e Raspberry Pi Pico (MicroPython). No final, você também vai aprender a enrolar a fita na árvore, com o que tomar cuidado em termos de segurança e como resolver os problemas mais comuns.

Por que usar uma fita LED WS2812B na árvore de Natal?

Nos pisca-piscas de Natal clássicos, todas as lâmpadas acendem ao mesmo tempo ou funcionam em sequência, em poucos grupos. Já no WS2812B, cada LED tem um pequeno chip driver dentro. O Arduino envia os dados de cor um após o outro pela linha de dados; o primeiro LED pega a sua parte de 24 bits e repassa o restante para o próximo LED. Assim, você controla uma fita de 100 ou 300 LEDs com um único pino e pode dar a cada LED uma cor própria. É isso que dá aos efeitos com movimento, como a neve caindo, uma vivacidade que as luzes fixas não conseguem igualar. Se quiser entender melhor como os LEDs endereçáveis funcionam, confira o post LED WS2812B NeoPixel.

Lista de materiais

• Fita LED WS2812B: para uma árvore de 1,5–1,8 m de altura, 2,5 m de fita com 60 LEDs/m ou 5 m de fita com 30 LEDs/m é um bom começo. As versões IP65 com cobertura de silicone resistem melhor a ficar penduradas nos galhos e à poeira.
• Placa de controle: Arduino Uno, Nano, ESP32 ou Raspberry Pi Pico.
• Fonte de 5 V: escolha a corrente pela tabela abaixo; para 100 LEDs, uma fonte de 5 V 4 A é uma escolha confortável.
• Conector DC fêmea (com borne de parafuso): para ligar o plugue da fonte aos fios sem precisar soldar.
• Capacitor eletrolítico de 1000 µF / 10 V: suaviza os picos repentinos de corrente na entrada da fita.
• Resistor de 330 Ω: ligado em série com a linha de dados; amortece as reflexões no sinal e limita a corrente de entrada do primeiro LED.
• Botão: para alternar entre os efeitos.
• Fio grosso: fio com seção de pelo menos 0,75–1,5 mm² para as linhas de 5V e GND.
• 74AHCT125 ou 74HCT245 (opcional): para elevar o sinal de dados de 3,3 V do ESP32 e do Pico para 5 V.

Cálculo da fonte: de quantos ampères você precisa?

Cada um dos chips vermelho, verde e azul dentro de um WS2812B consome cerca de 20 mA no brilho máximo, então um LED gasta cerca de 60 mA no branco total. A corrente no pior caso é dada pela fórmula I = número de LEDs × 60 mA. Uma fita de 100 LEDs consome 6 A quando todos os LEDs estão em branco puro no brilho máximo, o que significa P = 5 V × 6 A = 30 W. Nos efeitos de arco-íris, neve e estrelas, a maioria dos LEDs fica em uma só cor ou com brilho reduzido, então na prática a corrente fica em torno de um terço do pior caso. Para uma escolha segura, multiplique essa corrente típica por 2 e arredonde para o valor de fonte mais próximo acima, e ajuste o limite de corrente no software para cerca de 80% da fonte. Você pode conferir facilmente a relação entre corrente, tensão e potência com a calculadora da lei de Ohm.

Em fitas longas, o segundo problema é a queda de tensão. Como as finas trilhas de cobre da fita têm resistência, a tensão no final de uma fita de 5 m pode cair abaixo de 4 V; os chips azul e verde enfraquecem e o branco fica amarelado e apagado. A solução é alimentar o 5V e o GND de novo, não só no início da fita, mas a cada 1–1,5 metro (ou a cada 100–150 LEDs), com fios separados vindos da fonte. Isso se chama injeção de alimentação. Nesses fios, use pelo menos 0,75 mm² para 5 ampères e 1,5 mm² para 10 ampères; ligue a linha de dados apenas no início da fita.

Esquema de ligação: fonte de 5 V, fita e placa

1. Encontre as setas na fita e solde um fio na ponta de onde a seta parte (DIN). Se você enviar os dados pela ponta oposta, a DOUT, nenhum LED vai acender.
2. Ligue a saída +5 V da fonte à ponta 5V da fita (em algumas fitas aparece como +5V ou VCC) e o GND da fonte à ponta GND da fita.
3. Ligue o capacitor de 1000 µF entre 5V e GND na entrada da fita; a perna longa (positivo) vai no 5V e a perna do lado da faixa marcada no corpo (negativo) vai no GND.
4. Ligue o pino GND da placa ao GND da fonte. Sem um GND comum, o sinal de dados fica sem referência.
5. Ligue o pino de dados da placa (D6 no Uno) à ponta DIN da fita através do resistor de 330 Ω; colocar o resistor perto da fita dá melhores resultados.
6. Ligue uma perna do botão ao D2 e a outra ao GND; o resistor de pull-up interno será ativado no código.
7. Se você usar mais de 150 LEDs, puxe também fios separados de 5V e GND da fonte até o meio e o final da fita.
8. Durante o desenvolvimento, alimente a placa pela USB e a fita pela fonte. Quando o projeto estiver pronto, você pode ligar os 5 V da fonte ao pino 5V do Uno; nesse caso, não conecte o cabo USB ao mesmo tempo.

Código para Arduino Uno (FastLED): três efeitos e troca de modo por botão

Abra o Gerenciador de Bibliotecas na Arduino IDE e instale a biblioteca buscando por FastLED; para um passo a passo detalhado, veja Como instalar biblioteca no Arduino. O programa abaixo inclui os efeitos de arco-íris, neve caindo e pisca-pisca de estrelas; cada toque no botão passa para o próximo efeito. Como o código usa millis() em vez de delay(), o botão é detectado a qualquer momento enquanto um efeito está rodando. A lógica desse método está no post millis vs delay.

1#include <FastLED.h>
2
3#define LED_PIN     6      // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  2      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6#define BRIGHTNESS  120    // genel parlaklık 0-255 / global brightness 0-255
7#define MAX_MA      3200   // 4 A adaptörün %80'i / 80% of a 4 A supply
8
9CRGB leds[NUM_LEDS];
10
11const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
12const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
13const CRGB XMAS[4] = {CRGB::Red, CRGB::Green, CRGB::Gold, CRGB::White};
14
15uint8_t mode = 0;
16uint8_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
21  FastLED.setMaxPowerInVoltsAndMilliamps(5, MAX_MA);  // akım sınırı / current limit
22  FastLED.setBrightness(BRIGHTNESS);
23  FastLED.clear(true);                                // açılışta hepsini söndür / all off at start
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      FastLED.clear();
36    }
37  }
38}
39
40void rainbow() {
41  fill_rainbow(leds, NUM_LEDS, hue, 3);   // her LED'de ton 3 artar / hue +3 per LED
42  hue += 2;                               // renkler döner / colours rotate
43}
44
45void snowfall() {
46  for (int i = 0; i < NUM_LEDS - 1; i++) {
47    leds[i] = leds[i + 1];                // bir LED aşağı kaydır / shift one LED down
48  }
49  if (random8() < 38) {
50    leds[NUM_LEDS - 1] = CRGB::White;     // tepede yeni kar tanesi / new flake at the top
51  } else {
52    leds[NUM_LEDS - 1] = CRGB(0, 0, 24);  // koyu mavi gece / dark blue night
53  }
54}
55
56void twinkle() {
57  fadeToBlackBy(leds, NUM_LEDS, 20);      // hepsini biraz kıs / dim everything a little
58  if (random8() < 80) {
59    leds[random16(NUM_LEDS)] = XMAS[random8(4)];  // rastgele yıldız / random star
60  }
61}
62
63void loop() {
64  checkButton();
65  static unsigned long lastFrame = 0;
66  if (millis() - lastFrame >= FRAME_MS[mode]) {
67    lastFrame = millis();
68    if (mode == 0) rainbow();
69    else if (mode == 1) snowfall();
70    else twinkle();
71    FastLED.show();                       // renkleri şeride gönder / push colours to the strip
72  }
73}

Como os efeitos funcionam?

Arco-íris: a função fill_rainbow começa pela matiz dada ao primeiro LED e aumenta a matiz em 3 passos a cada LED. Na FastLED, a matiz vai de 0 a 255; com 100 LEDs, a matiz avança 300 passos no total, então você vê um pouco mais de um círculo de cores completo ao longo da fita. Como aumentamos a variável hue em 2 a cada quadro, as cores giram devagar em volta da árvore. Se quiser faixas de cor mais largas, use 1 ou 2 em vez de 3.

Neve caindo: quando a fita é enrolada na árvore de baixo para cima, o primeiro LED fica embaixo e o último LED fica no topo. A cada quadro, deslocamos todas as cores um LED para baixo e adicionamos no topo um floco de neve branco ou um pixel azul-escuro de noite. Como random8() gera um número de 0 a 255, a chance de sair menor que 38 é de cerca de 15%; aumente esse número e a neve fica mais densa. Com um tempo de quadro de 60 ms, um floco leva 6 segundos para descer 100 LEDs. Pisca-pisca (estrelas): fadeToBlackBy reduz o brilho de todos os LEDs em cerca de 8% a cada quadro; ao mesmo tempo, um LED escolhido ao acaso acende no brilho máximo em vermelho, verde, dourado ou branco. O resultado é um brilho que lembra os pisca-piscas de Natal antigos, mas muito mais vivo.

Árvore de Natal com ESP32 (Adafruit NeoPixel)

A FastLED também funciona no ESP32, mas aqui escrevemos o mesmo projeto com a biblioteca Adafruit NeoPixel, para você conhecer as duas bibliotecas populares. A versão atual da biblioteca compila com o mesmo código nas versões 2.x e 3.x do core do Arduino para ESP32 e gera o sinal com a unidade de hardware RMT. Como na Adafruit NeoPixel as cores reduzidas com setBrightness podem ficar distorcidas ao serem lidas de volta, calculamos os efeitos no nosso próprio array de brilho (level) e os reescrevemos na fita do zero a cada quadro. O pino de dados é o GPIO 13 e o botão é o GPIO 4. Se mais tarde você quiser controlar a árvore pelo celular, o post sobre instalação do WLED oferece uma interface pronta.

1#include <Adafruit_NeoPixel.h>
2
3#define LED_PIN     13     // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  4      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6
7Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
8
9const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
10const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
11const uint8_t PALETTE[4][3] = {{255, 0, 0}, {0, 255, 0}, {255, 160, 0}, {255, 255, 255}};
12
13uint8_t level[NUM_LEDS];      // LED başına parlaklık / per-LED level
14uint8_t colorIdx[NUM_LEDS];   // yıldız rengi / star colour index
15uint8_t mode = 0;
16uint16_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  strip.begin();
21  strip.setBrightness(110);   // genel parlaklık / global brightness
22  strip.clear();
23  strip.show();
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      memset(level, 0, sizeof(level));                      // efekt belleğini sıfırla / reset effect buffer
36      strip.clear();
37    }
38  }
39}
40
41void rainbow() {
42  for (int i = 0; i < NUM_LEDS; i++) {
43    uint16_t h = hue + (uint32_t)i * 65536UL / NUM_LEDS;   // LED'e göre ton / hue per LED
44    strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(h)));
45  }
46  hue += 256;                                              // renkler döner / colours rotate
47}
48
49void snowfall() {
50  for (int i = 0; i < NUM_LEDS - 1; i++) level[i] = level[i + 1];   // bir LED aşağı kaydır / shift one LED down
51  level[NUM_LEDS - 1] = (random(100) < 15) ? 255 : 0;               // tepede yeni kar / new flake on top
52  for (int i = 0; i < NUM_LEDS; i++) {
53    if (level[i]) strip.setPixelColor(i, 255, 255, 255);            // kar tanesi / snowflake
54    else strip.setPixelColor(i, 0, 0, 24);                          // koyu mavi gece / dark blue night
55  }
56}
57
58void twinkle() {
59  for (int i = 0; i < NUM_LEDS; i++) {
60    level[i] = (level[i] > 12) ? level[i] - 12 : 0;                 // yavaşça sön / fade out
61  }
62  if (random(100) < 30) {
63    int p = random(NUM_LEDS);
64    level[p] = 255;                                                 // yeni yıldız / new star
65    colorIdx[p] = random(4);
66  }
67  for (int i = 0; i < NUM_LEDS; i++) {
68    const uint8_t *c = PALETTE[colorIdx[i]];
69    strip.setPixelColor(i, c[0] * level[i] / 255, c[1] * level[i] / 255, c[2] * level[i] / 255);
70  }
71}
72
73void loop() {
74  checkButton();
75  static unsigned long lastFrame = 0;
76  if (millis() - lastFrame >= FRAME_MS[mode]) {
77    lastFrame = millis();
78    if (mode == 0) rainbow();
79    else if (mode == 1) snowfall();
80    else twinkle();
81    strip.show();                                                   // renkleri şeride gönder / push colours to the strip
82  }
83}

Árvore de Natal com Raspberry Pi Pico e MicroPython

O módulo neopixel já vem embutido no MicroPython do Raspberry Pi Pico; você não precisa instalar nada a mais. Como o módulo cuida sozinho da temporização precisa do WS2812B, você pode usar qualquer pino GP; abaixo, os dados vão no GP0 e o botão no GP15. Como o MicroPython não tem uma configuração de brilho geral, nós mesmos reduzimos as cores com o fator BRIGHT. Como o Python roda mais devagar que o C++, os efeitos ficam fluidos com 100 LEDs; acima de 300 LEDs, os tempos de quadro podem aumentar. Se você está começando no MicroPython, pode começar pelo post fundamentos do MicroPython.

1from machine import Pin
2import neopixel, time, random
3
4NUM_LEDS = 100
5BRIGHT = 0.4                                   # 0-1 parlaklık / brightness
6np = neopixel.NeoPixel(Pin(0), NUM_LEDS)       # veri GP0 / data on GP0
7button = Pin(15, Pin.IN, Pin.PULL_UP)          # buton GP15-GND / button GP15-GND
8
9mode = 0
10MODE_COUNT = 3                                 # 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
11FRAME_MS = (20, 60, 30)                        # kare süreleri / frame times
12level = [0] * NUM_LEDS                         # LED başına parlaklık / per-LED level
13color_idx = [0] * NUM_LEDS                     # yıldız rengi / star colour index
14PALETTE = ((255, 0, 0), (0, 255, 0), (255, 160, 0), (255, 255, 255))
15hue = 0
16
17def scale(r, g, b):
18    return (int(r * BRIGHT), int(g * BRIGHT), int(b * BRIGHT))
19
20def wheel(pos):
21    # 0-255 -> gökkuşağı rengi / rainbow colour
22    pos = pos & 255
23    if pos < 85:
24        return (255 - pos * 3, pos * 3, 0)
25    if pos < 170:
26        pos -= 85
27        return (0, 255 - pos * 3, pos * 3)
28    pos -= 170
29    return (pos * 3, 0, 255 - pos * 3)
30
31def rainbow():
32    global hue
33    for i in range(NUM_LEDS):
34        np[i] = scale(*wheel(hue + i * 256 // NUM_LEDS))
35    hue = (hue + 2) & 255                      # renkler döner / colours rotate
36
37def snowfall():
38    for i in range(NUM_LEDS - 1):
39        level[i] = level[i + 1]                # bir LED aşağı kaydır / shift one LED down
40    level[-1] = 255 if random.randint(0, 99) < 15 else 0
41    for i in range(NUM_LEDS):
42        np[i] = scale(255, 255, 255) if level[i] else scale(0, 0, 24)
43
44def twinkle():
45    for i in range(NUM_LEDS):
46        level[i] = level[i] - 12 if level[i] > 12 else 0   # yavaşça sön / fade out
47    if random.randint(0, 99) < 30:
48        p = random.randint(0, NUM_LEDS - 1)
49        level[p] = 255                         # yeni yıldız / new star
50        color_idx[p] = random.randint(0, 3)
51    for i in range(NUM_LEDS):
52        r, g, b = PALETTE[color_idx[i]]
53        k = level[i] * BRIGHT / 255
54        np[i] = (int(r * k), int(g * k), int(b * k))
55
56effects = (rainbow, snowfall, twinkle)
57last_btn = 1
58last_change = time.ticks_ms()
59last_frame = time.ticks_ms()
60
61while True:
62    now = time.ticks_ms()
63    state = button.value()
64    if state != last_btn and time.ticks_diff(now, last_change) > 50:   # zıplama filtresi / debounce
65        last_change = now
66        last_btn = state
67        if state == 0:                         # basıldı / pressed
68            mode = (mode + 1) % MODE_COUNT
69            for i in range(NUM_LEDS):
70                level[i] = 0
71    if time.ticks_diff(now, last_frame) >= FRAME_MS[mode]:
72        last_frame = now
73        effects[mode]()
74        np.write()                             # şeride gönder / push to the strip

Como instalar a fita na árvore e segurança

• Comece por baixo: deixe a ponta DIN da fita na base da árvore, ao lado da caixa de controle, e enrole a fita para cima em espiral. Assim o efeito de neve flui de cima para baixo e o fio de dados fica curto.
• Espaçamento da espiral: em uma árvore de 1,8 m, enrolar com espaçamento de 20–25 cm distribui uma fita de 5 m de forma equilibrada pelos galhos; como o diâmetro das voltas diminui em direção ao topo, você pode reduzir um pouco o espaçamento.
• Fitas verticais: você também pode dispor a fita em zigue-zague, de cima para baixo e de baixo para cima. Nesse arranjo, a direção do efeito de neve se inverte a cada segunda fita, então é preciso fazer um pequeno ajuste que calcule a ordem dos LEDs a partir do número da fita.
• Calor: a fita WS2812B esquenta com brilho alto; não a pressione com força contra enfeites de papel ou galhos secos. Manter o brilho em torno de 100–150 reduz tanto o calor quanto a corrente.
• Segurança da fonte: não monte seu próprio circuito no lado de 220 V; use uma fonte de 5 V pronta, com gabinete fechado e selo CE. Mantenha a caixa de controle longe da água e da rega de vasos, e desligue a árvore quando sair de casa.
• Fusível: em sistemas acima de 5 A, adicionar um fusível de lâmina de valor adequado na saída da fonte é uma boa precaução contra um possível curto-circuito.

Ideias de projetos para a árvore de Natal

• Árvore que reage à música: acenda as luzes no ritmo da música com um microfone; os detalhes estão no post LED que reage à música.
• Contagem regressiva de Ano-Novo: mostre em um display o tempo que falta até a meia-noite e inicie um efeito de fogos de artifício na árvore às 00:00; confira o post contador regressivo de Ano-Novo.
• Árvore que liga sozinha: acenda as luzes automaticamente quando escurecer com um sensor de luz LDR.
• Árvore que brilha quando você chega perto: aumente o brilho com um sensor de movimento PIR quando alguém entrar na sala e reduza quando a sala estiver vazia.
• Controle pelo celular: crie uma página web com o ESP32 e escolha efeitos e cores pelo celular; o post sobre servidor web com ESP32 é um bom ponto de partida.
• Display de estrela no topo: coloque uma pequena matriz de LED WS2812B no topo da árvore e rode uma animação de estrela ou floco de neve.

Erros comuns e como corrigir

Com alguns metros de fita LED, um único botão e uma fonte de 5 V bem dimensionada, sua árvore de Natal vira um show de luzes programável, que pode ganhar novos efeitos todo ano. Você pode criar seus próprios efeitos brincando com paletas de cores e tempos de quadro e, para qualquer dúvida sobre alimentação e ligações, voltar ao guia de alimentação do Arduino. No app BlueGrays, você encontra projetos de LED sequencial com WS2812B, efeito Knight Rider, luzes de polícia e animações, além do controle de fita NeoPixel com ESP32, com esquemas do circuito e código passo a passo.