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 |

Contrôle de 3 servomoteurs à l'aide de 3 résistances variables.

ARDUINO - EXPERT - CAN - SERVO
Par X. HINAULT - Créé le 28/02/2010

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.

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