Le contrôle du sens et de la vitesse de rotation d’un moteur CC (courant continu) est une tâche importante pour de nombreuses applications industrielles. La mise en œuvre d’un système de contrôle peut être complexe et coûteuse. Cependant, il est possible de contrôler le sens et la vitesse de rotation d’un moteur CC à l’aide d’un bouton poussoir et d’une résistance variable. Dans cet article, nous allons examiner en détail comment un tel système peut être mis en place et comment il peut être utilisé pour contrôler le sens et la vitesse de rotation d’un moteur CC.
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

Le schéma théorique du montage
5. Le circuit du montage

Le schéma du montage à réaliser
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.

Le déroulement du programme
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 ---
Articles similaires:
- Contrôle du sens de rotation d’un moteur CC (courant continu) à l’aide d’un bouton poussoir
- Afficher les chiffres 0 à 9 sur un digit à cathode commune
- Tester les segments d’un digit à cathode commune
- Test simple de la commande d’un moteur CC à l’aide du shield DFRduino Motor Driver 1A
- Shield Arduino Motor Shield V3 par Arduino Team
Articles Liés
- Contrôle du sens de rotation d'un moteur CC (courant continu) à l'aide d'un bouton poussoir
Le contrôle du sens de rotation d'un moteur CC (courant continu) est une tâche importante…
- Test simple d'un servomoteur à rotation continue : contrôle de la vitesse et du sens de rotation à l'aide d'une résistance variable.
Le servomoteur à rotation continue est un moteur électrique qui peut être utilisé pour contrôler…
- Test simple de la rotation de 2 servomoteurs à rotation continue.
Les servomoteurs à rotation continue sont des moteurs qui peuvent être utilisés pour contrôler la…