Un servomoteur est un moteur capable de rester en une position précise définit par l’utilisateur. Un servomoteur ne peut pas se déplacer à plus de 180 degrés. Enfin il exercer un couple plus au moins important à la position indiqué.
Toutes ses caractéristiques font de lui un très bon moteur pour des projets comme l’ouverture de porte, de vanne, ou bien la direction sur une voiture.
Néanmoins pour faire tourner les hélices d’un hélicoptère, tracter une voiture ou une dynamo il faut utiliser un moteur à courant continu.
Si vous cherchez un moteur qui garde sa position et qui tourne à 360 degrés, vous pouvez opter pour un moteur pas à pas.
Dans ce cours on verra comment contrôler le servomoteur de deux manières : un programme qui fait tourner le servomoteur de 0° à 180° puis revient à sa postion initiale et un programme qui permet de contrôler votre servomoteur par vous-même depuis le moniteur série.
Un servo moteur est composé de plusieurs éléments :
Le servomoteur se commande avec le Pulse width modulation (pwm) ayant une fréquence fixe de 50Hz (T=20ms) et la durée de l’état haut de ce signal détermine la position de l’axe du servomoteur.
Cela signifie que c’est la durée des impulsions qui détermine l’angle absolu de l’axe de sortie et donc la position du bras de commande du servomoteur.
Le signal est répété périodiquement, en général toutes les 20 millisecondes, ce qui permet à l’électronique de contrôler et de corriger continuellement la position angulaire de l’axe de sortie, cette dernière étant mesurée par le potentiomètre.
Un servomoteur fonctionne avec trois fils :
Néanmoins si vous avez besoin d’un servomoteur avec un couple plus important, vous pouvez opter pour des servomoteurs de 35 kg.
Le servomoteur fonctionne avec une librairie qui va vous permettre de simplier son utilisation.
Vous pouvez la télécharger et regarder notre cours sur les librairies pour l’installer.
Voici le circuit pour faire les projets que l’on va voir juste en dessous :
Voici le programme pour faire tourner votre servomoteur :
#include <Servo.h>
Servo monServomoteur; // On creer un objet servomoteur
int pos = 0; // variable pour stocker la position
void setup() {
monServomoteur.attach(9); // On attache le servomoteur a la broche 9
}
void loop() {
for (pos = 0; pos <= 180; pos += 1) { // boucle de 0 a 180 degrés
monServomoteur.write(pos); // On indique le servomoteur la position
delay(15); // On fait du 15 millisecondes
}
for (pos = 180; pos >= 0; pos -= 1) { // boucle de 180 a 0 degrés
monServomoteur.write(pos); // On indique le servomoteur la position
delay(15); // On fait du 15 millisecondes
}
}
Voici le programme pour contrôler un servomoteur depuis votre moniteur série :
#include <Servo.h>
Servo monServomoteur;
int position_question;
void setup(){
Serial.begin(9600);
monServomoteur.attach(9);
Serial.println("-------------------------");
Serial.println("Donnez la position du Servomoteur entre 0 et 180 : ");
}
void loop() {
if (Serial.available()) {
Serial.println("-------------------------");
Serial.print("Donnez la position du Servomoteur entre 0 et 180 : ");
position_question = Serial.parseInt();
Serial.println(position_question);
}
if (position_question < 0) {
Serial.println("La valeur est inferieur a 0 donc 0 sera retenu");
position_question=0;
}
if (position_question > 180) {
Serial.println("La valeur est superieur a 180 donc 180 sera retenu");
position_question=180;
}
monServomoteur.write(position_question);
}
Voici ce que l’on obtient sur le moniteur série :
On va maintenant voir comment contrôler un servomoteur avec un potentionmètre. Ce projet a beaucoup d’application possible, notamment pour contrôler un robot ou un bras mécanique ou bien même ouvrir une porte.
#include <Servo.h>
int Potentiometre; // Variable pour le composant potentiomètre
int Conversion;
Servo monServomoteur; // On creer un objet servomoteur
void setup() {
monServomoteur.attach(9); // On attache le servomoteur a la broche 9
}
void loop() {
Potentiometre = analogRead(A0); // On lit la valeur du potentiomètre
Conversion=map(Potentiometre,0,1023,180,0); // Permet d'obtenir la valeur entre 0° et 180° V.
monServomoteur.write(Conversion); // On indique le servomoteur la position
}
Le servomoteur fonctionne avec une librairie qui va vous permettre de simplier son utilisation.
Cette librairie inclue plusieurs fonctions qui vont vous être utile. Pour chaque fonction on vous donne le code correspondant dans la librairie si vous voulez le modifier ou l’intégrer directement à votre programme.
Voici le code correspondant à la fonction attach(pin) dans la librairie :
uint8_t Servo::attach(int pin, int min, int max)
{
if(this->servoIndex < MAX_SERVOS ) { // Si le nombre de servo est inférieur au nombre maximum de servo gérable (12)
pinMode( pin, OUTPUT) ; // On associe le servomoteur au pin de sortie
servos[this->servoIndex].Pin.nbr = pin;
this->min = (MIN_PULSE_WIDTH - min)/4; // On définit le minimum du servomoteur
this->max = (MAX_PULSE_WIDTH - max)/4; // On définit le maximum du servomoteur
// On initialise le timer
timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
if(isTimerActive(timer) == false)
initISR(timer);
servos[this->servoIndex].Pin.isActive = true; // On active le pin après le timer.
}
return this->servoIndex ;
}
Voici le code correspondant à la fonction write(angle) dans la librairie :
void Servo::write(int value)
{
if(value < MIN_PULSE_WIDTH)
{ // La valeur doit être inféieur à 544 degrés
if(value < 0) value = 0; // Si la valeur indiqué est inférieur à 0 on reste à 0.
if(value > 180) value = 180; // Si la valeur indiqué est supérieur à 180 degrés alors on reste à cette valeur
value = map(value, 0, 180, SERVO_MIN(), SERVO_MAX());
}
this->writeMicroseconds(value); // On écrit la valeur avec la fonction writeMicroseconds.
}
Voici le code correspondant à la fonction read(pin) dans la librairie :
int Servo::read() // retourne la postion du servomoteur actuel
{
return map( this->readMicroseconds()+1, SERVO_MIN(), SERVO_MAX(), 0, 180);
}
Voici le code correspondant à la fonction attached(pin) dans la librairie :
bool Servo::attached() // Retourne à quel pin est associé le servomoteur
{
return servos[this->servoIndex].Pin.isActive ;
}
Voici le code correspondant à la fonction writeMicroseconds dans la librairie :
void Servo::writeMicroseconds(int value)
{
// On créer une liaison entre le servomoteur et le programme
byte channel = this->servoIndex;
if( (channel < MAX_SERVOS) ) // ensure channel is valid
{
if( value < SERVO_MIN() ) // On vérifie que les valeurs entrées sont valide.
value = SERVO_MIN();
else if( value > SERVO_MAX() )
value = SERVO_MAX();
value = value - TRIM_DURATION; // On compense les interruptions
value = usToTicks(value);
uint8_t oldSREG = SREG;
cli();
servos[channel].ticks = value;
SREG = oldSREG;
}
}
Vous pouvez aussi contrôler votre servomoteur avec python. On a fait un cours pour cela.