Pour illustrer les contextes et le cycle de développement présentés ci-avant, on prend un premier exemple de programme très connu : afficher «Hello, World!» à l'écran.
La «mise au point» de ce programme simpliste sert aussi à prendre en main les outils de la chaîne de développement.
Voici le code source du premier programme hello.c
sous sa forme «usuelle».
 |
D'une manière générale, pour que l'on puisse utiliser les fonctions d'une bibliothèque, il faut que les prototypes (ou en-têtes) de ces fonctions soient parcourus par le pré-processeur (voir Section 4, « Cycle de développement »). Si cette condition est satisfaite, le pré-processeur «connaît» la liste des paramètres possibles d'une fonction et leurs types. Il peut ensuite contrôler que les appels à ces fonctions sont conformes. Cet exemple de programme utilise la fonction
|
 |
En C, le programme principal peut être assimilé à une «fonction comme les autres» à qui on peut passer des paramètres (entre les parenthèses) depuis le Shell et qui renvoie à ce même Shell une indication sur ses conditions d'exécution (un nombre entier). L'accolade |
 |
Une chaîne de caractères est délimitée par des guillemets et les
caractères spécifiques sont précédés par Les instructions sont séparées par le caractère
|
 |
La valeur Cette instruction n'a de sens que lorsque le programme est exécuté via un système d'exploitation avec lequel il est possible d'échanger des informations. |
Voici le code source du même premier programme
ser_hello.c sous sa forme «embarquée». Le code n'est pas
aussi simple que dans le cas précédent. Comme indiqué dans la Section 3.2, « Ordinateur cible sans système d'exploitation » on ne dispose pas de noyau dans ce
contexte. Le programme doit donc intégrer le pilotage du périphérique
d'affichage. Ici, il s'agit de la liaison série qui est utilisée pour
«l'affichage» de la chaîne «Hello, World!».
Avec le synoptique ci-dessus, on développe (voir Section 4, « Cycle de développement ») le programme sur le PC. Une fois que l'on a obtenu le fichier contenant le code exécutable du programme, on le transfère via la liaison série à l'aide du moniteur. Enfin, après avoir réinitialisé le microcontrôleur en mode exécution, le programme utilisateur est lancé.
En mode exécution, le programme utilisateur peut piloter la liaison série de façon complètement autonome si on lui fournit les sous-programmes nécessaires. C'est le cas de l'exemple de code source ci-dessous.
Exemple 2. Affichage de la chaîne «Hello, World!» avec un microcontrôleur MSC1210 & SDCC
#include <stdio.h>putcr(); while(1);
}
| |
Comme indiqué dans le premier cas, les directives
|
| |
Cette fonction fait «normalement» partie de la bibliothèque standard et
son rôle est d'envoyer un caractère à l'écran. Dans le cas présent, on
utilise une nouvelle définition de cette fonction. Son rôle est maintenant
d'envoyer le caractère sur la liaison série. La fonction
Le mot clé |
| |
Par différence avec le premier programme, on constate avec l'emploi des
mots clé |
| |
Cette fonction est très pratique. Le programme reste en attente d'un appui sur la touche <Entrée> du système de développement (le PC) pour déterminer le débit de transmission en bauds. Sans cette «attente», le programme se lancerait directement après le reset du microcontrôleur ce qui est trop rapide si des manipulation sont à effectuer manuellement sur le système embarqué. |
| |
Cet appel de fonction se présente comme dans le cas du premier
programme excepté pour le traitement du saut de ligne en fin de chaîne de
caractères. Avec la liaison série, on est obligé d'envoyer deux caractères
spécifiques : |
| |
Comme le programme est la seule application en cours d'exécution sur le microcontrôleur, et qu'il n'y a plus d'opération à effectuer, on place le processeur dans un état d'attente infinie grâce à cette instruction de bouclage. C'est une technique usuelle qui permet de s'assurer que le processeur ne cherche pas à interpréter le contenu de la mémoire située après l'application utilisateur comme un programme. |
Ce contexte est décrit dans la Section 3.1, « Ordinateur cible avec système d'exploitation ».
On distingue deux familles de systèmes d'exploitation : Windows et GNU/Linux.
Pour que le résultat de l'exécution du programme soit «visible», on a
ajouté l'instruction system("pause"); qui demande à
l'utilisateur d'appuyer sur une touche. Sans cette instruction, le Shell serait refermé dès la fin de l'exécution du
programme et le message ne serait pas visible.
Les outils de la chaîne de développement sont installés par défaut avec le système d'exploitation. On peut donc appeler directement le compilateur gcc (voir Section 13.2, « C/C++ sur GNU/linux ».
phil@b0x:~/src$ cat hello.c
#include <stdio.h>
int main() {
printf ("Hello, World!\n");
return 0;
}
phil@b0x:~/src$ gcc hello.c
phil@b0x:~/src$ ./a.out
Hello, World!
phil@b0x:~/src$
Dans ce contexte, on commence par ouvrir un nouveau Shell dans lequel on effectue toutes les opérations individuelles : édition du code source, compilation et exécution.
Ici, les programmes sont développés sur un PC et exécutés sur la machine cible. C'est le contexte décrit dans la Section 3.2, « Ordinateur cible sans système d'exploitation ».
Pour l'exemple de programme retenu, on choisit d'afficher la chaîne de caractères sur le terminal du système de développement (ie. le PC) via une liaison série.
Pour que la chaîne de développement SDCC soit plus facile à utiliser sur un système d'exploitation Microsoft™, il est vivement conseillé de reconstituer un environnement de travail GNU/Linux-like à l'aide des outils Cygwin.
Une fois les outils Cygwin installés, on dispose d'un shell Bash et surtout de l'application de contrôle du compilateur make qui permet de gérer les dépendances entre les différents fichiers sources et en-têtes.
Après avoir travaillé avec ces outils pendant «un certain temps», il ne restera plus qu'une dernière étape à franchir : abandonner le système Microsoft™ GNU/Linux-like au profit d'un véritable système GNU/Linux.
On appelle le compilateur SDCC à partir d'une console.
Le fichier ser_hello.ihx contient le code
exécutable du programme au format Intel Hex. Il
s'agit d'un format texte ASCII de représentation du code
machine du microcontrôleur utilisé pour le transfert du système de
développement vers le système cible.
Le fichier ser_hello.asm contient le code source
du programme en langage assembleur. Une lecture rapide de ce fichier montre
que les fonctions d'optimisation du compilateur ont été efficaces.
Pour faciliter les développements de programmes «plus complets» que cet exemple, un patron de Makefile est fourni avec les fichiers sources distribués avec ce document : Makefile.
Pour démarrer un nouveau développement, il suffit de copier ce patron
dans un nouveau répertoire et d'affecter à la variable
BASENAME le nom du nouveau fichier source en
langage C.
Ce patron de Makefile suppose que l'on utilise systématiquement la liaison série comme interface utilisateur. Il fait donc référence au fichiers sources et en-têtes qui permettent d'utiliser cette liaison série. Ces fichiers sont aussi présentés dans ce document à la Section 14.2, « Sources MSC1210 ».
Texas Instruments™ fournit un logiciel appelé TIDownloader qui pilote la liaison série entre le PC et le système embarqué. Ce logiciel sert à la fois au transfert du code du programme et aux tests d'exécution avec son terminal. Il est téléchargeable à l'adresse : Software for Programming the Flash Memory Using the Serial Port v1.3.4 (Rev. C) (sbac018c.zip, 2381 KB ).
Il faut positionner l'interrupteur «vers le haut» pour accéder au moniteur intégré du microcontrôleur. Après un appui sur le bouton Reset, les opérations de transfert peuvent débuter.
Une fois le transfert achevé, on positionne l'interrupteur «vers le bas» et on appuie sur le bouton Reset pour lancer le programme.
Ce contexte est identique au précédent. Les programmes sont développés sur une machine avec un système GNU/Linux et exécutés sur le microcontrôleur du système cible. Ces conditions sont décrites dans la Section 3.2, « Ordinateur cible sans système d'exploitation ».
Relativement à la section précédente, il est inutile d'installer des outils supplémentaires pour mettre en oeuvre la chaîne de développement SDCC puisque les applications telles que le shell bash et make sont systématiquement fournies avec les distributions GNU/Linux.
Pour l'exemple de programme retenu, on choisit d'afficher la chaîne de caractères sur le terminal du système de développement (ie. le PC) via une liaison série.
L'appel du compilateur est identique entre les deux systèmes. Les
formats de fichiers sont aussi identiques. Le code exécutable du programme
est contenu dans le fichier ser_hello.ihx.
$ sdcc ser_hello.c $ ll total 144K -rw-r--r-- 1 phil phil 8.4K Apr 19 22:19 ser_hello.asm -rw-r--r-- 1 phil phil 466 Apr 18 21:38 ser_hello.c -rw-r--r-- 1 phil phil 12K Apr 19 22:19 ser_hello.ihx -rw-r--r-- 1 phil phil 193 Apr 19 22:19 ser_hello.lnk -rw-r--r-- 1 phil phil 22K Apr 19 22:19 ser_hello.lst -rw-r--r-- 1 phil phil 14K Apr 19 22:19 ser_hello.map -rw-r--r-- 1 phil phil 1.1K Apr 19 22:19 ser_hello.mem -rw-r--r-- 1 phil phil 3.7K Apr 19 22:19 ser_hello.rel -rw-r--r-- 1 phil phil 22K Apr 19 22:19 ser_hello.rst -rw-r--r-- 1 phil phil 37K Apr 19 22:19 ser_hello.sym
Pour faciliter les développements de programmes «plus complets» que cet exemple, un patron de Makefile est fourni avec les fichiers sources distribués avec ce document : Makefile.
Pour démarrer un nouveau développement, il suffit de copier ce patron
dans un nouveau répertoire et d'affecter à la variable
BASENAME le nom du nouveau fichier source en
langage C.
Ce patron de Makefile suppose que l'on utilise systématiquement la liaison série comme interface utilisateur. Il fait donc référence au fichiers sources et en-têtes qui permettent d'utiliser cette liaison série. Ces fichiers sont aussi présentés dans ce document à la Section 14.2, « Sources MSC1210 ».
Pour effectuer le transfert de fichier en mode ASCII entre le PC de développement et le microcontrôleur, on utilise une application appelée minicom sur les systèmes GNU/Linux.
À partir d'un Shell, on appelle minicom avec les options :
-o pour désactiver le dialogue
Hayes entre les équipements connectés sur la
liaison série.
-8 pour pouvoir utiliser les codes
ASCII sur 8 bits.
$ minicom -o -m -8
Le paramétrage de la liaison se fait avec les options suivantes :
A - Serial Device : /dev/ttyS0 B - Lockfile Location : /var/lock C - Callin Program : D - Callout Program : E - Bps/Par/Bits : 19200 8N1 F - Hardware Flow Control : No G - Software Flow Control : No
Il est important de désactiver le contrôle matériel de flux pour que la fonction de détection automatique du débit puisse s'exécuter normalement.
Il faut positionner l'interrupteur «vers le haut» pour accéder au moniteur intégré du microcontrôleur. Après un appui sur le bouton Reset, on doit obtenir l'invite de commande suivante :
MSC1210 Ver:000305F10 >
Il faut effacer le contenu de la mémoire du microcontrôleur avant de procéder au transfert. La séquence à saisir est la suivante :
>M0000 ok >M8000 ok >E >L
On peut ensuite lancer le transfert de fichier en mode
ASCII après avoir sélectionné le fichier
ser_hello.ihx :
+---------[ascii upload - Press CTRL-C to quit]---------+ |.......................................................| |7.8 Kbytes transferred at 1991 CPS.....................| |.......................................................| |.......................................................| |11.5 Kbytes transferred at 1962 CPS... Done. | | | | READY: press any key to continue...
Une fois le transfert achevé, on positionne l'interrupteur «vers le bas» et on appuie sur le bouton Reset pour lancer le programme.
On obtient alors un affichage de la chaîne de caractères «tant attendue» sur le terminal du PC de développement.
MSC1210 Ver:000305F10 >M0000 ok >M8000 ok >E >T > >Hello World !
![[Linux France logo]](./../images/lf-petit.png)
Vous êtes ici : 
