Qu'est ce qu'un servomoteur ? Comment s'en servir ? Comment le choisir ?

Introduction

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.

Comment fonctionne t-il ?

Un servo moteur est composé de plusieurs éléments :

  • Un moteur à courant continu de petite taille
  • Un réducteur qui va réduire la vitesse du moteur à courant continu mais augmenter le couple afin d’avoir plus de force pour garder la position.
  • Un potentiomètre générant en tension variable, proportionnelle à l’angle de l’axe de sortie

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 :

  • Un fils rouge : l’alimentation entre (3,5V et 5V)
  • Un fils noir : la masse (0V).
  • Le fils jaune : l’entrée du signal.

Lequel choisir ?

Si vous voulez l’utiliser pour faire de l’arduino alors nous vous conseillons le MG995 ou bien le SG90. Ces deux servomoteurs ont des tailles minimes et un couple de 25 kg, ce qui en font des servomoteur idéal pour l’arduino.

Néanmoins si vous avez besoin d’un servomoteur avec un couple plus important, vous pouvez opter pour des servomoteurs de 35 kg.

La librairie Servomoteur

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.

Contrôler votre servomoteur

Voici le circuit pour faire les projets que l’on va voir juste en dessous :

A) Faire tourner le servomoteur de 0° à 180° puis 180° à 0°

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

B) Contrôler le servomoteur depuis le moniteur série

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 :

Contrôler votre servomoteur avec un potentiomètre

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
}

Comment se passer de la librairie ?

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.

  • attach(pin) : permet d’associer le servomoteur au pin de la carte arduino auquel il est branché

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 ;
}
  • write(angle) : indique au servomoteur l’angle à laquelle il doit se déplacer.

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.
}
  • read(pin) : permet d’indiquer l’angle à laquelle le servomoteur est placé.

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);
}
  • attached(pin) : Permet de savoir à quel pin le  servomoteur  est attaché

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 ;
}
  • writeMicroseconds : Permet d’ajuster les positions extrême.

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

Pour aller plus loin : Contrôler votre composant avec Python

 

Vous pouvez aussi contrôler votre servomoteur avec python. On a fait un cours pour cela.