Luci Albero di Natale Arduino: Neve e Arcobaleno con WS2812B

Usare Arduino e una strip LED WS2812B per le luci dell'albero di Natale è il modo più divertente per andare oltre i pochi giochi di luce fissi delle luci già pronte. Poiché controlli colore e luminosità di ogni singolo LED, puoi far scendere fiocchi di neve dalla punta in giù, far girare un arcobaleno intorno ai rami o far scintillare stelle rosse, verdi e dorate in modo casuale. Per tutto questo bastano un solo filo dati, un pulsante e un alimentatore a 5 V scelto bene.

In questa guida partiamo dalla lista dei componenti, poi passiamo al calcolo dell'alimentazione in base alla lunghezza della strip, ai collegamenti corretti tra alimentatore, scheda e strip, a un programma completo per Arduino Uno (FastLED) con cambio effetto tramite pulsante e alle versioni dello stesso progetto per ESP32 (Adafruit NeoPixel) e Raspberry Pi Pico (MicroPython). Alla fine scoprirai come avvolgere la strip sull'albero, a cosa fare attenzione per la sicurezza e come risolvere i problemi più comuni.

Perché una strip LED WS2812B per l'albero di Natale?

Nelle luci di Natale classiche tutte le lampadine si accendono insieme o a gruppi in sequenza. Nel WS2812B, invece, ogni LED contiene un piccolo chip driver. Arduino invia in sequenza le informazioni di colore sulla linea dati: il primo LED prende i suoi 24 bit e passa il resto al LED successivo. Così gestisci una strip da 100 o 300 LED con un solo pin e puoi dare a ogni LED un colore diverso. Grazie a questa struttura, effetti in movimento come la neve che cade acquistano una vivacità impossibile con le luci fisse. Se vuoi capire meglio come funzionano i LED indirizzabili, dai un'occhiata all'articolo LED WS2812B NeoPixel.

Lista dei componenti

• Strip LED WS2812B: per un albero alto 1,5–1,8 m, una strip da 2,5 m a 60 LED/m o da 5 m a 30 LED/m è un buon punto di partenza. I modelli IP65 con rivestimento in silicone resistono meglio a polvere e al contatto con i rami.
• Scheda di controllo: Arduino Uno, Nano, ESP32 o Raspberry Pi Pico.
• Alimentatore a 5 V: scegli la corrente in base alla tabella qui sotto; per 100 LED un 5 V 4 A è una scelta comoda.
• Jack DC femmina (con morsetti a vite): per collegare la spina dell'alimentatore ai cavi senza saldare.
• Condensatore elettrolitico 1000 µF / 10 V: attenua i picchi di corrente improvvisi all'ingresso della strip.
• Resistenza da 330 Ω: si collega in serie alla linea dati; limita le riflessioni del segnale e la corrente d'ingresso del primo LED.
• Pulsante: per passare da un effetto all'altro.
• Cavo di sezione adeguata: almeno 0,75–1,5 mm² per le linee 5V e GND.
• Opzionale 74AHCT125 o 74HCT245: per portare a 5 V il segnale dati a 3,3 V di ESP32 e Pico.

Calcolo dell'alimentazione: quanti ampere servono?

Ciascuno dei chip rosso, verde e blu dentro il WS2812B assorbe circa 20 mA alla massima luminosità; quindi un LED a bianco pieno consuma circa 60 mA. La corrente nel caso peggiore si trova con la formula I = numero di LED × 60 mA. Una strip da 100 LED con tutti i LED bianchi e alla massima luminosità assorbe 6 A, cioè P = 5 V × 6 A = 30 W. Negli effetti arcobaleno, neve e stelle la maggior parte dei LED è di un solo colore o attenuata, quindi in pratica la corrente resta intorno a un terzo del caso peggiore. Per una scelta sicura moltiplica questa corrente tipica per 2, arrotonda al valore di alimentatore più vicino e imposta il limite di corrente nel software a circa l'80% dell'alimentatore. Puoi controllare facilmente il rapporto tra corrente, tensione e potenza con il calcolatore della legge di Ohm.

Nelle strip lunghe il secondo problema è la caduta di tensione. Poiché le sottili piste di rame sulla strip hanno resistenza, alla fine di una strip da 5 m la tensione può scendere sotto i 4 V; in tal caso i chip blu e verde si indeboliscono e il bianco appare giallastro e spento. La soluzione è alimentare di nuovo 5V e GND non solo dall'inizio della strip, ma ogni 1–1,5 metri (o ogni 100–150 LED) con cavi separati provenienti dall'alimentatore. Si chiama iniezione di alimentazione. Per questi cavi usa almeno 0,75 mm² per 5 ampere e 1,5 mm² per 10 ampere; la linea dati, invece, collegala solo all'inizio della strip.

Schema di collegamento: alimentatore 5 V, strip e scheda

1. Trova le frecce stampate sulla strip e salda un cavo all'estremità da cui parte la freccia (DIN). Se invii i dati dal lato opposto, cioè dall'estremità DOUT, nessun LED si accende.
2. Collega l'uscita +5 V dell'alimentatore al terminale 5V della strip (su alcune strip c'è scritto +5V o VCC) e il GND dell'alimentatore al terminale GND della strip.
3. Collega il condensatore da 1000 µF tra 5V e GND all'ingresso della strip; la gamba lunga (positivo) va al 5V, la gamba con la striscia sul corpo (negativo) al GND.
4. Collega il pin GND della scheda al GND dell'alimentatore. Senza GND comune il segnale dati non ha un riferimento.
5. Collega il pin dati della scheda (D6 sulla Uno) al terminale DIN della strip attraverso la resistenza da 330 Ω; è meglio mettere la resistenza vicino alla strip.
6. Collega un piedino del pulsante a D2 e l'altro a GND; la resistenza di pull-up interna verrà attivata nel codice.
7. Se usi più di 150 LED, porta cavi separati di 5V e GND dall'alimentatore anche al centro e alla fine della strip.
8. Durante lo sviluppo alimenta la scheda via USB e la strip dall'alimentatore. A progetto finito puoi collegare i 5 V dell'alimentatore al pin 5V della Uno; in tal caso non collegare il cavo USB contemporaneamente.

Codice Arduino Uno (FastLED): tre effetti e cambio modalità con pulsante

Nell'Arduino IDE apri il Gestore Librerie, cerca FastLED e installa la libreria; per una spiegazione dettagliata consulta l'articolo Come aggiungere una libreria ad Arduino. Il programma qui sotto contiene gli effetti arcobaleno, neve e scintillio di stelle; a ogni pressione del pulsante passa all'effetto successivo. Poiché il codice usa millis() invece di delay(), il pulsante viene rilevato in ogni momento mentre l'effetto è in esecuzione. Trovi la logica di questo metodo nell'articolo sulla differenza tra millis e 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}

Come funzionano gli effetti?

Arcobaleno: la funzione fill_rainbow parte dalla tonalità (hue) assegnata al primo LED e aumenta la tonalità di 3 passi a ogni LED. In FastLED la tonalità va da 0 a 255; con 100 LED la tonalità avanza in totale di 300 passi, quindi sulla strip si vede un po' più di un cerchio cromatico completo. Poiché a ogni frame aumentiamo la variabile hue di 2, i colori ruotano lentamente intorno all'albero. Se vuoi bande di colore più ampie, usa 1 o 2 al posto di 3.

Neve che cade: quando la strip è avvolta sull'albero dal basso verso l'alto, il primo LED è in basso e l'ultimo in cima. A ogni frame facciamo scorrere tutti i colori di un LED verso il basso e in cima aggiungiamo o un fiocco di neve bianco o un pixel blu scuro di notte. Poiché random8() genera un numero tra 0 e 255, la probabilità che sia minore di 38 è circa il 15%; se aumenti questo numero, la neve si infittisce. Con un frame da 60 ms un fiocco percorre 100 LED in 6 secondi. Scintillio (stelle): fadeToBlackBy attenua tutti i LED di circa l'8% a ogni frame; nello stesso momento un LED scelto a caso si accende alla massima luminosità in rosso, verde, oro o bianco. Il risultato è uno scintillio che ricorda le vecchie luci di Natale, ma molto più vivace.

Albero di Natale con ESP32 (Adafruit NeoPixel)

Su ESP32 funziona anche FastLED, ma qui scriviamo lo stesso progetto con la libreria Adafruit NeoPixel, così conosci entrambe le librerie più diffuse. La versione attuale della libreria si compila con lo stesso codice sia con il core Arduino ESP32 2.x sia con il 3.x e genera il segnale con l'unità hardware RMT. Poiché in Adafruit NeoPixel i colori attenuati con setBrightness possono degradarsi quando vengono riletti, calcoliamo gli effetti in un nostro array di luminosità (level) e a ogni frame riscriviamo tutto sulla strip. Il pin dati è il GPIO 13, il pulsante il GPIO 4. Se in futuro vorrai gestire l'albero dal telefono, l'articolo Installazione di WLED offre un'interfaccia già 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}

Albero di Natale con Raspberry Pi Pico e MicroPython

Nel firmware MicroPython di Raspberry Pi Pico il modulo neopixel è già incluso; non devi installare nient'altro. Poiché il modulo gestisce da solo la temporizzazione precisa del WS2812B, puoi usare qualsiasi pin GP; qui sotto i dati sono su GP0 e il pulsante su GP15. Dato che in MicroPython non c'è un'impostazione di luminosità globale, attenuiamo noi i colori con il coefficiente BRIGHT. Poiché Python è più lento del C++, con 100 LED gli effetti sono fluidi; oltre i 300 LED i tempi dei frame possono allungarsi. Se sei alle prime armi con MicroPython, puoi iniziare con l'articolo Le basi di 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

Posizionare la strip sull'albero e sicurezza

• Parti dal basso: metti l'estremità DIN della strip alla base dell'albero, vicino alla scatola di controllo, e avvolgi la strip a spirale verso l'alto. Così l'effetto neve scende dall'alto e il cavo dati resta corto.
• Distanza tra le spire: su un albero di 1,8 m, avvolgere con 20–25 cm di passo distribuisce in modo equilibrato la strip da 5 m sui rami; poiché il diametro dei giri si riduce verso la punta, puoi stringere un po' il passo.
• Strisce verticali: puoi anche stendere la strip a zig-zag, dall'alto in basso e dal basso in alto. In questa disposizione la direzione dell'effetto neve si inverte a ogni seconda striscia, quindi devi fare una piccola modifica che calcoli l'ordine dei LED in base al numero della striscia.
• Calore: la strip WS2812B si scalda a luminosità elevata; non premerla contro decorazioni di carta o rami secchi. Tenere la luminosità intorno a 100–150 riduce sia il calore sia la corrente.
• Sicurezza dell'alimentatore: sul lato 220 V non costruire circuiti da solo; usa un alimentatore a 5 V già pronto, con marchio CE e custodia chiusa. Tieni la scatola di controllo lontana dall'acqua e dall'annaffiatura del vaso e spegni l'albero quando esci di casa.
• Fusibile: nei sistemi sopra i 5 A, aggiungere sull'uscita dell'alimentatore un fusibile a lama di valore adeguato è una buona precauzione contro un eventuale cortocircuito.

Idee di progetto per l'albero di Natale

• Albero sensibile alla musica: con un microfono accendi le luci a ritmo di canzone; i dettagli sono nell'articolo sui LED sensibili alla musica.
• Conto alla rovescia di Capodanno: mostra su uno schermo il tempo che manca a mezzanotte e, quando scatta lo 00:00, avvia sull'albero un effetto fuochi d'artificio; dai un'occhiata all'articolo sul contatore del conto alla rovescia di Capodanno.
• Albero che si accende da solo: quando fa buio, accendi automaticamente le luci con un sensore di luce LDR.
• Albero che brilla quando ti avvicini: con un sensore di movimento PIR aumenta la luminosità quando qualcuno entra nella stanza e abbassala quando è vuota.
• Controllo dal telefono: con l'ESP32 crea una pagina web per scegliere effetti e colori dal telefono; l'articolo sul web server ESP32 è un buon punto di partenza.
• Display del puntale: metti in cima all'albero una piccola matrice LED WS2812B e riproduci un'animazione di stella o fiocco di neve.

Errori comuni e come risolverli

Con qualche metro di strip LED, un solo pulsante e un alimentatore a 5 V dimensionato correttamente, il tuo albero di Natale diventa uno spettacolo di luci programmabile che puoi rinnovare ogni anno con nuovi effetti. Puoi progettare i tuoi effetti giocando con le palette di colori e i tempi dei frame e, per i dubbi su alimentazione e collegamenti, tornare alla guida all'alimentazione di Arduino. Nell'app BlueGrays trovi, con schemi dei circuiti e codice passo passo, i progetti con WS2812B come luci scorrevoli, Knight Rider, lampeggianti della polizia e animazioni, oltre al controllo di strip NeoPixel con ESP32.