Guides · 12 min de lecture

Comparatif driver moteur : L298N, L293D, TB6612FNG, A4988

Comparatif des drivers moteur L298N, L293D, L9110S, TB6612FNG et A4988 : courant, chute de tension, rendement, compatibilité 3,3 V, robot et pas à pas.

Quand tu compares des drivers moteur, trois questions viennent d'abord : quel courant ton moteur consomme-t-il, sous quelle tension fonctionne-t-il et quel niveau logique utilise ta carte (5 V ou 3,3 V) ? Les cinq drivers les plus utilisés par les makers sont le L298N, le L293D, le L9110S, le TB6612FNG et l'A4988. La réponse courte : TB6612FNG pour un petit robot sur batterie, L298N pour des moteurs 12 V de 1 à 2 A, L9110S pour le budget minimal, shield L293D pour piloter quatre moteurs avec un Arduino Uno, et A4988 pour les moteurs pas à pas bipolaires comme le NEMA 17.

Dans ce guide, on regarde pour chaque driver le courant réellement disponible, la tension perdue, l'effet sur l'autonomie et l'échauffement, et la compatibilité avec les cartes 3,3 V comme l'ESP32 et la Raspberry Pi Pico. Tu trouveras ensuite des codes fonctionnels pour piloter deux moteurs avec Arduino, ESP32 et Pico, un exemple de moteur pas à pas avec l'A4988 et un tableau de choix par projet.

Module driver moteur L298N avec dissipateur
Module driver moteur L298N : deux canaux, jusqu'à 2 A, grand dissipateur en aluminium et régulateur 5 V sur la carte.

Qu'est-ce qu'un driver moteur et pourquoi en as-tu besoin ?

Une broche numérique d'Arduino fournit au maximum 20 à 40 mA environ ; même un petit moteur réducteur TT consomme 150 à 250 mA en marche et près de 1 A quand il cale (stall). Brancher le moteur directement sur la broche la grille, et les pics de tension inverse du moteur réinitialisent le microcontrôleur. Un driver moteur est un circuit de commutation qui prend le signal faible du microcontrôleur et alimente le moteur depuis une source séparée. Au cœur d'un driver DC se trouve le pont en H : en fermant les quatre interrupteurs par paires diagonales, on inverse la polarité du moteur, qui tourne en avant ou en arrière. La vitesse se règle avec un signal PWM qui ouvre et ferme les interrupteurs des milliers de fois par seconde. Les drivers pas à pas vont plus loin : ils alimentent les bobines à tour de rôle en limitant le courant pour faire tourner le moteur par angles précis.

Présentation rapide des cinq drivers

  • L298N : ancien mais très répandu, pont en H à transistors bipolaires à deux canaux. Il supporte une tension élevée (5–35 V sur le module) et jusqu'à 2 A par canal, mais perd 2 à 3 V et chauffe beaucoup. Détails dans commande de moteur DC avec L298N.
  • L293D : circuit DIP à 16 broches ; 600 mA en continu par canal, 1,2 A en pointe et diodes de protection intégrées. Il est connu grâce au shield moteur L293D pour Arduino Uno, qui pilote quatre moteurs DC.
  • L9110S : l'option la moins chère et la plus petite. Il fonctionne de 2,5 à 12 V et fournit environ 800 mA par canal ; pas de broche enable, chaque moteur se commande avec deux broches. Détails dans l'article driver moteur L9110S.
  • TB6612FNG : pont en H moderne à MOSFET. 1,2 A en continu et 3,2 A en pointe par canal, résistance à l'état passant d'environ 0,5 ohm : il ne chauffe presque pas et accepte une logique dès 2,7 V.
  • A4988 : ce n'est pas un driver DC mais un driver de moteur pas à pas bipolaire. Tension moteur de 8 à 35 V, limite de courant réglable et micro-pas jusqu'à 1/16. La mise en route est détaillée dans driver pas à pas A4988.

Tableau comparatif : courant, tension, compatibilité 3,3 V et prix

CaractéristiqueL298NL293DL9110STB6612FNGA4988
Type de moteur2 DC ou 1 pas à pas bipolaire2 DC ou 1 pas à pas bipolaire2 DC2 DC ou 1 pas à pas bipolaire1 pas à pas bipolaire
Tension moteur5–35 V (module)4,5–36 V2,5–12 V4,5–13,5 V (max absolu 15 V)8–35 V
Courant continu (par canal)2 A (avec dissipateur)0,6 Aenviron 0,8 A1,2 Aenviron 1 A sans dissipateur, 2 A avec refroidissement
Courant de pointe3 A1,2 Aenviron 1,5 A3,2 A2 A
Technologie de commutationTransistor bipolaireTransistor bipolaireTransistor (faible saturation)MOSFETMOSFET + contrôle du courant
Chute de tensionenviron 2–3 Venviron 1,8–2,6 Venviron 1 Venviron 0,5 V (à 1 A)Courant contrôlé, sans problème
RendementFaibleFaibleMoyenÉlevéÉlevé
Alimentation logique5 V (régulateur sur le module)4,5–7 V (VCC1)Commune avec l'alimentation moteur2,7–5,5 V (VCC)3–5,5 V (VDD)
Compatibilité signal 3,3 VFonctionne en généralEntrées OK, alimentation logique 5 VTotalement compatibleTotalement compatibleTotalement compatible
Prix (relatif)BasBasTrès basMoyenBas

Les valeurs de courant du tableau sont des limites de fiche technique ; en pratique, la zone sûre est d'environ 70 % de ces valeurs. Par exemple, les 2 A du L298N ne sont possibles qu'avec un grand dissipateur et une bonne ventilation ; si tu forces un module sans dissipateur au-dessus de 1 A en continu, le circuit chauffe vite et passe en protection thermique. Pour connaître le vrai besoin d'un moteur, ne regarde pas le courant de fonctionnement mais le courant de calage (stall) : c'est ce que le moteur consomme quand la roue bute sur un obstacle, et le driver doit au moins le supporter brièvement. La colonne prix est un classement relatif : le L9110S est généralement le module le moins cher, et le TB6612FNG, un peu plus cher, compense largement par son rendement et sa petite taille.

Chute de tension et rendement : pourquoi le L298N chauffe-t-il autant ?

Dans les drivers à transistors bipolaires (L298N, L293D), le courant traverse deux transistors avant d'atteindre le moteur et perd environ 1 à 1,5 V dans chacun. Cette perte se transforme en chaleur : la puissance perdue vaut P = V_chute × I. Dans le TB6612FNG à MOSFET, les interrupteurs se comportent comme une résistance et la perte vaut P = I² × R_on ; pour 0,5 ohm et 1 A, cela ne fait que 0,5 W. Avec des batteries basses tension, l'écart est énorme : perdre 2 V sur un pack de 6 V, c'est jeter un tiers de la puissance du moteur. Tu peux refaire ces calculs pour ton moteur avec la calculatrice de loi d'Ohm et estimer l'autonomie avec le calculateur d'autonomie de batterie. Le tableau suivant montre les valeurs typiques pour une alimentation de 6 V et un courant moteur de 0,6 A :

DriverChute de tension typiqueTension restante au moteurPuissance dissipée dans le driverRendement approx.
L298N1,8 V4,2 V1,08 W70 %
L293D2,0 V4,0 V1,2 W67 %
L9110S0,8 V5,2 V0,48 W87 %
TB6612FNG0,3 V5,7 V0,18 W95 %
Si tu dois utiliser un L298N, choisis une alimentation moteur supérieure d'environ 2 V à la tension nominale du moteur. Par exemple, 8 V pour un moteur 6 V et environ 14 V pour un moteur 12 V compensent la perte du driver. Avec le TB6612FNG, cette correction est inutile.

Compatibilité 3,3 V : quel driver avec l'ESP32 et la Raspberry Pi Pico ?

Les broches de l'ESP32 et de la Pico sortent en 3,3 V. L'alimentation logique (VCC) du TB6612FNG pouvant être reliée directement au 3,3 V, c'est l'association la plus propre avec ces cartes. L'entrée logique de l'A4988 fonctionne aussi de 3 à 5,5 V, et les entrées du L9110S détectent sans problème un signal 3,3 V. Sur le L298N et le L293D, le seuil de niveau haut est d'au moins 2,3 V, donc un signal 3,3 V fonctionne dans la plupart des cas ; mais la partie logique du circuit a besoin d'une alimentation 5 V, et travailler près du seuil peut provoquer des déclenchements erronés dans un environnement bruité. Bref, si tu démarres un projet ESP32 ou Pico, commence avec le TB6612FNG ; si tu as un L298N, il fonctionnera souvent, mais n'oublie jamais la masse commune.

Câblage : tableau des broches L298N et TB6612FNG

FonctionBroche L298NBroche TB6612FNGArduino UnoESP32Raspberry Pi Pico
Vitesse moteur A (PWM)ENAPWMAD5GPIO 25GP16
Sens moteur A 1IN1AIN1D4GPIO 26GP17
Sens moteur A 2IN2AIN2D7GPIO 27GP18
Vitesse moteur B (PWM)ENBPWMBD6GPIO 13GP21
Sens moteur B 1IN3BIN1D8GPIO 33GP19
Sens moteur B 2IN4BIN2D9GPIO 32GP20
Veille / activationAucuneSTBYD10GPIO 4GP22
Alimentation logique+5V (sortie du régulateur)VCC5V3V33V3 (OUT)
Alimentation moteur+12VVMSource externeSource externeSource externe
MasseGNDGNDGNDGNDGND
L'erreur la plus fréquente est de ne pas relier la masse de l'alimentation moteur à celle de la carte ; sans masse commune, les signaux de sens et de PWM n'ont plus aucun sens. La deuxième grosse erreur est de laisser le cavalier 5V-EN en place sur un module L298N alimenté au-dessus de 12 V : le régulateur de la carte peut surchauffer et griller. Au-delà de 12 V, retire le cavalier et alimente la broche +5V avec le 5V de l'Arduino. Et n'alimente jamais les moteurs depuis la broche 5V de l'Arduino.

Pas à pas : piloter deux moteurs DC avec Arduino

  1. Relie la source moteur (par exemple 7,4 V avec 2 accus 18650 ou 9 V avec 6 piles AA) à l'entrée d'alimentation moteur du driver : +12V sur le L298N, VM sur le TB6612FNG.
  2. Relie le pôle négatif de la source à la fois au GND du driver et au GND de l'Arduino.
  3. Si tu utilises un L298N, retire les cavaliers sur ENA et ENB ; sinon tu ne pourras pas régler la vitesse et le moteur tournera toujours à fond.
  4. Relie les broches PWM à D5 et D6 et les broches de sens à D4, D7, D8 et D9 comme dans le tableau. Sur le TB6612FNG, relie STBY à D10 et VCC au 5V de l'Arduino.
  5. Branche les moteurs sur les sorties OUT1–OUT2 (A01–A02) et OUT3–OUT4 (B01–B02). Si un moteur tourne à l'envers, inverse ses fils ou change le sens dans le code.
  6. Téléverse le code ci-dessous et fais le premier test avec les roues en l'air.
C++ (Arduino IDE)
1// L298N ya da TB6612FNG ile iki DC motor / Two DC motors with L298N or TB6612FNG
2const int ENA  = 5;   // PWMA (PWM pini / PWM pin)
3const int IN1  = 4;   // AIN1
4const int IN2  = 7;   // AIN2
5const int ENB  = 6;   // PWMB (PWM pini / PWM pin)
6const int IN3  = 8;   // BIN1
7const int IN4  = 9;   // BIN2
8const int STBY = 10;  // yalnız TB6612FNG / TB6612FNG only
9
10// hiz: -255 (tam geri) ... 255 (tam ileri) / speed: -255 (full reverse) ... 255 (full forward)
11void motorSur(int en, int inA, int inB, int hiz) {
12  hiz = constrain(hiz, -255, 255);
13  if (hiz > 0) {
14    digitalWrite(inA, HIGH);
15    digitalWrite(inB, LOW);
16  } else if (hiz < 0) {
17    digitalWrite(inA, LOW);
18    digitalWrite(inB, HIGH);
19  } else {
20    digitalWrite(inA, LOW);   // dur / stop
21    digitalWrite(inB, LOW);
22  }
23  analogWrite(en, abs(hiz));
24}
25
26// Kısa devre freni: iki giriş HIGH / Short brake: both inputs HIGH
27void fren(int en, int inA, int inB) {
28  digitalWrite(inA, HIGH);
29  digitalWrite(inB, HIGH);
30  analogWrite(en, 255);
31}
32
33void setup() {
34  pinMode(ENA, OUTPUT);
35  pinMode(IN1, OUTPUT);
36  pinMode(IN2, OUTPUT);
37  pinMode(ENB, OUTPUT);
38  pinMode(IN3, OUTPUT);
39  pinMode(IN4, OUTPUT);
40  pinMode(STBY, OUTPUT);
41  digitalWrite(STBY, HIGH);   // TB6612FNG'yi uyandır / wake up the TB6612FNG
42}
43
44void loop() {
45  motorSur(ENA, IN1, IN2, 180);    // ileri / forward
46  motorSur(ENB, IN3, IN4, 180);
47  delay(2000);
48
49  fren(ENA, IN1, IN2);             // fren / brake
50  fren(ENB, IN3, IN4);
51  delay(500);
52
53  motorSur(ENA, IN1, IN2, -180);   // geri / reverse
54  motorSur(ENB, IN3, IN4, -180);
55  delay(2000);
56
57  motorSur(ENA, IN1, IN2, 180);    // yerinde dönüş / spin in place
58  motorSur(ENB, IN3, IN4, -180);
59  delay(1000);
60
61  motorSur(ENA, IN1, IN2, 0);      // dur / stop
62  motorSur(ENB, IN3, IN4, 0);
63  delay(1000);
64}

Le bon point de ce code, c'est qu'il fonctionne avec le même brochage sur le L298N et le TB6612FNG ; la table de vérité des deux drivers est presque identique. Quand l'une des broches de sens est HIGH et l'autre LOW, le moteur tourne ; la valeur PWM (0–255) fixe la vitesse. Si tu mets les deux broches de sens à HIGH, les bornes du moteur sont court-circuitées et le moteur freine avec sa propre tension : le robot s'arrête sur une distance plus courte, en pente ou à vitesse élevée. Les broches D5 et D6 de l'Uno génèrent un PWM d'environ 980 Hz ; il est normal d'entendre un léger sifflement des moteurs à cette fréquence. Avec le L298N, à de très faibles valeurs PWM (en dessous de 60 environ), tu verras que le moteur ne tourne pas, car la tension moyenne restante après la perte du driver ne suffit pas à vaincre les frottements.

ESP32 avec TB6612FNG : PWM silencieux à 20 kHz

Sur l'ESP32, utiliser l'unité PWM matérielle LEDC à la place d'analogWrite te permet de choisir la fréquence. Comme le TB6612FNG accepte un PWM jusqu'à 100 kHz, passer à 20 kHz place le signal hors de portée de l'oreille humaine et le sifflement du moteur disparaît complètement. Le code ci-dessous compile avec les versions 2.x et 3.x du core Arduino ESP32 ; les fonctions LEDC qui changent selon la version sont séparées par un bloc de compilation conditionnelle. N'oublie pas de relier la broche VCC du TB6612FNG à la broche 3V3 de l'ESP32.

C++ (Arduino IDE)
1#include <Arduino.h>
2
3// ESP32 + TB6612FNG pinleri / ESP32 + TB6612FNG pins
4const int PWMA = 25, AIN1 = 26, AIN2 = 27;
5const int PWMB = 13, BIN1 = 33, BIN2 = 32;
6const int STBY = 4;
7
8const int PWM_FREQ = 20000;   // 20 kHz: duyulmayan PWM / inaudible PWM
9const int PWM_RES  = 8;       // 0-255 çözünürlük / 0-255 resolution
10
11void pwmBaslat(int pin, int kanal) {
12#if ESP_ARDUINO_VERSION_MAJOR >= 3
13  ledcAttach(pin, PWM_FREQ, PWM_RES);   // core 3.x
14  (void)kanal;
15#else
16  ledcSetup(kanal, PWM_FREQ, PWM_RES);  // core 2.x
17  ledcAttachPin(pin, kanal);
18#endif
19}
20
21void pwmYaz(int pin, int kanal, int deger) {
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23  ledcWrite(pin, deger);
24  (void)kanal;
25#else
26  ledcWrite(kanal, deger);
27  (void)pin;
28#endif
29}
30
31// hiz: -255 ... 255 / speed: -255 ... 255
32void motor(int pwmPin, int kanal, int in1, int in2, int hiz) {
33  hiz = constrain(hiz, -255, 255);
34  digitalWrite(in1, hiz > 0 ? HIGH : LOW);
35  digitalWrite(in2, hiz < 0 ? HIGH : LOW);
36  pwmYaz(pwmPin, kanal, abs(hiz));
37}
38
39void setup() {
40  pinMode(AIN1, OUTPUT);
41  pinMode(AIN2, OUTPUT);
42  pinMode(BIN1, OUTPUT);
43  pinMode(BIN2, OUTPUT);
44  pinMode(STBY, OUTPUT);
45  digitalWrite(STBY, HIGH);   // sürücüyü etkinleştir / enable the driver
46  pwmBaslat(PWMA, 0);
47  pwmBaslat(PWMB, 1);
48}
49
50void loop() {
51  for (int h = 0; h <= 255; h += 5) {   // yumuşak hızlanma / soft acceleration
52    motor(PWMA, 0, AIN1, AIN2, h);
53    motor(PWMB, 1, BIN1, BIN2, h);
54    delay(30);
55  }
56  delay(1500);
57  motor(PWMA, 0, AIN1, AIN2, -200);     // geri / reverse
58  motor(PWMB, 1, BIN1, BIN2, -200);
59  delay(1500);
60  motor(PWMA, 0, AIN1, AIN2, 0);        // dur / stop
61  motor(PWMB, 1, BIN1, BIN2, 0);
62  delay(1000);
63}

Raspberry Pi Pico et MicroPython avec TB6612FNG

Toutes les broches GPIO de la Pico peuvent générer du PWM matériel, et en MicroPython le rapport cyclique se donne sur 16 bits (0–65535). Dans l'exemple ci-dessous, la vitesse est saisie en pourcentage (de -100 à 100) et la fonction la convertit en valeur duty_u16. GP16 et GP21 étant sur des tranches PWM différentes, la fréquence d'un moteur n'influence pas l'autre. Relie la broche VCC du TB6612FNG à la broche 3V3 (OUT) de la Pico et la broche VM à l'alimentation moteur externe ; alimenter les moteurs par la broche VSYS de la Pico fait redémarrer la carte à cause du courant limité de l'USB.

MicroPython
1from machine import Pin, PWM
2import time
3
4stby = Pin(22, Pin.OUT, value=1)   # sürücüyü uyandır / wake the driver
5
6pwma = PWM(Pin(16))
7pwma.freq(20000)                   # 20 kHz sessiz PWM / quiet PWM
8ain1 = Pin(17, Pin.OUT)
9ain2 = Pin(18, Pin.OUT)
10
11pwmb = PWM(Pin(21))
12pwmb.freq(20000)
13bin1 = Pin(19, Pin.OUT)
14bin2 = Pin(20, Pin.OUT)
15
16def motor(pwm, in1, in2, hiz):     # hiz: -100 ... 100 / speed in percent
17    hiz = max(-100, min(100, hiz))
18    in1.value(1 if hiz > 0 else 0)
19    in2.value(1 if hiz < 0 else 0)
20    pwm.duty_u16(int(abs(hiz) * 65535 / 100))
21
22while True:
23    motor(pwma, ain1, ain2, 70)    # ileri / forward
24    motor(pwmb, bin1, bin2, 70)
25    time.sleep(2)
26    motor(pwma, ain1, ain2, -70)   # geri / reverse
27    motor(pwmb, bin1, bin2, -70)
28    time.sleep(2)
29    motor(pwma, ain1, ain2, 0)     # dur / stop
30    motor(pwmb, bin1, bin2, 0)
31    time.sleep(1)

A4988 pour moteur pas à pas : limite de courant et réglage de Vref

Le L298N et le L293D peuvent aussi piloter un moteur pas à pas bipolaire avec deux ponts en H, mais comme ils ne limitent pas le courant, le moteur manque de puissance à basse tension ou chauffe trop à haute tension. L'A4988 mesure en permanence le courant des bobines et le maintient constant (pilotage en hacheur) ; tu peux ainsi piloter en toute sécurité, avec un couple élevé, même un NEMA 17 de 2,8 V depuis une source de 12 V ou 24 V. La limite de courant se règle avec le petit potentiomètre de la carte, selon la formule : I_max = Vref / (8 × Rs). Rs est la résistance de mesure du courant sur la carte ; sur beaucoup de clones, elle porte R100 (0,1 ohm), sur certaines cartes R068 (0,068 ohm). Par exemple, sur une carte de 0,1 ohm, pour 1 A il faut Vref = 1 × 8 × 0,1 = 0,8 V ; pour garder une marge thermique, environ 0,56 V (70 %) est un bon point de départ. L'A4988 ne se commande qu'avec deux broches : chaque impulsion sur STEP fait un pas, et DIR donne le sens. Quand MS1, MS2 et MS3 sont LOW, il fonctionne en pas entier et un moteur de 1,8 degré fait 200 pas par tour. N'oublie pas de relier SLEEP à RESET et de placer un condensateur d'au moins 100 µF entre VMOT et GND.

C++ (Arduino IDE)
1// A4988 ile NEMA 17 step motor / NEMA 17 stepper with A4988
2// MS1-MS3 LOW = tam adım, SLEEP ile RESET birbirine bağlı / MS1-MS3 LOW = full step, SLEEP tied to RESET
3const int DIR_PIN  = 2;
4const int STEP_PIN = 3;
5const int ADIM_TUR = 200;   // 1,8 derece motor / 1.8 degree motor
6
7void adimAt(int adim, bool yon, unsigned int bekleme) {
8  digitalWrite(DIR_PIN, yon ? HIGH : LOW);
9  for (int i = 0; i < adim; i++) {
10    digitalWrite(STEP_PIN, HIGH);
11    delayMicroseconds(bekleme);
12    digitalWrite(STEP_PIN, LOW);
13    delayMicroseconds(bekleme);
14  }
15}
16
17void setup() {
18  pinMode(DIR_PIN, OUTPUT);
19  pinMode(STEP_PIN, OUTPUT);
20}
21
22void loop() {
23  adimAt(ADIM_TUR, true, 800);    // saat yönünde 1 tur / one turn clockwise
24  delay(1000);
25  adimAt(ADIM_TUR, false, 800);   // ters yönde 1 tur / one turn counter-clockwise
26  delay(1000);
27}
Ne branche et ne débranche jamais le câble d'un moteur pas à pas quand l'A4988 est sous tension ; l'impulsion de tension générée dans la bobine peut griller le driver instantanément. De plus, les moteurs unipolaires à 5 fils comme le 28BYJ-48 ne se pilotent pas directement avec l'A4988 ; utilise pour eux la carte ULN2003 fournie avec.

Quel driver pour quel projet ?

ProjetDriver recommandéPourquoi ?
Voiture robot à 2 moteurs TT (sur batterie)TB6612FNG (L9110S pour le budget)Faibles pertes, longue autonomie, petite taille
Voiture à 4 roues avec Arduino UnoShield L293D ou L298N4 moteurs avec une seule carte ; sur le L298N, 2 moteurs en parallèle de chaque côté
Moteur réducteur 12 V (1–2 A)L298N (avec dissipateur)Supporte tension et courant élevés ; pour de plus gros moteurs, passe à des drivers MOSFET comme le BTS7960
Moteur pas à pas NEMA 17 (imprimante 3D, CNC, slider)A4988Limite de courant et micro-pas
Moteur pas à pas 28BYJ-48Carte ULN2003Moteur unipolaire, compatible directement avec 5 V
Mini pompe à eau 6 V à sens uniqueMOSFET niveau logique ou L9110S un canalSi le sens ne change pas, le pont en H est inutile
Pompe réversible ou pompe péristaltiqueTB6612FNGInversion du sens et PWM efficace
Tout projet moteur DC avec ESP32 ou PicoTB6612FNGCompatibilité totale avec la logique 3,3 V

L'exemple de la pompe est particulièrement important : dans un système d'arrosage, la pompe tourne toujours dans le même sens, donc un seul MOSFET canal N et une diode de roue libre suffisent ; tu trouveras cette méthode dans l'article utilisation d'un MOSFET avec Arduino. Sur les voitures robots, plus la tension de la batterie est basse, plus l'avantage d'un driver à MOSFET augmente : une voiture alimentée par deux piles 18650 roule visiblement plus vite et plus longtemps avec un TB6612FNG qu'avec un L298N.

Idées de projets avec des drivers moteur

  • Voiture robot commandée en Bluetooth : pilote deux moteurs depuis ton téléphone avec un TB6612FNG ou un L298N ; les étapes sont dans l'article fabriquer une voiture robot.
  • Robot évitant les obstacles : un véhicule qui détecte l'obstacle devant lui avec un HC-SR04 et change de direction ; détails dans robot évitant les obstacles.
  • Robot suiveur de ligne : dans ce projet qui demande une réponse PWM rapide, le rendement du TB6612FNG fait la différence ; jette un œil à robot suiveur de ligne.
  • Arrosage automatique : déclenche la mini pompe quand l'humidité du sol baisse ; les connexions d'alimentation sont expliquées dans mini pompe à eau.
  • Suiveur solaire : oriente le panneau vers la lumière avec un moteur pas à pas ou un moteur DC à réducteur ; regarde suiveur solaire.
  • Positionnement précis : pour un slider de caméra ou un plateau tournant à petits angles, commence avec le moteur pas à pas 28BYJ-48, puis passe à l'A4988 et au NEMA 17.

Erreurs fréquentes et solutions

ProblèmeCause probableSolution
L'Arduino redémarre quand le moteur tourneLe moteur est alimenté par le 5V de l'Arduino ou la source est faibleUtilise une source moteur séparée, relie les GND, ajoute un condensateur de 100–470 µF sur l'alimentation
Les moteurs ne réagissent pas du toutPas de GND commun ou STBY à LOW sur le TB6612FNGRelie les GND, mets la broche STBY à HIGH
La vitesse ne change pas, le moteur tourne toujours à fondCavalier ENA/ENB en place sur le L298NRetire le cavalier, relie ENA/ENB à une broche PWM
Le moteur est très lent et faible avec le L298NPerte de 2–3 V dans le driverAugmente la tension de la source ou passe au TB6612FNG
Le moteur émet un sifflement aiguLa fréquence PWM est dans la plage audiblePasse le PWM à 20 kHz sur ESP32 ou Pico
Le moteur pas à pas vibre mais ne tourne pasPaires de bobines mal appariées ou Vref trop basTrouve les paires de bobines au multimètre, règle Vref avec la formule
Le driver chauffe trop et se coupeLe courant de calage du moteur dépasse la limite du driverChoisis un driver plus puissant, ajoute un dissipateur, ne force pas le moteur
Avant de travailler avec un nouveau moteur, mesure la résistance de sa bobine au multimètre et estime son courant de calage avec I = V / R. Par exemple, un moteur de 6 V et 5 ohms consomme environ 1,2 A quand il cale ; dans ce cas, la limite de 0,6 A du L293D est insuffisante, alors que le TB6612FNG ou le L298N conviennent.

Bien choisir un driver moteur, c'est connaître le courant de ton moteur, sa tension d'alimentation et le niveau logique de ta carte. Avec ces trois informations, les tableaux ci-dessus te mènent à la bonne carte en quelques secondes, et tu sais maintenant à quoi sert ce vieux L298N qui traîne dans ton tiroir. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schémas de câblage et codes prêts à l'emploi, des projets comme la voiture Bluetooth avec L298N, le robot évitant les obstacles, le moteur pas à pas et l'arrosage intelligent, puis te lancer tout de suite.

Questions fréquentes

L298N ou TB6612FNG : lequel est le meilleur ?

Pour des moteurs sur batterie qui consomment moins de 1 A, le TB6612FNG est meilleur : grâce à ses MOSFET, il ne perd qu'environ 0,5 V et ne chauffe presque pas. Le L298N se choisit au-delà de 13,5 V et pour des moteurs demandant 1 à 2 A par canal. En résumé : TB6612FNG pour les petits robots, L298N pour les gros moteurs de 12–24 V.

Pourquoi le L298N chauffe-t-il autant ?

Comme le L298N utilise des transistors bipolaires, il perd environ 2 à 3 V quand le courant passe, et cette perte se transforme en chaleur. À 1 A, le driver produit environ 2 W de chaleur ; c'est pourquoi il est livré avec un grand dissipateur. Pour réduire l'échauffement, garde un courant faible ou passe à un driver à MOSFET.

Peut-on utiliser un L298N avec un ESP32 ?

Oui : les entrées du L298N acceptent comme niveau haut dès 2,3 V, donc le signal 3,3 V de l'ESP32 fonctionne dans la plupart des cas. La partie logique du module doit être alimentée en 5 V et les GND de l'ESP32 et du driver doivent absolument être reliés. Pour un nouveau projet, le TB6612FNG, pleinement compatible 3,3 V, reste un choix plus sûr.

Quel courant le L293D peut-il fournir ?

Le L293D peut fournir 600 mA en continu et 1,2 A en pointe par canal ; il a deux canaux. Ces valeurs suffisent pour de petits moteurs de jouets et des robots légers, mais avec un moteur dont le courant de calage dépasse 1 A, le circuit chauffe et passe en protection thermique. Pour plus de courant, pense au L298N ou au TB6612FNG.

Quel driver choisir pour un moteur pas à pas ?

Pour les moteurs pas à pas bipolaires à 4 fils comme le NEMA 17, utilise un driver à courant contrôlé comme l'A4988 : tu peux régler la limite de courant avec Vref et utiliser les micro-pas. Pour les moteurs unipolaires à 5 fils comme le 28BYJ-48, la carte ULN2003 est la solution la plus simple. Le L298N peut piloter un pas à pas bipolaire, mais il est peu efficace car il ne limite pas le courant.

A-t-on besoin d'un driver moteur pour une pompe à eau ?

Si la pompe ne tourne que dans un sens, un driver à pont en H n'est pas nécessaire : un MOSFET niveau logique, une diode et une résistance suffisent. Si tu veux inverser la pompe ou régler sa vitesse en PWM, tu peux utiliser un canal d'un driver comme le L9110S ou le TB6612FNG. Dans tous les cas, alimente la pompe avec une source séparée et non depuis une broche de l'Arduino.

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
Utilisation du moteur pas à pas
AR-67Intermédiaire
Premium

Utilisation du moteur pas à pas

Un moteur qui tourne pas à pas, exactement autant que tu le veux, comme l'aiguille d'une horloge.

4.5(31)
42
Construction d'un servomoteur à 360 degrés à partir d'un moteur pas à pas
AR-68Intermédiaire
Premium

Construction d'un servomoteur à 360 degrés à partir d'un moteur pas à pas

Apprends à un moteur pas à pas ordinaire à aller à l'angle que tu veux, sur tout le tour.

4.5(22)
33
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57
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