Uso di Eclipse per i progetti per ARM7TDMI - Creazione di un nuovo progetto

Uso di Eclipse per i progetti per ARM7TDMI
Creazione di un nuovo progetto
Avviare Eclipse e scegliere la workspace che contiene i progetti per LPC2103:

Premere OK.

Se non appare già scritto il giusto percorso, basterà cercare la cartella workspace_2103 con Browse:

per poi premere OK.

Entrati nell'ambiente di Eclipse, per creare un nuovo progetto bisogna abbassare la tendina File, New ->
Makefile Project with Existing Code:

digitare il nome (*) del progetto che si intende creare nella riga Project Name e premere Finish.

(*) Si consiglia di non inserire spazi e caratteri speciali nel nome per evitare errate interpretazioni da
parte del sistema operativo.

Si noterà che nella sezione Project Explorer sulla sinistra viene creata una nuova cartella (per il momento
vuota) denominata come abbiamo scelto.

Normalmente un progetto nuovo rappresenta una evoluzione di prove e progetti già creati
precedentemente. In questo articolo immaginiamo di creare il nuovo progetto da uno precedente
denominato LCD.

Vogliamo per prima cosa importare i diversi file sorgente del precedente progetto.
A tale scopo, selezioniamo col tasto destro del mouse il nuovo progetto ADC_LCD e scegliamo
Import... (oppure, avendo selezionato la cartella ADC_LCD, scegliamo File -> Import...):

come mostrato in figura dobbiamo selezionare File System della cartella General.
Dopo aver premuto Next > cerchiamo con Browse

la cartella LCD che contiene i file sorgente che vogliamo importare:

e premiamo OK.

Nella finestra di destra possiamo selezionare i file che intendiamo importare e premere infine Finish.
Se ora espandiamo la cartella del nuovo progetto possiamo notare la presenza di tutti i file importati:

Ora entriamo nella fase in cui dobbiamo scrivere il codice del main.c.
Facciamo doppio click su main.c della scheda Project Explorer del nuovo progetto su stiamo lavorando e
modifichiamo il codice nella finestra centrale di editing.
Il correttore in-line ci aiuta nel correggere il più possibile errori di sintassi.

Qui di seguito è riportato il testo del file main.c del progetto ADC_LCD usato come esempio:

/*   ********************************************************
 *   File name : main.c
 *   Project   : ADC_LCD
 *   Abstract : write ADC Nout CH0 on LCD
 *   Date      : may 2013
 *   Author    : Stefano Salvatori
 *   Course    : "Microelettronica" - 2013
 *   ********************************************************/

/**********************************************************
                  Header files
 **********************************************************/
#include "lpc2103.h"
#include "framework.h"
#include "HD44780.h"

/**********************************************************
                       MAIN
**********************************************************/

int    main (void) {
       int ADCdata;

Initialize();          // Initialize the system

       InitLCD(); // Initialize the LCD
       PutCommand(DISPLAY_CLEAR); delayMs(5);
       PutCommand(RETURN_HOME);   delayMs(5);

       PINSEL1 |= 0x00003000; // sel CH0 of ADC
       ADCR = 0x00200301;
       delayMs(1); // a short delay

       // endless loop
       while (1) {
             // read ADC value
             ADCR = ADCR & 0xFEFFFF01; // set ADC read on CH0
             ADCR |= (1 > 6)&0x3FF; //read 10 bit ADC data

               PutCommand(RETURN_HOME);   delayMs(5);
               Write_ndigitsval(ADCdata, 4); // write the ADC value

               delayMs(500);
       }
}

Compilazione
Per avviare la compilazione basterà lanciare: Project -> Clean...

Come mostrato in figura, conviene selezionare «Clean project selected below» e spuntare il nostro nuovo
progetto. Per avviare la compilazione subito dopo il clean, spuntiamo Start a build immediately e
scegliamo Build only the selected projects.
Premiamo OK.

In console (in basso) noteremo che appaiono tutti i messaggi che avevamo già osservato durante le
operazioni di compilazione che effettuavamo da terminale.

Al solito, se tutto va a buon fine, l'ultimo messaggio rigurda la dimensione del codice, nonché la scritta
*** FINISHED! ***

Verifica del funzionamento
Allestiamo l'hardware della scheda. Quando siamo certi che tutti i collegamenti sono stabili e corretti
(soprattutto quelli relativi alle alimentazioni), colleghiamo il cavo USB della scheda eng4arm.

Apertura sessione OpenOCD
Abbassiamo la tendina Run e selezioniamo External Tools -> External Tools Configurations...

Le impostazioni dovranno coincidere con quelle riportate nella seguente figura:

in cui si nota che l'argomento riguarda proprio openocd con il file di configurazione contenuto nella
cartella install della Scrivania.

Premiamo Run.

Viene avviato openOCD e si dovrà visualizzare un messaggio in Console del tipo riportato nella seguente
figura.

In particolare l'ultima riga deve riportare che sono possibili 2 breakpoint.

Avvio della sessione di debug con GDB
Per fare in modo che all'avvio di una sessione di debug Eclipse chieda di cambiare prospettiva (passando
da quella corrente "C/C++" a "Debug" abbassiamo la tendina Window e selezioniamo Preferences:

Espandiamo Run/Debug e selezioniamo Perspectives.

Selezioniamo «Prompt» per «Open the associated perspective when launching»:

premiamo OK.

Per avviare correttamente la sessione di debug, in cui la prima volta deve anche avvenire la scrittura del
codice nella flash del micro, dobbiamo impostare Eclipse per lanciare correttamente i comandi verso
OpenOCD con GDB.

Abbassiamo la tendina Run e selezioniamo Debug Configurations...
Sotto a Zylin Embedded Debug dovrebbe essere già presenti le due possibili configurazioni:

       write_flash

       debug_only

Nella prima scheda Main dobbiamo correttamente inserire il nome del progetto attuale. Per questo
bisogna premere Browse e selezionare ADC_LCD :

(nel caso di figura c'è un solo progetto aperto e quindi si ha solo il progetto corrente, nel caso generale si
ha pure l'ultimo progetto che è stato affrontato).

Osserviamo che la scheda Commands sia correttamente compilata:

altrimenti nella sezione 'Initialize' dobbiamo scrivere:

     target remote localhost:3333
     monitor targets
     monitor reset init
     monitor targets
     monitor flash erase_sector 0 0 7
     monitor flash write_image /home/ubuntu/Desktop/workspace_2103/ADC_LCD/
main.hex 0 ihex

mentre in quella 'Run'

       monitor soft_reset_halt

N.B. nella linea di comando «monitor flash write_image» si deve essere certi che ci sia l'intero percorso
del file main.elf che bisogna scrivere in flash. In particolare, l'ultima directory del percorso deve riportare
il nome del progetto che stiamo verificando (ADC_LCD).

Se abbiamo fatto qualche modifica, dobbiamo premere Apply e poi Debug (altrimenti solo quest'ultimo).

Avendo impostato la scelta della prospettiva da Prompt, apparirà la richiesta di cambio:

Se vogliamo che questa domanda non ci venga sempre posta, spuntiamo Remember my decision.
Premiamo OK.

Si sarà notato che nel frattempo la sessione di debug con il lancio dei comandi verso OpenOCD era già in
corso.
I messaggi riportati in Console, del tutto identici a quanto trovavamo nelle sessioni eseguite da Terminale,
devono essere osservati. In particole, si verifichi la presenza del messaggio che riporta il tempo di
scrittura della flash evidenziato nella figura seguente. (Se il messaggio è assente e è segnalato un
eventuale errore, significa che la scrittura non è andata a buon fine e si dovrà ripetere il tentativo
correggendo gli eventuali errori. In questo caso si vada alla sezione che descrive la Chiusura di una
sessione di debug).

L'ultimo comando (soft_reset_halt) invia un reset al processore e lo pone in halt.

Eclipse è stato impostato perché l'esecuzione, se lanciata, si arresti comunque al main.
Per far ciò dobbiamo premere Resume (l'icona col simbolo tipo play di un registratore) oppure F8.
Nella seguente figura la freccia (del mouse) indica il tasto resume da premere.

Premuto resume (forse a volte serve un paio di volte) si deve osservare che il cursore è fermo alla prima
istruzione del main come nella seguente figura:

Si noti pure che l'istruzione che ancora deve essere eseguita (Initialize) è pure evidenziata.

A questo punto possiamo procedere con l'esecuzione passo-passo oppure lamnciando definitivamente il
codice, o ancora nserendo un breakpoint prima del lancio.

Esecuzione passo-passo
Per l'esecuzione passo passo abbiamo due possibilità (offerte da GDB):

       esecuzione passo-passo anche dentro le funzioni che vengono chiamate;

       esecuzione passo passo considerando una funzione chiamata come unica istruzione.

Per il primo caso dobbiamo premere il tasto «Step Into», nel secondo quello denominato «Step Over».
Entrambi sono rappresentai come frecce ricurve gialle ne si trovano sulla stessa linea di resume, a destra.

Inserimento di un breakpoint
Vogliamo lanciare il programma facendo eseguire tutta la parte di codice che riguarda l'inizializzazione
del sistema e fermarci alla prima istruzione del ciclo infinito del main.

Come mostrato in figura, facciamo doppio click col mouse all'altezza dell'istruzione a cui intendiamo
fermarci nella zona evidenziata sulla sinistra della finestra di editing:

Se premiamo resume (o F8) noteremo che il cursore si arresta proprio nel punto indicato.

N.B. Trattandosi di breakpoint di tipo hardware, nel caso di codice residente in flash, il numero di
breakpoint è limitato a due. In realtà un breakpoint è già usato dal debugger e quindi a nostra
disposizione c'è un solo breakpoint.

In base alla nota precedente, se vogliamo arrestare l'esecuzione in un altro punto, prima di inserire il
nuovo breakpoint dobbiamo togliere quello precedente.
Per esempio vogliamo lanciare il codice fino all'acquisizione del valore convertito dall'ADC, dobbiamo
fare doppio click nel punto in cui avevamo inserito il precedente breakpoint e un altro doppio click nella
nuova posizione:

L'esecuzione, come indicato dal cursore, è ovviamente ancora bloccata al punto precedente. Premiamo
resume e osserviamo che l'esecuzione si arresta nel nuovo punto.

Eseguiamo ora il codice con Step Over (o F6) per osservare l'aggiornamento del dato acquisito sull'LCD.

Se vogliamo lanciare definitivamente il programma, togliamo il breakpoint e premiamo resume.

Termine della sessione di Debug
Per terminare la sessione di GDB si può premere Terminate (tasto rosso quadrato):

Sia in Console che nella finestra superiore sono indicati i messaggi relativi alla chiusura della sessione.

N.B. Non si deve usare terminate per chiudere OpenOCD perché non ha effetto. Lasciare per ora
OpenOCD in funzione non causerà alcun problema.

Avvio di una nuova sessione di debug senza scrittura nella flash
Se vogliamo avviare una nuova sessione di debug sul codice già scritto nella flash senza nessuna
modifica è del tutto inutile (e antieconomico perché i cicli di scrittura della flash sono di numero finito)
possiamo svolgere passi del tutto simili ai precedenti.
Per prima cosa abbassiamo Run e selezioniamo Debug Configurations...
Evidenziamo only_debug:

Anche qui occorre accertarsi che il progetto sia quello corretto (Project Location).

I comandi di questa sessione sono simili a quelli già visti ma manca la parte di cancellazione e scrittura
della flash:

Se abbiamo modificato qualcosa, premiamo Apply.
Premiamo Debug e notiamo che si avvia una sessione del tutto identica a quella già analizzata nella
precedente sezione di questo articolo.

Chiusura definitiva anche per OpenOcd
Per chiudere definitivamente la sessione e scollegare anche l'alimentazione della scheda, dobbiamo per
prima cosa terminare GDB come descritto precedentemente.

Per OpenOCD dobbiamo invece aprire un terminale (ad esempio con Applications -> Accessori ->
Terminale

Sul terminale scriviamo telnet localhost 4444
e, entrati in comunicazione con OpenOCD, digitiamo:

       shutdown.

Il terminale può essere anche chiuso.

Riandando in Eclipse si noterà che anche la sessione denominata jtag è terminata.

Per pulire il «tavolo» di Debug basterà premere l'icona con la doppia x:

A questo punto l'hardware (il processore, terminato GDB si trova in halt) può essere disalimentato
scollegando il cavo USB.