Mesure de fréquence pic 16f628

[Ticlem]

Bonjour à tous,

Je me lance dans la programmation des pic, j'ai lu les cours de Mr. BIGONOFF, sur les pic 16f84.

Dans mon application je souhaite mesurer une fréquence d'un signal carré et allumer plusieurs leds à des fréquences différentes.

Je pense pour cela utiliser le pic 16f628 et le module ccp. Cependant je manque de connaissance sur ce pic, le nombre démesurer d'exemple que j'ai en assempbleur m'hérisse le poil et sont assez repoussant à travailler.

Je viens demander votre aide, si vous avez des piste de programmation en C (plus intuitif) et des documents sur le pic 16f628 ( en francais pour que je garder mes cheveux le plus longtemps possible) je suis preneur.

Merci d'avance de votre aide, je cherche vraiment à apprendre et surtout comprendre ce que je fait.
-----

[RISC]

Salut,

Tu télécharges le compilateur Lite gratuit ici : http://www.microchip.com/compilers

Ensuite tu lis les cours de C sur les PICs sur ce site français : http://www.aix-mrs.iufm.fr/formation...indexPIC_C.htm

a+

[Ticlem]

Merci pour tes liens RISC,

Je me suis renseigné sur le module ccp et plus particulièrement le mode Capture du pic 16f628 celui qui me conviet le plus.

J'ai compris comment mettre en place le mode capture en configurant les différents registres.

C'est à dire CCP1CON = 0b 0000 0101 pour capture à chaque front montant
Puis permettre les intérruptions et le timer1 : PIE1 = 0b 0000 0101
On efface les flags PIR1 = 0b 0000 0000

Et on active le timer1, configure le timer1 en timer et sans prescaleur (car ma période max est de 35918µs or le timer1 va de 0h 0000 à 0h FFFF soit 65350µs donc pas de débordement possible)

J'ai donc T1CON = 0b 0000 1001

Mais pour la suite j'ai un peu plus de mal, j'aurais donc deux captures 1er front montant = t1 et front montant suivant = t2 donc ma période = t2-t1, et comment sont gérer les fronts montants suivants?
Si j'ai bien compris j'utilise TMR1H et TMR1L pour lire le temps de mes captures, mais comment les manipuler? TMR1H correspond à la 1er capture et TMR1L à la deuxième?

Et à quoi servent CCPR1H et CCPR1L ?

Merci de votre aide

[Ticlem]

Alors j'ai compris que l'on vient copier les valeurs de TMR1H et TMR1L dans CCPR1H et CCPR1L quand on a le flag PIR1.2 de l'intérruption.

On obtient donc une valeur allant de 0h 0000 à 0h FFFF.

Voici mon code :

#include "int16CXX.h"

//---------------------ES et Variable--------------------------

bit Led1@RB2;
bit Led2@RB1;
bit Led3@RB0;

//--------------------Variables globales--------------------

char temps;
char cph;
char cpl;

//-----------------------Fonction principale---------------

void main(void)
{
TRISA = 0b00000000;
TRISB = 0b00001000;
PORTB = 0b00000000;
CCP1CON = 0b00000101;
T1CON = 0b00000001;

boucle: ;

temps = 0x0000;
cph = CCPR1H;
cpl = CCPR1L;
TMR1H = 0x00;
TMR1L = 0x00;
PIR1.2 = 0;

PIE1 = 0b00000101;
temps = cph*256;
temps = cpl + temps;
if (temps<0x138F)
{
Led1=1;
Led2=0;
Led3=0;
}
if (temps>0x138F && temps<0x09CA)
{
Led1=1;
Led2=1;
Led3=0;
}
if (temps>0x09CA)
{
Led1=1;
Led2=1;
Led3=1;
}
goto boucle;

}

Avec ce programme j'essaie d'allumer une led si la fréquence est inférieur à 200Hz, deux leds si la fréquence est supérieur à 200hz et inférieur à 400Hz et trois leds si la fréquence est supérieur à 400Hz bien sur je convertis les fréquences en périodes.

Avec la simulation sous proteus j'ai toujours qu'une seule led qui s'allume.

Cela m'amene donc à penser que les intérruptions ne sont gérées qu'une seule fois. Et le temps d'acquistion de la 1er intérruption est tellement rapide que le signal est toujours inférieur à 200Hz.

Comment faire pour obtenir un valeur de période à chaque front montant de mon signal ?
c'est à dire faire en sorte que l'acquisition des intérruptions soit continue afin d'avoir les leds qui s'allume en fonction de la période en temps réel.

Merci de votre aide

[A voir en vidéo sur Futura]

[RISC]

Salut,

Il va falloir impérativment apprendre à gérer les interruptions...

Lis les cours dont j'ai parlé plus haut et aussi celui-ci dédié aux PIC16 : http://www.aix2pic.net/

Le principe est le suivant :
* Quand tu as une interruption du module CCP, tu lis CCP1H et CCP1L
* Quand tu as une interruption TIMER (overflow) tu incrémentes le poids fort de val1 (17e bit) au cas ou tu pourrais avoir plusieurs dépassements :
Exemple si tu as val1= 0xFFFE et val2 = 0x0006
Autre possibilité, tu fais une soustraction SIGNEE : 0X0006 -0xFFFE = 6 - (-2) = 8 (CQFD)
* Tu fait une soustraction Val2 - val1 et tu obtiens un nombre d'impulsions que tu compares pour savoir quelle gamme de fréquence tu as.

Il te faut donc gérer les 2 interruptions ou 1 si tu n'as potentiellement qu'un dépassement.

Pour connaitre le nombre de dépassement max tu prends ton signal le plus faible fréquence. S'il est > 0xFFFF et < 0x1FFFF tu peux utiliser le mode signé sinon la méthode multi dépasements

Il faut bien sur mémoriser toujours ta dernière valeur val2 qui devient val1 de la prochaine soustraction...
N'oublie pas aussi de "nettoyer" le 17e bit et plus si nécessaire.

Ton timer doit bien sûr tourner en permanence

a+

[Ticlem]

C'est encore un peu vague :

Je lance le timer1 : T1CON = 0b 00000001

J'incrémente une variable (val1 si je comprend) qui correspond au dépassement du timer1 donc à chaque flag du timer1 dans INTCON si j'ai bonne mémoire.

Je configure le module capture avec CCP1CON

Puis j'efface les flags avec PIR1 et j'active le module capture avec PIE1

Petite tempo pour entre la mise en place du signal.

A la première intérruption je sauvegarde les registres CCPR1H et CCPR1l dans deux variables (par exemple cph1 et cpl1) et je sauvegarde la valeur de val1 (nbr de débordement du timer1).

Début boucle infini :
J'ai une deuxième intérruption je sauvegarde les registres CCPR1H et CCPR1l dans deux autres variables (par exemple cph2 et cpl2) et le nbr de débordement du timer1 dans une variable val2.

Ainsi ma période est égale à :

(val2 - val1)*65536 + (cph2-cph1)*256 +(cpl2-cpl1)*prédiviseur (ici prédiviseur = 1)

Puis pour les intérruptions suivantes je dois sauvegarder les valeurs des variables cph2, cpl2 et val2 dans cph1, cpl1 et val1 et enregistrer les nouvelles valeurs des registres CCPR1H et CCPR1L dans cph2 et cpl2 et toujours les débordements du timer1 dans val2.

Ainsi ma période correspond toujours à la même formule.
On reboucle .....


C'est bien cette procédure que je dois suivre, avec les intérruptions données par le flag dans PIR1 que je dois mettre à 0 entre chaque intérruption. Et également le flag du timer1 que je dois mettre à 0 à chaque fois que j'incrémente ma variable val1 ou val2?

[Ticlem]

Voilà le code que j'ai écris mis je n'ai aucun résultat sur proteus.... est ce que le code semble bon?

#include "int16CXX.h"

//------------------------------------ES et Variable------------------------------

bit Led1@RB2;
bit Led2@RB1;
bit Led3@RB0;

//-----------------------------------Variables globales-----------------------

char temps;
char calc;
char cmpt;
char cph1;
char cpl1;
char cph2;
char cpl2;
char val1;
char val2;
char front;

//-----------------------------------Fonction principale------------------------

void main(void)
{
TRISA = 0b00000000; // configuration en E/S des ports A
TRISB = 0b00001000; // confuguration en E/S des ports B
PORTB = 0b00000000; // Mise à zéro des ports B
CCP1CON = 0b00000101; // configuration du mode capture

PIR1 = 0b00000000; // Efface les flags
TMR1H = 0x00;
TMR1L = 0x00;

T1CON = 0b00000001; // configuration Timer 1
PIE1 = 0b00000101; // configuration et activtion du module capture

val1 = 0;
val2 = 0;
front = 0;

for ( ;; ){
if(PIR1.2==1) // si une intérruption
{
if(PIR1.0==1){++cmpt; PIR1.0 = 0;} // on vérifie si il y a eu un débordement du timer1 si oui on incrémente cmpt et on efface le flag
PIR1.0 = 0; // on efface le flag de l'intérruption
cph1 = cph2; // on sauvegarde les valeurs de cph2, cpl2 et val2 dans cph1,cpl1 et val1 pour la 1er période valeur erroné
cpl1 = cpl2;
val1 = val2;
cph2 = CCPR1H; // on sauvegarde les nouvelles valeurs de cph2, cpl2 et val2
cpl2 = CCPR1L;
val2 = cmpt;
}

temps = val2-val1;
temps = temps*65536;
calc = cph2-cph1;
calc = calc * 256;
temps = temps+calc;
calc = cpl2-cpl1;
temps = temps+calc;

if (temps<0x138F) // si fréquence < 200Hz
{
Led1=1;
Led2=0;
Led3=0;
}
if (temps>0x138F && temps<0x09CA) //si fréquence entre 200Hz et 400Hz
{
Led1=1;
Led2=1;
Led3=0;
}
if (temps>0x09CA) // si fréquence > 400Hz
{
Led1=1;
Led2=1;
Led3=1;
}
}
}
J'ai peut être fait des erreurs avec les si imbriqué.
Sinon à la premiere intérruption la valeur de période est érroné ce qui est normale vu qu'on a qu'une intérruption. Mais à partir de la deuxième normalement c'est juste.

Est ce que ce code est juste et permet bien d'obtenir la période d'un signal carré?

Merci de votre aide

[Ticlem]

Afin d'avoir un peu d'aide je suis parti sur plus basic et je me rend compte qui oui je dois apprendre à gérer mes intérruptions :

#include "int16CXX.h"

//------------------------------------ES et Variable------------------------------

bit Led1@RB2;
bit Led2@RB1;
bit Led3@RB4;
char temps;

//------------------------------------Interruption-----------------------------
#pragma origin 4

interrupt Timer0_Rb0(void)
{
int_save_registers

if(PORTB.0==1) {Led2 = !Led2;}
if(INTCON.2==1) {Led3 = !Led3; INTCON.2=0;}
if(INTCON.3==1) {++temps; if(temps==15){Led1 = !Led1; temps=0;} INTCON.3=0;}

int_restore_registers
}

//-----------------------------------Fonction principale------------------------

void main(void)
{
TRISB = 0b00001001; // confuguration en E/S des ports B
PORTB = 0b00000000; // Mise à zéro des ports B
TMR0 = 0;
INTCON = 0b10110000;
OPTION_REG = 0b11000111;

for ( ;; ){
nop();
}
}


Je sais au moins dans ce cas là qu'il y a bien de la vie dans la gestion de mes intérruptions puisque mes leds s'allument mais il se passe un peu n'importe quoi.
Pour la simulation j'utilise proteus sur un pc virtuel avec virtualbox......

Quand je lance mon programme :

ma led3 qui doit s'allumer quand j'ai le flag d'intérruption sur RB0 s'allume de manière normale que si je met la ligne de code avec la led2 sinon la led3 clignote très rapidement sans raison même si je n'ai pas d'intérruption sur RB0.......
Et la Led1 qui doit s'allumer quand j'ai le flag du timer ne s'allume jamais....

Aidez moi s'il vous plait à mieux gérer mes intérruptions et mon timer

[RISC]

Salut,

Ton programme est difficile à lire....
Utilise les balises CODE et /CODE entourées de crochets [] autour de ton code pour qu'il soit formaté correctement.

Tu n'as pas programmé les bits de configuration au début de ton programme. Il faut impérativement prendre l'habitude de le faire sous peine de gros PB ...

Quand on a une interruption avec les PIC16, il vaut mieux vérifier le flag au début de ta routine pour connaitre le périphérique qui l'a provoquée, même s'il n'y en a qu'un. Cela facilitera l'addition d'autres interruptions.

a+

[Ticlem]

Très bien je mettrais les balises,

merci de ton aide, quels bits de configurations ai-je oublié?

Je ne suis pas trop tes remarques, peux tu les illustrer, ou m'éclaircir???

[Ticlem]

Tu n'as pas programmé les bits de configuration au début de ton programme. Il faut impérativement prendre l'habitude de le faire sous peine de gros PB ...

Quand on a une interruption avec les PIC16, il vaut mieux vérifier le flag au début de ta routine pour connaitre le périphérique qui l'a provoquée, même s'il n'y en a qu'un. Cela facilitera l'addition d'autres interruptions.

a+

Quand tu parles des bits de configuration il s'agit de ligne #pragma bit (nom) @ ........ ????????
Justement de quoi s'agit il, à quoi cela sert il?

Et en ce qui concerne vérifier les flags au début de routine, tu veux dire mettre des if..... exemple : if(TOIF)... ?

Merci de ton aide

[Ticlem]

J'arrive enfin à gérer les intérruptions sur Rbo de manière propre, en faisant clignoter une led.
J'arrive également à gérer les intérruptions du Timer 1 de la même manière en faisant clignoter une led.

Mais je n'arrive pas à gérer simplement les intérruptions du module capture de CCP1.

#include "int16CXX.h"

//------------------------------------ES et Variable------------------------------

bit Led1@RB2;
bit Led2@RB1;
bit Led3@RB4;
char temps;

//------------------------------------Interruption-----------------------------
#pragma CCP1IF @ PIR1.2
#pragma CCP1IE @ PIE1.2
#pragma origin 4

interrupt RB3(void)
{
int_save_registers

if(CCP1IF==1){Led1 = !Led1; CCP1IF=0;}

int_restore_registers
}

//-----------------------------------Fonction principale------------------------

void main(void)
{
	TRISB = 0b00001001;					// confuguration en E/S des ports B
	PORTB = 0b00000000;					// Mise à zéro des ports B

    INTCON = 0b11000000;   			// activation interruptions périphériques
 	CCP1CON = 0b00000101;			// configue de ccp à chaque front montant
    PIE1 = 0b00000100;   			//activation interruption de ccp1        
	PIR1 = 0b00000000;

for (;;){	
			nop();
		}
}

Pouvez vous me dire ou est mon erreur,je cherche mais en vain.....

Je simule avec proteus....

Merci de votre aide, on peut remarquer une certaine progression tout de même dans mes programmes par rapport à mes post précedent.

[Ticlem]

Un petit coup de main pour l'intérruption module ccp........

[Ticlem]

Personne ne peut m'aider sur le mode capture!

Pour l'instant j'aimerai de l'aide sur l'interruption du mode capture puis après je rajouterai le timer1

Pourquoi mon derniere petit code ne fonctionne pas sur proteus?

[RISC]

Salut,

Quel compilateur utilises-tu ????

Concernant les bits de configuration, tu ouvres la datashet du PIC16F628 et tu lis le chapitre "Special Features".
Ces bits sont VITAUX pour le démarrage et le fonctionnement du PIC car ces choix ne peuvent pas être changés une fois le RESET relaché...

Tu lis aussile cours de Bigonoff pour comprendre (au moins la partie dédiée au CCP).

Le mode capture est aussi expliqué ici.

Avant de courir il faut marcher....et acquérir les bases avant de bruler les étapes et de tourner en rond (on est tous passé par là et on y repasse de temps en temps ;=)

a+

[Ticlem]

Merci de ton aide RISC,

Cette page :
http://www.ccsinfo.com/forum/viewtopic.php?t=41962

ma confirmé que c'est bien proteus qui ne simule pas le mode capture avec les pic 16f. Ainsi mon code précedent fonctionnerait pour un essai réel.

Je suis donc passé au pic 18f, notamment le 18f2553 car j'ai vu une platine d'essai avec ce pic, que pensez vous de ce pic? Généralement quel quartz avons nous avec?

J'ai donc lu le cours sur le site que RISC ma donné : http://www.aix-mrs.iufm.fr/formation...indexPIC_C.htm

Il traite un exemple de mode capture voici le code que j'ai repris :

#include "p18f2553.h"
    
 //------------------------------------ES et Variable------------------------------

unsigned int periode=0;
char maj=0; // indique qu'une nouvelle mesure est prête.

 //------------------------------------Interruption-----------------------------

#pragma interrupt itercapt

void itercapt(void)
{
      
   if(PIR1bits.CCP1IF == 1)  {
						periode = CCPR1;
						maj =1;
							}	
			
 PIR1bits.CCP1IF = 0;
        	
}   
 
#pragma code interruption=0x8
void ma_fonction (void)
{
_asm goto itercapt _endasm
}


//-----------------------------------Fonction principale------------------------
#pragma code
void main(void)
{
	TRISC = 0b00000100;					// confuguration en E/S des ports B
	PORTC = 0b00000000;					// Mise à zéro des ports B

	TRISB = 0b00000000;
	PORTB = 0b00000000;

	T1CON  = 0b00000001; 			//démarre TMR1, avec PreScaler = 1

	T3CONbits.T3CCP2 = 0;			// active Timer1 avec mode capture
	CCP1CON = 0b00000101;			// configue de ccp à chaque front montant

   	PIE1 = 0b00000100;   			//activation interruption de ccp1  
			
	RCONbits.IPEN = 1;				// Interruption prioritaires activées

	
	INTCON = 0b10000000;   			// activation interruptions périphériques	
	
while(1){
		if(maj){ 
			if(periode < 34000) {PORTB=0b00000001;} else {PORTB=0b00000010;}
			maj=0;	
				}
		}
}

J'ai maintenant bien une led qui s'allume avec le mode capture, mais je n'arrive pas à la faire clignoter avec le symbole "!" non (pas de le code ci-joint). Ce symbole "non" existe bien sous MCC18?

Ensuite dans l'exemple il utilise la variable période qui prend la valeur du registre CCPR1. Ce registre existe? Ne faut il pas créer trois variables une CCPR1H et l'autre CCPR1L et le débordement du timer 1, comme j'ai pu le lire dans le cours de Mr.Bigonoff?

De l'exemple je comprends que la variable "periode" me donne ma période en µs, cela me parait bizarre... je me trompe?

Merci de votre aide

[Ticlem]

Voila le code ou je cherche à faire clignoter ma Led, celle-ci s'allume dès le début et reste allumé.

#include "p18f2553.h"
    
 //------------------------------------ES et Variable------------------------------

unsigned int periode=0;
char maj=0; // indique qu'une nouvelle mesure est prête.

 //------------------------------------Interruption-----------------------------

#pragma interrupt itercapt

void itercapt(void)
{
      
   if(PIR1bits.CCP1IF == 1)  {
						PIR1bits.CCP1IF = 0;
						PORTBbits.RB0=!PORTBbits.RB0;
							}	
       	
}   
 
#pragma code interruption=0x8
void ma_fonction (void)
{
_asm goto itercapt _endasm
}


//-----------------------------------Fonction principale------------------------
#pragma code
void main(void)
{
	TRISC = 0b00000100;					// confuguration en E/S des ports B
	PORTC = 0b00000000;					// Mise à zéro des ports B

	TRISB = 0b00000000;
	PORTB = 0b00000000;

	T1CON  = 0b00000001; 			//démarre TMR1, avec PreScaler = 1

	T3CONbits.T3CCP2 = 0;			// active Timer1 avec mode capture
	CCP1CON = 0b00000101;			// configue de ccp à chaque front montant

   	PIE1 = 0b00000100;   			//activation interruption de ccp1  
			
	RCONbits.IPEN = 1;				// Interruption prioritaires activées

	
	INTCON = 0b10000000;   			// activation interruptions périphériques	
	
while(1);
}

Pourquoi elle ne clignote pas?
Est ce encore un problème de simulation de proteus, je ne pense pas....

[Ticlem]

Voila un code qui fonctionne.......

#include "p18f2553.h"

 //------------------------------------ES et Variable------------------------------

unsigned int periode;
unsigned int ancien;

 //------------------------------------Interruption-----------------------------

#pragma interrupt itercapt

void itercapt(void)
{
      
   if(PIR1bits.CCP1IF)  {						
						periode = CCPR1 - ancien;
						ancien = CCPR1;
						}	
   PIR1bits.CCP1IF = 0;    	
}   
 
#pragma code interruption=0x8
void ma_fonction (void)
{
_asm goto itercapt _endasm
}


//-----------------------------------Fonction principale------------------------
#pragma code
void main(void)
{
	TRISC = 0b00000100;					// confuguration en E/S des ports B
	PORTC = 0b00000000;					// Mise à zéro des ports B

	TRISB = 0b00000000;
	PORTB = 0b00000000;

	T1CON  = 0b00000001; 			//démarre TMR1, avec PreScaler = 1

	T3CONbits.T3CCP2 = 0;			// active Timer1 avec mode capture
	CCP1CON = 0b00000101;			// configue de ccp à chaque front montant

   	PIE1 = 0b00000100;   			//activation interruption de ccp1  
			
	RCONbits.IPEN = 1;				// Interruption prioritaires activées
	
	INTCON = 0b10000000;   			// activation interruptions périphériques	
	
while(1){
	
		if (periode==10000){PORTB=0b00011000;}
		if (periode==2000){PORTB=0b00100100;}
		if (periode==1000){PORTB=0b10000001;}

		}
}

J'ai bien mes lumières qui s'allument à la bonne periode.
Bien sur je ne gère pas le débordement du timer, donc pour avoir un résultat correct ma période doit être inférieur à 65536µs.

Cependant j'ai quelques questions :

- Mes lumières restent éclairées même quand la condition de mes "if" n'est pas respecté, si je rajoute une condition "else" pour éteindre sinon mes led clignotent anormalement. Quel est le soucis?

- Est ce que le registre CCPR1 existe aussi avec un pic 16F? Puis je retranscrire facilement ce code pour un 16f?

Merci de votre aide

[Ticlem]

Au faite j'utilise le compilateur Mcc18 pour les pic 18f et cc5x pour les 16f mais j'ai également en secour Hi-tech pour les 16f et 18f le tout avec Mplab.