Dveloppement logiciel

pour
microcontrleurs PIC

Langage C

T.Berenguer
 Dveloppement dun 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
 Flux de donnes dun projet

Fichiers source fichier1.c fichier2.c fichier3.asm

Assembleur

Compilateur mcc18 mcc18 MPASMWIN

Script pour le
Bibliothques linkage

Fichiers objet fichier1.o fichier2.o fichier3.o lib1.lib script.lkr

Editeur de liens mplink

Fichiers de sortie projet.cof projet.hex projet.map

Programmation
Debug
du composant
Programme source en C
Commentaire /* bla bla
sur plusieurs lignes bla bla */

Insertion dun fichier

#include < nom.ext > dfini dans options
#include " nom.ext " dans dossier local

Commentaire // bla bla

sur 1 ligne

Dfinition quivalence
#define symbole valeur

Dclaration des variables

m , c , d u sont des octets en RAM

Unsigned, char, void, while, if sont

des mots rservs. Il y en a 32 en C.

Fonction principale
Son nom est main, cest un mot rserv.

Le point virgule indique la fin dune

instruction. On peut mettre plusieurs
instructions sur une ligne.

Un couple daccolades indique le dbut { et

la fin } dun bloc dinstructions.

Les accolades indiques aussi le dbut et la

fin des fonctions.
 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 dtre 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;

 Dclaration des donnes en ROM

Elles sont ranges dans la ROM et ne sont donc pas modifiables

rom type nom = valeur_initiale;

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

rom int maxi = 1024; // maxi mot 16 bit initialis 1024 en ROM

rom char lettre = A; // caractre A code ASCII 65 en ROM

 Equivalences

Les quivalences sont remplaces par leur valeur

par le pr-processeur du compilateur.

#define nom valeur

Espaces ou tabulations

Une quivalence nest 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 cest 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

la nombre est prcd de 0x... a = 0x001a; // a = 26

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 lutilisation 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 dinstruction { .. .. .. } 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
Condition
??
Action1 et action2 sont if( a > b )
un bloc dinstructions
{ c = c - a;
Vrai
d = c - a;
Action
Action1 1 Action
Action22 }
else { c = c - b;
d = c - b;
}
Si la condition est vrai
faire laction 1
ELSE nexiste 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 derreur mais

Egal == if( a == b )
le rsultat ne sera pas celui escompt. . . .

Diffrent != if( a != b )

Simplification
Oprateurs logique de test if( a )
else
ET && if( (a > b) && ( b > 0) )

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;
Linstruction break permet de sortir dun bloc. }
Ici cela permet de ne pas tester les case suivants.

Default est effectu si aucun des case nest

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
Initialisation for ( initialisation ; condition ; modification )
{
action;

Condition ;
Condition
?? }
Sortie de
la boucle

Action
Action
Version 1 Version 2
Modification
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
Condition ; {
?? action;
Sortie de
}
x++;
la boucle
}

Action
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 laction tant que le poussoir est maintenu appuy. {
On sort de la boucle quant le bouton nest plus appuy.
action; action;
; }
}

while(1) est une boucle qui permet dexcuter indfiniment un bloc dinstructions.
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 est toujours excute au moins une fois

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

Sortie de
la boucle

x = 0; Nombre dexcutions 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.
Linitialisation est facultative elle est de la forme :
= { lment0 , lment1 , .. .. , lmentx }

type nom[taille] = { lments } ;

Indique le nombre dlments 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 dexcutions de la boucle : 5

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

Fin de la premire partie

suivre...