Servo 360 degrés (FS90R) : contrôler vitesse et sens avec Arduino

Un servo 360 degrés porte le nom de servo, mais c'est en réalité un petit motoréducteur qui tourne en continu au lieu d'aller à un angle et d'y rester. Le plus connu est le FEETECH FS90R : il a la même taille et les mêmes trois fils qu'un SG90, mais le signal que tu lui envoies fixe sa vitesse et son sens de rotation, pas un angle. Comme il se branche directement sur une broche d'Arduino sans driver moteur, il est très pratique pour les roues de petits robots, les plateaux tournants ou les distributeurs de croquettes.

Dans ce guide, tu découvriras ce qui change à l'intérieur du FS90R par rapport à un servo classique, pourquoi la commande write(90) arrête le moteur, comment régler vitesse et sens avec la largeur d'impulsion et comment utiliser le trimmer de neutre pour corriger un servo qui continue de tourner tout seul. Tu piloteras ensuite un petit robot avec deux FS90R, tu régleras la vitesse avec un potentiomètre et tu feras la même chose avec un ESP32 et une Raspberry Pi Pico. Enfin, tu verras pourquoi ce servo ne peut pas faire de contrôle de position et ce qu'il faut choisir à la place.

Qu'est-ce qu'un servo 360 degrés et en quoi diffère-t-il d'un servo classique ?

Un servo classique contient un petit moteur à courant continu, un réducteur, un circuit de commande et un potentiomètre relié à l'axe de sortie. Le circuit compare l'angle demandé par l'impulsion avec l'angle réel lu sur le potentiomètre et fait tourner le moteur jusqu'à ce que l'écart soit nul ; quand l'axe atteint la cible, il s'arrête. Dans un servo à rotation continue, cette boucle de retour est coupée : le potentiomètre est désolidarisé de l'axe et bloqué en position médiane, et la butée mécanique des engrenages a disparu. Le circuit calcule toujours « l'écart entre la position voulue et la position réelle », mais comme la position réelle ne change jamais, l'écart ne se referme jamais. Résultat : plus l'écart est grand, plus le moteur tourne vite, et son signe donne le sens.

Caractéristiques techniques du FS90R

Câblage du FS90R : Arduino Uno, ESP32 et Pico

Pour faire tourner un seul FS90R à vide, la broche 5V de l'Uno suffit. Dès que la roue touche le sol ou que deux servos démarrent ensemble, le courant monte à quelques centaines de milliampères ; la tension USB chute, l'Arduino peut redémarrer ou les servos trembler. Sur un robot, alimente donc les servos avec une source 5 V séparée (4 accus NiMH, un régulateur 5 V ou une alimentation adaptée), relie toujours la masse de cette alimentation à celle de l'Arduino et ajoute un condensateur de 470 µF près des fils des servos. Le signal 3,3 V de l'ESP32 et de la Pico suffit au FS90R ; le servo lui-même doit malgré tout être alimenté en 5 V, pas par la broche 3,3 V.

write(90) = arrêt : comment la largeur d'impulsion devient-elle une vitesse ?

Le signal de commande d'un servo est une impulsion envoyée 50 fois par seconde (toutes les 20 ms), et c'est sa durée qui compte. Pour le FS90R, 1500 µs signifie « arrêt ». Quand l'impulsion dépasse 1500 µs, le servo accélère dans un sens ; quand elle raccourcit, dans l'autre ; il atteint sa pleine vitesse vers 1000 µs et 2000 µs, et au-delà la vitesse n'augmente presque plus. C'est pourquoi, dans la bibliothèque Servo d'Arduino, write(90) veut dire arrêt, tandis que write(0) et write(180) veulent dire pleine vitesse dans chaque sens. Attention à un petit piège : par défaut, la bibliothèque convertit 0–180 en 544–2400 µs, donc write(90) produit en réalité 1472 µs. Cet écart peut suffire à faire tourner lentement le servo même avec write(90). La solution consiste à resserrer la plage avec attach(9, 1000, 2000) ou à utiliser directement writeMicroseconds(1500).

Premier programme : avant, arrêt, arrière

1// FS90R ilk test: ileri, dur, geri / FS90R first test: forward, stop, backward
2#include <Servo.h>
3
4Servo teker;                         // sürekli dönüş servosu / continuous rotation servo
5
6void setup() {
7  teker.attach(9, 1000, 2000);       // write(0..180) artık 1000..2000 µs üretir / write(0..180) now outputs 1000..2000 µs
8}
9
10void loop() {
11  teker.write(180);                  // tam hız bir yöne / full speed one way
12  delay(2000);
13  teker.write(90);                   // 1500 µs: dur / 1500 µs: stop
14  delay(1000);
15  teker.write(0);                    // tam hız ters yöne / full speed the other way
16  delay(2000);
17  teker.write(110);                  // yavaş / slow
18  delay(2000);
19  teker.writeMicroseconds(1500);     // durmanın en kesin yolu / the most precise way to stop
20  delay(1000);
21}

Le programme attache le servo à D9 et, avec attach(9, 1000, 2000), fait correspondre l'échelle de write() à la plage réellement utilisée par le FS90R ; write(90) donne ainsi exactement 1500 µs. La vitesse ne suit pas l'impulsion de façon linéaire : juste autour de 1500 µs, il existe une bande morte de quelques dizaines de microsecondes où le servo ne bouge pas, dans la plage 1500 ± 300 µs la vitesse monte vite, et vers les extrémités elle reste presque constante. Pour un mouvement lent et précis, reste près de 1500 µs. Le principe de la largeur d'impulsion est expliqué dans Qu'est-ce que la PWM, et la commande d'angle des servos classiques dans Qu'est-ce qu'un servomoteur.

Régler le trimmer de neutre (point d'arrêt)

1. Téléverse le programme de calibration ci-dessous ; le servo reçoit un signal de 1500 µs et devrait normalement rester immobile.
2. Si le servo tourne lentement, repère le petit trou sur le côté du boîtier, près de la sortie du câble ; à l'intérieur se trouve le trimmer qui fixe le point d'arrêt.
3. Tourne le trimmer d'un tout petit peu avec un petit tournevis plat ou cruciforme ; si le servo ralentit, tu vas dans le bon sens.
4. Continue par petits pas jusqu'à ce que le servo s'arrête complètement et que même le léger bourdonnement disparaisse. Le trimmer est très sensible, un quart de tour est déjà trop.
5. Si tu préfères ne pas toucher au trimmer, envoie + et - depuis le Moniteur série pour trouver la valeur d'impulsion où le servo s'arrête, puis utilise-la dans ton code à la place de 1500.

1// Durma noktası ayarı: Serial Monitor'den µs değeri gönder
2// Stop point calibration: send a µs value from the Serial Monitor
3#include <Servo.h>
4
5Servo teker;
6int darbe = 1500;                    // başlangıç: teorik durma noktası / start: theoretical stop point
7
8void setup() {
9  Serial.begin(9600);
10  teker.attach(9);
11  teker.writeMicroseconds(darbe);
12  Serial.println(F("Sayi yaz (900-2100) ya da + / - gonder"));
13  Serial.println(F("Type a number (900-2100) or send + / -"));
14}
15
16void loop() {
17  if (Serial.available()) {
18    char c = Serial.peek();
19    if (c == '+') { Serial.read(); darbe += 5; }          // 5 µs artır / add 5 µs
20    else if (c == '-') { Serial.read(); darbe -= 5; }     // 5 µs azalt / subtract 5 µs
21    else if (isDigit(c)) darbe = Serial.parseInt();       // doğrudan değer / direct value
22    else { Serial.read(); return; }                       // satır sonu vb. atla / skip line endings etc.
23
24    darbe = constrain(darbe, 900, 2100);
25    teker.writeMicroseconds(darbe);
26    Serial.print(F("Darbe / pulse: "));
27    Serial.print(darbe);
28    Serial.println(F(" us"));
29  }
30}

Vitesse et sens avec un potentiomètre

1// Potansiyometreyle hız ve yön: ortada dur, sağa ileri, sola geri
2// Speed and direction with a pot: centre = stop, right = forward, left = backward
3#include <Servo.h>
4
5const int POT_PIN = A0;
6const int OLU_BOLGE = 40;            // ortadaki ±40 adım: kesin dur / ±40 steps in the middle: solid stop
7Servo teker;
8
9void setup() {
10  teker.attach(9);
11}
12
13void loop() {
14  int okuma = analogRead(POT_PIN) - 512;                   // -512 ... +511
15  int darbe = 1500;                                        // varsayılan: dur / default: stop
16  if (okuma > OLU_BOLGE) {
17    darbe = map(okuma, OLU_BOLGE, 511, 1540, 2000);        // ileri, yavaştan hızlıya / forward, slow to fast
18  } else if (okuma < -OLU_BOLGE) {
19    darbe = map(okuma, -OLU_BOLGE, -512, 1460, 1000);      // geri / backward
20  }
21  teker.writeMicroseconds(darbe);
22  delay(20);                                               // servo periyodu kadar / one servo period
23}

Avec le potentiomètre branché entre 5V, A0 et GND, la position médiane signifie arrêt, tourner à droite avancer et tourner à gauche reculer. Le code définit une zone morte de ±40 pas au centre, pour que le servo s'arrête franchement même si le potentiomètre n'est pas parfaitement centré ou que les mesures fluctuent un peu. Hors de la zone morte, la valeur est convertie en 1540–2000 µs ou en 1460–1000 µs : en tournant un peu le bouton, le servo avance lentement, en le tournant à fond il va à pleine vitesse. Tu peux appliquer la même idée avec un joystick ; le câblage du potentiomètre est dans Qu'est-ce qu'un potentiomètre.

Le FS90R comme roue de petit robot

Le FS90R plaît tant en robotique pour sa simplicité : comme le réducteur et le circuit de commande sont intégrés, il ne faut ni driver moteur, ni pont en H, ni encodeur ; une broche de signal par roue suffit. Les deux servos se montent de chaque côté du châssis en miroir, donc pour avancer l'un doit tourner dans le sens horaire et l'autre dans le sens inverse. Le code ci-dessous gère cette inversion dans la fonction surus() ; tu donnes seulement une vitesse entre -100 et +100. Une roue de 60 mm de diamètre qui tourne à 130 tr/min sous 6 V parcourt environ 0,4 mètre par seconde ; sous 4,8 V, on descend vers 0,3 m/s.

1// İki FS90R ile küçük robot: tekerlekler ayna gibi takılır
2// A small robot with two FS90Rs: the wheels are mounted as mirror images
3#include <Servo.h>
4
5Servo sol, sag;
6const int DUR_SOL = 1500;            // kalibrasyonla bulduğun değerler / values you found during calibration
7const int DUR_SAG = 1500;
8
9// hiz: -100 (tam geri) ... +100 (tam ileri) / speed: -100 (full back) ... +100 (full forward)
10void surus(int hizSol, int hizSag) {
11  sol.writeMicroseconds(DUR_SOL + hizSol * 5);             // sol teker normal yönde / left wheel normal direction
12  sag.writeMicroseconds(DUR_SAG - hizSag * 5);             // sağ teker ters takılı / right wheel is mounted reversed
13}
14
15void setup() {
16  sol.attach(9);
17  sag.attach(10);
18  surus(0, 0);
19  delay(1000);
20}
21
22void loop() {
23  surus(80, 80);    delay(1500);     // ileri / forward
24  surus(0, 0);      delay(500);      // dur / stop
25  surus(-60, 60);   delay(600);      // yerinde sola dön / spin left in place
26  surus(60, 60);    delay(1000);
27  surus(30, 80);    delay(1500);     // sola doğru yay çiz / curve to the left
28  surus(-80, -80);  delay(1000);     // geri / backward
29  surus(0, 0);      delay(2000);
30}

Deux servos ne tournent jamais exactement à la même vitesse ; si ton robot dérive d'un côté au lieu d'aller droit, calibre séparément la valeur d'arrêt de chaque servo (DUR_SOL, DUR_SAG) et réduis légèrement le coefficient du plus rapide. Le couple de 1,5 kg·cm du FS90R convient aux petits robots de quelques centaines de grammes au plus ; pour un châssis plus lourd ou de grandes roues, un moteur à courant continu avec L298N ou des motoréducteurs sont un meilleur choix. Sur piles, 4 accus NiMH (4,8 V) donnent la tension idéale ; 4 piles alcalines neuves peuvent monter à 6,4 V et dépasser la limite du servo. Pour monter un châssis complet avec capteurs, vois Fabriquer une voiture robot Arduino.

Le FS90R avec l'ESP32

La bibliothèque Servo d'Arduino ne fonctionne pas sur l'ESP32 ; installe plutôt la bibliothèque ESP32Servo depuis le gestionnaire de bibliothèques. Elle s'utilise presque de la même façon, sauf que tu indiques explicitement les 50 Hz avec setPeriodHertz(50). Presque n'importe quel GPIO capable de sortir de la PWM convient pour le signal ; seules les GPIO 34 à 39, uniquement en entrée, sont à exclure. Relie le fil rouge du servo à la broche VIN (5 V de l'USB) de l'ESP32 ou à une alimentation 5 V externe, pas à la broche 3V3. Le code ci-dessous fait passer doucement le servo de l'arrêt à la pleine vitesse, puis le ralentit et inverse son sens ; le Moniteur série affiche la durée d'impulsion à chaque étape.

1// ESP32 + FS90R: ESP32Servo kütüphanesiyle hız rampası
2// ESP32 + FS90R: a speed ramp with the ESP32Servo library
3#include <ESP32Servo.h>
4
5const int SERVO_PIN = 18;            // PWM verebilen herhangi bir GPIO / any PWM-capable GPIO
6Servo teker;
7
8void setup() {
9  Serial.begin(115200);
10  teker.setPeriodHertz(50);          // standart servo frekansı / standard servo frequency
11  teker.attach(SERVO_PIN, 1000, 2000);
12  teker.writeMicroseconds(1500);     // dur / stop
13  delay(1000);
14}
15
16void loop() {
17  for (int us = 1500; us <= 2000; us += 25) {   // yavaşça hızlan / speed up gently
18    teker.writeMicroseconds(us);
19    Serial.println(us);
20    delay(200);
21  }
22  for (int us = 2000; us >= 1000; us -= 25) {   // yavaşla, dur, ters yöne hızlan / slow down, stop, reverse
23    teker.writeMicroseconds(us);
24    Serial.println(us);
25    delay(200);
26  }
27  teker.writeMicroseconds(1500);
28  delay(2000);
29}

Le FS90R avec la Raspberry Pi Pico et MicroPython

Sur la Pico, aucune bibliothèque supplémentaire n'est nécessaire : règle l'objet machine.PWM sur 50 Hz et donne la durée d'impulsion en nanosecondes avec duty_ns(). La fonction hiz() du code convertit une valeur entre -100 et +100 en 1000–2000 µs ; il suffit d'écrire sur la ligne DUR_US la valeur d'arrêt trouvée lors de ta calibration. Quand le programme est interrompu avec Ctrl+C, le servo est arrêté lui aussi ; sinon la PWM continue avec la dernière valeur et la roue continue de tourner. Alimente le servo par la broche VBUS de la Pico (le 5 V de l'USB). Si tu débutes avec MicroPython, lis d'abord Les bases de MicroPython.

1# Raspberry Pi Pico (MicroPython) + FS90R: hız -100 ... +100
2# Raspberry Pi Pico (MicroPython) + FS90R: speed -100 ... +100
3from machine import Pin, PWM
4import time
5
6servo = PWM(Pin(15))
7servo.freq(50)                        # 20 ms periyot / 20 ms period
8DUR_US = 1500                         # kalibrasyonla bulduğun durma noktası / your calibrated stop point
9
10def hiz(yuzde):
11    yuzde = max(-100, min(100, yuzde))
12    us = DUR_US + yuzde * 5           # -100 -> 1000 µs, +100 -> 2000 µs
13    servo.duty_ns(us * 1000)
14
15try:
16    while True:
17        for h in (50, 100, 0, -50, -100, 0):
18            hiz(h)
19            print("Hiz / speed:", h)
20            time.sleep(2)
21except KeyboardInterrupt:
22    hiz(0)                            # durdurunca teker dönmeye devam etmesin / stop the wheel on exit
23    servo.deinit()

Idées de projets avec un servo 360 degrés

• Mini suiveur de ligne : Un châssis léger avec deux FS90R et deux capteurs infrarouges ; la logique est dans Robot suiveur de ligne.
• Robot éviteur d'obstacles : Ajoute un HC-SR04 à l'avant pour qu'il pivote sur place et change de direction devant un obstacle.
• Voiture pilotée au téléphone : Envoie les commandes depuis ton téléphone avec un module Bluetooth HC-05.
• Distributeur de croquettes : Le FS90R entraîne une vis sans fin et une minuterie fait tomber la nourriture à heures fixes.
• Plateau tournant de présentation : Une plateforme qui tourne très lentement pour des photos produit ou des timelapses ; règle la vitesse avec des valeurs proches de 1500 µs.
• Petit treuil ou tireur de rideau : Enroule une ficelle légère et place deux fins de course aux extrémités pour arrêter le moteur au bon endroit.

Erreurs fréquentes et solutions

Le FS90R est le moyen le plus simple de commander un mécanisme à rotation continue avec une seule broche et sans driver moteur : il s'arrête à 1500 µs, tourne dans les deux sens à la vitesse voulue et constitue un moteur de roue tout prêt pour les petits robots. Règle une fois le point d'arrêt, pense à passer à un servo classique ou à un moteur pas à pas pour les tâches qui demandent un contrôle de position, et il fonctionnera longtemps sans souci. Dans l'application BlueGrays, tu trouveras l'utilisation de base du servo, la commande d'un servo par potentiomètre et joystick, la fabrication d'un servo 360 degrés à partir d'un moteur pas à pas et des projets de voiture robot, avec schémas de câblage et code prêt à l'emploi, étape par étape.