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.

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
| Eigenschaft | L298N | L293D | L9110S | TB6612FNG | A4988 |
|---|---|---|---|---|---|
| Motortyp | 2 DC oder 1 bipolarer Schrittmotor | 2 DC oder 1 bipolarer Schrittmotor | 2 DC | 2 DC oder 1 bipolarer Schrittmotor | 1 bipolarer Schrittmotor |
| Motorspannung | 5–35 V (Modul) | 4,5–36 V | 2,5–12 V | 4,5–13,5 V (absolut max. 15 V) | 8–35 V |
| Dauerstrom (pro Kanal) | 2 A (mit Kühlkörper) | 0,6 A | ca. 0,8 A | 1,2 A | ca. 1 A ohne Kühlkörper, 2 A mit Kühlung |
| Spitzenstrom | 3 A | 1,2 A | ca. 1,5 A | 3,2 A | 2 A |
| Schalttechnik | Bipolartransistor | Bipolartransistor | Transistor (geringe Sättigung) | MOSFET | MOSFET + Stromregelung |
| Spannungsabfall | ca. 2–3 V | ca. 1,8–2,6 V | ca. 1 V | ca. 0,5 V (bei 1 A) | Stromgeregelt, kein Problem |
| Wirkungsgrad | Niedrig | Niedrig | Mittel | Hoch | Hoch |
| Logikversorgung | 5 V (Regler auf dem Modul) | 4,5–7 V (VCC1) | Gemeinsam mit der Motorversorgung | 2,7–5,5 V (VCC) | 3–5,5 V (VDD) |
| 3,3-V-Signalkompatibilität | Funktioniert meist | Eingänge akzeptieren es, Logikversorgung 5 V | Voll kompatibel | Voll kompatibel | Voll kompatibel |
| Preis (relativ) | Niedrig | Niedrig | Sehr niedrig | Mittel | Niedrig |
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:
| Treiber | Typischer Spannungsverlust | Spannung am Motor | Verlustleistung im Treiber | Ungefährer Wirkungsgrad |
|---|---|---|---|---|
| L298N | 1,8 V | 4,2 V | 1,08 W | 70 % |
| L293D | 2,0 V | 4,0 V | 1,2 W | 67 % |
| L9110S | 0,8 V | 5,2 V | 0,48 W | 87 % |
| TB6612FNG | 0,3 V | 5,7 V | 0,18 W | 95 % |
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
| Funktion | L298N-Pin | TB6612FNG-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|---|
| Motor A Drehzahl (PWM) | ENA | PWMA | D5 | GPIO 25 | GP16 |
| Motor A Richtung 1 | IN1 | AIN1 | D4 | GPIO 26 | GP17 |
| Motor A Richtung 2 | IN2 | AIN2 | D7 | GPIO 27 | GP18 |
| Motor B Drehzahl (PWM) | ENB | PWMB | D6 | GPIO 13 | GP21 |
| Motor B Richtung 1 | IN3 | BIN1 | D8 | GPIO 33 | GP19 |
| Motor B Richtung 2 | IN4 | BIN2 | D9 | GPIO 32 | GP20 |
| Standby / Aktivierung | Keiner | STBY | D10 | GPIO 4 | GP22 |
| Logikversorgung | +5V (Reglerausgang) | VCC | 5V | 3V3 | 3V3 (OUT) |
| Motorversorgung | +12V | VM | Externe Quelle | Externe Quelle | Externe Quelle |
| Masse | GND | GND | GND | GND | GND |
Schritt für Schritt: Zwei DC-Motoren mit dem Arduino ansteuern
- 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.
- Verbinde den Minuspol der Quelle sowohl mit GND des Treibers als auch mit GND des Arduino.
- 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.
- 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.
- 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.
- Lade den folgenden Code hoch und mach den ersten Test, solange die Räder in der Luft sind.
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.
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.
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.
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}Welcher Treiber für welches Projekt?
| Projekt | Empfohlener Treiber | Warum? |
|---|---|---|
| Roboterauto mit 2 TT-Motoren (Akku) | TB6612FNG (bei knappem Budget L9110S) | Geringer Verlust, lange Akkulaufzeit, kleine Bauform |
| Vierradauto mit Arduino Uno | L293D-Shield oder L298N | 4 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) | A4988 | Strombegrenzung und Mikroschritt |
| 28BYJ-48-Schrittmotor | ULN2003-Platine | Unipolarer Motor, direkt mit 5 V kompatibel |
| Mini-Wasserpumpe 6 V, nur eine Richtung | Logic-Level-MOSFET oder einkanaliger L9110S | Ändert sich die Richtung nicht, ist eine H-Brücke überflüssig |
| Umkehrbare oder Peristaltikpumpe | TB6612FNG | Richtungswechsel und effizientes PWM |
| Jedes DC-Motorprojekt mit ESP32 oder Pico | TB6612FNG | Volle 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
| Problem | Mögliche Ursache | Lösung |
|---|---|---|
| Der Arduino startet neu, wenn der Motor läuft | Der Motor hängt am 5V-Pin des Arduino oder die Quelle ist zu schwach | Eigene Motorversorgung verwenden, GNDs verbinden, einen Kondensator von 100–470 µF an die Versorgung setzen |
| Die Motoren reagieren gar nicht | Keine gemeinsame Masse oder STBY beim TB6612FNG ist LOW | GNDs verbinden, STBY-Pin auf HIGH setzen |
| Die Drehzahl ändert sich nicht, Motor läuft immer voll | Beim L298N steckt der ENA/ENB-Jumper | Jumper entfernen, ENA/ENB an einen PWM-Pin anschließen |
| Motor am L298N sehr langsam und kraftlos | 2–3 V Spannungsverlust im Treiber | Versorgungsspannung erhöhen oder auf den TB6612FNG wechseln |
| Der Motor pfeift hoch | PWM-Frequenz liegt im hörbaren Bereich | Beim ESP32 oder Pico PWM auf 20 kHz erhöhen |
| Der Schrittmotor zittert, dreht sich aber nicht | Spulenpaare falsch zugeordnet oder Vref zu niedrig | Spulenpaare mit dem Multimeter finden, Vref nach der Formel einstellen |
| Der Treiber wird sehr heiß und schaltet ab | Der Blockierstrom des Motors übersteigt die Grenze des Treibers | Stärkeren Treiber wählen, Kühlkörper ergänzen, den Motor nicht blockieren |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

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

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.

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

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

