Componenti · 10 min di lettura

Driver motore L9110S Arduino: controllo velocità PWM

Come collegare il driver motore L9110S ad Arduino: pin, direzione e velocità PWM, limite di 800 mA, esempi con auto robot e ventola, codice per Uno, ESP32 e Pico.

Il L9110S è un modulo driver a doppio canale grande quanto la punta di un dito e molto economico, che ti permette di controllare contemporaneamente direzione e velocità di due piccoli motori DC. L9110S e Arduino sono una delle soluzioni più pratiche per mini auto robot a batteria, piccole ventole, barchette giocattolo e progetti con l'elica. Sul modulo ci sono due chip L9110S; ognuno può pilotare un motore con circa 800 mA continui per canale, in un intervallo di 2,5–12 V.

I pin di Arduino non possono fornire la corrente necessaria ad alimentare direttamente un motore: un pin dell'Uno dà al massimo 20–40 mA, mentre un piccolo motoriduttore giallo all'avvio ne assorbe decine di volte tanto. Inoltre, per invertire il senso di rotazione bisogna invertire il verso della corrente. In questo articolo conoscerai i pin del modulo L9110S, la tabella di verità, la regolazione della velocità con il PWM e il limite di corrente; scriverai il codice per un'auto robot con Arduino Uno, una ventola controllata da potenziometro con ESP32 e MicroPython con Raspberry Pi Pico. Nell'ultima sezione chiariremo quando L9110S può sostituire il L298N e quando no.

Modulo driver motore doppio canale L9110S
Modulo L9110S: due ponti H, connettore a 6 pin (B-IA, B-IB, GND, VCC, A-IA, A-IB) e morsettiere a vite per due motori.

Che cos'è il L9110S e come funziona?

Dentro il L9110S c'è un ponte H formato da quattro interruttori. Quando gli interruttori si aprono e si chiudono a coppie incrociate, la corrente attraversa il motore in un verso o nell'altro, e il motore gira avanti o indietro. Ogni ponte H ha due pin di ingresso (IA e IB) e due di uscita (OA e OB). Con IA a HIGH e IB a LOW il motore gira in un verso, con i valori invertiti nell'altro. Applicando un segnale PWM a uno dei due ingressi cambia la tensione media vista dal motore, e quindi ne regoli la velocità. Nel chip ci sono anche diodi di protezione contro gli impulsi di tensione inversa generati dal motore quando si ferma o cambia direzione, quindi non serve aggiungere diodi esterni. Il modulo non ha un'alimentazione logica separata né un regolatore da 5 V: la tensione che dai al pin VCC alimenta sia i chip sia i motori.

CaratteristicaValore
Chip driver2 × L9110S (uno per motore)
Numero di canali2 motori DC oppure 1 piccolo motore passo-passo bipolare
Tensione di alimentazione (VCC)2,5–12 V
Corrente continuaCirca 800 mA per canale
Corrente di piccoCirca 1,5 A per breve tempo
Ingresso logicoCompatibile 3,3 V e 5 V
Controllo della velocitàPWM sui pin di ingresso (nessun pin enable separato)
ProtezioneDiodi di smorzamento integrati
DimensioniCirca 3 × 2,5 cm, pochi grammi

Pin del L9110S e tabella di verità

PinFunzione
B-IAIngresso 1 del motore B (si può usare PWM)
B-IBIngresso 2 del motore B (si può usare PWM)
GNDMassa comune (negativo della batteria e GND del microcontrollore)
VCCAlimentazione di motori e chip, 2,5–12 V
A-IAIngresso 1 del motore A (si può usare PWM)
A-IBIngresso 2 del motore A (si può usare PWM)
MOTOR A / MOTOR BMorsettiere a vite a due poli per collegare i motori
A-IAA-IBMotore A
HIGHLOWGira in avanti
LOWHIGHGira indietro
LOWLOWSi ferma
HIGHHIGHSi ferma
PWMLOWAvanti, velocità in base al duty cycle
LOWPWMIndietro, velocità in base al duty cycle

"Avanti" e "indietro" sono solo nomi: il verso in cui il motore gira davvero dipende dall'ordine in cui colleghi i fili alla morsettiera. Se il motore gira al contrario, invece di modificare il codice basta scambiare i due fili. Poiché il modulo non ha pin ENA/ENB come il L298N, per la velocità applichi il PWM a uno dei due ingressi. Se hai pochi pin PWM puoi tenere un ingresso fisso a HIGH e dare il PWM all'altro; ma in questo caso la logica si inverte: più sale il duty cycle, più il motore rallenta, perché con entrambi gli ingressi a HIGH il motore si ferma. Per questo il metodo più pulito è dedicare due pin PWM a ogni motore.

Collegamento del L9110S: Arduino Uno, ESP32 e Pico

Pin L9110SArduino UnoESP32Raspberry Pi Pico
A-IAD5GPIO 25GP16
A-IBD6GPIO 26GP17
B-IAD9GPIO 32GP18
B-IBD10GPIO 33GP19
VCCPositivo della batteria (es. 4×AA, 6 V)Positivo della batteria (es. 4×AA, 6 V)Positivo della batteria (es. 4×AA, 6 V)
GNDGND (in comune con il negativo della batteria)GND (in comune con il negativo della batteria)GND (in comune con il negativo della batteria)
Cursore del potenziometro (opzionale)A0GPIO 34GP26
Non alimentare mai i motori dal pin 5V di Arduino e non dimenticare di collegare il GND del modulo al GND del microcontrollore. L'assorbimento improvviso all'avvio del motore fa crollare la linea 5V: la scheda si resetta e sull'ESP32 ottieni un errore di brownout. Senza GND in comune il segnale PWM perde il suo riferimento e il motore o non gira o si comporta in modo casuale. Invertire VCC e GND brucia subito i chip L9110S.

Per l'alimentazione scegli una sorgente vicina alla tensione nominale del motore. Per i motoriduttori gialli TT e i micromotori N20, 4 batterie AA (circa 6 V) sono un ottimo inizio. Due batterie Li-Ion 18650 in serie danno 7,4 V (8,4 V a piena carica); i motori da 6 V lo sopportano ma si scaldano e si consumano prima, quindi in questo caso conviene limitare la velocità massima con il PWM. Saldare un condensatore elettrolitico da 100 µF sulla linea VCC del modulo, vicino alla morsettiera, e uno ceramico da 100 nF tra i due terminali di ogni motore riduce molto l'effetto del rumore dei motori sul microcontrollore. Per stimare la durata della batteria puoi usare il calcolatore di durata batteria: con pile AA da 2000 mAh, un robot che assorbe 450 mA in totale dura circa 2000 / 450 ≈ 4,4 ore; in pratica un po' meno.

Passo dopo passo: auto robot con L9110S (Arduino Uno)

  1. Monta i due motoriduttori DC sul telaio; collega il motore sinistro alla morsettiera MOTOR A e il destro a MOTOR B.
  2. Collega i pin A-IA e A-IB del modulo ai pin D5 e D6 dell'Uno e B-IA e B-IB ai pin D9 e D10; tutti e quattro supportano il PWM.
  3. Collega il positivo del portabatterie 4×AA al pin VCC del modulo e il negativo al pin GND.
  4. Collega il pin GND del modulo al GND dell'Uno con un cavetto jumper per creare la massa comune.
  5. Alimenta l'Uno via USB e carica il codice qui sotto; alla prima prova tieni le ruote sollevate da terra.
  6. Se un motore gira in senso inverso, scambia i suoi due fili nella morsettiera.
Set motoriduttore DC con ruota
I motoriduttori gialli TT sono i motori più diffusi per auto robot e si pilotano senza problemi entro il limite di corrente del L9110S.
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}
Parte di codiceCosa fa
setMotor(pinIA, pinIB, speed)In base al segno della velocità dà il PWM a un ingresso e 0 all'altro; positivo significa avanti, negativo indietro, 0 fermo.
constrain(speed, -255, 255)Limita i valori che superano i confini di analogWrite.
drive(left, right)Gestisce i due motori insieme; valori uguali vanno dritti, segni opposti fanno ruotare l'auto sul posto.
ciclo for (80 → 200)Partenza dolce: riduce l'impulso di corrente e lo slittamento delle ruote.
drive(-150, 150)Il motore sinistro gira indietro e il destro avanti; l'auto ruota a sinistra attorno al proprio asse.
La maggior parte dei piccoli motoriduttori non riesce a partire con duty cycle bassi; per vincere l'attrito serve di solito un limite minimo tra 70 e 100 (30–40%). Per trovare il valore di avvio del tuo motore, aumenta la velocità da 0 passo dopo passo, stampala sul Serial Monitor e inserisci nel codice come velocità minima il valore a cui il motore comincia a girare.

Controllo della velocità con PWM: duty cycle e tensione media

Il PWM consiste nell'accendere e spegnere il pin centinaia di volte al secondo, applicando al motore una tensione media. Grazie alla sua inerzia, il motore percepisce questi impulsi rapidi come un valore medio. La tensione media si calcola approssimativamente con la formula V_media = V_alimentazione × duty / 255: con alimentazione a 6 V, analogWrite(pin, 150) corrisponde a circa 6 × 150 / 255 ≈ 3,5 V. Sull'Arduino Uno i pin D5 e D6 generano un PWM di circa 980 Hz, i pin D9 e D10 di circa 490 Hz; a queste frequenze è normale sentire un leggero ronzio dal motore. Su ESP32 e Pico puoi scegliere tu la frequenza; circa 1 kHz è un punto di partenza sicuro per il L9110S. A frequenze molto alte il chip produce più calore a ogni commutazione, a frequenze molto basse il motore gira a scatti. Per approfondire dai un'occhiata all'articolo Che cos'è il PWM.

Limite di corrente: quali motori regge il L9110S?

Il limite più importante del L9110S è la corrente continua di circa 800 mA per canale. Il valore a cui devi fare attenzione non è la corrente a vuoto del motore, ma la corrente di stallo. Quando il motore parte o la ruota si blocca contro un ostacolo, solo la resistenza dell'avvolgimento limita la corrente e il motore assorbe il massimo. Puoi stimarla con la legge di Ohm: se la resistenza dell'avvolgimento misurata con il multimetro è 5 Ω e l'alimentazione è 6 V, la corrente di stallo è circa 6 / 5 = 1,2 A. Questo valore non crea problemi nel breve istante dell'avviamento, ma se l'auto resta per secondi contro un muro con le ruote ferme, il chip si scalda in fretta. Poiché il modulo non ha dissipatore, è meglio non mantenere a lungo carichi continui superiori a 500 mA per canale.

MotoreCorrente tipicaPer il L9110S
Micromotoriduttore N20 (6 V)A vuoto 30–100 mAMolto adatto
Motoriduttore giallo TT (3–6 V)A vuoto 150–250 mA, circa 1 A in stalloAdatto; evita stalli prolungati
Motore DC tipo 130 + elica200–500 mAAdatto (mini ventola)
Ventola per PC brushless 5 V100–250 mAAdatta solo in un senso di rotazione
Motoriduttore metallico 12 V (25GA/37GA)2–5 A in stalloNon adatto, serve un driver più potente
Motore RS-550 / 775Da alcuni ampere a decine di ampereAssolutamente non adatto

L9110S con ESP32: velocità e direzione della ventola con un potenziometro

I pin dell'ESP32 lavorano a 3,3 V e gli ingressi del L9110S riconoscono senza problemi questo livello; non serve nessun convertitore di livello. Nell'esempio qui sotto colleghiamo alla morsettiera MOTOR A un piccolo motore 130 con elica. Con un potenziometro con i capi esterni su 3V3 e GND e il cursore sul GPIO 34, la ventola resta ferma al centro; girandolo in un verso soffia sempre più forte, girandolo nell'altro aspira in senso inverso. La piccola zona morta al centro evita che le letture ballerine del potenziometro facciano muovere continuamente il motore avanti e indietro. Il codice gestisce con #if la differenza LEDC tra ESP32 Arduino core 2.x e 3.x; se vuoi usare anche il canale B puoi aggiungere allo stesso modo i GPIO 32 e 33.

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 e MicroPython con L9110S

Ogni pin GPIO del Pico può generare PWM hardware, quindi sei piuttosto libero nella scelta dei pin. Nell'esempio il motore sinistro è collegato a GP16 e GP17, il destro a GP18 e GP19. Il codice definisce ogni motore come una classe e riceve la velocità in percentuale (da -100 a 100), così non devi occuparti dell'intervallo 0–65535 di duty_u16. Alimenta il Pico via USB e i motori con il pacco batterie collegato al VCC del modulo, e unisci i due GND. Quando fermi il programma in Thonny con Ctrl+C, il blocco KeyboardInterrupt ferma i motori in sicurezza; senza questo blocco l'hardware PWM continuerebbe a funzionare e la tua auto potrebbe cadere dal tavolo.

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 o L298N? Quando usare l'uno o l'altro

CaratteristicaModulo L9110SModulo L298N
Tensione motori2,5–12 VCirca 5–35 V
Corrente per canaleCirca 800 mA continuiCirca 2 A continui
Caduta di tensione sul driverBassaCirca 2 V e oltre
Controllo della velocitàPWM sui pin IA/IBPWM sui pin ENA/ENB
Pin di controllo necessari46 (4 con i jumper)
Regolatore 5 V integratoNoSì (con alimentazione fino a 12 V)
Dimensioni e pesoMolto piccolo, pochi grammiGrande, con dissipatore
Logica 3,3 VCompatibileDi solito funziona

In breve, se i tuoi motori sono sotto i 12 V e ciascuno non supera 1 A nemmeno in stallo, il L9110S è la scelta migliore: è più piccolo, più leggero e non spreca i circa 2 V persi nei transistor bipolari del L298N. Questa differenza si nota molto nei progetti a batteria: con un pacco da 6 V il L298N lascia al motore circa 4 V, mentre il L9110S trasferisce al motore gran parte dell'alimentazione e la tua auto va visibilmente più veloce. D'altra parte, per motoriduttori metallici da 12 V, telai pesanti, carichi continui oltre 1 A o alimentazioni superiori a 12 V servono il L298N o driver più moderni con MOSFET. Per un confronto dettagliato con alternative come il TB6612FNG consulta l'articolo confronto tra driver motore.

Idee di progetto con il L9110S

  • Mini auto controllata via Bluetooth: con il modulo HC-05 richiama la funzione drive() in base alle lettere inviate dal telefono.
  • Robot evita ostacoli: monta davanti un HC-SR04 e costruisci un robot che arretra e gira quando trova un ostacolo a meno di 20 cm; i dettagli sono nell'articolo robot evita ostacoli.
  • Robot segui linea: segui la linea nera con due sensori TCRT5000; con motori N20 e L9110S ottieni un robot leggero e agile.
  • Ventola in base alla temperatura: aumenta gradualmente la velocità della ventola con il PWM in base alla temperatura misurata; trovi la logica nell'articolo controllo ventola con Arduino.
  • Guida a carro armato con joystick: trasforma gli assi X e Y di un joystick nelle velocità dei motori sinistro e destro.
  • Auto controllata via Wi-Fi: invia comandi di direzione e velocità con i pulsanti di una pagina web sull'ESP32.
  • Mini gru o apri-tenda: avvolgi una corda con un motoriduttore; ferma il motore con un finecorsa ai punti estremi.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
Il motore non gira per nienteManca il GND comune oppure VCC non è alimentatoCollega il GND del modulo al GND della scheda, misura VCC con il multimetro
A bassa velocità il motore non gira, ronza soltantoIl duty cycle è sotto la soglia di avvio del motorePorta la velocità minima intorno a 70–100
Arduino si resetta quando il motore parteI motori sono alimentati dalla stessa linea 5V della schedaUsa una batteria separata per i motori, aggiungi un condensatore da 100 µF su VCC
Gira in un verso ma non nell'altroUn ingresso è su un pin non PWM oppure il filo non fa contattoCollega tutti e quattro gli ingressi a pin PWM, controlla i jumper
Il chip si scalda moltoLa corrente del motore supera il limite di 800 mA oppure il motore è bloccatoUsa un motore più piccolo, evita gli stalli o passa al L298N
La regolazione di velocità funziona al contrarioUn ingresso è HIGH e l'altro è PWMMetti l'ingresso fisso a LOW oppure sottrai il duty da 255
Con l'ESP32 il motore gira un attimo all'accensioneIl pin scelto genera un segnale all'avvioUsa pin che restano silenziosi all'avvio, come GPIO 25, 26, 32, 33
Quando provi per la prima volta il robot appena montato, tieni sempre le ruote sollevate e limita la velocità intorno a 150. Se c'è un errore di cablaggio l'auto non schizza via dal tavolo e puoi controllare con calma la temperatura del chip. Se dopo qualche minuto di funzionamento il chip è troppo caldo per essere toccato, la corrente del motore è eccessiva per il L9110S.

Il L9110S è un driver leggero, economico ed efficiente per progetti a batteria con piccoli motori; se ne conosci i limiti e lo abbini al motore giusto, lavora a lungo senza problemi. Quando passerai a motori più grandi potrai continuare a usare la stessa logica di direzione e PWM con il L298N. Nell'app BlueGrays trovi passo dopo passo, con schemi e codici, progetti come l'auto controllata via Bluetooth, il robot evita ostacoli e il controllo PWM con potenziometro, e puoi adattarvi facilmente il collegamento del L9110S visto qui. Per la scelta di telaio, ruote e batteria ti guiderà anche la guida costruire un'auto robot con Arduino.

Domande frequenti

Quanti ampere regge il L9110S?

Il L9110S può fornire circa 800 mA continui per canale, con una corrente di picco di circa 1,5 A per brevi istanti. Poiché il modulo ha due chip, pilota due motori separatamente con questo limite. Per una lunga durata è buona regola tenere la corrente continua per motore sotto 500–600 mA.

Si può pilotare un motore da 12 V con il L9110S?

La tensione massima di alimentazione del modulo è 12 V, quindi in teoria si può pilotare un piccolo motore da 12 V. Ma la maggior parte dei motori da 12 V in stallo assorbe ben più di 1 A e il chip al limite si scalda. Per i motori da 12 V un L298N o un driver con MOSFET è una scelta più sicura.

Il L9110S funziona con ESP32 e 3,3 V?

Sì. I pin di ingresso del L9110S riconoscono il livello logico 3,3 V come HIGH, quindi si collega direttamente a ESP32, Raspberry Pi Pico e altre schede a 3,3 V. Basta alimentare i motori separatamente su VCC e unire i GND.

È meglio il L9110S o il L298N?

Nei progetti a batteria con piccoli motori il L9110S è migliore: è più piccolo e leggero e non perde circa 2 V come il L298N. Se la corrente del motore supera 1 A o serve un'alimentazione oltre 12 V, è preferibile il L298N.

Si può pilotare un motore passo-passo con il L9110S?

Sì, i due ponti H del modulo possono pilotare le due bobine di un piccolo motore passo-passo bipolare (4 fili) e la libreria Stepper di Arduino funziona con questo collegamento. La corrente di bobina non deve superare 800 mA. Per i motori unipolari a 5 fili come il 28BYJ-48 è più adatta la scheda ULN2003.

Perché il L9110S si scalda molto?

La causa più frequente è un motore che assorbe una corrente vicina al limite del chip; soprattutto i motori con ruote bloccate o che trasportano un carico pesante si avvicinano alla corrente di stallo. Anche una tensione di alimentazione superiore a quella nominale del motore aumenta la corrente. Usa un motore più piccolo, limita la velocità massima con il PWM o passa a un driver più potente.

Vedi tutti i progetti
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

Auto controllata via Bluetooth con L298N

Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

5.0(39)
66
Robot che evita gli ostacoli
AR-81Avanzato
Premium

Robot che evita gli ostacoli

Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

5.0(38)
49
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)

In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

4.5(19)
32
Dissolvenza LED ESP32 con PWM
ES-8Principiante

Dissolvenza LED ESP32 con PWM

Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Effetto Respiro)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Effetto Respiro)

Il LED non lampeggia più — respira! Con il PWM (modulazione di larghezza d'impulso) del Raspberry Pi Pico, la luminosità sale e scende lentamente. Impara la classe machine.PWM, duty_u16() (luminosità a 16 bit 0–65535), la frequenza PWM, i cicli range() e l'uscita quasi analogica. Base per miscelazione colori RGB, controllo motori, servo e buzzer.

4
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

4.7(42)
58
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

Funzionamento del servomotore con potenziometro

Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

4.6(37)
53
Utilizzo del motore passo-passo
AR-67Intermedio
Premium

Utilizzo del motore passo-passo

Un motore che gira passo dopo passo, esattamente quanto vuoi tu, come la lancetta di un orologio.

4.5(31)
42