Bauteile · 8 Min. Lesezeit

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.

L9110S Zweikanal-Motortreiber-Modul
L9110S-Modul: zwei H-Brücken, 6-polige Eingangsleiste (B-IA, B-IB, GND, VCC, A-IA, A-IB) und Schraubklemmen für zwei Motoren.

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.

EigenschaftWert
Treiberchip2 × L9110S (einer pro Motor)
Kanäle2 DC-Motoren oder 1 kleiner bipolarer Schrittmotor
Versorgungsspannung (VCC)2,5–12 V
Dauerstromca. 800 mA pro Kanal
Spitzenstromkurzzeitig ca. 1,5 A
Logikeingang3,3 V und 5 V kompatibel
DrehzahlregelungPWM auf den Eingangspins (kein separater Enable-Pin)
SchutzIntegrierte Freilaufdioden
Größeca. 3 × 2,5 cm, wenige Gramm

L9110S-Pinbelegung und Wahrheitstabelle

PinFunktion
B-IAEingang 1 von Motor B (PWM möglich)
B-IBEingang 2 von Motor B (PWM möglich)
GNDGemeinsame Masse (Batterie-Minus und GND des Mikrocontrollers)
VCCVersorgung für Motor und Chip, 2,5–12 V
A-IAEingang 1 von Motor A (PWM möglich)
A-IBEingang 2 von Motor A (PWM möglich)
MOTOR A / MOTOR BSchraubklemmen mit je zwei Anschlüssen für die Motoren
A-IAA-IBMotor A
HIGHLOWDreht vorwärts
LOWHIGHDreht rückwärts
LOWLOWSteht
HIGHHIGHSteht
PWMLOWVorwärts, Drehzahl nach Tastverhältnis
LOWPWMRü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-PinArduino UnoESP32Raspberry Pi Pico
A-IAD5GPIO 25GP16
A-IBD6GPIO 26GP17
B-IAD9GPIO 32GP18
B-IBD10GPIO 33GP19
VCCBatterie-Plus (z. B. 4×AA, 6 V)Batterie-Plus (z. B. 4×AA, 6 V)Batterie-Plus (z. B. 4×AA, 6 V)
GNDGND (gemeinsam mit Batterie-Minus)GND (gemeinsam mit Batterie-Minus)GND (gemeinsam mit Batterie-Minus)
Mittelabgriff Potentiometer (optional)A0GPIO 34GP26
Versorge die Motoren niemals über den 5V-Pin des Arduino und vergiss nicht, die GND des Moduls mit der GND des Mikrocontrollers zu verbinden. Der Anlaufstrom des Motors lässt die 5V-Leitung einbrechen; das Board startet neu, beim ESP32 bekommst du einen Brownout-Fehler. Ohne gemeinsame Masse fehlt dem PWM-Signal die Referenz, und der Motor dreht entweder gar nicht oder verhält sich zufällig. Wenn du VCC und GND vertauschst, brennen die L9110S-Chips sofort durch.

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)

  1. 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.
  2. 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.
  3. Verbinde den Pluspol des 4×AA-Batteriehalters mit VCC und den Minuspol mit GND des Moduls.
  4. Verbinde GND des Moduls mit einem Jumperkabel mit GND des Uno, um die gemeinsame Masse herzustellen.
  5. Versorge den Uno über USB und lade den folgenden Code hoch; hebe die Räder beim ersten Test in die Luft.
  6. Dreht ein Motor in die falsche Richtung, vertausche seine beiden Kabel an der Klemme.
Gelber TT-Getriebemotor mit Rad
Gelbe TT-Getriebemotoren sind die verbreitetsten Roboterauto-Motoren, die sich innerhalb der Stromgrenze des L9110S problemlos antreiben lassen.
C++ (Arduino IDE)
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}
CodeabschnittWas 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.
Die meisten kleinen Getriebemotoren laufen bei niedrigen Duty-Werten nicht an; um die Reibung zu überwinden, braucht man meist eine Untergrenze von 70–100 (30–40 Prozent). Um den Startwert deines Motors zu finden, erhöhe die Drehzahl von 0 schrittweise, gib sie im Serial Monitor aus und übernimm den Wert, bei dem der Motor anläuft, als Mindestdrehzahl in deinen Code.

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.

MotorTypischer StromEignung für L9110S
N20-Mikrogetriebemotor (6 V)Leerlauf 30–100 mASehr gut geeignet
Gelber TT-Getriebemotor (3–6 V)Leerlauf 150–250 mA, blockiert ca. 1 AGeeignet; lange Blockade vermeiden
130er DC-Motor + Propeller200–500 mAGeeignet (Mini-Lüfter)
5-V-bürstenloser PC-Lüfter100–250 mANur in einer Richtung geeignet
12-V-Metallgetriebemotor (25GA/37GA)Blockiert 2–5 ANicht geeignet, stärkerer Treiber nötig
RS-550 / 775-MotorEinige bis mehrere zehn AmpereAuf 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.

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

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

EigenschaftL9110S-ModulL298N-Modul
Motorspannung2,5–12 Vca. 5–35 V
Strom pro Kanalca. 800 mA Dauerstromca. 2 A Dauerstrom
Spannungsabfall am TreiberGeringca. 2 V und mehr
DrehzahlregelungPWM auf IA/IB-PinsPWM auf ENA/ENB-Pins
Benötigte Steuerpins46 (4 mit Jumpern)
Integrierter 5-V-ReglerNeinJa (bis 12 V Versorgung)
Größe und GewichtSehr klein, wenige GrammGroß, mit Kühlkörper
3,3-V-LogikKompatibelFunktioniert 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

SymptomMögliche UrsacheLösung
Motor dreht gar nichtKeine gemeinsame GND oder keine Spannung an VCCGND des Moduls mit GND des Boards verbinden, VCC mit dem Multimeter messen
Motor dreht bei niedriger Drehzahl nicht, brummt nurDuty-Wert liegt unter der Anlaufschwelle des MotorsMindestdrehzahl auf etwa 70–100 anheben
Arduino startet neu, wenn der Motor anläuftMotoren hängen an derselben 5V-Leitung wie das BoardSeparate Batterie für die Motoren verwenden, 100-µF-Kondensator an VCC ergänzen
Dreht in eine Richtung, in die andere nichtEin Eingang hängt an einem Pin ohne PWM oder ein Kabel hat keinen KontaktAlle 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 blockiertKleineren Motor verwenden, Blockieren vermeiden oder auf L298N wechseln
Drehzahlregelung arbeitet verkehrt herumEin Eingang ist HIGH, der andere PWMFesten Eingang auf LOW legen oder Duty-Wert von 255 abziehen
ESP32-Motor dreht beim Start kurzDer gewählte Pin gibt beim Booten ein Signal ausPins verwenden, die beim Start ruhig bleiben, z. B. GPIO 25, 26, 32, 33
Heb die Räder bei der ersten Inbetriebnahme deines neuen Roboters unbedingt in die Luft und begrenze die Drehzahl auf etwa 150. Bei einem Verdrahtungsfehler springt das Auto nicht vom Tisch, und du kannst die Chip-Temperatur in Ruhe prüfen. Ist der Chip nach einigen Minuten Betrieb so heiß, dass du ihn nicht berühren kannst, ist der Motorstrom für den L9110S zu hoch.

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.

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
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

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.

4.5(19)
32
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
Servo-Steuerung mit Joystick
AR-60Mittel
Premium

Servo-Steuerung mit Joystick

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

4.7(42)
58
Servomotorbetrieb mit Potentiometer
AR-36Anfänger
Premium

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.

4.6(37)
53
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