Rieccoci qui.
Oggi voglio proporvi un progetto veramente molto semplice quanto efficace e utilizzabile per svariate applicazioni.
Trattasi di un sensore di continuità ad altissima resistenza (guadagno di corrente di circa 30000 volte), basato sull’interessante Darlington NPN BC517, e dal costo estremamente contenuto.
Il progetto base qui pubblicato semplicemente permette di accendere un LED toccando o immergendo in acqua due elementi metallici (cavi, piastre o quant’altro), ma “clonando” il circuito e inserendo più transistor e più LED, possiamo ottenere un indicatore di livello a 2, 3, 4 o 30 settori.
Ovviamento nulla vieta di sostituire il LED con un relè in modo da poter pilotare carichi più importanti.
Ma vediamio nel dettaglio il circuito:
Il funzionamento è alquanto banale: toccando i due contatti del sensore sens con le mani ad esempio, la debole corrente che passa attraverso il nostro corpo è sufficiente a far eccitare il transistor tramite la resistenza R1 che serve da protezione qualora unissimo direttamente i due contatti. Il BC517 è in grado di amplificare tale corrente di circa 30.000 volte, per cui una corrente di 10 μA, è in grado di fare scorrere fino a 300 mA attraverso il transistor. La resistenza R2 serve per evitare accensioni accidentali mettendo a terra la base del transistor, mentre la R3 è semplicemente la resistenza per limitare la corrente che scorre attraverso il LED.
Anche se semplice, credo che il progetta possa essere uno spunto per altre applicazioni.
Inoltre a volte le cose semplici sono le più funzionali, e un po’ di elettronica discreta ogni tanto… non guasta…
Saluti e alla prossima!!!
Aggiornamento – 03/10/2012
Schema corretto: ovviamente uno dei due puntali non andava a massa ma sul positivo… chiedo scusa per l’errore e a chi giustamente mi ha corretto con i suoi commenti.
Ed ora un’altro interessante progettino.
Dopo aver visto vari progetti in rete, soprattutto basati sui microcontroller PIC, ho deciso di realizzare un caricabatterie per batterie NiMh gestito da un’Attiny85.
Per quale motivo, penserà qualcuno, serve un microcontrollore per gestire la carica di una batteria. La risposta è molto semplice… La maggior parte dei caricabatterie economici che ci sono in commercio, regolano la carica basandosi su un timer, cioè se devo caricare una batteria da 2500mAh, forniscono una corrente di carica ad esempio di 250mAh, continuando la carica per ad esempio 14 ore (una parte dell’energia se ne va a quel paese, 10 ore non sarebbero sufficienti).
Questo modo di caricare le batterie al Nichel (Mh o Cd), non è tanto funzionale. In primo luogo è un processo lento, e poi non garantisce la corretta carica precisa al 100% delle celle, oltre a presentare rischi di sovrraccarica.
I caricabatterie di tipo “smart” in commercio invece, caricano le batterie correttamente, ma oltre ad essere abbastanza costosi, hanno solitamente correnti di carica non elevatissime, con tempi quindi non sempre sopportabili.
Da qui, oltre che la curiosità e la voglia di creare qualcosa di mio, nasce questo progetto…
Ma andiamo con ordine, e cominciamo con il il video che mostra il progetto finito ed in funzione:
Cerchiamo ora di capire un’attimo il funzionamento.
Innanzitutto le batterie al Nichel necessitano di una corrente costante per essere caricate correttamente. In questo caso si è utilizzato un generatore di corrente costante basato su transistor, derivato da quello che abbiamo visto in un post precedente, e fin qui niente di particolare, ma come facciamo a capire quando la batteria è carica?
Dobbiamo leggere continuamente la tensione della batteria sotto carica, e quando questa presenterà dopo un picco massimo di tensione, una discesa repentina di circa 20mv, la batteria potrà considerarsi carica. Tale fenomeno (chiamato Negative Delta V) è legato alla chimica di questa tipologia di batteria, e permette di stabilire con precisione il momento corretto per terminare la carica.
Vediamo quindi lo schema del circuito:
Lo schema è abbastanza semplice. Il transistor dalington Q1 (TIP127), tramite il LED1 (che deve essere assolutamente ROSSO) e la resistenza R3 da 0,3Ω, crea una corrente costante che scorre in direzione della batteria a 6 celle (7.2V), mentre il diodo Schottky 1N5822 da 3A, serve per proteggere tutto il circuito nel caso che venga a mancare la tensione di ingresso con la batteria connessa. Il partitore di tensione R4-R5, serve per portare alla porta 7 dell’Attiny (A1) il voltaggio della batteria diminuito a circa 1/3, in maniera tale che possa funzionare con tensioni sino a 15V (l’ingresso analogico dell’Attiny non può superare i 5V). Il transistor Q2, pilotato dalla porta 5 dell’Attiny (D0), serve come interrutore per attivare o disattivare il LED1 e il transistor Q1. E’ fondamentale che il LED sia ROSSO, e questo non per una questione di estetica, ma perchè la potenza uscita è data dal rapporto tra la tensione del LED (nei led rossi è di circa 1,8-2,2V) e la resistenza R3. Usando un LED verde, la tensione di riferimento si alza, e di conseguenza anche la corrente si alza (e non di poco).
Il circuito così fornito, può erogare circa 1,5-2,5A, dovete eventualmente fare un po’ di prove con vari tipi di LED rosso, oppure variare la resistenza, che deve essere da 2W. Nel caso non abbiate a disposizione o non riusciate a trovare resistenze di valori così bassi, potete utilizzare 3 o 4 resistenze da 1Ω in parallelo.
Altra cosa da tenere in conto, è la potenza dissipata dal TIP127, che può arrivare anche a 20Watt (dipende dalla corrente e dalla differenza di tensione tra l’ingresso e la batteria), quindi va montato un dissipatore adeguato. Nel mio caso ho usato il case di alluminio che risulta essere sufficiente.
Ultimo appunto è il voltaggio di ingresso, che non deve essere troppo alto altrimenti si rischia di far bruciare il transistor, ma non deve essere nemmeno troppo basso, perchè altrimenti il dropout indotto dai vari componenti fa scendere troppo la corrente di carica. Consiglio all’incirca una differenza di circa 5V tra la tensione di ingresso ed il valore nominale della batteria. Ad esempio con 6 celle, il voltaggio consigliato è di 12,2V (va bene anche 12). Ovviamente si possono caricare anche meno celle, regolando opportunamente la tensione in ingresso. Per una cella, dovremmo alimentare il tutto con una tensione di circa 1,2+5 = 6,2V (va bene anche 6 o 7).
Vediamo ora il circuito stampato:
Da notare le due chicche che non erano visibili nello schema. Il connettore ICSP (quindi la possibilità di aggiornare il firmware sull’Attiny (via programmatore ad esempio UsbTinyISP), e il connettore debug, da collegare ad un convertitore TTL per potere leggere il voltaggio della batteria durante la carica.
Il connettore J1 invece è un jumper che deve essere sempre chiuso, tranne quando aggiorniamo il firmware dell’Attiny85.
A proposito di firmware… Il codice sorgente del firmware è il seguente:
/*
NiMh Charger 0.9
con AtTiny85 @ 1Mhz
by Luca Soltoggio
10/03/2012 - 20/04/2012
Usa il -dT per determinare la fine carica.
Funziona con batteerie NiMh e NiCd.
I valori di default sono per pacchi da 6 celle e 2500mAh
Necessita di qualche aggiustamento hardware/software per parametri differenti.
Vedi https://arduinoelettronica.wordpress.com/
*/
const int inputPin = A1;
const int outputPin = 0;
const int numReadings = 30; // numero di letture analogiche prima di fare il check della batteria
const int multi = 1614; // coefficiente di moltiplica per ottenere il voltaggio corretto dall'analogread
long interval = 1000; // intevallo del pulse charge - non modificare
long interval2 = 250; // intervalle pulse off - modificabile. Utlizzare 100 per 2-4Ah, 500 per 1-2Ah
long interval2b=interval2;
long previousMillis,currentMillis,currentMillis2,trickleMillis = 0;
unsigned int readingtemp;
unsigned int total = 0;
unsigned int average,medium,maxmedium = 0;
boolean executed,endcharge,trickle=false; // variabili di controllo
unsigned int myarray [7]; // arrray che memorizza le ultime 7 letture
int index,i = 0;
void setup()
{
Serial.begin(9600);
pinMode(0,OUTPUT);
// Alcune letture per un controllo iniziale
for (i=0;i<10;i++) {
readingtemp = analogRead(inputPin);
total=total+readingtemp;
}
average = (((float)total / 1023.0) * (float)multi) / 10.0 + 0.5;
if (average<=70) endcharge=true; // Se la batteria non è presente, termina la carica
Serial.println(average);
total=0;
average=0;
}
void pusharray() {
// push dell'array
for (i=0;i<=5;++i) {
myarray[i]=myarray[i+1];
}
myarray[6]=average;
}
void voltread() {
readingtemp = analogRead(inputPin); // legge l'input analogico
total= total + readingtemp;
index++;
// se è stato raggiunto "numReadings" calcola la media
if (index==numReadings) {
index=0;
average = (((float)total / 1023.0) * (float)multi) / numReadings + 0.5;
if (average<=70) endcharge=true; // termina la carica se la batteria viene scollegata
total=0;
pusharray(); // inserisce la nuova media nell'array
// calcola la media delle ultime 7 letture
medium=(float)(myarray[6]+myarray[5]+myarray[4]+myarray[3]+myarray[2]+myarray[1]+myarray[0])/7.0+0.5;
if (medium>maxmedium) maxmedium=medium; // salva il valore della media più alta in "maxmedium"
Serial.print(medium);
Serial.print(",");
Serial.print(maxmedium);
Serial.print(",");
Serial.println(myarray[6]);
// se la batteria è carica (la media dei voltaggi è scesa di 0.02v), ma non nei primi 11 minuti
if ( ((medium+1) < maxmedium) && ((millis()/60000)>=11) ) {
if (!trickle) trickleMillis=millis(); // parte il timer per la "trickle charge" finale
trickle=true; // parte la "trickle charge" finale
// se la batteria si è caricata nei primi 15 minuti, non utilizzare la "trickle charge" finale
// (probabilmente la batteria era già carica)
if ((millis()/60000)<=15) endcharge=true;
}
}
}
void loop() {
currentMillis = millis();
// esegui ogni "interval" millis
if(currentMillis - previousMillis > interval) {
voltread(); // chiama la funzione di lettura e controllo
digitalWrite(outputPin,LOW); // ferma temporaneamente la carica
previousMillis = currentMillis;
executed=false; // variabile per controlloare se è già stata riattivata la carica
// nei primi 10 minuti e negli utlimi 15 minuti effettua una "trickle charge"
// (modifica il tempo di OFF)
if ( ( (trickle) && (((millis()-trickleMillis)/60000)<15) ) || ((millis()/60000)<10) ) {
interval2=(interval-(interval-interval2b)/5);
// dopo la carica iniziale ripristina il valore corretto di interval2
} else if ((millis()/60000)>=10) interval2=interval2b;
// alla fine dell'ultima "trickle charge" termina la carica
if ( (trickle) && (((millis()-trickleMillis)/60000)>=15) ) endcharge=true;
}
currentMillis2 = millis();
// esegui "interval2" millis dopo aver fermato la carica
if ((currentMillis2 - previousMillis > interval2) && (!executed)) {
executed=true;
if (!endcharge) {
digitalWrite(outputPin,HIGH); // se la batteria non è carica, riabilita la carica
}
}
}
Alcuni miei post passati che parlavano di LED Driver, hanno generato un po’ di confusione in qualcuno… Volevo quindi fare un po’ di chiarezza.
In particolare in un commento mi è stato chiesto se tali driver andavano bene per pilotare delle LED Strip.
La risposta è ovviamente: ASSOLUTAMENTE NO!
Non c’entra niente. Le LED Strip dobbiamo considerarle come se fossero delle lampadine o dei motori a 12V: non necessitano di particolari driver per essere pilotate, ma vanno semplicemente alimentate con una tensione adeguata (normalmente appunto 12V).
Questo perchè le LED strip non sono dei semplici LED, ma contengono al loro interno un circuito di led serie-parallelo dotato di resistenze adeguate, e viene quindi gestito come un normale utizzatore a 12V.
Diverso è il caso del LED singolo, che non ha un voltaggio vero e proprio di funzionamento, ma ha bisogno di una corrente fissa e costante per poter funzionare.
Il circuito corretto per pilotare un LED strip con Arduino è quindi il seguente:
Dove VCC rappresenta ovviamente un’uscita di Arduino (digitale o analogica) e X1 rappresenta la mia LED strip (o motore o qualsiasi altra utlizzatore in 12V).
Q1 è un TIP120, ma qualsiasi transistor NPN o darlington NPN va bene, purchè sia adeguato alla potenza del carico.
Spero che questo articolo possa aver fatto un po’ di chiarezza.
A presto!
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 