Institut Supérieur des Technologies Médicales de

Tunis

Cours : Architecture des systèmes à

processeurs
3ème année Licence Appliquée en GBM
Cours Préparé par :
M. Hedi ABDELKRIM
M. Slim BEN OTHMAN
M. Ahmed Karim BEN SALEM
M. Taoufik Majoul
(Classés par ordre alphabétique de noms)
2019/2020
Chapitre 2 : Le Langage C pour le
Microcontrôleur PIC
 2.1 Chaine de compilation C
 2.2 Syntaxe
 2.3 Variables & Constantes
 2.4 Les opérateurs
 2.5 Les structures conditionnelles
 2.6 Les structures itératives
 2.7 Les sous-programmes : Fonctions
I/ Chaine de compilation C

Programmateur Compilateur C

3
I/ Chaine de compilation C
#include Bibliothèques pré compilées
<stdio.h> (fichiers objet)
Bibliothèques Fichiers
en C (texte) header
main() *.c *.h
{ puts(" Bonjour
à tous ");
}

Éditeur de lien
Préprocesseur Compilateur C LINKER
remplace les Transforme le fichier C en un Lie (donne des adresses
#define et effectue fichier objet (code machine), aux fonctions) tous les
les #include les fonctions pré compilées fichiers objets et crée un
Fichier sont déclarées dans les fichiers fichier exécutable
source C *.h
contenant la
fonction
main
FLUX DE DONNEES D’UN
Fichier de Programme
COMPILATEUR C symboles exécutable
pour debug *.hex

4
I/ Chaine de compilation C

• Programmation hors ligne, hors circuit

• Charger le fichier hex du programme
compilé dans la mémoire programme du
microcontrôleur
• Principalement utilisé pour charger le
BootLoader
Programmateur universel de mémoires.
5
I/ Chaine de compilation C
Bootloader est un petit programme chargé dans le microcontrôleur à programmer.
Son rôle est de programmer en ligne et sur circuit le microcontrôleur.
Il permet de télécharger des programmes sur le microcontrôleur via des interfaces
series (RS232/USB).

Code chargé
par un
équipement
programmateur

Code chargé
par le
Bootloader

6
II/ Syntaxe du langage C
/*exemple typique d’un programme C Commentaire
Cours Microprocesseur-API*/
# : Instructions de préprocesseurs
#include <PIC16f84.h>
#include "mylcd.h"
Insertion d’un fichier
#fuses XT,NOWDT,NOPROTECT,NOLVP #include < nom.ext > défini dans options
#use delay(clock=4000000) #include " nom.ext " dans dossier local

#define bpraz PIN_B0 //BP reset Établir la configuration interne du microcontrôleur

void init_micro()
{ Préciser la fréquence d’horloge utilisée en Hz
set_tris_a(0x0F);
set_tris_b(0xF1);
} Définition d’équivalence, le préprocesseur remplacera tous
Unsigned char m,c,d,u; les bpraz par PIN_B0
Prototype et corps d’une
void main() fonction Déclaration de variables globales
{
int mm; Fonction principale Déclaration de variables locales
init_micro();
while(1)
{ Appel d’une fonction
mm++;
if (input(bpraz) Tout programme microcontrôleur doit obligatoirement tourner en boucle 
{
m=0;c=0;d=0;u=0;
} Un couple d’accolades indique le début { et la fin } d’un bloc
delay_ms(50); d’instructions.
output_high(PIN_B2);
… Les accolades indiquent aussi le début et la fin des
} fonctions.
}
7
 III/ Variables & Constantes
Exemples de déclaration

char tata,blabla,alea ; trois caractères

int table[100] ; tableau de 100 entiers

char tableau[ ]={0b110,0x1c,’A’,55,4}

tableau de 5 char initialisé

Remarque:
un nombre entier en hexadécimal est précédé de 0x ou 0X, (0x1FB9)
un nombre entier en décimal n’a pas besoin de préfixe

un nombre réel se note 13.145 ou 1.3145e+1.

Dans les compilateurs pour µC: notation binaire 0b11010001

8
 III/ Variables & Constantes
Équivalences
directive #define
Les équivalences sont remplacées par leur valeur par le préprocesseur
#define pi 3.14

Constantes
• Elles sont rangées dans la ROM et ne sont donc pas modifiables.
• const int i=16569, char c=0x4c ;
• const float pi=3.14;
Le mot réservé « const » définit une constante

9
 III/ Variables & Constantes
VARIABLES LOCALES ET GLOBALES
Les variables sont stockées en RAM afin d’être modifiables au cours du
programme. Elles peuvent être à une adresse fixe (static) ou dans une pile
(volatile).

• GLOBLALE Déclarées en dehors d’une fonction

toujours statiques

•LOCALES Déclarées dans une fonction

10
 III/ Variables & Constantes
Les types de données propres à PICC
Par défaut, les types entiers (int, char) de base sont non signés!
Ils peuvent être précédés de signed pour forcer le type signé.

Type Longueur Domaine de valeurs

int1 ou short 1 bit 0 ou 1
char 8 bits 0 à 255
int ou int8 8 bits 0 à 255
int16 ou long 16 bits 0 à 65535
int32 32 bits 0 à 4 294 967 295
float 32 bits ± 3.4 * (10-38) à ± 3.4 * (10+38)

11
 III/ Variables & Constantes
Le type tableau
• Un tableau permet de regrouper des variables ou des constantes de même type.
• Ces variables ou constantes sont appelées éléments du tableau.
• Un tableau doit être déclaré avant son utilisation.

Obligatoire comme pour les variables et

constantes
L’initialisation est facultative elle est de la
type nom[taille] = { éléments … } ; forme :
= { élément0 , élément1 , .. .. , élémentx }
Elle se fait obligatoirement à la déclaration
Indique le nombre d’éléments du tableau.

Nom du tableau, respecter la case.

• Exemple de déclaration
unsigned char TABLEAU[5] = { 1 , 10 , 30 , 40 , 50 } ;
• Exemple d’utilisation
X = TABLEAU[0]; // x = 1 indice 0 = premier élément du tableau
X = TABLEAU[3]; // x = 40 indice 3 = quatrième élément du tableau
12
 IV/ Les opérateurs
Opérateur d’affectation
a = 55; // a prend la valeur 55
Affectation = Y = a + b // la somme de a et b est mise dans y

Les opérateurs arithmétiques

a = 3;
Addition + c = a + 2; // c = 5

a = 3;
Soustraction - c = a - 2; // c = 1

a = 3;

Multiplication * b = 11;
c = a * b; // c = 33

a = 75;

Division / b = 3;
c = a / b; // c = 25

a = 75;
Modulo % diz = a / 10; // diz = 7
Reste de la division
unite = a % 10 // unite = 5 c ’est à dire le reste
13
 IV/ Les opérateurs
Les opérateurs logiques
ET bit à bit a = 0b11001100;

& c = a & 0b10101010; // c = 0b1001000

OU bit à bit a = 0b11001100;

| c = a | 0b00111100; // c = 0b11111100

a = 0x03;
Complément ~ c = ~ a; // c = 0xFC

a = 0b11001100;

OU exclusif ^ b = 0b10100010;
c = a ^ b; // c = 0b01101110

Décalage à droite a = 0b00110000;

>> c = a >> 2; // c = 0b00001100;

Décalage à gauche a = 0b00110000;

<< c = a << 2; // c = 0b11000000;

Autres opérateurs
a = 55;
Incrément ++ Décrément -- a = 20;
a++; // a = 56 a--; // a = 19 14
 V/ Les Structures Conditionnelles
if…else
Action1 et action2 sont une if( a > b ) c = c - a;
seule instruction else c = c- b;

Fausse
Condition Action1 et action2 sont un bloc if( a > b )
? d’instructions
{ c = c - a;
d = c - a;
Vraie }
else { c = c - b;
Action 1 Action 2
d = c - b;
}

ELSE n’existe pas if( a > b )

Si la condition est vraie { c = c - a;
•faire l’action 1 d = c - a;
•sinon faire action 2 }

Condition multiple if( (a > b) && ( b > 0) )

if( condition ) action1;
c = c - a;
else action2; else
c = c- b;
15
 V/ Les Structures Conditionnelles
switch…case Remplace une suite de IF .. ELSE
switch ( expression )
{ •expression doit être un entier ou un caractère.

case valeur1 : instruction(s) 1; break;

•Switch compare cette expression aux valeurs des
case valeur2 : instruction(s) 2; break; différents case.
case valeur3 : instruction(s) 3; break;
default : instruction(s) par défaut; •L’instruction break permet de sortir d’un bloc. cela
permet de ne pas tester les case suivants.
}
•Default est effectué si aucun des case n’est effectué.

Valeur led1 led2 led3

switch ( valeur )
0
{
1
case 1 : led1 = 1; led2 = 0; led3 = 0; break;
2
case 2 : led1 = 0; led2 = 1; led3 = 0; break;
3
case 7 : led3 = 1;
Répondre par 4
case 3 : led1 = 1; led2 = 1; break; • 0 5
default : led1 = 0; led2 = 0; led3 = 0; • 1
• x si pas de modification 6
}
7
16
 V/ Les Structures Conditionnelles
Opérateurs de comparaison
Supérieur > if( a > b )
if( a = b ) ...
Supérieur ou égal >= if( a >= b )
else ...
Inférieur < if( a < b )
Ne pas confondre :
• l’ affectation =
Inférieur ou égal <= if( a <= b ) • le test de comparaison ==

Egal == if( a == b ) Le compilateur ne détectera pas d’erreur

mais le résultat ne sera pas celui escompté. . . .

Différent != if( a != b )

Opérateurs logiques de test Simplification

if( (a > b) && ( b > 0) ) if( a ) …
ET &&
else …
OU || if( (a > b) || ( b > 0) )

NON ! if( !( a == b) )
ce test est :
• vrai si a > 0
17
• faux si a = 0
 VI/ Les Structures Itératives
Boucle for
Initialisation for ( initialisation ; condition ; modification )
{
action;
Condition …;
?
}
Sortie de
la boucle
Version 1 Version 2

Action
for( x = 0 ; x < 5 ; x++ ) for( x = 5 ; x > 0 ; x-- )
{ {
Modification
action; action;
} }

Ces 2 boucles sont identiques.

Action est exécutée 5 fois

18
 VI/ Les Structures Itératives
Boucle while Cette boucle est identique à une boucle FOR
while (condition)
x = 0;
{ while ( x < 5 )
action; {

…; action;
x++;
Condition }
? }

Sortie de x = 10;
la boucle
Dans cette boucle action ne while ( x < 5 )
sera jamais exécutée car la {
Action condition est déjà fausse lors
action;
de la première entrée.
x++;
}
Tant que condition vraie faire...
while ( bouton == 0 )
Soit un bouton poussoir qui donne 0 si il est appuyé.
Ici on fait l’action tant que le poussoir est maintenu {
appuyé. action;
while ( 1 ) On sort de la boucle quand le bouton n’est plus appuyé.
}
{
action; while(1) est une boucle qui permet d’exécuter indéfiniment un bloc d’instructions.
Cette boucle est volontairement rendue infinie en testant une condition toujours vrai : 1
……; étant > 0 donc vrai . . .
} On trouve très souvent une boucle while(1) dans la fonction main().

19
 VI/ Les Structures Itératives
Boucle do…while
do Action est toujours exécutée au moins une fois
Action que condition soit vraie ou fausse.
{
action;
…;
Condition
? }
while (condition);

Sortie de la x = 0; Nombre d’exécutions de la boucle : ,,,

boucle
total = 0;
A la sortie de la boucle total = ,,,
do
Faire... tant que condition vraie {
total = total + x;
x++;
}
while ( x < 5 );

20
 VI/ Les Structures Itératives
Les contrôles de boucles
• break permet de sortir de la boucle en cours (for, while, do while, switch)
• continue permet de sauter directement à l’itération suivante d’une
boucle
for(i=0 ;i<100 ;i++)
{
if (i<50)
continue;
else a=a+i;
}
• exit permet de quitter directement le programme (inutile sur micro
contrôleur)

21
 VII/ Les Sous Programmes : Fonctions
Appel de fonction void buzzer (void)
{
prog 3 ….
…..
}
Initialisation 7
des ports
void init_port (void)
{
Led1 éteinte ….
4 …..
buzzer();
…..
BP }
activé ?
1 2
void main (void)
{
Led1 éteinte Led1 allumée init_port();
5
led1 = 0;
Gestion du while(1)
buzzer {
if(bp == 0)
{
led1 = 1; 6
buzzer();
}
else led1 = 0;
}
}

22
 VII/ Les Sous Programmes : Fonctions
Passage de paramètres
Fonction avec passage de Fonction avec passage de Fonction sans
paramètres par valeur paramètre par adresse paramètres
qui retourne une valeur
Int somme (int a, int b) Void somme (int a, int b, int *s) Int a,b,s;
{ { Void somme ()
int s; *s = a+b; {
s = a+b; } s = a+b;
return (s); }
}

void main (void) void main (void) void main (void)

{ { {
int z,x,y; int z,x,y; ….
…. …. while(1)
while(1) while(1) {
{ { …
… … a = 5;
x = 5; x = 5; b = 6;
y = 6; y = 6; somme (); //s=11
z = somme (x,y); somme (x,y, &z); …
… … }
} } }
} }

23