Maîtriser le Contrôle des Moteurs Servo avec Arduino : Guide Étape par Étape

Introduction

Dans ce tutoriel, nous allons apprendre comment fonctionnent les moteurs servo et comment les contrôler avec Arduino. Les servomoteurs sont très populaires et largement utilisés dans de nombreux projets Arduino car ils sont faciles à utiliser et offrent un excellent contrôle de position.

Les servos sont un excellent choix pour les projets de robotique, d'automatisation, de modélisme RC, etc. Je les ai déjà utilisés dans plusieurs de mes projets Arduino que vous pouvez consulter ici :

• Bras Robot Arduino DIY avec Contrôle par Smartphone
• Robot Hexapode Fourmi Arduino
• Aérorafle RC DIY basée sur Arduino
• Robot SCARA | Comment Construire Votre Propre Robot Basé sur Arduino
• Réplique du Rover Mars Perseverance DIY – Projet basé sur Arduino

Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous. Il inclut plusieurs exemples d'utilisation d'un servomoteur avec Arduino, schémas de câblage et codes. En bonus, un guide pour contrôler plusieurs servomoteurs avec Arduino en utilisant le pilote PWM PCA9685.

Qu'est-ce qu'un Servomoteur ?

Un servomoteur est un système en boucle fermée qui utilise un retour de position pour contrôler son mouvement et sa position finale. Il existe de nombreux types de servomoteurs et leur caractéristique principale est la capacité de contrôler précisément la position de leur arbre.

Dans les servomoteurs industriels, le capteur de retour de position est généralement un encodeur de haute précision, tandis que dans les petits servos RC ou de modélisme, le capteur de position est généralement un simple potentiomètre. La position réelle captée par ces dispositifs est renvoyée au détecteur d'erreur où elle est comparée à la position cible. Ensuite, selon l'erreur, le contrôleur corrige la position réelle du moteur pour qu'elle corresponde à la position cible.

Dans ce tutoriel, nous examinerons en détail les servomoteurs de modélisme. Nous expliquerons comment ils fonctionnent et comment les contrôler avec Arduino.

Les servos de modélisme sont de petits actionneurs utilisés pour contrôler les voitures, bateaux, avions RC, etc. Ils sont aussi utilisés par les étudiants en ingénierie pour le prototypage en robotique, la création de bras robotiques, de robots bio-inspirés, de robots humanoïdes, etc.

Comment Fonctionnent les Servomoteurs ?

Il y a quatre composants principaux à l'intérieur d'un servo de modélisme : un moteur DC, un réducteur, un potentiomètre et un circuit de contrôle. Le moteur DC est à haute vitesse et faible couple, mais le réducteur réduit la vitesse à environ 60 tr/min tout en augmentant le couple.

Le potentiomètre est fixé sur l'engrenage final ou l'arbre de sortie, donc quand le moteur tourne, le potentiomètre tourne aussi, produisant une tension liée à l'angle absolu de l'arbre de sortie. Dans le circuit de contrôle, cette tension du potentiomètre est comparée à la tension provenant de la ligne de signal. Si nécessaire, le contrôleur active un pont en H intégré qui permet au moteur de tourner dans un sens ou dans l'autre jusqu'à ce que les deux signaux atteignent une différence nulle.

Un servomoteur est contrôlé en envoyant une série d'impulsions sur la ligne de signal. La fréquence du signal de contrôle doit être de 50 Hz, soit une impulsion toutes les 20 ms. La largeur de l'impulsion détermine la position angulaire du servo, et ces types de servos peuvent généralement tourner de 180 degrés (ils ont des limites physiques de course).

Généralement, des impulsions de 1 ms correspondent à 0 degré, 1,5 ms à 90 degrés et 2 ms à 180 degrés. Bien que les durées minimales et maximales des impulsions puissent varier selon les marques : 0,5 ms pour 0 degré et 2,5 ms pour 180 degrés.

Servos RC / Modélisme Populaires pour Projets Arduino

Il existe de nombreux modèles et fabricants de servos RC ou de modélisme. Les principaux critères de choix sont le couple, la tension d'alimentation, la consommation de courant et la taille.

Voici les deux modèles les plus populaires parmi les makers : le SG90 Micro Servo et le MG996R.

Spécifications Techniques du SG90 Micro Servo

Spécifications Techniques du MG996R

Contrôle de Servomoteur avec Arduino

Mettons en pratique ce qui précède avec un exemple concret de contrôle d'un servo de modélisme avec Arduino. J'utiliserai le MG996R, un servo à haut couple avec engrenages métalliques et un couple d'arrêt de 10 kg-cm. Ce couple élevé a un coût : le courant d'arrêt de 2,5 A. Le courant de fonctionnement varie de 500 à 900 mA et la tension d'alimentation de 4,8 à 7,2 V.

Ces valeurs de courant indiquent qu'on ne peut pas connecter directement ce servo à l'Arduino, il faut une alimentation séparée.

Schéma de Câblage

Voici le schéma de câblage pour cet exemple.

Il suffit de connecter la broche de contrôle du servo à n'importe quelle broche numérique de l'Arduino, la masse et le fil positif à l'alimentation externe 5V, et de relier la masse de l'Arduino à celle du servo.

Si on utilise un servo plus petit comme le S90 Micro Servo, il est possible de l'alimenter directement depuis la broche 5V de l'Arduino.

Le S90 Micro Servo a une consommation plus faible, environ 100-200 mA à vide, mais 500-700 mA en arrêt. La broche 5V de l'Arduino peut fournir environ 500 mA si alimenté via USB, ou jusqu'à 1 A via le connecteur jack.

Même si c'est possible de faire fonctionner ces servos 9g directement sur l'Arduino, pour un fonctionnement plus stable, je recommande d'utiliser toujours une alimentation externe pour eux.

Composants Nécessaires

• Servomoteur MG996R
• ou Servo S90 Micro Servo
• Carte Arduino
• Alimentation 5V 2A DC

Code Arduino pour Contrôle de Servomoteur

Regardons le code Arduino pour contrôler le servomoteur. Le code est très simple. Il faut juste définir la broche du servo, la définir comme sortie, et dans la boucle générer des impulsions avec la durée et la fréquence spécifiques expliquées plus haut.

/* Contrôle Servomoteur - Générateur d'impulsions 50Hz par Dejan, https://howtomechatronics.com */
#define servoPin 9

void setup() {
  pinMode(servoPin, OUTPUT);
}

void loop() {
  // Une impulsion toutes les 20ms
  digitalWrite(servoPin, HIGH);
  delayMicroseconds(1450); // Durée de l'impulsion en microsecondes
  digitalWrite(servoPin, LOW);
  delayMicroseconds(18550); // 20ms - durée de l'impulsion
  // Durées d'impulsion : 600 - 0°; 1450 - 90°; 2300 - 180°
}

Après quelques tests, j'ai obtenu les valeurs suivantes pour les durées d'impulsion qui fonctionnent avec mon servo : 0,6 ms pour 0°, 1,45 ms pour 90° et 2,3 ms pour 180°.

J'ai connecté un multimètre en série avec le servo pour vérifier la consommation. Le courant maximum observé était de 0,63 A à l'arrêt. C'est parce que ce n'est pas le MG996R original TowerPro, mais une réplique moins chère aux performances inférieures.

Regardons maintenant une méthode plus pratique pour contrôler les servos avec Arduino : la bibliothèque Servo d'Arduino.

/* Contrôle Servomoteur avec la bibliothèque Arduino Servo par Dejan, https://howtomechatronics.com */
#include <Servo.h>
Servo myservo; // Crée un objet servo

void setup() {
  myservo.attach(9, 600, 2300); // (broche, min, max en microsecondes)
}

void loop() {
  myservo.write(0);  // Positionne le servo à 0°
  delay(1000);
  myservo.write(90); // Positionne à 90°
  delay(500);
  myservo.write(135); // Positionne à 135°
  delay(500);
  myservo.write(180); // Positionne à 180°
  delay(1500);
}

Il suffit d'inclure la bibliothèque, de définir l'objet servo, et avec la fonction attach() de définir la broche ainsi que les valeurs minimales et maximales des durées d'impulsion. Ensuite, avec write(), on définit simplement la position du servo de 0 à 180 degrés.

Contrôler Plusieurs Servomoteurs avec Arduino

La bibliothèque Servo d'Arduino permet de contrôler jusqu'à 12 servos simultanément avec la plupart des cartes Arduino, et 48 servos avec l'Arduino Mega. Contrôler plusieurs servos est aussi simple qu'en contrôler un seul.

Voici un exemple de code pour contrôler plusieurs servos :

/* Contrôle de plusieurs servomoteurs avec Arduino par Dejan, https://howtomechatronics.com */
#include <Servo.h>

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;

void setup() {
  servo1.attach(8);
  servo2.attach(9);
  servo3.attach(10);
  servo4.attach(11);
  servo5.attach(12);
}

void loop() {
  // Position 0 pour tous
  servo1.write(0);
  servo2.write(0);
  servo3.write(0);
  servo4.write(0);
  servo5.write(0);
  delay(2000);
  
  // Position 90 pour tous
  servo1.write(90);
  servo2.write(90);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  delay(2000);
  
  // Position 180 pour tous
  servo1.write(180);
  servo2.write(180);
  servo3.write(180);
  servo4.write(180);
  servo5.write(180);
  delay(2000);
}

Il suffit de créer des objets de la classe Servo pour chaque moteur et de définir à quelle broche Arduino chacun est connecté. Bien sûr, on peut positionner n'importe quel servo à n'importe quel angle, à tout moment.

En exemple, vous pouvez consulter mon projet Robot Hexapode Fourmi Arduino où j'ai utilisé une carte Arduino MEGA pour contrôler 22 servomoteurs.

Arduino et Pilote PWM/Servo PCA9685

Il existe une autre façon de contrôler des servos avec Arduino : utiliser le pilote de servos PCA9685. C'est un pilote PWM 16 canaux 12 bits qui communique avec Arduino via le bus I2C. Il possède une horloge intégrée pour piloter 16 servos de manière autonome, indépendamment de l'Arduino.

Ce qui est encore plus intéressant, on peut chaîner jusqu'à 62 de ces pilotes sur un seul bus I2C. Théoriquement, on peut contrôler jusqu'à 992 servos en utilisant seulement les deux broches I2C de l'Arduino. Les 6 broches de sélection d'adresse servent à définir des adresses I2C différentes pour chaque pilote supplémentaire. Il suffit de souder les pads selon ce tableau.

Voici le schéma de câblage, on remarque encore qu'une alimentation séparée est nécessaire pour les servos.

Composants Nécessaires

• Servomoteur MG996R
• Pilote PWM Servo PCA9685
• Carte Arduino
• Alimentation 5V 6A DC

Code Arduino et PCA9685

Pour contrôler ce pilote, nous utiliserons la bibliothèque PCA9685 disponible sur GitHub.

/* Contrôle Servomoteur avec Arduino et PCA9685 par Dejan, https://howtomechatronics.com
   Bibliothèque : https://github.com/NachtRaveVL/PCA9685-Arduino */
#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;
// Sorties PCA9685 = 12-bit = 4096 pas
// 2,5% de 20ms = 0,5ms ; 12,5% de 20ms = 2,5ms
// 2,5% de 4096 = 102 pas ; 12,5% de 4096 = 512 pas
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90°, +90°)
// Second servo
// PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0°, 90°, 180°)

void setup() {
  Wire.begin();
  Wire.setClock(400000); // Baud rates supportés : 100kHz, 400kHz, 1000kHz
  driver.resetDevices(); // Reset logiciel de tous les PCA9685 sur le bus Wire
  driver.init(B000000); // Broches d'adresse A5-A0 à B000000
  driver.setPWMFrequency(50); // Fréquence 50Hz
}

void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}

On inclut les bibliothèques et on définit l'objet PCA9685. Avec l'instance ServoEvaluator, on définit la durée des impulsions ou la sortie PWM. Les sorties sont en 12 bits (4096 pas). L'impulsion minimale de 0,5 ms (0°) correspond à 102 pas, et la maximale de 2,5 ms (180°) à 512 pas. Mais ces valeurs doivent être ajustées selon votre servo. J'ai utilisé 102 à 470 pour 0 à 180°.

Dans le setup, on définit la fréquence I2C, l'adresse du pilote et la fréquence PWM à 50 Hz.

Dans la boucle, avec setChannelPWM() et pwmForAngle(), on positionne simplement le servo à l'angle désiré.

J'ai connecté un second servo et, comme prévu, il ne se positionnait pas pareil que le premier, car ce sont des copies bon marché peu fiables. Mais ce n'est pas grave car avec l'instance ServoEvaluator, on peut définir des réglages différents pour chaque servo. On peut aussi ajuster la position 90° si elle n'est pas exactement au milieu. Ainsi tous les servos fonctionneront de la même façon et se positionneront à l'angle exact.

Contrôler Beaucoup de Servos avec Arduino et des Pilotes PCA9685 en Chaîne

Regardons un dernier exemple : contrôler beaucoup de servos avec plusieurs pilotes PCA9685 chaînés.

Pour cela, il faut connecter les pilotes entre eux et souder les pads de sélection d'adresse appropriés. Voici le schéma :

/* Contrôle Servomoteur avec Arduino et PCA9685 (multiples) par Dejan, https://howtomechatronics.com
   Bibliothèque : https://github.com/NachtRaveVL/PCA9685-Arduino */
#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;
PCA9685 driver2; // Second pilote

PCA9685_ServoEvaluator pwmServo(102, 470);
PCA9685_ServoEvaluator pwmServo2(102, 310, 505);

void setup() {
  Wire.begin();
  Wire.setClock(400000);
  driver.resetDevices();
  driver.init(B000000); // Adresse premier pilote
  driver2.init(B000001); // Adresse second pilote
  driver.setPWMFrequency(50);
  driver2.setPWMFrequency(50);
}

void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  driver2.setChannelPWM(0, pwmServo2.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  driver2.setChannelPWM(0, pwmServo2.pwmForAngle(90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  driver2.setChannelPWM(0, pwmServo2.pwmForAngle(180));
  delay(1000);
}

Il faut créer un objet PCA9685 distinct pour chaque pilote, définir les adresses et la fréquence à 50 Hz. Ensuite, avec setChannelPWM() et pwmForAngle(), on peut positionner n'importe quel servo sur n'importe quel pilote à n'importe quel angle.

Dépannage

Le servomoteur tremble et réinitialise ma carte Arduino

C'est un problème courant avec les servos de modélisme SG90 et MG996R. La cause est qu'ils peuvent consommer beaucoup de courant sous charge, ce qui peut faire redémarrer la carte Arduino, surtout si le servo est alimenté directement par la broche 5V de l'Arduino.

Pour résoudre ce problème, on peut placer un condensateur entre GND et la broche 5V. Il agira comme un condensateur de découplage qui fournira du courant supplémentaire au démarrage quand le moteur DC démarre.

Le servomoteur ne parcourt pas toute la plage de 0 à 180 degrés

Autre problème courant. Comme expliqué, une impulsion de 1 ms (0,5 ms) correspond à 0° et 2 ms (2,5 ms) à 180°. Mais ces valeurs varient selon les servos et fabricants.

Pour résoudre cela, il faut ajuster la largeur d'impulsion envoyée au servo. Heureusement, avec la bibliothèque Servo d'Arduino, on peut facilement ajuster ces valeurs dans la fonction attach().

La fonction attach() accepte deux paramètres supplémentaires : la largeur d'impulsion minimale et maximale en microsecondes. Les valeurs par défaut sont 544 µs (0,544 ms) pour le minimum (0°) et 2400 µs (2,4 ms) pour le maximum. En ajustant ces valeurs, on affine la plage de mouvement du servo.

myservo.attach(9, 600, 2300); // (broche, min, max)

Dimensions et Modèles 3D

J'ai créé des modèles 3D des deux servos les plus populaires : le SG90 Micro Servo et le MG996R. Vous pouvez les télécharger via les liens ci-dessous.

SG90 Micro Servo

Modèle 3D : Téléchargement depuis Thangs.

Dimensions :

MG996R Servo Motor

Modèle 3D MG996R : Téléchargement depuis Thangs.

Dimensions :

Conclusion

Nous avons couvert presque tout ce qu'il faut savoir sur l'utilisation des servomoteurs avec Arduino. Bien sûr, il existe de nombreux fabricants et modèles, chacun avec ses particularités.

Les possibilités pour créer des projets robotiques, d'automatisation et RC sont infinies, mais choisir le bon modèle pour votre application est crucial.

J'espère que ce tutoriel vous a plu. N'hésitez pas à poser vos questions dans les commentaires et consultez ma collection de projets Arduino.

Questions Fréquentes (FAQ)

C'est assez simple. Le servo a 3 fils : deux pour l'alimentation (GND et 5V) et le troisième est la ligne de contrôle qui va sur l'Arduino.

On peut faire tourner des servos directement depuis l'Arduino, mais on risque des problèmes d'alimentation. Si le servo consomme plus de 500 mA, l'Arduino peut perdre l'alimentation et redémarrer. Il vaut mieux toujours utiliser une source d'alimentation dédiée pour les servos.

Avec la bibliothèque Servo, on peut contrôler jusqu'à 12 servos avec la plupart des cartes Arduino, et 48 avec l'Arduino Mega. Bien sûr, il faut une alimentation dédiée pour les servos.