mesure de dephasage entre deux signaux

[invitec35bc9ea]

bonjour,
à partir d'un codeur incremental relatif, je dois obtenir la position et la vitesse.
pour ce qui est de la vitesse c'est bon, je mesure la frequence du signal
par contre pour la position, l'idée est de detecter les fronts, pour ça j'utilise un trigger, et à chaque detection j'incremente une variable. j'incremente? non je peux aussi derementer et c'est la que ça se corce.
du codeur j'obtiens en realité deux signaux carrés en quadrature de phase. selon que l'un est en avance ou en retard par rapport à l'autre, le sens de rotation sera droite ou gauche.
the question is:
comment savoir lequel est en avance ou en retard?
somme? non ça donnerait 012101210 pas d'info sur le sens
difference? non ça dennerait 10-1010-1
filtre à retour pur puis somme? ça marche pas car la pariode de rotation et donc la frequence du signal est variable.
Je sèche.
qqun aurait une petite idée?

merci

PS: il s'ajit de traitement de signal, je cherche donc une solution algorithique pas un schema electronique
-----

[invite936c567e]

Bonsoir

Il faut détecter les fronts montants et descendants sur les deux signaux en quadrature, et tenir compte du niveau du signal resté constant pour déterminer s'il faut incrémenter ou décrémenter le compteur.

Exemple:

  _     ___      _____          _____      ___
A  |___|   |____|     |________|     |____|   |___
      ___     _____       __       _____     ___
B ___|   |___|     |_____|  |_____|     |___|   |_
N 0 1 2 3 4 5 6  7  8  9  10 9  8  7  6  5 4 3 2 1

On incrémente le compteur lorsque :
- A=1 et B passe de 1 à 0
- A=0 et B passe de 0 à 1
- B=1 et A passe de 0 à 1
- B=0 et A passe de 1 à 0

On décrémente le compteur lorsque :
- A=0 et B passe de 1 à 0
- A=1 et B passe de 0 à 1
- B=0 et A passe de 0 à 1
- B=1 et A passe de 1 à 0

[invite936c567e]

Si A et B constituent les bits d'un nombre AB (A=poids fort, B=poids faible), alors il faut incrémenter le compteur lorsqu'on détecte sur AB l'une des transitions suivantes :
0 -> 1
1 -> 3
2 -> 0
3 -> 2
et il faut décrémenter le compteur lorsqu'on détecte sur AB l'une des transitions suivantes :
0 -> 2
1 -> 0
2 -> 3
3 -> 1

[invite936c567e]

Exemple de programme :

int transition[16] = {
  0,         /* 00 -> 00 inchange   */
 +1,         /* 00 -> 01 incremente */
 -1,         /* 00 -> 10 decremente */
  0,         /* 00 -> 11 impossible */
 -1,         /* 01 -> 00 decremente */
  0,         /* 01 -> 01 inchange   */
  0,         /* 01 -> 10 impossible */
 +1,         /* 01 -> 11 incremente */
 +1,         /* 10 -> 00 incremente */
  0,         /* 10 -> 01 impossible */
  0,         /* 10 -> 10 inchange   */
 -1,         /* 10 -> 11 decremente */
  0,         /* 11 -> 00 impossible */
 -1,         /* 11 -> 01 decremente */
 +1,         /* 11 -> 10 incremente */
  0          /* 11 -> 11 inchange   */
};

int count = 0;                 /* compteur donnant la position     */
int inputAB, index;

index = read(PORT) & 0x03;     /* lit l'etat initial des signaux   */
while (1) {
  inputAB = read(PORT) & 0x03; /* lit l'etat des signaux           */
  index <<= 2;                 /* conserve l'etat anterieur        */
  index |= inputAB;            /* memorise le nouvel etat          */
  index &= 0x0F;               /* garde les deux derniers etats    */
  count += transition[index];  /* determine la transition survenue */
}

[A voir en vidéo sur Futura]

[invite936c567e]

Partant, la dernière transition modifiant le compteur permet de déterminer le sens :

int transition[16] = {
  0,         /* 00 -> 00 inchange   */
 +1,         /* 00 -> 01 incremente */
 -1,         /* 00 -> 10 decremente */
  0,         /* 00 -> 11 impossible */
 -1,         /* 01 -> 00 decremente */
  0,         /* 01 -> 01 inchange   */
  0,         /* 01 -> 10 impossible */
 +1,         /* 01 -> 11 incremente */
 +1,         /* 10 -> 00 incremente */
  0,         /* 10 -> 01 impossible */
  0,         /* 10 -> 10 inchange   */
 -1,         /* 10 -> 11 decremente */
  0,         /* 11 -> 00 impossible */
 -1,         /* 11 -> 01 decremente */
 +1,         /* 11 -> 10 incremente */
  0          /* 11 -> 11 inchange   */
};

int count = 0;                 /* compteur donnant la position     */
int dir = 0;                   /* sens de rotation                 */
int inputAB, index, trans;

index = read(PORT) & 0x03;     /* lit l'etat initial des signaux   */
while (1) {
  inputAB = read(PORT) & 0x03; /* lit l'etat des signaux           */
  index <<= 2;                 /* conserve l'etat anterieur        */
  index |= inputAB;            /* memorise le nouvel etat          */
  index &= 0x0F;               /* garde les deux derniers etats    */
  trans = transition[index];   /* determine la transition survenue */
  count += trans;              /* actualise la position            */
  if (trans!=0)
    dir = trans;               /* actualise le sens                */
}

[invite936c567e]

(Ce n'est qu'un exemple sans prétention, juste pour montrer ce qu'on peut faire. On peut faire beaucoup mieux sans trop d'effort).

[Qristoff]

Salut,
n'est ce pas plus simple de prendre une des signaux en référence et lors du front montant de ce signal, on regarde l'état de l'autre à cet instant. S'il vaut 0; on incrémente, s'il vaut 1 on décrémente (ou l'inverse)
Je ne sais pas le faire en C mais avec une bascule D, on a le résultat tout de suite.

[polo974]

on peut voir les signaux comme le signe du cos et du sin d'un angle variable.
c'est donc une sorte de trigo numérique...

ne tenir compte que d'un front d'un signal divise par 4 la résolution maximale possible.
c'est comme si on ne regardait qu'à 0° d'une rotation.

tenir comte des 2 front d'un signal, c'est comme regarder à 0° et 180°.
tenir comte enfin des 4 fronts, c'est comme regarder tous les 90°.

[Tropique]

on peut voir les signaux comme le signe du cos et du sin d'un angle variable.
c'est donc une sorte de trigo numérique...

ne tenir compte que d'un front d'un signal divise par 4 la résolution maximale possible.
c'est comme si on ne regardait qu'à 0° d'une rotation.

tenir comte des 2 front d'un signal, c'est comme regarder à 0° et 180°.
tenir comte enfin des 4 fronts, c'est comme regarder tous les 90°.

.... et cela signifie que si l'on fait de petits mouvements avant-arrière entre deux positions critiques, on va tout le temps incrémenter ou décrémenter alors qu'en fait, en moyenne, on reste sur place.

[invitec35bc9ea]

bonjour,
merci pour vos reponses.
j'ai testé la methode de detection de niveau de A plus la detection de front de B, mais pôur une raison obscure elle incremente que je troune à droite ou à gauche.
J'ai finalement resolu le probleme autrement:
je recupere la frequence du signal, j'en deduit la periode, je dephase le signal B de 1/4 de la periode, il sera donc en phase ou en opposition de phase selon qu'il est en retard ou en avance et ça c'est facile à detecter il suffit de faire la difference.
merci

[invite936c567e]

je recupere la frequence du signal, j'en deduit la periode, je dephase le signal B de 1/4 de la periode, il sera donc en phase ou en opposition de phase selon qu'il est en retard ou en avance et ça c'est facile à detecter il suffit de faire la difference.i

Et que se passe-t-il lorsqu'on change de sens de rotation ?

[invitec35bc9ea]

le signal que je recupere est de l'ordre de 4V.
en tournant à droite, A est en avance de T/4 par rapport à B
si j'ajoute un retard pur de T/4 à B, A et B seront en opposition donc A+B sera egal à Zero ou preque (car je trvaille avec des signaux analogique)

en tournant à gauche, A est en retard de T/4 par rapport à B
si j'ajoute un retard pur de T/4 à B, A et B seront en phase donc A+B sera carré de l'ordre de 8V (RMS=4)
concretement, je calcule le RMS de A+B s'il est superieur à 2 je dis que je tourne à gauche sinon, c'est à droite

[invite936c567e]

Comment obtenir T lorsque la vitesse varie, et notamment lorsqu'on change de sens ?

De plus, tu parles de déterminer le sens (ce que l'état d'un signal lors du changement d'état de l'autre devrait pouvoir faire, mais bon). N'est-ce pas plutôt la position qu'il faudrait obtenir avant tout ? (le sens peut être déduit de la variation de la position, d'ailleurs)

Avec ce système, comment peux-tu garantir qu'il ne peut pas y avoir d'erreur sur la position évaluée lors d'un changement de sens ?

[invitec35bc9ea]

Comment obtenir T lorsque la vitesse varie, et notamment lorsqu'on change de sens ?

avec la FFT, j'arrive à determiner la frequence du signal. T=1/f
le fait de changer de sens ne modifie pas l'allure de mon signal. il s'ajit toujours d'un signal carré dont la freqnece est image de la vitesse.

N'est-ce pas plutôt la position qu'il faudrait obtenir avant tout ?

comment j'obtiens la position? en incrementant ou decrementant une variable à chaque front montant, il faut donc au prealable savoir si je dois incrementer ou decrementer.

Avec ce système, comment peux-tu garantir qu'il ne peut pas y avoir d'erreur sur la position évaluée lors d'un changement de sens ?

je ne vois pas le probleme

[invite936c567e]

avec la FFT, j'arrive à determiner la frequence du signal. T=1/f

Une FFT pour évaluer une fréquence qui varie, je voudrais bien voir ça !

il faut donc au prealable savoir si je dois incrementer ou decrementer

C'est bien là le problème.

Tu ne peux pas utiliser de façon fiable une méthode qui repose sur la mesure d'une situation passée et variable pour analyser des états futurs.

Pour t'en convaincre, je te suggère de faire quelques simulations de changements de sens. Tu devrais voir rapidement qu'il n'est pas possible de déterminer le moment exact du changement de sens à partir d'une mesure de la fréquence, et encore moins d'une FFT. Il apparaîtra donc souvent une erreur, cumulative, dans l'évaluation de la position.

En comparaison, la méthode que j'ai donnée est infaillible, tant que l'échantillonnage des signaux reste nettement supérieur à 4 fois leur fréquence maximale.

[invitec35bc9ea]

Une FFT pour évaluer une fréquence qui varie, je voudrais bien voir ça !

hmmm! c'est le but meme d'une fft, c'est de pouvoir traiter des signaux non periodiques.
J'ai testé avec avec un signal carré dont je fesais parier la frequence avec un curseur et ça a l'air correct.

Tu ne peux pas utiliser de façon fiable une méthode qui repose sur la mesure d'une situation passée et variable pour analyser des états futurs.

oui tu as raison. e faisant les essais et decalant le sugnal B, je n'etais jammais exactement en opposition ou en phase, c'est pourquoi j'ai mis le seuil de detection à 2V.

Pour t'en convaincre, je te suggère de faire quelques simulations de changements de sens. Tu devrais voir rapidement qu'il n'est pas possible de déterminer le moment exact du changement de sens à partir d'une mesure de la fréquence, et encore moins d'une FFT. Il apparaîtra donc souvent une erreur, cumulative, dans l'évaluation de la position.

Je vais verifier, mais pour l'instant je vais en WE

En comparaison, la méthode que j'ai donnée est infaillible, tant que l'échantillonnage des signaux reste nettement supérieur à 4 fois leur fréquence maximale.

ça va de soi

[invite936c567e]

hmmm! c'est le but meme d'une fft, c'est de pouvoir traiter des signaux non periodiques.

Traiter, soit, mais pas en déduire une fréquence exacte : un signal non périodique n'a pas de fréquence définie.

[polo974]

avec la FFT,...

Pour une encodeur relatif...
Einstein, Einstein, voyons, on n'utilise pas la bombe A pour souffler une bougie (j'ai du mal à trouver plus light que la bougie à éteindre...).

Quelques bascules, et quelques portes logiques suffisent amplement.
Pour mémoire, il y avait 2 machins comme ça dans une souris à boule (3 avec la molette), il n'y avait pas de FFT dans ces petites choses...

Reprenons au début:

en tournant à droite, A est en avance de T/4 par rapport à B

donc à droite:

    ____      ____
A__/    \____/    \____
       ____      ____
B   __/    \____/    \____

et inversement à gauche:

       ____      ____
A   __/    \____/    \____
    ____      ____
B__/    \____/    \____

donc en regardant juste un tout petit peu les 2 chronogrammes, on voit :

si A montant
    si /B
        droite
    sinon
        gauche
si A descendant
    si B
        droite
    sinon
        gauche
si B montant
    si A
        droite
    sinon
        gauche
si B descendant
    si /A
        droite
    sinon
        gauche

[invitec35bc9ea]

bonsoir,
avant d'untiliser ma bombe A, j'ai mis en place cet algorithme mais ça n'a pas marché comme j'etais pressé, au lieu de debugger j'ai preferé realiser ma bombe mais c'est vrai que j'ai utilisé de la grosse artillerie

[polo974]

Bonjour,
Pour un essai ultra raide "pour voir", ça peut passer (avec un soft genre octave, ,c'est tout cuit ou presque).

Pour la suite, il vaut mieux revenir au test sur front, au début avec juste le test sur un front dans un sens, puis dans les 2 sens, puis pour la meilleure précision, sur les 4 fronts.

Si tu veux qu'on jette un oeil neuf sur ton bout de code, on devrait pouvoir trouver où ça coince...

[invite7ce20dfd]

salut,
j ai un mini projet sur pic de 16f84 et j envisage le meme probleme pour determiner le sens d une roue, il me faut controler le front sur l une des entrees du pic , notez bien que j utilise le mikroC pour programmer le microcontroleur... merci bien

[invitee05a3fcc]

http://forums.futura-sciences.com/pr...cremental.html

[invite7ce20dfd]

merci
j ai trouve 1 solution mais je veut la traduire en mikroC pour comprendre le prog pr l adapter selon mes besoins...voila donc le prog :

///////////////////////////////
#define SIG_A PIND.2
#define SIG_B PIND.3
#define INC_MAX 100
#define INC_MIN 0
/* Les lignes précédentes sont à ajuster 
   en fonction du codeur et du µcontroleur.
   On peut par exemple les placer dans un fichier .h à part.
 */
#define INCREMENTER \
    if (var<INC_MAX) var++;\
    var_ab=(SIG_A<<1)+SIG_B;
    
#define DECREMENTER \
    if (var>INC_MIN) var--;\
    var_ab=(SIG_A<<1)+SIG_B;
   
unsigned var=0; //variables globales
 
interrupt[14] void gray() // interruption sur compteur (toutes les 1,6ms)
{
        static unsigned char var_ab=0;
        switch (var_ab){
            case 0:if(SIG_A==0 && SIG_B==1) INCREMENTER 
                   else if(SIG_A==1 && SIG_B==0) DECREMENTER
                   break;
            case 1:if(SIG_A==1 && SIG_B==1) INCREMENTER
                   else if(SIG_A==0 && SIG_B==0) DECREMENTER
                   break;
            case 2:if(SIG_A==0 && SIG_B==0) INCREMENTER
                   else if(SIG_A==1 && SIG_B==1) DECREMENTER
                   break;
            case 3:if(SIG_A==1 && SIG_B==0) INCREMENTER
                   else if(SIG_A==0 && SIG_B==1) DECREMENTER      
        }
///////////

[antek]

Je connais pas C mais avec commentaires c'est mieux !