domenica , 15 Dicembre 2019
iten
Home » Elettronica » Configurare una toolchain GCC/Eclipse per STM32Nucleo - Parte I

Configurare una toolchain GCC/Eclipse per STM32Nucleo - Parte I

Questo articolo è diventato un po' datato, e nel frattempo sono cambiate un po' di cose. Non ho ancora avuto modo di aggiornarlo, anche perché nel frattempo ho cominciato a scrivere un libro sulla piattaforma STM32 in maniera più strutturata. Potete scaricare gratuitamente un'anteprima del libro che contiene tutti i passi necessari per installare la toolchain in ambiente Windows. Purtroppo, il libro è solo in inglese.

Nel mio precedente articolo sulla piattaforma di sviluppo STM32Nucleo di ST Microelectronics vi avevo lasciato con una descrizione sommaria delle caratteristiche hardware di questa board di sviluppo che è nata per essere compatibile con le shield Arduino UNO. Vi ho anche accennato al fatto che ST distribuisce un framework, denominato STM32Cube, nato per accelerare il processo di sviluppo sulla piattaforma di microcontrollori STM32, che vi ricordo essere dei micro a core ARM Cortex-Mx. Tuttavia, l'STM32Cube si basa prevalentemente su IDE commerciali, e l'ST non dà alcun supporto né aiuto per adoperare una eventuale suite free basata su GCC ARM (che possiamo adoperare grazie al fatto che i micro STM32 sono per l'appunto a core ARM-Cortex).

In questo articolo vedremo come configurare un insieme minimale di strumenti per ottenere una suite basata su GCC ed Eclipse Luna (la versione 4.4 di Eclipse). A differenza di altri tutorial che si trovano in giro, mi limiterò allo stretto necessario per ottenere che il led LD2 della nostra scheda STM32Nucleo lampeggi ad intermittenza. Eviterò quindi di farvi installare troppi strumenti contemporaneamente, cosa che contribuisce ad aumentare la confusione e l'intera curva di apprendimento di questa piattaforma. In pratica, alla fine di questo articolo avremo un eseguibile in formato binario che caricheremo con il software ST-Link Utility sulla nostra scheda, rimandando tutti gli aspetti connessi con il debugging in tempo reale in un prossimo articolo. Prerequisiti di questo articolo sono:

  • Windows XP SP3 (io userò XP, però dovrebbe andare bene anche Vista e 7) a 32 bit.
  • Una board STM32Nucelo (dovrebbe essere indifferente il modello) - io mi baserò sulla STM32Nucleo-F401RE.
  • Java 7 update 71 o successivi (va meglio usare Java 8 se avete Vista o 7) - aggiornate all'ultima versione di Java 7 prima di cominciare questo tutorial (si scarica da questa pagina); poi non dite che non vi ho avvertito.
  • Taaaaaaaaaaanta pazienza.
Attenzione: Vi consiglio calorosamente di mettere su una macchina virtuale con cui farete tutti gli esperimenti del caso, e che potrete poi eventualmente buttare via in caso di problemi. Vi sconsiglio di usare un PC di produzione/sviluppo che usate per altre cose. VirtualBox è un software di virtualizzazione gratuito, che vi richiederà poco tempo per configurare un'immagine Windows di prova. Quando poi avrete preso confidenza con tutti i prodotti di cui vi parlerò, potrete impostare direttamente il vostro PC fisico nel migliore dei modi e come più vi piace.

Installare Eclipse Luna

Il primo passo consiste nell'installare Eclipse, l'IDE su cui baseremo la nostra intera tool-chain. In realtà, per sviluppare su questo micro usando GCC non sarebbe necessario usare Eclipse. Tuttavia, per abbassare la curva di apprendimento è molto meglio usare un ambiente che fa molto lavoro per noi (anche se Eclipse non è proprio un tool per neofiti come l'IDE di Arduino).

Questo tutorial si basa su Eclipse Luna (la versione 4.4). Dovete scaricare da questa pagina la versione "Eclipse IDE for C/C++ Developers" per la vostra versione di Windows.

Schermata 2014-12-20 alle 17.04.53

Il file scaricato è un comune file ZIP che va scompattato nella cartella C:\STM32Toolchain (N.B.: quel path non è obbligatorio, ma lo assumerò tale lungo tutti i tutorial sull'argomento. Se lo cambiate, adattate le indicazioni di conseguenza). Alla fine vi troverete una directory denominata "eclipse" contenente tutto l'IDE (quindi C:\STM32Toolchain\eclipse). Lanciare il file eclipse.exe contenuto nella cartella "eclipse".

L'IDE partirà e la prima cosa che vi chiederà sarà il percorso dove posizionare tutti i progetti realizzati. Vi consiglio di adoperare il percorso C:\STM32Toolchain\projects.

Una volta che l'IDE è partito regolarmente, cliccare su Help->Install New Software....

Schermata 2014-12-20 alle 17.28.28

Successivamente selezionare il repository dei C/C++ Development Tool (CDT) ed installare solo il pacchetto della voce CDT Main Feature, come mostrato nell'immagine seguente.

Schermata 2014-12-20 alle 17.34.29

Fare click su Next e seguire le istruzioni. L'installazione richiederà un po' di tempo. Al termine, riavviare l'IDE come indicato, e proseguire con il passaggio successivo.

Installare il plug-in GNU ARM per Eclipse

Il passaggio successivo consiste nell'installare il plug-in per Eclipse per il cross compiler GCC per la piattaforma ARM Cortex. Il plug-in è stato sviluppato ed è manutenuto da Liviu Ionescu, il quale ha fatto un eccellente lavoro per semplificare tutta una serie di passaggi configurativi di Eclipse.

Procedere nel modo seguente. Andare sempre su Help->Install New Software... e cliccare sul bottone "Add...". Riempire le seguenti voci:

  • Name: GNU ARM Eclipse Plug-ins
  • Location: http://gnuarmeclipse.sourceforge.net/updates

e cliccare su OK. Dopo un po' apparirà una lista di plug-in disponibili. Selezionare i plug-in come nell'immagine seguente.

Schermata 2014-12-20 alle 17.44.45

Fare click su "Next" e seguire le istruzioni. Riavviare l'IDE come richiesto.

Installare la tool-chain GCC per ARM

Il passo successivo consiste nell'installare la tool-chain di compilatori e strumenti di debugging di GCC per ARM. Potete scaricare la versione precompilata per il vostro sistema operativo da qui. Io ho testato con successo la 4.8-2014-q3-update. Scaricate direttamente l'installer .exe ed eseguite il pacchetto. Installate i file nella directory C:\STM32Toolchain\gnu-arm\4.8-2014q3 (come detto in precedenza potete scegliere un qualunque percorso; io mi baserò su questi path). IMPORTANTE: alla fine dell'installazione, lasciate senza spunta la voce "Add path to environment variable". Procedere con il passo successivo.

Installare i Build Tools

Windows è da sempre deficitario di alcuni tool che sono un must nel mondo UNIX per la compilazione di sorgenti. Fra questi vi è make, il celebre tool realizzato da Richard Stallman per la compilazione di codice sorgente in C/C++. Nel caso in cui avete già installato su Windows un prodotto come MinGW potete adoperare i comandi messi a disposizione dalla suite. In alternativa (consigliato qui) installare il pacchetto dei Build Tools realizzato dallo stesso autore dei plug-in per GCC ARM di Eclipse e scaricabile da qui.  Scaricare il file .exe e lanciarlo. Installare il pacchetto in C:\STM32Toolchain\Build Tools.

Riavviare Eclipse.

Installare i driver ST Link per STM32Nucleo

Questo è un passaggio molto delicato. Seguitemi attentamente. Prima di installare ogni altro software, conviene installare i driver della scheda STM32Nucleo.

Importante: prima di installare i driver, scollegate la vostra scheda Nucleo dalla porta USB del PC.

Il primo passo consiste nell'installare i driver della vostra scheda Nucleo. Come detto nel precedente articolo, le schede Nucleo integrano anche un programmatore in-circuit ST-Link, nello specifico la versione 2.1. Dovete quindi scaricare i driver aggiornati da qui per il vostro sistema operativo. Installate i driver, collegate la scheda ed assicuratevi che tutto funzioni (nelle periferiche hardware, tutte risultano correttamente installate). Solo allora procederete con i prossimi passi.

Importante: una volta installato il driver, dovete anche installare il tool di aggiornamento del firmware della scheda, disponibile qui, e seguire le istruzioni. Questo passo è molto importante!

Installare STM32CubeMX e ST-Link

I processori della famiglia STM32 richiedono una configurazione hardware iniziale per poter funzionare correttamente. Chi conosce il mondo Arduino, diciamo che nel mondo STM32 esiste un processo analogo a quello di configurazione dei fuses. Tuttavia, le operazioni da fare sono molto più complesse, e vanno fatte nella fase di bootstrap del micro. Per facilitare questo compito, ST ha messo a disposizione un tool che si chiama STM32CubeMX. Questo programma ci servirà successivamente. Nel frattempo cominciatelo a scaricare da qui (il link si trova in fondo alla pagina). Installatelo con le impostazioni standard di ST.

In questo articolo non adopereremo strumenti di debugging dall'IDE, ma ci serviremo del tool ST-Link Utility per uploadare il binario sulla flash del micro. Scaricate questo tool di ST da qui. Installatelo con le impostazioni standard di ST.

Importante: installate ST-Link Utility solo DOPO aver installato i driver della vostra Nucleo, altrimenti ci sono diversi problemi di conflitti con i driver. Mi è capitato a me e non è stato facile risolverli.

Una volta installato l'ST-Link Utility eseguirlo e provate a connettervi con la vostra scheda, per verificare che tutto è OK.

Creare un progetto di test

Abbiamo fatto gran parte del lavoro. Ora si tratta di provare che tutto funzioni a dovere.

Per prima cosa lanciate Eclipse e cliccate su File->New->C Project. Se, come me, avete una board STM32Nucleo-F4 impostate tutto come nella capture seguente, altrimenti scegliete la famiglia della vostra board. Date come nome al progetto "test1", o quello che più vi piace, e cliccate su "Next"

Schermata 2014-12-20 alle 18.58.16

Nel passaggio successivo si tratta di scegliere la famiglia esatta del chip. Nel caso della Nucleo-F401RE la famiglia corretta è STM32F401xE. Attenzione: assicuratevi di scegliere la famiglia giusta per il vostro chip. Impostate tutti i parametri come nella capture sotto.

Schermata 2014-12-20 alle 19.02.42

Cliccate su "Next". Nelle prossime due schermate lasciate tutto invariato. Nella schermata relativa alla tool-chain impostate questi valori:

Toolchain name: GNU Tools for ARM Embedded Processors (arm-none-eabi-gcc)
Toolchain path: C:\STM32Toolchain\gnu-arm\4.8-2014q3\bin

Cliccate su "Finish".

Ora, se siete un po' a digiuno di Eclipse, la schermata che vi si parrà dinanzi potrebbe confondere le idee. Eclipse è un IDE multifinestra (si chiamano perspective nel gergo di Eclipse) e le vare finestre possono essere organizzate in vari modi a seconda del contesto operativo in cui ci troviamo. Ora è un po' complicato nello spazio di questo articolo descrivere l'interfaccia di Eclipse. Per il momento vi esorto a cliccare sulle icone evidenziate dai cerchi rossi nella capture successiva.

Schermata 2014-12-20 alle 22.16.28

Dopo un po' di click vi ritroverete un'interfaccia simile a questa qui sotto.

Schermata 2014-12-20 alle 22.22.50

Compilare il progetto di test

Prima di poter compilare il nostro progetto di test, manca ancora qualche passaggio. Tuttavia, cominciamo a familiarizzare con l'IDE e proviamo a compilare. Andiamo su Project->Build all. Dopo qualche secondo apparirà la console del compilatore, che genererà questo messaggio di errore:

Schermata 2014-12-20 alle 22.26.36

L'IDE ci sta dicendo una cosa molto semplice: non riesce a trovare il comando make.exe che occorre per compilare l'albero dei sorgenti. Se vi ricordate, ad un certo punto abbiamo installato i Build Tool, che forniscono per l'appunto questo comando. Dobbiamo specificare il path dei Build Tool all'IDE.

Andiamo su Window->Preferences. Ci apparirà la finestra di impostazione dell'IDE, con tutte le configurazioni. Andiamo su C/C++->Build->Environment e clicchiamo su Add.

Schermata 2014-12-20 alle 22.34.30

Nel campo "Name" immettiamo il valore Path e nel campo "Value" scriveremo quanto segue: C:\STM32Toolchain\Build Tools;${Path}. Clicchiamo su "OK", poi su "Apply" e infine su "OK".

Rilanciamo il processo di compilazione cliccando su Project->Build all. Questa volta la compilazione durerà di più, segno che sta andando tutto ok. Al termine ci ritroveremo con questo messaggio in console.

Schermata 2014-12-20 alle 22.37.36

Bingo. Abbiamo ottenuto il nostro primo binario per STM32. Il più è fatto.

Caricare il binario sulla board STM32Nucleo

Per caricare il binario sul micro target, per il momento ci avvantaggeremo di ST-LINK Utility. Lanciamola, colleghiamo la board al PC (se non l'abbiamo ancora fatto) e andiamo su Target->Connect. Il LED LD1 (affianco al connettore mini USB) comincerà a lampeggiare in maniera alternata verde/rosso e ci appariranno le informazioni circa il chip presente sulla nostra board Nucleo. A questo punto non ci resta che andare su Target->Program & Verify.... Ci apparirà una finestra di selezione file. Dirigiamoci in C:\STM32Toolchain\projects\test1\Debug e selezioniamo il file test1.hex. Ci apparirà la seguente finestra di dialogo.

Schermata 2014-12-20 alle 22.46.08

Clicchiamo sul pulsante "Start". Dopo pochi istanti il processo di upload è terminato.

Fine. Abbiamo con successo programmato la nostra board. 🙂

Adattare il codice alla board Nucleo

A questo punto l'entusiasmo si è già bello che spento: il LED verde LD2 tutto fa tranne che lampeggiare. Non vi scoraggiate. Altri pochi passi e abbiamo risolto.

Il codice generato dal plug-in di Eclipse si basa sull'hardware delle board STM32 Discovery, che sono delle board di sviluppo differenti dalla Nucleo per quanto riguarda il pinout scelto dai progettisti. In pratica il LED di stato è mappato su un pin diverso sulla Discovery. Inoltre, il plug-in genera codice per una board dotata di oscillatore esterno. La mia Nucleo (STM32Nucleo-F401RE) non ha l'oscillatore esterno. Ho dato uno sguardo alle varie Nucleo, ed ho visto che alcune ce l'hanno e altre no. Tuttavia, la soluzione che vi sto per proporre io permetterà di generare codice corretto su tutte le Nucleo. Vediamo come.

Per fare ciò ci avvantaggeremo del tool STM32CubeMX che abbiamo installato qualche paragrafo fa.

Quando abbiamo installato il CubeMX non vi ho detto che in realtà ST distribuisce una versione plug-in di questo tool per Eclipse. Sembrerebbe la scelta più sensata, perché automaticamente vi permette di interagire con il vostro progetto. Tuttavia, io ho avuto grossi problemi ad usarlo con il mio Eclipse. Mi manda il programma in crash rendendolo inusabile. Io sospetto che questa cosa si debba ad una versione di Java: probabilmente vuole Java 8. Fate delle prove, magari quando leggerete questo articolo esisterà una versione aggiornata. Alla fine il lavoro svolto è lo stesso, quindi ci limiteremo ad usare il programma standalone

Lanciate il programma e cliccate sulla voce "New Project". Cliccate sul tab "Board Selector". In "Type of Board" scegliate Nucleo, e in "MCU Series" scegliete la serie della vostra Nucleo. Nel mio caso la STM32F4. Dopo di che, nella colonna "Peripheral Selection" aggiungete "1" alla riga Led e Button e nella "Board List" scegliete la vostra board. Ecco il risultato nel caso della Nucleo-F401RE.

Schermata 2014-12-21 alle 07.28.23

Cliccate su "OK". Vi apparirà l'immagine della vostra MCU con la configurazione dei PIN.

Schermata 2014-12-21 alle 07.29.47

Non entrerò nei dettagli di questo programma. Ci ritornerò in un prossimo articolo. Per il momento vi dico di andare su "Project->Generate Code" e di riempire il form come nella capture seguente.

Schermata 2014-12-21 alle 07.33.10

In pratica, CubeMX non farà altro che generare dei file sorgenti che contengono la configurazione (righe di codice C) del nostro hardware. Cliccando su "OK" ci verrà chiesto se vogliamo scaricare l'ultima release del framework STM32CubeF4 (al momento della scrittura di questo articolo, la 1.3.0). Nel nostro caso cliccheremo su "NO", dato che il plug-in di Eclipse già inserisce nel nostro progetto generato tutto il framework per noi. Nel messaggio successivo cliccheremo su "Continue". Al termine della generazione del codice clicchiamo su "Open Folder" ed entriamo nella cartella "src". Apriamo il file "main.c" e copiamo tutto il codice contenuto all'interno della funzione SystemClock_Config(void), che nel caso della mia Nucleo è il seguente.

Questo codice è in pratica l'inizializzazione corretta dell'oscillatore (interno nel caso della mia Nucleo) e di conseguenza del clock di sistema. I processori STM32 hanno un fase di configurazione del clock tutt'altro che banale, come potete vedere voi stessi. La generazione del codice del tool CubeMX è una manna caduta dal cielo, perché ci permette - almeno per ora - di non andare a leggere il datasheet monstre del micro della nostra board.

Quindi, copiamo il codice contenuto nella funzione. Torniamo poi in Eclipse, ed apriamo il file _initialize_hardware.c contenuto in "src". Sostituiamo il contenuto della funzione configure_system_clock(void) con quello che abbiamo copiato in precedenza. Manca poco.

Ora, dobbiamo rimappare il pin del LED LD2. Sempre in Eclipse, andiamo in "include" ed editiamo il file BlinkLed.h. Alla riga 30 modifichiamo la porta e il pin del led in questo modo:

In pratica stiamo configurando il codice in modo da usare il pin A5. Salviamo tutti i file (Attenzione: assicuratevi di salvare i file, perché Eclipse non lo fa automaticamente per noi quando lanciamo la compilazione) e ricompiliamo il file eseguibile.

Carichiamo il codice sulla nostra scheda con il tool ST Link Utility et voilà: finalmente il nostro LED LD2 lampeggia 🙂

Attenzione: su questa cosa ci sono sbattutto 4 ore. 4 maledettissime ore della mia vita sprecate per una cosa che per me è assurda. Il programma ST Link Utility non effettua il caricamento del file .hex ogni volta che lo modificate, ma lo fa solo all'atto della sua prima apertura e se lo tiene in memoria. Quindi, quando voi cliccate su "Program & Verify" state in realtà caricando la vecchia immagine binaria generata, e non la nuova (ovviamente se non avete chiuso il programma nel frattempo). Si deve prima chiudere il file test1.hex e poi riaprirlo. Il file si chiude cliccando con il tasto dx del mouse sul tab contenente il nome del file, come mostrato nella capture sotto.

Schermata 2014-12-21 alle 07.53.06

In alternativa, potete cliccare sulla voce "Open File" sempre nello stesso menu a tendina. Il file verrà ricaricato.

Siamo quindi riusciti a far funzionare la nostra scheda Nucleo. Insomma, indubbiamente siamo lontani dalla velocità e semplicità di Arduino, ma stiamo parlando di ben altra piattaforma.

Nel prossimo articolo vi farò vedere come configurare il debugger per effettuare operazioni di debugging passo passo dallo stesso IDE. A presto.

 

Questo articolo fa parte di una serie di tre post. La seconda parte è disponibile qui, la terza qui.

 


Check Also

Compilare micropython per una scheda STM32Nucleo-F4

Chi mi conosce sa che il mio linguaggio di programmazione preferito è Python. Ho scritto …

33 comments

  1. Ciao, grazie per il tutorial.
    ...magari un giorno anche ST ci delizierà di un tool "preconfezionato" come LPXpresso...

    Credo che il link ai Build Tools sia errato, dovrebbe essere questo?
    http://sourceforge.net/projects/gnuarmeclipse/files/Build Tools/

  2. Ciao Carmine, volevo avere un tuo parere su questo tool http://visualgdb.com/tutorials/arm/stm32/nucleo411re/ che mi ha concesso di compilare il sample blink led e di effettuare il debugging del tutto in meno di 30 minuti !

    Visual Studio Community è gratuito, l'addin di Visual GB costa una inezia e apparentemente ho un ambiente di sviluppo professionale per le STM Nucleo pari a quello che otterrei con Keil o IAR per migliaia di euro!

    Visto che è troppo bello per essere vero, mi piacerebbe avere un tuo parere sul tema
    Ciao Roberto

    • Carmine Noviello

      Ciao Roberto,
      purtroppo non ho esperienza diretta e quindi non ti so dire, anche perché io ad oggi con l'accoppiata Eclipse/GCC mi sto trovando bene. Ti assicuro, inoltre, che almeno per quanto riguarda IAR, secondo me il gioco non vale la candela. Sono costretto ad usarlo su altra piattaforma (8051) e ti dico che tra bug del compilatore e altri, quello che costa non vale proprio.
      Mi hanno anche parlato bene di CocoX http://www.coocox.org/index.html, ma non l'ho ancora provato.

  3. Ciao Carmine, grazie per il tutorial, che è scritto veramente bene. Volevo informarti che con l'ultima versione di eclipse luna (4.5) sembra che non sia più necessario impostare manualmente il path dei Build Tool all’IDE... in pratica, la compilazione del programma di test va a buon fine al primo colpo, senza generare errori. Inoltre, ho aggiornato il mio XP (SP3) a l'ultima versione di Java ed apparentemente non ho nessun problema. CubeMX ha fatto egregiamente il suo dovere ed il LED2 della mia F401 ora lampeggia come descritto. Spero che queste piccole informazioni ti ritornino utili per altre eventuali prove.

    Marcello

    • Carmine Noviello

      Ciao Marcello,
      ti ringrazio per l'informazione. Purtroppo questi tool sono in continua evoluzione e basta un niente che le informazioni riportate non sono più aggiornate. I feedback sono importantissimi per tenere queste guide "active" 😉

  4. Ho una NUCLEO STM32L053, sai se c'è un modo per poter seguire il tuo tutorial e programmare con eclipse questa board?

    • Ciao Luca,
      questo tutorial qui

      http://www.carminenoviello.com/en/2015/06/04/stm32-applications-eclipse-gcc-stcube/

      è più generico e ti permette di mettere su un progetto anche per la tua Nucleo.

      Fammi sapere.

      • Ciao Carmine,
        Grazie per la risposta, ho provato il tutorial e sono riuscito a compilare correttamente e a programmare la board con successo ma il led non lampeggia.
        Parallelamente però ho istallato anche la tool chain di openstm32 chiamata System Workbench for STM32 - Bare Metal Edition. Con questa seguendo il tuo tutorial sono riuscito a far lampeggiare il led. Devo dire che è molto più semplice in quanto configura tutto l'HAL da sola non devi fare altro che copiare i file dell'esempio e compilare. Inoltre il risultato è un file .bin che volendo può essere caricato direttamente nel drive virtuale che istalla nel sistema la board.

  5. Ciao Carmine,
    complimenti per la chiarezza dei post.
    Di recente ho approntato una tool-chain su windows 7 e oggi incoraggiato dal fatto che cubeMX gira su Mac, ho pensato perché non fare una tool-chain su Mac? Ho seguito questo post e ha funzionato anche sul mio Mac-Book, tutto ok fino all'ST-LINK utility... 🙂 adesso che ho il binario come lo carico sulla scheda?
    Intendo: c'è un modo per chiudere la tool-chain su Mac o devo passare obbligatoriamente su windows?
    Grazie

    • Ciao Raffaele,
      su Mac ti conviene direttamente installare OpenOCD, descritto nella seconda parte. I binari per Mac li trovi qua:

      https://github.com/gnuarmeclipse/openocd/releases

      Altrimenti nel mio libro è descritta la procedura di compilazione.

      • Grazie mille, stasera provo.
        Qui http://gnuarmeclipse.github.io/debug/openocd/ leggo che c'e' un ulteriore plug-in per Eclipse che lo fa lavorare meglio con OpenOCD... ma non e' chiaro se in realta' poi sia sufficiente installare questo: http://gnuarmeclipse.github.io/openocd/ mi sembra un po' confuso.
        Raffaele

        • Il plug-in dovrebbe essere automaticamente installato quando vengono installati tutti gli altri plug-in di GNU ARM Eclipse.
          Tuttavia, il plug-in è comunque un front-end all'accoppiata GDB+OpenOCD, quindi ti serve comunque installare OpenOCD per la tua piattaforma.

          • Ciao Carmine,
            ho installato e configurato tutto secondo i vari passi anche se per il momento non funziona fino in fondo :). OpenOCD e' attivo, (comunico anche col telnet) ma forse ho generato male il binario per la flash, perche' se lo prendo e lo carico con ST utility (windows) non funziona ugualmente.
            Grazie per i chiarimenti.
            Raffaele

          • Apri il file ldscripts/mem.ld e assicurati che la FLASH sia mappata da 0x08000000, ossia trovi questo dentro:

            MEMORY
            {
            FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 64K
            RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 8K

            Attenzione: LENGTH dipende dal tuo micro!!

  6. Sì ok questo è regolare. Grazie. Starò facendo qualche errore altrove.

  7. Dunque sembra che tutto sia funzionante, l'OpenOCD lavora correttamente, carica la flash. Tuttavia quando attivo il debug in Eclipse, non si ferma ai breakpoints: il thread è running (posso metterlo in pausa e farlo ripartire)... e quindi non riesco ad avanzare step by step. Nonostante sia running non vedo le trace_printf.
    Nella debug configuration ho creato una configurazione di tipo "GDB OpenOCD Debugging" penso sia corretta, ho seguito quanto spiegato nel capitolo 5.
    Se hai suggerimenti sono ben accetti 🙂

    • Dunque, per il discorso breakpoint, non è che nella perspective Debug è attiva l'icona "Skip all breakpoints" sulla toolbar di Eclipse? Lo puoi anche verificare dal menu "RUN".

      Per il discorso della trace_printf() assicurati che nella configurazione di debug di tipo "GDB OpenOCD Debugging" sia attiva la spunta "Enable ARM semihosting" nella sezione "Startup", e che il progetto sia compilato con le giuste macro OS_USE_TRACE_SEMIHOSTING_DEBUG e OS_USE_SEMIHOSTING.

  8. anche io ho avuto quel sospetto sui breakpoint un attimo dopo averti scritto 🙂 ma erano in regola.
    Semplicemente si blocca prima di arrivare al main, un problema di codice che devo indagare meglio.
    Per quel che riguarda le trace: ho aggiunto sotto: project->properties->C/C++ General->Paths and Symbols la definizione di "TRACE" e ho scommentato quella di OS_USE_TRACE_SEMIHOSTING_DEBUG come mi avevi suggerito tu e ora le trace funzionano.
    Grazie mille.
    Raffaele

  9. La programmazione del PLL per la F446RE non era corretta. Ora funziona tutto alla perfezione. La tool-chain su Mac ora è completa :).
    Grazie soprattutto alle tue competenze.
    Saluti

  10. Ciao, grazie per il tutorial! Devo utilizzare una board wifi X-NUCLEO IDW01M1 per un progetto di lavoro.
    Vorrei sapere se si potrebbe, secondo te, montare su un semplice arduino e utilizzare con l'IDE arduino.
    I connettori dovrebbero essere compatibili...

    • Carmine Noviello

      Ciao,
      purtroppo non ho mai giocato con questa shield e non ho idea non tanto della parte di connettorizzazione, che credo sia compatibile, ma piuttosto del costo computazionale della parte software, che potrebbe non essere alla portata di un Arduino UNO. Vanno fatte delle prove.

  11. Ciao Carmine,
    hai una vaga idea se il tool chain con tutte le fautures che hai descritte qui è possibile crearlo anche sotto linux?
    Grazie mille Lucio

    • Carmine Noviello

      Ciao Lucio,
      a grandi linee è la stessa installazione. L'unica differenza è che OpenOCD ti conviene compilarlo dai sorgenti. Altrimenti qua li trovi già compilati.

      In alternativa trovi spiegato tutto passo per passo nel mio libro.

  12. Ciao Carmine,
    Mi sono 'regalato' pochi giorni fa una board Nucleo STM32412ZG e ho seguito le tue istruzioni, apprezzando la precisione e dovizia di dettagli (complimenti!!), per crearmi la toolchain GCC/Eclipse. Tutto e' andato perfettamente come da istruzioni, sino a quando non ho provato a creare il primo programma di test: la mia board non risulta supportata!
    Sapresti dirmi se/come si puo' aggirare l'ostacolo?
    Grazie. Pier

    • Dovrebbe andarti bene usare anche l'STM32F411xE, e poi specifici una flash di 1024 KB.

      Poi, nella parte di codice dovrai specificare:

      #define BLINK_PORT_NUMBER (1)
      #define BLINK_PIN_NUMBER (7)
      #define BLINK_ACTIVE_LOW (0)

      Dovrebbe andare.

      • Grazie Carmine per le 'dritte'. Tutto e' andato alla perfezione, sono riuscito a programmare la mia board e ho il mio led che blinka!!
        Ci sono alcuni passaggi che rispetto alle descrizioni nell'articolo sono leggermente cambiati (es. aggiornamento dei tool come accennavi tu), ma con qualche piccolo aggiustamento ho completato tutti i passaggi.
        Ora iniziero' a divertirmi (spero) con questa board.
        A presto ciao!
        Pier

        • Si purtroppo alcune cose sono cambiate. Per quanto riguarda la tool-chain, trovi informazioni più dettagliate nell'anteprima gratuita del mio libro. Però a questo punto non credo che ti servano.

  13. Ciao Carmine,
    son finito sul tuo sito cercando qualcosa in stile "getting started" per cominiciare a lavorare con le Nucleo ST. Il tuo libro tratta in termini pratici le nucleo?
    Il problema piu grosso che sto riscontrando e' trovare una guida che ti spieghi passo passo come creare un programma, le funzioni da utilizzare, e un ambiente semplice in cui programmare (un po' in stile Arduino per intenderci). Ho fatto qualcosa con MBED ma sempre modificando il lavoro d'altri...insomma vorrei trovare un percorso da seguire che mi permetta di crescere.

    Non ultimi, i miei complimenti, hai una cultura in tecnologia impressionante, e riesci anche a scrivere in un italiano scorrevole, non e' da tutti!

    Grazie,
    M.B

    • Ciao,
      ti ringrazio per i complimenti.

      Tutti gli esempi del mio libro si basano sulle sedici Nucleo-64. Tuttavia, io credo che il mio libro insegna i concetti di base di questa piattaforma, e quindi dovrebbe essere facile adattare gli esempi ad alte schede STM32.

      Tieni però presente che io nel libro assumo che il lettore abbia un minimo di confidenza con la programmazione embedded. In pratica è un libro per chi vuole fare "il salto", ma non è un libro per chi comincia.

  14. Salve, ringrazio per la guida...sono arrivato a fare i ìl debug del codice.. sto avendo problemi con l'ultima parte della guida, ovvero "Stampa di messaggi via ARM Semihosting"...non sono riuscito a configurare il tutto...
    potreste darmi indicazioni più dettagliate? (ad esempio non ho capito la porta 4444 dova va configurata)...è possibile avere una guida in pdf ? grazie mille

  15. Buonasera Carmine, complimenti per la guida. Molto chiara e senza troppi orpelli.
    Volevo chiederle se poteva darmi una mano, ho seguito i suoi passaggi, ma alla fine mi viene creato un file .hex vuoto. Ho controllato che il box dell'image flash sia checkato come scritto in rete e così è, cosa potrebbe essere?
    Inoltre non credo di aver colto bene la mappatura dei pin indicata su CubeMX.
    Grazie, buona serata.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.