I led RGB (Red, Green, Blue) sono dei led modulari ovvero sono presenti tre led ognuno con la propria lunghezza d’onda di emissione . Consentono dunque di ottenere differenti colori miscelando i tre colori del modello RGB: rosso, verde e blu (da non confondere con i colori primari).

La lunghezza d’onda dipende dal semiconduttore di cui è composto, ad esempio Seleniuro di zinco o Carburo di silicio per il Blu, Fosfuro di gallio per il verde ecc.

Va da se che si avranno tensioni di soglia differenti per ogni colore (tensione al di sotto della quale il diodo non entra in conduzione).

Notare che differenti tensioni di soglia, a parità di alimentazione, si traducono in diversi valori di resistenza da collegare in serie.

La luminosità viene modulata variando il valor medio della corrente, ovvero modulando in modo opportuno la tensione di alimentazione. In questo modo si riesce a modulare con elevata dinamica la potenza fornita al diodo (modulazione PWM: non esplicitata in questo articolo).

Generalmente i microcontrollori presentano dei moduli appositi per la generazione di segnali PWM con frequenza e duty-cycle imposti, ma è bene rammentare che le GPIO di tali dispositivi non sono dimensionate per fornire correnti troppo elevate.

Di seguito lo schema di connessione del modulo ad un microcontrollore . Per comodità i pin vengono nominati a seconda del colore che gestiscono (si rammenta che bisogna connetterli nei pin con simbolo “~ ” se si lavora con Arduino, che sta ad indicare l’uscita di uno dei moduli PWM, con altri controllori è necessario consultare i fogli tecnici).

In questo progetto si utiliza una scheda Arduino UNO (R3). La frequenza di commutazione per pin 9,10 e 11 (relativi ai moduli PWM dell’ATMEGA) di default è di circa 500Hz (T=2ms).

Volendo variare la composizione dello spettro luminoso (in intensità) si può ricorrere ad un “JOYSTICK” , che altro non è che un doppio potenziometro ad assi incrociati.

Le tensioni di uscita (che vanno da 0v a Vcc) saranno le coordinate di un punto nel piano XY:

Il convertitore AC/DC presenta una risoluzione di 10bit. Pertanto il valore letto (ad esempio dai canali A0 e A1) andrà da 0 a 1023. Fissando le coordinate del punto P (x e y letti dal partitore) si definisce il punto di lavoro del modulo. Per ogni colore, il valore di duty-cycle (che si traduce, in intensità luminosa)è proporzionale alla distanza tra il centro del cerchio relativo a quel colore e il punto P. Se maggiore di un certo raggio R quel colore non sarà acceso. Nell’esempio in figura il led verde resterà spento mentre il blu e il rosso verranno miscelati opportunatamente.

Lo sketch in arduino:

//pin PWM ( ~ )
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11

int x,y; //coordinate punto P

//coordinate centro dei cerchi
int x_r = 512,y_r = 718;
int x_g = 206,y_g = 206;
int x_b = 718,y_b = 206;

float R = 600;//raggio del cerchio
float dis; //distanza dai P dal centro del cerchio 

//canali analogici 
const int X_pin = A1; 
const int Y_pin = A0; 

 void setup() {
   pinMode(PIN_R ,OUTPUT);
   pinMode(PIN_G ,OUTPUT);
   pinMode(PIN_B ,OUTPUT);
 }

void loop() {
//letture 
  y = analogRead(X_pin);
  x = analogRead(Y_pin);
  analogWrite(PIN_R,int(intensity(x_r,y_r)));
  analogWrite(PIN_G,int(intensity(x_g,y_g)));
  analogWrite(PIN_B,int(intensity(x_b,y_b)));
  delay(100);
}

//funzione assegnazione duty-cycle
int intensity(int xp,int yp){
  int pwm;
  dis = sqrt(pow(x-xp,2)+pow(y-yp,2));//Pitagora
  if(dis<= R){
    pwm = int(255*dis/R); //convert to int (serve intero)
  }
  else{
    pwm = 0; //se fuori dal cerchio: colore spento 
  }
 return pwm;
}

Il delay() all’interno del loop principale serve ad evitare che si cambino parametri ai moduli pwm troppo velocemente. La risposta dinamica rimane comunque buona.

Introducendo la funzione random() si può riprodurre il classico sfarfallio di una fiamma e creare effetti luminosi tipo quelli di una candela accesa:

//pin PWM ( ~ )
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11
//porzione duty-cycle randomizzata 
int R_rand  =200;
int G_rand  =10;
int B_rand =6;
//porzione duty-cycle fissa
int R  =50;
int G  =0;
int B =0;
//ritardo (randomizzato)
int del_rand = 150;
void setup() {
  pinMode(PIN_R ,OUTPUT);
  pinMode(PIN_G ,OUTPUT);
  pinMode(PIN_B ,OUTPUT);
}

void loop() {
  analogWrite(PIN_R, random(R_rand)+R);
  analogWrite(PIN_G, random(G_rand)+G);
  analogWrite(PIN_B, random(B_rand)+B);
  delay(random(del_rand));
}

Matteo Gentileschi