EOS

IAR Embedded Workbench

Embedded Workbench è l’IDE di IAR per lo sviluppo di applicazioni con microcontrollori di svariate case madri. Eccone una descrizione dettagliata con riferimento al microcontrollore Texas Instruments MSP430.

IAR Embedded Workbench per ARM è un ambiente di sviluppo integrato (IDE) progettato per consentire lo sviluppo ed il debug di applicazioni embedded. Per ogni specifica famiglia di microcontrollori esiste una specifica versione del software che include generalmente un compilatore C/C++, un IDE espandibile che mette a disposizione dello sviluppatore un project manager in grado di gestire progetti gerarchici e la possibilità di integrazione con strumenti per il controllo di configurazione del codice sorgente. In questo articolo presentiamo un tutorial introduttivo sull’uso di Embedded Workbench con riferimento ai microcontrollori MSP430.

CREAZIONE DI UN NUOVO PROGETTO

Il primo passo è ovviamente la creazione di un nuovo progetto selezionando New dal menu File, quindi la voce “Project” nella finestra che appare e confermando con il tasto OK. A questo punto appare la finestra delle opzioni del progetto (figura 1) in cui si dovrà selezionare la CPU target (nel nostro caso MSP430) ed il nome del file di progetto, confermando con il pulsante “Create”.

Figura 1: la finestra delle opzioni di progetto.

Figura 1: la finestra delle opzioni di progetto.

Nella nuova finestra di progetto che vi viene mostrata, selezionate la voce “Debug” selezionandola eventualmente dall’elenco a discesa, quindi selezionate Option dal menu Project e assicuratevi che l’opzione Processor Configuration sia impostata a -v0 come mostrato in figura 2. Confermate i valori con il tasto OK.

Figura 2: impostazione del Processor Configuration.

Figura 2: impostazione del Processor Configuration.

I FILE SORGENTE

Per questo tutorial faremo riferimento ai file sorgente tutor.c, common.c, tutor.h e common.h forniti con il pacchetto di installazione del software. Questo programma inizializza un array con i primi dieci numeri della serie di Fibonacci e stampa i valori nella finestra terminale. Per convenienza il contenuto del file tutor.c è riportato nel listato 1.

#include “tutor.h”
/* Global call counter */
int call_count;
/* Get and print next Fibonacci number. */
void do_foreground_process(void)
{
unsigned int fib;
next_counter();
fib = get_fib( call_count );
put_fib( fib );
}
/* Main program. Prints the Fibonacci numbers. */
void main(void)
{
call_count = 0;
init_fib();
while ( call_count < MAX_FIB )
do_foreground_process();
}
Listato 1

Per aggiungere i file .C al progetto selezionare la voce File dal menu Project, sfogliate le cartelle fino a trovare il file tutor.c quindi selezionatelo e aggiungetelo al progetto con il pulsante “Add”. La stessa operazione dovrà essere ripetuta per il file common.c. Confermate infine l’aggiunta dei due file con il pulsante “Done”. Ora cliccando sul segno “+” nella finestra di progetto potrete vedere i due file sotto il gruppo Common Sources.

OPZIONI DI COMPILAZIONE

E’ ora il momento di impostare le opzioni di compilazione per il progetto. Selezionate l’icona Debug nella finestra di progetto quindi selezionate ICC430 nella lista delle categorie per accedere alle opzioni del compilatore (figura 3).

Figura 3: le opzioni del compilatore.

Figura 3: le opzioni del compilatore.

I parametri da impostare sono i seguenti (gli altri vanno lasciati ai valori di default):

Code Generation:
   Enable language extensions
Type checking:
   Global strict type checking
   Flag old-style functions
Optimization:
   Speed, Medium
Debug:
  Generate debug information
List:
  List file
  Insert mnemonics

COMPILAZIONE

Selezionate il file tutor.c nella Project Window qindi scegliete Compile dal menu Project per avviare la compilazione. Si aprirà automaticamente una finestra di messaggi per informarvi sull’avanzamento e gli eventuali errori di compilazione. E’ possibile specificare quante e quali informazioni visualizzare nella finestra dei messaggi dal menu Option->Settings->Make Control. Procedete in modo analogo per compilare il file common.c. Terminata la compilazione, IAR EW avrà creato una cartella DEBUG contenente tre nuove sottocartelle:

  • LIST (contiene i file di estensione lst)
  • OBJ (contiene i file oggetto con estensione r43. Nei file oggetto viene riportato anche il codice assembler e tali file serviranno come input al linker)
  • EXE (contiene i file eseguibili con estensione d43 che verranno usati come input per la fase di debug).

Vediamo come è strutturato il file LST e quali informazioni contiene. Aprite il file tutor.lst dal menu File->Open per visualizzarne il contenuto. Tale file contiene una intestazione che riporta i dati del progetto, la data e ora della compilazione e le opzioni di compilazione utilizzate:

###############################
###############################
############
#
# IAR MSP430 C-Compiler
VX.xxx/WIN
#
# Compile time = dd/Mmm/yyyy
hh:mm:ss
# Target option = SP430x31x
# Memory model = small
# Source file =
c:\iar\ew23\430\tutor\tutor.c
# List file =
c:\iar\ew23\430\projects\debug\
list\tutor.lst
# Object file =
c:\iar\ew23\430\projects\debug\
obj\tutor.r43
# Command line = -
OC:\IAR\ew23\430\projects\Debug
\Obj\ -e -gA -s6#
# -RCODE -r0 -
LC:\IAR\ew23\430\projects\Debug
\List\
# -q -t8 -IC:\IAR\ew23\430\inc\
# C:\IAR\ew23\430\tutor\tutor.c
#
# Copyright yyyy IAR Systems.
All rights reserved.#
###############################
###############################
###########

All’intestazione segue poi il corpo del file che contiene il codice assembler, e il codice binario relativo ad ogni comando C:

25 void main(void)
26 {
27 call_count = 0;
\ 0012 82430000 MOV
#0,&call_count
28 init_fib();
\ 0016 B0120000 CALL #init_fib
\ 001A ?0001:
29 while ( call_count < MAX_FIB
)
\ 001A B2900A00 CMP
#10,&call_count
\ 001E 0000
\ 0020 0334 JGE (?0000)
30 do_foreground_process();
\ 0022 B0120000 CALL
#do_foreground_process
31 }
\ 0026 F93F JMP (?0001)
\ 0028 ?0000:
\ 0028 3041 RET
32
\ 0000 RSEG UDATA0

La parte finale del file riporta l’esito della compilazione e l’ammontare di memoria richiesta per allocare il codice generato:

Errors: none
Warnings: none
Code size: 42
Constant size: 0
Static variable size: 2

LINKER

Prima di procedure al link dei vari file oggetto, è necessario impostare le opzioni del linker selezionando la cartella Debug nella finestra di progetto, quindi scegliere Options dal menu Project. Selezionale XLINK dalla lista delle categorie di sinistra (figura 4) ed impostate le seguenti opzioni:

Output:
Debug info with terminal I/O
List:
Generate linker listing
Segment map
Module map
Include:
Override default: lnk430.xcl

L’operazione di link vero e proprio dei file oggetto si avvia con la voce Link dal menu Project. Al solito, la finestra dei messaggi vi terrà informati sull’avanzamento e l’esito dell’operazione. Alla fine dell’operazione otterrete il file project1.d43 (che servirà per il debug) ed il file project1.map. Quest’ultimo contiene la informazioni circa l’allocazione dei comandi e delle variabili nella memoria del microcontrollore.

Figura 4: le opzioni del linker.

Figura 4: le opzioni del linker.

DEBUG DEL PROGRAMMA

Per avviare l’avvio della fase di debug selezionare la voce Debugger dal menu Project che aprirà la finestra C-SPY per il file eseguibile selezionato (project1.d43). All’avvio la finestra C-SPY mostrerà il sorgente del programma ed evidenzierà il primo comando che sarà eseguito (figura 5).

Figura 5: la finestra C-SPY all’avvio.

Figura 5: la finestra C-SPY all’avvio.

Le istruzioni assembler sono sempre disponibili e possono essere visualizzate mediante la voce Toggle Source/Disassembly dal menu View. Procedete con l’esecuzione del primo comando del programma usando la voce Step dal menu Execute o cliccando sulla relativa icona: vedrete che nella finestra C-SPY verrà evidenziato il comando successivo che comunque non verrà eseguito fino a che non darete voi il successivo comando di step. Qualora il successivo comando sia una funzione, se avanzate con Step verrà eseguita la funzione e il programma si posizionerà all’istruzione successiva alla funzione. Se volete eseguire passopasso anche i comandi interni alla funzione dovrete avanzare con Step Into. E’ possibile inoltre effettuare un multistep per l’esecuzione di un numero predefinito di comandi ad ogni step.

MONITORARE LE VARIABILI

C-SPY consente di inserire dei watchpoint su variabili o espressioni in C per poterne monitorare costantemente il valore durante tutta l’esecuzione del programma. Selezionare Watch dal menu Window per aprire la finestra di visualizzazione dei valori. Nella finestra del file sorgente selezionate la variabile o la finzione che volete monitorare e trascinatela nella finestra di visualizzazione. Procedendo con l’esecuzione del programma vedrete i valori assunti ad ogni step dalla variabile o dalla funzione da voi selezionata.

IMPOSTAZIONE DEI BREAKPOINT

L’uso dei breakpoint permette di eseguire automaticamente il programma senza interruzioni fino ad un punto ben preciso. Avviando il programma con il comando Go dal menu Execute, quando si raggiunge un breakpoint l’esecuzione si arresta e il sistema resta in attesa di input dall’utente: si può procedere con uno Step, uno Step Into

o con un nuovo comando Go. In quest’ultimo caso l’esecuzione riprende fino alla fine del programma o fino al breakpoint successivo eventualmente impostato. L’impostazione di un breakpoint è piuttosto semplice:

  • selezionate nel sorgente il punto del programma in cui volete inserire il breakpoint;
  • cliccare su Toggle Breakpoint nel menu Control.

La presenza del breakpoint viene segnalata grazie ad una evidenziazione del comando su cui il breakpoint è attivo (figura 6). Per rimuovere un breakpoint precedentemente impostato, selezionatelo e cliccate nuovamente su Toggle Breakpoint nel menu Control.

Figura 6: un breakpoint impostato sul comando di incremento della variabile i nel ciclo for.

Figura 6: un breakpoint impostato sul comando di incremento della variabile i nel ciclo for.

CONCLUSIONI

In questo articolo è stato mostrato come nuovere i primi passi in questo potentissimo ambiente di sviluppo. Per approfondimenti si rimanda al manuale e alla guida del programma (accessibile dall’apposito menu o mediante il tasto F1).

 

Scrivi un commento

EOS