Arduino Nano ESP32 - Encodeur rotatif
Dans ce guide, vous apprendrez à utiliser l'encodeur rotatif avec un Arduino Nano ESP32. Voici ce que nous allons apprendre :
- Quelles sont les différences entre un encodeur rotatif et un potentiomètre
- Comment fonctionne l'encodeur rotatif
- Comment connecter l'encodeur rotatif à l'Arduino Nano ESP32
- Comment écrire du code pour l'Arduino Nano ESP32 pour lire la direction et la position de l'encodeur rotatif SANS interruption.
- Comment écrire du code pour l'Arduino Nano ESP32 pour lire la direction et la position de l'encodeur rotatif AVEC interruption.
Préparation du matériel
| 1 | × | Arduino Nano ESP32 | |
| 1 | × | USB Cable Type-C | |
| 1 | × | Rotary Encoder | |
| 1 | × | Breadboard | |
| 1 | × | Jumper Wires | |
| 1 | × | (Recommended) Screw Terminal Adapter for Arduino Nano |
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 bouton rotatif, comme sur une radio, peut envoyer des signaux qui se transforment en électricité. Il nous aide à savoir combien il a tourné et où il est placé. Il existe deux types principaux :
- Encodeur incrémental : Celui-ci utilise des signaux rapides pour mesurer combien quelque chose a changé de position.
- Encodeur absolu : Ce type fournit un code secret pour chaque position, ce qui nous aide à déterminer où se trouve quelque chose, même si le courant est coupé.
Cette leçon concerne principalement le premier type, l'encodeur incrémental.
Brochage du module d'encodeur rotatif
Un module d'encodeur rotatif possède 4 broches :
- Broche CLK (Sortie A) : est l'impulsion principale qui indique l'ampleur de la rotation. Chaque fois que vous tournez le bouton d'un cran (clic) dans l'une ou l'autre direction, la broche CLK émet un signal qui complète un cycle complet (BAS → HAUT → BAS).
- 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 : provient du bouton de l'encodeur. Elle est normalement ouverte. Lorsque nous ajoutons une résistance de tirage à cette broche, la broche SW sera HAUTE lorsque le bouton n'est pas poussé et BASSE lorsqu'il est poussé.
- 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 pourriez 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 en rond sans s'arrêter, alors que le potentiomètre ne peut tourner qu'environ les trois quarts du 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 de 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
À l'intérieur de l'encodeur, il y a un petit disque avec des fentes qui est connecté à une broche appelée C, qui agit comme une masse commune. Vous avez deux autres broches, A et B.
- Lorsque vous tournez le bouton, les broches A et B touchent cette broche de masse partagée C, mais l'ordre dans lequel elles la touchent dépend du sens dans lequel vous tournez le bouton (soit dans le sens des aiguilles d'une montre ou dans le sens inverse).
- Ces contacts créent deux signaux. Ils sont un peu différents en termes de timing car une broche touche la masse avant l'autre. Ces signaux sont déphasés de 90 degrés, ce qui est appelé codage par quadrature.
- Si vous tournez le bouton dans le sens des aiguilles d'une montre, la broche A touche la masse avant la broche B. Mais si vous tournez dans le sens inverse, c'est la broche B qui touche la masse en premier avant la broche A.
- En vérifiant quand chaque broche touche ou quitte la masse, nous pouvons déterminer dans quel sens le bouton tourne. Nous faisons cela en vérifiant ce qui arrive à la broche B lorsque la broche A change.
Lorsque A change d'état de BAS à HAUT :
- Si B est ÉLEVÉ, le bouton est tourné dans le sens antihoraire.
- Si B est BAS, le bouton est tourné dans le sens horaire.
※ 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
- Arduino Nano ESP32 lit le signal de la broche CLK
- Si l'état passe de LOW à HIGH, alors l'Arduino Nano ESP32 lit l'état de la broche DT.
- Si la broche DT est HIGH, le bouton est tourné dans le sens antihoraire, l'Arduino Nano ESP32 augmente le compteur de 1
- Si la broche DT est LOW, le bouton est tourné dans le sens horaire, l'Arduino Nano ESP32 diminue le compteur de 1
Diagramme de câblage
This image is created using Fritzing. Click to enlarge image
Code Arduino Nano ESP32 – Encodeur rotatif
Le code Arduino Nano ESP32 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 antihoraire, diminuer le compteur de un.
- Détecte si le bouton est pressé.
/*
* Ce code Arduino Nano ESP32 a été développé par newbiely.fr
* Ce code Arduino Nano ESP32 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-nano-esp32/arduino-nano-esp32-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D2 // The Arduino Nano ESP32 pin D2 connected to the rotary encoder's CLK pin
#define DT_PIN D3 // The Arduino Nano ESP32 pin D3 connected to the rotary encoder's DT pin
#define SW_PIN D4 // The Arduino Nano ESP32 pin D4 connected to the rotary encoder's SW pin
#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 for pin 7;
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("Rotary Encoder:: direction: ");
if (direction == DIRECTION_CW)
Serial.print("Clockwise");
else
Serial.print("Counter-clockwise");
Serial.print(" - count: ");
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 de l'anti-rebond des boutons, la bibliothèque ezButton est utilisée.
Étapes rapides
Si c'est la première fois que vous utilisez Arduino Nano ESP32, consultez comment configurer l'environnement pour Arduino Nano ESP32 sur Arduino IDE.
- Installez la bibliothèque ezButton sur Arduino IDE.
- 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 Nano ESP32
- Tournez le bouton dans le sens horaire, puis dans le sens antihoraire
- Appuyez sur le bouton
- Consultez le résultat sur le moniteur série.
COM6
Rotary Encoder:: direction: CLOCKWISE - count: 1
Rotary Encoder:: direction: CLOCKWISE - count: 2
Rotary Encoder:: direction: CLOCKWISE - count: 3
Rotary Encoder:: direction: CLOCKWISE - count: 4
Rotary Encoder:: direction: CLOCKWISE - count: 5
Rotary Encoder:: direction: ANTICLOCKWISE - count: 4
Rotary Encoder:: direction: ANTICLOCKWISE - count: 3
Rotary Encoder:: direction: ANTICLOCKWISE - count: 2
Rotary Encoder:: direction: ANTICLOCKWISE - count: 1
Rotary Encoder:: direction: ANTICLOCKWISE - count: 0
The button is pressed
Autoscroll
Clear output
9600 baud
Newline
Explication du code
Consultez les commentaires ligne par ligne dans le code.
Code Arduino Nano ESP32 - Encodeur rotatif avec interruption
Dans le code précédent, l'utilisation du polling pour vérifier en continu l'état de la broche peut gaspiller les ressources de l'Arduino Nano ESP32 et entraîner des comptages manqués si l'exécution d'autres codes est lente.
Une solution efficace consiste à utiliser l'interruption, qui élimine la nécessité du polling. Cela permet à l'Arduino Nano ESP32 de réaliser d'autres tâches sans manquer les comptages. Voici le code de l'Arduino Nano ESP32 qui utilise l'interruption pour lire la direction et la position à partir de l'encodeur rotatif.
/*
* Ce code Arduino Nano ESP32 a été développé par newbiely.fr
* Ce code Arduino Nano ESP32 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-nano-esp32/arduino-nano-esp32-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D2 // The Arduino Nano ESP32 pin D2 connected to the rotary encoder's CLK pin
#define DT_PIN D3 // The Arduino Nano ESP32 pin D3 connected to the rotary encoder's DT pin
#define SW_PIN D4 // The Arduino Nano ESP32 pin D4 connected to the rotary encoder's SW pin
#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 for pin 7;
void IRAM_ATTR ISR_encoder() {
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();
}
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_encoder() when CLK pin changes from LOW to HIGH
attachInterrupt(digitalPinToInterrupt(CLK_PIN), ISR_encoder, RISING);
}
void loop() {
button.loop(); // MUST call the loop() function first
if (prev_counter != counter) {
Serial.print("Rotary Encoder:: direction: ");
if (direction == DIRECTION_CW)
Serial.print("CLOCKWISE");
else
Serial.print("ANTICLOCKWISE");
Serial.print(" - count: ");
Serial.println(counter);
prev_counter = counter;
}
if (button.isPressed()) {
Serial.println("The button is pressed");
}
// TO DO: your other work here
}
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:
- Vous pouvez trouver des tutoriels sur d'autres sites qui utilisent deux interruptions pour un seul encodeur, mais cela est inutile et gaspilleur. Une seule interruption suffit.
- 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 codeur rotatif Arduino Nano ESP32
Avec l'encodeur rotatif, nous pouvons réaliser les applications suivantes, sans nous limiter à :
- Arduino Nano ESP32 - L'encodeur rotatif contrôle la position du moteur servo
- Arduino Nano ESP32 - L'encodeur rotatif contrôle la luminosité de la LED
- Arduino Nano ESP32 - L'encodeur rotatif contrôle la vitesse du moteur pas à pas