Arduino Full Memory

Miglioriamo l’IDE di Arduino aggiornando il compilatore con l’ultima versione inclusa nella Toolchain ATMEL in modo da superare la attuale difficoltà all’utilizzo di aree dati che occupano più di 128k di memoria flash, eliminando una delle cause di crash dei programmi più difficili da individuare.

Le pagine di questo breve tutorial, pur essendo fondamentalmente rivolte agli utenti più “navigati” di Arduino, ed in particolare ai possessori delle versioni della famiglia “MEGA”, sono da considerare appetibili anche per gli utilizzatori delle versioni standard (UNO e Duemilanove in primis) di questa ormai famosissima board di prototipazione e sperimentazione, il perché sarà chiaro più avanti.

Tutto nasce dal progetto di Elettronica In, denominato TiDiGino e basato, come è ormai noto, sul microcontrollore ATmega2560, una potentissima MCU con ben 256kByte di flash memory, che è anche il cuore della board Arduino MEGA 2560. Nel momento in cui i nostri lettori che partecipavano al Contest hanno realizzato firmware di notevole entità, per sfruttare tutte le numerose caratteristiche hardware della scheda, hanno riscontrato dei problemi di crash o difficoltà di esecuzione degli sketch.

Dopo una serie di test sul TiDiGino, confermato che dal punto di vista hardware il funzionamento era più che perfetto, abbiamo effettuato una ricerca approfondita sul sito di ATMEL, produttore dei microcontrollori di cui stiamo parlando, e abbiamo scoperto la causa di tali problemi: si tratta del programma compilatore in dotazione all’IDE versione 0022/0023 ed anche alla successiva versione 1.0, che è denominato “avr-gcc-4.3.2.exe”.

Tale programma non è in grado di compilare correttamente sketch che occupano oltre 64kWord, pari a 128kByte di memoria flash, in quanto gestisce in modo erroneo i salti oltre 64kB; in realtà la problematica è estremamente più complessa (vedi box “La gestione della memoria”).

Il compilatore di cui stiamo parlando (v.4.3.2) è quello integrato nel software WinAVR, risalente al 2008, quando i microcontrollori ATMEL non superavano la capacità di memoria flash di 64kB.

Tale progetto è stato aggiornato l’ultima volta a gennaio 2010, e la versione si chiama “WinAVR-20100110” (il numero in effetti è la data di rilascio, nel formato aaaammgg, quindi 10/01/2010), e contiene la versione di compilatore denominata “avr-gcc-4.3.3.exe”; abbiamo provato ad usare questa versione ma il limite restava.

Naturalmente va da sé che il problema assume una importanza decisamente più rilevante, se pensiamo che qualsiasi possessore di board Arduino MEGA (basata sull’ATmega1280) o di board Arduino MEGA 2560, oggi non è in condizioni di poter sfruttare le potenzialità della propria scheda.

Il limite di 64kWord, ovvero 128kB di memoria, permette comunque il perfetto funzionamento dei programmi, però non è possibile introdurre dati nella flash oltre i primi 64kB, se lo si fa i risultati sono imprevedibili, in linea di massima fino a che il software non tenta di accedere a questi dati funziona tutto, non appena cerca di farlo va in crash. Ovvero il programma funziona fino a che i dati introdotti nella flash non superano il limite dei primi 64kB; per poter mettere dei dati nella flash oltre i 64kB è indispensabile accedervi tramite le apposite funzioni messe a disposizione dalla Progmem, perché è necessario usare salti con puntatori a 24 bit.

Un programma composto da 60kB di dati, a patto che si trovino sotto il limite, e altri 60kB di codice funzionerebbe anche nelle attuali condizioni.

Oggi, dopo moltissima sperimentazione siamo riusciti a far funzionare le varie versioni dell’IDE con l’ultima versione della Toolchain dell’ATMEL, superando tali vincoli, ferma restando la necessità di scrivere dei firmware nel rispetto di quanto abbiamo appena affermato.

La Toolchain è un insieme di programmi e librerie (tools), usati per trasformare un codice sorgente in eseguibile, mediante una sorta di “catena di montaggio virtuale” (da cui il termine chain = catena, concatenamento): il prodotto in uscita da un tool diventa l’input per il tool successivo. Il tool più importante della Toolchain è naturalmente il compilatore, la cui ultima versione attualmente disponibile è “avr-gcc-4.5.1.exe”.

Questa versione, basta confrontare i numeri per capirlo (4.5.1 contro 4.3.2), è notevolmente più aggiornata rispetto a quella usata dal software in dotazione ad Arduino, ed i vantaggi sono notevoli:

supporta tutti i micro Atmel a 8 bit;
supera il limite di 128kB e compila correttamente sketch fino a 256kB;
contiene librerie aggiornate e decisamente migliori;
produce un codice mediamente più compatto e spreca meno risorse di sistema.

Completiamo queste brevi note teoriche parlando dei file avrdude.exe e avrdude.conf, premettendo che nelle indicazioni dei percorsi delle cartelle faremo riferimento alla versione 0022, ma che i passaggi valgono per tutte le versioni, ovviamente cambiando opportunamente percorso.

Avrdude.exe è un programma di servizio in dotazione all’IDE e si trova nella cartella
“MyPath\arduino-0022\hardware\tools\avr\bin”
e, rispetto all’originale AVR, è stato modificato per poter funzionare con il bootloader.

Avrdude.conf è invece un file che contiene informazioni di configurazione sui vari microcontrollori ATMEL che i più esperti potrebbero aver modificato per l’aggiunta di nuovi modelli, e si trova nella cartella
“MyPath\arduino-0022\hardware\tools\avr\etc”.

Il motivo per cui abbiamo appena spiegato la funzione e la localizzazione di questi due file consiste nel fatto che essi non sono coinvolti in questa operazione di aggiornamento e dovranno quindi essere preservati, nel momento in cui vi faremo cancellare tutto il contenuto della cartella “MyPath\arduino-0022\hardware\tools\avr”.

Dobbiamo ancora sottolineare come la semplice operazione di sostituzione della cartella “avr” non risolverebbe assolutamente nulla, anzi renderebbe non più utilizzabile l’IDE, e qui diventa indispensabile il lavoro che abbiamo fatto e che vi mettiamo a disposizione.

Bene, a questo punto, avendo le idee più chiare sull’argomento possiamo procedere con i necessari passaggi per effettuare questo importantissimo aggiornamento. Il consiglio che vi diamo è seguirli alla lettera, senza invertirli e senza aggiungere o togliere nulla. La procedura che vi spieghiamo è stata effettuata e collaudata svariate volte, al fine di poterne garantire il perfetto funzionamento.

Procedura di aggiornamento IDE.

La procedura di seguito descritta è applicabile alle versioni IDE di Arduino denominate: 0022, 0023, 1.0, 1.0.1-rc1; quest’ultima in particolare è la release candidate della nuova versione dell’IDE 1.0, una sorta di versione beta, ancora in fase di test, ma che abbiamo collaudato ugualmente.

I passaggi da seguire sono:

Copiare tutto l’IDE originale in una nuova cartella, anche nello stesso punto in cui si trova l’originale, così da avere sempre a disposizione l’installazione originale. Questo passaggio è fondamentale qualora riscontriate dei malfunzionamenti attribuibili all’aggiornamento (ma i nostri test, ad oggi, ci hanno dato prova di notevole affidabilità);
Rinominate la nuova cartella in modo da poterla distinguere facilmente dall’originale (Fig. 1), chiamandola, p.es., arduino-0022-tcnew;
Fig.1 - La cartella originale dell'IDE e il suo clone.
Nella nuova cartella cancellate completamente la cartella “avr” che si trova in “MyPath\arduino-0022-tcnew\hardware\tools” (Fig. 2);
Fig.2 - La cartella avr da cancellare.
Scaricate l’ultima versione della Toolchain Atmel per Windows, dal link http://www.atmel.com/tools/ATMELAVRTOOLCHAIN3_2_3FORWINDOWS.aspx, per poter accedere alla sezione di download è necessario compilare un form di registrazione on-line; successivamente riceverete sull’indirizzo fornito una email contenente il link diretto al download (Fig. 3);
Fig.3 - La sezione download del sito ATMEL.
Il file scaricato, denominato “avr-toolchain-installer-3.2.3.579-win32.win32.x86.exe”, va regolarmente installato sul PC. Segnatevi il percorso di installazione, in modo da poterlo poi localizzare rapidamente. Se nel vostro sistema è già presente una installazione di AVR Studio il percorso proposto sarà quello già esistente per questo programma che, in tal modo, verrà aggiornato;
Copiate da questo nuovo percorso la cartella “AVR Toolchain” e incollatela all’interno della cartella “MyPath\arduino-0022-tcnew\hardware\tools”, quindi rinominatela “avr”; in tal modo avrete ricreato il percorso “MyPath\arduino-0022-tcnew\hardware\tools\avr”;
Entrate nella nuova cartella “avr” ed eliminate la sottocartella “avr32” (Fig. 4);
Fig.4 - La cartella avr32 da cancellare.
Copiate dalla cartella originale “MyPath\arduino-0022\hardware\tools\avr\bin” il file avrdude.exe e incollatelo nella cartella “MyPath\arduino-0022-tcnew\hardware\tools\avr\bin”, confermando la richiesta di sovrascrittura;
Copiate tutta la cartella originale “MyPath\arduino-0022\hardware\tools\avr\etc” e incollatela nella cartella “MyPath\arduino-0022-tcnew\hardware\tools\avr\”; in tal modo ora avrete anche il percorso “MyPath\arduino-0022-tcnew\hardware\tools\avr\etc”;
Eliminate la cartella “include” posta in “ MyPath\arduino-0022-tcnew\hardware\tools\avr\avr” (N.B.: fate molta attenzione al doppio “avr”, si tratta proprio di una sottocartella “avr” posta all’interno della cartella “avr”! (Fig. 5) ed al suo posto inserite quella da noi modificata, scaricabile da qui; come spiegato in precedenza la procedura è identica per tutte le versioni di IDE a partire dalla 0022.
Fig. 5 - La cartella include da cancellare e sostituire.
A questo punto entrate nella cartella “MyPath\arduino-0022-tcnew\examples\”, eliminate la cartella ArduinoISP (e lo sketch che contiene) e aggiungete la cartella “ArduinoISP101”, che è la nuova versione di questo sketch, in dotazione all’IDE 1.0.1-rc1. All’inizio vi abbiamo fatto copiare l’intera cartella dell’IDE per poi aggiornare la copia; il motivo è quello comunque di mantenere l’originale, che resta valida in qualche caso in cui dovreste riscontrare qualche difficoltà con la nuova versione. La versione originale continuerà a funzionare con sketch di dimensioni minori di 64kB, in quanto sicuramente non ci sarà il rischio che qualche dato finisca nella parte superiore. Da notare che lo sketch contenuto nella cartella ha estensione “.pde” e quindi funziona con le versioni IDE 0022 e 0023; se invece usate la versione 1.0 allora bisogna rinominare l’estensione in “.ino” (la nuova estensione adottata per l’IDE 1.0).

Una sola nota riguarda quest’ultimo passaggio: lo sketch, che interessa ovviamente tutti coloro che usano Arduino come Programmatore ISP, funziona correttamente a 19200 BAUD con le versioni 0022, 0023, ed a 9600 BAUD con la versione 1.0.1-rc1, ma non funziona con la versione 1.0.
Quindi in base alla versione di IDE che usate potrebbe essere necessario impostare la riga “Serial.begin(19200);” portandola a “Serial.begin(9600);”.

Per gli utenti della versione IDE 1.0 abbiamo messo a disposizione nella sezione download una ulteriore versione di ArduinoISP, denominata “ArduinoISP101LM”; in pratica si tratta della versione originale 1.0.1 a cui è stata applicata una patch correttiva, da parte di due esperti programmatori, i cui nomi sono nei credits dello sketch e che approfittiamo per ringraziare della collaborazione e disponibilità fornita.

Se adottate questa versione, avendo però ben chiaro che non è ufficiale, funzionerà anche con l’IDE 1.0, a 19200 BAUD; inoltre usandola in ambiente IDE 1.0.1-rc1 non ci sarà alcuna necessità di settare la velocità a 9600 BAUD in quanto tale sketch rileva automaticamente la versione dell’IDE ed imposta la corretta velocità della seriale; naturalmente dovrete mettere la relativa cartella sempre in “MyPath\arduino-0022-tcnew\examples\”.

Possiamo comunque garantire che questa versione, sebbene non ufficiale, funziona anche meglio della 101 originale, specialmente nei casi in cui si debbano programmare MCU di grandi dimensioni. Per meglio chiarire quanto appena spiegato date uno sguardo alla Tabella 1.

Tabella 1 - Quadro comparativo delle due versioni di ArduinoISP fornite.

Per finire non ci resta che aggiungere un’ulteriore nota, che interessa tutti coloro che utilizzano i microcontrollori della serie ATtiny e la versione IDE 1.0 o 1.0.1: abbiamo riscontrato che, in alcuni casi, il nostro aggiornamento potrebbe dare origine ad errori durante la fase di compilazione. La soluzione è piuttosto semplice: nel file wiring.h del “core” tiny basta aggiungere “#include <math.h>” come prima istruzione.

Il problema è dovuto alla struttura di tale core, in particolare le varie precedenze di invocazione delle librerie; math.h deve essere caricata prima di ogni altra, e non come dipendenza di altre librerie. Con questa semplice modifica gli errori scompariranno.

Arrivati a questo punto non vi resta che sperimentare questo prezioso aggiornamento; le prove con gli sketch di esempio in dotazione all’IDE oppure con i propri sketch certamente andranno a buon fine, se avete eseguito alla lettera ogni punto spiegato. Abbiamo pensato che non tutti i nostri lettori avranno realizzato sketch di dimensioni così elevate da superare il fatidico limite; per tale ragione, sempre nella sezione download, troverete uno sketch denominato “test_80k” che vi permetterà di verificare come il vostro Arduino MEGA (1280) o MEGA 2560, ed anche il TiDiGino siano ora in grado di ricevere correttamente e far funzionare sketch in cui la memoria dati si collochi anche oltre i primi 64kB.

Noi il nostro test lo abbiamo fatto proprio sul TiDiGino: in Fig. 6 potete vedere a sinistra lo sketch compilato e inviato, e sulla destra due LED accesi durante l’attività dello sketch, uno di quelli in dotazione ed uno che abbiamo inserito per il test sul pin 13 del connettore collegato all’ATmega2560.

Fig. 6 - Il TiDiGino funzionante dopo il caricamento di uno sketch da 80k.

Naturalmente le nostre sperimentazioni e ricerche continuano, a beneficio dei nostri lettori e degli utenti del TiDiGino e, più in generale, di tutta l’utenza del mondo Arduino; se ci saranno ulteriori novità vi terremo aggiornati.

La gestione della memoria

Il byte, ovvero 8 bit, è l’unità di memoria minima indirizzabile, vale per tutte le MCU ed i microprocessori, la word rappresenta la quantità di dati che l’unità di calcolo può trattare ad ogni ciclo macchina, quindi le dimensioni della word non sono un valore fisso perché dipendono dall’architettura hardware.

Sulle MCU AVR la word dati è un byte, sulle MCU con core ARM la word dati è quattro byte, su un processore X86 a seconda dei modelli e di come vengono utilizzati la word dati può essere sia di quattro byte che di otto byte (64 bit).

Quasi tutte le MCU esistenti sono di tipo RISC e adottano l’architettura Harvard che prevede una distinzione tra memoria dati e memoria di programma con relativi bus separati.

Sugli AVR la memoria di programma è costituita da due byte quindi la relativa word è di 16 bit, il che ci porta a dover fare una distinzione tra word di programma e word dati; dal momento che il “core” degli AVR è da 8 bit, solitamente per i dati si fa semplicemente riferimento ai byte mentre per la memoria di programma si può fare riferimento sia alle word che ai byte realmente impiegati.

Quando si compila un programma il risultato dell’occupazione di memoria viene sempre fornita in byte perché questa è l’unità di misura con la quale viene indicata la memoria totale disponibile nei vari micro, però l’occupazione di questa avviene di due byte in due byte per ogni istruzione assembly, alcune richiedono l’uso di due o tre word nel caso siano da specificare indirizzi estesi.

Per quanto riguarda l’occupazione della memoria di programma da parte dei dati anche in questo caso avviene per word di due byte sugli AVR, cioè se si mette un dato di un solo byte nella flash occupa comunque due byte, un vettore di tipo char composto da 8 elementi occupa quattro word, ovvero 8 byte, uno di 9 elementi occupa 5 word, ovvero 10 byte.

Download

(a cura dell’Ing. Marco d’Ambrosio e Prof. Michele Menniti)