Le contrôle de servomoteurs est une tâche complexe qui nécessite une précision et une prévisibilité élevées. Cependant, en utilisant des résistances variables, il est possible de contrôler plusieurs servomoteurs avec une précision et une prévisibilité accrues. Dans cet article, nous allons examiner comment contrôler trois servomoteurs à l’aide de trois résistances variables. Nous verrons comment cette méthode peut être utilisée pour améliorer la précision et la prévisibilité des servomoteurs et comment elle peut être appliquée à des applications industrielles.
Contrôle de 3 servomoteurs à l’aide de 3 résistances variables.



1. Présentation
Ce programme contrôler 3 servomoteurs à l’aide de 3 résistances variables. Ceci peut être utile pour fabriquer par exemple un bras articulé contrôlé par 3 potentiomètres.
Le point essentiel ici est l’alimentation des servomoteurs qui doit être externe à la carte Arduino : voir cette page pour plus de détails.
Ce programme utilise les fonctionnalités suivantes :
- la conversion analogique numérique 10bits sur les voies analogiques analog 0, analog 1, analog 2,
- 3 servomoteurs
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,

- 3 résistances variables linéaires de 10 KOhms,



- 3 servomoteurs



3. Instructions de montage
- Connecter sur la broche 2 (configurée en sortie) broche de commande du servomoteur 0 alimenté par alim externe
- Connecter sur la broche 3 (configurée en sortie) broche de commande du servomoteur 1 alimenté par alim externe
- Connecter sur la broche 4 (configurée en sortie) broche de commande du servomoteur 2 alimenté par alim externe
- Dans le cas d’une carte Arduino :
- l’intensité maximale disponible sur une broche est de 40mA
- l’intensité maximale cumulée pour l’ensemble des broches est 200mA
- l’instensité maximale que peut fournir l’alimentation 5V de la carte est 500mA.
- Par conséquent, avec une carte Arduino :
- En ce qui concerne la ligne de commande du servomoteur par la carte Arduino :
- on pourra commander directement autant de servomoteur que l’on veut (broche de commande) avec une carte Arduino, le nombre maximal étant 200mA / I commande, soit 100 environ dans le cas du Futaba S3003, ce qui est largement supérieur au nombre de broches de la carte.
- Il n’y aura par ailleurs pas besoin d’amplification (type ULN 2803) sur la ligne de commande du servomoteur même si l’on utilise un grand nombre de servomoteurs.
- En ce qui concerne l’alimentation principale des servomoteurs par une carte Arduino
- on ne peut alimenter que 3 à 4 servomoteurs simultanément par l’alimentation 5V de la carte Arduino, le nombre maximal étant 500mA / I fonctionnement = 500 / 120 = 4 servomoteurs dans le cas du Futaba S3003.
- Une alimentation externe sera indispensable dès que l’on dépassera ce nombre pour ne pas risquer de « griller » la carte Arduino.
- En ce qui concerne la ligne de commande du servomoteur par la carte Arduino :
Pour plus de détails, voir : Principes d’utilisation des alimentations avec une carte Arduino et des servomoteurs
- Broche Analog 0 (=broche 14) en entrée Analogique
- Broche Analog 1 (=broche 15) en entrée Analogique
- Broche Analog 2 (=broche 16) en entrée Analogique
4. Le schéma théorique du montage
Le point essentiel ici est l’alimentation des servomoteurs qui doit être externe à la carte Arduino :

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 :
Inclusion des librairies utilisées
- On inclut les librairies des fonctionnalités utilisées :
- Inclusion de la librairie pour les servomoteurs :
#include <Servo.h> // librairie pour servomoteur
Déclaration de constantes utiles
- On déclare les constantes utiles dans le programme :
- Déclaration des constantes utiles pour les servomoteurs :
const int POS_MIN=550; // largeur impulsion pour position 0° servomoteur // POS_MIN=550 pour futaba S3003 const int POS_MAX=2330; // largeur impulsion pour position 180° servomoteur // POS_MAS=2330 pour futaba s3003
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme :
const int SERVO_0=2; //declaration constante de broche const int SERVO_1=3; //declaration constante de broche const int SERVO_2=4; //declaration constante de broche const int Voie_0=0; //declaration constante de broche analogique const int Voie_1=1; //declaration constante de broche analogique const int Voie_2=2; //declaration constante de broche analogique
Déclaration des variables globales
- Déclaration des variables globales du programmes :
- 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 positionnement des servomoteurs
int angle_servo_0=0; // variable pour angle du servomoteur int angle_servo_1=0; // variable pour angle du servomoteur int angle_servo_2=0; // variable pour angle du servomoteur
Déclarations des objets utiles pour les fonctionnalités utilisées
- Déclaration des objets utiles pour les fonctionnalités utilisées :
- Déclaration de 3 objets servomoteurs
Servo mon_servo_0; // crée un objet servo pour contrôler le servomoteur Servo mon_servo_1; // crée un objet servo pour contrôler le servomoteur Servo mon_servo_2; // crée un objet servo pour contrôler le servomoteur
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 du servomoteur
mon_servo_0.attach(SERVO_0, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur mon_servo_1.attach(SERVO_1, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur mon_servo_2.attach(SERVO_2, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur
configuration des broches utilisées :
- Configuration des broches en sortie :
pinMode(SERVO_0, OUTPUT); //met la broche en sortie pinMode(SERVO_1, OUTPUT); //met la broche en sortie pinMode(SERVO_2, OUTPUT); //met la broche en sortie
@]
9. Au niveau de la boucle principale, la fonction loop ( ) :
- Pour chaque servomoteur :
- on commence par lire la valeur de la tension sur la broche analogique de commande à l’aide de l’instruction analogRead()
- on transpose la valeur en degrés à l’aide de l’instruction map()
- on positionne le servomoteur à l’aide de l’instruction write()
//========== SERVO_0 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_0); angle_servo_0=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_0.write(angle_servo_0); // positionne le servo à l'angle voulu //========== SERVO_1 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_1); angle_servo_1=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_1.write(angle_servo_1); // positionne le servo à l'angle voulu //========== SERVO_2 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_2); angle_servo_2=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_2.write(angle_servo_2); // positionne le servo à l'angle voulu
- 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. 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
- En faisant varier les résistances, on obtient un positionnement linéaire des servomoteurs.
11. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// --- Programme Arduino --- // par X. HINAULT - Le 28/02/2010 // www.mon-club-elec.fr // --- Que fait ce programme ? --- /* contrôler 3 servomoteurs à l'aide de 3 résistances variables*/ // --- Fonctionnalités utilisées --- // Utilise la conversion analogique numérique 10bits sur les voies analogiques analog 0, analog 1, analog 2, // Utilise les servomoteurs // --- Circuit à réaliser --- // Connecter sur la broche 2 (configurée en sortie) broche de commande du servomoteur 0 alimenté par alim externe // Connecter sur la broche 3 (configurée en sortie) broche de commande du servomoteur 1 alimenté par alim externe // Connecter sur la broche 4 (configurée en sortie) broche de commande du servomoteur 2 alimenté par alim externe // Broche Analog 0 (=broche 14) en entrée Analogique // Broche Analog 1 (=broche 15) en entrée Analogique // Broche Analog 2 (=broche 16) en entrée Analogique // IMPORTANT : IL EST IMPERATIF D'UTILISER UNE ALIMENTATION EXTERNE DE 6V POUR ALIMENTER LES SERVOMOTEURS //**************** Entête déclarative ******* // A ce niveau sont déclarées les librairies, les constantes, les variables... // --- Inclusion des librairies utilisées --- #include <Servo.h> // librairie pour servomoteur // --- Déclaration des constantes --- const int POS_MIN=550; // largeur impulsion pour position 0° servomoteur // POS_MIN=550 pour futaba S3003 const int POS_MAX=2330; // largeur impulsion pour position 180° servomoteur // POS_MAS=2330 pour futaba s3003 // --- constantes des broches --- const int SERVO_0=2; //declaration constante de broche const int SERVO_1=3; //declaration constante de broche const int SERVO_2=4; //declaration constante de broche const int Voie_0=0; //declaration constante de broche analogique const int Voie_1=1; //declaration constante de broche analogique const int Voie_2=2; //declaration constante de broche analogique // --- Déclaration des variables globales --- 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 int angle_servo_0=0; // variable pour angle du servomoteur int angle_servo_1=0; // variable pour angle du servomoteur int angle_servo_2=0; // variable pour angle du servomoteur // --- Déclaration des objets utiles pour les fonctionnalités utilisées --- Servo mon_servo_0; // crée un objet servo pour contrôler le servomoteur Servo mon_servo_1; // crée un objet servo pour contrôler le servomoteur Servo mon_servo_2; // crée un objet servo pour contrôler le servomoteur //**************** 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 --- mon_servo_0.attach(SERVO_0, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur mon_servo_1.attach(SERVO_1, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur mon_servo_2.attach(SERVO_2, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur // ------- Broches en sortie ------- pinMode(SERVO_0, OUTPUT); //met la broche en sortie pinMode(SERVO_1, OUTPUT); //met la broche en sortie pinMode(SERVO_2, OUTPUT); //met la broche 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 --- //========== SERVO_0 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_0); angle_servo_0=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_0.write(angle_servo_0); // positionne le servo à l'angle voulu //========== SERVO_1 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_1); angle_servo_1=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_1.write(angle_servo_1); // positionne le servo à l'angle voulu //========== SERVO_2 =============== // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée - résultat 10bits (0-1023) mesure_brute=analogRead(Voie_2); angle_servo_2=map(mesure_brute,0,1023,0,180); // convertit la valeur mesurée comprise entre 0 et 1023 en un angle entre 0 et 180 // map(value, fromLow, fromHigh, toLow, toHigh); // permet changement d'échelle simplifié mon_servo_2.write(angle_servo_2); // positionne le servo à l'angle voulu } // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin // ******************************************************************************** //*************** Autres Fonctions du programme ************* // --- Fin programme ---
Articles similaires:
- Positionner un servomoteur à l’aide d’une résistance variable
- Controler la rotation un servomoteur à l’aide d’un shield Joystick
- Test simple d’un servomoteur à rotation continue : contrôle de la vitesse et du sens de rotation à l’aide d’une résistance variable.
- Contrôler la rotation de 2 servomoteurs (tourelle pan/tilt) à l’aide d’un shield Joystick
- « Radar » de distance à capteur GP2D12 monté sur servomoteur et affichage sur écran couleur S65
Articles Liés
- Positionner un servomoteur à l'aide d'une résistance variable
Le servomoteur est un moteur électrique qui peut être utilisé pour contrôler la position d'un…