Composants · 13 min de lecture

Motoréducteur DC Arduino : moteur TT, vitesse, PWM et encodeur

Qu'est-ce qu'un motoréducteur DC (moteur TT jaune) ? Rapport 1:48, vitesse, couple, 3–6 V, courant, égalisation PWM, condensateur antiparasite, encodeur, N20.

Un motoréducteur DC est un petit moteur à courant continu rapide auquel on ajoute une boîte de vitesses (réducteur) sur l'arbre pour baisser la vitesse et augmenter le couple. Le moteur TT jaune en plastique qu'on voit sur les voitures robots Arduino est le membre le plus répandu de cette famille : le moteur intérieur tourne des milliers de fois par minute, mais grâce aux engrenages la roue ne fait que 100 à 250 tours par minute et gagne assez de force pour faire avancer une voiture sans peine. Il est généralement vendu en kit avec une roue en caoutchouc de 65 mm et fonctionne sous 3–6 V.

Dans ce guide, tu apprendras comment le rapport de réduction (1:48) modifie la vitesse et le couple, quelles sont la tension, le courant et la vitesse du moteur TT, comment mesurer le courant consommé et comment choisir le bon driver de moteur. Tu verras ensuite pourquoi deux moteurs tournent à des vitesses différentes avec la même valeur PWM, et tu les égaliseras d'abord par logiciel, puis en mesurant avec un disque encodeur. Tu trouveras aussi les condensateurs antiparasites, le code pour ESP32 et Raspberry Pi Pico et une comparaison avec le micromoteur N20.

Motoréducteur TT jaune et sa roue
Moteur TT jaune et roue de 65 mm : réducteur 1:48, tension de fonctionnement de 3–6 V et arbre qui sort des deux côtés.

Qu'est-ce qu'un motoréducteur DC et comment fonctionne-t-il ?

Un petit moteur à courant continu ordinaire tourne à vide à 8 000–10 000 tr/min, mais son couple est très faible ; monté directement sur une roue, il ne ferait pas bouger la voiture. Le réducteur, avec des engrenages qui s'emboîtent, abaisse cette vitesse élevée et augmente le couple dans la même proportion. Avec un rapport de 1:48, l'arbre de sortie fait 1 tour quand l'arbre du moteur en fait 48 : la vitesse est divisée par 48 et le couple multiplié par environ 48 (moins les pertes par frottement des engrenages). La puissance (couple × vitesse) reste la même ; le réducteur échange simplement de la vitesse contre de la force. C'est pourquoi le motoréducteur est idéal pour les mouvements lents mais puissants : roues, treuils, portes ou convoyeurs.

CaractéristiqueMoteur TT jaune (1:48, valeurs typiques)
Tension de fonctionnement3–6 V CC
Rapport de réduction1:48 (il existe aussi des versions 1:120 et 1:220)
Vitesse de sortie à videEnviron 90–120 tr/min sous 3 V, environ 200–250 tr/min sous 6 V
Courant à videEnviron 150 mA
Courant de blocageEnviron 1,2 A sous 4,5 V, environ 1,5 A sous 6 V
Couple de blocageEnviron 0,4 kg·cm sous 3 V, environ 0,8 kg·cm sous 6 V
ArbreArbre en plastique à double sortie avec deux méplats
Corps et engrenagesPlastique ; environ 70 × 22 × 18 mm, 30 g
RoueEnviron 65 mm de diamètre, caoutchouc

Calcul du rapport, de la vitesse et du couple

Quelques calculs simples suffisent pour choisir un moteur ou estimer la vitesse d'un robot. La circonférence d'une roue vaut π × diamètre : pour une roue de 65 mm, 3,14 × 6,5 ≈ 20,4 cm. Une roue qui tourne à vide à 200 tr/min sous 6 V parcourt 200 × 20,4 = 4080 cm par minute, soit environ 0,68 m/s ; en charge, cette valeur baisse de 20–30 %. Côté couple, 0,8 kg·cm au rayon de 3,25 cm de la roue correspondent à une force de poussée de 0,8 / 3,25 ≈ 0,25 kg ; c'est le maximum que le moteur peut fournir avant de caler. Un moteur ne devrait pas travailler longtemps au-delà d'environ un tiers de son couple de blocage.

RapportVitesse de sortie (6 V, à vide)CoupleUsage adapté
1:48Environ 200–250 tr/minMoyenVoiture robot, suiveur de ligne, robot évitant les obstacles
1:120Environ 80–100 tr/minÉlevéVoiture chargée, mouvement lent et contrôlé
1:220Environ 45–55 tr/minTrès élevéPorte, rideau, plateau tournant, suiveur solaire
Rapide mais faible ou lent mais puissant : avec le rapport de réduction, on ne gagne pas sur les deux tableaux. Pour une voiture de course, 1:48 suffit ; pour un robot qui doit gravir une rampe ou porter une lourde charge de piles, capteurs et écran, 1:120 est plus sûr. En choisissant les piles, tu peux vérifier la capacité totale avec le calculateur d'autonomie de batterie.

Sous quelle tension fonctionne un moteur TT ?

La tension nominale du moteur TT est de 3–6 V, et dans cette plage sa vitesse varie presque proportionnellement à la tension. La source la plus courante est un pack de 4 piles AA : des alcalines neuves donnent 6,0–6,4 V, des accus Ni-MH 4,8–5,2 V. Deux cellules Li-ion 18650 donnent 8,4 V une fois pleines, ce qui est trop pour un moteur de 6 V ; mais des drivers comme le L298N perdent environ 2 V, si bien qu'environ 6 V arrivent au moteur. Avec un driver plus efficace, tu peux limiter la valeur PWM maximale : pour obtenir en moyenne 6 V à partir de 8,4 V, utilise au plus 255 × 6 / 8,4 ≈ 182. Les détails sur les piles se trouvent dans les articles alimenter un Arduino sur piles et capacité de batterie en mAh.

N'alimente jamais le moteur directement par la broche 5V ou une broche numérique de l'Arduino. Une broche fournit au maximum 20–40 mA ; le moteur TT consomme 150 mA même à vide et 1,5 A bloqué. De plus, à l'arrêt, le moteur produit une tension inverse (force contre-électromotrice). Alimente toujours le moteur via un driver (L298N, L9110S, TB6612FNG) ou un MOSFET avec diode, à partir d'une batterie séparée dont le moins est relié au GND de l'Arduino.

Mesurer le courant consommé par le moteur

Connaître le courant permet de choisir le bon driver et de calculer l'autonomie de la batterie. Le plus simple est de régler un multimètre sur courant et de le brancher en série avec le moteur : mets la pointe rouge dans la borne 10A, débranche le fil qui vient du plus de la batterie et place le multimètre entre les deux. Mesure d'abord moteur en l'air (à vide), puis robot au sol, et enfin en retenant brièvement la roue avec la main. Pour l'utilisation du multimètre, vois comment utiliser un multimètre ; pour surveiller le courant en continu avec un Arduino, l'article capteur de courant ACS712.

SituationCourant typique (6 V)Que signifie-t-il ?
Roue en l'air, à vide150–170 mAFrottement des engrenages et des balais ; le moteur est en bon état
Robot roulant sur sol plat200–350 mAFonctionnement normal ; utilise cette valeur pour le calcul de batterie
Rampe ou tapis400–700 mALe moteur force ; envisage le rapport 1:120 ou un châssis plus léger
Roue bloquée1,2–1,5 APire cas pour le driver et la batterie ; si cela dure, le moteur chauffe
Au démarrageBrièvement jusqu'à 1 APeut faire chuter la tension de la batterie et réinitialiser l'Arduino

L'autonomie se déduit facilement de ces valeurs : un robot dont les deux moteurs consomment 0,6 A au total sur sol plat roule environ 2000 / 600 ≈ 3,3 heures avec des accus AA Ni-MH de 2000 mAh. Pour choisir le driver, on regarde le courant de blocage : le L9110S fournit environ 800 mA par canal, ce qui est limite pour des moteurs TT ; le TB6612FNG, avec 1,2 A en continu et 3,2 A en pointe par canal, a plus de marge. Pour calculer rapidement la relation entre courant, tension et résistance, utilise le calculateur de loi d'Ohm.

Choisir et brancher le driver de moteur

Module driver double L298N
Le module L298N peut piloter deux moteurs TT à la fois ; mais comme il perd environ 2 V, les moteurs reçoivent moins que la tension de la batterie.
DriverCourant par canalChute de tensionRemarque
L298N2 AEnviron 1,5–2,5 VRobuste et courant ; avec 4×AA il reste environ 4–4,5 V au moteur
L293D (shield)0,6 A (pointe 1,2 A)Environ 1,5–2,5 VSe monte sur l'Uno, pilote quatre moteurs ; limite pour un TT
L9110S0,8 AFaiblePetit et bon marché ; peine au courant de blocage
TB6612FNG1,2 A (pointe 3,2 A)Très faible (MOSFET)Exploite bien la tension de la batterie, l'un des meilleurs choix pour un TT
ConnexionArduino UnoESP32Raspberry Pi Pico
L298N ENA (vitesse moteur gauche, PWM)D5GPIO 25GP15
L298N IN1 / IN2D7 / D8GPIO 27 / GPIO 33GP14 / GP13
L298N ENB (vitesse moteur droit, PWM)D6GPIO 26GP10
L298N IN3 / IN4D9 / D4GPIO 32 / GPIO 4GP12 / GP11
Sortie encodeur gauche / droit (LM393)D2 / D3GPIO 34 / GPIO 35GP16 / GP17
VCC du module encodeur5V3V33V3(OUT)
GNDMoins de la batterie, L298N et GND de l'Arduino communsCommunCommun

N'oublie pas de retirer les cavaliers d'ENA et ENB ; s'ils restent en place, le moteur ignore le PWM et tourne toujours à pleine vitesse. Toutes les broches du L298N ainsi que le freinage et la roue libre sont détaillés dans l'article moteur DC et L298N. Si un moteur tourne dans le mauvais sens, le plus propre est d'inverser ses deux fils sur le driver plutôt que de modifier le code.

Code Arduino : avancer, reculer, tourner et égaliser la vitesse

C++ (Arduino IDE)
1// İki TT motoru L298N ile: ileri, geri, dönüş ve hız dengeleme
2// Two TT motors with an L298N: forward, reverse, turning and speed trim
3const byte ENA = 5, IN1 = 7, IN2 = 8;    // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4;    // sağ motor / right motor
5const int MIN_PWM = 70;                  // altında motor kalkamaz / below this the motor won't start
6const float SOL_KATSAYI = 1.00;          // hızlı motoru yavaşlatmak için / to slow the faster motor
7const float SAG_KATSAYI = 0.92;
8
9void motorSur(byte en, byte inA, byte inB, int hiz, float katsayi) {   // hiz: -255..255
10  int pwm = abs(hiz) * katsayi;
11  if (pwm > 0 && pwm < MIN_PWM) pwm = MIN_PWM;    // ölü bölgeyi atla / skip the dead zone
12  digitalWrite(inA, hiz > 0 ? HIGH : LOW);
13  digitalWrite(inB, hiz < 0 ? HIGH : LOW);
14  analogWrite(en, hiz == 0 ? 0 : pwm);
15}
16
17void sur(int sol, int sag) {
18  motorSur(ENA, IN1, IN2, sol, SOL_KATSAYI);
19  motorSur(ENB, IN3, IN4, sag, SAG_KATSAYI);
20}
21
22void setup() {
23  byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24  for (byte p : pinler) pinMode(p, OUTPUT);
25}
26
27void loop() {
28  sur(200, 200);    // ileri / forward
29  delay(2000);
30  sur(0, 0);        // dur / stop
31  delay(500);
32  sur(-180, -180);  // geri / reverse
33  delay(1500);
34  sur(0, 0);
35  delay(500);
36  sur(180, -180);   // yerinde sağa dön / spin right in place
37  delay(600);
38  sur(0, 0);
39  delay(1500);
40}

Dans le code, MIN_PWM est la plus petite valeur PWM à laquelle le moteur vainc le frottement statique et commence à tourner. Les broches 5 et 6 de l'Uno produisent un PWM d'environ 980 Hz ; sous une valeur comprise entre 60 et 90, les moteurs TT se contentent généralement de bourdonner sans tourner. Trouver cette valeur pour ton moteur est facile : pars de PWM 0, augmente de cinq en cinq et note la valeur à laquelle la roue tourne pour la première fois. Pour le principe du PWM et sa fréquence, vois Qu'est-ce que la PWM ?.

Pourquoi deux moteurs tournent-ils à des vitesses différentes ?

Quand tu donnes le même PWM à deux moteurs TT de la même boîte, tu t'attends à ce que le robot aille tout droit, mais le plus souvent la voiture dérive d'un côté. La raison tient aux écarts de fabrication des moteurs bon marché : tolérances des balais et des aimants, frottement des engrenages, lubrification et alignement des arbres en plastique varient légèrement d'un moteur à l'autre. La tolérance de ±10 % annoncée par les vendeurs peut se traduire par jusqu'à 20 % d'écart de vitesse entre deux moteurs. En outre, l'écart n'est pas fixe : il change quand la tension de la batterie baisse, quand le moteur chauffe ou quand le sol change. Et comme les moteurs sont montés en miroir, l'un tourne en avant et l'autre en arrière du point de vue du moteur, et certains moteurs n'ont pas la même vitesse dans les deux sens.

  1. Fais avancer le robot sur 2–3 mètres de sol plat avec le même PWM et note de quel côté il dérive.
  2. Si la voiture part à droite, le moteur gauche est plus rapide ; baisse SOL_KATSAYI à 0,95 et recommence.
  3. Modifie le facteur par pas de 0,01–0,02 jusqu'à ce que la voiture aille droit ; il faut généralement 3 à 5 essais.
  4. Refais le test en marche arrière ; si l'écart est important, utilise des facteurs différents pour avancer et reculer.
  5. Le réglage peut dériver quand la tension de la batterie change ; pour une solution durable qui se corrige seule, passe à la méthode avec encodeur ci-dessous.

Supprimer les parasites : condensateurs sur le moteur

Quand un moteur DC à balais tourne, de petites étincelles se forment entre les balais et le collecteur. Elles provoquent des pics de tension sur la ligne d'alimentation et des parasites électriques rayonnés dans l'air. Les symptômes sont connus : l'Arduino redémarre tout seul quand le moteur tourne, des caractères étranges apparaissent dans le moniteur série, le capteur à ultrasons mesure des distances absurdes ou la liaison Bluetooth se coupe. La solution consiste à étouffer les parasites à la source, directement sur le moteur.

  • 100 nF entre les bornes du moteur : soude entre les deux bornes de chaque moteur un condensateur céramique de 100 nF marqué 104. Garde les pattes aussi courtes que possible.
  • Deux autres vers le boîtier : sur les moteurs à boîtier métallique, ajouter un 100 nF de chaque borne vers le boîtier réduit encore les parasites. Le boîtier du moteur TT étant en plastique, le seul condensateur entre les bornes suffit généralement.
  • Électrolytique sur l'alimentation du driver : place un condensateur électrolytique de 470–1000 µF à l'entrée d'alimentation du L298N ; il adoucit la chute de tension de la batterie au démarrage.
  • Torsade les fils : torsade ensemble les deux fils du moteur ; ils rayonnent ainsi moins de parasites.
  • Sépare les alimentations : si possible, alimente l'Arduino et les moteurs avec des batteries séparées et relie les GND en un seul point.

Tu trouveras le fonctionnement des condensateurs et la lecture de leurs codes dans Qu'est-ce qu'un condensateur ?, et d'autres causes de redémarrage quand le moteur tourne dans l'Arduino redémarre tout seul.

Mesurer la vitesse avec un disque encodeur

L'arbre du moteur TT sort des deux côtés ; sur l'extrémité qui ne porte pas la roue, on monte généralement le disque encodeur en plastique à 20 fentes fourni avec le kit. Les fentes passent entre les branches d'un capteur optique à fourche en U (un module à comparateur LM393), et chaque fente produit une impulsion. Comme le disque tourne à la même vitesse que la roue, 20 impulsions correspondent à un tour de roue. Si l'on compte 30 impulsions en une demi-seconde, la roue a fait 30 / 20 = 1,5 tour, soit 1,5 × 120 = 180 tr/min. En multipliant le nombre de tours par la circonférence de la roue, tu obtiens aussi la distance parcourue : chaque impulsion vaut environ 20,4 / 20 ≈ 1 cm.

Le code suivant mesure la vitesse des deux roues et ajuste automatiquement le PWM du moteur droit jusqu'à ce que les deux côtés comptent autant d'impulsions. C'est un simple régulateur proportionnel (P) : plus l'écart est grand, plus la correction est forte. Comme les capteurs à fourche peuvent produire plusieurs impulsions au passage d'un bord, la fonction d'interruption ignore les impulsions espacées de moins de 2 ms. Pour les détails sur les interruptions, vois l'article les interruptions Arduino.

C++ (Arduino IDE)
1// 20 yarıklı enkoder diskiyle devir ölçümü ve iki motoru eşitleme
2// RPM measurement with 20-slot encoder discs and matching two motors
3const byte ENA = 5, IN1 = 7, IN2 = 8;      // sol motor / left motor
4const byte ENB = 6, IN3 = 9, IN4 = 4;      // sağ motor / right motor
5const byte ENC_SOL = 2, ENC_SAG = 3;       // LM393 yarık sensörleri / slot sensors
6const byte YARIK = 20;                     // disk başına yarık / slots per disc
7const int TEMEL_PWM = 180;                 // sol motorun sabit hızı / fixed left speed
8const float KP = 4.0;                      // oransal kazanç / proportional gain
9
10volatile unsigned int solSayac = 0, sagSayac = 0;
11volatile unsigned long solSon = 0, sagSon = 0;
12int sagPwm = TEMEL_PWM;
13unsigned long oncekiZaman = 0;
14
15void solDarbe() {
16  unsigned long t = micros();
17  if (t - solSon > 2000) {                 // 2 ms'den yakın darbeleri yok say / ignore bounces
18    solSayac++;
19    solSon = t;
20  }
21}
22
23void sagDarbe() {
24  unsigned long t = micros();
25  if (t - sagSon > 2000) {
26    sagSayac++;
27    sagSon = t;
28  }
29}
30
31void setup() {
32  Serial.begin(9600);
33  byte pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
34  for (byte p : pinler) pinMode(p, OUTPUT);
35  pinMode(ENC_SOL, INPUT);
36  pinMode(ENC_SAG, INPUT);
37  attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
38  attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
39  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);   // iki motor da ileri / both forward
40  digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
41  analogWrite(ENA, TEMEL_PWM);
42  analogWrite(ENB, sagPwm);
43}
44
45void loop() {
46  if (millis() - oncekiZaman >= 500) {     // yarım saniyede bir / every half second
47    oncekiZaman = millis();
48    noInterrupts();
49    unsigned int sol = solSayac, sag = sagSayac;
50    solSayac = 0;
51    sagSayac = 0;
52    interrupts();
53
54    float solDevir = sol * 120.0 / YARIK;  // 0,5 s'deki darbe -> d/dk / pulses in 0.5 s -> rpm
55    float sagDevir = sag * 120.0 / YARIK;
56    sagPwm += (int)(KP * ((int)sol - (int)sag));    // sağ geride kaldıysa hızlandır / speed up if behind
57    sagPwm = constrain(sagPwm, 70, 255);
58    analogWrite(ENB, sagPwm);
59
60    Serial.print(F("Sol / Left: "));
61    Serial.print(solDevir, 0);
62    Serial.print(F(" d/dk  Sag / Right: "));
63    Serial.print(sagDevir, 0);
64    Serial.print(F(" d/dk  Sag PWM: "));
65    Serial.println(sagPwm);
66  }
67}

En lançant le code, tu verras dans le moniteur série que la valeur PWM droite change pendant les premières secondes, puis que les vitesses des deux roues se rapprochent. Si KP est trop grand, le moteur droit oscille en accélérant et ralentissant ; s'il est trop petit, la correction est lente ; essayer des valeurs entre 2 et 6 est un bon point de départ. Pour une conduite plus précise, tu peux aussi égaliser la distance totale ou écrire un vrai régulateur PID. Le capteur de l'encodeur fonctionne un peu comme les capteurs infrarouges des robots suiveurs de ligne ; détails dans l'article capteur infrarouge TCRT5000.

Piloter un moteur TT avec un ESP32

Les broches 3,3 V de l'ESP32 pilotent sans problème les entrées du L298N et du TB6612FNG, car ces drivers considèrent tout ce qui dépasse 2,3 V comme HIGH. Le cœur Arduino de l'ESP32 prend en charge analogWrite ; la fréquence PWM par défaut est d'environ 1 kHz. Alimente les capteurs de l'encodeur en 3V3 pour que leurs sorties soient aussi en 3,3 V ; les GPIO 34 et 35 sont des entrées seules, idéales pour les encodeurs. Grâce au Wi-Fi et au Bluetooth de l'ESP32, tu peux piloter le robot depuis ton téléphone et afficher la vitesse sur une page web.

C++ (Arduino IDE)
1// ESP32: iki TT motor, enkoderle devir ölçümü / two TT motors with RPM measurement
2const int ENA = 25, IN1 = 27, IN2 = 33;      // sol motor / left motor
3const int ENB = 26, IN3 = 32, IN4 = 4;       // sağ motor / right motor
4const int ENC_SOL = 34, ENC_SAG = 35;        // yalnız giriş pinleri / input-only pins
5const int YARIK = 20;
6
7volatile uint32_t solSayac = 0, sagSayac = 0;
8portMUX_TYPE kilit = portMUX_INITIALIZER_UNLOCKED;
9
10void IRAM_ATTR solDarbe() {
11  portENTER_CRITICAL_ISR(&kilit);
12  solSayac++;
13  portEXIT_CRITICAL_ISR(&kilit);
14}
15
16void IRAM_ATTR sagDarbe() {
17  portENTER_CRITICAL_ISR(&kilit);
18  sagSayac++;
19  portEXIT_CRITICAL_ISR(&kilit);
20}
21
22void sur(int sol, int sag) {                 // -255..255
23  digitalWrite(IN1, sol > 0); digitalWrite(IN2, sol < 0);
24  digitalWrite(IN3, sag > 0); digitalWrite(IN4, sag < 0);
25  analogWrite(ENA, abs(sol));
26  analogWrite(ENB, abs(sag));
27}
28
29void setup() {
30  Serial.begin(115200);
31  int pinler[] = {ENA, IN1, IN2, ENB, IN3, IN4};
32  for (int p : pinler) pinMode(p, OUTPUT);
33  pinMode(ENC_SOL, INPUT);
34  pinMode(ENC_SAG, INPUT);
35  attachInterrupt(digitalPinToInterrupt(ENC_SOL), solDarbe, RISING);
36  attachInterrupt(digitalPinToInterrupt(ENC_SAG), sagDarbe, RISING);
37  sur(180, 180);                             // ileri / forward
38}
39
40void loop() {
41  delay(1000);
42  portENTER_CRITICAL(&kilit);
43  uint32_t sol = solSayac, sag = sagSayac;
44  solSayac = 0;
45  sagSayac = 0;
46  portEXIT_CRITICAL(&kilit);
47  Serial.printf("Sol / Left: %.0f d/dk  Sag / Right: %.0f d/dk\n",
48                sol * 60.0 / YARIK, sag * 60.0 / YARIK);   // 1 s'deki darbe -> d/dk / pulses in 1 s -> rpm
49}

Moteur TT avec la Raspberry Pi Pico et MicroPython

Sur la Pico, chaque GPIO peut générer du PWM. En MicroPython, tu règles la fréquence de l'objet PWM sur 1 kHz et tu donnes la vitesse avec duty_u16() dans la plage 0–65535 ; 65535 correspond à la pleine vitesse. Le code suivant fait tourner le moteur gauche à différentes vitesses et mesure sa vitesse avec l'encodeur. Pour alimenter la Pico avec la même batterie que les moteurs, tu peux relier la sortie 5V du L298N à la broche VSYS.

MicroPython
1from machine import Pin, PWM
2import machine
3import time
4
5ena = PWM(Pin(15))                     # sol motor hızı / left motor speed
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9YARIK = 20
10sayac = 0
11
12def darbe(pin):                        # enkoder kesmesi / encoder interrupt
13    global sayac
14    sayac += 1
15
16enc = Pin(16, Pin.IN)
17enc.irq(trigger=Pin.IRQ_RISING, handler=darbe)
18
19def motor(hiz):                        # hiz: -100..100 (%)
20    in1.value(1 if hiz > 0 else 0)
21    in2.value(1 if hiz < 0 else 0)
22    ena.duty_u16(int(abs(hiz) * 65535 / 100))
23
24for hiz in (40, 60, 80, 100):
25    motor(hiz)
26    time.sleep(1)                      # hızlanmayı bekle / let it settle
27    durum = machine.disable_irq()
28    sayac = 0
29    machine.enable_irq(durum)
30    time.sleep(1)                      # 1 saniye say / count for 1 second
31    print("PWM %{}: {} d/dk".format(hiz, sayac * 60 // YARIK))
32motor(0)

Moteur TT ou micromoteur N20 ?

Micromotoréducteur DC N20
Micromotoréducteur N20 : engrenages métalliques, arbre en D de 3 mm et environ un cinquième du volume d'un moteur TT.
CaractéristiqueMoteur TT (jaune)Micromoteur N20
TailleEnviron 70 × 22 × 18 mmSection d'environ 12 × 10 mm, 25–35 mm de long
EngrenagesPlastiqueMétal
Versions de tension3–6 VVersions 3 V, 6 V et 12 V
Rapport de réductionGénéralement 1:48 (1:120, 1:220)Large choix de 1:10 à 1:1000
ArbrePlastique, avec deux méplatsArbre métallique en D de 3 mm
EncodeurDisque et capteur à fourche séparésVersions avec encodeur Hall magnétique monté à l'arrière courantes
Prix et durabilitéTrès bon marché, engrenages qui s'usent avec le tempsPlus cher, plus précis et plus durable
Projets adaptésRobots pédagogiques, kits de voiture robotMini-sumo, suiveurs de ligne rapides, petits mécanismes

En résumé, le moteur TT est le meilleur point de départ pour une première voiture robot et les projets scolaires, car il est bon marché et facile à monter. Si tu as besoin d'un mécanisme plus petit, plus précis et plus durable, ou si tu construis un robot de compétition, préfère le N20 ; les N20 à encodeur mesurent sur l'arbre du moteur et donnent des centaines d'impulsions par tour de roue, pour une mesure de vitesse bien plus fine. Pour voir quel type de moteur convient à quel usage, lis l'article différences entre moteur DC, servo et pas à pas.

Idées de projets avec un motoréducteur

  • Voiture robot : construis une voiture pilotée en Bluetooth avec deux moteurs TT, une roue folle et un L298N ; toutes les étapes dans l'article fabriquer une voiture robot Arduino.
  • Robot suiveur de ligne : suis une ligne noire avec des capteurs infrarouges ; l'équilibre de vitesse des moteurs est ici crucial. Vois robot suiveur de ligne.
  • Robot qui évite les obstacles : détecte les obstacles avec un HC-SR04 et change de direction ; montage dans l'article robot évitant les obstacles.
  • Roue de mesure : fais rouler au sol une roue à encodeur pour créer un mètre numérique pour les pièces ; chaque impulsion vaut environ 1 cm.
  • Rideau automatique : ouvre le rideau le matin et ferme-le le soir avec un moteur TT 1:220 ; déclenche-le selon la lumière avec une LDR.
  • Plateau tournant d'exposition : fabrique avec un moteur lent un support qui fait tourner doucement un petit produit ou une maquette.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Le moteur bourdonne mais ne tourne pasPWM sous la zone morte ou batterie faibleAugmente MIN_PWM, mesure la tension de la batterie
Le moteur toujours à pleine vitesseCavalier ENA/ENB en place ou broche sans PWMRetire le cavalier ; utilise les broches 3, 5, 6, 9, 10, 11 sur l'Uno
La voiture ne va pas droitÉcart de fabrication entre les moteursÉquilibre avec un facteur ou crée une boucle fermée avec des encodeurs
L'Arduino redémarre quand le moteur tourneLe courant de démarrage fait chuter la tension, parasites des balaisAjoute 100 nF aux bornes du moteur et 470 µF à l'entrée du driver ; alimente l'Arduino à part
Une roue tourne à l'enversFils du moteur inversésInverse les deux fils de ce moteur sur le driver
Vitesse plus faible que prévu2 V perdus dans le L298NUtilise une batterie de tension plus élevée ou un driver MOSFET comme le TB6612FNG
L'encodeur compte trop d'impulsionsRebonds du capteur au bord de la fenteUtilise un filtre de 2 ms dans l'interruption, centre le disque dans le capteur
Après avoir monté ton robot, teste chaque moteur séparément, roue en l'air : vérifie que avancer, reculer et s'arrêter fonctionnent correctement et que les deux moteurs font à peu près le même bruit. Si l'un sonne nettement différemment, ses engrenages frottent peut-être ou ont une dent cassée ; régler le problème avant de poser le robot au sol fait gagner des heures.

Le motoréducteur TT est une pièce bon marché mais très pédagogique pour comprendre le compromis entre vitesse et couple dans un réducteur, le contrôle de vitesse par PWM et la rétroaction par encodeur. Avec le bon driver, quelques condensateurs et un simple code d'équilibrage, ton robot roule droit et de façon fiable. Dans l'application BlueGrays, tu trouveras la voiture pilotée en Bluetooth, le robot qui évite les obstacles et des projets avec capteurs infrarouges, avec schémas et code pas à pas, pour transformer tout de suite ces moteurs en projet.

Questions fréquentes

Qu'est-ce qu'un motoréducteur DC ?

Un motoréducteur DC est un petit moteur à courant continu rapide équipé d'une boîte d'engrenages sur son arbre. Les engrenages réduisent la vitesse et augmentent le couple dans la même proportion ; avec 1:48, l'arbre de sortie fait 1 tour pendant que l'arbre du moteur en fait 48. Un petit moteur peut ainsi déplacer facilement une voiture robot ou un mécanisme.

Sous quelle tension fonctionne un moteur TT ?

Les moteurs TT jaunes fonctionnent entre 3 et 6 V, et l'alimentation la plus courante est un pack de 4 piles AA. Ils tournent à environ 90–120 tr/min sous 3 V et 200–250 tr/min sous 6 V. Au-delà de 6 V, le moteur va plus vite mais chauffe et use rapidement ses engrenages.

Quel courant consomme un moteur TT ?

Environ 150 mA à vide et 200–350 mA dans un robot qui roule sur sol plat. Quand la roue est bloquée, le courant peut monter à 1,5 A sous 6 V. C'est pourquoi le driver et la batterie doivent être choisis en fonction du courant de blocage, et le moteur ne doit jamais être alimenté directement par une broche de l'Arduino.

Pourquoi deux moteurs DC ne tournent-ils pas à la même vitesse ?

Les moteurs bon marché diffèrent par leurs balais, leurs aimants, le frottement des engrenages et la lubrification ; même au même PWM, leurs vitesses peuvent varier de 10–20 %. La tension de la batterie et la température modifient aussi l'écart. Appliquer un facteur au moteur le plus rapide dans le logiciel, ou mesurer la vitesse des deux roues avec des encodeurs et ajuster le PWM automatiquement, règle le problème.

Pourquoi met-on un condensateur sur un moteur DC ?

En tournant, les moteurs à balais produisent de petites étincelles qui génèrent des parasites électriques. Ces parasites peuvent réinitialiser l'Arduino, fausser les mesures des capteurs et couper les liaisons sans fil. Un condensateur céramique de 100 nF soudé entre les bornes du moteur supprime les parasites à la source.

Comment mesurer la vitesse d'un moteur avec un disque encodeur ?

Un disque à fentes monté sur l'arbre du moteur passe dans un capteur optique à fourche, et chaque fente produit une impulsion. L'Arduino compte ces impulsions par interruption ; avec un disque à 20 fentes, 20 impulsions font un tour de roue. En divisant les impulsions d'une seconde par 20 puis en multipliant par 60, on obtient les tours par minute.

Voir tous les projets
Voiture contrôlée par Bluetooth avec L298N
AR-80Avancé
Premium

Voiture contrôlée par Bluetooth avec L298N

Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

5.0(39)
66
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

5.0(38)
49
TCRT5000 Détection de surface noire et blanche
AR-78Intermédiaire
Premium

TCRT5000 Détection de surface noire et blanche

Avec le petit capteur qui sert d'œil aux robots suiveurs de ligne, tu sais si le sol est noir ou blanc.

4.7(40)
49
Lecture de réflexion (proximité) avec TCRT5000
AR-77Intermédiaire
Premium

Lecture de réflexion (proximité) avec TCRT5000

Avec un petit capteur qui envoie une lumière invisible et mesure ce qui revient, tu détectes la surface placée devant lui.

4.6(33)
43
Servocommande avec joystick
AR-60Intermédiaire
Premium

Servocommande avec joystick

Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.

4.7(42)
58
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)

Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

4.5(19)
32
ESP32 LED Fade avec PWM
ES-8Débutant

ESP32 LED Fade avec PWM

Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

Raspberry Pi Pico PWM LED Fade (Effet Respiration)

La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.

4