ESP32 C3 Super Mini - Encodeur Rotatif
Apprenez à utiliser un encodeur rotatif avec votre ESP32 C3 Super Mini pour détecter la direction de rotation et la position. Ce tutoriel convivial pour les débutants couvre tout, du câblage au codage avec des techniques basées sur les interruptions.
Dans ce guide, vous apprendrez :
- Ce que sont les encodeurs rotatifs et comment ils diffèrent des potentiomètres
- Comment fonctionnent les encodeurs et détectent la rotation
- Comment câbler un encodeur rotatif à l'ESP32 C3 Super Mini
- Comment programmer l'ESP32 C3 Super Mini pour lire la direction et la position de l'encodeur
- Comment utiliser les interruptions pour une lecture plus efficace de l'encodeur
- Les applications réelles pour les projets d'encodeur rotatif
Matériel Requis
| 1 | × | ESP32 C3 Super Mini | |
| 1 | × | Câble USB Type-C | |
| 1 | × | Encodeur Rotatif | |
| 1 | × | Plaque d'essai | |
| 1 | × | Fils Jumper |
Ou vous pouvez acheter les kits suivants:
| 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 capteur de position qui convertit le mouvement rotatif en signaux électriques pour déterminer la direction et la quantité de rotation.
Types clés d'encodeurs rotatifs :
- Encodeur incrémental : Utilise des signaux d'impulsion pour mesurer les changements de position relative - parfait pour suivre la rotation
- Encodeur absolu : Fournit des codes de position uniques qui conservent les données de position même lors de la perte d'alimentation
Pourquoi les encodeurs rotatifs sont géniaux pour les débutants :
- Facile à utiliser avec seulement quelques broches
- Fournissent à la fois la détection de direction de rotation et la détection d'appui sur bouton
- Peut tourner en continu sans limites mécaniques
- Fonctionnent bien avec les interruptions pour les projets efficaces ESP32 C3 Super Mini
Ce tutoriel se concentre sur les encodeurs rotatifs incrémentaux, le type le plus courant pour les projets Arduino et ESP32.
Brochage du Module d'Encodeur Rotatif
Le module d'encodeur rotatif a 5 broches que vous connecterez à votre ESP32 C3 Super Mini :
- Broche CLK (Sortie A) : Sortie d'impulsion principale qui signale la rotation - produit un cycle complet (BAS → HAUT → BAS) par clic de cran
- Broche DT (Sortie B) : Sortie d'impulsion secondaire qui retarde CLK de 90 degrés pour déterminer la direction de rotation (sens horaire ou antihoraire)
- Broche SW : Connexion du bouton poussoir - normalement ouvert, lit HAUT quand pas appuyé et BAS quand appuyé (nécessite résistor de pull-up)
- Broche VCC (+) : Connexion d'alimentation - connectez à 3.3V ou 5V
- Broche GND : Connexion de terre - connectez à GND (0V)
Encodeur Rotatif vs Potentiomètre
Vous pourriez confondre l'encodeur rotatif avec un potentiomètre, mais ils servent des objectifs différents.
Différences clés :
- Plage de rotation : Les encodeurs rotatifs tournent en continu 360° tandis que les potentiomètres ont une rotation limitée (généralement 270°)
- Type de sortie : Les encodeurs fournissent des impulsions numériques tandis que les potentiomètres fournissent une tension analogique
- Suivi de position : Les encodeurs suivent le mouvement relatif (combien cela a tourné) tandis que les potentiomètres suivent la position absolue
- Meilleure utilisation : Les encodeurs excellent dans le suivi de la quantité de rotation et de la direction ; les potentiomètres sont mieux quand vous avez besoin de valeurs de position exactes
- Design moderne : Les encodeurs rotatifs sont l'évolution numérique des potentiomètres avec des capacités améliorées
Comment fonctionne l'Encodeur Rotatif
Mécanisme interne :
- Un disque fendu à l'intérieur se connecte à la broche C (terre commune)
- Les broches A et B prennent contact avec la terre commune à mesure que le bouton tourne
- L'ordre de contact entre A et B détermine la direction de rotation
- Cela crée deux signaux d'impulsion qui sont déphasés de 90 degrés (codage de quadrature)
Détection de la direction de rotation :
- Rotation dans le sens horaire : La broche A prend contact avec la terre avant la broche B
- Rotation dans le sens antihoraire : La broche B prend contact avec la terre avant la broche A
- En surveillant l'état de la broche B quand la broche A change, l'ESP32 C3 Super Mini détermine la direction de rotation
Logique de détection de direction :
Quand la broche A change de BAS à HAUT :
- Si la broche B est HAUT : Le bouton a tourné antihoraire
- Si la broche B est BAS : Le bouton a tourné dans le sens horaire
※ Note:
Les broches A et B se connectent aux broches CLK et DT. Selon le fabricant, l'ordre peut varier. Le code ci-dessous est testé avec les encodeurs rotatifs DIYables.
Comment Programmer pour l'Encodeur Rotatif
Processus basique de lecture d'encodeur ESP32 C3 Super Mini :
- L'ESP32 lit le signal de la broche CLK en continu
- Quand l'état de CLK change de BAS à HAUT, l'ESP32 lit immédiatement l'état de la broche DT
- Si la broche DT est HAUT : Rotation antihoraire détectée → augmentez le compteur de 1
- Si la broche DT est BAS : Rotation horaire détectée → diminuez le compteur de 1
- Cette méthode suit à la fois la direction et la quantité totale de rotation
Schéma de Câblage
Ce diagramme montre comment connecter l'encodeur rotatif à votre carte ESP32 C3 Super Mini.
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Tableau de Connexion :
| Broche Encodeur Rotatif | Broche ESP32 C3 Super Mini |
|---|---|
| CLK | D7 |
| DT | D6 |
| SW | D5 |
| VCC | 3.3V |
| GND | GND |
Code ESP32 C3 Super Mini – Encodeur Rotatif
Ce code ESP32 C3 Super Mini démontre la fonctionnalité basique de l'encodeur rotatif :
Ce que fait ce code :
- Détecte la direction de rotation (sens horaire ou antihoraire)
- Compte les clics de rotation en suivant les crans
- Augmente le compteur quand tourné dans le sens horaire
- Diminue le compteur quand tourné antihoraire
- Détecte les appuis sur le bouton du bouton de l'encodeur
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini 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/esp32-c3/esp32-c3-super-mini-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN 7 // The ESP32 C3 SuperMini pin 7 connected to the rotary encoder's CLK pin
#define DT_PIN 6 // The ESP32 C3 SuperMini pin 6 connected to the rotary encoder's DT pin
#define SW_PIN 5 // The ESP32 C3 SuperMini pin 5 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(115200);
// 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");
}
}
Remarque : Ce code utilise la bibliothèque ezButton pour simplifier le dépannage des boutons pour une détection fiable des appuis.
Étapes Rapides
- Nouveau sur ESP32 C3 Mini ? Complétez d'abord notre tutoriel ESP32 C3 Super Mini - Premiers pas pour configurer votre environnement de développement.
- Installez la Bibliothèque : Ajoutez la bibliothèque ezButton via le Gestionnaire de Bibliothèques Arduino IDE
- Ouvrez le Code : Copiez le code ci-dessus et collez-le dans Arduino IDE
- Téléchargez : Cliquez sur le bouton Upload pour transférer le code à votre ESP32 C3 Super Mini
- Testez la Rotation : Tournez le bouton de l'encodeur dans le sens horaire plusieurs clics, puis antihoraire
- Testez le Bouton : Appuyez sur le bouton de l'encodeur
- Voyez les Résultats : Ouvrez le Moniteur Série (115200 bauds) pour voir la direction de rotation et le comptage
- Pro Tip : Chaque "clic" que vous ressentez quand vous tournez s'appelle un cran - l'encodeur produit une impulsion complète par cran
Sortie du Moniteur Série :
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
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
The button is pressed
Explication du Code
Examinez les commentaires détaillés ligne par ligne dans le code ci-dessus pour comprendre le fonctionnement de chaque section.
Code ESP32 C3 Super Mini – Encodeur Rotatif avec Interruption
La méthode de scrutation dans le code précédent vérifie continuellement les états des broches, ce qui gaspille la puissance de traitement de l'ESP32 C3 Super Mini et peut manquer les comptages de rotation lors de l'exécution lente du code.
Pourquoi utiliser les interruptions pour les encodeurs rotatifs :
- Élimine le scrutation continu - libère les ressources de l'ESP32
- Ne manque jamais les impulsions de l'encodeur même pendant les autres tâches
- Plus efficace et fiable pour les projets du monde réel
- Permet à l'ESP32 C3 Super Mini de multitâche efficacement
Le code ci-dessous utilise les interruptions matérielles pour lire la direction et la position de l'encodeur rotatif efficacement :
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini 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/esp32-c3/esp32-c3-super-mini-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN 7 // The ESP32 C3 SuperMini pin 7 connected to the rotary encoder's CLK pin
#define DT_PIN 6 // The ESP32 C3 SuperMini pin 6 connected to the rotary encoder's DT pin
#define SW_PIN 5 // The ESP32 C3 SuperMini pin 5 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(115200);
// 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
}
Quand vous tournez le bouton, le Moniteur Série affiche les mêmes informations de rotation que l'exemple précédent, mais avec des performances améliorées.
※ Note:
- Une interruption suffit : Beaucoup de tutoriels utilisent deux interruptions pour un encodeur, mais cela gaspille les ressources - une seule interruption fonctionne parfaitement
- Utilisez le mot-clé volatile : Déclarez toujours les variables globales utilisées dans les interruptions comme volatile pour prévenir le comportement inattendu
- Gardez les interruptions simples : Minimisez le code à l'intérieur des fonctions d'interruption - évitez d'utiliser Serial.print() ou Serial.println() dans les interruptions
- Exécution rapide : Le code d'interruption doit s'exécuter aussi rapidement que possible pour les meilleures performances
Application d'Encodeur Rotatif ESP32 C3 Super Mini
Les encodeurs rotatifs ouvrent de nombreuses possibilités de projets passionnants pour votre ESP32 C3 Super Mini.
Idées de projet d'encodeur rotatif populaires :
- Contrôlez la position du servomoteur avec précision grâce à la rotation de l'encodeur
- Ajustez la luminosité des LED en douceur en tournant le bouton de l'encodeur
- Réglez la vitesse du moteur pas à pas pour les projets de robotique
- Créez un contrôle de volume numérique pour les systèmes audio