L293D-motorshield voor Arduino: AFMotor, 4 dc-motoren, stappenmotor, servo
Zo gebruik je het L293D-motorshield: AFMotor-bibliotheek, PWR-jumper, vrije pins, 4WD-autocode, stappenmotoren, servo's, de limiet van 0,6 A en oplossingen als motoren niet draaien.
Het L293D-motorshield is een motordriverboard dat je direct bovenop een Arduino Uno steekt en waarmee je 4 dc-motoren, 2 stappenmotoren en 2 servo's met één board aanstuurt. De twee L293D-chips leveren de stroom die de motoren nodig hebben, keren hun draairichting om en regelen hun snelheid met PWM. Zo bestuur je alle motoren van een robotauto met vier wielen zonder één jumperdraad. Bijna elk board op de markt is een kopie van het oude ontwerp van Adafruit, de Motor Shield V1, en wordt met dezelfde bibliotheek geprogrammeerd: AFMotor.
In deze gids leer je wat er op het shield zit, welke Arduino-pins het gebruikt en welke vrij blijven voor sensoren, hoe de verwarrende PWR-jumper werkt in drie verschillende voedingsopstellingen, wat de commando's van de AFMotor-bibliotheek zijn en wat de volledige code is voor een robotauto met vier wielen die je met je telefoon bestuurt. In de laatste delen behandelen we de stroomlimiet van 0,6 A, waarom de chip heet wordt, hoe het shield zich verhoudt tot de L298N en alle bekende oorzaken van "mijn motoren draaien niet" in één tabel.

Wat is het L293D-motorshield en hoe werkt het?
Om een dc-motor in beide richtingen te laten draaien heb je een schakeling met vier schakelaars nodig, een H-brug; het idee leggen we uitgebreid uit in L298N dc-motor aansturen. De L293D-chip bevat twee H-bruggen en omdat het shield twee van deze chips draagt, heb je in totaal vier motorkanalen. De "D" in de naam betekent dat de beveiligingsdiodes, die de omgekeerde spanningspieken van een motor bij het uitschakelen opvangen, in de chip zijn ingebouwd. De L293D schakelt zijn uitgangen ook zelf uit als hij oververhit raakt.
De echte truc van het shield is het 74HC595-schuifregister in het midden. Elke motor heeft twee signalen voor de richting en één voor de snelheid nodig, samen 12 Arduino-pins. Het shield stuurt de acht richtingssignalen serieel naar de 74HC595 en gebruikt daarvoor maar 4 pins (D4, D7, D8, D12), plus 4 PWM-pins voor de snelheid (D3, D5, D6, D11). Dit ontwerp bespaart pins, maar er is een nadeel: je kunt de motoren niet rechtstreeks met digitalWrite aansturen; je hebt een bibliotheek nodig die de richtingsbits in het register schuift. Die bibliotheek is AFMotor.
| Eigenschap | Waarde |
|---|---|
| Driverchips | 2 × L293D (in totaal 4 H-bruggen) |
| Richtingsregeling | 74HC595-schuifregister (D4, D7, D8, D12) |
| Voedingsspanning van de motoren | 4,5–25 V (externe voedingsklem) |
| Stroom per kanaal | 0,6 A continu, 1,2 A zeer kort piekvermogen |
| Snelheidsregeling | 8-bits PWM, setSpeed(0–255) |
| Motoren die hij kan aansturen | 4 dc-motoren, 2 stappenmotoren of 2 dc-motoren + 1 stappenmotor |
| Servo's | 2, gevoed vanaf de 5V-lijn van de Arduino (D9 en D10) |
| Beveiliging | Ingebouwde diodes, thermische uitschakeling |
| Compatibele boards | Arduino Uno R3 en Mega 2560 (Uno R4 en Leonardo worden niet ondersteund) |
Wat zit er op het board? Klemmen, headers en jumper
| Onderdeel | Wat het doet |
|---|---|
| Klemmenblok M1 en M2 (links) | Dc-motoren 1 en 2; de GND-schroef in het midden is voor de gemeenschappelijke draad van een unipolaire stappenmotor |
| Klemmenblok M3 en M4 (rechts) | Dc-motoren 3 en 4, of stappenmotorpoort 2 |
| EXT_PWR (+M en GND) | Voedingsingang voor de motoren: batterijhouder of adapter |
| PWR-jumper | Verbindt, als hij geplaatst is, de motorvoeding met de Vin-lijn van de Arduino |
| SER1 en SERVO_2 | Twee servoheaders (−, +, S); D10 en D9 |
| PWR-led | Laat zien of er motorvoeding is; als hij uit is, draaien de motoren niet |
| RESET-knop | Een kopie van de resetknop van de Arduino bovenop het shield |
| Rij A0–A5 | Vrije analoge pins; de meeste boards hebben ernaast ook rijen met +5V en GND |
Welke pins gebruikt het shield en welke blijven vrij?
| Arduino-pin | Functie op het shield | Wanneer is de pin bezet? |
|---|---|---|
| D3 | Snelheid M2 (PWM, Timer2) | Als M2 of stappenmotor 1 wordt gebruikt |
| D4 | Klok van de 74HC595 (CLK) | Als een dc- of stappenmotor wordt gebruikt |
| D5 | Snelheid M4 (PWM, Timer0) | Als M4 of stappenmotor 2 wordt gebruikt |
| D6 | Snelheid M3 (PWM, Timer0) | Als M3 of stappenmotor 2 wordt gebruikt |
| D7 | Output enable van de 74HC595 (EN) | Als een motor wordt gebruikt |
| D8 | Data-ingang van de 74HC595 (DATA) | Als een motor wordt gebruikt |
| D9 | Signaal SERVO_2 (Timer1) | Alleen als die servo wordt gebruikt |
| D10 | Signaal SER1 (Timer1) | Alleen als die servo wordt gebruikt |
| D11 | Snelheid M1 (PWM, Timer2) | Als M1 of stappenmotor 1 wordt gebruikt |
| D12 | Latch van de 74HC595 (LATCH) | Als een motor wordt gebruikt |
| D0, D1 | Niet gebruikt (seriële USB-lijn) | Tijdens het uploaden en zolang de Serial Monitor openstaat |
| D2 | Niet gebruikt; er zit een klein soldeerpad op het board | Nooit |
| D13 | Niet gebruikt, maar niet naar buiten gebracht op het shield | Nooit |
| A0–A5 (D14–D19) | Niet gebruikt; naar buiten gebracht in een rij langs de rand | Nooit |
De zes vrije analoge pins zijn ruim voldoende voor sensoren, want A0–A5 van de Uno werken indien nodig ook als digitale pins 14–19. Een praktische indeling: een HC-SR04-afstandssensor of een Bluetooth-module via SoftwareSerial op A0 en A1, lijnvolg- of obstakelsensoren op A2 en A3 en de I2C-bus (OLED, LCD, MPU6050) op A4 en A5. Voor een wielencoder of een knop die attachInterrupt() gebruikt is D2 de enige vrije pin; de andere interruptpin van de Uno, D3, is de snelheidspin van M2. Als je geen servo's gebruikt, zijn D9 en D10 ook vrij. De indeling van je board zie je in de tool Pinout en wat elke pin kan lees je in Arduino Uno-pinout.
Voeding en de PWR-jumper: drie goede manieren om aan te sluiten
De EXT_PWR-klem met twee schroeven aan de onderrand van het board is de voedingsingang voor de motoren; de plus is meestal gemarkeerd met "+M" of "+" en de min met "GND". De PWR-jumper er vlak naast verbindt deze motorlijn met de Vin-pin van de Arduino. Met de jumper erop werken beide boards op één bron: de spanning die je op EXT_PWR zet, voedt via Vin ook de Arduino, of een adapter in de DC-jack van de Arduino voedt ook de motoren. Zonder jumper zijn de twee lijnen volledig gescheiden. De PWR-led op het board brandt alleen als er motorvoeding is; het is het eerste wat je controleert voordat je motoren gaat oplossen.
| Opstelling | Voeding Arduino | Voeding motoren | PWR-jumper |
|---|---|---|---|
| Eén bron (7–12 V batterij of adapter) | Dezelfde bron, via Vin | EXT_PWR of de DC-jack van de Arduino | Geplaatst |
| Arduino via USB, motoren op batterijen | USB-kabel | EXT_PWR | Verwijderd |
| Twee aparte bronnen (de veiligste) | DC-jack of USB | EXT_PWR | Verwijderd |
De meest gekozen opstelling voor robotauto's is één bron: je sluit een pakket van twee 18650-cellen aan op EXT_PWR, plaatst de jumper en zowel de Arduino als de motoren werken op dezelfde batterij. Het is simpel, maar als de motoren bij het starten veel stroom trekken, kan de batterijspanning even inzakken en kan de Arduino resetten. Gebeurt dat, dan lost het verwijderen van de jumper en het voeden van de Arduino met een aparte bron (powerbank, USB of een 9V-adapter) het definitief op. Op de werkbank is de tweede opstelling het handigst: de Arduino blijft met je computer verbonden, de motoren draaien op batterijen en de jumper is verwijderd.
Welke batterij kies je? Afhankelijk van de stroom slikken de uitgangstransistors van de L293D ongeveer 1,5–2,6 V, dus de motor krijgt zoveel minder dan de batterijspanning. Voor de gele TT-motoren van 3–6 V uit robotkits zijn twee 18650-lithiumcellen (7,4 V nominaal, 8,4 V vol) ideaal: de motoren krijgen ongeveer 5,5–6 V en met de jumper erop is de regelaar van de Arduino ook tevreden. Vier AA-cellen (6 V) laten maar ongeveer 4 V voor de motoren over en zijn niet genoeg om de Arduino via Vin te voeden. Een 9V-blokbatterij (PP3) kan niet meer dan een paar honderd milliampère leveren; de motoren draaien dan helemaal niet of de batterij is binnen minuten leeg. Met de batterijduurcalculator schat je de looptijd en alle voedingsopties lees je in Arduino voeden met een batterij.
De AFMotor-bibliotheek installeren
- Open de Library Manager in de Arduino IDE (Tools > Manage Libraries of Ctrl+Shift+I).
- Typ Adafruit Motor Shield in het zoekvak. Er verschijnen twee resultaten: Adafruit Motor Shield library, waarvan de beschrijving "V1 firmware" vermeldt, en Adafruit Motor Shield V2 Library.
- Installeer voor het L293D-shield de V1-versie. De V2-bibliotheek is voor een heel ander board dat via I2C communiceert en TB6612-chips gebruikt.
- Voeg de regel #include <AFMotor.h> bovenaan je sketch toe.
- Open eventueel File > Examples > Adafruit Motor Shield library > MotorTest en test het board met een motor op M1.
Eerste sketch: een dc-motor vooruit, achteruit en op verschillende snelheden laten draaien
Draai de twee draden van de motor vast in de twee buitenste schroeven van de M1-klem en laat de GND-schroef in het midden leeg. Sluit de batterijhouder aan op EXT_PWR, steek de Arduino via USB in je computer en verwijder de PWR-jumper (de tweede opstelling hierboven). Brandt de PWR-led, upload dan de code hieronder: de motor versnelt en vertraagt eerst rustig, draait dan twee seconden achteruit en stopt.
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}| Commando | Wat het doet |
|---|---|
| AF_DCMotor motor(1); | Maakt de motor op de M1-klem aan; neemt een getal van 1 tot 4 |
| AF_DCMotor motor(1, MOTOR12_64KHZ); | Kiest ook de PWM-frequentie voor M1 en M2 |
| motor.setSpeed(200); | Stelt de snelheid in van 0 tot 255 (0 stopt, 255 is volle snelheid) |
| motor.run(FORWARD); | Draait vooruit |
| motor.run(BACKWARD); | Draait achteruit |
| motor.run(RELEASE); | Stuurt de motor niet meer aan; de motor stopt |
| motor.run(BRAKE); | Is in de bibliotheek gedefinieerd, maar doet niets in V1 |
De snelheid wordt ingesteld door de stroom naar de motor duizenden keren per seconde aan en uit te zetten; de details staan in Wat is PWM?. Omdat M1 en M2 Timer2 gebruiken, kun je hun frequentie kiezen: MOTOR12_64KHZ, MOTOR12_8KHZ (de standaard), MOTOR12_2KHZ en MOTOR12_1KHZ. Met 64 kHz is het gejank van de motor niet hoorbaar, maar de L293D wordt bij die frequentie heter. M3 en M4 zijn daarentegen gekoppeld aan Timer0; omdat die timer ook millis() en delay() aanstuurt, laat de bibliotheek de frequentie ervan met rust en draaien deze twee kanalen altijd op ongeveer 1 kHz.
Code voor een robotauto met vier wielen (4WD)

Het favoriete gebruik van het L293D-motorshield is een robotauto met vier wielen, omdat elk van de vier motoren een eigen klem heeft en er geen kabelwirwar ontstaat. Deze auto's hebben geen stuur; ze draaien als een tank: als de twee linkerwielen de ene kant op draaien en de twee rechterwielen de andere, draait de auto op de plek. Daarom stuurt de code de motoren niet één voor één aan, maar in twee groepen: de linkerkant en de rechterkant. Voor bediening met je telefoon sluiten we met SoftwareSerial een HC-05 Bluetooth-module aan op de vrije pins A0 en A1; de module wordt uitgebreid behandeld in HC-05 Bluetooth-module.
| Onderdeel | Aansluiting |
|---|---|
| Motor linksvoor | M1 |
| Motor linksachter | M2 |
| Motor rechtsachter | M3 |
| Motor rechtsvoor | M4 |
| HC-05 TXD | A0 (SoftwareSerial RX) |
| HC-05 RXD | A1, via een spanningsdeler van 1 kΩ + 2 kΩ (5 V → 3,3 V) |
| VCC en GND van de HC-05 | De rij +5V en GND op het shield |
| 2 × 18650-cellen (7,4 V) | EXT_PWR (+M en GND), PWR-jumper geplaatst |
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}Het hart van de code is de functie drive(left, right): die neemt voor elke kant een waarde van -255 tot 255, waarbij positief vooruit betekent, negatief achteruit en nul stoppen. setSpeed() geeft beide motoren aan één kant dezelfde snelheid en richting. De commando's zijn de losse letters die apps in de stijl van "Arduino Bluetooth RC Car" uit de appstores sturen: F vooruit, B achteruit, L en R draaien op de plek, G en I bochten, S stop. De snelheidsschuif in de app stuurt een cijfer van 0 tot 9; de code zet dat om in een PWM-waarde tussen 90 en 240 en omdat de ondergrens 90 is, kunnen de motoren ook op de laagste stand nog starten. Als één wiel de verkeerde kant op draait, pas dan de code niet aan; verwissel de twee draden van die motor in zijn klem. Voor de montage van het chassis en een versie met twee motoren zie je Een Arduino-robotauto maken.
Stappenmotoren aansturen: 28BYJ-48 en NEMA 17
Het shield kan twee stappenmotoren tegelijk aansturen: stappenmotorpoort 1 gebruikt de klemmen M1 en M2 en poort 2 gebruikt M3 en M4. Bij een bipolaire motor (4 draden, zoals een NEMA 17) sluit je de ene spoel aan op M1 en de andere spoel op M2. Bij een unipolaire motor (5 of 6 draden) gaan de twee spoelen ook naar M1 en M2 en gaat de gemeenschappelijke draad naar de GND-schroef in het midden van het klemmenblok. Voor de populaire 28BYJ-48 is de bedrading: blauwe en gele draad naar M1, roze en oranje draad naar M2 en de rode gemeenschappelijke draad naar GND. Het gebruik van deze motor met het ULN2003-board staat in Wat is een stappenmotor?.
| Stapstijl | Hoe het werkt | Wanneer gebruik je het |
|---|---|---|
| SINGLE | Er wordt telkens één spoel bekrachtigd | Laagste stroom, laagste koppel |
| DOUBLE | Twee spoelen worden samen bekrachtigd | Hoger koppel; de meest gekozen optie |
| INTERLEAVE | Wisselt enkele en dubbele spoelen af (halve stappen) | Dubbele resolutie, soepelere rotatie |
| MICROSTEP | De spoelstromen veranderen geleidelijk met PWM; elke hele stap wordt in 16 verdeeld | Langzame en stille rotatie; het koppel daalt |
De 28BYJ-48 is een 5V-motor; voed de motoren voor deze test met 4 AA-cellen (6 V), verwijder de jumper en laat de Arduino op USB draaien. Door de tandwielkast in de motor is één omwenteling 2048 hele stappen:
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() stelt het aantal toeren per minuut in; door zijn tandwielkast kan de 28BYJ-48 niet sneller draaien dan ongeveer 10–15 RPM. Let op: step() is blokkerend; totdat de motor de gevraagde stappen heeft gezet, doet loop() niets anders. Als je sensoren wilt uitlezen of dc-motoren wilt aansturen terwijl de stappenmotor draait, gebruik dan de functie onestep() van de bibliotheek samen met de AccelStepper-bibliotheek; het voorbeeld AFMotor_ConstantSpeed dat bij de bibliotheek hoort, laat precies dat zien. Als je release() aanroept terwijl de motor wacht, gaan de spoelen uit en voorkom je opwarming, maar de as verliest ondertussen zijn houdkoppel.
Servo's aansluiten: de headers SER1 en SERVO_2
De twee headers met drie pins in de hoek van het shield zijn voor servo's. Volgens de markeringen op het board zijn de pins − (GND), + (5 V) en S (signaal): de bruine draad van de servo gaat naar −, de rode naar + en de oranje naar S. Volgens het schema van het board is de SER1-header verbonden met D10 en de SERVO_2-header met D9 (sommige bronnen noemen de nummers andersom; als de servo niet beweegt, probeer dan de andere pin in de code). Servo's stuur je aan met de standaard Servo-bibliotheek en de Timer1 die die op de Uno gebruikt, komt niet in conflict met de timers van de motoren, dus dc-motoren en servo's werken zonder problemen samen.
De servo's worden niet gevoed vanaf de motorbatterij maar vanaf de 5V-lijn van de Arduino. Dat is prima voor een SG90, maar grote servo's zoals de MG996R kunnen tijdens het bewegen meer dan 1 A trekken; de regelaar van de Arduino wordt heet, de spanning stort in en het board reset. Steek bij grote servo's alleen de signaaldraad in de header, voed de + en − van de servo met een aparte 5–6V-bron en verbind de massa's. De details staan in MG996R-servo met Arduino en Wat is een servomotor?. De code hieronder laat de servo op SER1 naar links en rechts zwaaien terwijl de motor op M3 draait:
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}Stroomlimiet (0,6 A) en warmte
De belangrijkste regel in de datasheet van de L293D is 0,6 A continu en 1,2 A piek per kanaal. De piekwaarde is alleen voor zeer korte pulsen; als een motor seconden lang 1 A trekt, krijgt de chip het zwaar. Een eenvoudige berekening laat zien waarom hij heet wordt: de L293D is een driver van het oude type met bipolaire transistors en bij 0,6 A valt er doorgaans 1,4 V over de bovenste transistor en 1,2 V over de onderste. Als een motor 0,6 A trekt, ontstaat dus 0,6 A × 2,6 V ≈ 1,6 W warmte in de chip; twee motoren op dezelfde chip geven twee keer zoveel, ongeveer 3 W. Een kleine DIP-chip zonder koelplaat kan die warmte niet kwijt, de temperatuur stijgt snel en uiteindelijk schakelt de thermische uitschakeling de uitgangen uit. Het symptoom is bekend: de motoren draaien een tijdje, stoppen en starten weer zodra de chip is afgekoeld.
Gele TT-motoren trekken ongeveer 150 mA zonder belasting en 200–300 mA tijdens het rijden over de vloer, en dat valt binnen de grenzen van het shield. Het probleem zijn de momenten waarop een wiel tegen een obstakel duwt of de auto op de plek draait: een vastgelopen TT-motor kan 1–1,5 A trekken en in een 4WD-auto spannen alle vier de motoren zich tegelijk in bij een draai op de plek. Om de echte stroom van je motor te vinden, sluit je een multimeter in serie met de motor aan en meet je terwijl je het wiel kort met je hand vasthoudt; Een multimeter gebruiken laat zien hoe. Zo houd je het shield koel:
- Gebruik een zachte start: Spring niet van 0 naar 255; verhoog de snelheid geleidelijk over 200–300 ms en de startstroom daalt merkbaar.
- Laat de motor niet vastlopen: Stop bij robots die obstakels ontwijken de auto voordat hij het obstakel raakt; een vastgelopen motor produceert de meeste warmte.
- Plak koelplaatjes op de chips: Kleine aluminium koelplaatjes met thermische tape verlagen de temperatuur van de L293D enigszins.
- Soldeer een tweede L293D erbovenop: Adafruit merkt ook op dat je een tweede L293D bovenop de bestaande chips kunt solderen, pootje op pootje, om de stroomcapaciteit te vergroten; de twee chips delen de stroom.
- Gebruik niet meer spanning dan nodig: 12 V op motoren van 6 V geven zowel meer stroom als meer warmte.
- Stap over op de juiste driver: Als je motor continu meer dan 0,6 A trekt, gebruik dan een driver op basis van de L298N of TB6612FNG.
L293D-motorshield of L298N?

| Eigenschap | L293D motor shield | L298N-module |
|---|---|---|
| Aantal motoren | 4 dc-motoren, of 2 stappenmotoren + 2 servo's | 2 dc-motoren of 1 stappenmotor |
| Stroom per kanaal | 0,6 A continu, 1,2 A piek | 2 A continu, 3 A piek |
| Motorspanning | 4,5–25 V | 5–35 V |
| Spanningsverlies | Ongeveer 1,5–2,6 V | Ongeveer 2–3 V |
| Aansluiting | Steek je op de Uno, geen draden | Jumperdraden; je kiest zelf de pins |
| Gebruikte pins | 8 vaste pins + D9 en D10 voor servo's | 6 pins (ENA, IN1–IN4, ENB) |
| Bibliotheek | AFMotor vereist | Niet nodig (digitalWrite, analogWrite) |
| ESP32 en Pico | Niet geschikt | Werkt rechtstreeks |
| Het best voor | 4WD-auto's met TT-motoren, leerkits | Sterkere motoren, 2WD-robots |
Kortom: als je een 4WD-auto met TT-motoren op een Arduino Uno bouwt, houdt het L293D-shield de bedrading minimaal en zitten alle vier de motoren op één board. Als je motoren sterker zijn, je board een ESP32 of een Pico is, of je zelf de pins wilt kiezen, is de L298N flexibeler; details staan in L298N dc-motor aansturen. Wil je iets efficiënters dan beide, dan heeft de MOSFET-gebaseerde TB6612FNG een heel laag spanningsverlies en gaan je batterijen langer mee. Welk motortype bij welke taak past, vergelijken we in Dc-motor, servomotor en stappenmotor vergeleken.
Kun je het gebruiken met een ESP32, Raspberry Pi Pico of Mega?
Het werkt prima met de Arduino Mega 2560: het shield zit op de eerste digitale en analoge pins van de Mega en AFMotor kent de timers van de Mega. Het werkt niet met de Uno R4, Leonardo, ESP32 of Raspberry Pi Pico, omdat AFMotor rechtstreeks naar de timerregisters van de ATmega328P en ATmega2560 schrijft. Met een ESP32 geselecteerd stopt de build met 'DC_MOTOR_PWM_RATE' was not declared in this scope en met een Leonardo geselecteerd met #error "This chip is not supported!". ESP32-boards in Uno-vorm (zoals de ESPDuino-32) passen fysiek op het shield, maar de pinnummers en het signaalniveau van 3,3 V zijn anders. Op deze boards is het veel makkelijker om in plaats van het shield een L298N, een TB6612FNG of een losse L293D-chip te gebruiken. De ingangen van de L293D beschouwen alles boven 2,3 V als HIGH, dus hij werkt rechtstreeks met boards van 3,3 V:
| L293D-pin | Functie | Raspberry Pi Pico | ESP32 |
|---|---|---|---|
| 1 (1,2EN) | Snelheid (PWM) | GP15 | GPIO 25 |
| 2 (1A) | Richting 1 | GP14 | GPIO 26 |
| 7 (2A) | Richting 2 | GP13 | GPIO 27 |
| 3 en 6 (1Y, 2Y) | Motorklemmen | Naar de motor | Naar de motor |
| 4, 5, 12, 13 | GND (via deze pins gaat ook warmte weg) | GND | GND |
| 16 (VCC1) | Voeding voor de logica, 5 V | VBUS (pin 40) | 5V (VIN) |
| 8 (VCC2) | Motorvoeding | Plus van de batterij | Plus van de batterij |
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)De massa's van de Pico en de batterij moeten met elkaar zijn verbonden. Op de ESP32 bouw je dezelfde logica in de Arduino-taal: richting met digitalWrite en snelheid met analogWrite op de pins uit de tabel. Als deze boards nieuw voor je zijn, begin dan met Wat is de ESP32? en Wat is de Raspberry Pi Pico?.
Motoren draaien niet: veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Geen enkele motor draait, PWR-led is uit | Geen motorvoeding: EXT_PWR is leeg of alleen USB is aangesloten | Sluit een batterij van 6–12 V aan op EXT_PWR; de motoren draaien pas als de led brandt |
| Led brandt, code geüpload, maar de motor beweegt niet | Geen setSpeed() in de code, of het motornummer komt niet overeen met de klem | Voeg setSpeed(200) toe in setup(); controleer of AF_DCMotor(1) overeenkomt met M1 |
| Motor zoemt maar draait niet | PWM-waarde te laag of batterij zwak | Begin boven 100; laad de batterij op of gebruik twee 18650-cellen |
| "AFMotor.h: No such file or directory" | Bibliotheek niet geïnstalleerd, of V2 geïnstalleerd in plaats van V1 | Installeer de V1 Adafruit Motor Shield library via de Library Manager |
| "This chip is not supported!" of een "DC_MOTOR_PWM_RATE"-fout | Uno R4, Leonardo of ESP32 geselecteerd als board | Kies Uno of Mega onder Tools > Board |
| Arduino reset als de motoren starten | De startstroom trekt de batterijspanning omlaag (brownout) | Verwijder de jumper en voed de Arduino apart; soldeer een condensator van 100 nF over de motorklemmen |
| Motor draait een tijdje en stopt dan, chip is erg heet | De thermische uitschakeling van de L293D is geactiveerd | Verminder de belasting, gebruik een zachte start, voeg koelplaatjes toe of stap over op een L298N |
| Motoren wisselen willekeurig van richting | D4, D7, D8 of D12 wordt in de code voor iets anders gebruikt | Verplaats je sensoren naar A0–A5 |
| Snelheid van M1 en M2 verandert niet, M3 en M4 zijn in orde | tone() of IRremote gebruikt Timer2 | Verplaats deze motoren naar M3 en M4 of verwijder de conflicterende code |
| Eén wiel draait achteruit | Motordraden in de klem verwisseld | Verwissel de twee draden van die motor |
| Board gedraagt zich vreemd zodra het shield erop zit | De USB-poort van de Uno raakt soldeerpunten onder het shield, of een pin is verbogen | Plak isolatietape op de USB-poort, buig de pins recht en plaats het shield opnieuw |
Projectideeën met het L293D-motorshield
- Met Bluetooth bestuurde 4WD-auto: Een robot met vierwielaandrijving die je met de code hierboven met je telefoon bestuurt.
- Robot die obstakels ontwijkt: Een auto die vooruit scant met een HC-SR04 op de servo van SER1 en naar de meest open richting draait; de volledige gids staat in Obstakelontwijkende robot met Arduino.
- Lijnvolgrobot: Volg een zwarte lijn op de vloer met infraroodsensoren op A0–A3; het afstellen van de PID staat in Lijnvolgrobot met Arduino.
- Camerarail: Verplaats een camera langzaam over een rail met een stappenmotor en maak timelapsevideo's.
- Pan-tilt-kop: Steek twee servo's in de twee servoheaders en richt een camera of een laser over twee assen; voor meer servo's zie je Arduino-robotarm.
- Automatisch gordijn of lopende band: Open en sluit een gordijn met een dc-motor afhankelijk van het licht, of bouw een kleine lopende band.
Hier is de samenvatting van het juiste gebruik van het L293D-motorshield: installeer de V1-bibliotheek, controleer de PWR-led, zet de jumper passend bij je voedingsopstelling, vergeet setSpeed() niet, sluit sensoren aan op A0–A5 en houd je motoren onder de limiet van 0,6 A. Volg deze regels en een klein shield kan in zijn eentje alle spierkracht van een robot met vier motoren dragen. In de BlueGrays-app vind je de projecten met Bluetooth-auto, obstakelontwijkende robot, stappenmotor en servo stap voor stap met schakelschema's en code.
Veelgestelde vragen
Hoeveel motoren kan het L293D-motorshield aansturen?
Het shield kan 4 dc-motoren tegelijk aansturen, elk onafhankelijk vooruit, achteruit en op verschillende snelheden. In plaats van dc-motoren kun je ook 2 stappenmotoren aansluiten (de paren M1–M2 en M3–M4), of 2 dc-motoren plus 1 stappenmotor. Daarnaast zijn er twee servoheaders; de servo's worden onafhankelijk van de motoren aangestuurd vanaf D9 en D10.
Waar dient de PWR-jumper op het L293D-motorshield voor?
Met de jumper erop is de motorvoeding van het shield verbonden met de Vin-lijn van de Arduino en werken beide boards op één bron. Als je de Arduino via USB voedt en de motoren met een aparte batterij, moet je de jumper verwijderen. Als je met de jumper erop aparte bronnen aansluit op zowel de DC-jack als EXT_PWR, sluit je de twee voedingen kort.
Welke batterij moet ik gebruiken met het L293D-motorshield?
Voor robotauto's met TT-motoren is de beste keuze twee 18650-lithiumcellen (7,4 V); omdat de L293D ongeveer 2 V verliest, krijgen de motoren 5,5–6 V. Vier AA-cellen laten de motoren maar ongeveer 4 V en een 9V-blokbatterij (PP3) kan niet genoeg stroom leveren om motoren aan te sturen. Let op de polariteit als je de batterij op EXT_PWR aansluit, want de klem heeft geen beveiliging tegen omgekeerde polariteit.
Hoe los ik "AFMotor.h: No such file or directory" op?
Deze fout betekent dat de AFMotor-bibliotheek niet is geïnstalleerd. Zoek in de Library Manager naar Adafruit Motor Shield en installeer de Adafruit Motor Shield library waarvan de beschrijving V1 vermeldt. De V2-bibliotheek is voor een ander board en bevat het bestand AFMotor.h niet.
Hoeveel stroom kan het L293D-motorshield aan en waarom wordt het heet?
Elk kanaal kan 0,6 A continu leveren en 1,2 A voor zeer korte pieken. Omdat de transistors van de L293D bij 0,6 A ongeveer 2,6 V laten vallen, ontstaat per motor bijna 1,5 W warmte; daarom wordt de chip heet en schakelt hij zichzelf uit als de limiet wordt overschreden. Zorg dat je motoren niet vastlopen en gebruik voor motoren die continu meer dan 0,6 A trekken een sterkere driver zoals de L298N.
Is het L293D-motorshield of de L298N beter?
Als je een 4WD-auto met TT-motoren op een Arduino Uno bouwt, is het L293D-shield praktischer omdat het zonder draden direct past en vier motorkanalen heeft. Gebruik je sterkere motoren, een ESP32 of een Pico, of wil je de pins zelf kiezen, dan past de L298N met 2 A per kanaal beter. Beide verliezen ongeveer 2 V van de motorspanning.
Projecten om hierna te bouwen
Alle projecten bekijken
Auto met Bluetooth-besturing en L298N
Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

Obstakelvermijdende robot
Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

Een stappenmotor gebruiken
Een motor die stap voor stap draait, precies zo ver als jij wilt, zoals de wijzer van een klok.

360-gradenservo van een stappenmotor
Leer een gewone stappenmotor naar elke gewenste hoek te gaan, helemaal rond de cirkel.

Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

Servomotor aansturen met een potentiometer
Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

LED bedienen met je telefoon via Bluetooth
Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

Zwart-wit ondergrond herkennen met TCRT5000
Met de kleine sensor die de ogen van lijnvolgrobots vormt, merk je of de ondergrond zwart of wit is.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

