atmega328

Tutti gli articoli con tag atmega328

Atmega328 standalone senza il bootloader di Arduino

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

Nel post precedente abbiamo visto come programmare il bootloader di Arduino su un Atmega328 standalone, mentre in un’altro post abbiamo visto come effettuare l’upload degli sketch sul microcontrollere con bootloader Arduino.
In questo post vogliamo invece evidenziare quella che a mio parere è l’obiettivo finale dei progetti prototipizzati con Arduino: programmare l’Atmega328 senza bootloader, in maniera tale da sovrascrivere con i nostri sketch completamente la memoria del microcontrollore.
Ma per quale motivo dovremo farlo? I principali vantaggi sono l’esecuzione immediata del nostro programma all’accensione dell’Atmega e maggiore spazio a disposizione per i nostri programmi nella memoria del microcontrollore. Lo svantaggio è dato dal fatto che non è più possibile programmarlo tramite semplice seriale (a meno di ricaricargli il bootloader), ma occorre utilizzare un programmatore dedicato (o un ArduinoISP) e il tempo di upload dello sketch e parecchio più lungo. Consiglio quindi di utilizzare eventualmente questa modalità solo a progetto finito, mentre di utilizzare il bootloader di Arduino quando stiamo facendo il debug dei nostri programmi (quindi upload continui).
Ma veniamo alla pratica. La programmazione si attua nella stessa modalità del post precedente, con una piccola modifica. Dobbiamo editare il solito file boards.txt ed aggiungere la  riga xxxxxxx.upload.using=arduino:arduinoisp nella configurazione della board che ci interessa programmare, dove xxxxxxx corrisponde al nome della board. Facciamo un’esempio pratico, prendiamo la configurazione da inserire nel file boards.txt che abbiamo visto l’altra volta per l’Atmega a 8Mhz, con questa nuova aggiunta diventerebbe così:

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

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

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=32768
atmega328bb.upload.speed=57600
atmega328bb.upload.using=arduino:arduinoisp

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

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

Con questa aggiunta specifichiamo che l’upload dello sketch non deve andare a finire sulla nostra Arduino UNO, ma sull’Atmega che vogliamo programmare.
Da notare anche la modifica (opzionale) di atmega328bb.upload.maximum_size il cui valore diventa 32768. Praticamente è lo spazio massimo in byte a disposizione per caricare il nostro sketch. Non essendoci più il bootloader lo spazio liberato rimane a nostra disposizione.

1 – Carichiamo tramite la IDE (versione 0022) lo sketch d’esempio ArduinoISP sulla nostra Arduino UNO
2 – Spegniamo il tutto e poi colleghiamo un condensatore da 22uF tra il RESET e il GND di Arduino UNO
3 – Colleghiamo il pin 10 di Arduino UNO al pin di RESET dell’Atmega e i pin 11,12,13 ai pin 17,18,19 del microcontrollore (o ai pin 11,12,13 di un’altra board Arduino) come nella figura:

4 – Eseguiamo l’upload dello sketch usando il comando tradizionale File –> Upload to I/O board

E il gioco è fatto… Abbiamo programmato il microcontrollore per lavorare in standalone senza bootloader Arduino e senza (o quasi) componenti esterni.
Come  vedete è molto semplice e ci permette non solo di programmare gli Atmega328 standalone, ma anche una scheda Arduino completo.
Ad esempio io utilizzo questo sistema con le Arduino Mini Pro. Sono schede economiche, che hanno praticamente tutte le funzionalità della Arduino UNO, ma sono molto piccole. Di solito invece che utilizzare un Atmega328 in standalone all’interno di un progetto ben definito, utilizzo queste piccole schedine, e una volta che il tutto è pronto per essere inscatolato, gli faccio l’upload dello sketch bypassando il bootloader, in particolare modo per renderlo più veloce all’accensione.
Le scheda Arduino Mini Pro è prodotta da Sparkfun ed è disponibile a 3,3V, 5V e con Atmega168 e Atmega328. Io consiglio se gli sketch non superano i 16kB di utilizzare l’Atmega168 e di usare la versione 8Mhz a 3,3V soprattutto se il vostro progetto funziona a batteria perchè consuma parecchio meno.
Ovviamente in fase di programmazione dovremo selezionare la scheda corrispondente dall’elenco delle boards, ad esempio Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega168.
Ma il bello non finisce qui…
Con questo sistema possiamo programmare anche gli Attiny, i fratelli minori degli Atmega. Ne esistono diverse versioni ma i più interessanti sono gli Attiny85 a 8 piedini e l’Attiny2313 a 20 piedini. Hanno il vantaggio che consumano pochissimo, sono più piccoli e più economici.
L’Attiny85 ha solo 5 I/O, ma per tanti progetti va più che bene, considerando anche il costo di circa 2,50 € in Italia.
Inoltre lavorando con clock interno ad 1Mhz il consumo è veramente bassissimo, e la dimensione è come quella di un NE555.
Pensate quindi quanti progetti che possiamo semplificare utlizzando gli Attiny. Anche solo per esempio un controllo PWM di una striscia LED, che richiederebbe operazionali, condensatori, NE555 ecc. con un semplice Attiny85, un potenziometro, un transistor, pochissimi altri componenti e 2 righe di codice, il gioco è bello che fatto…
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 standalone (Arduino senza Arduino)

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

In questo post vorrei mostrare come utilizzare Arduino in configurazione standalone, ovvero utlizzare l’Atmega328 (munito di bootloader) in circuito senza dover portarsi dietro tutta la nostra board Arduino Uno (o quella che avete).
Il concetto è questo: ho finito il mio progetto con Arduino (ad esempio una con LED RGB) e sono pronto per realizzare la versione definitiva da inscatolare in una lampada.
Potrei si usare la board Arduino, ma sarebbe sconveniente sia dal punto di vista del costo, che dal punto di vista delle dimensioni e dei consumi… In realtà quello che a noi serve è semplicemente il microcontroller dotato di bootloader e pochi altri componenti esterni.
Se il nostro Atmega non ha il bootloader, dobbiamo caricarglielo, ma andiamo con ordine… Poniamo che al momento abbiamo già il bootloader onboard.
Per poter fare l’upload degli sketch dobbiamo utlizzare i collegamenti come indicato in figura:

E’ importante rimuove il microcontroller dalla scheda con cui andiamo a programmare, altrimenti programmeremmo quello al posto del nostro Atmega standalone.
Come vedete lo schema è molto semplice, si collega l’alimentazione, i pin TX e RX dei rispettivi microcontroller e il pin RESET.
A questo punto dal nostro Arduino IDE possiamo andare a fare l’upload dello sketch, dopo aver selezionato ovviamente “Arduino Duemilanove or Nano w/ ATmega328” dal menu Tools –> Board. E’ il gioco è fatto.
Ovviamente lo stesso discorso varrebbe se l’Atmega fosse programmato per lavorare con l’oscillatore interno a 8mhz. Con la differenza che non ci sarebbero i due condensatori e il cristallo indicati in figura. Per utilizzare però l’oscillatore interno, va riprogrammato il bootloader (lo vedremo nel prossimo post).
Qualora avessimo a disposizione (e vi consiglio di prenderlo perchè è un’accessorio che costa poco ed è veramente utile) un convertitore USB/Seriale tipo lo Sparkfun FTDI Basic o l’Arduino USB-Serial Light il collegamento sarebbe tipo il seguente:

Non è niente di complicato, semplicemente i collegamenti sono quasi come prima: VCC, GND, RX, TX, mentre il reset è un po’ diverso perchè richiede un condensatore da 100nF tra il PIN DTR (o RTS – da non confondere con RST) e il PIN RST dell’Atmega.
Abbiamo quindi visto come programmare un Atmega328 in standalone con il bootloader già preinstallato; nel prossimo post vedremo come caricare il bootloader su un’Atmega328 vergine sia in versione con cristallo esterno a 16mhz, sia in versione con oscillatore interno a 8mhz.

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.