Il Neopixel Ring Watch è montato e pronto per il primo test di funzionamento, ho realizzato uno sketch di simulazione che verifica il corretto funzionamento dei due anelli e l’effetto orologio realizzato con i neopixel
I due anelli come sai sono stati collegati uno in cascata all’altro, in particolare il pin Data In dell’anello composto da 12 led WS2812 è connesso al pin Data Out dell’anello esterno da 60 led.
Questa informazione in questo momento potrebbe sembrarti superflua ma è su questo collegamento che si basa il funzionamento dell’orologio.
Collegamento del Neopixel Ring Watch ad Arduino
il collegamento tra il primo anello, quello costituito da 60 led, avviene con un soli 3 contatti di cui 2 sono il +5v e il Gnd ed un terzo è il cavo dati che io ho mantenuto al pin 6 come negli esperimenti che hai già visto con i neopixel:
anche se in figura è rappresentato solo un anello devi considerare che il collegamento generale è più simile al seguente:
già visto in precedenza.
Osservando lo schema elettrico e prima di passare alla descrizione dello sketch avrai già capito che i primi 60 led hanno una numerazione che parte da 0 a 59 ( come i secondi ed i minuti ) ed i 12 led WS2812 del Neopixel Ring Watch posizionati sull’anello da 12 led partono dal pixel 60 al 72.
Quest’ultima informazione è fondamentale per controllare in modo corretto i led relativi alla visualizzazione dell’orario.
Sketch di simulazione
#include <Adafruit_NeoPixel.h> #ifdef __AVR__ #include <avr/power.h> #endif #define PIN 6 #define NUMPIXELS 72 Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 1000; // delay for half a second int colorH[] = {150,0,0}; int colorM[] = {0,150,0}; int colorS[] = {0,0,150}; byte H = 8; byte M = 59; byte S = 0; void setup() { pixels.begin(); // This initializes the NeoPixel library. Serial.begin(9600); for ( int i=0; i<NUMPIXELS; i++ ) { pixels.setPixelColor(i, pixels.Color(0,0,0)); pixels.show(); delay( 5 ); } } void loop() { if ( S > 59 ) { pixels.setPixelColor(M, pixels.Color(0,0,0)); // prev min pixels.setPixelColor(59, pixels.Color(0,0,0)); // last second M++; S = 0; } if ( M > 59 ) { pixels.setPixelColor((60+H), pixels.Color(0,0,0)); // prev hour pixels.setPixelColor(59, pixels.Color(0,0,0)); // last second, min H++; M = 0; S = 0; } if ( H > 12 ) { pixels.setPixelColor((60+H), pixels.Color(0,0,0)); // last hour pixels.setPixelColor(59, pixels.Color(0,0,0)); // last second, min H = 0; M = 0; S = 0; } pixels.setPixelColor((S-1), pixels.Color(0,0,0)); pixels.setPixelColor(S, pixels.Color(colorS[0],colorS[1],colorS[2])); pixels.setPixelColor(M, pixels.Color(colorM[0],colorM[1],colorM[2])); pixels.setPixelColor((60+H), pixels.Color(colorH[0],colorH[1],colorH[2])); pixels.show(); delay( delayval ); S++; }
inizia subito con le linee 01-04: includi la libreria Adafruit_NeoPixel.h e la power.h se è definita la costante __AVR__;
linee 06-07: definisci il pin a cui è collegata tutta la catena di NeoPixel ( pin 6 di arduino ) e il numero di pixel di cui è composto il tuo Neopixel Ring Watch ( 72 = 60 + 12 );
linea 09: inizializza l’istanza pixels dalla classe Adafruit_Neopixel;
linee 12-15: definisci il tempo di delay che utilizzerai tra un ciclo di loop() ed il successivo per la simulazione ( 1000 millisecondi = 1 secondo ) e tre array ciascuno composto da 3 valori che serviranno ad rispettivamente a formare il colore del led per le ore, i minuti e i secondi;
linee 17-19: definisci tre variabili di tipo byte una per tener traccia dell’ora, dei minuti e dei secondi durante la simulazione;
linea 22: inizializza l’istanza di comunicazione con i led dell’Neopixel Ring Watch ;
linea 23: imposta un canale di comunicazione seriale;
linee 24-25: il ciclo for da 0a 71 ( 72 valori in tutto ) serve a porre a 0,0,0 il colore di ciascun led del Neopixel Ring Watch in fase di setup che equivale a spegnere il led corrispondente;
linee 29-34: quando il valore di S supera il 59, ultimo secondo, spegni il minuto corrente, corrispondente al valore di M, e contemporaneamente il led corrispondente al 59esimo secondo; incrementa il valore di M, in modo che nella simulazione i minuti scorrano come se ci fosse realmente un RTC connesso ed, infine, poni a 0 il valore di S simulando l’azzeramento dei secondi;
linee 35-41: accade un processo simile a quello appena analizzato per S solo applicato al cambio di ora dopo il minuto 59. Il led che si spengono sono quelli relativi all’ora ed ai minuti e secondi, che in questo caso coincidono = 59; l’ora viene incrementata e i minuti e secondi posti a 0. Nota il controllo del led che viene spento non è solo indicato da H ma dalla formula 60 + H ossia l’ora corrente sul secondo anello i cui led partono dal numero 60 fino al 71;
linee 42-48: oramai il gioco ti è chiaro, al passaggio dell’ora spegni il led relativo all’ora corrente e il led 59 dei minuti e dei secondi, l’unica differenza è data dal mancato incremento della variabile H dell’ora che poni a 0 essendo un orologio AM/PM con solo 12 led;
linea 50: questa linea ti permette di spegnere il led dei secondi durante il loro scorrere, infatti il valore di S-1 viene posto a 0,0,0 ad ogni ciclo;
linea 51: accendi il led relativo al secondo corrente S;
linea 52: accendi il led corrispondente al valore di M ossia il valore del minuto corrente;
linea 53: accendi il ler relativo all’ora corrente usando il solito calcolo ( 60 + H );
linea 54: al termine di tutte le impostazioni eseguite rendi visibile la situazione sul Neopixel Ring Watch usando il metodo show() dell’istanza pixels;
linea 56: attendi il tempo impostato alla linea 12 prima di proseguire con lo sketch, essendo un orologio questo valore di incremento, in fase di simulazione, l’ho fissato a 1000 in modo che sembri quasi un orologio preciso.
linea 57: subito dopo la pausa di 1 secondo incrementa il valore di S in modo che al loop() successivo scateni tutto quanto necessario per cambiare l’ora visualizzata.
Warning!
Ricorda che questa è solo una simulazione e non un orologio reale, per realizzarlo dovrai usare un differente sistema di RTC di cui Arduino non è dotato.
Ogni istruzione che lo sketch deve eseguire impiega un tempo computazionale che rallenta sempre più un orologio realizzato con questo sistema.
Il video di simulazione dell’orologio neopixel
Ecco cosa dovresti riuscire a vedere se il tuo orologio funziona come il mio: