Arduino – lezione 09: uso di LED RGB

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)

arduino-led-rgb-01

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)

arduino-led-rgb-02

Negli esempi che seguiranno sono stati utilizzati dei diodi ad anodo comune.

arduino-led-rgb-ac-03

In serie ad ogni LED sarà inserita una resistenze che consentirà di regolare la corrente circolante nel diodo.

arduino-led-rgb-04

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.

arduino-led-rgb-05

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à:

arduino-led-rgb-06

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:

arduino-led-rgb-07

1/* Prof. Michele Maffucci
2   27.09.2014
3  
4   Uso di un led RGB
5   Spegnimento graduale del LED Verde
6  
7   Questo codice è di dominio pubblico 
8*/
9 
10// pin a cui collegare i piedini del LED RGB
11const int VERDE = 9;
12const int BLU = 10;
13const int ROSSO = 11;
14 
15// tempo di transizione colore
16const int delayTime = 20;
17 
18void setup() {
19 
20  // imposta il pin digitale come output
21  pinMode(VERDE, OUTPUT);
22  pinMode(BLU, OUTPUT);
23  pinMode(ROSSO, OUTPUT);
24 
25 
26  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
27  // inizialmente il led RGB sarà spento
28  digitalWrite(VERDE, HIGH);
29  digitalWrite(BLU, HIGH);
30  digitalWrite(ROSSO, HIGH);
31}
32 
33// definizione di variabili globali
34int ValVerde;
35 
36void loop() {
37  // spegnimento graduale del verde
38 
39  // coordinate RGB del rosso: 0, 255, 0
40 
41  ValVerde = 255;
42 
43  for( int i = 0 ; i < 255 ; i += 1 ){
44 
45    ValVerde -= 1;
46 
47    /* ad ogni ciclio la differenza
48     255 - ValVerde AUMENTA
49     provocando un graduale spegnimento del verde
50     */
51 
52    analogWrite( VERDE, 255 - ValVerde );
53 
54    // attesa di 20 ms per percepire il colore
55    delay( delayTime );
56  }
57}

I pin utilizzati per collegare il led RGB sono:

1...
2// pin a cui collegare i piedini del LED RGB
3const int VERDE = 9;
4const int BLU = 10;
5const int ROSSO = 11;
6...

Nel setup vengono impostati i pin ad HIGH ciò implica che il led RGB in fase iniziale viene spento:

1...
2  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
3  // inizialmente il led RGB sarà spento
4  digitalWrite(VERDE, HIGH);
5  digitalWrite(BLU, HIGH);
6  digitalWrite(ROSSO, HIGH);
7...

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:

arduino-led-rgb-04

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)

1ValVerde = 255;
2 
3 for( int i = 0 ; i < 255 ; i += 1 ){
4 
5   ValVerde -= 1;
6 
7   /* ad ogni ciclio la differenza
8    255 - ValVerde AUMENTA
9    provocando un graduale spegnimento del verde
10    */
11 
12   analogWrite( VERDE, 255 - ValVerde );
13 
14   // attesa di 20 ms per percepire il colore
15   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:

1/* Prof. Michele Maffucci
2   27.09.2014
3  
4   Uso di un led RGB
5   Spegnimento graduale del LED Rosso
6  
7   Questo codice è di dominio pubblico 
8*/
9 
10// pin a cui collegare i piedini del LED RGB
11const int VERDE = 9;
12const int BLU = 10;
13const int ROSSO = 11;
14 
15// tempo di transizione colore
16const int delayTime = 20;
17 
18void setup() {
19 
20  // imposta il pin digitale come output
21  pinMode(VERDE, OUTPUT);
22  pinMode(BLU, OUTPUT);
23  pinMode(ROSSO, OUTPUT);
24 
25 
26  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
27  // inizialmente il led RGB sarà spento
28  digitalWrite(VERDE, HIGH);
29  digitalWrite(BLU, HIGH);
30  digitalWrite(ROSSO, HIGH);
31}
32 
33// definizione di variabili globali
34int ValRosso;
35 
36void loop() {
37  // spegnimento graduale del rosso
38 
39  // coordinate RGB del rosso: 255, 0, 0
40 
41  ValRosso = 255;
42 
43  for( int i = 0 ; i < 255 ; i += 1 ){
44 
45    ValRosso -= 1;
46 
47    /* ad ogni ciclio la differenza
48     255 - ValVerde AUMENTA
49     provocando un graduale spegnimento del rosso
50     */
51 
52    analogWrite( ROSSO, 255 - ValRosso );
53 
54    // attesa di 20 ms per percepire il colore
55    delay( delayTime );
56  }
57}

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:

1/* Prof. Michele Maffucci
2   16.03.2014
3  
4   Uso di un led RGB
5   Spegnimento graduale del LED Blu
6  
7   Questo codice è di dominio pubblico 
8*/
9 
10// pin a cui collegare i piedini del LED RGB
11const int VERDE = 9;
12const int BLU = 10;
13const int ROSSO = 11;
14 
15// tempo di transizione colore
16const int delayTime = 20;
17 
18void setup() {
19 
20  // imposta il pin digitale come output
21  pinMode(VERDE, OUTPUT);
22  pinMode(BLU, OUTPUT);
23  pinMode(ROSSO, OUTPUT);
24 
25 
26  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
27  // inizialmente il led RGB sarà spento
28  digitalWrite(VERDE, HIGH);
29  digitalWrite(BLU, HIGH);
30  digitalWrite(ROSSO, HIGH);
31}
32 
33// definizione di variabili globali
34int ValBlu;
35 
36void loop() {
37  // spegnimento graduale del blu
38 
39  // coordinate RGB del rosso: 255, 0, 0
40 
41  ValBlu = 255;
42 
43  for( int i = 0 ; i < 255 ; i += 1 ){
44 
45    ValBlu -= 1;
46 
47    /* ad ogni ciclio la differenza
48     255 - ValVerde AUMENTA
49     provocando un graduale spegnimento del rosso
50     */
51 
52    analogWrite( BLU, 255 - ValBlu );
53 
54    // attesa di 20 ms per percepire il colore
55    delay( delayTime );
56  }
57}

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:

1/* Prof. Michele Maffucci
2   27.09.2014
3  
4   Uso di un led RGB
5   Spegnimento graduale in sequenza
6   dei LED: verde, rosso, blu
7  
8   Questo codice è di dominio pubblico 
9*/
10 
11// pin a cui collegare i piedini del LED RGB
12const int VERDE = 9;
13const int BLU = 10;
14const int ROSSO = 11;
15 
16// tempo di transizione colore
17const int delayTime = 20;
18 
19void setup() {
20 
21  // imposta il pin digitale come output
22  pinMode(VERDE, OUTPUT);
23  pinMode(BLU, OUTPUT);
24  pinMode(ROSSO, OUTPUT);
25 
26 
27  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
28  // inizialmente il led RGB sarà spento
29  digitalWrite(VERDE, HIGH);
30  digitalWrite(BLU, HIGH);
31  digitalWrite(ROSSO, HIGH);
32}
33 
34// definizione di variabili globali
35int ValVerde;
36int ValRosso;
37int ValBlu;
38 
39void loop() {
40  // spegnimento graduale del verde
41 
42  // coordinate RGB del rosso: 0, 255, 0
43 
44  ValVerde = 255;
45 
46  for( int i = 0 ; i < 255 ; i += 1 ){
47 
48    ValVerde -= 1;
49 
50    /* ad ogni ciclio la differenza
51     255 - ValVerde AUMENTA
52     provocando un graduale spegnimento del verde
53     */
54 
55    analogWrite( VERDE, 255 - ValVerde );
56 
57    // attesa di 20 ms per percepire il colore
58    delay( delayTime );
59  }
60   
61  // spegnimento graduale del rosso
62 
63  // coordinate RGB del rosso: 255, 0, 0
64 
65  ValRosso = 255;
66 
67  for( int i = 0 ; i < 255 ; i += 1 ){
68 
69    ValRosso -= 1;
70 
71    /* ad ogni ciclio la differenza
72     255 - ValVerde AUMENTA
73     provocando un graduale spegnimento del rosso
74     */
75 
76    analogWrite( ROSSO, 255 - ValRosso );
77 
78    // attesa di 20 ms per percepire il colore
79    delay( delayTime );
80  }
81  // spegnimento graduale del blu
82 
83  // coordinate RGB del rosso: 255, 0, 0
84 
85  ValBlu = 255;
86 
87  for( int i = 0 ; i < 255 ; i += 1 ){
88 
89    ValBlu -= 1;
90 
91    /* ad ogni ciclio la differenza
92     255 - ValVerde AUMENTA
93     provocando un graduale spegnimento del rosso
94     */
95 
96    analogWrite( BLU, 255 - ValBlu );
97 
98    // attesa di 20 ms per percepire il colore
99    delay( delayTime );
100  } 
101}

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

1/* Prof. Michele Maffucci
2   27.09.2014
3  
4   Variazione colore continuo di un
5   LED RGB ad anodo comune
6    
7   passaggi:
8   verde-rosso
9   blu-verde
10   rosso-blu
11    
12   Questo codice è di dominio pubblico 
13*/
14 
15// pin a cui collegare i piedini del LED RGB
16const int VERDE = 9;
17const int BLU = 10;
18const int ROSSO = 11;
19 
20// tempo di transizione colore
21const int delayTime = 20;
22 
23void setup() {
24 
25  // imposta il pin digitale come output
26  pinMode(VERDE, OUTPUT);
27  pinMode(BLU, OUTPUT);
28  pinMode(ROSSO, OUTPUT);
29 
30  // si impostano ad HIGH i pin VERDE, BLU, ROSSO
31  // inizialmente il led RGB sarà spento
32  digitalWrite(VERDE, HIGH);
33  digitalWrite(BLU, HIGH);
34  digitalWrite(ROSSO, HIGH);
35 
36}
37 
38// definizione di variabili globali
39int ValRosso;
40int ValBlu;
41int ValVerde;
42 
43 
44void loop() {
45 
46  // variazione da verde a rosso
47 
48  int ValRosso = 255;
49  int ValBlu = 0;
50  int ValVerde = 0;
51 
52  for( int i = 0 ; i < 255 ; i += 1 ){
53 
54    ValVerde += 1;
55    ValRosso -= 1;
56 
57    /* ad ogni ciclio la differenza
58     255 - ValVerde DIMINUISCE
59     255 - ValRosso AUMENTA
60     provocando un graduale passaggio
61     dal verde al rosso
62     */
63 
64    analogWrite( VERDE, 255 - ValVerde );
65    analogWrite( ROSSO, 255 - ValRosso );
66 
67 
68    // attesa di 20 ms per percepire il colore
69    delay( delayTime );
70  }
71 
72  // variazione da blu al verde
73 
74  ValRosso = 0;
75  ValBlu = 0;
76  ValVerde = 255;
77 
78  ValRosso = 0;
79  ValBlu = 0;
80  ValVerde = 255;
81 
82  for( int i = 0 ; i < 255 ; i += 1 ){
83 
84    ValBlu += 1;
85    ValVerde -= 1;
86 
87    /* ad ogni ciclio la differenza
88     255 - ValBlu DIMINUISCE
89     255 - ValVerde AUMENTA
90     provocando un graduale passaggio
91     dal blu al verde
92     */
93 
94    analogWrite( BLU, 255 - ValBlu );
95    analogWrite( VERDE, 255 - ValVerde );
96 
97    // attesa di 20 ms per percepire il colore
98    delay( delayTime );
99  }
100 
101  // variazione da rosso al blu
102 
103  ValRosso = 0;
104  ValBlu = 255;
105  ValVerde = 0;
106 
107  for( int i = 0 ; i < 255 ; i += 1 ){
108 
109    ValRosso += 1;
110    ValBlu -= 1;
111 
112    /* ad ogni ciclio la differenza
113     255 - ValRosso DIMINUISCE
114     255 - ValBlu AUMENTA
115     provocando un graduale passaggio
116     dal rosso al blu
117     */
118 
119    analogWrite( ROSSO, 255 - ValRosso );
120    analogWrite( BLU, 255 - ValBlu );
121 
122    // attesa di 20 ms per percepire il colore
123    delay( delayTime );
124  }
125}

4 pensieri su “Arduino – lezione 09: uso di LED RGB”

angelo salvatelli Ottobre 6, 2014 alle 4:29 pm

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

Rispondi ↓
Marco Ottobre 11, 2014 alle 11:26 pm

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.

Rispondi ↓
miki Marzo 16, 2016 alle 10:05 am

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

Rispondi ↓
Roberto Settembre 4, 2017 alle 5:14 pm

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.

Rispondi ↓