L293D Motor Shield am Arduino: AFMotor, 4 Motoren, Stepper, Servo

Das L293D Motor Shield ist eine Motortreiberplatine, die du direkt auf einen Arduino Uno steckst und mit der du 4 DC-Motoren, 2 Schrittmotoren und 2 Servos über eine einzige Platine ansteuerst. Die beiden L293D-Chips liefern den Strom, den die Motoren brauchen, kehren ihre Drehrichtung um und stellen die Geschwindigkeit per PWM ein. So steuerst du alle Motoren eines vierrädrigen Roboterautos, ohne ein einziges Jumper-Kabel zu verlegen. Fast alle Platinen auf dem Markt sind Kopien des alten Motor Shield V1 von Adafruit und werden mit derselben Bibliothek programmiert: AFMotor.

In dieser Anleitung erfährst du, was auf dem Shield sitzt, welche Arduino-Pins es belegt und welche für Sensoren frei bleiben, wie der oft missverstandene PWR-Jumper in drei verschiedenen Stromversorgungen funktioniert, welche Befehle die AFMotor-Bibliothek kennt, und du bekommst den kompletten Code für ein vierrädriges Roboterauto, das du per Handy steuerst. In den letzten Abschnitten geht es um die Stromgrenze von 0,6 A, warum der Chip heiß wird, den Vergleich mit dem L298N und alle bekannten Ursachen für „die Motoren drehen nicht“ in einer Tabelle.

Was ist das L293D Motor Shield und wie funktioniert es?

Damit sich ein DC-Motor in beide Richtungen dreht, brauchst du eine Schaltung mit vier Schaltern, die H-Brücke; das Prinzip erklären wir ausführlich in DC-Motor mit L298N steuern. Im L293D stecken zwei H-Brücken, und weil das Shield zwei dieser Chips trägt, hast du insgesamt vier Motorkanäle. Das „D“ im Namen bedeutet, dass die Schutzdioden, die die Gegenspannungsspitzen beim Abschalten eines Motors abfangen, bereits im Chip eingebaut sind. Außerdem schaltet der L293D seine Ausgänge bei Überhitzung selbst ab.

Der eigentliche Trick des Shields ist das Schieberegister 74HC595 in der Mitte. Jeder der vier Motoren braucht zwei Signale für die Richtung und eins für die Geschwindigkeit, zusammen also 12 Arduino-Pins. Das Shield schickt die acht Richtungssignale seriell an den 74HC595 und braucht dafür nur 4 Pins (D4, D7, D8, D12), dazu 4 PWM-Pins für die Geschwindigkeit (D3, D5, D6, D11). Das spart Pins, hat aber einen Preis: Du kannst die Motoren nicht direkt mit digitalWrite ansteuern, sondern brauchst eine Bibliothek, die die Richtungsbits ins Register schiebt. Diese Bibliothek ist AFMotor.

Was ist auf der Platine? Klemmen, Stiftleisten und Jumper

Welche Pins belegt das Shield und welche bleiben frei?

Die sechs freien Analogpins reichen für Sensoren mehr als aus, denn A0–A5 des Uno arbeiten bei Bedarf auch als digitale Pins 14–19. Eine praktische Aufteilung wäre: ein Ultraschallsensor HC-SR04 oder ein Bluetooth-Modul per SoftwareSerial an A0 und A1, Linien- oder Hindernissensoren an A2 und A3 und der I2C-Bus (OLED, LCD, MPU6050) an A4 und A5. Für einen Radencoder oder Taster mit attachInterrupt() bleibt nur D2 frei; der zweite Interrupt-Pin des Uno, D3, ist der Geschwindigkeitspin von M2. Wenn du keine Servos nutzt, sind auch D9 und D10 frei. Die Pinbelegung deines Boards siehst du im Tool Pinout, was die einzelnen Pins können, in Arduino Uno Pinbelegung.

Stromversorgung und PWR-Jumper: drei richtige Varianten

Die zweipolige Klemme EXT_PWR am unteren Rand der Platine ist der Stromeingang für die Motoren; der Pluspol ist meist mit „+M“ oder „+“, der Minuspol mit „GND“ beschriftet. Der PWR-Jumper direkt daneben verbindet diese Motorleitung mit dem Vin-Pin des Arduino. Mit gestecktem Jumper laufen beide Platinen aus einer Quelle: Die Spannung an EXT_PWR versorgt über Vin auch den Arduino, oder ein Netzteil an der Hohlbuchse des Arduino versorgt auch die Motoren. Ohne Jumper sind beide Leitungen vollständig getrennt. Die PWR-LED auf der Platine leuchtet nur, wenn Motorstrom anliegt; sie ist das Erste, was du prüfst, bevor du dich mit den Motoren beschäftigst.

Bei Roboterautos ist eine einzige Quelle am verbreitetsten: Du schließt einen Pack aus zwei 18650-Zellen an EXT_PWR an, steckst den Jumper, und Arduino und Motoren laufen am selben Akku. Das ist einfach, aber wenn die Motoren beim Anfahren viel Strom ziehen, kann die Akkuspannung kurz einbrechen und der Arduino neu starten. Passiert dir das, ist die sichere Lösung, den Jumper zu entfernen und den Arduino aus einer eigenen Quelle zu versorgen (Powerbank, USB oder ein 9-V-Netzteil). Auf dem Schreibtisch ist die zweite Variante am praktischsten: Der Arduino bleibt am Computer, die Motoren laufen am Akku und der Jumper ist entfernt.

Welchen Akku solltest du wählen? Je nach Strom verschlucken die Ausgangstransistoren des L293D etwa 1,5–2,6 V, der Motor bekommt also so viel weniger als die Akkuspannung. Für die gelben 3–6-V-TT-Motoren aus Roboterbausätzen sind zwei 18650-Lithiumzellen (7,4 V nominal, 8,4 V voll geladen) ideal: Die Motoren bekommen etwa 5,5–6 V, und mit gestecktem Jumper arbeitet auch der Spannungsregler des Arduino problemlos. Vier AA-Batterien (6 V) lassen den Motoren nur etwa 4 V und reichen nicht, um den Arduino über Vin zu versorgen. Ein 9-V-Block liefert höchstens einige hundert Milliampere; die Motoren drehen entweder gar nicht oder die Batterie ist nach Minuten leer. Die Laufzeit berechnest du mit dem Akkulaufzeit-Rechner, alle Versorgungsvarianten findest du in Arduino mit Batterie betreiben.

Die AFMotor-Bibliothek installieren

1. Öffne in der Arduino IDE den Bibliotheksverwalter (Werkzeuge > Bibliotheken verwalten oder Strg+Umschalt+I).
2. Gib Adafruit Motor Shield ins Suchfeld ein. Es erscheinen zwei Treffer: die Adafruit Motor Shield library mit „V1 firmware“ in der Beschreibung und die Adafruit Motor Shield V2 Library.
3. Installiere für das L293D-Shield die V1-Version. Die V2-Bibliothek ist für eine ganz andere Platine mit I2C und TB6612-Chips.
4. Füge oben in deinem Sketch die Zeile #include <AFMotor.h> ein.
5. Wenn du magst, öffne Datei > Beispiele > Adafruit Motor Shield library > MotorTest und teste die Platine mit einem Motor an M1.

Erster Sketch: einen DC-Motor vorwärts, rückwärts und unterschiedlich schnell drehen

Schraube die beiden Motorkabel an die beiden äußeren Schrauben der Klemme M1 und lass die GND-Schraube in der Mitte frei. Schließe den Akkupack an EXT_PWR an, verbinde den Arduino per USB mit dem Computer und entferne den PWR-Jumper (die zweite Variante oben). Leuchtet die PWR-LED, lade den folgenden Code hoch: Der Motor beschleunigt erst langsam und bremst wieder ab, dreht dann zwei Sekunden rückwärts und hält an.

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}

Die Geschwindigkeit wird eingestellt, indem die Motorspannung tausende Male pro Sekunde ein- und ausgeschaltet wird; Details findest du in Was ist PWM?. Weil M1 und M2 Timer2 nutzen, kannst du ihre Frequenz wählen: MOTOR12_64KHZ, MOTOR12_8KHZ (Standard), MOTOR12_2KHZ und MOTOR12_1KHZ. Mit 64 kHz ist das Fiepen des Motors nicht mehr hörbar, der L293D wird dabei aber wärmer. M3 und M4 hängen dagegen an Timer0; weil dieser Timer auch millis() und delay() antreibt, lässt die Bibliothek seine Frequenz in Ruhe, und diese beiden Kanäle laufen immer mit etwa 1 kHz.

Code für ein vierrädriges Roboterauto (4WD)

Die beliebteste Anwendung des L293D Motor Shields ist ein vierrädriges Roboterauto, denn jeder der vier Motoren bekommt seine eigene Klemme und es gibt kein Kabelchaos. Solche Autos haben keine Lenkung; sie lenken wie ein Panzer: Drehen sich die beiden linken Räder in die eine und die beiden rechten in die andere Richtung, dreht sich das Auto auf der Stelle. Deshalb steuert der Code die Motoren nicht einzeln, sondern als zwei Gruppen, linke Seite und rechte Seite. Für die Handysteuerung schließen wir ein HC-05-Bluetooth-Modul per SoftwareSerial an die freien Pins A0 und A1 an; das Modul erklären wir ausführlich in Bluetooth-Modul 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}

Das Herzstück des Codes ist die Funktion drive(links, rechts): Sie nimmt für jede Seite einen Wert von -255 bis 255; positiv heißt vorwärts, negativ rückwärts, null steht. setSide() gibt beiden Motoren einer Seite dieselbe Geschwindigkeit und Richtung. Die Befehle sind die Einzelbuchstaben, die Apps vom Typ „Arduino Bluetooth RC Car“ aus den App-Stores senden: F vorwärts, B rückwärts, L und R auf der Stelle drehen, G und I Kurve, S Stopp. Der Geschwindigkeitsregler der App sendet eine Ziffer von 0 bis 9; der Code macht daraus einen PWM-Wert zwischen 90 und 240, und weil die Untergrenze bei 90 liegt, laufen die Motoren auch auf der niedrigsten Stufe an. Dreht ein Rad falsch herum, ändere nicht den Code, sondern tausche die beiden Kabel dieses Motors an der Klemme. Für den Aufbau des Chassis und eine Version mit zwei Motoren siehe Arduino Roboterauto bauen.

Schrittmotoren ansteuern: 28BYJ-48 und NEMA 17

Das Shield kann zwei Schrittmotoren gleichzeitig ansteuern: Schrittmotor-Port 1 nutzt die Klemmen M1 und M2, Port 2 nutzt M3 und M4. Bei einem bipolaren Motor (4 Kabel, etwa ein NEMA 17) kommt eine Spule an M1 und die andere an M2. Bei einem unipolaren Motor (5 oder 6 Kabel) gehen die beiden Spulen ebenfalls an M1 und M2, und das gemeinsame Kabel kommt an die GND-Schraube in der Mitte der Klemme. Beim beliebten 28BYJ-48 sieht die Verdrahtung so aus: blaues und gelbes Kabel an M1, rosa und orangefarbenes Kabel an M2, rotes gemeinsames Kabel an GND. Wie du diesen Motor mit der ULN2003-Platine nutzt, steht in Was ist ein Schrittmotor?.

Der 28BYJ-48 ist ein 5-V-Motor; versorge die Motoren für diesen Test mit 4 AA-Batterien (6 V), entferne den Jumper und betreibe den Arduino über USB. Wegen des eingebauten Getriebes besteht eine Umdrehung aus 2048 Vollschritten:

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() legt die Umdrehungen pro Minute fest; wegen seines Getriebes schafft der 28BYJ-48 nicht mehr als etwa 10–15 U/min. Achte darauf, dass step() blockierend ist: Bis der Motor die verlangten Schritte erledigt hat, macht loop() nichts anderes. Willst du Sensoren lesen oder DC-Motoren ansteuern, während der Schrittmotor dreht, nutze die Funktion onestep() der Bibliothek zusammen mit der AccelStepper-Bibliothek; das Beispiel AFMotor_ConstantSpeed aus der Bibliothek zeigt genau das. Mit release() schaltest du die Spulen in Pausen ab und vermeidest Erwärmung, die Welle verliert dabei aber ihr Haltemoment.

Servos anschließen: die Anschlüsse SER1 und SERVO_2

Die beiden dreipoligen Stiftleisten in der Ecke des Shields sind für Servos. Laut Beschriftung sind die Pins − (GND), + (5 V) und S (Signal): Das braune Servokabel kommt an −, das rote an + und das orange an S. Laut Schaltplan der Platine ist SER1 mit D10 und SERVO_2 mit D9 verbunden (manche Quellen nennen die Nummern umgekehrt; bewegt sich das Servo nicht, probiere im Code den anderen Pin). Servos steuerst du mit der Standardbibliothek Servo, und der Timer1, den sie auf dem Uno nutzt, kommt den Timern der Motoren nicht in die Quere; DC-Motoren und Servos arbeiten also problemlos gleichzeitig.

Die Servos werden nicht vom Motorakku, sondern von der 5-V-Schiene des Arduino versorgt. Für ein SG90 ist das kein Problem, große Servos wie das MG996R können in Bewegung aber über 1 A ziehen; der Spannungsregler des Arduino wird heiß, die Spannung bricht ein und das Board startet neu. Stecke bei großen Servos nur das Signalkabel auf die Stiftleiste, versorge + und − des Servos aus einer eigenen 5–6-V-Quelle und verbinde die Massen. Details findest du in MG996R Servo am Arduino und Was ist ein Servomotor?. Der folgende Code schwenkt das Servo an SER1 hin und her, während der Motor an M3 läuft:

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}

Stromgrenze (0,6 A) und Erwärmung

Die wichtigste Zeile im Datenblatt des L293D lautet 0,6 A dauerhaft und 1,2 A Spitze pro Kanal. Der Spitzenwert gilt nur für sehr kurze Impulse; zieht ein Motor sekundenlang 1 A, kommt der Chip an seine Grenzen. Warum er heiß wird, zeigt eine einfache Rechnung: Der L293D ist ein älterer Treiber mit Bipolartransistoren, und bei 0,6 A fallen am oberen Transistor typisch 1,4 V und am unteren 1,2 V ab. Zieht ein Motor 0,6 A, entstehen im Chip also 0,6 A × 2,6 V ≈ 1,6 W Wärme; zwei Motoren am selben Chip erzeugen das Doppelte, etwa 3 W. Ein kleiner DIP-Chip ohne Kühlkörper wird diese Wärme nicht los, seine Temperatur steigt schnell, und schließlich schaltet die Übertemperaturabschaltung die Ausgänge ab. Das Symptom kennst du vielleicht: Die Motoren laufen eine Weile, bleiben stehen und laufen wieder an, sobald der Chip abgekühlt ist.

Gelbe TT-Motoren ziehen ohne Last etwa 150 mA und beim Fahren auf dem Boden 200–300 mA; das liegt innerhalb der Grenzen des Shields. Kritisch sind die Momente, in denen ein Rad gegen ein Hindernis drückt oder das Auto auf der Stelle dreht: Ein blockierter TT-Motor kann 1–1,5 A ziehen, und bei einem 4WD-Auto kämpfen beim Drehen auf der Stelle alle vier Motoren gleichzeitig. Um den echten Strom deines Motors zu messen, schaltest du ein Multimeter in Reihe zum Motor und hältst das Rad kurz mit der Hand fest; wie das geht, zeigt Multimeter richtig benutzen. So bleibt das Shield kühl:

• Sanft anfahren: Springe nicht von 0 auf 255, sondern erhöhe die Geschwindigkeit über 200–300 ms schrittweise; der Anlaufstrom sinkt deutlich.
• Motor nicht blockieren lassen: Lass einen Hindernisvermeider anhalten, bevor er gegen das Hindernis fährt; ein blockierter Motor erzeugt die meiste Wärme.
• Kühlkörper auf die Chips kleben: Kleine Aluminium-Kühlkörper mit Wärmeleitklebeband senken die Temperatur des L293D etwas.
• Einen zweiten L293D auflöten: Auch Adafruit erwähnt, dass man zur Erhöhung der Strombelastbarkeit einen zweiten L293D Bein an Bein auf die vorhandenen Chips löten kann; die beiden Chips teilen sich dann den Strom.
• Nicht mehr Spannung als nötig: 12 V an 6-V-Motoren erhöhen Strom und Wärme.
• Auf den passenden Treiber wechseln: Zieht dein Motor dauerhaft mehr als 0,6 A, nimm einen Treiber mit L298N oder TB6612FNG.

L293D Motor Shield oder L298N?

Kurz gesagt: Baust du mit einem Arduino Uno ein 4WD-Auto mit TT-Motoren, hält das L293D Shield die Verkabelung minimal und bringt alle vier Motoren auf eine Platine. Sind deine Motoren kräftiger, ist dein Board ein ESP32 oder Pico, oder willst du die Pins selbst wählen, ist der L298N flexibler; Details stehen in DC-Motor mit L298N steuern. Suchst du etwas Effizienteres als beide, hat der MOSFET-basierte TB6612FNG einen sehr kleinen Spannungsabfall und verlängert die Akkulaufzeit. Welcher Motortyp zu welcher Aufgabe passt, vergleichen wir in DC-Motor, Servo und Schrittmotor.

Funktioniert es mit ESP32, Raspberry Pi Pico oder Mega?

Mit dem Arduino Mega 2560 funktioniert es problemlos: Das Shield sitzt auf den ersten Digital- und Analogpins des Mega, und AFMotor kennt die Timer des Mega. Mit Uno R4, Leonardo, ESP32 und Raspberry Pi Pico funktioniert es dagegen nicht, weil AFMotor direkt in die Timer-Register von ATmega328P und ATmega2560 schreibt. Ist ein ESP32 ausgewählt, bricht der Build mit 'DC_MOTOR_PWM_RATE' was not declared in this scope ab, bei einem Leonardo mit #error "This chip is not supported!". ESP32-Boards im Uno-Format (etwa der ESPDuino-32) passen zwar mechanisch auf das Shield, aber Pinnummern und der 3,3-V-Signalpegel sind anders. Bei diesen Boards ist ein L298N, ein TB6612FNG oder ein einzelner L293D-Chip statt des Shields viel einfacher. Die Eingänge des L293D erkennen alles über 2,3 V als HIGH und arbeiten deshalb direkt mit 3,3-V-Boards:

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)

Die Masse von Pico und Akku muss unbedingt verbunden sein. Beim ESP32 baust du dieselbe Logik in der Arduino-Sprache auf: Richtung mit digitalWrite, Geschwindigkeit mit analogWrite an den Pins aus der Tabelle. Sind diese Boards neu für dich, beginne mit Was ist der ESP32? und Was ist der Raspberry Pi Pico?.

Motoren drehen nicht: häufige Fehler und Lösungen

Projektideen mit dem L293D Motor Shield

• Bluetooth-gesteuertes 4WD-Auto: Ein Roboter mit Allradantrieb, den du mit dem Code oben per Handy fährst.
• Hindernisvermeidender Roboter: Ein Auto, das mit einem HC-SR04 auf dem Servo an SER1 nach vorne scannt und in die freieste Richtung abbiegt; die komplette Anleitung steht in Hindernisvermeidender Roboter mit Arduino.
• Linienfolger: Folge mit Infrarotsensoren an A0–A3 einer schwarzen Linie auf dem Boden; die PID-Einstellung steht in Linienfolger-Roboter mit Arduino.
• Kameraslider: Fahre eine Kamera mit einem Schrittmotor langsam über eine Schiene und filme Zeitraffer.
• Pan-Tilt-Kopf: Stecke zwei Servos an die beiden Servo-Anschlüsse und richte eine Kamera oder einen Laser in zwei Achsen aus; für mehr Servos siehe Arduino Roboterarm bauen.
• Automatischer Vorhang oder Förderband: Öffne und schließe mit einem DC-Motor einen Vorhang je nach Helligkeit oder baue ein kleines Förderband.

Zusammengefasst nutzt du das L293D Motor Shield richtig, wenn du die V1-Bibliothek installierst, die PWR-LED prüfst, den Jumper passend zur Stromversorgung setzt, setSpeed() nicht vergisst, Sensoren an A0–A5 anschließt und deine Motoren unter der Grenze von 0,6 A hältst. Mit diesen Regeln trägt ein kleines Shield allein die ganze Muskelkraft eines Roboters mit vier Motoren. In der BlueGrays-App findest du das Bluetooth-gesteuerte Auto, den hindernisvermeidenden Roboter sowie Schrittmotor- und Servo-Projekte Schritt für Schritt mit Schaltplänen und Code.