Shield L293D Arduino : AFMotor, 4 moteurs CC, pas à pas et servo

Le shield moteur L293D (L293D motor shield) est une carte de pilotage de moteurs qui s'enfiche directement sur un Arduino Uno et te permet de commander 4 moteurs à courant continu, 2 moteurs pas à pas et 2 servos depuis une seule carte. Ses deux puces L293D fournissent le courant dont les moteurs ont besoin, inversent leur sens de rotation et règlent leur vitesse en PWM : tu peux donc piloter tous les moteurs d'une voiture robot à quatre roues sans un seul fil de liaison. Presque toutes les cartes du marché sont des copies de l'ancien Motor Shield V1 d'Adafruit et se programment avec la même bibliothèque : AFMotor.

Dans ce guide, tu vas découvrir ce qu'il y a sur le shield, quelles broches de l'Arduino il occupe et lesquelles restent libres pour les capteurs, comment fonctionne le fameux cavalier PWR dans trois montages d'alimentation, les commandes de la bibliothèque AFMotor et le code complet d'une voiture robot à quatre roues pilotée depuis ton téléphone. Les dernières sections traitent de la limite de courant de 0,6 A, de l'échauffement de la puce, de la comparaison avec le L298N et de toutes les causes connues du problème « mes moteurs ne tournent pas », réunies dans un seul tableau.

Qu'est-ce que le shield moteur L293D et comment fonctionne-t-il ?

Pour faire tourner un moteur à courant continu dans les deux sens, il faut un circuit à quatre interrupteurs appelé pont en H ; nous expliquons le principe en détail dans Commander un moteur à courant continu avec le L298N. La puce L293D contient deux ponts en H et, comme le shield en porte deux, tu disposes de quatre canaux moteur au total. Le « D » du nom indique que les diodes de protection, qui absorbent les pics de tension inverse produits par un moteur à la coupure, sont intégrées à la puce. Le L293D coupe aussi ses sorties tout seul en cas de surchauffe.

La vraie astuce du shield, c'est le registre à décalage 74HC595 au centre. Chacun des quatre moteurs a besoin de deux signaux de sens et d'un signal de vitesse, soit 12 broches de l'Arduino au total. Le shield envoie les huit signaux de sens en série au 74HC595 et n'y consacre que 4 broches (D4, D7, D8, D12), plus 4 broches PWM pour la vitesse (D3, D5, D6, D11). Cette conception économise des broches, mais elle a un prix : tu ne peux pas piloter les moteurs directement avec digitalWrite, il faut une bibliothèque qui envoie les bits de sens dans le registre. Cette bibliothèque, c'est AFMotor.

Que trouve-t-on sur la carte ? Borniers, connecteurs et cavalier

Quelles broches le shield utilise-t-il et lesquelles restent libres ?

Les six broches analogiques libres suffisent largement pour les capteurs, car A0–A5 de l'Uno fonctionnent aussi comme broches numériques 14–19 au besoin. Une répartition pratique pourrait être : un capteur de distance HC-SR04 ou un module Bluetooth en SoftwareSerial sur A0 et A1, des capteurs de ligne ou d'obstacles sur A2 et A3, et le bus I2C (OLED, LCD, MPU6050) sur A4 et A5. Pour un encodeur de roue ou un bouton qui utilise attachInterrupt(), la seule broche libre est D2 ; l'autre broche d'interruption de l'Uno, D3, est la broche de vitesse de M2. Si tu n'utilises pas de servos, D9 et D10 sont libres aussi. Tu peux voir le brochage de ta carte dans l'outil Pinout et le rôle de chaque broche dans Brochage Arduino Uno.

Alimentation et cavalier PWR : trois montages corrects

Le bornier à deux vis EXT_PWR, sur le bord inférieur de la carte, est l'entrée d'alimentation des moteurs ; le pôle positif est généralement marqué « +M » ou « + », le négatif « GND ». Le cavalier PWR juste à côté relie cette ligne moteur à la broche Vin de l'Arduino. Cavalier en place, les deux cartes sont alimentées par une seule source : la tension appliquée sur EXT_PWR alimente aussi l'Arduino via Vin, ou un adaptateur branché sur la prise jack de l'Arduino alimente aussi les moteurs. Cavalier retiré, les deux lignes sont complètement séparées. La LED PWR de la carte ne s'allume que si l'alimentation moteur est présente ; c'est la première chose à vérifier avant de t'attaquer aux moteurs.

Sur les voitures robots, le plus courant est la source unique : tu branches un pack de deux accus 18650 sur EXT_PWR, tu mets le cavalier, et l'Arduino comme les moteurs fonctionnent sur la même batterie. C'est simple, mais quand les moteurs démarrent et tirent beaucoup de courant, la tension de la batterie peut chuter un instant et l'Arduino redémarrer. Si cela t'arrive, retirer le cavalier et alimenter l'Arduino par une autre source (batterie externe, USB ou adaptateur 9 V) règle le problème pour de bon. Pour les essais sur table, le deuxième montage est le plus pratique : l'Arduino reste branché à l'ordinateur, les moteurs tournent sur piles et le cavalier est retiré.

Quelle batterie choisir ? Selon le courant, les transistors de sortie du L293D avalent environ 1,5–2,6 V : le moteur reçoit donc d'autant moins que la tension de la batterie. Pour les moteurs TT jaunes de 3–6 V des kits robotiques, deux accus lithium 18650 (7,4 V nominal, 8,4 V à pleine charge) sont idéaux : les moteurs reçoivent environ 5,5–6 V et, cavalier en place, le régulateur de l'Arduino travaille à l'aise. Quatre piles AA (6 V) ne laissent qu'environ 4 V aux moteurs et ne suffisent pas pour alimenter l'Arduino par Vin. Une pile 9 V ne fournit guère plus de quelques centaines de milliampères : les moteurs ne tournent pas du tout ou la pile est vide en quelques minutes. Tu peux estimer l'autonomie avec le calculateur d'autonomie de batterie et lire toutes les options d'alimentation dans Alimenter un Arduino avec une pile.

Installer la bibliothèque AFMotor

1. Ouvre le gestionnaire de bibliothèques de l'Arduino IDE (Outils > Gérer les bibliothèques ou Ctrl+Maj+I).
2. Tape Adafruit Motor Shield dans la recherche. Deux résultats apparaissent : Adafruit Motor Shield library, dont la description indique « V1 firmware », et Adafruit Motor Shield V2 Library.
3. Pour le shield L293D, installe la version V1. La bibliothèque V2 sert à une carte complètement différente qui communique en I2C et utilise des puces TB6612.
4. Ajoute la ligne #include <AFMotor.h> en haut de ton croquis.
5. Si tu veux, ouvre Fichier > Exemples > Adafruit Motor Shield library > MotorTest et teste la carte avec un moteur sur M1.

Premier programme : faire tourner un moteur CC en avant, en arrière et à différentes vitesses

Visse les deux fils du moteur sur les deux vis extérieures du bornier M1 et laisse libre la vis GND du milieu. Branche le pack de piles sur EXT_PWR, relie l'Arduino à l'ordinateur en USB et retire le cavalier PWR (le deuxième montage ci-dessus). Si la LED PWR est allumée, téléverse le code ci-dessous : le moteur accélère puis ralentit doucement, tourne ensuite en arrière pendant deux secondes et s'arrête.

1#include <AFMotor.h>                  // Adafruit Motor Shield V1 kütüphanesi / library
2
3AF_DCMotor motor(1);                  // M1 klemensi / M1 terminal
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("L293D motor testi / motor test"));
8  motor.setSpeed(200);                // 0–255; bunu unutursan motor dönmez / skip this and the motor won't turn
9  motor.run(RELEASE);                 // başlangıçta dur / start stopped
10}
11
12void loop() {
13  motor.run(FORWARD);                 // ileri / forward
14  for (int s = 60; s <= 255; s++) {   // yavaşça hızlan / ramp up
15    motor.setSpeed(s);
16    delay(10);
17  }
18  for (int s = 255; s >= 60; s--) {   // yavaşça yavaşla / ramp down
19    motor.setSpeed(s);
20    delay(10);
21  }
22  motor.run(RELEASE);                 // dur / stop
23  delay(500);
24
25  motor.setSpeed(180);
26  motor.run(BACKWARD);                // geri / backward
27  delay(2000);
28  motor.run(RELEASE);
29  delay(1000);
30}

La vitesse se règle en coupant et rétablissant l'alimentation du moteur des milliers de fois par seconde ; les détails sont dans Qu'est-ce que le PWM ?. Comme M1 et M2 utilisent le Timer2, tu peux choisir leur fréquence : MOTOR12_64KHZ, MOTOR12_8KHZ (par défaut), MOTOR12_2KHZ et MOTOR12_1KHZ. À 64 kHz, le sifflement du moteur devient inaudible, mais le L293D chauffe davantage. M3 et M4 dépendent en revanche du Timer0 ; comme ce timer fait aussi tourner millis() et delay(), la bibliothèque ne touche pas à sa fréquence et ces deux canaux fonctionnent toujours à environ 1 kHz.

Code de la voiture robot à quatre roues (4WD)

L'usage préféré du shield moteur L293D est la voiture robot à quatre roues, car chacun des quatre moteurs a son propre bornier et il n'y a pas de fouillis de fils. Ces voitures n'ont pas de direction ; elles tournent comme un char : si les deux roues de gauche tournent dans un sens et les deux de droite dans l'autre, la voiture pivote sur place. C'est pourquoi le code ne pilote pas les moteurs un par un, mais en deux groupes : côté gauche et côté droit. Pour piloter depuis le téléphone, on branche un module Bluetooth HC-05 sur les broches libres A0 et A1 avec SoftwareSerial ; le module est détaillé dans Module Bluetooth HC-05.

1#include <AFMotor.h>
2#include <SoftwareSerial.h>
3
4AF_DCMotor frontLeft(1);              // M1: sol ön / front left
5AF_DCMotor rearLeft(2);               // M2: sol arka / rear left
6AF_DCMotor rearRight(3);              // M3: sağ arka / rear right
7AF_DCMotor frontRight(4);             // M4: sağ ön / front right
8
9SoftwareSerial bt(A0, A1);            // RX = A0 (HC-05 TXD), TX = A1 (HC-05 RXD, bölücüyle / via a divider)
10
11int speed = 200;                      // 0–255 arası sürüş hızı / driving speed 0–255
12
13void setSide(AF_DCMotor &a, AF_DCMotor &b, int value) {   // -255 … 255
14  uint8_t dir = value > 0 ? FORWARD : (value < 0 ? BACKWARD : RELEASE);
15  uint8_t pwm = constrain(abs(value), 0, 255);
16  a.setSpeed(pwm);
17  b.setSpeed(pwm);
18  a.run(dir);
19  b.run(dir);
20}
21
22void drive(int left, int right) {     // sol ve sağ taraf / left and right side
23  setSide(frontLeft, rearLeft, left);
24  setSide(frontRight, rearRight, right);
25}
26
27void setup() {
28  Serial.begin(9600);                 // hata ayıklama / debugging
29  bt.begin(9600);                     // HC-05 varsayılan hızı / default baud rate
30  drive(0, 0);
31}
32
33void loop() {
34  if (!bt.available()) return;
35  char c = bt.read();
36  Serial.println(c);
37
38  switch (c) {
39    case 'F': drive(speed, speed);        break;   // ileri / forward
40    case 'B': drive(-speed, -speed);      break;   // geri / backward
41    case 'L': drive(-speed, speed);       break;   // yerinde sola / spin left
42    case 'R': drive(speed, -speed);       break;   // yerinde sağa / spin right
43    case 'G': drive(speed / 3, speed);    break;   // ileri-sola kavis / curve forward-left
44    case 'I': drive(speed, speed / 3);    break;   // ileri-sağa kavis / curve forward-right
45    case 'S': drive(0, 0);                break;   // dur / stop
46    case 'q': speed = 255;                break;   // tam hız / full speed
47    default:
48      if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 90, 240);   // hız kademesi / speed step
49  }
50}

Le cœur du code est la fonction drive(gauche, droite) : elle prend une valeur de -255 à 255 pour chaque côté ; positif signifie en avant, négatif en arrière et zéro à l'arrêt. setSide() donne la même vitesse et le même sens aux deux moteurs d'un côté. Les commandes sont les lettres envoyées par les applis de type « Arduino Bluetooth RC Car » des magasins d'applications : F avant, B arrière, L et R rotation sur place, G et I virage en courbe, S arrêt. Le curseur de vitesse de l'appli envoie un chiffre de 0 à 9 ; le code le convertit en une valeur PWM entre 90 et 240 et, comme le minimum est de 90, les moteurs démarrent même au réglage le plus bas. Si une roue tourne à l'envers, ne touche pas au code : inverse les deux fils de ce moteur dans son bornier. Pour le montage du châssis et une version à deux moteurs, consulte Voiture robot Arduino.

Piloter des moteurs pas à pas : 28BYJ-48 et NEMA 17

Le shield peut piloter deux moteurs pas à pas en même temps : le port 1 utilise les borniers M1 et M2 et le port 2 utilise M3 et M4. Avec un moteur bipolaire (4 fils, comme un NEMA 17), tu branches une bobine sur M1 et l'autre sur M2. Avec un moteur unipolaire (5 ou 6 fils), les deux bobines vont aussi sur M1 et M2, et le fil commun va sur la vis GND au milieu du bornier. Pour le très répandu 28BYJ-48, le câblage est le suivant : fils bleu et jaune sur M1, fils rose et orange sur M2, fil commun rouge sur GND. L'utilisation de ce moteur avec la carte ULN2003 est expliquée dans Qu'est-ce qu'un moteur pas à pas ?.

Le 28BYJ-48 est un moteur 5 V ; pour cet essai, alimente les moteurs avec 4 piles AA (6 V), retire le cavalier et alimente l'Arduino en USB. À cause du réducteur intégré, un tour complet fait 2048 pas entiers :

1#include <AFMotor.h>
2
3// 28BYJ-48: tam adımda tur başına 2048 adım / 2048 full steps per revolution
4AF_Stepper stepper(2048, 1);          // 1 = M1 + M2, 2 = M3 + M4
5
6void setup() {
7  stepper.setSpeed(10);               // dakikada 10 tur / 10 RPM
8}
9
10void loop() {
11  stepper.step(2048, FORWARD, DOUBLE);       // bir tur ileri, güçlü tork / one turn forward, more torque
12  delay(500);
13  stepper.step(4096, BACKWARD, INTERLEAVE);  // yarım adımla bir tur geri / one turn back in half steps
14  stepper.release();                         // bobinleri kapat, ısınmasın / de-energise the coils
15  delay(1000);
16}

setSpeed() fixe le nombre de tours par minute ; à cause de son réducteur, le 28BYJ-48 ne dépasse pas environ 10–15 tr/min. Attention : step() est bloquante ; tant que le moteur n'a pas fini les pas demandés, loop() ne fait rien d'autre. Si tu veux lire des capteurs ou piloter des moteurs CC pendant que le pas à pas tourne, utilise la fonction onestep() de la bibliothèque avec la bibliothèque AccelStepper ; l'exemple AFMotor_ConstantSpeed fourni avec la bibliothèque montre exactement cela. Appeler release() pendant les pauses coupe les bobines et évite l'échauffement, mais l'axe perd alors son couple de maintien.

Brancher des servos : les connecteurs SER1 et SERVO_2

Les deux connecteurs à trois broches dans le coin du shield sont destinés aux servos. D'après les marquages de la carte, les broches sont − (GND), + (5 V) et S (signal) : le fil marron du servo va sur −, le rouge sur + et l'orange sur S. D'après le schéma de la carte, SER1 est relié à D10 et SERVO_2 à D9 (certaines sources donnent les numéros dans l'autre sens ; si le servo ne bouge pas, essaie l'autre broche dans le code). Les servos se pilotent avec la bibliothèque standard Servo, et le Timer1 qu'elle utilise sur l'Uno n'entre pas en conflit avec les timers des moteurs : moteurs CC et servos fonctionnent donc ensemble sans problème.

Les servos ne sont pas alimentés par la batterie des moteurs, mais par la ligne 5 V de l'Arduino. Pour un SG90, aucun souci, mais les gros servos comme le MG996R peuvent tirer plus de 1 A en mouvement ; le régulateur de l'Arduino chauffe, la tension s'effondre et la carte redémarre. Avec un gros servo, branche seulement le fil de signal sur le connecteur, alimente le + et le − du servo par une source 5–6 V séparée et relie les masses. Les détails sont dans Servo MG996R avec Arduino et Qu'est-ce qu'un servomoteur ?. Le code ci-dessous fait balayer le servo de SER1 de gauche à droite pendant que le moteur de M3 tourne :

1#include <AFMotor.h>
2#include <Servo.h>
3
4AF_DCMotor motor(3);                  // M3 klemensi / M3 terminal
5Servo servo1;                         // SER1 başlığı / SER1 header
6
7void setup() {
8  servo1.attach(10);                  // SER1 = D10, SERVO_2 = D9
9  motor.setSpeed(170);
10  motor.run(FORWARD);                 // motor dönerken servo tarar / servo sweeps while the motor runs
11}
12
13void loop() {
14  for (int a = 20; a <= 160; a += 2) {   // sağa tara / sweep right
15    servo1.write(a);
16    delay(15);
17  }
18  for (int a = 160; a >= 20; a -= 2) {   // sola tara / sweep left
19    servo1.write(a);
20    delay(15);
21  }
22}

Limite de courant (0,6 A) et échauffement

La ligne la plus importante de la fiche technique du L293D, c'est 0,6 A en continu et 1,2 A en pointe par canal. La valeur de pointe ne vaut que pour des impulsions très courtes ; si un moteur tire 1 A pendant plusieurs secondes, la puce souffre. Un calcul simple montre pourquoi elle chauffe : le L293D est un pilote ancien à transistors bipolaires et, à 0,6 A, il perd typiquement 1,4 V dans le transistor du haut et 1,2 V dans celui du bas. Quand un moteur consomme 0,6 A, la puce dissipe donc 0,6 A × 2,6 V ≈ 1,6 W ; deux moteurs sur la même puce produisent le double, environ 3 W. Une petite puce DIP sans dissipateur ne peut pas évacuer cette chaleur, sa température monte vite et la protection thermique finit par couper les sorties. Le symptôme est bien connu : les moteurs tournent un moment, s'arrêtent, puis repartent quand la puce a refroidi.

Les moteurs TT jaunes consomment environ 150 mA à vide et 200–300 mA en roulant au sol, ce qui reste dans les limites du shield. Le problème, ce sont les moments où une roue bute contre un obstacle ou où la voiture pivote sur place : un moteur TT bloqué peut tirer 1–1,5 A, et sur une voiture 4WD les quatre moteurs forcent en même temps pendant une rotation sur place. Pour connaître le courant réel de ton moteur, branche un multimètre en série avec lui et mesure en retenant brièvement la roue avec la main ; la méthode est expliquée dans Comment utiliser un multimètre. Pour garder le shield au frais :

• Démarre en douceur : ne passe pas de 0 à 255 d'un coup ; augmente la vitesse progressivement sur 200–300 ms et le courant de démarrage baisse nettement.
• Ne bloque pas le moteur : sur un robot éviteur d'obstacles, arrête la voiture avant qu'elle ne touche l'obstacle ; un moteur bloqué est celui qui chauffe le plus.
• Colle des dissipateurs sur les puces : de petits dissipateurs en aluminium avec adhésif thermique abaissent un peu la température du L293D.
• Soude un second L293D : Adafruit indique aussi qu'on peut souder un second L293D sur les puces existantes, patte sur patte, pour augmenter la capacité en courant ; les deux puces se partagent alors le courant.
• Pas plus de tension que nécessaire : mettre 12 V sur des moteurs 6 V augmente le courant et la chaleur.
• Passe au bon pilote : si ton moteur consomme en continu plus de 0,6 A, utilise un pilote à base de L298N ou de TB6612FNG.

Shield moteur L293D ou L298N ?

En bref, si tu construis une voiture 4WD à moteurs TT sur un Arduino Uno, le shield L293D réduit le câblage au minimum et regroupe les quatre moteurs sur une seule carte. Si tes moteurs sont plus puissants, si ta carte est un ESP32 ou une Pico, ou si tu tiens à choisir les broches, le L298N est plus souple ; les détails sont dans Commander un moteur à courant continu avec le L298N. Si tu veux plus efficace que les deux, le TB6612FNG, à base de MOSFET, a une chute de tension très faible et prolonge l'autonomie des piles. Nous comparons quel type de moteur convient à quel usage dans Moteur CC, servomoteur et moteur pas à pas.

Fonctionne-t-il avec un ESP32, un Raspberry Pi Pico ou un Mega ?

Avec l'Arduino Mega 2560, il fonctionne sans problème : le shield s'enfiche sur les premières broches numériques et analogiques du Mega, et AFMotor connaît les timers du Mega. Avec l'Uno R4, le Leonardo, l'ESP32 et le Raspberry Pi Pico, en revanche, il ne fonctionne pas, car AFMotor écrit directement dans les registres de timer de l'ATmega328P et de l'ATmega2560. Avec un ESP32 sélectionné, la compilation s'arrête sur 'DC_MOTOR_PWM_RATE' was not declared in this scope, et avec un Leonardo sur #error "This chip is not supported!". Les cartes ESP32 au format Uno (comme l'ESPDuino-32) s'enfichent physiquement sur le shield, mais les numéros de broches et le niveau de signal de 3,3 V sont différents. Avec ces cartes, il est bien plus simple d'utiliser un L298N, un TB6612FNG ou une seule puce L293D à la place du shield. Les entrées du L293D considèrent comme HIGH tout ce qui dépasse 2,3 V ; elles fonctionnent donc directement avec des cartes en 3,3 V :

1from machine import Pin, PWM
2import time
3
4en = PWM(Pin(15))                 # L293D pin 1 (1,2EN): hız / speed
5en.freq(1000)
6in1 = Pin(14, Pin.OUT)            # L293D pin 2 (1A): yön / direction
7in2 = Pin(13, Pin.OUT)            # L293D pin 7 (2A): yön / direction
8
9def motor(speed):                 # -100 … 100
10    in1.value(1 if speed > 0 else 0)
11    in2.value(1 if speed < 0 else 0)
12    en.duty_u16(int(abs(speed) * 655.35))
13
14while True:
15    motor(80)                     # ileri / forward
16    time.sleep(2)
17    motor(0)                      # dur / stop
18    time.sleep(0.5)
19    motor(-60)                    # geri / backward
20    time.sleep(2)
21    motor(0)
22    time.sleep(0.5)

Les masses de la Pico et de la batterie doivent impérativement être reliées. Sur l'ESP32, tu construis la même logique en langage Arduino : le sens avec digitalWrite et la vitesse avec analogWrite sur les broches du tableau. Si ces cartes sont nouvelles pour toi, commence par Qu'est-ce que l'ESP32 ? et Qu'est-ce que le Raspberry Pi Pico ?.

Les moteurs ne tournent pas : erreurs fréquentes et solutions

Idées de projets avec le shield moteur L293D

• Voiture 4WD pilotée en Bluetooth : un robot à quatre roues motrices que tu conduis depuis ton téléphone avec le code ci-dessus.
• Robot éviteur d'obstacles : une voiture qui scrute l'avant avec un HC-SR04 monté sur le servo de SER1 et tourne vers la direction la plus dégagée ; le guide complet est dans Robot éviteur d'obstacles Arduino.
• Robot suiveur de ligne : suis une ligne noire au sol avec des capteurs infrarouges sur A0–A3 ; le réglage PID est expliqué dans Robot suiveur de ligne Arduino.
• Slider pour caméra : fais glisser lentement une caméra sur un rail avec un moteur pas à pas pour filmer des timelapses.
• Tourelle pan-tilt : branche deux servos sur les deux connecteurs de servo et oriente une caméra ou un laser sur deux axes ; pour plus de servos, vois Bras robotique Arduino.
• Rideau automatique ou tapis roulant : ouvre et ferme un rideau avec un moteur CC selon la lumière, ou construis un petit convoyeur.

En résumé, pour bien utiliser le shield moteur L293D : installe la bibliothèque V1, vérifie la LED PWR, place le cavalier selon ton montage d'alimentation, n'oublie pas setSpeed(), branche les capteurs sur A0–A5 et garde tes moteurs sous la limite de 0,6 A. Avec ces règles, un petit shield porte à lui seul toute la force d'un robot à quatre moteurs. Dans l'application BlueGrays, tu trouveras la voiture pilotée en Bluetooth, le robot éviteur d'obstacles et des projets avec moteurs pas à pas et servos, étape par étape, avec schémas et code.