[PIC]gestion des interruptions

[invitec35bc9ea]

bonjour,

 Cliquez pour afficher

#include <p18f4520.h>
#include <delays.h>
#include <math.h>

#define R 6371 // R Rayon de la terre

#pragma config OSC = HS
#pragma config MCLRE = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

unsigned short int pos1,pos2;
unsigned short int posr1,posr2;
unsigned long X, Y, Z;


/* Prototype des fonctions */

void init_pic(void);
void init_var(void);
void recupercoord(void);
void convertionsoul(unsigned long X,unsigned long Y,unsigned long Z, unsigned short int pos1,unsigned short int pos2);
void revolt1(char s1);
void revolt2(char s2);
void init(void);
void track(void);

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

/* initialisation du Pic */

void init_pic(){

	INTCON=0b11001000;
	INTCON2=0x01;
	INTCON3=0x00;
	RCON=0x00;
  
	TRISA=0b00000000;//on peut ajouter 5 LEDs eventuelles de RA0 à RA4
	PORTA=0b00000000;

	TRISB=0b11111111;//RB4 à RB7 sont es entrées des codeurs eventuels

	TRISC=0b10001111;//RC0: 1er fin de course / RC1: eme fin de course / RC2: bouton d'init / RC3 entree force de signal XBEE / RC6: sortie PC / RC7: entree signal XBEE
	PORTC=0b00000000;
	PORTCbits.RC4=0;
	PORTCbits.RC5=0;
	PORTCbits.RC6=0;

	TRISD=0b00000000;//sorties commande des moteurs
	PORTD=0b11111111;

	TRISEbits.TRISE0=0;//LED
	PORTEbits.RE0=0;

}

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

/* initialisation des variables globales */

void init_var(void){
	X=0;
	Y=0;
	Z=0;
	pos1=0;
	pos2=0;
	posr1=0;
	posr2=0;
}

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

/* Fonction recupercoord *///recuperer longitude, latitude et altitude 

/*void recupercoord(){
	int i;
	RCSTA=0b10010000;
  	while(1){
		if(PIR1bits.RCIF){		//on vérifie que le registre RCREG est plein
    		if(RCREG==0x88) break;     //on veut écouter l'entree jusqu'à ce que le caractère X apparaisse dans la trame reçue, X=88 en caractère ASCII
 		}
 	}
	//RCREG est maintenant égal à 'X'
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet car on ne veut pas récupérer 'X', un octet équivaut à un caractère ASCII
	}
	X=0; //initialisation
	X=X+RCREG;  //on ajoute l'octet que contient le registre
	X=X<<8; 	//on le décalle vers la gauche
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet, un octet équivaut à un caractère ASCII
	}
	X=X+RCREG;	//on recommence
	X=X<<8;
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet
	}
	X=X+RCREG;	//X contient maintenant les trois octets de la valeur de la coordonnées EST du GPS par rapport à la station au sol=longitude/station 

	//récupération de Y :
	while(1){
	 	if(PIR1bits.RCIF) break;
 	}	
	
	if(RCREG!=0x89){
		PORTEbits.RE0=1;
		return;
	}

	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet car on ne veut pas récupérer 'Y', un octet équivaut à un caractère ASCII
	}
	Y=0; //initialisation
	Y=Y+RCREG;  //on ajoute l'octet que contient le registre
	Y=Y<<8; 	//on le décalle vers la gauche
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet, un octet équivaut à un caractère ASCII
	}
	Y=Y+RCREG;	//on recommence
	Y=Y<<8;
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet
	}
//	Y=Y+RCREG;	//X contient maintenant les trois octets de la valeur de la latitude GPS /station au sol


	//récupération de l'altitude Z :
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet, un octet équivaut à un caractère ASCII
	}
	if(RCREG!=0x90){	//Z en caractère ASCII est 90
		PORTEbits.RE0=1;
		return;
	}

	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet car on ne veut pas récupérer 'Z', un octet équivaut à un caractère ASCII
	}
	Z=0; //initialisation
	Z=Z+RCREG;  //on ajoute l'octet que contient le registre
	Z=Z<<8; 	//on le décalle vers la gauche
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet, un octet équivaut à un caractère ASCII
	}
	Z=Z+RCREG;	//on recommence
	Z=Z<<8;
	while(PIR1bits.RCIF==0){	//on attend que RCREG reçoive à nouveau un octet
	}
	Z=Z+RCREG;	//X contient maintenant les trois octets de la valeur de l'altitude /station au sol	
}*/

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

/* Fonction convertionsoul *///transformer X, Y, et Z en 2 positions angulaires à donner à chacun des deux moteurs

/*void convertionsoul(unsigned long X, unsigned long Y, unsigned long Z, unsigned short int pos1, unsigned short int pos2){
//X : longitude pris p/r à la station au sol
//Y : latitude pris p/r à la station au sol
//Z : altitude par r/p à la surface de la terre
	while(1){

		unsigned long x, y, z; // x, y, z coordonnées cartésiennes du done p/r à la station au sol

		// conversion en coordonnées cartésiennes 

		x=R*X; // hypothèse de calcul : x=R*tanX, R>>X d'où x=R*X
		y=R*Y; //même hypothèse  pour le calcul de x
		z=Z; 
 
 		//Conversion en position angulaire 

		pos1=(atan(x/y))/1.8;
		pos2=atan(z/sqrt(x*x + y*y))/1.8;
	}
}*/

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

/* Fonction revolt1 *///tourner le moteur 1 dans le sens s1

/*void revolt1(char s1){
	PORTDbits.RD1=s1;//sens de rotation
	while(1){//Step
		PORTDbits.RD2 = 1;
		Delay10KTCYx(0);
		PORTDbits.RD2 = 0;
		Delay10KTCYx(0);
		posr1=posr1+1;//incrementation de la position du moteur 1
	}
}*/

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

/* Fonction revolt1 *///tourner le moteur 2 dans le sens s2

/*void revolt2(char s2){
	PORTDbits.RD5=s2;//sens de rotation
	while(1){//Step
		PORTDbits.RD6 = 1;
		Delay10KTCYx(0);
		PORTDbits.RD6 = 0;
		Delay10KTCYx(0);
		posr2=posr2+1;//incrementation de la position du moteur 2
	}
}*/

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

/* Fonction init *///initialisation des positions des moteurs

void init(){
	if(PORTCbits.RC2){// action sur le bouton init
		while(PORTCbits.RC0!=1){//tant que le moteur 1 ne rencontre pas le fin de course	
			PORTDbits.RD1=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD2 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD2 = 0;
				Delay10KTCYx(0);
				posr1=posr1+1;//incrementation de la position du moteur 1
			}
		}
		/*while(PORTCbits.RC1!=1){//tant que le moteur 2 ne rencontre pas le fin de course
			PORTDbits.RD5=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD6 = 1;
				Delay10KTCYx(10);
				PORTDbits.RD6 = 0;
				Delay10KTCYx(10);
				posr2=posr2+1;//incrementation de la position du moteur 2
			}
		}*/
	}
	posr1=0;//initialiser la position du moteur 1
	posr2=0;//initialiser la position du moteur 2
}

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

/* Fonction track*///suivi de trajectoire

/*void track(){
	while(1){
		if(posr1<pos1){//pos reelle < pos voulue
			revolt1(1);//tourner M1 sens direct
		}
		else if(posr1>pos1){//pos reelle > pos voulue
			revolt1(0);//tourner M1 sens inverse
		}
		if(posr2<pos2){//pos reelle < pos voulue
			revolt2(1);//tourner M2 sens direct
		}
		else if(posr2>pos2){//pos reelle > pos voulue
			revolt2(0);//tourner M2 sens inverse
		}
	}
}*/
	
/*****************/

/* Fonction Main */	

void main(){   
	init_pic();//initialisation du PIC
    init_var();//initialisation des variables

	while(1){
		init();//debut de cycle
	/*	recupercoord();//recuperation des coordonnees GPS
		convertionsoul(X,Y,Z,pos1,pos2);//conversion des coordonnées GPS en positions moteurs
		track();//suivi de trajectoire*/
	}
}

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

j'utilise la fonction:

Delay10KTCYx(0);

dans deux fonctions differentes (c'est le probleme de gestion des interruptions ou qqch comme ça non? enfin c'est ce que j'ai cru comprendre).
ce qui fait que ce programme marche:

 Cliquez pour afficher

#include <p18f4520.h>
#include <delays.h>
#include <math.h>

#define R 6371 // R Rayon de la terre

#pragma config OSC = HS
#pragma config MCLRE = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

unsigned short int pos1,pos2;
unsigned short int posr1,posr2;
unsigned long X, Y, Z;


/* Prototype des fonctions */

void init_pic(void);
void init_var(void);
void recupercoord(void);
void convertionsoul(unsigned long X,unsigned long Y,unsigned long Z, unsigned short int pos1,unsigned short int pos2);
void revolt1(char s1);
void revolt2(char s2);
void init(void);
void track(void);

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

/* initialisation du Pic */

void init_pic(){

	INTCON=0b11001000;
	INTCON2=0x01;
	INTCON3=0x00;
	RCON=0x00;
  
	TRISA=0b00000000;//on peut ajouter 5 LEDs eventuelles de RA0 à RA4
	PORTA=0b00000000;

	TRISB=0b11111111;//RB4 à RB7 sont es entrées des codeurs eventuels

	TRISC=0b10001111;//RC0: 1er fin de course / RC1: eme fin de course / RC2: bouton d'init / RC3 entree force de signal XBEE / RC6: sortie PC / RC7: entree signal XBEE
	PORTC=0b00000000;
	PORTCbits.RC4=0;
	PORTCbits.RC5=0;
	PORTCbits.RC6=0;

	TRISD=0b00000000;//sorties commande des moteurs
	PORTD=0b11111111;

	TRISEbits.TRISE0=0;//LED
	PORTEbits.RE0=0;

}

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

/* initialisation des variables globales */

void init_var(void){
	X=0;
	Y=0;
	Z=0;
	pos1=0;
	pos2=0;
	posr1=0;
	posr2=0;
}

/* Fonction init *///initialisation des positions des moteurs

void init(){
	if(PORTCbits.RC2){// action sur le bouton init
		while(PORTCbits.RC0!=1){//tant que le moteur 1 ne rencontre pas le fin de course	
			PORTDbits.RD1=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD2 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD2 = 0;
				Delay10KTCYx(0);
				posr1=posr1+1;//incrementation de la position du moteur 1
			}
		}
		/*while(PORTCbits.RC1!=1){//tant que le moteur 2 ne rencontre pas le fin de course
			PORTDbits.RD5=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD6 = 1;
				Delay10KTCYx(10);
				PORTDbits.RD6 = 0;
				Delay10KTCYx(10);
				posr2=posr2+1;//incrementation de la position du moteur 2
			}
		}*/
	}
	posr1=0;//initialiser la position du moteur 1
	posr2=0;//initialiser la position du moteur 2
}

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


/* Fonction Main */	

void main(){   
	init_pic();//initialisation du PIC
    init_var();//initialisation des variables

	while(1){
		init();//debut de cycle
	/*	recupercoord();//recuperation des coordonnees GPS
		convertionsoul(X,Y,Z,pos1,pos2);//conversion des coordonnées GPS en positions moteurs
		track();//suivi de trajectoire*/
	}
}

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

mais pas celui-ci:

 Cliquez pour afficher

	
	
#include <p18f4520.h>
#include <delays.h>
#include <math.h>

#define R 6371 // R Rayon de la terre

#pragma config OSC = HS
#pragma config MCLRE = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

unsigned short int pos1,pos2;
unsigned short int posr1,posr2;
unsigned long X, Y, Z;


/* Prototype des fonctions */

void init_pic(void);
void init_var(void);
void recupercoord(void);
void convertionsoul(unsigned long X,unsigned long Y,unsigned long Z, unsigned short int pos1,unsigned short int pos2);
void revolt1(char s1);
void revolt2(char s2);
void init(void);
void track(void);

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

/* initialisation du Pic */

void init_pic(){

	INTCON=0b11001000;
	INTCON2=0x01;
	INTCON3=0x00;
	RCON=0x00;
  
	TRISA=0b00000000;//on peut ajouter 5 LEDs eventuelles de RA0 à RA4
	PORTA=0b00000000;

	TRISB=0b11111111;//RB4 à RB7 sont es entrées des codeurs eventuels

	TRISC=0b10001111;//RC0: 1er fin de course / RC1: eme fin de course / RC2: bouton d'init / RC3 entree force de signal XBEE / RC6: sortie PC / RC7: entree signal XBEE
	PORTC=0b00000000;
	PORTCbits.RC4=0;
	PORTCbits.RC5=0;
	PORTCbits.RC6=0;

	TRISD=0b00000000;//sorties commande des moteurs
	PORTD=0b11111111;

	TRISEbits.TRISE0=0;//LED
	PORTEbits.RE0=0;

}

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

/* initialisation des variables globales */

void init_var(void){
	X=0;
	Y=0;
	Z=0;
	pos1=0;
	pos2=0;
	posr1=0;
	posr2=0;
}

/* Fonction init *///initialisation des positions des moteurs

void init(){
	if(PORTCbits.RC2){// action sur le bouton init
		while(PORTCbits.RC0!=1){//tant que le moteur 1 ne rencontre pas le fin de course	
			PORTDbits.RD1=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD2 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD2 = 0;
				Delay10KTCYx(0);
				posr1=posr1+1;//incrementation de la position du moteur 1
			}
		}
		while(PORTCbits.RC1!=1){//tant que le moteur 2 ne rencontre pas le fin de course
			PORTDbits.RD5=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD6 = 1;
				Delay10KTCYx(10);
				PORTDbits.RD6 = 0;
				Delay10KTCYx(10);
				posr2=posr2+1;//incrementation de la position du moteur 2
			}
		}
	}
	posr1=0;//initialiser la position du moteur 1
	posr2=0;//initialiser la position du moteur 2
}

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


/* Fonction Main */	

void main(){   
	init_pic();//initialisation du PIC
    init_var();//initialisation des variables

	while(1){
		init();//debut de cycle
	/*	recupercoord();//recuperation des coordonnees GPS
		convertionsoul(X,Y,Z,pos1,pos2);//conversion des coordonnées GPS en positions moteurs
		track();//suivi de trajectoire*/
	}
}

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

donc si j'essaie de commander un moteur ça va mais deux non.
comment resoudre ça? (ça equivaut à faire clignoter deux LEDs endependemment l'une de l'autre).

**************

deuxieme probleme:
meme pour un seul moteur, je n'obtiens pas le fonctionnement voulu. certe il tourne mas pas de la facon que je veux:

/* Fonction init *///initialisation des positions des moteurs

void init(){
	if(PORTCbits.RC2){// action sur le bouton init
		while(PORTCbits.RC0!=1){//tant que le moteur 1 ne rencontre pas le fin de course	
			PORTDbits.RD1=1;//sens de rotation
			while(1){//Step
				PORTDbits.RD2 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD2 = 0;
				Delay10KTCYx(0);
				posr1=posr1+1;//incrementation de la position du moteur 1
			}
		}
		
	posr1=0;//initialiser la position du moteur 1
	posr2=0;//initialiser la position du moteur 2
}

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

à RC0 et RC2 j'ai connecté deux boutons poussoirs avec des resistances de pull-down.
donc au demarrage du pic RC0 et RC2 sont à niveau bas. et tout le port BD est à niveau haut.
je veux avoir le fonctionnement suivant:
une impulsion sur le BP de RC2 fait osciller RD2.
meme en lachant le BP, RD2 continue à osciller.
une impulsion sur RC0 (RC2 n'est plus appuié) arrete l'oscillation de RD2 qui garde le niveau de sa derniere oscillation.
avec le bout de code ci-dessus, j'arrives à respecter les deux premiers points mais pas le 3eme: une implusion sur RC0 laisse le PIC indifferent.

merci
-----

[RISC]

Einstein,

Je n'ai pas analysé tout ton code mais voici peut être une piste :
1/ Supposons que ton programme principal utilise la fonction1
2/ Supposons que ton interruption utilise aussi la fonction1

Pendant l'exécution du programme principal, fonction1 est appelée ET manque de chance (merci Murphy) pendant que fonction1 s'exécute, ton interruption arrive.
Ton interruption utilise aussi fonction1. Les paramètres de fonction1 vont donc être écrasés par l'appel dans l'interruption et au retour dans le programme principal, fonction1 finira de s'exécuter avec les paramètres de l'interruption qui auront écrasés ceux de que fonction1 avait dans l'appel du programme principal.

Ce cas est "facile" à détecter (et à résoudre voir ci-dessous) mais parfois c'est beaucoup plus vicieux...

A/ Suppose que fonction1 dans le prog principal ait besoin d'une "sous-fonction" fonction2 qui ait elle même besoin de fonction3.
B/ Suppose maintenant que fonctionA dans ton interruption utilise la "sous-fonction" fonctionB qui elle même utilise la "sous-fonction" fonction3
Tu es alors en présence du même PB que précédemment mais c'est beaucoup plus difficile de détecter cela.

C'est pourquoi il faut connaitre ce qu'on appelle les "dépendances" des fonctions (dependencies en anglais).
Telle fonction utilise telle fonction qui elle-même utilise...

Comment résoudre ce genre de PB :
1/ Le compilateur analyse automatiquement tous les appels pour détecter ces PB potentiels : très compliqué car le compilateur doit alors être capable d'analyser simultanément tous les fichiers du projet....Le C18 n'est pas capable de faire cela. Par contre je crois que le compilateur HiTech possède cette faculté (analyse de tous les fichiers) mais je ne sais pas s'il analyse les dépendances...
2/ Si tu as créé les fonctions toi-même, il suffit de dupliquer la fonction commune et de changer son nom ET ses arguments : fonction1 devient fonction1a et fonction1b
fonction1a sera appelé par le prog principal et fonction1b sera appelé par l'interruption
3/ Tu gardes la même fonction appelée par le programme principal et l'interruption mais alors tu dois prévoir dans la sauvegarde du changement de contexte, la préservation de l'espace de travail de cette fonction et sa restoration à la sortie de l'interruption.
La conséquence de cela est bien sur un temps de latence allongé pour l'interruption qui peut évidemment entrainer des PB de temps-réel (cela dépend purement des temps de réponse dont tu as besoin).
4/ La solution la plus simple est de ne PAS faire le traitement dans l'interruption mais plutôt dans le prog principal (quand c'est possible) et de dialoguer au travers de sémaphores.

J'espère que cette explication un peu longue "éclaire" certains PB potentiels du C lorsque les interruptions utilisent des fonctions communes.

a+

[invitec35bc9ea]

bonsoir,

J'espère que cette explication un peu longue "éclaire" certains PB potentiels du C lorsque les interruptions utilisent des fonctions communes.

à mois que l'ais mal compris, je n'ai pas l'impression que ça repond à ma question.

Je n'ai pas analysé tout ton code mais voici peut être une piste :

imaginons un programme qui ait le fonctionnement suivant:
l'appui sur une bouton 1 fait clignotter une LED1
independemment de ce qui precede, l'appui sur une bouton 2 fait clignotter une LED2.
j'ecris le programme suivant:

void main(){
                [...]
                if(PORTCbits.RC0){
			while(1){
				PORTDbits.RD2 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD2 = 0;
				Delay10KTCYx(0);
			}
		}
		if(PORTCbits.RC1){
			while(1){
				PORTDbits.RD6 = 1;
				Delay10KTCYx(0);
				PORTDbits.RD6 = 0;
				Delay10KTCYx(0);
			}
		}
                [...]
}

et c'est là qu'est le problème: tel que fait maintenant j'ai un niveau indéfini pour RD2 et RD6

[invite2562e666]

Salut,

Ton problème peut parfaitement être résolu par l'emploi d'un RTOS.

th.

[A voir en vidéo sur Futura]

[invitec35bc9ea]

tu peux developper stp?
merci

[invite2562e666]

ton problème est assez typique, tu veux faire plusieurs choses en même temps. Par exemple avec un RTOS, tu as une "tache" qui commande un moteur, une seconde "tache" qui commande un aute moteur, une troisième qui scrute un clavier,...Le RTOS attubue successivement des fractions du temps CPU à chaque tâche, le CPU ne perds pas son temps à faire du "pooling"...

Je ne vais pas développer (il faudrait plusieurs pages)mais te revoyer vers une intro que j'avais écrite :
http://www.68hc08.net/modules/smarts...php?itemid=115

cela doit aussi exister pour des pics.

th.

[Seb.26]

RTOS = scheduler ...

C'est ce que j'avais déjà essayé de t'expliquer ... fait toi une boucle qui exécute des taches ( drivers, appli ... ect ... )

Et surtout : ne jamais bloquer le CPU, n'utilise que des automates d'états ...

[RISC]

Bonsoir,

Je n'ai pas vu de gestion d'anti-rebond dans ton logiciel...

Si tu as des boutons poussoir ou des contacts mécaniques de fin de course, il faut impérativement gérer les rebonds par matériel ou par logiciel.

Si les rebonds ne sont pas gérés cela produit des fonctionnements imprédictibles.

a+

[invitec35bc9ea]

il faut impérativement gérer les rebonds par matériel ou par logiciel.

entendu, mais je resoudrais ça un peu plus tard.

C'est ce que j'avais déjà essayé de t'expliquer ... fait toi une boucle qui exécute des taches ( drivers, appli ... ect ... )

Et surtout : ne jamais bloquer le CPU, n'utilise que des automates d'états ...

desolé mais j'ai pas compris(ou peut etre oublié?).
merci

[invite2d21c929]

Bonjour,

je veux avoir le fonctionnement suivant:
une impulsion sur le BP de RC2 fait osciller RD2.
meme en lachant le BP, RD2 continue à osciller.
une impulsion sur RC0 (RC2 n'est plus appuié) arrete l'oscillation de RD2 qui garde le niveau de sa derniere oscillation.
avec le bout de code ci-dessus, j'arrives à respecter les deux premiers points mais pas le 3eme: une implusion sur RC0 laisse le PIC indifferent.

A mon avis ce problème viens de ta boucle infinie "while(1)", essai de l'enlever et de tout mettre dans ton "while(PORTCbits.RC0!=1)"; avec peut être une gestion du sens de rotation conditionnelle.
plus