Tecnologica decorazione natalizia realizzata con LED Neopixel e controllata da una board Arduino Micro.

All’approssimarsi delle festività di fine anno, in Redazione si cerca sempre questa o quell’idea che possa coniugare la tradizione con l’innovazione, per non cadere nel solito o triviale, pur sempre gradito, gadget da decorazione natalizia che non può mancare sull’albero, su una finestra o sulla porta di casa.

Per queste cose, LED RGB e strip luminescenti sono ormai divenute un “must” e quindi non abbiamo potuto esimerci dal proporre un classico delle decorazioni luminose (perché il Natale è festa tanto più se ci sono tante luci, segno di vita e di speranza…) rivisitato in chiave moderna perché affidato ai versatili e prestanti LED Neopixel.

Con un certo numero di essi, collegati in fila e gestiti in cascata da una scheda Arduino, abbiamo dato vita a una stella di Natale a 5 punte, che farà bella mostra di sé in cima all’albero o dove altro la vorrete collocare (per esempio sull’uscio di casa).

Vediamo dunque di cosa si tratta analizzando lo schema elettrico del circuito, che consta di una parte composta dai LED e della scheda di con-trollo, che nel nostro caso è una Arduino Micro, giusto per minimizzare l’ingombro della stella.

Schema elettrico della Stella Neopixel

Diamo dunque uno sguardo alla parte elettronica del progetto, che consta sostanzialmente di un insieme di 56 LED Neopixel disposti in modo da formare due stelle concentriche; dei 56 LED RGB, i primi 35 compongono la stella più grande (esterna), mentre gli altri 20 quella più piccola (interna). Il LED numero 56 è esattamente al centro del circuito stampato, che ha la forma di una stella a cinque punte.

I LED Neopixel sono collegati in cascata ma alimentati in parallelo; tale configurazione permette di indirizzare ogni singolo LED e scegliere il colore individualmente, tra le possibili sfumature, fra le 256 combinazioni possibili per ogni colore base (quindi disponiamo di 256x256x256 combinazioni!) determinando un totale di 16.777.216 colori: quel che si dice true color!

Ricordiamo che Neopixel è una soluzione che prevede l’integrazione in ogni LED RGB di un driver e del rispettivo LED RGB in SMD e perciò il comando diretto LED per LED.

Il canale dati per la comunicazione è seriale di tipo oneWire e l’alimentazione a 5 volt; i LED Neopixel si collegano in cascata, nel senso che la linea dati in ingresso, oltre a raggiungere il rispettivo controller, viene ripetuta sull’uscita.

La comunicazione sul canale dati avviene a un massimo di 800 kbps ed è del tipo con clock embedded. Il controllo seriale è indispensabile perché altrimenti per gestire individualmente i singoli LED che compongono la nostra stella servirebbero, pur adottando il comando a matrice in multiplex, tantissime linee. Invece a noi serve un unico canale dati da gestire con una sola linea della scheda Arduino, per ragioni di semplicità e ingombro.

La soluzione adottata consente di affidarsi a una piccolissima Arduino Micro, mentre se avessimo dovuto implementare il multiplex per i nostri 56 LED, la quantità di linee ci avrebbe imposto l’adozione delle “grandi” della famiglia Arduino.

Se è vero che i LED del sistema Neopixel possono essere collegati in cascata in modo che la linea dati da uno passi al successivo, l’effetto collaterale è che oltre un certo numero di LED la velocità di gestione deve ridursi sensibilmente.

A causa di ciò, se si devono realizzare matrici per mostrare della grafica veloce è preferibile impiegare molte linee con pochi LED ciascuna.

Ma non è comunque il nostro caso, perché nella nostra stella di Natale, sebbene qualche animazione preveda la variazione della luminosità individuale per comporre vari effetti luminosi, la velocità di esecuzione dei giochi non è tale da raggiungere il data-rate limite dei Neopixel.

 

Download del Codice per la Stella di Natale Neopixel

 

La definizione di tutti gli effetti previsti dallo sketch che gira in Arduino è riportata nel Listato 1.

Listato 1

void startShow(int i) { 
Imposta_Colore(modo);
switch(i){
case 0: colorOff(); //Tutto spento
break;
case 1: Imposta_Colore(random(0,colore_max));
Stella1_Dissolvenza(); //Dissolvenza stella 1
Stella2_Dissolvenza(); //Dissolvenza stella 2
break;
case 2: Stella1(); //Accensione sequenziale stella 1 e spegnimento
Stella2(); //Accensione sequenziale stella 2 e spegnimento
break;
case 3: Stella_Alternata(); //accensione alternata stelle
break; 
case 4: Imposta_Colore(random(0,colore_max));
for (int ciclo=0; ciclo<3; ciclo++)
{
colorCarica(); // Effeto carica
delay(pausa_effetti*2000);
colorScarica(); // Effeto scarica
delay(pausa_effetti*1000);
}
break; 
case 5: Stella_Casuale();
break; 
case 6: Imposta_Colore(random(0,colore_max));
Strobo(); // Effetto strobo
break; 
case 7: Imposta_Colore(random(0,colore_max));
barraScorrevole(pausa_sfumatura); //effetto scorrimento
break; 
case 8: rainbowCycle(12);
break;
case 9: colorMix (10);
break;
}
}

 

Se volete apportare modifiche al firmware per realizzare effetti non previsti dal nostro (il Listato 2 ne riporta uno d’esempio, che provvede all’accensione in dissolvenza delle due stelle…) ricordate che la frequenza di refresh e quindi la velocità di accensione/spegnimento dei singoli LED, è inversamente proporzionale alla quantità di LED da gestire.

Per ogni strip di LED è possibile impostare a piacimento la frequenza di refresh, in modo da rendere impercettibili determinati giochi di luce. Nel nostro caso la frequenza di scansione dei LED è di 400 Hz.

La massima velocità di invio dei dati condiziona, a parità di numero di LED comandabili, la frequenza di refresh; questo significa che più sono i LED da gestire, minore è la frequenza di refresh e quindi la velocità di movimento dell’immagine rappresentata.

Il protocollo di comando del sistema Neopixel prevede l’invio ciclico (a una frequenza che dipende da quella del refresh desiderato) di stringhe di dati composte ognuna da 24 bit suddivisi in gruppi di tre byte (quindi 3×8 bit); ognuno dei byte di una stringa da 24 bit contiene lo stato di illuminazione di ciascun colore base in questo ordine: prima gli otto bit del verde, poi quelli del rosso e infine quelli del verde.

Dallo schema elettrico appare il collegamento in cascata dei LED Neopixel: la linea dati entrante nel terminale DI esce dal DO, che ne ripete i dati; la DI del primo LED (LD1) fa capo al contatto IN del circuito, cui si applicano i dati forniti da Arduino. La massa di riferimento di alimentazione e dati è unica e fa capo al contatto GND dello stampato; l’alimentazione a 5 volt anche, e fa capo a 5V.

Con riferimento allo schema di cablaggio, vediamo che Arduino pilota il circuito della stella utilizzando una sola linea dati, quindi il contatto IN si collega a tale I/O della scheda, che è il pin digitale 9, in questa applicazione impostato nello sketch come output.

L’alimentazione della stella viene prelevata dalle linee 5V e GND di Arduino Micro; per evidenti ragioni di assorbimento la Arduino dev’essere alimentata da un alimentatore esterno capace di fornire circa 800 mA su 5V stabilizzati.

È possibile ottenere l’alimentazione dalla presa microUSB oppure fornendola tra Vin e GND, ma in questo caso l’alimentatore deve erogare almeno 7 volt.

Listato 2

void Stella1_Dissolvenza(void)
{
int pixel = 0;
int i=0;
uint32_t R=0;
uint32_t G=0;
uint32_t B=0; 
num_pixel=strip.numPixels(); //ottengo il numero di pixel (led presenti)
colorOff(); //Spengo tutto
for (int ciclo=0; ciclo<7; ciclo++)
{
if (R_ON==true) R=0; 
if (G_ON==true) G=0;
if (B_ON==true) B=0;
//Incremento luminosità
for(int i=0; i<luce_max; i++)
{ 
if (R_ON==true)
{
R=i; 
}
if (G_ON==true)
{
G=i; 
}
if (B_ON==true)
{
B=i; 
}

for(pixel=0; pixel<num_pixel-21; pixel++) //Accendo la prima stella in modo graduale
{
strip.setPixelColor(pixel, strip.Color(R, G, B)); 
} 
strip.show();
delay(pausa_sfumatura/2); 
}
//Decremento luminosità
for(int i=luce_max; i>0; i--)
{ 
if (R_ON==true)
{
R=i; 
}
if (G_ON==true)
{
G=i; 
}
if (B_ON==true)
{
B=i; 
}

for(pixel=0; pixel<num_pixel-21; pixel++) //Aggiorno lo stato della prima stella
{
strip.setPixelColor(pixel, strip.Color(R, G, B)); 
} 
strip.show();
delay(pausa_sfumatura/2); 
}
}
}

I Collegamenti della Stella Neopixel ad Arduino Micro

I componenti della Stella Neopixel

Elenco componenti

C1÷C28: 100 nF ceramico (0805)
R1: 470 ohm (0805)
LD1÷LD56: LED Neopixel WS2812B
(5050)

Varie: 
- Connettore Filo/Scheda Maschio 3 vie 90°
- Connettore Filo/Scheda Femmina 3 vie 90°
- Circuito stampato S1300 (148 x 148mm)

Come controllare la Stella Neopixel

Il montaggio del connettore non crea alcun problema: basta infilare i terminali nei rispettivi fori e stagnarli dal lato dove si trovano i componenti.

Per collegare la Arduino Micro dovete utilizzare dei jumper cui tagliare le estremità per poi saldarle ai contatti del connettore femmina volante che inserirete nel 3 poli della stella; ricordate che la massa (GND) va sul contatto in mezzo, l’IN dei dati all’esterno della stella e il 5V all’interno.

Prima di connettere la Arduino dovete collegarla al PC mediante un cavo USB/microUSB e caricarvi lo sketch che trovate, per il download, nel nostro sito www.elettronicain.it insieme ai file del progetto.

Una volta caricato il firmware, collegato e alimentato il tutto, potete verificare che tutto funzioni correttamente: le animazioni dovrebbero partire pochi istanti dopo aver fornito l’alimentazione, in quanto lo sketch che abbiamo scritto permette di generare differenti effetti ciclati sequenzialmente appena fornita l’alimentazione.

Notate che se alimentate il tutto dai pin Vin e GND della scheda Arduino non dovete lasciare attaccato il computer sull’USB.