Servomoteur Arduino code : contrôler un servo

Programmer un servomoteur avec Arduino ouvre la porte à une mécanique précise, fluide et fiable. Avec quelques lignes de code bien structurées, un câblage propre et quelques notions de PWM, un simple SG90 ou MG996R se transforme en actionneur robuste pour robot, bras articulé ou système de visée.

Entre choix du modèle, alimentation stable, librairie Servo et gestion de plusieurs canaux, chaque détail influence la précision des 0-180° ou d’une rotation 360° continue. Les sections qui suivent posent les bases, puis vont progressivement vers des montages plus avancés et des optimisations souvent négligées.

Comprendre le fonctionnement d’un servomoteur avec Arduino

Un servomoteur Arduino combine un petit moteur à courant continu, un réducteur, un potentiomètre et une électronique de contrôle. L’ensemble réagit à un signal PWM (Pulse Width Modulation) envoyé par la carte Arduino et oriente l’axe en fonction de la largeur d’impulsion.

Sur Arduino, le pilotage d’un servo repose sur une période d’environ 20 ms, soit une fréquence de 50 Hz. La largeur de l’impulsion varie généralement de 1 ms à 2 ms et se traduit par une position angulaire. Cette logique reste la même pour la plupart des micro servos 9 g, des servos standards et des servos à rotation continue, même si le comportement final diffère.

La plupart des servomoteurs standards proposent un débattement autour de 180°. Un micro servo 9 g typique accepte un angle de 0 à 180°, contrôlé par une impulsion de 1 ms pour 0°, 1,5 ms pour 90° et 2 ms pour 180°. Le signal PWM suit une fréquence de 50 Hz, ce qui correspond à un envoi d’impulsion toutes les 20 ms.

« Signal de commande type servo : période 20 ms, impulsion de 1 ms pour 0°, 1,5 ms pour 90°, 2 ms pour 180°. Fréquence d’envoi 50 Hz. »

Les servomoteurs à rotation continue réutilisent le même type de signal mais ne se positionnent plus sur un angle. Ils interprètent la largeur d’impulsion comme une vitesse et un sens de rotation : 90 correspond à l’arrêt, 0-89 au sens inverse, 91-180 au sens direct, avec une vitesse plus élevée à mesure que l’on se rapproche de 0 ou 180.

22 septembre 2026

Code erreur E03 sur un lave-linge Candy : 3 contrôles avant d’appeler un réparateur

0 commentaires

Choisir le bon servomoteur pour un projet Arduino

Avant de rédiger la moindre ligne de code, la sélection du servomoteur conditionne la stratégie de contrôle. Couple, vitesse, tension, matériau des pignons et type de rotation influencent la réponse de l’actionneur et la fiabilité de l’ensemble.

Les servos courants autour d’Arduino se répartissent entre micro servos légers, servos métal plus coupleux et modèles standards. Chaque référence possède des caractéristiques précises qui orientent le choix selon la charge mécanique, la vitesse de déplacement et les contraintes d’alimentation.

Micro servo 9 g, SG90, MG90S : comparaison pratique

Les micro servos 9 g sont très utilisés avec Arduino pour des maquettes, des volets, des petites pinces ou des systèmes de direction légers. Parmi les références populaires, on retrouve les SG90 et MG90S, avec des spécifications qui orientent le dimensionnement mécanique.

Le SG90 reste adapté pour des efforts modérés, des volets de maquette ou un capteur orientable. Le MG90S, lui, dispose d’un couple supérieur et de pignons métalliques, plus résistant pour des montages dynamiques ou soumis à des chocs. Les micro servos 9 g génériques partagent souvent des caractéristiques proches de ces modèles.

Servo standard MG996R et classes de couple

Pour des bras robotisés plus lourds, des roues motrices ou des systèmes de levage, un servo standard comme le MG996R apporte une réserve de couple appréciable. Ce modèle fonctionne entre 4,8 et 6,6 V, avec un courant de repos autour de 10 mA, un courant sans charge de 170 mA et un courant de blocage pouvant atteindre 1 400 mA.

Le MG996R délivre environ 9,4 kg/cm à 4,8 V et jusqu’à 11 kg/cm à 6 V. La plage de couple l’inscrit dans la catégorie des servos standards pour applications plus exigeantes. Dans un projet Arduino, ce type de servo réclame une alimentation dédiée et un soin particulier sur la dissipation thermique et la mécanique de fixation.

On distingue généralement :

• Micro servos : 1,2 à 2,2 kg/cm, adaptés aux charges réduites et à une intégration compacte.
• Servos standards : autour de 9,4 à 11 kg/cm, conçus pour des bras articulés, plateformes motorisées ou mécanismes avec bras de levier plus long.

21 septembre 2026

Code erreur sur un lave-linge Bosch : décoder la panne et éviter une réparation inutile

0 commentaires

Servomoteurs à rotation continue 360°

Les servos à rotation continue remplacent le contrôle d’angle par un contrôle de vitesse. Le signal PWM reste identique, mais l’interprétation change :

• 0 à 89 : rotation inverse, plus la valeur se rapproche de 0, plus la vitesse augmente.
• 90 : arrêt.
• 91 à 180 : rotation directe, plus la valeur se rapproche de 180, plus la vitesse augmente.

Ils conviennent pour des mini robots mobiles, des convoyeurs et des systèmes d’entrainement continus. Sur Arduino, la même librairie Servo permet de les piloter, en remplaçant les angles par des consignes de vitesse.

Câblage d’un servomoteur sur Arduino : schéma et bonnes pratiques

Le câblage conditionne la stabilité du servo et la répétabilité de la position. Trois fils composent en général le faisceau du servomoteur :

• Alimentation +V (rouge) : 4,5 à 6 V selon le modèle.
• Masse GND (noir ou marron).
• Signal PWM (orange, jaune ou blanc) : relié à une broche numérique Arduino.

Le plus des servos micro s’alimente souvent en 5 V depuis une alimentation externe ou la broche 5V de l’Arduino dans les cas de faible consommation. Les servos plus puissants comme le MG996R nécessitent une source séparée capable de fournir un courant de blocage soutenu.

21 septembre 2026

Erreur L11-06 sur Livebox 4 : 4 vérifications avant d’appeler Orange

0 commentaires

Schéma de câblage minimal

Pour un micro servo SG90 ou 9 g :

• Fil rouge sur +5 V.
• Fil noir ou marron sur GND.
• Fil orange sur une broche numérique, par exemple D9.

Le GND du servo et celui de l’Arduino doivent rester reliés pour partager la même référence de masse. Sans cette liaison, le signal PWM n’a plus de référence et le servo réagit de manière erratique.

Pour un MG996R, on reprend le même schéma, mais on remplace le 5 V Arduino par une alimentation 5-6 V externe. La masse de cette alimentation reste connectée à GND Arduino. Cette configuration protège la carte et stabilise le fonctionnement du servo.

Librairie Servo Arduino : base du code pour contrôler un servo

La librairie Servo fournie avec l’IDE Arduino simplifie l’utilisation de la PWM pour servomoteur. Elle gère en interne les temporisations d’impulsion et la synchronisation, ce qui libère l’utilisateur de la gestion manuelle des timers.

Voici un code minimal pour piloter un servo standard de 0 à 180° :

#include <Servo.h>

Servo monServo;  // Création d'un objet Servo

void setup() {
  monServo.attach(9);      // Broche de signal PWM (D9)
}

void loop() {
  // Aller de 0 à 180°
  for (int angle = 0; angle <= 180; angle++) {
    monServo.write(angle); // Envoi de la position en degrés
    delay(20);             // Attente pour laisser le temps au servo de se déplacer
  }

  // Retour de 180 à 0°
  for (int angle = 180; angle >= 0; angle--) {
    monServo.write(angle);
    delay(20);
  }
}

La méthode attach() associe l’objet Servo à une broche numérique. La méthode write() accepte un angle en degrés, généralement entre 0 et 180. Le délai de 20 ms dans les boucles assure un mouvement progressif, en cohérence avec la fréquence de 50 Hz.

Contrôle par microsecondes : writeMicroseconds()

Pour un réglage plus fin, la librairie Servo propose writeMicroseconds(). Cette méthode n’utilise plus des degrés mais directement la durée de l’impulsion en microsecondes.

#include <Servo.h>

Servo monServo;

void setup() {
  monServo.attach(9);
}

void loop() {
  // 0° environ
  monServo.writeMicroseconds(1000);
  delay(500);

  // 90° environ
  monServo.writeMicroseconds(1500);
  delay(500);

  // 180° environ
  monServo.writeMicroseconds(2000);
  delay(500);
}

Cette approche s’avère pratique pour calibrer finement les extrémités, surtout si le servo n’atteint pas réellement 0° ou 180° avec les valeurs par défaut. Certains modèles tolèrent des impulsions légèrement en dehors de [1 ms ; 2 ms], par exemple 500 à 2 500 μs, mais un test progressif reste préférable pour éviter des blocages mécaniques.

Contrôler précisément un micro servo 9 g avec Arduino

Un micro servo 9 g s’intègre parfaitement à un projet Arduino de petite taille. Ses caractéristiques typiques sont :

• Tension de fonctionnement entre 4,5 et 6 V.
• Couple autour de 1,2 kg/cm (4,5 V) et 1,4 kg/cm (6 V).
• Vitesse de l’ordre de 0,12 s/60° à 4,5 V et 0,10 s/60° à 6 V.
• Débattement habituel de 180°.

Pour un mouvement fluide en boucle, on peut utiliser un code de progression par pas déterminés :

#include <Servo.h>

Servo microServo;

void setup() {
  microServo.attach(9);
}

void loop() {
  int pas = 5; // Incrément en degrés
  
  for (int angle = 0; angle <= 180; angle += pas) {
    microServo.write(angle);
    delay(20); // Cohérent avec un temps de 0,10 s/60° environ
  }

  for (int angle = 180; angle >= 0; angle -= pas) {
    microServo.write(angle);
    delay(20);
  }
}

Un pas de 5° procure un bon compromis entre précision et fluidité. Pour des mouvements plus doux, on réduit la valeur du pas et on ajuste le délai pour coller à la vitesse du servo.

Exemple de code : contrôler un SG90 avec Arduino

Le SG90 figure souvent dans les kits Arduino. Il fonctionne de manière optimale à 5 V, avec une consommation autour de 10 mA au repos et 100 à 250 mA en rotation. Il supporte un signal PWM de 50 Hz avec des impulsions de 1 à 2 ms, mais accepte aussi une plage plus large de fréquence, entre 40 et 200 Hz.

Voici un exemple de code pour positionner un SG90 sur trois angles clés :

#include <Servo.h>

Servo sg90;

void setup() {
  sg90.attach(9);
}

void loop() {
  // Position fermée
  sg90.write(0);
  delay(1000);

  // Position médiane
  sg90.write(90);
  delay(1000);

  // Position ouverte
  sg90.write(180);
  delay(1000);
}

Ce schéma sert de base à de nombreux projets : ouverture de trappe, orientation de capteur, verrouillage mécanique. Pour un contrôle plus stable, une alimentation 5 V régulée et une bonne liaison de masse améliorent la répétabilité du positionnement.

Exemple de code : contrôler un MG90S avec Arduino

Le MG90S se distingue par ses pignons en aluminium 6061-T6 et un couple plus élevé que le SG90. À 4,8 V, il fournit environ 1,8 kg/cm, et jusqu’à 2,2 kg/cm à 6,6 V. Sa vitesse tourne autour de 0,10 s/60° à 4,8 V et 0,08 s/60° à 6 V. La plage de température indiquée de 0 à 55 °C le rend adapté à un environnement de laboratoire ou de maquette.

Le code suivant propose un déplacement angulaire contrôlé, avec une rampe simple pour limiter les efforts mécaniques :

#include <Servo.h>

Servo mg90s;

void allerALentement(Servo &servo, int angleDepart, int angleArrivee, int pas, int delaiMs) {
  if (angleDepart < angleArrivee) {
    for (int a = angleDepart; a <= angleArrivee; a += pas) {
      servo.write(a);
      delay(delaiMs);
    }
  } else {
    for (int a = angleDepart; a >= angleArrivee; a -= pas) {
      servo.write(a);
      delay(delaiMs);
    }
  }
}

void setup() {
  mg90s.attach(9);
}

void loop() {
  allerALentement(mg90s, 0, 180, 2, 15);
  delay(500);
  allerALentement(mg90s, 180, 0, 2, 15);
  delay(500);
}

La fonction allerALentement() gère un déplacement progressif de l’angle de départ vers l’angle d’arrivée en appliquant une rampe de position. Ce type d’approche limite les à-coups, préserve les pignons et réduit les pics de courant dans l’alimentation.

Exemple de code : contrôler un MG996R avec Arduino

Le MG996R exige une approche plus rigoureuse en matière d’alimentation et de rampes de mouvement. Avec un couple autour de 9,4 kg/cm à 4,8 V et 11 kg/cm à 6 V, ainsi qu’un courant en blocage proche de 1 400 mA, une alimentation spécifique et des câbles adaptés deviennent nécessaires.

Voici un exemple de pilotage avec contrôle par microsecondes pour ajuster précisément les limites :

#include <Servo.h>

Servo mg996r;

int posMin = 1000;  // microsecondes pour limite basse
int posMax = 2000;  // microsecondes pour limite haute

void setup() {
  mg996r.attach(9);
}

void loop() {
  // Aller en position min
  for (int us = posMax; us >= posMin; us -= 10) {
    mg996r.writeMicroseconds(us);
    delay(15);
  }

  delay(500);

  // Aller en position max
  for (int us = posMin; us <= posMax; us += 10) {
    mg996r.writeMicroseconds(us);
    delay(15);
  }

  delay(500);
}

La variation par pas de 10 microsecondes crée une rampe douce. En pratique, un calibrage initial au banc permet de déterminer des valeurs de posMin et posMax qui n’emmènent pas le servo en butée mécanique dure.

Servomoteur Arduino : code pour une rotation continue 360°

Un servomoteur à rotation continue piloté par Arduino réagit au PWM d’une manière différente. La consigne n’exprime plus un angle, mais une vitesse et un sens de rotation. La logique générale reste :

• 0 à 89 : rotation inverse, vitesse proportionnelle à l’écart par rapport à 90.
• 90 : arrêt.
• 91 à 180 : rotation directe, vitesse croissante à mesure que l’on s’éloigne de 90.

Voici un exemple de code pour gérer un tel servo :

#include <Servo.h>

Servo servo360;

void setup() {
  servo360.attach(9);
}

void loop() {
  // Rotation directe vitesse moyenne
  servo360.write(135);
  delay(2000);

  // Arrêt
  servo360.write(90);
  delay(1000);

  // Rotation inverse vitesse rapide
  servo360.write(30);
  delay(2000);

  // Arrêt
  servo360.write(90);
  delay(1000);
}

Pour un robot mobile, cette logique permet de gérer les roues avec deux servos 360° en combinant vitesses et sens de rotation. Une calibration initiale, en ajustant légèrement autour de 90 pour l’arrêt parfait, reste utile selon les tolérances du servo.

Gestion de plusieurs servomoteurs sur Arduino

Les projets avancés utilisent souvent plusieurs servos : bras articulé à plusieurs degrés de liberté, quadrupède, tête pan/tilt… Sur un Arduino Uno, la librairie Servo autorise jusqu’à 12 servos sans driver externe. Au-delà, l’utilisation d’un module PCA9685 ou d’un autre contrôleur PWM se révèle utile.

Le PCA9685 offre 16 canaux de PWM pilotés via le bus I2C, en utilisant seulement deux broches Arduino (SDA et SCL). On délègue ainsi la génération des signaux à ce driver, tandis que l’Arduino se concentre sur la logique de contrôle et le traitement des capteurs.

Exemple avec plusieurs servos sur pins Arduino

Voici un exemple simple avec trois servos contrôlés directement :

#include <Servo.h>

Servo servoBase;
Servo servoBras;
Servo servoPince;

void setup() {
  servoBase.attach(3);
  servoBras.attach(5);
  servoPince.attach(6);
}

void loop() {
  servoBase.write(90);
  servoBras.write(45);
  servoPince.write(10);
  delay(1000);

  servoBase.write(0);
  servoBras.write(90);
  servoPince.write(50);
  delay(1000);
}

Au-delà de quelques servos, le temps passé dans les delay() et la gestion des signaux limite la réactivité. Le PCA9685 ou un microcontrôleur plus puissant constitue alors une base plus confortable.

Optimiser le code Arduino pour des mouvements de servomoteur fluides

Un servo réagit directement à la séquence de commandes que tu lui envoies. Pour améliorer la fluidité, la précision et la durée de vie mécanique, plusieurs techniques s’appliquent dans le code :

• Rampe d’accélération et de décélération.
• Limitation de la fréquence d’actualisation des ordres.
• Filtrage logiciel des consignes issues de capteurs bruyants.

Rampe d’accélération simple

Une rampe d’accélération évite un démarrage brutal en passant par des positions intermédiaires. Le principe :

• Calculer la différence entre la position actuelle et la nouvelle position.
• Découper ce déplacement en pas réguliers.
• Insérer un délai entre chaque incrément.

Un exemple de fonction simple :

void allerProgressif(Servo &servo, int angleCible, int vitesseMs) {
  int angleActuel = 0; // À mémoriser ou à estimer
  int pas = (angleCible > angleActuel) ? 1 : -1;

  for (int a = angleActuel; a != angleCible; a += pas) {
    servo.write(a);
    delay(vitesseMs);
  }
}

Dans une version plus aboutie, on mémorise l’angle courant dans une variable globale pour éviter l’hypothèse de départ à 0, et on ajuste le pas selon la distance à parcourir.

Bonnes pratiques d’alimentation et de fiabilité avec Arduino et servos

La fiabilité d’un projet Arduino avec servomoteur dépend fortement de la qualité de l’alimentation. Entre courant au repos, courant en charge et courant de blocage, l’écart reste significatif. Une dimension trop faible entraîne des resets, des mouvements incohérents ou des pertes de couple.

Un micro servo SG90 consomme environ 10 mA au repos et 100 à 250 mA en rotation. Un modèle comme le MG996R monte à 1 400 mA en blocage. Réunir plusieurs servos sur un même rail d’alimentation exige un calcul de marge et une attention particulière à la section des conducteurs.

Points clés pour l’alimentation des servos

• Prévoir une marge de courant : additionner les courants en charge de chaque servo, puis ajouter une marge pour les pics temporaires.
• Séparer logique et puissance : alimentation 5 V propre pour l’Arduino, alimentation dédiée pour les servos, masse commune.
• Ajouter un condensateur de filtrage : un condensateur électrochimique en parallèle sur le rail des servos amortit les pics de courant.

« Certains servos exigent une alimentation 4,8 à 6,6 V. Une tension trop faible réduit le couple, une tension trop élevée accélère l’usure ou déclenche une surchauffe. »

Une fois l’alimentation stabilisée, les réactions du servo deviennent reproductibles. Les temps de réponse (0,12 s/60° ou 0,10 s/60°) restent cohérents, le couple disponible se rapproche des valeurs nominales et le code produit le mouvement attendu.

Aller plus loin : intégration du contrôle de servo dans un système complet

Dans un projet global, le code de contrôle du servomoteur s’intègre parmi d’autres tâches : lecture de capteurs, communication série, gestion de menus, enregistrement de données. Une architecture propre simplifie l’évolution du projet.

Une bonne pratique consiste à isoler la logique de commande du servo dans une fonction ou une classe, puis à l’appeler depuis la boucle principale avec les consignes calculées à partir des entrées. Cette approche facilite le passage d’un micro servo SG90 à un MG90S ou à un MG996R en limitant les modifications au code de bas niveau.

Pour des projets domotiques ou des systèmes mécaniques intégrés dans un bâtiment ou un coffret électrique, la maîtrise des normes et des contrôles sur le reste de l’installation reste également déterminante pour la sécurité globale. Un simple module servo sur Arduino peut se retrouver inséré dans un environnement électrique plus vaste, soumis à des exigences de la norme NFC 15-100 ou à un contrôle d’installation électrique plus large, notamment quand la partie puissance interagit avec le secteur.

Dans ce contexte, la partie faible tension pilotée par Arduino et servomoteurs s’inscrit alors dans une architecture globale, confiée à une alimentation basse tension adaptée, et intégrée à une éventuelle mise aux normes électrique du système complet. Le code de contrôle du servo devient alors un maillon d’une chaîne plus large, qui respecte à la fois la logique logicielle et les contraintes matérielles.