Développement logicielpour

microcontrôleurs PIC

Langage C

T.Berenguer

Développement d ’un projet

Projet

Ecriture algorithme

Compilation

Erreurs ?

Debug du programme

non

FonctionnementOK ?

oui

oui

Programmationde la carte

Fin du projet

Ecriture

du

logiciel

Test

du logiciel

sur le

matériel

Ecriture du source

non

Flux de données d ’un projet

fichier3.asmfichier1.c fichier2.c

mcc18 mcc18 MPASMWIN

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

mplink

projet.hex projet.mapprojet.cof

Fichiers sourceFichiers source

CompilateurCompilateur

AssembleurAssembleur

Fichiers objetFichiers objet

DebugDebugProgrammation Programmation

du composantdu composant

Fichiers de sortieFichiers de sortie

Editeur de liensEditeur de liens

BibliothèquesBibliothèquesScript pour le Script pour le

linkage linkage

Programme source en CCommentaire /* bla blasur plusieurs lignes bla bla */

Commentaire // bla blasur 1 ligne

Insertion d ’un fichier #include < nom.ext > défini dans options

#include " nom.ext "  dans dossier local

Définition équivalence#define symbole valeur

Déclaration des variablesm , c , d u sont des octets en RAM

Fonction principaleSon nom est main, c ’est un mot réservé.

Le point virgule indique la fin d ’une instruction. On peut mettre plusieurs instructions sur une ligne.

Un couple d ’accolades indique le début { et la fin } d ’un bloc d ’instructions.

Les accolades indiques aussi le début et la fin des fonctions.

Unsigned, char, void, while, if … sont des mots réservés. Il y en a 32 en C.

Les types de données

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

Type longueur domaine de valeur

Déclaration des données en RAM

type nom;

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

int maxi; // maxi mot 16 bit -32768…32767 placé en RAM

char lettre; // lettre est un caractère 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’; // caractère A code ASCII 65 en RAM

unsigned char unit;

unsigned char UNIT;

unsigned char Unit;

Une variable doit être déclarée avant d ’être utilisée

Ces 3 variables sont différentes !

Le langage C fait la différence entre les MAJUSCULES et les minuscules

Déclaration des données en ROM

Elles sont rangées 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’; // caractère A code ASCII 65 en ROM

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

Equivalences

Les équivalences sont remplacées par leur valeurpar le pré-processeur du

compilateur.

#define maxi 150

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

#define nom valeur

#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

Espaces ou tabulations

Les fonctions

void main (void){ init_port(); led1 = 0; while(1) { if(bp == 0) { led1 = 1; buzzer(); } else led1 = 0; }}

void init_port (void){

….…..

}

void buzzer (void){

….…..

}

prog

Initialisationdes ports

Led1 éteinte

BPactivé ?

Led1 allumée

Gestion du buzzer

Led1 éteinte

Les opérateurs arithmétiques

Addition +

a = 3;

c = a + 2; // c = 5

Soustraction -a = 3;

c = a - 2; // c = 1

Multiplication *a = 3;

b = 11;

c = a + b; // c = 33

Division /a = 75;

b = 3;

c = a / b; // c = 25

Modulo %Reste de la division

a = 75;

diz = a / 10; // diz = 7

unite = a % 10 // unite = 5 c ’est à dire le reste

Bases

Base 10 décimal

symboles : 0 1 2 3 4 5 6 7 8 9

a = 26;

c = a + 857;

Base 16 hexadécimal

symboles : 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

la nombre est précédé de 0x...

a = 0x1a; // a = 26

a = 0x1A; // a = 26

a = 0x001a; // a =

26

Base 2 binaire

symboles : 0 1

la nombre est précédé de 0b...

a = 0b11010; // a = 26

a = 0b00011010; // a = 26

Le programmeur utilisera la base la plus adaptée et la plus facile à manipuler

Le compilateur accepte aussi l ’utilisation de bases différentes dans un calcul :

- a = 0x01101 >> 3;

- b = ( c * 2 ) + ( a / 0b1010 );

Les opérateurs logiques

ET &a = 0b11001100;

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

OU |a = 0b11001100;

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

Complément ~a = 0x03;

c = ~ a; // c = 0xFC

OU exclusif ^a = 0b11001100;

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

Incrément ++a = 55;

a++; // a = 56

Décrément --a = 20;

a--; // a = 19

Affectation =a = 55; // a prend la valeur 55

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

Séparateur ; a = 55; b = a + 1;

•Bloc d ’instruction { .. .. .. }

•Liste de variables ou de constantes

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

•Début et fin des fonctions

•Dans les tableaux pour séparer les éléments

•Utilisé dans les tests IF..THEN SWITCH.. CASE

•Utilisé dans les boucles FOR WHILE DO..WHILE

• Etc ...

Instruction conditionnelle IF…. ELSE

Condition?

Condition?

Action 1Action 1 Action 2Action 2

Vrai

Fausse

if( condition ) action1;

else action2;

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

else c = c- b;

if( a > b )

{ c = c - a;

d = c - a;

}

else { c = c - b;

d = c - b;

}

if( a > b )

{ c = c - a;

d = c - a;

}

if( (a > b) && ( b > 0) ) c = c - a;

else c = c- b;

Action1 et action2 sont un bloc d ’instructions

Action1 et action2 sont une seule instruction

ELSE n ’existe pas

Condition multiples

Si la condition est vrai

•faire l ’action 1

•sinon faire action 2

if( a = b ) ...

else ...

Ne pas confondre :• l ’ affectation =• le test de comparaison ==

Le compilateur ne détectera pas d ’erreur mais le résultat ne sera pas celui escompté. . . .

Opérateurs de comparaison

Supérieur >

Supérieur ou égal >=

Inférieur <

Inférieur ou égal <=

Egal ==

Différent !=

if( a > b )

if( a >= b )

if( a < b )

if( a <= b )

if( a == b )

if( a != b )

Opérateurs logique de test

ET &&

OU ||

NON !

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

if( (a > b) || ( b > 0) )

if( !( a == b) )

Simplification

if( a ) …

else …

ce test est :

• vrai si a > 0

• faux si a = 0

Instruction conditionnelle SWITCH … CASE

Remplace une suite de IF .. ELSE

•expression doit être un entier ou un caractère.

•Switch compare cette expression aux valeurs des différents case.

•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é.

switch ( expression )

{

case valeur1 : instruction(s) 1; break;

case valeur2 : instruction(s) 2; break;

case valeur3 : instruction(s) 3; break;

default : instruction(s) par défaut;

}

switch ( valeur )

{

case 1 : led1 = 1; led2 = 0; led3 = 0; break;

case 2 : led1 = 0; led2 = 1; led3 = 0; break;

case 7 : led3 = 1;

case 3 : led1 = 1; led2 = 1; break;

default : led1 = 0; led2 = 0; led3 = 0;

}

Valeur led1 led2 led3

0

1

2

3

4

5

6

7

0 0 0

1 0 0

0 1 0

1 1 x

0 0 0

0 0 0

0 0 0

1 1 1

Répondre par• 0• 1 • x si pas de modification

Boucle FOR

Condition?

Condition?

ActionAction

ModificationModification

Sortie de la boucle

InitialisationInitialisation for ( initialisation ; condition ; modification )

{

action;

… ;

}

Version 1

for( x = 0 ; x < 5 ; x++ )

{

action;

}

Version 2

for( x = 5 ; x > 0 ; x-- )

{

action;

}

Ces 2 boucles sont identiques.

Action est exécutée 5 fois

Version 2 simplifiée

for( x = 5 ; x ; x-- )

{

action;

}

x est vrai si x > 0 donc la boucle sera exécutée tant que x > 0Attention aux conditions qui rendent la boucle

infinie.

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().

Boucle WHILE

while (condition)

{

action;

… ;

}

x = 0;

while ( x < 5 )

{

action;

x++;

}

x = 10;

while ( x < 5 )

{

action;

x++;

}

Cette boucle est identique à une boucle FOR

Dans cette boucle action ne sera jamais exécutée car la condition est déjà fausse lors de la première entrée.

while ( bouton == 0 )

{

action;

}

Soit un bouton poussoir qui donne 0 si il est appuyé.Ici on fait l ’action tant que le poussoir est maintenu appuyé.On sort de la boucle quant le bouton n ’est plus appuyé.

Tant que condition vraie faire...

while ( 1 )

{

action;

… … ;

}

Condition?

Condition?

ActionAction

Sortie de la boucle

Nombre d ’exécutions de la boucle :

A la sortie de la boucle total =

5

10

Boucle DO … WHILE

Faire... tant que condition vraie

do

{

action;

… ;

}

while (condition);

Action est toujours exécutée au moins une fois

que condition soit vraie ou fausse.

x = 0;

total = 0;

do

{

total = total + x;

x++;

}

while ( x < 5 );

Condition?

Condition?

ActionAction

Sortie de la boucle

// x = 1 indice 0 = premier élément du tableau

// x = 40 indice 3 = quatrième élément du tableau

LES TABLEAUX

Un tableau permet de regrouper des variables ou des constantes de même type.

Ces variables ou constantes sont appelées élémentséléments du tableau.

Un tableau doit être déclaré avant son utilisation.

type nom[taille] = { éléments … } ;

Obligatoire comme pour les variables et constantes

Nom du tableau, respecter la case.

Indique le nombre d ’éléments du tableau.

L ’initialisation est facultative elle est de la forme :

= { élément0 , élément1 , .. .. , élémentx }

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

X = TABLEAU[0];

X = TABLEAU[3];

Nombre d ’exécutions de la boucle :

A la sortie de la boucle somme =

5

131

somme = 0;

for(i = 0 ; i < 5 ; i++ )

{

somme = somme + TABLEAU[i];

}

...C

Fin de la première partie

à suivre...