Breathing led non bloccante

Pubblicato da Luca Soltoggio in 12 Mag 2015
Pubblicato in: Arduino. Tag: , , . 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!!! 🙂

Annunci

Ultra Low Power Led Flasher (con ATtiny)

Pubblicato da Luca Soltoggio in 6 gennaio 2014
Pubblicato in: Circuiti. Tag: , , . 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!!!

Arduino Yún: benvenuto futuro!

Pubblicato da Luca Soltoggio in 25 ottobre 2013
Pubblicato in: Arduino. Tag: , , , , , , , , . 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!

Semplicissimo interrutore crepuscolare

Pubblicato da Luca Soltoggio in 4 settembre 2013
Pubblicato in: Circuiti. Tag: , , . 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!

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

Pubblicato da Luca Soltoggio in 5 Mag 2013
Pubblicato in: Arduino. Tag: , , , , . 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!!!

Actarus: Pallone sonda Open Source con Arduino e Android.

Pubblicato da Luca Soltoggio in 11 aprile 2013
Pubblicato in: Progetti Arduino. Tag: , , . 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!!!

Arduino Due: Prime impressioni e novità introdotte

Pubblicato da Luca Soltoggio in 5 novembre 2012
Pubblicato in: Arduino. Tag: , , , , . 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!