Controllare un motore con Arduino sembra semplice finché non si passa dal LED al carico reale. Nel mondo dell’arduino motor, il vero problema non è far partire il rotore, ma farlo in modo stabile, con la giusta corrente e senza stressare la scheda. Qui chiarisco quale motore scegliere, quale elettronica interporre e come scrivere un controllo pulito per piccoli progetti, robot e automazioni hobbistiche.
Le decisioni giuste sono motore, driver e alimentazione
- Un Arduino comanda il motore, ma quasi mai lo alimenta direttamente.
- Per un motore DC servono spesso transistor o H-bridge; per servo e stepper servono librerie e hardware diversi.
- Sul classico UNO R3 hai 6 uscite PWM, utili per regolare la velocità.
-
analogWrite()lavora su una scala 0-255 sui board Arduino tradizionali. - Un driver ben scelto vale più di uno sketch complicato.
Capire quale motore ti serve davvero
Io parto sempre da una distinzione netta: un motore DC gira, un servo si posiziona, uno stepper avanza per passi. Se confondi questi tre mondi, finisci a comprare componenti sbagliati o a scrivere codice che non può funzionare come immagini. Il primo passo, quindi, non è il cablaggio: è la scelta del motore in base al movimento che vuoi ottenere.
| Tipo di motore | Quando conviene | Punto forte | Limite pratico |
|---|---|---|---|
| DC brushless o brushed, se pilotato con il driver giusto | Ruote, ventole, nastri, meccanismi che devono ruotare in continuo | È semplice da controllare in velocità e molto diffuso nei progetti hobbistici | Da solo non ti dà la posizione; per invertire il verso serve elettronica adatta |
| Servo | Bracci leggeri, timoni, pan/tilt, comandi angolari | Si porta rapidamente a un angolo preciso, spesso in un range di 0-180° | Non è pensato per rotazioni continue nei modelli standard |
| Stepper | Assi, piccoli plotter, dispenser, posizionamento ripetibile | Avanza a passi controllati e rende il movimento prevedibile | Richiede hardware adeguato e, nei fatti, un po’ più di cura nell’alimentazione |
Questa scelta ti evita gran parte dei problemi a valle. Se il tuo obiettivo è solo ruotare ruote o ventole, la strada è diversa da quella di un braccio robotico o di un asse lineare. Una volta chiarito il tipo di motore, il passo successivo è capire quali componenti servono davvero sul banco di lavoro.
Cosa serve per non bruciare il progetto
La regola pratica è semplice: Arduino decide, il driver eroga corrente, l’alimentazione esterna tiene in piedi il carico. Su un UNO R3 hai 14 pin digitali e 6 uscite PWM, quindi hai spazio per comandare più segnali, ma non per alimentare un motore direttamente. Il codice può essere perfetto, ma se la parte di potenza è debole il progetto resta fragile.- Scheda Arduino, che genera i segnali di comando.
- Driver o transistor, che fanno da interfaccia tra microcontrollore e motore.
- Alimentazione esterna, dimensionata sul motore e non sulla scheda.
- Massa comune, indispensabile per far “parlare” correttamente logica e potenza.
- Eventuali sensori, come encoder o potenziometri, se vuoi più precisione.
Un altro dettaglio utile è la scala del PWM: con analogWrite() lavori normalmente su valori da 0 a 255, quindi stai regolando il duty cycle, non inviando una tensione analogica continua. In pratica, il microcontrollore accende e spegne il segnale molto velocemente, e il motore interpreta quel ritmo come una velocità media. Quando questi elementi sono chiari, il cablaggio diventa molto più lineare.
Collegare un motore DC con transistor o driver H-bridge
Per un piccolo motore DC ci sono due strade comuni. Se ti basta accensione, spegnimento e una sola direzione, un transistor usato come interruttore può bastare; se vuoi anche inversione di marcia, serve un H-bridge o una scheda motori. La differenza pratica è questa: il transistor semplifica, l’H-bridge rende il controllo più completo.
- Alimenta il motore o il driver con una sorgente esterna adatta al carico.
- Collega la massa dell’alimentatore e quella di Arduino in comune.
- Usa un pin PWM per la velocità, se il driver lo supporta.
- Usa due pin logici per stabilire il verso di rotazione, quando lavori con un H-bridge.
- Fai il primo test a duty cycle basso, non a potenza piena.
Se vuoi una soluzione più pronta, l’Arduino Motor Shield Rev3 è comodo perché si basa su un L298, un dual full-bridge driver pensato per carichi induttivi. In pratica permette di pilotare due motori DC in modo indipendente e offre anche la lettura dell’assorbimento di corrente, che nei prototipi è più utile di quanto sembri. Io lo considero valido quando voglio ridurre il tempo di montaggio e avere un controllo più ordinato del cablaggio.
Con il cablaggio impostato, il codice diventa il pezzo più pulito del progetto.
Gestire velocità e direzione con il PWM
Il PWM è la parte che spesso crea confusione, ma in realtà è solo un segnale acceso-spento molto veloce con un rapporto di duty cycle variabile.analogWrite() usa una risoluzione a 8 bit sui board classici, quindi i valori vanno da 0 a 255. Su alcune schede più recenti la risoluzione si può modificare, ma per la maggior parte dei progetti con Arduino la scala 0-255 resta il riferimento più immediato.
const int ENA = 5; // PWM
const int IN1 = 8;
const int IN2 = 9;
void setup() {
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
}
void loop() {
// Avanti
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
analogWrite(ENA, 180); // circa 70% su scala 0-255
delay(2000);
// Stop
analogWrite(ENA, 0);
delay(1000);
// Indietro
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
analogWrite(ENA, 180);
delay(2000);
analogWrite(ENA, 0);
delay(1000);
}In questo schema il pin PWM regola la velocità, mentre i due pin direzionali decidono il verso. Se il tuo driver usa solo un transistor, la parte di inversione scompare e lo sketch si semplifica ancora di più. Se invece il motore deve lavorare in modo reversibile, questa logica è la base corretta da cui partire. Quando hai chiaro il comando in PWM, il confronto con servo e stepper diventa molto più semplice.
Servo e stepper non sono la stessa cosa
Qui vedo spesso il primo equivoco: si cerca di comandare un servo come se fosse un DC, oppure uno stepper come se bastasse un semplice segnale PWM. La realtà è diversa. Il servo standard è nato per un posizionamento angolare rapido, mentre lo stepper è pensato per muoversi per passi e conservare una logica di posizione molto più precisa.
| Motore | Quando lo scelgo | Libreria o supporto utile | Attenzione pratica |
|---|---|---|---|
| Servo | Quando mi serve un angolo preciso e limitato | Servo Library | Nei modelli standard il range tipico è intorno a 0-180° |
| Stepper | Quando mi serve un movimento ripetibile e controllato | Stepper library o driver dedicato | Serve l’hardware appropriato e una cura maggiore nella potenza disponibile |
La Servo Library è la scelta naturale per il servo standard, mentre la libreria Stepper gestisce motori unipolari o bipolari, ma richiede comunque il supporto elettrico giusto. In pratica, se devi far ruotare un braccio di pochi gradi, il servo è spesso la soluzione più pulita; se devi posizionare un carrello, uno stepper ti dà più controllo. Capito questo, restano gli errori che fanno perdere più tempo di tutti.
Gli errori che vedo più spesso nei primi prototipi
Quando un motore “non va”, quasi mai il problema è il codice in sé. Molto più spesso c’è un errore di architettura: alimentazione sbagliata, cablaggio incompleto o aspettative irrealistiche sul carico. Io controllo sempre questi punti prima di cercare il colpevole nello sketch.
- Alimentare il motore dal 5V di Arduino: è una scorciatoia che regge solo esperimenti molto piccoli, non un progetto serio.
- Dimenticare la massa comune: senza riferimento condiviso, il segnale di comando perde affidabilità.
- Usare il driver sbagliato: un semplice transistor non sostituisce un H-bridge quando serve l’inversione di marcia.
- Ignorare la corrente di spunto: il momento più duro non è sempre il funzionamento continuo, ma l’avvio sotto carico.
- Testare solo a vuoto: un motore che gira bene senza carico può crollare appena incontra resistenza.
- Sottovalutare il calore: driver, cavi e alimentatore vanno verificati anche dopo alcuni minuti di lavoro.
Se hai un shield che misura l’assorbimento, sfruttalo: è una delle informazioni più utili per capire se il motore sta lavorando entro limiti sani. A quel punto la scelta non è più solo tecnica, ma anche di architettura del progetto.
Il dettaglio che separa un prototipo curioso da un sistema affidabile
Io partirei sempre dalla potenza, non dal codice. Se il motore è piccolo e il comportamento è semplice, un driver elementare basta; se servono coppia, inversione o precisione, conviene investire subito nella parte di potenza giusta. Separare alimentazione logica e alimentazione motore, poi, è una scelta che paga quasi sempre, perché rende il sistema più leggibile e meno instabile.
Per un primo test serio, uso un solo motore, duty cycle basso, cavi corti e una verifica del riscaldamento dopo pochi minuti. Se tutto resta pulito, solo allora aggiungo sensori, encoder o controllo remoto. È questo approccio che trasforma un semplice esperimento in un progetto davvero replicabile.
