PhilippeLatu Linux France

philippe.latu(at)linux-france.org

Ce support est une initiation au développement en Langage C sur les systèmes embarqués. Cette version s'appuie sur le microcontrôleur MSC1210 de Texas Instruments. Le support est destiné aux débutants. On présente sommairement l'environnement système, les chaînes de développement, le Langage C et on illustre les applications classiques de ces systèmes spécialisés. Aujourd'hui, la grande majorité des étudiants ont l'habitude d'utiliser des systèmes informatiques sans se poser de questions sur la présence ou non d'un système d'exploitation qui prend en charge la gestion du temps processeur, de la mémoire et des périphériques. Ce document essaie d'illustrer les différences entre les deux contextes d'utilisation avec et sans noyau de système d'exploitation. Le maximum d'exemples de programmes sont présentés dans ces deux contextes. $Revision: 1153 $ $Date: 2007-06-14 14:25:15 +0200 (jeu, 14 jun 2007) $ $Author: latu $ Année universitaire 2006-2007. sdcc langage C microcontrôleur msc1210 msc1210.h rom1210.h rom1210.asm tidownloader Copyright (c) 2000,2007 Philippe Latu. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". Copyright (c) 2000,2007 Philippe Latu. Permission est accordée de copier, distribuer et/ou modifier ce document selon les termes de la Licence de Documentation Libre GNU (GNU Free Documentation License), version 1.2 ou toute version ultérieure publiée par la Free Software Foundation ; sans Sections Invariables ; sans Texte de Première de Couverture, et sans Texte de Quatrième de Couverture. Une copie de la présente Licence est incluse dans la section intitulée « Licence de Documentation Libre GNU ». Cet article est écrit avec DocBook XML sur un système Debian GNU/Linux. Il est disponible en version imprimable aux formats PDF et PostScript : sdcc_course.pdf| sdcc_course.ps.gz. Le système d'exploitation Unix a été conçu au début des années 70. Le Langage C a été développé parallèlement à la mise au point de ce système. Sa première standardisation «de fait» a été publiée dans l'ouvrage de B.W. KERNIGHAN et D.M. RITCHIE en 1978. Même si l'évolution des Langages de programmation C puis C++ est liée à la progression des systèmes Unix, ces langages sont universellement connus et utilisés. On peut pratiquement affirmer qu'il n'existe pas de plate-forme informatique actuelle sur laquelle il n'existe pas une chaîne de développement C/C++. Le Langage C a été conçu pour de multiples utilisations, il n'offre que des structures de programme permettant l'ordonnancement séquentiel, des tests, des boucles et des sous-programmes. Cet aspect, limité en apparence, garantit la «portabilité» des codes sources écrits en C. Dans le domaine des systèmes embarqués, le C est le langage de programmation le plus répandu. Il convient parfaitement au développement des pilotes de périphériques spécialisés tels que les convertisseurs analogiques/numériques, les capteurs, etc. Les outils de développement modernes possèdent des fonctions d'optimisation performantes et le recours au langage assembleur est devenu inutile. Jusqu'à la fin des années 80, la seule méthode de programmation utilisable était procédurale ou structurée. Cette approche consiste à décomposer un problème complexe en un ensemble de tâches ou «procédures» faciles à réaliser. Les données sont alors choisies en fonction des procédures qui vont les manipuler. En fait, cette méthodologie convient parfaitement aux logiciels écrits par des informaticiens à l'usage des informaticiens. Curieusement, le développement des outils informatiques à l'usage de non spécialistes a considérablement augmenté la complexité des programmes. Ces logiciels de plus en plus sophistiqués ont amené les concepteurs à changer de démarche. Il est devenu indispensable de penser d'abord aux données et ensuite aux actions que l'on doit réaliser avec. Un autre aspect très important dans la conception est la réutilisation des développements précédents. Ce principe d'héritage permet de construire des composants logiciels avec des propriétés connues que l'on réutilise suivant ses besoins. De tels composants peuvent même être complétés lors des évolutions des applications. Si la programmation orientée objet n'est pas largement utilisés dans la mise au point des systèmes embarqués, certains de ses concepts ont été repris avec succès. La surdéfinition et l'héritage se retrouvent très souvent dans les développements d'interfaces spécialisées. Comme le développement de pilotes de périphériques matériels est une problématique assez éloignée de l'interface utilisateur, le recours à la programmation orientée objet reste très limité dans ce domaine. Le noyau Linux est un exemple caractéristique ; il est entièrement développé en Langage C. Les évolutions des systèmes d'exploitation basés sur les principes d'Unix et des langages de programmation C/C++ sont associés au développement de l'Internet. Tous ces éléments utilisant un modèle de développement ouvert ont favorisé l'émergence des logiciels libres. De nombreux concepteurs ont produit des bibliothèques d'objets qu'ils ont rendu libres d'utilisation à l'aide de la General Public License. Cette disponibilité d'outils de très grande qualité a permis à d'autres concepteurs de fournir de nouveaux outils et etc. Ainsi, avec un minimum de coordination, on trouve aujourd'hui des systèmes d'exploitation, des environnements graphiques, des chaînes de développement et des suites d'applications de plus en plus performantes. Les principaux outils utilisés dans le présent document sont issus de projets de logiciels libres. La chaîne de développement SDCC - Small Device C Compiler pour microcontrôleurs en est le meilleur exemple. Voir . À l'heure actuelle, la majorité des chaînes de développement suivent le modèle initié par les outils GNU au milieu des années 1980. Les principes sont les suivants. Les outils de base comme le compilateur, l'éditeur de liens et le debugger, etc. sont des briques logicielles individuelles accessibles au niveau . Ils disposent d'un grand nombre d'options ou de commandes permettant de répondre à pratiquement tous les besoins. Ils partagent avec le système d'exploitation de nombreuses bibliothèques telles que la ou bibliothèque standard du Langage C courament appelée libc. Les fonctions ou les appels systèmes fournis par cette bibliothèque sont supportés depuis plus de 25 ans. Elles ont donc été largement adoptées sur un très grand nombre de systèmes différents. Les interfaces de développement sont indépendantes des outils. Les environnements graphiques utilisateurs ne sont que des interfaces facilitant l'utilisation des jeux de commandes des outils GNU. Compte tenu du nombre et de la qualité de ces environnements, les développeurs se «composent» souvent une interface graphique à la carte. Suivant le contexte de développement, les modes d'exploitation diffèrent. Généralement, on distingue les ordinateurs cibles avec système d'exploitation tels que les PCs et les ordinateurs cibles sans système d'exploitation comme les systèmes embarqués qui utilisent des microcontrôleurs spécialisés. Ce contexte correspond aux enseignements «traditionnels» de programmation. L'utilisateur dispose d'une interface graphique (voir ) pour éditer, compiler et exécuter les programmes (voir ). En règle générale, lorsque le programme est exécuté sur une machine cible avec système d'exploitation, les périphériques tels que le clavier, l'écran et la souris sont toujours disponibles. Cette situation «confortable» suppose plusieurs couches intermédiaires de logiciel entre l'utilisateur et le matériel. L'ensemble de ces couches intermédiaires s'appelle un système d'exploitation. L'image ci-dessous représente les couches constituant un système d'exploitation. Les couches logicielles d'un système d'exploitation Les couches logicielles d'un système d'exploitation BIOS Basic Input Output System Ce logiciel ne fait pas vraiment partie du système d'exploitation. À la mise sous tension de l'équipement (PC ou autre), son rôle est de recenser les ressources matérielles disponibles : type de processeur, quantité de mémoire, nombre et type de périphériques de stockage, interfaces réseau, écran, clavier, etc. Une fois l'étape de recensement passée, les périphériques de stockage sont scrutés un à un à la recherche d'un code particulier qui permet le lancement du système d'exploitation. Kernel noyau Ce logiciel constitue le coeur du système d'exploitation. Il assure 3 fonctions principales : La gestion des entrées-sorties Le noyau intègre ses propres fonctions de recensement des ressources matérielles. Il peut très bien ne tenir aucun compte des informations fournies par le BIOS. Le noyau doit posséder un pilote pour chaque périphérique d'entrée-sortie «présent» dans le système. Un noyau moderne doit aussi gérer l'ajout et le retrait de périphériques en cours de fonctionnement. On parle de branchement «à chaud» ou hotplug. La gestion des accès mémoire Un système peut intégrer différents types de mémoires dynamiques et le noyau doit gérer ces différents éléments comme un tout cohérent. Les programmes doivent accéder à ce «plan mémoire» de façon transparente en utilisant des segments alloués en fonction de leurs besoins. De plus, si le plan mémoire est partagé entre plusieurs programmes, le noyau doit utiliser un algorithme spécifique de planification et de distribution des accès entre ces programmes. On parle alors de système multi-tâches. Linux est un exemple caractéristique de ce type de noyau. La gestion du temps processeur Le temps du processeur doit être partagé entre les programmes comme le plan mémoire. On découpe donc ce temps processeur en tranches qui sont attribuées aux programmes à la demande. La fonction correspondante du noyau est appelée ordonnanceur ou scheduler. Sur un système moderne dans lequel les temps d'accès aux périphériques et les transmissions réseau sont suffisamment rapides, c'est l'ordonnanceur qui est le «maître» du temps. On peut le comparer à une horloge de réglage du rythme cardiaque d'un système. Shell L'interface des commandes utilisateur Un Shell permet à l'utilisateur du système de lancer des programmes ou commandes. On parle de commande lorsqu'il s'agit de «manipuler» le système : lister les fichiers d'un répertoire, afficher la quantité de mémoire disponible, etc. Sur les systèmes multi-tâches et multi-utilisateurs tels que GNU/Linux et *BSD, de nombreux Shells peuvent être actifs en même temps. À l'inverse, sur les systèmes mono-tâches hérités du DOS (Disk Operating System) de Micro$oft, on ne dispose que d'un Shell unique. Le séquencement entre le les programmes Lorsque plusieurs programmes doivent être exécutés sur un même système, il est fréquent que ces programmes échangent des paramètres où se lancent en fonction d'actions réalisées par d'autres programmes. Lorsque l'on utilise une interface graphique et que l'on clique sur une fenêtre pour l'activer, on réalise une opération de ce type. Application À ce niveau on trouve généralement l'interface graphique utilisateur qui permet de réaliser les manipulations système de façon plus intuitives qu'au niveau Shell. À ce gestionnaire de fenêtres sont associées toutes les applications usuelles d'un système généraliste : navigation Web, traitement de textes, Environnement de développement intégré (comme ), etc. C'est aussi à ce niveau que les programmes développés par nos soins sont exécutés. Ce contexte correspond aux enseignements pratiques d'informatique industrielle. Si l'utilisateur dispose d'une interface graphique de développement intégrée, le logiciel développé doit être exécuté sur un système spécialisé. On parle de système embarqué dédié à la réalisation de fonctions spécifiques. Il est rare que ces systèmes disposent d'un écran et d'un clavier. Contrairement à la situation précédente avec système d'exploitation, les conditions de développement sont moins «confortables». Ceci-dit, comme le nombre de couches logicielles est nettement réduit, la description est plus simple. Les couches logicielles d'un système embarqué simple Les couches logicielles d'un système embarqué simple Le moniteur Le seul point commun entre le moniteur et le BIOS se situe au niveau du lancement de programme. Là où le BIOS identifie le code de lancement du système sur le premier secteur d'un périphérique, le moniteur identifie l'adresse de lancement d'une application dans le plan mémoire du microcontrôleur. Sur un système spécialisé avec microcontrôleur, la configuration matérielle est figée. Il est donc totalement inutile de procéder à un recensement des ressources du système. Le premier rôle d'un moniteur est d'assurer le téléchargement des programmes entre le système de développement (généralement un PC) et le système spécialisé (le microcontrôleur). Ce téléchargement est réalisé à l'aide une liaison série ou réseau. Les microcontrôleurs récents intègrent en plus du moniteur un ensemble de sous-programmes (routines) qui offrent des fonctions simples de pilotage de périphériques et de manipulations de la mémoire intégrée au composant. Application À ce niveau le microcontrôleur exécute le ou les programme(s) utilisateur. Comme on n'utilise pas de noyau, les programmes utilisateur doivent intégrer directement le pilotage des périphériques : liaison série, affichage LCD, conversion analogique/numérique, capteurs, etc. Si tous les programmes que vous avez à écrire fonctionnaient parfaitement du premier coup le cycle de développement se résumerait aux 3 étapes suivantes : Écrire le code source, le compiler, lancer le programme. Malheureusement, quelque soit le programme et quelque soit le niveau d'expérience en programmation, on rencontre toujours des erreurs à chacune des étapes énoncées ci-dessus. Le cycle de développement devient alors le suivant : Synoptique du cycle de développement Synoptique du cycle de développement 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». #include <stdio.h> int main() { printf ("Hello, World!\n"); return 0; } #include <stdio.h> : inclusion des prototypes de sous-programmes de la bibliothèque standard d'entrée-sortie (stdio ou standard input output). 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 ). 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 printf qui appartient à la bibliothèque stdio. int main() { : début du programme principal. 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 et qui renvoie à ce même une indication sur ses conditions d'exécution (un nombre entier). L'accolade '{' est le délimiteur de début des instructions du programme principal. printf ("Hello, World!\n"); : appel de la fonction printf de la bibliothèque standard d'entrée-sortie. 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 '\'. On parle de caractères d'échappement. Dans cet exemple, '\n' correspond au saut de ligne. Les instructions sont séparées par le caractère ';'. return 0; : valeur renvoyée au système d'exploitation (via le ) en fin de programme. La valeur 0 correspond à une sortie «sans erreur» du programme. 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 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!». Environnement de développement sur système embarqué Environnement de développement sur système embarqué Avec le synoptique ci-dessus, on développe (voir ) 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. #include <stdio.h> #include <msc1210.h> #include "ser_msc1210.h" // (sur)définition du sous-programme putchar utilisé par printf void putchar(char c) { ser_putc(c); } void main(void) { // Appuyer sur <Entrée> pour ajuster automatiquement // le débit de la liaison autobaud(); // Initialisations pour SDCC EA=1; // Affichage sur le terminal printf("Hello, World!"); putcr(); while(1); } Comme indiqué dans le premier cas, les directives #include servent à inclure des définitions pour le pré-processeur. Dans le cas présent, 3 fichiers de définitions sont utilisés. stdio.h : fichier d'en-tête contenant les prototypes des fonctions d'entrées-sorties standard. Si ce fichier porte le même nom que celui donné dans le premier fichier source, le catalogue des sous-programmes mis à disposition sur un microcontrôleur est nettement réduit relativement au cas général d'une machine avec système d'exploitation. Dans le cas présent, ce fichier fournit le prototype de la fonction printf utilisée pour émettre la chaîne de caractères depuis le microcontrôleur sur la liaison série. msc1210.h : fichier d'en-tête contenant les définitions des registres des microcontrôleurs de la famille MSC12xx. ser_msc1210.h : fichier d'en-tête contenant les prototypes des sous-programmes intégrés dans la mémoire ROM du composant microcontrôleur. Dans cet exemple, ce sont les fonctions de pilotage de la liaison série qui sont utiles : autobaud et ser_putc. Le fait que ce fichier soit noté «entre guillemets» indique qu'il s'agit d'un fichier local qui n'est pas fourni avec la chaîne de développement. Voir le fichier et la documentation sur ces fonctions intégrées. void putchar(char c); : surdéfinition de la fonction d'affichage d'un caractère. 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 tx_byte fait partie de la bibliothèque intégrée du microcontrôleur. Sa définition est donnée dans le fichier d'en-tête rom1210.h. Voir . Le mot clé void signifie que la fonction ne renvoie aucun paramètre. Le paramètre d'entrée c est défini comme étant de type caractère (représenté sur un octet) par le mot clé char. Voir void main(void) { : début du programme principal. Par différence avec le premier programme, on constate avec l'emploi des mots clé void qu'aucun paramètre n'est passé en entrée et qu'aucun paramètre n'est renvoyé en sortie. Ce codage est tout à fait normal dans un contexte sans système d'exploitation. Ce programme sera le seul exécuté sur le microcontrôleur. Il n'aura donc pas à échanger avec un autre logiciel. autobaud(); : appel de la fonction de détection automatique du débit sur la liaison série. 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é. printf("Hello World !"); : appel de la fonction printf. 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 : '\r' (retour chariot ou Carriage Return ou CR) pour renvoyer le curseur en début de ligne et '\n' (saut de ligne ou Line Feed ou LF) pour descendre le curseur d'une ligne. Cette opération est réalisée par l'appel à la fonction putcr(). while(1); : boucle «d'attente» infinie. 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 . On distingue deux familles de systèmes d'exploitation : Windows et GNU/Linux. Copie d'écran Dev-Cpp & exécution Hello, World! Copie d'écran Dev-Cpp & exécution Hello, World! 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 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 . 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 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 . 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. Outils de développement 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. Compilation avec Windows XP On appelle le compilateur SDCC à partir d'une console. Copie d'écran compilation hello.c sur Windows XP avec SDCC Copie d'écran compilation hello.c sur Windows XP avec SDCC 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. Utilisation d'un Makefile 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 : . 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 . Transfert du programme avec Windows XP 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. Sélection du fichier ser_hello.ihx Sélection du fichier ser_hello.ihx Paramétrage de la liaison série pour le transfert Paramétrage de la liaison série pour le transfert Transfert du code du programme vers le système cible Transfert du code du programme vers le système cible Exécution du programme depuis Windows XP Une fois le transfert achevé, on positionne l'interrupteur «vers le bas» et on appuie sur le bouton Reset pour lancer le programme. Exécution du programme Exécution du 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 . 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. Compilation avec GNU/Linux 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 Utilisation d'un Makefile 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 : . 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 . Transfert du programme avec GNU/Linux 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... Exécution du programme depuis GNU/Linux 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 ! Les composants de la famille MSC12xx reprennent les caractéristiques usuelles d'un microcontrôleur : des fonctions de conversion analogique numérique, un coeur «amélioré» de la famille Intel MCS51, de la mémoire de type RAM et de type FLASH, des périphériques logiques performants. Le coeur MCS51 «amélioré» comprend deux pointeurs de données et exécute la plupart des instructions trois fois plus vite qu'un coeur 8051 standard. Avec une vitesse d'exécution plus grande, ce composant est utilisable avec un grand nombre d'applications qui réclament des performances en fréquence. La liste des documents de référence sur cette famille de microcontrôleurs est donnée à la . Cette section présente succinctement les éléments essentiels du Langage C en donnant un maximum d'exemples adaptés au développement sur système spécialisé. On utilise un exemple de programme presque aussi connu que le très fameux «Hello, World!» ; le calcul des nombres de Fibonacci. On commence par présenter le listing complet, puis on détaille les éléments de la syntaxe du Langage C. Le même programme est présenté sous plusieurs formes différentes en fonction du contexte de développement. 01: /* $Id: gcc_fibonacci_single.c 1129 2007-05-07 15:07:52Z latu $ 02: * Un programme simple pour calculer les n premiers nombres de Fibonacci */ 03: 04: #include <stdio.h> 05: #include <stdlib.h> 06: 07: #define MAX_FIB 49 08: 09: main() { 10: 11: int n, i; 12: unsigned int nombrePrecedent, nombreCourant, fibonacci; 13: 14: 15: printf("Saisir le nombre de calculs de Fibonacci(n) :\n"); 16: scanf("%d", &n); 17: if (n >= MAX_FIB) { 18: printf("Fibonacci(%d) depasse la capacite d'un mot de 32 bits\n", n); 19: exit(1); 20: } 21: 22: nombrePrecedent = 0; 23: nombreCourant = 1; 24: for (i = 0; i < n; i++) { 25: if (i > 1) { 26: fibonacci = nombrePrecedent + nombreCourant; 27: nombrePrecedent = nombreCourant; 28: nombreCourant = fibonacci; 29: printf("Fibonacci (%d) = %u\n", i, fibonacci); 30: } 31: else 32: printf("Fibonacci (%d) = %u\n", i, i); 33: } 34: } Voici un exemple d'exécution du programme  : $ ./gcc_fibonacci_single.out Saisir le nombre de calculs de Fibonacci(n) : 11 Fibonacci (0) = 0 Fibonacci (1) = 1 Fibonacci (2) = 1 Fibonacci (3) = 2 Fibonacci (4) = 3 Fibonacci (5) = 5 Fibonacci (6) = 8 Fibonacci (7) = 13 Fibonacci (8) = 21 Fibonacci (9) = 34 Fibonacci (10) = 55 Comme dans le cas du premier programme présenté, le code source du programme destiné au microcontrôleur MSC1210 inclut le pilotage de l'interface série. Dans ce contexte de développement, on ne dispose pas de système d'exploitation. 01: #include <stdio.h> 02: #include <stdlib.h> 03: #include <msc1210.h> 04: #include "ser_msc1210.h" 05: 06: #define MAX_FIB 49 07: 08: // surdefinition du sous-programme putchar 09: void putchar(char c) { 10: ser_putc(c); 11: } 12: 13: void main(void) { 14: 15: unsigned char s[3] = {'\0','\0','\0'}; 16: int n, i; 17: unsigned long nombrePrecedent, nombreCourant, fibonacci; 18: 19: // Appuyer sur <Entree> pour ajuster automatiquement 20: // le debit de la liaison 21: autobaud(); 22: EA=1; 23: 24: do { 25: printf("Saisir le nombre de calculs de Fibonacci :\r\n"); 26: ser_gets_echo(s, 2); 27: n = atoi(s); 28: if (n >= MAX_FIB) 29: printf("\nFibonacci(%d) depasse la capacite d'un mot de 32 bits\r\n", n); 30: } while (n >= MAX_FIB); 31: 32: printf("\r\n\n"); 33: nombrePrecedent = 0; 34: nombreCourant = 1; 35: for (i = 0; i < n; i++) { 36: if (i > 1) { 37: fibonacci = nombrePrecedent + nombreCourant; 38: nombrePrecedent = nombreCourant; 39: nombreCourant = fibonacci; 40: printf("Fibonacci (%d) = %lu\r\n", i, fibonacci); 41: } 42: else 43: printf("Fibonacci (%d) = %d\r\n", i, i); 44: } 45: while(1); 46: } Voici un exemple de résultat d'exécution du programme  : MSC1210 Ver:000305F10 >M0000 ok >M8000 ok >E >Saisir le nombre de calculs de Fibonacci : 11 Fibonacci (0) = 0 Fibonacci (1) = 1 Fibonacci (2) = 1 Fibonacci (3) = 2 Fibonacci (4) = 3 Fibonacci (5) = 5 Fibonacci (6) = 8 Fibonacci (7) = 13 Fibonacci (8) = 21 Fibonacci (9) = 34 Fibonacci (10) = 55 Généralités sur les délimiteurs de syntaxe du Langage C des exemples ci-dessus : Les commentaires Ils sont repérés par deux slashes (//) si le texte du commentaire ne comprend qu'une seule ligne. Ils sont délimités entre les balises /* et */ si le texte du commentaire comprend plusieurs lignes.  : les lignes 1 et 2 correspondent à un même commentaire.  : les lignes 8, 19 et 20 sont des commentaires sur une ligne unique. Les directives du préprocesseur Elles sont repérées par le caractère dièse en début de ligne : #include <stdio.h> #define TRUE 1 Ces directives ne sont pas considérées comme faisant partie du code. Elles ne sont donc pas délimitées comme des instructions «classiques».  : lignes 4, 5 et 7.  : lignes 1 à 4 puis 6. Les instructions Elles sont séparées par le caractère point-virgule : printf ("Hello,"); printf (" World!"); Dans les deux exemples de référence ci-dessus, on relève que toutes les instructions (déclarations de variables, opérations, etc.) sont délimitées par des caractères ';' à l'exception des directives du préprocesseur. Les groupes d'instructions Ils sont délimités par les caractères accolades ouvertes et fermées : while(1) { printf ("Hello,"); printf (" World!"); }  : les lignes 9 et 34 contiennent les accolades qui délimitent le début et la fin du programme principal.  : les lignes 24 et 30 délimitent le groupe d'instructions qui doivent être répétées tant que le test (n >= MAX_FIB) n'est pas satisfait. En programmation, les données manipulées sont appelées variables ou constantes. Une variable sert au stockage d'une information en vue de sa réutilisation dans le programme principal et|ou un sous-programme. Du point de vue gestion de la mémoire (RAM ou Random Access Memory), une variable est une zone mémoire réservée et «étiquetée» avec le nom de cette variable. Sur une machine avec système d'exploitation, la phase de déclaration d'une variable correspond à une demande de réservation mémoire au gestionnaire de mémoire virtuelle du noyau. Ce gestionnaire doit gérer au mieux ces demandes en fonction des programmes actifs sur le système. Sur un système spécialisé, c'est au développeur de gérer «manuellement» son espace mémoire. Il n'existe aucune protection contre le débordement de la capacité mémoire. Du point de vue syntaxique, il existe certaines restrictions dans l'emploi des noms de variables et de constantes. Les caractères de ponctuation ne sont pas utilisables. Le caractère «souligné» (underscore) est considéré comme une lettre ; il est beaucoup utilisé par le préprocesseur. En Langage C, les majuscules et les minuscules sont traitées différemment. On utilise généralement les majuscules pour les définitions de constantes et les minuscules pour les variables. Suivant la génération du compilateur utilisé, le nombre de caractère pris en compte pour les noms de variables est plus ou moins limité. Historiquement, cette limite était fixée à 8 bien que l'on puisse en utiliser davantage dans le code source. Dans les deux exemples ci-dessus, on trouve les déclarations des variables après l'accolade de début de programme principal (fonction main()).  : lignes 11 et 12.  : lignes 15 à 17. Pour représenter les données à manipuler on distingue différents types élémentaires définis dans la syntaxe du langage de programmation. La table ci-dessous donne une liste complète de ces types. Type de donnée syntaxe C rien ou vide void caractère char nombre entier court short nombre entier int nombre entier long long nombre entier long double long long nombre réel float nombre réel double double nombre réel long double long double À la lecture de la table ci-dessus, on constate que le langage C n'offre pas de type booléen. Pour autant, la valeur entière 0 correspond à l'état faux et toutes les autres valeurs entières correspondent à l'état vrai. La technique usuelle pour représenter les deux états booléens consiste à définir deux constantes. Voir . En Langage C, si les noms de types sont toujours les mêmes, leurs formats diffèrent suivant les chaînes de développement et les processeurs utilisés. Les deux exemples ci-dessous illustrent ces différences. Dans le cas de la chaîne de développement GNU utilisée sur PC, il est possible de représenter de très grands nombres réels sur 12 octets soit 96 bits. À l'inverse, il n'est pas possible de représenter une donnée sur moins d'un octet. Voici le résultat d'un programme utilisant la fonction sizeof pour chacun des types donnés dans la liste ci-dessus. Le code source de ce programme est disponible à l'adresse : gcc_sizeof.tar.bz2. Dimension de chaque type en octets : 'char' : 1 'unsigned char' : 1 'short' : 2 'int' : 4 'long' : 4 'long long' : 8 'float' : 4 'double' : 8 'long double' : 12 Dans le cas du compilateur SDCC et du microcontrôleur cible MSC1210, il n'est pas possible d'utiliser des nombres réels au delà de la représentation simple sur 4 octets. La plus petite unité représentée est le bit même si l'appel à la fonction sizeof pour ce type produit un résultat surprenant  1 octet pour 1 bit. Comme avec la chaîne de développement GNU/GCC, voici le résultat d'un programme utilisant la fonction sizeof pour chacun des types donnés dans la liste ci-dessus. Le code source de ce programme est disponible à l'adresse : sdcc_sizeof.tar.bz2. >Dimension de chaque type en octets : 'char' : 1 'unsigned char' : 1 'short' : 2 'int' : 2 'long' : 4 'long long' : 4 'float' : 4 Attention ! le type bit existe : 'bit' : 1  : lignes 11 et 12. Ce programme est limité au calcul des nombres de Fibonacci qui ne dépassent pas la capacité d'un entier représenté sur 32 bits (soit 4 octets). On utilise donc le type int dans le code source du programme.  : ligne 16 et 17. Ce programme est aussi limité à une représentation des nombres entiers sur 32 bits. Avec le compilateur SDCC, c'est le type long qui est utilisé dans le code source du programme pour répondre au critère de calcul. Une constante est une valeur particulière que l'on utilise tout au long du programme. Si cette valeur doit être modifiée, il est préférable de n'avoir qu'une seule ligne à éditer. En terme de maintenabilité du code source, l'utilisation de constantes est très avantageux. De plus, l'utilisation d'une représentation littérale d'une valeur numérique particulière permet de gagner en lisibilité. En informatique industrielle, on fait un usage «massif» des constantes. En effet tous les registres et les adresses de pilotage des périphériques spécialisés sont représentés à l'aide de constantes. Si ce mode de représentation n'existait pas, on ne pourrait utiliser que des valeurs hexadécimales. Les difficultés de développement des programmes seraient beaucoup plus importantes du fait des confusions possibles entre des valeurs voisines. En Langage C, les constantes sont en fait des directives destinées au préprocesseur. En effet, comme le rôle du préprocesseur est d'analyser la syntaxe du code source d'un programme, il peut se charger de substituer toutes les occurrences des constantes par leurs valeurs numériques avant de passer à la compilation proprement dite. Cette technique est très avantageuse puisque l'utilisation des constante ne nécessite aucune réservation en mémoire. Les deux exemples de programmes montrent la même constante MAX_FIB déclarée à l'aide de la directive #define. Cette constante correspond aux rang maximum du nombre de Fibonacci que l'on peut représenter sur 32 bits. Il faut noter qu'une directive de préprocesseur n'est pas instruction du langage C. C'est la raison pour laquelle on n'utilise pas le caractère ';' comme délimiteur. Cette absence de délimitation ne pose pas de difficulté dans la mesure où on ne peut trouver qu'une directive par ligne.  : ligne 7.  : ligne 6. Dans les exemples «rituels» de définition de constantes on trouve les deux états booléens : #define FALSE 0 #define TRUE 1 Le fichier d'en-tête standard limits.h est un exemple caractéristique de liste de définitions de constantes. Ce fichier contient les définitions des valeurs entières maximales pour chaque type connu. Voici un extrait du fichier fourni avec la chaîne GNU/GCC : /* Number of bits in a `char'. */ # define CHAR_BIT 8 /* Minimum and maximum values a `signed char' can hold. */ # define SCHAR_MIN (-128) # define SCHAR_MAX 127 /* Maximum value an `unsigned char' can hold. (Minimum is 0.) */ # define UCHAR_MAX 255 /* Minimum and maximum values a `char' can hold. */ # ifdef __CHAR_UNSIGNED__ # define CHAR_MIN 0 # define CHAR_MAX UCHAR_MAX # else # define CHAR_MIN SCHAR_MIN # define CHAR_MAX SCHAR_MAX # endif /* Minimum and maximum values a `signed short int' can hold. */ # define SHRT_MIN (-32768) # define SHRT_MAX 32767 /* Maximum value an `unsigned short int' can hold. (Minimum is 0.) */ # define USHRT_MAX 65535 /* Minimum and maximum values a `signed int' can hold. */ # define INT_MIN (-INT_MAX - 1) # define INT_MAX 2147483647 /* Maximum value an `unsigned int' can hold. (Minimum is 0.) */ # define UINT_MAX 4294967295U On retrouve les opérateurs usuels en Langage C : +, -, * et /. À cette liste, il faut ajouter les éléments propres aux calculs en Langage C. Opérateur modulo % Cet opérateur, noté %, renvoie le reste de la division entre 2 entiers. Par exemple : 24 % 9 = 6 Opérateurs d'incrémentation et de décrémentation ++ et -- Pour ajouter une unité à une variable, on utilise l'opérateur d'incrémentation ++. Pour soustraire une unité à une variable, on utilise l'opérateur de décrémentation --. La position de l'opérateur, à la gauche ou à la droite du nom de variable à une signification particulière. Dans l'expression 'while (++n < 10)', la variable n sera incrémentée avant d'être comparée à 10. À l'inverse, dans l'expression 'while (n++ < 10)', la variable n est comparée à 10 avant d'être incrémentée. Opérateurs et expressions d'affectation En Langage C, on peut appliquer la règle suivante sur les 2 expressions e1 et e2 : '(e1) = (e1) (opérateur) (e2)' est équivalent à '(e1) (opérateur)= (e2)'. Tous les opérateurs usuels de calculs sont utilisables avec cette règle. Ainsi, i = i + 2; est équivalent à i += 2;.  : à la ligne 24, on trouve un opérateur d'incrémentation du compteur des calculs à effectuer.  : à la ligne 35, on retrouve le même opérateur d'incrémentation. Ces opérateurs évaluent une condition sur des nombres entiers ou réels et renvoient une valeur booléenne 0 ou 1. Symbole Opérateur|Condition == égalité != différence > supérieur à < inférieur à >= supérieur ou égal à <= inférieur ou égal à  : lignes 17, 24 et 25. Ces opérateurs relationnels sont utilisés pour évaluer une condition sur des valeurs entières dans les calculs.  : lignes 28, 30, 35 et 36. Comme dans le cas précédent, on évalue une condition sur des valeurs entières. Symbole Opérateur & ET | OU (inclusif) ^ OU (exclusif) << décalage à gauche avec remplissage par 0 >> décalage à gauche avec remplissage par 0 ~ négation binaire ou complément à 1 On utilise l'instruction if-else pour prendre des décisions. Sa forme générale est  : if ( expression ) instruction1; else instruction2; Si l'expression est vraie, c'est l'instruction 1 qui est exécutée ; sinon c'est l'instruction 2. Les instructions 1 et 2 peuvent correspondre à des groupes délimités par des caractères { et }. La partie else est optionnelle. Si l'instruction 2 n'existe pas, on n'utilise pas ce mot clé. Si la condition codée dans l'expression n'est pas vérifiée (est fausse) c'est la valeur numérique 0 qui est renvoyée. Pour toutes les autres valeurs renvoyées par l'expression, la condition est considérée comme vérifiée (est vraie). En langage C, il est très fréquent d'utiliser directement les valeurs numériques dans les instructions if-else sans coder explicitement la condition dans l'expression. De nombreux exemples de ce mode de codage ont été volontairement placés dans les exemples de programmes fournis dans le présent document.  : les lignes 17 à 20 permettent de contrôler que l'utilisateur a bien saisi un nombre de calculs compatible avec la représentation sur 32 bits du résultat. Si l'utilisateur saisit une valeur supérieure à la constante MAX_FIB, on affiche le message d'erreur à la console et l'exécution du programme s'arrête. Les deux instructions à traiter si l'expression est vraie sont encadrées par des accolades. Les lignes 25 à 30 montrent que l'on effectue le calcul des nombres de Fibonacci pour les valeurs de la variable i strictement supérieures à 1. Si cette condition n'est pas respectée, on affiche directement le numéro du calcul comme résultat.  : les lignes 28 et 30 permettent de contrôler que l'utilisateur a bien saisi un nombre de calculs dont les résultats sont correctement représentés sur 32 bits. Dans ce cas, on se contente d'afficher le message d'erreur. On n'utilise pas d'accolades de délimitation de groupe d'instructions. Comme dans la version GNU/GCC, les lignes 36 à 41 montrent que l'on effectue le calcul des nombres de Fibonacci pour les valeurs de la variable i strictement supérieures à 1. Le traitement des choix multiples peut devenir compliqué lorsque l'imbrication des blocs d'instructions entre instructions if-else augmente. C'est pour cette raison qu'une syntaxe particulière à été introduite : l'instruction switch dont le synoptique est le suivant. switch (expression) { case Valeur1: // Instructions break; case Valeur2: // Instructions break; ... case ValeurN: // Instructions break; default: // Instructions } Le cas classique d'utilisation de l'instruction switch consiste à programmer un menu à choix multiples. La variable à tester est de type simple puisqu'il s'agit d'un caractère. Le programme illustre justement l'utilisation d'un menu suivi d'un test à choix multiples. Cette structure est très pratique lorsque le résultat de l'expression est de type simple. Lorsque l'on doit évaluer non pas une valeur mais une plage de valeurs, il devient alors plus pratique de retenir un codage du type suivant. if (condition1) { // Instructions } else if (condition2) { // Instructions } else if (condition3) { // Instructions } // autres conditions else { // Instructions } Dès lors qu'une ou plusieurs instructions doivent être répétées, on utilise les instructions de boucles disponibles avec le Langage C. Indépendemment du langage de programmation utilisé, il existe des règles dans l'emploi des boucles. On emploie la boucle pour (for) lorsque l'on connaît le nombre d'itérations (ie. le nombre de fois où le traitement doit être répété dans la boucle). On emploie la boucle répéter jusqu'à (do-while) lorsque le corps de la boucle doit être exécuté au moins une fois. On emploie la boucle tant que (while) lorsque le corps de la boucle peut ne pas être exécuté. La boucle pour (for) en C/C++ comprend 3 champs distincts : l'initialisation, le test de sortie et l'incrémentation. for (initialisation; test; incrémentation ) { // Instructions } Les 3 champs définis ci-dessus peuvent être composés à l'aide de n'importe quelle expression C/C++ valide. Ce mode de construction des boucles pour est une originalité importante du C/C++. Il faut cependant être vigilant lors du choix des expressions placées dans ces champs. Un codage trop compact (avec des appels multiples de fonctions par exemple) et|ou des opérations sur des variables sans relations sont très pénalisant pour la mise au point des programmes.  : lignes 24 à 30. On trouve ici un exemple de boucle pour servant à compter le nombre de calculs à effectuer. La variable i sert au comptage. Elle est initialisée à 0 dans le premier champ. Le comptage se poursuit tant que la variable i est strictement inférieur au nombre n. À chaque «tour» la variable i est incrémentée.  : lignes 35 à 41. On retrouve une syntaxe identique à l'exemple précédent. Conformément à la règle énoncée ci-dessus, le test est effectué après une première exécution du corps de la boucle répéter jusqu'à (do-while). do { // Instructions } while (test); Comme dans le cas de la boucle précédente, la condition testée peut être composée à l'aide de n'importe quelle expression C/C++ valide. Il est donc préférable de limiter la complexité de cette expression pour faciliter la mise au point des programmes.  : lignes 24 à 30. Ici, la saisie du nombre de calculs à effectuer dans la suite du programme est répétée tant que la valeur est supérieure ou égale à la limite MAX_FIB. La limite MAX_FIB correspond au maximum pour lequel le calcul du nombre de Fibonacci est représentable sur 32 bits. Conformément à la règle énoncée ci-dessus, le test est effectué avant que le corps de la boucle tant que (while) ne soit exécuté. while (test) { // Instructions } Une fois encore ! attention à l'expression de test.  : lignes 7 et 8. On trouve ici un exemple de boucle tant que servant à reproduire à la console le caractère saisi au clavier tant que celui-ci est différent du code ASCII EOF. On remarque que la boucle ne comprend qu'une seule instruction putchar(c). C'est la raison pour laquelle les accolades ne sont pas nécessaires. Voir .  : lignes 24 à 28. On retrouve le même traitement que dans l'exemple précédent. On a simplement ajouté un test nécessaire au saut le ligne lors d'un appui sur la touche Entrée. La démarche classique de construction d'un programme informatique veut que l'on découpe un problème complexe en sous-ensembles plus faciles à traiter. Du point de vue du codage, cette démarche se traduit par l'utilisation de sous-programmes correspondant à ces sous-ensembles. La réutilisation de code est un autre argument pour l'emploi des sous-programmes. Si un même traitement doit être répété à plusieurs reprises dans un programme, il est préférable de le placer dans un sous-programme qui sera appelé autant de fois que nécessaire. Enfin, le recours aux sous-programmes doit faciliter la lecture et la mise au point des programmes. Un jeu de sous-programmes bien écrit et compréhensible par un grand nombre de programmeurs peut être réutilisé sous forme de bibliothèque. La bibliothèque glibc est probablement l'exemple le plus emblématique de bibliothèque partagée. Elle est disponible avec la totalité des chaînes de développement en Langage C sur tous les systèmes d'exploitation et pour presque tous les processeurs. Les fonctions getchar, putchar, printf et atoi sont quelques exemples de sous-programmes partagés à l'aide de la bibliothèque glibc. On les retrouve dans les programmes d'illustration présentés dans ce document. 01: #include <stdio.h> 02: #include <stdlib.h> 03: 04: #define MAX_FIB 49 05: 06: unsigned long iterative_fibonacci(unsigned long f) { 07: 08: unsigned long nombrePrecedent = 0, nombreCourant = 1, fibonacci = 0; 09: int i; 10: 11: if (f > 1 ) 12: for (i = 1; i < f; i++) { 13: fibonacci = nombrePrecedent + nombreCourant; 14: nombrePrecedent = nombreCourant; 15: nombreCourant = fibonacci; 16: } 17: else 18: fibonacci = f; 19: 20: return fibonacci; 21: } 22: 23: main() { 24: 25: int n, i; 26: 27: printf("Saisir le nombre de calculs de Fibonacci(n) :\n"); 28: scanf("%d", &n); 29: if (n >= MAX_FIB) { 30: printf("Fibonacci(%d) depasse la capacite d'un mot de 32 bits\n", n); 31: exit(1); 32: } 33: 34: for (i = 0; i < n; i++) 35: printf("Fibonacci (%d) = %lu\r\n", i, iterative_fibonacci(i)); 36: } On retrouve des résultats identiques aux précédents avec le programme . 01: #include <msc1210.h> 02: #include "ser_msc1210.h" 03: #include <stdio.h> 04: #include <stdlib.h> 05: 06: #define MAX_FIB 49 07: 08: // surdefinition du sous-programme putchar 09: void putchar(char c) { 10: ser_putc(c); 11: } 12: 13: unsigned long iterative_fibonacci(unsigned long f) { 14: 15: unsigned long nombrePrecedent = 0, nombreCourant = 1, fibonacci = 0; 16: int i; 17: 18: if (f > 1 ) 19: for (i = 1; i < f; i++) { 20: fibonacci = nombrePrecedent + nombreCourant; 21: nombrePrecedent = nombreCourant; 22: nombreCourant = fibonacci; 23: } 24: else 25: fibonacci = f; 26: 27: return fibonacci; 28: } 29: 30: void main(void) { 31: 32: unsigned char s[3] = {'\0','\0','\0'}; 33: int n, i; 34: 35: // Appuyer sur <Entree> pour ajuster automatiquement 36: // le debit de la liaison 37: autobaud(); 38: EA=1; 39: 40: do { 41: printf("Saisir le nombre de calculs de Fibonacci :\r\n"); 42: ser_gets_echo(s, 2); 43: n = atoi(s); 44: if (n >= MAX_FIB) 45: printf("\nFibonacci(%d) depasse la capacite d'un mot de 32 bits\r\n", n); 46: } while (n >= MAX_FIB); 47: 48: printf("\r\n\n"); 49: for (i = 0; i < n; i++) 50: printf("Fibonacci (%d) = %lu\r\n", i, iterative_fibonacci(i)); 51: 52: while(1); 53: } On retrouve aussi des résultats identiques aux précédents avec le programme . MSC1210 Ver:000305F10 >M0000 ok >M8000 ok >E >T > >Saisir le nombre de calculs de Fibonacci : 11 Fibonacci (0) = 0 Fibonacci (1) = 1 Fibonacci (2) = 1 Fibonacci (3) = 2 Fibonacci (4) = 3 Fibonacci (5) = 5 Fibonacci (6) = 8 Fibonacci (7) = 13 Fibonacci (8) = 21 Fibonacci (9) = 34 Fibonacci (10) = 55  : Dans le programme principal (main()), à la ligne 35, on trouve l'appel au sous-programme iterative_fibonacci(i). La variable i est passée comme paramètre d'entrée lors de l'appel au sous-programme. Entre les lignes 6 et 21, on trouve le sous-programme iterative_fibonacci(i). La ligne 6 correspond au prototype du sous-programme : c'est là que l'on désigne le nom du sous-programme ainsi que les types des paramètres d'entrée et de sortie. Dans l'exemple, les paramètres échangés sont de type unsigned long.  : On retrouve les mêmes éléments que dans le cas précédent. Le sous-programme iterative_fibonacci(i) est appelé au niveau de la ligne 50. Ce sous-programme est défini entre les lignes 13 et 28. Les paramètres échangés sont du même type entre les deux programmes. Entrée standard Fonction getchar Flux stdin Le mécanisme d'entrée le plus simple consiste à lire un caractère provenant de l'entrée standard. Suivant le contexte, cette entrée standard peut prendre différente formes. Sur un ordinateur, les caractères sont généralement lus à partir d'un clavier. Ils peuvent cependant provenir de différents «canaux» : fichiers, redirections de flux ou opérations de séquencement entre les programmes de la couche (pipes ou tubes). Sur un système embarqué les caractères peuvent provenir des même canaux. Sans système d'exploitation, la liste des canaux est limitée aux interfaces disponibles. Dans les exemples présentés dans ce document, c'est la liaison série qui sert le plus souvent de flux d'entrée standard. Par principe, la fonction getchar transmet au programme appelant le caractère suivant de la file d'entrée à chaque appel. Sortie standard Fonction putchar Flux stdout Par analogie avec le cas de l'entrée standard, le mécanisme le plus simple consiste à émettre un caractère vers la sortie standard. Suivant le contexte cette sortie standard peut aussi prendre différentes formes. Sur un ordinateur, les caractères sont émis par défaut vers le terminal (ie. la fenêtre du courant). Comme pour toute manipulation au niveau , les opérations de séquencement, de redirection et les tubes sont utilisables. Voir les exemples d'exécution ci-après. Ces mécanismes d'entrées-sorties standard ont été définis avec les systèmes d'exploitation UNIX au début des années 70. On les retrouve aujourd'hui sur la totalité des systèmes d'exploitation contemporains. Les files d'attentes des caractères issus de l'écran, du clavier, des fichiers stockés sur tous types de supports, etc. sont appelés flux d'entrées-sorties (input-output streams). Des flux standards ont été définis ; chacun étant dédié à un «pseudo-périphérique». stdin : flux d'entrée ; généralement le clavier, stdout : flux de sortie ; généralement l'écran, stderr : flux d'erreurs vers lequel sont redirigés tous les messages d'erreurs lors de l'exécution d'un programme, stdprn : flux d'impression ; généralement le port parallèle, stdaux : flux auxiliaire ; généralement le port série. Flux d'entrées-sorties standard et système d'exploitation Flux d'entrées-sorties standard et système d'exploitation Voici un exemple simple de programme utilisant les flux d'entrées-sorties standard via les fonctions getchar et putchar. Ce programme recopie les caractères reçus sur le flux d'entrée stdin vers le flux de sortie stdout. Cette copie se poursuit tant que le caractère saisi est différent du code ASCII de délimitation de fin de fichier EOF (code obtenu en appuyant simultanément sur les touches Ctrl + D). 01: #include <stdio.h> 02: 03: int main() { 04: 05: char c; 06: 07: while ((c = getchar()) != EOF) 08: putchar(c); 09: 10: return 0; 11: } L'exemple d'exécution du programme ci-dessous montre que l'opération de transfert d'un flux vers l'autre est séquencée par le caractère de saut de ligne \n. Le flux d'entrée se «remplit» tant qu'aucun appui sur la touche Entrée n'intervient. Dès que le code ASCII du saut de ligne entre dans le flux d'entrée standard, son contenu est transféré au programme utilisateur via l'appel à la fonction getchar. Les appels à la fonction putchar suivent le même fonctionnement vis-à-vis du flux de sortie standard. Voici un exemple d'exécution du programme  : $ ./gcc_stdio.out test test 123 123 Voici deux autres exemples d'exécution du même programme en utilisant les opérations de séquencement entre les programmes offertes par le . On commence par créer un fichier test.txt à l'aide de la commande cat. Tous les caractères saisis au clavier sont redirigés vers le fichier. L'opération s'arrête avec la saisie du code ASCII EOF (Ctrl + D). Le programme est exécuté avec une nouvelle redirection : ./stdio <test.txt. Avec cette redirection, le contenu du fichier test.txt se substitue au flux d'entrée standard stdin. Le programme est à nouveau exécuté en utilisant un tube (pipe). En fait, deux programmes sont exécutés : cat test.txt et stdio. Le premier à pour but d'afficher le contenu du fichier texte sur le flux de sortie standard stdout (ie. la console). Le fonctionnement du second programme a déjà été décrit ci-dessus. L'utilisation du tube permet de transférer la sortie du premier programme vers l'entrée du second. phil@b0x:~/src$ cat >test.txt Fichier texte exemple phil@b0x:~/src$ ./stdio <test.txt Fichier texte exemple phil@b0x:~/src$ cat test.txt | ./stdio Fichier texte exemple Pour plus de détails sur les manipulations à la console, voir . Flux d'entrées-sorties standard sans système d'exploitation Flux d'entrées-sorties standard sans système d'exploitation Voici maintenant le même exemple simple de programme utilisant les flux d'entrées-sorties standard sur un système spécialisé. Dans ce contexte sans système d'exploitation, on ne dispose pas de définition des flux stdin et stdout entre le noyau et le . On continue cependant à utiliser les fonctions getchar et putchar. La technique usuelle sur les systèmes spécialisés consiste à donner une nouvelle définition de ces deux fonctions en désignant explicitement le canal de réception et d'émission des caractères. Dans l'exemple, c'est la liaison série entre le PC de développement et le système spécialisé qui sert à faire transiter les caractères dans les deux sens. 01: #include <stdio.h> 02: #include <msc1210.h> 03: #include "ser_msc1210.h" 04: 05: #define EOF 0x04 06: #define CR 0x0d 07: 08: char getchar(void) { 09: return ser_getc(); 10: } 11: 12: void putchar(char c) { 13: ser_putc(c); 14: } 15: 16: void main(void) { 17: 18: char c; 19: 20: // Press <Enter> for auto baudrate adjust 21: autobaud(); 22: EA=1; 23: 24: while ((c = getchar()) != EOF) { 25: if (c == CR) 26: putcr(); 27: putchar(c); 28: } 29: putcr(); 30: putchar('!'); 31: putcr(); 32: 33: while (1); 34: } Comme on l'a déjà indiqué, il n'existe pas de couche Shell dans ce contexte. On ne dispose donc pas d'opération de séquencement entre programmes puisque cet exemple est le seul programme exécuté par le microcontrôleur. Voici un exemple d'exécution du programme  : MSC1210 Ver:000305F10 >M0000 ok >M8000 ok >E >T > >azerty 123 !  : ce programme ne fait pas directement appel aux fonctions getchar et putchar. Il utilise plutôt les fonctions d'entrées-sorties formatées décrites ci-après.  : lignes 11 à 13. La liaison série étant utilisée comme canal d'entrée-sortie standard, on définit la fonction putchar en conséquence. Cette définition est ensuite réutilisée pour les sorties formatées lors des appels à la fonction printf : lignes 27, 31, 34, 42 et 45. Pour la saisie du nombre de calcul, la fonction ser_gets_echo est définie dans le fichier d'en-tête . Les flux d'entrées-sorties standards sont limités aux manipulations sur des caractères codés en ASCII. Cette limitation est très contraignante lorsque l'on cherche à formater l'affichage de valeurs numériques. C'est pour dépasser ces contraintes que l'on a introduit deux fonctions dédiées à la «traduction» entre valeurs numériques et chaînes de caractères. La fonction printf sert à formater les sorties sur le flux stdout et la fonction scanf sert à formater les entrées reçues sur le flux stdin. Les prototypes génériques de ces deux fonctions se présentent sous la forme : scanf(control, arg1, arg2, ...) printf(control, arg1, arg2, ...) control est une chaîne de caractère qui sert à mettre en forme les arguments. Cette chaîne peut contenir des caractères «ordinaires» qui sont recopiés directement depuis ou vers le flux d'entrée-sortie standard et des formats de conversion positionnés dans la chaîne à l'aide du caractère balise % suivi du format choisi. Les arguments arg1, arg2, ..., doivent correspondre à chaque caractère % placé dans la chaîne control. Le caractère % est une balise de positionnement suivie d'une spécification de traduction dont le prototype est : %[indicateur][largeur][.precision][modification]type. Tous les champs notés entre crochets sont optionnels. Spécifications du champ obligatoire type : type signification %c caractère %s chaîne de caractères %d nombre entier en décimal %e nombre réel sous la forme mantisse/exposant [-]m.nnnnnne[+|-]xx %E nombre réel sous la forme mantisse/exposant en majuscule [-]m.nnnnnnE[+|-]xx %f nombre réel sous la forme [-]mmm.nnnnnn %g nombre réel sous la forme la plus courte entre les types %e et %f %G nombre réel sous la forme la plus courte entre les types %E et %f %o nombre entier en octal %p pointeur ou adresse de la valeur numérique %u nombre entier non signé en décimal %x nombre entier en hexadécimal %X nombre entier en hexadécimal ; lettres affichées en majuscules Spécifications du champ optionnel [indicateur] : [indicateur] signification - alignement à gauche pour la largeur donnée + affichage forcé du signe de la valeur numérique espace insertion d'un caractère d'espacement si la valeur numérique est positive # affichage précédé de 0, 0x ou 0X avec les types respectifs o, x ou X force l'affichage du point décimal avec les types e, E et f même si la partie décimale ne contient que des zéros force l'affichage du point décimal avec les types g et G sans supprimer les zéros inutiles Spécifications du champ optionnel [largeur] : [largeur] signification nombre nombre minimum de caractères à afficher ; ajout de caractères d'espacement si la valeur est plus «courte» que l'affichage demandé 0nombre idem ci-dessus ; ajout de caractères 0 si la valeur est plus «courte» que l'affichage demandé *nombre la largeur n'est pas spécifiée dans la chaîne control mais par un entier précédent l'argument à afficher Spécifications du champ optionnel [precision] : [precision] signification .nombre pour les types d, i, o, u, x et X : nombre minimum de chiffres décimaux à afficher ; ajout de caractères d'espacement si la valeur est plus «courte» que l'affichage demandé pour les types e, E et f : nombre de chiffres à afficher après le point décimal pour les types g et G : nombre maximum de chiffres significatifs à afficher pour le type s : nombre maximum de caractères à afficher pour le type c : pas d'effet Spécifications du champ optionnel [modification] : [modification] signification h argument traité comme un entier court (short) l argument traité comme un entier long pour les types entiers (long) ou comme un réel double pour les types réels (double) L argument traité comme un réel long double Voici deux programmes d'illustration de sorties formatées avec la fonction printf. Le premier bénéficie du jeu de définitions complet sur GNU/Linux. Le second, exécuté sur un microcontrôleur MSC1210 et compilé avec SDCC, ne dispose que d'un jeu de définitions de formats plus restreint. 01: /* $Id: gcc_printf.c 1129 2007-05-07 15:07:52Z latu $ */ 02: 03: #include <stdio.h> 04: 05: #define M_PI 3.14159265358979323846 /* pi */ 06: 07: #define YEAR 2007 08: 09: int main() { 10: 11: printf ("Caracteres : %c %c %c %c\n", 'a', 65, 0x30, '0'); 12: printf ("Entiers : %d %ld\n", YEAR, 650000); 13: printf ("Affichage avec espaces : |%10d|\n", YEAR); 14: printf ("Affichage avec zeros : |%010d|\n", YEAR); 15: printf ("Differentes bases : %d %x %o %#x %#o \n", 100, 100, 100, 100, 100); 16: printf ("Reels : |%4.2f| |%+.4e| |%E|\n", M_PI, M_PI*YEAR, M_PI); 17: printf ("Largeur en argument : |%*d|\n", 5, 10); 18: printf ("%s\n", "Debian GNU/Linux"); 19: return 0; 20: } Voici un exemple d'exécution du programme  : $ ./gcc_printf.out Caracteres : a A 0 0 Entiers : 2007 650000 Affichage avec espaces : | 2007| Affichage avec zeros : |0000002007| Differentes bases : 100 64 144 0x64 0144 Reels : |3.14| |+6.3052e+03| |3.141593E+00| Largeur en argument : | 10| Debian GNU/Linux Par défaut, le support des nombres réels est désactivé dans la chaîne de développement SDCC. Il est nécessaire de passer par une recompilation manuelle des outils de compilation pour obtenir le résultat ci-dessous. Voir . 01: #define YEAR 2007 02: 03: void putchar(char c) { 04: ser_putc(c); 05: } 06: 07: int main() { 08: 09: autobaud(); 10: EA = 1; 11: 12: printf ("Caracteres : %c %c %c %c\n\r", 'a', 65, 0x30, '0'); 13: printf ("Entiers : %d %ld\n\r", YEAR, 650000); 14: printf ("Affichage avec espaces : |%10d|\n\r", YEAR); 15: printf ("Affichage avec zeros : |%010d|\n\r", YEAR); 16: printf ("Differentes bases : %d %x %o %#x %#o \n\r", 100, 100, 100, 100, 100); 17: printf ("Reels : |%f| |%+.4f| |%e|\n\r", M_PI, M_PI*YEAR, M_PI); 18: printf ("Largeur en argument : |%*d|\n\r", 5, 10); 19: printf ("%s\n\r", "Debian GNU/Linux"); 20: return 0; 21: } Voici un exemple d'exécution du programme  : MSC1210 Ver:000305F10 >M0000 ok >M8000 ok >E >T > >Caracteres : a A 0 0 Entiers : 2007 650000 Affichage avec espaces : | 2007| Affichage avec zeros : |0000002007| Differentes bases : 100 64 144 #x #o Reels : |3.141593| |+6305.1762| |E| Largeur en argument : |*d| Debian GNU/Linux La copie d'écran ci-dessus montre que toutes les options de formatage des sorties ne sont pas supportées par la bibliothèque standard implantée dans la chaîne de développement SDCC. C'est une situation classique, sachant qu'un système spécialisé n'est pas fait pour réaliser une interface utilisateur. Séquence d'échappement signification %% affichage du caractère '%' \0 caractère null ; valeur 0, délimiteur de fin de chaîne de caractères \a alerte ; beep système \b backspace ; déplacement du curseur d'un caractère en arrière \f form feed ; saut de page \n new line ; saut de ligne \r carriage return ; retour chariot \t tabulation horizontale \v tabulation verticale \\ affichage du caractère '\' \' affichage du caractère ''' \" affichage du caractère '"' \Onn affichage de la valeur nn en octal \Xnn affichage de la valeur nn en hexadécimal L'utilisation d'un afficheur à cristaux liquides ou LCD est assez courante sur les systèmes embarqués. C'est un écran de faible dimension employé pour informer l'utilisateur sur l'état du système ou pour afficher les mesures effectuées par différents capteurs. Il existe un standard très populaire qui permet de gérer les communications avec la grande majorité des modèles d'afficheurs LCD quelque soit le fabricant. Ce standard est connu sous le le nom HD44780U. Ce nom correspond au contrôleur qui reçoit les données du microcontrôleur et qui les communique directement avec l'afficheur à cristaux liquides. La standard HD44780U utilise 3 signaux de contrôle ainsi que 4 ou 8 lignes d'entrée-sortie pour le bus de données. L'utilisateur peut choisir si l'afficheur à cristaux liquides doit fonctionner avec un bus de données de 4 bits ou un bus de données de 8 bits. Si un bus de données de 4 bits est utilisé l'afficheur LCD utilise un total de 7 lignes (3 signaux de contrôle plus les 4 lignes pour le bus de données). Si un bus de données de 8 bits est utilisé l'afficheur LCD utilise un total de 11 lignes (3 signaux de contrôle plus les 8 lignes pour le bus de données). Les trois signaux de contrôle sont appelés : EN, RS et RW. EN enable Le signal enable est utilisé pour indiquer à l'afficheur à cristaux liquides qu'on va lui envoyer des données. Pour envoyer des données à l'afficheur, le programme doit s'assurer que le signal est au niveau bas (0) avant de faire évoluer les deux autres signaux de contrôle et de placer des données sur le bus de données. Quand l'ensemble des autres lignes sont correctement positionnées, le signal EN doit être placé au niveau haut (1) et il faut attendre un temps minimum requis par le composant (ce temps varie d'un afficheur à l'autre) avant de le placer au niveau bas (0) à nouveau. RS register select Le signal register select est utilisé pour distinguer les instructions de commande des données à afficher. Si on place RS au niveau bas (0), les données sont traitées comme une commande ou instruction spéciale (effacer l'écran, positionner le curseur de position, etc.). Si on place RS au niveau haut (1), les données envoyées sont des caractères que l'écran doit afficher. RW read/write Le signal read/write est utilisé pour distinguer si les informations sur le bus de données sont lues ou écrites. Si on place le signal RW au niveau haut (1), le programme interroge l'afficheur à cristaux liquides sur son état (Get LCD status). Dans tous les autres cas des commandes sont écrites. Ainsi, le signal RW sera presque toujours au niveau bas. Le premier exemple reprend le programme «Hello, World!» en utilisant l'afficheur LCD comme écran. 01: #include <stdio.h> 02: #include <msc1210.h> 03: #include "ser_msc1210.h" 04: #include "lcd_msc1210.h" 05: 06: void putchar(char c) { 07: if (print2lcd) 08: lcd_putc(c); 09: else 10: ser_putc(c); 11: } 12: 13: void main(void) { 14: 15: // Appuyer sur <Entrée> pour ajuster 16: // automatiquement le (débit|baudrate) 17: autobaud(); 18: 19: // Initialisations pour SDCC 20: EA=1; 21: 22: print2lcd = 0; 23: 24: // initialisation de l'afficheur LCD 25: lcd_init(); 26: 27: // effacement de l'écran 28: lcd_clear(); 29: 30: // positionnement du curseur dans 31: // le coin supérieur gauche 32: lcd_home(); 33: 34: print2lcd = 1; 35: printf("Hello, World !"); 36: 37: // Affichage du même message 38: // sur la console 39: print2lcd = 0; 40: printf("Hello, World!"); 41: putcr(); 42: 43: while(1); 44: } Voici le résultat de l'exécution du programme  : Programme «Hello, World!» sur afficheur LCD Programme «Hello, World!» sur afficheur LCD Le second exemple illustre le positionnement du curseur d'affichage sur l'écran à cristaux liquides. Le modèle d'écran à cristaux liquides utilisé dans les exemples suivants dispose de 4 lignes de 20 caractères. Chaque caractère alphanumérique est accessible via une adresse définie dans le plan ci-dessous. On remarque que les adresses de chaque ligne ne sont pas consécutives ; ce qui n'est pas des plus pratique pour gérer le positionnement du curseur d'affichage. ligne 0 : 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 ligne 1 : 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 ligne 2 : 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 ligne 3 : 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 01: #include <stdio.h> 02: #include <stdlib.h> 03: #include <msc1210.h> 04: