Utiliser les PIC 16F et 18F/Le Timer0 des 16FXXX et le langage C

**Le Timer0 des 16FXXX et le langage C**
Leçon : Utiliser les PIC 16F et 18F

Chapitre n^o 8
Chap. préc. :	Les ports et le langage C
Chap. suiv. :	Interruption timer0 en langage C
Exercices :	Le Timer0 des 16FXXX et le langage C

En raison de limitations techniques, la typographie souhaitable du titre, « Utiliser les PIC 16F et 18F : Le Timer0 des 16FXXX et le langage C
Utiliser les PIC 16F et 18F/Le Timer0 des 16FXXX et le langage C », n'a pu être restituée correctement ci-dessus.

Le timer 0 du PIC 16FXXX[modifier | modifier le wikicode]

Description matérielle[modifier | modifier le wikicode]

Le timer0 est un timer sur 8 bits. C'est totalement visible sur la figure ci-dessous. Les bits des registres 8 bits seront toujours repérés de b0 (poids faible) à b7 (poids fort).

Cette figure est la première d'une longue série qui décrit complètement le fonctionnement matériel du timer0. Il vous faut cependant passer du temps pour la comprendre si vous voulez comprendre aussi les autres.

Que voit-on sur cette figure ?

La fréquence du quartz est divisée par 4 avant utilisation (en haut à droite)
C'est le registre OPTION qui permet une configuration du fonctionnement du timer0
Lors d'un débordement (overflow) du timer 0, un bit nommé "TMR0IF" du registre INTCON est positionné. Ce bit n'est jamais remis à 0 par le matériel car c’est un drapeau (flag)
Le bit "T0CS" du registre OPTION permet, à l'aide du multiplexeur en haut à droite de choisir l'entrée du timer 0. On voit qu’il peut s'agir du quartz interne du PIC ou du bit "T0CKI" du PORTA.
Le ou exclusif (=1) permet une éventuelle inversion
Les trois bits "PS2", "PS1" et "PS0" permettent un choix de division entre 2 et 256
La fameuse division ci-dessus ne sera prise en compte que si le multiplexeur du bas est positionné correctement par le bit "PSA" du registre OPTION.
Cette figure vous donne aussi la position de tous les bits. Par exemple, le fameux bit "T0CKI" du PORTA est le bit b4 du PORTA.

Remarque

Après un reset le registre OPTION se positionne à 11111111

Et pour terminer une remarque sur le registre OPTION.

Remarque

Les deux bits (b7 et b6) non présentés du registre OPTION sont

NOTRBPU : sans rapport avec le timer0, ce bit permet de renseigner le mode de fonctionnement concernant la présence de résistances de rappel sur le portB.B0 : positionne des résistances en interne.
INTEDG : sans rapport avec le timer0, ce bit indique le sens de déclenchement sur l'interruption RB0. Nous n'utilisons pas cette option, nous pouvons laisser ce bit à 1.

Comment l’utiliser avec un programme[modifier | modifier le wikicode]

Pour réaliser un programme, la première question que l’on se pose, est de savoir comment s'appellent les registres et comment s'appellent les bits correspondant. Encore une fois on donne ces noms à travers des fichiers d'en-tête et pour deux compilateurs différents.

Nom des bits et registres avec MikroC[modifier | modifier le wikicode]

Regardez ci-dessous comment les registres sont appelés ainsi que pour une fois quelques noms de bits :

const unsigned short
//********* bits de INTCON
GIE      = 0x0007,
EEIE       = 0x0006,
T0IE       = 0x0005,
INTE       = 0x0004,
RBIE       = 0x0003,
T0IF       = 0x0002,
INTF       = 0x0001,
RBIF       = 0x0000,
....
//********** bits de OPTION
NOT_RBPU       = 0x0007,
INTEDG       = 0x0006,
T1 T0CS       = 0x0005,
T0SE       = 0x0004,
PSA      = 0x0003,
PS2      = 0x0002,
PS1      = 0x0001,
PS0      = 0x0000,
...
unsigned short register volatile
  TMR0       absolute 0x0001;
...
unsigned short register volatile
  PORTA      absolute 0x0005;
...
unsigned short register volatile
  INTCON       absolute 0x000B;
unsigned short register
  OPTION_REG       absolute 0x0081,
  TRISA      absolute 0x0085,
...

Exemple

La documentation ci-dessus nous montre que pour mettre le bit GIE du registre INTCON, on peut le faire de trois façons :

//********* MikroC *********
INTCON.GIE = 1; //idem en Hitech C
// ou encore (MikroC pro seulement) :
GIE_bit =1;
// ou encore
INTCON.F7 = 1; // INTCON.B7 = 1;

Remarque

Très important : le registre OPTION se note OPTION_REG en MikroC.

Nom des bits et registres avec HitechC[modifier | modifier le wikicode]

Comme d'habitude, les noms des registres sont sans surprise. Hitech C définit aussi un certain nombres de bits.

volatile unsigned char	TMR0	@ 0x01;
...
volatile unsigned char	PORTA	@ 0x05;
...
volatile unsigned char	INTCON	@ 0x0B;
unsigned char      	OPTION	@ 0x81;
...
volatile unsigned char  	TRISA	@ 0x85;
...
/*      PORTA bits      */
volatile bit	RA4	@ (unsigned)&PORTA*8+4;
volatile bit	RA3	@ (unsigned)&PORTA*8+3;
volatile bit	RA2	@ (unsigned)&PORTA*8+2;
volatile bit	RA1	@ (unsigned)&PORTA*8+1;
volatile bit	RA0	@ (unsigned)&PORTA*8+0;

/*	INTCON bits	*/
volatile bit	GIE	@ (unsigned)&INTCON*8+7;
volatile bit	EEIE	@ (unsigned)&INTCON*8+6;
volatile bit	T0IE	@ (unsigned)&INTCON*8+5;
volatile bit	INTE	@ (unsigned)&INTCON*8+4;
volatile bit	RBIE	@ (unsigned)&INTCON*8+3;
volatile bit	T0IF	@ (unsigned)&INTCON*8+2;
volatile bit	INTF	@ (unsigned)&INTCON*8+1;
volatile bit	RBIF	@ (unsigned)&INTCON*8+0;

/*	OPTION bits	*/
      bit	RBPU	@ (unsigned)&OPTION*8+7;
      bit	INTEDG	@ (unsigned)&OPTION*8+6;
      bit	T0CS	@ (unsigned)&OPTION*8+5;
      bit	T0SE	@ (unsigned)&OPTION*8+4;
      bit	PSA	@ (unsigned)&OPTION*8+3;
      bit	PS2	@ (unsigned)&OPTION*8+2;
      bit	PS1	@ (unsigned)&OPTION*8+1;
      bit	PS0	@ (unsigned)&OPTION*8+0;
...

/*      TRISA bits      */
volatile       bit	TRISA4	@ (unsigned)&TRISA*8+4;
volatile       bit	TRISA3	@ (unsigned)&TRISA*8+3;
volatile       bit	TRISA2	@ (unsigned)&TRISA*8+2;
volatile       bit	TRISA1	@ (unsigned)&TRISA*8+1;
volatile       bit	TRISA0	@ (unsigned)&TRISA*8+0;

Les différents modes de fonctionnement[modifier | modifier le wikicode]

Le timer0 est en fait un compteur. Mais qu’allez-vous compter avec ce timer ? Et bien, vous avez deux possibilités :

En premier lieu, vous pouvez compter les impulsions reçues sur la pin RA4/T0CKI. Nous dirons dans ce cas que nous sommes en mode compteur
Vous pouvez aussi décider de compter les cycles d’horloge du PIC® lui-même. Dans ce cas, comme l’horloge est fixe, nous compterons donc en réalité du temps. Donc, nous serons en mode « timer ».

La sélection d’un ou l’autre de ces deux modes de fonctionnement s’effectue par le bit 5 du registre OPTION : T0CS pour Tmr0 Clock Source select bit.

T0CS = 1 : Fonctionnement en mode compteur
T0CS = 0 : Fonctionnement en mode timer

Dans le cas où vous décidez de travailler en mode compteur, vous devez aussi préciser lors de quelle transition de niveau le comptage est effectué. Ceci est précisé grâce au bit 4 du registre T0CON : T0SE pour Timer0 Source Edge select bit.

T0SE = 0 : comptage si l’entrée RA4/TOKI passe de 0 à 1 (front montant)
T0SE = 1 : comptage si l’entrée RA4/TOKI passe de 1 à 0 (front descendant)

Mesure du temps d'exécution d'un algorithme[modifier | modifier le wikicode]

L'optimisation d'un algorithme en vitesse (ou en taille) est très importante dans les systèmes embarqués réalisés par des micro-contrôleurs. Une recherche d'algorithmes sur Internet vous donnera des résultats qu’il vous faudra évaluer. Par exemple, le site : http://www.piclist.com/techref/language/ccpp/convertbase.htm vous propose un algorithme de division par 10 que voici :

unsigned int A;
unsigned int Q; /* the quotient */
        Q = ((A >> 1) + A) >> 1; /* Q = A*0.11 */
        Q = ((Q >> 4) + Q)     ; /* Q = A*0.110011 */
        Q = ((Q >> 8) + Q) >> 3; /* Q = A*0.00011001100110011 */
        /* either Q = A/10 or Q+1 = A/10 for all A < 534,890 */

L'exercice 1 se propose de mesurer le temps d'exécution de cet algorithme et d’en faire des comparaisons.

Le mode de scrutation du flag[modifier | modifier le wikicode]

Nous devons savoir à ce niveau, que tout débordement du timer0 (passage de 0xFF à 0x00) entraîne le positionnement du flag T0IF, bit b2 du registre INTCON. Vous pouvez donc utiliser ce flag pour déterminer si vous avez eu débordement du timer0, ou, en d’autres termes, si le temps programmé est écoulé. Cette méthode à l’inconvénient de vous faire perdre du temps inutilement dans une boucle d'attente. Petit exemple :

 
     clrf        tmr0                 ; début du comptage dans 2 cycles 
                                      ; (voir remarque plus bas) 
     bcf         INTCON , T0IF        ; effacement du flag 
loop 
     btfss       INTCON , T0IF        ; tester si compteur a débordé 
     goto        loop                 ; non, attendre débordement 
     xxx                              ; poursuivre : 256/65536 évènements écoulés

Le timer 0 du pic 18FXXXX[modifier | modifier le wikicode]

Le titre de ce chapitre ne contient pas le PIC 18F, mais nous décidons quand même de le documenter.

Que voit-on sur cette figure ?

La fréquence du quartz est divisée par 4 avant utilisation (en haut à droite)
C'est le registre T0CON qui permet une configuration du fonctionnement du timer0
Le timer 0 est sur 16 bits alors qu’il est sur 8 bits dans les 16F. En fait le timer 0 peut être configuré sur 8 ou 16 bits à l'aide du bit T08Bit du registre T0CON.
Lors d'un débordement (overflow) du timer 0, un bit nommé "TMR0IF" du registre INTCON est positionné. Ce bit n'est jamais remis à 0 par le matériel car c’est un drapeau (flag)
Le bit "T0CS" du registre T0CON permet, à l'aide du multiplexeur en haut à droite de choisir l'entrée du timer 0. On voit qu’il peut s'agir du quartz interne du PIC ou du bit "T0CKI" du PORTA.
Le ou exclusif (=1) permet une éventuelle inversion
Les trois bits "T0PS2", "T0PS1" et "T0PS0" permettent un choix de division entre 2 et 256
La fameuse division ci-dessus ne sera prise en compte que si le multiplexeur du bas est positionné correctement par le bit "PSA" du registre T0CON.
Le Timer0 peut être arrêter par le bit TMR0ON de T0CON. Les 16F n'offrent pas cette possibilité pour le Timer0.
Cette figure vous donne aussi la position de tous les bits. Par exemple, le fameux bit "T0CKI" du PORTA est le bit b4 du PORTA.

Les schémas donnés dans les documentations Microchip sont plus du style :

On est confronté au problème de l'écriture dans un registre 16 bits par un processeur 8 bits. Ce problème est documenté dans cette figure.

Pour écrire on commence par les 8 bits de poids fort puis par les 8 bits du poids faible.
Pour lire on commence par lire les 8 bits de poids faible puis les 8 bits de poids fort.

Faites ces exercices : Le timer0.

Utiliser les PIC 16F et 18F

Les ports et le langage C

Interruption timer0 en langage C