Compte tours 002 avec PIC 16F88

Dernière mise à jour le --/--/2015

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Présentation 

Ce montage électronique, est basé sur un PIC16F88 calibré à une fréquence de 2Mhz, (Horloge interne au PIC). Le comptage des tours est fait par l’intermédiaire de diode infrarouge, qui au moment ou le rayon infrarouge est coupé donne une information logique (tout ou rien).  

Cette information logique est mise en forme avant d’attaquer directement l’entrée du microcontrôleur. L’affichage de la vitesse, c'est-à-dire le nombre de fois que le faisceau est coupé ce fait grâce à un afficheur LCD 2x16 caractères.  

Concernant la tolérance, pour une fréquence de 1Hz précision de 100%.

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Schéma

Fonctionnement

Ce montage électronique a pour but de compter le nombre de tour exactement comme le titre de ce présent article, avec une fréquence de rotation maxi 199 Tr/min. (bien utilise pour compter le nombre de tour fait par un pédalier de vélo les cycliste se reconnaitrons ;-))

Diode émettrice L-7113

Cette diode  émettrice infrarouge de couleur bleu transparent, a une tension direct de Vf=1,2V typique sous un courant If=20mA, et ce qui donne une largeur de bande spectral proche des 940 nm.

Le montage est alimenté sus une tension de 9V et afin de protéger ce courant à 20mA, la résistance R1=(Upile-Vf)/If=(9-1,2)/0.020=390 Ohms (400 Ohms fera bien l’affaire (2*200))

Diode réceptrice LTR-4208

Prenons deux résistances de 10Kohms, et mettons entre ces deux résistances la diode LTR-4208. Rien de bien compliqué pensez-vous ? Et bien voyez-vous tous va dépendre de la distance entre la diode émettrice et réceptrice qui cette dernière laissera ou non circuler le courant entre ces deux résistances.

Prenons le cas où les deux diodes sont très proche voir même en contact, le courant qui circule est d’environ 0,326mA soit 326µA. La chute de tension aux bornes de la résistance est donc UR6=R6*I=10000*0,000326= 3.26V.

Maintenant pour un éloignement d’environ 35cm le courant à lui à chuter et à une valeur d’environ 1,5µA. La nouvelle chute de tension aux bornes de la résistance est donc UR6=R6*I=10000*0,0000015= 0,015V.

Cœur du montage

Ce montage électronique tourne autour d’un PIC 16F88 et d’un affichage digital 2*16 caractères.

Comptage et MikroPascal

Nous allons nous intéresser plus particulièrement sur la base de la programmation c’est-à-dire sur la mise en œuvre de la programmation de notre compte tour en langage MikroPascal.

Le comptage doit s’effectuer en Tr/min (tour/minutes) ce qui veut dire que tous les secondes quelque chose se passe…

Prenons l’exemple d’un aimant qui passe toute les secondes devant le récepteur, chaque fois que cette l’aimant passe devant le récepteur, toutes les secondes au bout de 1min nous aurons 60passage c’est-à-dire 60Tr/min. La complexité de cette programmation doit tenir compte du nombre de passage de l’aimant en une seconde. Si maintenant il passe deux fois devant le récepteur nous aurons bien évidement le double soit 120tr/min, mais si maintenant il passe 1,5 fois, nous aurons 1,5*60=90tr/min ?? Oui mais difficile de compter des moitiés de tour avec ce montage électronique.

Interruption

En voilà une bonne idée !! Pourquoi faire ? Et bien l’explication sans plus attendre.

Le but est de cibler toutes les fois que l’aimant passe devant le capteur en une secondes, et pour cela nous allons cibler cette seconde et analyser le nombre fois que l’aimant est passé dans cette seconde.

C’est comme si nous avons un créneau qui dure (niveau haut logique « 1 logique ») pendant 1 seconde, et que pendant ce niveau haut logique, il compte le nombre de fois que l’aimant est passé dans ce créneau.

Pour cela nous allons utiliser les timers disponibles dans le PIC 16F88 (Timer0/Timer1/Timer2), oui mais quel timer utiliser ? La réponse n’est pas compliqué, il faut déjà dans un 1er temps calculer à la seconde prêt, puisque cette notre idée de départ.

Timer0

Prenons le Timer 0 et en utilisant l’horloge interne (oui sans horloge le PIC ne peut fonctionner choix entre Horloge interne ou horloge externe Quartz ou autres). L’horloge interne peux être calibré en fonction des différents paramètres qui sont consultables à la page 40 du datasheet, c’est d’ailleurs le registre du contrôle de l’oscillateur (OSSCON) qui prédétermine les valeurs d’oscillation interne.

Pour une fréquence interne de 31,250Khz qui celle-ci est encore divisé par 4 (Fosc/4) nous donne 7812,5 Hz, (au passage je tiens à signaler que c’est cette fréquence interne qui fera osciller les minuscules milliards de composants). Ensuite vient s’ajouter le coefficient prescaler qui est égale aux bits programmé dans le logiciel multiplié par la période de Fosc/4 :

Pour exemple prescaler assigné  ½ :

OPTION_REG.PS0:=0;

OPTION_REG.PS1:=1;

OPTION_REG.PS2:=1;

Le timer 0 est réglé afin que l’on commence à compter à partir de 0 soit TMR0:=$00 allant jusqu’à TMR0:=$FF, ce qui correspond à 255 (8 bits) valeurs soit T la période en intégrant le prescaler qui est égale 64µs. Puis on va multiplier pas ces 255 soit 8bits, ce qui est égale 65,28ms.

Formule général

En résumé de ce que nous venons de  voir ci-dessus la formule à retenir est celle-ci :

T=(1/[(Fosc/4)*(prescaler)]) * (valeur programmé du compteur (8 bits / 16 bits / etc)

Fosc= Oscillateur interne ou externe

Exemple :

Fosc= 1Mhz TMR0=0F, 0F représente 15 en décimal mais au total 240 (255-15) (255 car 8 bits pour le timer0) donc 240 valeurs à compter en partant de 15 pour arriver à 255, puis pour finir,

prescaler= 1/16 ce qui donne :

T=(1/[(1000000/4)*(1/16)])* (240)=15,36ms qui correspond au temps que va mettre le timer0 pour compter de 15 jusqu’à 255

Quels timer utiliser ?

Ceci étant dit il faut trouver un moyen d’obtenir un temps de comptage proche des 1seconde et non des quelques millisecondes.

Après plusieurs tentatives de calculs le timer 0 fera bien l’affaire, avec une Fosc=31,25Khz Prescaler = 1/32 TMR0=$00 soit :

T=(1/[(31250/4)*(1/32)])* (255)=1,044s (proche de la seconde)

Super !! Mais gros problème, en effet la vitesse de traitement des données va être faite à une vitesse de 7Khz (vue précédemment), et l’affichage digital va avoir du mal à fonctionner à cette fréquence en raison du rafraichissement. Mieux vaut monter en oscillation pour que celui-ci soit en pleine forme (voir TIMER 1 plus bas).

TIMER 0 pour le comptage

Nous allons utiliser le TIMER 0 uniquement pour récupérer les signaux venant du transistor, signaux qui sont compris entre 0V et 5Vdc, ces signaux vont venir attaquer directement la broche 3 du PIC 16F88, pour cela il suffit d’activer les bits ci-dessous :

//*******Config TIMER0*******

OPTION_REG:=$00;

OPTION_REG.T0CS:=1; //Cycle de comptage externe sur la broche 3 (T0CKI)

OPTION_REG.PSA:=1;  // voir diagramme TIMER0/WDT

INTCON.TMR0IE:=0;  //On active pas ce bit sur débordement du Timer 0

INTCON.TMR0IF:=0;  // débordement mis à zéro

TMR0:=$00; // pré-réglé à zéro

TIMER 1 

J’ai opté pour le timer 1 afin d’obtenir une fréquence de 2Mhz pour un prescaler de 1/8 vous devez tomber sur 1,04 (à vous calculette ;-) d’autre part faite attention il s’agit d’un timer qui compte sur 16bits soit 2^16=65535 (moins le zéro).

Configuration des bits :

//*******Config TIMER1*******

T1CON:=$00;

T1CON.T1CKPS0:=1;

T1CON.T1CKPS1:=1;

T1CON.TMR1ON:=1;

PIE1.TMR1IE:=1; //On active ce bit sur débordement du Timer 1

PIR1.TMR1IF:=0;  // débordement mis à zéro

TMR1H:=$00;

TMR1L:=$00;

Fonctionnement du comptage 

Nous allons par rentrer dans toute la programmation, mais regarder une partie qui est intéressante sur la façon de compter les impulsions venant sur la broche 3 du PIC 18F88. La partie de la programmation qui celle-ci nous intéresse est celle-ci :

  • // procedure init;
  • //...
  • //...
  •  
  • procedure Comptage;
  • begin
  •  if bCount=true then
  •       begin  
  •       iSpeed:=TMR0;
  •       iSpeed_LCD:=iSpeed;
  •       bCount:=false;
  •       TMR0:=$00;
  •       end;
  • end;
  •  
  • procedure interrupt;
  • begin
  • if  PIR1.TMR1IF=1 then
  •    begin
  •    bCount:=true;
  •    PIR1.TMR1IF:=0;
  •    end;
  • end;
  •  
  • begin
  • init;
  • while true do
  • begin
  • Comptage;
  • // procedure ...
  • // ...
  • // ...
  • end;
  • end.

 

Mais comment ça marche?

Le fonctionnement est le principe, toutes les secondes on autorise le comptage via la variable booléen bCount.

Prenons l’exemple avec TIMER 1 à zéro (TMR1H et TMR1L :=0), la variable bCount est fausse (pré-programmé dna les procédures d'initialisation) bCount :=false. Dans ce cas de figure il faut absolument attendre que le TIMER 1 compte afin que TMR1H et TMR1L arrive à $FF c’est-à-dire à 1,04sec (voir calculs précédents) ce qui enclenchera dans la foulée la variable booléen bCount :=true.

Ceci étant dit, tant que bCount :=false, est à l’état faux, la boucle while true do scrute en boucle la procédure comptage et celle-ci ne peut se faire en raison que bCount est à l’état faux. Oui !!Mais il y’a un mais, effectivement le TIMER 0 (TMR0) lui s’incrémente dès qu’un front montant est présent sur sa broche 3.

Revenons sur cette broche 3, et parallèlement prenons le cas où le TIMER 1 n’a pas débordé (TMR1H et TMR1L égale à $FF) la broche 3 du PIC 16F88 reçoit une multitudes de fronts, et pour faciliter les choses prenons arbitrairement 10 fronts montants TMR0 :=$0A (décimal 10), au moment du débordement du TIMER 1 la variable booléen va passer de l’état false à l’état true (bCount :=true) (puis le TIMER 1 recommence à compter TMR1H et TMR1L égale à $00) , la scrutation au niveau de la boucle while true do sera ainsi être réalisée et la procédure comptage va donc être lu en boucle, ce qui va permette de scruter la ligne TMR0 qui cette valeur est à l'état prcédent c'est-à-dire TMR0 :=$0A pour être « injecté » dans la variable iSpeed à une vitesse grand V..., la scrutation continu son chemin afin d’arriver sur la variable bCount qui repasse à l’état false empechant de nouveau la lecture en boucle de la procédure Comptage,  et de terminer par la remise à zéro du TIMER 0 (TMR0 :=$00).

Ce qui est intéressant c’est que nous lisons aussi vite la valeur du TIMER 1 pour l’effacer rapidement  c’est comme un effet mémoire, bien sur nous pouvons le constater à l'aide d'un afficheur LCD et on remarque cette valeur ne s'efface pas. (à moins d’utiliser la fonction Clear sur l’afficheur LCD qui pour le coup et non par magie fera disparaitre la valeur du TMR0).

Créer un site gratuit avec e-monsite - Signaler un contenu illicite sur ce site

×