Premiers pas

En ligne de commande, allez dans /usr/share/gnum16cm32c_v0603_elf-1/samples/R8C/, il s'y trouve 2 répertoires, contenant des exemples de programmes pour les familles R8C/11 et R8C/17. L'utilisation du compilateur sera strictement la même quelle que soit la famille R8C utilisée. Seuls certain fichier du projet changeront.

Allez par exemple dans le répertoire R8C_17, puis dans app1, qui est le 1er exemple pour cette famille. Pour ne pas avoir besoin de travailler en root, l'idéal est de copier ces répertoires dans votre compte utilisateur.

Voici la description des fichiers importants que l'on trouve dans ce répertoire :

• start.S :
  Fichier source assembleur, contient les toutes premières instructions qu'executera le R8C au démarrage.
• vects.S :
  Fichier source assembleur, dans lequel on va placer nos différents vecteurs d'interruption. Pour l'instant un seul vecteur est configuré : le vecteur de Reset, qui pointe sur _start. Donc au démarrage, le R8C récupère l'adresse de _start dans son vecteur de Reset, et saute l'execution dessus.
• hwinit.c :
  Fichier source en C, utilisé pour placer les initialisations bas niveau que l'on veut effectuer avant que la fonction main() soit appelée. La fonction hw_initialise() contenue dans ce fichier est appelée par start.S. Actuellement elle bascule l'horloge système de la clock interne vers la clock externe, et active les blocs de "data flash" du R8C.
• blink.c :
  Fichier source C, qui contient l'application, et donc la fonction main().
• blink.lnk :
  Fichier utilisé par le compilateur au moment de l'édition des liens. Il contient le descriptif des zones mémoires à utiliser pour stocker le code, les variables, les vecteurs, etc...
• ior8c17.h :
  Fichier entête décrivant les registres du R8C. Il permet dans un programme de se simplifier la vie lorsqu'on veut lire ou écrire un registre.
• makefile :
  Fichier utilisé par l'utilitaire make, il contient les commandes à executer pour compiler les fichiers sources et construire l'application.

Pour lancer la construction de l'application, rien de plus simple :


3 nouveaux fichiers apparaissent alors dans le répertoire :

• blink.out :
  Executable généré par gcc, au format elf. Attention, ce fichier n'est pas utilisable par le R8C.
• blink.mot :
  Fichier HEX au format motorola, crée à partir du fichier blink.out, grâce à la commande  m32-elf-objcopy -O srec blink.out blink.mot. C'est ce fichier qui contient les données permettant de flasher le R8C.
• blink.map:
  Fichier généré par le compilateur contenant le plan mémoire de l'application.

Reste à voir quelle commande a executé la commande make -f makefile pour construire l'application, et analyser les parametres :


-nostartfiles : Indique au compilateur de ne pas utiliser le code de démarrage de la librairie, mais le code que l'on va fournir (en l'occurence start.S).

-mcpu=r8c : Indique au compilateur qu'il doit compiler pour un R8C.

-DROMSTART et -DRELEASE : Définitions qui permettent de faire de la compilation conditionnelle dans les fichiers sources qui vont être compilés.

-Tblink.lnk : Indique au compilateur le fichier à utiliser pour l'édition des liens.

-Xlinker -Map -Xlinker blink.map : Options à passer à l'éditeur des liens, pour lui dire de générer le fichier map.

-o blink.out : Nom du fichier executable qui va être généré.
start.S hwinit.c vects.S blink.c : fichiers sources à compiler.


Utiliser le compilateur dans un IDE (Integrated Development Environnement)

Pour des petits projets, il n'y a aucune obligation d'utiliser un IDE pour travailler. Il suffit d'utiliser un éditeur de texte pour éditer ses fichiers sources, et ensuite de contruire le projet grâce à la commande make -f makefile. En revanche, pour des projets plus gros, ou si l'on veut un minimum de confort pour le développement, comme par exemple cliquer sur une erreur de compilation pour aller directement sur la bonne ligne dans le bon fichier, un IDE devient indispensable. C'est lui qui mettra à jour le makefile lorsqu'on ajoutera ou supprimera des fichiers sources au projet.

J'ai choisi d'utiliser l'IDE Eclipse, car j'avais déjà eu l'occasion de l'essayer, et j'avais pu remarquer qu'il est très abouti et qu'il contient un tas d'astuce d'aide à la saisie qui permettent d'écrire du code en un temps record !

A la base, Eclipse était un IDE prévu pour écrire des applications Java, mais des plugin's permettent de développer des applications dans d'autres languages, dont le C.


Installation d'Eclipse et du plugin's CDT

Puisque Eclipse fonctionne en java, si vous n'avez pas une machine virtuelle Java (JRE) sur votre machine, il vous faut d'abord en installer une. J'utilise la version 1.5.0. Rendez vous ici, puis selectionnez Java Runtime Environment (JRE) 5.0 Update X. Téléchargez ensuite jre-1_5_0_X-linux-i586.bin, puis executer ces commandes :

1. chmod +x jre-1_5_0_X-linux-i586.bin
2. ./jre-1_5_0_X-linux-i586.bin
3. Acceptez la licence
4. Executez la commande mv jre1.5.0_X/  /usr/local/  (a moins que vous ne souhaitiez le mettre ailleurs !) pour déplacer le répertoire contenant le JRE vers l'emplacement définitif.
   

Ensuite on peut passer à l'installation d'Eclipse/CDT, c'est plutôt simple :

1. Téléchargez Eclipse, j'utilise la version 3.2.1
2. Téléchargez le plugin's CDT, qui va permettre de gérer les projets en C/C++, j'utilise la version 3.1.1
3. Décompressez les archives avec la commande "tar zxf nom_fichier", en respectant cet ordre : Eclipse d'abord, CDT ensuite. Si tout se passe bien, le plugin's CDT se décompresse et se place directement dans le répertoire "eclipse" qui s'est crée en décompactant l'archive Eclipse.
   
4. Déplacez le répertoire "eclipse" à l'endroit définitif : mv eclipse /usr/local/ (ou ailleurs, c'est vous qui voyez !)
5. Il faut indiquer à eclipse le JRE à utiliser. Par défaut Eclipse cherche un JRE dans le répertoire /xxx/eclipse/jre. Donc on va le feinter avec un lien symbolique : ln -s /usr/local/jre1.5.0_X/ /xxx/eclipse/jre

Pour lancer eclipse, il suffit de lancer la commande /xxx/eclipse/eclipse. Moi j'ai mis un raccourci sur mon bureau, c'est quand même plus pratique !
Au 1er lancement, Eclipse vous demande le nom du répertoire ou seront stockés tous vos projets. Si "workspace" ne vous convient pas, vous pouvez choisir un autre nom.
Une fois lancé vous pouvez vérifier si le plugin's CDT à bien été pris en compte : Dans Help / About Eclipse SDK / plug'in detail, vous devez trouver quelques lignes C/C++ dans la liste.


Création d'un projet R8C

Au 1er lancement, Eclipse ouvre une "perspective" de présentation, vous pouvez la fermer. Une perspective est une sorte d'environnement dans l'environnement. Eclipse est le conteneur, et on peut ouvrir à l'intérieur plusieurs perspectives, une pour créer des applications Java, une pour le C/C++, etc...
Si aucune perspective n'est ouverte, ouvrez une perspective C/C++, vous obtiendrez quelque chose comme ça :


A gauche se trouve l'explorateur de vos projets et des fichiers qu'ils contiennent. Au centre, la zone d'édition, à droite des raccourcis vers les fonctions ou variables du fichier source en cours d'édition, et en bas, la zone permettant de visualiser les errreurs de compilation et les commandes lancées par eclipse (dans l'onglet console).

A présent faites File / New / Managed Make C Project, et appelez le projet "blink". Vous pouvez bien sûr prendre un autre nom, mais comme je vais récuperer pour l'exemple le projet blink vu ci dessus....

Ensuite cliquez sur Next, décochez la case "Debug" et faites "Finish". Lorsque les 2 sont cochées, cela permet d'avoir 2 configurations différentes pour le projet, pour lesquelles on peut configurer des options différentes de compilation. Pour cet exemple nous n'avons pas besoin de 2 configurations différentes de projet.

Maintenant le projet "blink" apparaît à gauche, et il est ouvert. Nous allons maintenant importer dans le projet les fichiers sources du projet "blink" déjà testé plus haut en mode console.
Cliquez droit sur le projet "blink", et faites Import / General / File system. Sélectionnez d'abord le dossier à partir duquel vous allez importer les fichiers (/usr/share/gnum16cm32c_v0603_elf-1/samples/R8C/R8C_17/app1/), puis sélectionnez les fichiers blink.c, blink.lnk, hwinit.c, ior8c17.h, start.S et vects.S., et enfin cliquez sur "Finish" (notez que les fichiers sont physiquement copiés vers le repertoire workspace/blink/).

Dès qu'Eclipse détecte un changement dans le projet (fichier ajouté ou modifié), il construit automatiquement le projet. C'est très pratique, cela évite de cliquer sur une icone "Compiler" ou "Construire". Un simple Ctrl-S ou Ctrl-Shift-S pour sauver le fichier ou tous les fichiers en cours d'édition, et Eclipse reconstruit le projet en compilant tous les sources modifiés.
En l'occurence, si vous allez voir dans l'onglet console, vous verrez qu'il a construit le projet avec succès !! Mais par contre il a utilisé le gcc standard...
Vous constaterez aussi qu'il n'a pas compilé les 2 sources assembleurs. C'est dû au fait qu'Eclipse n'a pas consideré les extensions .S comme des fichiers sources. Pour y remédier c'est très simple, cliquez droit sur ces 2 fichiers, et renommez les pour passer l'extension de .S en .s

On se retrouve maintenant avec des erreurs, ce qui est normal puisque gcc ne reconnait pas les instructions assembleur contenues dans ces 2 fichiers...

On va maintenant indiquer à Eclipse le compilateur et les options qu'il va devoir utiliser pour construire l'application.

Cliquez droit sur le nom du projet "blink", faites "Properties" puis sélectionnez C/C++ Build. C'est dans l'onglet Tool Settings que tout va se passer :


Dans la rubrique "GCC C compiler", changez la commande gcc en m32c-elf-gcc. Dans la sous rubrique "Optimization", sélectionnez l'option -02, c'est celle qui donne le meilleur compris taille/rapidité du code. Dans la sous rubrique "Warning", décochez tout, le mieux est d'indiquer sous forme d'options quels warnings nous désirons activer. Dans la sous rubrique "Miscellaneous", mettez dans la case other flag : -c -fmessage-length=0 -mcpu=r8c -fno-strict-aliasing -fno-common -fomit-frame-pointer -save-temps -Wimplicit -Wreturn-type -Wparentheses -Wpointer-arith

A présent faites OK. Comme vous avez changé la configuration du projet, Eclipse va essayer de reconstruire le projet. Si vous regardez dans la console, vous verrez qu'Eclipse a recompilé blink.c et hwinit.c en utilisant m32c-elf-gcc et nos propres options.
Par contre on voit bien qu'il a recompilé les fichiers assembleurs avec "as", l'assembleur de gcc, ce qui provoque les mêmes erreurs que tout à l'heure.
Maintenant retournez dans la configuration du projet.

Dans la rubrique "GCC Assembler", changez la commande as en m32c-elf-as, et faites OK. Dans la console vous verrez maintenant que start.s et vects.s sont à présent assemblés correctement. Cependant ça ne fonctionne pas encore, il y a encore une erreur, au niveau de l'édition des liens (linker). On va maintenant configurer les options de l'édition des liens, retournez dans la configuration du projet.

Dans la rubrique "GCC Linker", changez la commande ld par m32c-elf-gcc -nostartfiles -T ../blink.lnk. Théoriquement on aurait dû mettre m32c-elf-ld, mais ça provoque une erreur et je n'ai pas encore eu le temps de chercher pourquoi. Mais ça n'est pas trop grave, m32c-elf-gcc detecte qu'on veut faire l'édition des liens et se débrouille.

Et maintenant, dans la console on a : Build complete for project bldcController

Et voilà, le projet blink a été correctement construit. Par contre, l'executable ~/workspace/blink/Release/blink n'est pas directement utilisable. Il faut d'abord le convertir en fichier binaire ou en fichier hex avant de le télécharger dans le R8C.

Pour créer un fichier hex, il faut se placer dans le repertoire Release, et lancer la commande m32c-elf-objcopy -O ihex blink blink.hex
Pour créer un fichier binaire, la commande sera m32c-elf-objcopy -O binary blink blink.bin
On peut aussi créer un fichier srecord avec l'option -O srec

Pour automatiser la conversion, retournez dans la configuration du projet, dans l'onglet "Build steps". Dans la case Post-Build step / command, mettez m32c-elf-objcopy -O xxx blink blink.yyy, en remplacant les xxx par ihex, srec ou binary, et les yyy par hex, mot ou bin.

Notez qu'avec Eclipse, on peut donc constuire des applications pour n'importe quelle architecture, il suffit d'appeler le compilateur adapté à l'architecture. Pour ma part, j'utlise Eclipse pour tous mes développements :

• Projets logiciels Linux, par exemple le logiciel r8cwrite pour flasher les R8C sous Linux.
• Projets logiciels pour microcontrôleurs de la famille H8-300H (Compilateur h8300-elf-gcc).
• Projets logiciels pour microcontrôleurs R8C.
• Projets logiciels pour microcontrôleur PIC (Avec le compilateur de chez Hitech).
• Projets logiciels pour les gros DSP BlackFin de chez Analog Device (Avec le compilateur bfin-elf-gcc).

En fait il n'y a aucune limitation, dès l'instant où le compilateur pour une architecture existe sous Linux, on peut utiliser Eclipse pour gérer les projets !

Si vous avez des soucis de mise en oeuvre, ou des questions particulières, n'hésitez pas à m'envoyer un e-mail.

Si maintenant vous voulez flasher un R8C sous Linux, passez à la section suivante !