Commande d’un moteur pas à pas bipolaire à l’aide d’un clavier et LCD.

1.  Présentation

Ce programme positionne un moteur pas à pas bipolaire connecté via interface sur 4 broches
en saisissant une valeur numérique au clavier, correspondant au nombre de pas à exécuter. Fonctionne dans les 2 sens.

La touche * est utilisée comme touche de signe – .
La touche # est utilisée comme touche de validation.

Ce programme utilise les fonctionnalités suivantes :

• un afficheur LCD alphanumérique 4×20 en mode 4 bits
• un Clavier matriciel 4×4 (16 touches)
• un moteur pas à pas bipolaire

Ce programme utilise les 3 librairies suivantes :

• La librairie LCD – pour l’utilisation et le contrôle d’un afficheur LCD alpha-numérique standard.
• La librairie Stepper – pour contrôler les moteurs pas à pas
• La librairie Keypad – pour l’utilisation des claviers matriciels. (hors référence)

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 afficheur LCD alpha-numérique (préparé pour une utilisation simplifiée en mode 4 bits avec la carte Arduino)

• un clavier matriciel 4×4 (16 touches)

• un moteur pas à pas bipolaire

• une interface moteur de puissance double driver (basée sur un ci tb6612) ou équivalent

Disponible ici (6 Euros) : http://www.watterott.com/Motor-Driver-1A-Dual-TB6612FNG_1
Plus d’infos ici : Carte double driver de moteur 1A basé sur le CI tb6612fng

3.  Instructions de montage

Ce montage utilise 18 broches de la carte Arduino : être rigoureux donc…

Connexion du clavier

• Connecter sur la broche 2 la Colonne 4 du Clavier
• Connecter sur la broche 3 la Colonne 3 du Clavier
• Connecter sur la broche 4 la Colonne 2 du Clavier
• Connecter sur la broche 5 la Colonne 1 du Clavier
• Connecter sur la broche 16 la Ligne 4 du Clavier
• Connecter sur la broche 17 la Ligne 3 du Clavier
• Connecter sur la broche 18 la Ligne 2 du Clavier
• Connecter sur la broche 19 la Ligne 1 du Clavier

Connexion du LCD

• Connecter sur la broche 6 la broche RS du LCD
• Connecter sur la broche 7 la broche E du LCD
• Connecter sur la broche 8 la broche D4 du LCD
• Connecter sur la broche 9 la broche D5 du LCD
• Connecter sur la broche 10 la broche D6 du LCD
• Connecter sur la broche 11 la broche D7 du LCD

Connexion du moteur pas à pas bipolaire

• Connecter sur la broche 12 la broche de commande du pas 1 du moteur pas à pas
• Connecter sur la broche 13 la broche de commande du pas 2 du moteur pas à pas
• Connecter sur la broche 14 la broche de commande du pas 3 du moteur pas à pas
• Connecter sur la broche 15 la broche de commande du pas 4 du moteur pas à pas

4.  Le schéma théorique du montage

5.  Le circuit du montage

6.  Explication du programme

6.1  Structure globale du programme

Ce programme simple comprend :

• une entête déclarative
• une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
• une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

• Après avoir pris en compte les instructions de la partie déclarative,
• puis après avoir exécuté la partie configuration ( fonction setup( ) ),
• le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

7.  Au niveau de la partie déclarative :

Inclusion des librairies utilisées

• On inclut les librairies des fonctionnalités utilisées :
  • Inclusion de la librairie pour l’afficheur LCD alphanumérique :

#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD 

• Inclusion de la librairie pour le clavier matriciel :

#include <Keypad.h> // inclusion de la librairie pour clavier matriciel 

• Inclusion de la librairie pour les moteurs pas à pas :

#include <Stepper.h> // librairie pour servomoteur

Déclaration de constantes utiles

• On déclare les constantes utiles dans le programme :
  • Déclaration des constantes utiles pour l’utilisation du clavier 4×4 :

//--- Constantes utilisées avec le clavier 4x4
const byte LIGNES = 4; // 4 lignes
const byte COLONNES = 4; //4 colonnes

• Déclaration des constantes utiles pour les servomoteurs :

const int NombrePas=200; // Nombre de pas du servomoteur 

Déclaration des constantes de broches

• Déclaration des constantes pour les broches utilisées dans le programme :

const int C4=2; //declaration constante de broche 
const int C3=3; //declaration constante de broche 
const int C2=4; //declaration constante de broche 
const int C1=5; //declaration constante de broche 
const int RS=6; //declaration constante de broche 
const int E=7; //declaration constante de broche 
const int D4=8; //declaration constante de broche 
const int D5=9; //declaration constante de broche 
const int D6=10; //declaration constante de broche 
const int D7=11; //declaration constante de broche 
const int Pas_1=12; //declaration constante de broche 
const int Pas_2=13; //declaration constante de broche 
const int Pas_3=14; //declaration constante de broche 
const int Pas_4=15; //declaration constante de broche 
const int L4=16; //declaration constante de broche 
const int L3=17; //declaration constante de broche 
const int L2=18; //declaration constante de broche 
const int L1=19; //declaration constante de broche 

Déclaration des variables globales

• Déclaration des variables globales du programmes :
  • Déclaration variables globales des touches du clavier 4×4

//--- Définition des touches 
char touches[LIGNES][COLONNES] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

• Déclaration variables globales de lignes et de colonnes du clavier 4×4

// tableaux de lignes et colonnes
byte BrochesLignes[LIGNES] = {L1, L2, L3, L4}; //connexions utilisées pour les broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {C1, C2, C3, C4}; //connexions utilisées pour les broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée

• Déclaration variables globales utiles

long valeur; 

Déclarations des objets utiles pour les fonctionnalités utilisées

• Déclaration des objets utiles pour les fonctionnalités utilisées :
  • Déclaration d’un objet LCD alphanumérique :

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// Création d'un objet LiquidCrystal = initialisation LCD en mode 4 bits 

• Déclaration d’un objet clavier matriciel :

// création d'un objet keypad = initialisation clavier 
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );
// les broches de lignes sont automatiquement configurées en ENTREE avec pullup interne activé 
// les broches de colonnes sont automatiquement configurées en SORTIE

• Déclaration d’un objet moteur pas à pas

Stepper stepper(NombrePas, Pas_1, Pas_2, Pas_3, Pas_4);  // crée un objet Stepper pour contrôler le moteur pas à pas

8.  Au niveau de la fonction d’initialisation setup( ) :

Initialisation des fonctionnalités utilisées :

• On initialise les différentes fonctionnalités utilisées :
  • Initialisation de l’utilisation de l’afficheur LCD alpha-numérique

lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes 

delay(10); // pause rapide pour laisser temps initialisation

• Test de l’afficheur LCD alpha-numérique

// Test du LCD

lcd.print("LCD OK") ; // affiche la chaîne texte - message de test
delay(2000); // pause de 2 secondes

lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran

• Initialisation de la vitesse de rotation moteur pas à pas

// initialise la vitesse de rotation du moteur pas à pas en tour par minute
stepper.setSpeed(100);  

configuration des broches utilisées :

• Les broches de lignes et d’entrée sont configurées automatiquement lors de l’initialisation du clavier et du moteur pas à pas et du LCD

9.  Au niveau de la boucle principale, la fonction loop ( ) :

• On réalise la saisie d’une valeur au clavier qui est envoyée ensuite à la fonction step pour rotation du moteur :

valeur=SAISIE_LONG(); 
Lcd.setCursor(0,1);// positionne curseur 2ème ligne, 1ère colonne
Lcd.print(valeur); 

stepper.step(valeur); // fait tourner le moteur du nombre pas indiqués - sens + et - 

Lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran

• Le programme recommence en boucle les instructions de la fonction loop( ).

Se reporter aux commentaires présents dans le programme pour plus de détails.

10.  Autres Fonctions du programme :

• Le coeur de ce programme est la fonction de saisie d’un nombre long au clavier (voir le programme)

11.  Mise en oeuvre du programme

11.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

11.2  Fonctionnement

• Saisir un nombre au clavier : le moteur tourne du nombre de pas voulu. La touche * pour les nombres négatifs. La touche # pour valider le nombre saisi.

12.  Le programme complet en langage Arduino :

A copier/coller directement dans l’éditeur Arduino

// --- Programme Arduino ---
// par X. HINAULT - Le 10/03/2010
// www.mon-club-elec.fr 

// --- Que fait ce programme ? ---
/* positionne un moteur pas à pas bipolaire connecté via interface sur 4 broches
en saisissant une valeur au clavier. */

// --- Fonctionnalités utilisées ---
// Utilise un afficheur LCD alphanumérique4x20 en mode 4 bits 
// Utilise un Clavier matriciel 4x4 (16 touches) 
// Utilise un ou plusieurs moteurs pas à pas 

// --- Circuit à réaliser ---
// Connecter  sur la broche 2 la Colonne 4 du Clavier
// Connecter  sur la broche 3 la Colonne 3 du Clavier
// Connecter  sur la broche 4 la Colonne 2 du Clavier
// Connecter  sur la broche 5 la Colonne 1 du Clavier

// Connecter  sur la broche 6 la broche RS du LCD
// Connecter  sur la broche 7 la broche E du LCD
// Connecter  sur la broche 8 la broche D4 du LCD
// Connecter  sur la broche 9 la broche D5 du LCD
// Connecter  sur la broche 10 la broche D6 du LCD
// Connecter  sur la broche 11 la broche D7 du LCD

// Connecter  sur la broche 12 la broche de commande du pas 1 du moteur pas à pas
// Connecter  sur la broche 13 la broche de commande du pas 2 du moteur pas à pas
// Connecter  sur la broche 14 la broche de commande du pas 3 du moteur pas à pas
// Connecter  sur la broche 15 la broche de commande du pas 4 du moteur pas à pas

// Connecter  sur la broche 16 la Ligne 4 du Clavier
// Connecter  sur la broche 17 la Ligne 3 du Clavier 
// Connecter  sur la broche 18 la Ligne 2 du Clavier
// Connecter  sur la broche 19 la Ligne 1 du Clavier

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD 

#include <Keypad.h> // inclusion de la librairie pour clavier matriciel 

#include <Stepper.h> // librairie pour moteurs pas à pas

// --- Déclaration des constantes ---

//--- Constantes utilisées avec le clavier 4x4

const byte LIGNES = 4; // 4 lignes
const byte COLONNES = 4; //4 colonnes

const int NombrePas=200; // Nombre de pas du servomoteur 

// --- constantes des broches ---

const int C4=2; //declaration constante de broche 
const int C3=3; //declaration constante de broche 
const int C2=4; //declaration constante de broche 
const int C1=5; //declaration constante de broche 

const int RS=6; //declaration constante de broche 
const int E=7; //declaration constante de broche 

const int D4=8; //declaration constante de broche 
const int D5=9; //declaration constante de broche 
const int D6=10; //declaration constante de broche 
const int D7=11; //declaration constante de broche 

const int Pas_1=12; //declaration constante de broche 
const int Pas_2=13; //declaration constante de broche 
const int Pas_3=14; //declaration constante de broche 
const int Pas_4=15; //declaration constante de broche 

const int L4=16; //declaration constante de broche 
const int L3=17; //declaration constante de broche 
const int L2=18; //declaration constante de broche 
const int L1=19; //declaration constante de broche 

// --- Déclaration des variables globales ---

//--- Définition des touches 

char touches[LIGNES][COLONNES] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

// tableaux de lignes et colonnes
byte BrochesLignes[LIGNES] = {L1, L2, L3, L4}; //connexions utilisées pour les broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {C1, C2, C3, C4}; //connexions utilisées pour les broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée

long valeur; 

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

LiquidCrystal Lcd(RS, E, D4, D5, D6, D7);// Création d'un objet LiquidCrystal = initialisation LCD en mode 4 bits 


// création d'un objet keypad = initialisation clavier 
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );
// les broches de lignes sont automatiquement configurées en ENTREE avec pullup interne activé 
// les broches de colonnes sont automatiquement configurées en SORTIE

Stepper stepper(NombrePas, Pas_1, Pas_3, Pas_2, Pas_4);  // crée un objet Stepper pour contrôler le moteur pas à pas
// Pas_1 et Pas_3 commandent la 1ère phase, Pas_2 et Pas_4 la 2ème phase 


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

Lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes 

delay(10); // pause rapide pour laisser temps initialisation

// Test du LCD

Lcd.print("LCD OK") ; // affiche la chaîne texte - message de test
delay(2000); // pause de 2 secondes

Lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran

// initialise la vitesse de rotation du moteur pas à pas en tour par minute
stepper.setSpeed(100);  


// les broches de lignes et d'entrée sont configurées automatiquement lors de l'initialisation du clavier 

// ------- Broches en sortie -------  


// ------- Broches en entrée -------  


// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------  


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

valeur=SAISIE_LONG(); 
Lcd.setCursor(0,1);// positionne curseur 2ème ligne, 1ère colonne
Lcd.print(valeur); 

stepper.step(valeur); // fait tourner le moteur du nombre pas indiqués - sens + et - 

Lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran


// touche = clavier.getKey(); // lecture de la touche appuyée
//if (touche != NO_KEY){ // si une touche a été frappée -- gestion de la touche appuyée 

//} // fin gestion de la touche appuyée 

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

long SAISIE_LONG (){ // fonction qui renvoie une valeur long signé (32bits)

//---- variables locales utilisées dans la fonction
long saisie_long[11]={0,0,0,0,0,0,0,0,0,0,0}; // crée un tableau de variables pour saisir valeur - long maxi = 10 chiffres + signe
char compt_touche; // variable de comptage du nombre de touches saisies
long nombre_saisi; // variable de calcul du nombre saisi
//float valeurf; // variable de caclul de la valeur convertie    
char touche_long; // variable locale pour valeur touche appuyée de 0 à 15

//---- initialisation des variables utilisées ----
compt_touche=0; // aucune touche saisie au démarrage
nombre_saisi=0; // initialise la variable


//-------- initialisation curseur --------
//// mode clignotant

//------ gestion appui touche sur clavier

 while (compt_touche<11) { // tant que pas appuis maxi = 11 touches pour long + signe (valeur maxi=+2 147 483 647)

       touche_long= clavier.getKey(); // lecture de la touche appuyée

       if (touche_long!= NO_KEY){ // si une touche a été frappée -- gestion de la touche appuyée 

          Lcd.print(touche_long); // debug

           if (compt_touche==0) { // au premier passage 
              if (touche_long=='*') { // si appui signe - 
                saisie_long[10]=-1; // mémorise -1 dans le 11ème caractère 
                continue; // poursuit while comme si pas de premier passage
              }
             else {
               if (saisie_long[10]==0)saisie_long[10]=1; // mémorise le signe + dans le 11ème caractère si pas déjà à -1
             }
           } // fin if compt_touche==0


           if (touche_long=='#') break; // sort du while si appui sur #

           //---- calcul valeur numérique touches 0 à 9  (3ères lignes x 3ères colonnes)
           //--- à partir lignes colonnes ---
           for (byte i=0;i<3;i++) {
             for (byte j=0; j<3;j++){
               if (touche_long==touches[i][j]) touche_long=(j+1)+(i*3);//calcul de la valeur numérique
             }
           }
           //---- à patir valeur ascii --- 

           // touche 0
           if (touche_long=='0') touche_long=0;

           //---- calcul valeur numériques autres touches 
           if (touche_long=='A') touche_long=10;
           if (touche_long=='B') touche_long=11;
           if (touche_long=='C') touche_long=12;
           if (touche_long=='D') touche_long=13;

           saisie_long[compt_touche]=touche_long; //enregistre le caractère dans tableau code_saisi


           compt_touche=compt_touche+1; // on incrémente la variable compt qui mémorise le nombre de caractères saisis

           //delay () 


         } //---- fin gestion appui clavier

}// fin du While = fin de la lecture du clavier

//--------- calcul valeur saisie en fonction du nombre de chiffres saisis et x signe (saisie_long[10]) ---------
if (compt_touche==0)nombre_saisi=0;   // si aucun chiffre saisi
if (compt_touche==1)nombre_saisi=(saisie_long[0]);   // si 1 seul chiffre saisi
if (compt_touche==2)nombre_saisi=(saisie_long[0]*10)+(saisie_long[1]*1);   // si 2 chiffres saisi
if (compt_touche==3)nombre_saisi=(saisie_long[0]*100)+(saisie_long[1]*10)+(saisie_long[2]*1);   // si 3 chiffres saisi
if (compt_touche==4)nombre_saisi=(saisie_long[0]*1000)+(saisie_long[1]*100)+(saisie_long[2]*10)+(saisie_long[3]*1);   // si 4 chiffres saisi
if (compt_touche==5)nombre_saisi=(saisie_long[0]*10000)+(saisie_long[1]*1000)+(saisie_long[2]*100)+(saisie_long[3]*10)+(saisie_long[4]*1);   // si 5 chiffres saisi
if (compt_touche==6)nombre_saisi=(saisie_long[0]*100000)+(saisie_long[1]*10000)+(saisie_long[2]*1000)+(saisie_long[3]*100)+(saisie_long[4]*10)+(saisie_long[5]*1);   // si 6 chiffres saisi
if (compt_touche==7)nombre_saisi=(saisie_long[0]*1000000)+(saisie_long[1]*100000)+(saisie_long[2]*10000)+(saisie_long[3]*1000)+(saisie_long[4]*100)+(saisie_long[4]*10)+(saisie_long[5]*1);   // si 6 chiffres saisi
if (compt_touche==8)nombre_saisi=(saisie_long[0]*10000000)+(saisie_long[1]*1000000)+(saisie_long[2]*100000)+(saisie_long[3]*10000)+(saisie_long[4]*1000)+(saisie_long[5]*100)+(saisie_long[6]*10)+(saisie_long[7]*1);   // si 7 chiffres saisi
if (compt_touche==9)nombre_saisi=(saisie_long[0]*100000000)+(saisie_long[1]*10000000)+(saisie_long[2]*1000000)+(saisie_long[3]*100000)+(saisie_long[4]*10000)+(saisie_long[5]*1000)+(saisie_long[6]*100)+(saisie_long[7]*10)+(saisie_long[8]*1);   // si 8 chiffres saisi
if (compt_touche==10)nombre_saisi=(saisie_long[0]*1000000000)+(saisie_long[1]*100000000)+(saisie_long[2]*10000000)+(saisie_long[3]*1000000)+(saisie_long[4]*100000)+(saisie_long[5]*10000)+(saisie_long[6]*1000)+(saisie_long[7]*100)+(saisie_long[8]*10)+(saisie_long[9]*1);   // si 9 chiffres saisi

//Serial.println(int(saisie_long[10])); // debug - affiche signe

nombre_saisi=nombre_saisi*long(saisie_long[10]); // prise en compte du signe 

//------ à réaliser en sortie de lecture du clavier ----

compt_touche=0; // réinitialise le nombre de touche saisies

//-------- initialisation curseur --------
//// désactive mode clignotant

//----- renvoi de la valeur saisie ----

return (nombre_saisi); // renvoie la valeur - sortie de la fonction 

}

// --- Fin programme ---