La Programmation Des PIC en C (Le Temp D'horloge) PDF

La programmation des PIC en C
La gestion du temps
Ralisation : HOLLARD Herv.

http://electronique-facile.com
Date
: 26 aot 2004
Rvision
: 1.2
La programmation des PIC en C La gestion du temps
Sommaire
Sommaire ............................................................................................................................ 2
Introduction .......................................................................................................................... 3
Structure de ce document .................................................................................................... 4
Le matriel ncessaire ......................................................................................................... 4
La platine d'essai ................................................................................................................. 4
But atteindre ..................................................................................................................... 5
L'instruction "delay" .............................................................................................................. 5
Le "nop();" ............................................................................................................................ 7
La boucle ............................................................................................................................. 8
Le timer .............................................................................................................................. 11
Rcapitulatif ....................................................................................................................... 16
Le chien de garde .............................................................................................................. 17
Conclusion ......................................................................................................................... 19
Page 2/19
Introduction
Les microcontrleurs PIC 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 PIC 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 MICROCHIP
http://www.microchip.com
Logiciel de programmation des composants:
IC-PROG de Bonny Gijzen
http://www.ic-prog.com
Programmateur de composants:
PROPIC2 d'Octavio Noguera voir notre site http://electronique-facile.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://abcelectronique.com/bigonoff.
Les fonctions que nous demandons de raliser nos PIC sont de plus en plus complexes, les
programmes pour les raliser demandent de plus en plus de mmoires. L'utilisateur est ainsi la
recherche de langages "volus" pouvant simplifier la tche de programmation.
Depuis l'ouverture du site http://electronique-facile.com, le nombre de questions sur la
programmation des PIC en C est en constante augmentation. Il 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 PIC, m'a naturellement amen l'criture de ce
didacticiel. Celui-ci se veut accessible 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 quatrime fascicule vous permettra de raliser n'importe quelle application, sera la fin de
"l'apprentissage indispensable". Tous ce qui suivra vous permettra uniquement de programmer
plus rapidement et de faon plus structure.
Page 3/19
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 les termes importants.
Vous trouverez la dfinition de chaque terme nouveau en bas de la page o apparat pour la
premire fois ce terme. Le terme est alors en italique.
La couleur bleue est utilise pour vous indiquer que ce texte est taper exactement sous cette
forme.
La couleur rouge indique des commandes informatiques utiliser.
Le matriel ncessaire
Les deux logiciels utiliss lors du premier fascicule.
Un programmateur de PIC comprenant un logiciel et une carte de programmation. Vous
trouverez tout ceci sur notre site.
Un PIC 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 platine 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.
Il est ainsi ncessaire de raliser sur une platine
de type LAB, par exemple, le montage ci-contre.
Page 4/19
But atteindre
Ce didacticiel vous permettra de grer le temps avec un PIC. Nous verrons 3 niveaux de
gestion.
Le premier niveau nous permettra de consommer du temps grce l'instruction nop et aux
boucles.
Le deuxime niveau nous obligera comprendre de faon dtaille comment fonctionne la
partie matrielle du PIC destine la gestion du temps afin de crer des temporisations
prcises.
Le troisime niveau nous montrera comment grer le temps tout en effectuant d'autres
oprations.
Pour atteindre ces buts, nous utiliserons comme dans les autres didacticiels la platine d'essai de
la page 4.
Avant tout a, afin de rapidement mettre en pratique des temporisations, nous allons crire un
petit programme, qui nous permettra d'utiliser une instruction trs apprciable : l'instruction "delay".
L'instruction "delay"
Il serait intressant d'avoir des instructions qui nous permettraient de consommer du temps.
Nous allons crer les instructions suivantes:
delay_10us(temps);
temporisation de dure : temps * 10 microsecondes
delay_ms(temps);
temporisation de dure : temps * 1 milliseconde
delay_10ms(temps);
temporisation de dure : temps * 10 millisecondes
avec temps : entier entre 1 et 255.
Nous allons crire un fichier contenant 3 fonctions correspondantes aux 3 instructions
prcdentes. Il suffira de dclarer le nom de ce fichier en dbut de programme pour pouvoir utiliser
ces 3 instructions.
Ne cherchez pas encore comprendre comment est construit ce fichier. Le but de ce chapitre
est de pouvoir utiliser rapidement des temporisations sans connaissances sur le
fonctionnement du PIC, sur les fonctions.
En allant plus loin dans ce fascicule, vous pourrez comprendre le corps des 3 procdures; leur
forme vous sera accessible avec le prochain didacticiel.
1 -Cration du fichier contenant le code des instructions

Nous allons crer un fichier dans lequel nous allons mettre le code correspondant la rsolution
des 3 nouvelles instructions.
Dans MPLAB, cliquez sur New du menu File. Tapez le texte suivant dans la nouvelle
fentre cre.
/*
delay_10us (char) : delay en multiple de 10 us pour un quartz de 4 MHz
delay_ms (char) : delay en ms pour un quartz de 4 MHz
delay_10ms (char) : delay en multiple de 10 ms pour un quartz de 4 MHz
*/
//--------------------------delay en multiple de 10 us. Quartz de 4 MHz -----------------
Page 5/19

void delay_10us (char usecs)
{
while (-- usecs > 0)
{
clrwdt();
// only if necessary, nop(); a la place
nop();
nop();
nop();
nop();
}
}
//--------------------------delay en multiple de ms. Quartz de 4 MHz ----------------void delay_ms (char millisec)
{
OPTION = 2;
// prescaler divide by 8
do
{
TMR0 = 0;
clrwdt();
// only if necessary
while (TMR0 < 125);
// 125us * 8 =1000us
}
while (-- millisec > 0);
}
//-----------------delay en multiple de 10ms. Quartz de 4 MHz, erreur 0.16 %-------------void delay_10ms (char n)
{
char i;
OPTION = 7;
//prescaler to 256
do
{
clrwdt();
// only if necessary
i =TMR0 +39;
// 256us * 39 =10 ms
while (i != TMR0);
}
while (--n > 0);
}
Sauvegarder ce fichier grce
la commande File>Save As
Fermer ce fichier.
Page 6/19
2 - Cration du programme
Nous allons maintenant crire un programme qui nous permettra de faire clignoter la led1 avec
une priode de 2 secondes (1seconde allume et une seconde teinte).
Tapez le texte suivant dans le fichier clignotement.C
// Attention de respecter les majuscules et minuscules
// ------------------------------Dclaration de fichier externes-------------#include "delay.c"
// dclaration du fichier contenant les temporisations
//---------------------------------E/S----------------------------------------------char sortie @ PORTB;
bit led1 @ RB0;
//------------------------------Variables generales------------------------------char etat_inters;
char a;
//-------------------------------Fonction principale-----------------------------void main(void)
{
sortie = 0;
// Initialisation des pattes du microcontrleur
TRISB = 0b11110000;
for (;;) // La suite du programme s'effectue en boucle
{
led1=!led1;
delay_10ms(100);
}
}
Essayez ce programme avec la platine d'essai
L'intrt de cette mthode est de pouvoir utiliser une instruction simple pour effectuer une
temporisation. L'inconvnient est le manque de prcision de la temporisation, ainsi que
l'impossibilit de raliser une opration pendant la temporisation.
Le "nop();"
Il existe une instruction pour les PIC qui consomme 4 priodes d'oscillation du quartz. Pour notre
platine d'essai avec un quartz de 4Mhz, cette instruction consomme donc 1s.
En C, il suffit d'crire nop ();
Ex : temporisation de 3s
nop();
nop();
nop();
Cette mthode est la plus simple mettre en uvre. Elle convient parfaitement pour des petites
temporisations ( moins de 10s).
Page 7/19
La boucle
Pour raliser une temporisation un peu plus longue, le plus simple est de raliser une itration
avec rien, un ou plusieurs "nop();" comme corps de la boucle. C'est cette mthode qui a t
utilise pour la cration de l'instruction "delay_10us( );"
Attention : la boucle elle-mme prend du temps se raliser. Il y a ainsi trois tapes pour utiliser
cette mthode:
1 - criture d'une boucle simple ;
2 - recherche du temps mis par cette boucle ;
3 rglage final de la boucle.
Nous allons chercher raliser une boucle d'une dure approximative de 1ms. Pour cela, nous
allons raliser les 3 tapes prcdentes.
1 - Ecriture d'une boucle simple
La boucle la plus simple crire en C est :
for (temps=0;temps<100;temps++) ;
Le corps de la boucle est vide, car il n'y a rien avant le point virgule. Cette boucle ne va donc rien
faire d'autre qu'incrmenter la variable temps de 0 jusqu' 100.
Ecrire le programme suivant qui est constitu d'un "nop();", d'une boucle de dure encore
inconnue, puis d'un autre "nop();"
//---------------------------------E/S et variables generales--------------------char sortie @ PORTB;
char temps;
{
sortie = 0;
// Initialisation des pattes du microcontroleur
TRISB = 0b11110000;
{
nop();
nop();
}
}
Page 8/19
2 - Recherche du temps mis par cette boucle
Vrifier que l'horloge est de 4 Mhz

(voir fascicule 1)
Ouvrez la fentre
Debugger>Stopwatch
La ligne "Instruction Cycles" nous informe sur le nombre de cycle instruction1.

La ligne "Time (usecs) nous informe sur l'coulement du temps en micro-seconde.
La colonne Total simulated nous informe sur le nombre de cycles d'instruction et le temps pass
depuis le dbut du programme.
La colonne Stopwatch nous informe sur le nombre de cycles d'instruction et le temps pass depuis
la dernire action sur le bouton "Zero"
Cliquez sur l'icne "Build", puis sur l'icne "Reset".
Faites un Run to cursor sur la boucle " for (temps=0;temps<100;temps++) ;"
La fentre Stopwatch vous indique alors que 8 s s'est coul depuis le dbut du
programme.
Cliquez sur le bouton Zero de la fentre stopwatch afin de remettre 0 la colonne
Stopwatch.
Faites un Run to cursor sur le deuxime "nop();"
La fentre stopwatch nous indique que 70s s'est coul pour la ralisation de la boucle.
Nous avons donc une temporisation de 706s.
3 - Rglage final de la boucle
Nous recherchons une temporisation de 1ms, remplaons la limite suprieure de 100 par le
nombre 140. Nous obtenons alors une temporisation de 986 s, notre but est atteint.
Cette mthode ne nous permet pas de dpasser quelques milli-secondes car nous sommes
limits pour la borne suprieure par le nombre 255. En effet, la variable temps est de type char.
Nous allons modifier notre type de variable et choisir un type de 16 bits. Ainsi notre variable temps
pourra aller jusqu' 65535. Les diffrentes variables seront traites dans le volume 6.
Le programme ci-dessous est constitu d'une boucle possdant comme limite suprieure le
nombre 60000.
1 cycle d'instruction correspond 4 priodes d'horloge soit ici 1s.
Page 9/19

unsigned temps : 16;
{
sortie = 0;
TRISB = 0b11110000;
{
nop();
nop();
}
}
Notre nouvelle temporisation fait maintenant 600ms.
Attention : il est difficile de prvoir la dure de ralisation d'une mthode de boucle, car la dure
dpend du code final en assembleur et ce code final dpend du type de variable, des bornes de la
boucle. Avec une borne suprieure trs grande, on peut avoir une temporisation plus courte
qu'avec une borne suprieure petite. Observez le tableau pour vous en convaincre.
Borne suprieure de la
boucle
100
100
63000
65000
Dure avec une

variable de 8 bits
0.706ms
Dure avec une

variable de 16 bits
1.21ms
630 ms
524 ms
Nombre d'instructions
en assembleur
7
13
16
12
Il existe des variables de 24 et 32 bits, mais elles ne sont pas disponibles avec la version
d'valuation de CC5X.
Il est possible d'augmenter la dure d'une boucle en ajoutant des nop(); dans le corps de boucle.
La boucle for (temps=0;temps<63000;temps++) {nop(); nop(); nop(); nop(); nop();} dure 945ms.
Pour finir, crez un programme qui permettra de faire clignoter la led 1 avec une priode
d'approximativement 1 seconde (0.5 seconde allum, 0.5 seconde teinte). Je ne donne pas la
solution, vous de vous dbrouiller.
L'intrt de cette mthode est de ne pas utiliser le timer2 afin de le rserver pour d'autres
oprations plus critiques.
L'inconvnient est qu'il est difficile d'obtenir des temporisations prcises, longues. De plus,
chaque temporisation prend de la place en mmoire, contrairement l'utilisation du timer. Il est
aussi impossible de raliser des oprations pendant la temporisation puisque le PIC est en train de
traiter une boucle.
Ressource du PIC permettant de grer le temps de faon prcise tout en effectuant d'autres oprations.
Page 10/19
Le timer
Nous arrivons au traitement de la partie la plus complexe du PIC : le timer. Le timer est un
compteur de cycles d'instructions. Il suffit de lire rgulirement ce compteur pour valuer le
temps qui s'coule. Il est galement possible d'initialiser ce compteur avec le nombre de notre
choix. Il faut aussi noter que ce compteur doit tre configur pour fonctionner.
1 - Constitution du timer.
Le timer est constitu de :
le TMR0. C'est un registre de 8 bits, qui compte les front montant3 du signal qu'on lui
fournit. Arriv 255, il repasse 0. Il est accessible en lecture ou criture de la mme
faon que le PORTA, le PORTB ou les variables.
le prdiviseur. Il divise la frquence du signal qu'on lui fournit par une constante qu'il est
ncessaire de programmer. Ex : un signal de priode 1us divis par 32 donnera un signal
de priode 32s.
les aiguillages. Ils permettent de dfinir le chemin qu'emprunteront les informations (sortie
des aiguillages en B et C).
les bits de configuration (RTE, RTS ). Ils permettent de dfinir les diffrentes fonctions.
la synchro. Retarde le dbut du fonctionnement de 2 cycles d'instruction lorsqu'un bit
relatif au timer est modifi. Cette fonction est due l'architecture du timer et ne peut tre
contourne.
Voici le schma du timer. Pas d'affolement, nous allons l'expliquer.
fosc/4
Patte
RA4
Synchro
TMR0
Prdiviseur
A
RTE
RTS
PS2, PS1, PS0
PSA
A gauche, sont notes les entres du timer. Elles sont au nombre de deux : le signal du
quartz divis par 4 (soit un signal de priode 1us) et la patte RA4.
L'entre RA4 attaque une porte "ou exclusif" qui fournit en A un signal dpendant du bit
RTE selon le tableau ci-contre.
RTE = 0
RTE = 1
Cette fonction permet d'inverser les fronts montant et les
A = RA4
A = !RA4
fronts descendants4 si RTE=1.
Le signal en B dpend de l'aiguillage command par RTS.
RTS = 0
RTS = 1
Nous avons donc grce RTS le choix de la source
B = fosc/4
B=A
d'entre du timer.
Le signal en C dpend de l'aiguillage command par PSA.
PSA = 0
PSA = 1
Nous choisissons donc avec PSA d'utiliser ou non le C = Prdiviseur
C=B
prdiviseur.
Le prdiviseur divise la frquence du signal prsente en B par un nombre calcul grce
PS2, PS1, PS0. et donn dans le tableau page suivante.
La synchro retarde de 2 cycles d'instruction le dbut du comptage.
TMR0 compte les fronts montants.
3
4
Un front montant est le passage de l'tat 0 l'tat 1 d'une entit.

Un front descendant est le passage de l'tat 1 l'tat 0 d'une entit.
Page 11/19

PS2
PS1
PS0
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Ex : En positionnant PS2, PS1 et PS0 1,

le taux de prdivision est de 256. Un signal en
entre du prdiviseur de priode 1s,
donnera en sortie un signal de priode 256
s.
Taux du
prdiviseur
2
4
8
16
32
64
128
256
2 - Configuration du timer
La configuration du timer se fait par la configuration des bits vus prcdemment. Ces bits sont
accessibles par le registre appel OPTION.
Registre OPTION
7
6
5
Reset
5
RTS
4
RTE
3
PSA
2
PS2
1
PS1
0
PS0
Remarques :
Les fonctions des deux bits de gauche de ce registre ne sont pas donnes. Ces deux bits
sont utiliss pour d'autres ressources du PIC.
Les tats du registre option sont donns lors du reset (ligne Reset). Dans cette
configuration, TMR0 compte les fronts descendants de la patte RA4.
3 - Utilisation du timer.
L'utilisation du timer est assez simple et se fait en 3 tapes.
mise jour du registre OPTION
mise jour du TMR0
lecture du TMR0
Remarques :
A chaque mise jour du registre TMR0 ou d'un bit de configuration, 2 cycles d'instructions
sont ncessaires avant le commencement du comptage.
La lecture d'un bit par contre ne perturbe pas le comptage.
4 Exemples de programmes.
Notre premier exemple sera trs original puisque nous allons faire clignoter la led 1 avec une
priode de 2 secondes (1 seconde allume, 1 seconde teinte).
Nous configurerons le timer de la faon suivante :
source : fosc/4
prdiviseur : 256.
Avec une horloge de 4Mhz, TMR0 s'incrmentera toutes les 256s. Pour obtenir cette
configuration, nous mettrons le registre OPTION 0b11000111 (le bit 4 peut tre indiffremment
positionn 0 ou 1. Les bits 6 et 7 sont laisss leur tat au reset).
Pour raliser notre temporisation de 1 seconde, nous allons :
attendre que le registre TMR0 initialement 0 atteigne 250 (il se sera donc coul
256s*250 = 64 ms) pour incrmenter une variable temps initialement 0.
5
Mise sous tension du pic ou action sur la patte MCLR
Page 12/19

attendre que la variable temps atteigne 16 ( il se sera coul 64ms * 16 = 1.024 seconde).
mettre jour la led 1.

bit led1 @ RB0;
char temps;
{
sortie = 0;
TRISB = 0b11110000;
OPTION = 0b11000111;
//prediviseur 256 entre : clock/4
temps = 0;
TMR0 = 0;
for (;;)
// La suite du programme s'effectue en boucle
{
if (TMR0 == 250) { ++temps; TMR0 = 0; }
// 64ms sont passes
if (temps == 16) { led1=!led1; temps = 0; }
// 1,024 seconde est passe
}
}
Je vous laisse tester et comprendre compltement ce programme.
Si vous voulez observer la temporisation avec la fentre stopwatch et les "run to cursor", il faudra
crire le dernier if de la faon suivante : if (temps == 16) {
led1=!led1; temps = 0; }
et faire un 'run to cursor' sur la deuxime ligne. En effet, l'criture sur une ligne provoque l'arrt de
la simulation chaque excution du if, soit 16 fois par seconde.
Voici une deuxime configuration du timer qui va rpondre au mme clignotement sans aucune
erreur sur la temporisation. Nous configurerons le timer de la faon suivante :
source du timer :fosc/4;
prdiviseur : 64.
Avec une horloge de 4Mhz, TMR0 s'incrmentera toutes les 64s. Pour obtenir cette
configuration, nous mettrons le registre OPTION 0b11000101 (le bit 4 peut tre indiffremment
positionn 0 ou 1. Les bits 6 et 7 sont laisss leur tat au reset).
Pour raliser notre temporisation de 1 seconde, nous allons :
incrmenter une variable temps chaque incrmentation du TMR0 (donc toutes les 64s);
attendre que la variable temps atteigne 15625. Il se sera coul exactement 1 seconde;
mettre jour la led 1.
Afin d'viter une quelconque erreur, il ne faudra jamais mettre jour TMR0 ou un bit de
configuration (voir le problme de la fonction synchro).
Nous avons donc besoin d'une variable temps de 16 bits et d'une autre variable afin de dtecter
l'incrmentation de TMR0.Nous l'appellerons newtmro.

bit led1 @ RB0;
Page 13/19

char newtmro;
{
sortie = 0;
TRISB = 0b11110000;
OPTION = 0b11000101;
temps = 0;
newtmro = TMR0+1;
for (;;)
{
if (TMR0 == newtmro) { ++temps; ++newtmro; }
// 64us sont passes
if (temps == 15625) {led1=!led1; temps = 0; }
// 1 seconde est passe
}
}
Je vous laisse tester et comprendre compltement ce programme.
Voici un dernier exemple qui met en avant l'intrt du timer sur la fonction delay.
Le bouton poussoir 1 allume la led 1 et teint les autres.
Le bouton poussoir 2 allume la led 2 et teint les autres.
Le bouton poussoir 3 allume les leds 1, 2 et 3.
Le bouton poussoir 4 teint les leds. 1, 2 et 3.
Dans le cas o aucun ou plusieurs interrupteurs sont actionns, rien ne se produit.
La led 4 clignote avec une priode de 2 secondes.
Nous avons donc le clignotement de la led 4 en mme temps que d'autres actions.
Voici le programme correspondant.
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 generales-------------------------------char etat_inters;
char temps;
{
sortie = 0;
TRISB = 0b11110000;
OPTION = 0b11000111; //prediviseur 256 entre : clock/4
temps = 0;
TMR0 = 0;
etat_inters=0;
{
Page 14/19

etat_inters.0=inter1; // Mise de l'etat des inter dans la variable etat_inters
etat_inters.1=inter2;
switch (etat_inters){
case 1:
//action sur inter1 uniquement
led1=1;
led2=0;
led3=0;
break;
case 2:
// action sur inter2 uniquement
led2=1;
led1=0;
led3=0;
break;
case 4:
led1=1;
led2=1;
led3=1;
break;
case 8:
led1=0;
led2=0;
led3=0;
break;
}
if (TMR0 == 250) { ++temps; TMR0 = 0; }
// 64ms sont passs
if (temps == 16) { led4=!led4; temps = 0; }
// 1,024 seconde est pass
}
}
Pour raliser un programme avec cette mthode, il faut faire attention plusieurs choses.
Le programme doit obligatoirement excuter la ligne if (TMR0 == rgulirement.
Il est donc interdit d'utiliser une boucle longue.
La dure maximale de scrutation de tout le programme autorise est de 64 ms. En effet,
toutes les 64 ms, il est indispensable de raliser la ligne if (TMR0 == . La prcision de la
temporisation est donc ici au minimum de 64 ms.
Reprenez maintenant le code correspondant la rsolution des 3 instructions delay en dbut du
fascicule. Vous tes enfin capable de le comprendre. Nous aborderons l'instruction clrwdt(); un
peu plus loin.
L'intrt du timer est d'tre prcis, de permettre d'effectuer des oprations pendant la
temporisation. Son inconvnient est d'tre difficile programmer, ncessite la ralisation de
comparaison rgulirement pendant le programme. Il rend donc difficile l'utilisation de boucle
longue. Pour palier au dernier inconvnient, il sera ncessaire d'avoir recours aux interruptions,
notion qui sera aborde dans le prochain fascicule.
Page 15/19
Rcapitulatif
Le tableau ci-dessous rcapitule les utilisations classiques de chaque mthode.
nop();
Temporisation trs courte
Temporisation sans le timer
Temporisation peu prcise,

facile mettre en uvre
Temporisation prcise
Temporisation prcise,
accompagne de boucles longues
boucle
delay
timer
timer
+
interruption
X
X
X
X
X
Le timer du PIC 16F84 correspond la structure la plus rpandue chez les PIC. Il existe aussi
des timers 8 bits plus complexes, des timers 16 bits. Certains pic ont plusieurs timers. Il est donc
ncessaire en fonction de la complexit de l'application raliser de choisir le pic le plus
appropri. Il sera alors indispensable de bien lire la documentation du pic afin de pouvoir le
programmer.
Je vous conseille de regarder la doc du PIC16F627 ou 16F628. Ces deux pic sont compatibles
broche broche avec le 16F84, les programmes du 16F84 sont utilisables directement avec les
16F627 et 16F628 condition de rajouter une instruction supplmentaire en dbut de programme
de faon dsactiver la ressource appele "comparateurs analogiques".
L'avantage de ces PIC est de possder un timer 8 bits pour les petites temporisations, un timer
16 bits pour les longues temporisations, un timer 8 bits complexes pour des horloges particulires.
Il est aussi possible de gnrer automatiquement grce aux deux derniers timer des signaux avec
des priodes variables, des rapports cycliques6 variables.
Temps l'tat haut divis par la priode (permet de quantifier combien de temps le signal reste l'tat haut
pendant la dure d'une priode).
Page 16/19
Le chien de garde
On retrouve le chien de garde sous le nom watchdog timer dans toutes les documentations de
PIC. Le chien de garde est utilis pour faire un reset (le programme recommence au dbut,
certaines ressources sont mises des tats dtermins) du PIC. Cette fonction, premire vue
sans intrt pour un dbutant, est en ralit principale.
Dans un microcontrleur, donc un PIC, les causes de dysfonctionnement d'un programme sont
nombreuses mme lorsque celui-ci est sans erreur :
coupure courte d'alimentation modifiant un registre,
champs lectromagntique modifiant un registre,
action imprvue sur la patte reset (cause mcanique lectromagntique),
choc mcanique, modifiant un registre,
surtension due la mise en fonction d'un appareil proche, d'un composant
Vous savez bien que lorsqu'un appareil lectronique ne fonctionne pas correctement, il suffit de
le dbrancher, puis de le remettre en fonction pour obtenir le fonctionnement attendu. Personne ne
s'explique le disfonctionnement, et bien il en est de mme pour les PIC. Le chien de garde permet
un reset du PIC lorsque certains dfauts apparaissent.
Le chien de garde correspond un timer particulier.
Celui-ci est connect une horloge interne, indpendante du quartz.
Il compte en permanence et au moment du dbordement7, fait un reset du
microcontrleur.
Afin d'viter le dbordement il est indispensable de le remettre 0 grce l'instruction
clrwdt();.
Le temps de dbordement est typiquement de 18ms. Il est possible d'allonger ce
temps en utilisant le prdiviseur du timer. Le prdiviseur n'est alors plus utilisable par le
timer.
Il est aussi possible de dsactiver cette fonction grce un fusible accessible au
moment de la programmation.
Ci-dessous le schma du timer et du chien de garde.
fosc/4
Patte
RA4
Synchro
TMRO
0
0
Prdiviseur
A
1
RTE
RTS
PSA
PS2, PS1, PS0
PSA
1
Chien de
garde
WDT
Fusible de validation du
chien de garde
7
dbordement
gnration
du
reset
PSA
Passage de FF 0 du chien de garde.
Page 17/19

Le bit PSA dtermine si le prdiviseur est affect au timer ou au chien de garde
PSA = 0, le prdiviseur est utilis pour le timer, le chien de garde gnre un reset au bout
de 18ms.
PSA = 1, le prdiviseur est affect au chien de garde, le taux de prdivision est donn dans
le tableau ci-dessous (diffrent du taux pour l'affectation au timer).
PS2
PS1
PS0
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Taux du
prdiviseur
1
2
4
8
16
32
64
128
Reprenez maintenant le code correspondant la rsolution des 3 instructions delay en dbut du

fascicule. Vous pouvez maintenant comprendre l'utilit des instructions clrwdt();
L'exemple ci-dessous est identique celui permettant le clignotement de la led 1 avec une
priode exacte de 1 seconde, plus l'utilisation du chien de garde en scurit. Si pour une raison
inexplique l'instruction clrwdt(); ne se ralise pas toutes les 18ms au maximum, le programme
recommence 0.
bit led1 @ RB0;
char newtmro;
{
sortie = 0;
TRISB = 0b11110000;
OPTION = 0b11000101;
temps = 0;
newtmro = TMR0+1;
for (;;)
{
clrwdt();
if (TMR0 == newtmro) { ++temps; ++newtmro; }
// 64us sont passs
if (temps == 15625) {
led1=!led1; temps = 0; }
// 1 seconde est pass
}
}
Page 18/19

Tapez ce programme sous MPLAB.
Ouvrez la fentre Configure>Configuration Bits.
Mettre watchdog Timer 'on' pour la simulation.
Simuler ce programme, la led1 clignote.
Enlevez l'instruction clrwdt();
Compiler, faites un run to cursor sur la ligne led1=!led1; temps = 0; }.La simulation n'arrive
jamais sur cette ligne puisque toutes les 18ms le chien de garde dborde.
Il est possible d'arrter la simulation au moment
du dbordement du chien de garde. Pour cela
ouvrez la fentre Debugger>Settings, cliquez
sur l'onglet Break Options et configurez comme
ci-contre.
Simuler votre programme. Celui-ci s'arrte au
moment du dbordement, donc au bout de
18ms.
Rajoutez l'instruction clrwdt();

Pour programmer le PIC il est obligatoire
d'autoriser le watchdog timer. Pour cela,
avant de lancer la programmation, validez la
coche "WDT".
Tester votre PIC sur la platine LAB.
Conclusion
Avec ce quatrime didacticiel, vous tes enfin capable de parfaitement grer le temps. Vous
pouvez maintenant concevoir n'importe quel programme. avec un PIC 16F84.
Afin de programmer efficacement, il vous manque toutefois quelques notions. La notion de
fonction, primordiale en C, sera aborde dans le prochain fascicule. Nous verrons aussi comment
gnrer des interruptions afin d'utiliser, entre autres, le plus efficacement possible le timer.
Page 19/19

La Programmation Des PIC en C (Le Temp D'horloge) PDF

Transféré par

Droits d'auteur :

Formats disponibles

La Programmation Des PIC en C (Le Temp D'horloge) PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

La Programmation Des PIC en C (Le Temp D'horloge) PDF

Transféré par

Droits d'auteur :

Formats disponibles

La programmation des PIC en C

Ralisation : HOLLARD Herv.

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

Pour la programmation en assembleur, beaucoup de routines sont dj crites, des didacticiels

Mon exprience dans le domaine de la programmation en C due en partie mon mtier

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

1 -Cration du fichier contenant le code des instructions

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

2 - Recherche du temps mis par cette boucle

Vrifier que l'horloge est de 4 Mhz

La ligne "Instruction Cycles" nous informe sur le nombre de cycle instruction1.

1 cycle d'instruction correspond 4 priodes d'horloge soit ici 1s.

La programmation des PIC en C La gestion du temps

Dure avec une

Dure avec une

La programmation des PIC en C La gestion du temps

PS2, PS1, PS0

Un front montant est le passage de l'tat 0 l'tat 1 d'une entit.

La programmation des PIC en C La gestion du temps

Ex : En positionnant PS2, PS1 et PS0 1,

Mise sous tension du pic ou action sur la patte MCLR

La programmation des PIC en C La gestion du temps

// Attention de respecter les majuscules et minuscules

// Attention de respecter les majuscules et minuscules

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

La programmation des PIC en C La gestion du temps

Temporisation trs courte

Temporisation sans le timer

Temporisation peu prcise,

La programmation des PIC en C La gestion du temps

PS2, PS1, PS0

Passage de FF 0 du chien de garde.

La programmation des PIC en C La gestion du temps

Reprenez maintenant le code correspondant la rsolution des 3 instructions delay en dbut du

La programmation des PIC en C La gestion du temps

Rajoutez l'instruction clrwdt();

Vous aimerez peut-être aussi