avr

Tutti gli articoli con tag avr

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!!!

Programmare l’Attiny85 (o Attiny45, Attiny84, Attiny25, Attiny2313) con Arduino

Pubblicato da Luca Soltoggio in 19 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , , , . 10 commenti

Eccoci dunque a questo tanto atteso post.
In questo articolo vedremo come programmare alcuni Atmel della famiglia Attiny, in particolare quelli evidenziati nel titolo, utlizzando le librerie Arduino e Arduino Uno come ISP. Ovviamente il tutto può essere fatto anche utilizzando un programmatore dedicato, ma qui non mi soffermo su questo argomento più di tanto in quanto le differenze sono minime.
Partiamo da una premessa: sull’Attiny non andiamo a caricare il bootloader, ma procediamo ad un caricamento degli sketch direttamente nella memoria del microcontrollore. Quindi questa è una prima differenza rispetto agli Atmega328. Esistono forse cercando qua e là alcuni bootlaoder anche per Attiny, ma non ha molto senso montarli per diversi motivi. Il primo è l’esigua memoria che hanno questi microcontrollori (8kb per l’Attiny85 rispetto ai 32kb dell’Atmega328). In secondo luogo la maggior parte degli Attiny non hanno la seriale hardware, quindi non avrebbe senso montare un bootloader se poi non ci serve a fare l’upload via seriale.
Vediamo ora i vantaggi dell’Attiny85 rispetto all’Atmega328:
1 – minore consumo elettrico (quindi adatto per progetti a batteria)
2 – minore dimensione (l’Atmega328 ha 28 piedini, mentre l’Attiny85 ne ha solo 8)
3 – minor costo
Ovviamente presenta lo svantaggio che avendo meno piedini abbiamo un numero limitato di I/O rispetto ai fratelli maggiori.
Per quanto riguarda la programmazione è molto simile a quella vista nel post precedente e in quello prima ancora.
Vediamo innanzitutto la piedinatura dell’Attiny85 che useremo come esempio in questo articolo:

Mentre dal punti di vista di Arduino:

                             +-\/-+
    Ain0       (D  5)  PB5  1|    |8   VCC
    Ain3       (D  3)  PB3  2|    |7   PB2  (D  2)  INT0  Ain1
    Ain2       (D  4)  PB4  3|    |6   PB1  (D  1)        pwm1
                       GND  4|    |5   PB0  (D  0)        pwm0
                             +----+

Quindi se voglio usare il PIN6 come uscita digitale userò pinMode(1,output) e se volessi leggere l’ingresso analogico dal PIN3 userò analogRead(A2).
Ovviamente anche qui come in arduino possiamo usare gli ingressi analogici come uscite digitali.
La seriale hardware non esiste come dicevamo, ma possiamo utlizzare il PIN2 (PB3) come seriale software monodirezionale. Praticamente usando i comandi standard di arduino tipo Serial.begin(9600), sul PIN2 abbiamo il segnale di TX, collegabile all’RX di un convertitore USB-SERIALE per comunicare dall’Attiny verso il PC, quindi è come se avessimo una “seriale in sola lettura”.
Ma veniamo alla pratica: rispetto alla programmazione dell’Atmega328, la programmazione dell’Attiny richiede la modifica e/o l’aggiunta di alcune librerie all’IDE.
Consiglio di usare la versione 0023 dell’IDE, scaricabile dal sito di Arduino (con altre versioni non sono riuscito), e di creare una cartella apposita separata da usare unicamente per la programmazione degli Attiny.
Quindi se abbiamo già Arduino (ad esempio sotto la cartella c:\Arduino), andremo a creare una nuova cartella che chiameremo ad esempio c:\Arduino-Tiny.
Fatto questo dobbiamo andare a scaricare il core arduino-tiny-0022-0009.zip, che trovate qui, poi dobbiamo scaricare la libreria PinChangeInterrupt-0001.zip che troviamo qui e infine la libreria TinyTuner-0003.zip che trovate qui. Il primo files lo scompattate così com’è dentro la cartella hardware (es.: c:\Arduino-Tiny\hardware). Vi chiederà di sovrascrivere alcuni files. Ditegli di si senza problemi. Le altre due librerie le scompattate sotto la cartella libraries (es.: c:\Arduino-Tiny\libraries). A questo punto dovrebbe essere tutto apposto. Potete eseguire l’upload dei vostri esempi usando il seguente schema:

Praticamente è come per l’Atmega328. Il pin 10 va collegato al RESET, e i pin 11, 12, 13 ai pin MOSI, MISO, SCK (cioè in questo caso 5, 6, 7), più ovviamente l’alimentazione.
Ricordatevi come sempre di inserire il condensatore da 22uF tra GND e RESET dell’Arduino UNO altrimenti la board si resetterà e l’upload non funzionarà generando un errore di sincronizzazione!!!
A questo punto aprendo dil nostro IDE, e aprendo uno sketch di esempio possiamo selezionando Tools –> Boards –> Attiny85 @1Mhz e poi File –> Upload to I/O Board.
Vi darà un errore di tipo “PAGEL”, ma si può ignorare. Vedrete il messaggio “Done Uploading” che vi avviserà che tutto è andato a buon fine.
Come vedete è molto semplice.
Gli Attiny escono di fabbrica con i fuse impostati in maniera tale che il microcontrollore utilizzi l’oscillatore interno a 1Mhz. E’ l’opzione migliore per la maggior parte dei progetti, ma se aveste bisogno di una velocità maggiore si può programmare l’Attiny in maniera tale che utilizzi il proprio oscillatore interno a 8Mhz oppure utlizzando un oscillatore esterno a 16Mhz (vedi post precedenti). Se vogliamo cambiare velocità al nostro Attiny, utlizzando as esempio l’oscillatore interno a 8Mhz, dobbiamo settare i fuse, facendo un’upload di un bootloader vuoto, contenente solo i settaggi che ci interessano. Per fare ciò è sufficiente selezionare da Tools –> Boards il settaggio che ci interessa (ad esempio Attiny85 @ 8Mhz), e poi Tools –> Burn bootloader —> w/Arduino as ISP.
A questo punto probabilmente vi darà il seguente errore:

avr_read(): error reading address 0x0000
read operation not supported for memory "lock"
avrdude: failed to read all of lock memory, rc=-2

Errore dovuto al fatto che manca nel file c:\Arduino-Tiny\hardware\tools\avr\etc\avrdude.conf la riga che riguarda l’operazione memory lock.
Quindi andiamo ad editare tale file e aggiugiamo la seguente riga:

read            = "0 1 0 1  1 0 0 0  0 0 0 0  0 0 0 0",
                  "0 0 0 0  0 0 0 0  o o o o  o o o o";

Nella sezione dell’Attiny85 sotto la riga memory “lock” che dovrebbe apparire così dopo la modifica:

#   ATtiny85 has Signature Bytes: 0x1E 0x93 0x08.
     memory "signature"
         size            = 3;
         read            = "0  0  1  1   0  0  0  0   0  0  0  x   x  x  x  x",
                           "x  x  x  x   x  x a1 a0   o  o  o  o   o  o  o  o";
       ;
     memory "lock"
         size            = 1;
         write           = "1 0 1 0  1 1 0 0  1 1 1 x  x x x x",
                           "x x x x  x x x x  1 1 i i  i i i i";
         read            = "0 1 0 1  1 0 0 0  0 0 0 0  0 0 0 0",
                           "0 0 0 0  0 0 0 0  o o o o  o o o o";
        min_write_delay = 9000;
        max_write_delay = 9000;
       ;

Ora eseguendo l’operazione di bootloader dovrebbe andare.
Se vogliamo possiamo andare a sistemare anche il problema del messaggio “PAGEL”  aggiungeno le seguenti righe:

     pagel            = 0xB3;
     bs2              = 0xB4;

Sotto la riga chip_erase_delay = 4500; nella sezione relativa all’Attiny85. In questo modo dovrebbe apparire così dopo le modifiche:

#------------------------------------------------------------
# ATtiny85
#------------------------------------------------------------

part
     id            = "t85";
     desc          = "ATtiny85";
     has_debugwire = yes;
     flash_instr   = 0xB4, 0x02, 0x12;
     eeprom_instr  = 0xBB, 0xFF, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
                     0xBC, 0x02, 0xB4, 0x02, 0xBA, 0x0D, 0xBB, 0xBC,
                     0x99, 0xE1, 0xBB, 0xAC;
## no STK500 devcode in XML file, use the ATtiny45 one
     stk500_devcode   = 0x14;
##  avr910_devcode   = ?;
##  Try the AT90S2313 devcode:
     avr910_devcode   = 0x20;
     signature        = 0x1e 0x93 0x0b;
     reset            = io;
     chip_erase_delay = 4500;
     pagel            = 0xB3;
     bs2              = 0xB4;

     pgm_enable       = "1 0 1 0  1 1 0 0    0 1 0 1  0 0 1 1",
                        "x x x x  x x x x    x x x x  x x x x";

In questo modo l’errore è corretto ma solo sull’Attiny85. Per risolvere il problema anche per gli altri microcontroller, qui vi ho dato uno spunto. Fate eventualmente una ricerca su google con l’errore che vi è apparso durante l’upload del bootloader.
Potrebbe verificarsi un’ulteriore errore (non ricordo la dicitura) quando fate l’upload di sketch molto grossi.
In questo caso so che era legato ad un bug dell’avr-gcc, e per risolvero bisogna scaricare il tools Winavr, installarlo, e copiare il contenuto della cartella c:\WinAvr\tools\ in c:\Arduino-Tiny\hardware\tools\ sostituendo tutti i files presenti (eccetto il file avrdude.conf precedentemente modificato).
Questa ultima parte è un po’ più complessa, ma vedrete che se seguirete tutto alla lettera non sarà difficile.
Al prossimo post allora!!!

Caricamento bootloader su Arduino standalone – Arduino UNO ISP

Pubblicato da Luca Soltoggio in 7 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , , , , , . 16 commenti

Nel post precedente abbiamo visto come programmare un Arduino in modalità standalone.
Uno dei requisiti era quello che il bootloader fosse già precaricato.
Ma se avessimo un Atmega328 vergine, oppure volessimo programmare il nostro micro per essere utlizzato senza un oscillatore esterno come dobbiamo fare?
Se abbiamo già un programmatore AVR, la cosa è semplicissima, e non la descrivo qui, anche perchè non tutti possediamo tale accessorio.
Vediamo quindi come usare la nostra Arduino UNO come programmatore ISP.
Si dice che con la UNO non sia possibile ma in realtà con un piccolo escamotage, è possibile bypassare il problema.
Non scoraggiatevi se ci sono problemi di sincronizzazione durante l’upload del bootloader, per ogni problema c’è la soluzione… ma vediamo la procedura.
Per prima cosa consiglio vivamente di utlizzare la versione 0022 dell’IDE di Arduino. Con la versione 1.0 sono riuscito saltuariamente e con difficolta.
Consiglio quindi di tenere le due installazioni del software installate. In una cartella la 1.0 e in un’altra la 0022. Possono coesistere entrambe senza darsi fastidio più di tanto l’una con l’altra.
Apriamo quindi l’IDE 0022 a carichiamo dai file di esempio lo sketch ArduinoISP. Questo esempio permette di trasformare la nostra board in un programmatore AVR. Una volta che l’upload è stato eseguito possiamo collegare la nostra UNO secondo il seguente schema:

Dobbiamo quindi collegare come in figura il pin 10 della UNO al pin RESET dell’Atmega, e i pin 11, 12, 13 ai pin 17, 18, 19 del microcontroller (o ai pin 11, 12, 13 di un’altra board Arduino).
Nello schema non è segnato, ma prima di procedere oltre dobbiamo assolutamente collegare un condensatore da 22uF tra il GND e il RESET della board Arduino altrimenti durante l’upload avverrà l’autoreset e l’IDE darà un errore di sync in fase di upload.
A questo punto possiamo tranquillamente selezionare dal menu Tools –> Board –> Arduino Duemilanove or Nano w/ ATmega328 e lanciare Burn Bootloader –> w/ Arduino as ISP e se tutto è stato eseguito correttamente dovremmo avere il nostro bootloader caricato sul microcontroller, pronto per essere programmato tramite seriale come indicato nel post precedente. La nostra Arduino UNO possiamo invece riprogrammarla normalmente (ricordiamoci di togliere il conensatore inserito precedentemente).
Ovviamente possiamo caricare il bootloader non solo su un Arduino standalone o su breadboard, ma anche su un’altra scheda Arduino UNO, 2009, Mini, ecc.
Se invece volessimo programmare la board con una configurazione minmale, senza oscillatore esterno?
La procedura è leggermente diversa perchè nelle Board predefinite dell’IDE non c’è una configurazione di questo tipo.
Va aggiunta manualmente quindi nel file boards.txt che si trova nella cartella di arduino (sotto hardware\arduino) la seguente configurazione:

##############################################################

atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino

##############################################################

A questo punto avremo uno schema tipo il seguente:

Ricordiamoci sempre di inserire il condensatore da 22uF tra GND e RESET, e verifichiamo che lo sketch ArduinoISP sia caricato sulla nostra board.
A questo punto possiamo caricare il bootloader selezionando Tools –> Board –> ATmega328 on a breadboard (8 MHz internal clock)
Se tutto va bene, dovremmo avere il nostro Atmega328 con il bootloader Arduino caricato e funzionante a 8Mhz. In questa modalità potremo alimentare il nostro circuito definitivo con 3.3V (se vogliamo) permettendo un consumo minore del nostro progetto.
Se l’upload a 16Mhz è andato a buon fine e quello a 8Mhz no, è perchè il primo caricamento di bootloader a 8Mhz va fatto con il circuito configurato ancora con il cristallo esterno, in quanto se togliamo l’oscillatore il circuito non è in grado di comunicare con il programmatore ISP. Successivamento ogni ulteriore caricamento può essere fatto senza il circuito oscillatore.
E qui anticipo una chicca che sarà oggetto del nostro prossimo post. Se io ho finito il mio progetto e quindi non mi serve più utilizzare il bootloader di Arduino (perchè non mi interessa più la possibilità di fare l’upload via seriale – vedi post precedente), posso fare l’upload dello sketch direttamente nella memoria dell’Atmega328 sovrascrivendo il bootloader. E per farlo devo semplicemente utilizzare gli stessi collegamenti visti qui sopra…
Ma per ora ci fermiamo e continueremo a parlarne nel prossimo post.

Arduino e Atmega328: Un po’ di chiarezza

Pubblicato da Luca Soltoggio in 2 febbraio 2012
Pubblicato in: Arduino. Tag: , , , , , , , , , , , , , , , . 16 commenti

Fino a qualche settimana fa, nemmeno io sapevo con precisione qual’era la differenza tra Arduino, ed il suo “core” Atmega328.
Leggevo qua e la che l’Atmega328 può lavorare in stand-alone, con o senza il bootloader di Arduino, e addirittura, nella sua configurazione minimale, senza alcun componente esterno.
Ero confuso quindi su cosa facesse esattamente Arduino e su cosa facesse l’Atmega328 “senza Arduino”, non trovando nemmeno tante informazioni in merito su Internet.
Alla fine, con tanta pazienza, “sbocconcellando” qua e la qualche informazione sui vari blog, leggendo riviste e libri specializzati, e facendo delle prove sul campo, finalmente mi si è accessa la lampadina (o il LED) in testa e tutto mi è apparso più chiaro.
Ho deciso quindi di pubblicare questo post dove spiego brevemente ed in maniera semplice (e probabilmente anche in maniera non del tutto professionale – chiedo quindi scusa se ci sono delle imprecisioni) cos’è Arduino e cosa lo differenzia dall’Atmega328 (che è inserito nelle schede Arduino di ultima generazione).
Se dovessi definire il progetto Arduino, lo definirei una piattaforma Hardware e Software opensource, che permette di sfruttare in maniera più semplice e rapida le potenzialità offerte dal microcontrollore Atmega328.
La parte Hardware, tipicamente è rappresentata dalle schede elencate sul sito ufficiale, con tanto di schemi aperti che ci permettono di realizzare da noi le varie schede Arduino o di modificarle e personalizzarle a nostro piacimento. La parte Software invece è raprresentata dal tanto citato bootloader, dalle librerie (presenti sempre sul sito) e dall’IDE, l’interfaccia che permette di programmare e “debuggare” la nostra scheda Arduino.
Ma quali sono le differenze tra Arduino e il suo microcontrollore Atmega328 e quali vantaggi ci offre Arduino nella programmazione del microcontrollore?
Dal punto di vista Hardware, la scheda di Arduino (prendiamo come esempio Arduino UNO) è pronta all’uso: ha tutto quello che ci serve per programmare il microcontrollore collegando la scheda semplicemente alla porta USB del PC; contiene al suo interno un connettore di alimentazione, una porta usb, un integrato che fa da convertitore USB/Seriale, un LED ci accensione, un LED di controllo collegato al PIN 13, due led di segnalazione TX/RX, le strip header femmina per il collegamento degli ingressi/uscite tramite cavetti per breadboard e ovviamente il nostro microcontrollore Atmega328 con bootloader Arduino già caricato.
In questo modo aprendo l’IDE e selzionando la porta seriale del PC possiamo caricare i nostri sketch con un semplice tasto ed in pochi secondi (tipicamente 2-3). L’upload avviene tramite la porta seriale emulata dall’USB, che va a collegarsi ai PIN TX e RX dell’Atmega (piedini rispettivamente 3 e 2).
Dal punto di vista Software , il bootloader precaricato sull’Atmega (indipendentemente che sia montato su una scheda Arduino o semplicemente su una breadboard), è quello che permette la comunicazione seriale con il nostro PC. Senza il bootloader, per caricare gli sketch (i nostri “programmi”), avremmo bisogno di un programmatore per AVR, più costoso, un po’ più macchinoso da utilizzare e più lento nel caricare gli sketch. Il bootloader è quindi un programma, un firmware potremmo dire, il cui compito è praticamente quello di caricare i nostri sketch compilati all’interno della memoria flash del microcontrollore tramite comunicazione seriale, facendo si che tale programmazione non vada a sovrascrivere la zona di memoria dove è presente il bootloader. Quindi quando facciamo l’upload di uno sketch andiamo a scrivere in una zona di memoria libera e il bootloader non viente toccato e rimane integro.
Il vantaggio rispetto all’Atmega senza bootloader come abbiamo già visto è quello di poter effettuare l’upload tramite una semplice comunicazione seriale, e ad una velocità maggiore rispetto a quello che avremmo caricando direttamente gli sketch tramite programmatore AVR.
L’altra parte che riguarda il software sono le librerie incluse nell’IDE di Arduino. Tali librerie aggiungono svariate funzioni e costanti che permettono di semplificare enormemente il codice che andiamo a scrivere rendendolo molto più fruibile rispetto a quello standard del microcontrollore. Il tutto viene gestito tramite l’IDE, che è l’intefaccia di Arduino con cui noi scriviamo gli sketch, li “uploadiamo” e li “debugghiamo”.
Fatta questa premessa (sperando di non avervi tediato e di essere riuscito a spiegare senza creare ulteriore confusione) nei prossimi post andremo a vedere come fare a costruire un’Arduino stand-alone e come programmare un’Atmega328 senza bootloader, soluzione che a volte può risultare vantaggiosa.