Arduino Mega - Encodeur rotatif
Ce guide montre comment utiliser un encodeur incrémental avec Arduino Mega. Nous couvrirons :
- Ce qu'est un encodeur rotatif et comment il fonctionne
- En quoi un encodeur rotatif diffère d'un potentiomètre
- Comment connecter un encodeur rotatif à un Arduino Mega
- Comment lire un encodeur rotatif avec un Arduino Mega sans interruptions
- Comment lire un encodeur rotatif avec un Arduino Mega en utilisant les interruptions
Matériel requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
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 qui convertit un mouvement de rotation en signal électrique. Il mesure combien un arbre ou un bouton a tourné et sa position. Il existe deux types principaux :
- Encodeur incrémental : Il envoie des impulsions pour suivre le mouvement.
- Encodeur absolu : Il donne un code numérique unique pour chaque position, donc il montre la position exacte même si l'alimentation est coupée.
Ce guide concerne l'encodeur incrémental.
Brochage du module encodeur rotatif
Un module encodeur rotatif a quatre broches :
- Broche CLK (Sortie A) : Envoie une impulsion chaque fois que vous faites tourner le bouton d'un cran dans l'une ou l'autre direction, de bas vers haut puis de nouveau vers le bas. Cela montre jusqu'où le bouton s'est déplacé.
- Broche DT (Sortie B) : Identique à CLK, mais l'impulsion arrive un peu plus tard—90 degrés après l'impulsion CLK. Ce délai nous aide à déterminer si la rotation est dans le sens horaire ou antihoraire.
- Broche SW : Se connecte au bouton poussoir intégré de l'encodeur, qui est normalement ouvert. Avec une résistance de rappel (pull-up), cette broche lit HIGH quand elle n'est pas pressée et LOW quand elle est pressée.
- Broche VCC (+) : Connecter à une alimentation de 3,3 à 5 volts.
- Broche GND : Connecter à la masse (0V).
Encodeur rotatif vs Potentiomètre
Vous pourriez confondre l'encodeur rotatif avec le Arduino Mega - Potentiomètre, mais ce sont deux composants différents. Voici comment ils diffèrent :
- Un encodeur rotatif peut tourner indéfiniment, mais un potentiomètre ne peut tourner qu'environ 3/4 de cercle.
- Un encodeur rotatif envoie des impulsions, tandis qu'un potentiomètre fournit une tension variable.
- Un encodeur rotatif vous aide à savoir approximativement jusqu'où le bouton a tourné, mais pas la position exacte. Un potentiomètre donne la position exacte du bouton.
Fonctionnement de l'encodeur rotatif
Dans l'encodeur, un disque rond avec des fentes est connecté à une broche nommée C, qui est la masse commune. Il y a aussi deux autres broches, A et B.
- Quand vous tournez le bouton, les broches A et B touchent la broche de masse commune C dans un certain ordre. L'ordre dépend de si vous tournez dans le sens horaire ou antihoraire.
- Ce contact crée deux signaux qui sont légèrement déphasés car une broche va à la masse avant l'autre. Les signaux sont déphasés de 90 degrés. Cette méthode s'appelle l'encodage en quadrature.
- Rotation horaire : la broche A atteint la masse avant la broche B. Rotation antihoraire : la broche B atteint la masse avant la broche A.
- En observant quand chaque broche fait ou rompt le contact avec la masse, nous pouvons dire dans quelle direction le bouton tourne. Nous déterminons la direction en regardant comment la broche B change par rapport à la broche A.
Quand A passe de bas à haut :
- Tourner le bouton vers la droite si B est bas.
- Tourner le bouton vers la gauche si B est haut.
※ Note:
Les broches A et B se connectent aux broches CLK et DT. La configuration peut varier selon le fabricant. Les codes montrés ici ont été testés avec l'encodeur rotatif de DIYables.
Comment programmer pour l'encodeur rotatif
- Vérifier le signal sur la broche CLK.
- Quand le signal passe de bas à haut, vérifier la broche DT.
- Si la broche DT est haute, le bouton a bougé dans le sens antihoraire (vers la gauche). Ajouter 1 au compteur.
- Si la broche DT est basse, le bouton a bougé dans le sens horaire (vers la droite). Soustraire 1 au compteur.
Schéma de câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code Arduino Mega – Encodeur rotatif sans interruption
Ce code Arduino Mega fait ces choses :
- Il détecte jusqu'où le bouton est tourné.
- Si le bouton est tourné d'un cran vers la droite, il ajoute un au compteur.
- Si le bouton est tourné d'un cran vers la gauche, il soustrait un du compteur.
- Il détecte quand le bouton est pressé.
/*
* Ce code Arduino Mega a été développé par newbiely.fr
* Ce code Arduino Mega 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-mega/arduino-mega-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2 // The Arduino Mega pin connected to the CLK pin of encoder
#define DT_PIN 3 // The Arduino Mega pin connected to the DT pin of encoder
#define SW_PIN 4 // The Arduino Mega pin connected to the SW pin of encoder
#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");
}
}
Nous utilisons la bibliothèque ezButton pour rendre le code du bouton plus facile et éviter les pressions multiples.
Étapes rapides
Suivez ces étapes une par une.
- Connectez l'encodeur rotatif à l'Arduino Mega comme montré dans le schéma.
- Connectez l'Arduino Mega à votre ordinateur avec un câble USB.
- Ouvrez l'IDE Arduino sur votre ordinateur.
- Choisissez la carte Arduino Mega et le bon port COM.
- Installez la bibliothèque ezButton dans l'IDE Arduino. Pour les étapes, visitez https://arduinogetstarted.com/tutorials/arduino-button-library#content_how_to_install
- Copiez le code donné et ouvrez-le dans l'IDE Arduino.
- Cliquez sur le bouton Téléverser dans l'IDE Arduino pour envoyer le code à l'Arduino Mega.
- Tournez le bouton dans le sens horaire, puis dans le sens antihoraire.
- Pressez le bouton.
- Vérifiez les résultats dans le Moniteur Série.
COM6
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
Clear output
9600 baud
Newline
Explication du code
Lisez les commentaires dans le code pour chaque ligne.
Code Arduino Mega – Encodeur rotatif avec interruption
Dans l'exemple de code précédent, nous avons utilisé le polling, qui vérifie constamment l'état de la broche. Cette approche a deux inconvénients :
- Utilise mal les ressources de l'Arduino Mega.
- Certains comptages peuvent être manqués si un autre programme s'exécute trop lentement.
Une façon de gérer cela est avec les interruptions. Les interruptions vous évitent d'avoir à vérifier constamment un événement spécifique. Cela permet à l'Arduino Mega de faire d'autres tâches tout en surveillant les événements.
Regardons le code ci-dessous qui utilise une interruption pour lire la valeur de l'encodeur.
/*
* Ce code Arduino Mega a été développé par newbiely.fr
* Ce code Arduino Mega 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-mega/arduino-mega-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2 // The Arduino Mega pin connected to the CLK pin of encoder
#define DT_PIN 3 // The Arduino Mega pin connected to the DT pin of encoder
#define SW_PIN 4 // The Arduino Mega pin connected to the SW pin of encoder
#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();
}
- Copiez le code qui vous a été donné et ouvrez-le dans l'IDE Arduino.
- Cliquez sur le bouton Téléverser dans l'IDE Arduino pour téléverser le code vers l'Arduino Mega.
Maintenant, quand vous tournez le bouton, vous verrez des informations apparaître sur le Moniteur Série, exactement comme vous l'avez vu avant dans le code précédent.
※ Note:
- Pour connecter la broche CLK de l'encodeur à un Arduino Mega avec une interruption, utilisez les broches 2 ou 3. Ce sont les seules broches qui peuvent faire des interruptions.
- Certains guides en ligne disent que vous devriez utiliser deux interruptions pour un encodeur, mais vous n'en avez pas besoin. Une interruption suffit.
- Déclarez toute variable globale utilisée dans l'interruption comme volatile pour éviter les problèmes.
- Gardez le code à l'intérieur de l'interruption simple. N'utilisez pas Serial.print() ou Serial.println() là-dedans.