Le contrôle de la position d’un servomoteur à partir du clavier d’un ordinateur est une tâche qui peut s’avérer très utile dans de nombreuses applications. En effet, cette méthode permet de contrôler facilement et précisément la position d’un servomoteur à partir d’un clavier PC, ce qui peut être très pratique pour les applications industrielles et robotiques. Dans cet article, nous allons examiner les différentes méthodes qui peuvent être utilisées pour contrôler la position d’un servomoteur à partir du clavier d’un ordinateur.
Contrôler la position d’un servomoteur à partir du clavier PC.
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.
- 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
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 :
Déclaration de constantes utiles
- On déclare les constantes utiles dans le programme :
- Déclaration des constantes utiles pour les servomoteurs :
// 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 :
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.
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
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
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
-
- Initialisation 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° :
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 :
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() :
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.
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
// 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
// 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 à 200×200 (largeur x hauteur) // 1ère instruction de Setup
// si Size() oublié => fenêtre 100×100 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
