oui, il y a plusieurs discussions sur les encodeurs rotatifs.
J'arrive avec une question matérielle afin de bien comprendre.
Quelques modèles m'intéressent, mais les conceptions me déconcertent un peu.
J'observe deux types:
Selon ce que je lis, EC-12 et EC-16 ont - comme les deux autres - la fonction du bouton-poussoir incluse.
Alors, comment est-il possible d'obtenir le même résultat avec 3 connexion qu'avec 5 ?
Le KY-040 est le modèle donné dans tous les tutos (comme celui-ci).
Le format du EC-12 m'intéresse davantage. J'irais bien avec un EC-12 si j'étais sûr de pouvoir exploiter les fonctions d'avant/arrière et le bouton poussoir.
Quant au EDR-11, il semble allumer les pattes 1, 2, 4, 8 pour composer des nombres. Le connaissez-vous?
l' EDR-11 est ce totalement différent , ce n'est pas un encodeur incrémental comme les autres
Autre usage.
En permanence on a sur 4 bits la valeur du nombre sélectionné (en binaire naturel ou en code Gray selon les modèles) . C'es assimilable à une roue codeuse décimale , ou hexadécimale selon le nombre de crans
Chez un distributeur de composants 'pro' comme Farnell c'est catalogué comme Commutateur codé rotatif chaque modèle en vente ayant notice technique téléchargeable
Il existe aussi les encodeurs rotatifs absolus qui donnent également une info sur plusieurs bits mais n'ont pas de crans
Mon défi est d'avoir 4 encodeurs rotatifs pour gérer RVB sur plusieurs bandes DEL, en plus de gérer quelques relais; tout cela dans un câble réseau à 8 brins. Je n'ai pas à me soucier de l'alimentation, ayant accès à une source locale.
Si je comprends bien, je pourrais mettre en commun les broches CLK de mes encodeurs, 4 CLK sur un brin; 4 brins distincts; un par encodeur pour les données et 3 brins pour la sélection de l'appareil contrôlé avec EDR-11
Ça occuperait mes 8 brins, sans me donner la chance d'exploiter les fonctions bouton-poussoir.
C'est la naissance d'un projet, je n'ai pas encore de code, mais la description ci-haut pourrait être gérée par quelque chose du genre:
#include <Encoder.h>
//Définition des broches
EDR11_pinA = 1;
EDR11_pinB = 2;
EDR11_pinC = 3;
Encodeur_R = 4;
Encodeur_V = 5;
Encodeur_B = 6;
Encodeur_T = 7;
Encodeur_CLK = 8;
long posiRouge = -999;
long posiVert = -999;
long posiBleu = -999;
long posiTout = -999;
Encoder rouge(Encodeur_CLK, Encodeur_R);
Encoder vert(Encodeur_CLK, Encodeur_V);
Encoder bleu(Encodeur_CLK, Encodeur_B);
Encoder tout(Encodeur_CLK, Encodeur_T);
void setup() {
Serial.begin(115400);
delay(50);
pinMode(EDR11_pinA, INPUT);
pinMode(EDR11_pinB, INPUT);
pinMode(EDR11_pinC, INPUT);
}
void loop() {
long nouvRouge, nouvVert, nouvBleu, nouvTout;
nouvRouge = rouge.read();
nouvVert = vert.read();
nouvBleu = bleu.read();
nouvTout = tout.read();
//On a changé au moins une des valeurs d'encodeur
if (nouvRouge != posiRouge || nouvVert != posiVert || nouvBleu != posiBleu || nouvTout != posiTout) {
if (EDR11_pinA == HIGH && EDR11_pinB == HIGH && EDR11_pinC == HIGH ) {
///Agissons selon les règles de la situation 7
} else if (EDR11_pinA == HIGH && EDR11_pinB == HIGH && EDR11_pinC == LOW) {
///Agissons selon les règles de la situation 7
} else if (EDR11_pinA == HIGH && EDR11_pinB == LOW && EDR11_pinC == HIGH) {
///Agissons selon les règles de la situation 6
} else if (EDR11_pinA == HIGH && EDR11_pinB == LOW && EDR11_pinC == LOW) {
///Agissons selon les règles de la situation 5
} else if (EDR11_pinA == LOW && EDR11_pinB == HIGH && EDR11_pinC == HIGH) {
///Agissons selon les règles de la situation 4
} else if (EDR11_pinA == LOW && EDR11_pinB == HIGH && EDR11_pinC == LOW) {
///Agissons selon les règles de la situation 3
} else if (EDR11_pinA == LOW && EDR11_pinB == LOW && EDR11_pinC == HIGH) {
///Agissons selon les règles de la situation 2
} else if (EDR11_pinA == LOW && EDR11_pinB == LOW && EDR11_pinC == LOW) {
///Agissons selon les règles de la situation 1
}
}
}
Je ne sais plus trop où, mais il me semble avoir vu que la pulsation CLK est générée par le composant et non par le micro-contrôleur. Je serais donc, dans ce cas, forcé d'abandonner cette économie de fil! Ouille! Il faut vraiment que j'entre toutes les informations dans 8 conducteurs! Beau défi!
A mon humble avis, tu peut mettre en commun le CLK et une broche du SW pour tous tes encodeurs
-Ca fait 1 fil pour tous
Ensuite, pour 4 encodeurs, il y a
-4 voies A
-4 voies B
-4 voies SW
Ca fait 13 fils.
Les voies A et B sont nécessaires pour déterminer le sens de rotation, dans 1 sens, tu incrémente, dans l'autre tu décremente par exemple, si tu t'en fous du sens tu peux économiser 4 fils, on passe à 9.
Si tu fais un décodeur 4 to 3 pour les SW, tu économises 1 fil
000 pas de SW
001 SW1
010 SW2
011 SW3
100 SW4
Non ce n'est pas possible. Si tous les CLK sont reliés comment sauras-tu lequel a bougé?
Éventuellement câbler les encodeurs en matrice comme pour les claviers mais là je ne crois pas qu'il existe une librairie qui fasse cela il va falloir la créer. Il faudra mettre des diodes en série avec les sorties des encodeurs car il y a toujours un contact fermé lorsque l'encodeur est statique.
Sur les encodeurs, il y a 3 broches souvent repérées C, A, B.
C : ce n'est pas le CLK c'est le commun de l'encodeur
A et B : 2 signaux déphasés (normalement) de 90°.
Certains modules présentent CLK et Data mais c'est un abus de langage cela correspond aux sorties A et B.
A priori j'ai un doute sur le rendu de la bibliothèque Encoder avec une série de connections/déconnections à un encodeur, mais bon il y a peut être une combine acceptable...
Voilà où je me suis fait prendre. J'ai pensé que CLK était comme dans d'autres composants: une pulsation.
J'avais vu cela dans le code Encoder.h et dans les exemples, mais je ne comprenais pas.
Là, tout s'explique.
Bref: des encodeurs comme EC11 ont besoin de deux brins chacun en plus du commun.
Le commun pourrait être commun à plusieurs encodeurs; puisque le commun n'apparaît sur aucune description de broche, je suppose que c'est le VCC.
Même si je réduis de 4 à 3 mon nombre d'encodeurs, j'ai encore besoin de 7 brins pour eux. Il ne m'en reste donc qu'un brin pour le sélecteur.
Matière à réflexion !
Ça vaut la peine d'en parler ici. Merci à tous.
Sur ces codeurs ainsi que sur les boutons, le commun est en général le GND.
Dans les bibliothèques, en général, c'est en mode PULLUP, par défaut, qu'elles sont paramétrées, comme les bibliothèque pour le traitement de boutons par ailleur.
