A chi non è capitato almeno una volta di notare quel bellissimo effetto led presente su alcuni dispositivi elettronici, il cosiddetto breathing led ovvero “led che respira”?
In rete ci sono makers da ogni parte del mondo che muniti di oscilloscopio hanno provato a fare reverse engingering per riprodurre l’algoritmo in questione e trasformarlo in uno sketch per Arduino.
Il problema sta nel fatto che la maggior parte dei codici trovati in rete hanno due difetti: il primo è che tali algoritmi non contengono una funzione ma una serie di valori precalcolati che non rendono continuato e preciso l’effetto, mentre il secondo risiede nel fatto che spesso questi codici sono bloccanti, ovvero fanno uso di delay e non permettono quindi la corretta continuazione del restante codice all’interno dello sketch.
Prendendo spunto dal codice pubblicato da Sean Voisen che ha trovato la funzione che definisce i valori PWM per pilotare il led, ho fatto delle modifiche e dei test per renderlo non bloccante, ovvero per farlo lavorare in background e permettere l’esecuzione di altro codice.
Il risultato finale è il seguente:
Il collegamento avviene ovviamente come per qualsiasi altro led e il sistema è in grado di pilotare anche led di potenza o led strip, tramite opportuno transistor o mosfet (Vedi: Pilotare una led strip con Arduino)
Il codice per Arduino è il seguente:
/*
NonBlockingBreathingLed 0.1
by Luca Soltoggio - 2015
12 May 2015
http://www.arduinoelettronica.com/
http://arduinoelectronics.wordpress.com/
http://minibianpi.wodpress.com/
Use a exp + sin function to recreate a
non-blocking breathing led effect
Released under GPL v.2 license
*/
#include <math.h>
#define ledPin 11
int i=0;
int breathe_delay = 15; // delay between loops
unsigned long breathe_time = millis();
void setup()
{
}
void loop()
{
nonBlockingBreath(); // call the nonblocking function
// yourOtherCodeHere();
}
void nonBlockingBreath()
{
if( (breathe_time + breathe_delay) < millis() ){
breathe_time = millis();
float val = (exp(sin(i/2000.0*PI*10)) - 0.36787944)*108.0;
// this is the math function recreating the effect
analogWrite(ledPin, val); // PWM
i=i+1;
}
}
Finalmente dopo una lunga assenza, in cui ero immerso nella realizzazione finale di questo mio progetto, CE L’HO FATTA!!!
Dopo mesi di progettazione, studi, ricerche e ostacoli vari, la RGB LED Lamp 1.0 by Toggio è realtà.
Posto subito il video che mostra il risultato definitivo ottenuto:
Ed ora una breve cronistoria.
Una delle cose che mi ha attirato di più quando ho sentito parlare di Arduino, era la luce, e in particolar modo ho sempre avuto il sogno di realizzare una lampada a LED RGB.
Niente di difficile, si potrebbe pensare… Solo che lungo questo percorso ho trovato diversi ostacoli.
Innanzitutto non ho trovato progetti completi in rete… Si trova qualcosa, ma, a mio avviso, con algoritmi fatti male, con poche spiegazioni, con metodi elaborati.
Io volevo una cosa semplice da regalare alla persona che amo e che mi ha dato una bellissima figlia…
Volevo qualcosa che avesse una luce abbastanza potente, senza però scaldare troppo. Volevo qualcosa che avesse la possibilità di scegliere il colore e non una semplice “color cycler”. Volevo qualcosa che fungesse anche da lampada standard. Ed infine volevo qualcosa che fosse modulare e upgradabile in futuro.
Dopo queste riflessioni, ho cominciato a studiare innanzitutto l’hardware. Non volevo usare l’Arduino UNO perchè mi sembrava eccessivamente grande per il mio progetto. Ho deciso quindi (e qui si potrebbe aprire un’enorme parentesi) di utilizzare una board non tanto diffusa ma a mio avviso eccezionale (tant’è che ne ho comprate 4 o 5): la Arduino Mini Pro.
(Resta inteso che nel progetto di questo post, può essere tranquillamente sostituita con una UNO o qualsiasi altra Arduino board.)
E’ una board estremamente piccola (18mm x 33mm), compatibile al 100% con Arduino Dumilanove, e a basso consumo. Esiste in quattro versioni: con Atmega328 a 3.3V e 5V e con Atmega168 a 3.3 e 5V.
Ho quindi optato per questo progetto per la versione a 5V con Atmega168. In definitiva si tratta di una soluzione molto economica (costa circa la metà dell’Arduino UNO), alquanto compatta e bella da vedere.
Ho poi pensato di utilizzare delle comodissime Strip LED RGB, che offrono numerosi vantaggi rispetto ad utilizzare led di potenza a 1W o a 3W: non scaldano, si alimentano a 12V e offrono una potenza fino a 13-14W per metro lineare.
Ogni canale può essere alimentato da un’uscita PWM di Arduino tramite un semplice transistor (nel mio caso ho usato dei BC337, ma per potenze superiori si possono usare altri transistor o addirittura dei Mosfet).
Ho quindi provveduto a costruire una specie di shield per la mia board. In pratica ho realizzato un circuito in cui la Arduino Mini Pro possa inserirsi con dei connettori strip ed essere eventualmente rimossa per aggiornare il firmware. Il tutto è stato progettato con Fritzing e realizzato da Fritzing Fab.
Il risultato finale del circuito stampato è il seguente:
Si possono notare le due file di fori dove andrà montata la Mini Pro… Praticamente è una shield al contrario 🙂
Ma facciamo un passo indietro e vediamo lo schema di circuito:
Spero sia abbastanza chiaro anche se non l’ho disegnato proprio benissimo!
In ogni caso il funzionamento è il seguente: I due potenziometri da 10k posti tra i +5V e la massa, sono i due input analogici che permettono di regolare la luminosità e altri parametri stabiliti dal software. Il deviatore a 3 posizioni SW2, permette di selezionare tre funzioni diverse per la lampada. Le uscite digitali 3,5,6 vanno a pilotare tramite un resistore i 3 transistori BC337 che andranno a dare corrente alle 3 uscite negative R,G,B della striscia a LED. Il positivo comune va ai +12V, mentre l’Arduino è alimentato tramite porta RAW (ingresso da 7V a 13V) tramite un diodo che oltre a fornire protezione da eventuale inversione di polarità, abbassa leggermente la tensione. SW1 è semplicemente il ponte dove andrà collegato un normalissimo interuttore di accensione.
Una volta saldati i vari componenti, connettori e potenziometri, montato il circuito, incapsulata la board Arduino, e montato il tutto dentro una scatola da elettricista, il risultato è quello della foto seguente:
La dimensione della scatola è di circa 10cmx10cmx7cm.
Per la parte superiore, ho utilizzato circa 70cm di striscia led RGB, per una potenza totale di circa 10W. Per farla stare tutta l’ho arrotolata intorno al perno di supporto di una campana da CD. Ho tagliato con un taglierino tale perno e l’ho incollato con dei distanziatori sopra la scatola. Ho poi incollato con della colla a caldo la striscia a led avvolgendola sul perno… Insomma un lavoro un po’ artigianale ma il risultato alla fine è il seguente:
Il vetro che si vede sulla scrivania leggermente spostato rispetto alla lampada, è il pezzo finale che manca: la copertura in vetro di una lampada IKEA, opportunamente fatta tagliare da un vetraio locale, affinché rimanga vuota sui due lati. Questa coperturà verrà infine appoggiata sopra la scatola da elettricista ed incollata, ottenendo il seguento risultato:
Mica male vero?
Ovviamente manca ancora la ciliegina sulla torta, una parte non meno importante: il software.
Il codice autoesplicativo è il seguente:
/*
RGB Led Lamp 1.0a
by Luca Soltoggio
15/03/2012
https://arduinoelettronica.wordpress.com/
*/
int rpin = 3; // pin RED
int gpin = 5; // pin GREEN
int bpin = 6; // pin BLU
unsigned int r=0, g=0, b=0,bm=0; // valori rgb e coefficiente divisore del blu
unsigned int valh=0, vals=0, valv=0; // hue, saturation, value
unsigned int sensorValue; // variabile che memorizza il valore dei potenziometri
const int analogInPin = A0; // pin dei potenziometri
const int analogInPin2 = A1;
const int digitalInPin = 10; // pin del deviatore
const int digitalInPin2= 11;
int red[]={255,255,135}; // array con i valori RGB della funzione "Bianco"
int green[]={157,255,158};
int blue[]={51,255,255};
boolean DIG1, DIG2;
long previousMillis = 0;
int i=0,j=0;
int dl=0; // delay
void setup()
{
pinMode(digitalInPin,INPUT);
pinMode(digitalInPin2,INPUT);
}
void loop()
{
DIG1=digitalRead(digitalInPin);
DIG2=digitalRead(digitalInPin2);
if (DIG1) {
bm=1.1;
HSV_Game();
}
else if (DIG2) {
bm=1.9;
RAINBOW_Game();
}
else {
bm=2.4;
LIGHT_Game();
}
analogWrite(rpin, r/1.09); // ROSSO
analogWrite(gpin, g/1); // VERDE
analogWrite(bpin, b/bm); // BLUE
}
// funzione di armonizzazione dei valori analogici tramite media aritmetica
int SensorSmooth (int pin) {
sensorValue=0;
for (int i = 0; i<10; i++) { sensorValue+= analogRead(pin); } return int ((float)sensorValue/10+0.5); } // prima funzione: selezione del colore e della luminosità tramite potenziometri void HSV_Game() { valh = SensorSmooth(analogInPin); vals = 255; valv = SensorSmooth(analogInPin2); valh = map(valh,0,1023,0,359); valv = map(valv,0,1023,32,255); hsv2rgb(valh,vals,valv,r,g,b); } // seconda funzione: selezione di bianco caldo, bianco neutro e bianco freddo, oltre alla luminosità void LIGHT_Game() { valv = SensorSmooth(analogInPin2); valv = map(valv,0,1023,16,255); valh = SensorSmooth(analogInPin); if (valh=742) valh=2; if (valh>2) valh=1;
r=red[valh]*valv/255;
g=green[valh]*valv/255;
b=blue[valh]*valv/255;
}
// terza funzione: selezione della velocità di rotazione tra tutti i colori e della luminosità
void RAINBOW_Game() {
dl = SensorSmooth(analogInPin); // tempo di pausa
dl = map(dl,0,1023,1,100);
valv = SensorSmooth(analogInPin2);
valv = map(valv,0,1023,64,255);
unsigned long currentMillis = millis();
switch (j) {
case 0:
r=255*valv/255;
g=i*valv/255;
b=0*valv/255;
break;
case 1:
r=(255-i)*valv/255;
g=255*valv/255;
b=0*valv/255;
break;
case 2:
r=0*valv/255;
g=255*valv/255;
b=i*valv/255;
break;
case 3:
r=0*valv/255;
g=(255-i)*valv/255;
b=255*valv/255;
break;
case 4:
r=i*valv/255;
g=0*valv/255;
b=255*valv/255;
break;
case 5:
r=255*valv/255;
g=0*valv/255;
b=(255-i)*valv/255;
}
if (currentMillis-previousMillis > (long)(100-dl)) { // usa millis invece che delay
previousMillis=currentMillis;
i=i+1;
if (i==256) {
i=1;
j=j+1;
if (j==6) j=0;
}
}
}
/* Funzione che trasforma HSV in RGB
(c) Elco Jacobs, E-atelier Industrial Design TU/e, July 2011
http://code.google.com/p/shiftpwm/source/browse/trunk/examples/ShiftPWM_Example1/hsv2rgb.cpp?r=3
*/
void hsv2rgb(int hue, int sat, int val, unsigned int& r, unsigned int& g, unsigned int& b)
{
int H_accent = hue/60;
int bottom = ((255 - sat) * val)>>8;
int top = val;
int rising = ((top-bottom) *(hue%60 ) ) / 60 + bottom;
int falling = ((top-bottom) *(60-hue%60) ) / 60 + bottom;
switch(H_accent) {
case 0:
r = top;
g = rising;
b = bottom;
break;
case 1:
r = falling;
g = top;
b = bottom;
break;
case 2:
r = bottom;
g = top;
b = rising;
break;
case 3:
r = bottom;
g = falling;
b = top;
break;
case 4:
r = rising;
g = bottom;
b = top;
break;
case 5:
r = top;
g = bottom;
b = falling;
break;
}
}
Nel post precedente abbiamo visto un semplice LED driver basato sull’integrato LM317, ma come spiegato uno dei difetti di quel circuito è il dropout elevato.
Vediamo quindi oggi uno schema basato su un singolo transistor (nel nostro caso un BC337, ma qualsiasi NPN va bene purchè se ne conoscano i valori in gioco), che ha un dropout di circa 1,25V.
Il circuito è il seguente:
Ovviamente si può inserire anche solo un LED. Ne ho messi tre in serie a titolo d’esempio, poichè siamo in grado di pilotare 3 LED da 1w con un efficienza abbastanza elevata. Nell’esempio in figura, abbiamo una potenza dissipata dai LED di circa 3W, mentre l’intero circuito consuma circa 4W.
Ma vediamo il principio di funzionamento:
I LEDR è un LED standard e serve come voltaggio di riferimento per il transistor. Il dropout del led rosso è di circa 1,8v, quindi sul collettore del transistor avremo all’incirca 950mV. Applicando sempre la legge di Ohm 0,950/2,8=339, quindi con R2 a 2,8V si ha un passaggio di corrente di 339mA, che scorrerrà anche attraverso l’emettitore di Q1. In questo modo avremo un corrente costante indipendentemente dal voltaggio di ingresso. Questo è vero finchè il voltaggio, sarà sufficiente a mantenere 1,8V sul LEDR, ovvero 1,2V sull’emettitore di Q1. Insomma in parole povere dobbiamo prevedere che il voltaggio in ingresso sia di almeno 1,2V superiore al dropout dei led che si va a pilotare. I led bianchi da 1W per esempio hanno un voltaggio massimo dichiarato di 3,6V, percui 3,6×3=10,8V. 10,8+1,2=12V. In questo caso siamo perfetti. Consiglio sempre un voltaggio di circa 1,5V in più per sicurezza.
Se il carico da pilotare è maggiore di 500-600mA, è possibile diminuire il valore di R1 fino a 470Ω.
Se volessimo superare invece i 750mA, dovremmo sostituire il transistor con un darlington tipo il BD677A che può erogare fino a 4A di corrente!!!
Potete sperimentare il circuito variandone i valori, utlizzando il simulatore gratuito online a questo link.
Ovviamente anche questo circuito è “PWM capable”. Possiamo quindi alimentare il tutto tramite un circuito PWM, oppure utlizzare il seguente schema per utilizzare ad esempio un’uscita PWM di Arduino:
In questo caso dovremo diminuire leggermente la resistenza R2 a causa del fatto che il voltaggio con cui pilotiamo l’ingresso di Q1 non è 12V ma 5V.
L’importante come sempre è sperimentare, sperimentare, sperimentare!!!
L’utilizzo dei LED nella vita quotidiana, negli ultimi anni ha sempre più preso piede.
Con l’uscita sul mercato di LED di potenza da 1W, 3W, 5W, 10W e così via la possibilità di illuminare con questi diodi le nostre vite è alla portata di tutti.
Purtroppo i sistemi a LED di potenza integrati (tipo lampadine di marca) hanno dei costi ancora abbastanza elevati, ma i singoli diodi led sono abbordabilissimi.
Il problema per tanti è l’alimentazione, in quanto rispetto ai classici LED da 20ma che tipicamente si alimentano a 12V con una resistenza in serie da 470Ω , questo tipo di LED hanno bisogno, a maggior ragione viste le potenze in gioco, di essere alimentati non a tensione costante, ma a corrente costante.
Quando si compra un LED di potenza, spesso il venditore fornisce anche il suo alimentatore specifico a prezzi non sempre accettabili.
Da qui nasce la mia ricerca sui vari siti e blog di un sistema per alimentare questi LED, che mi dia la possibilità anche di essere dimmerato eventualmente da un circuito PWM o da un microcontroller (tipo Arduino).
Ho trovato due progetti interessanti, semplici, di facile realizzazione, sperimentati e soprattutto economici e costruiti con componenti molto comuni e diffusi.
Il primo circuito che vi voglio presentare, è costruito utilizzando l’integrato LM317, che è un regolatore variabile di tensione, ma in questo caso lo utilizzeremo come regolatore di corrente.
Il circuito qui mostrato è abbastanza semplice da capire. Tra Vout e ADJ è presente un voltaggio di riferimento di 1,25V, quindi applicando la legge di Ohm I=V/R, con un voltaggio di 1,25V e una resistenza di 3,6Ω, avremo una corrente costante di circa 347ma che scorre attraverso il LED1, indipendentemente dal voltaggio di ingresso. Questo circuito è quindi adatto per esempio per alimentare un LED da 1w (che tipicamente va alimentato con una corrente di assorbimento di 350ma).
Ovviamente si possono mettere più LED in serie, ma va tenuto conto del dropout del circuito che è di circa 3V, quindi il voltaggio in ingresso deve essere di almeno 3V superiore a quello nominale del (o dei) LED. Se però il voltaggio è troppo alto l’integrato si scalderà troppo poichè tutto il voltaggio in eccesso verrà dissipato proprio dall’LM317.
Infatti questo circuito dal punto di vista del rendimento non è il massimo; per alimentare un LED da 1W, il circuito assorbe circa 4W.
Bisogna tener conto anche del fatto che la resistenza dissipa una potenza pari a 1,25V per la corrente di circuito (in questo caso 347mA), dovremmo quindi prestare attenzione che le resistenze abbiano una potenza adeguata (eventualmente se ne possono mettere due o più in serie o in parallelo).
Il tutto è “PWM capable”, possiamo quindi alimentare il tutto con un circuito PWM di potenza adeguato (magari ne pubblico uno in un prossimo post), oppure pilotarlo da un circuito PWM a bassa potenza, tipo l’uscita di Arduino a 5V e allora lo schema sarà così modificato:
Abbiamo dovuto modificare il valore della resistenza R1 perchè introducendo la R2, il valore di riferimento mi si porta a 1,75v circa. Eventualmente va sperimentato e misurato con un amoperometro.
In questo circuito VCC che rappresenta l’ingresso TTL del nostro circuito (l’uscita PWM di un Arduino, piuttosto che l’uscita logica di un NE555), quando è a ad un valore alto (+5V), il transistor Q1 conduce e il piedino ADJ dell’LM317 va a massa, inibendo il passaggio di corrente nella R1 e quindi nel LED. Viceversa se porto l’ingresso logico ad un valore basso (0V) il transistor non conduce permettendo il passaggio di corrente: il LED si accende come nel’esempio precedente. Ovviamente lavora a logica invertita e quindi nella programmazione del microcontrollore se ne dovrà tenere conto, o al limite si può aggiungere un transistor ulteriore per invertire nuovamente la logica.
In un prossimo post, vedremo di realizzare un’altro circuito che abbia la stessa funzione, utlizzando però un transistor al posto dell’LM317.
Elettronica & Arduino 