Guide · 11 min di lettura

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.

Modulo driver motore L298N con dissipatore
Modulo driver motore L298N: due canali, fino a 2 A, grande dissipatore in alluminio e regolatore da 5 V sulla scheda.

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

CaratteristicaL298NL293DL9110STB6612FNGA4988
Tipo di motore2 DC o 1 passo-passo bipolare2 DC o 1 passo-passo bipolare2 DC2 DC o 1 passo-passo bipolare1 passo-passo bipolare
Tensione motore5–35 V (modulo)4,5–36 V2,5–12 V4,5–13,5 V (massimo assoluto 15 V)8–35 V
Corrente continua (per canale)2 A (con dissipatore)0,6 Acirca 0,8 A1,2 Acirca 1 A senza dissipatore, 2 A con raffreddamento
Corrente di picco3 A1,2 Acirca 1,5 A3,2 A2 A
Tecnologia degli interruttoriTransistor bipolareTransistor bipolareTransistor (bassa saturazione)MOSFETMOSFET + controllo di corrente
Caduta di tensionecirca 2–3 Vcirca 1,8–2,6 Vcirca 1 Vcirca 0,5 V (a 1 A)Controllato in corrente, non è un problema
EfficienzaBassaBassaMediaAltaAlta
Alimentazione logica5 V (regolatore sul modulo)4,5–7 V (VCC1)In comune con l'alimentazione motore2,7–5,5 V (VCC)3–5,5 V (VDD)
Compatibilità segnale 3,3 VDi solito funzionaGli ingressi lo accettano, alimentazione logica a 5 VPienaPienaPiena
Prezzo (relativo)BassoBassoMolto bassoMedioBasso

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:

DriverCaduta di tensione tipicaTensione rimasta al motorePotenza dissipata nel driverEfficienza approssimativa
L298N1,8 V4,2 V1,08 W70%
L293D2,0 V4,0 V1,2 W67%
L9110S0,8 V5,2 V0,48 W87%
TB6612FNG0,3 V5,7 V0,18 W95%
Se devi usare l'L298N, scegli un'alimentazione motore di circa 2 V superiore alla tensione nominale del motore. Per esempio 8 V per motori da 6 V e circa 14 V per motori da 12 V compensano la perdita nel driver. Con il TB6612FNG questa correzione non serve.

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

FunzionePin L298NPin TB6612FNGArduino UnoESP32Raspberry Pi Pico
Velocità motore A (PWM)ENAPWMAD5GPIO 25GP16
Direzione motore A 1IN1AIN1D4GPIO 26GP17
Direzione motore A 2IN2AIN2D7GPIO 27GP18
Velocità motore B (PWM)ENBPWMBD6GPIO 13GP21
Direzione motore B 1IN3BIN1D8GPIO 33GP19
Direzione motore B 2IN4BIN2D9GPIO 32GP20
Standby / abilitazioneAssenteSTBYD10GPIO 4GP22
Alimentazione logica+5V (uscita regolatore)VCC5V3V33V3 (OUT)
Alimentazione motore+12VVMAlimentatore esternoAlimentatore esternoAlimentatore esterno
MassaGNDGNDGNDGNDGND
L'errore più comune è non collegare il GND dell'alimentazione dei motori al GND della scheda; senza massa in comune i segnali di direzione e PWM perdono significato. Il secondo grande errore è lasciare inserito il jumper 5V-EN sul modulo L298N con alimentazione sopra i 12 V: il regolatore sulla scheda può surriscaldarsi e bruciare. Se superi i 12 V, togli il jumper e alimenta il pin +5V con il 5V di Arduino. E non alimentare mai i motori dal pin 5V di Arduino.

Passo passo: pilotare due motori DC con Arduino

  1. 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.
  2. Collega il polo negativo dell'alimentazione sia al GND del driver sia al GND di Arduino.
  3. Se usi l'L298N, togli i jumper su ENA ed ENB; altrimenti non puoi regolare la velocità e il motore gira sempre al massimo.
  4. 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.
  5. 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.
  6. Carica il codice qui sotto e fai il primo test con le ruote in aria.
C++ (Arduino IDE)
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.

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

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

C++ (Arduino IDE)
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}
Non collegare né scollegare mai il cavo del motore passo-passo mentre l'A4988 è alimentato: l'impulso di tensione generato dalla bobina può bruciare il driver all'istante. Inoltre i motori unipolari a 5 fili come il 28BYJ-48 non si pilotano direttamente con l'A4988; per quelli usa la scheda ULN2003 fornita insieme.

Quale driver per quale progetto?

ProgettoDriver consigliatoPerché?
Robot con 2 motori TT (a batteria)TB6612FNG (L9110S per il budget)Perdite basse, lunga autonomia, dimensioni ridotte
Auto a 4 ruote con Arduino UnoShield L293D o L298N4 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)A4988Limite di corrente e microstepping
Passo-passo 28BYJ-48Scheda ULN2003Motore unipolare, compatibile direttamente con 5 V
Mini pompa dell'acqua a 6 V a una direzioneMOSFET a livello logico o L9110S a canale singoloSe la direzione non cambia, il ponte H è superfluo
Pompa reversibile o peristalticaTB6612FNGInversione di direzione e PWM efficiente
Qualsiasi progetto DC basato su ESP32 o PicoTB6612FNGPiena 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

ProblemaCausa probabileSoluzione
Arduino si resetta quando il motore giraIl motore è alimentato dal 5V di Arduino o l'alimentazione è deboleUsa un'alimentazione motore separata, unisci i GND, aggiungi un condensatore da 100–470 µF all'alimentazione
I motori non reagisconoManca la massa comune o STBY è LOW sul TB6612FNGUnisci i GND, porta il pin STBY a HIGH
La velocità non cambia, il motore è sempre al massimoJumper ENA/ENB inserito sull'L298NTogli il jumper, collega ENA/ENB a un pin PWM
Il motore con l'L298N è lento e debolePerdita di 2–3 V nel driverAumenta la tensione di alimentazione o passa al TB6612FNG
Il motore emette un fischio acutoFrequenza PWM in zona udibilePorta il PWM a 20 kHz su ESP32 o Pico
Il passo-passo vibra ma non giraCoppie di bobine scambiate o Vref troppo bassoTrova le coppie di bobine con il multimetro, regola Vref con la formula
Il driver si scalda molto e si spegneLa corrente di stallo del motore supera il limite del driverScegli un driver più potente, aggiungi un dissipatore, non forzare il motore
Prima di iniziare a lavorare con un nuovo motore, misura con il multimetro la resistenza della bobina e stima la corrente di stallo con I = V / R. Per esempio un motore da 6 V con 5 ohm di resistenza, quando si blocca, assorbe circa 1,2 A; in questo caso il limite di 0,6 A dell'L293D è insufficiente, mentre TB6612FNG o L298N vanno bene.

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.

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
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
Costruzione del servomotore a 360 gradi dal motore passo-passo
AR-68Intermedio
Premium

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.

4.5(22)
33
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

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

5.0(42)
57
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