L9110S Motortreiber Arduino: PWM-Drehzahl und Anschluss
L9110S an Arduino anschließen: Pinbelegung, Richtung und PWM-Drehzahl, 800-mA-Grenze, Roboterauto und Lüfter mit Uno, ESP32 und Pico inklusive Code.
Der L9110S ist ein winziges, sehr günstiges Zweikanal-Motortreibermodul, mit dem du zwei kleine DC-Motoren gleichzeitig in Richtung und Drehzahl steuern kannst. L9110S und Arduino sind ein Duo für batteriebetriebene Mini-Roboterautos, kleine Lüfter, Spielzeugboote und Propellerprojekte. Auf dem Modul sitzen zwei L9110S-Chips; jeder treibt einen Motor mit etwa 800 mA Dauerstrom pro Kanal bei 2,5–12 V.
Die Pins des Arduino können einen Motor nicht direkt versorgen: Ein Uno-Pin liefert höchstens 20–40 mA, ein kleiner gelber Getriebemotor zieht beim Anlaufen ein Vielfaches davon. Außerdem muss zum Umkehren der Drehrichtung die Stromrichtung durch den Motor gewechselt werden. In diesem Beitrag lernst du Pins, Wahrheitstabelle, PWM-Drehzahlregelung und Stromgrenze des L9110S kennen und schreibst Code für ein Roboterauto mit dem Arduino Uno, einen Lüfter mit Potentiometer am ESP32 und MicroPython auf dem Raspberry Pi Pico. Zum Schluss klären wir, wann der L9110S den L298N ersetzen kann und wann nicht.

Was ist der L9110S und wie funktioniert er?
Im L9110S steckt eine H-Brücke aus vier Schaltern. Werden die Schalter über Kreuz paarweise geschaltet, fließt der Strom in die eine oder andere Richtung durch den Motor, und der Motor dreht vorwärts oder rückwärts. Jede H-Brücke hat zwei Eingänge (IA und IB) und zwei Ausgänge (OA und OB). Legst du IA auf HIGH und IB auf LOW, dreht der Motor in eine Richtung, bei umgekehrter Belegung in die andere. Gibst du auf einen der beiden Eingänge ein PWM-Signal, ändert sich die mittlere Spannung am Motor und damit seine Drehzahl. Im Chip sind außerdem Schutzdioden gegen die Spannungsspitzen beim Stoppen und Umschalten eingebaut, du brauchst also keine externe Diode. Das Modul hat keine getrennte Logikversorgung und keinen 5-V-Regler: Die Spannung an VCC versorgt Chips und Motoren zugleich.
| Eigenschaft | Wert |
|---|---|
| Treiberchip | 2 × L9110S (einer pro Motor) |
| Kanäle | 2 DC-Motoren oder 1 kleiner bipolarer Schrittmotor |
| Versorgungsspannung (VCC) | 2,5–12 V |
| Dauerstrom | ca. 800 mA pro Kanal |
| Spitzenstrom | kurzzeitig ca. 1,5 A |
| Logikeingang | 3,3 V und 5 V kompatibel |
| Drehzahlregelung | PWM auf den Eingangspins (kein separater Enable-Pin) |
| Schutz | Integrierte Freilaufdioden |
| Größe | ca. 3 × 2,5 cm, wenige Gramm |
L9110S-Pinbelegung und Wahrheitstabelle
| Pin | Funktion |
|---|---|
| B-IA | Eingang 1 von Motor B (PWM möglich) |
| B-IB | Eingang 2 von Motor B (PWM möglich) |
| GND | Gemeinsame Masse (Batterie-Minus und GND des Mikrocontrollers) |
| VCC | Versorgung für Motor und Chip, 2,5–12 V |
| A-IA | Eingang 1 von Motor A (PWM möglich) |
| A-IB | Eingang 2 von Motor A (PWM möglich) |
| MOTOR A / MOTOR B | Schraubklemmen mit je zwei Anschlüssen für die Motoren |
| A-IA | A-IB | Motor A |
|---|---|---|
| HIGH | LOW | Dreht vorwärts |
| LOW | HIGH | Dreht rückwärts |
| LOW | LOW | Steht |
| HIGH | HIGH | Steht |
| PWM | LOW | Vorwärts, Drehzahl nach Tastverhältnis |
| LOW | PWM | Rückwärts, Drehzahl nach Tastverhältnis |
„Vorwärts“ und „rückwärts“ sind nur Bezeichnungen; in welche Richtung der Motor wirklich dreht, hängt davon ab, wie du die Kabel an die Klemme anschließt. Dreht der Motor falsch herum, vertausche einfach seine beiden Kabel, statt am Code zu basteln. Weil das Modul keine ENA/ENB-Pins wie der L298N hat, gibst du die PWM auf einen der beiden Eingänge. Hast du zu wenige PWM-Pins, kannst du einen Eingang fest auf HIGH legen und den anderen mit PWM ansteuern; dann kehrt sich die Logik um: Je höher das Tastverhältnis, desto langsamer wird der Motor, denn bei zweimal HIGH steht er. Am saubersten ist es deshalb, pro Motor zwei PWM-Pins zu verwenden.
L9110S anschließen: Arduino Uno, ESP32 und Pico
| L9110S-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| A-IA | D5 | GPIO 25 | GP16 |
| A-IB | D6 | GPIO 26 | GP17 |
| B-IA | D9 | GPIO 32 | GP18 |
| B-IB | D10 | GPIO 33 | GP19 |
| VCC | Batterie-Plus (z. B. 4×AA, 6 V) | Batterie-Plus (z. B. 4×AA, 6 V) | Batterie-Plus (z. B. 4×AA, 6 V) |
| GND | GND (gemeinsam mit Batterie-Minus) | GND (gemeinsam mit Batterie-Minus) | GND (gemeinsam mit Batterie-Minus) |
| Mittelabgriff Potentiometer (optional) | A0 | GPIO 34 | GP26 |
Wähle eine Versorgung nahe der Nennspannung deines Motors. Für gelbe TT-Getriebemotoren und N20-Mikromotoren sind 4 AA-Batterien (ca. 6 V) ein idealer Start. Zwei in Reihe geschaltete 18650-Li-Ion-Akkus liefern 7,4 V (voll geladen 8,4 V); 6-V-Motoren vertragen das, werden aber heißer und verschleißen schneller, daher ist es sinnvoll, die Höchstdrehzahl per PWM zu begrenzen. Ein 100-µF-Elko (Kondensator) an VCC nahe der Klemme und ein 100-nF-Keramikkondensator über den beiden Anschlüssen jedes Motors verringern Motorstörungen auf den Mikrocontroller deutlich. Die Akkulaufzeit schätzt du mit dem Batterielaufzeit-Rechner: Mit 2000-mAh-AA-Zellen hält ein Roboter, der insgesamt 450 mA zieht, grob 2000 / 450 ≈ 4,4 Stunden; in der Praxis etwas weniger.
Schritt für Schritt: Roboterauto mit L9110S (Arduino Uno)
- Montiere die beiden Getriebe-DC-Motoren am Chassis; schließe den linken Motor an die Klemme MOTOR A und den rechten an MOTOR B an.
- Verbinde A-IA und A-IB des Moduls mit D5 und D6 des Uno, B-IA und B-IB mit D9 und D10; alle vier sind PWM-fähige Pins.
- Verbinde den Pluspol des 4×AA-Batteriehalters mit VCC und den Minuspol mit GND des Moduls.
- Verbinde GND des Moduls mit einem Jumperkabel mit GND des Uno, um die gemeinsame Masse herzustellen.
- Versorge den Uno über USB und lade den folgenden Code hoch; hebe die Räder beim ersten Test in die Luft.
- Dreht ein Motor in die falsche Richtung, vertausche seine beiden Kabel an der Klemme.

1// L9110S ile iki motorlu robot araba / Two-motor robot car with L9110S
2const int A_IA = 5; // Sol motor girişi 1 (PWM) / left motor input 1 (PWM)
3const int A_IB = 6; // Sol motor girişi 2 (PWM) / left motor input 2 (PWM)
4const int B_IA = 9; // Sağ motor girişi 1 (PWM) / right motor input 1 (PWM)
5const int B_IB = 10; // Sağ motor girişi 2 (PWM) / right motor input 2 (PWM)
6
7// hız: -255 tam geri, 0 dur, 255 tam ileri / speed: -255 full reverse, 0 stop, 255 full forward
8void setMotor(int pinIA, int pinIB, int speed) {
9 speed = constrain(speed, -255, 255);
10 if (speed > 0) {
11 analogWrite(pinIA, speed); // ileri / forward
12 analogWrite(pinIB, 0);
13 } else if (speed < 0) {
14 analogWrite(pinIA, 0); // geri / reverse
15 analogWrite(pinIB, -speed);
16 } else {
17 analogWrite(pinIA, 0); // dur / stop
18 analogWrite(pinIB, 0);
19 }
20}
21
22void drive(int left, int right) {
23 setMotor(A_IA, A_IB, left);
24 setMotor(B_IA, B_IB, right);
25}
26
27void setup() {
28 pinMode(A_IA, OUTPUT);
29 pinMode(A_IB, OUTPUT);
30 pinMode(B_IA, OUTPUT);
31 pinMode(B_IB, OUTPUT);
32 drive(0, 0);
33 delay(2000); // tekerlekleri kaldırmak için süre / time to lift the wheels
34}
35
36void loop() {
37 for (int s = 80; s <= 200; s += 5) { // yumuşak kalkış / soft start
38 drive(s, s);
39 delay(30);
40 }
41 delay(1500); // 200 hızla ileri / forward at speed 200
42 drive(0, 0);
43 delay(500);
44 drive(-160, -160); // geri / reverse
45 delay(1000);
46 drive(0, 0);
47 delay(500);
48 drive(-150, 150); // yerinde sola dön / spin left in place
49 delay(600);
50 drive(150, -150); // yerinde sağa dön / spin right in place
51 delay(600);
52 drive(0, 0);
53 delay(2000);
54}| Codeabschnitt | Was er macht |
|---|---|
| setMotor(pinIA, pinIB, speed) | Gibt je nach Vorzeichen der Drehzahl PWM auf einen Eingang und 0 auf den anderen; positiv heißt vorwärts, negativ rückwärts, 0 Stopp. |
| constrain(speed, -255, 255) | Begrenzt Werte, die über die Grenzen von analogWrite hinausgehen. |
| drive(left, right) | Steuert beide Motoren gemeinsam; gleiche Werte fahren geradeaus, umgekehrte Vorzeichen drehen das Auto auf der Stelle. |
| for-Schleife (80 → 200) | Sanfter Anlauf: verringert Stromspitzen und durchdrehende Räder. |
| drive(-150, 150) | Linker Motor rückwärts, rechter vorwärts; das Auto dreht sich um die eigene Achse nach links. |
PWM-Drehzahlregelung: Tastverhältnis und mittlere Spannung
PWM bedeutet, den Pin hunderte Male pro Sekunde ein- und auszuschalten und so dem Motor eine mittlere Spannung zuzuführen. Dank seiner Trägheit nimmt der Motor die schnellen Impulse als Mittelwert wahr. Die mittlere Spannung berechnest du grob mit V_mittel = V_Versorgung × Duty / 255: Bei 6 V Versorgung entspricht analogWrite(pin, 150) etwa 6 × 150 / 255 ≈ 3,5 V. Beim Arduino Uno erzeugen D5 und D6 etwa 980 Hz, D9 und D10 etwa 490 Hz PWM; bei diesen Frequenzen ist ein leises Summen des Motors normal. Beim ESP32 und Pico kannst du die Frequenz selbst wählen; um 1 kHz ist ein sicherer Startwert für den L9110S. Bei sehr hohen Frequenzen erzeugt der Chip bei jedem Schaltvorgang mehr Wärme, bei sehr niedrigen läuft der Motor ruckelnd. Details findest du im Beitrag Was ist PWM.
Stromgrenze: Welche Motoren schafft der L9110S?
Die wichtigste Grenze des L9110S ist der Dauerstrom von etwa 800 mA pro Kanal. Entscheidend ist nicht der Leerlaufstrom des Motors, sondern der Blockierstrom (Stall). Beim Anlaufen oder wenn ein Rad an einem Hindernis hängen bleibt, begrenzt nur der Wicklungswiderstand den Strom, und der Motor zieht seinen Höchststrom. Mit dem Ohmschen Gesetz kannst du ihn grob abschätzen: Bei einem mit dem Multimeter gemessenen Wicklungswiderstand von 5 Ω und 6 V Versorgung beträgt der Blockierstrom etwa 6 / 5 = 1,2 A. Beim kurzen Anlaufen ist das unproblematisch, steht das Auto aber sekundenlang an einer Wand und die Räder können sich nicht drehen, erhitzt sich der Chip schnell. Da das Modul keinen Kühlkörper hat, solltest du Dauerlasten über 500 mA pro Kanal nicht lange laufen lassen.
| Motor | Typischer Strom | Eignung für L9110S |
|---|---|---|
| N20-Mikrogetriebemotor (6 V) | Leerlauf 30–100 mA | Sehr gut geeignet |
| Gelber TT-Getriebemotor (3–6 V) | Leerlauf 150–250 mA, blockiert ca. 1 A | Geeignet; lange Blockade vermeiden |
| 130er DC-Motor + Propeller | 200–500 mA | Geeignet (Mini-Lüfter) |
| 5-V-bürstenloser PC-Lüfter | 100–250 mA | Nur in einer Richtung geeignet |
| 12-V-Metallgetriebemotor (25GA/37GA) | Blockiert 2–5 A | Nicht geeignet, stärkerer Treiber nötig |
| RS-550 / 775-Motor | Einige bis mehrere zehn Ampere | Auf keinen Fall geeignet |
ESP32 mit L9110S: Lüfterdrehzahl und -richtung per Potentiometer
Die Pins des ESP32 arbeiten mit 3,3 V, und die Eingänge des L9110S erkennen diesen Pegel problemlos; ein Pegelwandler ist nicht nötig. Im folgenden Beispiel schließen wir an die Klemme MOTOR A einen kleinen 130er-Motor mit Propeller an. Ein Potentiometer mit den Außenanschlüssen an 3V3 und GND und dem Mittelabgriff an GPIO 34 lässt den Lüfter in der Mitte stehen; drehst du in eine Richtung, bläst er immer schneller, in die andere saugt er in Gegenrichtung. Eine kleine Totzone in der Mitte verhindert, dass das Zittern der Potentiometerwerte den Motor ständig hin- und herschaltet. Der Code trennt den LEDC-Unterschied zwischen ESP32-Arduino-Core 2.x und 3.x mit #if; für Kanal B kannst du GPIO 32 und 33 auf dieselbe Weise ergänzen.
1// ESP32 + L9110S: potansiyometre ile fan hızı ve yönü / fan speed and direction with a potentiometer
2const int FAN_IA = 25; // Motor A girişi 1 / Motor A input 1
3const int FAN_IB = 26; // Motor A girişi 2 / Motor A input 2
4const int POT_PIN = 34; // Potansiyometre orta ucu (ADC1) / potentiometer wiper (ADC1)
5const int PWM_FREQ = 1000; // PWM frekansı (Hz) / PWM frequency (Hz)
6const int PWM_RES = 8; // 8 bit: 0-255 / 8 bit: 0-255
7const int DEAD_ZONE = 40; // ortadaki ölü bölge / dead zone around the middle
8
9void pwmBegin(int pin, int channel) {
10#if ESP_ARDUINO_VERSION_MAJOR >= 3
11 (void)channel; // 3.x kanalı kendisi seçer / 3.x picks the channel itself
12 ledcAttach(pin, PWM_FREQ, PWM_RES);
13#else
14 ledcSetup(channel, PWM_FREQ, PWM_RES); // 2.x: önce kanal ayarı / 2.x: set up the channel first
15 ledcAttachPin(pin, channel);
16#endif
17}
18
19void pwmSet(int pin, int channel, int duty) {
20#if ESP_ARDUINO_VERSION_MAJOR >= 3
21 (void)channel;
22 ledcWrite(pin, duty); // 3.x: pin numarasıyla / 3.x: by pin number
23#else
24 (void)pin;
25 ledcWrite(channel, duty); // 2.x: kanal numarasıyla / 2.x: by channel number
26#endif
27}
28
29void setFan(int speed) {
30 speed = constrain(speed, -255, 255);
31 if (speed >= 0) {
32 pwmSet(FAN_IA, 0, speed); // üfle / blow
33 pwmSet(FAN_IB, 1, 0);
34 } else {
35 pwmSet(FAN_IA, 0, 0); // ters yönde em / suck in reverse
36 pwmSet(FAN_IB, 1, -speed);
37 }
38}
39
40void setup() {
41 Serial.begin(115200);
42 analogReadResolution(12); // 0-4095
43 pwmBegin(FAN_IA, 0);
44 pwmBegin(FAN_IB, 1);
45 setFan(0);
46}
47
48void loop() {
49 int raw = analogRead(POT_PIN);
50 int speed = map(raw, 0, 4095, -255, 255);
51 if (abs(speed) < DEAD_ZONE) speed = 0; // ortada dur / stop in the middle
52 setFan(speed);
53 Serial.printf("ADC: %d Hiz/Speed: %d\n", raw, speed);
54 delay(50);
55}Raspberry Pi Pico und MicroPython mit L9110S
Jeder GPIO-Pin des Pico kann Hardware-PWM erzeugen, bei der Pinwahl bist du also ziemlich frei. Im Beispiel hängt der linke Motor an GP16 und GP17, der rechte an GP18 und GP19. Der Code definiert jeden Motor als Klasse und nimmt die Drehzahl in Prozent (-100 bis 100), sodass du dich nicht mit dem Bereich 0–65535 von duty_u16 herumschlagen musst. Versorge den Pico über USB, die Motoren über den an VCC des Moduls angeschlossenen Akkupack und verbinde beide GND. Wenn du das Programm in Thonny mit Strg+C stoppst, hält der KeyboardInterrupt-Block die Motoren sicher an; ohne ihn läuft die PWM-Hardware weiter und dein Auto könnte vom Tisch fahren.
1from machine import Pin, PWM
2import time
3
4class Motor:
5 def __init__(self, pin_ia, pin_ib, freq=1000):
6 self.ia = PWM(Pin(pin_ia)) # IA girişi / IA input
7 self.ib = PWM(Pin(pin_ib)) # IB girişi / IB input
8 self.ia.freq(freq)
9 self.ib.freq(freq)
10 self.stop()
11
12 def speed(self, percent): # -100 geri ... 100 ileri / -100 reverse ... 100 forward
13 percent = max(-100, min(100, percent))
14 duty = int(abs(percent) * 65535 // 100)
15 if percent > 0:
16 self.ia.duty_u16(duty)
17 self.ib.duty_u16(0)
18 elif percent < 0:
19 self.ia.duty_u16(0)
20 self.ib.duty_u16(duty)
21 else:
22 self.stop()
23
24 def stop(self):
25 self.ia.duty_u16(0)
26 self.ib.duty_u16(0)
27
28left = Motor(16, 17) # A-IA = GP16, A-IB = GP17
29right = Motor(18, 19) # B-IA = GP18, B-IB = GP19
30
31def drive(l, r, ms):
32 left.speed(l)
33 right.speed(r)
34 time.sleep_ms(ms)
35
36try:
37 while True:
38 for s in range(30, 81, 5): # yumuşak kalkış / soft start
39 drive(s, s, 40)
40 drive(80, 80, 1500) # ileri / forward
41 drive(0, 0, 500)
42 drive(-60, -60, 1000) # geri / reverse
43 drive(0, 0, 500)
44 drive(-60, 60, 600) # yerinde sola dön / spin left in place
45 drive(0, 0, 2000)
46except KeyboardInterrupt:
47 left.stop() # Ctrl+C ile güvenli dur / safe stop on Ctrl+C
48 right.stop()L9110S oder L298N? Wann nimmst du welchen?
| Eigenschaft | L9110S-Modul | L298N-Modul |
|---|---|---|
| Motorspannung | 2,5–12 V | ca. 5–35 V |
| Strom pro Kanal | ca. 800 mA Dauerstrom | ca. 2 A Dauerstrom |
| Spannungsabfall am Treiber | Gering | ca. 2 V und mehr |
| Drehzahlregelung | PWM auf IA/IB-Pins | PWM auf ENA/ENB-Pins |
| Benötigte Steuerpins | 4 | 6 (4 mit Jumpern) |
| Integrierter 5-V-Regler | Nein | Ja (bis 12 V Versorgung) |
| Größe und Gewicht | Sehr klein, wenige Gramm | Groß, mit Kühlkörper |
| 3,3-V-Logik | Kompatibel | Funktioniert meist |
Kurz gesagt: Liegen deine Motoren unter 12 V und überschreiten selbst blockiert kaum 1 A, ist der L9110S die bessere Wahl: Er ist kleiner, leichter und verschwendet nicht die etwa 2 V, die in den Bipolartransistoren des L298N verloren gehen. Bei batteriebetriebenen Projekten ist der Unterschied deutlich: Mit einem 6-V-Akkupack lässt der L298N dem Motor etwa 4 V, während der L9110S den Großteil der Versorgung weitergibt und dein Auto sichtbar schneller fährt. Für 12-V-Metallgetriebemotoren, schwere Chassis, Dauerlasten über 1 A oder Versorgungen über 12 V brauchst du dagegen den L298N oder modernere MOSFET-Treiber. Einen ausführlichen Vergleich mit Alternativen wie dem TB6612FNG findest du im Beitrag Motortreiber im Vergleich.
Projektideen mit dem L9110S
- Bluetooth-gesteuertes Mini-Auto: Rufe mit einem HC-05-Modul je nach vom Handy empfangenem Buchstaben die Funktion drive() auf.
- Hindernisvermeidender Roboter: Baue einen HC-SR04 vorn ein und lass den Roboter bei Hindernissen unter 20 cm zurücksetzen und abbiegen; Details im Beitrag Hindernisvermeidender Roboter.
- Linienfolger-Roboter: Folge mit zwei TCRT5000-Sensoren einer schwarzen Linie; mit N20-Motoren und L9110S wird der Roboter leicht und wendig.
- Temperaturgesteuerter Lüfter: Erhöhe die Lüfterdrehzahl per PWM stufenweise mit der gemessenen Temperatur; die Logik findest du im Beitrag Arduino-Lüftersteuerung.
- Panzersteuerung mit Joystick: Wandle die X- und Y-Achse eines Joysticks in linke und rechte Motordrehzahl um.
- WLAN-gesteuertes Auto: Sende Richtungs- und Geschwindigkeitsbefehle über Buttons auf einer Webseite des ESP32.
- Mini-Kran oder Vorhangöffner: Wickle mit einem Getriebemotor ein Seil auf; stoppe den Motor an den Endpunkten mit einem Endschalter.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Motor dreht gar nicht | Keine gemeinsame GND oder keine Spannung an VCC | GND des Moduls mit GND des Boards verbinden, VCC mit dem Multimeter messen |
| Motor dreht bei niedriger Drehzahl nicht, brummt nur | Duty-Wert liegt unter der Anlaufschwelle des Motors | Mindestdrehzahl auf etwa 70–100 anheben |
| Arduino startet neu, wenn der Motor anläuft | Motoren hängen an derselben 5V-Leitung wie das Board | Separate Batterie für die Motoren verwenden, 100-µF-Kondensator an VCC ergänzen |
| Dreht in eine Richtung, in die andere nicht | Ein Eingang hängt an einem Pin ohne PWM oder ein Kabel hat keinen Kontakt | Alle vier Eingänge an PWM-Pins anschließen, Jumper prüfen |
| Chip wird sehr heiß | Motorstrom überschreitet die 800-mA-Grenze oder der Motor ist blockiert | Kleineren Motor verwenden, Blockieren vermeiden oder auf L298N wechseln |
| Drehzahlregelung arbeitet verkehrt herum | Ein Eingang ist HIGH, der andere PWM | Festen Eingang auf LOW legen oder Duty-Wert von 255 abziehen |
| ESP32-Motor dreht beim Start kurz | Der gewählte Pin gibt beim Booten ein Signal aus | Pins verwenden, die beim Start ruhig bleiben, z. B. GPIO 25, 26, 32, 33 |
Der L9110S ist ein leichter, günstiger und effizienter Treiber für batteriebetriebene Projekte mit kleinen Motoren; kennst du seine Grenzen und kombinierst ihn mit dem passenden Motor, läuft er lange problemlos. Wechselst du später auf größere Motoren, kannst du dieselbe Richtungs- und PWM-Logik beim L298N weiterverwenden. In der BlueGrays-App findest du Projekte wie ein Bluetooth-gesteuertes Auto, einen hindernisvermeidenden Roboter und PWM-Steuerung per Potentiometer mit Schaltplan und Code Schritt für Schritt; den L9110S-Anschluss von hier kannst du leicht darauf übertragen. Bei der Wahl von Chassis, Rädern und Akku hilft dir die Anleitung Arduino-Roboterauto bauen.
Häufige Fragen
Wie viel Ampere verträgt der L9110S?
Der L9110S liefert pro Kanal etwa 800 mA Dauerstrom, der kurzzeitige Spitzenstrom liegt bei rund 1,5 A. Da das Modul zwei Chips hat, treibt es zwei Motoren jeweils mit dieser Grenze. Für eine lange Lebensdauer solltest du den Dauerstrom pro Motor unter 500–600 mA halten.
Kann ich mit dem L9110S einen 12-V-Motor ansteuern?
Die maximale Versorgungsspannung des Moduls beträgt 12 V, ein kleiner 12-V-Motor ist also theoretisch möglich. Die meisten 12-V-Motoren ziehen blockiert aber weit über 1 A, und ein Chip an der Grenze wird heiß. Für 12-V-Motoren sind ein L298N oder ein MOSFET-Treiber die sicherere Wahl.
Funktioniert der L9110S mit ESP32 und 3,3 V?
Ja. Die Eingänge des L9110S erkennen 3,3-V-Logik als HIGH, deshalb kannst du ihn direkt an ESP32, Raspberry Pi Pico und andere 3,3-V-Boards anschließen. Du musst nur die Motorspannung separat an VCC legen und die GND-Anschlüsse verbinden.
Was ist besser: L9110S oder L298N?
Bei Projekten mit kleinen Motoren und Batterie ist der L9110S besser: Er ist kleiner und leichter und verliert nicht wie der L298N rund 2 V Spannung. Überschreitet der Motorstrom 1 A oder brauchst du mehr als 12 V Versorgung, ist der L298N die richtige Wahl.
Kann man mit dem L9110S einen Schrittmotor ansteuern?
Ja, die zwei H-Brücken des Moduls können die beiden Spulen eines kleinen bipolaren (4-adrigen) Schrittmotors treiben, und die Arduino-Stepper-Bibliothek funktioniert mit dieser Verdrahtung. Der Spulenstrom darf 800 mA nicht überschreiten. Für unipolare 5-adrige Motoren wie den 28BYJ-48 ist ein ULN2003-Board besser geeignet.
Warum wird der L9110S so heiß?
Meist zieht der Motor einen Strom nahe der Chipgrenze; besonders Motoren mit blockierten Rädern oder schwerer Last nähern sich dem Blockierstrom. Auch eine Versorgungsspannung über der Nennspannung des Motors erhöht den Strom. Nimm einen kleineren Motor, begrenze die Höchstdrehzahl per PWM oder wechsle zu einem stärkeren Treiber.
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.

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

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.

Servo-Steuerung mit Joystick
Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.

Servomotorbetrieb mit Potentiometer
Während du am Knopf des Potentiometers drehst, dreht sich der Arm des Servomotors einfach mit: Das eine Ende des Knopfes bedeutet null Grad, das andere eine halbe Umdrehung.

Verwendung von Schrittmotoren
Ein Motor, der sich Schritt für Schritt genau so weit dreht, wie du willst, wie der Zeiger einer Uhr.
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

