Arduino - Encodeur rotatif

Dans ce tutoriel, nous allons apprendre à utiliser l'encodeur incrémental avec Arduino. En détail, nous apprendrons :

Préparation du matériel

1×Arduino Uno
1×USB 2.0 cable type A/B
1×Rotary Encoder
1×Jumper Wires
1×(Optional) 9V Power Adapter for Arduino
1×(Recommended) Screw Terminal Block Shield for Arduino Uno
1×(Optional) Transparent Acrylic Enclosure For Arduino Uno

Or you can buy the following sensor kits:

1×DIYables Sensor Kit (30 sensors/displays)
1×DIYables Sensor Kit (18 sensors/displays)
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

À propos de l'encodeur rotatif

Un encodeur rotatif est un dispositif électromécanique qui convertit un mouvement de rotation en un signal électrique. Il mesure la rotation et la position d'un arbre ou d'un bouton. Il existe deux types principaux :

  • Encodeur incrémental : qui génère des impulsions pour mesurer le changement relatif
  • Encodeur absolu : qui fournit un code numérique unique pour chaque position, les rendant idéaux pour un positionnement précis même après une perte de puissance.

Ce guide concerne l'encodeur incrémental.

Brochage du module encodeur rotatif

brochage de l'encodeur rotatif

Un module d'encodeur rotatif possède 4 broches :

  • Broche CLK (Sortie A) : est l'impulsion principale qui nous indique l'ampleur de la rotation. Chaque fois que vous tournez le bouton d'un cran (clic) dans n'importe quelle direction, la broche CLK émet un signal qui complète un cycle complet (LOW HIGH LOW).
  • Broche DT (Sortie B) : agit comme la broche CLK mais émet un signal qui est en retard de 90 degrés par rapport au signal CLK. Cela nous aide à déterminer la direction de la rotation (dans le sens des aiguilles d'une montre ou dans le sens inverse).
  • Broche SW : est la sortie du bouton-poussoir à l'intérieur de l'encodeur. Elle est normalement ouverte. Si nous utilisons une résistance de tirage sur cette broche, la broche SW sera HIGH lorsque le bouton n'est pas pressé, et LOW lorsque il est pressé.
  • Broche VCC (+) : doit être connectée à VCC (entre 3.3 et 5 volts)
  • Broche GND : doit être connectée à GND (0V)

Encodeur rotatif vs Potentiomètre

Vous pouvez confondre l'encodeur rotatif avec le potentiomètre, mais ce sont des composants distincts. Voici une comparaison entre eux :

  • L'encodeur rotatif est comme la version moderne du potentiomètre, mais il peut faire plus de choses.
  • L'encodeur rotatif peut tourner complètement sans s'arrêter, tandis que le potentiomètre ne peut tourner qu'à environ trois quarts de cercle.
  • L'encodeur rotatif émet des impulsions, tandis que le potentiomètre émet une tension analogique.
  • L'encodeur rotatif est pratique lorsque vous avez juste besoin de déterminer combien le bouton a bougé, pas exactement où il se trouve. Le potentiomètre est utile lorsque vous avez vraiment besoin de savoir exactement où se trouve un bouton.

Fonctionnement d'un encodeur rotatif

sortie d'encodeur rotatif

À l'intérieur de l'encodeur, il y a un disque avec des fentes relié à une broche appelée C, qui fait office de masse commune. Il y a deux autres broches, A et B.

  • Lorsque vous tournez le bouton, les broches A et B touchent la broche de masse commune C, mais dans un certain ordre selon le sens dans lequel vous tournez le bouton (dans le sens horaire ou antihoraire).
  • Ces contacts créent deux signaux. Ils sont légèrement différents en termes de timing car une broche touche la masse avant l'autre. Les deux signaux sont déphasés de 90 degrés l'un par rapport à l'autre. Cela est appelé encodage en quadrature.
  • Lorsque vous tournez le bouton dans le sens horaire, la broche A touche la masse avant la broche B. Lorsque vous tournez le bouton dans le sens antihoraire, la broche B touche la masse avant la broche A.
  • En surveillant quand chaque broche touche ou quitte la masse, nous pouvons déterminer dans quel sens tourne le bouton. Nous faisons cela en vérifiant ce qui arrive à la broche B lorsque la broche A change.
Comment fonctionne un encodeur rotatif

Lorsque A passe de l'état BAS à l'état HAUT:

  • Si B est BAS, le bouton est tourné dans le sens des aiguilles d'une montre.
  • Si B est ÉLEVÉ, le bouton est tourné dans le sens inverse des aiguilles d'une montre.

※ NOTE THAT:

Les broches A et B sont connectées aux broches CLK et DT. Cependant, selon les fabricants, l'ordre peut être différent. Les codes fournis ci-dessous ont été testés avec l'encodeur rotatif de DIYables.

Comment programmer pour un encodeur rotatif

  • Vérifiez le signal de la broche CLK
  • Si l'état passe de BAS à HAUT, vérifiez l'état de la broche DT.
    • Si l'état de la broche DT est HAUT, le bouton est tourné dans le sens antihoraire, augmentez le compteur de 1
    • Si l'état de la broche DT est BAS, le bouton est tourné dans le sens horaire, diminuez le compteur de 1

Diagramme de câblage

Schéma de câblage de l'encodeur rotatif Arduino

This image is created using Fritzing. Click to enlarge image

Code Arduino - Encodeur rotatif sans interruption

Le code Arduino ci-dessous fait :

  • Détecte la direction et l'ampleur de la rotation de l'encodeur.
    • Si détection du bouton tourné d'un cran (clic) dans le sens des aiguilles d'une montre, augmenter le compteur de un.
    • Si détection du bouton tourné d'un cran (clic) dans le sens inverse des aiguilles d'une montre, diminuer le compteur de un.
  • Détecte si le bouton est pressé.
/* * Ce code Arduino a été développé par newbiely.fr * Ce code Arduino est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino/arduino-rotary-encoder */ #include <ezButton.h> // the library to use for SW pin #define CLK_PIN 2 #define DT_PIN 3 #define SW_PIN 4 #define DIRECTION_CW 0 // clockwise direction #define DIRECTION_CCW 1 // counter-clockwise direction int counter = 0; int direction = DIRECTION_CW; int CLK_state; int prev_CLK_state; ezButton button(SW_PIN); // create ezButton object that attach to pin 4 void setup() { Serial.begin(9600); // configure encoder pins as inputs pinMode(CLK_PIN, INPUT); pinMode(DT_PIN, INPUT); button.setDebounceTime(50); // set debounce time to 50 milliseconds // read the initial state of the rotary encoder's CLK pin prev_CLK_state = digitalRead(CLK_PIN); } void loop() { button.loop(); // MUST call the loop() function first // read the current state of the rotary encoder's CLK pin CLK_state = digitalRead(CLK_PIN); // If the state of CLK is changed, then pulse occurred // React to only the rising edge (from LOW to HIGH) to avoid double count if (CLK_state != prev_CLK_state && CLK_state == HIGH) { // if the DT state is HIGH // the encoder is rotating in counter-clockwise direction => decrease the counter if (digitalRead(DT_PIN) == HIGH) { counter--; direction = DIRECTION_CCW; } else { // the encoder is rotating in clockwise direction => increase the counter counter++; direction = DIRECTION_CW; } Serial.print("DIRECTION: "); if (direction == DIRECTION_CW) Serial.print("Clockwise"); else Serial.print("Counter-clockwise"); Serial.print(" | COUNTER: "); Serial.println(counter); } // save last CLK state prev_CLK_state = CLK_state; if (button.isPressed()) { Serial.println("The button is pressed"); } }

Pour simplifier le code pour le debouncing de bouton, la bibliothèque ezButton est utilisée.

Étapes rapides

  • Installez la bibliothèque ezButton sur Arduino IDE. Voir Comment faire
  • Copiez le code ci-dessus et ouvrez-le avec Arduino IDE
  • Cliquez sur le bouton Upload sur Arduino IDE pour téléverser le code sur Arduino
  • Tournez le bouton dans le sens des aiguilles d'une montre, puis dans le sens inverse
  • Appuyez sur le bouton
  • Vérifiez le résultat sur le moniteur série.
COM6
Send
DIRECTION: Clockwise | COUNTER: 1 DIRECTION: Clockwise | COUNTER: 2 DIRECTION: Clockwise | COUNTER: 3 DIRECTION: Clockwise | COUNTER: 4 DIRECTION: Clockwise | COUNTER: 5 DIRECTION: Counter-clockwise | COUNTER: 4 DIRECTION: Counter-clockwise | COUNTER: 3 DIRECTION: Counter-clockwise | COUNTER: 2 DIRECTION: Counter-clockwise | COUNTER: 1 DIRECTION: Counter-clockwise | COUNTER: 0 The button is pressed
Autoscroll Show timestamp
Clear output
9600 baud  
Newline  

Explication du code

Consultez les commentaires ligne par ligne dans le code.

Code Arduino - Encodeur rotatif avec interruption

Dans l'exemple de code précédent, nous utilisons la méthode de polling, qui vérifie en continu l'état de la broche. Cela présente deux inconvénients :

  • Gaspiller la ressource Arduino
  • Certains compteurs peuvent être manqués si un autre code prend beaucoup de temps à exécuter.

Une approche pour gérer cela est d'utiliser des interruptions. Les interruptions suppriment le besoin de vérifier constamment un événement particulier. Cela permet à l'Arduino d'effectuer d'autres tâches sans négliger un événement.

Voici un exemple de lecture d'un encodeur rotatif avec des interruptions.

/* * Ce code Arduino a été développé par newbiely.fr * Ce code Arduino est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino/arduino-rotary-encoder */ #include <ezButton.h> // the library to use for SW pin #define CLK_PIN 2 #define DT_PIN 3 #define SW_PIN 4 #define DIRECTION_CW 0 // clockwise direction #define DIRECTION_CCW 1 // counter-clockwise direction volatile int counter = 0; volatile int direction = DIRECTION_CW; volatile unsigned long last_time; // for debouncing int prev_counter; ezButton button(SW_PIN); // create ezButton object that attach to pin 4 void setup() { Serial.begin(9600); // configure encoder pins as inputs pinMode(CLK_PIN, INPUT); pinMode(DT_PIN, INPUT); button.setDebounceTime(50); // set debounce time to 50 milliseconds // use interrupt for CLK pin is enough // call ISR_encoderChange() when CLK pin changes from LOW to HIGH attachInterrupt(digitalPinToInterrupt(CLK_PIN), ISR_encoderChange, RISING); } void loop() { button.loop(); // MUST call the loop() function first if (prev_counter != counter) { Serial.print("DIRECTION: "); if (direction == DIRECTION_CW) Serial.print("Clockwise"); else Serial.print("Counter-clockwise"); Serial.print(" | COUNTER: "); Serial.println(counter); prev_counter = counter; } if (button.isPressed()) { Serial.println("The button is pressed"); } // TO DO: your other work here } void ISR_encoderChange() { if ((millis() - last_time) < 50) // debounce time is 50ms return; if (digitalRead(DT_PIN) == HIGH) { // the encoder is rotating in counter-clockwise direction => decrease the counter counter--; direction = DIRECTION_CCW; } else { // the encoder is rotating in clockwise direction => increase the counter counter++; direction = DIRECTION_CW; } last_time = millis(); }

Maintenant, lorsque vous tournez le bouton, vous remarquerez que des informations apparaissent sur le moniteur série, tout comme ce que vous avez vu dans le code précédent.

※ NOTE THAT:

  • Si vous utilisez l'interruption, vous devez connecter la broche CLK de l'encodeur à une broche Arduino capable de gérer les interruptions. Mais rappelez-vous, toutes les broches Arduino ne peuvent pas faire cela. Par exemple, sur l'Arduino Uno, seules les broches 2 et 3 peuvent fonctionner avec des interruptions.
  • Vous pourriez trouver des tutoriels sur d'autres sites qui utilisent deux interruptions pour un seul encodeur, mais cela est inutile et gaspilleur. Une seule interruption est suffisante.
  • Il est important d'utiliser le mot-clé volatile pour les variables globales utilisées dans l'interruption. Négliger cela pourrait entraîner des problèmes inattendus.
  • Gardez le code à l'intérieur de l'interruption aussi simple que possible. Évitez d'utiliser Serial.print() ou Serial.println() à l'intérieur de l'interruption.

Application de l'encodeur rotatif Arduino

Avec l'encodeur rotatif, nous pouvons réaliser les applications suivantes, sans nous y limiter :

  • Arduino - L'encodeur rotatif contrôle la position du moteur servo
  • Arduino - L'encodeur rotatif contrôle la luminosité de la LED
  • Arduino - L'encodeur rotatif contrôle la vitesse du moteur pas à pas

Vidéo

Références de fonction

※ OUR MESSAGES

  • Please feel free to share the link of this tutorial. However, Please do not use our content on any other websites. We invested a lot of effort and time to create the content, please respect our work!