Dveloppement logiciel

pour
microcontrleurs PIC

Langage C
 Dveloppement d un projet

Projet

Ecriture algorithme

Ecriture
Ecriture du source
du
logiciel Compilation

oui
Erreurs ?

non

Debug du programme
Test
du logiciel
non
Fonctionnement
sur le
OK ?
matriel oui

Programmation
de la carte

Fin du projet
 Les types de donnes

Type longueur domaine de valeur

char ou signed char 8bits -128 127

unsigned char 8bits 0 ... 255

int ou short 16bits -32768 32767

unsigned int 16bits 0 ... 65535

long 32bits -2.147.483.648 ... 2.147.483.647

unsigned long 32bits 0 4.294.967.295

short long 24bits -8.388.608 ... 8.388.607

unsigned short long 24bits 0 16.777.215

float ou double 32bits -3,4 . 1038 ... 3,4 . 1038

double 64bits -1,7 . 10308 ... 1,7 . 10308

 Dclaration des donnes en RAM

Une variable doit tre dclare avant d tre utilise

type nom;
unsigned char unit; // unit est un octet 0..255 plac en RAM

int maxi; // maxi mot 16 bit -3276832767 plac en RAM

char lettre; // lettre est un caractre code ASCII plac en RAM

type nom = valeur_initiale;

unsigned char unit = 10; // unit est un octet initialis 10 en RAM

int maxi = 1024; // maxi mot 16 bit initialis 1024 en RAM

char lettre = A; // caractre A code ASCII 65 en RAM

unsigned char unit;

Ces 3 variables sont diffrentes !
unsigned char UNIT; Le langage C fait la diffrence entre les MAJUSCULES et les minuscules

unsigned char Unit;

 Equivalences

Les quivalences sont remplaces par leur valeur

par le pr-processeur du compilateur.
#define nom valeur
Espaces ou tabulations

Une quivalence n est pas une instruction du programme mais une directive pour le compilateur afin de faciliter la programmation.

#define maxi 150

temperature = maxi; // la variable temperature prend la valeur 150

#define led_allume 1
#define led_eteinte 0

led1 = led_allume; // la variable led1 prend la valeur 1

led2 = led_eteinte; // la variable led2 prend la valeur 0

 Les fonctions

void buzzer (void)

{
prog .
..
}
Initialisation
des ports
void init_port (void)
Led1 teinte {
.
..
}
BP
activ ?

void main (void)

{
Led1 teinte Led1 allume init_port();
led1 = 0;
Gestion du while(1)
buzzer {
if(bp == 0)
{
led1 = 1;
buzzer();
}
else led1 = 0;
}
}
 Les oprateurs arithmtiques

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
 Bases

Base 10 dcimal a = 26;

symboles : 0 1 2 3 4 5 6 7 8 9 c = a + 857;

Base 16 hexadcimal a = 0x1a; // a = 26

symboles : 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F a = 0x1A; // a = 26
a = 0x001a; // a = 26
la nombre est prcd de 0x ...

Base 2 binaire
a = 0b11010; // a = 26
symboles : 0 1
a = 0b00011010; // a = 26
la nombre est prcd de 0b ...

Le programmeur utilisera la base la plus adapte et la plus facile manipuler

Le compilateur accepte aussi l utilisation de bases diffrentes dans un calcul :

- a = 0x01101 >> 3;
- b = ( c * 2 ) + ( a / 0b1010 );
 Les oprateurs logiques

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

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

a = 0x03;
Complment ~ c = ~ a; // c = 0xFC

a = 0b11001100;

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

a = 0b00110000;
Dcalage DROITE >> c = a >> 2; // c = 0b00001100;

a = 0b00110000;
Dcalage GAUCHE << c = a << 2; // c = 0b11000000;
 Autres oprateurs

a = 55;
Incrment ++ a++; // a = 56

a = 20;
Dcrment -- a--; // a = 19

a = 55; // a prend la valeur 55

Affectation = a = a + b; // la somme de a et b est mise dans a

Sparateur ; a = 55; b = a + 1;

Dbut et fin des fonctions

Bloc d instruction { .. .. .. } Dans les tableaux pour sparer les lments

Utilis dans les tests IF..THEN SWITCH.. CASE
Liste de variables ou de constantes Utilis dans les boucles FOR WHILE DO..WHILE
Etc ...

Sparateur , unsigned char TAB[5] = { 2, 5, 8, 20, 5 }; // tableau de 5 valeurs

 Instruction conditionnelle IF. ELSE

if( a > b ) c = c - a;
Action1 et action2 sont une seule instruction
else c = c- b;
Fausse
Condition
?
Action1 et action2 sont if( a > b )
un bloc d instructions
{ c = c - a;
Vrai
d = c - a;
Action 1 Action 2 }
else { c = c - b;
d = c - b;
}
Si la condition est vrai
faire l action 1
ELSE n existe pas if( a > b )
sinon faire action 2
{ c = c - a;
d = c - a;
}
if( condition ) action1;
else action2; if( (a > b) && ( b > 0) ) c = c - a;
Condition multiples
else c = c- b;
 Oprateurs de comparaison

Suprieur > if( a > b )

if( a = b ) ...
Suprieur ou gal >= if( a >= b )
else ...
Infrieur < if( a < b )
Ne pas confondre :
l affectation =
le test de comparaison ==
Infrieur ou gal <= if( a <= b )
Le compilateur ne dtectera pas d erreur mais
le rsultat ne sera pas celui escompt. . . .
Egal == if( a == b )

Diffrent != if( a != b )

Simplification
Oprateurs logique de test if( a )
else
if( (a > b) && ( b > 0) )
ET &&
OU || if( (a > b) || ( b > 0) ) ce test est :
vrai si a > 0
NON ! if( !( a == b) ) faux si a = 0
 Instruction conditionnelle SWITCH CASE

Remplace une suite de IF .. ELSE switch ( expression )

{
expression doit tre un entier ou un caractre. case valeur1 : instruction(s) 1; break;
case valeur2 : instruction(s) 2; break;
Switch compare cette expression aux valeurs des
diffrents case. case valeur3 : instruction(s) 3; break;
default : instruction(s) par dfaut;
L instruction break permet de sortir d un bloc. }
Ici 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 0 0 0
{ 1 1 0 0
case 1 : led1 = 1; led2 = 0; led3 = 0; break;
Rpondre par 2 0 1 0
case 2 : led1 = 0; led2 = 1; led3 = 0; break;
0
3 1 1 x
case 7 : led3 = 1; 1
x si pas de modification 4
case 3 : led1 = 1; led2 = 1; break; 0 0 0
default : led1 = 0; led2 = 0; led3 = 0; 5 0 0 0
} 6 0 0 0
7 1 1 1
 Boucle FOR

Initialisation for ( initialisation ; condition ; modification )

{
action;

Condition ;
? }
Sortie de
la boucle

Action

Version 1 Version 2
Modification
for( x = 0 ; x < 5 ; x++ ) for( x = 5 ; x > 0 ; x-- )
{ { Version 2 simplifie
action; action;
} } for( x = 5 ; x ; x-- )
{
Ces 2 boucles sont identiques.
action;
Action est excute 5 fois
}

x est vrai si x > 0 donc la

boucle sera excute tant que
Attention aux conditions qui rendent la boucle infinie. x>0
 Boucle WHILE
Tant que condition vraie faire...

while (condition)
Cette boucle est identique une boucle FOR
{
x = 0;
action; while ( x < 5 )
Condition ; {
? action;
Sortie de
}
x++;
la boucle
}

Action Dans cette boucle action ne sera x = 10;

jamais excute car la condition est
while ( x < 5 )
dj fausse lors de la premire
entre. {
action;
x++;
}

while ( 1 ) Soit un bouton poussoir qui donne 0 si il est appuy. while ( bouton == 0 )
{ Ici on fait l action tant que le poussoir est maintenu appuy. {
On sort de la boucle quant le bouton n est plus appuy.
action; action;
; }
}

while(1) est une boucle qui permet d excuter indfiniment un bloc d instructions.
Cette boucle est volontairement rendue infinie en testant une condition toujours vrai : 1 tant > 0 donc vrai . . .
On trouve trs souvent une boucle while(1) dans la fonction main().
 Boucle DO WHILE

Faire... tant que condition vraie

Action Action est toujours excute au moins une fois

do
que condition soit vraie ou fausse.
{
action;
Condition
? ;
}
while (condition);

Sortie de
la boucle

x = 0; Nombre d excutions de la boucle : 5

total = 0;
A la sortie de la boucle total = 10
do
{
total = total + x;
x++;
}
while ( x < 5 );
 LES TABLEAUX

Un tableau permet de regrouper des variables ou des constantes de mme type.

Ces variables ou constantes sont appeles lments du tableau.
Un tableau doit tre dclar avant son utilisation.
L initialisation est facultative elle est de la forme :
= { lment0 , lment1 , .. .. , lmentx }

type nom[taille] = { lments } ;

Indique le nombre d lments du tableau.

Nom du tableau, respecter la case.

Obligatoire comme pour les variables et constantes

unsigned char TABLEAU[5] = { 1 , 10 , 30 , 40 , 50 } ;

X = TABLEAU[0]; // x = 1 indice 0 = premier lment du tableau

X = TABLEAU[3]; // x = 40 indice 3 = quatrime lment du tableau

somme = 0; Nombre d excutions de la boucle : 5

for(i = 0 ; i < 5 ; i++ )
A la sortie de la boucle somme = 131
{
somme = somme + TABLEAU[i];
}