Arduino Nano - Encodeur rotatif
Ce tutoriel vous explique comment utiliser l'encodeur rotatif avec l'Arduino Nano. 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 l'encodeur rotatif à un Arduino Nano
- Comment écrire le code pour l'Arduino Nano pour lire la direction et la position à partir de l'encodeur rotatif.
Préparation du matériel
| 1 | × | Arduino Nano | |
| 1 | × | USB A to Mini-B USB cable | |
| 1 | × | Rotary Encoder | |
| 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 appelé encodeur rotatif peut transformer des torsions en un signal. Il montre à quel point quelque chose a tourné et où cela se trouve. Il existe deux types principaux :
- Encodeur incrémental : Il utilise des signaux rapides pour mesurer l'ampleur du mouvement.
- Encodeur absolu : Ce type fournit un code unique pour chaque position, ce qui permet de déterminer précisément où se trouve quelque chose, même en cas de coupure de courant.
Ce guide concerne l'encodeur incrémental.
Brochage du module d'encodeur rotatif
Un module d'encodeur rotatif possède 4 broches :
- Broche CLK (Sortie A) : c'est l'impulsion principale qui nous indique combien de rotation a eu lieu. Chaque fois que vous tournez le bouton d'un cran (clic) dans n'importe quelle 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 décalé 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 lorsque le bouton n'est pas pressé, et BASSE lorsqu'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 pourriez confondre l'encodeur rotatif avec le potentiomètre, mais ce sont des pièces distinctes. Voici une comparaison entre eux :
- L'encodeur rotatif peut être considéré comme la version moderne d'un potentiomètre, mais il offre plus de capacités.
- L'encodeur rotatif peut tourner entièrement sans s'arrêter, tandis que le potentiomètre ne peut tourner que sur environ trois quarts de tour.
- L'encodeur rotatif émet des impulsions, tandis que le potentiomètre produit une tension analogique.
- Lorsque vous avez seulement besoin de savoir combien le bouton a été déplacé sans localiser sa position exacte, l'encodeur rotatif est pratique. D'autre part, le potentiomètre est précieux lorsque vous avez besoin de connaître précisément la position d'un bouton.
Comment fonctionne un encodeur rotatif
À l'intérieur de l'encodeur, il y a un disque avec des fentes relié à une broche appelée C, qui sert 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 terre commune C, mais dans un certain ordre selon le 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 un peu différents en termes de timing car une broche touche la terre 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 terre avant la broche B. Lorsque vous tournez le bouton dans le sens inverse des aiguilles d'une montre, la broche B touche la terre avant la broche A.
- En surveillant quand chaque broche touche ou quitte la terre, nous pouvons déterminer dans quel sens tourne le bouton. 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 contraire des aiguilles d'une montre.
※ 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
- 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
Code Arduino Nano - Encodeur Rotatif
Le code Arduino Nano ci-dessous fait :
- Détecte la direction et l'ampleur de la rotation de l'encodeur.
- Si détection d'une rotation du bouton d'un cran (clic) dans le sens horaire, augmentez le compteur de un.
- Si détection d'une rotation du bouton d'un cran (clic) dans le sens antihoraire, diminuez le compteur de un.
- Détecte si le bouton est pressé.
/*
* Ce code Arduino Nano a été développé par newbiely.fr
* Ce code Arduino Nano 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/arduino-nano-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN 2
#define DT_PIN 3
#define SW_PIN 4
#define DIRECTION_CW 0 // clockwise direction
#define DIRECTION_CCW 1 // anticlockwise direction
int counter = 0;
int direction = DIRECTION_CW;
int CLK_state;
int prev_CLK_state;
ezButton button(SW_PIN);
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 anticlockwise 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("Twisted direction: ");
if (direction == DIRECTION_CW)
Serial.print("CLOCKWISE");
else
Serial.print("ANTICLOCKWISE");
Serial.print(" - counter: ");
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
- Installez la bibliothèque ezButton sur l'IDE Arduino. Voir Comment faire
- Copiez le code ci-dessus et ouvrez-le avec l'IDE Arduino
- Cliquez sur le bouton Upload sur l'IDE Arduino pour téléverser le code sur Arduino Nano
- Tournez le bouton dans le sens des aiguilles d'une montre, puis dans le sens inverse
- Appuyez sur le bouton
- Vérifiez le résultat sur le moniteur série.
COM6
Twisted direction: CLOCKWISE - counter: 1
Twisted direction: CLOCKWISE - counter: 2
Twisted direction: CLOCKWISE - counter: 3
Twisted direction: CLOCKWISE - counter: 4
Twisted direction: CLOCKWISE - counter: 5
Twisted direction: ANTICLOCKWISE - counter: 4
Twisted direction: ANTICLOCKWISE - counter: 3
Twisted direction: ANTICLOCKWISE - counter: 2
Twisted direction: ANTICLOCKWISE - counter: 1
Twisted direction: ANTICLOCKWISE - counter: 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 - Encodeur rotatif avec interruption
Dans l'exemple de code précédent, nous utilisons la méthode de sondage, qui vérifie en continu l'état de la broche. Cela présente deux inconvénients :
- Gaspiller la ressource Arduino Nano
- Certains compteurs peuvent être manqués si un autre code prend trop de temps à s'exécuter.
Une approche pour gérer cela consiste à utiliser des interruptions. Les interruptions éliminent le besoin de vérification constante d'un événement particulier. Cela permet à l'Arduino Nano d'effectuer d'autres tâches sans négliger un événement.
Voici un exemple de la façon de lire un encodeur rotatif avec des interruptions.
/*
* Ce code Arduino Nano a été développé par newbiely.fr
* Ce code Arduino Nano 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/arduino-nano-rotary-encoder
*/
#include <ezButton.h> // The library to use for SW pin
#define CLK_PIN 2 // The Arduino Nano pin D2 connect to the pin CLK of the rotary encoder
#define DT_PIN 3 // The Arduino Nano pin D3 connect to the pin DT of the rotary encoder
#define SW_PIN 4 // The Arduino Nano pin D4 connect to the pin SW of the rotary encoder
#define DIRECTION_CW 0 // clockwise direction
#define DIRECTION_CCW 1 // anticlockwise direction
volatile int counter = 0;
volatile int direction = DIRECTION_CW;
volatile unsigned long last_time; // for debouncing
int prev_counter;
ezButton button(SW_PIN);
void INTERRUPT_handler() {
if ((millis() - last_time) < 50) // debounce time is 10ms
return;
if (digitalRead(DT_PIN) == HIGH) {
// The encoder is rotating in anticlockwise 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("Twisted direction: ");
if (direction == DIRECTION_CW)
Serial.print("CLOCKWISE");
else
Serial.print("ANTICLOCKWISE");
Serial.print(" - counter: ");
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 des informations qui apparaissent sur le moniteur série, tout comme ce que vous avez vu dans le code précédent.
※ NOTE THAT:
- Si vous utilisez l'interrupt, vous devez connecter la broche CLK de l'encodeur à une broche de l'Arduino Nano capable de gérer les interruptions. Mais souvenez-vous, toutes les broches de l'Arduino Nano ne peuvent pas faire cela. Par exemple, sur l'Arduino Nano, seules les broches 2 et 3 peuvent fonctionner avec des interruptions.
- Vous pourriez trouver des tutoriels sur d'autres sites qui utilisent deux interruptions pour un seul encodeur, mais cela est inutile et gaspilleur. Une seule interruption est suffisante.
- 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
Avec l'encodeur rotatif, nous pouvons réaliser les applications suivantes, sans nous y limiter :
- Arduino Nano - Encodeur rotatif contrôle la position du moteur servo
- Arduino Nano - Encodeur rotatif contrôle la luminosité de la LED
- Arduino Nano - Encodeur rotatif contrôle la vitesse du moteur pas à pas