[Programmation C] - Interruption / Appui long

[Seb.26]

Tu n'aurais pas fais une petite erreur??
Tu n'aurais pas voulus mettre

si( lissage>10 && lissage<=20 )

??
Mais je me trompe peut etre, et ça serait plus cohérent avec le message que tu avais mis ensuite:

En fait, ça revient au même ... car si lissage>20 alors lissage=0xFF ...
mais je trouvais ça plus clair, cela permet de bien "marquer le status" de lissage : en cours de comptage ( 0 < lissage < 20 ) et appui long detecté ( lissage = 0xFF ) ...

NB: ou alors je me suis gourré ... je vais me relire ...
-----

[Seb.26]

Je crois que c'est OK ... analyse le code et dis moi ce que tu en pense ...

[edit] ça évite d'ailleurs d'avoir 2 fois la valeur '20' ... mais tu dois quand même faire un #define !!!

[invite3c35244f]

Désolé, après réflexion, il est vrai que c'est pareil, car si lissage > 20, lissage est ensuite égal à 0xFF, donc le test suivant est correct..
Merci encore..
PS: je n'ai toujours pas testé sur ma carte mais je vous tiens au courant...

[Seb.26]

PS: juste au cas ou, j'ajoute les { ... } pour mieux définir les blocs de code :

  si( BP==appuyé )
  {
    si( lissage!=0xFF )
    {
      lissage++;
      si( lissage>20 )
      {
        lissage = 0xFF;
        Action_BP_long();
      }
    }
  }
  sinon
  {
    si( lissage>10 && lissage!=0xFF )
    {
      Action_BP_court();
    }
    lissage=0;
  }

voila, maintenant, à toi de jouer ...

@++

[Edit] PS: il faut bien initialiser lissage à 0 au début du soft ...

[invite3c35244f]

Merci merci merci...

[invite3c35244f]

Bonjour.....
ça marche!!!!
et en plus j'ai compris...j'ai mis le temps mais j'y suis arrivé...
Mille merci à vous deux pour votre patience et vos conseils...
A bienot pour de nouvelles aventures....avec les PIC

[invite3c35244f]

(Ah...je reviens plus vite que prévu!! )
J'ai fais un test, j'ai rajouté deux interruptions sur INT0(BP0) et INT2(BP3)..jusque là tout fonctionnait correctement, mais j'ai voulu rajouter une autres interruptions sur INT1(BP1) et y insérer:

flag_10ms = 0;
while(!flag_10ms);
TypePush_10ms();

Et là, tout bloque!!
Es-ce normal!!
Je vais debugger pour voir où ça coince..

[invite74b5b8f7]

De rien (même si la c´est plus grace à Seb.26 , c´est vrai que où c´en était, c´était mieux de tout reprendre)

Et au fait c´est pour quoi tout ca?

[invite74b5b8f7]

(Ah...je reviens plus vite que prévu!! )

OK, rebonjour alors...

Avec juste ce petit bout, pas facile à dire!

Revois peut-être mon message #48 (page 3) ?

[invite3c35244f]

Je viens d'essayer en inversant de mettre

	INTCON3bits.INT1IF=0;
	flag_10ms = 0;
 	 while(!flag_10ms);
	TypePush_10ms();

Bon j'explique ce que j'ai en pratique sur ma carte..
1er cas:
lorsque je lance mon programme, et que je n'appui sur aucun bouton, le programme prend en compte la présence d'interruption, car LEDA2(pour BP0) s'allume alors que je l'initialise à 0 en début de programme.et ensuite tout se bloque, aucune interruption nest prise en compte..
2eme cas:
lorsque je lance mon programme mais en laissant appuyé le BP1, le programme tourne,Les LEDA2(BP0) et LEDA4(BP2) s'allume(ce que je ne comprend toujours pas) et ensuite des que j'appui sur BP0 ou BP2, LEDA2 et LEDA4 change bien d'état a chaque interruption, mais si jappui sur BP1, le programme se bloque... j'espère que mon explication est compréhensible..

[invite74b5b8f7]

j'espère que mon explication est compréhensible..

Ca a l´air, mais sans le programme qui va avec difficile de répondre (pour ne pas dire impossible )

[invite3c35244f]

Avec le programme, c'est sur que c'est plus simple...

#pragma interrupt LED
void LED(void)
{
	if (INTCONbits.INT0IF)
	{
	LEDA2=!LEDA2;
	INTCONbits.INT0IF=0;
	}

	if (INTCON3bits.INT1IF)
	{
	INTCON3bits.INT1IF=0;
	flag_10ms = 0;
 	 while(!flag_10ms);
	TypePush_10ms();
	
	}

	if (INTCON3bits.INT2IF)
	{
	LEDA4=!LEDA4;
	INTCON3bits.INT2IF=0;
	}

	if (INTCONbits.TMR0IF)		//Test du drapeau d'IT
		{
		TMR0L=0x3D;					//Fixe le départ du timer->timer de 10ms
		flag_10ms=1;
		INTCONbits.TMR0IF = 0;		//efface le drapeau d'IT
		}
}

#pragma code vecteur_d_IT=0x08
void TIMER(void)
{
	_asm 
	goto LED
	_endasm
}
#pragma code

/***************************************************************************
*********************Programme Principal************************************
***************************************************************************/
void main (void)
{
init_uc();				//Appel SP Initialisation du microcontroleur
config_timer();			//Appel SP Initialisation du Timer
config_IT();			//Appel SP Initialisation des interruptions	
		
while(1)
{
Nop();
}//Fin While(1)
}//Fin Programme Principal

/***************************************************************************
Nom   : void init_uc(void)
Role  : Configuration et initialisation des Ports E/S
*****************************************************************************/
void init_uc(void)
{
 ADCON1=0x0F;					// Configuration en numérique
 TRISA=0x00;					// PORTA en sortie
 TRISB=0xF7;					// PORTB en entrée --sauf RB3 en sortie
 TRISC=0x00;					// PORTC en sortie
 TRISD=0x00;					// PORTD en sortie
 TRISE=0x00;					// PORTE en sortie

 PORTA=0x00;					//
 PORTB=0x07;					///
 PORTC=0x00;					////Initialisation à 0 des Ports
 PORTD=0x00; 					///
 PORTE=0x00;					//
}

/***************************************************************************
Nom   : void config_timer(void);
Role  :
*****************************************************************************/
void config_timer(void)
{
T0CON=0xC7;
}

/***************************************************************************
Nom   : void config_IT(void);
Role  :
*****************************************************************************/
void config_IT(void)
{
INTCONbits.GIE=1;		//Autorise les interruptions
INTCONbits.GIEH = 1;	//Autorise toutes les interruptions
INTCONbits.TMR0IE=1;	//autorise les interruptions de TMR0
INTCON2bits.INTEDG0=0;	//Interruption sur un front descendant sur RB0
INTCONbits.INT0IE=1;	//Autorie les interruptions externes sur INT0
INTCON2bits.INTEDG1=0;	//Interruption sur un front descendant sur RB1
INTCON3bits.INT1IE=1;	//Autorie les interruptions externes sur INT1
INTCON2bits.INTEDG2=0;	//Interruption sur un front descendant sur RB2
INTCON3bits.INT2IE=1;	//Autorie les interruptions externes sur INT2
}


/***************************************************************************
Nom   : void TypePush_10ms(void);
Role  :
*****************************************************************************/
void TypePush_10ms(void)
{
if(PORTBbits.RB1==0)					//Teste bouton appuyé
	{
    if( lissage != 0xFF )
		{
      	lissage ++;
      	if( lissage > 100 )				//Appui long
			{
        	lissage = 0xFF;
       		LEDA5=!LEDA5;
			}
		}
	}
else
	{
	 if( lissage>2 && lissage<=100 )	//Appui court
		{
        LEDA3=!LEDA3;
		}
	 lissage = 0;		
	}
}

[Seb.26]

C'est impossible que ça marche ... ton PIC ne peut declencher une IT dans une IT, pour faire cela, il te faudrait utiliser un PIC plus gros avec 2 niveaux d'IT ( priorité haute et basse ) ...

Mais de toute façon, l'idée d'attendre dans une IT n'est pas bonne ... une IT doit être le plus court et le plus efficace possible ...

[Seb.26]

Au pire, remplace :

	if (INTCON3bits.INT1IF)
	{
	INTCON3bits.INT1IF=0;
	flag_10ms = 0;
 	 while(!flag_10ms);
	TypePush_10ms();
	
	}

par

	if (INTCON3bits.INT1IF)
	{
	INTCON3bits.INT1IF=0;
	INTCONbits.TMR0IF = 0;
 	 while(!INTCONbits.TMR0IF);
	TypePush_10ms();
	}

ça devrait marcher ... mais c'est très très moche ...

[invite74b5b8f7]

#pragma code vecteur_d_IT=0x08
void TIMER(void)
{
_asm
goto LED
_endasm
}

Moi déjà il y a toujours eu ca qui me turlupine, ton vecteur 0x08 est celui qui gere aussi les interruptions de tes BP?
T´es sur que cela fonctionne?

Moi je mettrais plutot tout dans ton prog principal plutot que dans tes interuptions:

main()
{

//Inits, etc...

while(1)
{
INT_BP1 = 0;
while(INT_BP1 == 0){}
TypePush();
}
}

//Interruptions
{
if (INTCONbits.INT0IF)
{
LEDA2=!LEDA2;
INTCONbits.INT0IF=0;
}

if (INTCON3bits.INT1IF)
{
INT_BP1 = 1;
INTCON3bits.INT1IF=0;
}

if (INTCON3bits.INT2IF)
{
LEDA4=!LEDA4;
INTCON3bits.INT2IF=0;
}

if (INTCONbits.TMR0IF) //Test du drapeau d'IT
{
TMR0L=0x3D; //Fixe le départ du timer->timer de 10ms
flag_10ms=1;
INTCONbits.TMR0IF = 0; //efface le drapeau d'IT
}
}

void TypePush()
{
lissage = 0;
while (lissage != 0xFF)
{
flag_10ms = 0;
while (flag_10ms == 0){}
if(PORTBbits.RB1==0) //Teste bouton appuyé
{
if( lissage != 0xFF )
{
lissage ++;
if( lissage > 100 ) //Appui long
{
lissage = 0xFF;
LEDA5=!LEDA5;
}
}
}
else
{
if( lissage>2 && lissage<=100 ) //Appui court
{
lissage = 0xFF;
LEDA3=!LEDA3;
}
}
}
}

PS: je l´ais fait vite fait, pas sur que ca marche mais c´est normal que le tiens ne fonctionne pas (pas mal d´erreurs), dsl c´est un peu trop long à expliquer

[invite3c35244f]

D'accord...d'ou le blocage dans le while()...il peut toujours attentre..
mon PIC184525, me permet d'avoir 2 niveaux d'interruptions:

The high priority
interrupt vector is at 0008h and the low priority interrupt
vector is at 0018h.

Et si il n'y a pas d'autres moyens, j'essayerai bien..
Le principe doit etre quasi identique sauf que la routine d'interruption du timer se situe en High interrupt..
Je vais essayé quand meme...meme si ce n'est pas très conseillé..

[invite3c35244f]

En ce qui concerne les interruptions..tout fonctionne correctement..
Je vais tester ta proposition Seb26..
Et je vous tiens au courant..

[invite74b5b8f7]

ça devrait marcher ... mais c'est très très moche ...

A mon avis non(enfin pour ce morceau oui mais pas pour ce qui suit), parsqu´une des grosses erreurs c´est que la il n´appel TypePush() qu´une fois à chaque appuis sur BP1 donc lissage s´incrémenmte à chaque appui sur BP1 et comme dés qu´il va dans TypePush() c´est que le BP est appuyé, le premier test est toujours vrai donc il faut qu´il appuis 100 fois sur son BP pour changer l´état de LEDA5...
(En plus des autres erreurs)

[invite3c35244f]

Lilvince, ta remarque est juste..j'ai remplacé le 100 par 4, et au bout de 4 appui, la led change d'état..et ensuite impossible de lui refaire changer d'état..

[invite74b5b8f7]

Question bete:

Est ce que tu lance bien ton Timer à chaque début de programme???

[invite74b5b8f7]

et ensuite impossible de lui refaire changer d'état.

Oui parsque du coup tu ne remet jamais lissage à 0!
Bon, sinon c´est que ton timer fonctionne aussi...

A mon avis essaye ma poroposition message#75...

Qu´est ce que tu en penses Seb.26?

[Seb.26]

A mon avis non(enfin pour ce morceau oui mais pas pour ce qui suit), parsqu´une des grosses erreurs c´est que la il n´appel TypePush() qu´une fois à chaque appuis sur BP1 donc lissage s´incrémenmte à chaque appui sur BP1 et comme dés qu´il va dans TypePush() c´est que le BP est appuyé, le premier test est toujours vrai donc il faut qu´il appuis 100 fois sur son BP pour changer l´état de LEDA5...
(En plus des autres erreurs)

Je sais pas, je me suis arrêté sur le while(!flag_10ms); ... mon corps a refusé de subir plus longuement la lecture de ce code ...

@jorg1n : ( mais ce n'est que mon avis ) ... une IT ça sert à quoi ?
Une IT ça a 2 intérêts principaux :
1) ça réveille un CPU. En effet, certaines IT sont capable de sortir le CPU d'un sleep() ...
2) une IT ça permet d'exécuter du code en temps réel, par exemple, ton code pour le timer peut être exécute à n'importe quel moment du programme principal.

Mais une IT se doit de prendre le moins de temps CPU possible, premièrement car si une IT prend 10ms ( comme dans ton cas ou tu attends jusqu'à 10ms ), et bien aucune IT ne peut être déclenchée durant ces 10ms ... donc tes IT ne servent plus à rien, et donc pourquoi les utiliser ? ...

Une IT doit être vu comme un évènement, mais si le traitement de cet évènement est long, il ne doit pas être fait dans l'IT ...

NB: Si tu te dis que c'est pas possible, c'est que tu as mal pensé ton programme et qu'il faut repasser par la case "conception logicielle" ...

Donc, pose toi la question : à quoi sert ton IT sur le BP ?

[invite3c35244f]

Mon timer est bien lancé, il est dans les initialisations..
Sinon, je viens de rajouter un lissage=0, et oui la ça change d'état...

[invite74b5b8f7]

Donc, pose toi la question : à quoi sert ton IT sur le BP ?

C´est pour ca que ca pourraiot aider de savoir oú tu veux en venir à la fin???
(Dans quel but fais-tu tout cela?)

[invite74b5b8f7]

Sinon, je viens de rajouter un lissage=0, et oui la ça change d'état...

Apparemment tu veux pas essayer ma reponse#75 (Il y a aussi lissage =0 ), t´as juste à faire du copier coller!

[invite3c35244f]

Bon , je vais vous expliquer...je veux réaliser un petit système avec un afficheur graphique 128x64..et 3 boutons poussoirs..ce système viendra mesuré la tension (acquise par le CAN du PIC) et l'affichera sur le LCD..
Et les 3 boutons me permetteront de venir "naviguer" dans les menus de l'afficheur d'où l'utilisation des interruptions..non?
Sinon, pour ton explication Seb26, je connais le role des interruptions (je les utilise peut etre moins bien que vous peut etre...)et c'est pour ça que je souhaite les utiliser..

[invite74b5b8f7]

Tu peux peut-être te passer des interruptions elles-mêmes et n´utiliser que leur flags? ou tu veux avoir un mode veille?

Enfin sinon tu peux faire un peu comme tu fais mais sans erreurs (c´est pas mechant!)

Je me repete:message #75 (enfin j´espere que ca marche )

[invite3c35244f]

Pour ta proposition en #75 lil-vince, c'est pas que je ne veut pas la tester, mais le truc, c'est que je reviens dans le while (1) pour finir l'opération sur le bouton, et je souhaite plutot avoir toute la gestion du BP dans la routine d'INT, sinon, autant ne pas utiliser les interruptions, là je suis d'accord..
Le truc, c'est que lorsque j'imagine mon système en fonctionnement, sans les interruptions, il faudra que le programme vienne tester les flag d'INT (sans les INT), donc à un instant t; alors que si j'utilise les interruptions, cela me permettera de venir gérer les BP que lorsque j'ai une interruption...c'est comme cela que je voyai les choses..dites moi si je me trompe, ou si ce n'est pas cohérent..
merci pour votre aide quand meme

[invite74b5b8f7]

Message #75:

Prog principal: attends appuis sur BP1 (mais permet d´autres interruptions en attendant)
-> quand appuis: lancement de TypePush()
TypePush(): regarde l´état de BP1 toutes les 10ms jusqu´à 2,56 secondes max et fais la différence entre appui inferieur a 1sec.(mais superieur à 20ms) et appui superieur à 1sec.
Puis retour dans ta boucle infinie...(ca recommence)

Ca te permet de faire tout ca en dehors des routine d´interruptions...

[invite74b5b8f7]

mais le truc, c'est que je reviens dans le while (1) pour finir l'opération sur le bouton

je comprends pas ?!

PS: j´ai écris le message précédent en meme temps