Componenten · 17 min leestijd

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.

L293D-motorshield bovenaanzicht: klemmen M1–M4, servoheaders en voedingsjumper
L293D-motorshield (Adafruit V1-ontwerp): de 74HC595 in het midden met aan elke kant een L293D-chip; klemmen M1–M2 links, M3–M4 rechts, twee servoheaders linksboven en onderaan de externe voedingsklem en de PWR-jumper.

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.

EigenschapWaarde
Driverchips2 × L293D (in totaal 4 H-bruggen)
Richtingsregeling74HC595-schuifregister (D4, D7, D8, D12)
Voedingsspanning van de motoren4,5–25 V (externe voedingsklem)
Stroom per kanaal0,6 A continu, 1,2 A zeer kort piekvermogen
Snelheidsregeling8-bits PWM, setSpeed(0–255)
Motoren die hij kan aansturen4 dc-motoren, 2 stappenmotoren of 2 dc-motoren + 1 stappenmotor
Servo's2, gevoed vanaf de 5V-lijn van de Arduino (D9 en D10)
BeveiligingIngebouwde diodes, thermische uitschakeling
Compatibele boardsArduino Uno R3 en Mega 2560 (Uno R4 en Leonardo worden niet ondersteund)

Wat zit er op het board? Klemmen, headers en jumper

OnderdeelWat 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-jumperVerbindt, als hij geplaatst is, de motorvoeding met de Vin-lijn van de Arduino
SER1 en SERVO_2Twee servoheaders (−, +, S); D10 en D9
PWR-ledLaat zien of er motorvoeding is; als hij uit is, draaien de motoren niet
RESET-knopEen kopie van de resetknop van de Arduino bovenop het shield
Rij A0–A5Vrije analoge pins; de meeste boards hebben ernaast ook rijen met +5V en GND

Welke pins gebruikt het shield en welke blijven vrij?

Arduino-pinFunctie op het shieldWanneer is de pin bezet?
D3Snelheid M2 (PWM, Timer2)Als M2 of stappenmotor 1 wordt gebruikt
D4Klok van de 74HC595 (CLK)Als een dc- of stappenmotor wordt gebruikt
D5Snelheid M4 (PWM, Timer0)Als M4 of stappenmotor 2 wordt gebruikt
D6Snelheid M3 (PWM, Timer0)Als M3 of stappenmotor 2 wordt gebruikt
D7Output enable van de 74HC595 (EN)Als een motor wordt gebruikt
D8Data-ingang van de 74HC595 (DATA)Als een motor wordt gebruikt
D9Signaal SERVO_2 (Timer1)Alleen als die servo wordt gebruikt
D10Signaal SER1 (Timer1)Alleen als die servo wordt gebruikt
D11Snelheid M1 (PWM, Timer2)Als M1 of stappenmotor 1 wordt gebruikt
D12Latch van de 74HC595 (LATCH)Als een motor wordt gebruikt
D0, D1Niet gebruikt (seriële USB-lijn)Tijdens het uploaden en zolang de Serial Monitor openstaat
D2Niet gebruikt; er zit een klein soldeerpad op het boardNooit
D13Niet gebruikt, maar niet naar buiten gebracht op het shieldNooit
A0–A5 (D14–D19)Niet gebruikt; naar buiten gebracht in een rij langs de randNooit

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.

Zolang het shield erop zit, gebruik je D3–D8, D11 en D12 niet voor iets anders in je code. Als je bijvoorbeeld de trig-pin van de HC-SR04 op D7 of een led op D12 aansluit, raken de gegevens naar de 74HC595 verstoord en wisselen de motoren willekeurig van richting. Bovendien komt het snelheidssignaal voor M1 en M2 van Timer2: de functie tone() en de IRremote-bibliotheek gebruiken op de Uno ook Timer2, dus zolang die draaien werkt de snelheidsregeling van M1 en M2 niet.

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.

OpstellingVoeding ArduinoVoeding motorenPWR-jumper
Eén bron (7–12 V batterij of adapter)Dezelfde bron, via VinEXT_PWR of de DC-jack van de ArduinoGeplaatst
Arduino via USB, motoren op batterijenUSB-kabelEXT_PWRVerwijderd
Twee aparte bronnen (de veiligste)DC-jack of USBEXT_PWRVerwijderd

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.

De EXT_PWR-klem heeft geen diode tegen omgekeerde polariteit; als je de batterij verkeerd om aansluit, is het shield direct kapot en hoogstwaarschijnlijk ook de Arduino. Sluit met de jumper erop nooit aparte bronnen aan op zowel de DC-jack als EXT_PWR, anders sluit je de twee voedingen kort. En voed nooit de motorvoeding in de 5V-pin van de Arduino.

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

  1. Open de Library Manager in de Arduino IDE (Tools > Manage Libraries of Ctrl+Shift+I).
  2. 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.
  3. 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.
  4. Voeg de regel #include <AFMotor.h> bovenaan je sketch toe.
  5. Open eventueel File > Examples > Adafruit Motor Shield library > MotorTest en test het board met een motor op M1.
Als je bij het compileren AFMotor.h: No such file or directory krijgt, is de bibliotheek niet geïnstalleerd of heb je per ongeluk de V2-bibliotheek geïnstalleerd; het headerbestand van V2 heet Adafruit_MotorShield.h en werkt niet met het L293D-board. Voor andere problemen met het installeren van bibliotheken zie je Een Arduino-bibliotheek installeren.

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.

C++ (Arduino IDE)
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}
CommandoWat 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.

De meest gemaakte fout is het vergeten van setSpeed(). De bibliotheek zet de snelheid op 0 bij het aanmaken van de motor, dus ook al schrijf je run(FORWARD), de motor beweegt niet zonder snelheid. De meeste TT-motoren zoemen bovendien alleen en draaien niet onder 80–100, dus begin op 100–120 of hoger.

Code voor een robotauto met vier wielen (4WD)

Gele TT-dc-motor met tandwielkast en wiel
De gele TT-motor met tandwielkast uit robotkits: werkt op 3–6 V, trekt ongeveer 150 mA zonder belasting en meer dan 1 A als hij vastloopt.

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.

OnderdeelAansluiting
Motor linksvoorM1
Motor linksachterM2
Motor rechtsachterM3
Motor rechtsvoorM4
HC-05 TXDA0 (SoftwareSerial RX)
HC-05 RXDA1, via een spanningsdeler van 1 kΩ + 2 kΩ (5 V → 3,3 V)
VCC en GND van de HC-05De rij +5V en GND op het shield
2 × 18650-cellen (7,4 V)EXT_PWR (+M en GND), PWR-jumper geplaatst
C++ (Arduino IDE)
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.

De RXD-pin van de HC-05 werkt op 3,3 V; sluit het 5V-TX-signaal van de Arduino er niet op aan zonder het te verlagen met een spanningsdeler. Als de verbinding wegvalt, rijdt de auto bovendien door met het laatste commando; met millis() voeg je eenvoudig een veiligheidsregel toe die drive(0, 0) aanroept zodra er een seconde is verstreken sinds de laatste letter.

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?.

StapstijlHoe het werktWanneer gebruik je het
SINGLEEr wordt telkens één spoel bekrachtigdLaagste stroom, laagste koppel
DOUBLETwee spoelen worden samen bekrachtigdHoger koppel; de meest gekozen optie
INTERLEAVEWisselt enkele en dubbele spoelen af (halve stappen)Dubbele resolutie, soepelere rotatie
MICROSTEPDe spoelstromen veranderen geleidelijk met PWM; elke hele stap wordt in 16 verdeeldLangzame 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:

C++ (Arduino IDE)
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.

De meeste NEMA 17-motoren trekken 1,5–2 A per spoel en hebben een spoelweerstand van ongeveer 1,5–3 Ω. Omdat de L293D geen stroombegrenzing heeft, overschrijden deze motoren op 12 V de kanaallimiet vele malen en schakelt de chip zichzelf binnen seconden uit. Gebruik met het L293D-shield alleen stappenmotoren met een hoge spoelweerstand die bij 12 V minder dan 0,4 A trekken; voor krachtige NEMA 17-motoren is een A4988-driver de juiste keuze.

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:

C++ (Arduino IDE)
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?

L298N-module voor twee motoren
L298N-module: twee H-bruggen in één chip, een grote koelplaat en 2 A per kanaal; wordt met kabels aangesloten, dus past bij elk board.
EigenschapL293D motor shieldL298N-module
Aantal motoren4 dc-motoren, of 2 stappenmotoren + 2 servo's2 dc-motoren of 1 stappenmotor
Stroom per kanaal0,6 A continu, 1,2 A piek2 A continu, 3 A piek
Motorspanning4,5–25 V5–35 V
SpanningsverliesOngeveer 1,5–2,6 VOngeveer 2–3 V
AansluitingSteek je op de Uno, geen dradenJumperdraden; je kiest zelf de pins
Gebruikte pins8 vaste pins + D9 en D10 voor servo's6 pins (ENA, IN1–IN4, ENB)
BibliotheekAFMotor vereistNiet nodig (digitalWrite, analogWrite)
ESP32 en PicoNiet geschiktWerkt rechtstreeks
Het best voor4WD-auto's met TT-motoren, leerkitsSterkere 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-pinFunctieRaspberry Pi PicoESP32
1 (1,2EN)Snelheid (PWM)GP15GPIO 25
2 (1A)Richting 1GP14GPIO 26
7 (2A)Richting 2GP13GPIO 27
3 en 6 (1Y, 2Y)MotorklemmenNaar de motorNaar de motor
4, 5, 12, 13GND (via deze pins gaat ook warmte weg)GNDGND
16 (VCC1)Voeding voor de logica, 5 VVBUS (pin 40)5V (VIN)
8 (VCC2)MotorvoedingPlus van de batterijPlus van de batterij
MicroPython
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

SymptoomWaarschijnlijke oorzaakOplossing
Geen enkele motor draait, PWR-led is uitGeen motorvoeding: EXT_PWR is leeg of alleen USB is aangeslotenSluit 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 nietGeen setSpeed() in de code, of het motornummer komt niet overeen met de klemVoeg setSpeed(200) toe in setup(); controleer of AF_DCMotor(1) overeenkomt met M1
Motor zoemt maar draait nietPWM-waarde te laag of batterij zwakBegin 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 V1Installeer de V1 Adafruit Motor Shield library via de Library Manager
"This chip is not supported!" of een "DC_MOTOR_PWM_RATE"-foutUno R4, Leonardo of ESP32 geselecteerd als boardKies Uno of Mega onder Tools > Board
Arduino reset als de motoren startenDe 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 heetDe thermische uitschakeling van de L293D is geactiveerdVerminder de belasting, gebruik een zachte start, voeg koelplaatjes toe of stap over op een L298N
Motoren wisselen willekeurig van richtingD4, D7, D8 of D12 wordt in de code voor iets anders gebruiktVerplaats je sensoren naar A0–A5
Snelheid van M1 en M2 verandert niet, M3 en M4 zijn in ordetone() of IRremote gebruikt Timer2Verplaats deze motoren naar M3 en M4 of verwijder de conflicterende code
Eén wiel draait achteruitMotordraden in de klem verwisseldVerwissel de twee draden van die motor
Board gedraagt zich vreemd zodra het shield erop zitDe USB-poort van de Uno raakt soldeerpunten onder het shield, of een pin is verbogenPlak isolatietape op de USB-poort, buig de pins recht en plaats het shield opnieuw
De snelste manier om het probleem te vinden is de test terug te brengen tot het eenvoudigste: leg de hele autosketch opzij, sluit één motor aan op M1, controleer of de PWR-led brandt en upload de eerste sketch hierboven. Als die werkt, zit het probleem in je code en niet in het shield; werkt hij niet, begin dan bij de voeding en de bibliotheek. Alle redenen waarom een Arduino steeds opnieuw start, staan in Arduino blijft resetten?.

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.

Alle projecten bekijken
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

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…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

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.

5.0(38)
49
Een stappenmotor gebruiken
AR-67Gemiddeld
Premium

Een stappenmotor gebruiken

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

4.5(31)
42
360-gradenservo van een stappenmotor
AR-68Gemiddeld
Premium

360-gradenservo van een stappenmotor

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

4.5(22)
33
Een servomotor gebruiken
AR-35Beginner
Premium

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.

4.7(48)
67
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

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.

4.6(37)
53
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

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

4.8(69)
91
Zwart-wit ondergrond herkennen met TCRT5000
AR-78Gemiddeld
Premium

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.

4.7(40)
49