atmel

Tutti gli articoli con tag atmel

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!

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.