Moteur CC, servomoteur et moteur pas à pas : les différences

La différence entre un moteur à courant continu (CC), un servomoteur et un moteur pas à pas tient en une phrase : le moteur CC tourne en continu et vite tant que tu l'alimentes, le servomoteur va à l'angle demandé et y reste, et le moteur pas à pas tourne par petits pas que l'on peut compter. Pour faire tourner une roue, tu prends donc un moteur CC ; pour ouvrir un couvercle de 90 degrés, un servo ; pour déplacer une pièce au dixième de millimètre près, un moteur pas à pas. Dès qu'il faut faire bouger quelque chose dans un projet Arduino, ESP32 ou Raspberry Pi Pico, tu croiseras l'un de ces trois moteurs.

Dans ce guide, nous comparons ce qu'il y a dans chaque moteur, les vrais chiffres de vitesse, de couple et de précision de modèles courants (moteur TT, SG90, MG996R, 28BYJ-48, NEMA 17), le driver dont chacun a besoin (L298N, signal PWM, ULN2003, A4988), le courant qu'ils consomment et lequel utiliser dans quel projet. À la fin, tu trouveras du code Arduino, ESP32 et Pico qui pilote les trois en même temps, une courte introduction aux moteurs brushless (BLDC) et aux ESC, ainsi que les erreurs les plus fréquentes.

Réponse courte : les trois moteurs dans un seul tableau

La ligne la plus importante du tableau est celle du retour de position. Un servo sait où il se trouve grâce à son potentiomètre interne, et quand quelque chose le pousse, il revient à sa position. Un moteur pas à pas ne sait pas où il est ; tu comptes simplement le nombre de pas effectués, et ce compte reste juste tant que le moteur n'est pas surchargé et ne perd pas de pas. Un moteur CC, lui, ignore totalement de combien il a tourné ; si tu as besoin de la position, il faut ajouter un encodeur sur son axe. Le choix du moteur dépend donc beaucoup du besoin de ton projet en information de position.

Comment fonctionne un moteur à courant continu ?

Presque tous les moteurs CC des projets amateurs sont des moteurs à balais. À l'intérieur, on trouve des aimants fixes et une bobine qui tourne (le rotor) ; les balais en carbone et le collecteur à lames de cuivre inversent le sens du courant au fil de la rotation, pour que le rotor ne s'arrête jamais. Le moteur a deux fils : applique une tension et il tourne, inverse les fils et il tourne dans l'autre sens. La tension fixe la vitesse et le courant consommé fixe le couple. Pendant la rotation, les bobines produisent une tension opposée appelée force contre-électromotrice qui limite le courant ; quand l'axe est bloqué, cette tension disparaît et le courant grimpe jusqu'au courant de blocage.

Un petit moteur CC sans réducteur tourne à des milliers de tours par minute mais a très peu de couple ; c'est pourquoi les robots utilisent toujours des motoréducteurs. Le réducteur 1:48 du moteur TT ramène environ 12 000 tr/min sur l'axe du moteur à 250 tr/min à la roue, tout en multipliant le couple par environ 48 (pertes des engrenages mises à part). Tu règles la vitesse en PWM et le sens avec un pont en H ; tous les détails sont dans Piloter un moteur CC avec le L298N. Le point faible du moteur CC, c'est la position : la même valeur PWM donne une vitesse différente selon la tension de la batterie et la charge, donc la commande "avance pendant 2 secondes" ne donne jamais la même distance. Si tu as besoin d'une distance exacte, on ajoute un encodeur sur la roue.

Comment fonctionne un servomoteur ?

Un servomoteur est en réalité un système complet logé dans un petit boîtier : un moteur CC, un train d'engrenages qui réduit la vitesse et augmente le couple, un potentiomètre relié à l'axe de sortie et une carte de commande. L'Arduino n'envoie pas directement un angle au servo, mais une impulsion à 50 Hz (toutes les 20 ms) ; la largeur de l'impulsion indique la position souhaitée. La carte compare cette consigne à la position réelle lue sur le potentiomètre et fait tourner le moteur dans ce sens jusqu'à ce que l'écart soit nul. C'est ce qu'on appelle une commande en boucle fermée, et c'est pour ça qu'un servo résiste quand tu essaies de le tourner à la main.

La plage RC standard va de 1 à 2 ms, mais la plupart des servos bon marché comme le SG90 demandent environ 0,5–2,4 ms pour couvrir les 180°, et la bibliothèque Servo d'Arduino utilise par défaut la plage 544–2400 µs. La bande morte du SG90, c'est-à-dire le plus petit changement auquel il réagit, est d'environ 10 µs, soit à peu près 1° ; la précision pratique d'un servo tourne donc autour du degré. Un servo à rotation continue (FS90R) est un servo dont le retour de position est désactivé : tu contrôles la vitesse et le sens au lieu de l'angle, et l'information de position est perdue. Si tu as besoin de plus de force, le MG996R à pignons métalliques est le choix standard ; pour les bases, consulte Qu'est-ce qu'un servomoteur ?

Comment fonctionne un moteur pas à pas ?

Un moteur pas à pas n'a pas de balais. Les bobines du stator sont alimentées dans un ordre précis, et le rotor aimanté fait à chaque fois un seul pas vers la bobine suivante. Les moteurs hybrides les plus courants font 200 pas par tour, soit 1,8° par pas. Envoie un certain nombre d'impulsions et il fait exactement ce nombre de pas ; envoie-les plus vite et il tourne plus vite. Tant que les bobines sont alimentées, le moteur reste bloqué en place : c'est le couple de maintien. La différence essentielle : le moteur pas à pas fonctionne en boucle ouverte. Si la charge dépasse son couple, il perd des pas et l'Arduino ne s'en rend pas compte. C'est pour ça que les imprimantes 3D envoient chaque axe sur un capteur de fin de course au démarrage (prise d'origine, ou homing).

Tu rencontreras deux types de moteurs pas à pas. Les moteurs unipolaires (28BYJ-48, 5 fils) ont un point commun aux bobines et se pilotent avec un simple réseau de transistors comme l'ULN2003. Avec les moteurs bipolaires (NEMA 17, 4 fils), il faut inverser le sens du courant dans les bobines ; c'est le rôle des drivers à limitation de courant comme l'A4988, le DRV8825 ou le TMC2209. Ces drivers savent aussi faire du micropas : l'A4988 découpe chaque pas complet en 16, ce qui porte le nombre de pas par tour à 3200 et rend le mouvement beaucoup plus silencieux et fluide. Pour plus de détails, vois 28BYJ-48 et ULN2003 et driver de moteur pas à pas A4988.

Vitesse, couple et précision : la comparaison en chiffres

Le couple est généralement donné en kg·cm : un moteur de 1 kg·cm peut tenir une charge de 1 kg à 1 cm de son axe, mais seulement 0,5 kg à 2 cm (1 kg·cm ≈ 0,098 N·m). Par exemple, un MG996R sous 6 V fournit 11 kg·cm ; au bout d'un bras de 15 cm, il tient en théorie 11 / 15 ≈ 0,73 kg. Mais il s'agit du couple maximal au moment du blocage, et le poids du bras lui-même s'ajoute à la charge. Pour que le moteur dure longtemps, une bonne règle consiste à rester sous la moitié de cette valeur ; en pratique, tu peux porter quelques centaines de grammes au bout de ce bras.

Côté vitesse, le classement s'inverse. Le moteur CC est de loin le plus rapide. Un servo SG90 effectue un mouvement de 180° en environ 0,3 seconde et ne peut pas aller plus vite. Le couple du moteur pas à pas baisse quand la vitesse augmente, car le courant de la bobine n'a pas le temps de monter complètement à chaque pas ; un 28BYJ-48 commence à perdre des pas au-delà d'environ 15 tr/min. Alimenter un NEMA 17 avec un A4988 en 24 V plutôt qu'en 12 V donne plus de couple à haute vitesse, puisque le driver limite de toute façon le courant. En précision, en revanche, le pas à pas l'emporte : un NEMA 17 offre 1,8° en pas complet et, sur le papier, 0,1125° en micropas 1/16. Petite remarque : le réducteur interne du 28BYJ-48 n'est pas exactement de 1:64 mais d'environ 1:63,68 ; un vrai tour fait donc environ 2038 pas et non 2048. Dans les projets qui tournent en permanence, comme une horloge, cet écart s'accumule.

Quel driver pour quel moteur ?

Une broche d'Arduino fournit au maximum 40 mA, et la limite sûre tourne autour de 20 mA ; même un petit moteur TT consomme environ 7 fois plus à vide et plus de 70 fois plus bloqué. De plus, la bobine d'un moteur produit un pic de tension inverse au moment où l'on coupe le courant, capable de détruire une broche non protégée. C'est pourquoi il y a toujours un driver entre le moteur et la carte : la carte n'envoie que de petits signaux de commande, et le courant du moteur passe directement de l'alimentation au moteur à travers le driver. Les drivers contiennent des transistors et des diodes qui absorbent la tension inverse. Pour un ventilateur ou une pompe qui ne tournent que dans un sens, un seul MOSFET suffit.

Consommation : combien de courant tire chaque moteur ?

Les trois moteurs se comportent très différemment côté courant, et il faut choisir l'alimentation en conséquence. Un moteur CC consomme davantage quand la charge augmente ; au démarrage et quand une roue se coince, il s'approche de son courant de blocage. Dimensionne l'alimentation pour ce pic, pas pour le courant à vide. Un servo consomme très peu au repos, mais produit à chaque mouvement des pics de courant courts et brutaux : un seul SG90 peut dépasser 0,5 A un bref instant, et un MG996R monte à 2,5 A quand il force. Ces pics font chuter la tension et redémarrer l'Arduino, ou déclenchent une erreur de brownout sur l'ESP32. Dans les bobines d'un moteur pas à pas, au contraire, le courant circule même s'il ne bouge pas du tout : un 28BYJ-48 consomme 150 à 200 mA à l'arrêt et chauffe. Sur batterie, si tu n'as pas besoin du couple de maintien, couper les bobines (mettre la broche EN de l'A4988 à HIGH) allonge nettement l'autonomie.

• Utilise une alimentation séparée : n'alimente pas les moteurs par la broche 5V de l'Arduino. Un port USB fournit environ 500 mA et la carte en utilise déjà une partie ; à part un seul petit servo, chaque moteur a besoin de sa propre source.
• Relie les masses : le négatif de l'alimentation des moteurs doit absolument être relié au GND de la carte, sinon le signal de commande n'a pas de référence (voir masse commune).
• Ajoute des condensateurs : place un électrolytique de 470 à 1000 µF sur l'alimentation des servos, au moins 47 µF sur l'entrée VMOT de l'A4988 et un condensateur céramique de 100 nF aux bornes d'un moteur CC à balais. Le premier limite les chutes de tension, le dernier atténue les parasites des balais.
• Choisis l'alimentation selon le courant de pointe : par exemple, un bras robot à 4 servos demande une alimentation 5–6 V d'au moins 3 A, et une voiture à deux moteurs TT un pack de batteries qui supporte 2 × 1,5 A. Tu peux estimer l'autonomie avec le calculateur d'autonomie de batterie.
• Abaisse correctement la tension : s'il te faut 5–6 V pour les servos à partir d'un pack de 7,4 V, utilise un régulateur à découpage comme le LM2596 ; les régulateurs linéaires comme le 7805 chauffent énormément à des courants de l'ordre de l'ampère.

Piloter les trois moteurs avec un seul Arduino : étape par étape

La meilleure façon de voir la différence, c'est de faire tourner les trois côte à côte. Dans le montage ci-dessous, un moteur TT est piloté par un L298N, un SG90 directement par une broche et un 28BYJ-48 par une carte ULN2003. Le tableau de câblage convient aux trois codes : Arduino Uno, ESP32 et Raspberry Pi Pico.

1. Retire le cavalier ENA du L298N ; relie ENA, IN1 et IN2 aux broches du tableau et le moteur CC aux borniers OUT1 et OUT2. Branche l'alimentation des moteurs (par exemple deux accus 18650 en série, 7,4 V) sur le bornier 12V.
2. Relie le fil marron du servo au GND, le rouge à une source séparée de 5–6 V et le fil orange de signal à D9.
3. Branche le connecteur blanc du 28BYJ-48 sur la carte ULN2003, relie IN1–IN4 à D10–D13 et alimente la borne + de la carte en 5 V.
4. Relie entre eux les négatifs de toutes les sources et le GND de l'Arduino.
5. Téléverse le code avec l'IDE Arduino ; les bibliothèques Servo et Stepper sont fournies avec l'IDE, inutile de les installer.
6. Mets les alimentations des moteurs sous tension et observe le comportement des trois moteurs l'un après l'autre.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

En lançant le code, tu vois clairement la différence : le moteur CC tourne pendant deux secondes, mais son axe s'arrête chaque fois à un endroit différent. Le servo file à 0°, 180° puis 90° et résiste si tu essaies de le tourner à la main. Le moteur pas à pas avance lentement d'exactement un quart de tour et revient au même point ; après l'appel à releaseStepper(), son axe se tourne facilement à la main. La fonction step() de la bibliothèque Stepper bloque le code jusqu'à la fin du mouvement ; si tu veux piloter plusieurs moteurs en même temps avec des accélérations douces, passe à la bibliothèque AccelStepper.

Moteur CC, servo et pas à pas avec l'ESP32

Les broches de l'ESP32 sortent du 3,3 V ; les entrées du L298N et de l'ULN2003 lisent ce niveau comme HIGH, et les servos fonctionnent aussi avec un signal de 3,3 V. Les moteurs ont toujours besoin de leur propre alimentation. La différence, c'est le servo : la bibliothèque Servo standard d'Arduino ne prend pas en charge l'ESP32. Soit tu installes la bibliothèque ESP32Servo, soit, comme ci-dessous, tu génères toi-même le signal 50 Hz avec le module PWM matériel de l'ESP32, LEDC. Comme nous utilisons deux fréquences différentes, 1 kHz pour le moteur CC et 50 Hz pour le servo, nous plaçons les canaux sur des timers séparés (canaux 0 et 2) avec ledcAttachChannel ; dans certaines versions du core, des canaux voisins partagent le même timer. Le code est prévu pour le core Arduino ESP32 3.x ; dans les versions 2.x, on utilise à la place ledcSetup et ledcAttachPin. La bibliothèque Stepper fonctionne telle quelle sur l'ESP32 ; si tu découvres cette carte, jette un œil à Qu'est-ce que l'ESP32 ?

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Code MicroPython pour le Raspberry Pi Pico

Sur le Pico, chaque broche GP peut sortir du PWM. En MicroPython, tu règles la vitesse du moteur CC entre 0 et 65535 avec duty_u16() et la largeur d'impulsion du servo en nanosecondes avec duty_ns(). Le moteur pas à pas tourne en écrivant la séquence en demi-pas sur quatre broches, l'une après l'autre ; en demi-pas, un tour du 28BYJ-48 fait 4096 pas. Si tu débutes avec le Pico, commence par Qu'est-ce que le Raspberry Pi Pico ?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Quel moteur pour quel projet ?

Dans certains projets, les deux moteurs conviennent et le choix se joue sur les détails. Sur une voiture robot, les moteurs CC suffisent pour les roues, mais si tu veux que la voiture parcoure exactement 50 cm, il faut soit ajouter des encodeurs, soit entraîner les roues avec des moteurs pas à pas. Pour un bras robot, les servos sont la solution la plus simple ; les bras lourds et précis utilisent des moteurs pas à pas avec réducteurs aux articulations. Sur une imprimante 3D, il est facile de calculer combien de pas un axe demande par millimètre : avec un moteur de 200 pas, du micropas 1/16 et une poulie GT2 de 20 dents (pas de 2 mm), on obtient 200 × 16 / (20 × 2) = 80 pas/mm ; avec une tige filetée trapézoïdale T8 de 8 mm d'avance, on passe à 200 × 16 / 8 = 400 pas/mm. Pour les projets qui balaient 0–180°, comme un radar ou un suiveur solaire, le servo est à la fois la solution la moins chère et la plus simple.

Courte introduction aux moteurs brushless (BLDC) et aux ESC

Dans un moteur à courant continu sans balais (brushless, BLDC), la structure est inversée : les aimants sont sur la partie tournante et les bobines dans le carter fixe. Sans balais ni collecteur, il n'y a ni frottement, ni étincelles, ni usure ; le moteur est plus efficace, plus silencieux et dure bien plus longtemps. La contrepartie : le sens du courant doit maintenant être commuté par un circuit électronique et non plus par les balais. C'est pourquoi les moteurs BLDC ont 3 fils et ne tournent pas si tu les branches directement sur une batterie. Pour les moteurs de modélisme, la vitesse est donnée par la valeur KV : le nombre de tours par minute à vide par volt. Un moteur de 1000 KV (par exemple l'A2212) sur une LiPo 3 cellules (11,1 V) tourne à vide à environ 11 100 tr/min. Les drones, avions RC, skateboards et trottinettes électriques, ventilateurs d'ordinateur et disques durs utilisent tous des moteurs brushless.

Pour relier un moteur BLDC à l'Arduino, il faut un ESC (Electronic Speed Controller, contrôleur électronique de vitesse). L'ESC transforme la tension continue de la batterie en impulsions triphasées pour le moteur ; les ESC sans capteur estiment la position du rotor à partir de la force contre-électromotrice dans la bobine non alimentée. Le bon côté, c'est que l'entrée de commande de l'ESC est la même que celle d'un servo : avec des impulsions à 50 Hz, 1000 µs signifie arrêt et 2000 µs plein gaz. Le courant admissible de l'ESC (par exemple 30 A) doit dépasser le courant maximal que le moteur peut tirer, et la plupart des ESC ont une sortie BEC qui fournit du 5 V. Par sécurité, l'ESC veut d'abord voir les gaz au minimum à la mise sous tension ; c'est l'armement (arming), et sans ce signal il ne fait pas tourner le moteur. Dans le code ci-dessous, le fil de signal de l'ESC est relié à D9 et le curseur du potentiomètre servant de manette des gaz à A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Erreurs fréquentes et solutions

• L'Arduino redémarre quand le moteur tourne : le moteur ou le servo est alimenté par la broche 5V de la carte. Utilise une source séparée, relie les masses et ajoute un gros condensateur sur l'alimentation.
• Le servo tremble ou fait des sauts : l'alimentation est trop faible, les fils sont fins et longs ou la masse n'est pas commune. Alimente le servo avec une source 5–6 V capable de fournir au moins 1 A.
• Avec un servo, la vitesse du moteur CC ne change pas : sur l'Uno, ENA est relié à la broche 9 ou 10, et la bibliothèque Servo désactive le PWM sur ces broches. Déplace ENA sur 3, 5, 6 ou 11.
• Le moteur CC ne tourne pas avec des valeurs PWM faibles, il ronronne seulement : la puissance ne suffit pas à vaincre le frottement statique. Démarre le moteur un court instant avec une valeur élevée puis baisse la vitesse, ou garde la valeur minimale vers 80–100. Tiens compte aussi de la chute de tension d'environ 2 V du L298N.
• Le moteur pas à pas vibre mais ne tourne pas : l'ordre des bobines est faux ou la vitesse est trop élevée. Pour le 28BYJ-48, utilise l'ordre Stepper(2048, IN1, IN3, IN2, IN4) et reste sous 15 tr/min.
• Le moteur pas à pas perd des pas : la charge est trop lourde, l'accélération trop brutale ou la limite de courant de l'A4988 trop basse. Règle Vref avec la formule I = Vref / (8 × Rcs), où Rcs est la résistance de mesure de courant de la carte, et utilise une accélération douce avec AccelStepper.
• L'A4988 a grillé : le câble du moteur a été branché ou débranché alors que le driver était alimenté, Vref était trop élevé ou il manquait le condensateur sur VMOT. Branche toujours le moteur hors tension.
• L'ESC ne fait pas tourner le moteur et bipe sans arrêt : il n'a pas reçu le signal de gaz minimum à la mise sous tension. Vérifie que setup() envoie writeMicroseconds(1000) et attend quelques secondes ; si besoin, calibre l'ESC comme l'indique sa notice.

En résumé, le moteur CC, c'est la vitesse, le servo, l'angle, et le moteur pas à pas, la position ; associe le bon moteur au bon driver et la moitié de ton projet est réglée. Commencer par un SG90 et un moteur TT, puis passer au pas à pas, est la façon la plus simple d'apprendre les trois. Dans l'application BlueGrays, tu trouveras des projets sur l'utilisation du servomoteur, le contrôle d'un servo avec un potentiomètre, l'utilisation du moteur pas à pas, un servo 360 degrés fabriqué à partir d'un moteur pas à pas, une voiture pilotée en Bluetooth avec un L298N et un robot qui évite les obstacles, chacun étape par étape avec schéma de câblage et code.