Voici la façon que pc compteur

Le TMRO par François VE2JX

Voici la façon que pc compteur, le pré-diviseur (prescaler) et TMR0 fonctionnent.

Lorsque le PIC débute d'exécuter des instructions le pc compteur tourne à la même vitesse que l’exécution des instructions.

Pour connaître la vitesse interne du PIC, il s’agit de prendre la fréquence du cristal branché au PIC et diviser par 4.

Cristal de 4,000,000 Hz /4 = 1,000,000 d’instructions exécutables en 1 seconde. Alors, chaque instruction prend 1 us (micro seconde) soit 0.000001 sec.

Il est possible de faire tourner TMR0 soit direct drive ou soit avec un pré-diviseur (prescaler) sélectable soit un ratio de 1:2 1:4 1:8 1:16 1:32 1:64 1:128 1:256

Lorsque le PIC démarre, le pc compteur avance à chaque instruction. Si dans le PIC il y a eu 23 instructions de faites, le pc compteur a avancé de 23. Si vous faites une initialisation pour que le FLAG de TMR0 lève lors de son passage à 0, bien entendu GLOBAL doit être activé pour qu’une interruption soit générée( nous y reviendrons pour comment faire l’initialisation de GLOBAL et du FLAG de TMR0 ).

Dans la fig. pc compteur et TMR0 sont directs, le Flag a été initialisé, il sort lorsque TMR0 retourne à 0. Mais rien ne se produit car GLOBAL n’a pas été activé.

Dans le prochain cas GLOBAL et le flag TMR0 seront activés. Cela donnera comme résultat que lorsque TMR0 lèvera son flag lors du à son passage de 255 à 0, une interruption sera donc générée et le programme sera forcé d’aller à #int_rtcc qui sera écrit dans votre programme et entrer dans la fonction qui sera écrite.

Ex : #int_rtcc

Interrupt( )

{

instruction;

}

Pour savoir quand le flag lèvera faite le calcul suivant.

Cristal ( Hz ) /4 = vitesse interne

Vitesse interne ( Hz ) / 256 = temps

1/ temps= réponse en millième secondes

4000000 /4 =1000000

1000000/256(TMR0)= 3906.25

1/3906.25= 0.000256 us (256 us) ce calcul prouve que TMR0 tourne à la même vitesse que le PC compteur.

Avec un cristal de 4 Mhz/4 = 1 Mhz chaque instruction prend 1 us donc en direct drive si TMR0 a la vitesse de 0.000256 us(.256ms) pc compteur lui aussi tourne à la même vitesse.

Maintenant regardons l’utilisation du pré-diviseur (prescaler) qui est dans le PIC.

Le fonctionnement de celui-ci est for simple imaginez un odomètre de voiture . Les odomètres fonctionnent en base 10. Donc les cadrans sont gradués de 0-9 et lorsque vous revenez à 0 le cadran suivant avance de 1

Ex : 001, 002, 003, 004, 005, 006, 007, 008, 009, 010, 011…

Imaginez maintenant que le premier cadran peut changer de base soit base 2, 4, 8, 16, 32, 64, 128, 256.

Changeons le cadran par une roue d’engrenage et le mot base par les dents d’engrenages.

Maintenant la roue peut avoir soit 2, 4, 8, 16, 32, 64, 128, 256 dents.

Comment cette roue avance-t-elle?

EX : Activation du pré-diviseur ratio de 1 : 2

Activation du flag et global.

4000000 (cristal) / 4 = 1000000 (vitesse interne du PIC)

1000000 /2 (ratio) = 500000

500000 / 256 (TMR0) =1953.125 nombre d’interruptions par seconde

1/temps

1/1953.125 = .000512 us (.512 ms) interruption à toute les micros secondes le flag du overflow de TMR0 lèvera à chaque demi et des poussières millième de seconde, donc une interruption sera générée.

Dans l’exemple du pré-diviseur avec un ratio 1:2 la roue d’engrenage n’a seulement 2 dents soit 0 et 1. Cette roue avant de 1 à chaque fois que pc compteur avance de 1 soit à chaque instruction. Cela veut dire que chaque 2 instructions TMR0 avance de 1.

Ratio 1 :4 4 instructions qui est dans le ROM du PIC et non pas dans votre programme en langage C.

Ratio 1 :8 8 instructions

Si le pré-diviseur, global, et TMR0 ont été activés en programmation, chaque instruction que le PIC exécute fera avancer le présélecteur de 1 et lorsqu’il retournera à 0 celui-ci fera avancer TMR0 de 1. Lorsque TMR0 passera de 255 à 0 le flag lèvera et une interruption sera généré. Après avoir fait le ou les Instruction(s), le flag est abaissé automatiquement en sortant de la fonction interrupt.

Maintenant voici comment initialiser TMR0, PRESCALER.

Dans votre programme en C écrivez une fonction qui s’appellera setup( ) ou pic_init( ) naturellement ne pas oublier de faire votre déclaration de fonction dans le programme. Dans cette fonction nous allons retrouver tout ce qui touche les paramètres que l’on veut pour le PIC comme éducation des ports A et B, TMR0, prescaler…

Dans le PIC, il est possible de choisir la provenance de l’impulsion qui fera avancer soit TMR0 ou le prescaler. Donc il y a deux choix, une source interne ou externe. Il est possible de faire fonctionner TMR0 seul ou avec un prescaler de 2,4,8,16… 256. Activer le flag pour générer l’interruption et pour finir il faut activer GLOBAL pour faire fonctionner le tout.

Voici comment écrire dans le programme.

-TMR0 interne avec un prescaler de 2.

setup_counters( rtcc_internal , rtcc_div_2 );

-Activer le flag

enable_interrupts( int_rtcc );

-Activer global

enable_interrupts( global );

setup( )

{

setup_counters( rtcc_internal , rtcc_div_2 );

enable_interrupts( int_rtcc );

enable_interrupts( global );

}

Dernière étape, lorsque l’interruption est générée le programme est forcé d’aller dans la fonction interrupt( ) que vous aurez écrit. Prendre note que interrupt( ) n’est pas déclaré dans le programme le compilateur s’occupe de tout. Mais il faut indiquer où aller pour trouver interrupt( ). Vous devez écrire #int_rtcc la ligne avant interrupt( )

Exemple

#int_rtcc

interrupt( )

{

}

écrit ainsi le programme sera que la fonction interruption est écrite sous #int_rtcc.