Arduino e Attuatori: LED RGB

A prima vista i LED RGB (Red, Green, Blue) sembrano dei normali led. Tuttavia all’interno del solito corpo del led ci sono 3 led differenti, uno Rosso, uno Verde e ovviamente uno Blu. Controllando la luminosità di ogni led individualmente puoi controllare e mischiare praticamente qualsiasi colore tu voglia. 

I colori si mischiano nello stesso modo in cui si mischiano i colori in una tavolozza aggiustando la luminosità in ognuno dei tre LED.

Il poter creare ogni tipo di colore mischiando e variando la quantità di Rosso, Verde e Blu è dovuto al fatto che i tuoi occhi hanno tre tipi di ricettori per la luce in essi (verde, rosso e blue). I tuoi occhi e il tuo cervello processano la quantità di rosso, verde e blu, e la convertono in uno spettro di colori. 

Se impostiamo la stessa luminosità per tutti e tre i led, il colore finale che si svilupperà sarà il bianco. Se spegniamo il led Blue, quindi tenendo acceso solo rosso e verde alla stessa luminosità, la luce apparirà gialla. 

Possiamo controllare la luminosità di ognuno dei tre colori Rosso, verde e blu separatamente, mischiandoli e creando qualsiasi colore vogliamo. 

Il nero non è considerato un colore, ma semplicemente l’assenza di luce. Infatti, l’unico modo per avvicinarci a quel colore è semplicemente spegnendo tutti e tre i colori. 

In questo modo utilizzando 3 led molto vicini, stiamo semplicemente imbrogliando gli occhi, facendogli credere che sia un colore solo invece che tre. La stessa idea è utilizzata in TV dove gli schermi LCD hanno puntini rossi, verdi e blu molto vicini uno all’altro formando un pixel. 

Collegamenti

La parte più difficile di tutto questo è utilizzare differenti valori di resistenza (o resistenze variabili). Fortunatamente la scheda Arduino ha una funzione analogWrite che puoi utilizzare sui pin marcati con il simbolo ~, la quale permette di fornire una quantità variabile di potenza per ogni singola uscita, e quindi per ogni singolo LED. 

Il LED RGB ha quattro piedini. Tre di essi sono l’ingresso positivo (o negativo) dei tre led presenti nel corpo, un capo per ogni led, il quarto è un l’ingresso negativo (o positivo) in comune per tutti e 3 i led. 

Ogni led interno al corpo necessita una resistenza da 220Ω per prevenire che troppa corrente fluisca attraverso di esso. I tre capi dei LED (uno rosso, uno verde, ed uno blu) vanno connessi ai pin di output della scheda Arduino utilizzando le resistenze da 220Ω.

In questo esempio usiamo un Arduino Mega e ci colleghiamo ai pin D3, D5 e D6.  

Teoria PWM

Pulse Width Modulation (PWM) è una tecnica per controllare la potenza. Si usa anche qui per controllare la luminosità di ogni singolo LED. 

Il diagramma qui sotto mostra il segnale da uno dei pin PWM della scheda Arduino. 

Approssimativamente ogni 1/500 di secondo l’uscita PWM produce una pulsazione. La lunghezza di tale pulsazione è controllata dalla funzione analogWrite. Perciò analogWrite(0) non produrrà alcuna pulsazione, mentre analogWrite(255) produrrà una pulsazione che durerà fino all’inizio della prossima pulsazione, perciò l’uscita sarà allo stato di ON per tutto il periodo. 

Se specifichiamo un valore nella funziona analogWrite che è compresa tra 0 e 255, verrà prodotto a una pulsazione. Se l’uscita è alta, per esempio, solo per il 5% del tempo, qualsiasi cosa ci sarà connessa a tale uscita riceverà il 5% della potenza disponibile.

Se l’output è a 5V per il 90% del tempo, il carico riceverà il 90% della potenza emessa. Non possiamo vedere il LED accendersi e spegnersi a tale velocità, perciò, al nostro occhio sembrerà semplicemente un cambio di luminosità. 

Sketch

Il codice inizia specificando quali pin verranno usati per quali colori:

// Definire Pin
#define BLUE 3
#define GREEN 5
#define RED 6

Il prossimo passo è quello di scrivere la funzione di setup. La funzione di setup viene eseguita una sola volta dopo che viene resettata la scheda di Arduino. In questo caso, tutto quello che fa la funzione è definire che i tre pin che andremo ad utilizzare saranno degli output.

void setup()
{
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
digitalWrite(RED, HIGH);
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
}

Prima di guardare la funzione di “loop”, andiamo a vedere l’ultima funzione nel codice. La definizione delle variabili. 

redValue = 255; // choose a value between 1 and 255 to change the color.
greenValue = 0; 
blueValue = 0; 

Questa funzione ha tre argomenti, uno per la luminosità del rosso, uno per il verde e uno per il led blu. In ogni caso i tre numeri dovranno avere un range compreso tra 0 e 255, dove 0 significa spento e 255 significa massima luminosità. La funzione si occuperà di chiamare “analogWrite” per impostare la luminosità di ogni led. 

Se guardi la funzione “loop” puoi vedere che viene settata la quantità di rosso verde e blu che vogliamo visualizzare, dopodiché viene fatta una pausa di un secondo prima di iniziare con il prossimo colore. 

#define delayTime 10 // fading time between colors
delay(delayTime); 

Prova tu stesso ad aggiungere diversi colori al tuo codice e caricalo sulla scheda Arduino per vedere l’effetto del LED. 

//www.ilsito.net

// Define Pins
#define BLUE 3
#define GREEN 5
#define RED 6

void setup()
{
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
digitalWrite(RED, HIGH);
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
}

// define variables
int redValue;
int greenValue;
int blueValue;

// main loop
void loop()
{
#define delayTime 10 // fading time between colors

redValue = 255; // choose a value between 1 and 255 to change the color.
greenValue = 0;
blueValue = 0;

// this is unnecessary as we've either turned on RED in SETUP
// or in the previous loop ... regardless, this turns RED off
// analogWrite(RED, 0);
// delay(1000);

for(int i = 0; i < 255; i += 1) // fades out red bring green full when i=255
{
redValue -= 1;
greenValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(RED, 255 - redValue);
// analogWrite(GREEN, 255 - greenValue);
analogWrite(RED, redValue);
analogWrite(GREEN, greenValue);
delay(delayTime);
}

redValue = 0;
greenValue = 255;
blueValue = 0;

for(int i = 0; i < 255; i += 1) // fades out green bring blue full when i=255
{
greenValue -= 1;
blueValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(GREEN, 255 - greenValue);
// analogWrite(BLUE, 255 - blueValue);
analogWrite(GREEN, greenValue);
analogWrite(BLUE, blueValue);
delay(delayTime);
}

redValue = 0;
greenValue = 0;
blueValue = 255;

for(int i = 0; i < 255; i += 1) // fades out blue bring red full when i=255
{
// The following code has been rearranged to match the other two similar sections
blueValue -= 1;
redValue += 1;
// The following was reversed, counting in the wrong directions
// analogWrite(BLUE, 255 - blueValue);
// analogWrite(RED, 255 - redValue);
analogWrite(BLUE, blueValue);
analogWrite(RED, redValue);
delay(delayTime);
}
}

Download