Questo articolo ti guiderà attraverso le basi dell’uso di un LED RGB con Arduino, così potrai creare i tuoi colori personalizzati con l’aiuto di potenziometri.
Ti mostrerò passo dopo passo gli schemi di collegamento e spiegherò il codice in modo che tu possa comprendere appieno come utilizzare questo componente.
Dopo questo tutorial, dovresti avere un circuito che emette luce nel colore preferito usando valori RGB, controllati dai potenziometri e visualizzati nel Monitor Seriale.
Materiali
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware
- x1 Arduino Uno Rev3 (Amazon)
- x1 LED RGB, catodo comune (Amazon)
- x3 Resistenze da 220 Ohm (Amazon)
- x3 Potenziometri da 10k Ohm (Amazon)
- x1 Breadboard (Amazon)
- x~17 Jumper Wires (Amazon)
- x1 Cavo USB B (Amazon)
Software
- Arduino IDE
Puoi trovare LED RGB anche in KY-016 moduli, che hanno il LED e le resistenze necessarie su un singolo PCB.
Questi moduli non permettono molta flessibilità nella costruzione del circuito, ma sono più plug-and-play rispetto alle alternative.
Non li consiglierei, preferisco la flessibilità di usare resistenze separate, e alcune recensioni mostrano una scarsa riproduzione dei colori usando valori RGB.
Istruzioni
Passo 1 – Collegare il LED RGB
Questo schema di collegamento ti mostra come connettere un LED RGB alla scheda Arduino.
Nota che si tratta di un LED a catodo comune, in cui il pin più lungo è collegato a massa; più avanti spiegherò cosa significa catodo comune.
Le connessioni sono anche riportate nella tabella sottostante.
| Componente | Pin Arduino |
| LED – Rosso | 11 |
| LED – Catodo | GND |
| LED – Verde | 10 |
| LED – Blu | 9 |
Assicurati di inserire una resistenza da 220Ω tra i pin rosso, verde e blu del LED e le uscite per evitare danni sia al LED che all’Arduino.
Nozioni di base sul LED RGB
Un LED RGB può essere visto come tre LED — uno rosso, uno verde e uno blu — in un unico componente; questo singolo LED emette luce combinando le intensità di rosso, verde e blu.
I LED RGB sembrano LED normali con quattro pin, il più lungo è il pin comune.
LED RGB a Catodo Comune e Anodo Comune
Ho già menzionato i LED a catodo comune e anodo comune. I LED RGB esistono in due tipi: catodo comune e anodo comune.
Nei LED a catodo comune il pin più lungo è collegato a GND e i componenti si accendono con un segnale a 5V; nei LED ad anodo comune è l’opposto: il pin più lungo va a 5V e un segnale a 0V accende i componenti.
In questo esempio useremo LED a catodo comune; se hai un LED RGB ad anodo comune, il cablaggio e le uscite dovranno essere invertiti.
L’unico modo per sapere se il tuo LED RGB è a catodo comune o anodo comune è testarlo; consiglio di usare un multimetro con la funzione diodi.
Per testare, metti la sonda negativa sul pin comune e la sonda positiva su un altro pin; se il LED si accende è a catodo comune.
Se non si accende, metti la sonda positiva sul pin comune e la negativa su un altro pin; il LED dovrebbe accendersi, indicando che è ad anodo comune.
Se non hai un multimetro, puoi fare questo test con i pin 5V e GND dell’Arduino, assicurandoti di avere una resistenza da 220Ω nel circuito.
Controllare la luminosità del LED con PWM
La luminosità di un LED è controllata dalla quantità di corrente che lo attraversa, ma non possiamo controllare direttamente la corrente perché l’Arduino Uno non ha uscite analogiche vere; per regolare la luminosità useremo la modulazione di larghezza di impulso (PWM).
Il PWM accende e spegne periodicamente l’uscita, e la durata dell’accensione determina la luminosità del LED.
Il PWM accende e spegne periodicamente l’uscita, e la durata dell’accensione determina la luminosità del LED.
L’intensità del LED è determinata dal duty cycle del PWM, cioè quanto tempo l’uscita rimane accesa. Un duty cycle del 50% significa che l’uscita è alta per il 50% del tempo e bassa per l’altro 50%.
Questo ciclo avviene a 490 Hz, 490 volte al secondo, e puoi controllare questo duty cycle con AnalogWrite.
Il PWM accende e spegne periodicamente l’uscita, e la durata dell’accensione determina la luminosità del LED.
Passo 2 – Collegare i tre potenziometri
Per questo passo devi collegare tre potenziometri a 5V, GND e ai pin analogici A0, A1 e A2.
I pin esterni saranno collegati a 5V e GND, il pin centrale si collega ai pin analogici secondo questa figura:
In forma tabellare:
| Componente | Pin Arduino |
| Pin più a destra (qualsiasi) | 5V |
| Pin più a sinistra (qualsiasi) | GND |
| Pin centrale (rosso) | A0 |
| Pin centrale (verde) | A1 |
| Pin centrale (blu) | A2 |
Usare un potenziometro come ingresso analogico
Per controllare i valori del LED RGB userai le uscite dei potenziometri (pin centrale) come ingressi analogici.
Arduino Uno ha 6 ingressi analogici, etichettati da A0 a A5; questi usano un convertitore analogico-digitale (ADC) a 10 bit con 6 canali.
Questo convertitore analogico-digitale restituisce un numero da 0 a 1023 (1024 valori = 2¹⁰ = 10 bit), a seconda della tensione letta su un canale.
Modificheremo il duty cycle PWM dei componenti del LED in base a questo valore.
Puoi considerare un potenziometro in questo circuito come un partitore di tensione: ruotando la manopola cambia la resistenza del pin centrale e quindi la tensione.
Questo “dividerà” la tensione di 5V in due parti se misuri la tensione tra l’uscita e 5V, e tra l’uscita e GND.
Passo 3: Codice di esempio Arduino RGB LCD
Ora che il cablaggio è fatto, non resta che collegare l’Arduino al PC e caricare lo sketch.
Puoi caricare il seguente codice tramite l’Arduino IDE, puoi copiarlo cliccando sul pulsante in alto a destra nel campo del codice.
/*Example sketch to control an RGB LED with Arduino using potentiometers
More info: https://www.makerguides.com */
//Definition of pins: outputs
#define redPin 11
#define greenPin 10
#define bluePin 9
//Definition of pins: analog inputs
#define redPot A0
#define greenPot A1
#define bluePot A2
int redVal, greenVal, blueVal; // RGB component values
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
}
void loop() {
//Reading potentiometer values
//When the pot is in the leftmost position, the voltage reading is 0
redVal = analogRead(redPot)/4;
greenVal = analogRead(greenPot)/4;
blueVal = analogRead(bluePot)/4;
//Sets the individual colors with the pot values
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
delay(50);
//Printing the values of Red, Green and Blue in a single line
Serial.print("R: "); Serial.print(redVal);
//The \t character creates a tab space between colors
Serial.print("\tG: "); Serial.print(greenVal);
//Final value is Serial.println to create a new line between readings
Serial.print("\tB: "); Serial.println(blueVal);
}
Come funziona il codice
Il primo passo è definire i pin rilevanti, fatto tramite l’istruzione #define che sostituisce la parola chiave definita con il valore desiderato durante la compilazione.
Con questo definiamo le uscite LED rosso, verde e blu rispettivamente ai pin 11, 10 e 9.
Poi facciamo la stessa cosa con gli ingressi dei potenziometri, usando i pin analogici A0, A1 e A2.
Ho anche definito tre variabili globali, una per ogni pin RGB. Questi valori sono interi, da usare ogni volta che si lavora con numeri interi.
Il valore di un intero può andare da -2.147.483.648 a 2.147.483.647. Se vuoi essere più efficiente con la memoria dell’Arduino puoi usare il tipo di dato byte , che va da 0 a 255.
Non è necessario in questo semplice esempio, ma è utile tenerlo a mente in sketch più complessi.
//Definition of pins: outputs #define redPin 11 #define greenPin 10 #define bluePin 9 int redVal, greenVal, blueVal; //RGB component values
Nella funzione setup() dello sketch definiamo i pin LED come Output e i pin potenziometri come Input usando la funzione pinMode().
Poi iniziamo la comunicazione seriale a 9600 baud con Serial.begin(9600), con questa funzione potrai leggere i valori di colore stampati in una sezione successiva dello sketch.
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
Ora passiamo alla funzione loop(). Prima leggiamo i valori dei potenziometri.
Questo si fa con la funzione analogRead(), specificando il pin, che restituisce un valore tra 0 e 1024, come detto prima.
Purtroppo, per controllare i LED con analogWrite() dobbiamo fornire valori tra 0 e 255, quindi dividiamo il valore letto per 4 e lo assegniamo agli interi.
//Reading potentiometer values //When the pot is in the leftmost position, the voltage reading is 0V redVal = analogRead(redPot)/4; greenVal = analogRead(greenPot)/4; blueVal = analogRead(bluePot)/4;
In questo passaggio uso le uscite PWM dell’Arduino per accendere i pin rosso, verde e blu del LED RGB con i valori interi ottenuti dai potenziometri, basta specificare il pin e il numero tra 0 e 255.
//Sets the individual colors with the pot values analogWrite(redPin, redVal); analogWrite(greenPin, greenVal); analogWrite(bluePin, blueVal);
Poi inserisco un piccolo ritardo nel codice, per evitare che il monitor seriale scorra troppo velocemente mantenendo comunque il LED RGB reattivo agli input.
Questo ritardo dura 50 millisecondi: 50 millesimi di secondo o 0,05 secondi.
Puoi regolare questo ritardo a piacere, tieni solo presente che un ritardo troppo lungo rallenterà anche l’aggiornamento dei valori RGB.
delay(50);
Infine, per controllare i valori RGB mostrati dal LED li stampiamo nel monitor seriale.
Per chiarezza, saranno stampati su una singola riga usando la funzione Serial.print().
Qui stampo la lettera corrispondente a ogni componente del LED RGB e il suo valore scritto. Ho usato il carattere di escape \t per creare una tabulazione tra i colori, escape characters seguono una barra rovesciata e non appaiono nella stringa stampata, poiché svolgono funzioni speciali.
Inoltre, l’ultima funzione seriale è Serial.println(), che assicura che il messaggio seriale successivo appaia su una nuova riga.
Serial.print("R: "); Serial.print(redVal);
Serial.print("\\tG: "); Serial.print(greenVal);
Serial.print("\\tB: "); Serial.println(blueVal);
Per vedere i messaggi nel monitor seriale premi Ctrl+Shift+M nell’Arduino IDE, o clicca sull’icona della lente di ingrandimento. Assicurati che la velocità di trasmissione sia impostata a 9600 per leggere correttamente i messaggi.
Dovresti vedere qualcosa di simile all’immagine seguente:
Ecco fatto! Se hai seguito correttamente i passaggi, dovresti poter controllare il LED RGB e produrre tutti i tipi di colori usando i potenziometri.
Colore Additivo
La proprietà delle luci di colori diversi di combinarsi per creare un nuovo colore si chiama colore additivo.
Questa proprietà permette agli schermi di mostrare circa 16 milioni di sfumature di colore: impostando i valori di rosso, verde e blu da 0 a 255 proprio come nel nostro progetto.
Puoi provare alcune delle combinazioni base mostrate nell’immagine qui sotto, o andare su un color picker e creare la tua!
I risultati possono variare: alcuni componenti nei LED RGB sono più forti di altri e potrebbero richiedere aggiustamenti.
Conclusione
In questo articolo ti ho mostrato come usare un LED RGB con Arduino: il cablaggio, le uscite analogiche necessarie e un semplice circuito che mostra come personalizzare facilmente il colore del LED.
Se hai domande o suggerimenti per questo tutorial, lascia un commento qui sotto.
Mi piacerebbe aiutarti!
