Comment fonctionne un contrôleur rotatif avec un encodeur rotatif à l’intérieur – Živěcz

Dans le prochain épisode de notre série de programmation électronique, nous reviendrons aux bases, montrant comment fonctionne un contrôleur sous la forme de codeur rotatif.

Si vous entendez ce terme pour la première fois, rappelez-vous que les encodeurs rotatifs font partie des composants d’entrée numérique les plus répandus. Ils peuvent servir soit de compte-tours d’un arbre – par exemple un moteur électrique – soit de commande rotative.

Une commande qui peut être tournée pour augmenter le volume, changer la fréquence du récepteur radio, le mode de la machine à laver ou peut-être faire défiler un menu sur l’écran. Un codeur rotatif est donc une variante numérique d’un contrôleur analogique sous la forme d’un potentiomètre.

Regardez la vidéo sur le fonctionnement d’un codeur rotatif, à quoi ressemble son signal dans un analyseur logique et comment il peut être utilisé dans la pratique :

Alors que le potentiomètre modifie la résistance électrique dans le circuit en faisant tourner l’arbre, le codeur rotatif connecte et déconnecte le circuit en faisant tourner l’arbreet y crée ainsi un signal rectangulaire.

Tachymètres magnétiques et IR

Il existe un certain nombre d’encodeurs en fonction de la façon dont ils commutent le circuit. Dans le cas des tachymètres numériques, un champ magnétique ou une lumière infrarouge est généralement utilisé à cet effet.

Si nous plaçons un aimant sur l’arbre rotatif (peut-être) d’un moteur électrique et un capteur de champ magnétique Hall à proximité, chaque fois que l’aimant rotatif s’approche, le capteur ferme un circuit dans lequel une impulsion est créée.

Un moteur à courant continu commun avec un module tachymètre avec deux capteurs magnétiques

Ou nous pourrions attacher un petit disque avec des trous à l’arbre. Il y aura une LED IR d’un côté du disque et un détecteur IR de l’autre. Dès qu’il y a une ouverture entre la LED IR et le détecteur IR lors de la rotation du disque, le capteur enregistre la lumière et referme le circuit.

L’arbre rotatif produit un signal rectangulaire

On peut donc détecter la rotation de l’arbre comme une séquence d’impulsions sur le fil du codeur. S’il n’y avait qu’un seul trou sur le disque, ou si nous ne placions qu’un seul capteur Hall sur l’encodeur, chaque impulsion représenterait exactement un tour complet.

Tachymètre infrarouge sans contact avec détection de tours entiers

En les comptant et en mesurant le temps, on peut facilement connaître la vitesse angulaire de rotation (°/s), le nombre de tours par minute (RPM), et si un tel moteur électrique entraînera, par exemple, une machine télécommandée petite voiture, puis enfin aussi les km/ha parcourus depuis la circonférence de ses pneus.

Mais un trou ne suffit pas, et le capteur aussi

Cependant, un trou ne suffit généralement pas, car nous devons souvent mesurer la rotation avec une résolution beaucoup plus élevée que les 360° complets. Si nous forons dix trous de ce type dans le disque, la résolution passera de 360°/impulsion à 36°/impulsion.

De la même manière, avec la plupart des encodeurs, on ne peut pas se contenter d’un seul fil de sortie, car c’est simple on ne peut pas déterminer le sens de rotation en mesurant les impulsions. Mais lorsque nous plaçons deux capteurs l’un à côté de l’autre avec leurs propres circuits qui se connectent et se déconnectent, tout change soudainement.

Disque à six trous et collecteurs de contact avec un petit déphasage. Le variateur est connecté à la masse du système, donc lorsque les collecteurs sont touchés, ils sont au niveau logique bas et lorsque le contact est coupé (collecteurs au-dessus du trou), ils sont au niveau logique haut

Dans les deux circuits, le même signal rectangulaire sera créé par rotation, cependant, du fait que les capteurs sont côte à côte, leurs signaux de sortie seront légèrement décalés en phase. Le changement se produit d’abord sur le premier capteur, et seulement après un autre petit déplacement de l’arbre également sur le second. Eh bien, à partir de cette séquence, nous déterminerons la direction.

Encodeur rotatif à contact avec deux capteurs

Montrons-le sur l’encodeur rotatif le plus simple, qui est utilisé pour un contrôle précis de l’appareil cible, et vous pouvez trouver un modèle pratiquement identique sur de nombreuses imprimantes 3D, par exemple, en tant que broche rotative de contrôle pour faire défiler le menu sur l’écran LCD afficher. Les machines de Czech Prusa Research ne font pas exception.

Module de prototypage d’un codeur rotatif combiné avec un bouton. Vous pouvez en trouver un similaire sur les imprimantes 3D de Prusa Research

Un encodeur similaire sous la forme d’un module de prototypage pour une connexion facile a généralement trois broches logiques nommées en plus de l’alimentation CLK, DT un SW. Alors que CLK et DT représentent le circuit de capteurs consécutifs, SW est connecté au circuit du bouton.

La plupart des encodeurs rotatifs de contrôle combinent également un bouton de confirmation en appuyant sur l’arbre. Avec un seul composant, nous pouvons alors contrôler toute l’interface utilisateur sur l’écran.

Signal dans le traceur Arduino et l’analyseur logique

Dans le premier programme, nous connecterons le module de contrôleur d’encodeur rotatif à la carte tchèque Kit ESP32-LP par Laskakit et nous écrirons simplement les états logiques sur les broches SW, CLK et DT dans une boucle infinie, que nous examinerons dans le traceur graphique de l’environnement Arduino.

Schéma de câblage de l’exemple du jour avec la carte ESP32-LPKit

Cependant, la carte ESP32-LPKit n’est bien sûr pas une nécessité. Il fonctionnera également avec d’autres kits Arduino. Faites juste attention que dans les exemples, nous utilisons la méthode Serial.printf, qui n’est pas prise en charge par de nombreuses autres puces, et nous devrions décomposer l’impression sur la ligne série partie par partie en utilisant print et println.

Le premier programme simple avec une simple sortie d’états numériques sur les broches CLK, DT et SW

#define CLK 25
#define DT 26
#define SW 27

void setup() {
  Serial.begin(115200);
  pinMode(CLK, INPUT);
  pinMode(DT, INPUT);
  pinMode(SW, INPUT_PULLUP);
}

void loop() {
  Serial.printf("CLK:%dtDT:%dtSW:%drn", digitalRead(CLK), digitalRead(DT), digitalRead(SW));
  delay(10);
}

Nous avons connecté les broches CLK, DT et SW aux broches de la carte 25, 26 et 27 comme indiqué sur l’image. Le circuit du bouton renvoie un un logique à l’état inactif (le circuit est fermé) et un zéro logique lorsqu’il est enfoncé (le circuit est connecté à la masse du système en appuyant dessus).

Sortie dans le traceur Arduino pour les deux sens de rotation

Les états logiques des broches CLK et DT correspondront alors à l’état actuel des collecteurs à l’intérieur du codeur. En tournant, leur signal rectangulaire avec des impulsions sera tracé dans le traceur, tandis que le petit déphasage entre les deux signaux dû au fait que les collecteurs CLK et DT sont côte à côte avec un petit retard sera magnifiquement visible.

Selon le sens de rotation, le signal CLK sera légèrement en avance, ou DT au contraire. Lors d’une rotation dans le sens inverse des aiguilles d’une montre, un état haut apparaît toujours en premier sur la broche CLK, tandis que lors d’une rotation dans le sens des aiguilles d’une montre, sur la broche DT. Cela sera également confirmé en examinant la sortie beaucoup plus précise de l’analyseur logique dans le programme Logique.

Même situation, mais cette fois dans l’analyseur logique et l’application logique

Compteur codeur avec détermination du sens

Maintenant, nous allons l’utiliser et écrire un compteur avec détection de direction. Si nous tournons l’arbre dans le sens des aiguilles d’une montre, le compteur augmentera, et si nous inversons le sens, le compteur diminuera. A chaque changement d’état, la valeur et la direction actuelles seront écrites sur la ligne série.

Sortie du deuxième programme avec le compteur du codeur dans la ligne série

Nous pourrions déjà utiliser cette information, par exemple, juste pour parcourir un menu sur l’écran, tandis que la valeur du compteur représentera l’index de l’élément dans la liste. Ou peut-être le volume ou un autre changement.

Détection des impulsions CLK et comparaison avec DT

Comment fait-on exactement cela ? Nous avons déjà montré que, selon le sens de rotation, soit l’impulsion est créée en premier sur la broche CLK, soit sur la broche DT. Par conséquent, dans une boucle infinie, nous continuerons à lire l’état sur la broche CLK et à le comparer avec l’état de l’exécution précédente.

Nous tournons l’encodeur rotatif

Si l’état sur CLK est haut et en même temps différent du précédent, on est au début d’une nouvelle impulsion. Si nous faisons tourner l’arbre dans le sens des aiguilles d’une montre, la broche DT doit toujours être au zéro logique à ce moment. Si c’est le cas, nous incrémentons le compteur et réglons la direction sur “dans le sens des aiguilles d’une montre”.

Lors de la détection d’une nouvelle impulsion sur CLK, nous détectons l’état sur DT et augmentons ou diminuons le compteur en conséquence et changeons le sens de rotation

Cependant, si l’état sur la broche DT est également égal à un logique, cela signifie qu’au début de l’impulsion sur CLK, il y avait déjà une impulsion sur la broche DT également, et donc le DT est légèrement en avance. Cela signifie donc que nous tournons l’arbre dans le sens inverse des aiguilles d’une montre, diminuons la valeur du compteur et également la direction.

À la fin, nous écrivons la valeur du compteur et la direction de la ligne série, et à la toute fin, dans la boucle infinie, nous détectons l’appui sur le bouton, c’est-à-dire la déconnexion du circuit sur la broche SW.

Le deuxième programme simple, qui convertit déjà la rotation en compteur, notamment en déterminant le sens :

// Vystupy rotacniho enkoderu pripojime na rtyto piny desky ESP32-LPKit
// Muzete samozrejme pouzit jakokoliv jine
#define CLK 25
#define DT 26
#define SW 27

// Pomocne promenne pocitadla,
// aktualniho stavu, stisku a smeru
int16_t pocitadlo = 0;
uint8_t aktualniCLK;
uint8_t posledniCLK;
String smer = "";
uint32_t posledniStiskTlacitka = 0;


// Hlavni funkce setup se zpracuje hned na zacatku 
void setup() {
  // Nastartujeme seriovbou linku do PC rychlosti 115200 b/s
  Serial.begin(115200);
 // Nastavime piny enkoderu CLK a DT na vsrtup 
  pinMode(CLK, INPUT);
  pinMode(DT, INPUT);
  // Nastavime pin tlacitka SW na vstup v rezimu pull-up (v klidovem stavu vysoke napeti, pri stisku nizke)
  pinMode(SW, INPUT_PULLUP);
  // Precteme aktualni stav prvnihjo sberace pripojeneho k pinu CLK 
  posledniCLK = digitalRead(CLK);

}

// Smycka loop se opakuje stale dokola
// a spusti se po zpracovani funkce setup
void loop() {
  // Precteme aktualni stav prvniho sberace
  aktualniCLK = digitalRead(CLK);
  // Pokud se lisi od predchoziho a je roven logicke 1,
  // znamena to, ze detekujeme novy pulz a otacime hrideli
  if (aktualniCLK != posledniCLK  && aktualniCLK == 1) {
    // Precteme stav druheho sberace
    // Pokud je rovne nule, sberac CLK predbiha DT (na DT jeste neni vysoky pulz),
    // takze tocime po smeru hodinovych rucicek
    if (digitalRead(DT) == 0) {
      // Navysime pocitadlo
      pocitadlo++;
      smer = "Po smeru hodinovych rucicek";
    // Pokud je roven 1, sberac DT predbiha CLK (na DT uz je vysoky pulz),
    // takze tocime proti smeru hodinovych rucicek 
    } else {
      // Snizime pocitadlo
      pocitadlo--;
      smer = "Proti smeru hodinovych rucicek";
    }
    // Vypiseme stav enkoderu do serioveho terminalu
    Serial.print("Pocitadlo: ");
    Serial.print(pocitadlo);
    Serial.print(" (");
    Serial.print(smer);
    Serial.println(")");
  }

  // Aktualizujeme promennou s predchozim stavem prvniho sberace
  posledniCLK = aktualniCLK;

  // Zjistime, jestli nedoslo ke stisku tlacitka
  if (digitalRead(SW) == LOW) {
    // Stisk registrujeme jen kazdych 50 ms,
    // cimz igfnorujeme sum a vicenasobny rychly stisk
    if (millis() - posledniStiskTlacitka > 50)
      Serial.println("Stisk tlacitka!");
    posledniStiskTlacitka = millis();
  }

}

On pourrait modifier le code ci-dessus de manière à ce que la détection du front montant sur CLK (arrivée d’une nouvelle impulsion) soit détectée de manière asynchrone à l’aide d’une interruption système et d’une fonction attachInterrupt.

Dans celui-ci, nous enregistrerions l’événement RISING (détection du front montant de l’impulsion) sur la broche CLK et lirions l’état sur la broche DT en même temps. En les comparant à nouveau, nous arriverons à la même logique.

En pratique, travailler avec un encodeur rotatif est couvert par l’une des nombreuses bibliothèques que vous pouvez trouver sur GitHub ou dans le catalogue des bibliothèques pour Arduino. Aujourd’hui, cependant, nous avons voulu pénétrer jusqu’au cœur du principe de fonctionnement de l’encodeur rotatif, nous avons donc tout écrit jusqu’au niveau le plus bas.