Arduino UNO R4 - Encodeur rotatif
Dans ce guide, nous apprendrons comment utiliser un encodeur incrémental avec l'Arduino UNO R4. Nous aborderons :
- Comment fonctionne un encodeur rotatif
- Différences entre un encodeur rotatif et un potentiomètre
- Comment connecter un encodeur rotatif à un Arduino UNO R4
- Comment programmer l'Arduino UNO R4 pour lire la valeur d'un encodeur rotatif sans utiliser d'interruptions
- Comment programmer l'Arduino UNO R4 pour lire la valeur d'un encodeur rotatif avec des interruptions
Préparation du matériel
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables STEM V4 IoT (Arduino inclus) | |
| 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 codeur rotatif est un dispositif qui transforme le mouvement de rotation en un signal électrique. Il détecte la rotation et la position d'un arbre ou d'un bouton. Il existe deux types principaux :
- Encodeur incrémental : Cela génère des impulsions pour mesurer les changements de position.
- Encodeur absolu : Cela fournit un code numérique spécial pour chaque position, ce qui le rend idéal pour un positionnement précis, même en cas de coupure d'alimentation.
Ce tutoriel porte sur l'encodeur incrémentiel.
Schéma des broches du module d'encodeur rotatif
Un module d'encodeur rotatif est livré avec quatre broches :
- Broche CLK (Sortie A) : Cette broche envoie un signal à chaque fois que vous tournez le bouton d'un cran dans n'importe quelle direction, montrant un cycle de signal complet du LOW au HIGH puis au LOW. Cela nous indique de combien le bouton a été tourné.
- Broche DT (Sortie B) : Semblable à la broche CLK, mais le signal de cette broche est légèrement retardé, apparaissant 90 degrés après le signal CLK. Ce retard nous aide à déterminer si la rotation est dans le sens horaire ou antihoraire.
- Broche SW : Cette broche se connecte au bouton-poussoir interne de l'encodeur, qui est généralement ouvert. En utilisant une résistance de pull-up sur cette broche, elle affichera HIGH lorsque le bouton n'est pas enfoncé et LOW lorsqu'il est enfoncé.
- Broche VCC (+) : Connectez cette broche à une alimentation qui fournit entre 3,3 et 5 volts.
- Broche GND : Connectez cette broche à la masse (0V).
Encodeur rotatif vs potentiomètre
Vous pourriez confondre l'encodeur rotatif avec le Arduino UNO R4 - potentiomètre., mais ce sont des pièces différentes. Voici comment ils se comparent :
- Un encodeur rotatif peut tourner indéfiniment, mais un potentiomètre ne peut effectuer qu'environ trois quarts d'un tour.
- Un encodeur rotatif émet des impulsions, tandis qu'un potentiomètre émet une tension analogique.
- Un encodeur rotatif est utile pour savoir de combien un bouton a tourné, mais pas pour connaître sa position exacte. Un potentiomètre est utile pour connaître la position précise d'un bouton.
Comment fonctionne un encodeur rotatif
Dans l'encodeur, il y a un disque doté de fentes relié à une broche nommée C, servant de masse commune. Il y a aussi deux broches supplémentaires, A et B.
- Lorsque vous tournez le bouton, les broches A et B entrent en contact avec la broche de masse commune C, mais dans une séquence spécifique en fonction de la direction de la rotation, soit dans le sens des aiguilles d'une montre, soit dans le sens antihoraire.
- Ce contact génère deux signaux dont le timing diffère légèrement, car l'une des broches se met au contact de la masse avant l'autre. Ces signaux présentent un déphasage de 90 degrés, et cela s'appelle le codage en quadrature.
- Tourner le bouton dans le sens horaire fait que la broche A entre en contact avec la masse plus tôt que la broche B. Tourner dans le sens antihoraire fait que la broche B entre en contact avec la masse avant la broche A.
- En observant quand chaque broche entre en contact avec la masse ou cesse de l'être, nous pouvons déterminer la direction de la rotation du bouton. Nous y parvenons en analysant les changements de la broche B par rapport à la broche A.
Lorsque A passe de BAS à HAUT :
- Tournez le bouton dans le sens des aiguilles d'une montre si B est bas.
- Tournez le bouton dans le sens inverse des aiguilles d'une montre si B est haut.
※ Note:
Les broches A et B sont connectées aux broches CLK et DT. La disposition peut varier selon le fabricant. Les codes donnés ici ont été testés avec l'encodeur rotatif de DIYables.
Comment programmer pour un encodeur rotatif
- Vérifiez le signal sur la broche CLK.
- Lorsque le signal passe de bas à haut, vérifiez ce que montre la broche DT.
- Si la broche DT affiche haut, la molette est tournée dans le sens antihoraire. Ajoutez 1 au compteur.
- Si la broche DT affiche bas, la molette est tournée dans le sens horaire. Soustrayez 1 du compteur.
Diagramme de câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code Arduino UNO R4 – Codeur rotatif sans interruption
Ce code Arduino UNO R4 effectue les actions suivantes :
- Il détecte comment et dans quelle mesure l'encodeur tourne.
- S'il détecte que le bouton tourne d'un clic vers la droite, il incrémente le compteur d'un.
- S'il détecte que le bouton tourne d'un clic vers la gauche, il réduit le compteur d'un.
- Il remarque si le bouton est pressé.
/*
* Ce code Arduino UNO R4 a été développé par newbiely.fr
* Ce code Arduino UNO R4 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-uno-r4/arduino-uno-r4-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2 // The Arduino UNO R4 pin connected to the CLK pin of encoder
#define DT_PIN 3 // The Arduino UNO R4 pin connected to the DT pin of encoder
#define SW_PIN 4 // The Arduino UNO R4 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 simplifier le code d’anti-rebond du bouton.
Étapes rapides
Suivez ces instructions étape par étape :
- Si c'est la première fois que vous utilisez l'Arduino Uno R4 WiFi/Minima, consultez le tutoriel sur Arduino UNO R4 - Installation du logiciel..
- Connectez l'encodeur rotatif à l'Arduino UNO R4 selon le schéma fourni.
- Connectez la carte Arduino Uno R4 à votre ordinateur à l'aide d'un câble USB.
- Lancez l'IDE Arduino sur votre ordinateur.
- Sélectionnez la carte Arduino Uno R4 appropriée (par exemple, Arduino Uno R4 WiFi) et le port COM.
- Ajoutez la bibliothèque ezButton à l'IDE Arduino. Pour les instructions, consultez ce lien : [bibliothèque ezButton](https://arduinogetstarted.com/tutorials/arduino-button-library#content_how_to_install
- Copiez le code fourni et ouvrez-le dans l'IDE Arduino.
- Cliquez sur le bouton Upload dans l'IDE Arduino pour charger le code sur l'Arduino UNO R4.
- Tournez le bouton dans le sens des aiguilles d'une montre puis dans le sens inverse des aiguilles d'une montre.
- Appuyez sur le bouton.
- Vérifiez les résultats sur 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
Regardez les commentaires dans le code pour chaque ligne.
Code Arduino UNO R4 – Codeur rotatif avec interruption
Dans l'exemple de code précédent, nous avons utilisé la méthode de sondage, qui vérifie en permanence l'état de la broche. Cette méthode présente deux inconvénients :
- Utiliser les ressources de l'Arduino UNO R4 de manière inefficace
- Certains compteurs peuvent être ignorés si un autre code prend trop de temps à s'exécuter.
Une méthode pour contrôler cela est d'utiliser des interruptions. Les interruptions permettent d'éviter le besoin constant de vérifier un événement spécifique. Cela permet à l'Arduino UNO R4 d'effectuer d'autres tâches tout en surveillant des événements.
Voyons le code ci-dessous qui utilise une interruption pour lire la valeur de l'encodeur.
/*
* Ce code Arduino UNO R4 a été développé par newbiely.fr
* Ce code Arduino UNO R4 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-uno-r4/arduino-uno-r4-rotary-encoder
*/
#include <ezButton.h> // the library to use for SW pin
#define CLK_PIN 2 // The Arduino UNO R4 pin connected to the CLK pin of encoder
#define DT_PIN 3 // The Arduino UNO R4 pin connected to the DT pin of encoder
#define SW_PIN 4 // The Arduino UNO R4 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 fourni et ouvrez-le dans l'IDE Arduino.
- Cliquez sur le bouton Upload dans l'IDE Arduino pour charger le code sur l'Arduino UNO R4.
Maintenant, lorsque vous tournez le potentiomètre, vous verrez des informations s'afficher dans le Moniteur Série, similaires à ce que vous aviez remarqué auparavant dans le code précédent.
※ Note:
- Pour connecter la broche CLK de l'encodeur à un Arduino UNO R4 en utilisant une interruption, vous devez utiliser les broches 2 ou 3. Ce sont les seules broches qui prennent en charge les interruptions.
- Certains guides en ligne pourraient suggérer d'utiliser deux interruptions pour un seul encodeur, mais ce n'est pas nécessaire. Utiliser une seule interruption suffit.
- Assurez-vous d'utiliser le mot-clé volatile pour toute variable globale dans l'interruption afin d'éviter les problèmes.
- Gardez la programmation à l'intérieur de l'interruption simple. N'utilisez pas Serial.print() ou Serial.println() là-bas.