Gestion sens de rotation encodeur par PIC18F45K20

[invite95ba0329]

Bonjour,
Je développe actuellement sur un PIC18F45K20 (carte de dev 44-pin demo board avec MPLAB 8.80 et en C18) un gestionnaire d'encodeur rotatif ALPS 24 cran/tour.
Je récupère par interruption (INT0 et INT1) sur RB0 et RB1 les deux sorties (A et B) de mon encodeur (sorties montées avec resistance de pull-up).
D'après la datasheet, une rotation vers la droite implique que A passe à 0 avant B, et vis-versa (actif état bas).

Voici ma fonction d'interruption:

void MyInterrupt(void)
{
	INTCONbits.GIE = 0; // Désactivation des interruptions

    if (INTCONbits.INT0IF || INTCON3bits.INT1IF)
    {         
		for(j=0;j<50;j++){} // Boucle d'attente-anti rebond
                          	
		if(INTCONbits.INT0IF && !INTCON3bits.INT1IF) 
		{
			if(i!=7) i++;
			else i=0;	
		}
		else if(!INTCONbits.INT0IF && INTCON3bits.INT1IF)
		{
			if(i!=0) i--;
		}

		PORTD = tab[i]; // Affichage sur LEDS tab={1,2,4,8,16,32,64,128}

		INTCONbits.INT0IF = 0;            //clear interrupt flag
		INTCON3bits.INT1IF = 0;  
		
    }

	INTCONbits.GIE = 1; // Activation des interruptions
}

La configuration des registres d'interruption est bonne car si je met le deuxième test "else if" en commentaire, la rotation de l'encodeu fait bien évoluer les LEDS.
Cependant, quand tout le programme est actif, la rotation de l'encodeur dans un sens ou dans l'autre ne donne pas de résultat cohérent (sur une rotation d'un cran, i va subir ++ et -- ou juste ++ ou juste -- sans discernement ).

Auriez vous une idée géniale pour que mon programme puisse détecter de manière "propre et précise" le sens de rotation de cet encodeur?

Merci d'avance
-----

[invitee05a3fcc]

Bonjour AquaBoB et bienvenue sur FUTURA

Auriez vous une idée géniale pour que mon programme puisse détecter de manière "propre et précise" le sens de rotation de cet encodeur?

De regarder ce Tuto http://forums.futura-sciences.com/pr...cremental.html

[invite95ba0329]

Si je comprend bien le code en bas de tuto, il s'agit d'utiliser uniquement l'interruption sur timer et de "scruter" les valeurs n et n_1 sur les deux entrées à une fréquence asses élevée à chaque overflow du timer?

Si c'est le cas, je m'en vais coder et faire quelques tests, et je repasserais.

[Qristoff]

Salut,
l'utilisation des interruptions pour détecter le sens de rotation me parait trés gourmand en ressources.
Tu peux utiliser une interruption pour détecter qu'il y a mouvement du potar mais pour le sens de rotation, il suffit de comparerles deux entrées lorsque la première change d'état.

[A voir en vidéo sur Futura]

[RISC]

Salut,

Il ne faut SURTOUT PAS toucher à GIE dans l'interruption...
L'acceptation d'une interruption entraine la désactivation automatique des interruptions (GIE=0) heureusement ...
De même à la fin de l'interruption, la sortie provoque automatiquement la réautorisation des interruptions (GIE=1).
Le programmeur doit simplement remettre à 0 le flag de l'interruption qui a été activé.

Pour ce qui est de ton encodeur, cela dépend de la vitesse...si elle est importante, ton micro va passer son temps en interruptions...
Cette note d'application (AN718) montre une méthode qui consomme peu de ressources micro, mais nécessite des bascules externes.

a+

[invite95ba0329]

Mon utilisation finale est un contrôle numérique de façade d'une tranche de console audio, donc vitesse de rotation des encodeurs faible.

Merci pour vos infos.

[invitee05a3fcc]

donc vitesse de rotation des encodeurs faible.

Ce qui compte ..... c'est de compter tous les pas , sans en oublier ou en rajouter . Donc tu utilises mon tuto avec le soft de Jack en #3

[invite95ba0329]

J'ai adapté mon programme à la solution proposée par Daudet78:

void MyInterrupt(void)
{
    if (INTCONbits.TMR0IF) // Overflow du timer0
    {                               	
		buffer_A = A;
		buffer_B = B;
		A = PORTBbits.RB0;
		B = PORTBbits.RB1;
		
		if(buffer_A==A && buffer_B==B)
		{
			if(A && !B) if(i!=7) i++;
			else if(!A && B) if(i!=0) i--;
		}

		PORTD = tab[i]; // Affichage sur LEDS

		INTCONbits.TMR0IF = 0;            //clear interrupt flag 		
    }
}

J'ai du régler le prescaler du Timer0 (010 = 1:8 prescale value) de manière à limiter l'anti-rebond tout en gardant une bonne sensibilité (le résultat n'est pas très probant).
Cependant, le programme ne rentre jamais dans le cas ""else if(!A && B) if(i!=0) i--;"", et donc un seul sens de rotation est detecté, quelque soit le sens de rotation de l'encodeur.

Avez vous une idée?

Edit: toutes les variables utilisées sont globales.

[invitee05a3fcc]

Donc tu utilises mon tuto avec le soft de Jack en #3

Ca n'a rien à voir avec le soft de Jack !

[RISC]

Salut AquaBob,

Un petit conseil. Si tu utilises plusieurs interruptions dans ton système, il est prudent de faire ce test :

    if (INTCONbits.TMR0IF && INTCONbits.TMR0IE) // Overflow du timer0
    ..

Cela t'évitera de traiter une interruption TIMER0 dans le cas ou tu aurais désactiver temporairement cette source et que d'autres sont actives dans ton système. Il est conseillé de le faire pour chaque interruption

a+

[invite95ba0329]

J'ai modifié mon code en copiant littéralement la proposition de Jack en #3, cependant je conserve un gros problème de rebond que je n'arrive pas à corriger ...

[invite95ba0329]

Voici mon code:

////////////////////////////////////////////
////// Rotation encodeur sens horaire //////
void ROT_H(int * i,unsigned char * var_ab) 
{
    if((*i)<INC_MAX) (*i)++;
    (*var_ab)=SIG_A; // Ecriture de RB0 et RB1 sur 2 bits
    (*var_ab)<<1;
    (*var_ab)=(*var_ab) | SIG_B;
	
	return;
}

/////////////////////////////////////////////////
////// Rotation encodeur sens anti-horaire //////
void ROT_AH(int * i,unsigned char * var_ab) 
{    
	if((*i)>INC_MIN) (*i)--;
    (*var_ab)=SIG_A; // Ecriture de RB0 et RB1 sur 2 bits
	(*var_ab)<<1;
	(*var_ab)=(*var_ab) | SIG_B;

	return;
}

#pragma interrupt MyInterrupt 
void MyInterrupt(void)
{
        if (INTCONbits.TMR0IF && INTCONbits.TMR0IE) // Overflow du timer0
    	{     
	                unsigned char var_ab=0;
		        int A,B,BufferA,BufferB;
			BufferA=SIG_A;
			BufferB=SIG_B;

			do{                              // Anti-rebond
				A=SIG_A;
				B=SIG_B;
			    }while(BufferA!=A || BufferB!=B); 

        		switch (var_ab)
				{
           			 case 0:if(SIG_A==0 && SIG_B==1) ROT_H(&i,&var_ab);
                	 	           else if(SIG_A==1 && SIG_B==0) ROT_AH(&i,&var_ab);
                   		 	   break; 
           			 case 1:if(SIG_A==1 && SIG_B==1) ROT_H(&i,&var_ab);
               		   		   else if(SIG_A==0 && SIG_B==0) ROT_AH(&i,&var_ab);
               	    		           break; 
            		        case 2:if(SIG_A==0 && SIG_B==0) ROT_H(&i,&var_ab);
                   	 	  	  else if(SIG_A==1 && SIG_B==1) ROT_AH(&i,&var_ab);
                  			  break; 
                 	        case 3:if(SIG_A==1 && SIG_B==0) ROT_H(&i,&var_ab);
                	    	          else if(SIG_A==0 && SIG_B==1) ROT_AH(&i,&var_ab);  
				}

			PORTD = tab[i]; // Affichage sur LEDS

			INTCONbits.TMR0IF = 0;            //clear interrupt flag 	 
        }
}

[invite95ba0329]

Petit UP car je n'arrive toujours pas à résoudre ce problème.

[invite89303051]

Bonjour

De base, il faut aller vite dans les interruptions. Donc l'histoire de la boucle, ce n'est pas bon.
Sinon, pour ton problème, pourquoi ne fixes tu pas une des 2 interruptions comme indicateur de sens et l'autre comme compteur.
Un peu du style (par defaut, sens est négatif)
if (INTCONbits.INT0IF)
{
sens = positif
}
if(INTCON3bits.INT1IF)
{
compteur++;
//On remet le sens par defaut
sens = négatif
}

Cordialement