Вы находитесь на странице: 1из 110

Le langage C pour l'embarqu

pk

LE LANGAGE C POUR LEMBARQUE


Patrice KADIONIK
http://www.enseirb.fr/~kadionik
Daprs le cours originel de M. Touravane, Matre de Confrence lESIL
1 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

PLAN
1. Objectifs .................................................................................................................... 9
2. Introduction ............................................................................................................ 10
2.1.

Historique.................................................................................................................................................................................................................................................. 10

2.2.

C K&R....................................................................................................................................................................................................................................................... 11

2.3.

C ANSI ...................................................................................................................................................................................................................................................... 13

2.4.

C++ ............................................................................................................................................................................................................................................................ 14

2.5.

Le langage C par rapport aux autres langages de programmation..................................................................................................................................................... 15

2.6.

Avantages du langage C........................................................................................................................................................................................................................... 16

2.7.

Inconvnients du langage C..................................................................................................................................................................................................................... 18

3. Les principes de base de la compilation................................................................. 21


3.1.

Quelques gnralits ................................................................................................................................................................................................................................ 21

3.2.

Programme C : Hello world .................................................................................................................................................................................................................... 23

3.3.

Compilation et dition de liens ................................................................................................................................................................................................................ 25

4. Remarques gnrales.............................................................................................. 29
4.1.

Les fichiers include................................................................................................................................................................................................................................... 29

4.2.

Les commentaires ..................................................................................................................................................................................................................................... 30

2 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

5. Elments de base..................................................................................................... 32
5.1.

Les types de donnes lmentaires.......................................................................................................................................................................................................... 32

5.2.

Les entiers ................................................................................................................................................................................................................................................. 38


Le type char........................................................................................................................................................................................................................................... 39
Les types short, long ou int .................................................................................................................................................................................................................. 41
Le type rel ............................................................................................................................................................................................................................................ 41

5.3.

Les constantes littrales ........................................................................................................................................................................................................................... 43


Les constantes de type caractre ......................................................................................................................................................................................................... 43
Les chanes de caractres ..................................................................................................................................................................................................................... 45
Les boolens........................................................................................................................................................................................................................................... 46

5.4.

Les variables ............................................................................................................................................................................................................................................. 47

6. Oprateurs et expressions....................................................................................... 51
6.1.

Gnralits sur les oprateurs ................................................................................................................................................................................................................. 51


Oprateurs et priorits ......................................................................................................................................................................................................................... 52
L'oprateur d'affectation ..................................................................................................................................................................................................................... 54
Les oprateurs arithmtiques .............................................................................................................................................................................................................. 56
Les oprateurs de comparaison ........................................................................................................................................................................................................... 59
Les oprateurs logiques........................................................................................................................................................................................................................ 61
Les oprateurs de manipulation de bits.............................................................................................................................................................................................. 62
Les autres oprateurs binaires d'affectation ...................................................................................................................................................................................... 67
Les autres oprateurs unaires d'affectation ....................................................................................................................................................................................... 68
Autres oprateurs ................................................................................................................................................................................................................................. 69

6.2.

Conversion de types ................................................................................................................................................................................................................................. 75


Les conversions implicites .................................................................................................................................................................................................................... 76
Les conversions explicites..................................................................................................................................................................................................................... 78

6.3.

Rcapitulatif.............................................................................................................................................................................................................................................. 79

3 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

7. Structures de contrle de programme.................................................................... 83


7.1.

L'instruction if .......................................................................................................................................................................................................................................... 83

7.2.

Les instructions while, do et for .............................................................................................................................................................................................................. 88

7.3.

L instruction goto.................................................................................................................................................................................................................................... 90

8. Structures de programmes et fonctions ................................................................. 92


8.1.

Introduction .............................................................................................................................................................................................................................................. 93
Dclaration de fonction ........................................................................................................................................................................................................................ 97
Arguments formels ............................................................................................................................................................................................................................... 97
Arguments effectifs............................................................................................................................................................................................................................... 97
Type de la fonction................................................................................................................................................................................................................................ 98

8.2.

Appels de fonction et gestion de la pile................................................................................................................................................................................................... 98


Passage par valeur ................................................................................................................................................................................................................................ 99
Passage par adresse ............................................................................................................................................................................................................................ 101

8.3.

Divers....................................................................................................................................................................................................................................................... 105
Fonction sans argument et/ou qui ne retourne rien......................................................................................................................................................................... 105
Fonction rcursive .............................................................................................................................................................................................................................. 106

9. Visibilit des donnes............................................................................................ 107


9.1.

Variables globales et locales .................................................................................................................................................................................................................. 107

9.2.

Variables globales prives et publiques................................................................................................................................................................................................ 110

9.3.

Fonctions prives et publiques .............................................................................................................................................................................................................. 111

10. Pointeurs ............................................................................................................. 113


10.1.

Introduction ........................................................................................................................................................................................................................................ 113

10.2.

Pointeurs et tableaux .......................................................................................................................................................................................................................... 115

4 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu


10.3.

pk

Le type void ......................................................................................................................................................................................................................................... 116

11. Les entres sorties haut niveau formates ......................................................... 118


11.1.

Les E/S formats. Les E/S bas niveau ............................................................................................................................................................................................... 118

11.2.

Le tampon d'entre sortie des appels d'E/S formats...................................................................................................................................................................... 120

11.3.

Fonctions gnrales sur les flots ........................................................................................................................................................................................................ 123


fopen..................................................................................................................................................................................................................................................... 124
fclose..................................................................................................................................................................................................................................................... 128
fflush .................................................................................................................................................................................................................................................... 129
feof........................................................................................................................................................................................................................................................ 129

11.4.

Les flots standards dE/S.................................................................................................................................................................................................................... 130

11.5.

Lecture et criture en mode caractre .............................................................................................................................................................................................. 131


fputc ..................................................................................................................................................................................................................................................... 131
fgetc ...................................................................................................................................................................................................................................................... 131
Les macros putc et getc ...................................................................................................................................................................................................................... 132
getchar ................................................................................................................................................................................................................................................. 132
putchar................................................................................................................................................................................................................................................. 133

11.6.

Lecture et criture en mode chane de caractres............................................................................................................................................................................ 133


fgets ...................................................................................................................................................................................................................................................... 133
fputs...................................................................................................................................................................................................................................................... 134
gets........................................................................................................................................................................................................................................................ 135
puts....................................................................................................................................................................................................................................................... 135

11.7.

Lecture et criture formate .............................................................................................................................................................................................................. 136


Ecriture formate avec printf ............................................................................................................................................................................................................ 137
Ecriture formate avec scanf ............................................................................................................................................................................................................. 140

12. Les entres sorties bas niveau ............................................................................ 141


open et create....................................................................................................................................................................................................................................... 142
read et write ........................................................................................................................................................................................................................................ 144

5 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

ioctl....................................................................................................................................................................................................................................................... 147
close ...................................................................................................................................................................................................................................................... 149

13. Comparaison entre les E/S bas niveau et haut niveau ...................................... 150
13.1.

Cas de Linux........................................................................................................................................................................................................................................ 150

13.2.

Comparaisons par lexemple ............................................................................................................................................................................................................. 153

14. Programmation C avance ................................................................................. 162


14.1.

Arguments passs un programme .................................................................................................................................................................................................. 162

14.2.

Options de compilation....................................................................................................................................................................................................................... 164

15. Les bibliothques standards................................................................................ 168


15.1.

Entres sorties <stdio.h>............................................................................................................................................................................................................... 169


Oprations sur les fichiers.................................................................................................................................................................................................................. 169
Accs aux fichiers................................................................................................................................................................................................................................ 170
E/S formates et bufferises ............................................................................................................................................................................................................... 171
E/S mode caractre ............................................................................................................................................................................................................................. 172
E/S mode binaire................................................................................................................................................................................................................................. 173
Position dans un fichier ...................................................................................................................................................................................................................... 173
Gestion des erreurs ............................................................................................................................................................................................................................. 174

15.2.

Mathmatiques <math.h> ............................................................................................................................................................................................................... 175


Fonctions trigonomtriques et hyperboliques .................................................................................................................................................................................. 176
Fonctions exponentielles et logarithmiques...................................................................................................................................................................................... 177
Fonctions diverses............................................................................................................................................................................................................................... 178

15.3.

Manipulation de chanes de caractres <string.h> .................................................................................................................................................................... 179

15.4.

Manipulation de caractres <ctype.h>.............................................................................................................................................................................................. 180

15.5.

Utilitaires divers <stdlib.h>......................................................................................................................................................................................................... 182

6 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Conversion de nombres...................................................................................................................................................................................................................... 182


Gnration de nombres pseudo alatoires........................................................................................................................................................................................ 183
gestion de la mmoire ......................................................................................................................................................................................................................... 183
Communication avec l'environnement ............................................................................................................................................................................................. 184
Arithmtique sur les entiers............................................................................................................................................................................................................... 184

16. Exemples de programmes C pour lembarqu................................................... 185


16.1.

Exemple 1 : programmation mmoire EPROM .............................................................................................................................................................................. 185

16.2.

Exemple 2 : pilotage dun module par la liaison srie..................................................................................................................................................................... 188

16.3.

Exemple 3 : bibliothque de contrle dune carte VME ................................................................................................................................................................. 192

16.4.

Exemple 4 : pilotage de la liaison srie dun microcontrleur........................................................................................................................................................ 196

16.5.

Exemple 5 : pilotage dun priphrique dE/S. Structure C........................................................................................................................................................... 208

17. Quelques piges classiques................................................................................. 211


17.1.

Erreurs sur l'affectation..................................................................................................................................................................................................................... 211

17.2.

Erreurs avec les macros ..................................................................................................................................................................................................................... 211


Un #define n'est pas une dclaration ............................................................................................................................................................................................ 211
Un #define n'est pas une initialisation .......................................................................................................................................................................................... 212

17.3.

Erreurs avec l'instruction if............................................................................................................................................................................................................. 213

17.4.

Erreurs avec les commentaires.......................................................................................................................................................................................................... 213

17.5.

Erreurs avec les priorits des oprateurs ......................................................................................................................................................................................... 214

17.6.

Erreurs avec l'instruction switch ................................................................................................................................................................................................... 215


Oubli du break .................................................................................................................................................................................................................................. 215
Erreurs sur le default..................................................................................................................................................................................................................... 216

17.7.

Erreurs sur les tableaux multidimensionnels................................................................................................................................................................................... 217

7 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

18. Bibliographie....................................................................................................... 218


19. Webographie ....................................................................................................... 218

8 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Ce cours a t rdig partir du cours originel de M. Touravane, Matre de Confrence lESIL


(http://www.esil.univ-mrs.fr/~tourai/), revu et complt pour introduire les points importants du langage C
pour lembarqu.

1. OBJECTIFS
1. Balayer et revoir les aspects importants et essentiels du langage C que doit
matriser tout ingnieur lectronicien afin de concevoir le logiciel de base d'un
systme numrique (systme embarqu). Les bases du langage C ont t vues en
premire anne
2. Connatre les points forts et les points faibles du langage C. Eviter les piges
classiques.
3. Matriser les appels dE/S de base et formats en langage C. Intrt pour les
systmes embarqus.
4. Comprendre comment on dveloppe une application embarque en langage C
travers des exemples.
9 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

2. INTRODUCTION
2.1.

Historique

Aucun langage de programmation n'a pu se vanter d'une croissance en popularit


comparable celle de C.
Le langage C n'est pas un nouveau n dans le monde informatique :
- 1972 : dveloppement par ATT Bell Laboratories.
But :
- Dvelopper une version portable d'un systme d'exploitation ouvert qui ne plante pas
(UNIX) (Kernighan et Ritchie) sur PDP7 afin de mettre en commun les imprimantes
des secrtaires du laboratoire.

10 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Le langage C par rapport d'autres langages pour comparaison :


- C++
: 1988, 1990
- Fortran : 1954, 1978 (Fortran 77), 1990, 1995 (Fortran 1995)
- Cobol
: 1964, 1970
- Pascal : 1970
- Lisp
: 1956, 1984 (CommonLisp)
2.2.

C K&R

1978 : Kernighan et Ritchie publient la dfinition classique du langage C (connue sous


le nom de standard K&R-C ) dans un livre intitul The C Programming Language.
Anecdote :
Remarquer le style dindentation dun source en langage C : K&R vs C-ANSI :

11 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

for(i=0 ; i<100 ; i++) {

}
K&R
for(i=0 ; i<100 ; i++)
{

}
C-ANSI

12 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

2.3.

pk

C ANSI

Ncessit la dfinition d'un standard actualis et plus prcis.


1983 : lAmerican National Standards Institute (ANSI) charge une commission de
mettre au point une dfinition explicite et indpendante machine pour le langage C
(standardisation des appels d'E/S. Il n'y a pas de mots cls rservs read, readln
write, writeln comme avec le langage Pascal) : naissance du standard C-ANSI
(ANSI-C). Dans le cas d'un systme embarqu programm en C, il faut mme se poser
la question de l'existence du "printf()" ! Voir plus loin
1988 : seconde dition du livre The C Programming Language respectant le standard C-ANSI. C'est la bible du programmeur en C (Le langage C. K&R. Editions Masson).

13 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

2.4.

pk

C++

1983 : cration du langage C++ par un groupe de dveloppeurs de AT&T sous la


direction de Bjarne Stroustrup.
But :
- Dvelopper un langage qui garde les avantages de ANSI-C mais orient objet.
Depuis 1990, il existe une bauche pour un standard ANSI-C++.
Remarque :
- C++ est un sur-ensemble du C si bien que 80 % des gens qui dclarent dvelopper en
C++ dveloppent en fait en C !

14 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

2.5.

pk

Le langage C par rapport aux autres langages de programmation


Langage Orient Objet
(LOO)

Java
C++
C Pascal Fortran

Langage proche de la
machine

Assembleurs
(autant de langages ASM
que de processeurs)

Les langages prcdents sont orients informatique scientifique et technique.


Il existe des langages ddis : SQL, COBOL, ADA, Scheme, HTML, Perl
15 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

2.6.

pk

Avantages du langage C

C est un langage :
(1) universel :
C n'est pas orient vers un domaine d'applications spciales comme SQL par
exemple
(2) compact :
C est bas sur un noyau de fonctions et d'oprateurs limits qui permet la formulation
d'expressions simples mais efficaces.
(3) moderne :
C est un langage structur, dclaratif et rcursif. Il offre des structures de contrle et de
dclaration comme le langage Pascal.
16 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

(4) prs de la machine :


C offre des oprateurs qui sont trs proches de ceux du langage machine
(manipulations de bits, pointeurs). C'est un atout essentiel pour la programmation
des systmes embarqus.
(5) rapide :
C permet de dvelopper des programmes concis et rapides.
(6) indpendant de la machine :
C est un langage prs de la machine (microprocesseur) mais il peut tre utilis sur
n'importe quel systme ayant un compilateur C.
Au dbut C tait surtout le langage des systmes UNIX mais on le retrouve comme
langage de dveloppement aujourd'hui de tous les systmes d'exploitation.

17 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

(7) portable :
En respectant le standard ANSI-C, il est possible d'utiliser (thoriquement ) le mme
programme sur tout autre systme (autre hardware, autre systme d'exploitation),
simplement en le recompilant. Il convient nanmoins de faire attention dans le cas d'un
systme embarqu qui n'inclut pas toujours un systme d'exploitation
(8) extensible :
C peut tre tendu et enrichi par l'utilisation de bibliothque de fonctions achetes ou
rcupres (logiciels libres).
2.7.

Inconvnients du langage C

(1) efficacit et comprhensibilit :


C autorise d'utiliser des expressions compactes et efficaces. Les programmes sources
doivent rester comprhensibles pour nous-mmes et pour les autres.
18 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
Les deux lignes suivantes impriment les N premiers lments d'un tableau A[] en
insrant un espace entre les lments et en commenant une nouvelle ligne aprs
chaque dixime chiffre :
for (i=0; i<n; i++)
printf("%6d%c", a[i], (i%10==9)?'\n':' ');

Cette notation est trs pratique mais plutt intimidante pour un dbutant. L'autre
variante est plus lisible :
for (I=0; I<N; I=I+1){
printf("%6d", A[I]);
if ((I%10) == 9)
printf("\n");
else
printf(" ");
}
19 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La programmation efficace en langage C ncessite beaucoup d'exprience.


Sans commentaires ou explications, les fichiers sources C peuvent devenir
incomprhensibles et donc inutilisables (maintenance ?).
(2) portabilit et bibliothques de fonctions :
- La portabilit est l'un des avantages les plus importants de C : en crivant des
programmes qui respectent le standard ANSI-C, nous pouvons les utiliser sur
n'importe quelle machine possdant un compilateur ANSI-C.
- Le nombre de fonctions standards ANSI-C (d'E/S) est limit. La portabilit est
perdue si l'on utilise une fonction spcifique la machine de dveloppement.
(3) discipline de programmation :
- C est un langage prs de la machine donc dangereux bien que C soit un langage de
programmation structur.
20 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

- C est un langage qui n'est pas fortement typ comme par exemple Pascal ou Java (ou
VHDL).
- C ninclut pas de gestion automatique de la mmoire comme Java. La gestion
mmoire en C est la cause de beaucoup de problmes (certains ont peut tre eu
une mauvaise exprience avec les malloc()/free())
- L'instruction goto existe en C.
3. LES PRINCIPES DE BASE DE LA COMPILATION
3.1.

Quelques gnralits

Un langage de programmation a pour finalit de communiquer avec la machine. Il y a


diverses manires de communiquer avec la machine.

21 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Le langage naturel de la machine n'utilise que deux symboles (0 et 1) : c'est le langage


machine. Le langage machine ne comprend et n'excute qu'une suite de 0 et 1
structure sous forme doctets (8 bits).
Le langage assembleur permet l'humain de gnrer cette suite de 0 et 1 partir d'un
fichier source comprhensible qui utilise des instructions assembleur. Le programme
assembleur ou assembleur par abus de langage traduit le source assembleur en code
objet (suite de 0 et 1) excutable par la machine.
Le langage C va oprer la mme chose que prcdemment mais avec plus de lisibilit
encore.
Un programme C est un texte crit avec un diteur de texte respectant une certaine
syntaxe et stock sous forme d'un ou plusieurs fichiers (gnralement avec l'extension
.c).
22 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

A l'oppos du langage assembleur, les instructions du langage C sont obligatoirement


encapsules dans des fonctions et il existe une fonction privilgie appele main()
qui est le point dentre de tout programme C (sous UNIX pour l'instant). Dans le cas
d'un systme embarqu sans systme d'exploitation, la fonction spcifique main()
perd son sens. Le point d'entre du programme sera celui spcifi (en mmoire
ROM) dans la table des vecteurs pour l'initialisation du compteur programme au
RESET
3.2.

Programme C : Hello world

Fichier source C hello.c :


#include <stdio.h>
int main() {
printf("Hello world \n");
return(0) ;
}
23 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Affichage de "Hello world " l'cran.


Pour afficher cette chane, le programme fait appel la fonction printf qui fait
partie des appels dE/S standards dfinis par la norme C-ANSI.
L'ensemble de ces fonctions standards (appel bibliothque C) est stock dans un ou
plusieurs fichiers (ici libc.a).
On utilisera indiffremment fonction la place dappel systme bien que la dernire
expression soit la plus correcte sous UNIX.

24 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

3.3.

pk

Compilation et dition de liens

La traduction du fichier texte ci-dessus en un programme excutable se dcompose en


deux phases :
1. la compilation qui est la traduction d'un programme C en une suite d'instructions
machine. Le rsultat produit est un fichier objet (gnralement avec l'extension .o).
2. l'dition de liens produit partir d'un ou de plusieurs fichiers objets et des
bibliothques un fichier excutable.
Outre la compilation des divers fichiers objets, l'dition des liens inclut le code objet
des fonctions standards utilises par le programme.
Compilation de hello.c (sous UNIX qui est la plateforme traditionnelle de
dveloppement) :
% cc hello.c [-lc]
[-lm pour libm.a]
cration de l'excutable a.out par dfault
25 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

% cc hello.c -o hello
cration de l'excutable hello
% hello
ou
% ./hello
excution du programme depuis le shell
Les compilateurs C font subir deux transformations aux fichiers sources :
1. un prprocesseur ralise des transformations d'ordre purement textuel pour rendre
des services du type inclusion de source, compilation conditionnelle et traitement de
macros.
2. le compilateur C proprement dit prend le texte gnr par le prprocesseur et le
traduit en code objet.
La fonction de prprocesseur est assez souvent implmente par un programme spar
(cpp sous UNIX) qui est automatiquement appel par le compilateur C.
26 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

excutable

27 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Chaque fichier source (ou texte) est appel module et est compos :
des dfinitions de fonctions
des dfinitions de variables
des dclarations de variables et fonctions externes
des directives pour le prprocesseur (lignes commenant par #) de dfinitions de
types ou de constantes (struct, union...).
C'est la base de la programmation modulaire !

28 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

4. REMARQUES GENERALES
4.1.

Les fichiers include

Pour compiler correctement un fichier, le compilateur a besoin d'informations


concernant les dclarations des structures de donnes et de variables externes ainsi que
de l'aspect (on dira prototype ou signature) des fonctions prdfinies.
Un programme de compose donc :
- De structures de donnes.
- Dalgorithmes utilisant ces structures de donnes.
Ces informations sont contenues dans des fichiers header avec l'extension .h. Ces
fichiers doivent tre inclus dans le fichier source que l'on veut compiler.
Pour cela, le langage C offre la directive du prprocesseur :
#include nom_de_fichier
29 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple pour utiliser lappel printf (affichage lcran) :


#include <stdio.h>
stdio.h : contient les dclarations de variables externes et les prototypes de
fonctions de la bibliothque d'E/S formates (standard input output).
4.2.

Les commentaires

Ds lors que l'on crit un programme important, il est indispensable d'y inclure des
commentaires qui ont pour but d'expliquer ce qu'est sens faire le programme rendant
le programme lisible soi mme et autrui . Il est important d'assurer la
maintenance du code ; ce qui est bien programmer !
Un commentaire commence par les caractres /* et se termine par */.
30 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'erreur classique avec les commentaires est d'oublier la squence fermante */.
Dans ce cas, le compilateur va considrer que le commentaire se poursuit jusqu' la fin
du prochain commentaire. Ceci peut ne pas gnrer d'erreur syntaxique .
Exemple :
instruction
/* premier commentaire
instruction
...
instruction
/* second commentaire */
instruction
31 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On voit que dans ce cas, tout un ensemble d'instructions sera ignor par le compilateur
sans gnrer le moindre message d'erreur.
5. ELEMENTS DE BASE
5.1.

Les types de donnes lmentaires

Un programme C manipule deux types de donnes de base :


- les nombres entiers.
- les nombres flottants.
Un autre type de donne lmentaire est le pointeur (adresse dune variable).
Toute autre structure de donne sera drive partir de ces types fondamentaux.
Par exemple, les caractres, les boolens, les constantes ... ne sont rien d'autres que des
nombres.
32 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Notation binaire, dcimale, hexadcimale, octal


Rappelons qu'un nombre n en notation dcimale est reprsent en base b par le nombre
ai ai-1 ... a1 a0
o :
n = am * bm + am-1 * bm-1 + ... + a1 * b1 + a0 b0 avec 0 <= ai < b.
Voici une liste des bases habituellement utilises en (micro)informatique :

Notation
Base
2 binaire
8 octale
10 dcimale
16 hexadcimale

Symboles
0, 1
0, 1, ... 7
0, 1, ... 9
0, 1, ... 9, a, b, c, d, e, f
33 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
Le nombre 70 (en notation dcimale) est reprsent par 1000110 en notation binaire,
0106 en notation octale, 0x46 en notation hexadcimale.
Reprsentation des nombres signs (positifs et ngatifs)
On appelle bit de signe, le bit le plus lev (bit de poids fort ou MSB Most Significant
Bit) d'un nombre entier.
Si l'on considre un nombre cod sur un octet, lorsque le bit de signe vaut 0, il s'agit
d'un nombre positif. Inversement lorsque ce bit vaut 1, il s'agit d'un nombre ngatif.

34 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple sur 8 bits :


01111111: +127
10000000: -128
11111111 : -1
00000000: 0 (+0, -0)
Ce format de reprsentation dun entier est appel complmentation 2 qui permet
davoir une seul unit arithmtique et logique (ALU) pour manipuler des nombres
entiers positifs ou ngatifs, une soustraction se ramenant une addition et assure
lunicit de reprsentation du nombre 0.
Entiers non signs :
Dans un octet, il est possible de ranger 28 valeurs diffrentes. Si l'on dcide que cet
octet est susceptible de contenir des entiers positifs et ngatifs (le bit de signe est
occup), on codera les valeurs comprises entre -27. et 27-1. Inversement, si l'on dcide
35 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

que cet octet ne contient que des entiers sans signe (positifs ou nuls), on codera les
valeurs comprises entre 0 et 28-1.
Cest nous de savoir priori si lon travaille sur un nombre entier sign ou non
sign (structure de donnes) et non le processeur.
La diffrence entre ces 2 types apparat au niveau des tests dingalit :

char c;

/* nombre sign */

c = 129;
if(c >= 128) {
Je fais qq chose;
}

/* Est-on vraiment sr de rentrer ici ? */

36 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

unsigned char c;
c = 129;
if(c >= 128) {
Je fais autre chose;
}

/* oui */

Le langage C considre par dfaut les variables de base comme signes. Dans les
structures de donnes utilises par un programme, il faut se poser la question du type
sign ou non. Si l'on travaille en valeur absolue (non sign), il est obligatoire
d'ajouter la qualificatif unsigned sous peine d'effets de bord en cours d'excution !

37 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

5.2.

pk

Les entiers

En C, on dispose de divers types d'entiers qui se distinguent par la place qu'ils occupent
en mmoire :
sur 1 octet, les entiers signs et non signs (char) et (unsigned char).
sur 2 octets, les entiers signs et non signs (short) et (unsigned short).
sur 4 octets (en gnral), les entiers signs et non signs (long) et
(unsigned long).
le type int (unsigned int) est selon les machines synonyme de short
(unsigned short) ou de long (unsigned long).
Il faudra priori s'assurer de la taille de reprsentation du type int sur sa machine en
utilisant par exemple l'instruction sizeof :
printf("int=%d octets\n", sizeof(int));
38 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Le type char
Le type char dsigne un nombre entier sign cod sur 1 octet.
Dcimal

Caractre
NULL
...

...
48
...
57
...
65
...
90
...

...
9
...
A
...
Z
...
39 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

97
...
122
...
127

pk

a
...
z
...
Code ASCII

Toutes les oprations autorises sur les entiers peuvent tre utilises sur les caractres :
on peut ajouter ou soustraire deux caractres, ajouter ou soustraire un entier un
caractre .
Exemple :
Conversion du caractre c dsignant un chiffre en sa valeur numrique v
correspondante :
v = c - '0';
40 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les types short, long ou int


Le type short reprsente un entier sign cod sur 2 octets (de -32768 32767) et le
type unsigned short reprsente un entier non sign cod sur 2 octets (de 0
65535).
Le type long (ou int suivant la machine) reprsente un entier sign cod sur 4 octets
(de -2147843648 2147843647) et le type unsigned long (ou unsigned int)
reprsente un entier non sign cod sur 4 octets (de 0 4294967295).
Le type rel
Les nombres virgule flottante (abusivement appels rels) servent coder de manire
approche les nombres rels. Un nombre virgule flottante est compose d'un signe,
d'une mantisse et d'un exposant.
On dispose de trois types de nombres virgule flottante :
41 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

float
double
long double
Les floats :
Un float est cod sur 4 octets avec 1 bit de signe, 23 bits de mantisse et 8 bits
d'exposant (valeurs comprises entre -3.4 * 10-38 et +3.4 * 1038 ).
Les doubles :
Un double est cod sur 8 octets avec 1 bit de signe, 52 bits de mantisse et 11 bits
d'exposant (valeurs comprises entre -1.7 * 10-308 et +1.7 * 10308 ).
Les long doubles :
Un long double est cod sur 10 octets avec 1 bit de signe, 64 bits de mantisse et 15
bits d'exposant (valeurs comprises entre -3.4 * 10-4932 et +3.4 * 104932 ).
42 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Remarques :
La reprsentation d'un nombre rel est normalis : norme IEEE754/854.
Les nombres virgule flottante sont des valeurs approches. En particulier, les
oprations sur ces nombres peuvent conduire des erreurs d'arrondis.
On ne peut pas travailler en langage C sur des nombres rels virgule fixe.
5.3.

Les constantes littrales

Les constantes de type caractre


Les constantes de type caractre se note entre apostrophes ' :
'a' '2' '"'

43 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Le caractre ' se note '\'' et le caractre \ se note '\\'. On peut galement


reprsenter des caractres non imprimables l'aide de squences d'chappement :
Squence
\n
\t
\v
\b
\r
\f
\a
\'
\"
\\

nouvelle ligne
tabulation horizontale
tabulation verticale
retour d'un caractre en arrire
retour chariot
saut de page
beep
apostrophe
guillemet
anti-slash
Squences d'chappement
44 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les chanes de caractres


Les chanes de caractres se note entre guillemets :
"coucou"
"C'est bientot fini !!!"
Une chane de caractres est une suite de caractres (ventuellement vide) entre
guillemets. Il en dcoule que l'on est autoris utiliser les squences d'chappement
dans les chanes.
En mmoire, une chane de caractres est une suite de caractres conscutifs et dont le
dernier lment est le caractre nul '\0'.

45 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Une chane de caractre doit tre crite sur une seule ligne. Lorsqu'il est trop long pour
tenir une mme ligne, on dcoupe celle-ci en plusieurs bouts. Chaque bout tant crite
sur une seule ligne et on masque le retour la ligne par le caractre \.
Les boolens
Contrairement d'autres langages (comme Pascal), il n'y a pas de type boolen en C.
Le type boolen est reprsent par un entier. Il se comporte comme la valeur boolenne
vraie si cette valeur entire est non nulle.
Dans un contexte qui exige une valeur boolenne (comme les tests, par exemple), un
entier non nul quivaut vrai et la valeur nulle quivaut faux.
De mme, une fonction qui retourne une valeur boolenne pourra retourner une valeur
non nulle comme quivalent vrai et la valeur 0 comme quivalent faux.
46 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

5.4.

pk

Les variables

Une variable possde :


Un nom (un identificateur) compos d'une suite de caractres commenant par un
caractre alphabtique et suivi de caractres alphanumriques ou du caractre _.
Exemple :
x, x1, x_1, Var, VarLocal, var_local
Contrairement aux constantes, le contenu d'une variable peut tre modifie volont ;
ce qui ne change pas c'est l'adresse de la variable.

47 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Dfinition et dclaration de variables :


En C, toute variable utilise dans un programme doit auparavant tre dfinie.
La dfinition d'une variable consiste la nommer et lui donner un type et
ventuellement lui donner une valeur initiale (on dira initialiser). C'est cette dfinition
qui rserve (on dira alloue) la place mmoire ncessaire en fonction du type.
Initialiser une variable consiste remplir, avec une constante, la zone mmoire
rserve cette variable. Cette opration s'effectue avec l'oprateur =
Il ne faut pas confondre l'initialisation et affectation. Malheureusement, ces deux
oprations utilisent le mme symbole =.

48 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
int x = 2;
char c = 'c';
float f = 1.3;
Lorsque le programme que l'on ralise est dcompos en plusieurs modules, une mme
variable, utilise dans plusieurs modules, doit tre dclare dans chacun de ces
modules. Par contre, on ne dfinira cette variable que dans un seul de ces modules.
C'est au moment de l'dition des liens que l'on mettra en correspondance les variables
apparaissant dans plusieurs modules (variable partage, mot cl extern).
49 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
int x, y = 0, z;
extern float a, b;
unsigned short cpt = 1000;
Porte des variables :
La position de la dclaration ou de la dfinition d'une variable dtermine sa porte i.e.
sa dure de vie et sa visibilit.
Les variables globales sont dclares en dehors de toute fonction.
Les variables locales sont dclares l'intrieur des fonctions et ne sont pas
visibles l'extrieur de la fonction dans laquelle celle-ci est dfinie.
50 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

6. OPERATEURS ET EXPRESSIONS
6.1.

Gnralits sur les oprateurs

Une expression est un objet syntaxique obtenu en assemblant des constantes, des
variables et des oprateurs.
Exemple :
x+3
Dans le langage C, il y a bien d'autres oprateurs que les oprateurs arithmtiques
qu'on a l'habitude de manipuler. Il y en a en fait plus de 40 oprateurs.

51 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Oprateurs et priorits
Nous avons l'habitude de manipuler des expressions arithmtiques :
2+3*4*5-2 2-3-4
On sait que ces expressions sont quivalentes (2+(3*(4*5)))-2, (2-3)-4.
Introduire les parenthses permet de dfinir sans ambigut l'expression que l'on
manipule.
Pour viter l'usage des parenthses qui alourdissent la lecture, il existe des rgles pour
lever toute ambigut :
Exemple :
2+3*4
la sous expression 3*4 est value en premier et le rsultat obtenu est ajout la valeur
2 (forme avec parenthse : 2 + ( 3 * 4)).
52 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On dit que l'oprateur * possde une priorit suprieure la priorit de l'oprateur +.


2-3-4
la sous expression 2-3 est value en premier et au rsultat obtenu, on soustrait la
valeur 4 (forme avec parenthse : (2 - 3) - 4).
On dit que l'ordre (d'valuation) de l'oprateur - est de gauche droite.
La donne d'une priorit et d'un ordre d'valuation permet de fixer des rgles
communes d'valuation des expressions.
Ces priorits et ordre d'valuation ne permettent videmment pas de se dispenser
compltement des parenthses :
(2+3)*4 comparer 2+3*4

53 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Caractristiques de l'oprateur () :
Oprateur
Nom
Notation Priorit Ordre
()
parenthses (...)
15
gauche-droite
Systme de classification des oprateurs C

L'oprateur d'affectation
L'opration la plus importante dans un langage de programmation est celle qui consiste
donner une valeur une variable.
Cette opration est dsigne par le symbole =.
54 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Comme l'affectation range une valeur dans une variable (une zone mmoire), il
est impratif que le membre gauche d'une affectation reprsente une zone
mmoire (left value).
Une constante n'est pas une left value car il ne dsigne pas l'adresse d'une zone
mmoire. Elle ne peut donc pas figurer en membre gauche d'une affectation.
Le membre droit d'une affectation peut dsigner soit une constante soit une zone
mmoire soit une expression.
Oprateur
=

Nom
Notation
Affectation x = y

Priorit Ordre
2
droite-gauche

55 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les oprateurs arithmtiques


Oprateur Nom
+
Addition
soustraction
*
multiplication
/
division
%
modulo

Notation
x+y
x-y
x*y
x/y
x%y

Priorit
12
12
13
13
13

Ordre
gauche-droite
gauche-droite
gauche-droite
gauche-droite
gauche-droite

Les oprateurs +, -, * fonctionnent comme en arithmtique.


Par contre, l'oprateur / (division) se comporte de manire diffrente selon que les
oprandes sont des entiers ou des nombres flottants :
nombres flottants : le rsultat est un nombre flottant obtenu en divisant les deux
nombres.
56 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

nombres entiers : le rsultat est un nombre entier obtenu en calculant la division


entire ou division euclidienne. L'oprateur % n'est dfini que pour les entiers et le
rsultat est le reste de la division entire des oprandes.
Rappel sur la division entire : On appelle quotient et reste de la division entire de
a et de b , les nombres entiers q et r vrifiant :
a = q * b + r; 0 < r < b
Exemple :
Si a =20 et b =3 alors q =6 et r =2 (20 = 6 * 3 + 2).
Il faut aussi faire attention et savoir si lon fait une division euclidienne ou relle.

57 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Exemple :
int a, b, c ;
float x, y, z;
a = b / c;
a = x / y;
x = y / z;
x = 2 / 3;
x = 2.0/3.0;
x = (float) ((float) a)/y ;

division entire
reste entir
division relle
division entire
division relle
division relle

L'oprateur unaire - a une priorit suprieure aux oprateurs binaires arithmtiques :


Oprateur
- (unaire)

Nom
Notation Priorit Ordre
ngation - x
14
droite-gauche
58 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Les oprateurs de comparaison


Oprateur
==
!=
<=
>=
<
>

Nom
Notation
x == y
test d'galit
test de non galit x != y
test infrieur ou x <= y
gal
test suprieur ou x >= y
gal
test infrieur strict x < y
test suprieur strict x > y

Priorit Ordre
9
gauche-droite
9
gauche-droite
10

gauche-droite

10

gauche-droite

10
10

gauche-droite
gauche-droite

Thoriquement, le rsultat d'une comparaison est une valeur boolenne (vrai ou faux).
En C, le rsultat d'une comparaison est 1 ( != 0) ou 0 selon que cette comparaison est
vraie ou fausse.
59 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Il n'existe pas de type boolen en C :


La valeur entire 0 sera considre comme quivalente la valeur faux et toute valeur
diffrente de 0 quivalente la valeur vrai.
Pige :
Ne pas confondre == (test d'galit) et = (affectation)
Exemple :
if (x == 2) {
if (x = 2)
vs
...
{ ...
La premire teste l'galit de la valeur contenue dans la variable x et la valeur 2 , alors
que la deuxime teste la valeur de l'affectation x=2 qui vaut 2 quelle que soit la valeur
de x (dans cet exemple).
60 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les oprateurs logiques


Une variable boolenne est une variable pouvant prendre la valeur vrai ou faux.
La valeur d'une expression boolenne est, comme le rsultat des comparaisons, une
valeur entire.
Oprateur
&&
||
! (unaire)

Nom
ET
OU
NON

Notation
x && y
x || y
! x

Priorit
5
4
14

Ordre
gauche-droite
gauche-droite
droite-gauche

61 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les oprateurs de manipulation de bits


Oprateur
&
|
^
~ (unaire)
<<

Nom
Notation
x & y
ET bit bit
x | y
OU bit bit
OU exclusif bit x ^ y
bit
~ x
NON bit bit
dcalage droite x
dcalage
<< x
gauche

62 / 219
pk-mt/enseirb/2005

Priorit
8
6

Ordre
gauche-droite
gauche-droite

gauche-droite

14
11

droite-gauche
droite-gauche

11

droite-gauche

Le langage C pour l'embarqu

pk

Les manipulations de bits sont beaucoup utilises dans lembarqu. Pour contrler un
priphrique matriel, on retrouve des registres gnralement de 8 bits appels aussi
ports. Cela permet gnralement dchanger des donnes avec le monde extrieur
(liaison srie, port parallle) :
- Des registres de donne : Data Register. Exemple PADR (module PIT). Ce registre
contient la donne reue ou mettre.
- Des registres dtat : Status Register. Exemple PASR. Ce registre donne ltat
courant du priphrique.
- Des registres de contrle : Control Register. Exemple PACR. Ce registre permet de
contrler le priphrique.
Chaque bit dun registre SR et CR correspond une fonctionnalit ou tat du
priphrique.
63 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
Validation dune fonctionnalit. Mise 1 du bit 7 du registre CR pour autoriser les
interruptions par le priphrique :
unsigned char *PACR = (unsigned char *) 0xF500001 ;
*PACR

= *PACR | 0x80;

soit aussi *PACR |= 0x80;

Inhibition dune fonctionnalit. Mise 0 du bit 7 du registre CR pour interdire les


interruptions par le priphrique :
unsigned char *PACR = (unsigned char *) 0xF500001 ;
*PACR

= *PACR & 0x7f;

soit aussi *PACR &= 0x7f;


64 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On notera que la somme des 2 constantes de masquage donne 0xff !


Il faut aussi noter les diffrents types daccs un registre :
- Type 1 : registre accessible en lecture/criture (registre R/W) et lon peut lire
exactement la dernire valeur crite.
- Type 2 : registre accessible en lecture/criture (registre R/W) et lon ne relit pas la
dernire valeur crite. En cas de manipulation de bits sur ce registre, il est obligatoire
de connatre la dernire valeur crite !
- Type 3 : registre accessible en lecture seulement (registre Ronly).
- Type 4 : registre accessible en criture seulement (registre Wonly). En cas de
manipulation de bits sur ce registre, il est obligatoire de connatre la dernire valeur
crite !
Exemple type 1 :
Validation dune fonctionnalit. Mise 1 du bit 7 du registre R/W :
65 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

unsigned char *PACR = (unsigned char *) 0xF500001 ;


*PACR |= 0x80;
Exemple type 2 :
Validation dune fonctionnalit. Mise 1 du bit 7 du registre R/W :
unsigned char *PACR = (unsigned char *) 0xF500001 ;
unsigned char tmp = 0x0c;
// Initialisation du registre
*PACR = tmp;

tmp |= 0x80;
*PACR = tmp;
66 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Les autres oprateurs binaires d'affectation


Les oprateurs suivants ne sont que des raccourcis de notation (pas doptimisation du
code gnr) :
Oprateur quivalent
Notation
Priorit Ordre
+=
x = x + y x += y
2
droite-gauche
-=
x = x - y x -= y
2
droite-gauche
*=
x = x * y x *= y
2
droite-gauche
/=
x = x / y x /= y
2
droite-gauche
%=
x = x % y x %= y
2
droite-gauche
=
x = x y
x = y
2
droite-gauche
<<=
x = x << y x <<= y 2
droite-gauche
&=
x = x & y x &= y
2
droite-gauche
|=
x = x | y x |= y
2
droite-gauche
^=
x = x ^ y x ^= y
2
droite-gauche
67 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les autres oprateurs unaires d'affectation


++
--

x = x + 1
x = x - 1

x++ ou ++x 14
x-- ou --x 14

droite-gauche
droite-gauche

y = x++; est le raccourci pour y = x; x = x + 1;


y = ++x ; est le raccourci pour x = x + 1; y = x;

68 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Autres oprateurs
L'oprateur conditionnel
Oprateur ternaire (le seul dans C) :
?:

oprateur conditionnel e ? x : y

3 droite-gauche

Cette expression est une sorte de si alors sinon sous forme d'expression : si la condition
e est vraie alors cette expression vaut x sinon elle vaut y .
Exemple :
a = (v == 2) ? 1 : 2;
affecte la variable a la valeur 1 si v vaut 2, sinon affecte la variable a la valeur 2.

69 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'oprateur squentiel
,

oprateur
squentiel

e1, e2

droite-gauche

Cet oprateur permet de regrouper plusieurs expressions en une seule : l'valuation de


l'expression e1, e2 consiste en l'valuation successives (dans l'ordre) des expressions
e1 puis de e2.
L'oprateur de dimension
Cet oprateur donne l'occupation mmoire (en octets) d'une variable ou d'un type de
donn.
sizeof oprateur de dimension sizeof(e) 14
droite-gauche
70 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
La valeur de l'expression sizeof(c) est 1 si c est une variable de type char.
L'expression sizeof(char) donne galement la valeur 1.
L'oprateur d'adressage
L'oprateur d'adressage & donne l'adresse d'une variable ou d'une expression.
&

oprateur d'adressage &x

14

droite-gauche

71 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'oprateur de conversion de type (cast)


Cet oprateur permet de convertir explicitement le type d'une donne en un autre type.
Il est noter que le compilateur C ralise des conversions implicites.
(type) oprateur de conversion (long int)c 14 droite-gauche
Exemple :
char i ;
int j ;
j = (int) i ;

72 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'oprateur de parenthse
L'oprateur de parenthse () permet de dfinir l'ordre d'valuation d'une expression.
C'est galement ce mme oprateur qui est utilis pour encapsuler les paramtres des
fonctions.
Mme lorsqu'une fonction n'a pas d'arguments, ces parenthses sont
obligatoires :
() parenthse () 15
gauche-droite

73 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'oprateur de slection
Ces oprateurs
aprs).
.
->
[]

. et - servent slectionner des champs de donnes structures (cf.


oprateur de slection
oprateur de slection
oprateur de slection

x.info
x->info
x[3]

74 / 219
pk-mt/enseirb/2005

15
15
15

gauche-droite
gauche-droite
gauche-droite

Le langage C pour l'embarqu

6.2.

pk

Conversion de types

Le problme de la conversion des types se pose lorsqu'une expression est compose de


donnes de nature diffrentes. Par exemple, quel sens donner une addition d'un entier
et d'un nombre flottant ?
Le langage de C dfinit prcisment quels sont les types de donnes compatibles et
quel type de conversion est effectue.

75 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les conversions implicites


Les conversion implicites sont celles faites automatiquement par le compilateur C lors
de l'valuation d'une expression (et donc galement d'une affectation).
Cas de l'valuation d'une expression :
Lorsqu'il est ncessaire de procder des conversions, le compilateur C effectue tout
d'abord les conversions puis value l'expression. Les rgles de conversion suivantes
s'appliquent un ordre de conversion :
Si l'un des oprandes est de type long double, conversion de l'autre expression
en long double; le rsultat est un long double.
Si l'un des oprandes est de type double, conversion de l'autre expression en
double; le rsultat est un double.

76 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Cas de l'affectation :
Lors d'une affectation, le type de l'expression membre droit est converti (si ncessaire)
en le type de l'expression en membre gauche. Par exemple, les char sont convertis en
int.
Cas o lon affecte une expression plus ``longue'' une expression plus ``courte'' ?
int i;
char j;
j = i;
La valeur affecte la variable j sera tronque des bits de poids faible.
La conversion d'un float en un int tronque la partie fractionnaire.
Dans tous les cas, il vaut mieux avoir une conversion explicite sinon se rfrer la
documentation du compilateur C !
77 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les conversions explicites


Le programmeur peut effectuer des conversions grce l'oprateur de conversion de
type (cast).
Exemple :
L'expression (int) 1.225 convertit le rel de type double en un entier. il en
dcoule videmment une perte de prcision.
La conversion de (int) 1.225 donne comme rsultat la valeur entire 1.

78 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

6.3.

pk

Rcapitulatif
Oprateur
[]
()
.
&
sizeof
(type)
! (unaire)
~ (unaire)
++
-*

Nom
Elment de tableau
Parenthse
Slection
Slection
Adressage
Dimension
Conversion
NON
NON bit bit
Incrment
Dcrment
Multiplication

Priorit
15
15
15
15
15
14
14
14
14
14
14
13

Ordre
gauche-droite
gauche-droite
gauche-droite
gauche-droite
gauche-droite
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
gauche-droite

79 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

/
%
+
<<
<=
=
<
>
==
!=
&

Division
13
Modulo
13
Addition
12
Soustraction
12
Dcalage droite 11
Dcalage gauche 11
Test d'infrieur ou
10
gal
Test suprieur ou
10
gal
Test infrieur strict 10
Test suprieur strict 10
Test d'galit
9
Test de non-galit 9
ET bit bit
8
80 / 219
pk-mt/enseirb/2005

gauche-droite
gauche-droite
gauche-droite
gauche-droite
droite-gauche
droite-gauche
gauche-droite
gauche-droite
gauche-droite
gauche-droite
gauche-droite
gauche-droite
gauche-droite

pk

Le langage C pour l'embarqu

^
|
&&
||
?:
=
+=
-=
. *=
/=
%=
=
<<=
&=

OU exclusif bit bit 7


OU bit bit
6
ET
5
OU
4
Oprateur
3
conditionnel
Affectation
2
Affectation
2
Affectation
2
Affectation
2
Affectation
2
Affectation
2
Affectation
2
Affectation
2
Affectation
2

pk

gauche-droite
gauche-droite
gauche-droite
gauche-droite
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche
droite-gauche

81 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

|=
^=
,

Affectation
Affectation
Squentiel

2
2
1

82 / 219
pk-mt/enseirb/2005

droite-gauche
droite-gauche
droite-gauche

pk

Le langage C pour l'embarqu

7.

pk

STRUCTURES DE CONTROLE DE PROGRAMME

Un programme C est constitu de :


dfinitions et dclarations de variables
de fonctions. Les fonctions sont construites l'aide d'instructions combines entre
elles avec des structures de contrle.
7.1.

L'instruction if

Cette instruction conditionnelle permet d'excuter des instructions de manire slective


en fonction du rsultat d'un test. La syntaxe de l'instruction est :
if (expression)
instruction1
else
instruction2
83 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Si l'expression est vraie (valeur non nulle), l'instruction1 s'excute sinon, dans le
deuxime cas, c'est l'instruction2 qui s'excute.
Rappelons que si la valeur d'une expression est diffrente de 0, la valeur boolenne de
l'expression est vraie (C nest pas un langage fortement typ). Il en dcoule que les
deux critures suivantes sont quivalentes :
if (expression)
...
et
if (expression != 0)
...
D'aprs la syntaxe de l'instruction if, la partie else est facultative.
84 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Il en dcoule une ambigut lorsqu'il y a des instructions if imbriques.


Dans l'exemple suivant, comme le suggre l'indentation du programme :
if (expression1)
if (expression2)
instruction1
else
instruction2
l'instruction2 correspond au else de l'expression2.

L'criture suivante est strictement identique la premire.


85 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

if (expression1)
if (expression2)
instruction1
else
instruction2
Visiblement, le programmeur veut faire correspondre l'instruction2 au else de
l'expression1. Il suffit de transformer l'instruction imbrique en un bloc d' instruction(s)
de la manire suivante :
if (expression1) {
if (expression2)
instruction1
}
else
instruction2
86 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Voici une construction, que l'on rencontre frquemment :


if (expression1)
instruction1
else if (expression2)
instruction2
else if (expression3)
instruction3
else
instruction4
Cette instruction effectue successivement chacun des tests et aucun des tests n'est vraie,
l'instruction4 sera excute (instruction par dfaut).

87 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

7.2.

pk

Les instructions while, do et for

Les instructions itratives ou boucles sont ralises l'aide d'une des trois structures de
contrle suivantes :
while (expression)
instruction
do
instruction
while (expression);
for (expression1; expression2; expression3)
instruction

88 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Pour lembarqu, on na gnralement pas de systme dexploitation mis en


uvre. On a donc un programme C qui sexcute indfiniment. Cela correspond
une boucle infinie en concurrence ventuellement avec les interruptions du
systme (on parle de superboucle). Il faut donc savoir crire une boucle infinie en
langage C :
for (; ;) {
}
ou
while (1) {
{
89 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

7.3.

pk

L instruction goto

Linstruction goto est gnralement bannie quand on programme en langage C


standard. Mais elle a son intrt dans le cas de lembarqu pour acclrer un
traitement
Une tiquette est un identificateur; elle sera suivie par un deux points (:) et sera place
devant une instruction.
L'instruction
goto tiquette;
transfre le contrle l'instruction prfixe par l'tiquette mentionne.
90 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Une tiquette n'a pas besoin d'tre dclare (contrairement aux variables). De plus, elle
est locale une fonction i.e. qu'il ne peut y avoir un goto vers une tiquette figurant
dans une autre fonction que celle dans laquelle se trouve l'instruction goto.
Dans la quasi totalit des programmes, l'instruction goto n'est pas utile. On la
retrouve nanmoins dans lembarqu dans les routines dinterruption pour
optimiser les temps dexcution

91 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

8. STRUCTURES DE PROGRAMMES ET FONCTIONS


Dans ce qui suit, on ne s'intresse qu'au C ANSI.
Un programme C est constitu d'un ensemble de fonctions toutes accessibles partir du
programme principal main().
main est un mot cl rserv du langage C. Cest le point dentre du programme sous
UNIX (et Windows).
Dans le cas dun systme embarqu, il ny a pas de systme dexploitation sousjacent. main redevient banalis et se comporte comme une simple fonction C. Le
point dentre du programme sera prcis alors dans la phase ddition liens par
initialisation de vecteur dinterruption RESET : adresse du point dentre de la
fonction main ou le point dentre dune autre fonction

92 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

8.1.

pk

Introduction

Une fonction est dfinie par :


son nom
ses arguments formels
le type de la fonction (type de l'argument retourn par la fonction)
son corps

93 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Exemple :
unsigned long pgcd(unsigned long x, unsigned long y) {
unsigned long r;
if (x < y) { r = x; x = y; y = x; }
do {
r = x % y;
x = y;
94 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

}
}

pk

y = r;
}
while (r != 0)
;
return x;

/* retourne le pgcd calcul */

Voici une utilisation de la fonction pgcd dfinie plus haut :


main() {
unsigned long a, b;
printf("Donnez deux entiers\n");
scanf("%u %u", &a, &b);
printf("Le pgcd de %u et de %u est %u\n", a, b, pgcd(a, b));
printf("Le pgcd de 5 et de %u est %u\n", b, pgcd(5, b));
}

95 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Remarque :
La dclaration dune fonction crite en C-ANSI est :
unsigned long pgcd(unsigned long x, unsigned long y) {

alors quen C K&R, elle est :


unsigned long pgcd(x, y) {
unsigned long x ;
unsigned long y ;

Par dfaut, une fonction retourne un entier int.

96 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Dclaration de fonction
On appelle dclaration d'une fonction son nom, ses arguments formels et le type (type
de la valeur retourne) de la fonction.
Arguments formels
Les variables x et y sont les paramtres ou arguments formels de la fonction pgcd. Ce
sont bien des arguments formels en ce sens que cette fonction s'applique quelles que
soient les valeurs de x et y. Ces valeurs ne seront en fait connues que lors de l'appel de
cette fonction.
Arguments effectifs
Les variables a, b ainsi que la constante 5 sont les paramtres ou arguments effectifs
de la fonction pgcd pour cet appel.
97 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Type de la fonction
Cette fonction retourne une valeur de type unsigned long qui correspond au pgcd
calcul par cette fonction.
La variable r est une variable locale la fonction pgcd.
8.2.

Appels de fonction et gestion de la pile

Une pile (tout comme une pile de linge ou feuille de brouillon) est une structure de
donnes ayant les caractristiques suivantes:
on dpose le dernier lment en haut (on dira sommet) de la pile et le premier
lment que l'on utilisera sera le dernier dpos. Une structure de donne qui possde
le comportement que l'on vient de dcrire se nomme liste LIFO ou pile (Last In First
Out).
98 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les arguments formels et les variables locales d'une fonction sont stocks dans une
zone particulire de la mmoire que l'on appelle segment de pile ou pile ou stack (en
anglais). Un registre du processeur pointe sur le haut de cette zone (pointeur de pile).
Passage par valeur
Lors de l'appel d'une fonction C, le systme alloue une portion de la pile ddie au
programme. Cette zone mmoire est utilise pour :
stocker les arguments
les variables locales
l'adresse de retour de la fonction.
A chaque appel de fonction, les arguments effectifs sont recopis l'emplacement
prvu.
99 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

main() {
unsigned long a=10, b=15, c;
c = pgcd(a, b) ;
...
}
Etat de la pile juste avant l'appel de la fonction pgcd :
10 5 0
a b c
Etat de la pile aprs appel de la fonction pgcd :
Restitution de l'espace des arguments effectifs et des variables locales. Au retour de
cette fonction, les valeurs de a et b sont inchanges.
10 15 5
a b c
100 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Cette manire de passer les arguments (par recopie des valeurs des arguments effectifs)
se nomme passage d'arguments par valeur.
Passage par adresse
Il est parfois utile de conserver les valeurs calcules par les paramtres formels.
Exemple : fonction qui calcule deux rsultats que l'on voudrait rcuprer.
passage par adresse
Pour avoir un passage par adresse, on se contente de passer par valeur l'adresse d'une
variable.
La fonction ne travaille plus sur une copie de la valeur de l'argument effectif mais
directement sur celui-ci.
101 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
Modification de la fonction pgcd de telle sorte que l'appel de la cette fonction modifie
la valeur du premier paramtre effectif.
void pgcd(unsigned long *x, unsigned long y) {
unsigned long r;

if (*x < y) {
r = *x;
*x = y;
y = *x;
}
do {
r = *x % y;
*x = y;
y = r;
} while (r != 0);

102 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Lappel de cette fonction doit se faire de la manire suivante :


main(){
unsigned long a=10, b=15;
pgcd(&a, b);
...
}
Etat de la pile juste avant l'appel de la fonction pgcd :
10 5 0
a b c

103 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Etat de la pile aprs appel de la fonction pgcd :


Restitution de l'espace des arguments effectifs et des variables locales. Au retour de
cette fonction, la valeur de b est inchange ; par contre a contient prsent la valeur
calcule par la fonction.
5 15 5
a b c
A comparer au passage de paramtres par valeurs :
10 15 5
a b c

104 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

8.3.

pk

Divers

Fonction sans argument et/ou qui ne retourne rien


Le mot cl void permet de spcifier que la fonction n'a aucun argument :
int fonction(void) {
...
}
L'appel une fonction sans argument se fait de la manire suivante :
{
...
i = fonction();
...
}

Ne pas oublier les parenthses !!!

105 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

De mme, une fonction qui ne retourne rien (procdure) se note :


void fonction(...)
Fonction rcursive
En C, les fonctions peuvent tre utilises de manire rcursive :
une fonction peut s'appeler elle-mme.
Lorsqu'une fonction s'appelle rcursivement, chaque niveau d'appel possde son propre
jeu de variables locales.
Il est noter que la rcursivit peut entraner des dbordements de piles sil y a
trop dappels imbriqus !
Dans lembarqu, la rcursivit est viter car on peut avoir une pile limite ou pas
du tout (microcontrleur PIC avec une pile 8 niveaux dimbrication).
106 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

9. VISIBILITE DES DONNEES


Nous avons jusqu' prsent associ aux variables un type particulier. Cet attribut n'est
pas le seul que l'on assigne une variable : il y a galement la classification qui est un
autre attribut important. Cette classification dtermine l'emplacement mmoire o la
variable sera stocke (voir le langage Java).
La classification concerne aussi les fonctions.
9.1.

Variables globales et locales

Selon l'emplacement de la dfinition d'une variable, celle-ci est soit :


une variable locale.
une variable globale.

107 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Toute variable dfinie l'extrieur des fonctions est une variable globale.
Toute variable dfinie l'intrieur des fonctions est une variable locale.
Une variable globale est connue donc utilisable dans n'importe quelle partie du fichier
o elle est dfinie en particulier l'intrieur de n'importe quelle fonction du module.
Cette porte peut mme s'tendre d'autres modules du programme, si le programme
est constitu de plusieurs fichiers.
Une variable locale est dfinie l'intrieur d'une fonction et au dbut d'un bloc (c'est le
seul endroit o il est permis de dfinir des variables locales). Une variable locale n'est
connue qu' l'intrieur du bloc dans lequel elle est dfinie.

108 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple :
int g;

g est une variable globale

main() {
int i; i est une variable locale
static int k; i est une variable globale prive
. . .
}

On retiendra que :
Les variables globales sont statiques c'est--dire qu'elles sont permanentes.
Elles existent toute la dure de l'excution du programme. Au dmarrage du
programme, le systme alloue l'espace ncessaire et effectue les initialisations.
Tout cet espace sera rendu au systme lors de la terminaison du programme.
les variables locales et les arguments formels des fonctions sont automatiques.
L'espace ncessaire est allou lors de l'activation de la fonction ou du bloc
correspondant. Il est restitu au systme la fin du bloc ou de la fonction.
109 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

9.2.

pk

Variables globales prives et publiques

Dans cette section, on s'intresse aux programmes constitus de plusieurs modules.


Toutes les variables globales sont publiques c'est--dire qu'elles peuvent (moyennant
une dclaration spcifique) tre utilises dans les autres modules (fichiers C).
On peut interdire cette facilit en donnant ces variables le qualificateur static. On
dit alors qu'il s'agit d'une variable globale prive.
Variables externes :
Le qualificateur extern plac devant la dclaration d'une variable ou d'une fonction
informe que celui-ci sera dfini plus loin dans le mme module ou dans un autre
module.
110 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

A chaque variable, il ne peut y avoir qu'une seule dfinition. Par contre, il peut y avoir
plusieurs dclarations dans le mme module ou dans d'autres modules.
9.3.

Fonctions prives et publiques

Comme pour les variables globales, les fonctions peuvent tre prives ou publiques.
Une fonction prive ne peut tre appele que par des fonctions qui figurent dans le
mme module.
Par contre, une fonction publique peut tre appele par n'importe quelle fonction dun
module du programme.
Toutes les fonctions sont publiques c'est--dire qu'elles peuvent (moyennant une
dclaration spcifique, voir plus loin) tre utilises dans les autres modules.
111 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On peut interdire cette facilit en donnant ces fonctions ltat static. On dit alors
qu'il s'agit d'une fonction prive.
Fonctions externes :
Le qualificateur extern plac devant la dclaration d'une fonction informe que celleci sera dfinie plus loin dans le mme module ou dans un autre module.
A chaque fonction, il ne peut y avoir qu'une seule dfinition. Par contre, il peut y avoir
plusieurs dclarations dans le mme module ou dans d'autres modules.

112 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

10. POINTEURS
10.1.

Introduction

Un pointeur est une variable qui contient l'adresse d'une autre variable. L'oprateur
unaire & donne l'adresse mmoire d'un objet.
L'instruction :
p = &c;
affecte l'adresse de c la variable p.
On dit que p pointe sur c. L'oprateur unaire & s'applique uniquement sur des objets
en mmoire.
113 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

En particulier, il ne peut pas s'appliquer sur des constantes ou mme des


variables dclares comme register (registres du processeur).
L'oprateur unaire * reprsente l'oprateur d'indirection ou de drfrence.
Appliqu un pointeur, il donne accs l'objet point par ce pointeur.
int x = 1, y = 2, z[10];
int *pi;
pi pointeur sur un int
pi = &x;
pi pointe sur x
y = *pi;
y est affect la valeur de l'objet point par pi i.e. x
*pi = 0;
x vaut 0
pi = &z[0];
pi pointe sur le premier lment du tableau z

114 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

10.2.

pk

Pointeurs et tableaux

Les pointeurs et les tableaux sont conceptuellement similaires en C.


Soient tab un tableau de int de 10 lments et pint un pointeur vers un int.
L'affectation :
pint = &tab[0]; ou pint = tab;
fait en sorte que tab et pint pointe tous deux sur le mme lment (le premier
lment du tableau).
Si pint pointe sur le ime lment du tableau, alors *(pint + 1) dsigne
respectivement sur le (i +1)me lment du tableau.

115 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La correspondance entre pint et tab est si troite que l'on pourra crire tab[i] ou
*(pint +i).
De mme, &tab[i] ou pint+i sont quivalents.
10.3.

Le type void

Le type void se comporte comme un type fondamental.


Il sert prciser qu'une fonction ne renvoie aucune valeur (procdure).
Il peut tre utilis comme type de base pour des pointeurs sur des objets de type
inconnu (pointeur universel ).
void f();
void * pv;

116 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Cette facilit doit tre utilise pour se servir des fonctions gnriques qui rendent des
pointeurs vers n'importe quel type d'objets (exemple : fonction malloc).
Exemple :
void * malloc(unsigned taille);
void free(void *);
void une_fonction() {
int *pi;
char *pc;
pi = (int *) malloc(10*sizeof(int)); Noter la conversion explicite
pc = (char *) malloc(10*sizeof(char));
...
free(pi);
free(pc);
}

117 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

11. LES ENTREES SORTIES HAUT NIVEAU FORMATEES


11.1.

Les E/S formats. Les E/S bas niveau

Les E/S sont un point crucial dans le langage C. Ntant pas intgrs au langage
comme avec le Pascal (avec writeln et readln), les appels dE/S ont longtemps dpendu
du type de compilateur C ; ce qui a conduit des problmes de portabilit des
programmes C. Larrive de lextension C-ANSI a permis de corriger ce dfaut (du
moins thoriquement).
Un fichier est constitu d'une suite de donnes non structur (stream) et est vu par un
programme C comme un flot/flux i.e. une suite d'octets structurs ou non qui, selon le
cas, constitue soit un fichier texte ou un fichier binaire ou encore les donnes
provenant dun priphrique matriel.
On peut alors comparer un fichier C un tableau d'octets.
118 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Un fichier texte est un fichier structur en suite de lignes et exploitable par divers
programmes (diteur de texte, logiciel d'impression ...)
Un fichier binaire n'a aucune structure et est inexploitable par des programmes
externes qui ignorent la structure relle du fichier.
Il est noter que sous UNIX : Tout est fichier (et tout est processus) .
Un priphrique est repr par un point dentre dans le systme de fichiers (path) si
bien que :
Lire et crire sur un priphrique sous UNIX revient lire et crire dans un
fichier
Il en est aussi de mme pour la programmation socket en mode TCP !

119 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les priphriques sont reprsents traditionnellement par une entre dans le rpertoire
/dev sous UNIX :
Exemple :
Liaison srie : /dev/ttya sous Solaris /dev/ttyS0 sous Linux (port COM1 du
PC).
11.2.

Le tampon d'entre sortie des appels d'E/S formats

Quelle que soit l'opration que l'on veuille effectuer sur un fichier (lecture ou criture)
dun disque dur, les donnes transitent par un buffer de la bibliothque dE/S (libc) et
ensuite par une zone mmoire temporaire appel tampon (buffer cache du noyau sous
UNIX) avant d'tre dfinitivement ranges dans le fichier.
Le programmeur n'a pas se soucier de la gestion de ce tampon : c'est le systme
dexploitation qui en a la responsabilit.
120 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

L'utilisation par lintermdiaire d'un tampon permet d'optimiser le fonctionnement des


E/S et notamment sur disque puisque l'criture ou la lecture dans un tampon de taille
N octets (qui rside en mmoire) est bien plus rapide que la mme opration sur le
fichier directement sous la forme de N lectures/critures dun octet.
On minimise ainsi les mouvements de la tte dcriture dun disque dur
Linconvnient est que lon ne contrle plus le moment de lecture/criture dans le
fichier qui est la charge du systme dexploitation, ce qui est gnant pour laccs
des priphriques matriels comme une liaison srie.

121 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On utilisera alors les appels dE/S bas niveau non bufferiss pour laccs un
priphrique matriel (pas de buffer libc et ventuellement pas de tampon
noyau)
On utilisera alors les appels dE/S de haut niveau formates et bufferiss (buffer
libc et tampon du noyau) pour laccs un fichier sur disque (bien que les appels
dE/S bas niveau non bufferiss (pas de buffer libc et tampon noyau) soient aussi
utilisables)
Le passage par un tampon, s'il acclre les oprations dE/S introduit un problme de
dcalage dans la chronologie, puisque l'opration effective de lecture ou d'criture dans
le fichier n'est pas prdictible par le programmeur.
Il en dcoule qu'une interruption brutale d'un programme (ou du systme) peut
conduire des pertes d'informations dans les fichiers.

122 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

11.3.

pk

Fonctions gnrales sur les flots

Les flots sont dsigns par des variables de type FILE * (pointeur sur une structure
de type FILE).
Le type FILE est dfini dans le fichier d'interface stdio.h.
Pour utiliser un fichier dans un programme C, il faut donc inclure le fichier stdio.h
et dfinir une variable par fichier :
#include <stdio.h>
FILE *fd1, *fd2;
...

123 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

fopen
Avant qu'un programme puisse utiliser un fichier, il faut ouvrir ce fichier. L'ouverture
du fichier initialise tous les champs du descripteur voqu plus haut. C'est la fonction :
FILE *fopen(char *nom, char *mode_d_accs);
qui est utilise pour ouvrir un fichier.
Cette fonction retourne un pointeur vers une structure de type FILE qui sera utilise
pour les oprations dE/S par la suite.
Le paramtre nom est une chane de caractres qui dsigne le nom du fichier.
Le paramtre mode_d_accs est une galement une chane de caractres qui spcifie
le type d'opration que l'on veut effectuer sur ce fichier :

124 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

"r"
"w"

"a"
"r+"
"w+"

"a+"

pk

Ouvrir le fichier en lecture seule


Ouvrir le fichier en criture seule
(Cration du fichier si le fichier n'existe pas)
(Si le fichier existe, son ancien contenu sera perdu)
Ouvrir le fichier en ajout i.e. criture la fin du fichier
(Cration du fichier si le fichier n'existe pas)
Ouvrir le fichier en lecture et criture
Ouvrir le fichier en lecture et criture
(Cration du fichier si le fichier n'existe pas)
(Si le fichier existe, son ancien contenu sera perdu)
Ouvrir le fichier en lecture et en ajout
(Cration du fichier si le fichier n'existe pas)

Lorsqu'il y a une erreur, le programme ne s'arrte pas (pour arrter le programme, il


faut utiliser lappel exit(int cause) ).
125 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La fonction/appel renvoie la valeur NULL (qui vaut 0). C'est au programmeur de tester
cette valeur chaque fois qu'il appelle cette fonction.
Bien programmer, cest toujours tester le code de retour de tous les appels
systme ! ! !
#include <stdio.h>
main() {
FILE *fd;
fd = fopen("toto.c", "r");
if (fd == NULL) {
printf("Erreur d'ouverture du fichier %s", "toto.c");
exit(0);
}
. . .
}

126 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

ou plus concis la sauce UNIX :


#include <stdio.h>
main() {
FILE *fd;
if ((fd = fopen("toto.c", "r")) == NULL) {
printf("Erreur d'ouverture du fichier %s", "toto.c");
exit(0);
}
. . .
}

127 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

fclose
Mme si le systme se charge de fermer tous les fichiers ouverts la fin de l'excution
d'un programme, il est vivement conseill de fermer les fichiers ds qu'ils ne sont plus
utiliss notamment pour rduire le nombre de descripteurs ouverts et se prmunir
contre toute interruption brutale du programme.
C'est la fonction :
int fclose(FILE *flot);
qui est utilise pour fermer un fichier.
Le paramtre flot (stream) est un pointeur vers une structure de type FILE qui est la
valeur retourne par un appel la fonction fopen.
La fonction fclose retourne EOF (End Of File) si la fermeture du fichier s'est mal
passe. Sinon, c'est la valeur 0 qui est retourne.
128 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

fflush
Cette fonction provoque l'criture physique immdiate du tampon la demande du
programmeur et non lorsque le systme le dcide. Elle retourne EOF en cas d'erreur et
0 dans les autres cas.
int fflush( FILE *flot);
feof
La fonction feof teste l'indicateur de fin de fichier du flot spcifi par le paramtre
flot et retourne une valeur non nulle.
int feof(FILE * flot);

129 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

11.4.

pk

Les flots standards dE/S

Par dfaut, lorsqu'un programme dbute, il existe trois flots prdfinis qui sont
ouverts :
stdin
stdout
stderr

Ces flots sont connects sur les organes d'E/S naturels :


stdin : l'unit d'entre standard (le clavier) dont le descripteur bas niveau est 0.
stdout : l'unit de sortie standard (l'cran) dont le descripteur bas niveau est 1.
stderr : l'unit de sortie erreur (l'cran) dont le descripteur bas niveau est 2.

130 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

11.5.

pk

Lecture et criture en mode caractre

fputc
La fonction fputc transfre le caractre car dans le fichier reprsent par le
paramtre flot. La valeur de retour de cette fonction est le caractre car ou EOF en
cas d'erreur :
int fputc(int car, FILE *flot);
fgetc
La fonction fgetc retourne le caractre lu dans le fichier reprsent par le paramtre
flot. En cas d'erreur ou de fin de fichier, elle retourne la valeur EOF.
int fgetc(FILE *flot);
131 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les macros putc et getc


Les macros :
int putc(int car, FILE *flot);
int getc(FILE *flot);
font exactement la mme chose que fputc et fgetc mais leur diffrence vient du
fait qu'elles sont des macros (#define ) donc plus efficaces en temps dexcution.
getchar
getchar() est un synonyme de getc(stdin).
int getchar(void);
132 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

putchar
putchar(c) est un synonyme de putc(c, stdout).
int putchar(int c);
11.6.

Lecture et criture en mode chane de caractres

fgets
La fonction fgets lit une chane de caractres dans un flot et le range dans un tampon
dfini (et allou) par l'utilisateur.
char *fgets(char *s, int taille, FILE *flot);
133 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Plus prcisment, cette fonction lit taille-1 caractres dans le fichier de descripteur
flot ou bien jusqu'au caractre '\n', s'il survient avant les taille-1 caractres.
Le dernier caractre du tampon est '\0'.
La fonction rend le pointeur vers le dbut du tampon ou NULL en cas d'erreur ou de fin
de flot.
fputs
La fonction fputs crit une chane de caractres dans un flot. Cette fonction n'crit
pas le caractre '\0' .
int fputs(const char *s, FILE *flot);
La fonction retourne une valeur non ngative si tout s'est bien pass. La valeur EOF
indique une erreur.
134 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

gets
Comme on peut le voir sur le prototype de la fonction, le flot ainsi que le nombre
maximum de caractres lire ne sont pas spcifis.
char *gets(char *s);
Le flot par dfaut est stdin.
puts
La fonction puts crit sur le flot stdout la chane de caractres s.
int puts(char *s);

135 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La fonction retourne une valeur non ngative si tout s'est bien pass. La valeur EOF
indique une erreur. Contrairement la fonction fputs, la fonction ajoute le caractre
'\n' la fin de l'criture.
11.7.

Lecture et criture formate

Les fonctions fprintf et fscanf permettent d'effectuer des lectures et critures


formates de donnes dans un flot. Les fonctions printf et scanf sont des
raccourcis pour les fonctions fprintf et fscanf lorsque le flot est l'entre standard
ou la sortie standard.
int fprintf(FILE *flot, char *format, arg1, ...,

136 / 219
pk-mt/enseirb/2005

argN);

Le langage C pour l'embarqu

pk

Ecriture formate avec printf


Nous avons dj rencontr ce type d'criture dans les divers exemples prcdents.
Le format gnral de la fonction printf est de la forme :
int printf(const char *format, arg1, ...,

argN);

La fonction printf affiche les arguments donns en fonction du format spcifi et ce


aprs conversion et mise en forme si ncessaire.
Cette fonction retourne le nombre de caractres affichs.
Le format est une chane de caractres qui contient deux types d'objets :
des caractres ordinaires, qui sont affichs sans aucune modification
des spcifications qui dterminent le type de conversion et de mise en forme
effectuer avant l'affichage proprement dit.
137 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Toutes les spcifications commencent par le caractre % et se terminent par un


caractre de conversion. Entre ces deux caractres, on peut placer dans l'ordre:
1. des drapeaux :
+

: impression du signe du nombre

espace : place un espace au dbut


0 : complte (si besoin) le dbut du champ par des zros (pour les arguments
numriques)
2. un nombre qui prcise la largeur minimum du champ d'impression.
3. un point qui spare la largeur du champ et la prcision demande.
4. un nombre qui spcifie la prcision du champ.
5. une lettre qui modifie la largeur du champ (h pour short, l pour long et L pour long
double)
138 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

d, i
u
o
x, X
c
s
f
%

pk

notation dcimale signe


int
notation dcimale non signe
int
notation octale non signe
int
notation hexadcimale non signe sans les
int
caractres 0x ou 0X
caractre aprs conversion en unsigned char int
impression d'une chane de caractres se
char *
terminant pas par le caractre de fin de chane
notation dcimale de la forme [-]mmm.ddd
double
imprime le caractre %

float x = 123.456;
printf("%f ", x);
printf("%.2f ", x);

123.456000
123.46
139 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Ecriture formate avec scanf


Le format gnral de la fonction scanf est de la forme :
int scanf(const char *format, arg1, ...,

argN);

Cette fonction lit dans le flot, en fonction des spcifications du format les donnes pour
les affecter aux arguments fournis.
Cette fonction rend EOF en cas d'erreur ou si la fin de flot est atteint. Sinon, elle
retourne le nombre d'objets lus.
Le format est le mme que celui de printf.

140 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

12. LES ENTREES SORTIES BAS NIVEAU


Jusqu' prsent, les fonctions d'E/S que avons voques (C ANSI) sont de haut niveau
(bufferises et formates)
Elles sont indpendantes des systmes d'exploitation que l'on utilise.
Nous allons nous intresser des fonctions de plus bas niveau et qui peuvent diffrer
d'un systme l'autre.
Ce qui va suivre s'applique pour tous les systmes d'exploitation UNIX.
Au dmarrage d'un programme, trois fichiers standards sont ouverts : stdin, stdout
et stderr dont les descripteurs sont respectivement 0, 1 et 2. On peut donc utiliser
ces fichiers sans avoir les ouvrir comme c'est le cas pour tout autre flot.

141 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

open et create
Les fonctions de bas niveau open et creat permettent d'ouvrir un fichier donc un
priphrique matriel et ventuellement de le crer :
int open(const char *pathname, int flags, mode_t mode);
int creat(const char *pathname, mode_t mode);
Ces fonctions retournent un descripteur de fichier (file descriptor) qui est un entier
(int).
Le paramtre flags a pour valeur O_RDONLY, O_WRONLY ou O_RDWR selon le l'on
veuille utiliser le fichier en lecture seule, en criture seule ou en lecture et criture.

142 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Le paramtre flags peut galement tre un entier vu comme une suite de bits que l'on
positionne avec des ou (|).
Les bits positionner sont :
O_CREAT : Crer le fichier s'il n'existe pas.
O_EXCL : Ouverture du fichier pour un usage exclusif.
O_APPEND
: Ouverture du fichier en mode append .
O_NONBLOCK ou O_NDELAY : Ouverture du fichier en mode non bloquant.
Le paramtre mode dfinit les permissions du fichier (en cas de cration).
Gnralement la valeur de mode est 0.
Pour utiliser ces constantes, il faut inclure le fichier :
#include <stdlib.h>
143 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La fonction creat sert crer un fichier s'il n'existe pas ou rcrire sur d'anciens
fichiers. Les permissions daccs sont donnes en notation octale (Cf permissions
daccs sous UNIX).
read et write
Les E/S de haut niveau sont toutes bties par des appels systmes (fonctions de bas
niveau) read et write. Ces appels bas niveau sont non bufferiss (pas de buffer
libc, on peut ventuellement passer par le tampon du noyau) et le flux doctets est
non format :
int read(int fd, char *buf, int count);
int write(int fd, const char *buf, int count);

La fonction read lit dans le fichier dsign par le descripteur de fichier fd, count
octets et les range dans le tableau de caractres buf.
144 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La fonction write crit dans le fichier dsign par le descripteur de fichier fd,
count octets du tableau de caractres buf.
Ces fonctions renvoient le nombre d'octets effectivement transfrs. On peut donc
demander lire ou crire n octets mais si le nombre d'octets disponibles est infrieur
n.
La valeur 0 est retourne lorsqu'on atteint une fin de fichier et -1 pour toute autre
erreur.

145 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Exemple : Programme qui lit une suite de caractres frapps au clavier et qui les rcrit
la console.
int main() {
char buf[128];
int n;
while (n = read(0, buf, sizeof(buf)))
write(1, buf, n);
return 0;
}

146 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

ioctl
La fonction ioctl permet de changer le comportement par dfaut du priphrique
ouvert ou du fichier ouvert.
La syntaxe est :
#include <unistd.h>
#include <stropts.h>
int ioctl(int fildes, int request, /* arg */ ...);
request est la commande de reconfiguration et arg le ou les paramtres.

147 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Exemple : Etat courant dune liaison srie


#include <stdio.h>
#include <termio.h>
extern int errno;
main(){
struct termio etat1;
int n;
if((n = ioctl(0, TCGETA, &etat1)) == -1)
{ fprintf(stderr, "echec de ioctl => erreur %d\n", errno);
exit(1);
}
printf("ioctl reussi => valeur de retour : %d\n", n);
printf("comportement de la liaison : %d\n", etat1.c_line);
printf("valeurs du caractere special <intr> : %d\n", etat1.c_cc[0]);
}
148 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

close
La fonction close permet de librer le descripteur de fichier et donc de fermer le
priphrique matriel ou le fichier.
La syntaxe est :
int close(int fildes);
close renvoie -1 en cas dchec ou 0 sinon.

149 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

13. COMPARAISON ENTRE LES E/S BAS NIVEAU ET HAUT NIVEAU


13.1.

Cas de Linux

On se placera dans le cas du systme dexploitation Linux : il faut gnralement


vrifier comment est mis en uvre le tampon du noyau

Les appels de la famille read() and Co sont sous Linux comme suit :
- travaillent sur un descripteur de fichier de type int.
- ne sont pas standards C ANSI (_read() sous Visual C).
- sont conformes la norme POSIX.
- sont des wrappers aux appels systmes syscalls.
- sont des E/S non formates : on a un bloc non format de 1 ou plusieurs octets.
- nutilisent pas de buffer standard libc dans lespace user.
150 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

- peuvent utiliser les buffers Linux VFS et/ou le tampon du noyau (espace kernel). Cela
dpend de quoi lon parle : fichiers, liaison srie, FIFO, socket, pty... Le tampon de
lespace kernel peut tre dvalid par fcntl(..., F_SETFL, O_DIRECT) ou
par open() avec le flag O_DIRECT.
- sont utiliss gnralement pour accder des donnes niveau bas : priphrique
matriel ou systme de fichiers en mode raw.
On a donc :
- un buffer utilisateur (paramtre de lappel) que lon peut utiliser.
- des buffers Linux VFS et/ou le tampon du noyau mis en uvre ventuellement.

151 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les appels de la famille fread() and Co sont sont sous Linux comme suit :
- sont un niveau additionnel dabstraction pour les E/S fichier.
- travaillent sur un descripteur de fichier de type FILE * .
- sont standards C ANSI.
- sont des fonctions de la bibliothque dE/S standard libc (glibc).
- utilisent un buffer standard libc dans lespace user. La bufferisation user space peut
tre contrle (setvbuf()) ou dvalide.
- permettent des E/S formates pour certains.
- peuvent utiliser les buffers Linux VFS buffers et/ou le tampon du noyau (espace
kernel). Cela dpend de quoi lon parle : fichiers, liaison srie, FIFO, socket, pty... Le
tampon de lespace kernel peut tre dvalid par (fileno() avec fcntl(...,
F_SETFL, O_DIRECT)).
- sont utiliss gnralement pour accder des flux de donnes de faon indpendante
du priphrique matriel utilis.

152 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On a donc :
- un buffer utilisateur (paramtre de lappel) que lon peut utiliser.
- un buffer standard libc.
- des buffers Linux VFS et/ou le tampon du noyau mis en uvre ventuellement.
13.2.

Comparaisons par lexemple

Les exemples suivantes prsentent la mise en uvre des E/S bas niveau et formates
haut niveau mettant en vidence les bienfaits/mfaits de la bufferisation (adapt de
http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Cat/lecture.html) sous UNIX (Solaris 5.7
machine fakir).

153 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Fichier C simpcat1.c :
#include <stdio.h>
#include <fcntl.h>
#include <stdio.h>
main()
{
char c;

c = getchar();
while(c != EOF) {
putchar(c);
c = getchar();
}
154 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Fichier C simpcat2.c :
main()
{
char c;
int i;
i = read(0, &c, 1);
while(i > 0) {
write(1, &c, 1);
i = read(0, &c, 1);
}
}

155 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Fichier C simpcat3.c :
#include <stdio.h>
main()
{
char c[1];
int i;

i = fread(c, 1, 1, stdin);
while(i > 0) {
fwrite(c, 1, 1, stdout);
i = fread(c, 1, 1, stdin);
}

156 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

On cre un gros fichier lire large de 2 Mo et on mesure le temps dexcution de


lexcutable (-O2) par la commande UNIX time :
% dd if=/dev/zero of=large bs=1M count=2
% time simpcat1 < large > /dev/null
real
0m0.375s
user
0m0.320s
sys
0m0.040s
% time simpcat2 < large > /dev/null
real
0m56.183s
user
0m12.530s
sys
0m40.800s
% time simpcat3 < large > /dev/null
real
0m2.959s
user
0m2.730s
sys
0m0.130s
157 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

- Dans simpcat1.c, getchar() et putchar() sont appels 2M fois pour 1


octet. Ce sont des macros optimises des appels de la bibliothque libc.
- Dans simpcat2.c, read() et write() sont appels 2M fois pour 1 octet. Ils
font appel des appels systmes plus lents (changement de contexte).
- Dans simpcat3.c, fread() et fwrite() sont appels 2M fois pour 1 octet. Ce
sont des fonctions de la bibliothque libc plus rapides.
On peut maintenant jouer sur le paramtre de la taille du buffer utilisateur (paramtre
de lappel) :

158 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Fichier C simpcat4.c :
#include <stdio.h>
main(int argc, char **argv)
{
int bufsize;
char *c;
int i;
bufsize = atoi(argv[1]);
c = malloc(bufsize*sizeof(char));
i = 1;
while (i > 0) {
i = read(0, c, bufsize);
if (i > 0) write(1, c, i);
}
}
159 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Fichier C simpcat5.c :
#include <stdio.h>
main(int argc, char **argv)
{
int bufsize;
char *c;
int i;
bufsize = atoi(argv[1]);
c = (char *)malloc(bufsize*sizeof(char));
i = 1;
while (i > 0) {
i = fread(c, 1, bufsize, stdin);
if (i > 0) fwrite(c, 1, i, stdout);
}
}
160 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

On fait varier ainsi la valeur de bufsize et lon obtient le diagramme similaire :

On limite ainsi le nombre dappels systme ou dappels de fonctions de la bibliothque


libc ds que lon augmente la taille du buffer utilisateur.
161 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

14. PROGRAMMATION C AVANCEE


Nous venons de voir le langage C dont sa principale faiblesse rside dans sa non prise
en compte au niveau du langage du traitement des E/S. Cest dailleurs pour cela
que lon doit faire appel des bibliothques dappels dE/S
Des lments connexes au langage sont parfois ncessaires comme :
Les arguments de la ligne de commande et les variables d'environnement
Signaux
Communications inter processus

14.1.

Arguments passs un programme

Il est possible de passer des arguments un programme lors de son excution par
l'intermdiaire de la ligne de commande qui le lance :
162 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

% mon_exe arg1 arg2 arg3


Ici, 3 arguments sont passs au programme. Ils sont vus comme des chanes de
caractres.
Au niveau du fichier source C (ici mon_exe.c), la dclaration des arguments se fait
comme suit :
main(int argc, char *argv[])
{
if(argc != 4) {
prinft("Erreur d'arguments\n");
exit(0);
}

}
163 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

La variable argc du type int contient le nombre d'arguments plus la commande ellemme (4 sur l'exemple).
La variable argv du type char ** est un tableau de chanes de caractres contenant
les arguments. argv[0] contient la chane de caractres du nom de la commande
elle-mme (ici "mon_exe"), argv[1] contient la chane de caractres "arg1"
Il est noter que si les arguments sont considrs comme des entiers, une conversion
chane de caractres / entier est faire avant leur utilisation. On pourra utiliser l'appel
atoi() par exemple
14.2.

Options de compilation

Dans le contexte de lembarqu, il est important de bien connatre les options de


compilation du compilateur C. Il y a en fait un compromis trouver entre la taille de
164 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

lexcutable produit et son temps dexcution. Un systme embarqu est gnralement


peu performant (par rapport un PC) et a des ressources mmoire limites.
Les options de compilations sont lies au compilateur C utilis. Le compilateur C
prsent ici est le compilateur C du projet GNU (Gnu is Not Unix) gcc.
La compilation standard par gcc est :
% gcc o toto toto.c
Le compilateur gcc possde 4 niveaux doptimisation :
- O0 : niveau par dfaut. Implicite.
- O1 : premier niveau. Optimisation du temps de compilation.
- O2 : deuxime niveau. Compromis temps dexcution et taille du code gnr.
- O3 : troisime niveau. Optimisation du temps dexcution (au dtriment de la taille
du code gnr).
- Os : cas spcial. Optimisation de la taille du code gnr.
165 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

La compilation O2 par gcc est :


% gcc O2 o toto toto.c
Il est possible doptimiser le code produit en fonction du type du processeur utilis
(architecture) en mettant en uvre des instructions assembleur spcifiques.
La compilation par gcc est :
% gcc march=xxx toto toto.c
o xxx vaut (famille x86) :
- i386 : processeur i386 DX/SX/CX/EX/SL
- i486 : processeur i486 DX/SX/DX2/SL/SX2/DX4 ou 487.
- pentium : processeur Pentium.
- pentium2 : processeur Pentium 2.
- pentium4 : processeur Pentium 4.
- c3 : processeur VIA C3.
- k6 : processeur AMD K6
166 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

- athlon : processeur Athlon.


-
Il est possible de prciser quelle unit mathmatique le processeur supporte.
La compilation par gcc est :
% gcc mfpmath=xxx toto toto.c
o xxx vaut (famille x86) :
- 387 : FPU 387. Processeur i386
- sse : FPU Streaming SIMD Extensions. Processeurs Pentium III, Athlon
- sse2 : FPU Streaming SIMD Extensions II. Processeur Pentium IV

167 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

15. LES BIBLIOTHEQUES STANDARDS


Ce paragraphe se propose de prsenter les appels/fonctions de quelques bibliothques
gnralement fournies avec tout bon compilateur C.
A tout moment, pour avoir de laide supplmentaire sous UNIX sur un appel, taper la
commande :
% man mon_appel
Exemple :
% man fopen
% man s 2 read

168 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

15.1.

pk

Entres sorties <stdio.h>

Oprations sur les fichiers


fonction
remove
rename
tmpfile
tmpnam

description
destruction de fichier
modification de nom de fichier
cration d'un fichier temporaire
gnration de nom appropri pour un fichier
temporaire

169 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Accs aux fichiers


fonction
fclose
fflush
fopen
freopen

description
fermeture de fichier
criture sur fichier des buffers en mmoire
ouverture de fichier
ouverture de fichier

170 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

E/S formates et bufferises


fonction
fprintf
fscanf
printf
scanf
sprintf
sscanf
vfprintf
vprintf
vsprintf

description
criture formate sur flot de donnes
lecture formate sur flot de donnes
criture formate sur sortie standard
lecture formate sur entre standard
criture formate dans une chane de
caractres
lecture formate depuis une chane de
caractres
variante de fprintf
variante de printf
variante de sprintf
171 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

E/S mode caractre


fonction
fgetc
fgets
fputc
fputs
getc
getchar
gets
putc
putchar
puts
ungetc

Description
lecture d'un caractre
lecture d'une chane de caractres
criture d'un caractre
criture d'une chane de caractres
fgetc implment par une macro
getc sur l'entre standard
lecture d'une chane de caractres sur l'entre
standard
fputc implment par une macro
putc sur la sortie standard
criture d'une chane de caractres sur la sortie
standard
refoule un caractre (sera lu par la prochain lecture)
172 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

E/S mode binaire


Pour lire et crire des donnes binaires, on dispose de deux fonctions : fread et
fwrite.
Position dans un fichier
fonction
fgetpos
fseek
fsetpos
ftell
rewind

description
donne la position courante dans un fichier
permet de se positionner dans un fichier
permet de se positionner dans un fichier
donne la position courante dans un fichier
permet de se positionner au dbut d'un
fichier
173 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Gestion des erreurs


fonction

description
clearerr remet faux les indicateurs d'erreur et de fin
de fichier
feof
test de l'indicateur de fin de fichier
feror
test de l'indicateur d'erreur
imprime un message d'erreur correspondant
perror
errno

174 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

15.2.

pk

Mathmatiques <math.h>

Sous UNIX, on veillera de dire au compilateur C dinclure la bibliothque


mathmatique libm.a en tapant la commande :
% cc o toto

toto.c -lm

175 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Fonctions trigonomtriques et hyperboliques


fonction
acos
asin
atan
atan2
cos
cosh
sin
sinh
tan
tanh

smantique
arc cosinus
arc sinus
arc tangente
arc tangente
cosinus
cosinus hyperbolique
sinus hyperbolique
sinus
tangente
tangente hyperbolique

176 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Fonctions exponentielles et logarithmiques


fonction
exp
frexp
Ldexp
log
log10
modf

smantique
exponentielle
tant donn x, trouve n et p tels que x = n *
2p
multiplie un nombre par une puissance
entire de 2
logarithme
logarithme dcimal
calcule partie entire et dcimale d'un
nombre

177 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Fonctions diverses
fonction
ceil
fabs
floor
fmod
pow
sqrt

smantique
entier le plus proche par les valeurs
suprieures
valeur absolue
entier le plus proche par les valeurs
infrieures
reste de division
puissance
racine carre

178 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

15.3. Manipulation de chanes de caractres <string.h>


On dispose de fonctions pour :
copier : memcpy, memmove, strcpy, strncpy
concatner : strcat, strncat
comparer : memcmp, strcmp, strcoll, strncmp
transformer : strxfrm
rechercher : memchr, strchr, strcspn, strpbrk, strrchr, strspn,
strstr, strtok
initialiser : memset
calculer une longueur : strlen
obtenir un message d'erreur partir du numro de l'erreur : strerror.
179 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

15.4. Manipulation de caractres <ctype.h>


Toutes les fonctions ci-dessous permettent de tester une proprit du caractre pass
en paramtre :
fonction
le paramtre est :
isalnum
une lettre ou un chiffre
isalpha
une lettre
iscntrl
un caractre de commande
isdigit
un chiffre dcimal
isgraph
un caractre imprimable ou le blanc
islower
une lettre minuscule
isprint
un caractre imprimable (pas le blanc)
ispunct
un caractre imprimable pas isalnum
isspace
un caractre d'espace blanc
isupper
une lettre majuscule
isxdigit
un chiffre hexadcimal
180 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

On dispose galement de deux fonctions de conversions entre majuscules et


minuscules :
tolower : conversion en minuscule
toupper : conversion en majuscule

181 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

15.5.

Utilitaires divers <stdlib.h>

Conversion de nombres
Les fonctions suivantes permettent de convertir des nombres entre la forme binaire et
la forme chanes de caractres.
fonction
description
atof
conversion de chane vers double
atoi
conversion de chane vers int
atol
conversion de chane vers long int
strtod
conversion de chane vers double
strtol
conversion de chane vers long int
conversion de chane vers unsigned
strtoul
long int
182 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Gnration de nombres pseudo alatoires


On dispose de rand et srand.
gestion de la mmoire
La liste exhaustive est calloc, free, malloc et realloc.

183 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

Communication avec l'environnement


fonction
Description
abort
terminaison anormale du programme
installe une fonction qui sera excute sur
atexit
terminaison normale du programme
getenv
obtention d'une variable d'environnement
system
excution d'un programme
Arithmtique sur les entiers
fonction
abs
div
labs

description
valeur absolue
obtention de quotient et reste
idem abs sur des long int
184 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

16. EXEMPLES DE PROGRAMMES C POUR LEMBARQUE


16.1.

Exemple 1 : programmation mmoire EPROM

But :
Cration dun fichier de programmation dune mmoire EPROM 8 bits avec les 32K
chantillons dune priode de sinusode.
Systme :
UNIX Solaris sur Sun (marche sur tout UNIX).
#include <stdio.h>
#include <fcntl.h>
#include <termio.h>
#include <math.h>
extern int errno;
185 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

#define SAMPLE 32768


#define FREQ
1000.0
main()
{
int fd, n, i, total=0;
double w;
char s;
if((fd=creat("sinus.dat", 0600)) == -1) {
perror("Creation fichier");
exit(-1);
}
w = 2.0 * M_PI * FREQ;
printf("w=%f rad/s\n", w);
// close(1);
186 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

// dup(fd);
for(i=0; i<SAMPLE; i++) {
s = (char)(128.0 * (1.0 + cos(2 * M_PI * i / SAMPLE)));
write(fd, &s, 1);
// printf("%c", s);
}
close(fd);
exit(0);
}
Remarques :
Utilisation des E/S bas niveau.
Les appels close(1)et dup(fd)permettent de fermer la sortie standard et de
dupliquer le descripteur de fichier fd qui prend la plus petite valeur positive libre ;
187 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

c'est--dire 1 ici. Lappel printf permet alors dcrire directement dans le fichier
dchantillons.
16.2.

Exemple 2 : pilotage dun module par la liaison srie

But :
Pilotage dun module lectronique reli au port srie dune station Sun.
Systme :
UNIX Solaris sur Sun.

8 leds
/dev/ttya
RS.232
Station Sun pour le dveloppement

80C51

8 interrupteurs

188 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

#include <stdio.h>
#include <fcntl.h>
#include <termio.h>
extern int errno;
main()
{
int fd;
char commande[80]= "readbp\n";
char reponse[80]="";
int n, i, j;
if((fd=open("/dev/ttya", O_RDWR, 0)) == -1) {
perror("Ouverture ttya");
exit(-1);
}
189 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

while(1) {
printf("Commande No %d\n", ++j);
write(fd, commande, sizeof(commande));
bzero(reponse, sizeof(reponse));
n = read(fd, reponse, sizeof(reponse));
printf("\tn2=%d BP=%d\n", n, atoi(reponse));
sleep(1);
}
close(fd);
exit(0);
}
190 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Remarques :
Utilisation des E/S bas niveau.
On lit toutes les 1 secondes ltat courant de boutons poussoirs du module lectronique
reli par la liaison srie. La liaison srie est dj configure par le systme
dexploitation en 9600 b/s, 8 bits, sans parit, 1 stop bit.

191 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

16.3.

Exemple 3 : bibliothque de contrle dune carte VME

But :
Pilotage dune carte VME dans un chssis VME sous UNIX System V.
Systme :
UNIX System V sur carte 68040.
struct cbuf cmic_d_ini(tampon_dem)
struct cbuf tampon_dem;
{
struct cbuf tampon_con;
int semid, id;
int fd;
int i;
int j;
struct params params;
int status;
192 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

if((semid = semget(CMICSEMKEY, CMICNBRSEM, 0)) == -1) {


tampon_con.code = CMIC_C_INI;
tampon_con.par0 = B_NOK;
tampon_con.par1 = E_DBA;
return(tampon_con);
}
/* On prend le semaphore
if((id = Psem(semid)) == -1) {
tampon_con.code = CMIC_C_INI;
tampon_con.par0 = B_NOK;
tampon_con.par1 = E_DBA;
return(tampon_con);
}

*/

193 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

if((fd=open("/dev/cmic",O_RDWR)) == -1) {
Vsem(semid);
tampon_con.code = CMIC_C_INI;
tampon_con.par0 = B_NOK;
tampon_con.par1 = E_DRI;
return(tampon_con);
}
params.vme_address = DUMMYADD;
params.value = DUMMYVAL;
params.indice = DUMMYVAL;
ioctl(fd, CMIC_RESET, &params);
. . .
params.vme_address = (char *)(CMICVMELOW
i*ACFAVMEOFFSET);
params.value = 0xFE;
params.indice = 7 + i*ACFAINDOFFSET;
194 / 219
pk-mt/enseirb/2005

ACFAXC1

Le langage C pour l'embarqu

pk

ioctl(fd, DB_VME_WRITE, &params);


. . .
Vsem(semid);
close(fd);
tampon_con.code = CMIC_C_INI;
tampon_con.par0 = B_OK;
tampon_con.par1 = B_OK;
return(tampon_con);
}
Remarques :
La carte VME est repre sous UNIX par le fichier /dev/cmic.
Utilisation des E/S bas niveau.
On utilise lappel ioctl() pour la configuration et le contrle de la carte VME.
195 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

On a cr une bibliothque de fonctions pour le pilotage de la carte VME en ayant une


approche de conception modulaire.
16.4.

Exemple 4 : pilotage de la liaison srie dun microcontrleur

But :
Pilotage de la liaison srie du microcontrleur 68HC11. Programme dcho.
Systme :
Aucun. Boucle infinie.
Le programme principal :
#include "libhc11.h"
unsigned char c;
char *text = "Programme ping pong \r\n";
void main (void) {
196 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

int i = 0;
baudrate(9600);
while(*(text+i) != '\n') {
write_com (*(text+i));
i++;
}
write_com ('\n');
while(1) {
if (read_com (&c)) {
if(c == '\r') {
write_com ('\r');
write_com ('\n');
}
else
write_com(c);
/* echo */
}
}
}
197 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Remarques :
Le programme ralise lcho de tout ce qui est reu depuis la liaison srie.
Le programme est bti autour dune boucle infinie.
Le port srie du microcontrleur est configur laide de la fonction baudrate()
fourni par la bibliothque libhc11. Lapproche modulaire a t choisie.
On utilise les fonctions spcifiques read_com() et write_com() pour lire le
caractre reu ou mettre un caractre.
Il semblerait que lon ne connaisse pas les printf() et scanf(). Cest une
particularit du langage C pour lembarqu. Ces fonctions sont en fait fournies avec le
compilateur C crois (quivalent de la libc UNIX) et il convient dcrire les
fonctions de base getch() et putch() qui collent au matriel
La fonction main() apparat comme une simple fonction banale. Il faudra
gnralement renseigner le vecteur reset du microcontrleur par ladresse de son point
dentre.

198 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Bibliothque libhc11. Extrait :


void baudrate(unsigned int bps_rate) {
SCCR1 = 0x00;
parite */
SCCR2 = 0x0C;
BAUD=0x30;
if (bps_rate
BAUD
if (bps_rate
BAUD
if (bps_rate
BAUD
if (bps_rate
BAUD
}

/* 1 bit de start, 8 bits de donnees, 1 stop, pas de


/* pas d'interruption, modes de Tx et de Rx valides */
/* 9600 bps valeur par defaut, Q = 8 MHz
*/

== 9600)
= 0x30;
== 4800)
= 0x31;
== 2400)
= 0x32;
== 1200)
= 0x33;

199 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

unsigned char read_com (unsigned char *caractere) {


if (SCSR & 0x20) {
/* si RDFR=1 alors on a recu un caractere
*caractere = SCDR;
return (1);
}
return (0);
*/
}

/* si pas de caractere, 0

Remarques :
Il faut connatre bien sr le fonctionnement du priphrique contrler.
Script de compilation et ddition de liens :
@echo off
cx6811 -v -e ping1.c
if errorlevel 1 goto bad
:clink
200 / 219
pk-mt/enseirb/2005

pk

*/

Le langage C pour l'embarqu

pk

echo.
echo Linking ...
clnk -o ping1.h11 -m ping1.map ping1.lkf
if errorlevel 1 goto bad
:chexa
echo.
echo Converting ...
chex -o ping1.s19 ping1.h11
if errorlevel 1 goto bad
:cobj
echo.
echo Section size ...
cobj -n ping1.h11
if errorlevel 1 goto bad
echo.
echo.
echo
OK.
goto sortie
:bad
echo.
echo.
201 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

echo
:sortie

BAD.

Fichier ddition de liens :


#
link command file for test program
#
Copyright (c) 1995 by COSMIC Software
#
+seg .text -b 0x2000 -n .text
# program start address
+seg .const -a .text
# constants follow program
+seg .data -b 0x3000
# data start address bss
ping1.o
# application program
libhc11.o
# 68hc11 enseirb lib
d:/logiciel/68hc11/cx32/lib/libi.h11
# C library
d:/logiciel/68hc11/cx32/lib/libm.h11
# machine library

Remarques :
Le code est plac en mmoire partir de ladresse 0x2000 (.text).
202 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

Les donnes du programme (initialises ou non .data) sont places partir de


ladresse 0x3000.
Les modules objets sont relogs suivant un ordre prcis le premier tant le programme
principal. Le point dentre du programme est donc ladresse 0x2000 ce qui
correspond ladresse de la fonction main().
Table des symboles. Mapping :
Segments:
start
start
start
start

00002000
000021b9
00003000
00003002

end
end
end
end

000021b9
000021d0
00003002
00003003

length
length
length
length

441
23
2
1

segment
segment
segment
segment

.text
.const
.data
.bss

Modules:
ping1.o:
start 00002000 end 00002049 length
start 00003000 end 00003002 length
start 00003002 end 00003003 length

73 section .text
2 section .data
1 section .bss
203 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu


start 000021b9 end 000021d0 length
libhc11.o:
start 00002049 end 0000219f length

23 section .const
342 section .text

(d:/logiciel/68hc11/cx32/lib/libm.h11)ilsh.o:
start 0000219f end 000021b9 length
26 section .text
Stack usage:
_AppTickInit
_baudrate
_get1A
_get1E
_get8E
_main
_put1A
_put8A
_read_com
_tempo
_write_com

>
>
>
>
>
>
>
>

2
6
7
7
2
12
10
6
6
8
6

(2)
(6)
(7)
(7)
(2)
(6)
(10)
(6)
(6)
(8)
(6)

Symbols:
204 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu


_AppTickInit

0000218f

_baudrate

00002110

_c
_get1A

00003002
0000207d

_get1E

0000209d

_get8E

000020bd

_main

00002000

_put1A

000020d5

_put8A

000020c5

_read_com

0000215c

_tempo

00002049

_text

00003000

defined
*** not
defined
used in
defined
defined
*** not
defined
*** not
defined
*** not
defined
*** not
defined
*** not
defined
*** not
defined
used in
defined
*** not
defined

pk

in libhc11.o section .text


used ***
in libhc11.o section .text
ping1.o
in ping1.o section .bss
in libhc11.o section .text
used ***
in libhc11.o section .text
used ***
in libhc11.o section .text
used ***
in ping1.o section .text
used ***
in libhc11.o section .text
used ***
in libhc11.o section .text
used ***
in libhc11.o section .text
ping1.o
in libhc11.o section .text
used ***
in ping1.o section .data, initialized
205 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu


_write_com

0000217a

defined in libhc11.o section .text


used in ping1.o
c_ilsh
0000219f
defined in
(d:/logiciel/68hc11/cx32/lib/libm.h11)ilsh.o section .text
used in libhc11.o

Fichier de programmation :
S00C000070696E67312E6831311C
S12320003C3C304F5FED00CC2580BD2110EC00200B4FBD217AEC00C30001ED00F330001884
S12320208F18E600C10A26E9CC000ABD217ACC3002BD215C5D27F7F63002C10D2608CC0064
S12320400DBD217A20E24F20E23C37363C30EC02ED00201718CE100018EC0EE30018ED1895
S1232060181C2340181F2340FBEC021AEE02830001ED02188C000026DB383838393C373696
S12320803430C601E700A6022704584A26FCE70018CE100018E600E400313838393C373651
S12320A03430C601E700A6022704584A26FCE70018CE100018E60AE400313838393CCE10B6
S12320C000E60A38393C373630E60118CE100018E7003838393C37363C30CC0001ED00E688
S12320E003188FEC00BD219FED00E6095A260C18CE100018E600EA0118E700E609260D1849
S1232100CE1000E6015318E40018E700383838393C3736305F18CE100018E72CC60C18E79D
S12321202DC63018E72BEC001A8325802607C63018E72BEC001A8312C02607C63118E72B2A
S1232140EC001A8309602607C63218E72BEC008304B02605C63318E72B3838393C37363047
S123216018CE1000181F2E200D18E62F1AEE0018E700C60120015F3838393C37363018CEF0
S12321801000181F2E80FBE60118E72F3838393CCE1000EC0EC309C4ED161C22803839189F
S11C21A08C00082508175F188FC008188F188C0000270505180926FB3985
S11A21B950726F6772616D6D652070696E6720706F6E67200D0A0088

206 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

S105300021B9F0
S903FFFFFE

Remarques :
Cest un fichier ASCII de type SRecord.
Il est tlcharg via la liaison srie pour programmer la mmoire (RAM) laide dun
programme moniteur.
Le lancement du programme se fait laide dune commande du moniteur (G 2000).

207 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

16.5.

pk

Exemple 5 : pilotage dun priphrique dE/S. Structure C

But :
Cration dune structure C qui mappe les registres de contrle, dtat et de donnes
dun priphrique dE/S (PIT 68230).
typedef volatile struct
{
unsigned char PGCR; /*
Port general Control Register */
unsigned char vide1;
unsigned char PSRR; /* Port service request register */
unsigned char vide2;
unsigned char PADDR; /* Port A Data Direction Register */
. . .
unsigned char vide5;
unsigned char PIVR; /*
Port Interrupt Vector Register */
unsigned char vide6;
unsigned char PACR; /*
Port A Control Register */
208 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

unsigned char
unsigned char
unsigned char
unsigned char
unsigned char
. . .
unsigned char
unsigned char
. . .
unsigned char
} PIT_68230;

pk

vide7;
PBCR; /* Port B Control Register */
vide8;
PADR; /* Port A Data Register */
vide9;
PSR; /* Port Status Register */
vide14;
TSR ; /*Timer Status register

*/

/* carte mmoire */
#define ADR_PIT

((PIT_68230 *) 0xF40081)

Remarques :
La structure C colle aux diffrents registres du priphrique qui apparat dans
lespace dadressage ladresse impaire 0xF40081.
209 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Les registres ne sont quaux adresses impaires (voir les videxx).


La structure est dfinie comme volatile : on ne demande pas doptimisation au
compilateur C quand on accde aux diffrents champs de la structure donc aux
registres du priphrique.

210 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

17. QUELQUES PIEGES CLASSIQUES


17.1.

Erreurs sur l'affectation


a == b;
a = b;

Ce que le programmeur a crit


Ce qu'il aurait d crire
17.2.

Erreurs avec les macros

Un #define n'est pas une dclaration


#define MAX 10;
#define MAX 10

Ce que le programmeur a crit


Ce qu'il aurait d crire

Cette erreur peut provoquer ou non une erreur de compilation l'utilisation de la


macro :
211 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

L'utilisation x = MAX; aura pour expansion x = 10;;


ce qui est licite : il y a une instruction nulle derrire x = 10;.
L'utilisation int t[MAX]; aura pour expansion int t[10;]; ce qui gnrera
un message d'erreur.
Un #define n'est pas une initialisation
Ce que le programmeur a crit
Ce qu'il aurait d crire

#define MAX = 10
#define MAX 10

212 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

17.3.

Erreurs avec l'instruction if


if ( a > b) ;
a = b;
if ( a > b)
a = b;

Ce que le programmeur a crit


Ce qu'il aurait d crire

17.4.

pk

Erreurs avec les commentaires

Il y a deux erreurs avec les commentaires :


1. Le programmeur oublie la squence fermante /*. Le compilateur ignore donc tout
le texte jusqu' la squence fermante du prochain commentaire.
2. On veut enlever (en le mettant en commentaire) un gros bloc d'instructions sans
prendre garde au fait qu'il comporte des commentaires.
213 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

17.5.

Erreurs avec les priorits des oprateurs

Les priorits des oprateurs sont parfois surprenantes. Les cas les plus gnants sont
les suivants :
La priorit des oprateurs bit bit est infrieure celle des oprateurs de
comparaison.
Le programmeur a crit il dsirait
il a obtenu
x & 0xff == 0xac (x & 0xff) == 0xac x & (0xff == 0xac)
La priorit des oprateurs de dcalage est infrieure celle des oprateurs
arithmtiques.
Le programmeur a crit il dsirait
il a obtenu
x << 4 + 0xf
(x << 4) + 0xf
x << (4 + 0xf)
214 / 219
pk-mt/enseirb/2005

pk

Le langage C pour l'embarqu

pk

La priorit de l'oprateur d'affectation est infrieure celle des oprateurs de


comparaison. Dans la squence ci-dessous, trs souvent utilise, toutes les
parenthses sont ncessaires :
while ((c = getchar()) != EOF){
...
}
17.6.

Erreurs avec l'instruction switch

Oubli du break

215 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

Erreurs sur le default


L'alternative excuter par dfaut est introduite par l'tiquette default. Si une
faute de frappe est commise sur cette tiquette, l'alternative par dfaut ne sera plus
reconnue : l'tiquette sera prise pour une tiquette d'instruction sur laquelle ne sera
fait aucun goto.
switch(a){
case 1 : a = b;
defult : return(1);
}

/*

erreur non dtecte

216 / 219
pk-mt/enseirb/2005

*/

Le langage C pour l'embarqu

17.7.

pk

Erreurs sur les tableaux multidimensionnels

La rfrence un tableau t deux dimensions s'crit t[i][j] et non pas t[i,j].

217 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

pk

18. BIBLIOGRAPHIE
[1] Brian W. Kernighan and Dennis M. Ritchie. The C programming language.
Editions Prentice Hall, seconde dition, 1988. Le livre sur C crit par les concepteurs
du langage. La seconde dition est conforme au standard ANSI alors que la premire
dition dfinissait le langage C dans sa version dite ``Kernighan et Ritchie''.
[2] C - Guide complet. Claude Delannoy. Editions Eyrolles.
19. WEBOGRAPHIE
[1] Le langage C. M. Touravane, Matre de confrence l'ESIL.
Ce support de cours est trs largement inspir du travail de ce collgue qui a su
synthtiser l'essentiel savoir sur le langage C. http://www.esil.univ-mrs.fr/~tourai/
218 / 219
pk-mt/enseirb/2005

Le langage C pour l'embarqu

[2] Le langage C adapt aux microcontrleurs. Jean Luc PADIOLLEAU.


http://www.ac-orleans-tours.fr/sti-gel/MICROCONTROLEUR/Accueil_Micro.htm

219 / 219
pk-mt/enseirb/2005

pk

Вам также может понравиться