CAPTEURS/ACTIONNEURS

ESP32 S3 - Encodeur rotatif

Apprenez à utiliser un encodeur rotatif avec votre ESP32 S3 pour détecter la direction de rotation et la position. Ce tutoriel vous accompagne à travers le câblage, un code de base par scrutation (polling), et une approche plus efficace basée sur les interruptions — vous donnant tout ce dont vous avez besoin pour intégrer un encodeur rotatif dans vos projets ESP32 S3.

Ce que vous allez construire :

Un circuit connectant un encodeur rotatif à l'ESP32 S3
Un croquis qui détecte la rotation horaire et anti-horaire
Une version pilotée par interruption pour de meilleures performances et fiabilité
Une base pour des applications réelles comme les menus, le contrôle de moteur, et le réglage de volume

Matériel nécessaire

1	×	ESP32 S3 WROOM N16R8
1	×	Alternativement: ESP32 S3 SuperMini Dev Module
1	×	Alternativement: ESP32 S3 Uno-form Board
1	×	Alternativement: ESP32 S3 Camera Board
1	×	Câble USB Type-A vers Type-C (pour PC USB-A)
1	×	Câble USB Type-C vers Type-C (pour PC USB-C)
1	×	Encodeur rotatif
1	×	Plaque d'essai
1	×	Fils de connexion
1	×	Recommandé: Screw Terminal Expansion Board for ESP32 S3
1	×	Recommandé: Breakout Expansion Board for ESP32 S3
1	×	Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

1	×	Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 inclus)
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 un mouvement de rotation en signaux électriques, permettant à un microcontrôleur comme l'ESP32 S3 de déterminer à la fois la direction et la quantité de rotation. Contrairement à un potentiomètre, un encodeur rotatif peut tourner en continu sans atteindre de butée mécanique, ce qui le rend idéal pour les menus de navigation, le contrôle de vitesse de moteur, et d'autres applications où une rotation illimitée est nécessaire.

Ce tutoriel se concentre sur les encodeurs rotatifs incrémentaux — le type le plus courant et le plus adapté aux débutants pour les projets ESP32 S3.

Spécifications clés

Les encodeurs incrémentaux génèrent deux signaux d'impulsion numériques (A et B) déphasés de 90 degrés. En comparant lequel des deux signaux change en premier, l'ESP32 S3 peut déterminer si le bouton a été tourné dans le sens horaire ou anti-horaire. La plupart des modules incluent aussi un interrupteur bouton-poussoir intégré, activé en appuyant sur le bouton. L'encodeur peut tourner en continu dans les deux directions sans butée de fin de course, et le module embarqué accepte typiquement une tension d'alimentation de 3,3V à 5V.

Brochage du module encodeur rotatif

Le module encodeur rotatif expose cinq broches qui se connectent à votre ESP32 S3 :

Broche CLK (Sortie A) : sortie d'impulsion principale qui signale la rotation — produit un cycle complet LOW-vers-HIGH-vers-LOW par clic de cran
Broche DT (Sortie B) : sortie d'impulsion secondaire qui est en retard de 90 degrés par rapport à CLK, utilisée pour déterminer la direction de rotation
Broche SW : connexion du bouton-poussoir — normalement ouverte, lit HIGH au repos et LOW quand le bouton est appuyé (nécessite une résistance de pull-up)
Broche VCC (+) : alimentation — connectez au 3,3V sur l'ESP32 S3
Broche GND : référence de masse — connectez à GND

Encodeur rotatif contre potentiomètre

Vous pourriez être tenté de confondre un encodeur rotatif avec un ESP32 S3 - Potentiomètre, mais ils servent des objectifs fondamentalement différents. Un potentiomètre produit une tension analogique proportionnelle à une plage de rotation fixe (typiquement 270°), ce qui le rend le mieux adapté pour lire une position absolue. Un encodeur rotatif produit des impulsions numériques sur une rotation illimitée, ce qui le rend idéal pour suivre un mouvement relatif — combien et dans quelle direction le bouton a tourné.

Différences clés

Les encodeurs rotatifs tournent en continu sur 360° tandis que les potentiomètres ont une limite mécanique fixe. Les encodeurs produisent des impulsions numériques ; les potentiomètres produisent une tension analogique. Les encodeurs suivent un mouvement relatif ; les potentiomètres suivent une position absolue. Pour les projets sur ESP32 S3 nécessitant une navigation de menu, un ajustement de vitesse de moteur, ou tout bouton qui continue de tourner, un encodeur rotatif est le bon choix.

Comment fonctionne l'encodeur rotatif

À l'intérieur de l'encodeur, un disque fendu se connecte à une masse commune (broche C). Pendant que le bouton tourne, les broches A et B entrent alternativement en contact avec la masse commune, générant deux trains d'impulsions déphasés de 90 degrés — une technique appelée encodage en quadrature.

Mécanisme interne :

Un disque fendu à l'intérieur se connecte à la broche C (masse commune)
Les broches A et B entrent en contact avec la masse commune pendant que le bouton tourne
L'ordre de contact entre A et B détermine la direction de rotation
Deux signaux d'impulsion déphasés de 90 degrés sont produits (encodage en quadrature)

Détecter la direction de rotation :

Rotation horaire : la broche A entre en contact avec la masse avant la broche B
Rotation anti-horaire : la broche B entre en contact avec la masse avant la broche A
L'ESP32 S3 lit l'état de la broche B au moment où la broche A transitionne, et l'utilise pour déterminer la direction

Logique de détection de direction :

Quand la broche A passe de LOW à HIGH :

Si la broche B est HIGH : le bouton a été tourné dans le sens anti-horaire
Si la broche B est LOW : le bouton a été 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

L'ESP32 S3 lit l'encodeur rotatif en surveillant la broche CLK pour des changements d'état. Quand CLK passe de LOW à HIGH, le croquis échantillonne immédiatement la broche DT :

L'ESP32 S3 surveille en continu la broche CLK
Quand CLK passe de LOW à HIGH, la broche DT est lue immédiatement
Si DT est HIGH : rotation anti-horaire → incrémentez le compteur de 1
Si DT est LOW : rotation horaire → décrémentez le compteur de 1
Cette méthode suit de façon fiable à la fois la direction et la quantité de rotation cumulée

Schéma de câblage

Connectez l'encodeur rotatif à votre ESP32 S3 comme indiqué dans le schéma ci-dessous. Utilisez des fils de câblage courts pour garder les lignes de signal propres et éviter le bruit qui pourrait causer de faux comptages.

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Notes de sécurité

Connectez toujours VCC à la broche 3,3V de l'ESP32 S3 plutôt qu'au 5V pour rester dans la tolérance de tension GPIO de la carte. La broche SW nécessite une résistance de pull-up — la plupart des modules d'encodeur rotatif en incluent une embarquée, mais vérifiez cela sur votre module avant de vous passer d'une résistance externe.

Broche de l'encodeur rotatif	Broche ESP32 S3
CLK	GPIO19
DT	GPIO20
SW	GPIO21
VCC	3,3V
GND	GND

Code ESP32 S3 – Encodeur rotatif

Le croquis suivant démontre la lecture de base d'un encodeur rotatif sur l'ESP32 S3 en utilisant une approche par scrutation (polling). Il détecte la direction de rotation, maintient un compteur courant de clics de cran, et rapporte les appuis sur le bouton — le tout affiché sur le Serial Monitor. La bibliothèque ezButton gère automatiquement l'anti-rebond de l'interrupteur, rendant la détection de bouton fiable sans code répétitif supplémentaire.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 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-s3/esp32-s3-rotary-encoder */ #include <ezButton.h> // The library to use for SW pin #define CLK_PIN 19 // The ESP32 S3 pin 19 connected to the rotary encoder's CLK pin #define DT_PIN 20 // The ESP32 S3 pin 20 connected to the rotary encoder's DT pin #define SW_PIN 21 // The ESP32 S3 pin 21 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 21; 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"); } }

Note : ce code utilise la bibliothèque ezButton pour simplifier l'anti-rebond du bouton pour une détection fiable des appuis.

Étapes rapides

Nouveau sur ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
Installez la bibliothèque : ajoutez la bibliothèque ezButton via le Library Manager d'Arduino IDE
Ouvrez le code : copiez le code ci-dessus et collez-le dans Arduino IDE
Téléversez : cliquez sur le bouton Upload pour transférer le croquis vers votre ESP32 S3
Testez la rotation : tournez le bouton de l'encodeur dans le sens horaire plusieurs clics, puis dans le sens anti-horaire
Testez le bouton : appuyez sur le bouton de l'encodeur
Consultez les résultats : ouvrez le Serial Monitor (115200 bauds) pour voir la direction de rotation et le compteur
Astuce pro : chaque "clic" tactile que vous ressentez en tournant le bouton s'appelle un cran (detent) — l'encodeur produit exactement un cycle d'impulsion complet par cran, donc votre nombre de clics et la valeur du compteur correspondront toujours

Sortie du Serial Monitor :

Newbiely | Arduino IDE 2.3.8

──

☐

Newbiely.ino

···

8 Serial.println("Hello World!");

Output

Serial Monitor

Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')

New Line

9600 baud

[2026-06-16 10:23:01] Rotary Encoder:: direction: CLOCKWISE - count: 1 [2026-06-16 10:23:01] Rotary Encoder:: direction: CLOCKWISE - count: 2 [2026-06-16 10:23:02] Rotary Encoder:: direction: CLOCKWISE - count: 3 [2026-06-16 10:23:02] Rotary Encoder:: direction: CLOCKWISE - count: 4 [2026-06-16 10:23:03] Rotary Encoder:: direction: CLOCKWISE - count: 5 [2026-06-16 10:23:04] Rotary Encoder:: direction: ANTICLOCKWISE - count: 4 [2026-06-16 10:23:04] Rotary Encoder:: direction: ANTICLOCKWISE - count: 3 [2026-06-16 10:23:05] Rotary Encoder:: direction: ANTICLOCKWISE - count: 2 [2026-06-16 10:23:05] Rotary Encoder:: direction: ANTICLOCKWISE - count: 1 [2026-06-16 10:23:06] Rotary Encoder:: direction: ANTICLOCKWISE - count: 0 [2026-06-16 10:23:08] The button is pressed [2026-06-16 10:23:09] The button is pressed

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Explication du code

Consultez les commentaires détaillés ligne par ligne dans le code ci-dessus pour comprendre comment fonctionne chaque section.

Code ESP32 S3 – Encodeur rotatif avec interruption

L'approche par scrutation du croquis précédent fonctionne bien pour des projets simples, mais elle consomme des cycles de traitement de l'ESP32 S3 même quand le bouton ne bouge pas — et peut manquer des impulsions si un autre code s'exécute trop lentement. Les interruptions résolvent les deux problèmes en laissant le matériel notifier l'ESP32 S3 à l'instant même où une transition CLK se produit, libérant la boucle principale pour d'autres tâches.

Le croquis suivant utilise une interruption matérielle sur la broche CLK pour lire l'encodeur rotatif efficacement. La logique de direction est identique à la version par scrutation, mais l'état de l'encodeur est capturé à l'intérieur d'une routine de service d'interruption (ISR), afin qu'aucune impulsion ne soit jamais manquée.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 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-s3/esp32-s3-rotary-encoder */ #include <ezButton.h> // The library to use for SW pin #define CLK_PIN 19 // The ESP32 S3 pin 19 connected to the rotary encoder's CLK pin #define DT_PIN 20 // The ESP32 S3 pin 20 connected to the rotary encoder's DT pin #define SW_PIN 21 // The ESP32 S3 pin 21 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 21; 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 Serial Monitor affiche la même information de rotation que l'exemple précédent, mais avec de meilleures performances et fiabilité sur l'ESP32 S3.

※ Note:

Une seule interruption suffit : de nombreux tutoriels attachent des interruptions à la fois sur CLK et DT, mais une seule interruption sur CLK suffit et utilise moins de ressources
Utilisez le mot-clé volatile : déclarez toujours les variables modifiées à l'intérieur d'une ISR comme volatile afin que le compilateur ne les optimise pas
Gardez les ISR courtes : évitez d'appeler Serial.print() ou Serial.println() à l'intérieur d'une interruption — définissez un drapeau ou mettez à jour un compteur, puis traitez la sortie dans la boucle principale
Exécution rapide : plus votre ISR est courte et rapide, plus la lecture de l'encodeur sera fiable sous charge

Applications de l'encodeur rotatif ESP32 S3

Les encodeurs rotatifs s'associent naturellement à la puissance de traitement et à la connectivité de l'ESP32 S3, permettant un large éventail de projets interactifs et orientés contrôle.

Contrôle de servomoteur : faites tourner l'encodeur pour régler la position du servomoteur avec un contrôle angulaire précis, clic par clic
Gradateur de luminosité LED : associez le compteur de l'encodeur à un rapport cyclique PWM pour un réglage de luminosité fluide et continu
Contrôle de vitesse de moteur pas à pas : régulez la vitesse du moteur pas à pas en temps réel pour des applications de robotique et de CNC
Contrôle de volume numérique : ajustez le niveau de sortie audio dans des projets de domotique ou d'enceinte Bluetooth
Navigation de menu OLED : faites défiler les éléments de menu en tournant le bouton et sélectionnez avec un appui sur le bouton
Thermostat intelligent : réglez la température cible avec l'encodeur et affichez la valeur sur un écran
Sélecteur de couleur LED RVB : associez la position de l'encodeur à la teinte, en parcourant tout le spectre de couleurs

Tutoriel vidéo

Regardez la vidéo pas à pas de ce projet ESP32 S3 ci-dessous.

Mettez-vous au défi

Maintenant que vous avez un encodeur rotatif fonctionnel sur l'ESP32 S3, essayez ces exercices pour approfondir votre compréhension et pousser le projet plus loin.

Débutant : câblez une LED qui clignote une fois chaque fois que le bouton de l'encodeur est appuyé
Débutant : affichez la valeur actuelle du compteur sur un afficheur 7 segments à 4 chiffres au lieu du Serial Monitor
Intermédiaire : utilisez le compteur de l'encodeur pour contrôler l'angle d'un servomoteur — associez la plage du compteur à 0–180 degrés
Intermédiaire : construisez un gradateur de luminosité LED basé sur PWM qui répond en temps réel à la rotation de l'encodeur
Avancé : créez un système de menu à plusieurs niveaux sur un écran OLED ou LCD, avec l'encodeur pour le défilement et le bouton pour la sélection

Références de fonctions

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !