
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.
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.
L’architettura del Project Manager è esemplificata nella figura 2.
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).
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.
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.
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).
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.
Fatto ciò, verrà mostrata la Dialog Box del nuovo progetto, come da figura 7c.
È 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”.
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”.
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.
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.
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.
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).
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.
Visualizzazione dei registri
Per questa operazione, dalla barra del menù principale, selezionare View -> Registers. Apparirà la finestra dei Registri (figura 9d).
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”.
Questo farà aprire la finestra Memory View di figura 9f, indicante il contenuto della memoria.
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..”.
Infine, con il tasto Kill si fermerà l’esecuzione del Debugger.

E’ sempre comodo avere a disposizione un articolo su Code Warrior. Le funzionalità IDE da versioni a versioni sono rimaste pressochè simili, ovviamente è migliorata la grafica e sono incrementale le features per lo sviluppo di programmi per i nuovi MCU immessi sul mercato. La fusione NXP/Freescale spero possa essere vantaggiosa a questo tool.