Mi viene continuamente richiesto da molti lettori di questo blog di inserire le lezioni che svolgo a scuola con i miei studenti quindi dopo questa tirata d’orecchie che mi viene fatta 🙂 spessissimo riprendo questa attività.
Per dare ordine al percorso di apprendimento, riprendo i contenuti sviluppati nelle mie slide di dominio pubblico e quanto già scritto in una mia precedente attività pratica svolta con gli studenti: Arduino: effetti luminosi per rendere attraente la lezione
Agendo in questo modo i miei colleghi, che desiderano implementare una didattica in cui viene utilizzo Arduino, si troveranno una sequenza ordinata di lezioni dove gli argomenti e gli esercizi sono scelti per sviluppare ed approfondire aspetti particolari della programmazione, quindi perdonate le ripetizioni (fisime da Prof. bacchettone), ma l’ordine è fondamentale se si desidera spiegare e quindi faccio ordine 🙂
Parliamo dei LED RGB, uno dei componenti che suscita negli studenti sempre molto interesse, soprattutto perché si presta a molteplici attività creative i LED RGB.
Quanto scritto è ripreso dalle mie slide che sono di dominio pubblico a queste aggiungerò ulteriori esercizi.
I led RGB sono led capaci di produrre 3 differenti lunghezze d’onda:
- Rosso (R, red)
- Verde (G, green)
- Blu (B, blue)
Posseggono 4 terminali e si possono presentare in due tipi di configurazione:
- 1 anodo e 3 catodi (RGB ad anodo comune)
- 3 anodi e 1 catodo (RGB a catodo comune)
La mescolanza dei tre colori dà luogo ad una luce di un determinato colore che dipende dall’intensità di ciascuno dei tre colori originari (si veda la composizione RGB)
Negli esempi che seguiranno sono stati utilizzati dei diodi ad anodo comune.
In serie ad ogni LED sarà inserita una resistenze che consentirà di regolare la corrente circolante nel diodo.
Dai datasheet si può notare come la caduta di tensione Vf, a parità di corrente nominale If sia diversa per ogni LED e la variabilità di Vf è piuttosto ampia, per questo motivo per effettuare i calcoli delle resistenze da porre in serie ai rispettivi LED bisognerà considerare un valore medio di Vf.
La tensione di funzionamento dei diodi da considerare può essere letta in colonna TYP questi valori fanno riferimento ad una corrente diretta di 20 mA, usando questi valori di tensione siamo ora in grado di calcolare il valore della resistenza da porre in serie ai singoli diodi led.
Sapendo che la tensione di alimentazione sarà di 5V (tensione in uscita sul piedino digitale della scheda Arduino) e che su ogni singolo diodo led è da considerare una tensione tipica come da colonna TYP, sia avrà:
Si sceglieranno dei valori commerciali di resistenza prossime a quelle calcolate. Poiché nella dotazione disponibile nello Starter Kit di Arduino si hanno resistenze minime da 220 Ohm sceglieremo queste per gli esempi che seguiranno, non vi preoccupate, se scegliete valori leggermente inferiori (180 Ohm) o leggermente superiori (270 Ohm), il tutto funzionerà ugualmente.
Esercizio 1
Come primo esercizio realizziamo lo sketch in cui il led RGB emette una luce verde che si accende e spegne gradualmente, i restanti colori non verranno visualizzati.
Per implementare questa funzionalità utilizziamo 1 led RGB e tre resistori da 220 Ohm:
/* Prof. Michele Maffucci
27.09.2014
Uso di un led RGB
Spegnimento graduale del LED Verde
Questo codice è di dominio pubblico
*/
// pin a cui collegare i piedini del LED RGB
const int VERDE = 9;
const int BLU = 10;
const int ROSSO = 11;
// tempo di transizione colore
const int delayTime = 20;
void setup() {
// imposta il pin digitale come output
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
pinMode(ROSSO, OUTPUT);
// si impostano ad HIGH i pin VERDE, BLU, ROSSO
// inizialmente il led RGB sarà spento
digitalWrite(VERDE, HIGH);
digitalWrite(BLU, HIGH);
digitalWrite(ROSSO, HIGH);
}
// definizione di variabili globali
int ValVerde;
void loop() {
// spegnimento graduale del verde
// coordinate RGB del rosso: 0, 255, 0
ValVerde = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValVerde -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del verde
*/
analogWrite( VERDE, 255 - ValVerde );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
}
I pin utilizzati per collegare il led RGB sono:
... // pin a cui collegare i piedini del LED RGB const int VERDE = 9; const int BLU = 10; const int ROSSO = 11; ...
Nel setup vengono impostati i pin ad HIGH ciò implica che il led RGB in fase iniziale viene spento:
... // si impostano ad HIGH i pin VERDE, BLU, ROSSO // inizialmente il led RGB sarà spento digitalWrite(VERDE, HIGH); digitalWrite(BLU, HIGH); digitalWrite(ROSSO, HIGH); ...
Infatti accade che se i catodi, connessi ai pin 9, 10, 11, si trovano ad HIGH, poiché l’anodo si trova a +Vcc si avrà che i tre LED non vanno in conduzione, quindi non emetteranno luce:
All’interno del loop il ciclo for esegue 255 iterazioni e ad ogni ciclo l’indice i viene incrementato di 1. Ad ogni iterazione ValVerde viene decrementato di 1. Il led VERDE sarà al primo ciclo del for spento:
analogWrite(VERDE, 0)
nell’ultimo ciclo del for il led VERDE sarà acceso:
analogWrite(VERDE, 255)
ValVerde = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValVerde -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del verde
*/
analogWrite( VERDE, 255 - ValVerde );
// attesa di 20 ms per percepire il colore
delay( delayTime );
Poichè lo scopo è quello di far emettere in modo graduale tutti i colori possibili, vi invito, anche se si tratta di un semplice copia ed incolla gli esercizi 2 e 3.
Esercizio 2
Usando il medesimo circuito realizzato nell’esercizio 1 realizzare uno sketch in cui led rosso si accende e si spegne gradualmente. Potete quindi realizzare questo sketch in maniera simile al precedente:
/* Prof. Michele Maffucci
27.09.2014
Uso di un led RGB
Spegnimento graduale del LED Rosso
Questo codice è di dominio pubblico
*/
// pin a cui collegare i piedini del LED RGB
const int VERDE = 9;
const int BLU = 10;
const int ROSSO = 11;
// tempo di transizione colore
const int delayTime = 20;
void setup() {
// imposta il pin digitale come output
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
pinMode(ROSSO, OUTPUT);
// si impostano ad HIGH i pin VERDE, BLU, ROSSO
// inizialmente il led RGB sarà spento
digitalWrite(VERDE, HIGH);
digitalWrite(BLU, HIGH);
digitalWrite(ROSSO, HIGH);
}
// definizione di variabili globali
int ValRosso;
void loop() {
// spegnimento graduale del rosso
// coordinate RGB del rosso: 255, 0, 0
ValRosso = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValRosso -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del rosso
*/
analogWrite( ROSSO, 255 - ValRosso );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
}
Esercizio 3
Usando il medesimo circuito realizzato nell’esercizio 1 realizzare uno sketch in cui led blu si accende e si spegne gradualmente. Potete quindi realizzare questo sketch in maniera simile al precedente:
/* Prof. Michele Maffucci
16.03.2014
Uso di un led RGB
Spegnimento graduale del LED Blu
Questo codice è di dominio pubblico
*/
// pin a cui collegare i piedini del LED RGB
const int VERDE = 9;
const int BLU = 10;
const int ROSSO = 11;
// tempo di transizione colore
const int delayTime = 20;
void setup() {
// imposta il pin digitale come output
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
pinMode(ROSSO, OUTPUT);
// si impostano ad HIGH i pin VERDE, BLU, ROSSO
// inizialmente il led RGB sarà spento
digitalWrite(VERDE, HIGH);
digitalWrite(BLU, HIGH);
digitalWrite(ROSSO, HIGH);
}
// definizione di variabili globali
int ValBlu;
void loop() {
// spegnimento graduale del blu
// coordinate RGB del rosso: 255, 0, 0
ValBlu = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValBlu -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del rosso
*/
analogWrite( BLU, 255 - ValBlu );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
}
Esercizio 4
Usando il medesimo circuito realizzato nell’esercizio 1 realizzare uno sketch in cui si realizzi una sequenza di accensione e spegnimento dei verde del rosso e del blu:
/* Prof. Michele Maffucci
27.09.2014
Uso di un led RGB
Spegnimento graduale in sequenza
dei LED: verde, rosso, blu
Questo codice è di dominio pubblico
*/
// pin a cui collegare i piedini del LED RGB
const int VERDE = 9;
const int BLU = 10;
const int ROSSO = 11;
// tempo di transizione colore
const int delayTime = 20;
void setup() {
// imposta il pin digitale come output
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
pinMode(ROSSO, OUTPUT);
// si impostano ad HIGH i pin VERDE, BLU, ROSSO
// inizialmente il led RGB sarà spento
digitalWrite(VERDE, HIGH);
digitalWrite(BLU, HIGH);
digitalWrite(ROSSO, HIGH);
}
// definizione di variabili globali
int ValVerde;
int ValRosso;
int ValBlu;
void loop() {
// spegnimento graduale del verde
// coordinate RGB del rosso: 0, 255, 0
ValVerde = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValVerde -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del verde
*/
analogWrite( VERDE, 255 - ValVerde );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
// spegnimento graduale del rosso
// coordinate RGB del rosso: 255, 0, 0
ValRosso = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValRosso -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del rosso
*/
analogWrite( ROSSO, 255 - ValRosso );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
// spegnimento graduale del blu
// coordinate RGB del rosso: 255, 0, 0
ValBlu = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValBlu -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde AUMENTA
provocando un graduale spegnimento del rosso
*/
analogWrite( BLU, 255 - ValBlu );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
}
Esercizio 5
Usando il medesimo circuito realizzato nell’esercizio 1 realizzare uno sketch in cui vi sia una variazione continua e graduale:
- da verde a rosso
- da blu a verde
- da rosso a blu
Ricordare che:
- le coordinate RGB del rosso sono: 255,0,0
- le coordinate RGB del verde sono: 0,255,0
- le coordinate RGB del blu sono: 0,0,255
/* Prof. Michele Maffucci
27.09.2014
Variazione colore continuo di un
LED RGB ad anodo comune
passaggi:
verde-rosso
blu-verde
rosso-blu
Questo codice è di dominio pubblico
*/
// pin a cui collegare i piedini del LED RGB
const int VERDE = 9;
const int BLU = 10;
const int ROSSO = 11;
// tempo di transizione colore
const int delayTime = 20;
void setup() {
// imposta il pin digitale come output
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
pinMode(ROSSO, OUTPUT);
// si impostano ad HIGH i pin VERDE, BLU, ROSSO
// inizialmente il led RGB sarà spento
digitalWrite(VERDE, HIGH);
digitalWrite(BLU, HIGH);
digitalWrite(ROSSO, HIGH);
}
// definizione di variabili globali
int ValRosso;
int ValBlu;
int ValVerde;
void loop() {
// variazione da verde a rosso
int ValRosso = 255;
int ValBlu = 0;
int ValVerde = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
ValVerde += 1;
ValRosso -= 1;
/* ad ogni ciclio la differenza
255 - ValVerde DIMINUISCE
255 - ValRosso AUMENTA
provocando un graduale passaggio
dal verde al rosso
*/
analogWrite( VERDE, 255 - ValVerde );
analogWrite( ROSSO, 255 - ValRosso );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
// variazione da blu al verde
ValRosso = 0;
ValBlu = 0;
ValVerde = 255;
ValRosso = 0;
ValBlu = 0;
ValVerde = 255;
for( int i = 0 ; i < 255 ; i += 1 ){
ValBlu += 1;
ValVerde -= 1;
/* ad ogni ciclio la differenza
255 - ValBlu DIMINUISCE
255 - ValVerde AUMENTA
provocando un graduale passaggio
dal blu al verde
*/
analogWrite( BLU, 255 - ValBlu );
analogWrite( VERDE, 255 - ValVerde );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
// variazione da rosso al blu
ValRosso = 0;
ValBlu = 255;
ValVerde = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
ValRosso += 1;
ValBlu -= 1;
/* ad ogni ciclio la differenza
255 - ValRosso DIMINUISCE
255 - ValBlu AUMENTA
provocando un graduale passaggio
dal rosso al blu
*/
analogWrite( ROSSO, 255 - ValRosso );
analogWrite( BLU, 255 - ValBlu );
// attesa di 20 ms per percepire il colore
delay( delayTime );
}
}
Salve , sarei curioso di capire come interrompere un ciclo nop (delay) , in breve vorrei attivare un led x 10 secondi e nel frattempo poter attivare altri led tramite altri tasti , non ci riesco se non dopo l’attesa del primo delay. grazie
Complimenti al professore ! Queste lezioni sono veramente stupende ; io frequento l’universita e per quanto riguarda la programmazione me la cavo, oserei dire, molto bene, ma per la parte elettronica bè, ho un pò di lacune 😀 Queste lezioni sono chiare, interessanti e spiegate in ogni parte…qualsiasi dubbio io abbia la risposta è contenuta nella lezione. Comunque Angelo Salvatelli, penso che per fare quello che chiedi tu serva una programmazione multithread, perchè il delay non è altro che un modo per dire al thread “fermati per N millesimi di secondo” ; e quindi avresti bisogno di un’altro thread per gestire altri eventi mentre il thread è in delay.
grazie professore per la fittissima serie di esempi,chiari e facilmente eseguibili
sono un pensionato ex elettronico hardware,mai avuto lezioni di software ed
alla mia età non mi ci metto,però mi passa il tempo a copiare i circuiti col nipotino di 8 anni molto attratto da quello che facciamo
grazie
Buongiorno, ho in mente un progetto e ne chiedo fattibilità. Nelle automobili di ultima generazione è possibile cambiare il colore dell’illuminazione interna passando dai colori come viola, rosso, bianco ecc. La mia idea sarebbe di poter comandare un led smd rgb (sostituendolo all’attuale smd bianco) sfruttando la diversa tensione che posso avere nelle luci abitacolo impostando dal menu’ car la luminosità da più chiaro a più scuro.
Potrei così andare a sostituire le luci a led sotto ai piedi anteriori e posteriori, nonchè sotto ai braccioli delle 4 porte e poter regolare trammite un comando implementato del menu dell’auto la colorazione di tali punti luce.
Grazie per il tempo che mi dedicherete.
Roberto.