Ratgeber · 10 Min. Lesezeit

Motortreiber-Vergleich: L298N, L293D, TB6612FNG, A4988

Motortreiber-Vergleich: L298N, L293D, L9110S, TB6612FNG und A4988 mit Strom, Spannungsabfall, Wirkungsgrad und 3,3-V-Tabelle für Roboterauto und Schrittmotor.

Beim Motortreiber-Vergleich lauten die ersten Fragen: Wie viel Strom zieht dein Motor, mit welcher Spannung läuft er und mit welchem Logikpegel (5 V oder 3,3 V) spricht dein Board? Die fünf beliebtesten Treiber für Hobbyprojekte sind L298N, L293D, L9110S, TB6612FNG und A4988. Die Kurzantwort: Für ein kleines Roboterauto mit Akku ist der TB6612FNG am besten, für 12-V-Motoren mit 1–2 A der L298N, für das kleinste Budget der L9110S, für vier Motoren am Arduino Uno mit einer Platine das L293D-Shield und für bipolare Schrittmotoren wie NEMA 17 der A4988.

In diesem Guide schauen wir uns für jeden Treiber an, wie viel Strom er wirklich liefert, wie viel Spannung er verliert, wie sich das auf Akkulaufzeit und Erwärmung auswirkt und wie gut er mit 3,3-V-Boards wie ESP32 und Raspberry Pi Pico harmoniert. Danach findest du lauffähigen Code, der dieselben zwei Motoren mit Arduino, ESP32 und Pico ansteuert, ein Schrittmotor-Beispiel mit dem A4988 und eine Auswahltabelle nach Projekt.

L298N-Motortreibermodul mit Kühlkörper
L298N-Motortreibermodul: zwei Kanäle, bis zu 2 A Strom, großer Aluminium-Kühlkörper und 5-V-Regler auf der Platine.

Was ist ein Motortreiber und wozu brauchst du ihn?

Ein digitaler Pin des Arduino liefert höchstens etwa 20–40 mA. Schon ein kleiner TT-Getriebemotor zieht im Lauf 150–250 mA und blockiert fast 1 A. Schließt du den Motor direkt an den Pin an, brennt der Pin durch, und die Spannungsspitzen des Motors setzen den Mikrocontroller zurück. Ein Motortreiber ist ein Schalter, der das schwache Signal vom Mikrocontroller aufnimmt und den Motor aus einer getrennten Stromquelle speist. Das Herz eines DC-Motortreibers ist die H-Brücke: Vier Schalter werden diagonal paarweise geschaltet, dadurch wechselt die Polarität am Motor und er dreht vor oder zurück. Die Drehzahl regelst du mit einem PWM-Signal, das die Schalter tausendfach pro Sekunde ein- und ausschaltet. Schrittmotortreiber gehen noch weiter: Sie bestromen die Spulen nacheinander mit begrenztem Strom und drehen den Motor in präzisen Winkeln.

Die fünf Treiber im Kurzporträt

  • L298N: Alter, aber weit verbreiteter Zweikanal-H-Brücken-Baustein mit Bipolartransistoren. Er verträgt hohe Spannungen (Modul: 5–35 V) und schafft bis zu 2 A pro Kanal, verliert aber 2–3 V und wird deshalb sehr heiß. Details findest du im Beitrag DC-Motor mit dem L298N steuern.
  • L293D: IC mit 16 Pins im DIP-Gehäuse; 600 mA Dauerstrom pro Kanal, 1,2 A Spitzenstrom und eingebaute Schutzdioden. Bekannt ist er durch das L293D-Motor-Shield für den Arduino Uno, das vier DC-Motoren ansteuert.
  • L9110S: Die günstigste und kleinste Option. Arbeitet bei 2,5–12 V und liefert etwa 800 mA pro Kanal; es gibt keinen Enable-Pin, jeder Motor wird mit zwei Pins gesteuert. Mehr dazu im Beitrag L9110S Motortreiber.
  • TB6612FNG: Moderne H-Brücke auf MOSFET-Basis. Liefert 1,2 A Dauerstrom und 3,2 A Spitzenstrom pro Kanal, der Durchlasswiderstand liegt bei etwa 0,5 Ohm; deshalb wird er kaum warm und arbeitet ab 2,7 V problemlos mit dem Logikpegel.
  • A4988: Kein DC-Motortreiber, sondern ein Treiber für bipolare Schrittmotoren. Bietet 8–35 V Motorspannung, einstellbare Strombegrenzung und Mikroschritt bis 1/16. Der Aufbau wird Schritt für Schritt im Beitrag A4988 Schrittmotortreiber erklärt.

Vergleichstabelle: Strom, Spannung, 3,3-V-Kompatibilität und Preis

EigenschaftL298NL293DL9110STB6612FNGA4988
Motortyp2 DC oder 1 bipolarer Schrittmotor2 DC oder 1 bipolarer Schrittmotor2 DC2 DC oder 1 bipolarer Schrittmotor1 bipolarer Schrittmotor
Motorspannung5–35 V (Modul)4,5–36 V2,5–12 V4,5–13,5 V (absolut max. 15 V)8–35 V
Dauerstrom (pro Kanal)2 A (mit Kühlkörper)0,6 Aca. 0,8 A1,2 Aca. 1 A ohne Kühlkörper, 2 A mit Kühlung
Spitzenstrom3 A1,2 Aca. 1,5 A3,2 A2 A
SchalttechnikBipolartransistorBipolartransistorTransistor (geringe Sättigung)MOSFETMOSFET + Stromregelung
Spannungsabfallca. 2–3 Vca. 1,8–2,6 Vca. 1 Vca. 0,5 V (bei 1 A)Stromgeregelt, kein Problem
WirkungsgradNiedrigNiedrigMittelHochHoch
Logikversorgung5 V (Regler auf dem Modul)4,5–7 V (VCC1)Gemeinsam mit der Motorversorgung2,7–5,5 V (VCC)3–5,5 V (VDD)
3,3-V-SignalkompatibilitätFunktioniert meistEingänge akzeptieren es, Logikversorgung 5 VVoll kompatibelVoll kompatibelVoll kompatibel
Preis (relativ)NiedrigNiedrigSehr niedrigMittelNiedrig

Die Stromwerte in der Tabelle sind Grenzwerte aus den Datenblättern; in der Praxis liegt der sichere Bereich bei etwa 70 Prozent davon. Die 2 A des L298N erreichst du zum Beispiel nur mit großem Kühlkörper und guter Luftzirkulation; belastest du ein Modul ohne Kühlkörper dauerhaft mit mehr als 1 A, erhitzt sich der Baustein schnell und geht in den thermischen Schutz. Um den echten Bedarf eines Motors zu kennen, musst du nicht den Betriebsstrom, sondern den Blockierstrom (Stall) betrachten: Bleibt das Rad an einem Hindernis hängen, zieht der Motor diesen Strom, und der Treiber muss ihn zumindest kurzzeitig aushalten. Die Preisspalte ist nur eine relative Rangfolge: Der L9110S ist meist das günstigste Modul, der TB6612FNG ist etwas teurer, macht das aber mit Wirkungsgrad und kleiner Bauform mehr als wett.

Spannungsabfall und Wirkungsgrad: Warum wird der L298N so heiß?

Bei Treibern mit Bipolartransistoren (L298N, L293D) fließt der Strom durch zwei Transistoren, bevor er den Motor erreicht, und an jedem gehen etwa 1–1,5 V verloren. Dieser Verlust wird zu Wärme: Die Verlustleistung berechnest du mit P = U_Abfall × I. Beim MOSFET-Treiber TB6612FNG verhalten sich die Schalter wie ein Widerstand, und der Verlust ergibt sich aus P = I² × R_on; bei 0,5 Ohm und 1 A sind das nur 0,5 W. Bei Akkus mit niedriger Spannung ist der Unterschied riesig: 2 V von einem 6-V-Akkupack zu verlieren heißt, ein Drittel der Motorleistung zu verschenken. Die Rechnungen kannst du mit dem Ohmschen-Gesetz-Rechner für deinen eigenen Motor wiederholen und die Akkulaufzeit mit dem Akkulaufzeit-Rechner abschätzen. Die folgende Tabelle zeigt typische Werte für 6 V Versorgung und 0,6 A Motorstrom:

TreiberTypischer SpannungsverlustSpannung am MotorVerlustleistung im TreiberUngefährer Wirkungsgrad
L298N1,8 V4,2 V1,08 W70 %
L293D2,0 V4,0 V1,2 W67 %
L9110S0,8 V5,2 V0,48 W87 %
TB6612FNG0,3 V5,7 V0,18 W95 %
Wenn du den L298N verwenden musst, wähle die Motorversorgung etwa 2 V höher als die Nennspannung des Motors. Für 6-V-Motoren sind 8 V, für 12-V-Motoren etwa 14 V eine Quelle, die den Verlust im Treiber ausgleicht. Beim TB6612FNG ist diese Korrektur nicht nötig.

3,3-V-Kompatibilität: Welcher Treiber passt zu ESP32 und Raspberry Pi Pico?

Die Pins von ESP32 und Pico geben 3,3 V aus. Da sich die Logikversorgung (VCC) des TB6612FNG direkt an 3,3 V anschließen lässt, ist er die sauberste Kombination mit diesen Boards. Auch der Logikeingang des A4988 arbeitet im Bereich von 3–5,5 V. Die Eingänge des L9110S erkennen 3,3-V-Signale problemlos. Bei L298N und L293D liegt die Schwelle für den High-Pegel bei mindestens 2,3 V, sodass ein 3,3-V-Signal meist funktioniert; der Logikteil des ICs braucht aber 5 V Versorgung, und der Betrieb nahe der Schwelle kann in störungsreicher Umgebung zu Fehlauslösungen führen. Kurz: Beginnst du ein neues ESP32- oder Pico-Projekt, nimm den TB6612FNG; hast du einen L298N, funktioniert er meistens auch, aber vergiss niemals die gemeinsame Masse.

Anschluss: Pin-Tabelle für L298N und TB6612FNG

FunktionL298N-PinTB6612FNG-PinArduino UnoESP32Raspberry Pi Pico
Motor A Drehzahl (PWM)ENAPWMAD5GPIO 25GP16
Motor A Richtung 1IN1AIN1D4GPIO 26GP17
Motor A Richtung 2IN2AIN2D7GPIO 27GP18
Motor B Drehzahl (PWM)ENBPWMBD6GPIO 13GP21
Motor B Richtung 1IN3BIN1D8GPIO 33GP19
Motor B Richtung 2IN4BIN2D9GPIO 32GP20
Standby / AktivierungKeinerSTBYD10GPIO 4GP22
Logikversorgung+5V (Reglerausgang)VCC5V3V33V3 (OUT)
Motorversorgung+12VVMExterne QuelleExterne QuelleExterne Quelle
MasseGNDGNDGNDGNDGND
Der häufigste Fehler: Die Masse (GND) der Motorversorgung wird nicht mit der Masse der Platine verbunden; ohne gemeinsame Masse sind Richtungs- und PWM-Signale bedeutungslos. Der zweite große Fehler ist, beim L298N-Modul bei über 12 V Versorgung den 5V-EN-Jumper gesteckt zu lassen; der Regler auf der Platine kann überhitzen und durchbrennen. Liegst du über 12 V, ziehe den Jumper ab und speise den +5V-Pin mit dem 5V-Pin des Arduino. Versorge die Motoren außerdem niemals über den 5V-Pin des Arduino.

Schritt für Schritt: Zwei DC-Motoren mit dem Arduino ansteuern

  1. Verbinde die Motorversorgung (zum Beispiel 7,4 V mit 2 Zellen 18650 oder 9 V mit 6×AA) mit dem Motorversorgungseingang des Treibers: beim L298N +12V, beim TB6612FNG VM.
  2. Verbinde den Minuspol der Quelle sowohl mit GND des Treibers als auch mit GND des Arduino.
  3. Beim L298N entfernst du die Jumper an ENA und ENB; sonst lässt sich die Drehzahl nicht regeln und der Motor läuft immer mit voller Drehzahl.
  4. Verbinde wie in der Tabelle die PWM-Pins mit D5 und D6 und die Richtungspins mit D4, D7, D8 und D9. Beim TB6612FNG kommt STBY an D10 und VCC an den 5V-Pin des Arduino.
  5. Stecke die Motoranschlüsse an OUT1–OUT2 (A01–A02) und OUT3–OUT4 (B01–B02). Dreht ein Motor falsch herum, vertausche die Kabel oder drehe die Richtung im Code um.
  6. Lade den folgenden Code hoch und mach den ersten Test, solange die Räder in der Luft sind.
C++ (Arduino IDE)
1// L298N ya da TB6612FNG ile iki DC motor / Two DC motors with L298N or TB6612FNG
2const int ENA  = 5;   // PWMA (PWM pini / PWM pin)
3const int IN1  = 4;   // AIN1
4const int IN2  = 7;   // AIN2
5const int ENB  = 6;   // PWMB (PWM pini / PWM pin)
6const int IN3  = 8;   // BIN1
7const int IN4  = 9;   // BIN2
8const int STBY = 10;  // yalnız TB6612FNG / TB6612FNG only
9
10// hiz: -255 (tam geri) ... 255 (tam ileri) / speed: -255 (full reverse) ... 255 (full forward)
11void motorSur(int en, int inA, int inB, int hiz) {
12  hiz = constrain(hiz, -255, 255);
13  if (hiz > 0) {
14    digitalWrite(inA, HIGH);
15    digitalWrite(inB, LOW);
16  } else if (hiz < 0) {
17    digitalWrite(inA, LOW);
18    digitalWrite(inB, HIGH);
19  } else {
20    digitalWrite(inA, LOW);   // dur / stop
21    digitalWrite(inB, LOW);
22  }
23  analogWrite(en, abs(hiz));
24}
25
26// Kısa devre freni: iki giriş HIGH / Short brake: both inputs HIGH
27void fren(int en, int inA, int inB) {
28  digitalWrite(inA, HIGH);
29  digitalWrite(inB, HIGH);
30  analogWrite(en, 255);
31}
32
33void setup() {
34  pinMode(ENA, OUTPUT);
35  pinMode(IN1, OUTPUT);
36  pinMode(IN2, OUTPUT);
37  pinMode(ENB, OUTPUT);
38  pinMode(IN3, OUTPUT);
39  pinMode(IN4, OUTPUT);
40  pinMode(STBY, OUTPUT);
41  digitalWrite(STBY, HIGH);   // TB6612FNG'yi uyandır / wake up the TB6612FNG
42}
43
44void loop() {
45  motorSur(ENA, IN1, IN2, 180);    // ileri / forward
46  motorSur(ENB, IN3, IN4, 180);
47  delay(2000);
48
49  fren(ENA, IN1, IN2);             // fren / brake
50  fren(ENB, IN3, IN4);
51  delay(500);
52
53  motorSur(ENA, IN1, IN2, -180);   // geri / reverse
54  motorSur(ENB, IN3, IN4, -180);
55  delay(2000);
56
57  motorSur(ENA, IN1, IN2, 180);    // yerinde dönüş / spin in place
58  motorSur(ENB, IN3, IN4, -180);
59  delay(1000);
60
61  motorSur(ENA, IN1, IN2, 0);      // dur / stop
62  motorSur(ENB, IN3, IN4, 0);
63  delay(1000);
64}

Das Schöne an diesem Code: Er läuft mit derselben Pinbelegung sowohl am L298N als auch am TB6612FNG; die Logiktabellen der beiden Treiber sind fast identisch. Ist ein Richtungspin HIGH und der andere LOW, dreht der Motor; der PWM-Wert (0–255) bestimmt die Drehzahl. Setzt du beide Richtungspins auf HIGH, werden die Motoranschlüsse kurzgeschlossen und der Motor wird mit seiner eigenen Spannung gebremst; so hält der Roboter am Hang oder bei hoher Geschwindigkeit auf kürzerer Strecke an. Die Pins D5 und D6 des Uno erzeugen etwa 980 Hz PWM; bei dieser Frequenz ist ein leichtes Summen der Motoren normal. Beim L298N siehst du bei sehr kleinen PWM-Werten (unter etwa 60), dass der Motor nicht anläuft, weil die nach dem Verlust im Treiber verbleibende mittlere Spannung die Reibung nicht überwinden kann.

ESP32 mit TB6612FNG: Leises 20-kHz-PWM

Auf dem ESP32 kannst du statt analogWrite die LEDC-Hardware-PWM-Einheit nutzen und die Frequenz frei wählen. Da der TB6612FNG PWM bis 100 kHz akzeptiert, rückt eine Frequenz von 20 kHz in einen Bereich, den das menschliche Ohr nicht hört, und das Motorsummen verschwindet vollständig. Der folgende Code lässt sich mit den Versionen 2.x und 3.x des ESP32-Arduino-Core kompilieren; die je nach Version unterschiedlichen LEDC-Funktionen sind durch einen Block mit bedingter Kompilierung getrennt. Vergiss nicht, den VCC-Pin des TB6612FNG an den 3V3-Pin des ESP32 anzuschließen.

C++ (Arduino IDE)
1#include <Arduino.h>
2
3// ESP32 + TB6612FNG pinleri / ESP32 + TB6612FNG pins
4const int PWMA = 25, AIN1 = 26, AIN2 = 27;
5const int PWMB = 13, BIN1 = 33, BIN2 = 32;
6const int STBY = 4;
7
8const int PWM_FREQ = 20000;   // 20 kHz: duyulmayan PWM / inaudible PWM
9const int PWM_RES  = 8;       // 0-255 çözünürlük / 0-255 resolution
10
11void pwmBaslat(int pin, int kanal) {
12#if ESP_ARDUINO_VERSION_MAJOR >= 3
13  ledcAttach(pin, PWM_FREQ, PWM_RES);   // core 3.x
14  (void)kanal;
15#else
16  ledcSetup(kanal, PWM_FREQ, PWM_RES);  // core 2.x
17  ledcAttachPin(pin, kanal);
18#endif
19}
20
21void pwmYaz(int pin, int kanal, int deger) {
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23  ledcWrite(pin, deger);
24  (void)kanal;
25#else
26  ledcWrite(kanal, deger);
27  (void)pin;
28#endif
29}
30
31// hiz: -255 ... 255 / speed: -255 ... 255
32void motor(int pwmPin, int kanal, int in1, int in2, int hiz) {
33  hiz = constrain(hiz, -255, 255);
34  digitalWrite(in1, hiz > 0 ? HIGH : LOW);
35  digitalWrite(in2, hiz < 0 ? HIGH : LOW);
36  pwmYaz(pwmPin, kanal, abs(hiz));
37}
38
39void setup() {
40  pinMode(AIN1, OUTPUT);
41  pinMode(AIN2, OUTPUT);
42  pinMode(BIN1, OUTPUT);
43  pinMode(BIN2, OUTPUT);
44  pinMode(STBY, OUTPUT);
45  digitalWrite(STBY, HIGH);   // sürücüyü etkinleştir / enable the driver
46  pwmBaslat(PWMA, 0);
47  pwmBaslat(PWMB, 1);
48}
49
50void loop() {
51  for (int h = 0; h <= 255; h += 5) {   // yumuşak hızlanma / soft acceleration
52    motor(PWMA, 0, AIN1, AIN2, h);
53    motor(PWMB, 1, BIN1, BIN2, h);
54    delay(30);
55  }
56  delay(1500);
57  motor(PWMA, 0, AIN1, AIN2, -200);     // geri / reverse
58  motor(PWMB, 1, BIN1, BIN2, -200);
59  delay(1500);
60  motor(PWMA, 0, AIN1, AIN2, 0);        // dur / stop
61  motor(PWMB, 1, BIN1, BIN2, 0);
62  delay(1000);
63}

Raspberry Pi Pico und MicroPython mit TB6612FNG

Alle GPIO-Pins des Pico können Hardware-PWM erzeugen, und in MicroPython wird das Tastverhältnis als 16-Bit-Zahl (0–65535) angegeben. Im folgenden Beispiel gibst du die Geschwindigkeit in Prozent (-100 bis 100) ein, und die Funktion rechnet sie in einen duty_u16-Wert um. Da GP16 und GP21 in verschiedenen PWM-Slices liegen, beeinflussen sich die Frequenzen der beiden Motoren nicht. Schließe den VCC-Pin des TB6612FNG an den 3V3-(OUT)-Pin des Pico und den VM-Pin an die externe Motorversorgung an; speist du den Motor über den VSYS-Pin des Pico, führt der begrenzte USB-Strom zum Reset des Boards.

MicroPython
1from machine import Pin, PWM
2import time
3
4stby = Pin(22, Pin.OUT, value=1)   # sürücüyü uyandır / wake the driver
5
6pwma = PWM(Pin(16))
7pwma.freq(20000)                   # 20 kHz sessiz PWM / quiet PWM
8ain1 = Pin(17, Pin.OUT)
9ain2 = Pin(18, Pin.OUT)
10
11pwmb = PWM(Pin(21))
12pwmb.freq(20000)
13bin1 = Pin(19, Pin.OUT)
14bin2 = Pin(20, Pin.OUT)
15
16def motor(pwm, in1, in2, hiz):     # hiz: -100 ... 100 / speed in percent
17    hiz = max(-100, min(100, hiz))
18    in1.value(1 if hiz > 0 else 0)
19    in2.value(1 if hiz < 0 else 0)
20    pwm.duty_u16(int(abs(hiz) * 65535 / 100))
21
22while True:
23    motor(pwma, ain1, ain2, 70)    # ileri / forward
24    motor(pwmb, bin1, bin2, 70)
25    time.sleep(2)
26    motor(pwma, ain1, ain2, -70)   # geri / reverse
27    motor(pwmb, bin1, bin2, -70)
28    time.sleep(2)
29    motor(pwma, ain1, ain2, 0)     # dur / stop
30    motor(pwmb, bin1, bin2, 0)
31    time.sleep(1)

Schrittmotor mit A4988: Strombegrenzung und Vref-Einstellung

L298N und L293D können einen bipolaren Schrittmotor ebenfalls mit zwei H-Brücken ansteuern, aber da sie den Strom nicht begrenzen können, ist der Motor bei niedriger Spannung kraftlos oder überhitzt bei hoher Spannung. Der A4988 misst den Spulenstrom dagegen ständig und hält ihn konstant (Chopper-Betrieb); so kannst du sogar einen NEMA-17-Motor mit 2,8 V an einer 12-V- oder 24-V-Quelle sicher und mit hohem Drehmoment betreiben. Die Strombegrenzung stellst du mit dem kleinen Trimmpoti auf der Platine ein, und die Formel lautet: I_max = Vref / (8 × Rs). Rs ist der Strommesswiderstand auf der Platine; auf vielen Klon-Platinen steht R100 (0,1 Ohm), auf manchen R068 (0,068 Ohm). Bei einer Platine mit 0,1 Ohm muss Vref für 1 A zum Beispiel 1 × 8 × 0,1 = 0,8 V betragen; für etwas Wärmereserve sind 70 Prozent davon, also etwa 0,56 V, ein guter Startwert. Der A4988 wird nur über zwei Pins gesteuert: Jeder Impuls am STEP-Pin ist ein Schritt, der DIR-Pin bestimmt die Richtung. Sind MS1, MS2 und MS3 auf LOW, arbeitet er im Vollschritt, und ein 1,8-Grad-Motor macht 200 Schritte pro Umdrehung. Vergiss nicht, SLEEP und RESET miteinander zu verbinden und zwischen VMOT und GND einen Kondensator von mindestens 100 µF zu setzen.

C++ (Arduino IDE)
1// A4988 ile NEMA 17 step motor / NEMA 17 stepper with A4988
2// MS1-MS3 LOW = tam adım, SLEEP ile RESET birbirine bağlı / MS1-MS3 LOW = full step, SLEEP tied to RESET
3const int DIR_PIN  = 2;
4const int STEP_PIN = 3;
5const int ADIM_TUR = 200;   // 1,8 derece motor / 1.8 degree motor
6
7void adimAt(int adim, bool yon, unsigned int bekleme) {
8  digitalWrite(DIR_PIN, yon ? HIGH : LOW);
9  for (int i = 0; i < adim; i++) {
10    digitalWrite(STEP_PIN, HIGH);
11    delayMicroseconds(bekleme);
12    digitalWrite(STEP_PIN, LOW);
13    delayMicroseconds(bekleme);
14  }
15}
16
17void setup() {
18  pinMode(DIR_PIN, OUTPUT);
19  pinMode(STEP_PIN, OUTPUT);
20}
21
22void loop() {
23  adimAt(ADIM_TUR, true, 800);    // saat yönünde 1 tur / one turn clockwise
24  delay(1000);
25  adimAt(ADIM_TUR, false, 800);   // ters yönde 1 tur / one turn counter-clockwise
26  delay(1000);
27}
Stecke das Schrittmotorkabel niemals bei eingeschaltetem A4988 ein oder aus; der Spannungsimpuls der Spule kann den Treiber sofort zerstören. Außerdem lassen sich unipolare Motoren mit 5 Kabeln wie der 28BYJ-48 nicht direkt mit dem A4988 betreiben; verwende dafür die mitgelieferte ULN2003-Platine.

Welcher Treiber für welches Projekt?

ProjektEmpfohlener TreiberWarum?
Roboterauto mit 2 TT-Motoren (Akku)TB6612FNG (bei knappem Budget L9110S)Geringer Verlust, lange Akkulaufzeit, kleine Bauform
Vierradauto mit Arduino UnoL293D-Shield oder L298N4 Motoren mit einer Platine; beim L298N werden pro Seite 2 Motoren parallel angeschlossen
12-V-Getriebemotor (1–2 A)L298N (mit Kühlkörper)Verträgt hohe Spannung und hohen Strom; für größere Motoren wechsle zu MOSFET-Treibern wie dem BTS7960
NEMA-17-Schrittmotor (3D-Drucker, CNC, Kameraschlitten)A4988Strombegrenzung und Mikroschritt
28BYJ-48-SchrittmotorULN2003-PlatineUnipolarer Motor, direkt mit 5 V kompatibel
Mini-Wasserpumpe 6 V, nur eine RichtungLogic-Level-MOSFET oder einkanaliger L9110SÄndert sich die Richtung nicht, ist eine H-Brücke überflüssig
Umkehrbare oder PeristaltikpumpeTB6612FNGRichtungswechsel und effizientes PWM
Jedes DC-Motorprojekt mit ESP32 oder PicoTB6612FNGVolle Kompatibilität mit 3,3-V-Logik

Das Pumpenbeispiel ist besonders wichtig: In einer Bewässerungsanlage dreht die Pumpe immer in dieselbe Richtung, deshalb genügen ein einzelner N-Kanal-MOSFET und eine Freilaufdiode; diese Methode findest du im Beitrag MOSFET am Arduino verwenden. Bei Roboterautos wächst der Vorteil des MOSFET-Treibers, je niedriger die Akkuspannung ist; ein Auto mit zwei 18650-Akkus fährt mit dem TB6612FNG statt des L298N spürbar schneller und läuft länger.

Projektideen mit Motortreibern

  • Bluetooth-gesteuertes Roboterauto: Steuere zwei Motoren per Smartphone mit TB6612FNG oder L298N; die Schritte stehen im Beitrag Roboterauto bauen.
  • Hindernisvermeidender Roboter: Ein Fahrzeug, das mit dem HC-SR04 Hindernisse erkennt und die Richtung wechselt; Details im Beitrag Hindernisvermeidender Roboter.
  • Linienfolger: Bei diesem Projekt mit schneller PWM-Reaktion macht der Wirkungsgrad des TB6612FNG den Unterschied; schau dir den Beitrag Linienfolger-Roboter an.
  • Automatische Bewässerung: Starte die Mini-Pumpe, wenn die Bodenfeuchte sinkt; die Stromanschlüsse werden im Beitrag Mini-Wasserpumpe erklärt.
  • Solar-Tracker: Drehe das Panel mit Schrittmotor oder Getriebemotor zum Licht; sieh dir den Beitrag Solar-Tracker an.
  • Präzise Positionierung: Für einen Kameraschlitten oder Drehteller mit kleinen Winkeln kannst du mit dem 28BYJ-48-Schrittmotor beginnen und später auf A4988 und NEMA 17 umsteigen.

Häufige Fehler und ihre Lösungen

ProblemMögliche UrsacheLösung
Der Arduino startet neu, wenn der Motor läuftDer Motor hängt am 5V-Pin des Arduino oder die Quelle ist zu schwachEigene Motorversorgung verwenden, GNDs verbinden, einen Kondensator von 100–470 µF an die Versorgung setzen
Die Motoren reagieren gar nichtKeine gemeinsame Masse oder STBY beim TB6612FNG ist LOWGNDs verbinden, STBY-Pin auf HIGH setzen
Die Drehzahl ändert sich nicht, Motor läuft immer vollBeim L298N steckt der ENA/ENB-JumperJumper entfernen, ENA/ENB an einen PWM-Pin anschließen
Motor am L298N sehr langsam und kraftlos2–3 V Spannungsverlust im TreiberVersorgungsspannung erhöhen oder auf den TB6612FNG wechseln
Der Motor pfeift hochPWM-Frequenz liegt im hörbaren BereichBeim ESP32 oder Pico PWM auf 20 kHz erhöhen
Der Schrittmotor zittert, dreht sich aber nichtSpulenpaare falsch zugeordnet oder Vref zu niedrigSpulenpaare mit dem Multimeter finden, Vref nach der Formel einstellen
Der Treiber wird sehr heiß und schaltet abDer Blockierstrom des Motors übersteigt die Grenze des TreibersStärkeren Treiber wählen, Kühlkörper ergänzen, den Motor nicht blockieren
Miss mit dem Multimeter den Spulenwiderstand, bevor du mit einem neuen Motor arbeitest, und schätze den Blockierstrom mit I = U / R ab. Ein 6-V-Motor mit 5 Ohm zieht zum Beispiel bei Blockierung etwa 1,2 A; dann reicht die 0,6-A-Grenze des L293D nicht aus, der TB6612FNG oder der L298N sind dagegen geeignet.

Den richtigen Motortreiber zu wählen heißt, den Strom deines Motors, die Versorgungsspannung und den Logikpegel deines Boards zu kennen. Mit diesen drei Angaben führen dich die Tabellen oben in wenigen Sekunden zur passenden Platine; und den alten L298N in der Schublade musst du jetzt nicht mehr liegen lassen, denn du weißt, wo er nützlich ist. In der BlueGrays-App findest du Projekte wie das Bluetooth-Auto mit L298N, den hindernisvermeidenden Roboter, Schrittmotor und intelligente Bewässerung mit Schaltplänen und fertigem Code zum sofortigen Nachbauen.

Häufige Fragen

L298N oder TB6612FNG: Was ist besser?

Für Motoren mit Akkubetrieb und unter 1 A Strom ist der TB6612FNG besser; dank MOSFET-Aufbau verliert er nur etwa 0,5 V und wird kaum warm. Der L298N wird bei Spannungen über 13,5 V und bei Motoren bevorzugt, die 1–2 A pro Kanal brauchen. Kurz: TB6612FNG für kleine Roboter, L298N für größere Motoren mit 12–24 V.

Warum wird der L298N so heiß?

Da der L298N Bipolartransistoren nutzt, gehen beim Stromfluss etwa 2–3 V verloren, und dieser Verlust wird zu Wärme. Bei 1 A erzeugt der Treiber etwa 2 W Wärme; deshalb kommt er mit einem großen Kühlkörper. Um die Erwärmung zu senken, kannst du den Strom niedrig halten oder auf einen MOSFET-Treiber wechseln.

Kann ich den L298N mit dem ESP32 verwenden?

Ja, da die Eingänge des L298N ab 2,3 V als High akzeptieren, funktioniert das 3,3-V-Signal des ESP32 meist. Der Logikteil des Moduls muss mit 5 V versorgt werden, und die GNDs von ESP32 und Treiber müssen unbedingt verbunden sein. Bei einem neuen Projekt ist der TB6612FNG, der voll mit 3,3 V kompatibel ist, die sicherere Wahl.

Wie viel Strom liefert der L293D?

Der L293D liefert pro Kanal 600 mA Dauerstrom und 1,2 A Spitzenstrom und hat zwei Kanäle. Das reicht für kleine Spielzeugmotoren und leichte Roboter, aber bei Motoren mit einem Blockierstrom über 1 A erhitzt sich der Baustein und geht in den thermischen Schutz. Für mehr Strom solltest du L298N oder TB6612FNG in Betracht ziehen.

Welchen Treiber brauche ich für einen Schrittmotor?

Für bipolare Schrittmotoren mit 4 Kabeln wie NEMA 17 solltest du den A4988 oder einen ähnlichen stromgeregelten Treiber verwenden; du kannst die Strombegrenzung über Vref einstellen und Mikroschritt nutzen. Für unipolare Motoren mit 5 Kabeln wie den 28BYJ-48 ist die ULN2003-Platine die einfachste Lösung. Der L298N kann einen bipolaren Schrittmotor zwar ansteuern, ist aber ineffizient, weil er den Strom nicht begrenzen kann.

Brauche ich für eine Wasserpumpe einen Motortreiber?

Dreht die Pumpe nur in eine Richtung, brauchst du keinen Motortreiber mit H-Brücke; ein Logic-Level-MOSFET, eine Diode und ein Widerstand genügen. Willst du die Pumpe umkehren oder ihre Drehzahl per PWM regeln, kannst du einen Kanal eines Treibers wie L9110S oder TB6612FNG nutzen. In jedem Fall solltest du die Pumpe nicht über den Pin des Arduino, sondern aus einer eigenen Stromquelle versorgen.

Alle Projekte ansehen
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

Bluetooth-gesteuertes Auto mit L298N

Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

5.0(39)
66
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

Roboter zur Hindernisvermeidung

Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

5.0(38)
49
Verwendung von Schrittmotoren
AR-67Mittel
Premium

Verwendung von Schrittmotoren

Ein Motor, der sich Schritt für Schritt genau so weit dreht, wie du willst, wie der Zeiger einer Uhr.

4.5(31)
42
360-Grad-Servo aus einem Schrittmotor bauen
AR-68Mittel
Premium

360-Grad-Servo aus einem Schrittmotor bauen

Bring einem gewöhnlichen Schrittmotor bei, jeden gewünschten Winkel anzufahren, und zwar rund um den ganzen Kreis.

4.5(22)
33
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)

Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

4