PIC en C - Temps

La programmation des PC en C
La gestion du temps

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

La programmation des PC en C La gestion du temps
Page 2/19

Sommaire

Sommaire ............................................................................................................................2
ntroduction..........................................................................................................................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 3/19

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 mmoires. 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 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 4/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 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 italique.

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/19

But atteindre

Ce didacticiel vous permettra de grer Ie temps avec un PC. 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 PC 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 "deIay"

l serait intressant d'avoir des instructions qui nous permettraient de consommer du temps.
Nous allons crer les instructions suivantes:
deIay_10us(temps); temporisation de dure : temps * 10 microsecondes
deIay_ms(temps); temporisation de dure : temps * 1 milliseconde
deIay_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. l 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 utiIiser rapidement des temporisations sans connaissances sur le
fonctionnement du PC, 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 Ie 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 FiIe. 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 6/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)
{
OPTON = 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;
OPTON = 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 FiIe>Save As.

Fermer ce fichier.

Page 7/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; // nitialisation des pattes du microcontrleur
TRSB = 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();"

l existe une instruction pour les PC 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 ouvre. Elle convient parfaitement pour des petites
temporisations ( moins de 10s).
Page 8/19

La boucIe

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. l 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 boucIe simpIe

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 temps;
void main(void)
{
sortie = 0; // nitialisation des pattes du microcontroleur
TRSB = 0b11110000;

{
nop();
nop();
}
}

Page 9/19

2 - Recherche du temps mis par cette boucIe

Vrifier que l'horloge est de 4 Mhz
(voir fascicule 1)

Ouvrez la fentre
Debugger>Stopwatch

La ligne "nstruction Cycles" nous informe sur le nombre de cycle instruction
1
.
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 - RgIage finaI de Ia boucIe

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
1 cycle d'instruction correspond 4 priodes d'horloge soit ici 1s.
Page 10/19

unsigned temps : 16;
void main(void)
{
TRSB = 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
Dure avec une
variable de 8 bits
Dure avec une
variable de 16 bits
Nombre d'instructions
en assembleur
100 0.706ms 7
100 1.21ms 13
63000 630 ms 16
65000 524 ms 12

l existe des variables de 24 et 32 bits, mais elles ne sont pas disponibles avec la version
d'valuation de CC5X.

l 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 timer
2
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. l est
aussi impossible de raliser des oprations pendant la temporisation puisque le PC est en train de
traiter une boucle.

2
Ressource du PC permettant de grer le temps de faon prcise tout en effectuant d'autres oprations.
Page 11/19

Le timer

Nous arrivons au traitement de la partie la plus complexe du PC : le timer. Le timer est un
compteur de cycIes d'instructions. l suffit de lire rgulirement ce compteur pour valuer le
temps qui s'coule. l est galement possible d'initialiser ce compteur avec le nombre de notre
choix. l faut aussi noter que ce compteur doit tre configur pour fonctionner.

1 - Constitution du timer.

Le timer est constitu de :
Ie TMR0. C'est un registre de 8 bits, qui compte les front montant
3
du signal qu'on lui
fournit. Arriv 255, il repasse 0. l est accessible en lecture ou criture de la mme
faon que le PORTA, le PORTB ou les variables.
Ie prdiviseur. l 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.
Ies aiguiIIages. ls permettent de dfinir le chemin qu'emprunteront les informations (sortie
des aiguillages en B et C).
Ies bits de configuration (RTE, RTS .). ls permettent de dfinir les diffrentes fonctions.
Ia 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.

Prdiviseur
TMR0 Synchro Patte
RA4
RTE
fosc/4
RTS PS2, PS1, PS0 PSA
1
0
0
1
A
B C

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.
Cette fonction permet d'inverser les fronts montant et les
fronts descendants
4
si RTE=1.
Le signal en B dpend de l'aiguillage command par RTS.
Nous avons donc grce RTS le choix de la source
d'entre du timer.
Le signal en C dpend de l'aiguillage command par PSA.
Nous choisissons donc avec PSA d'utiliser ou non le
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
Un front montant est le passage de l'tat 0 l'tat 1 d'une entit.
4
Un front descendant est le passage de l'tat 1 l'tat 0 d'une entit.
RTE = 0 RTE = 1
A = RA4 A = !RA4
RTS = 0 RTS = 1
B = fosc/4 B = A
PSA = 0 PSA = 1
C = Prdiviseur C = B
Page 12/19

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.

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 OPTON.

Registre OPTION
7 6 5 4 3 2 1 0
RTS RTE PSA PS2 PS1 PS0
Reset
5
1 1 1 1 1 1 1 1

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 PC.
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 - UtiIisation du timer.

L'utilisation du timer est assez simple et se fait en 3 tapes.
mise jour du registre OPTION
mise jour du TMR0
Iecture 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 - ExempIes 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 OPTON 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
PS2 PS1 PS0
Taux du
prdiviseur
0 0 0 2
0 0 1 4
0 1 0 8
0 1 1 16
1 0 0 32
1 0 1 64
1 1 0 128
1 1 1 256
Page 13/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;
void main(void)
{
TRSB = 0b11110000;
OPTON = 0b11000111; //prediviseur 256 entre : clock/4
temps = 0;
TMR0 = 0;
{
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 OPTON 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. l 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 14/19
char newtmro;
void main(void)
{
TRSB = 0b11110000;
temps = 0;
newtmro = TMR0+1;
{
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;
void main(void)
{
TRSB = 0b11110000;
temps = 0;
TMR0 = 0;
etat_inters=0;
{
Page 15/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;
led1=1;
led2=1;
led3=1;
break;
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.
l 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. l 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 16/19

RcapituIatif

Le tableau ci-dessous rcapitule les utilisations classiques de chaque mthode.

nop(); boucle delay timer
timer
+
interruption
Temporisation trs courte
X

Temporisation sans le timer
X

Temporisation peu prcise,
facile mettre en ouvre

X

Temporisation prcise
X

Temporisation prcise,
accompagne de boucles longues

X

Le timer du PC 16F84 correspond la structure la plus rpandue chez les PC. l existe aussi
des timers 8 bits plus complexes, des timers 16 bits. Certains pic ont plusieurs timers. l est donc
ncessaire en fonction de la complexit de l'application raliser de choisir le pic le plus
appropri. l sera alors indispensable de bien lire la documentation du pic afin de pouvoir le
programmer.

Je vous conseille de regarder la doc du PC16F627 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 PC 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.
l est aussi possible de gnrer automatiquement grce aux deux derniers timer des signaux avec
des priodes variables, des rapports cycliques
6
variables.

6
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 17/19

Le chien de garde

On retrouve le chien de garde sous le nom watchdog timer dans toutes les documentations de
PC. Le chien de garde est utilis pour faire un reset (le programme recommence au dbut,
certaines ressources sont mises des tats dtermins) du PC. Cette fonction, premire vue
sans intrt pour un dbutant, est en ralit principale.

Dans un microcontrleur, donc un PC, 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 PC. Le chien de garde permet
un reset du PC lorsque certains dfauts apparaissent.

Le chien de garde correspond un timer particuIier.
Celui-ci est connect une horIoge interne, indpendante du quartz.
l compte en permanence et au moment du dbordement
7
, fait un reset du
microcontrIeur.
Afin d'viter Ie dbordement il est indispensable de le remettre 0 grce l'instruction
cIrwdt();.
Le temps de dbordement est typiquement de 18ms. l est possibIe d'aIIonger ce
temps en utilisant le prdiviseur du timer. Le prdiviseur n'est alors plus utilisable par le
timer.
II est aussi possibIe de dsactiver cette fonction grce un fusible accessible au
moment de la programmation.

Ci-dessous le schma du timer et du chien de garde.

Prdiviseur
TMRO Synchro Patte
RA4
RTE
fosc/4
RTS PS2, PS1, PS0 PSA
1
0
0
1
A
B C
PSA
0
1
PSA
1
0
Chien de
garde
WDT
Fusible de validation du
chien de garde
gnration
du
reset
dbordement

7
Passage de FF 0 du chien de garde.
Page 18/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).

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;
void main(void)
{
TRSB = 0b11110000;
temps = 0;
newtmro = TMR0+1;
{
clrwdt();
if (TMR0 == newtmro) { ++temps; ++newtmro; } // 64ms sont passs
if (temps == 15625) {
led1=!led1; temps = 0; } // 1 seconde est pass
}
}

PS2 PS1 PS0
Taux du
prdiviseur
0 0 0 1
0 0 1 2
0 1 0 4
0 1 1 8
1 0 0 16
1 0 1 32
1 1 0 64
1 1 1 128
Page 19/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.

l 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 PC il est obligatoire
d'autoriser le watchdog timer. Pour cela,
avant de lancer la programmation, validez la
coche "WDT".

Tester votre PC sur la platine LAB.

ConcIusion

Avec ce quatrime didacticiel, vous tes enfin capable de parfaitement grer le temps. Vous
pouvez maintenant concevoir n'importe quel programme. avec un PC 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.

PIC en C - Temps

Transféré par

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

PIC en C - Temps

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

PIC en C - Temps

Transféré par

Droits d'auteur :

Formats disponibles

La programmation des PC en C

Vous aimerez peut-être aussi

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.