Componenten · 10 min leestijd

L9110S met Arduino: dubbele motordriver en toerentalregeling met PWM

Hoe sluit je een L9110S-motordriver aan op Arduino? Pinout, draairichting en toerentalregeling met PWM, de limiet van 800 mA, voorbeelden voor een robotauto en een ventilator, plus code voor Uno, ESP32 en Pico.

De L9110S is een vingertopgrote, zeer goedkope motordrivermodule met twee kanalen, waarmee je tegelijk de draairichting en het toerental van twee kleine gelijkstroommotoren regelt. L9110S en Arduino vormen een van de handigste combinaties voor mini-robotauto's op batterijen, kleine ventilatoren, speelgoedbootjes en propellerprojecten. De module bevat twee L9110S-chips en elke chip kan een motor aansturen met ongeveer 800 mA continue stroom per kanaal, binnen een bereik van 2,5–12 V.

Een Arduino-pin kan niet genoeg stroom leveren om een motor rechtstreeks aan te sturen: een Uno-pin geeft maximaal 20–40 mA, terwijl een kleine gele tandwielmotor bij het starten een veelvoud daarvan trekt. Om de draairichting van een motor te veranderen, moet je bovendien de richting van de stroom door de motor omkeren. In dit artikel leer je de pinout, de waarheidstabel, de toerentalregeling met PWM en de stroomlimiet van de L9110S kennen, en schrijf je code voor een robotauto met een Arduino Uno, een ventilator met potmeter op een ESP32 en MicroPython op een Raspberry Pi Pico. In de laatste sectie leggen we uit wanneer de L9110S de L298N kan vervangen en wanneer niet.

L9110S-motordrivermodule met twee kanalen
L9110S-module: twee H-bruggen, een ingangsheader met 6 pinnen (B-IA, B-IB, GND, VCC, A-IA, A-IB) en schroefklemmen voor twee motoren.

Wat is de L9110S en hoe werkt hij?

In de L9110S zit een H-brug van vier schakelaars. Wanneer de schakelaars diagonaal in paren openen en sluiten, loopt de stroom in de ene of de andere richting door de motor en draait de motor dus vooruit of achteruit. Elke H-brug heeft twee ingangspinnen (IA en IB) en twee uitgangspinnen (OA en OB). Geef je IA HIGH en IB LOW, dan draait de motor de ene kant op; wissel je ze om, dan draait hij de andere kant op. Zet je een PWM-signaal op een van deze twee ingangen, dan verandert de gemiddelde spanning die de motor ziet, en zo stel je het toerental in. De chip bevat ook beveiligingsdiodes tegen de spanningspieken in omgekeerde richting die de motor opwekt als hij stopt of van richting verandert, dus een externe diode hoef je niet toe te voegen. De module heeft geen aparte logicavoeding of 5V-regelaar: de spanning die je op de VCC-pin zet, voedt zowel de chips als de motoren.

EigenschapWaarde
Driverchip2 × L9110S (één per motor)
Kanalen2 gelijkstroommotoren of 1 kleine bipolaire stappenmotor
Voedingsspanning (VCC)2,5–12 V
Continue stroomOngeveer 800 mA per kanaal
PiekstroomOngeveer 1,5 A voor korte tijd
Logica-ingangGeschikt voor 3,3 V en 5 V
ToerentalregelingPWM op de ingangspinnen (geen aparte enable-pin)
BeveiligingIngebouwde vrijloopdiodes
AfmetingenOngeveer 3 × 2,5 cm, een paar gram

L9110S-pinout en waarheidstabel

PinFunctie
B-IAIngang 1 van motor B (PWM toegestaan)
B-IBIngang 2 van motor B (PWM toegestaan)
GNDGemeenschappelijke massa (min van de batterij en GND van de microcontroller)
VCCVoeding van motoren en chip, 2,5–12 V
A-IAIngang 1 van motor A (PWM toegestaan)
A-IBIngang 2 van motor A (PWM toegestaan)
MOTOR A / MOTOR BTweepolige schroefklemmen waarop je de motoren aansluit
A-IAA-IBMotor A
HIGHLOWDraait vooruit
LOWHIGHDraait achteruit
LOWLOWStopt
HIGHHIGHStopt
PWMLOWVooruit, toerental bepaald door de duty cycle
LOWPWMAchteruit, toerental bepaald door de duty cycle

"Vooruit" en "achteruit" zijn hier slechts labels; welke kant de motor echt op draait, hangt af van de volgorde waarin je zijn draden op de klem aansluit. Draait een motor de verkeerde kant op, wissel dan gewoon zijn twee draden om in plaats van aan de code te sleutelen. Omdat de module geen ENA/ENB-pins heeft zoals de L298N, zet je voor het toerental PWM op een van de twee ingangen. Heb je te weinig PWM-pinnen, dan kun je één ingang constant HIGH houden en de andere met PWM aansturen, maar dan is de logica omgekeerd: naarmate de duty cycle stijgt, vertraagt de motor, want de motor stopt als beide ingangen HIGH zijn. Daarom is het netst om per motor twee PWM-pinnen te gebruiken.

L9110S-bedrading: Arduino Uno, ESP32 en Pico

L9110S-pinArduino UnoESP32Raspberry Pi Pico
A-IAD5GPIO 25GP16
A-IBD6GPIO 26GP17
B-IAD9GPIO 32GP18
B-IBD10GPIO 33GP19
VCCPlus van de batterij (bijv. 4×AA, 6 V)Plus van de batterij (bijv. 4×AA, 6 V)Plus van de batterij (bijv. 4×AA, 6 V)
GNDGND (gedeeld met min van de batterij)GND (gedeeld met min van de batterij)GND (gedeeld met min van de batterij)
Sleper van de potmeter (optioneel)A0GPIO 34GP26
Voed de motoren nooit via de 5V-pin van de Arduino en vergeet niet de GND van de module te verbinden met de GND van de microcontroller. De plotselinge stroom die een motor bij het starten trekt, laat de 5V-lijn instorten; het board reset en bij een ESP32 krijg je een brownout-fout. Zonder een gemeenschappelijke GND verliest het PWM-signaal zijn referentie en draait de motor helemaal niet of gedraagt hij zich willekeurig. Als je VCC en GND verkeerd om aansluit, branden de L9110S-chips direct door.

Kies een voeding die dicht bij de nominale spanning van je motor ligt. Voor gele TT-tandwielmotoren en N20-micromotoren zijn 4 AA-batterijen (ongeveer 6 V) een ideale start. Twee 18650 Li-ion-cellen in serie geven 7,4 V (8,4 V volgeladen); motoren van 6 V kunnen dit aan, maar ze worden warmer en slijten sneller, dus het is verstandig de topsnelheid met PWM te beperken. Een elektrolytische condensator van 100 µF over de VCC-lijn van de module, vlak bij de klem, en een keramische condensator van 100 nF over de twee aansluitingen van elke motor, verminderen de motorruis naar de microcontroller sterk. Om de gebruiksduur van de batterij in te schatten, kun je de batterijduurcalculator gebruiken: een robot die in totaal 450 mA trekt uit AA-cellen van 2000 mAh, gaat grofweg 2000 / 450 ≈ 4,4 uur mee; in de praktijk iets korter.

Stap voor stap: een robotauto met de L9110S (Arduino Uno)

  1. Monteer de twee gelijkstroom-tandwielmotoren op het chassis; sluit de linkermotor aan op de klem MOTOR A en de rechtermotor op MOTOR B.
  2. Verbind de pinnen A-IA en A-IB van de module met pin D5 en D6 van de Uno, en B-IA en B-IB met D9 en D10; alle vier ondersteunen PWM.
  3. Verbind de plus van de 4×AA-batterijhouder met de VCC-pin van de module en de min met GND.
  4. Maak de gemeenschappelijke massa door de GND-pin van de module met een jumperdraad te verbinden met de GND-pin van de Uno.
  5. Voed de Uno via USB en upload de onderstaande code; til voor de eerste test de wielen van de grond.
  6. Draait een motor de verkeerde kant op, wissel dan de twee draden van die motor om op de klem.
Set met gelijkstroom-tandwielmotor en wiel
Gele TT-tandwielmotoren zijn de meest gebruikte motoren voor robotauto's en de L9110S kan ze binnen zijn stroomlimiet prima aansturen.
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}
CodedeelWat het doet
setMotor(pinIA, pinIB, speed)Stuurt PWM naar de ene ingang en 0 naar de andere, afhankelijk van het teken van het toerental; positief is vooruit, negatief achteruit, 0 stoppen.
constrain(speed, -255, 255)Begrenst waarden die buiten het bereik van analogWrite vallen.
drive(left, right)Stuurt beide motoren tegelijk aan; gelijke waarden rijden rechtdoor, tegengestelde tekens laten de auto op de plek draaien.
for-lus (80 → 200)Zachte start: vermindert de plotselinge stroompiek en het doorslippen van de wielen.
drive(-150, 150)De linkermotor draait achteruit en de rechter vooruit; de auto draait linksom om zijn eigen as.
De meeste kleine tandwielmotoren kunnen bij lage duty-waarden niet op gang komen; om de wrijving te overwinnen heb je meestal een ondergrens van 70–100 (30–40 procent) nodig. Om de startwaarde van jouw motor te vinden, verhoog je het toerental stap voor stap vanaf 0, print je het naar de Serial Monitor en neem je de waarde waarbij de motor begint te draaien als minimumsnelheid op in je code.

Toerentalregeling met PWM: duty cycle en gemiddelde spanning

PWM zet een gemiddelde spanning op de motor door de pin honderden keren per seconde aan en uit te schakelen. Dankzij zijn traagheid ervaart de motor deze snelle pulsen als een gemiddelde. De gemiddelde spanning bereken je bij benadering met de formule V_gem = V_voeding × duty / 255: bij een voeding van 6 V komt analogWrite(pin, 150) overeen met ongeveer 6 × 150 / 255 ≈ 3,5 V. Op de Arduino Uno leveren pin D5 en D6 ongeveer 980 Hz PWM en pin D9 en D10 ongeveer 490 Hz; een licht gejank van de motor bij deze frequenties is normaal. Op de ESP32 en Pico kun je de frequentie zelf kiezen; rond 1 kHz is een veilige start voor de L9110S. Bij zeer hoge frequenties produceert de chip bij elke schakeling meer warmte, terwijl de motor bij zeer lage frequenties schokkerig draait. Voor meer details kun je het artikel Wat is PWM bekijken.

Stroomlimiet: welke motoren kan de L9110S aansturen?

De belangrijkste limiet van de L9110S is ongeveer 800 mA continue stroom per kanaal. De waarde waar je op moet letten is niet de stroom die de motor zonder belasting trekt, maar zijn blokkeerstroom. Als de motor start, of als een wiel een obstakel raakt en stilvalt, beperkt alleen de wikkelweerstand de stroom en trekt de motor zijn maximum. Je kunt die grofweg schatten met de wet van Ohm: als de wikkelweerstand die je met een multimeter meet 5 Ω is en de voeding 6 V, dan is de blokkeerstroom ongeveer 6 / 5 = 1,2 A. Dit is geen probleem bij een korte start, maar als de auto tegen een muur duwt en seconden blijft staan terwijl de wielen niet kunnen draaien, wordt de chip snel warm. Omdat de module geen koelplaat heeft, kun je continue belastingen boven 500 mA per kanaal het best niet lang volhouden.

MotorTypische stroomVoor de L9110S
N20-micro-tandwielmotor (6 V)30–100 mA onbelastZeer geschikt
Gele TT-tandwielmotor (3–6 V)150–250 mA onbelast, ongeveer 1 A bij blokkeringGeschikt; vermijd langdurig blokkeren
DC-motor type 130 + propeller200–500 mAGeschikt (miniventilator)
Borstelloze computerventilator van 5 V100–250 mAAlleen in één richting geschikt
12V-metalen tandwielmotor (25GA/37GA)2–5 A bij blokkeringNiet geschikt, vereist een sterkere driver
RS-550 / 775 motorEnkele ampères tot tientallen ampèresAbsoluut niet geschikt

L9110S met ESP32: toerental en richting van een ventilator met een potmeter

De pinnen van de ESP32 werken op 3,3 V en de ingangen van de L9110S lezen dit niveau zonder problemen; een niveauconverter heb je niet nodig. In het onderstaande voorbeeld sluiten we een kleine 130-motor met een propeller aan op de klem MOTOR A. Met een potmeter waarvan de buitenste pinnen naar 3V3 en GND gaan en de sleper naar GPIO 34, staat de ventilator stil als de potmeter in het midden staat; draai je hem naar de ene kant, dan blaast hij steeds harder, draai je hem naar de andere kant, dan zuigt hij in de omgekeerde richting. De kleine dode zone in het midden zorgt ervoor dat de schommelende metingen van de potmeter de motor niet steeds heen en weer duwen. De code scheidt het LEDC-verschil tussen ESP32 Arduino core 2.x en 3.x met #if; wil je ook kanaal B gebruiken, dan kun je GPIO 32 en 33 op dezelfde manier toevoegen.

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 en MicroPython met de L9110S

Elke GPIO-pin van de Pico kan hardware-PWM leveren, dus je hebt veel vrijheid bij het kiezen van pinnen. In het voorbeeld zit de linkermotor op GP16 en GP17 en de rechtermotor op GP18 en GP19. De code definieert elke motor als een klasse en neemt het toerental als percentage (-100 tot 100), zodat je niet met het bereik 0–65535 van duty_u16 te maken hebt. Voed de Pico via USB en de motoren via het batterijpakket dat op VCC van de module is aangesloten, en verbind de twee GND's. Als je het programma in Thonny stopt met Ctrl+C, stopt het KeyboardInterrupt-blok de motoren veilig; zonder dit blok blijft de PWM-hardware doorlopen en kan je auto van de tafel rijden.

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 of L298N? Welke kies je?

EigenschapL9110S-moduleL298N-module
Motorspanning2,5–12 VOngeveer 5–35 V
Stroom per kanaalOngeveer 800 mA continuOngeveer 2 A continu
Spanningsverlies over de driverLaagOngeveer 2 V of meer
ToerentalregelingPWM op de IA/IB-pinnenPWM op de ENA/ENB-pinnen
Benodigde stuurpinnen46 (4 met jumpers)
Ingebouwde 5V-regelaarGeenJa (bij een voeding tot 12 V)
Afmetingen en gewichtZeer klein, een paar gramGroot, met een koelplaat
3,3V-logicaCompatibelWerkt meestal

Kortom: als je motoren onder 12 V werken en geen enkele ook bij blokkering ver boven 1 A komt, is de L9110S de betere keuze: hij is kleiner, lichter en verspilt niet de ongeveer 2 V die in de bipolaire transistors van de L298N verloren gaat. Dit verschil merk je sterk in projecten op batterijen: bij een batterijpakket van 6 V laat de L298N ongeveer 4 V over voor de motor, terwijl de L9110S het grootste deel van de voeding naar de motor doorgeeft en je auto zichtbaar sneller rijdt. Voor metalen tandwielmotoren van 12 V, zware chassis, continue belastingen boven 1 A of voedingen boven 12 V heb je daarentegen de L298N of modernere MOSFET-drivers nodig. Voor een uitgebreide vergelijking met alternatieven zoals de TB6612FNG, zie het artikel vergelijking van motordrivers.

Projectideeën met de L9110S

  • Mini-auto met Bluetooth-besturing: roep met een HC-05-module de functie drive() aan op basis van de letters die van je telefoon komen.
  • Robot die obstakels ontwijkt: voeg vooraan een HC-SR04 toe en bouw een robot die achteruit rijdt en draait als een obstakel dichterbij is dan 20 cm; details staan in het artikel robot die obstakels ontwijkt.
  • Lijnvolgrobot: volg een zwarte lijn met twee TCRT5000-sensoren; N20-motoren en de L9110S maken een lichte en wendbare robot.
  • Ventilator met temperatuurregeling: verhoog het toerental van de ventilator met PWM geleidelijk op basis van de gemeten temperatuur; de logica vind je in het artikel Arduino-ventilatorbesturing.
  • Tankbesturing met een joystick: zet de X- en Y-as van de joystick om in toerentallen voor de linker- en rechtermotor.
  • Auto met wifibesturing: stuur richting- en snelheidscommando's vanaf knoppen op een webpagina die door een ESP32 wordt aangeboden.
  • Minikraan of gordijnopener: wind een touwtje op met een tandwielmotor; stop de motor in de eindpunten met een eindschakelaar.

Veelgemaakte fouten en hoe je ze verhelpt

SymptoomWaarschijnlijke oorzaakOplossing
De motor draait helemaal nietGeen gemeenschappelijke GND, of geen voeding op VCCVerbind de GND van de module met de GND van het board en meet VCC met een multimeter
De motor draait niet op lage snelheid, hij bromt alleenDe duty-waarde ligt onder de startdrempel van de motorVerhoog het minimumtoerental naar ongeveer 70–100
De Arduino reset als de motor startDe motoren worden gevoed vanaf dezelfde 5V-lijn als het boardGebruik een aparte batterij voor de motoren en voeg een condensator van 100 µF toe aan VCC
Hij draait in de ene richting maar niet in de andereEen ingang zit op een pin zonder PWM, of een draad maakt geen contactSluit alle vier de ingangen aan op PWM-pinnen en controleer de jumpers
De chip wordt erg heetDe motorstroom overschrijdt de limiet van 800 mA, of de motor is geblokkeerdGebruik een kleinere motor, vermijd blokkeren of schakel over op een L298N
De toerentalregeling werkt omgekeerdEen ingang is HIGH en de andere krijgt PWMMaak de vaste ingang LOW, of trek de duty-waarde af van 255
De motor draait even als de ESP32 opstartDe gekozen pin geeft bij het opstarten een signaal afGebruik pinnen die bij het opstarten stil blijven, zoals GPIO 25, 26, 32 en 33
Als je een nieuw gebouwde robot voor het eerst test, til dan altijd de wielen van de grond en beperk het toerental tot ongeveer 150. Als er een bedradingsfout is, schiet de auto niet van de tafel en kun je de temperatuur van de chip veilig controleren. Is de chip na een paar minuten draaien te heet om aan te raken, dan is de motorstroom te hoog voor de L9110S.

De L9110S is een lichte, goedkope en efficiënte driver voor projecten op batterijen met kleine motoren; als je zijn limieten kent en hem combineert met de juiste motor, werkt hij lang probleemloos. Als je op grotere motoren overstapt, kun je dezelfde richtings- en PWM-logica blijven gebruiken met de L298N. In de BlueGrays-app vind je stap-voor-stap schakelschema's en code voor projecten zoals een auto met Bluetooth-besturing, een robot die obstakels ontwijkt en PWM-regeling met een potmeter, en je kunt de L9110S-bedrading hier eenvoudig daarop aanpassen. De gids een Arduino-robotauto bouwen helpt je ook bij het kiezen van chassis, wielen en batterij.

Veelgestelde vragen

Hoeveel ampère kan de L9110S aan?

De L9110S kan ongeveer 800 mA continue stroom per kanaal leveren, met een kortstondige piek van rond 1,5 A. Omdat de module twee chips heeft, stuurt hij twee motoren apart aan, elk met deze limiet. Voor een lange levensduur is het een goede regel de continue stroom per motor onder 500–600 mA te houden.

Kan de L9110S een motor van 12 V aansturen?

De maximale voedingsspanning van de module is 12 V, dus een kleine 12V-motor kan in theorie worden aangestuurd. De meeste 12V-motoren trekken bij blokkering echter ruim meer dan 1 A, en een chip die op zijn limiet werkt, wordt heet. Voor 12V-motoren is een L298N of een driver op basis van MOSFET's een veiligere keuze.

Werkt de L9110S met de ESP32 en 3,3 V?

Ja. De ingangspinnen van de L9110S lezen een logisch niveau van 3,3 V als HIGH, dus je kunt hem direct aansluiten op de ESP32, de Raspberry Pi Pico en andere 3,3V-boards. Je moet alleen de motorvoeding apart op VCC aansluiten en de GND's met elkaar verbinden.

Is de L9110S of de L298N beter?

Voor projecten op batterijen met kleine motoren is de L9110S beter; hij is kleiner en lichter en verliest niet ongeveer 2 V zoals de L298N. Overschrijdt de motorstroom 1 A of heb je een voeding boven 12 V nodig, kies dan de L298N.

Kan de L9110S een stappenmotor aansturen?

Ja, de twee H-bruggen op de module kunnen de twee spoelen van een kleine bipolaire (4-draads) stappenmotor aansturen, en de Arduino Stepper-bibliotheek werkt met deze bedrading. De spoelstroom mag niet hoger zijn dan 800 mA. Voor unipolaire motoren met 5 draden, zoals de 28BYJ-48, is een ULN2003-board geschikter.

Waarom wordt de L9110S zo heet?

De meest voorkomende oorzaak van verwarming is dat de motor stroom trekt die dicht bij de limiet van de chip ligt; motoren met vastgelopen wielen of zware belasting komen vooral in de buurt van hun blokkeerstroom. Een voedingsspanning die hoger is dan de nominale spanning van de motor verhoogt de stroom ook. Gebruik een kleinere motor, beperk de topsnelheid met PWM of stap over op een krachtigere driver.

Alle projecten bekijken
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

4.7(42)
58
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

Servomotor aansturen met een potentiometer

Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

4.6(37)
53
Een stappenmotor gebruiken
AR-67Gemiddeld
Premium

Een stappenmotor gebruiken

Een motor die stap voor stap draait, precies zo ver als jij wilt, zoals de wijzer van een klok.

4.5(31)
42