Il modulo ULN2003 con Arduino è una delle soluzioni più semplici per comandare un piccolo motore passo-passo senza entrare subito in driver più complessi. Qui trovi come lavora il chip, come collegare il classico 28BYJ-48, quale alimentazione usare davvero e quali dettagli fanno la differenza tra un prototipo che vibra e uno che gira con continuità.
In breve, è una soluzione semplice ma con limiti precisi
- ULN2003 è un array di 7 canali Darlington pensato per pilotare carichi induttivi dal lato massa.
- Con Arduino funziona bene soprattutto con motori passo-passo unipolari a 5 V, come il 28BYJ-48.
- Il motore va alimentato con una sorgente esterna stabile; i pin di Arduino devono inviare solo i segnali di controllo.
- Il chip regge correnti elevate per singolo canale, ma la caduta di tensione interna non è trascurabile.
- Per motori bipolari o carichi più impegnativi conviene passare a driver a corrente regolata.
Che cosa fa davvero il ULN2003
Il ULN2003 non è un “motore” né un driver intelligente: è uno stadio di potenza. In pratica Arduino dice al chip quando attivare una bobina, e il chip porta a massa la corrente del carico. Questa logica low-side, cioè lato massa, è semplice da gestire e molto utile con bobine, relè e piccoli attuatori. Una coppia Darlington mette due transistor in cascata per aumentare il guadagno di corrente: il vantaggio è che Arduino deve fornire pochissima corrente in ingresso, il compromesso è una caduta di tensione più alta rispetto a soluzioni moderne a MOSFET.
La scheda TI indica 7 canali, uscita fino a 50 V e corrente fino a 500 mA per singolo canale. Gli ingressi sono adatti alla logica 5 V e, nei casi corretti, anche a quella a 3,3 V. C’è anche un dettaglio importante: i diodi di clamp sono integrati, quindi il chip è già pensato per gestire il ritorno di energia tipico dei carichi induttivi. Io leggo tutto questo così: è un componente robusto, ma nasce per semplicità e compatibilità, non per spremere il motore al massimo dell’efficienza.
| Parametro | Valore utile | Perché conta |
|---|---|---|
| Canali | 7 | Ne usi 4 per un piccolo stepper unipolare, gli altri restano liberi. |
| Corrente per canale | Fino a 500 mA | È un limite massimo, non un obiettivo da inseguire per forza. |
| Tensione di uscita | Fino a 50 V | Molto più di quanto serva ai comuni progetti con Arduino. |
| Tipo di uscita | Open collector, sink | Il chip commuta la massa del carico, non il positivo. |
| Protezione | Diodi di clamp integrati | Aiutano con le sovratensioni generate dalle bobine. |
| Compatibilità logica | 5 V e 3,3 V | Comodo anche se il progetto poi si sposta su altri microcontrollori. |
Capito il ruolo del chip, il passo successivo è il cablaggio corretto: lì nascono quasi tutti i problemi reali.
Collegamenti corretti e alimentazione esterna
La regola più importante è semplice: alimenta il motore con una sorgente esterna e tieni la massa in comune con Arduino. I pin digitali della scheda servono a comandare gli ingressi del ULN2003, non a fornire la corrente delle bobine. Su un Arduino UNO i pin sono fatti per segnali, non per alimentare un motore passo-passo in modo diretto.
| Collegamento | Dove va | Perché conta |
|---|---|---|
| IN1-IN4 | Quattro pin digitali di Arduino, per esempio 8, 9, 10 e 11 | Inviano la sequenza di eccitazione delle bobine. |
| VCC del modulo | Alimentazione 5 V esterna | È la parte di potenza, non va confusa con l’alimentazione logica. |
| GND del modulo | Massa comune con Arduino e alimentatore | Senza massa comune i livelli logici diventano inaffidabili. |
| Connettore motore | Motore unipolare compatibile, come il 28BYJ-48 | Il colore dei fili può cambiare da un produttore all’altro. |
Se il tuo modulo espone anche un pin COM separato, quello serve per i diodi di ricircolo e va collegato come previsto dal costruttore; su molte schedine già pronte per il 28BYJ-48 il collegamento è già gestito sul PCB. In pratica, il cablaggio giusto è più importante di quanto sembri: un alimentatore da banco o un piccolo 5 V ben filtrato spesso fa la differenza tra un motore che perde passi e uno che si comporta bene. Io aggiungo quasi sempre un condensatore elettrolitico da 100-470 µF vicino al modulo, soprattutto se i cavi non sono cortissimi.
Una volta chiaro l’hardware, il codice diventa molto più lineare.
Come far muovere il motore con un codice minimo
Per il primo test io resto su un approccio essenziale. La libreria Stepper di Arduino basta per iniziare con un motore unipolare: imposti i pin, dai una velocità prudente e poi fai ruotare il motore avanti e indietro. Se il progetto crescerà, potrai passare a una gestione più raffinata; qui, però, l’obiettivo è ottenere un movimento chiaro e ripetibile.
#include
const int passiPerGiro = 2048; // punto di partenza tipico, da calibrare sul tuo motore
Stepper motore(passiPerGiro, 8, 10, 9, 11);
void setup() {
motore.setSpeed(10); // giri al minuto
}
void loop() {
motore.step(passiPerGiro);
delay(500);
motore.step(-passiPerGiro);
delay(500);
} Ci sono due dettagli che vedo spesso ignorati. Il primo è l’ordine dei pin nel costruttore: se il motore vibra ma non ruota, quasi sempre la sequenza delle bobine è sbagliata. Il secondo è la taratura dei passi per giro: sul 28BYJ-48 il valore di partenza comunemente usato è 2048, ma in pratica può servire una piccola calibrazione. Io parto sempre basso con la velocità e la aumento a piccoli gradini, perché con questo tipo di motore il carico meccanico conta molto più di quanto sembri.
A questo punto vale la pena capire quando questa soluzione è davvero adatta e quando invece è meglio cambiare architettura.
Dove il modulo rende bene e dove no
Il ULN2003 dà il meglio di sé quando hai un motore piccolo, una meccanica leggera e vuoi una soluzione economica e comprensibile. È perfetto per dimostrazioni, piccoli movimenti ripetitivi, indicatori, sportelli leggeri, manopole e meccanismi da banco. Lo tengo volentieri anche nei progetti didattici, perché fa capire bene la separazione tra logica e potenza senza costringerti a tarare una corrente di fase.
| Scenario | ULN2003 | Alternativa migliore | Motivo |
|---|---|---|---|
| 28BYJ-48 e piccoli attuatori | Ottimo | Non necessario | Semplice, economico e sufficiente per carichi leggeri. |
| Motori bipolari tipo NEMA17 | Non adatto | A4988, DRV8825, TMC2209 o simili | Serve un driver a corrente regolata e una logica diversa. |
| Progetti a batteria | Accettabile solo se il consumo non è critico | Driver più efficienti | La caduta di tensione dei Darlington pesa sull’efficienza. |
| Movimenti silenziosi e fluidi | Limitato | Driver con micropassi | I micropassi suddividono il passo e riducono vibrazioni e rumore. |
Qui il limite non è solo la corrente nominale. La caduta di tensione interna del Darlington riduce la tensione effettiva sulle bobine e aumenta la dissipazione termica. Tradotto in pratica: il motore gira, ma non va trattato come se avesse un driver moderno con controllo di corrente. Io lo uso senza problemi per piccoli meccanismi; se devo chiedere coppia vera, velocità alta o precisione più pulita, passo a un’altra architettura. Prima di farlo, però, conviene eliminare gli errori tipici che fanno perdere tempo al primo collaudo.
Gli errori che vedo più spesso nei primi test
- Alimentare il motore direttamente dai pin di Arduino invece che dal modulo e da una sorgente esterna.
- Dimenticare la massa comune tra alimentatore, ULN2003 e scheda di controllo.
- Scambiare l’ordine dei fili o la sequenza degli ingressi IN1-IN4.
- Provare subito velocità troppo alte e concludere che il motore “non funziona”.
- Ignorare il fatto che una bobina sotto carico resta calda anche quando il motore è fermo.
Il sintomo più ingannevole è questo: il motore vibra, scatta, fa rumore, ma non ruota davvero. In molti casi il chip è innocente; il problema è quasi sempre il cablaggio o la sequenza di eccitazione. Anche l’alimentazione conta moltissimo: un 5 V debole o rumoroso crea reset, passi persi e comportamenti casuali che sembrano difetti del codice ma non lo sono. Se eviti questi inciampi, restano pochi accorgimenti pratici che migliorano subito l’affidabilità.
Due accorgimenti che fanno la differenza al primo collaudo
Se dovessi ridurre tutto a due consigli, direi questo: alimentazione separata e velocità prudente. Un alimentatore 5 V stabile, con massa comune e cavi corti, risolve più problemi di quanto faccia cambiare sketch. Il condensatore da 100-470 µF vicino al modulo aiuta a reggere i picchi quando le bobine commutano, soprattutto se il motore parte e si ferma di continuo.
- Parti con pochi giri al minuto e aumenta solo quando il motore resta regolare sotto il tuo carico reale.
- Se il progetto deve muovere qualcosa di pesante, non cercare di “compensare” con più corrente sul ULN2003: cambia motore o driver.
- Per maggiore precisione meccanica, usa finecorsa o riferimenti di zero; contare i passi senza un punto di homing lascia sempre un margine di errore.
- Se il cablaggio è lungo o l’ambiente è rumoroso, tieni separati i percorsi di potenza e segnale per quanto possibile.
Per me il ULN2003 resta un ottimo punto di ingresso nel mondo dei motori passo-passo: costa poco, si capisce in fretta e insegna bene il rapporto tra logica e potenza. Se però il progetto deve andare oltre il banco di prova, la scelta giusta non è forzare il modulo, ma passare a un sistema di pilotaggio più adatto al carico reale.
