Luces de Árbol de Navidad con Arduino y WS2812B: Nieve y Arcoíris

Usar Arduino y una tira LED WS2812B para tus luces de árbol de Navidad es la forma más divertida de ir más allá de los pocos modos fijos de las luces comerciales. Como puedes controlar el color y el brillo de cada LED por separado, puedes hacer que caigan copos de nieve desde la punta, que un arcoíris gire alrededor de las ramas o que parpadeen estrellas rojas, verdes y doradas al azar. Y para todo eso solo necesitas un cable de datos, un botón y una fuente de 5 V bien elegida.

En esta guía empezamos por la lista de materiales y el cálculo de la fuente según la longitud de la tira, la conexión correcta entre fuente, placa y tira, un programa completo para Arduino Uno (FastLED) que cambia de efecto con un botón y las versiones del mismo proyecto para ESP32 (Adafruit NeoPixel) y Raspberry Pi Pico (MicroPython). Al final aprenderás cómo enrollar la tira en el árbol, qué cuidar en cuanto a seguridad y cómo resolver los problemas más comunes.

¿Por qué una tira LED WS2812B para el árbol de Navidad?

En las luces navideñas clásicas todas las bombillas se encienden a la vez o funcionan por grupos en secuencia. En el WS2812B, en cambio, cada LED lleva un pequeño chip controlador. Arduino envía por la línea de datos la información de color una detrás de otra; el primer LED toma sus 24 bits y pasa el resto al siguiente. Así controlas una tira de 100 o 300 LED con un solo pin y puedes dar a cada LED un color distinto. Gracias a esto, efectos en movimiento como la nieve cobran una vida imposible con luces fijas. Si quieres entender mejor cómo funcionan los LED direccionables, echa un vistazo al artículo LED WS2812B NeoPixel.

Lista de materiales

• Tira LED WS2812B: para un árbol de 1,5–1,8 m, una tira de 2,5 m con 60 LED/m o de 5 m con 30 LED/m es un buen comienzo. Los modelos IP65 con cubierta de silicona resisten mejor el roce con las ramas y el polvo.
• Placa de control: Arduino Uno, Nano, ESP32 o Raspberry Pi Pico.
• Fuente de 5 V: elige la corriente según la tabla de abajo; para 100 LED, 5 V 4 A es una opción cómoda.
• Conector DC hembra (con bornes de tornillo): para conectar el enchufe de la fuente a los cables sin soldar.
• Condensador electrolítico de 1000 µF / 10 V: suaviza los picos bruscos de corriente en la entrada de la tira.
• Resistencia de 330 Ω: se conecta en serie con la línea de datos; limita las reflexiones de la señal y la corriente de entrada del primer LED.
• Pulsador: para cambiar entre efectos.
• Cable grueso: cable de al menos 0,75–1,5 mm² de sección para las líneas de 5V y GND.
• Opcional, 74AHCT125 o 74HCT245: para subir a 5 V la señal de datos de 3,3 V del ESP32 y la Pico.

Cálculo de la fuente: ¿de cuántos amperios?

Cada uno de los chips rojo, verde y azul del WS2812B consume unos 20 mA a brillo máximo; es decir, un LED gasta unos 60 mA en blanco total. La corriente en el peor caso es I = número de LED × 60 mA. Una tira de 100 LED con todos en blanco puro y brillo máximo consume 6 A, o sea P = 5 V × 6 A = 30 W. En los efectos de arcoíris, nieve y estrellas, la mayoría de los LED están en un solo color o atenuados, así que en la práctica la corriente queda en torno a un tercio del peor caso. Para elegir con seguridad, multiplica esa corriente típica por 2 y redondea al valor de fuente más cercano; ajusta también el límite de corriente del software a aproximadamente el 80 % de la fuente. Puedes comprobar fácilmente la relación entre corriente, tensión y potencia con la calculadora de la ley de Ohm.

En tiras largas el segundo problema es la caída de tensión. Como las finas pistas de cobre de la tira tienen resistencia, al final de una tira de 5 m la tensión puede bajar de 4 V; entonces los chips azul y verde se debilitan y el blanco se ve amarillento y apagado. La solución es realimentar 5V y GND no solo desde el inicio de la tira, sino cada 1–1,5 metros (o cada 100–150 LED) con cables independientes que vengan de la fuente. Esto se llama inyección de alimentación. En estos cables usa una sección de al menos 0,75 mm² para 5 amperios y 1,5 mm² para 10 amperios; la línea de datos conéctala solo al inicio de la tira.

Esquema de conexión: fuente de 5 V, tira y placa

1. Busca las flechas de la tira y suelda un cable en el extremo donde empieza la flecha (DIN). Si envías datos en sentido contrario, es decir, por el extremo DOUT, no se enciende ningún LED.
2. Conecta la salida +5 V de la fuente al extremo 5V de la tira (en algunas tiras pone +5V o VCC) y el GND de la fuente al extremo GND de la tira.
3. Conecta el condensador de 1000 µF entre 5V y GND en la entrada de la tira; la pata larga (positivo) va a 5V y la pata con la franja marcada en el cuerpo (negativo) va a GND.
4. Conecta el pin GND de la placa al GND de la fuente. Sin un GND común, la señal de datos no tiene referencia.
5. Conecta el pin de datos de la placa (D6 en el Uno) al extremo DIN de la tira a través de la resistencia de 330 Ω; da mejor resultado colocar la resistencia cerca de la tira.
6. Conecta una pata del botón a D2 y la otra a GND; la resistencia pull-up interna se activará en el código.
7. Si usas más de 150 LED, tira también cables de 5V y GND independientes desde la fuente hasta el centro y el final de la tira.
8. Durante el desarrollo alimenta la placa por USB y la tira desde la fuente. Cuando termines, puedes dar los 5 V de la fuente al pin 5V del Uno; en ese caso no conectes el cable USB al mismo tiempo.

Código para Arduino Uno (FastLED): tres efectos y cambio de modo con botón

Abre el Gestor de bibliotecas en el IDE de Arduino y busca FastLED para instalar la biblioteca; para una explicación detallada, mira el artículo Cómo añadir una biblioteca a Arduino. El programa de abajo incluye arcoíris, nieve y destellos tipo estrella; cada vez que pulsas el botón pasa al siguiente efecto. Como el código usa millis() en lugar de delay(), el botón se detecta en todo momento mientras corre el efecto. La lógica de este método la encuentras en el artículo Diferencia entre millis y 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}

¿Cómo funcionan los efectos?

Arcoíris: la función fill_rainbow parte del tono (hue) dado al primer LED y aumenta el tono 3 pasos en cada LED. En FastLED el tono va de 0 a 255; con 100 LED el tono avanza 300 pasos en total, así que sobre la tira se ve un poco más que un círculo cromático completo. Como aumentamos la variable hue en 2 en cada fotograma, los colores giran lentamente alrededor del árbol. Si quieres bandas de color más anchas, usa 1 o 2 en lugar de 3.

Nieve: cuando la tira se enrolla en el árbol de abajo arriba, el primer LED queda abajo y el último en la punta. En cada fotograma desplazamos todos los colores un LED hacia abajo y añadimos en la punta un copo blanco o un píxel azul oscuro de noche. Como random8() genera un número entre 0 y 255, la probabilidad de que salga menor que 38 es de alrededor del 15 %; si aumentas ese número, la nevada se hace más densa. Con un fotograma de 60 ms, un copo tarda 6 segundos en bajar 100 LED. Destellos (estrellas): fadeToBlackBy atenúa todos los LED un 8 % aproximadamente en cada fotograma; a la vez, un LED elegido al azar se enciende a brillo máximo en rojo, verde, dorado o blanco. El resultado es un centelleo que recuerda a las luces navideñas de antes, pero mucho más vivo.

Árbol de Navidad con ESP32 (Adafruit NeoPixel)

FastLED también funciona en el ESP32, pero aquí escribimos el mismo proyecto con la biblioteca Adafruit NeoPixel; así conocerás las dos bibliotecas populares. La versión actual de la biblioteca compila con el mismo código en las versiones 2.x y 3.x del núcleo Arduino para ESP32 y genera la señal con la unidad RMT por hardware. Como en Adafruit NeoPixel los colores atenuados con setBrightness pueden distorsionarse al leerlos de nuevo, calculamos los efectos en nuestro propio array de brillo (level) y reescribimos la tira desde cero en cada fotograma. El pin de datos es el GPIO 13 y el botón, el GPIO 4. Si más adelante quieres controlar el árbol desde el móvil, el artículo Instalación de WLED ofrece una interfaz ya hecha.

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}

Árbol de Navidad con Raspberry Pi Pico y MicroPython

El módulo neopixel viene incluido en MicroPython para la Raspberry Pi Pico; no necesitas instalar nada más. Como el módulo se encarga por sí mismo de la temporización precisa del WS2812B, puedes usar cualquier pin GP; en el código de abajo los datos van a GP0 y el botón a GP15. Como MicroPython no tiene un ajuste de brillo general, atenuamos los colores nosotros mismos con el coeficiente BRIGHT. Aunque Python es más lento que C++, con 100 LED los efectos van fluidos; por encima de 300 LED los tiempos de fotograma pueden alargarse. Si eres nuevo en MicroPython, puedes empezar con el artículo Fundamentos de 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

Cómo colocar la tira en el árbol y seguridad

• Empieza por abajo: pon el extremo DIN de la tira en la base del árbol, junto a la caja de control, y enrolla la tira en espiral hacia arriba. Así el efecto de nieve cae desde la punta y el cable de datos queda corto.
• Separación de la espiral: en un árbol de 1,8 m, enrollar con 20–25 cm de separación reparte la tira de 5 m de forma equilibrada por las ramas; como el diámetro de cada vuelta se reduce hacia la punta, puedes estrechar un poco la separación.
• Tiras verticales: también puedes colocar la tira en zigzag, de la punta hacia abajo y de abajo hacia arriba. En esta disposición la dirección del efecto de nieve se invierte en una de cada dos tiras, por lo que tendrás que hacer un pequeño ajuste que calcule el orden de los LED según el número de tira.
• Calor: la tira WS2812B se calienta con brillo alto; no la presiones con fuerza contra adornos de papel ni ramas secas. Mantener el brillo en torno a 100–150 reduce tanto el calor como la corriente.
• Seguridad de la fuente: no montes tu propio circuito en el lado de 220 V; usa una fuente de 5 V ya fabricada, con marcado CE y carcasa cerrada. Mantén la caja de control lejos del agua y del riego de las macetas, y apaga el árbol cuando salgas de casa.
• Fusible: en sistemas de más de 5 A, añadir a la salida de la fuente un fusible de cuchilla del valor adecuado es una buena medida contra un posible cortocircuito.

Ideas de proyectos para el árbol de Navidad

• Árbol sensible a la música: enciende las luces al ritmo de la canción con un micrófono; los detalles están en el artículo LED sensible a la música.
• Cuenta atrás de Nochevieja: muestra en una pantalla el tiempo que falta para la medianoche y, cuando sean las 00:00, lanza un efecto de fuegos artificiales en el árbol; echa un vistazo al artículo contador de cuenta atrás de Nochevieja.
• Árbol que se enciende solo: enciende las luces automáticamente al anochecer con un sensor de luz LDR.
• Árbol que brilla al acercarte: sube el brillo cuando alguien entra en la habitación con un sensor de movimiento PIR y bájalo cuando está vacía.
• Control desde el móvil: abre una página web con el ESP32 y elige los efectos y colores desde el móvil; el artículo Servidor web con ESP32 es un buen punto de partida.
• Pantalla en la estrella de la punta: coloca en la punta del árbol una pequeña matriz LED WS2812B y reproduce una animación de estrella o copo de nieve.

Errores comunes y cómo solucionarlos

Con unos metros de tira LED, un solo botón y una fuente de 5 V bien dimensionada, tu árbol de Navidad se convierte en un espectáculo de luz programable que puedes renovar cada año con efectos nuevos. Puedes diseñar tus propios efectos jugando con las paletas de colores y los tiempos de fotograma, y si te quedan dudas sobre alimentación y conexiones, vuelve a la guía de alimentación de Arduino. En la app de BlueGrays encontrarás, con esquemas de circuito y código paso a paso, proyectos con WS2812B como luces en movimiento, coche fantástico, luces de policía y animaciones, además del control de tiras NeoPixel con ESP32.