Striscia LED WS2812B NeoPixel con Arduino: guida ai LED RGB indirizzabili

Il WS2812B è un LED RGB con un proprio chip di controllo integrato. Mentre un normale LED RGB richiede un pin per ogni colore, con il WS2812B controlli centinaia di LED con un solo filo dati e dai a ciascuno un colore e una luminosità propri. NeoPixel è il nome che Adafruit dà a questa famiglia di LED indirizzabili. Venduti come strisce, anelli, barrette e matrici, si trovano in innumerevoli progetti, dall'illuminazione d'ambiente agli orologi LED, fino a giochi e lampade di notifica.

Come funziona il WS2812B?

Nel contenitore da 5x5 mm di ogni WS2812B ci sono tre minuscoli LED, rosso, verde e blu, e un piccolo chip che li pilota. Arduino invia sulla linea dati, uno dopo l'altro, pacchetti di colore da 24 bit: 8 bit di verde, 8 di rosso e 8 di blu (ordine GRB). Il primo LED tiene per sé i primi 24 bit e passa il resto al LED successivo tramite il pin DO; ogni LED fa lo stesso. Quando la linea dati resta a LOW per almeno 50 microsecondi (280 nelle versioni più recenti), tutti i LED mostrano il proprio colore nello stesso istante. Con 256 livelli per colore, un solo LED può mostrare 16,7 milioni di colori.

Strisce, anelli e matrici

Collegamento del WS2812B

Il WS2812B ha tre collegamenti: 5V, GND e DIN (ingresso dati). Le frecce sulla striscia indicano la direzione dei dati; collega sempre Arduino all'estremità da cui partono le frecce, cioè il lato DIN. Una resistenza da 330–470 Ω in serie sulla linea dati e un condensatore da 1000 µF tra 5V e GND all'ingresso di alimentazione della striscia proteggono il primo LED da improvvisi picchi di tensione.

Calcolo della potenza: quanti ampere servono?

La formula per il caso peggiore è semplice: numero di LED × 60 mA. Nelle animazioni è raro che tutti i LED siano in bianco pieno nello stesso momento; in pratica si vede una media di circa 20 mA per LED. Conviene comunque scegliere l'alimentatore per il caso peggiore oppure limitare la luminosità via software. Per calcolare la potenza in watt usa lo strumento Legge di Ohm, e per stimare l'autonomia dei progetti a batteria lo strumento Durata batteria.

Il primo codice con la libreria Adafruit NeoPixel

Nel Gestore librerie cerca Adafruit NeoPixel e installala. Il codice qui sotto "spazza" la striscia con un colore accendendo i LED uno alla volta in rosso, verde e blu:

1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6          // DIN pini / data pin
4#define NUM_LEDS 8     // LED sayısı / number of LEDs
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(50);   // 0–255, yalnız bir kez / only once
11  strip.show();              // hepsini söndür / all off
12}
13
14void colorWipe(uint32_t color, int wait) {
15  for (int i = 0; i < NUM_LEDS; i++) {
16    strip.setPixelColor(i, color);
17    strip.show();            // değişikliği gönder / send the change
18    delay(wait);
19  }
20}
21
22void loop() {
23  colorWipe(strip.Color(255, 0, 0), 80);   // kırmızı / red
24  colorWipe(strip.Color(0, 255, 0), 80);   // yeşil / green
25  colorWipe(strip.Color(0, 0, 255), 80);   // mavi / blue
26}

setPixelColor() cambia solo il colore in memoria; per accendere davvero i LED devi chiamare show(). Così puoi impostare il colore di tutti i LED e mostrarli tutti in una volta. Poiché setBrightness() riscala in modo permanente i dati di colore, è meglio chiamarla una sola volta in setup() invece di cambiarla di continuo in loop(). Ogni LED occupa 3 byte della RAM di Arduino; i 2 KB dell'Uno si riempiono in fretta con centinaia di LED.

Effetto arcobaleno: i colori HSV

Invece di impostare i colori con i valori di rosso, verde e blu, usare HSV (tonalità, saturazione, luminosità) rende gli effetti molto più semplici: percorri tutta la ruota dei colori cambiando solo la tonalità. Nella libreria Adafruit la tonalità va da 0 a 65535. gamma32() corregge i colori in base a come li percepisce l'occhio, così le transizioni sembrano più naturali:

1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6
4#define NUM_LEDS 24
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(40);
11}
12
13void loop() {
14  for (long first = 0; first < 65536; first += 256) {
15    for (int i = 0; i < NUM_LEDS; i++) {
16      uint16_t hue = first + i * 65536L / NUM_LEDS;   // her LED'e farklı ton / a different hue per LED
17      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(hue)));
18    }
19    strip.show();
20    delay(10);
21  }
22}

La libreria FastLED

Per effetti più avanzati è molto popolare anche la libreria FastLED. Tiene i LED in un array CRGB, offre comandi molto leggibili come leds[3] = CRGB::Red; e usa un intervallo di tonalità da 0 a 255. Funzioni già pronte come fill_rainbow() e fadeToBlackBy() ti permettono di scrivere effetti fuoco, stella cadente o respiro in poche righe. Una delle funzioni più comode è FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000);: la libreria abbassa automaticamente la luminosità per mantenere la corrente sotto i 2 A.

Usare una matrice NeoPixel 8x8

Una matrice in realtà è solo una lunga striscia: 64 LED collegati uno dopo l'altro su un'unica linea dati. Nella maggior parte delle matrici le righe sono disposte a zigzag (serpentina): le righe pari vanno da sinistra a destra, quelle dispari da destra a sinistra. Per convertire una coordinata x, y in numero di LED si usa quindi y × 8 + x nelle righe pari e y × 8 + (7 − x) in quelle dispari. Poiché 64 LED possono assorbire 3,8 A in bianco pieno, tenere bassa la luminosità è particolarmente importante nelle matrici.

WS2812B con ESP32 e Raspberry Pi Pico

Le librerie Adafruit NeoPixel e FastLED funzionano anche sull'ESP32; grazie al Wi-Fi è facilissimo controllare i LED dal telefono o costruire una lampada che cambia colore in base al meteo. L'aspetto a cui fare attenzione è il livello di tensione: un WS2812B alimentato a 5 V si aspetta almeno 3,5 V sull'ingresso dati, mentre ESP32 e Pico forniscono 3,3 V. La maggior parte delle strisce funziona comunque, ma se il primo LED sfarfalla o compaiono colori casuali, aggiungi sulla linea dati un traslatore di livello come il 74AHCT125. Sul Raspberry Pi Pico, MicroPython include già il modulo neopixel:

1from machine import Pin
2import neopixel
3import time
4
5NUM = 8
6np = neopixel.NeoPixel(Pin(0), NUM)      # GP0 → DIN
7
8def wheel(pos):                          # 0–255 → renk çemberi / colour wheel
9    if pos < 85:
10        return (255 - pos * 3, pos * 3, 0)
11    if pos < 170:
12        pos -= 85
13        return (0, 255 - pos * 3, pos * 3)
14    pos -= 170
15    return (pos * 3, 0, 255 - pos * 3)
16
17j = 0
18while True:
19    for i in range(NUM):
20        r, g, b = wheel((i * 256 // NUM + j) & 255)
21        np[i] = (r // 5, g // 5, b // 5)  # parlaklığı düşür / dim it
22    np.write()
23    j = (j + 2) & 255
24    time.sleep_ms(20)

Idee di progetti con il WS2812B

• Luce d'ambiente per la TV: attacca una striscia dietro al televisore per dare alla stanza una luce morbida.
• Orologio NeoPixel: mostra ore, minuti e secondi con colori diversi su un anello da 60 LED.
• VU meter: con un modulo microfono crea una barra di LED che sale con il volume della musica.
• Lampada di notifica: cambia colore con l'ESP32 in base al meteo o alle e-mail in arrivo da internet.
• Lampeggiante della polizia e Supercar: programma lampeggi rosso-blu o una luce che scorre avanti e indietro.
• Gioco del serpente: ricrea il classico snake con una matrice 8x8 e un joystick.

Errori comuni e come risolverli

• Non si accende nessun LED: Arduino è collegato all'estremità sbagliata della striscia, il lato DOUT; guarda le frecce e usa l'estremità DIN.
• Colori scambiati (verde invece di rosso): l'ordine dei colori è sbagliato; usa NEO_GRB nel codice, anche se alcune strisce richiedono NEO_RGB.
• Il primo LED sfarfalla o mostra colori casuali: manca la resistenza in serie, la massa non è in comune oppure il segnale dati a 3,3 V non basta.
• La fine della striscia appare giallastra: c'è una caduta di tensione; alimenta la striscia in più punti o abbassa la luminosità.
• Arduino si riavvia quando si accendono i LED: si sta assorbendo troppa corrente dall'USB; usa un alimentatore esterno e un condensatore da 1000 µF.
• Si accendono solo i primi LED: il valore NUM_LEDS nel codice è inferiore al numero reale di LED, oppure c'è un collegamento interrotto in qualche punto della striscia.

Il WS2812B è un ottimo punto di partenza per capire come si mescolano i colori; la logica dei colori la trovi in Come usare un LED RGB e il controllo della luminosità in Cos'è il PWM? Nell'app BlueGrays trovi progetti sull'uso del WS2812B, lampeggiante della polizia, LED in sequenza, effetto Supercar, animazioni e controllo di strisce NeoPixel con l'ESP32, con schemi e codice.