Contrôle du sens et de la vitesse de rotation d’un moteur CC (courant continu) à l’aide d’un bouton poussoir et d’une résistance variable

1.  Présentation

Ce programme Contrôle du sens de rotation d’un moteur CC à l’aide d’un bouton poussoir : un appui sur un BP inverse le sens de rotation du moteur.
Une résistance variable permet le réglage de la vitesse de rotation du moteur.

Ce programme utilise les fonctionnalités suivantes :

• la conversion analogique numérique 10bits sur la voie analogique analog 0.

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 bouton poussoir pour CI,

• une résistance variable,

• un moto-réducteur CC

• ou un moteur cc

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

Disponible ici (6 Euros) : http://www.watterott.com/index.php?page=product&info=1339
Plus d’infos ici : Carte double driver de moteur 1A basé sur le CI tb6612fng

3.  Instructions de montage

• Connecter sur la broche 2 (configurée en entrée) un Bouton Poussoir connecté à la masse (0V)
• Connecter sur la broche 3 (configurée en sortie) la broche PWM de l’interface moteur
• Connecter sur la broche 4 (configurée en sortie) la broche IN2 de l’interface moteur
• Connecter sur la broche 5 (configurée en sortie) la broche IN1 de l’interface moteur
• Broche Analog 0 (=broche 14) en entrée Analogique connectée à la résistance variable

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 :

Déclaration de constantes utiles

• On déclare les constantes utiles dans le programme :
  • Déclaration des constantes utiles pour l’utilisation des boutons poussoirs :

const int APPUI=0; // constante état du BP - appui sur niveau bas
const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut

Déclaration des constantes de broches

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

const int BP=2; //declaration constante de broche 
const int VITESSE=3; //declaration constante de broche 
const int SENS_AV=4; //declaration constante de broche 
const int SENS_AR=5; //declaration constante de broche 
const int Voie_0=0; //declaration constante de broche analogique

Déclaration des variables globales

• Déclaration des variables globales du programmes :
  • Déclaration d’une variable globale utile pour l’utilisation des boutons poussoirs :

int ETAT_BP=0; // variable témoin de l'état du BP

• Déclaration des variables globales utilisées pour la conversion analogique-numérique

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
//float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

• Déclaration des variables globales utilisées pour le comptage des appuis BP

int compt=0; // variable pour comptage du nombre d'appui

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

configuration des broches utilisées :

• Configuration des broches en sortie :

pinMode(VITESSE, OUTPUT); //met la broche en sortie 
pinMode(SENS_AV, OUTPUT); //met la broche en sortie 
pinMode(SENS_AR, OUTPUT); //met la broche en sortie 

• Configuration des broches en entrée :

pinMode(BP, INPUT); //met la broche en entree 

• Activation du rappel au + interne des broches en entrée si nécessaire :

digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

• Initialisation des broches utilisées en sortie

// moteur à l'arrêt au démarrage
digitalWrite(SENS_AR, LOW) ; // controle sens AR
digitalWrite(SENS_AV, LOW) ; // controle sens AV

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

• On réalise un test du bouton poussoir :
  • si le BP est appuyé, on incrémente une variable de comptage
  • en fonction du nombre d’appui, on fixe le fonctionnement du moteur (marche avant, arrière, arrêt)

//---- gestion des appuis sur Bouton poussoir --- 
if (digitalRead(BP)==APPUI) { // test état du BP

 compt=compt+1; // incrémente la variable compt
 if (compt==4) compt=0; // RAZ variable compt de 3=>0

 if (compt==0){ 
  // moteur à l'arrêt 
  digitalWrite(SENS_AR, LOW) ; // controle sens AR
  digitalWrite(SENS_AV, LOW) ; // controle sens AV
 }

 if (compt==1){ 
  // moteur en marche arrière 
  digitalWrite(SENS_AR, HIGH) ; // sens AR en marche
  digitalWrite(SENS_AV, LOW) ; // sens AV à l'arrêt
 }

 if (compt==2){ 
  // moteur à l'arrêt 
  digitalWrite(SENS_AR, LOW) ; // controle sens AR
  digitalWrite(SENS_AV, LOW) ; // controle sens AV
 }

 if (compt==3){ 
  // moteur en marche avant 
  digitalWrite(SENS_AR, LOW) ; // sens AR à l'arrêt
  digitalWrite(SENS_AV, HIGH) ; // sens AV en marche
 }


 delay(300); // pause anti-rebond entre 2 appuis

}

• Ensuite, on fixe l’impulsion de commande de la vitesse du moteur en fonction de la mesure de la tension en sortie de la résistance variable :

//----- gestion de la vitesse de rotation 

  //mesure tension résistance variable 
  mesure_brute=analogRead(Voie_0); // mesure tension sur la voie analogique
  mesure_brute=map(mesure_brute,0,1023,0,255); // adaptation échelle valeur

  //génération impulsion PWM fonction de la tension mesurée
  analogWrite(VITESSE,mesure_brute); // génère une impulsion de largeur fonction de la mesure

10.  Mise en oeuvre du programme

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

10.2  Fonctionnement

• L’appui sur le bouton poussoir modifie le sens de rotation du moteur :
  • premier appui : moteur en marche avant
  • deuxème appui : arrêt
  • troisième appui : moteur en marche arrière
  • quatrième appui : arrêt
  • et ainsi de suite…
• en faisant varier la résistance variable, on modifie la vitesse de rotation du moteur.

11.  Le programme complet en langage Arduino :

A copier/coller directement dans l’éditeur Arduino

// --- Programme Arduino ---
// par X. HINAULT - 02/2010 

// --- Que fait ce programme ? ---
/* Contrôle du sens de rotation d'un moteur CC à l'aide d'un bouton poussoir : 
un appui sur un BP inverse le sens de rotation du moteur. 
Une résistance variable permet le réglage de la vitesse de rotation du moteur. */

// --- Fonctionnalités utilisées ---
// Utilise la conversion analogique numérique 10bits sur les voies analogiques  analog 0, 

// --- Circuit à réaliser ---

// Connecter  sur la broche 2 (configurée en entrée) un Bouton Poussoir connecté à la masse (0V)
// Connecter  sur la broche 3 (configurée en sortie) la broche PWM de l'interface moteur
// Connecter  sur la broche 4 (configurée en sortie) la broche IN2 de l'interface moteur
// Connecter  sur la broche 5 (configurée en sortie) la broche IN1 de l'interface moteur
// Broche Analog 0 (=broche 14) en entrée Analogique 

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

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

// --- Déclaration des constantes ---
const int APPUI=0; // constante état du BP - appui sur niveau bas
const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut


// --- constantes des broches ---

const int BP=2; //declaration constante de broche 
const int VITESSE=3; //declaration constante de broche 
const int SENS_AV=4; //declaration constante de broche 
const int SENS_AR=5; //declaration constante de broche 
const int Voie_0=0; //declaration constante de broche analogique

// --- Déclaration des variables globales ---
int ETAT_BP=0; // variable témoin de l'état du BP

int compt=0; // variable pour comptage du nombre d'appui

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
//float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique


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

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


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

pinMode(VITESSE, OUTPUT); //met la broche en sortie 
pinMode(SENS_AV, OUTPUT); //met la broche en sortie 
pinMode(SENS_AR, OUTPUT); //met la broche en sortie 

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

pinMode(BP, INPUT); //met la broche en entree 

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

digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

// ---- Initialisation de broches utilisées ---

// moteur à l'arrêt au démarrage
digitalWrite(SENS_AR, LOW) ; // controle sens AR
digitalWrite(SENS_AV, LOW) ; // controle sens AV



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

//---- gestion des appuis sur Bouton poussoir --- 
if (digitalRead(BP)==APPUI) { // test état du BP

 compt=compt+1; // incrémente la variable compt
 if (compt==4) compt=0; // RAZ variable compt de 3=>0

 if (compt==0){ 
  // moteur à l'arrêt 
  digitalWrite(SENS_AR, LOW) ; // controle sens AR
  digitalWrite(SENS_AV, LOW) ; // controle sens AV
 }

 if (compt==1){ 
  // moteur en marche arrière 
  digitalWrite(SENS_AR, HIGH) ; // sens AR en marche
  digitalWrite(SENS_AV, LOW) ; // sens AV à l'arrêt
 }

 if (compt==2){ 
  // moteur à l'arrêt 
  digitalWrite(SENS_AR, LOW) ; // controle sens AR
  digitalWrite(SENS_AV, LOW) ; // controle sens AV
 }

 if (compt==3){ 
  // moteur en marche avant 
  digitalWrite(SENS_AR, LOW) ; // sens AR à l'arrêt
  digitalWrite(SENS_AV, HIGH) ; // sens AV en marche
 }


 delay(300); // pause anti-rebond entre 2 appuis

}

//----- gestion de la vitesse de rotation 

  //mesure tension résistance variable 
  mesure_brute=analogRead(Voie_0); // mesure tension sur la voie analogique
  mesure_brute=map(mesure_brute,0,1023,0,255); // adaptation échelle valeur

  //génération impulsion PWM fonction de la tension mesurée
  analogWrite(VITESSE,mesure_brute); // génère une impulsion de largeur fonction de la mesure

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

// --- Fin programme ---