Confronto driver motore: L298N, L293D, TB6612FNG, A4988
Confronto tra driver motore L298N, L293D, L9110S, TB6612FNG e A4988: corrente, caduta di tensione, efficienza, compatibilità 3,3 V e scelta per robot e passo-passo.
Quando confronti i driver motore, la prima domanda è: quanta corrente assorbe il tuo motore, con che tensione lavora e a quale livello logico parla la scheda (5 V o 3,3 V)? I cinque driver più usati dagli hobbisti sono L298N, L293D, L9110S, TB6612FNG e A4988. In breve: per un piccolo robot a batteria scegli il TB6612FNG, per motori a 12 V da 1–2 A l'L298N, per il budget minimo l'L9110S, per pilotare quattro motori con una sola scheda su Arduino Uno lo shield L293D, e per passo-passo bipolari come i NEMA 17 l'A4988.
In questa guida vedremo quanta corrente può davvero erogare ogni driver, quanta tensione perde, come questa perdita influisce su autonomia della batteria e riscaldamento, e come si comportano con schede a 3,3 V come ESP32 e Raspberry Pi Pico. Poi troverai codici funzionanti per pilotare due motori con Arduino, ESP32 e Pico, un esempio di motore passo-passo con A4988 e una tabella di scelta per progetto.

Cos'è un driver motore e perché serve?
Un pin digitale di Arduino eroga al massimo circa 20–40 mA; anche un piccolo motoriduttore TT assorbe 150–250 mA in marcia e quasi 1 A quando si blocca (stall). Collegare il motore direttamente al pin lo brucia, e gli impulsi di tensione inversa generati dal motore resettano il microcontrollore. Il driver motore è un circuito a interruttori che prende il segnale debole del microcontrollore e alimenta il motore da un'alimentazione separata. Il cuore dei driver per motori DC è il ponte H: aprendo e chiudendo quattro interruttori a coppie diagonali si inverte la polarità ai capi del motore, che gira avanti o indietro. La velocità si regola con un segnale PWM che apre e chiude gli interruttori migliaia di volte al secondo. I driver per passo-passo vanno oltre: alimentano le bobine in sequenza limitando la corrente, per ruotare il motore ad angoli precisi.
Presentazione rapida dei cinque driver
- L298N: vecchio ma diffusissimo, doppio ponte H a transistor bipolari. Regge tensioni alte (5–35 V sul modulo) e arriva a 2 A per canale, ma perde 2–3 V e si scalda molto. Dettagli in controllo di motori DC con L298N.
- L293D: integrato DIP a 16 pin; 600 mA continui per canale, 1,2 A di picco e diodi di protezione interni. È famoso per lo shield motore L293D per Arduino Uno che pilota quattro motori DC.
- L9110S: l'opzione più economica e piccola. Lavora tra 2,5 e 12 V, eroga circa 800 mA per canale; non ha pin enable, ogni motore si controlla con due pin. Dettagli in driver motore L9110S.
- TB6612FNG: ponte H moderno a MOSFET. 1,2 A continui e 3,2 A di picco per canale, resistenza di circa 0,5 ohm: quasi non si scalda e funziona senza problemi con livelli logici da 2,7 V.
- A4988: non è un driver per motori DC ma per passo-passo bipolari. Tensione motore 8–35 V, limite di corrente regolabile e microstepping fino a 1/16. L'installazione è spiegata passo passo in driver passo-passo A4988.
Tabella di confronto: corrente, tensione, compatibilità 3,3 V e prezzo
| Caratteristica | L298N | L293D | L9110S | TB6612FNG | A4988 |
|---|---|---|---|---|---|
| Tipo di motore | 2 DC o 1 passo-passo bipolare | 2 DC o 1 passo-passo bipolare | 2 DC | 2 DC o 1 passo-passo bipolare | 1 passo-passo bipolare |
| Tensione motore | 5–35 V (modulo) | 4,5–36 V | 2,5–12 V | 4,5–13,5 V (massimo assoluto 15 V) | 8–35 V |
| Corrente continua (per canale) | 2 A (con dissipatore) | 0,6 A | circa 0,8 A | 1,2 A | circa 1 A senza dissipatore, 2 A con raffreddamento |
| Corrente di picco | 3 A | 1,2 A | circa 1,5 A | 3,2 A | 2 A |
| Tecnologia degli interruttori | Transistor bipolare | Transistor bipolare | Transistor (bassa saturazione) | MOSFET | MOSFET + controllo di corrente |
| Caduta di tensione | circa 2–3 V | circa 1,8–2,6 V | circa 1 V | circa 0,5 V (a 1 A) | Controllato in corrente, non è un problema |
| Efficienza | Bassa | Bassa | Media | Alta | Alta |
| Alimentazione logica | 5 V (regolatore sul modulo) | 4,5–7 V (VCC1) | In comune con l'alimentazione motore | 2,7–5,5 V (VCC) | 3–5,5 V (VDD) |
| Compatibilità segnale 3,3 V | Di solito funziona | Gli ingressi lo accettano, alimentazione logica a 5 V | Piena | Piena | Piena |
| Prezzo (relativo) | Basso | Basso | Molto basso | Medio | Basso |
I valori di corrente in tabella sono i limiti dei datasheet; in pratica la zona sicura è circa il 70% di questi. Per esempio i 2 A dell'L298N sono possibili solo con un grande dissipatore e un buon flusso d'aria; se forzi a lungo un modulo senza dissipatore oltre 1 A, l'integrato si scalda in fretta ed entra in protezione termica. Per sapere il fabbisogno reale di un motore non guardare la corrente di lavoro ma la corrente di stallo (stall): quando la ruota urta un ostacolo il motore assorbe quella corrente e il driver deve reggerla almeno per un breve periodo. La colonna del prezzo è una classifica relativa: l'L9110S è di solito il modulo più economico, mentre il TB6612FNG, pur costando un po' di più, compensa ampiamente con efficienza e dimensioni ridotte.
Caduta di tensione ed efficienza: perché l'L298N si scalda tanto?
Nei driver a transistor bipolari (L298N, L293D) la corrente attraversa due transistor prima di arrivare al motore e su ciascuno si perdono circa 1–1,5 V. Questa perdita diventa calore: la potenza dissipata si calcola con P = V_caduta × I. Nel TB6612FNG a MOSFET gli interruttori si comportano come una resistenza e la perdita è P = I² × R_on; con 0,5 ohm e 1 A sono solo 0,5 W. Con batterie a bassa tensione la differenza è enorme: perdere 2 V su un pacco da 6 V significa buttare via un terzo della potenza del motore. Puoi rifare i calcoli per il tuo motore con il calcolatore della legge di Ohm e stimare l'autonomia con il calcolatore di durata della batteria. La tabella seguente mostra i valori tipici per un'alimentazione di 6 V e una corrente motore di 0,6 A:
| Driver | Caduta di tensione tipica | Tensione rimasta al motore | Potenza dissipata nel driver | Efficienza approssimativa |
|---|---|---|---|---|
| L298N | 1,8 V | 4,2 V | 1,08 W | 70% |
| L293D | 2,0 V | 4,0 V | 1,2 W | 67% |
| L9110S | 0,8 V | 5,2 V | 0,48 W | 87% |
| TB6612FNG | 0,3 V | 5,7 V | 0,18 W | 95% |
Compatibilità 3,3 V: quale driver con ESP32 e Raspberry Pi Pico?
I pin di ESP32 e Pico escono a 3,3 V. L'alimentazione logica (VCC) del TB6612FNG si può collegare direttamente a 3,3 V, quindi è l'abbinamento più pulito con queste schede. Anche l'ingresso logico dell'A4988 funziona tra 3 e 5,5 V. Gli ingressi dell'L9110S riconoscono senza problemi un segnale a 3,3 V. Sugli ingressi di L298N e L293D la soglia del livello alto è di almeno 2,3 V, quindi un segnale a 3,3 V funziona nella maggior parte dei casi, ma la parte logica dell'integrato richiede un'alimentazione a 5 V e lavorare vicino alla soglia può causare falsi trigger in ambienti rumorosi. Insomma, se parti con un nuovo progetto ESP32 o Pico usa il TB6612FNG; se hai un L298N di solito funzionerà comunque, ma non dimenticare mai la massa in comune.
Collegamenti: tabella dei pin L298N e TB6612FNG
| Funzione | Pin L298N | Pin TB6612FNG | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|---|
| Velocità motore A (PWM) | ENA | PWMA | D5 | GPIO 25 | GP16 |
| Direzione motore A 1 | IN1 | AIN1 | D4 | GPIO 26 | GP17 |
| Direzione motore A 2 | IN2 | AIN2 | D7 | GPIO 27 | GP18 |
| Velocità motore B (PWM) | ENB | PWMB | D6 | GPIO 13 | GP21 |
| Direzione motore B 1 | IN3 | BIN1 | D8 | GPIO 33 | GP19 |
| Direzione motore B 2 | IN4 | BIN2 | D9 | GPIO 32 | GP20 |
| Standby / abilitazione | Assente | STBY | D10 | GPIO 4 | GP22 |
| Alimentazione logica | +5V (uscita regolatore) | VCC | 5V | 3V3 | 3V3 (OUT) |
| Alimentazione motore | +12V | VM | Alimentatore esterno | Alimentatore esterno | Alimentatore esterno |
| Massa | GND | GND | GND | GND | GND |
Passo passo: pilotare due motori DC con Arduino
- Collega l'alimentazione dei motori (per esempio 7,4 V con 2 celle 18650 o 9 V con 6×AA) all'ingresso di alimentazione motore del driver: +12V sull'L298N, VM sul TB6612FNG.
- Collega il polo negativo dell'alimentazione sia al GND del driver sia al GND di Arduino.
- Se usi l'L298N, togli i jumper su ENA ed ENB; altrimenti non puoi regolare la velocità e il motore gira sempre al massimo.
- Collega i pin PWM a D5 e D6 e i pin di direzione a D4, D7, D8 e D9 come in tabella. Sul TB6612FNG collega STBY a D10 e VCC al 5V di Arduino.
- Collega i motori alle uscite OUT1–OUT2 (A01–A02) e OUT3–OUT4 (B01–B02). Se un motore gira al contrario, scambia i fili o inverti la direzione nel codice.
- Carica il codice qui sotto e fai il primo test con le ruote in aria.
1// L298N ya da TB6612FNG ile iki DC motor / Two DC motors with L298N or TB6612FNG
2const int ENA = 5; // PWMA (PWM pini / PWM pin)
3const int IN1 = 4; // AIN1
4const int IN2 = 7; // AIN2
5const int ENB = 6; // PWMB (PWM pini / PWM pin)
6const int IN3 = 8; // BIN1
7const int IN4 = 9; // BIN2
8const int STBY = 10; // yalnız TB6612FNG / TB6612FNG only
9
10// hiz: -255 (tam geri) ... 255 (tam ileri) / speed: -255 (full reverse) ... 255 (full forward)
11void motorSur(int en, int inA, int inB, int hiz) {
12 hiz = constrain(hiz, -255, 255);
13 if (hiz > 0) {
14 digitalWrite(inA, HIGH);
15 digitalWrite(inB, LOW);
16 } else if (hiz < 0) {
17 digitalWrite(inA, LOW);
18 digitalWrite(inB, HIGH);
19 } else {
20 digitalWrite(inA, LOW); // dur / stop
21 digitalWrite(inB, LOW);
22 }
23 analogWrite(en, abs(hiz));
24}
25
26// Kısa devre freni: iki giriş HIGH / Short brake: both inputs HIGH
27void fren(int en, int inA, int inB) {
28 digitalWrite(inA, HIGH);
29 digitalWrite(inB, HIGH);
30 analogWrite(en, 255);
31}
32
33void setup() {
34 pinMode(ENA, OUTPUT);
35 pinMode(IN1, OUTPUT);
36 pinMode(IN2, OUTPUT);
37 pinMode(ENB, OUTPUT);
38 pinMode(IN3, OUTPUT);
39 pinMode(IN4, OUTPUT);
40 pinMode(STBY, OUTPUT);
41 digitalWrite(STBY, HIGH); // TB6612FNG'yi uyandır / wake up the TB6612FNG
42}
43
44void loop() {
45 motorSur(ENA, IN1, IN2, 180); // ileri / forward
46 motorSur(ENB, IN3, IN4, 180);
47 delay(2000);
48
49 fren(ENA, IN1, IN2); // fren / brake
50 fren(ENB, IN3, IN4);
51 delay(500);
52
53 motorSur(ENA, IN1, IN2, -180); // geri / reverse
54 motorSur(ENB, IN3, IN4, -180);
55 delay(2000);
56
57 motorSur(ENA, IN1, IN2, 180); // yerinde dönüş / spin in place
58 motorSur(ENB, IN3, IN4, -180);
59 delay(1000);
60
61 motorSur(ENA, IN1, IN2, 0); // dur / stop
62 motorSur(ENB, IN3, IN4, 0);
63 delay(1000);
64}Il bello di questo codice è che funziona con lo stesso schema di pin sia con l'L298N sia con il TB6612FNG; la tabella logica dei due driver è quasi identica. Quando uno dei pin di direzione è HIGH e l'altro LOW il motore gira, e il valore PWM (0–255) determina la velocità. Se metti entrambi i pin di direzione a HIGH i morsetti del motore vengono messi in corto e il motore frena con la tensione che genera lui stesso: così il robot si ferma in meno spazio in discesa o ad alta velocità. I pin D5 e D6 dell'Uno generano un PWM di circa 980 Hz; è normale sentire un leggero ronzio dai motori. Con l'L298N a valori PWM molto bassi (sotto circa 60) il motore non gira, perché dopo la perdita nel driver la tensione media rimasta non basta a vincere l'attrito.
ESP32 con TB6612FNG: PWM silenzioso a 20 kHz
Sull'ESP32, usare l'unità PWM hardware LEDC al posto di analogWrite ti permette di scegliere la frequenza. Il TB6612FNG accetta PWM fino a 100 kHz, quindi portando la frequenza a 20 kHz si passa in una zona che l'orecchio umano non sente e il ronzio del motore sparisce del tutto. Il codice seguente compila sia con l'Arduino core 2.x sia con il 3.x; le funzioni LEDC che cambiano tra le versioni sono separate da un blocco di compilazione condizionale. Non dimenticare di collegare il pin VCC del TB6612FNG al pin 3V3 dell'ESP32.
1#include <Arduino.h>
2
3// ESP32 + TB6612FNG pinleri / ESP32 + TB6612FNG pins
4const int PWMA = 25, AIN1 = 26, AIN2 = 27;
5const int PWMB = 13, BIN1 = 33, BIN2 = 32;
6const int STBY = 4;
7
8const int PWM_FREQ = 20000; // 20 kHz: duyulmayan PWM / inaudible PWM
9const int PWM_RES = 8; // 0-255 çözünürlük / 0-255 resolution
10
11void pwmBaslat(int pin, int kanal) {
12#if ESP_ARDUINO_VERSION_MAJOR >= 3
13 ledcAttach(pin, PWM_FREQ, PWM_RES); // core 3.x
14 (void)kanal;
15#else
16 ledcSetup(kanal, PWM_FREQ, PWM_RES); // core 2.x
17 ledcAttachPin(pin, kanal);
18#endif
19}
20
21void pwmYaz(int pin, int kanal, int deger) {
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23 ledcWrite(pin, deger);
24 (void)kanal;
25#else
26 ledcWrite(kanal, deger);
27 (void)pin;
28#endif
29}
30
31// hiz: -255 ... 255 / speed: -255 ... 255
32void motor(int pwmPin, int kanal, int in1, int in2, int hiz) {
33 hiz = constrain(hiz, -255, 255);
34 digitalWrite(in1, hiz > 0 ? HIGH : LOW);
35 digitalWrite(in2, hiz < 0 ? HIGH : LOW);
36 pwmYaz(pwmPin, kanal, abs(hiz));
37}
38
39void setup() {
40 pinMode(AIN1, OUTPUT);
41 pinMode(AIN2, OUTPUT);
42 pinMode(BIN1, OUTPUT);
43 pinMode(BIN2, OUTPUT);
44 pinMode(STBY, OUTPUT);
45 digitalWrite(STBY, HIGH); // sürücüyü etkinleştir / enable the driver
46 pwmBaslat(PWMA, 0);
47 pwmBaslat(PWMB, 1);
48}
49
50void loop() {
51 for (int h = 0; h <= 255; h += 5) { // yumuşak hızlanma / soft acceleration
52 motor(PWMA, 0, AIN1, AIN2, h);
53 motor(PWMB, 1, BIN1, BIN2, h);
54 delay(30);
55 }
56 delay(1500);
57 motor(PWMA, 0, AIN1, AIN2, -200); // geri / reverse
58 motor(PWMB, 1, BIN1, BIN2, -200);
59 delay(1500);
60 motor(PWMA, 0, AIN1, AIN2, 0); // dur / stop
61 motor(PWMB, 1, BIN1, BIN2, 0);
62 delay(1000);
63}Raspberry Pi Pico e MicroPython con TB6612FNG
Tutti i pin GPIO del Pico possono generare PWM hardware e in MicroPython il duty cycle si passa con un numero a 16 bit (0–65535). Nell'esempio seguente la velocità si inserisce in percentuale (da -100 a 100) e la funzione la converte in un valore duty_u16. Poiché GP16 e GP21 stanno in slice PWM diverse, la frequenza dei due motori non si influenza a vicenda. Collega il pin VCC del TB6612FNG al pin 3V3 (OUT) del Pico e il pin VM all'alimentazione motore esterna; alimentare i motori dal pin VSYS del Pico, a causa della corrente limitata della USB, provoca il reset della scheda.
1from machine import Pin, PWM
2import time
3
4stby = Pin(22, Pin.OUT, value=1) # sürücüyü uyandır / wake the driver
5
6pwma = PWM(Pin(16))
7pwma.freq(20000) # 20 kHz sessiz PWM / quiet PWM
8ain1 = Pin(17, Pin.OUT)
9ain2 = Pin(18, Pin.OUT)
10
11pwmb = PWM(Pin(21))
12pwmb.freq(20000)
13bin1 = Pin(19, Pin.OUT)
14bin2 = Pin(20, Pin.OUT)
15
16def motor(pwm, in1, in2, hiz): # hiz: -100 ... 100 / speed in percent
17 hiz = max(-100, min(100, hiz))
18 in1.value(1 if hiz > 0 else 0)
19 in2.value(1 if hiz < 0 else 0)
20 pwm.duty_u16(int(abs(hiz) * 65535 / 100))
21
22while True:
23 motor(pwma, ain1, ain2, 70) # ileri / forward
24 motor(pwmb, bin1, bin2, 70)
25 time.sleep(2)
26 motor(pwma, ain1, ain2, -70) # geri / reverse
27 motor(pwmb, bin1, bin2, -70)
28 time.sleep(2)
29 motor(pwma, ain1, ain2, 0) # dur / stop
30 motor(pwmb, bin1, bin2, 0)
31 time.sleep(1)A4988 per motori passo-passo: limite di corrente e regolazione di Vref
Anche L298N e L293D possono pilotare un passo-passo bipolare con due ponti H, ma non potendo limitare la corrente il motore o resta debole a bassa tensione o si surriscalda ad alta tensione. L'A4988 invece misura continuamente la corrente delle bobine e la mantiene costante (pilotaggio chopper); così con un'alimentazione a 12 V o 24 V puoi pilotare in sicurezza e con molta coppia anche un NEMA 17 da 2,8 V. Il limite di corrente si regola con il piccolo trimmer sulla scheda e la formula è: I_max = Vref / (8 × Rs). Rs è la resistenza di rilevamento della corrente sulla scheda; su molti cloni c'è scritto R100 (0,1 ohm), su altri R068 (0,068 ohm). Per esempio su una scheda da 0,1 ohm, per 1 A serve Vref = 1 × 8 × 0,1 = 0,8 V; per lasciare un margine termico, circa 0,56 V (il 70%) è un buon punto di partenza. L'A4988 si controlla con soli due pin: ogni impulso sul pin STEP è un passo e il pin DIR è la direzione. Con MS1, MS2 e MS3 su LOW funziona a passo intero e un motore da 1,8 gradi fa 200 passi per giro. Ricordati di collegare tra loro SLEEP e RESET e di mettere un condensatore da almeno 100 µF tra VMOT e GND.
1// A4988 ile NEMA 17 step motor / NEMA 17 stepper with A4988
2// MS1-MS3 LOW = tam adım, SLEEP ile RESET birbirine bağlı / MS1-MS3 LOW = full step, SLEEP tied to RESET
3const int DIR_PIN = 2;
4const int STEP_PIN = 3;
5const int ADIM_TUR = 200; // 1,8 derece motor / 1.8 degree motor
6
7void adimAt(int adim, bool yon, unsigned int bekleme) {
8 digitalWrite(DIR_PIN, yon ? HIGH : LOW);
9 for (int i = 0; i < adim; i++) {
10 digitalWrite(STEP_PIN, HIGH);
11 delayMicroseconds(bekleme);
12 digitalWrite(STEP_PIN, LOW);
13 delayMicroseconds(bekleme);
14 }
15}
16
17void setup() {
18 pinMode(DIR_PIN, OUTPUT);
19 pinMode(STEP_PIN, OUTPUT);
20}
21
22void loop() {
23 adimAt(ADIM_TUR, true, 800); // saat yönünde 1 tur / one turn clockwise
24 delay(1000);
25 adimAt(ADIM_TUR, false, 800); // ters yönde 1 tur / one turn counter-clockwise
26 delay(1000);
27}Quale driver per quale progetto?
| Progetto | Driver consigliato | Perché? |
|---|---|---|
| Robot con 2 motori TT (a batteria) | TB6612FNG (L9110S per il budget) | Perdite basse, lunga autonomia, dimensioni ridotte |
| Auto a 4 ruote con Arduino Uno | Shield L293D o L298N | 4 motori con una sola scheda; con l'L298N su ogni lato si collegano 2 motori in parallelo |
| Motoriduttore a 12 V (1–2 A) | L298N (con dissipatore) | Regge alta tensione e corrente; per motori più grandi passa a driver a MOSFET come il BTS7960 |
| Passo-passo NEMA 17 (stampante 3D, CNC, slitta) | A4988 | Limite di corrente e microstepping |
| Passo-passo 28BYJ-48 | Scheda ULN2003 | Motore unipolare, compatibile direttamente con 5 V |
| Mini pompa dell'acqua a 6 V a una direzione | MOSFET a livello logico o L9110S a canale singolo | Se la direzione non cambia, il ponte H è superfluo |
| Pompa reversibile o peristaltica | TB6612FNG | Inversione di direzione e PWM efficiente |
| Qualsiasi progetto DC basato su ESP32 o Pico | TB6612FNG | Piena compatibilità con logica a 3,3 V |
L'esempio della pompa è particolarmente importante: in un impianto di irrigazione la pompa gira sempre nello stesso verso, quindi bastano un MOSFET a canale N e un diodo di ricircolo; trovi questo metodo in uso del MOSFET con Arduino. Nei robot, invece, più bassa è la tensione della batteria, maggiore è il vantaggio del driver a MOSFET: un'auto alimentata con due batterie 18650 va visibilmente più veloce e dura più a lungo con il TB6612FNG rispetto all'L298N.
Idee di progetto con i driver motore
- Robot telecomandato via Bluetooth: pilota due motori dal telefono con TB6612FNG o L298N; i passaggi sono in costruzione di un robot auto.
- Robot che evita gli ostacoli: un veicolo che rileva l'ostacolo davanti con l'HC-SR04 e cambia direzione; dettagli in robot che evita gli ostacoli.
- Robot segui-linea: in questo progetto che richiede una risposta PWM rapida l'efficienza del TB6612FNG fa la differenza; dai un'occhiata a robot segui-linea.
- Irrigazione automatica: quando l'umidità del terreno cala, avvia la mini pompa; i collegamenti di alimentazione sono spiegati in mini pompa dell'acqua.
- Inseguitore solare: orienta il pannello verso la luce con un passo-passo o un motoriduttore DC; guarda inseguitore solare.
- Posizionamento preciso: per una slitta per fotocamera o un piatto rotante con piccoli angoli puoi partire dal motore passo-passo 28BYJ-48 e passare poi ad A4988 e NEMA 17.
Errori comuni e soluzioni
| Problema | Causa probabile | Soluzione |
|---|---|---|
| Arduino si resetta quando il motore gira | Il motore è alimentato dal 5V di Arduino o l'alimentazione è debole | Usa un'alimentazione motore separata, unisci i GND, aggiungi un condensatore da 100–470 µF all'alimentazione |
| I motori non reagiscono | Manca la massa comune o STBY è LOW sul TB6612FNG | Unisci i GND, porta il pin STBY a HIGH |
| La velocità non cambia, il motore è sempre al massimo | Jumper ENA/ENB inserito sull'L298N | Togli il jumper, collega ENA/ENB a un pin PWM |
| Il motore con l'L298N è lento e debole | Perdita di 2–3 V nel driver | Aumenta la tensione di alimentazione o passa al TB6612FNG |
| Il motore emette un fischio acuto | Frequenza PWM in zona udibile | Porta il PWM a 20 kHz su ESP32 o Pico |
| Il passo-passo vibra ma non gira | Coppie di bobine scambiate o Vref troppo basso | Trova le coppie di bobine con il multimetro, regola Vref con la formula |
| Il driver si scalda molto e si spegne | La corrente di stallo del motore supera il limite del driver | Scegli un driver più potente, aggiungi un dissipatore, non forzare il motore |
Scegliere il driver motore giusto significa conoscere la corrente del motore, la tensione di alimentazione e il livello logico della scheda. Con questi tre dati le tabelle qui sopra ti portano alla scheda giusta in pochi secondi; e ora sai anche a cosa può servire quel vecchio L298N che aspetta nel cassetto. Nell'app BlueGrays trovi, con schemi dei circuiti e codici pronti, i progetti con auto Bluetooth con L298N, robot che evita gli ostacoli, passo-passo e irrigazione intelligente, per iniziare a costruire subito.
Domande frequenti
È meglio L298N o TB6612FNG?
Per motori a batteria che assorbono meno di 1 A il TB6612FNG è migliore: grazie ai MOSFET perde solo circa 0,5 V e quasi non si scalda. L'L298N si preferisce sopra i 13,5 V e per motori che richiedono 1–2 A per canale. In breve: TB6612FNG per i piccoli robot, L298N per motori più grandi a 12–24 V.
Perché l'L298N si scalda così tanto?
Poiché l'L298N usa transistor bipolari, al passaggio della corrente perde circa 2–3 V e questa perdita diventa calore. A 1 A il driver produce circa 2 W di calore; per questo arriva con un grande dissipatore. Per ridurre il riscaldamento puoi tenere bassa la corrente o passare a un driver a MOSFET.
Posso usare l'L298N con l'ESP32?
Sì, poiché gli ingressi dell'L298N accettano come livello alto almeno 2,3 V, il segnale a 3,3 V dell'ESP32 nella maggior parte dei casi funziona. La parte logica del modulo deve essere alimentata a 5 V e i GND di ESP32 e driver devono essere sempre uniti. In un nuovo progetto, però, il TB6612FNG, pienamente compatibile con 3,3 V, è una scelta più sicura.
Quanti ampere eroga l'L293D?
L'L293D eroga 600 mA continui e 1,2 A di picco per canale; ha due canali. Questi valori bastano per piccoli motori giocattolo e robot leggeri, ma con motori la cui corrente di stallo supera 1 A l'integrato si scalda ed entra in protezione termica. Per correnti più alte conviene pensare a L298N o TB6612FNG.
Quale driver usare per un motore passo-passo?
Per passo-passo bipolari a 4 fili come i NEMA 17 si deve usare l'A4988 o un driver simile a controllo di corrente: puoi regolare il limite di corrente con Vref e usare il microstepping. Per motori unipolari a 5 fili come il 28BYJ-48 la soluzione più semplice è la scheda ULN2003. L'L298N può pilotare un passo-passo bipolare, ma non limitando la corrente è poco efficiente.
Serve un driver motore per una pompa dell'acqua?
Se la pompa deve girare in una sola direzione non serve un driver a ponte H: bastano un MOSFET a livello logico, un diodo e una resistenza. Se vuoi invertire la pompa o regolarne la velocità con il PWM, puoi usare un canale di un driver come L9110S o TB6612FNG. In ogni caso la pompa va alimentata da un alimentatore separato, non dal pin di Arduino.
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.

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

Costruzione del servomotore a 360 gradi dal motore passo-passo
Insegna a un normale motore passo-passo ad andare all'angolo che vuoi, lungo tutto il giro.

Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

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.
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

