Compilateur ARM
Le compilateur GCC:
Le compilateur utilisé ici sera ARM-GCC. Il est libre d'utilisation, sous licence GNU.
GCC, acronyme de GNU Compiler Collection, est une collection de compilateurs à l'initiative de Richard Stallman dont un compilateur C qui nous intéresse ici. Pour les autres modules (Java, Objective-C, C++), vous trouverez toutes les informations sur le net.
Installation sous Linux:
Une recherche sur Internet du fichier arm-toolchain-linux-2.tar.bz2 va nous permettre de l'installer.
Il est notamment disponible sur le site http://www.mikrocontroller.net/download/ .
Une fois téléchargé, il faudra le décompresser avec toute son arborescence. Pour cela, il suffit d'ouvrir une console dans le répertoire où se trouve ce fichier et de taper la commande suivante:
tar xjvf arm-toolchain-linux-2.tar.bz2
Il suffit ensuite de déplacer ce nouveau répertoire avec la commande:
sudo mv arm /usr/local/
On modifie ensuite le path du système par
echo 'export PATH=/usr/local/arm/bin:$PATH' >> ~/.profile
Pour vérifier que tout s'est bien passé, il suffit de se déconnecter de la session en cours, puis de se reconnecter pour que les modifications soient prises en compte.
Il suffira alors de lancer la commande arm-elf-gcc --version pour que la console nous retourne le numéro de version du compilateur.
Pour ma part, j'obtient le message suivant:
arm-elf-gcc (GCC) 4.1.0
Copyright © 2006 Free Software Foundation, Inc.
Pour ceux qui veulent pouvoir consulter le manuel de GCC, il est disponible par la commande
man arm-elf-gcc
Installation sous Windows:
La version Windows du compilateur GCC WinARM-20060606.zip peut être téléchargé à l'adresse http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/WinARM-20060606.zip .
Après le téléchargement, il suffit de décompresser ce fichier sur C:\
Ensuite, il faut ajouter les répertoires suivants au PATH du système:
C:\WinARM\Bin et C:\WinARM\Utils\Bin.
Pour une complète compatibilité avec ce que nous pourrons faire sous Linux, il est nécessaire de télécharger le fichier du downloader lpc21isp à l'adresse:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/lpc21isp_beta_v1_43.zip .
Décompresser alors ce fichier dans le répertoire C:\WinARM\Utils .
Lancer arm-elf-gcc --version pour vérifier que tout s'est bien passé. Le compilateur doit vous retourner son numéro de version.
De cette façon, les commandes utilisées sous Windows et Linux seront identiques. On peut changer d'environnement de travail sans reconfigurer notre projet.
Le fichier Makefile du compilateur:
La façon la plus simple et la plus efficace d'utiliser le compilateur GNU est d'utiliser la commande make associée à un fichier de configuration appelé makefile.
L'utilisation du MakeFile étant complexe, on se limitera aux parties qui nous intéressent ici.
Le manuel de Make se trouve en ligne à l'adresse suivante: http://www.gnu.org/software/make/manual/make.html
Pour ceux qui sont pressé, rendez-vous directement en bas de cette page où figure LE résumé...
Donc, lorsque notre programme sera écrit et sauvegardé dans le fichier main.c par exemple, on lancera la compilation avec l'utilitaire make. Cet utilitaire a été installé lors de l'installation du compilateur.
Le makefile que nous utiliserons sera le suivant (le fichier sur le disque s'appellera simplement makefile, sans extension):
NAME = Program
CC = arm-elf-gcc
LD = arm-elf-ld -v
AS = arm-elf-as
CP = arm-elf-objcopy
CFLAGS = -c
AFLAGS = -ahls -mapcs-32 -o crt.o
LFLAGS = -T LPC2106_flash.cmd
CPFLAGS = -O ihex
all: AllFiles
prog:
-lpc21isp $(NAME).hex /dev/ttyS0 19200 14745
wprog:
-lpc21isp $(NAME).hex com4 19200 14745
clean:
-rm crt.lst crt.o
-rm main.o
-rm $(NAME).out $(NAME).hex
AllFiles: $(NAME).out
@ echo "\n..... copying to Hex file"
$(CP) $(CPFLAGS) $(NAME).out $(NAME).hex
@ echo ""
$(NAME).out: crt.o main.o LPC2106_flash.cmd
@ echo "\n..... linking"
$(LD) $(LFLAGS) -o $(NAME).out crt.o main.o
crt.o: crt.s
@ echo "\n..... assembling"
$(AS) $(AFLAGS) crt.s > crt.lst
main.o: main.c
@ echo "\n..... compiling"
$(CC) $(CFLAGS) main.c
La commande make va lancer les commandes à notre place, lisant le script écrit dans le fichier makefile qui se trouve dans le répertoire du projet, aux côtés de nos fichiers sources.
Un autre fichier important du projet à compiler est LPC2106_flash.cmd qui va indiquer au linker quels espaces mémoires il va devoir utiliser pour rendre notre programme exécutable en mémoire Flash. Nous le commenterons plus tard.
En utilisant ce makefile, les paramètres que l'on pourra passer en ligne de commandes à make sont:
(il suffira de taper une de ces lignes de commande dans une console Dos ou Linux)
make
make all
make clean
make prog
make wprog
Détaillons un peu ces commandes:
make
ou bien indifférenment
make all
permet de compiler tous les fichiers modifiés.
make clean
permet de nettoyer le répertoire de notre projet en supprimant les fichiers objet, listings et autres que l'on ne juge pas utiles de garder.
make prog
envoie le programme ainsi créé à notre carte par l'intermédiaire de la liaison RS232.
Supposons que notre projet Program soit composé des deux seuls fichiers main.c et crt.s.
Pour l'instant, nous admettrons que le fichier crt.s est simplement un fichier assembleur ARM nécessaire à la compilation du projet. Il va servir à configurer notamment les vecteurs d'interruptions du microcontrolleur.
Regardons le fichier makefile pour voir ce qu'il contient et nous y verrons un peu plus clair:
NAME = Program
Il s'agit ici du nom donné à notre programme (Program) et que make utilisera lorsqu'il rencontrera plus loin dans le makefile sa variable $(NAME).
CC = arm-elf-gcc
LD = arm-elf-ld -v
AS = arm-elf-as
CP = arm-elf-objcopy
Nous retrouvons là les différents programmes que make va utiliser lors de la compilation. Il fera donc appel au compilateur arm-elf-gcc (CC), au linker arm-elf-ld (LD), à l'assembleur arm-elf-as (AS) et à l'utilitaire de conversion de format de fichier arm-elf-objcopy (CP).
Au lieu de lui redire à chaque fois d'utiliser arm-elf-gcc, makefile indiquera alors à make d'utiliser CC par exemple, ce qui nous facilitera bien la tâche pour des projets volumineux.
Ensuite:
CFLAGS = -c
AFLAGS = -ahls -mapcs-32 -o crt.o
LFLAGS = -T LPC2106_flash.cmd
CPFLAGS = -O ihex
Il s'agit là des options en ligne de commande que l'on va passer à chaque programme lors de son appel. Le manuel de GCC donne toutes les informations nécessaires à la compréhension des options en ligne de commande.
all: AllFiles
Lorsque l'on invoquera make all, l'utilitaire make fera appel à ce qu'il y a écrit sous l'étiquette AllFiles (voir un peu plus loin).
Sous Linux, commande prog:
prog:
-lpc21isp $(NAME).hex /dev/ttyS0 19200 14745
Lorsque l'on aura lancé la commande make prog sous Linux, make appellera alors lpc21isp avec les arguments Program.hex (puisque make aura remplacé $(NAME) par Program), puis la description du port com utilisé, la vitesse de transmission et la valeur du quartz en kilohertz.
Sous Linux, le port com sera défini par /dev/ttyS0.
Si vous utilisez un port série sous Linux différent de ttyS0, il faudra le mentionner à cette section prog.
Sous Windows, commande wprog:
wprog:
-lpc21isp $(NAME).hex com1 19200 14745
La fonctionnalité sera la même que pour la commande prog de Linux mais elle sera ici utilisée avec la définition d'un port COM sous Windows. En effet, sous Windows, le port RS232 sera défini par com1 (sous Linux, on avait /dev/ttys0, d'où incompatibilité).
Si vous utilisez un port série sous Windows différent de com1, il faudra le mentionner ici.
Pour ma part, j'utiliserai souvent com4 sous Windows.
Pour lancer le bootloader, on utilisera donc la commande make prog sous Linux, et on utilisera la commande make wprog sous Windows.
clean:
-rm crt.lst crt.o
-rm main.o
-rm $(NAME).out $(NAME).hex
make clean quant à lui aura donc pour but d'effacer les fichiers nommés.
AllFiles: $(NAME).out
@ echo "\n..... copying to Hex file"
$(CP) $(CPFLAGS) $(NAME).out $(NAME).hex
@ echo ""
La commande @echo a simplement pour fonction de copier la chaîne de caractère qui la suit sur la console, ce qui va nous permettre de suivre d'un peu plus près le processus de compilation.
La ligne
$(CP) $(CPFLAGS) $(NAME).out $(NAME).hex
lancera donc
arm-elf-objcopy -O ihex Program_1.out Program_1.hex
ce qui aura pour but de convertir le fichier .out issu de la compilation en fichier .hex programmable.
Avant de faire cette conversion, il aurait d'abord fallu compiler les fichiers sources. Si on regarde plus attentivement, on s'aperçoit que la première ligne de ce paragraphe n'est pas seulement une étiquette (AllFiles), mais qu'elle est suivie de $(NAME).out, ce qui veut dire que l'on va directement regarder à l'étiquette $(NAME).out pour voir ce qu'il faillait faire avant ça. On va donc aller voir les pré requis.
$(NAME).out: crt.o main.o LPC2106_flash.cmd
@ echo "\n..... linking"
$(LD) $(LFLAGS) -o $(NAME).out crt.o main.o
De la même façon, on voit ici que pour faire le fichier Program.out, il faut d'abord construire le fichier crt.o en regardant sa recette, puis le fichier main.o en regardant également sa recette de fabrication décrite plus bas dans le makefile, mais aussi que le fichier LPC2106_flash.cmd sera utilisé pour les mappings mémoire.
crt.o: crt.s
@ echo "\n..... assembling"
$(AS) $(AFLAGS) crt.s > crt.lst
On a ici la recette de fabrication du fichier crt.o à partir du fichier crt.s, avec l'utilisation de l'assembleur arm-elf-as.
main.o: main.c
@ echo "\n..... compiling"
$(CC) $(CFLAGS) main.c
Et ici celle du fichier main.o à partir du main.c avec l'utilisation du compilateur arm-elf-gcc.
En résumé,
La commande make all va créer le fichier Program.hex.
Ce fichier ainsi crée sera téléchargé sur la carte à l'aide de la commande make prog si on travaille sous Linux, ou à l'aide de la commande make wprog si on travaille sous Windows.
Pour compiler des projets plus complexes, on utilisera le même makefile, mais complété au fur et à mesure de nos besoin.