Home
Accesso / Registrazione
 di 

Arduino DUE & Eclipse: accoppiata vincente

eclipse & arduino

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

 

 

Scrivi un commento all'articolo esprimendo la tua opinione sul tema, chiedendo eventuali spiegazioni e/o approfondimenti e contribuendo allo sviluppo dell'argomento proposto. Verranno accettati solo commenti a tema con l'argomento dell'articolo stesso. Commenti NON a tema dovranno essere necessariamente inseriti nel Forum creando un "nuovo argomento di discussione". Per commentare devi accedere al Blog
ritratto di Giorgio B.

Ottima prova e davvero buon suggerimento :)

Ottima prova e davvero buon suggerimento :)

ritratto di frada

Ottima opportunità di svincolarsi da un IDE (quello originale di

Ottima opportunità di svincolarsi da un IDE (quello originale di Arduino) davvero troppo semplificato (almeno un syntax highlight e/o un code completion degni di questo nome li potevano mettere!!!).

Comunque, chi disponesse di Visual Studio 2008/2010/2012 (anche nella versione Express, quindi gratuita) potrebbe prendere in considerazione il plug-in sviluppato per questo IDE da Visual Micro (www.visualmicro.com); mette a disposizione di uno sviluppatore per Arduino praticamente tutte le funzionalità avanzate di Visual Studio e in più sfrutta benissimo il compilatore AVR-GCC compilando gli sketch in tempi nettamente inferiori rispetto all'IDE originale.

Lo sketch compilato viene poi caricato in Arduino direttamente da Visual Studio con il classico comando Run Debug e c'è anche un valido sostituto del Serial Monitor; al momento non è ancora disponibile l'adattamento ad Arduino 1.5, quindi non è compatibile con Arduino DUE ma sarà disponibile a breve; è anche stato annunciata una estensione per il debugging/profiling del codice Arduino, già disponibile in beta!

ritratto di frada

Oooops! Piccola rettifica: il plug-in di Visual Micro NON è comp

Oooops! Piccola rettifica: il plug-in di Visual Micro NON è compatibile con le edizioni Express di Visual Studio... Chiedo venia e vi invito a leggere qui http://www.visualmicro.com/pag... per le istruzioni su come ottenere una licenza gratuita di Visual Studio Professional Edition di durata fino a 3 anni!

ritratto di Antonello

Beh, perfetto direi...

Beh, perfetto direi...

ritratto di Piero Boccadoro

Ho avuto esperienza diretta con questo plug in e devo dire che f

Ho avuto esperienza diretta con questo plug in e devo dire che funziona abbastanza bene...
Un modo intelligente di perfezionare il lavoro dell'IDE di Arduino.

ritratto di Piero Boccadoro

Io sinceramente sono convinto del fatto che assieme ad Arduino p

Io sinceramente sono convinto del fatto che assieme ad Arduino potrebbe essere rilasciata una versione più complessa dell'IDE, magari a pagamento. Una cifra simbolica, più o meno come quella che si paga per aver la scheda, potrebbe essere un valido supporto a questo gruppo per fornire strumenti più professionali e più completi per la programmazione. Sempre lasciando la versione gratuita a disposizione gli utenti, però affiancandole quella con più utilità.
Probabilmente dietro ci dovrebbe essere molto più lavoro rispetto a quello che è necessario per creare la scheda però l'intera struttura del progetto ne guadagnerebbe in completezza.

ritratto di zad

Io vedrei molto piu' efficiente sviluppare una plug-in ufficiale

Io vedrei molto piu' efficiente sviluppare una plug-in ufficiale in eclipse, il lavoro sarebbe minore e sopratutto si acquisirebbero tutte le features di eclipse in un attimo senza troppi sforzi.

Tra le altre cose , per arduino uno ne esiste una mooolto semplice sviluppata da jantje : http://www.baeyens.it/eclipse/ la consiglio caldamente.

ritratto di Gaetano Cinnirella

"syscall_sam2.o"

Buongiorno a tutti, sn un nuovo utente, ed è la prima volta che scrivo sul forum, Ho letto con attenzione la stupenda guida riguardante l'utilizzo di Eclipse come ide x arduino2. Trovo la cosa assi interessante e poiché sto "giocherellando" con Arduino due ho provato a metterla in atto. Arrivo alla mia domanda. Nel configurare l'IDE non trovo il file "syscall_sam2.o" da nessuna parte e tantomeno nel direttorio.. ArduinoLib2/Debug/syscall_sam2.o.
Non sono riuscito a capire dove ho sbagliato qualcuno può cortesemente darmi una mano a risolvere la cosa?
Grazie sin d'ora.
Gaetano

ritratto di zad

syscall_sam2.o

Buongiorno ,
scusa il ritardo , ma e' un bel po' che non guardavo l'articolo e non mi e' arrivata nessuna notifica.
In caso non avessi risolto:
la syscall_sam2.o e' il risultato della compilazione della prima parte del tutorial , ovvero la compilazione delle librerie core dell'arduino 2.
Se non trovi il file ,le cause possono essere molteplici:
1) Non hai compilato le librerie
2) Le hai compilate ma c'e' stato un errore durante il build
3) Non hai usato il profilo "Debug" ma "Release" , allora l'oggetto si trova in ArduinoLib2/Release/syscall_sam2.o

Spero di essere stato di aiuto
Zad

ritratto di GianlucaC

Problemi durante la configurazione dell'ambiente di lavoro

Zad, Ragazzi,
Buon giorno.
Sono un nuovo utente; Nonostante questo post sia fatto veramente bene continuo ad avere problemi. Ora mi spiego:
Quando creo il primo progetto (ArduinoLib2 per intenderci) senza nemmeno configurarlo, ho subito due messaggi di errore che riporto qui di seguito :

Program "arm-none-eabi-g++" not found in PATH
Program "arm-none-eabi-gcc" not found in PATH

Anche dopo la configurazione del progetto i problemi persistono.

Non sono un grande esperto di Eclipse e quindi chiedo il vostro aiuto per la soluzione.

i file arm-none-eabi-g++ e arm-none-eabi-gcc sono nel percorso :
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin

La mia variabile d'ambiente PATH contiene i seguenti percorsi :
/Applications/Arduino.app//Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin/arm-none-eabi-g++
/usr/bin
/bin
/usr/sbin
/sbin
/usr/local/bin
/usr/local/CrossPack-AVR/bin
/usr/X11/bin

Qui di seguito quello che sto usando :

Mac OSX 10.7.5
Eclipse Version: Juno Service Release 2 - Build id: 20130225-0426
Arduino due
Arduino IDE 1.5.2

Grazie in anticipo per il vostro aiuto ...

ciao

ritratto di zad

Il percorso e' errato

Il percorso e' errato :
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin/arm-none-eabi-g++

arm-none-eabi-g++ e' di troppo , va rimosso , ovvero :
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin/

Ciao

ritratto di GianlucaC

Zad, Grazie per la celere

Zad,
Grazie per la celere risposta.
Ho fatto un errore stupido !! :-)
Pero', ora, alla fine della configurazione, quando faccio il build, mi appaiono un errore ed un warning:

Errore : make: *** [variants/arduino_due_x/variant.o] Error 1
Warning : comparison between signed and unsigned integer expressions

Hai idea di cosa possa essere ?

Grazie

ritratto di GianlucaC

Scusa, aggiungo che nel

Scusa,
aggiungo che nel punto :

>>>“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,

nel tuo screenshot hai delle entry completamente diverse da me.
Io sono partito con 4 path :
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/arm-none-eabi/include/
/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/
alle quali ho aggiunto i 3 path che hai segnalato :
"${workspace_loc:/${ProjName}/variants/arduino_due_x}"
"${workspace_loc:/${ProjName}/USB}"
"${workspace_loc:/${ProjName}}"

ho sbagliato qualche cosa ?

ciao

ritratto di zad

RIcapitolando , non sei

RIcapitolando ,
non sei riuscito a compilare la libreria core giusto ?
Prova a aprire l'IDE Arduino2 e compilare un progetto semplice , tipo blink led, questo tutoria prevede che ci siano dei *.o presenti nella directory dell'ide nativo, se non si ha mai compilato nulla non sono presenti di default.
Ciao

ritratto di GianlucaC

Allora, ricapitolando?

Allora, ricapitolando?
Quando faccio il Build mi compaiono i seguenti errori :
make: *** [USB/CDC.o] Error 1
make: *** [variants/arduino_due_x/variant.o] Error 1

Pero', a differenza delle altre volte, non mi compare piu' nessun simbolo (x o !) sull icona dell ArduinoLib2 nel Project Explorer.

Devo proseguire con il tutorial o devo risolvere i due errori?

Grazie

ciao

ritratto di zad

Vanno risolti i 2

Vanno risolti i 2 errori.
Riprendi il tutorial dal principio e controlla di aver inserito tutti i parametri correttamente.
Inoltre compila un semplice progetto nell'Ide nativo dell'arduino due per generare i .o necessari.
Ciao

ritratto di Piero Boccadoro

Ed ovviamente, poi, facci

Ed ovviamente, poi, facci sapere com'è andata :D

ritratto di GianlucaC

Dopo un giorno di pausa ho

Dopo un giorno di pausa ho ripreso a lavorare su Eclipse/Arduino.
La situazione e' alquanto frustrante.

Dopo aver ripetuto l'installazione da capo per un paio di volte ho ottenuto sempre lo stesso problema.
Inoltre ad ogni Build si aggiunge (alle due che vi ho gia' mandato) una riga di errore sempre sui file .o
Sono arrivato ad averne 19 di errori, ma sono sicuro che continuando a fare il build aumenteranno ....
Ho fatto una ricerca ed i file .o indicati dagli errori sono in varie cartelle a partire dal percorso percorso :
....../workspace/ArduinoLib2/Debug
Nelle proprieta' dell progetto, in
C/C++ Build / Environment, la variabile PATH (che nel mio caso e' : /usr/bin:/bin:/usr/ibin:/ibin:/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin ) e' evidenziata in giallo chiaro mentre le altre due variabili CWD ed PWD no. E' normale ?

Per quanto riguarda l'IDE nativo, l'ho usato per un paio di mesi facendogli compilare svariati programmi (non e' un'installazione ex novo) quindi credo che i file .o ci siano: come faccio a verificarlo con certezza ?

Grazie

ritratto di zad

TImeOut

Ciao ,
appena ho un po' di tempo ricontrollo passo passo la procedura effettuando la configurazione su un'altro pc.
Una cosa non ho capito: ma almeno la libreria core riesci a compilarla ?
P.S.
il tuo path contiene degli errori :
/usr/ibin:/ibin
delle "i" di troppo

ritratto di GianlucaC

Rifatto tutto da capo

Rifatto tutto da capo correggendo il PATH, ma sono giunto agli stessi risultati.

Re : "Una cosa non ho capito: ma almeno la libreria core riesci a compilarla ?"
Non mi e' chiaro cosa intendi e come fare a verificare.

Attendo con ansia il ricontrollo della procedura.

Ricordati che ho un mac, io .

Grazie ancora

ciao

ritratto di zad

intendo tutto quello che

intendo tutto quello che precede il punto 3)Prima applicazione.
P.S. Il tutorial l'ho fatto da un mac ;)

ritratto di zad

Cose da controllare: 1)

Cose da controllare:
1) Attenzione al copia e incolla di “ARM Sourcery Mac OSX GCC C Compiler/Miscellaneous”, il "–nostdlib" ha un hipen , se come errore il compilatore riporta : –nostdlib no such file , vuol dire che hai incollato il carattere sbagliato , scrivi quindi a mano il trattino alto -.
2) Aggiungi nel PATH di sistema (.bashrc) il percorso alla crosschain , per controllare che sia aggiunto correttamente , apri un termina in OSX e scrivi arm poi premi il tab un paio di volte e dovrebbero apparirti le seguenti righe di auto completamento :
arm-
arm-elf-gdb arm-none-eabi-c++filt arm-none-eabi-gcc-ar arm-none-eabi-gprof ....
Dopo questa modifica riavvia OSX
3) In Other object del programma Blink2 l'oggetto e' syscall_sam3.o e non syscall_sam2.o , cmq nello screen shoot si vede la libreria corretta

4) In Linker flags, la riga di comando aggiunta deve stare tutta sulla stessa riga , eliminare gli a capo del copia incolla.

Io ho RI-seguito alla lettera il mio tutorial e sono riuscito a compilare tranquillamente , fai attenzione a i punti sopra indicati.
Ciao

ritratto di GianlucaC

Grazie ancora Zad, nella

Grazie ancora Zad,
nella mia variabile PATH il percorso della crosschain e' presente!
/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/g++_arm_none_eabi/bin/

infatti se scrivo da terminale arm- e faccio il doppio tab per il completamento, vedo i seguenti files :
arm-none-eabi-addr2line arm-none-eabi-g++ arm-none-eabi-gdbtui arm-none-eabi-ranlib
arm-none-eabi-ar arm-none-eabi-gcc arm-none-eabi-gprof arm-none-eabi-readelf
arm-none-eabi-as arm-none-eabi-gcc-4.4.1 arm-none-eabi-ld arm-none-eabi-run
arm-none-eabi-c++ arm-none-eabi-gccbug arm-none-eabi-nm arm-none-eabi-size
arm-none-eabi-c++filt arm-none-eabi-gcov arm-none-eabi-objcopy arm-none-eabi-strings
arm-none-eabi-cpp arm-none-eabi-gdb arm-none-eabi-objdump arm-none-eabi-strip

ma non vedo ne arm-elf-gdb ne arm-none-eabi-gcc-ar

Ho provato a cercarli nel file system, ma non li ho trovati.

A questo punto direi che il problema e' nalle crosschian.
La mia IDE arduino e' la 1.5.2.

Hai qualche idea ?

ritratto di zad

Va bene cosi', quelli che

Va bene cosi',
quelli che non vedi sono delle mie toolchain aggiuntive.
Ciao

 

 

Login   
 Twitter Facebook LinkedIn Youtube Google RSS

Chi è online

Ci sono attualmente 7 utenti e 62 visitatori collegati.

Ultimi Commenti