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 position d'un servomoteur à partir du clavier PC.

ARDUINO - INITIATION - SERVO- PROCESSING- PC
Par X. HINAULT - Créé le 20/02/2010

Présentation

Ce programme positionne un servomoteur à l'aide du clavier du PC - 10 positions. Utilise une interface processing de visualisation côté PC. L'appui sur les touches HAUT/BAS incrémente/décrémente une variable dans Processing. La valeur (de 0 à 9) est envoyée vers l'Arduino

Lorsqu'un caractère est reçu, la position est calculée et le servomoteur est positionné. C'est un programme sommaire pour montrer le principe du contrôle de l'Arduino à partir du clavier du PC.

Ce programme utilise les fonctionnalités suivantes :

  • la connexion série vers le PC
  • un ou plusieurs servomoteurs

Matériel Nécessaire

L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

Le matériel suivant pour réaliser le montage associé

  • une plaque d'essai pour montage sans soudures,
  • des straps,
  • servomoteur

Instructions de montage

  • Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
  • Connecter sur la broche 2 (configurée en sortie) la broche de commande d'un servomoteur.
  • 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

Le schéma théorique du montage


Le schéma théorique du montage

Le circuit du montage


Le schéma du montage à réaliser

Explication du programme

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.

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

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 broche_servo=2; //declaration constante de broche
 

Déclaration des variables globales

  • Déclaration des variables globales du programmes : on déclare une variable pour la position du servomoteur et une variable pour stocker la caractère reçu par la liaison série.
// variable position du servomoteur en degré
int position_servo=0;

// variable de stockage des valeurs reçues
int OctetReception=0;

Déclarations des objets utiles pour les fonctionnalités utilisées

  • Déclaration des objets utiles pour les fonctionnalités utilisées :
    • Déclaration d'un objet servomoteur

Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur
 

Au niveau de la fonction d'initialisation setup( ) :

Initialisation des fonctionnalités utilisées :

  • On initialise les différentes fonctionnalités utilisées :
    • Initialisation de la communication série avec le PC

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
 
  • Initialisation du servomoteur

mon_servo.attach(broche_servo, POS_MIN, POS_MAX);  // attache l'objet servo à la broche de commande du servomoteur

(sourcend:)

!!!! configuration des broches utilisées :


* Configuration des broches en sortie :

(:source lang=arduino:)
pinMode(broche_servo, OUTPUT); //met la broche en sortie
  • Initialisation de la position initiale du servomoteur à 0° :
// ------- position initiale du servomoteur
mon_servo.write(position_servo);
delay(200);

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

  • A l'aide d'une condition, on teste si un caractère est reçu à l'aide de l'instruction available() de la librairie Serial. On mémorise ce caractère et on isole la valeur numérique à partir du nombre ASCII reçu :

if (Serial.available()>0) { // si un octet en réception

  OctetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable
  OctetReception=OctetReception-48; // isole valeur numerique 0-9 à partir valeur ASCII
 
  • Ensuite, rééchelonne la valeur 0-9 reçue pour une position en degré entre 0° et 180 à l'aide de l'instruction map() :

// calcule la nouvelle position
  position_servo=map(OctetReception,0,9,0,180);
 
  • Il ne reste plus alors qu'à positionner le servomoteur à l'aide de l'instruction write de la librairie servomoteur. On réalise un pause et on referme la condition.

//positionne le servomoteur
  mon_servo.write(position_servo);


  //entre chaque changement de position
  delay (200);

}// fin gestion octet en réception
 
  • Le programme recommence en boucle les instructions de la fonction loop( ). Le servomoteur prend la position en fonction de la valeur 0 à 9 reçue depuis le PC.

Se reporter aux commentaires présents dans le programme pour plus de détails.

Mise en oeuvre du programme

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

Fonctionnement

  • Côté PC, il faut lancer Processing et y copier/coller le programme en bas de page puis lancer l'exécution. L'appui sur les touches HAUT et BAS du clavier entraîne l'affichage sous forme d'un vumètre et l'envoi vers la carte Arduino d'une valeur comprise entre 0 et 9.
  • Le servomoteur prend la position en fonction de la valeur 0 à 9 reçue depuis le PC.

Le programme complet en langage Arduino :

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// par X. HINAULT - 02/2010
// www.mon-club-elec.fr

// --- Que fait ce programme ? ---
/* Positionne un servomoteur à l'aide du clavier du PC - 10 positions
Utilise une interface processing de visualisation côté PC.

L'appui sur les touches HAUT/BAS incrémente/décrémente une variable processing
La valeur (de 0 à 9) est envoyée vers l'Arduino

Lorsqu'un caractère est reçu,
la position est calculée et le servomoteur est positionné

*/


// --- Fonctionnalités utilisées ---
// Utilise la connexion série vers le PC
// Utilise les servomoteurs

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  
// Connecter  sur la broche 2 (configurée en sortie)  la broche de commande d'un servomoteur.  la broche de commande d'un servomoteur.
// Connecter les servomoteurs sur les broches de commandes utilisées

//**************** 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 broche_servo=2; //declaration constante de broche

// --- Déclaration des variables globales ---
// variable position du servomoteur en degré
int position_servo=0;

// variable de stockage des valeurs reçues
int OctetReception=0;

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
Servo mon_servo;  // 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 ---

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

mon_servo.attach(broche_servo, POS_MIN, POS_MAX);  // attache l'objet servo à la broche de commande du servomoteur

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

pinMode(broche_servo, OUTPUT); //met la broche en sortie

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


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

// ------- position initiale du servomoteur
mon_servo.write(position_servo);
delay(200);

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

if (Serial.available()>0) { // si un octet en réception

  OctetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable
  OctetReception=OctetReception-48; // isole valeur numerique 0-9 à partir valeur ASCII

  // calcule la nouvelle position
  position_servo=map(OctetReception,0,9,0,180);

  //positionne le servomoteur
  mon_servo.write(position_servo);


  //entre chaque changement de position
  delay (200);

}// fin gestion octet en réception

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

// --- Fin programme ---

 

Le programme Processing :

A copier/coller directement dans l'éditeur Processing sur le PC


// programme Processing
// par X. HINAULT - 02/2010
// www.mon-club-elec.fr

// Interface Vumètre réglable par clavier HAUT/BAS et envoi série vers arduino valeur 0-9

// inclusion librairies utilisées
import processing.serial.*; // importe la librairie série processing


// déclaration variables

//--- variables utiles tracé vumètre

float Y_ref=220; // ordonnée de ligne de référence dessin rectangle

float largeur=50;
float hauteur=180; //180 représente 100% (0 à 9 = 10 positions)

int SendValue=0; // valeur envoyée à Arduino
float niveau=0.0; // 0% au départ

Serial MySerialPort; // variable désignant le port série


void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

  size(100,250); //dimensionne la fenêtre processing à 200x200 (largeur x hauteur) // 1ère instruction de Setup
  // si Size() oublié => fenêtre 100x100 par défaut --

  //---- initialisation port série ---

  println(Serial.list()); // liste et affiche tous les ports disponibles

  // Open whatever port is the one you're using.
   MySerialPort = new Serial(this, Serial.list()[1], 115200); // vérifier si c'est le bon port qui est utilisé
   delay (100); // pause  

  background (255,255,255); // fixe la couleur du fond - format RGB
  stroke(255,0,0); // fixe la couleur du trait de dessin et bordure - format RGB
  //nostroke(); // Désactive trait de dessin et bordure

  // dessin des 2 rectangles du niveau de démmarrage (=50%)
  stroke (0); // trait de contour
  fill(255,255,255); // remplissage
  rect (10,Y_ref-hauteur,largeur, hauteur); // trace un rectangle de hauteur voulue
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

  stroke (255,0,0); // trait de contour
  fill(255,0,0); // remplissage rouge
  rect (10,Y_ref-niveau,largeur, niveau); // trace un rectangle de hauteur voulue
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

  //----- initialisation valeur série ----
  MySerialPort.write(48);   // valeur initiale 0+ 48 pour format ASCII
  delay (100); // pause  
}

void  draw() { // fonction exécutée en boucle

  //--- nb : la vitesse de rafraîchissement de l'écran est de 60 par seconde apr défaut  - cf frameRate()

}

// fonction de gestion des évènements

//----- clavier --------

 void keyPressed() {// cette fonction est exécutée quand un touche est appuyée...

if (key == CODED) { // si appui d'une touche particulière (les touches spéciales up, down, etc.. cf Keycode)

    if (keyCode == UP) { // si touche Haut appuyée

      niveau=niveau+(hauteur/9); // /9 pour avoir 10 niveaux
      if (niveau>=hauteur)niveau=hauteur; // ne pas dépasser hauteur

      SendValue=SendValue+1; // incrémente SendValue
      if (SendValue >=9) SendValue=9; // Empêche débordement variable SendValue

      MySerialPort.write(SendValue+48);   // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
      delay (100); // pause  
    }
    else if (keyCode == DOWN) {// si touche BAS appuyée

    niveau=niveau-(hauteur/9); // /9 pour avoir 10 niveaux
    if (niveau<=0)niveau=0; // ne pas dépasser 0

     SendValue=SendValue-1; // décrémente SendValue
      if (SendValue<=0) SendValue=0;// ne pas dépasser 0

      MySerialPort.write(SendValue+48);   // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
      delay (100); // pause  

    }

} // fin if key==coded

// dessin des 2 rectangles du niveau
  stroke(0); // contour noir
  fill(255,255,255); // remplissage blanc
  rect (10,Y_ref-hauteur,largeur, hauteur); // trace un rectangle de hauteur voulue
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

   stroke(255,0,0); // contour rouge
  fill(255,0,0); // remplissage rouge
  rect (10,Y_ref-niveau,largeur, niveau); // trace un rectangle de hauteur voulue
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

}

//------- souris -------
//void mousePressed() { // est appelée à chaque fois qu'un bouton de la souris est appuyé

//  }

//------- gestion du port Série ------

 //void serialEvent (Serial myPort) {



 // }  // fin gestion port série