I LED WS2812 possono essere pilotati attraverso funzioni matematiche complesse della libreria FastLED, per gestire i colori in modo armonico.
Nelle scorse puntate abbiamo conosciuto i “LED intelligenti” della serie WS2812, dotati di un microcontroller per modularne adeguatamente i colori, ed iniziato a giocare con le funzionalità di programmazione della libreria FastLED.
Oggi inizieremo a fare “sul serio”, ed impareremo ad applicare alcune funzioni, un tempo appannaggio di grafici e designer, per creare effetti “quasi” fantascientifici.
Si parte!
Articoli precedenti:
- LED WS2812 per Arduino – Cosa sono e come si usano
- LED WS2812 – Attività di configurazone con Arduino
- LED WS2812 e Arduino – Ora giochiamo con i colori
- LED WS2812 e Arduino – Altre animazioni sui colori
- LED WS2812 con Arduino – Gestire pattern variabili
Navigar per l’alto mare…
Dal punto di vista emotivo, parlare di onde ci fa tornare con nostalgia ad immagini di vacanze soleggiate in riva al mare, o a flussi di emozioni (“ondate”) difficili da gestire.
Dal punto di vista elettronico, invece, un’onda non è altro che un segnale periodico, che si ripete immutabile nel tempo. Il segnale viene riconosciuto attraverso la propria frequenza (quante volte al secondo viene ripetuto) o dalla lunghezza d’onda (ovvero quanto tempo intercorre tra l’inizio e la fine di ciascuna ripetizione). Inutile ricordare che frequenza e lunghezza d’onda sono valori reciproci: λ = 1/φ (la lunghezza d’onda è l’inverso della frequenza… e viceversa).
Iniziamo ora ad analizzare la funzione beatsin8():
|
1 |
beatsin8(segnali_al_minuto, led iniziale, NUM_LEDS - 1, timebase, phase_offset) |
La funzione dichiara una serie di parametri: il numero di segnali al minuto, il LED iniziale, il numero di led (o il valore finale dell’onda), e due parametri che conosceremo andando avanti nell’articolo. Vediamo un esempio di programma che utilizza questa funzione.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
/ Programma 14 - Onde 1 #include <FastLED.h> #define NUM_LEDS 17 #define LED_PIN 6 CRGB leds[NUM_LEDS]; void setup() { FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); FastLED.setBrightness(40); // up to 255 Serial.begin(57600); } void loop() { uint8_t battute_al_minuto = beatsin8(30, 0, NUM_LEDS - 1, 0, 0); leds[battute_al_minuto] = CRGB::Blue; fadeToBlackBy(leds, NUM_LEDS, 10); EVERY_N_MILLISECONDS(10) { Serial.println(battute_al_minuto); } FastLED.show(); } |
Dopo le definizioni ed il setup di base, che oramai dovremmo conoscere bene, ci troviamo all’interno del loop(). Definiamo la variabile intera a 8 bit battute_al_minuto e impostiamo un impulso ogni 2 secondi (60 / 30).
Per facilitare la comprensione del funzionamento della libreria, abbiamo aggiunto la funzione Serial.print() che stamperà il valore assunto dalla funzione durante il loop: il seguente grafico mostra una specie di sinusoide (da cui il nome beatsin() della funzione) che tocca uno per uno tutti i valori compresi tra il secondo ed il terzo parametro.
In altri termini, i valori della funzione verranno utilizzati per far accendere e spegnere in modo sequenziale i LED della nostra striscia con un bel colore blu (riga 20 nel codice).
Infine, la funzione fadeToBlackBy(leds, NUM_LEDS, 10) si occupa di “spegnere lentamente” ciascun LED acceso in precedenza. Il valore 10 indica che occorreranno circa 10 cicli per spegnere completamente ogni elemento, in modo da fornire una sorta di “effetto-scia” al movimento.
…ha fatto l’onda!
Proviamo a questo punto a rendere le cose ancor più divertenti: utilizziamo tre generatori d’onda, posti su diverse “fasi” (stiamo parlando dell’ultimo parametro della funzione beatsin8() ).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
// Programma 15 - Onde 3 #include <FastLED.h> #define NUM_LEDS 14 #define LED_PIN 6 CRGB leds[NUM_LEDS]; void setup() { FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); FastLED.setBrightness(40); // up to 255 Serial.begin(57600); } void loop() { uint8_t battute1 = beatsin8(30, 0, NUM_LEDS - 1, 0, 0); uint8_t battute2 = beatsin8(30, 0, NUM_LEDS - 1, 0, 85); uint8_t battute3 = beatsin8(30, 0, NUM_LEDS - 1, 0, 170); leds[battute1] = CRGB::Blue; leds[battute2] = CRGB::Red; leds[battute3] = CRGB::White; fadeToBlackBy(leds, NUM_LEDS, 10); EVERY_N_MILLISECONDS(10) { Serial.print(battute1); Serial.print(","); Serial.print(battute2); Serial.print(","); Serial.println(battute3); } FastLED.show(); } |
Il valore dell’ultimo parametro vale, rispettivamente, 0, 85 e 170. Ora 85 corrisponde (circa) ad un terzo di 255, mentre 170 corrisponde a due terzi di 255. Questo significa che le tre funzioni presentano valori sfasati di 120° l’una dall’altra, quindi accenderanno i LED ad una distanza pari a 0.33, 0.66 e 0.99 della lunghezza della striscia, per poi procedere avanti e indietro.
Il divertimento è dato dal fatto che stavolta ciascuna funzione pilota un LED di colore differente (nello specifico, blu, rosso e bianco) fornendo un effetto di luci simile a quello prodotto dalle auto della polizia nei telefilm americani. Allo stesso modo potremmo modificare la frequenza dell’onda attraverso il parametro timebase, ma questo lo vedremo nel prossimo tutorial.
Sfumature, che passione!
Avevamo già parlato di colori che sfumavano, attraverso la modifica della luminosità o tramite l’applicazione di una specifica tavolozza di colore. Possiamo fare di più: fare in modo che i colori di LED vicini tendano a “mescolarsi” tra loro dinamicamente.
La funzione blur1d(leds, NUM_LEDS, profondita_di_sfumatura) ci consente di lavorare esattamente su questo: il colore impostato sul LED n apparirà leggermente meno brillante sui LED n+1 ed n-1. Chiamando più volte la funzione, potremo otterene un effetto di sfumatura su più LED contigui. Pur essendo un intero a 8 bit, il parametro “profondita_di_sfumatura” andrà “solo” da 0 a 172, e tutti i valori superiori a 172 verranno automaticamente limitati. Questo accade perché la funzione è relativamente “costosa” dal punto di vista computazionale, e si è quindi scelto di limitarne la portata. Da notare inoltre che la “quantità di luce” non viene conservata, quindi blurring successivi porteranno il LED verso il colore nero.
Vediamo un esempio:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
// Programma 16 - Sfumature #include <FastLED.h> #define NUM_LEDS 14 #define LED_PIN 6 CRGB leds[NUM_LEDS]; void setup() { FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); FastLED.setBrightness(40); // up to 255 resetStrip(); } void loop() { EVERY_N_SECONDS(2) { for (int i = 0; i < 4; i++) { blur1d(leds, NUM_LEDS, 150); } } EVERY_N_SECONDS(4) { resetStrip(); } FastLED.show(); } void resetStrip() { // Inizializziamo la striscia con righe rosse, verdi e blu fill_solid(leds, NUM_LEDS, CRGB: :Red); fill_solid(leds, (NUM_LEDS / 3) * 2, CRGB::Green); fill_solid(leds, (NUM_LEDS / 3), CRGB::Blue); } |
Creiamo per prima cosa una funzione di inizializzazione, resetStrip(), che lanceremo nel setup: questo ci consentirà di creare tre “striscie” di colore solido, rispettivamente rosso, verde e blu, della stessa lunghezza, sulla striscia LED.
Nel loop imposteremo per ciascun pixel un blurring sui 4 pixel confinanti (ciclo for() ), e ripeteremo l’azione ogni due secondi. Infine, dal momento che (come abbiamo visto) la sfumatura consuma luminosità, ogni 4 secondi resettiamo i valori della striscia.
Riflessioni
E anche per questa settimana abbiamo terminato. La prossima volta approfondiremo l'”effetto-onda”; e cercheremo di riprodurre la funzione di interferenza che si crea quando due onde si attraversano. Infine, progetteremo una ulteriore variazione di sfumatura che ci consentirà di pilotare ciascun LED esattamente come lo desideriamo.
Troverete i file sorgente con gli esempi proposti su GitHub come al solito.
A risentirci tra sette giorni!
Link utili
- Arduino uno
- Arduino nano
- Raspberry PI Pico
- Elegoo starter kit
- Striscia LED WS2812 (5m 30 LED/m)
- Striscia LED WS2812 (1m 144 LED/m)
- Alimentatore 5V 1.5A
Parte dell’articolo si basa sulle lezioni online di Scott Marley.
Luigi_Morelli
Definire ciò che si è non risulta mai semplice o intuitivo, in specie quando nella vita si cerca costantemente di migliorarsi, di crescere tanto professionalmente quanto emotivamente. Lavoro per contribuire al mutamento dei settori cardine della computer science e per offrire sintesi ragionate e consulenza ad aziende e pubblicazioni ICT, ma anche perche’ ciò che riesco a portare a termine mi dà soddisfazione, piacere. Così come mi piace suonare (sax, tastiere, chitarra), cantare, scrivere (ho pubblicato 350 articoli scientfici e 3 libri sinora, ma non ho concluso ciò che ho da dire), leggere, Adoro la matematica, la logica, la filosofia, la scienza e la tecnologia, ed inseguo quel concetto di homo novus rinascimentale, cercando di completare quelle sezioni della mia vita che ancora appaiono poco ricche.