CHAPITRE V LES TIMERS

1-Définition
Un timer est un compteur de temps écoulé, il peut être utilisé pour :

▪ Mesurer le temps entre différents évènements

▪ Réaliser des temporisations précises
▪ Générer des signaux ayant des fréquences et rapports cycliques différents
▪ Générer des interruptions périodiques
▪ Réaliser des références de temps.
▪ ….

2-Principe de fonctionnement
Un timer est un compteur n bit (n=8 ou 16 bit) préchargeables dont l’horloge (l’unité de comptage) peut
être :

▪ Dérivée de l’horloge interne

▪ Fournie par un signal externe
▪ Fournie par un oscillateur interne spécifique

Deux techniques sont utilisées dans la conception des timers :

a) Timer utilisant le débordement pour détecter la fin de comptage

HORLOGE

PREDIVISEUR (Nps) TIMER

FREQUENCE: Fcy FREQUENCE: Fcy/Nps

PERIODE: Tcy PERIODE: Np*Tcy

Figure IV-5 : principe de fonctionnement d’un timer par débordement

DRIHMI F. Cours Microcontrôleurs Page 49

 Le bloc timer est un registre compteur pré-chargeable (avec une valeur initiale) et
pouvant s’incrémenter à chaque coup d’horloge à son entrée, il déborde (overflow) lorsqu’il
atteint la valeur maximale (2n-1).
Le bloc pré-diviseur est un compteur programmable capable de diviser la fréquence du signal
d’horloge à son entrée par un coefficient Nps choisi, permettant ainsi d’atteindre des
temporisations plus grandes.
La temporisation est donnée par l’équation suivante :
Temporisation = (2n- valeur initiale) Nps.Tcycle
Avec :
Nps : valeur de pré-division
Valeur initiale : valeur pré-chargée
n : largeur du compteur (8 ou 16)
Tcycle : période de l’horloge (à l’entrée du prédiviseur).

b) Timer utilisant la comparaison pour détecter la fin de conversion

Fcy Fcy/Nps Remise à zéro

Prédiviseur : 1/Nps
Horloge (prescaler) Nps.Tcy
Timer
Tcy

comparateur
Bit de flag
0 1

Registre période (PR)

Dans ce cas, le registre période (period register :PR) contient la période numérique qu’on
désire avoir, le timer commence le comptage des périodes (Nps.T) obtenues par division de la
fréquence F par Nps au niveau du prescaler (prédiviseur) ; lorsque le timer atteint la valeur PR,
cette égalité est détectée par le comparateur qui remet ainsi le timer à zéro et fait passer le bit
de flag associé au timer de zéro à 1.
La temporisation est donnée par l’équation suivante :
Temporisation = (1+PR) Nps .Tcy

3-Cas du timer0
Le timer0 est un timer généraliste 8/16 bit. Il utilise la technique de détection du
débordement; la maîtrise de sa programmation rend la manipulation des autres timers (1 et 3)
assez facile. Il peut fonctionner aussi bien en timer (compteur de temps écoulé) qu’en compteur
(compteur d’évènement). En mode timer, il s’incrémente à chaque coup d’horloge à son entrée
(entrée du compteur) ; en mode compteur, il s’incrémente à front sur la broche RA4/T0CKI
(front montant ou descendant selon le choix).

DRIHMI F. Cours Microcontrôleurs Page 50

a-Schémas fonctionnels

La figure ci-après donne le schéma bloc du TIMER0 dans ses deux modes : 8bits et 16bits.

FIGURE 11-1: TIMER0 BLOCK DIAGRAM (8-BIT MODE)

FOSC/4 0
0
Sync with Set
1 Internal TMR0L TMR0IF
Clocks on Overflow
T0CKI pin Programmable 1
Prescaler
T0SE (2 TCY Delay)
8
T0CS 3
T0PS2:T0PS0
8
PSA Internal Data Bus

Note: Upon Reset, Timer0 is enabled in 8-bit mode with clock input from T0CKI max. prescale.

FIGURE 11-2: TIMER0 BLOCK DIAGRAM (16-BIT MODE)

FOSC/4 0
0
Sync with Set
1 Internal TMR0
TMR0L High Byte TMR0IF
T0CKI pin Programmable 1 Clocks on Overflow
Prescaler 8
T0SE (2 TCY Delay)
T0CS 3 Read TMR0L
T0PS2:T0PS0
Write TMR0L
PSA

Figure IV-7 : TIMER0 en mode 16 bits

Internal Data

Note: Upon Reset, Timer0 is enabled in 8-bit mode with clock input from T0CKI max. prescale.

Figure IV-6 : TIMER0 en mode 8bits et 16bits

Mis à part le bloc de comptage qui passe de 8 bit à 16 bit suivant le mode choisi, les
autres blocs du timer0 fonctionnent de façons similaires.

Le choix du mode (8 bit ou 16 bit) se fait par le bit T08BIT du registre T0CON ;le choix du
fonctionnement (timer ou compteur) se fait par le bit T0CS, dans le cas du fonctionnement en
compteur, le bit T0SE permet de choisir entre front montant ou front descendant, l’emploi du

DRIHMI F. Cours Microcontrôleurs Page 51

prédiviseur (prescaler) se fait par le bit PSA et les bits T0PS0, T0PS1 et T0PS2. Le démarrage
/arrêt du timer se fait par le bit TMR0ON.

Dans le mode timer l’horloge est dérivée de l’horloge interne du microcontrôleur ; comme le
montre les schémas fonctionnels précédents elle est de Fosc/4, Fosc étant la fréquence
d’horloge du PIC.

b-Le registre T0CON

Figure IV-8 : le registre T0CON

c-L’interruption du timer0
L’interruption associée au timer0 a lieu lorsque le registre TMR0L (en mode 8 bit)
déborde et passe à 00h ou lorsque les registres TMR0L et TMR0H (en mode 16 bit) passent à
0000h ; lors du débordement, le bit de flag TMR0IF est mis à 1 ; l’interruption aura lieu lorsque
les bits d’autorisation de l’interruption sont activés.

d-Calcul des paramètres d’une temporisation

La temporisation est donnée par l’équation :
Temporisation = (2n- valeur initiale) Nps.Tcy

DRIHMI F. Cours Microcontrôleurs Page 52

En prenant :
Tcycle = Tcy = 1/Fosc/4 = 4/Fosc = 4*Tosc (Tosc = 1/Fosc)
L’équation de vient Temporisation = (2n- valeur initiale) Nps.4.Tosc
Les paramètres définissants la temporisation sont Nps et la valeur initiale qu’on notera Vi.

Temporisation = (2n- Vi) Nps.4.Tosc

Pour déterminer ces deux paramètres, on commence par poser Vi=0, on détermine la valeur de
Nps qu’on arrondit à la valeur normalisée supérieure la plus proche (valeurs normalisées : 2, 4,
8, 16, 32, 64, 128 et 256) ensuite on détermine Vi ; par exemple si la valeur calculée de Nps est
27, on prend Nps=32 puisque 27 appartient à [24, 25[. Dans le cas particulier où le calcul donne
Nps appartenant à ]0,1], on prend PSA=1 ( pas de prédiviseur).

n=8 n’est choisi que si on veut assurer la compatibilité avec un pic de la série 16x où le timer0
est un timer 8bits.

e-Exemple de calcul
Fosc=8Mhz
Temporisation = 1s
En posant Vi=0, on trouve Nps=temporisation*Fosc/(216 *4)= 8000000 /(65536*4)=
30.517. étant donné que 30.517 appa rtient à [24, 25[, On prend Nps= 32 d’où Vi=216-
temporisation*Fosc/(Np*4)=65536-8000000 /(32*4)=3036
En conclusion n = 16, Nps = 32 ( code 0b100) et Ni = 3036.

f-Programmation du timer0
La programmation du timer0 en assignant à la CPU la tâche de scruter en permanence
le bit de flag TMR0IF n’a aucun intérêt, puisque l’objectif principal de l’emploi d’un timer est de
décharger la CPU du comptage du temps. L’emploi de l’interruption est recommandé.
La programmation du timer0 doit comporter nécessairement :
Au niveau du programme principal :
▪ Configuration du timer (T0CON)
▪ Initialisation du timer
▪ Configuration de l’interruption
▪ Lancement du timer
Au niveau du programme d’interruption :
▪ Acquittement du bit de flag
▪ Rechargement du timer.

DRIHMI F. Cours Microcontrôleurs Page 53

g-Exemple de programme

#include<xc.h>

void interrupt tempo(void)

{
if(TMR0IF)
{
LATC0=!LATC0; // changer l’état de RC0 à chaque fin de temporisation (génération d’un
signal carré)
WRITETIMER0(3036); // rechargement du timer
TMR0IF=0; // acquittement du bit de flag
}
}

main()
{
TRISC0=0; // configurer RC0 en sortie.
T0CON=0b10000100; // configurer le timer (exemple
//précédent :n=16, Np=32→T0PS2 :T0PS0=100)
IPEN=0 ; // pas de priorité.
INTCON=0b11100000; //configurer l’interruption ( GIE=1 , PEIE=1,TMR0IE=1, TMR0IF=0).
WRITETIMER0(3036); //charger la valeur initiale (Ni=3036).
while(1)
{}

La fonction WRITETIMER0() sert à charger la valeur de Vi dans les registres TMR0H et

TMR0L. elle peut être remplacer (après conversion de Vi en hexadécimal Vi=0x0BDC) par les
deux lignes suivantes :

TMR0H=0x0B ;

TMR0L=0XDC ;

Avec TMR0H toujours le premier sinon il ne sera pas pris en compte.

DRIHMI F. Cours Microcontrôleurs Page 54

4-Cas du timer2
Le timer2 appartient à la catégorie des timers utilisant la comparaison pour détecter la fin du
comptage, sa conception le rend particulièrement utile pour la génération des périodes.

a) Schéma bloc du timer2

Le timer2 n’admet comme entrée que l’horloge système (Fosc/4). Son prédiviseur ne
peut diviser que sur 1,4 ou 16 ce qui rend les calculs très faciles ; ces valeurs peuvent être
fixer par le moyen des bits :T2KPS1 :T2KPS0.
En plus du prédiviseur, le timer2 est muni d’un postdiviseur pouvant accepter jusqu’à
16 valeurs de division (les bits T2OUTPS3 : T2OUTPS3 ) et sert à déclencher des opérations
(suivant l’application) en mettant à 1 le bit de flag TMR2IF après N périodes ( de 1 à 16
périodes).
b) Calcul des paramètres du timer2
La formule utilisée pour un tel timer est la suivante : tempo=(1+PR2).Nps.Tcy
Si à titre d’exemple on désire avoir une période de 2ms avec Fosc=8Mhz, il faut
déterminer PR2 et Nps.
Puisque le prédiviseur n’admet que 3 valeurs possibles, on commence par poser Nps=1
et on calcule la valeur de PR2, si cette dernière <=255, on retient Nps=1, sinon on
passe à la valeur Nps=4 et on recalcule PR2, si PR2<=255, on retient Nps=4, sinon on
passe à Nps=16.
Dans notre cas , pour Nps=1, 1+PR2=(tempo.Fosc)/(4.Nps) =
0.002*8000000/(4*1)=4000>255
On passe à Nps=4 ➔1+PR2=1000>255 on passe à Nps=16
➔1+PR2=250➔PR2=249<255
On retient Nps=16 et PR2=249.

DRIHMI F. Cours Microcontrôleurs Page 55