ESP8266 - Encodeur rotatif
Ce tutoriel vous explique comment utiliser l'encodeur rotatif incrémental avec l'ESP8266. Voici ce que nous allons aborder :
- Comment fonctionne l'encodeur rotatif
- La différence entre un encodeur rotatif et un potentiomètre (un autre type de bouton)
- Comment connecter physiquement l'encodeur rotatif à un ESP8266
- Comment écrire du code pour l'ESP8266 afin de lire la direction et la position à partir de l'encodeur rotatif.
Préparation du matériel
| 1 | × | ESP8266 NodeMCU | |
| 1 | × | Micro USB Cable | |
| 1 | × | Rotary Encoder | |
| 1 | × | Jumper Wires | |
| 1 | × | (Optional) ESP8266 Screw Terminal Adapter |
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 type de bouton qui peut transformer une rotation en signal électrique. Il indique à quel point quelque chose a été tordu et où il est positionné. Il existe deux types principaux :
- Encodeur incrémental : Celui-ci utilise des signaux rapides pour mesurer combien quelque chose s'est déplacé.
- Encodeur absolu : Ce type fournit un code spécial pour chaque position, ce qui aide à savoir exactement où se trouve quelque chose, même si le courant s'arrête.
Ce tutoriel est axé sur l'encodeur incrémental.
Brochage du module d'encodeur rotatif
Un module d'encodeur rotatif dispose 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 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 : 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 HAUTE quand le bouton n'est pas pressé, et BASSE quand 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 en rond sans s'arrêter, tandis que le potentiomètre peut seulement tourner sur environ trois quarts de cercle.
- L'encodeur rotatif génère des impulsions, tandis que le potentiomètre délivre 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 précisément où se trouve un bouton.
Fonctionnement d'un 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 dépendant du sens dans lequel vous tournez le bouton (dans le sens des aiguilles d'une montre ou dans le sens inverse).
- Ces contacts créent deux signaux. Ils sont légèrement différents en 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 s'appelle le codage en quadrature.
- Lorsque vous tournez le bouton dans le sens des aiguilles d'une montre, 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 le bouton tourne. Nous faisons cela en vérifiant ce qui arrive à la broche B lorsque la broche A change.
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 HAUT, 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. Toutefois, 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
This image is created using Fritzing. Click to enlarge image
Voir plus dans l'agencement des broches de l'ESP8266 et comment alimenter l'ESP8266 et d'autres composants.
Code ESP8266 - Encodeur rotatif
Le code ESP8266 ci-dessous fait :
- Détecte la direction et la quantité de 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é.
Pour simplifier le code de l'anti-rebond des boutons, la bibliothèque ezButton est utilisée.
/*
* Ce code ESP8266 NodeMCU a été développé par newbiely.fr
* Ce code ESP8266 NodeMCU 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/esp8266/esp8266-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D7 // The ESP8266 pin D7 connected to the rotary encoder's CLK pin
#define DT_PIN D6 // The ESP8266 pin D6 connected to the rotary encoder's DT pin
#define SW_PIN D5 // The ESP8266 pin D5 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("ANTICLOCKWISE");
Serial.print(" - count: ");
Serial.println(counter);
}
// save last CLK state
prev_CLK_state = CLK_state;
if (button.isPressed()) {
Serial.println("The button is pressed");
}
}
Étapes rapides
Pour commencer avec l'ESP8266 sur l'IDE Arduino, suivez ces étapes :
- Consultez le tutoriel comment configurer l'environnement pour ESP8266 sur Arduino IDE si c'est votre première utilisation de ESP8266.
- Câblez les composants comme indiqué dans le schéma.
- Connectez la carte ESP8266 à votre ordinateur à l'aide d'un câble USB.
- Ouvrez Arduino IDE sur votre ordinateur.
- Choisissez la bonne carte ESP8266, comme (par exemple NodeMCU 1.0 (Module ESP-12E)), et son port COM respectif.
- 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 ESP8266
- Tournez le bouton dans le sens horaire, puis dans le sens antihoraire
- Appuyez sur le bouton
- Vérifiez 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 ESP8266 - Encodeur rotatif avec interruption
Dans le code précédent, vérifier à plusieurs reprises le statut du pin par sondage peut gaspiller des ressources et pourrait ne pas compter correctement si d'autres tâches prennent beaucoup de temps. Les interruptions offrent une solution en évitant le contrôle continu, permettant à l'ESP8266 de gérer différentes tâches sans manquer aucun événement.
Voici un exemple avec l'ESP8266 de comment lire un encodeur rotatif avec des interruptions.
/*
* Ce code ESP8266 NodeMCU a été développé par newbiely.fr
* Ce code ESP8266 NodeMCU 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/esp8266/esp8266-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN D7 // The ESP8266 pin D7 connected to the rotary encoder's CLK pin
#define DT_PIN D6 // The ESP8266 pin D6 connected to the rotary encoder's DT pin
#define SW_PIN D5 // The ESP8266 pin D5 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 ICACHE_RAM_ATTR INTERRUPT_handler() {
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 INTERRUPT_handler() when CLK pin changes from LOW to HIGH
attachInterrupt(digitalPinToInterrupt(CLK_PIN), INTERRUPT_handler, 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 pourriez trouver des tutoriels sur d'autres sites web 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 dans 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 ESP8266
Avec un encodeur rotatif, nous pouvons réaliser les applications suivantes, sans nous y limiter :
- ESP8266 - Encodeur rotatif contrôle la position du moteur Servo
- ESP8266 - Encodeur rotatif contrôle la luminosité de la LED
- ESP8266 - Encodeur rotatif contrôle la vitesse du moteur pas à pas