Driver moteur pour Arduino : DC, servo ou pas à pas ?

Un driver moteur Arduino est le circuit qui se place entre la carte et le moteur : l’Arduino donne les ordres (sens, vitesse, position) et le driver fournit le courant que ses broches ne peuvent pas donner. Pour un moteur DC on utilise un pont en H, pour un servomoteur un simple signal PWM (ou une carte PCA9685 dès qu’il y en a plusieurs), et pour un moteur pas à pas un driver à deux ponts en H qui envoie les pas dans le bon ordre.

Vous voulez faire rouler un petit robot, ouvrir une trappe ou déplacer un chariot ? Le premier réflexe est souvent de brancher le moteur directement sur l’Arduino… et c’est la meilleure façon d’abîmer la carte. Ce guide explique simplement quel driver moteur Arduino choisir selon le type de moteur, comment le câbler et avec quel code le tester.

Pourquoi un driver moteur Arduino est indispensable

Une broche de l’Arduino UNO (microcontrôleur ATmega328P) supporte au maximum 40 mA, et le fabricant conseille de rester autour de 20 mA. Un petit moteur jouet consomme déjà plusieurs centaines de milliampères, et bien plus au démarrage ou quand on le bloque. Brancher un moteur directement sur une broche, c’est donc la surcharger.

Il y a aussi un problème moins visible : un moteur est une bobine. Quand on coupe son courant, il renvoie une surtension qui peut détruire le transistor ou le microcontrôleur. Un bon driver moteur règle les deux problèmes : il fournit le courant depuis une alimentation séparée et intègre (ou demande) des diodes de protection.

• L’Arduino décide : marche, arrêt, sens, vitesse ou position.
• Le driver obéit et fait passer le courant du moteur.
• L’alimentation moteur fournit l’énergie, séparée de celle de la carte, avec une masse (GND) commune.

Moteur DC, servo ou pas à pas : les différences

Avant de choisir un driver, il faut savoir quel moteur vous avez. Les trois familles ne se pilotent pas du tout de la même façon.

Moteur	Ce qu’il fait bien	Comment on le pilote	Exemples d’usage
Moteur DC (à courant continu)	Tourne vite et en continu	Pont en H : sens + vitesse par PWM	Roues de robot, ventilateur, pompe
Servomoteur	Va à un angle précis (souvent 0 à 180°) et le tient	Un fil de signal PWM, le driver est déjà dans le servo	Bras robotisé, trappe, direction d’une voiture RC
Moteur pas à pas	Avance d’un nombre exact de pas, sans capteur	Deux ponts en H (moteur bipolaire) commandés dans l’ordre	Imprimante 3D, table X-Y, vanne dosée

Piloter un moteur DC : le pont en H

Un moteur DC change de sens quand on inverse ses deux fils. Le pont en H fait exactement cela avec quatre interrupteurs électroniques disposés en forme de H : deux sont fermés pour un sens, les deux autres pour le sens inverse. La vitesse se règle par PWM : le driver allume et éteint le moteur très vite, et la proportion de temps « allumé » fixe la vitesse moyenne.

Si votre moteur ne tourne que dans un sens, un simple transistor suffit : voyez notre article sur le MOSFET canal N avec Arduino ou ESP32. Si vous voulez juste allumer ou couper un moteur, sans vitesse variable, un module relais et Arduino peut aussi convenir.

Petits moteurs : le shield L293D

Le shield moteur L293D pour Arduino s’enfiche directement sur une UNO ou une Mega. Il porte deux circuits L293D, soit quatre ponts en H : il pilote jusqu’à 4 moteurs DC ou 2 moteurs pas à pas, plus 2 servomoteurs. Chaque canal supporte 0,6 A en continu (1,2 A en pointe), avec des diodes de protection intégrées, et une tension moteur de 4,5 à 25 V. C’est le bon choix pour un robot à 2 ou 4 roues avec des moteurs jaunes à réducteur.

Sa limite : le L293D est un circuit ancien à transistors bipolaires. Il chauffe et perd une partie de la tension (souvent de l’ordre de 2 V au total à fort courant). Un moteur 6 V alimenté en 6 V tournera donc un peu moins vite que prévu.

Moteurs plus puissants : le LMD18200T

Pour un moteur 12 ou 24 V qui tire plusieurs ampères (convoyeur, actionneur, gros robot), il faut changer de catégorie. Le driver LMD18200T (3 A, 55 V) est un pont en H de Texas Instruments qui fournit 3 A en continu, de 12 à 55 V. Il reçoit trois signaux logiques compatibles avec l’Arduino : DIRECTION (sens), PWM (vitesse) et BRAKE (freinage). Il offre aussi une sortie de mesure de courant et un signal d’alerte de surchauffe, très utiles pour détecter un moteur bloqué.

C’est un circuit intégré nu (boîtier TO-220 à 11 broches), pas un module prêt à brancher : prévoyez un dissipateur, les deux condensateurs de « bootstrap » indiqués dans la fiche technique et un gros condensateur de découplage au plus près de l’alimentation.

Exemple de code avec le shield L293D

Avec la bibliothèque AFMotor (Adafruit Motor Shield V1), à installer depuis le gestionnaire de bibliothèques de l’Arduino IDE, ce programme fait tourner le moteur branché sur M1 dans un sens, puis dans l’autre :

#include <AFMotor.h>

AF_DCMotor moteur(1);    // moteur branché sur le bornier M1

void setup() {
  moteur.setSpeed(200);  // vitesse de 0 à 255
  moteur.run(RELEASE);   // moteur libre au démarrage
}

void loop() {
  moteur.run(FORWARD);   // marche avant
  delay(2000);
  moteur.run(RELEASE);   // arrêt
  delay(500);
  moteur.run(BACKWARD);  // marche arrière
  delay(2000);
  moteur.run(RELEASE);
  delay(1000);
}

Piloter un servomoteur avec Arduino

Ici, pas besoin d’un driver moteur Arduino au sens classique. Un servomoteur contient déjà son moteur, son réducteur, un capteur de position et sa propre électronique de commande. L’Arduino n’envoie qu’un signal : une impulsion toutes les 20 ms (50 Hz), dont la durée indique l’angle, en général autour de 1 ms pour une butée, 1,5 ms pour le milieu et 2 ms pour l’autre butée. Le servo a trois fils : alimentation (souvent rouge), masse (marron ou noir) et signal (orange ou jaune).

Pour un ou deux petits servos, la bibliothèque Servo de l’Arduino suffit, et le shield L293D a justement deux connecteurs servo. Attention : sur une UNO, cette bibliothèque désactive le PWM des broches 9 et 10. Et surtout, n’alimentez pas un servo par la broche 5 V de la carte : au démarrage, il peut tirer un pic de courant qui fait redémarrer l’Arduino.

Plusieurs servos : le driver PCA9685

Dès qu’on dépasse deux ou trois servos (bras robotisé, robot à pattes, maquette animée), le driver de servos PCA9685 16 canaux devient très pratique. Il génère lui-même 16 signaux PWM avec une résolution de 12 bits (4 096 niveaux) et ne demande que deux fils à l’Arduino, par le bus I²C (A4/SDA et A5/SCL sur une UNO). Les servos sont alimentés par le bornier V+ du module, depuis une alimentation séparée, par exemple un module abaisseur LM2596 réglé à 5 ou 6 V selon vos servos.

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(); // adresse 0x40

void setup() {
  pca.begin();
  pca.setOscillatorFrequency(27000000);
  pca.setPWMFreq(50);               // 50 Hz pour les servos
}

void loop() {
  pca.writeMicroseconds(0, 1000);   // servo du canal 0 en butée
  delay(1000);
  pca.writeMicroseconds(0, 1500);   // position milieu
  delay(1000);
  pca.writeMicroseconds(0, 2000);   // autre butée
  delay(1000);
}

Ce code utilise la bibliothèque « Adafruit PWM Servo Driver ». Vérifiez les butées réelles de vos servos : certains acceptent une plage plus large, d’autres forcent si on les pousse trop loin.

Piloter un moteur pas à pas avec Arduino

Un moteur pas à pas tourne par petits crans réguliers. Beaucoup de moteurs NEMA 17, comme ceux des imprimantes 3D, font 200 pas par tour, soit 1,8° par pas. L’intérêt : en comptant les pas envoyés, l’Arduino sait où se trouve l’axe, sans capteur, tant que le moteur ne force pas au point de « sauter » des pas.

Côté driver moteur Arduino, un moteur pas à pas bipolaire (4 fils) a deux bobines : il faut un pont en H par bobine, donc deux ponts en H par moteur. C’est pourquoi le shield L293D, avec ses quatre ponts, pilote deux moteurs pas à pas. Pour les moteurs qui demandent plus de 0,6 A par phase, on passe à un driver dédié qui limite le courant, comme ceux utilisés sur les cartes d’imprimante 3D.

#include <AFMotor.h>

AF_Stepper moteurPAP(200, 2); // 200 pas par tour, branché sur M3/M4

void setup() {
  moteurPAP.setSpeed(30);     // 30 tours par minute
}

void loop() {
  moteurPAP.step(200, FORWARD, DOUBLE);   // un tour complet
  delay(1000);
  moteurPAP.step(200, BACKWARD, DOUBLE);  // retour
  delay(1000);
}

Driver moteur Arduino : le tableau pour choisir

Voici les prix affichés sur djenni.ma au 11 novembre 2026 (ils peuvent évoluer, la fiche produit fait foi) :

Produit	Pour quel moteur	Points clés	Prix
shield moteur L293D pour Arduino	4 moteurs DC ou 2 pas à pas, + 2 servos	0,6 A par canal, 4,5 à 25 V, s’enfiche sur UNO ou Mega	50 Dhs
driver de servos PCA9685 16 canaux	Jusqu’à 16 servomoteurs (ou LED)	I²C, 12 bits, alimentation des servos séparée	95 Dhs
driver LMD18200T (3 A, 55 V)	1 moteur DC puissant	3 A continu, 12 à 55 V, mesure de courant et alerte thermique	420 Dhs
Arduino UNO	La carte qui commande le tout	14 broches numériques dont 6 en PWM	120 Dhs

Pour comparer les cartes, voyez notre guide Arduino UNO, Nano ou Mega. Retrouvez aussi nos cartes Arduino, nos modules et le rayon semi-conducteurs et circuits intégrés.

Alimenter un driver moteur sans faire redémarrer l’Arduino

La plupart des pannes « mystérieuses » d’un projet motorisé viennent de l’alimentation, pas du code. Quelques règles simples évitent des heures de recherche :

• Deux alimentations, une masse commune : l’Arduino d’un côté, les moteurs de l’autre, et les GND reliés entre eux. Sans masse commune, les signaux de commande n’ont pas de référence.
• Une alimentation qui tient le pic de démarrage : un moteur DC peut tirer plusieurs fois son courant normal au démarrage. Prévoyez de la marge.
• Un condensateur près du driver : quelques centaines de µF sur l’entrée moteur lissent les appels de courant.
• Des fils courts et assez gros pour le courant moteur, et torsadés deux à deux si possible.
• Pas de piles salines pour des moteurs : elles s’effondrent dès que le courant monte. Préférez une alimentation secteur ou des accus lithium bien protégés (voir notre article sur la batterie 18650 et protection BMS).

Pour abaisser une tension de 12 V vers 5 ou 6 V, un convertisseur buck LM2596 fait très bien l’affaire. Pour estimer un courant ou une résistance, utilisez notre calculateur loi d’Ohm, et pour savoir combien de temps tiendra votre robot, notre calculateur d’autonomie de batterie.

Check-list avant la première mise sous tension

1. Le type de moteur est identifié (DC, servo, pas à pas) et le driver lui correspond.
2. Le courant du moteur est inférieur à ce que le driver supporte en continu, avec de la marge.
3. La tension moteur est dans la plage du driver.
4. Les masses de l’Arduino et de l’alimentation moteur sont reliées.
5. Le moteur est testé d’abord à vitesse réduite, roues en l’air ou mécanique libre.

En résumé, le bon driver moteur Arduino dépend d’abord du moteur : pont en H pour un moteur DC, signal PWM ou PCA9685 pour les servos, double pont en H pour un pas à pas. Pour un projet plus gros ou une liste de composants complète, faites une demande de devis ou passez par le sourcing sur demande.

Questions fréquentes sur les drivers moteur Arduino

Photo de couverture : shield moteur sur Arduino avec un moteur pas à pas, un servomoteur et un moteur DC, par oomlout, Wikimedia Commons, licence CC BY-SA 2.0, recadrée et redimensionnée.