Encodeur rotatif

PieM

Senior Member
Bonjour,

Je dispose de cet encodeur :
http://www.gotronic.fr/art-encodeur-inter-ec11e15244g1-16982.htm
dit "15 impulsions", il possède 30 crans par tour et avec le petit code ci dessus, l'incrémentation est de 2 à chaque cran. Pour une incrémentation de 1, il faut s'arrêter entre deux crans.
Questions:
Peut on modifier ce code pour l'adapter à cet encodeur?
Sinon, quel encodeur faut il pour ce code?

En tout cas, merci pour ces quelques lignes.

MM
Bonjour,

Oui en effet ce type de codeur n'est pas fait pour être décodé en quadrature.
En quadrature , pour 15 impulsions, il y a 30 changements d'état par piste soit 60 changement d'état au total.
Comme il y a 30 crantages, il y a effectivement 2 comptages par cran. Chaque crantage correspond au même état de la sortie A.

Le décodage sera en fait beaucoup plus simple:
Il suffit de voir l'état de B lors de la transition de A de 1 > 0 pour déterminer sens et incrémenter.
Cela permet d'ailleurs d'utiliser facilement une interruption sur l'état 0 (ou 1) de A . Si B est à 1 on compte +1 et si B = 0 on compte -1.

Par contre pour eviter de faire un test if ... then ... else, il est possible de faire l'incrémentation / décrémentation comme précédemment avec une seule équation:

compteur = pinX.x * 2 + compteur - 1 min 0 va incrémenter si pinX.x est à 1, décrémenter dans le cas contraire.
 
Last edited:

MGU

Senior Member
Bonjour,

Avec cet encodeur, vu la position des crans, on incrémente de 1 tous les deux crans si on ne prend en compte que la transition de A dans un seul sens.
J'ai donc essayé un truc comme ça:

Code:
;décodeur 5
'================================

#picaxe 08M2

symbol InputA 		= pinc.3
symbol InputB 		= pinc.4
symbol baud			= N4800


symbol Compt	= w13	'compteur
'________________________________________________
main:

compt=1
setint %0000,%1000
serout C.0,baud, (254,192,#compt,"    ")
do
 	bit0 = InputA
 	bit1 = InputB	
	serout C.0,baud, (254,192,#compt,"    ")	
loop

interrupt:	
compt=bit1 xor bit0 *2+compt-1
Do 
loop while InputA<>InputB
if InputA= 1 then
		setint %0000,%1000
	else
		setint %1000,%1000
	endif
return
c'est tordu, ça fonctionne mais faut tourner doucement, surtout dans le sens montant.
Je vais essayer avec un setint OR sur A et B, et faire le tri, pour voir.

Sinon, une incrémention sur deux crans, c'est mieux que rien et pour introduire des paramètres, ça peut suffire...

MM
 

Attachments

jojojo

Senior Member
ça fonctionne mais faut tourner doucement

Hum ...
Le code est bien, Michel.

Je pense que c'est (comme d'hab) la liaison série, qui pose problème.
 

PieM

Senior Member
Bonjour,

Je pense que dans le principe il y a plus simple:
Déclencher l'interruption quand A passe de OFF à ON

dans l'interruption, voir alors la situation de B : soit à 1, soit à 0
donc

interrupt:
compt = InputB * 2 + compt -1 min 0
attendre que A revienne à sa position stable OFF
do while InputA = 0: loop
setint ......
return

Au niveau du serout, peut être utiliser plus que 4800bauds , et ne changer que la valeur numérique sur l'affichage pour gagner du temps.
 

MGU

Senior Member
Bonjour,

Code:
'================================
'Encodeur 15 pulses 30 crans

'================================
  
#picaxe 08M2
setfreq m32
symbol InputA 		= pinc.4
symbol InputB 		= pinc.3
symbol baud			= N4800_32
symbol intro		= pinC.1
symbol Aact  	= bit0	'Valeur de A actuelle
symbol Aprec 	= bit2	'Valeur de A pecédente
symbol Compt	= w13	'compteur
pullup %11010				;pullup sur C.1 ,C.3,C.4
Pause 500
'________________________________________________
Intro_parametre:
	compt=1
	serout C.0,baud, (254,128,#compt,"    ")
	
	do
		do 
			if intro=0 then
				serout C.0,baud, (254,192,#compt,"    ")
			endif
 			bit0 = InputA
 			bit1 = InputB 	
 		loop while Aact=Aprec 				;vivement le changement			
		compt= bit0 xor bit1 *2 + compt-1
		Aprec=Aact	
		serout C.0,baud, (254,128,#compt,"    ")
	loop
Et ça fonctionne plutôt bien, à chaque cran, dans les deux sens, sans ratée, évidemment, plus la fréquence est élevée, plus on peut tourner vite avant saturation.
L'encodeur en question fait aussi poussoir, pour un module de réglage de paramètres comme dans ce code, c'est parfaitement suffisant.

Bizarre, j'ai une curieuse impression de déjà vu....

J'ai ajouté le schéma du test

MM
 

Attachments

Last edited:

BESQUEUT

Senior Member
J'ai acheté celui-là
En combinaison avec le petit afficheur OLED, ça offre plein de possibilités,
mais comme d'hab je suis très occupé et le projet avance escargotesquement...
 

PieM

Senior Member
J'ai acheté celui-là
Il a l'air sympa et pas très cher.
Mais c'est un 24 positions cranté me semble t-il d'après la doc ?

@ Michel

Oui bien sûr, ça marche, mais quel intérêt dans le cas présent d'effectuer une comparaison état actuel/précédent de l'entrée A ?
L'entrée A passant d'une position OFF à une autre. La discrimination du sens et le comptage se faisant en fonction de l'état de B au moment du passage à ON.

C'est pour cela que pour cette appli, l'utilisation d'une interruption est toute indiquée et simplifie le programme.
En outre cela permet de ne pas rester boqué sur un do loop tout pendant que l'on ne touche à rien.
Perso, je mettrais un petit condo en // de chaque contact du codeur.
 

MGU

Senior Member
Il a l'air sympa et pas très cher.
Mais c'est un 24 positions cranté me semble t-il d'après la doc ?

@ Michel

Oui bien sûr, ça marche, mais quel intérêt dans le cas présent d'effectuer une comparaison état actuel/précédent de l'entrée A ?
L'entrée A passant d'une position OFF à une autre. La discrimination du sens et le comptage se faisant en fonction de l'état de B au moment du passage à ON.
Bonjour,

Et non, regarde le petit schéma en #42, les crans sont sur les états haut et bas, et le problème avec interruption, c'est qu'il faut détecter alternativement les deux transitions de A, et c'est pas plus simple.
La comparaison détecte le changement d'état dans les deux sens, et c'est juste à ce moment là, qu'il faut tester B pour appliquer la formule magique et attendre le changement d'état suivant.

MM
 

PieM

Senior Member
Bonjour,

Et non, regarde le petit schéma en #42, les crans sont sur les états haut et bas, et le problème avec interruption, c'est qu'il faut détecter alternativement les deux transitions de A, et c'est pas plus simple.
La comparaison détecte le changement d'état dans les deux sens, et c'est juste à ce moment là, qu'il faut tester B pour appliquer la formule magique et attendre le changement d'état suivant.

MM
Bonjour ,

Sorry !! je suis resté sur le schéma du EC20A !
Donc j'ai tout faux ! :eek:
 

BESQUEUT

Senior Member
Il a l'air sympa et pas très cher.
Mais c'est un 24 positions cranté me semble t-il d'après la doc ?
Ce qui est sur, c'est qu'il n'y a aucun crantage sur le modèle que j'ai reçu.
La doc indique pourtant toutes les caractéristiques du crantage ; sans doute existe-t-il différentes variantes.
Il y a 3 broches d'un coté (pas standard de 2,5mm) pour l'encodeur,
et 4 de l'autre (pas non standard de 2mm ...) pour les 2 leds et le poussoir.
La qualité de fabrication semble bonne. (La doc est basée sur une vitesse de 360° par seconde, et des tests sous 250V DC...)
On peut l'utiliser tel quel avec l'axe de 6mm (sans le bouton transparent), mais il ne peut être fixé que par soudure sur un CI.
Pas encore testé électriquement...
 

PieM

Senior Member
Reçus des codeurs rotatifs (20 crans, 20 impulsions code Gray avec inter) de chez Chinois.
Rien à redire sur le fonctionnement.

Le programme simple et rapide:

Une interruption permet de l'avoir toujours actif dans un programme.
Ma formule magique évite les test

Code:
'================================
'décodeur Grey Version 04
'Codeur 20 impulsions  20 crantages
'PieM 140519
'================================

#picaxe 14M2

symbol InputA 		= pinC.0
symbol InputB 		= pinC.1

symbol Compt		= w3	'compteur

setint NOT %00000011,%00000011
'________________________________________________
main:

do
	sertxd (#Compt, cr,lf)
loop
 
interrupt:
    Compt = InputB *2 + Compt - 1 
    do while inputA=0 or inputB= 0 : loop
    setint NOT %00000011,%00000011 
return
 

MGU

Senior Member
Reçus des codeurs rotatifs (20 crans, 20 impulsions code Gray avec inter) de chez Chinois.
Rien à redire sur le fonctionnement.

Le programme simple et rapide:

Une interruption permet de l'avoir toujours actif dans un programme.
Ma formule magique évite les test

Code:
'================================
'décodeur Grey Version 04
'Codeur 20 impulsions  20 crantages
'PieM 140519
'================================

#picaxe 14M2

symbol InputA 		= pinC.0
symbol InputB 		= pinC.1

symbol Compt		= w3	'compteur

setint NOT %00000011,%00000011
'________________________________________________
main:

do
	sertxd (#Compt, cr,lf)
loop
 
interrupt:
    Compt = InputB *2 + Compt - 1 
    do while inputA=0 or inputB= 0 : loop
    setint NOT %00000011,%00000011 
return
Bonjour,

Une petite confirmation SVP. En code Gray, on a une incrémentation à chaque cran avec ce programme?

MM
 

PieM

Senior Member
Bonjour,

Une petite confirmation SVP. En code Gray, on a une incrémentation à chaque cran avec ce programme?

MM
Bonjour,
Oui, mais attention que sur ce codeur, chaque cran correspond à la position OFF de A !
voir 2014-05-19 002.jpg

En outre, sur ces codeurs bon marché, les signaux sont loin d'être en quadrature comme sur le schéma. Cela peut avoir pour effet de limiter la vitesse dans un sens par rapport à l'autre.
Ce programme correspond à un câblage avec le commun sur Gnd.
 

jojojo

Senior Member
Gestion sûre d'un enco en quadrature

Bonjour.

Bon, en gestion "purement soft", ces encodeurs merdouillent, avec du Picaxe (vitesse de rotation excessive, ou changement de sens trop rapide aussi), sans compter les rebonds ...

Un peu de hard résout le problème.

Comme ça :
enco.jpg

Ça marche très bien.

Georges.

PS: Toujours rendre à César ... Merci, PapyJP, pour le #8 ...
 
Last edited:

PieM

Senior Member
Bonjour,
peut on avoir un petit explicatif de
setint NOT %00000011,%00000011
merci
Alain
Bonjour

Bonne question !
sur le codeur utilisé, à la position crantée correspond A= 1 B=1
il faut donc interrompre sur A=0 ou B=0
donc une interruption setint OR %00.
problème, sur mon 14M2, ça ne marche pas! (pas approfondi pourquoi...)
donc Boole -> setint NOT %11.
(ce qui revient à voir la position repos du codeur et interrompre sur l'inverse de sa combinaison logique.

Comme déjà souligné l'utilisation d'un µC interprété a ses limites pour ce genre d'appli.
Donc le hard type Georges peut être une solution (mais encombrement + fer à souder.)
Mais qui ne détecte pas les fronts descendants, ce qui peut engendrer des erreurs:
(la séquence /A B, A B, /A B, A B, voit deux comptages avec A sur clk)

d'autres existent:
les décodeurs en quadrature type HCTL2000 et LS7184, pas facile à trouver et chers
utiliser un PSOC
utiliser un Pic (ce qui me semble la meilleure solution et la moins chère...)
Une remarque: décodeurs et pic permettent de gérer les 16 cas de transition ( 4 comptage, 4 décomptage, 4 erreurs, 4 impossibles)
 
Last edited:

Nico49

Member
Bonsoir,
je suis novice dans la programmation des Picaxes, quelqu'un peut-il me donner un coup de main ?
Merci par avance pour vos réponses.
Nico
 

BESQUEUT

Senior Member
Bonsoir,
je suis novice dans la programmation des Picaxes, quelqu'un peut-il me donner un coup de main ?
Merci par avance pour vos réponses.
Nico
bonsoir et bienvenue sur ce forum.

Oui : le forum francophone compte une dizaine de participants réguliers
Mais vous devriez ouvrir un nouveau thread et décrire votre projet.
 
Top