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.

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.
| Caratteristica | Valore |
|---|---|
| Chip driver | 2 × L9110S (uno per motore) |
| Numero di canali | 2 motori DC oppure 1 piccolo motore passo-passo bipolare |
| Tensione di alimentazione (VCC) | 2,5–12 V |
| Corrente continua | Circa 800 mA per canale |
| Corrente di picco | Circa 1,5 A per breve tempo |
| Ingresso logico | Compatibile 3,3 V e 5 V |
| Controllo della velocità | PWM sui pin di ingresso (nessun pin enable separato) |
| Protezione | Diodi di smorzamento integrati |
| Dimensioni | Circa 3 × 2,5 cm, pochi grammi |
Pin del L9110S e tabella di verità
| Pin | Funzione |
|---|---|
| B-IA | Ingresso 1 del motore B (si può usare PWM) |
| B-IB | Ingresso 2 del motore B (si può usare PWM) |
| GND | Massa comune (negativo della batteria e GND del microcontrollore) |
| VCC | Alimentazione di motori e chip, 2,5–12 V |
| A-IA | Ingresso 1 del motore A (si può usare PWM) |
| A-IB | Ingresso 2 del motore A (si può usare PWM) |
| MOTOR A / MOTOR B | Morsettiere a vite a due poli per collegare i motori |
| A-IA | A-IB | Motore A |
|---|---|---|
| HIGH | LOW | Gira in avanti |
| LOW | HIGH | Gira indietro |
| LOW | LOW | Si ferma |
| HIGH | HIGH | Si ferma |
| PWM | LOW | Avanti, velocità in base al duty cycle |
| LOW | PWM | Indietro, 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 L9110S | 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 | Positivo della batteria (es. 4×AA, 6 V) | Positivo della batteria (es. 4×AA, 6 V) | Positivo della batteria (es. 4×AA, 6 V) |
| GND | GND (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) | A0 | GPIO 34 | GP26 |
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)
- Monta i due motoriduttori DC sul telaio; collega il motore sinistro alla morsettiera MOTOR A e il destro a MOTOR B.
- 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.
- Collega il positivo del portabatterie 4×AA al pin VCC del modulo e il negativo al pin GND.
- Collega il pin GND del modulo al GND dell'Uno con un cavetto jumper per creare la massa comune.
- Alimenta l'Uno via USB e carica il codice qui sotto; alla prima prova tieni le ruote sollevate da terra.
- Se un motore gira in senso inverso, scambia i suoi due fili nella morsettiera.

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 codice | Cosa 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. |
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.
| Motore | Corrente tipica | Per il L9110S |
|---|---|---|
| Micromotoriduttore N20 (6 V) | A vuoto 30–100 mA | Molto adatto |
| Motoriduttore giallo TT (3–6 V) | A vuoto 150–250 mA, circa 1 A in stallo | Adatto; evita stalli prolungati |
| Motore DC tipo 130 + elica | 200–500 mA | Adatto (mini ventola) |
| Ventola per PC brushless 5 V | 100–250 mA | Adatta solo in un senso di rotazione |
| Motoriduttore metallico 12 V (25GA/37GA) | 2–5 A in stallo | Non adatto, serve un driver più potente |
| Motore RS-550 / 775 | Da alcuni ampere a decine di ampere | Assolutamente 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.
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.
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
| Caratteristica | Modulo L9110S | Modulo L298N |
|---|---|---|
| Tensione motori | 2,5–12 V | Circa 5–35 V |
| Corrente per canale | Circa 800 mA continui | Circa 2 A continui |
| Caduta di tensione sul driver | Bassa | Circa 2 V e oltre |
| Controllo della velocità | PWM sui pin IA/IB | PWM sui pin ENA/ENB |
| Pin di controllo necessari | 4 | 6 (4 con i jumper) |
| Regolatore 5 V integrato | No | Sì (con alimentazione fino a 12 V) |
| Dimensioni e peso | Molto piccolo, pochi grammi | Grande, con dissipatore |
| Logica 3,3 V | Compatibile | Di 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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il motore non gira per niente | Manca il GND comune oppure VCC non è alimentato | Collega il GND del modulo al GND della scheda, misura VCC con il multimetro |
| A bassa velocità il motore non gira, ronza soltanto | Il duty cycle è sotto la soglia di avvio del motore | Porta la velocità minima intorno a 70–100 |
| Arduino si resetta quando il motore parte | I motori sono alimentati dalla stessa linea 5V della scheda | Usa una batteria separata per i motori, aggiungi un condensatore da 100 µF su VCC |
| Gira in un verso ma non nell'altro | Un ingresso è su un pin non PWM oppure il filo non fa contatto | Collega tutti e quattro gli ingressi a pin PWM, controlla i jumper |
| Il chip si scalda molto | La corrente del motore supera il limite di 800 mA oppure il motore è bloccato | Usa un motore più piccolo, evita gli stalli o passa al L298N |
| La regolazione di velocità funziona al contrario | Un ingresso è HIGH e l'altro è PWM | Metti l'ingresso fisso a LOW oppure sottrai il duty da 255 |
| Con l'ESP32 il motore gira un attimo all'accensione | Il pin scelto genera un segnale all'avvio | Usa pin che restano silenziosi all'avvio, come GPIO 25, 26, 32, 33 |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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.

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.

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.

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.

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

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.

Utilizzo del motore passo-passo
Un motore che gira passo dopo passo, esattamente quanto vuoi tu, come la lancetta di un orologio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

