I led RGB sono capaci di riprodurre tre differenti lunghezze d’onda (tre colori), il Rosso (R), il Verde (G) e il Blu (B). Sono composti da 4 piedini e possono essere configurati in due tipologie, ad anodo comune oppure a catodo comune, questo significa che possiamo avere 1 anodo e 3 catodi (RGB ad anodo comune) 3 anodi e 1 catodo (RGB a catodo comune)
Diodo Led RGB
In questo esempio utilizzeremo led RGB a catodo comun, questo significa che sul piedino numero 2 avremmo GND (0 V) mentre sui restanti piedini la tensione di alimentazione del led, questo significa che se sul piedino 1 applico una tensione di alimentazione il diodo emettere un colere di luce Rosso, se invece alimento il piedino 3 otterremo il colore Verde, diversamente se alimento il piedino 4 ottengo il colore blu, alimentando invece due piedini contemporaneamente otterrò colori diversi in base alle regole di mescolazione dei colori RGB.

Considerando che la tensione di alimentazione che andremo ad utilizzare per il progetto e quella in uscita sui piedini digitali della scheda Arduino (ovvero 5V) e che i diodi led RGB lavorano con tensioni di funzionamento dai 2 ai 3.5 V, 20mA di corrente, dovremo quindi inserire una resistenza in serie al catodo del diodo, io utilizzo per questo progetto una resistenza di 220 ohm leggermente superiore al necessario, il valore preciso della resistenza da utilizzare e calcolabile come: 5V (tensione di alimentazione) – 3.5V (tensione del diodo) tutto diviso 0.02A (corrente del diodo) = 75 ohm.
A questo punto possiamo procedere a collegare il nostro diodo RGB alla scheda Arduino per iniziare a “giocare” con i colori, colleghiamo i vari componenti seguendo questo schema:
Primo esempio
In questo primo esempio, molto semplice, non facciamo altro che far accedere il led RGB con un colore casuale, che vene ricavato, generando 3 numero casuali (grazie alla funzione random) per il canale Rosso, Verde e Blue. In questo sketch è presente una funzione colora(int R, int G, int B) che accetta tre interi, rispettivamente i valori per il rosso, il verde e il blu, e setta questi valori sui piedini di uscita di Arduino, mentre la funzione pulisci() molto semplicemente riporta a 0 tutti e tre i piedini del led.
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
| //definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegati i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
//la funzione random genera un numero casuale tra 0 e 255
colora(random(255),random(255),random(255)); //colore casuale
delay(delayTime);
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
} |
//definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegati i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
//la funzione random genera un numero casuale tra 0 e 255
colora(random(255),random(255),random(255)); //colore casuale
delay(delayTime);
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
}
Secondo esempio
In questo esempio variante del primo, non facciamo altro che far accedere il led RGB con i tre colori base, in progressione, prima accendiamo il colore rosso, poi il verde e per finire il blue, con un secondo di attesa tra un colore e l’altro.
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
38
39
40
41
42
| //definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegadi i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
colora(255,0,0); //ROSSO
delay(delayTime);
pulisci();
colora(0,255,0); //VERDE
delay(delayTime);
pulisci();
colora(0,0,255); //BLU
delay(delayTime);
pulisci();
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
} |
//definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegadi i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
colora(255,0,0); //ROSSO
delay(delayTime);
pulisci();
colora(0,255,0); //VERDE
delay(delayTime);
pulisci();
colora(0,0,255); //BLU
delay(delayTime);
pulisci();
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
}
Terzo esempio
In questo esempio invece, pilotiamo il led RGB facendolo transitare gradualmente dal colore rosso al verde al blue per poi tornare nuovamente al rosso, nella transizione da un colore all’altro si vedranno i colori intermedi, questo lo sketch:
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| //definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegadi i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
//transizione da ROSSO a VERDE
int coloreRosso = 255;
int coloreVerde = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
colora(coloreRosso, coloreVerde, 0);
coloreRosso -= 1;
coloreVerde += 1;
delay(20);
}
//transizione da VERDE a BLUE
int coloreBlue = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
colora(0, coloreVerde, coloreBlue);
coloreVerde -= 1;
coloreBlue += 1;
delay(20);
}
//transizione da BLUE a ROSSO
for( int i = 0 ; i < 255 ; i += 1 ){
colora(coloreRosso, 0, coloreBlue);
coloreBlue -= 1;
coloreRosso += 1;
delay(20);
}
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
} |
//definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
//impostazione i pin a cui sono collegadi i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
}
void loop() {
//transizione da ROSSO a VERDE
int coloreRosso = 255;
int coloreVerde = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
colora(coloreRosso, coloreVerde, 0);
coloreRosso -= 1;
coloreVerde += 1;
delay(20);
}
//transizione da VERDE a BLUE
int coloreBlue = 0;
for( int i = 0 ; i < 255 ; i += 1 ){
colora(0, coloreVerde, coloreBlue);
coloreVerde -= 1;
coloreBlue += 1;
delay(20);
}
//transizione da BLUE a ROSSO
for( int i = 0 ; i < 255 ; i += 1 ){
colora(coloreRosso, 0, coloreBlue);
coloreBlue -= 1;
coloreRosso += 1;
delay(20);
}
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
}
Quarto esempio
In questo ultimo esempio, vedremo come pilotare la colorazione del led RGB tramite l’utilizzo di un potenziometro. Nello schema seguente viene aggiunto al precedente schema del primo esempio un potenziometro sul piedino A0 degli ingressi analogici di Arduino, questo verrà utilizzato per variare il colore del led RGB, nello specifico il minimo valore di resistenza del potenziometro corrisponderà alla colorazione rossa del led, mentre al valore più alto del potenziometro corrisponderà il colore verde.
Per evitare di dover calcolare il valore di ogni potenziometro e quindi modificare il codice dello sketch ogni volta che si cambia il potenziometro, e in definitiva per non vincolare il progetto all’utilizzo di uno specifico potenziometro, ho sviluppato il codice in modo tale che si auto setta sui valori massimi e minimi ottenuti ruotando il potenziometro, in questo modo ad ogni ciclo viene letto il valore sul pid analogico a cui è collegato il potenziometro e confrontato con i precedenti valori massimi e minimi, che verranno aggiornati se il nuovo valore sarà più alto o più basso di quelli precedentemente memorizzati, in questo modo non dovremo settare manualmente il valore nel codice, ma di conseguenza sarà necessario far fare un giro completo al potenziometro al primo utilizzo.
Questo il codice dello sketch:
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
| //definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
//definisco il pin del potenziometro
const int POTENZIOMETRO = 0;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
Serial.begin(9600); //inizializzo la porta seriale
Serial.write("Power On\n"); //scrivo sulla porta seriale l'avvio dello sketch
//impostazione i pin a cui sono collegati i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
Serial.write("Setup end\n");
}
int valoremassimo = 0;
int valoreminimo = 1000;
void loop() {
int potenzval = 0;
potenzval = analogRead(POTENZIOMETRO);
Serial.println("Potenziometro : " + String(potenzval));
if(potenzval>0){
//ad ogni ciclo verifico il valore del potenziometro
//se ricevo un nuovo massimo o un nuovo minimo
//questi saranno i miei nuovo valori che utilizzerò per la colorazione.
if(valoremassimo<potenzval){valoremassimo = potenzval;}
if(valoreminimo>potenzval){valoreminimo = potenzval;}
}
Serial.println("max: " + String(valoremassimo)+" min: " + String(valoreminimo));
int r = 0;
int g = 0;
int b = 0;
if(potenzval > ((valoremassimo-valoreminimo)/2)){
r = map(potenzval,valoreminimo,valoremassimo,255,0); //rosso
g = map(potenzval,valoreminimo,valoremassimo,0,255); //verde
b = 255; //blue
}else{
r = 255; //rosso
g = map(potenzval,valoreminimo,valoremassimo,255,0); //verde
b = map(potenzval,valoreminimo,valoremassimo,0,255); //blue
}
Serial.println("Colora R:"+String(r)+" G:"+String(g)+" B:"+String(b));
colora(r,g,b);
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
} |
//definiamo i pin ai quali collegare i piedini del LED RGB
const int ROSSO = 10;
const int VERDE = 9;
const int BLU = 8;
//definisco il pin del potenziometro
const int POTENZIOMETRO = 0;
// tempo di attesa tra i colori in millisecondi
const int delayTime = 1000;
void setup() {
Serial.begin(9600); //inizializzo la porta seriale
Serial.write("Power On\n"); //scrivo sulla porta seriale l'avvio dello sketch
//impostazione i pin a cui sono collegati i piedini del led RGB come uscite
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(BLU, OUTPUT);
// inizializziamo a LOW i pin ROSSO, VERDE, BLU
// inizialmente il led RGB sarà spento
pulisci();
Serial.write("Setup end\n");
}
int valoremassimo = 0;
int valoreminimo = 1000;
void loop() {
int potenzval = 0;
potenzval = analogRead(POTENZIOMETRO);
Serial.println("Potenziometro : " + String(potenzval));
if(potenzval>0){
//ad ogni ciclo verifico il valore del potenziometro
//se ricevo un nuovo massimo o un nuovo minimo
//questi saranno i miei nuovo valori che utilizzerò per la colorazione.
if(valoremassimo<potenzval){valoremassimo = potenzval;}
if(valoreminimo>potenzval){valoreminimo = potenzval;}
}
Serial.println("max: " + String(valoremassimo)+" min: " + String(valoreminimo));
int r = 0;
int g = 0;
int b = 0;
if(potenzval > ((valoremassimo-valoreminimo)/2)){
r = map(potenzval,valoreminimo,valoremassimo,255,0); //rosso
g = map(potenzval,valoreminimo,valoremassimo,0,255); //verde
b = 255; //blue
}else{
r = 255; //rosso
g = map(potenzval,valoreminimo,valoremassimo,255,0); //verde
b = map(potenzval,valoreminimo,valoremassimo,0,255); //blue
}
Serial.println("Colora R:"+String(r)+" G:"+String(g)+" B:"+String(b));
colora(r,g,b);
}
void colora(int R, int G, int B){
analogWrite(ROSSO, R);
analogWrite(VERDE, G);
analogWrite(BLU, B);
}
void pulisci(){
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, LOW);
digitalWrite(BLU, LOW);
}
Il setup è identico agli esempi precedenti tranne che per l’inizializzazione della comunicazione seriale, che ho utilizzato solo per conoscere i valori che di volta in volta ottenevo ruotando il potenziometro. In più rispetto agli esempi precedenti c’è una costante che definisce il pin analogico utilizzato per la lettura del valore del potenziometro, e due variabili, valoremassimo e valoreminimo, che rappresentano rispettivamente il valore più alto e quello più basso, registrato sul pin analogico al quale e collegato il potenziometro.
Nel metodo loop(), per prima cosa viene letto il valore del potenziometro e confrontato con i valori massimo e minimo per verificare se è arrivato un valore più alto o più basso ed eventualmente aggiornare le variabili, dopo di che vengono generati i valori per i tre canali rgb. Prima di tutto viene verificato se il valore attuale è nella metà più altra del potenziometro o meno, se si (quindi siamo nella metà alta del valore assumibile dal potenziometro) viene fissato il canale blue a 255 e generati i canali rosso e verde, viceversa viene fissato il canale rosso a 255, e generato i canali verde e blue. Per la generazione delle variabili utilizziamo la funzione map() per scalare i valori, dal valore massimo e minimo del potenziometro all’intervallo 0, 255.
Ben scritto, ero alla ricerca di qualcosa di simile, e sono venuto qui, sono felice perché finalmente qualcuno scrive sinteticamente e
al punto. Seguirò la pagina
Am aflat aceasta pagina, dupa ce am cautat despre Pilotare un led RGB con Arduino
pe Google. Se pare ca informatia dvs e foarte valoroasa, mai ales ca am mai gasit aici si despre ora, ora exacta, lucruri interesante si folositoare.
Mult succes in continuare!
Thanks for one’s marvelous posting! I seriously enjoyed reading it, you could be a great author. I will always bookmark your blog and will eventually come back in the future. I want to encourage you to continue your great job, have a nice weekend!
It’s fantastic that you are getting ideas from this piece of writing as well as from our
discussion made at this time.
I truly love your blog.. Excellent colors & theme.
Did you create this web site yourself? Please reply back as I’m planning to create my own blog and want to know where
you got this from or what the theme is called.
Cheers!
hello the theme is called ” Illdy ” with some of the CSS Customization
Things are all very open by using a precise explanation of your challenges.
It absolutely was truly informative. Your internet site is very useful.
I appreciate you sharing!
I’m extremely pleased to uncover this brilliant site.
I needed to thanks for ones time only for this fantastic
read!! I definitely savored every component of it and i also have you
saved to fav to view new stuff in your website.
Thanks on your marvelous posting! I really enjoyed reading it, you might be a great author.
I will always bookmark your blog and definitely will come back in the future.
I want to encourage you to definitely continue your great work, have a nice afternoon!
I’m delighted to get this page. I needed to many
thanks for your time for this particular particularly fantastic read!!
I definitely liked every component of it and i also do
you have saved like a favorite to look into new things in your web site.
Molto utile. Grazie!
Salve,
spiegazioni molto interessanti, vorrei chiedere se volessi accendere un RGB con un colore alla volta senza Fade e o lampeggi.
Cioè dire ad arduino accendi l’RGB di un detrminato colore e basta sciegliendo un qualsiasi colore, come posso fare?
Ciao,
ti ringrazio, venendo alla tua domanda e facendo riferimento al secondo esempio fatto nell’articolo,
ti basterà semplicemente chiamare il metodo colora, passandogli i 3 parametri necessari, relativi rispettivamente ai canali R,G,B del colore che ti interessa,
quindi senza mai chiamare il metodo pulisci, che serve appunto per spegnere il led RGB.
Spero di esserti stato utile.