Interruptions multiples avec un pic 18f45j50

[invited003d5fc]

Bonjour,

Je suis actuellement sur un programme en C, et je dois gérer trois interruptions (une de priorité haute, les deux autres basses).

A la base, j'avais un timer2, qui doit gérer une modulation de courant.
J'y ai ajouté une interruption lorsque le pic reçoit quelque chose en usart (afin de gérer des trames).

Jusqu'ici, ça fonctionnait plutôt bien.

Puis, j'ai ajouté un timer4, et là, ça a commencé à partir un peu n'importe comment.

J'ai quelque peu lutté avec les déclarations des interruptions, et je pense que le problème vient de là. Je n'ai pas trouvé grand chose sur internet à propos des interruptions multiples pour une même priorité, je suppose donc que c'est très simple...

Voilà un bout de code :

void Timer2Int(void);

#pragma code Hight_vector=0x08				// The hight interrupt vector is found at 0x08.
void Interrupt_at_Hight_vector(void)
{
_asm GOTO Timer2Int _endasm					// jump to the ISR
}
#pragma code 								// return to the default code section 


void Timer4Int(void);
#pragma code Low_Vector=0x18		
						
void InterruptTimer4(void)
{
_asm GOTO Timer4Int _endasm					// jump to the ISR
}
#pragma code 								// return to the default code section 


void Usart1Int(void);

//#pragma code IntUsart=0x18				// The low interrupt vector is found at 0x18.
#pragma code Low_Vector				

void InterruptUsartInt(void)
{
_asm GOTO Usart1Int _endasm					// jump to the ISR
}
#pragma code 								// return to the default code section

Pour l'instant, Timer2 n'est pas allumé, Timer4 fait commuter une del toutes les 250ms, et UsartInt ne fait rien tant qu'on envoi pas de trame.

La del commute bien, c'est génial... sauf que si j'envoi une trame, elle se met à changer d'état toutes les 3µs.
(de plus usart ne reçoit alors qu'un seul octet de la trame, mais je pense que ça vient du fait que le programme est occupé dans le timer4)

Je commence à sécher là, et la doc de MPLab ou de C18 ne m'aide pas vraiment (faudrait-il passer par des nested interrupts ?)
-----

[RISC]

Salut,

Les PIC18 ont 2 vecteurs d'interruption et ne permettent pas d'imbriquer les interruptions sauf à réautoriser les interruptions à l'intérieur d'une interruption ce qui est toujours délicat...

Il faut tout d'abord être sûr que le code d'interruption exécuté est suffisamment court pour pouvoir ne pas louper d'interruptions.

A quelle fréquence fais-tu fonctionner ton PIC (Fosc) ?

Quelle version de MPLAB utilises-tu ?
Quelle version du compilateur C18 ?

As-tu une license du compilateur ? (Le mode optimisé permet de compresser la taille du code et de diminuer le temps d'exécution)

Il existe un bon webseminar concernant l'optimisation des interruptions pour le C18.

Voilà le lien d'un bon support de cours pour les PIC18 et le C18.

Il y a aussi pas mal d'exemples de code pour le PIC18 ici.

Ton minuscule morceau de code ne permet pas de comprendre quoi que ce soit...

a+

[invited003d5fc]

J'utilise MPLab 8.43 et C18 v3.34.

Le compilateur fonctionne bien en mode optimisation, et mon pic tourne à 48MHz.

Si mon code n'est pas compréhensible, c'est probablement parce que c'est là qu'il y a l'erreur/les erreurs.

En gros, j'ai essayé de faire un vecteur d'interruption en high pour le timer2, puis deux en low pour celles sur usart, et le timer4.

Si j'ai bien compris, il ne devrais y en avoir qu'un de chaque ? Celui en low devrait renvoyer sur une fonction, qui suivant le flag levé, ferait ce que j'ai prévu dans usart1int, ou timer4int ?

J'ai essayé, mais ça ne s'est pas avéré convaincant... Plutôt catastrophique en fait. (aucun des deux lows ne fonctionnaient, mais le programme passait dans le timer2, qui lui n'était pas censé être lancé )

void Timer2Int(void);

#pragma code Hight_vector=0x08				// The hight interrupt vector is found at 0x08.
											// The low interrupt vector is found at 0x18.
void Interrupt_at_Hight_vector(void)
{
_asm GOTO Timer2Int _endasm					// jump to the ISR
}
#pragma code 								// return to the default code section 
#pragma interrupt Timer2Int					//timer0Int as a hight priority interrupt 


void InterruptLow(void);

#pragma code Low_Vector=0x18		.

void InterruptLow(void)
{
 _asm GOTO ChoixInterruption _endasm					// jump to the ISR	

}
#pragma code 								// return to the default code section 

//****************************************//

#pragma interruptlow ChoixInterruption
void ChoixInterruption(void)
{
 if(PIR3bits.TMR4IF==1)
   {
	Timer4Int();					// jump to the ISR	
   }
   else{
		Usart1Int();					// jump to the ISR	
	   } 
}

/************************************************************/	//Execution toutes les 34.75µs
//////////////////////Interuption timer 2/////////////////////	//Attention, les appel de fonction dans le timer faisaient ramer le programme
/************************************************************/	//si des calculs étaient programmés quelque part, et ce même si ces calculs
																//n'étaient pas utilisés.

#pragma interrupt Timer2Int					//timer0Int as a hight priority interrupt 

void Timer2Int(void)	
{	
	CS_Dac=0;					// Select Dac Module
	
	PIR1bits.TMR2IF=0;					// Raz du flag dépassement Timer2
	
	
	if (Choix_Soin == Detoxication)
		{
		ValTab = Sinus22[n];			//Lecture de la table Sinus22
		
		if(n==0 || n==345 || n==691 || n==1036)
		TopDetox = 0;					// 
		
		if(n==46 || n==391 || n==737 || n==1082)
		TopDetox = 1;					// Raz sortie potentiomètre numérique
		
		n++;							// Incrémentation indice de la table Sinus22
		
		if (n == 1382)					// Echantillons Table = 1382 ?
		n=0;							// Indice de la table à 0
		
		}
		
	if (Choix_Soin == Tonification)
		{
		ValTab = Tonif[n++];			// Lecture et Incréméntation de la table Tonification
		TopDetox = 0;					// 
		if (n == 1344)					// Echantillons Table = 1344 ?
		n=0;							// Indice de la table à 0
		}
	
	StopCalcul++;
 
	if(Choix_Soin == Detoxication || Choix_Soin ==Tonification)
	  {
       TempVar = SSP2BUF;           // Clears BF
       PIR3bits.SSP2IF = 0;         // Clear interrupt flag
	   SSP2BUF = 0x30;          // write byte to SSP2BUF register
	   while(!PIR3bits.SSP2IF); //wait until bus cycle complete
	
	   TempVar = SSP2BUF;           // Clears BF
	   PIR3bits.SSP2IF = 0;         // Clear interrupt flag
	   SSP2BUF = ValTab;          // write byte to SSP2BUF register
	   while(!PIR3bits.SSP2IF); //wait until bus cycle complete
	
	   TempVar = SSP2BUF;           // Clears BF
	   PIR3bits.SSP2IF = 0;         // Clear interrupt flag
	   SSP2BUF = 0x00;          // write byte to SSP2BUF register
	   while(!PIR3bits.SSP2IF); //wait until bus cycle complete
	  }

	CS_Dac=1;					// Deselect Dac Module 		   	 
} 
//////////////////////////////////////////////////////////////////////