Elettronica & Arduino

Consigli, trucchi, soluzioni, schemi e codici per il mondo dell'elettronica e di Arduino

  • Blog
  • Rgb Lamp
  • ACTARUS
  • ArduDome
  • English Version

Breathing led non bloccante

Pubblicato da Luca Soltoggio in 12 Maggio 2015
Pubblicato in: Arduino. Tag: arduino, led, pwm. 6 commenti

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;
  }
}

Buon divertimento!!! 🙂

Vota:

Ultra Low Power Led Flasher (con ATtiny)

Pubblicato da Luca Soltoggio in 6 gennaio 2014
Pubblicato in: Circuiti. Tag: attiny, avr, led. 2 commenti

Di progetti per Led Flasher su internet ce ne sono tanti, alcuni anche con consumi modesti, ma quello di cui avevo bisogno io era un lampeggiatore a led, da usare per il geocaching, che fosse estremamente piccolo e che potesse durare almeno un’anno con una batteria a bottone.
Ho cominciato a fare quindi un po’ di esperimenti con l’Attiny85 in sleep mode basandomi sul codice di insidegadgets, riuscendo ad ottenere un consumo di circa 4.5uA in standby, e di circa 3mA durante il lampeggio che avviene ogni circa 4 secondi e dura per circa 30ms.
In questo modo il consumo medio si aggira intorno ai 25uA, che con una batteria a bottone CR2032 da circa 220mAh, significa circa un anno di durata!!!
Dopo una prima stesura del progetto, ho pensato che potesse essere utile anche una versione a 12V in modo da poter essere utilizzare anche alimentato dalla batteria di una automobile.
Qui potete vedere il circuito relativo alla prima versione, ovvero quella alimentabile dai 3V della batteria a bottone:

led_flasher_circuit

Lo schema è veramente molto semplice in quanto il lavoro vero e proprio lo fa il codice:

/*

Ultra Low Power Led Flasher
with AtTiny85 @ 1Mhz
by Luca Soltoggio
06/01/2014

http://www.arduinoelettronica.com

*/

#include <avr/sleep.h>
#include <avr/wdt.h>

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

int pinLed = 4;
volatile boolean f_wdt = 1;

void setup(){
pinMode(pinLed,OUTPUT);
setup_watchdog(8); // approximately 4 seconds sleep
}

void loop(){
if (f_wdt==1) {  // wait for timed out watchdog / flag is set when a watchdog timeout occurs
f_wdt=0;       // reset flag

digitalWrite(pinLed,HIGH);  // let led blink
delay(30);
digitalWrite(pinLed,LOW);

pinMode(pinLed,INPUT); // set all used port to intput to save power
system_sleep();
pinMode(pinLed,OUTPUT); // set all ports into state before sleep
}
}

// set system into the sleep state
// system wakes up when wtchdog is timed out
void system_sleep() {
cbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter OFF

set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
sleep_enable();

sleep_mode();                        // System sleeps here

sleep_disable();                     // System continues execution here when watchdog timed out
sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}

// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {

byte bb;
int ww;
if (ii > 9 ) ii=9;
bb=ii & 7;
if (ii > 7) bb|= (1<<5);
bb|= (1<<WDCE);
ww=bb;

MCUSR &= ~(1<<WDRF);
// start timed sequence
WDTCR |= (1<<WDCE) | (1<<WDE);
// set new watchdog timeout value
WDTCR = bb;
WDTCR |= _BV(WDIE);
}

// Watchdog Interrupt Service / is executed when watchdog timed out
ISR(WDT_vect) {
f_wdt=1;  // set global flag
}

Il progetto completo, nella versione doppio uso 3V/12V lo trovate pubblicato su fritzing al seguente indirizzo:
http://fritzing.org/projects/ultra-low-power-led-flasher-with-attiny

Alla prossima!!!

Vota:

Arduino Yún: benvenuto futuro!

Pubblicato da Luca Soltoggio in 25 ottobre 2013
Pubblicato in: Arduino. Tag: arduino, comunicazione, domotica, ethernet, linux embedded, raspberry pi, robotics, seriale, wifi. 2 commenti

Il titolo non poteva essere più azzeccato: Arduino Yún è infatti il capostipite di una serie di prodotti che sta già rivoluzionando il mondo dei Makers.
Non voglio esaminare in questa sede le caratteristiche tecniche (che sono già state ampiamente discusse in vari blog e che sono riassunte sul sito ufficiale), ma vorrei invece analizzare il modo di funzionamento di questa piattaforma, nonché evidenziare quelli che possono essere i possibili sviluppi.

arduino-yun

Il presupposto di partenza, è che l’ambiente Arduino, ha avuto una diffusione esponenziale dalla sua nascita, diventando uno standard di fatto e alimentando in un circolo virtuoso, il movimento mondiale dei Makers.
Da Arduino sono scaturiti infatti centinaia di progetti, di board simili, di idee nuove, tanto che ad oggi sono veramente poche le innovazioni tecnologiche che non hanno a che fare con questa board (basti pensare all’avvento delle stampanti 3D).

Ad Arduino mancava però ancora una cosa, di importanza sempre più fondamentale per poter partecipare all’Internet dell Cose: la capacità di scambiare ed elaborare metadati complessi con il resto del mondo (utilizzando ad esempio il web semantico).
A questa carenza il mondo degli artigiani digitali ha cercato di porre rimedio con soluzioni più o meno riuscite basate solitamente sull’unione di Arduino con sistemi linux embedded, come il Raspberry Pi, che sono molto web-oriented e predisposti all’elaborazione dati, ma che mancano di connessioni fisiche con il mondo reale (nel mio piccolo, ho fatto anche io qualche tentativo: vedi Ardudome).

I creatori di Arduino hanno reagito a questa esigenza sempre più impellente con un prodotto veramente unico: Arduino Yún.
La sua unicità è dovuta a diverse novità:
– la capacità di unire in un unica board, entrambe le cose, un linux embedded a basso consumo e un Arduino Leonardo
– il Wifi onboard che permette di connettersi alla rete e che rende possibile il caricamento degli sketch senza fili
– l’interazione con le più svariate API possibili (Google, Youtube, Twitter, ecc.)
– il sistema linux on board basato su OpenWrt, leggero e allo stesso tempo potente
– interfaccia web e REST API che permettono direttamente la comunicazione tra le pagine web ed Arduino
– il form factor compatibile con le precedenti board Arduino

Ma la novità che secondo me sopra ogni altra cosa è il fulcro di tutto il funzionamento, è la libreria Bridge, ovvero il software che permette a questi due mondi di comunicare l’uno con l’altro in maniera semplice e veloce.
Come primo impatto, leggendo i vari esempi, sembrava tutto abbastanza incomprensibile, ma utilizzando e sperimentando la libreria, ci si rende subito conto dell’enorme potenzialità e della genialità di questo prodotto: la connessione tra le due anime dello Yún avviene tramite una comunicazione seriale che permette in maniera diretta lo scambio di dati in maniera bidirezionale utilizzando delle semplici funzioni dedicate. E’ possibile perciò ad esempio accedere direttamente dal lato linux ai dati dei sensori di Arduino o viceversa dal microcontrollore accedere direttamente all’output di un comando linux.
Questa modalità di comunicazione semplifica il tutto e amplia in maniera incredibile le potenzialità delle vecchie board Arduino, ma anche quelle di una “banale” board linux embedded.

Possiamo ad esempio in maniera molto semplice accendere un led quando ci arriva un email, piuttosto che monitorare il consumo elettrico della nostra casa e salvare i dati su un documento Google Spreadsheet, oppure ancora costruire una sveglia che in base alle condizioni del traffico cercate su internet decida se è ancora presto o troppo tardi per svegliarci.

I risvolti pratici di questa tecnologia sono veramente avvenieristici e infiniti e c’è da immaginare che tale libreria sarà il motore della prossima rivoluzione arduiniana: Arduino Tre, che promette prestazioni da urlo rispetto ad Arduino Yún, soprattutto per quanto riguarda il lato Linux. Avrà infatti una potenza maggiore, un’uscita HDMI e sarà basato sul sistema Beagleboard.

In questi  giorni sto finendo di preparare il mio primo progetto che verrà pubblicato non appena sarà ultimato.

Arduino Yún: benvenuto futuro!

Vota:

Semplicissimo interrutore crepuscolare

Pubblicato da Luca Soltoggio in 4 settembre 2013
Pubblicato in: Circuiti. Tag: fotoresistenza, mosfet, sensore. 2 commenti

Ciao a tutti,
in questi giorni avevo l’esigenza di un interrutore crepuscolare che fosse completamente elettronico (leggi senza relè) e con pochissimi componenti.
Ho inizialmente optato per una soluzione a singolo transistor, ma purtroppo c’erano due svantaggi: il cambio di stato non era netto bensì molto graduale e il transistor generava un leggero dropout che diminuiva drasticamente la luminosità della Led Strip.
A questo punto ho pensato di optare per un mosfet N; in questo modo il cambio di stato era un po’ più netto e soprattutto il il dropout indotto era nell’ordine di qualche mV.
Lo schema adottato alla fine è il seguente:

Immagine

Il funzionamento è molto semplice: la fotoresistenza adottata ha un valore di circa 100kΩ al buio e quando questa si illumina, la resistenza diminuisce ed il partitore di tensione tra R1 e R2, fa si che il gate di Q1 si porti sotto il livello di soglia (tra i 2V e i 4V) spegnendo la Led Strip. Con R1 ovviamente regolo la sensibilità mentre e invertendo R1 ed R2, inverto il funzionamento (si accende con la luce, si spegne con il buio).
A presto!

Vota:

ArduDome: Domotica Opensource con Arduino + RaspberryPI + PHP + JSON + jQuery

Pubblicato da Luca Soltoggio in 5 Maggio 2013
Pubblicato in: Arduino. Tag: arduino, domotica, ethernet, raspberry pi, seriale. 122 commenti

Sottotitolo: Controllo e gestione remota bidirezionale basata su Arduino
Multipiattaforma, multibrowser e opensource (ottimizzata per smartphone)

ardudome_interface

Eccomi con il progetto forse più interessante fin’ora presentato.
Cercavo su internet un sistema per controllare Arduino via web, il tutto però doveva essere estrememanete flessibile, semplice, adattabile ad uno smartphone ma soprattutto doveva avere una comunicazione bidirezionale e un refresh automatico. Non ho trovato nulla che avesse tutte queste caratteristiche messe insieme, ecco perchè ho deciso di realizzare questo progetto.
La maggior parte dei progetti simili, hanno a mio avviso delle caratteristiche incomplete: quelli specifici per domotica solitamente hanno un’applicazione da scaricare e quindi non sono multipiattaforma, quelli basati via web o hanno un interfaccia graficamente scarsa oppure richiedono il refresh della pagina per aggiornare lo stato delle uscite, oppure ancora hanno la possibilità di leggere sensori, ma non di modificare le uscite…
L’esigenza che avevo io in particolare era che se modificavo lo stato di un uscita non da remoto, ma localmente (tramite un pulsante per esempio), l’interfaccia doveva presentarmi quasi in tempo reale tale modifica esattamente sul tasto di accensione o spegnimento dell’ interfaccia senza dover “refreshare” nulla.
Per fare ciò avevo l’esigenza di utilizzare un’interfaccia web un po’ più complessa di quella gestibile dall’ethernet shield di Arduino, ho quindi optato per utilizzare il Raspberry Pi lato web (ma può essere utilizzato qualsiasi PC con Linux, o con qualche modifica anche Windows), collegato via USB (quindi seriale) con Arduino.
In questo modo ho potuto implementare alcune tecnologie, in particolar modo PHP e jQuery, che mi hanno permesso di realizzare il tutto.
Il funzionamento finale è quindi molto semplice:
L’interfaccia visibile nella foto sopra è una semplice pagina web (ottimizzata come si vede per smartphone). Cliccando sullo slide abilito o disabilito un’uscita (che viene azionata in tempo reale) ed ogni 5 secondi ho il refresh automatico delle uscite e anche degli ingressi anlalogici (nell’esempio sopra ho abilitato solo quattro uscite ed un ingresso).
L’interfaccia completa contiene le 13 uscite di Arduino (escluse la 0 e la 1 che servono per la comunicazione seriale), e i 6 ingressi analogici.
Il collegamento e la configurazione sono semplicissimi: Il Raspberry Pi o il nostro PC va collegato via USB alla board Arduino sulla quale avremo caricato lo sketch, dopodichè caricheremo l’interfaccia e gli script sul Raspberry Pi et voilà, il gioco è fatto.
NOTA IMPORTANTE: Affinchè il tutto funzioni, dobbiamo disabilitare l’autoreset di Arduino. Questo può essere fatto collegando un condensatore da 10uF tra RESET e GND. Se non si fa questo la comunicazione seriale non funzionerà correttamente!

Ma vediamo ora il principio di funzionamento:
Lo sketch di Arduino si preoccupa principalmente di ricevere un comando via seriale. Tale comando deve essere di 7 caratteri, cominciare con *CMD e terminare con /.
Tra “*CMD” e “/”, va inserito il numero del pin seguito dall’azione:
V = value (read) – legge il valore dell’input analogico
S = status (read) – legge lo stato dell’uscita digitale
H = high (write) – porta il PIN digitale su “ON”
L = low (write) – porta il PIN digitale su “OFF”
T = toggle (write) – inverte il PIN digitale
Ovviamente tale sketch pur essendo nato per funzionare con il suo script PHP associato, può essere utilizzato per altre applicazioni.

Lo script PHP invece si occupa di fare da ponte tra l’interfaccia web e Arduino tramite seriale (USB).
Se lanciato senza parametri, restituisce una stringa JSON con lo stato delle uscite digitali e i valori delle porte analogiche.
Per esempio:
{“02″:0,”03″:0,”04″:0,”05″:0,”06″:0,”07″:0,”08″:0,”09″:0,”10″:0,”11″:0,”12″:0,”13″:0,”14″:756,”15″:745,”16″:722,”17″:679,”18″:634,”19”:494}
Se lanciato con il metodo GET, usa due parametri: “pin” (da P02 a P013) e “cmd” (0 oppure 1).
Esempio: http://raspberrypi/ardudome.php?pin=P13&cmd=1, manderà il comando *CMD13H/ ad Arduino, che porterà il PIN13 su HIGH.
Anche qui, pur essando nato per funzionare con la sua interfaccia web, può essere adattato ad altre applicazioni.

L’interfaccia web infine, basata su HTML, jQuery ed AJAX, non fa altro che chiamare ogni 5 secondi lo script PHP e aggiornare la pagine HTML con i valori corretti presi da Arduino. Se uno slider viene clickato, cambiando il suo valore, lo script chiamerà immediatamente lo script PHP passandogli il parametro del PIN da modificare e il VALORE da settare.
Come si può vedere il tutto è semplice ed intuitivo.

Veniamo ora alla fine alla modalità di installazione:

1 – Scaricare tutti i file da github (https://github.com/toggio/ardudome/)
2 – Caricare lo sketch ArduDome.ino sulla board Arduino UNO
3 – Inserire un condensatore da 10uF tra GND e RESET
4 – Connettere Arduino tramite la porta USB al Raspberry PI (o qualsiasi altro PC Linux) con apache e php preinstallato
5 – Caricare tutti i files (eccetto Ardudome.ino e functions.ino) nella directory www (normalmente /var/www)
6 – Verificare il nome della porta USB (normalmente /dev/ttyACM0) e modificarla nel file ardudome.php ($serial->deviceSet(“/dev/ttyACM0”);)
7 – Dare a www-data il permesso per usare la seriale (usermod -a -G dialout www-data)
8 – Verificare la connessione (lanciando il file ardudome.php)
9 – Aprire il browser dello smartphone o del PC su http://yourraspberryip/ardudome.html

Buon divertimento e ci vediamo al prossimo progetto!!!

Vota:

Actarus: Pallone sonda Open Source con Arduino e Android.

Pubblicato da Luca Soltoggio in 11 aprile 2013
Pubblicato in: Progetti Arduino. Tag: actarus, arduino, stratosfera. 3 commenti

actarus_500

In questi ultimi mesi sono stato occupato in un progetto che sto portando avanti con alcuni amici: lanciare un pallone sonda nella stratosfera (a oltre 38km di altutudine).
Sebbene non sia un progetto nuovo a livello mondiale, e nemmeno in italia (vedi il progetto Stratospera), crediamo vi sia una novità rispetto ad altri progetti simili.
In primo luogo il progetto è interamente Open Source, sia per quanto riguarda l’hardware che per quanto riguarda il software: ogni aspetto che man mano verrà fuori, sarà pubblicato sul sito ufficiale.
In secondo luogo, il “computer di bordo”, è realizzato interamente con Arduino, che si occuperà quindi della gestione della posizione, dei dati meteorologici, del datalogging, di una parte di comunicazione, e della gestione del “cut-off” di emergenza. Android si occuperà prevalentemente invece della gestione della posizione e dell’invio tramite rete cellulare dei dati in tempo reale (ovviamente quando sarà sotto copertura di rete, cioè realisticamente fino a 5-6km di altitudine).
Come terza novità c’è in previsione, non dal primo lancio ovviamente, la possibilità di recuperare il payload (contenente tutta l’attrezzatura elettronica), tramite un drone aliante, che dovrebbe autonomamente riportare il tutto al punto di lancio…
Dal punto di vista dello studio di fattibilità abbiamo finito, stiamo elaborando in questo momento il software per Arduino, e stiamo procedendo alla richiesta delle varie autorizzazioni, nonchè ad una raccolta fondi per le varie spese…

Se vuoi ulteriori informazioni, puoi andare sul nostro sito ufficiale italiano:
https://actarusprojectitalia.wordpress.com/
Oppure in inglese:
http://actarusproject.wordpress.com/
Questo invece il sito per la raccolta fondi su IndieGogo:
http://igg.me/at/actarus

Siamo alla ricerca anche di persone che vogliano contribuire al progetto, non solo economicamente ma anche umanamente al progetto.
Inoltre se qualche azienda volesse sponsorizzarci con del materiale che può servire al progetto, saremo ben lieti.
Vi terrò aggiornati!!!

Vota:

Arduino Due: Prime impressioni e novità introdotte

Pubblicato da Luca Soltoggio in 5 novembre 2012
Pubblicato in: Arduino. Tag: arduino, arm, atmel, power led, usb. Lascia un commento

Dopo mesi di attesa, la tanto annunciata Arduino Due è finalmente disponibile 🙂

Non ho ancora avuto modo di averla tra le mani, ma prendendo spunto qua e la ed in particolare dal sito ufficiale, volevo con questo articolo evidenziare le principali novità di questa sistema rispetto al suo predecessore Arduino UNO.
Beh, che dire!
Sulla carta effettivamente le novità sono tante e tutte partono dal nuovo microcontrollore Atmel SAM3X8E con CPU Cortex M3 e architettura ARM a 32bit che va a sostituire il vecchio AVR a 8bit:
1 – velocità di clock di 84Mhz (rispetto ai 16Mhz della versione precedente)
2 – 96Kb di RAM (contro i 2Kb di  Arduino UNO)
3 – 512Kb di Flash (la UNO ne aveva 32Kb)
4 – PWM e ingressi analogici a 12bit (contro gli 8 precedenti)
5 – Uscite DAC – Novità assoluta per Arduino
6 – Maggior numero di PIN
7 – Host USB

Tutto questo significa una velocità di elaborazione estremamente maggiore, una precisione decisamente migliorata e nuove possibilità grazie al DAC e all’host USB.

Le performance sono legate soprattutto alla velocità di clock unita ai 32bit (oltre che ovviamente alla maggiore quantità di RAM).
Con 32bit siamo in grado di eseguire un’operazione di 4byte (8 x 4 = 32) con una singola CPU clock. Questo significa in maniera empirica, che Arduino DUE potrebbe eseguire le operazioni circa 20 volte più veloce rispetto ad Arduino UNO.

La maggior precisione risiede nel fatto che avendo gli ingressi analogici e le uscite PWM a 12bit, abbiamo una risoluzione moltiplicate per 16, cioè abbiamo 4096 livelli di conversione analogico-digitale e viceversa rispetto ai 256 della versione precedente. Questo permette una densità maggiore di dati in ingresso e un maggiore controllo sui PWM in uscita.

Le nuove funzionalità riguardano invece soprattutto i pin DAC (uscite realmente analogiche, cioè lineari da 0 a 3,3V) che permettono ad esempio di eseguire un file Mp3 e sentirlo sulle casse collegate a queste uscite.

Uniche note negative a mio avviso (bisogna essere proprio pignoli però!!!), sono la mancanza di una porta ethernet – oggi indispensabile in qualuque applicazione, e il fatto che la logica TTL è a 3,3V e non compatibile con i 5V, pena la frittura del pin o del microcontrollore stesso. Questo porta ad una incompleta compatibilità con le shield esistenti o con hardware di terze parti.

Per quanto riguarda i consumi teoricamente dovrebbero essere simili all’Arduino Mega anche se non ho trovato nulla di preciso al riguardo.

La programmazione invece avviene sempre tramite il nostro Arduino IDE, aggiornato alla versione 1.5 per l’occasione, che contiene le librerie aggiuntive per la gestione delle nuove capacità della board. La modalità di programmazione è molto simile alla vecchie procedura.

Ovviamente abbiamo parlato in questo articolo di una versione uscita da pochissimi giorni e ancora in fase di testing. Il tempo ci dirà se questa scheda andrà completamente a sostituire le vecchie Arduino, o se ci sarà un mercato parallelo che si modulerà a seconda dell’applicazione finale. Certamente i progressi fatti, portano un’ulteriore innovazione in questo campo, tali da far pensare che ormai il prodotto Arduino possa sconfinare ulteriormente dal mondo degli “smanettoni casalinghi” a quello dell’elettronica professionale.
Certamente un prodotto come Arduino DUE, in termini di prestazioni e precisione è un prodotto che ben si presta per applicazioni che vanno oltre lo svago domestico, ad un prezzo estremamente competivo (dimenticavo: prezzo ufficiale Arduino Store: 39 Euro).
Dall’altro lato, questa piattaforma, permetterà con più difficoltà (o non permetterà del tutto) la creazioni di progetti embedded simili a quelli realizzabili con Attiny85 a Atmega328 standalone, ma si potrà ovviamente continuare a utilizzare i vecchi AVR: come dicevo prima a secondo dell’applicazione finale, si troverà la soluzione più adatta.

Chi vivrà, vedrà… Ci vediamo al prossimo post!

Vota:

Semplicissimo Sensore di Livello / Pioggia / Allagamenti / Touch / Altro a singolo transistor – CORRETTO 03/10/2012

Pubblicato da Luca Soltoggio in 31 Maggio 2012
Pubblicato in: Circuiti. Tag: led, sensore, transistor. 34 commenti

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.

Vota:

Caricabatterie intelligente NiMh con Attiny85 (e Arduino) – Smart NiMh battery charger

Pubblicato da Luca Soltoggio in 20 aprile 2012
Pubblicato in: Arduino, Progetti Arduino. Tag: arduino, attiny, fritzing, led, nimh, transistor, TTL. 68 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
    }
  }

}

Il codice è abbastanza semplice ed autoesplicativo.
Per la versione con i commenti in inglese – For commented English version, take a loke at:
http://fritzing.org/projects/smart-nimh-battery-power-charger-with-attiny85/

Concludo con qualche foto del progetto finito:

Trovi il mio progetto anche su Fritzing:
http://fritzing.org/projects/smart-nimh-battery-power-charger-with-attiny85/
Alla prossima!

Vota:

Pilotare una LED Strip con Arduino (anche in PWM)

Pubblicato da Luca Soltoggio in 11 aprile 2012
Pubblicato in: Arduino, Circuiti. Tag: arduino, led, transistor. 12 commenti

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!

Vota:

Navigazione articoli

← Voci più vecchie
  • Articoli recenti

    • Breathing led non bloccante
    • Ultra Low Power Led Flasher (con ATtiny)
    • Arduino Yún: benvenuto futuro!
    • Semplicissimo interrutore crepuscolare
    • ArduDome: Domotica Opensource con Arduino + RaspberryPI + PHP + JSON + jQuery
  • Archivi

    • Maggio 2015
    • gennaio 2014
    • ottobre 2013
    • settembre 2013
    • Maggio 2013
    • aprile 2013
    • novembre 2012
    • Maggio 2012
    • aprile 2012
    • marzo 2012
    • febbraio 2012
  • Categorie

    • Arduino
    • Circuiti
    • Progetti Arduino
    • Programmazione Arduino
    • Senza categoria
  • Tag

    actarus arduino arm atmega atmega328 atmel attiny avr bootloader breadboard comunicazione corrente costante domotica ethernet firmware fotoresistenza fritzing hardware IDE led linux embedded lm317 logica microbots mini pro mosfet ne555 nimh power led programmatore pwm raspberry pi RGB robot robotics sensore seriale sketch software standalone stratosfera transistor TTL usb wifi
  • Meta

    • Registrati
    • Accedi
    • Flusso di pubblicazione
    • Feed dei commenti
    • WordPress.com
  • Amici

    • Actarus Project
    • Il Portale di Tirano
    • MINImal raspBIAN RPi Image
    • My Ip Address
    • Parole Al Vento
    • Profilio Google+
Blog su WordPress.com.
Elettronica & Arduino
Crea un sito o un blog gratuito su WordPress.com.
  • Segui Siti che segui
    • Elettronica & Arduino
    • Segui assieme ad altri 79 follower
    • Hai già un account WordPress.com? Accedi ora.
    • Elettronica & Arduino
    • Personalizza
    • Segui Siti che segui
    • Registrati
    • Accedi
    • Segnala questo contenuto
    • Visualizza il sito nel Reader
    • Gestisci gli abbonamenti
    • Riduci la barra
 

Caricamento commenti...
 

  • Privacy e cookie: Questo sito utilizza cookie. Continuando a utilizzare questo sito web, si accetta l’utilizzo dei cookie.
    Per ulteriori informazioni, anche sul controllo dei cookie, leggi qui: Our Cookie Policy