timer et config pic 18f26k22

[jojo150393]

Bonjour a tous,
j'utilise des fonctions de temporisation et j'ai un problème qui pour moi n'est pas logique.
J'ai crée une première fonction tempoms qui réalise une temporisation en ms et qui marche très bien. J'en est crée une autre tempous qui réalise une temporisation en µs. Celle-ci à juste le prescaler et TMR0 qui change et pourtant je n'obtient pas du tout des µs. Voici mon programme:

#include "p18cxxx.h"

/*
*  prototypes
*/
void init();
void tempoms(unsigned long int ms);
void tempous(unsigned long int us);

/*
*  constantes
*/
void main()
{	
	init();
	while(1){
		PORTAbits.RA0 = 1;
		tempous(65000);
		PORTAbits.RA0 = 0;
		tempous(65000);
	}
}

/*
*  fonctions
*/
void init(){
	/**config oscillateur : 16Mhz*PLL = 64Mhz **/
	OSCCON   = 0b01110100;
	OSCCON2 = 0b10000111;
	OSCTUNE = 0b11000000;

	/*** entrée N/A ***/
	ANSELC = 0b00000000;  //

	/*** I/O ***/
	TRISA = 0x00; //port A en sortie 
	TRISB = 0x00; //port B en sortie 
	TRISC = 0x00;


}

/*
* T =64Mhz/(4*128*125) = 1ms
*
*/
void tempoms(unsigned long int ms){
	unsigned long int i = 0;
	T0CON = 0b11000110;  //en ms     T =64Mhz/(4*128*125) = 1ms
	for(i=0;i<ms;i++){
		INTCONbits.TMR0IF = 0; // RAZ du flag
		TMR0L = 131; //256-131 = 125. 
		while(INTCONbits.TMR0IF == 0);	
	}	
}


/*
* T =64Mhz/(4*16) = 1us
*
*/
void tempous(unsigned long int us){
	unsigned long int i = 0;
	
	T0CON = 0b11000011;  //prescaler = 16
	for(i=0;i<us;i++){
		INTCONbits.TMR0IF = 0; // RAZ du flag
		TMR0L = 255; 
		while(INTCONbits.TMR0IF == 0);	
	}	
}

décidément je ne comprend pas du tout pourquoi cela ne marche d'où ma demande sur FS
-----

[invite5637435c]

* T =64Mhz/(4*128*125) = 1ms

et

T =64Mhz/(4*16) = 1us

vous ne voyez pas comme un problème dans vos formules???

[invite5637435c]

void tempous(unsigned long int us){
	unsigned long int i = 0;
	
	T0CON = 0b11000011;  //prescaler = 16
	for(i=0;i<us;i++){
		INTCONbits.TMR0IF = 0; // RAZ du flag
		TMR0L = 255; 
		while(INTCONbits.TMR0IF == 0);	
	}	
}

Comment voulez-vous que ce genre de code fonctionne bien?
Et bloquer tout le reste du code pour faire un délai c'est vraiment pas élégant.
Il faut récupérer le passage à 1 du flag de débordement du timer0 et cela ne peut-être fait que dans la routine d'interruption, certainement pas à la volée dans une fonction.
Votre quartz travaille à 64MHz soit 16MHz de fréquence pour le cadencement du µC ou encore 62.5ns de temps de cycle.
Vous devez donc compter pour 1µs (=1000ns): 1000/62.5=16

Donc vous vous contentez d'un timer 8 bits sans prescaler, vous préchargez la valeur 256-16=240 dans le timer puis vous attendez que le flag de débordement soit activé automatiquement par le timer pour valider votre µs.
Attention c'est bien 256 et non pas 255 comme on le voit trop souvent sur le net, le drapeau n'est levé que lors du passage de 255 à 0 donc bien 256 coups d'horloge.

[invite5637435c]

Comme je sens venir la question suivante: "comment je fais pour avoir n'importe quel tempo en µs sur cette base là?"

Il suffit d'extrapoler ce que je vous ai indiqué plus haut en mettant un multiplicateur n.

Exemple: on veut 20µs

unsigned int n=20;
volatile int index=0;

void interrupt(void){

if((TMR0IF) && (INT0IE))  // si drapeau débordement du timer0 activé
  {
  index++;  // on incrémente à chaque débordement
  if(n == index)  // n represente n fois 1µs si match alors... 
   {
   flag_tempo = 1;  //... alors on active une variable (ou allumer une led) 
   index = 0; // on remet évidemment index à 0 pour un nouveau cycle de comptage ou on dévalide le timer (TMR0IE = 0)
   }
 TMR0IF = 0;  // et le drapeau du timer remis à 0 pour qu'un nouvel évènement puisse se produire
 }
}

code pas testé, mais le principe y est, reste à tester.
Si on veut pinailler il faut tenir compte des temps de cycles que dure certaines instructions après la levée du drapeau du timer, vu qu'à partir de ce moment là le temps s'écoule toujours...
Le plus simple souvent est de compter un peu moins genre quelques cycles et d'ajuster avec des NOP en assembleur pour avoir pile poil le temps souhaité.
@+

[A voir en vidéo sur Futura]

[jojo150393]

Merci pour la réponse.
Ma foi moi c'est les profs qui m'ont appris à faire comme cela alors bon ...
Mais utiliser une interruption pour simplement réaliser un délai cela me permet un peut superflus mais bon je vais en prendre note.

Et dans la formule, je suis désolé mais je ne vois pas d'erreur. 64/(4*16) = 1Mhz soit T = 1µs ...

[invite5637435c]

Tu écris:

T =64Mhz/(4*16) = 1us

Je doute qu'écrit ainsi le temps T soit juste...

En écrivant T=(4/64MHz)*16 là ça devient tout de suite plus cohérent.
Il faut être précis dans ce métier.
@+

[invite5637435c]

Mais utiliser une interruption pour simplement réaliser un délai cela me permet un peut superflus mais bon je vais en prendre note.

Pourquoi?
Ca aussi c'est tes profs qui t'ont inculqué ce genre de principe idiot?

[jojo150393]

absolument
Pour eux les flags s'utilisent de deux manières : Soit en scrutant le flag, soit en autorisant les interruptions.
Pour eux, une tempo s'utilise avec un flag. Deux manières de coder différente pour la même chose.

Bon en tout cas je vais essayer ta méthode ce que j'aurais du faire avant et si ça marche toujours pas alors c'est qu'il y a un autre problème.

Merci

[jojo150393]

Bon bin décidément j'y arrive pas...
j'ai changé de compilo pour Hi tech j'en avais marre des lignes a rallonge de C18
voici mon code :

unsigned  long int n = 65535;
unsigned long int index = 0;

void main()
{	
	init();
	T0CON = 0b11000000; 
	TMR0L = 240; //T = 1µs
	TMR0IF = 0; 
	while(1);
}

/*
*  interruptions
*/
void interrupt it_prioritaire(){

	if(TMR0IF){
		RA1 = 1; // confirmation IT
		index++;
		if(index == n){
			LED = !LED; 
			index = 0;
		}
		TMR0IF = 0;	
		TMR0L = 240; 
	}	
}

et la fonction init :

void init(){
	/**config oscillateur : 16Mhz*PLL = 64Mhz **/
	OSCCON   = 0b01110100;
	OSCCON2 = 0b10000111;
	OSCTUNE = 0b11000000;

	/*** entrée N/A ***/
	ANSELC = 0b00000000;  //

	/*** I/O ***/
	TRISA = 0x00; //port A en sortie 
	TRISB = 0x00; //port B en sortie 
	TRISC = 0x00;
	
	/*** Interruptions ***/
	GIE = 1; //IT enable
	TMR0IE = 1; //IT du timer 0 enable	
}

Ma led s'allume bien mais si je change la valeur de n, cela ne change que la luminosité.
C'est quand même incroyable que je n'arrive même pas à faire marcher un ptit pic ... ça craint
Pourtant j'ai l'impression de faire les chose correctement mais je ne vois pas ce qui cloche.

[paulfjujo]

bonsoir,


Ta boucle est trop rapide , meme avec n=65535µS => 65mS
si n est un entier long pourquoi ne pas mettre 1000000 µS => 1sec
et là l'effet sera bien visible.

[invite5637435c]

absolument
Pour eux les flags s'utilisent de deux manières : Soit en scrutant le flag, soit en autorisant les interruptions.
Pour eux, une tempo s'utilise avec un flag. Deux manières de coder différente pour la même chose.

La meme chose? non.
Un evenement qui est tres rapide doit se traiter par interruption sans quoi tu joues au loto et comme au loto tu as tres peu de chance de gagner.
La scrutation c'est bien quand il n'y a pas le feu.
Si tu veux de la precision sur une tempo et ne pas bloquer le reste du programme tu n'as qu'un seul choix possible.

Le jour ou tu auras plus de 10.000 lignes de codes dans ton programme tu comprendras mieux ce que j'essaye de te dire

[invite5637435c]

Ta boucle est trop rapide , meme avec n=65535µS => 65mS
si n est un entier long pourquoi ne pas mettre 1000000 µS => 1sec
et là l'effet sera bien visible.

+1************************

[jojo150393]

Merci pour vos réponses.
J'y est pas mal réfléchi et en regardé les sources assembleurs, on voit tout de suite la longueur d’exécution d'un tel système. C'est pour cela que je ne le remarquais pas sur la temporisation en milliseconde. J'en est parlé à mon prof et il à confirmé. Il ma aussi conseillé de tout simplement de l'ajusté empiriquement vu que j'ai pas besoin d’énormément de précision.

Merci hulk pour tout tes conseilles précieux j'en prendrais note quand le moment viendra. Pour le moment j'essaye d'aller au plus simple vu que je suis encore en train d'apprendre.

[invite5637435c]

Je comprends, mais souvent prendre le bon chemin s'avere etre aussi le plus court
Il est dommage de faire quelque chose "empiriquement" quand c'est aussi trivial.