CodeWarrior™ Development Studio è l’ambiente di sviluppo integrato che Freescale Semiconductor (NXP) mette a disposizione per la gestione di applicazioni embedded orientate ai microcontrollori delle famiglie ColdFire®.

Introduzione

In questo articolo verrà illustrato come utilizzare il tool di sviluppo CodeWarrior™ ancora utilizzato da molti progettisti. La versione comprende le seguenti caratteristiche:

• Interfaccia grafica CodeWarrior  IDE (Integrated Development Environment);
• Supporto per i processori delle famiglie MCF5213, con le varianti MCF5211 e MCF5212;
• Flash-programmer e supporto per  la diagnostica hardware;
• Supporto di debug via USB per mezzo del protocollo P&E Micro;
• Simulatore del Set di Istruzioni  (ISS) per i core dei processori nelle versioni supportate.

Edizioni di CodeWarrior™

Esistono tre  differenti  versioni di  CodeWarrior™ Development Studio, le cui caratteristiche sono riassunte in tabella 1.

Tabella 1. Caratteristiche di CodeWarrior ColdFire 6.0 Edition

Guida all’installazione

Requisiti di sistema

I requisiti minimi riguardanti il personal computer su cui installare l’ambiente sono i seguenti:

• Microprocessore Pentium® o compatibile da 800 Mhz;
• Sistema operativo Windows® 2000, XP o Linux;
• 512 Megabyte di Ram;
• Drive CD-ROM;
• Spazio libero sul disco principale di almeno 350 Megabyte, più un ragionevole margine per i progetti e i relativi codici sorgenti;
• Porta seriale (o Ethernet) per il collegamento del PC al target a scopo di debug;
• Porta parallela per il collegamento di accessori con interfaccia JTAG;
• Porta USB per poter utilizzare dispositivi con interfaccia USB attraverso il protocollo P&E Micro.

I requisiti riguardanti il sistema target su cui sviluppare le applicazioni prevedono:

• Schede di valutazione aventi processori delle famiglie ColdFire, come quelli già citati;
• Cavo seriale o null-modem per collegare il PC alla scheda di valutazione;
• Cavo parallelo per il PC, munito di adattatore e buffer (Wiggler), per i segnali della porta parallela nel caso di  connessioni BDM/JTAG per  Debugger  e Flash Programmer;
• Appropriato alimentatore per la target board.

L’IDE di CodeWarrior

L’ambiente di progetto  integrato,  o IDE (Integrated Design Environment) di  CodeWarrior™,  comprende  un Editor per i files sorgenti, Compilatore, Linker e Debugger, il tutto riunito in un solo applicativo. Il controllo è affidato a una comoda interfaccia grafica di utente (GUI, Graphical User Interface). Il Project Manager tiene sotto controllo l’intero  procedimento  e consente di organizzare i files sorgenti e i files accessori del progetto,  permettendo una gestione semplice e di facile apprendimento,  a tutto  vantaggio dell’utente nel portare a termine efficacemente le proprie applicazioni. Nella figura 1 è riportata una schermata dell’interfaccia di sviluppo integrata.

Figura 1. Una schermata di CodeWarrior IDE

L’architettura del Project Manager è esemplificata nella figura 2.

Figura 2. Architettura del Project Manager

Riguardo le codifiche supportate, CodeWarrior gestisce vari linguaggi ad alto livello (C, C++, Pascal, ecc...),  come  pure l’Assembler. Sono utilizzabili anche Assemblatori e Compilatori di terze parti di tipo stand-alone per diverse tipologie di processori.

Ciclo di progetto

Il procedimento per la gestione di un progetto può essere schematizzato come un ciclo composto di quattro fasi (figura 3).

Figura 3. Il ciclo di progetto

In questo, che è un modello semplificato, il progettista dapprima scrive il codice sorgente, lo compila generando il codice macchina (codice oggetto),  effettua il link dei codici oggetto  con le eventuali librerie e infine ottiene un codice eseguibile. Il debug  costituisce poi l’ultimo  step del procedimento, con lo scopo di verificare le varie funzionalità ed evidenziare eventuali malfunzionamenti. Tornando all’interfaccia IDE di CodeWarrior, il progettista ha, con questo strumento, la comodità di lavorare tenendo sotto controllo tutte le fasi del progetto. In particolare, la figura 4 evidenzia con maggiore dettaglio i passi da seguire nel flusso di sviluppo progettuale, a partire dalla definizione iniziale fino al rilascio della versione consolidata.

Figura 4. Passi da seguire per lo sviluppo di un’applicazione con l’IDE di CodeWarrior

Files di progetto

Un progetto sviluppato con CodeWarrior consiste di un codice sorgente, delle librerie e un certo numero di files accessori. La finestra di progetto  (Project Window, in figura 5) mette in evidenza tutti  i files presenti. Le operazioni fattibili  in questo contesto sono le seguenti:

• Aggiunta di files;
• Cancellazione di files;
• Specificazione della sequenza di Link;
• Assegnazione dei files ai target di compilazione;
• Generazione dei dati di debug per i files specificati.

Figura 5. La Project Window

L’interfaccia IDE si occupa di gestire in modo automatico le relazioni reciproche tra i files di progetto e memorizza i settaggi del Compilatore e del Linker per ciascun dispositivo target. Tiene inoltre traccia delle modifiche effettuate nel corso di un procedimento di “Build”,  in modo da ricompilare, se il caso, solo i files che sono stati effettivamente modificati. Un  progetto   gestito  entro  CodeWarrior  è,  grosso modo, una collezione di makefiles, in quanto un solo progetto può contenere non uno ma diversi processi di “Build”.  Ad esempio, possono coesistere sia versioni di codice di debug che versioni già completate e consolidate, entrambe parti di un medesimo progetto.

Editing del codice

L’Editor di testo di CodeWarrior gestisce files di diversi formati, dal MS-DOS, allo UNIX, al MacOS. Per editare un file sorgente, occorre cliccare sul suo identificativo nella Project Window. L’interfaccia IDE provvede ad aprire il file nella relativa finestra di editing (figura 6).

Figura 6. Editor Window

Build: Compilazione e Linking

Per l’IDE di CodeWarrior, l’operazione di “Build” comprende la Compilazione e il Link. Per effettuarla occorre selezionare Project -> Make dalla barra del menù principale. Il Compilatore, a questo punto:

• Genera un file oggetto per ciascun codice sorgente del dispositivo target, incorporando le opportune ottimizzazioni;
• Aggiorna gli altri files del target in oggetto;
• Nel caso si verifichino errori, invia i relativi messaggi e ferma l’esecuzione.

Una volta terminata  la Compilazione, si passa alla fase di Link. Il Linker dell’IDE:

• Riunisce i files oggetto in un file eseguibile, seguendo l’ordine specificato dal progettista;
• Se si verificano degli errori, invia i relativi messaggi e termina l’esecuzione.

Se il Linking va a buon fine, si può procedere con il Debug dell’applicazione. Nota: è possibile anche compilare un singolo file sorgente. Per farlo, basta selezionare il nome del file nella Project Window e cliccare su Project -> Compile dalla barra del menù principale. Un’altra utile opzione, come già osservato, consiste nel compilare solo i files modificati relativamente al target, questo si fa selezionando Project -> Bring Up To date, sempre dal menù principale.

Disassembler

Per disassemblare un file del progetto compilato o dato in formato ELF, si seleziona il nome del file nella Project Window, quindi si sceglie Project -> Disassamble. Dopo aver disassemblato il file, l’IDE di CodeWarrior crea un file con estensione .dump che contiene il codice oggetto disassemblato in formato Assembly, mentre le informazioni di debug vengono registrate nel formato DWARF (Debugging With Attribute Record Format). Il contenuto del file .dump  viene mostrato entro un nuova finestra.

Tutorial applicativo

In  questa sezione verrà mostrato come utilizzare l’ambiente  di programmazione IDE CodeWarrior. L’obiettivo non è di entrare nel dettaglio della programmazione, quanto esemplificare le fasi di impiego dell’ambiente, al fine di creare e debuggare applicazioni per una determinata piattaforma target. Prima di iniziare, occorre effettuare il setup della scheda di valutazione target (che verrà indicata brevemente con EVB). Tipicamente, questo comporta:

• Verificare tutti i jumpers e i settaggi dei dip-switches presenti;
• Collegare un cavo seriale (o altro tipo di collegamento richiesto) tra la EVB e il PC;
• Alimentare la EVB.

Creazione di un progetto

Verrà ora descritto come creare un progetto per una scheda di valutazione contenente un microprocessore ColdFire e come effettuare il setup  del   progetto   per   creare un’applicazione  stand-alone. Per iniziare, occorre effettuare i seguenti step:

• Dal menù Start di Windows, individuare Programs -> Freescale CodeWarrior -> Code Warrior for ColdFire V6.2 -> CodeWarrior IDE. Il che manda in esecuzione l’ambiente di sviluppo integrato (figura7a).
• A questo punto, dalla barra del menù superiore, selezionare File -> New, il che richiama la dialog box di figura 7b;
• Selezionare l’opzione Coldfire Stationery;
• Nella text box  del Project Name digitare il nome che si vuole dare al progetto, ad esempio MyProj;
• Cliccare quindi sul tasto OK per terminare.

Figura 7a. CodeWarrior IDE

Figura 7b. Dialog Box per l’opzione New File

Fatto ciò, verrà mostrata la Dialog Box del nuovo progetto,  come da figura 7c.

Figura 7c. Dialog Box per il nuovo progetto

È ora il momento di specificare il nome della evaluation board considerata, ad esempio CF_M5213EVB. La figura 7d mostra come la struttura si espande rivelando le opzioni sottostanti, di cui si sceglierà la “C”.

Figura 7d. Selezione della Stationery M5213 C

Confermare la scelta con il tasto OK. Con quest’ultima operazione si è completata la definizione del nuovo progetto. La figura 7e presenta la Project Window al termine della procedura. Occorre assicurarsi che il campo “Target Field”, appena sotto la tab della Project Window, riporti la dicitura “M5213EVB Console Debug”.

Figura 7e. La Project Window al termine della sequenza di definizione del progetto

Si può ora dare inizio alla fase “Build”  del progetto.

Fase "Build" del progetto

In questo paragrafo viene descritto come  selezionare il  Linker, predisporre il Debug remoto ed effettuare il Build (compilazione e link) del progetto. Dapprima  occorre  selezionare il Linker, con i seguenti passi:

• Selezionare Edit -> Target Settings, dove Target identifica il nome del dispositivo. La finestra relativa è mostrata in figura 8a;
• Dal pannello sulla sinistra, selezionare “Target Settings”;
• Mediante la list-box denominata “Linker”, specificare il Linker Embedded per ColdFire;
• Infine, cliccare su “Apply”. Viene così salvato il settaggio del Linker per il target.

Figura 8a. La Target Settings Window

Dopo questa sequenza di operazioni, occorre passare a predisporre il Remote Debugging:

• Dal pannello Target Settings, selezionare “Remote Debugging”. Il pannello viene quindi evidenziato in primo piano, come riportato in figura 8b;
• Utilizzare la list-box denominata “Connection” per specificare CCS-SIM;
• Cliccare su OK per completare il setup. La finestra Target Settings, a questo punto, si chiude.

Figura 8b. Pannello per la scelta “Remote Debugging”

Tutto è pronto  ora per effettuare la fase di Make: dalla barra del menù principale, selezionare Project -> Make. Questo fa sì che l’IDE aggiorni tutti i files, effettui il Link del codice nell’applicazione completata e mostri gli  eventuali messaggi di errore o warning  nella finestra Errors & Warning. Da notare che il comando Make si applica su tutti i files sorgenti presenti. Il Compilatore genera i codici oggetto e il Linker crea un  file  eseguibile. La Project Window mostra gli avanzamenti di tutte queste operazioni. Se non si sono verificati errori, l’operazione di Build si conclude in questo modo, rendendo possibile passare alla fase di Debug.

Debug dell’applicazione

Verrà ora analizzato come effettuare il debug dell’applicazione, per verificare se essa si comporta così come previsto. Verrà mostrato come lanciare l’esecuzione del Debugger, come inserire un breakpoint e come visualizzare il contenuto  dei registri e della memoria. Dapprima occorre predisporre i parametri preferenziali:

• Selezionare Edit -> Target Settings (dove Target è il dispositivo scelto per il Build). Si presenterà  la finestra di Target Settings di figura 9a. Dall’area di sinistra (Target Settings Panels) selezionare CF Debugger Settings; questo farà passare in  primo piano il relativo pannello;
• A questo punto, è utile assicurarsi che il campo Target Processor contenga “521x”;
• Verificare inoltre che la casella Target OS contenga “BareBoard”;
• Cliccare su OK. L’IDE salva i settaggi del Debugger e la finestra si chiude.

Figura 9a. Pannello per CF Debugger

Per mandare in esecuzione il Debugger, occorre dal menù principale selezionare Project -> Debug. Il sistema trasferisce il file di uscita verso il target e subito dopo Il Debug ha inizio con la comparsa della finestra di Debug (figura 9b).

Figura 9b. Finestra del Debugger

Si noti la barra di comandi al top della finestra: essa contiene i tasti per le funzioni Run,Stop,Kill,Step Over, Step Into e Step Out. È  presente poi il pannello dello Stack sulla sinistra in alto, che mostra le chiamate alle funzioni del programma. Il pannello delle variabili di programma sulla destra in alto, elenca i nomi e i contenuti delle variabili locali. Infine, il pannello del Sorgente, in basso, contiene il codice sorgente.

Breakpoints

Per settare un breakpoint, bisogna posizionarsi sulla riga di codice di interesse, per esempio (vedere figura 9c) la parentesi di inizio ( { ) del programma principale. Nella colonna più a sinistra di questa linea, si clicca sul trattino in grigio che identifica la riga. Un circoletto rosso si sostituirà al trattino, indicando con questo che il Debugger ha fissato un breakpoint su quella riga di codice.

Figura 9c. Set di un breakpoint

Visualizzazione dei registri

Per questa operazione, dalla barra del menù principale, selezionare View -> Registers. Apparirà la finestra dei Registri (figura 9d).

Figura 9d. Register Window

Qui si potrà discendere nella gerarchia del progetto  fino a visualizzare l’elenco di tutti  i registri interni, con a fianco il valore corrente. È anche possibile editare il contenuto dei registri direttamente dalla Register Window.

Visualizzazione della Memoria

Dal pannello Source della finestra di Debug, occorre cliccare con il tasto destro del mouse nell’area del codice sorgente. Fatto ciò, farà la sua comparsa il menù di figura 9e, in cui si sceglierà “View Memory”.

Figura 9e. Menù per visualizzare la Memoria

Questo farà aprire la finestra Memory View di figura 9f, indicante il contenuto della memoria.

Figura 9f. Finestra Memory View

La codifica è in esadecimale e ASCII, a partire dall’indirizzo di inizio del programma Main. Se, nel campo Display, si digita un indirizzo valido nell’ambito della Ram o della Rom di sistema, seguito dal tasto Enter, il contenuto della Memory View verrà aggiornato con quello indicato.

“Run”  dell’applicazione

Per far eseguire il Debug, ovviamente occorrerà cliccare sul tasto Project -> Run della barra di menù principale nella finestra del Debugger. A questo, apparirà una finestra di tipo Console (figura 9g) mostrante l’output del programma, la classica frase “Hello World..”.

Figura 9g. La Console Window

Infine, con il tasto Kill si fermerà l’esecuzione del Debugger.

Ti potrebbe interessare anche:

E’ disponibile il datasheet di ESPertino in italiano

Progetto di un estensore wireless di posto interno citofonico

Gideros Mobile: come creare avvincenti videogame per dispositivi Mobile utilizzando Lua