Mesure période signal en entrée d'un microcontrôleur pic

[invite67c84035]

Bonsoir a tous

Je vous expose ma problématique :

j ai besoin de calculer en temps réel l évolution de la période d ' un signal créneau de tension entre 0 et 5 volt applique sur une entrée déclare comme entrée logique sur un microcontrôleur plus précisément pic 16f877

muni de la datasheet et d un dictionnaire anglais français je me suis lance a la recherche de méthodes pour arriver a mes fins ...

j hésite entre utiliser juste le registre du timer tmr1h et tmr1l directement en le démarrant et le stoppant puis remise a zéro après stockage de la valeur pour exploitation dans chaque cycle de boucle ( boucle infini car mesure de la période en continu )

ou utiliser le mode capture si j envoie mon signal en entrée de ccp1 ou ccp2

j ai touche au registres t1con pour tenter de paramétrer et gérer la marche et arrêt de celui ci , mais sans résultats .


si quel qu un pouvait m expliquer avec quelques détails de plus , ou un exemple de programme en c déjà existant et je m adapterais ... c est en se cassant la tété que l on assimile

PS : j effectue en parallèle un test des programmes sur mon circuit simule sous proteus , pratique avant la fabrication matériel .

j attend vos réponse avec impatience

merci d avance de votre lecture

bonne soirée

[antek]

Donne une plage de durée des périodes à mesurer.
Tu utilises quel langage ?

[invite67c84035]

Bonjour

la fréquence de mon signal d entrée mis en forme correspond a l information de régime moteur
donc celui ci étant de 0 a 13000 rpm , pour avoir un peu de marge une fréquence de 1 a 300 hz me parait correcte histoire d avoir un peu de marge en cas de sur-régime .

Donc une période du signal d entrée a mesurer qui va osciller entre 1 seconde et 2.5 millisecondes .

La ou j ai besoin de plus de précision que possible c' est sur la plage régime moteur entre 500 et 8000 rpm, don entre 80 et 140 hz donc une mesure de période correct entre 7 ms et 13 ms


je programme avec mikroc

ensuite j' utilise le fichier .hex compilé par ce logiciel que je rentre dans le modèle de mon microcontrôleur sur proteus pour lancer la simulation sous Isis .

Merci de votre considération pour mon problème

Bonne journée

[invitee05a3fcc]

Donc une période du signal d entrée a mesurer qui va osciller entre 1 seconde et 2.5 millisecondes .

Irréaliste ! Ton moulin ne tourne pas à 60 tr/mn . C'est 80ms ( 750 tr/mn) à 4,6ms(13000 tr/mn)

La ou j ai besoin de plus de précision que possible

La précision dépend de la période du signal (plus elle est grande, plus tu as une bonne précision)

c' est sur la plage régime moteur entre 500 et 8000 rpm, don entre 80 et 140 hz donc une mesure de période correct entre 7 ms et 13 ms

500 tr/mn-> 120ms
8000 tr/mn-> 7,5ms

Pour améliorer la précision aux vitesses élevées, tu peux dire que tu fais la mesure sur 2 ou 3 ou 4 périodes. Le temps de mesure est plus long, mais c'est plus précis . Ce genre d'amélioration est à envisager une fois que ton programme de base est au point !


Exemple :
Tu as un timer 16 bits qui utilise une horloge interne de 10Khz (je ne sais pas si c'est possible, mais c'est une hypothèse d'école) , donc une résolution 100µs .
Tu reçois un top, tu lances le timer.
Tu reçois un nouveau top
Deux cas se présentent :
- Le timer est à 1200 . La période est de 120,0 ms, donc la vitesse= 500,0 tr/mn (+-0,4) . Tu resetes le timer
- Le timer est à 46 . La période est de 4,6 ms, donc la vitesse= 13043 tr/mn (+-277)
Donc , dans le deuxième cas, tu as une mesure toutes les 4,6ms mais avec une précision de +-2% . Si ça ne te convient pas, tu incrémentes un compteur de boucle (Cpt) et tu laisses tourner le timer. Au top suivant, le timer est à 92 . La mesure est de 9,2 ms . Donc la vitesse (60*(Cpt+1))/0,0092= 13043 tr/mn (+-138). tu as une mesure toutes les 9,2ms mais avec une précision de +-1%

[A voir en vidéo sur Futura]

[invite67c84035]

D' accord , je comprends bien le principe du programme

registre 16 bit a utiliser pour moi c est bien celui du TIMER1 ?

la mesure sur une seule période me suffira au vu de la précision apparente , ce sera facilement changeable si besoin .

[invitee05a3fcc]

registre 16 bit a utiliser pour moi c est bien celui du TIMER1 ?

J'en sais rien ... je ne m'occupe plus de µC depuis 2005 .

[RISC]

Salut,

Regardes la datasheet...l'unité CCP utilise le timer2 pour le mode capture
Il est possible d'utiliser aussi le Timer1 mais pas en mode capture. Il faut alors gérer les interruptions pour compter.
La mesure de temps avec CCP a été discutée des centaines de fois sur ce forum. Si tu cherches CCP PIC futura-sciences ou CCP PIC18 futura-sciences tu trouveras sans doute pas mal de liens et des exemples de code.

a+

[invitee05a3fcc]

Il est possible d'utiliser aussi le Timer1 mais pas en mode capture.

le mode capture? C'est le signal externe qui incrémente le timer ? Alors, ce n'est pas le fonctionnement souhaité ici.

[inviteb5b0fd5b]

Bonsoir a tous,
pour récupérer la période d'un signal délivrer par un capteur (tachy, optique..)
tu peux utiliser l'interruption externe RB0 comme détecteur des fronts et le timer1 pour compter la différence entre entre deux front ==> donc "T"
voici un exemple :

   void interrupt(){

   if (INTF_bit){
      INTF_bit=0 ;
   if (!premier_front){
       TMR1H =0x00;  // reseter le timer pour une nouvelle periode
       TMR1L =0x00;
       premier_front =1;} // desactive la condition du 1èr front
       
   else {periode =(TMR1L + TMR1H *256);premier_front=0; }}

  
   if (TMR1IF_bit){  //si le timer est déborder... 
      TMR1IF_bit =0;
      TMR1H =0x00;
      TMR1L =0x00;}}

N.B : La valeur du periode =(TMR1L + TMR1H *256) ne comporte pas la durée réel du signal, il faut prendre en considération le prescaler et l'osc

par exp: on a un quartz de Fosc=4Mhz <==> Tosc=1us ;
avec un prescaler 1:1 le timer incrément 1 chaque 1us...
avec ces params "periode =(TMR1L + TMR1H *256) " représente la durée en us
bn courage

[inviteb5b0fd5b]

pour info la Période maximal est limité a 65,535 ms <==> 15,25 Hz

[invite67c84035]

cela dépend de quel horloge on prend pour " alimenter " le timer1 non ?

je prends une horloge externe pour mon microcontrolleur de 20 mhz grâce a un quartz .

donc la frequence d execution du timer est celle de l horloge divisé par 4 si on prend prescaler pleine echelle ?

[paulfjujo]

pour info la Période maximal est limité a 65,535 ms <==> 15,25 Hz

sauf si on gere (compte) les debordement du compteur ..
X fois 65,53 ms

[invite67c84035]

Bonsoir a tous,
pour récupérer la période d'un signal délivrer par un capteur (tachy, optique..)
tu peux utiliser l'interruption externe RB0 comme détecteur des fronts et le timer1 pour compter la différence entre entre deux front ==> donc "T"
voici un exemple :

   void interrupt(){

   if (INTF_bit){
      INTF_bit=0 ;
   if (!premier_front){
       TMR1H =0x00;  // reseter le timer pour une nouvelle periode
       TMR1L =0x00;
       premier_front =1;} // desactive la condition du 1èr front
       
   else {periode =(TMR1L + TMR1H *256);premier_front=0; }}

  
   if (TMR1IF_bit){  //si le timer est déborder... 
      TMR1IF_bit =0;
      TMR1H =0x00;
      TMR1L =0x00;}}

N.B : La valeur du periode =(TMR1L + TMR1H *256) ne comporte pas la durée réel du signal, il faut prendre en considération le prescaler et l'osc

par exp: on a un quartz de Fosc=4Mhz <==> Tosc=1us ;
avec un prescaler 1:1 le timer incrément 1 chaque 1us...
avec ces params "periode =(TMR1L + TMR1H *256) " représente la durée en us
bn courage

je ne comprends pas tout de ce programme

a quoi correspond premier_front?

et if (INTF_bit)
{
}

et premier_front =1 entre autres ?

merci

[invite67c84035]

j ai tente de mettre en place un code pour mon utilisation , je ne sais pas si cela peut fonctionner , la structure est logique mais le reste je ne sais pas trop ...

//*CHAINE*DE*MESURE

*/*PROGRAMME*qui*as*pour*but*de*calculer*la*periode*d*'*un*signal*applique*sur*ra4/t0ck1
**d*ou*l*utilisation*du*timer1*pour*calculer*le*temps*entre*deux*fronts*montant*donc*de*la*periode*du*signal*envoyé*en*entrée***/
/**avec*cette*configuration*prescaler*1*et*horloge*ext*(20*mhz/4)*pour*timer0*,*temps*entre*deux
incrementations*du*timer0*=*0.2*microsceondes**/


void*main()
{


**************TRISA.B0*=0;***//*pin*0*du*port*A*est*declare*en*entree*pour*l*acquisition*du*signal
**************unsigned*int*periode*=*0;
**************unsigned*int*temps*=*0;
**************unsigned*int*tempstotal*=*0;
**************int*a=0*;*********//***variable*qui*sert*de*condition*test*sortie*de*boucle*des*que*l*on*as*acqui*notre*periode
**************int*dep=0;*******//*variable*qui*stocke*le*nombre*de*depassements*ayant*eue*lieu*durant*le*comptage*durant*une*periode
**************float*per_tim0*=*0.0000002;*//*temps*entre*deux*incrementations*du*timer0*=*0.2*microsceondes

**************TMR1CS_bit*=*1;***//*utilisation*pour*le*timer0*de*horloge*externe*a**quartz
**************T1SYNC_bit*=*0;***//*synchro*entre*l*incremenattion*du*timer*0*et*de*l*horloge*externe
**************T1OSCEN_bit*=*0;**//*oscillateur*interne*off*/*normal*(*on*s*en*sert*pas*)
**************T1CKPS1_bit*=*T1CKPS0_bit*=*0;****//*prediviseur*a*1*entre*timer0*et*horloge*externe*utilisé
**************
**************TMR1L*=*TMR1H*=*0;**********//*initialisation*du*timer0

**************do
**************{
************************if(PORTA.B0*=0)
************************{
*************************************a=0;****//*le*comptage*de*la*periode*commance*seulement*des*que*l'*on*detecte*le*premier*front*montant*si*non*on*reboucle*tant*que
************************}
************************if(PORTA.B0*=1)******//*le*comptage*de*la*periode*peut*commencer*car*on*as*detecte*le*premier*front*montant
************************{
************************************TMR1ON_bit*=*1;***//*mise*en*marche*de*l*incrementation*du*timer1
************************************do
************************************{
*************************************************if(TMR1IF_bit*=*1)****//**boucle*quidurant*le*comptage*de*la*periode*,*comptabilise*les*debordement*du*timer0
*************************************************{
**********************************************************dep=dep+1;
**********************************************************TMR1IF_bit*=*0;
*************************************************}
************************************}while(PORTA.B0*=1);
************************************TMR1ON_bit*=*0;***//*arret*de*l*incrementation*du*timer1
************************************temps*=*TMR1H*256+TMR1L;******//*calcul*de*la*valeur*contenu*si*on*accole*les*deux*registres*accolés*sans*compter*le*nombre*de*debordements
************************************tempstotal*=*dep*1024+temps;***//*calcul*nombres*d*incrementations*en*tout*durant*la*periode*,*debordements*multiples*compris
************************************periode*=*tempstotal*per_tim0;*//*calcul*periode*du*signal
************************************
************************************a=1;
*************************}

***************}*while(a=0);

*****PORTD*=*periode;*********//*On*envoie*les*8*bits*de*points*faibles*sur*le*port*D
*****PORTC*=*periode*>>*8;*//*On*fait*un*décalage*des*8*bits*de*poids*faibles*pour*faire*apparaitre*les*2*bits*de*poids*fort*restant*sur*le*PORTC

}*

[antek]

registre 16 bit a utiliser pour moi c est bien celui du TIMER1 ?

TMR1 affecte 2 registres TMR1L et TMR1H de 8 bits chacun.
Je ne sais pas comment c'est géré en MikroC.

Vérifier s'il ne serait pas préférable d'utiliser un timer 8 bit en fonction des fréquences d'horloge utilisées.

[paulfjujo]

Je ne sais pas comment c'est géré en MikroC.

Quelques exemples mode capture CCP ICI
avec mikroC et 16F ou 18F

Le mode CCP ne permet pas une tres large dynamique de mesure , si on ne gere pas les debordemnts de compteurs.
On peut aussi jouer sur le nombre de front accumulés ( valable sur certains PIC seulement)
pour garder une bonne résolution.
voir les test realises .. avec un generateur à quartz comme source de frequence.

Le mode Frequencemetre serait mieux adpaté au grandes vitesses (Freq elevée)
le timer compte le nombre de front du signal pendant un temps defini
Le mode Periodmetre CCP aux basses Frequence
le nombre de pulses FOSC (élevé) est compté entre le(s) front(s) du signal