View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Test d'un encodeur rotatif et affichage dans le Terminal série du logiciel Arduino

Par X. HINAULT - Page créée le : 9/2/2011.

(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 :

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 :

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


// --- Programme 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 ---