Arduino – lezione 09: uso di LED RGB – parte 1

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

/* 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:

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)

 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:

  1. da verde a rosso
  2. da blu a verde
  3. 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 );
  }
}

Nelle prossime lezioni vedremo come pilotare la variazione di colore del LED RGB con potenziometri e pulsanti.

Articoli simili:

Questa voce è stata pubblicata in arduino, i miei allievi e contrassegnata con , , . Contrassegna il permalink.

3 risposte a Arduino – lezione 09: uso di LED RGB – parte 1

  1. angelo salvatelli scrive:

    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

  2. Marco scrive:

    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.

  3. miki scrive:

    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

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *