E’ risaputo che l’IDE disponibile con l’Arduino, in apparenza identico a quello di Processing, non e’ esattamente il massimo che uno sviluppatore potrebbe desiderare. Esso manca, infatti, delle features di base disponibili sulla maggior parte degli IDE commerciali e non, come ad esempio il Syntax higlight, il code parsing and checking, smart indent, help in line e il syntax completation, naturalmente con questo NON voglio denigrare l’ottimo lavoro che il team dell’Arduino ha compiuto. L’IDE e’ ottimo ed intuitivo per tutti i neofiti e non che si avvicinano alla piattaforma open source ed open hardware. Sviluppare senza la possibilita’ di utilizzare tali funzioni puo’ risultare a volte poco efficiente, certo si potrebbe optare per la formazione vincente vim, c-scope, ctags e l’inseparabile riga di comando, ma sono certo che molti di voi stanno gia’ pensando di navigare altrove, quindi la mia scelta ricade su un IDE ormai diffusissimo e con tutte le features necessarie: Eclipse.

Tutto quello che si vorrebbe conoscere riguardo l’Arduino DUE puo’ essere trovato nell’interessante articolo di Piero Boccadoro "Arduino DUE prestazioni a confronto". Per quanto riguarda il review4U, ho deciso di evitarvi il lampeggio di un led, ma bensi di affrontare un argomento piu’ stimolante e utile per progetti corposi quale lo sviluppo su Arduino DUE tramite Eclipse. Questo argomento e’ stato affrontato e risolto in questi giorni sul forum dell’arduino con la mia personale partecipazione.

Basta chiacchiere e iniziamo con gli step necessari.

1) Download e Installazione dei componenti

Al fine di poter creare un progetto per l’Arduino DUE e’ necessario installare i seguenti software nell’ambiente di sviluppo.

• Arduino DUE IDE :  da cui verranno prese le librerie del progetto. Scompattare il contenuto e appuntarsi il percorso assoluto, ad esempio  “C:\arduino-1.5.1r2” o “/Applications/Arduino.app”, quindi aggiungere a tale percoso:
  in Windows: hardware\tools\g++_arm_none_eabi\bin
  in OSX: Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin/
  e renderlo disponibile nel path di esecuzione.
• Eclipse IDE for C/C++ Developers a 32 bits ( la versione a 64 bits sembra non sia compatibile con la RXTX plug-in), installare utilizzando il semplice wizard.
• GNU ARM Eclipse Plug-in contenente la cross-chain: Scaricate la versione corrente, che in questo momento è la versione 0.5.4. L’installazione può essere fatta usando il gestore plug-in di eclipse: Eclipse -> Install New Software -> Add ->Archive , indicando lo zip scaricato. Si noti che non utilizzeremo la toolchain fornita dalla plug-in ma quella dell’IDE arduino, l’installazione e’ necessaria per avere tutte le opzioni per la cross compilazione in un formato “user friendly”.

• La plug-in RXTX deve essere installata utilizzando il gestore plug-in nel seguente modo: Scrivendo “RXTX” nel campo Name e il seguente url http://rxtx.qbang.org/eclipse/ nel campo location. Quindi spuntare la versione 2.1.7-r4 e procedere con l’installazione
• Target Management Terminal Plug-in. Questa puo’ essere trovata tramite Eclipse->Install New Software...
  Selezionare in “work with” “all site” e in “Details” scrivere “Target Terminal” dopo qualche secondo vi apparira’ la plugin, selezionare ed installare.

2) Preparazione dell’environment

A questo punto siamo pronti per preparare l’ambiente di compilazione.

Creare il progetto ArduinoLib2rary in Eclipse:

Aperto Eclipse, creare un nuovo progetto File->New->C++ Project e specificare come nome del progetto: ArduinoLib2. Disabilitare l’opzione “Use default location” tramite l’apposito checkbox e indicare il percorso del progetto usando il bottone “Browse” SOLO nel caso si volesse usare una directory diversa da quella porposta da eclipse: “c:\Documents\workspace\” come “Project type” specificare “ARM Cross Target Static Library/Empty Project”, mentre per la “Toolchains” selezionare “ARM Windows GCC (Sourcery G++ Lite)” per OSX “ARM OSX GCC (Sourcery G++ Lite)”, quindi terminare premendo “Finish”.

Da qui in avanti i percorsi verranno specificati secondo OSX, essendo l’OS su cui sviluppo.

Aprire le proprieta’ del progetto, click destro sulla cartella nominata ArduinoLib2 nel tab “Project Explorer”.

Dobbiamo ora verificare che in “C/C++ General/Paths and Symbols” precisamente nel tab “Includes” e in “Include directories” sia presente per tutti e tre i linguaggi “ Assembli, GNU C e GNU C++, il percorso reso disponibile nel PATH durante l’installazione dell’Arduino IDE. Per essere chiari mettiamo un esempio :

Nel caso di OSX il percorso che dovra’ apparire e’

/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/...
...g++_arm_none_eabi/arm-none-eabi/include/

Si noti come la directory finale non sia “bin”, ma “include”. Nel caso tale percorso non sia presente, sara’ possibile includerlo manualmente tramite il pulsante “add...” e flaggando “add to all languages”.

Aggiungere nello stesso modo anche i seguenti percorsi:

/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...
...system/libsam/
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...
...system/CMSIS/CMSIS/Include/
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...
...system/CMSIS/Device/ATMEL/

Nota: in Windows le directory “Contents\Resources\Java\” non sono presenti, ma la cartella “hardware” si trova direttamente nella root dell’IDE.

Passando ora a “Symbols” aggiungiamo i seguenti simboli per tutti i linguaggi:

printf=iprintf
F_CPU=84000000L
ARDUINO=151
__SAM3X8E__
USB_PID=0x003e
USB_VID=0x2341
USBCON

Per inserire un simbolo, ad esempio “ARDUINO=151”, mettere in “Name” ARDUINO ed in “Value” 151. Per i simboli senza valore valorizzare solo il campo “Name”.

Nota: __SAM3X8E__ contiene due underscore per parte.

Adesso che il progetto e’ pronto, non resta che copiare i file di core dell’arduinoDue, per prima cosa, nel “Project Explorer” di Eclipse selezionare la cartella di progetto “ArduinoLib2” e premendo con il destro selezionare “import”.

Selezionere quindi General->FileSystem, premere “Browse” e selezionare la cartella arduino presente nel seguente path:

/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...
...cores/arduino

Non flaggare “Create top Level directory” e premere ok.

Stessa cosa per la directory

/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...
...variants/

Questa volta flaggando “Create top Level directory”
 

A questo punto selezionata la directory di progetto, premere F5 ed espandere l’alberatura, il risultato sara’ il seguente:

Nota: Non sono presenti tutti i file per motivi di spazio, l’importante e’ capire l’albertura del progetto, tutte le directory importate sono comunque visibili.

Configurazione del progetto per la compilazione:

E’ necessario configurare le opzioni e ottimizzazioni del cross-compilatore: right-click sul progetto e selezionare “property”, quindi selezionare C/C++ Build/ Settings sulla destra e nel “Tool Settings” tab impostare come “Target Processor “ il “cortex-m3” abilitando le istruzioni “Thumb” tramite il checkbox (1).

Per il “Debugging” selezionare “Default –g” e come “Debug format” gdb.

Per una compilazione senza errori, configurare il Compilatore C passando per i seguenti punti:

• “ARM Sourcery Mac OSX GCC C Compiler/Directories”
  (2), agginungere, selezionando “workspace” come riferimento, i seguenti path:
  “variants\arduino_due_x”
  “USB”
  e la cartella di progetto stessa,

• “ARM Sourcery Mac OSX GCC C Compiler/Optimization”

• “ARM Sourcery Mac OSX GCC C Compiler/Warnings”
  Selezionare –Wall.
• “ARM Sourcery Mac OSX GCC C Compiler/Miscellaneous”
  Come “Language standard” selezionare “Compiler defaults”. Non selezionare nessuna checkbox e assicurarsi che in “Other Flags” sia presente:

-c --param max-inline-insns-single=500 –nostdlib

Le stesse configurazioni vanno applicate a “ARM Sourcery Mac OSX GCC C++ Compiler”, ad eccezione di “ARM Sourcery Mac OSX GCC C++ Compiler/Miscellaneous” dove bisognera’ selezionare inoltre:

“Do not uses exceptions” e “Do not use RTTI”

Per OSX infine e’ necessario aggiungere in “environment” il percorso della toolchain, vedi riga blu nella figura sottostante, al momento dell’inserimento accertarsi che “Append variables to native environment” sia flaggato.

Finalmente possiamo compilare le librerie di base usando il il tasto build (simbolo del martello), al termine della compilazione avremo sotto Archives la libreria di core.

3) Prima applicazione

Creare un programma per Arduino DUE: Blink

Le librerie del core verranno da qui in avanti linkate a tutti i nuovi progetti.

Iniziamo dal tipico led, e’ vero, avevo esordito dicendo di saltare il blink project, ma quello sara’ il template da cui tutti i progetti piu’ complessi potranno partire. Bastera’ infatti duplicare il progetto blink per potere avere, in un batter d’occhio, un ambiente testato e pronto all’uso.

Iniziamo con il creare un nuovo progetto C++, questa volta invece di selezionare “static library” selezioneremo “ARM Cross Target Application” con Toolchain “Sourcery G++ Lite”, nominiamo il progetto Blink e premiamo “Finish”.

La maggior parte delle configurazioni sono uguali a quelle della libreria sopra creata, vediamole nuovamente tutte evidenziando cosa cambiare: apriamo le proprieta’ del progetto:

In “C/C++ General/Paths and Symbols” tutto identico alla configurazione precedente, aggiungere in Path, selezionando “Workspace” anche:

/<NomeProjLib>/
/<NomeProjLib>/USB/
/<NomeProjLib>/variants/arduino_due_x

Al posto di <NomeProjLib> dovremo inserire il nome di progetto delle librerie compilate precedentemente, nel mio caso ArduinoLib2.

C/C++ Build/ Settings:

 “Target Processor” come per le librerie.

 “Debugging” selezionare “Default –g” e come “Debug format” gdb.

Per quanto riguarda la voce “Additional Tools” selezionare tutte e tre le voci: ”Create flash image” , “Create Extended Listings” e “Print Size”

Passiamo alla configurazione del compilatore C:

•  “ARM Sourcery Mac OSX GCC C Compiler/Directories”, agginungere, selezionando “workspace” soltanto la cartella di progetto.
•  “ARM Sourcery Mac OSX GCC C Compiler/Optimization”, identico alle librerie.
• “ARM Sourcery Mac OSX GCC C Compiler/Warnings”
  Selezionare –Wall.
• “ARM Sourcery Mac OSX GCC C Compiler/Miscellaneous”
  Come “Language standard” selezionare “Compiler defaults”. Non selezionare nessuna checkbox e assicurarsi che in “Other Flags” sia presente:

-c --param max-inline-insns-single=500 –nostdlib

Le stesse configurazioni vanno applicate a “ARM Sourcery Mac OSX GCC C++ Compiler”, ad eccezione di “ARM Sourcery Mac OSX GCC C++ Compiler/Miscellaneous” dove bisognera’ selezionare:

“Do not uses exceptions” e “Do not use RTTI”

La vera differenza viene nella configurazione del Linker:

Partiamo selezionando l’elemento root del linker “ARM Sourcery Mac OSX GCC C++ Linker” e in “Command Line Pattern” copiamo la seguente riga:

${COMMAND} ${FLAGS} ${OUTPUT_FLAG}  ${OUTPUT_PREFIX}${OUTPUT}
 -Wl,--start-group ${INPUTS} -Wl,--end-group

In “General” nel campo “Script File (-T)” mettiamo il percorso che punta al file di configurazione flash.ld.

In ambiente OSX lo troviamo in:

/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/sam/...

...variants/arduino_due_x/linker_scripts/gcc/flash.ld

Questo file specifica in fase di linking la dimensione e le aree di memoria del processore (flash) e la definizione delle sezioni del programma : .bss .data .text etc.

In “Libraries” specifichiamo “contro” quali librerie il nostro programma deve essere linkato; qui inseriremo per prima cosa la libreria compilata precedentemente e poi una libreria precompilata che viene fornita con ArduinoIDE.

Nell’area “Libraries (-l)” aggiungere: ArduinoLib2 e sam_sam3x8e_gcc_rel.

In “Library Search Path (-L) aggiungere come workspace:

"ArduinoLib2/variants/arduino_due_x"
"ArduinoLib2/Debug"

In “Miscellaneous” aggiungere in “Other Objects” il percorso di workspace al file “ArduinoLib2/Debug/syscall_sam2.o” e in “Other Flags” specificare:

-lm -lgcc  -Wl,--cref -Wl,--check-sections -Wl,--gc-sections 
-Wl,--entry=Reset_Handler -Wl,--unresolved-symbols=report-all 
-Wl,--warn-common -Wl,--warn-section-align -Wl,--warn-unresolved-symbols

Passiamo al tab “Build Steps”, qui inseriremo l’ultimo passaggio necessario per ottenere il binario da caricare sull’Arduino.

Nella riga command: di “Post-Build Steps” scrivere:

/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/...
.../g++_arm_none_eabi/bin/arm-none-eabi-objcopy 
-O binary ${ProjName}.elf ${ProjName}.bin

Configurando infine il PATH in C/C++ Build/Environment come fatto per le ArduinoLib2, potremo aggiungere finalmente il file .cpp per la compilazione di “Blink”.

Chiudiamo le proprieta’ di progetto e creiamo un nuovo file c++, click con il destro sulla cartella di progetto New->source file, nominiamolo Blink.cpp e selezioniamo C++ Source Template.

Non ci resta che aggiungere nel nuovo file il “familiare” codice:

#include <Arduino.h>


/*

  Blink

  Turns  a LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.

 */

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13;


// the setup routine runs once when you press reset:

void setup() {
  // initialize the digital pin as an output.
     Serial.begin(115200);
     pinMode(led, OUTPUT);

}
// the loop routine runs over and over again forever:
void loop() {
     Serial.println("Test");
     digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
     delay(1000);               // wait for a second
     digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
     delay(1000);               // wait for a second
}

Salviamo e compiliamo! Il binario Blink.bin si trova nella cartella Debug del progetto.

Procedura di Erase e Upload del “compilato” sul target

Arduino DUE utilizza il programma precompilato chiamato bossac.exe o semplicemente bossac (Linux e OSX) per effettuare l’upload verso l’hardware.

Fino ad ora sono riuscito a programmare l’Arduino DUE usando la “Programming Port”, ovvero la porta mini usb vicina al jack dell’alimentazione. Sulla pagina ufficiale viene riportato che per usare la porta in programmazione e’ necessario avviare la procedura di erase della flash. Tale procedura, viene scritto, puo’ essere avviata semplicemente aprendo e chiudendo una connessione seriale sulla stessa.

Per quanto riguarda la “Native Port” invece servirebbe aprire una connessione con baud rate di 1200bps per attivare il “soft erase” effettuato dal processore.

Nelle varie prove ho notato che in realta’ sulla “Programming port” non basta aprire e chiudere una connessione ma bisogna aprirla a 1200bps.

Un’alternativa alla procedura software e’ quella manuale, si puo’ infatti attivare la procedura di erase anche premendo per piu’ di un secondo il tasto “erase”, quello sottostante alla serigrafia “COMMUNICATION”.

Per procedere dobbiamo a questo punto creare una configurazione Terminal usando la plugin installata precedentemente.

Bisogna far apparire in eclipse il tab “Terminal” cliccando nel menu’ “Windows”->ShowView->Others... e selezionare “Terminal”

Il tasto (1) permette di creare un nuovo settaggio del terminal, chiamiamolo “Reset” ed impostiamo i valori (2) come in figura. Ovviamente la porta dovra’ corrispondere a quella verso cui e’ collegato l’Arduino DUE.

Il primo tasto verde presente sulla barra per i settaggi serve per collegarsi all’arduino. Il tasto (3) per creare una nuova configurazione e il tasto (4) per passare da una configurazione all’altra.

Bastera’ premere il tasto “connetti” per attivare l’erase dell'Arduino DUE, una volta connessi, apparira’ un pulsante graficamente uguale a quello di connessione, ma di colore rosso, usato per disconnettere la seriale.

L’ultimo passo necessario e’ la configurazione del bossac per l’upload:

Premere “Run”->”External Tools”->”External Tool Configurations” , selezioniamo “Program” e inseriamo i valori in figura.

“Apply” e poi “close”.

Collegato l’Arduino DUE apriamo e chiudiamo un connessione verso l’arduino col Terminal, quindi successivamente premiamo il tasto “Run” (il play con la valigetta marrone” e dopo qualche secondo la nostra board blinkera’ con frequenza di 1Hz.

4) Uso Librerie aggiuntive

Per aggiungere una libreria esterna, quale ad esempio “LiquidCrystal”, e’ un’operazione semplice ed intuitiva.

Selezionando la cartella di progetto, apriamo il menu’ contestuale, tasto destro del mouse, e selezioniamo import.  Selezionare General->FileSystem e cliccare su browse.

La libreria “LiquidCrysta” si trova in

/Applications/Arduino.app/Contents/Resources/Java/Libraries/

selezionare la cartella LiquidCrystal, espanderla e flaggare solo LiquidCrystal.cpp LiquidCrystal.h, quindi selezionare “Create top level directory” per mantenere l’alberatura di progetto ordinata e premere ok.

Per includere la libreria, aggiungere nelle proprieta’ del sistema-> CC++ Build -> Settings:

“ARM Sourcery Mac OSX GCC C++ Compiler”, e

“ARM Sourcery Mac OSX GCC C Compiler”

in Directories , Include Paths anche il percorso alla cartella appena importata.

Salvata la configurazione, si potra includere <LiquidCrystal.h> all’interno del file .cpp che deve utilizzarla.

Conclusioni

L’IDE compreso con l’Arduinio Uno e DUE e’ sicuramente un valido compagno per tutti gli sviluppatori, nasconde le complicazioni della cross-compilazione per lasciare il programmatore concentrato sull’implementazione del progetto. Cio’ nonostante i piu’ esigenti potrebbero desiderare maggiori funzionalita’ e magari un ambiente piu’ famigliare, Eclipse puo’ essere una valida alternativa pur richiedendo uno sforzo di configurazione iniziale maggiore.

 Zad

Ti potrebbe interessare anche:

Analizzatore di Reti multiporta con Arduino M0 Pro

Sistemi di sviluppo per LPC2000

L’architettura ARM big.LITTLE – Puntata 2

Articoli Correlati

Arduino DUE Tutorial: Atmel SAM3X8E ARM Cortex-M3 CPU