Realizziamo installazioni luminose NeoPixel con Fishino e NodeMCU controllati via Wi-Fi da PC o da Raspberry Pi tramite una libreria Python.
Alcuni anni fa l’americana Adafruit Industries ha rivoluzionato il mercato dei LED introducendo i propri NeoPixel, la cui caratteristica principale è di integrare, in un unico package, un LED RGB e il rispettivo controller.
L’intento di Adafruit era chiaramente quello di andare incontro al mondo Arduino semplificando la gestione dei LED, integrando nello stesso package sia il controllore che il led RGB.
Da allora i NeoPixel si sono diffusi ampiamente tra il pubblico anche e soprattutto perché oltre a integrare il controller possono essere collegati in cascata e indirizzati individualmente, controllandone singolarmente il colore e la luminosità. All’interno di ciascun LED NeoPixel si trova un LED SMD RGB (solitamente un 5050 da circa 20 lumen) e un integrato WS2811 o WS2812 che svolge il ruolo di driver.
Un microcontrollore (ad esempio Arduino) invia un array di byte con un determinato timing attraverso a tutti i LED collegati in serie e rende possibile la creazione di colorate e luminose animazioni.
I prodotti NeoPixel sono disponibili in varie forme e composizioni: LED singoli, strisce, anelli, archi e matrici.
La grande diffusione di questi LED ha fatto sì che nascessero molti progetti che ne hanno dimostrato la loro versatilità: illuminazione interna ed esterna, gadget, vestiti luminosi, LED wall e molti altri ancora.
In molti progetti, il microcontrollore collegato ai NeoPixel contiene delle sequenze predefinite di effetti che riproduce ciclicamente oppure è connesso via USB al PC per ricevere comandi rendendo così difficile l’installazione di questi progetti in posti remoti senza dover ricorrere a lunghi cablaggi o all’aggiornamento dello sketch ogni volta che si deve cambiare animazione.
Il nostro progetto
In questo articolo presentiamo un sistema che permette di controllare svariate installazioni NeoPixel sparse per casa tramite WiFi, senza dover ogni volta modificare lo sketch caricato sui microcontrollori; collegheremo Fishino Guppy a una stella NeoPixel mentre NodeMCU sarà collegato a una striscia NeoPixel da 150 LED (tutti e due sono dotati del chip ESP8266 che fornirà la connettività WiFi), mentre come controller software utilizzeremo un programma in Python (con una libreria sviluppata appositamente) che potrà essere eseguito sia su un PC Windows che su Raspberry Pi e che manderà, tramite la rete WiFi, i vari effetti da riprodurre a tutti i dispositivi NeoPixel connessi.
Per realizzare il progetto abbiamo bisogno dei seguenti componenti, reperibili dal sito www.futurashop.it:
• una striscia NeoPixel da 5 metri (cod. STRIP300LED);
• una stella NeoPixel con 56 LED (cod. FT1300M);
• un alimentatore da 5 volt DC con potenza correttamente dimensionata (cod. MW05005);
• una resistenza da 470 ohm;
• due condensatori da 1.000 µF, 6 volt o superiori;
• una scheda Fishino Guppy (cod. GUPPY);
• una scheda NodeMCU (cod. NODEMCUESP);
• un convertitore di livelli logici 3,3 ÷ 5 volt (cod. LLCTTL);
• cavi per cablaggio e jumper;
• una scheda Raspberry Pi con relativa microSD e alimentatore.
Quando si lavora con i NeoPixel è molto importante dimensionare l’alimentatore perchè bisogna considerare che un LED di questa tipologia può arrivare ad assorbire 60 milliampere se acceso a luce bianca alla massima luminosità: moltiplicando questo valore per i 150 LED che troviamo nella striscia di 5 metri otteniamo un assorbimento di ben 9 ampere.
Altri due accorgimenti che dobbiamo prendere quando lavoriamo con questi LED sono sicuramente l’utilizzo del condensatore e della resistenza: il condensatore va collegato ai cavi di alimentazione rispettando la giusta polarità per livellare l’iniziale picco di tensione generata dall’alimentatore che andrebbe a danneggiare i LED; la resistenza va collegata tra il pin del microcontrollore e la linea dati (pin DIN) della striscia NeoPixel (non serve se utilizzate la stella perchè è già stata prevista nel PCB).
Solo se utilizzeremo un NodeMCU avremo bisogno di un convertitore di livelli logici, perché questa scheda utilizza una logica a 3,3 volt, mentre i NeoPixel hanno bisogno di essere pilotati con una logica a 5 volt (in realtà si potrebbe mantenere una logica da 3,3 volt se l’alimentazione dei NeoPixel fosse compresa tra i 3,3 e i 3,8 volt, ma noi abbiamo un alimentatore da 5 volt).
Per prima cosa scarichiamo l’archivio dei file di questo progetto da GitHub (https://github.com/open-electronics/NeoPy) dove troveremo sia gli sketch per le due schede che i sorgenti in Python della libreria, inclusi alcuni esempi di animazione.
Prepariamo l’ambiente di sviluppo Arduino IDE per poter programmare tutte e due le schede: per quanto riguarda Fishino dobbiamo scaricare dal sito www.fishino.it le librerie e verificare che la versione del firmware sia allineata con la versione delle librerie (per i dettagli visitate la pagina “Aggiornamento Firmware” nella sezione “Documentazione” del sito).
Per prepararci a programmare NodeMCU dobbiamo invece aprire le impostazioni dell’IDE tramite il menu “File” e cliccare sull’icona a destra della voce “URL aggiuntive per il Gestore Schede”; si aprirà una finestra dove potremo incollare la stringa:
http://arduino.esp8266.com/stable/package_esp8266com_index.json.
Dopo aver fatto questo primo passaggio possiamo installare la scheda, cliccando dalla schermata principale dell’IDE Strumenti->Scheda->Gestore schede… si aprirà la finestra “Gestore schede”; nella casella di ricerca scriviamo “esp8266” e installiamo l’ultima versione di “esp8266 by ESP8266 Community”.
A questo punto nella sezione Strumenti -> Scheda, dovremo vedere la scheda NodeMCU 1.0 sotto la sezione “ESP8266 Modules”: selezioniamola e cambiamo il parametro “Upload speed” in 115.200.
L’ultimo passaggio per completare la configurazione del nostro ambiente di sviluppo (necessario per tutte e due le schede) è quello di scaricare la libreria di gestione dei NeoPixel distribuita da Adafruit.
Scarichiamo lo zip e scompattiamolo nella cartella “libraries” di Arduino, poi riavviamo l’IDE per importare la nuova libreria; ora siamo pronti per aprire lo sketch “NeoPy_Fishino” (selezionando come scheda “Arduino Nano” nel menu Strumenti): modifichiamo i valori MY_SSID e MY_PASS della nostra rete WiFi e il numero di LED che intendiamo connettere alla scheda, lasciamo invece invariato il valore di PORT e di PIN; per settare un IP statico decommentiamo e modifichiamo la riga di IPADDR, infine carichiamo lo sketch su Fishino.
Connettiamo ora al PC la scheda NodeMCU e apriamo lo sketch “NeoPy_NodeMCU” (selezionando come scheda “NodeMCU 1.0” nel menu Strumenti), anche qui modifichiamo solo i valori contenuti nella sezione “SETUP” lasciando invariati i valori di PORT e PIN; carichiamo poi lo sketch su NodeMCU.
Il funzionamento del sistema è rappresentato nello schema in Fig. 1: tramite la libreria in Python “NeoPy” creiamo un oggetto che rappresenta la nostra installazione NeoPixel, successivamente andiamo a settare i LED, aggiornando solamente l’array contenuto nell’oggetto stesso con i metodi “Set()” o “SetAll()”; con il metodo “Show()” viene pacchettizzato l’array con le informazioni di tutti i LED e inviato in UDP all’endpoint (IP e porta) specificati.
Fig. 1 Funzionamento dell’oggetto NeoPy e degli sketch
Come possiamo vedere nel Listato 1 (sketch per Fishino Guppy) e nel Listato 2 (codice per il NodeMCU) gli sketch sono molto simili: nella funzione “setup” viene inizializzata la connessione alla rete WiFi con i parametri precedentemente impostati, successivamente viene creato un server UDP in ascolto sulla porta specificata.
Nella funzione “loop” viene ricevuto il pacchetto in UDP e ne viene validata la lunghezza: infatti un pacchetto corretto dovrà avere una lunghezza pari al triplo del numero dei LED specificati, in quanto il colore di ogni LED sarà rappresentato da un array di tre byte; ad esempio, per due LED il pacchetto sarà RGBRGB.
Listato 1
/*
Name: NeoPy - Fishino
Description: NeoPixels UDP controller
Author: Luca Bellan
Version: 1.3
*/
#include <Fishino.h>
#include <SPI.h>
#include <Adafruit_NeoPixel.h>
// BEGIN SETUP
#define MY_SSID“ mio_ssid”
#define MY_PASS“ mia_password”
#define LEDS 56
//#define IPADDR 192, 168, 1, 19
#define GATE 192, 168, 1, 1
#define SUB 255, 255, 255, 0
#define PORT 4242
#define PIN 3
// END SETUP
FishinoUDP Udp;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, _ PIN, NEO_GRB + NEO_KHZ800);
#ifdef IPADDR
IPAddress ip(IPADDR);
IPAddress gateway(GATE);
IPAddress subnet(SUB);
#endif
long unsigned int packetSize;
unsigned int len;
int r, g, b;
void setup() {
while (!Fishino.reset()) {
delay(500);
}
Fishino.setMode(STATION_MODE);
while (!Fishino.begin(MY_SSID, MY_PASS)) {
delay(500);
}
#ifdef IPADDR
Fishino.config(ip, gateway, subnet);
#else
Fishino.staStartDHCP();
#endif
while (Fishino.status() != STATION_GOT_IP) {
delay(500);
}
Udp.begin(PORT);
strip.begin();
strip.show();
}
void loop() {
packetSize = Udp.parsePacket();
if (packetSize == LEDS * 3) {
char packetBuffer[packetSize];
len = Udp.read(packetBuffer, packetSize);
if (len > 0) {
packetBuffer[len] = 0;
}
for (int i = 0; i < LEDS * 3; i += 3) {
r = (int)(byte * )(packetBuffer)[i];
g = (int)(byte * )(packetBuffer)[i + 1];
b = (int)(byte * )(packetBuffer)[i + 2];
strip.setPixelColor(i / 3, r, g, b);
}
strip.show();
}
}
Listato 2
/*
Name: NeoPy - NodeMCU
Description: NeoPixels UDP controller
Author: Luca Bellan
Version: 1.3
*/
#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
// BEGIN SETUP
#define MY_SSID“ mio_ssid”
#define MY_PASS“ mia_password”
#define LEDS 150
//#define IPADDR 192, 168, 1, 32
#define GATE 192, 168, 1, 1
#define SUB 255, 255, 255, 0
#define PORT 4242
#define PIN D3
// END SETUP
WiFiUDP Udp;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LEDS, PIN,
NEO_GRB + NEO_KHZ800);
#ifdef IPADDR
IPAddress ip(IPADDR);
IPAddress gateway(GATE);
IPAddress subnet(SUB);
#endif
long unsigned int packetSize;
unsigned int len;
int r, g, b;
void setup() {
WiFi.mode(WIFI_STA);
#ifdef IPADDR
WiFi.config(ip, gateway, subnet);
#endif
WiFi.begin(MY_SSID, MY_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
Udp.begin(PORT);
strip.begin();
strip.show();
}
void loop() {
packetSize = Udp.parsePacket();
if (packetSize == LEDS * 3) {
char packetBuffer[packetSize];
len = Udp.read(packetBuffer, packetSize);
if (len > 0) {
packetBuffer[len] = 0;
}
for (int i = 0; i < LEDS * 3; i += 3) {
r = (int)(byte * )(packetBuffer)[i];
g = (int)(byte * )(packetBuffer)[i + 1];
b = (int)(byte * )(packetBuffer)[i + 2];
strip.setPixelColor(i / 3, r, g, b);
}
strip.show();
}
}
Successivamente avviene lo spacchettamento della stringa UDP e il settaggio di ogni LED; infine viene richiamato il metodo per aggiornare tutti i LED con il comando “strip.show()”.
Per sviluppare questo sistema abbiamo scelto il protocollo UDP, perché uno dei suoi punti di forza è l’invio e ricezione di pacchetti molto più rapido rispetto al TCP e la velocità di trasmissione si rende necessaria nel caso in cui dovremo riprodurre effetti con cambi di colore abbastanza rapidi; uno dei punti deboli del protocollo UDP è che la perdita dei pacchetti non viene gestita soprattutto in caso di rete lenta o di alte velocità di trasmissione.
Proprio per questo, per creare i nostri effetti luminosi dovremo utilizzare dei piccoli delay per non fare accavallare i pacchetti in arrivo sul Fishino o sul NodeMCU. Dopo aver programmato le due schede seguiamo la Fig. 2 per collegare il pin 3 di Fishino alla linea dati dello strip NeoPixel (pin IN) mediante dei jumper: ricordate di inserire la resistenza da 470 Ohm.
Alimentiamo poi la stella collegandola all’alimentatore tramite i pin 5V e GND e Fishino collegandolo ai pin 5V e GND. Seguendo invece la Fig. 3 colleghiamo il pin D3 del NodeMCU a un canale nella sezione a 3,3 volt del convertitore di livelli, usciamo poi dallo stesso canale ma dalla sezione a 5 volt e colleghiamoci con la resistenza da 470 ohm alla linea dati della striscia NeoPixel (cavo bianco).
Alimentiamo la parte a bassa tensione del convertitore con i pin 3V3 e GND di NodeMCU; tramite i due cavi che arrivano dall’alimentatore andiamo ad alimentare la parte a 5 volt del convertitore, il NodeMCU (tramite i pin VIN e GND) e la striscia NeoPixel.
Alimentiamo ora le due installazioni NeoPixel e verifichiamo che siano connesse alla nostra rete WiFi (ad esempio accedendo alla pagina di configurazione del router o con il software gratuito Advanced IP Scanner); scarichiamo l’ultima versione disponibile di Python 3.x e installiamolo sul nostro PC.
Fig. 2 Schema dei collegamenti con Fishino Guppy e striscia NeoPixel
Fig. 3 Schema dei collegamenti con NodeMCU e striscia NeoPixel
Lo sviluppo in python
Per sviluppare il controller WiFi abbiamo scelto Python perchè è un linguaggio moderno, flessibile, intuitivo e semplice da imparare; inoltre è multipiattaforma, quindi il codice da noi scritto potrà essere eseguito su Windows, sui sistemi operativi Apple e su Linux (nel nostro caso su Raspberry Pi Pi).
Sul sito ufficiale possiamo anche trovare una guida completa a questo linguaggio.
Apriamo il programma IDLE appena installato, che sembra un semplice blocco note, ma in realtà ci permette di scrivere ed eseguire programmi in Python: salviamo subito il file vuoto nella stessa cartella in cui si trova neopy.py.
Tramite la libreria NeoPy abbiamo a disposizione i seguenti comandi:
• oggetto.Set(N, (R, G, B)): possiamo settare il LED numero N (nel nostro esempio da 0 a 55) con il colore formato da R, G, B (ciascuno può assumere un valore da 0 a 255); ad esempio per settare il quinto LED a verde il comando sarà oggetto.Set(4, (0, 255, 0));
• oggetto.SetAll((R, G, B)): molto simile al comando precedente, ma in questo caso settiamo tutti i LED sullo stesso colore facendo attenzione alle doppie parentesi; ad esempio per settare tutti i LED a blu il comando sarà oggetto.SetAll((0, 0, 255));
• oggetto.SetBrightness(L): serve a settare a tutti i LED una percentuale di luminosità L (valore compreso tra 0 e 100), valore di default 80; ad esempio per settare metà della luminosità il comando sarà oggetto.SetBrightness(50);
• oggetto.Wheel(V): restituisce un valore di tipo (R, G, B) in base al parametro V passato (valore compreso tra 0 e 255 che passa tutti i colori); ad esempio per settare tutti i LED a un colore random il comando sarà oggetto.SetAll(oggetto.Wheel(NUMERO_RANDOM));
• oggetto.Show(): serve per inviare effettivamente il comando UDP via WiFi e rendere effettive tutte le modifiche che abbiamo attuato, settando fisicamente i LED.
Ora che conosciamo i comandi disponibili, scriviamo questo piccolo programma:
from neopy import NeoPy import time stella= NeoPy(56, “192.168.1.3”) stella.SetBrightness(30) for i in range(56): stella.Set(i, (255, 0, 0)) stella.Show() time.sleep(0.5)
Nella prima riga abbiamo importato la libreria NeoPy, mentre nella seconda riga abbiamo importato la libreria “time” che ci servirà più avanti per temporizzare l’animazione; successivamente abbiamo istanziato un oggetto NeoPy nella variabile “stella” indicando 56 LED e l’indirizzo IP 192.168.1.3 (la porta di default è la 4242 e deve essere uguale a quella presente nello sketch).
Abbiamo poi settato la luminosità complessiva al 30% e abbiamo creato un ciclo for in cui, ad ogni step, la variabile “i” assumerà i valori che vanno da 0 a 55; sempre ad ogni step settiamo un LED alla volta sul colore rosso con il metodo “Set()”, aggiorniamo poi i LED con “Show()” e aspettiamo mezzo secondo grazie all’oggetto “time”.
Facciamo attenzione ad allineare i tre comandi dentro al ciclo for con una tabulazione altrimenti Python ci darà errore di compilazione, salviamo e premiamo F5 per eseguire il programma: se tutto è stato impostato correttamente vedremo i NeoPixel sulla stella animarsi.
Possiamo istanziare quanti oggetti vogliamo, ad esempio con il seguente programma istanziamo sia la stella che la striscia NeoPixel per poi colorarle una di bianco e l’altra di rosso:
from neopy import NeoPy stella= NeoPy(56, “192.168.1.3”) striscia= NeoPy(150, “192.168.1.19”) stella.SetAll((255, 255, 255)) stella.Show() striscia.SetAll((255, 0, 0)) striscia.Show()
Nel repository del progetto scaricato da GitHub possiamo trovare anche i file “examples_star.py” e “examples_strip.py” che contengono alcuni esempi e ci aiuteranno a comprendere meglio i vari script per creare le animazioni.
Spostiamoci ora su Raspberry Pi per provare gli stessi script Python che abbiamo creato e avviato sul PC: scarichiamo quindi una nuova immagine di Raspbian dal sito ufficiale, scriviamola sulla MicroSD con Win32DiskImager, inseriamo la MicroSD in Raspberry Pi, alimentiamo Raspberry Pi e connettiamolo alla stessa rete a cui sono connessi i nostri NeoPixel.
Con un terminale SSH (come Putty o MobaXTerm) connettiamoci a Raspberry Pi (utente “pi”, password “Raspberry Pi”) e spostiamoci nella cartella “pi”: cd /home/pi/ Installiamo git con il comando (dove richiesto premiamo Y e INVIO): sudo apt-get install git Scarichiamo anche qui i file appartenenti a questo progetto da GitHub ed entriamo nella relativa cartella con questi due comandi: git clone https://github.com/open-electronics/NeoPy cd NeoPy/
Controlliamo di essere nella stessa cartella del file “neopy.py” con il comando ls -l e creiamo un nuovo file “test.py”: nano test.py Copiamo il codice del piccolo programma scritto in precedenza per accendere la stella un LED alla volta e chiudiamo il file salvandolo con CTRL+X, poi Y e INVIO.
Ora proviamo ad eseguire il programma con il comando: python3 test.py La stella NeoPixel si illuminerà proprio come quando abbiamo lanciato lo stesso programma sul PC; questo serve ad evitare di tenere acceso un PC per fare da controller WiFi a tutte le installazioni NeoPixel: piuttosto terremo acceso Raspberry Pi che è molto più compatto e meno esoso di energia elettrica.
Immaginiamo ora di aver creato diversi programmi in Python sul nostro Raspberry Pi; ogni programma esegue degli effetti diversi sulle nostre installazioni NeoPixel e devono essere eseguito in determinati momenti della giornata.
Sarebbe molto scomodo ricordarsi di lanciarli a mano ogni volta e per questo ci viene in aiuto crontab; crontab è uno schedulatore presente in Raspbian a cui possiamo indicare l’esatto momento in cui vogliamo lanciare un programma: al primo impatto la sintassi risulterà un po’ complicata, ma la analizzeremo nel dettaglio.
Digitiamo il comando: crontab -e La prima volta ci verrà chiesto quale editor vogliamo usare per editare il file delle schedulazioni digitiamo il comando: 2 (Nano) e diamo INVIO; si aprirà così la finestra di editing per inserire le righe dei task, ogni riga corrisponde a un programma che vogliamo eseguire e deve essere composta da sei parametri separati dallo spazio: MI H D MO DW COMMAND.
Vediamo i parametri nel dettaglio:
• MI: minuti, valore da 0 a 59 oppure * significa “tutti”;
• H: ore, valore da 0 a 23 oppure * significa “tutti”;
• D: giorno del mese, valore da 1 a 31 oppure * significa “tutti”;
• MO: mese, valore da 1 a 12 oppure * significa “tutti”;
• DW: giorno della settimana, valore da 0 a 6 (dove 0 è domenica e 6 è sabato) oppure * significa “tutti”;
• COMMAND: il comando da eseguire (ricordiamoci di inserire sempre il percorso completo del file Python).
Spostiamoci in fondo al file e scriviamo questa riga: 0 * * * * python3 /home/pi/NeoPy/test.py
Abbiamo appena impostato l’esecuzione del nostro test.py al minuto zero, di ogni ora, di ogni giorno del mese, di ogni mese, di ogni giorno della settimana; salviamo e chiudiamo il file con CTRL+X, poi Y e INVIO, attendiamo quindi lo scoccare della nuova ora per l’avvio dello script e verifichiamo che la stella si accenda proprio come se avessimo lanciato lo script a mano: in questo modo possiamo programmare l’esecuzione di tutti gli script che vogliamo aggiungendo nuove righe nel crontab.
Conclusioni
Con i NeoPixel controllati in WiFi e il sistema delle schedulazioni su Raspberry Pi potremo, ad esempio, piazzare una striscia LED in camera e simulare l’alba a una determinata ora per realizzare una sveglia luminosa; oppure potremo creare dei simpatici effetti luminosi in giardino dopo il tramonto.
Inoltre, piazzando i LED in alcune stanze di casa, potremo accenderli in maniera temporizzata e randomica per simulare la nostra presenza in casa o, ancora, potremo collegare dei sensori a Raspberry Pi e comandare l’illuminazione in base al loro stato.
