LED RGB con Arduino - collegamento e codice senza errori

Un LED RGB con Arduino è uno dei progetti più utili per capire davvero come lavora un microcontrollore quando deve gestire luce, intensità e colori. In pratica, qui entrano in gioco tre cose che contano sempre: cablaggio corretto, PWM e scelta della polarità giusta. In questo articolo spiego come funziona il componente, come collegarlo senza errori, quale codice usare e quali problemi pratici conviene prevenire subito.

Io parto sempre da un punto semplice: un LED RGB non è un componente “magico”, ma un piccolo contenitore con tre LED separati, uno rosso, uno verde e uno blu. Arduino non crea colori dal nulla; regola solo quanta energia manda a ciascun canale, di solito con PWM, cioè un segnale che alterna rapidamente acceso e spento per simulare una luminosità intermedia.

La documentazione Arduino ricorda che analogWrite() usa di default una scala a 8 bit, quindi i valori pratici vanno da 0 a 255. In questo modo 0 significa spento e 255 significa massima intensità, mentre tutto ciò che sta in mezzo produce sfumature utili per mescolare i colori. Il punto meno intuitivo è che due valori identici non garantiscono sempre un risultato visivamente identico: il verde, per esempio, spesso sembra più forte del rosso a parità di numero.

Da qui nasce il vero lavoro: non basta accendere i tre canali, bisogna scegliere il tipo di LED giusto, cablarlo bene e poi bilanciare il mix con criterio. Ed è proprio da cablaggio e polarità che conviene partire.

Componenti e collegamento senza sorprese

Per un progetto pulito io uso sempre pochi elementi, ma usati nel modo giusto: una scheda Arduino, un LED RGB a 4 pin, tre resistenze separate, una breadboard e alcuni cavetti jumper. Le resistenze non sono un dettaglio: servono a limitare la corrente su ciascun colore e a evitare sia danni sia colori falsati.

Come valore di partenza, 220 Ω funziona bene nella maggior parte dei casi; se la luce è troppo forte o voglio un effetto più morbido, passo a 330 Ω. Se il LED è molto brillante già a bassa intensità, preferisco ridurre la luminosità via software invece di togliere la resistenza: il circuito resta più prevedibile.

Il dettaglio che fa davvero la differenza è che il piedino comune non è sempre nello stesso punto del package. Io non mi fido della sola forma esterna: controllo il datasheet oppure faccio una prova controllata con una resistenza, perché un LED collegato al contrario non si comporta come ci si aspetta.

Il cablaggio corretto, in pratica, è questo:

• collego ciascun canale colore a un pin PWM diverso;
• inserisco una resistenza per ogni canale, non una sola comune;
• porto il piedino comune a GND se il LED è a catodo comune, oppure a 5V se è a anodo comune;
• se uso alimentazione esterna, verifico che la massa sia condivisa con Arduino;
• controllo sempre l’ordine dei pin, perché non esiste una sequenza universale valida per tutti i LED RGB.

Quando il cablaggio è chiaro, il codice diventa molto più semplice da leggere e soprattutto da correggere. A quel punto ha senso passare alla parte che comanda davvero il colore.

Il codice base per accendere e mescolare i colori

Su una scheda classica io parto quasi sempre da tre pin PWM vicini, per esempio 9, 10 e 11. Se la tua scheda ha una mappa diversa, scelgo i pin indicati nella documentazione del modello, perché non tutte le board Arduino hanno gli stessi canali PWM.

const byte RED_PIN = 9;
const byte GREEN_PIN = 10;
const byte BLUE_PIN = 11;

const bool COMMON_ANODE = false;

void setColor(byte red, byte green, byte blue) {
  if (COMMON_ANODE) {
    red = 255 - red;
    green = 255 - green;
    blue = 255 - blue;
  }

  analogWrite(RED_PIN, red);
  analogWrite(GREEN_PIN, green);
  analogWrite(BLUE_PIN, blue);
}

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  setColor(255, 0, 0);
  delay(1000);

  setColor(0, 255, 0);
  delay(1000);

  setColor(0, 0, 255);
  delay(1000);

  setColor(255, 255, 255);
  delay(1000);

  setColor(0, 0, 0);
  delay(1000);
}

Questo sketch fa tre cose utili. Prima inizializza i pin come uscite. Poi usa una funzione unica, setColor(), per semplificare la lettura del codice. Infine gestisce anche il caso del LED a anodo comune, dove i valori vanno invertiti: in quel caso, per accendere un canale, il PWM deve scendere invece di salire.

Per avere un riferimento pratico, io uso spesso queste combinazioni:

Se la tua scheda lavora con una risoluzione diversa da 8 bit, conviene controllare analogWriteResolution(): in molte implementazioni moderne la scala non è obbligatoriamente 0-255. Io tengo sempre questo punto presente, perché un progetto che funziona su una UNO non è automaticamente identico su una board più recente. Quando il codice è sotto controllo, resta da capire perché a volte il risultato visivo non coincide con quello che ci si aspetta.

Gli errori che fanno perdere tempo al primo test

Nel 90% dei casi il problema non è il programma, ma un dettaglio elettrico o una polarità interpretata male. Per questo io controllo sempre prima il circuito e solo dopo il codice, perché una diagnosi ordinata fa risparmiare molto tempo.

Un errore che vedo spesso è l’uso di una sola resistenza sul comune invece che una per ciascun canale. Sembra un risparmio intelligente, ma in realtà altera il comportamento dei colori e rende il circuito meno affidabile. Un altro punto critico è il pin non PWM: se scelgo quello sbagliato, il LED sembra quasi solo acceso o spento, senza una vera modulazione.

Quando il progetto mostra un comportamento strano, io parto sempre da qui: polarità, resistenze, pin PWM e massa condivisa. Solo dopo mi sposto sul bilanciamento visivo dei colori, che è l’ultimo passo davvero importante.

Come ottenere colori più puliti e transizioni migliori

Quando voglio un colore credibile, non mi limito ai numeri massimi. Un bianco pulito, per esempio, spesso nasce da un piccolo ritocco dei tre canali, non da 255, 255, 255 buttato lì e basta. Il motivo è semplice: i LED non hanno la stessa efficienza spettrale e l’occhio umano non percepisce tutti i colori con la stessa intensità.

Qui entrano in gioco alcune abitudini pratiche che, per me, fanno molta differenza:

• per una luce d’ambiente parto spesso da valori massimi tra 120 e 180;
• per un fade fluido uso incrementi di 1-5 unità con pause da 5-20 ms;
• per una palette ripetibile salvo i colori in un array o in una piccola tabella di preset;
• se il bianco vira troppo al blu o al giallo, correggo un singolo canale di 10-30 punti;
• se il LED è diffuso, la fusione dei tre colori appare in genere più omogenea e meno “puntiforme”.

Un concetto utile, anche se non indispensabile al primo prototipo, è la correzione gamma: compensa il fatto che l’occhio non reagisce in modo lineare alla luminosità. Non serve per vedere un LED acceso, ma fa una grande differenza quando si cercano dissolvenze lente e passaggi più eleganti.

Io considero questa fase il passaggio da “il circuito funziona” a “il circuito sembra davvero curato”. E quando arrivi qui, la domanda successiva è quasi sempre quanto lontano si possa spingere il progetto senza cambiare architettura.

Quando un LED RGB singolo ti sta stretto

Se il progetto resta su un solo LED RGB, Arduino lavora senza problemi e l’esperimento è perfetto per imparare PWM, limitazione di corrente e logica di controllo. Quando però il numero di LED cresce, o quando si vogliono effetti più potenti, io cambio approccio prima di forzare i pin della scheda.

• Per più LED discreti conviene passare a transistor o MOSFET, così i pin non si caricano oltre misura.
• Per un effetto luminoso più scenografico ha senso aggiungere fade, pulsazioni e sequenze memorizzate.
• Per effetti di pixel indipendenti, una striscia addressable richiede una logica diversa rispetto a un LED RGB classico.
• Per un progetto ben leggibile, separo sempre la parte hardware dalla funzione che imposta il colore.

Il valore reale di questo piccolo esercizio è proprio qui: in poche prove impari a leggere un componente, scegliere il pin giusto, rispettare i limiti di corrente e ragionare in modo pulito sui colori. È un progetto semplice solo in apparenza, perché le stesse regole tornano poi in quasi tutti i lavori con microcontrollori e luce.