PIC en C - Fonctions

La programmation des PC en C
Les fonctions, les interruptions.

Ralisation : HOLLARD Herv.
http://electronique-facile.com
Date : 26 aot 2004
Rvision : 1

La programmation des PC en C Les fonctions, les interruptions
Page 2/17

Sommaire

Sommaire ............................................................................................................................2
ntroduction..........................................................................................................................3
Structure de ce document....................................................................................................4
Le matriel ncessaire.........................................................................................................4
La platine d'essai .................................................................................................................4
Les fonctions........................................................................................................................5
Gnralits.......................................................................................................................5
Fonction sans paramtres................................................................................................6
Fonction avec paramtres d'entre..................................................................................8
Fonction avec paramtres de sortie...............................................................................11
Fonction avec paramtres d'entre et de sortie .............................................................12
Les interruptions ................................................................................................................13
Gnralits.....................................................................................................................13
Le PC 16F84.................................................................................................................13
Exemples .......................................................................................................................15

Page 3/17

Introduction

Les microcontrleurs PC de la socit Microchip sont depuis quelques annes dans le "hit
parade" des meilleures ventes. Ceci est en partie d leur prix trs bas, leur simplicit de
programmation, les outils de dveloppement que l'on trouve sur le NET.

Aujourd'hui, dvelopper une application avec un PC n'a rien d'extraordinaire, et tous les outils
ncessaires sont disponibles gratuitement. Voici l'ensemble des matriels qui me semblent les
mieux adapts.
Ensemble de dveloppement (diteur, compilateur, simulateur) :
MPLAB de MCROCHP http://www.microchip.com
Logiciel de programmation des composants:
C-PROG de Bonny Gijzen http://www.ic-prog.com
Programmateur de composants:
PROPC2 d'Octavio Noguera voir notre site http://eIectronique-faciIe.com

Pour la programmation en assembleur, beaucoup de routines sont dj crites, des didacticiels
trs complets et gratuits sont disponibles comme par exemple les cours de BIGONOFF dont le site
est l'adresse suivante http://abceIectronique.com/bigonoff.

Les fonctions que nous demandons de raliser nos PC sont de plus en plus complexes, les
programmes pour les raliser demandent de plus en plus de mmoire. L'utilisateur est ainsi la
recherche de langages "volus" pouvant simplifier la tche de programmation.

Depuis l'ouverture du site http://eIectronique-faciIe.com, le nombre de questions sur la
programmation des PC en C est en constante augmentation. l est vrai que rien n'est aujourd'hui
disponible en franais.

Mon exprience dans le domaine de la programmation en C due en partie mon mtier
d'enseignant, et ma passion pour les PC, m'a naturellement amen l'criture de ce
didacticieI. Celui-ci se veut accessibIe tous ceux qui possdent une petite exprience
informatique et lectronique (utilisation de Windows, connaissances minimales sur les notions
suivantes : la tension, le courant, les rsistances, les LEDs, les quartz, l'criture sous forme binaire
et hexadcimale.).

Ce cinquime fascicule vous permettra de programmer de faon plus structure grce aux
fonctions. Vous pourrez enfin utiliser au mieux le PC 16F84 grce aux interruptions.
Page 4/17

Structure de ce document

Ce document est compos de chapitres. Chaque chapitre dpend des prcdents. Si vous
n'avez pas de notion de programmation, vous devez raliser chaque page pour progresser
rapidement.

Le type gras sert faire ressortir Ies termes importants.

Vous trouverez la dfinition de chaque terme nouveau en bas de Ia page o apparat pour la
premire fois ce terme. Le terme est alors en .

La couleur bIeue est utilise pour vous indiquer que ce texte est taper exactement sous cette
forme.

La couleur rouge indique des commandes informatiques utiliser.

Le matrieI ncessaire

Les deux logiciels utiliss lors du premier fascicule.

Un programmateur de PC comprenant un logiciel et une carte de programmation. Vous
trouverez tout ceci sur notre site.

Un PC 16F84, un quartz de 4MHz, deux condensateurs de 22pF, 4 leds rouges, 4 rsistances
de 470 ohms, 4 interrupteurs, 4 rsistances de 10 Kohms. Une platine d'essai sous 5 volts.

La pIatine d'essai

Pour tester les programmes proposs, il est possible :
-utiliser le simulateur comme prsent dans le premier manuel;
-programmer un composant et tester physiquement la ralisation;
-utiliser un mulateur.

Nous utiliserons dans ce didacticiel le test physique.
l est ainsi ncessaire de raliser sur une platine
de type LAB par exemple le montage ci-contre.
Page 5/17

Les fonctions
GnraIits

La plupart des langages de programmation nous permettent de subdiviser nos programmes en
sous-programmes plus simples et plus compacts : les fonctions. A l'aide de ces structures nous
pouvons moduIariser nos programmes pour obtenir des solutions plus lgantes et plus efficaces.

Une fonction peut en appeIer une autre grce des instructions particulires. A la suite d'un
appel, Ia fonction appeIante s'arrte et Ia fonction appeIe se met en excution jusqu' ce
qu'elle appelle une autre fonction ou se termine. Lors de la fin de son excution, la fonction
appelante reprend son fonctionnement depuis son arrt.
Une fonction peut envoyer Ies donnes Ia fonction qu'eIIe appeIIe au moment de son
appel.
Une fonction peut envoyer des donnes Ia fonction qui I'a appeIe au moment du retour.
Une fonction appeIe doit toujours tre dfinie avant Ia fonction qui I'appeIIe. Elle est soit
crite, soit dclare avant la fonction qui l'appelle.
l est possible d'imbriquer jusqu' 8 fonctions au maximum cause de la structure du PC 16F84.
Chaque fonction peut tre appele plusieurs fois si ncessaire.

Lors du Iancement du programme, Ia fonction "main" s'excute en premier. C'est pour cela
que nous avons crit avant la premire instruction qu'excutera le PC : "void main(void) {". Nous
avons ainsi dclar la fonction main. Vous comprendrez l'utilit des "void" plus tard.

Un programme en C aura donc la structure suivante:

Fonction X
{ nstruction en C }

Fonction Y
{ nstruction en C, appel de la fonction X si ncessaire}

Dclaration de la fonction Z

Fonction main
{ nstruction en C, appel des fonctions X, Y et Z si ncessaire}

Fonction Z
{ nstruction en C, appel des fonctions X et Y si ncessaire}

Les fonctions permettent :
Meilleure lisibilit
Diminution du risque d'erreurs
Possibilit de tests slectifs.
Dissimulation des mthodes
Lors de l'utilisation d'une fonction il faut seulement connatre son effet, sans devoir
s'occuper des dtails de sa ralisation.
Rutilisation d'une fonction dj existante
l est facile d'utiliser des fonctions que l'on a crites soi-mme ou qui ont t dveloppes
par d'autres personnes.
Simplicit de l'entretien

Pour Ia suite du didacticieI, nous ne parIerons que du C pour CC5X. Le fond restera valable
pour tous les langages C, mais des diffrences peuvent exister d'un langage l'autre ( obligation
de positionner les fonctions aprs main, types de donnes non compatibles .).
Page 6/17

Fonction sans paramtres

Une fonction sans paramtres raIise une suite d'oprations sans changer aucune donne
avec le reste du programme.

Structure d'une telle fonction :
void nom_de_la_fonction(void)
{
// Corps de la fonction (ensemble des instructions qui constituent
la fonction)
}

Dclaration d'une telle fonction :
void nom_de_la_fonction(void);

Utilisation de cette fonction :
instruction x;
nom_de_fonction();
instruction y;
nom_de_fonction();

L'instruction x se ralise, puis les instructions du corps de la fonction, ensuite l'instruction y, et
pour finir une nouvelle fois les instructions du corps de la fonction. Ainsi la fonction s'est ralise
deux fois, mais nous ne l'avons crite qu'une fois. Elle ne figurera en mmoire qu'une seule fois
aussi.

Exemple de programme: un compteur d'actions.
Notre nouveau programme comptera le nombre de fois que l'on a appuy sur le bouton
poussoir 1.
A chaque appui une nouvelle led s'allume. Nous aurons donc au maximum 4 actions.

La difficult vient du fait que les interrupteurs ont du rebond. C'est dire que chaque fois que l'on
appuie ou que l'on relche un bouton poussoir, l'interrupteur rebondit et le microcontrleur
comptabilise plusieurs actions. Nous allons donc crire une fonction "anti-rebond" qui sera tout
simplement une temporisation afin d'attendre que le contact s'immobilise.

Nous raliserons aussi une fonction affichage qui mettra jour les leds.

Dans le programme ci-dessous, la fonction "anti-rebond" est crite aprs la fonction qui l'appelle,
elle doit donc tre dclare avant. Ce n'est pas le cas de la fonction "affichage".

// Attention de respecter les majuscules et minuscules
//---------------------------------E/S------------------------------------------------
char sortie @ PORTB;
bit inter1 @ RA0;
bit inter2 @ RA1;
bit inter3 @ RA4;
bit inter4 @ RB5;
bit led1 @ RB0;
bit led2 @ RB1;
bit led3 @ RB2;
bit led4 @ RB3;

//-----------------------------Variables globales--------------------------------
char action; //nombre d'actions
unsigned tempo : 16; //tempo pour l'anti-rebond
Page 7/17

//-------------------------------Dclaration de fonction-------------------------
void antirebond(void);

//-------------------------------Fonction affichage-------------------------------
void affichage(void)
{
sortie=0; // affichage du nombre d'actions
if (action>0) led1=1;
}

//-------------------------------Fonction principale------------------------------
void main(void)
{
sortie = 0; // nitialisation du microcontrleur
action=0;
TRSB = 0b11110000;
for (;;) // La suite du programme s'effectue en boucle
{
if (inter1) { ++action; antirebond(); while (inter1); antirebond(); }
affichage();
}
}

//-------------------------------Fonction anti-rebond-------------------------------
void antirebond(void)
{
for (tempo=0;tempo<2000;tempo++); // anti-rebond de 20ms
}

Explications de la ligne : if (inter1) { ++action; antirebond(); while (inter1); antirebond(); }
A chaque fois que inter1 passe 1 on ralise :
incrmentation de "action" car on a une fois de plus enclench le bouton poussoir.
ralisation de "anti-rebond" pour attendre que le contact soit immobilis l'tat 1.
attente que le bouton poussoir soit relch grce l'instruction while(inter1);.
ralisation de anti-rebond pour attendre que le contact soit immobilis l'tat 0;.

Si le programme comptabilise mal, augmenter la dure de l'anti-rebond.

Page 8/17

Fonction avec paramtres d'entre

Dans une fonction avec paramtre d'entre, Ia fonction appeIe reoit une ou pIusieurs
donnes appeles "paramtres". Ces paramtres seront stocks au moment de l'appel de la
fonction dans des variables dites temporaires qui seront dtruite la fin de la ralisation de la
fonction. La notion de variable sera compltement traite dans le fascicule suivant.

Ce type de fonctionnement ne permet donc pas de modifier Ies donnes initiaIement
envoyes car une variable intermdiaire est cre. Nous parlerons alors de passage par donnes.
Pour pouvoir modifier le paramtre initial, il faudra utiliser un passage par adresse, qui ncessite
un pointeur et qui sera trait dans le didacticiel sur les tables.

Structure d'une telle fonction avec deux paramtres :
void nom_de_la_fonction(type1 nom1; type2 nom2)
{
la fonction) pouvant utiliser nom1 et nom2.
}

Le dbut de la structure est identique la fonction sans paramtres, seule la parenthse est
modifie. Le void qui signifiait "pas de paramtres" est maintenant remplac par les paramtres d'
entre et leurs types. ci le paramtre nom1 sera de type1 et le paramtre nom2 sera de type2.

Les paramtres peuvent tre de n'importe quel type (bit, char, unsigned 16, .)

void nom_de_la_fonction(type1 nom1; type2 nom2);

instruction x;
nom_de_fonction(p,q);
instruction y;
nom_de_fonction(r,s);

p, q, r, s peuvent tre un nombre, une variable. l est indispensable que p et q soient compatibles
avec type1, et que r et s soient compatibles avec type2.

Lors du premier appel, la fonction cre les variables nom1 et nom2. Elle copie ensuite p dans
nom1 et q dans nom2. Le corps de la fonction peut se raliser avec les variables nom1 et nom2
qui contiennent p et q. A la fin de la ralisation de la fonction, les variables nom1 et nom2 sont
dtruites.
Lors du deuxime appel, la fonction cre nouveau les variables nom1 et nom2, place r dans
nom1 et s dans nom2. Le corps de la fonction peut se raliser nouveau avec les variables nom1
et nom2 qui contiennent cette fois r et s. A la fin de la ralisation de la fonction, les variables nom1
et nom2 sont dtruites.
La fonction n'a t crite qu'une fois en mmoire, mais a t excute deux fois et avec des
donnes diffrentes.

Exemple de programme : un compteur de points
Quatre quipes s'affrontent et doivent chacune effectuer 5 actions.
Chaque fois qu'une quipe a ralis une action, elle appuie sur son bouton poussoir pour
incrmenter son compteur. La valeur du compteur est alors affiche sur les leds (1 led par
action).
Lorsqu'une quipe a ralis la 5
e
action, la led associe l'quipe s'allume, et le jeu est
termin.
Page 9/17

//--------------------------------------E/S---------------------------------------------
bit inter1 @ RA0;
bit inter2 @ RA1;
bit inter3 @ RA4;
bit inter4 @ RB5;
bit led1 @ RB0;
bit led2 @ RB1;
bit led3 @ RB2;
bit led4 @ RB3;

char equipe1; //point de l'quipe 1
unsigned tempo :16; //Tempo d'antirebond

void affichage(char equipe);
void antirebond(void);
void fin(char gagnant);

void main(void)
{
sortie =0; // nitialisation du microcontrleur
equipe1=0;
equipe2=0;
equipe3=0;
equipe4=0;
TRSB = 0b11110000;
for (;;) // La suite du programme s'effectue en boucle
{
if (inter1) { if (++equipe1==5) fin(1);
affichage(equipe1); // affichage des points de l'quipe 1
antirebond(); while (inter1); antirebond();}
affichage(equipe2);
antirebond(); while (inter2); antirebond();}
affichage(equipe3);
antirebond();while (inter3); antirebond();}
affichage(equipe4);
antirebond();while (inter4); antirebond();}
}
}

void affichage(char equipe)
{
sortie=0; // affichage des points
if (equipe>0) led1=1;
}

Page 10/17
{
for (tempo=0;tempo<2000;tempo++); // anti-rebond de 20ms
}

//-------------------------------Fonction fin-------------------------------
void fin(char gagnant)
{
sortie=0; // affichage du gagnant
if (gagnant==1) led1=1;
for (;;);
}

L'instruction if (++equipe1==5) fin(1); ralise les oprations suivantes:
ncrmentation de equipe1.
Comparaison de "equipe1" aprs incrmentation avec 5 pour raliser fin(1) en cas
d'galit.
Fin(1) claire la led1 afin de signaler que l'quipe 1 a gagn.
La fonction affichage est identique celle du programme prcdent la diffrence qu'on lui
fournit le nombre afficher. Nous remarquons que "equipe1", "equipe2", "equipe3", "equipe4" de
type char sont tout fait compatibles avec quipe de type char aussi.

l est possible d'utiliser comme paramtre de fonction un nom de variable dj utilis. Le
compilateur utilisera alors la dernire variable temporaire cre pour la fonction.

Exemple :
Nous allons utiliser la variable "equipe1" en tant que paramtre pour la procdure affiche.

Voici les modifications a apporter.

void affichage(char equipe1);

void affichage(char equipe1)
{
sortie=0; // affichage des points
if (equipe1>0) led1=1;
}

l pourrait y avoir ambigut avec la variable globale appele aussi "equipe1". Pourtant le
programme fonctionne de faon identique au programme initial. l a donc bien utilis la variable
temporaire dans la fonction et non pas la variable globale.
Ceci permet par exemple de crer plusieurs fonctions, qui ralisent des calculs mathmatiques
diffrents tout en utilisant des noms de paramtres identiques tels que "multiplicateur",
"multiplicande", "resultat" .

Ayez, s'il vous plat, une pense mue pour l'auteur. Les trois dernires parties ont pris une
trentaine d'heures pour tre rdiges. Si vous trouvez qu'elles ne sont pas assez claires, prenez
des pincettes pour m'en informer, je peux devenir violent.
Page 11/17

Fonction avec paramtres de sortie

Dans une fonction avec paramtres de sortie, Ia fonction appeIe retourne une donne au
programme. Cette donne est appele paramtre de sortie.

Structure d'une telle fonction sans paramtres d'entre :
type nom_de_la_fonction(void)
{
// Corps de la fonction
return donne ;
}

La structure est identique aux structures prcdentes. Le void prcdant le nom de la fonction
est maintenant remplac par le type du paramtre de sortie.

Le paramtre peut tre de n'importe quel type (bit, char, unsigned 16, .), la donne renvoyer
doit bien videmment tre compatible avec ce type.

Pour renvoyer le paramtre et mettre fin la fonction, il suffit de noter "return" suivi de la donne
que l'on veut renvoyer. Cette ligne doit obligatoirement tre la dernire de la fonction.

l est aussi possible d'avoir plusieurs lignes "return donne" dans une mme fonction. La
premire ligne rencontre met alors fin cette fonction.

La donne peut tre un nombre, une variable, un calcul.

type nom_de_la_fonction(void);

instruction x;
a = nom_de_fonction();
instruction y;

nstruction x se ralise en premier, puis les instructions de la fonction. A la fin de la ralisation de
la fonction, la donne qui constitue le paramtre de sortie est dpose dans a. Nous en sommes
la troisime ligne, nstruction y se ralise.

a est une variable compatible avec le type de paramtre de sortie.

Exemple de programme : un d lectronique
Le bouton poussoir 1 permet d'afficher de faon alatoire une led.

Nous allons alors crire une fonction qui fournira un nombre entre 1 et 4. Cette fonction sera
appele chaque fois que le bouton poussoir1 sera enclench.

//---------------------------------E/S et variable--------------------------------
bit inter1 @ RA0;
bit led1 @ RB0;
bit led2 @ RB1;
bit led3 @ RB2;
bit led4 @ RB3;
Page 12/17
char a; // variable tampon
char resultat; // chiffre afficher

//---------------------------------Fonction hasard-------------------------------
char hasard(void)
{
do {a=a+1; if (a==5) a=1;}
while (TMR0>0);
return (a);
}
void main(void)
{
sortie = 0; // nitialisation du microcontrleur
TRSB = 0b11110000;
OPTON = 0b11000111; // prdiviseur 256 entre : clock/4
for(;;) {
if (inter1)
{
resultat=hasard();
sortie=0;
if (resultat==1) led1=1;
}
}
}

La fonction "hasard" ne ncessite aucun paramtre en entre, par contre elle fournit un chiffre
entre 1 et 4. Pour obtenir ce chiffre, nous allons incrmenter une variable 'a' de 1 4 et
recommencer jusqu' ce que le timer ait atteint la valeur 0. La fonction principale rcupre cette
valeur dans "rsultat" afin d'afficher la bonne led.

Fonction avec paramtres d'entre et de sortie

Vous avez bien videmment devin comment fonctionne une telle fonction, il suffit de combiner
les paramtres d'entre et le paramtre de sortie.
Structure d'une telle fonction avec deux paramtres d'entre :
type nom_de_la_fonction(type1 nom1; type2 nom2)
{
la fonction) pouvant utiliser nom1 et nom2.
return donne ;
}

type nom_de_la_fonction(type1 nom1; type2 nom2);

instruction x;
a = nom_de_fonction(p,q);
instruction y;

Pour ce paragraphe, je ne proposerai pas d'exemple.

Page 13/17

Les interruptions

GnraIits

Ca y est, nous y sommes, nous entamons la notion qui va changer votre vie de programmateur.

Jusqu'ici, les fonctions taient appeles par le programme lui-mme. Une interruption est une
fonction qui se raIise Iorsque un vnement se produit, et non lorsque le programme le
dcide. Les vnements conduisant une interruption dpendent du microcontrleur.

Au moment de l'appel de l'interruption, le programme s'arrte. Le microcontrleur sauvegarde
l'adresse de la dernire instruction excute ainsi que les registres importants. L'excution de
l'interruption commence. A la fin de sa ralisation, les registres importants reprennent les tats
qu'ils avaient avant l'appel, le programme reprend l'endroit o il s'tait arrt.

Le PIC 16F84

Chaque microcontrleur fonctionne diffremment lors d'une interruption. De plus, chaque
langage C est diffrent face ces mmes interruptions. Nous allons donc assez rapidement
analyser le comportement du PC 16F84, et voir comment grer cette ressource avec le C que
nous utilisons depuis le dbut.

Le PC 16F84 possde 4 sources d'interruption :
Changement d'tat des pattes RB4 RB7;
Dbordement du timer (passage de 0XFF 00);
Front sur la patte NT (Cette patte est aussi la patte RB0). Le sens du front est dtermin
par certains bits du registre option;
Fin d'criture dans la EEprom du PC (partie de la mmoire qui ne s'efface pas en cas de
coupure d'alimentation).

La gestion des interruptions passe par 3 oprations:
dclaration du fichier utile la gestion des interruptions;
configuration des interruptions;
criture de l'interruption;

La dcIaration du fichier utiIe la gestion des interruptions est indispensable pour utiliser les
instructions de sauvegarde des registres important au moment de l'interruption. Elle passe par
l'criture de la ligne ci-dessous placer en dbut de fichier :
#include "int16CXX.h"

La configuration des 4 interruptions se fait l'aide de bits des registres NTCON (NTerrupt
CONfiguration) et OPTON, le plus souvent au dbut de la fonction main.
RBE (RB nterrupt Enable) : mis 1, il autorise les interruptions dues au changement
d'tat des pattes RB4 RB7.
T0E (Timer 0 nterrupt Enable) : mis 1, il autorise les interruptions dues au timer.
NTE : (NTerrupt Enable) : mis 1, il autorise les interruptions dues un front sur la patte
RB0/NT.
NTEDG : (NTerrupt EDGe) : un 1 valide les fronts montants comme source d'interruption
sur RB0/NT, un 0 valide les fronts descendants.
Page 14/17
EEE (EEprom nterrupt Enable) : un 1 valide la fin d'criture dans la EEprom comme
source d'interruption.
GE (General nterrupt Enable) : mis 1, il permet aux interruptions de s'excuter selon les
bits prcdents. Au dbut de l'interruption, ce bit est mis 0 automatiquement. A la fin de
l'interruption, ce bit est mis 1 automatiquement.

Registre INTCON
7 6 5 4 3 2 1 0
GIE EEIE T0IE INTE RBIE
Reset 0 0 0 0 0

Registre OPTION
7 6 5 4 3 2 1 0
INTEDG
Reset 1

L'criture de I'interruption est plus subtile qu'il n'y parat.
Lors de la mise sous tension du microcontrleur, le programme excute en premier l'instruction
l'adresse 0 du programme. Le compilateur place cette adresse l'instruction en assembleur "goto
main". Ce qui signifie aller la fonction "main".
Lorsqu'une interruption se produit, le microcontrleur sauvegarde son environnement et saute
l'adresse 0X4 du programme. l est donc indispensable d'crire l'interruption partir de cette
adresse, puis d'crire les autres fonctions. Ainsi les adresses 0X1, 0X2, 0X3 restent vides.

La structure prend la forme suivante :
#pragma origin 4

interrupt nom_de_l'interruption(void)
{
int_save_registers
Corps de l'interruption
int_restore_registers
}

#progma origin 4 indique au compilateur d'crire partir de l'adresse 4.
interrupt nom_de_l'interruption(void) indique que cette fonction est une interruption et lui
donne un nom.
int_save_register est une instruction qui sauvegarde l'tat des registres importants.
int_restore_registers est une instruction qui restitue l'tat des registres importants.

Le corps de l'interruption passe en premier par la dtection de la source d'interruption. Pour cela,
nous utiliserons certains bits du registre NTCON comme suit :
RBF (RB nterrupt Flag ) : mis 1 par le systme, ce bit indique un changement d'tat des
pattes RB4 RB7. Ce bit doit tre remis 0 manuellement avant la fin de l'interruption.
TOF (Timer 0 nterrupt Flag ) : mis 1 par le systme, ce bit indique un dbordement du
timer. Ce bit doit tre remis 0 manuellement avant la fin de l'interruption.
NTF (NTerrupt Flag ) : mis 1 par le systme, ce bit indique l'arrive d'un front sur la
patte RB0/NT. Ce bit doit tre remis 0 manuellement avant la fin de l'interruption.

Registre INTCON
7 6 5 4 3 2 1 0
T0IF INTF RBIF
Reset 0 0 U U = Unknown

Page 15/17

ExempIes

Notre premier exemple sera trs original puisque nous allons faire clignoter la led1 et mettre en
fonction la led 4 si le bouton poussoir 4 est enclench.

//---------------------------------E/S et variable--------------------------------
bit inter4 @ RB5;
bit led1 @ RB0;
bit led4 @ RB3;
char temps; //variable de gestion du temps gale 15 au bout d'une seconde

//--------------------------------nterruption-------------------------------------
#pragma origin 4

interrupt timer_et_RB5(void)
{
int_save_registers
if (T0F) { ++temps; // interruption timer, (65ms coules)
if (temps == 15) // si 1 seconde coule
{ led1=!led1; // cligontement de led1
temps = 0; }
T0F = 0;}
if (RBF) { led4=inter4; // changement de inter4
RBF = 0;}
int_restore_registers
}

void main(void)
{ sortie = 0; // nitialisation du microcontrleur
TRSB = 0b11110000;
TMR0 = 0;
NTCON = 0b10101000; // autorisation des interruptions par le timer et RB4 RB7
for(;;) {
nop();
}}

La deuxime ligne du fichier inclue le fichier servant aux interruptions.

La premire fonction est prcde d'une commande ordonnant au compilateur d'crire partir
de l'adresse 0X4, qui est l'adresse de saut en cas d'interruption.

La premire fonction est donc l'interruption.

Lors d'une interruption, il est ncessaire de
sauvegarder les registres importants,
tester la source d'interruption, ragir face cette source, l'autoriser nouveau,
restaurer les registres importants.

Au dbut du programme principal, le registre NTCON est positionn tel qu'il puisse y avoir une
interruption du timer ou de RB4, c'est dire de inter4.
Page 16/17

Nous allons maintenant programmer une serrure code.
Le code se compose grce aux 3 boutons poussoirs 1, 2 et 3 afin de verrouiller la porte. Le
code est 1322.
Le bouton poussoir 4 permet d'ouvrir la porte lorsqu'elle n'est pas verrouille. La LED 1
s'allume alors pendant que le bouton poussoir est enclench.
La LED4 clignote lorsque la porte n'est pas verrouille, reste rouge lorsque la porte est
verrouille.

Nous voyons clairement que pendant que l'on utilise les boutons poussoirs 1, 2 et 3, des
oprations se produisent : gestion de la porte, gestion de la LED4. Nous allons grer ces actions
par interruption. Cette gestion ressemble de plus trangement au programme prcdent.

Nous allons utiliser aussi une fonction anti-rebond pour viter les rebonds des interrupteurs et
une fonction attente qui vrifiera qu'aprs appui sur un bouton poussoir, celui-ci est bien relch,
et qui attendra qu'un nouveau bouton poussoir soit enclench.

//---------------------------------E/S------------------------------------------
bit inter1 @ RA0;
bit inter2 @ RA1;
bit inter3 @ RA4;
bit inter4 @ RB5;
bit led1 @ RB0;
bit led4 @ RB3;

bit ver; //etat de la porte 0=verrouill 1=non verrouill
unsigned tempo :16; //tempo pour l'anti-rebond
char temps; //variable de gestion du temps gale 15 au bout d'une seconde
char a; //variable tampon si ncessaire

//--------------------------------nterruption-------------------------------------
#pragma origin 4

interrupt timer_et_RB5(void)
{ int_save_registers
if (T0F) {++temps; // interruption timer, 65ms coules
if (temps == 15) // si 1 seconde coule
{ if (!ver)led1=!led1; // clignotement de led1 si non verrouillage
else led1=1; //sinon led1 est allume
temps = 0; }
T0F = 0;}
if (RBF) {if (!ver) led4=inter4; // changement de inter4, gestion de la
porte
else led4 = 0;
RBF = 0;}
int_restore_registers }

{ for (tempo=0;tempo<5000;tempo++); } // anti-rebond de 50ms

//-------------------------------Fonction attente------------------------------------
void attente(void)
Page 17/17
{ // attente que les 3 inters soient relchs puis un enclenche
antirebond();
a=0;
do {a.0=inter1; a.1=inter2; a.2=inter3;} while (a!=0); //attente que tout soit relch
antirebond();
do {a.0=inter1; a.1=inter2; a.2=inter3;} while (a==0); //attente qu'un inter soit enclench
antirebond();}

void main(void)
{ sortie = 0; // nitialisation du microcontrleur
ver = 0;
TRSB = 0b11110000;
TMR0 = 0;
NTCON = 0b10101000; // autorisation des interruptions par le timer et RB4 RB7
for(;;) {
// Recherche du code avec des if imbriqus
if (inter1){ attente();
if (inter3) { attente();
if (inter2) { attente();
if (inter2) {ver= !ver;}}}}
}}

Nous en resterons l pour les interruptions. Le prochain didacticiel vous permettra de
comprendre parfaitement la notion de variables globale, locale, de constante. Vous pourrez aussi
mettre en fonction vos quations les plus farfelues.

PIC en C - Fonctions

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PIC en C - Fonctions

Uploaded by

Copyright:

Available Formats

La programmation des PC en C

Les fonctions, les interruptions.

You might also like