PIC C 18F - Interruption 1S

[invite0098df65]

Bonjour,

Total débutant sur la programmation de pic j'essaie de crée une interruption dans mon programme tous les 1 seconde.
J'utilise un PIC 18f452 et un quartz a 40Mhz et mon Prescaler est réglé a 1:128.

J'ai trouvé un bout de code pour faire des interruption tout les 800us mais je n'arrive pas à le modifier pour ce que je voudrai faire, quelqu'un pourrait me dire comment procéder ?

Method 1: execute code every 800us by using polling to check the bit in main()

//(c)Shane Tolmie, http://www.microchipc.com/, distribute freely for non commercial use on the condition that you include this web link somewhere in your document.
#include <pic.h>
#define POLLING_PERIOD 200    //with 4Mhz processor, 200us    
#define TMR0_PRESCALER 1      //gives 1:4 prescaler
//the -3 factor is to make up for overhead
//the 0xff- factor is because the timer counts *up* to 0xff
//do not change this
#define TMR0_SETTING (0xff - (POLLING_PERIOD-3))  

main()
{
   OPTION&=0B11000000;        //turn off bottom 6 bits to configure tmr0
   OPTION|=TMR0_PRESCALER;    //set prescaler to 1:4
   while(1)
   {
      TMR0=TMR0_SETTING;
      T0IF=0;         
      while(T0IF==0);   //wait 800us for flag to go high
      //OK, tmr0 has overflowed, flag T0IF has gone high
      //this code right here is executed every 800us
   }
}

http://www.microchipc.com/HiTechCFAQ/#_Toc475127540

Merci d'avance
-----

[invite7a49d0d5]

Bonjour,

je vois pas l'interruption dans ton code...
(registre INTCON et associés...)...

sinon pour redéfinir une période/fréquence,
avec Q=40Mhz et PRE=128, il suffit de se
reporter à ta datasheet...

vede
;O]
___________________
...

[invite7a49d0d5]

ps :
@ 40Mhz et même avec le prescaler "à fond" (128),
tu auras du mal à dépasser 3,2768ms avec TMR0 à cette vitesse (40Mhz)
(0.1µs * 128 * 256)... il te faudra ajouter un "compteur" d'interruptions...

.

[invite0098df65]

je vois pas l'interruption dans ton code...
(registre INTCON et associés...)...

L'interruption se fait quand le programma arrive sur le while ?
Il est vraiment nécessaire de rajouté INTCONT ?

Dans la datasheet pour le moment je n'ai pas trouvé comment le redéfinir en dur dans le programme....

Pour le compteur cela signifie que je dois réaliser 30 fois cette fois cette boucle while pour attendre une seconde ? (boucle for qui itére l'opération 30 fois).

[A voir en vidéo sur Futura]

[invite7a49d0d5]

re ;O]

L'interruption se fait quand le programma arrive sur le while ?

non...

Il est vraiment nécessaire de rajouté INTCON(T) ?

oui, si tu veux utiliser l'interruption sur TMR0...

Dans la datasheet pour le moment je n'ai pas trouvé comment le redéfinir en dur dans le programme....

section 8 (interruptions) puis 8.7 (sur TMR0)... dans la datasheet...

Pour le compteur cela signifie que je dois réaliser 30 fois cette fois cette boucle while pour attendre une seconde ? (boucle for qui itére l'opération 30 fois).

plutôt 300 (x3ms = 1s), et un avec compteur dans l'interruption...
pas une boucle dans le main...

[invite7a49d0d5]

ps :

regardes le post n° #12 de ce fil, c'est un exemple basique
d'utilisation d'un timer et son interruption pour faire clignoter une led :
http://forums.futura-sciences.com/el...c16f690-2.html
(notamment le "programme principal" = boucle sans fin qui ne fait rien...)...

et fouines par là pour trouver mes autres tentatives d'explications
des principes de fonctionnement des timers et interruptions :
http://forums.futura-sciences.com/se...archid=4080272

[invite0098df65]

Bonsoir,

Je n'ai toujours pas réussi a réaliser cette interruption, mais je commence à comprendre comment utiliser les registres d'un pic.
Une adresse pour retrouver la datasheet de mon pic : http://clubs.ens-cachan.fr/krobot/do...xx8/18Fxx8.pdf

Tout d'abord revenons au calcul :
J'utilise un PIC18 cadencé à 40Mhz dont le prescaler mis au max est à 1:256.
J'ai donc 0,1µs*256*256 = 6,55 opération par ms ?
Si je veux une interruption d'une seconde il faut donc que je réalise 150 fois l'opération.

Ci-dessous mon code pour le compteur d'interruption en C :

#include <îc18fxx8.h>

void tempo(long temps);
void setup(void);

int flag_timer = 0;

void man(void)
{
	setup();
	while (1)
	{
		// mes instructions ici
		
		// interruption dans le programme
		tempo(....une certaine valeur....);
	}
}

void setup (void)
{

	TRISA = 0x03;
	
	PORTA = 0;
	
	T0CON = 0b00001111; 	/* Registre permettant de controller les aspects de Timer0,
			       	   notamment la selection du prescaller, ici prescaler 1:256 et timer0 sur Off */
	TMR0IE = 1;		// autorise les interruptions sur Timer0
	TMR0IF = 0;		// efface le flag d'overflow de Timer0
	GIE = 1;		// autorise les interruptions
	
	ADCON1 = 0x07;		// Passage du Port A en numérique
}

void tempo (long temps)
{
	TMR0H = 0; 	//Reset du timer - Registre de 16 bits
	TMR0l = 0;	

	TMR0ON = 1; 	//On lance le timer
	while (TMRO <= temps)
	TMROON = 0; 	//On stop le timer
}

Si mon code est correct, quel valeur dois-je mettre dans ma fonction tempo ?

Merci d'avance

[invite0098df65]

Sachant que je ne dois pas dépasser la taille d'un int de 16bits donc 65535 au maximun (si je comprends bien :s ).

[invite7a49d0d5]

Bonsoir,

en neffet ;O] tu as bien compris ;O]

je regarde ton code et tes calculs en détails et je re-poste dans la soirée...

vede
;O]
_________________
...

[RISC]

Salut Pir@nh@,

Tu as dis que tu utilises un quartz à 40MHz ?
Je te recommande de plutôt utiliser un quartz à 10MHz et d'activer la PLL x 4 car cela génèrera moins de bruit (EMI)...

Concernant le TIMER0, je te recommande d'activer le mode 16bits du TIMER0 : T0CONbits.T08BIT=0;

Si tu utilises le prescaler à 1/256 : T0CONbits.TPS=0b111;

Donc tu peux au maximum avoir un taux de division de :
256 * 65536 = 16777216

Si tu veux une interruption chaque seconde il suffit de choisir comme suite le prescaler et TMR0 :
Fosc / 4 = 40MHz / 4 = 10MHz --> 100ns.
Il faudrait donc compter 10.000.000...Malheureusement avec un prescaler de 256, le plus proche serait : 39062 ou 39063 (valeur à atteindre = 39062,5).
Avec le prescaler de 1/8 et PR0 = 25000 tu aurais un taux de division de 1/200000, il faudrait donc compter 50 interruptions pour avoir un compte exact et un delai de 1s ;=)

a+

[invite0098df65]

Merci à vous deux pour vos réponses.

Malheuresement je ne peux pas changer de quartz (il m'est imposé) et j'ai bien des problèmes d'EMI mais je suis obligé de faire avec ; le simple fait de passer la main au dessus du quartz pertube son oscillation. Je suis actuellement en HS, je peux très bien passer en PLL x4, cela divise bien la fréquence par 4 ?

Quand je verifie avec la datasheet, T0CON (le registre qui gére mon timer0) est bien activer en mode 16 bits, avec un prescaler a 1/256.
T0CON = 0b00001111;

Je ne comprends pas entierrement tes calculs RISC, c'est pourquoi je remet le détail ci-dessous :

T = 1 / f

1 Mhz = 1*10^6 Hz
(1 µs = 1*10^-6 s et 1 ns = 1*10^-9 s)

Pour un pic mis sur la PPL x4 je suis en 10 Mhz :

T = 10*10^-6 s soit 10µs, et 10µs est égal à 100000 nanosconde (car (1*10^-5)*(1*10^9)).
Pour faire une interruption d'une 1s, il me faut donc attendre 10*10^6 soit 10000000 cycles.

Avec un prescaler a 1:256 => 39062,5 cycles par seconde.
Avec un prescaler a 1:64  => 156250 cycles par seconde. 
Avec un prescaler a 1:8   => 1250000 cycles par seconde.

Avec le prescaler de 1/8 et PR0 = 25000 tu aurais un taux de division de 1/200000, il faudrait donc compter 50 interruptions pour avoir un compte exact et un delai de 1s ;=)

A partir de là je ne comprends pas, déjà qu'est-ce que PR0 ? Je ne le trouve pas dans ma datasheet. Comment ça un temps de division de 1/200000 ?

Et surtout qu'est-ce qui manque à mon code pour implémenter tout ça, dans ma fonction tempo je devrais mettre "25000" et relancer 50 fois mon compteur, quelque chose comme :

void tempo (long temps)
{
	int i;

	for (i=0 ; i<50 ; i++) {
		TMR0H = 0; 	//Reset du timer - Registre de 16 bits
		TMR0l = 0;	

		TMR0ON = 1; 	//On lance le timer
		while (TMRO <= temps)
		TMROON = 0; 	//On stop le timer
	}
}