Le test d’un encodeur rotatif et l’affichage dans le Terminal série du logiciel Arduino sont des techniques très utiles pour les développeurs qui souhaitent contrôler et surveiller leurs projets. Ces techniques permettent de mesurer et de contrôler la vitesse et la position d’un moteur, et de surveiller le fonctionnement d’un système. Dans cet article, nous allons examiner en détail comment tester un encodeur rotatif et afficher les données dans le Terminal série du logiciel Arduino. Nous verrons également comment ces techniques peuvent être utilisées pour contrôler et surveiller un projet.
Test d’un encodeur rotatif et affichage dans le Terminal série du logiciel Arduino
(cliquer sur l’image pour agrandir)
1. Présentation
Ce programme permet de tester l’utilisation d’un encodeur rotatif. Une variable de comptage est incrémentée/décrémentée par la rotation de l’encodeur. L’appui sur l’axe met à zéro le comptage.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise une interruption à intervalle régulier (Timer 2)
- en générant une interruption toutes les 1 millisecondes
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- La librairie MsTimer2 – pour générer une interruption du Timer 2 à intervalle régulier
- La librairie pour l’encodeur rotatif
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.

2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,

- des straps,

- un encodeur rotatif. L’encodeur rotatif utilisé ici est le même que celui de la carte S65 shield : c’est un encodeur à 24 impulsions par tour avec une fonction bouton poussoir.
- Le brochage de l’encodeur est le suivant :
Pour plus de détails, voir :
- Page de présentation de l’encodeur sur le site de Watterott (copie locale)
- Datasheet de l’encodeur rotatif
- la librairie est basée sur le comptage dit « code Gray » : http://fr.wikipedia.org/wiki/Code_de_Gray
3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- On connectera :
- la broche 5 de la carte Arduino est connectée au Bouton Poussoir de l’axe de l’encodeur (BP de validation)
- la broche 6 de la carte Arduino est connectée au bouton poussoir de phase A de l’encodeur
- la broche 7 de la carte Arduino est connectée au bouton poussoir de la phase B de l’encodeur
4. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Explication du programme
6.1 Au niveau de la partie déclarative :
- Inclusion de la librairie pour le Timer2 et pour l’encodeur rotatif.
- On déclare un objet encodeur Rotatif
6.2 Au niveau de la fonction d’initialisation setup( ) :
- On initialise l’objet Encodeur rotatif
- On initialise la connexion série
- On initialise le Timer 2 pour une interruption toutes les 1 ms (1000 fois par seconde)
6.3 Au niveau de la boucle principale, la fonction loop ( ) :
- Rien à ce niveau
6.4 Au niveau de la fonction de gestion de l’interruption du Timer2 :
- Chaque milliseconde, cette routine est appelée.
- On teste l’état de l’encodeur et on incrémente/décrémente la variable en conséquence.
- Un message est envoyé sur le port Série à chaque changement.
7. Mise en oeuvre du programme
7.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
7.2 Préparation du Terminal côté PC dans le logiciel Arduino
- Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».

- La fenêtre « Terminal » s’ouvre alors :

- Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

7.3 Fonctionnement
- Il suffit de tourner l’encodeur dans un sens ou dans l’autre pour incrémenter la variable
- L’appui sur l’axe remet le comptage à zéro.
(cliquer sur l’image pour agrandir)
8. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 09/02/2011
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// — Que fait ce programme ? —
/* Ce programme permet de tester l’utilisation d’un encodeur rotatif.
Une variable de comptage est incrémentée/décrémentée par la rotation de l’encodeur.
L’appui sur l’axe met à zéro le comptage. */
// — Fonctionnalités utilisées —
// Utilise Encodeur Rotatif
// Utilise interruption du Timer 2 à intervalle régulier
// — Circuit à réaliser —
// Encodeur rotatif contrôlé par 3 broches :
// > broche SW de l’encodeur sur la broche 5 de la carte Arduino
// > broche PhA de l’encodeur sur la broche 6 de la carte Arduino
// > broche PhB de l’encodeur sur la broche 7 de la carte Arduino
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables…
// — Inclusion des librairies utilisées —
//#include <S65Display.h> // Inclusion de la librairie pour afficheur TFT couleur S65
#include <RotaryEncoder.h> // Inclusion de la librairie pour encodeur rotatif du module S65
#include <MsTimer2.h> // inclusion de la librairie Timer2
// — Déclaration des constantes —
// — constantes des broches —
// — Déclaration des variables globales —
int compt=0; // variable de comptage
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
RotaryEncoder encodeur; // Création d’un objet RotaryEncoder appelé encodeur
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
encodeur.init(); // initialise l’encodeur rotatif sur les broches 5,6,7 qui sont mises en entrée.
// Le rappel au plus interne est également activé (pullup)
// ——- Broches en sortie ——-
// ——- Broches en entrée ——-
// ——- Activation du rappel au + interne des broches en entrée si nécessaire ——-
// initialisation interruption Timer 2
MsTimer2::set(1, InterruptTimer2); // période 1ms
MsTimer2::start(); // active Timer 2
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
// — la gestion de l’encodeur se fait dans la routine interruption du Timer2
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
void InterruptTimer2() { // debut de la fonction d’interruption Timer2
encodeur.service(); // appel de la routine de gestion de l’encodeur
int test=encodeur.step(); // lit une seule fois l’état de step
if (test==1) // si rotation + encodeur
{
compt=compt+1; // incrémente le compteur
Serial.println(compt);
}
else if (test==-1) // si rotation – encodeur
{
compt=compt–1; // décrémente le compteur
Serial.println(compt);
}
else if (encodeur.sw()==SW_PRESSED) // si appui axe encodeur
{
compt=0; // RAZ le compteur
Serial.println(compt);
}
}
// — Fin programme —
Articles similaires:
- Test simple d’incrémentation d’une valeur à l’aide de l’encodeur rotatif
- Déplacement d’un pixel sur l’écran TFT d’un module S65shield à l’aide d’un encodeur rotatif.
- Temporisation et Temps Réel
- Encodeur Rotatif 24 impulsions/tour type PEC12
- Horloge à affichage sur écran couleur et réglable à l’aide de l’encodeur rotatif (module S65 shield)
Articles Liés
- Afficheur graphique TFT 65536 couleurs 176x132 pixels + Encodeur Rotatif
Infos techniques utiles => Module d'affichage à écran couleur Arduino S65 shield => La…
- Test simple d'incrémentation d'une valeur à l'aide de l'encodeur rotatif
L'encodeur rotatif est un dispositif très pratique pour incrémenter une valeur numérique. Il est très…
- Afficheur graphique TFT 65536 couleurs 176x132 pixels seul + Encodeur Rotatif + Carte mémoire SD
Infos techniques utiles Programmes : A voir en ligne Sur le site officiel Arduino