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ôler la rotation de 2 servomoteurs (tourelle pan/tilt) à l'aide d'un shield Joystick

Par X. HINAULT - Page créée le : 22/5/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

  • Deux servomoteurs connectés à la carte Arduino sont contrôlés à l'aide d'un shield Joystick (DFRobot).
  • L'appui sur un bouton poussoir permet la réinitialisation de la position médiane de chaque servomoteur.
  • On pourra ainsi contrôler une tourelle dite "pan/tilt" (pan - axe panoramique et tilt - inclinaison) permettant de contrôler la position d'un capteur de distance, une webcam, etc...

Ce programme utilise les fonctionnalités suivantes :

Ressources utiles associées à ce programme :

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é

3.  Instructions de montage

  • 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

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Explication du programme

  • Une mesure analogique permet de tester la position de chaque axe du Joystick.
  • En fonction de cette position, on incrémente/décrémente une variable correspondant à l'angle du servomoteur contrôlé par cet axe
  • Le servomoteur est positionné dans la position voulue
  • Si un appui a lieu sur le BP rouge ou bleu de la carte Joystick, le servomoteur correspondant est positionné à 90°, ce qui correspond à sa position médiane.

7.  Mise en oeuvre du programme

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

7.2  Fonctionnement

  • Le servomoteur "pan" se positionne en fonction de la position du Joystick de l'axe 1.
  • Le servomoteur "tilt" se positionne en fonction de la position du Joystick de l'axe 2.
  • L'appui sur les BP rouge/bleu réinitialise la position de chaque servomoteur.

8.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 15/5/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Un servomoteur connecté à la carte Arduino est contrôlé
à l'aide d'un shield Joystick (DFRobot).
L'appui sur un bouton poussoir permet la réinitialisation
de la position du servomoteur.  */


// --- Fonctionnalités utilisées ---

// Utilise la conversion analogique numérique 10 bits
// Utilise la carte d'extension Arduino (shield) Joystick + BP x 2
// Utilise un servomoteur

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

// ******* ATTENTION : il est possible de connecter directement 2 ou 3 servomoteurs sur la carte Arduino
// Connecter un servomoteur sur la broche 8
// Connecter un servomoteur dur la brche 9
// Enficher la carte d'extension Arduino (shield) Joystick + BP x 2 broche à broche sur la carte EasyCard
// Enficher la carte EasyCard broche à broche sur la carte Arduino
// les connexions sont réalisées broche à broche entre le module et la carte Arduino


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

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

// --- Inclusion des librairies ---

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

// --- Déclaration des constantes utiles ---
const int APPUI=LOW; // constante pour tester état BP

//--- Constantes utilisées avec le servomoteur
const int ANGLE_MIN=0; // angle position MIN en degrés
const int POS_MIN=550; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur
                  // par exemple POS_MIN=600 pour ANGLE_MIN=10° avec un futaba S3003
                  // ou POS_MIN=550 pour ANGLE_MIN=0 avec un futaba S3003

const int ANGLE_MAX=172; // angle position MAX en degrés
int POS_MAX=2400; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur
                  // POS_MAS=2300 pour ANGLE_MIN=170° pour futaba s3003
                  // ou POS_MAX=2400 pour ANGLE_MAX=172 pour futaba S3003

// pour étalonner un servomoteur, voir la page :
//http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieDepuisPCPositionServomoteur

// --- Déclaration des constantes des broches E/S numériques ---

const int bpRouge=3; // Constante pour la broche 3
const int bpBleu=4; // Constante pour la broche 4
const int bpJoystick=5; // Constante pour la broche 5

const int broche_servoPan=8; // Constante pour la broche 8
const int broche_servoTilt=9; // Constante pour la broche 8

// --- Déclaration des constantes des broches analogiques ---

const int axe1Joystick=0; // Constante pour la broche analogique 0
const int axe2Joystick=1; // Constante pour la broche analogique 1

// --- 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 positionAxe1=0; // Variable pour acquisition résultat brut de conversion analogique numérique axe 1 Joystick
int positionAxe2=0; // Variable pour acquisition résultat brut de conversion analogique numérique axe 2 Joystick

int angleServoPan=90; // variable de position du servo  Pan en degrés
int angleServoTilt=90; // variable de position du servo  Tilt en degrés

int angleServoPan0=90; // variable de la dernière position du servo  Pan en degrés
int angleServoTilt0=90; // variable de la dernière position du servo  Tilt en degrés

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

//--- Création objet servomoteur
Servo mon_servoPan;  // crée un objet servo pour contrôler le servomoteur 1
Servo mon_servoTilt;  // crée un objet servo pour contrôler le servomoteur 2


// ////////////////////////// 2. 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 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

//--- Initialisation Servomoteur
mon_servoPan.attach(broche_servoPan);  // attache l'objet servo à la broche de commande du servomoteur Pan
mon_servoTilt.attach(broche_servoTilt);  // attache l'objet servo à la broche de commande du servomoteur Tilt


// ------- Broches en sorties numériques -------  
 pinMode (broche_servoPan,OUTPUT); // Broche broche_servoPan configurée en sortie
 pinMode (broche_servoTilt,OUTPUT); // Broche broche_servoPan configurée en sortie

// ------- Broches en entrées numériques -------  
 pinMode (bpRouge,INPUT); // Broche bpRouge configurée en entrée
 pinMode (bpBleu,INPUT); // Broche bpBleu configurée en entrée
 pinMode (bpJoystick,INPUT); // Broche bpJoystick configurée en entrée

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// Les BP du shield Joystick + BPx2 dispose d'un rappel au plus sur le shield


// ------- Initialisation des variables utilisées -------  

// ------- Codes d'initialisation utile -------  

mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle - plus précis que write()
mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle - plus précis que write()

delay(200);

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. 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()


//----- lecture position Joytstick
positionAxe1=analogRead(axe1Joystick); // acquisition conversion analogique numérique sur broche analogique axe 1
positionAxe2=analogRead(axe2Joystick); // acquisition conversion analogique numérique sur broche analogique axe 2

if (positionAxe1>700) {
   angleServoPan=angleServoPan+1;
   constrain(angleServoPan,ANGLE_MIN,ANGLE_MAX);
}

if (positionAxe1<300) {
   angleServoPan=angleServoPan-1;
   constrain(angleServoPan,ANGLE_MIN,ANGLE_MAX);
}

if (positionAxe2>700) {
   angleServoTilt=angleServoTilt+1;
   constrain(angleServoTilt,ANGLE_MIN,ANGLE_MAX);
}

if (positionAxe2<300) {
   angleServoTilt=angleServoTilt-1;
  constrain(angleServoTilt,ANGLE_MIN,ANGLE_MAX);  
}

//---- lecture état des BP du shield Joystick
if (digitalRead(bpRouge)==APPUI) { // si appui BP rouge

    angleServoTilt=90; // réinitialise angle Tilt

}

if (digitalRead(bpBleu)==APPUI) { // si appui BP

    angleServoPan=90; // réinitialise angle PAN
}

if (digitalRead(bpJoystick)==APPUI) { // si appui BP joystick

}

//------------- mise à jour de la position du servomoteur ---


    if (angleServoPan!=angleServoPan0) {
      mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle - plus précis que write()
      angleServoPan0=angleServoPan; // mémorise dernière valeur angle prise en compte
    }


    if (angleServoTilt!=angleServoTilt0) { // si angleServoTilt a changé
      mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle - plus précis que write()
      angleServoTilt0=angleServoTilt; // mémorise dernière valeur angle prise en compte
    }


   delay(6); // fixe la vitesse de mouvement du servo - entre 2 lecture analogique

//while(1); // stop loop

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


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

//------------- fonction calibrage impulsion servomoteur à partir valeur angle en degrés

int angle(int valeur_angle) {

        int impuls=0;
        impuls=map(valeur_angle,ANGLE_MIN,ANGLE_MAX,POS_MIN, POS_MAX);
        return impuls;  

} // fin fonction impulsion servomoteur

// ////////////////////////// Fin du programme ////////////////////