Un motore DC a spazzole è il contrario di un servo: non vuole un comando, vuole energia. La tensione decide quanto veloce gira, la polarità decide in che verso, la corrente è la coppia che stai chiedendo. Il tuo compito è dosare quell'energia — e per farlo serve un driver tra Arduino e il motore.
Dentro un motore DC a spazzole ci sono due relazioni quasi lineari, ed è tutto quello che serve sapere per controllarlo. La prima: a vuoto, la velocità è proporzionale alla tensione applicata — metà tensione, circa metà giri. La seconda: la coppia all'albero è proporzionale alla corrente che attraversa l'avvolgimento.
Le due si incontrano nella curva qui sotto. Più carico metti sull'albero, più il motore rallenta e più corrente assorbe, fino allo stallo: albero fermo, coppia massima, corrente massima. È la corrente di stallo — non quella a vuoto scritta in grande sulla scheda — che dimensiona driver, fusibile e cavi, perché il motore la richiede per un istante a ogni avvio e ogni inversione.
Per invertire un motore DC basta invertire la polarità ai suoi capi. Il circuito che lo fa elettronicamente si chiama ponte H, per la forma: due rami verticali, ciascuno con un interruttore verso il positivo e uno verso la massa, e il motore a fare da trattino orizzontale. Chiudi una coppia diagonale e la corrente attraversa il motore da sinistra a destra; chiudi l'altra e lo attraversa al contrario.
Oltre ad avanti e indietro, un ponte H sa fare altre due cose, e la differenza conta quando un robot deve fermarsi. In frenata i due interruttori bassi (o i due alti) sono chiusi insieme: i capi del motore sono in corto, la forza controelettromotrice genera una corrente che si oppone al moto e l'albero si ferma in pochi giri. In ruota libera tutto è aperto e il motore rallenta solo per attrito. Ecco come si traducono gli stati su un L298N, il driver didattico più diffuso:
| ENA | IN1 | IN2 | Motore | Ponte |
|---|---|---|---|---|
| PWM | HIGH | LOW | Avanti, velocità = duty cycle | S1 + S4 |
| PWM | LOW | HIGH | Indietro, velocità = duty cycle | S2 + S3 |
| HIGH | LOW | LOW | Frenata rapida | S3 + S4 |
| HIGH | HIGH | HIGH | Frenata rapida | S1 + S2 |
| LOW | × | × | Ruota libera (folle) | tutto aperto |
Abbassare la tensione con una resistenza in serie sprecherebbe in calore tutta l'energia tolta al motore. Il driver fa una cosa più furba: collega e scollega la batteria piena a frequenza alta. Il motore, che per inerzia meccanica e induttanza dell'avvolgimento non riesce a seguire le singole commutazioni, risponde alla tensione media: la frazione di tempo in cui l'interruttore è chiuso — il duty cycle — moltiplicata per la tensione di batteria.
Attenzione a non confonderlo con il PWM di un servo. Lì conta la durata assoluta dell'impulso e la trama è fissa a 50 Hz; qui conta solo la percentuale, e la frequenza va scelta alta — da qualche kHz a 20 kHz — perché il motore non ronzi e la corrente resti regolare.
Un pin di Arduino eroga una ventina di milliampere; anche un piccolo motoriduttore ne chiede centinaia, e diversi ampere quando parte o si blocca. In più il motore, quando gira trascinato o viene spento di colpo, rimanda indietro picchi di tensione che un microcontrollore non sopporta. Il driver sta in mezzo: prende i segnali logici da Arduino e la potenza dalla batteria.
Per sceglierlo servono due numeri. La tensione della batteria, con margine — una 12 V piena supera i 13 V. E la corrente di stallo del motore: un motoriduttore goBILDA Yellow Jacket a 12 V assorbe circa 0,25 A a vuoto e supera i 9 A in stallo. Un driver da 2 A lo farebbe girare libero sul banco e si spegnerebbe — o si brucerebbe — al primo carico vero.
| Tipo di driver | Corrente tipica | Ingressi | Quando usarlo |
|---|---|---|---|
| Ponte H bipolare (L298N) | 2 A per canale | ENA + IN1/IN2 | Motorini per esperimenti. Perde 2–4 V nel ponte e scalda: poco adatto ai motoriduttori da 12 V |
| Driver a MOSFET | 10 – 30 A | PWM + DIR | La scelta normale per motoriduttori da 12 V: caduta trascurabile, PWM fino a 20 kHz |
| Controller con ingresso servo | fino a 40 A+ | Impulso 1–2 ms a 50 Hz | Si comanda come un servo a rotazione continua: 1,5 ms fermo, 1,0 e 2,0 ms massima velocità nei due versi |
| Controller con encoder (RoboClaw) | 2 × 30 A | Seriale, USB, RC, analogico | Quando servono velocità e posizione garantite: legge gli encoder e chiude l'anello PID a bordo |
Il controller con ingresso servo è la scorciatoia più sottovalutata: usa esattamente il segnale descritto nella guida Come controllare un servomotore, quindi lo sketch si scrive con la libreria Servo e writeMicroseconds(), senza pensare a timer, frequenze o pin di direzione.
Il cablaggio di un motore DC separa nettamente due mondi. Il circuito di potenza — batteria, driver, motore — porta ampere e va fatto con cavi di sezione adeguata, corti, con un fusibile vicino alla batteria. Il circuito di segnale — Arduino verso il driver — porta milliampere e può essere fatto con normali jumper.
Il punto in cui i due mondi si toccano è la massa: il GND di Arduino va collegato al GND del driver, altrimenti i livelli logici HIGH e LOW non hanno riferimento. Arduino però va alimentato a parte, da USB o da un regolatore dedicato: i picchi di corrente del motore fanno oscillare la tensione di batteria quanto basta per resettarlo.
Con un driver PWM + DIR tutto si riduce a una funzione che accetta una velocità con segno, da −255 a +255: il segno sceglie il verso, il modulo diventa il duty cycle.
// Motore DC su driver PWM + DIR, batteria 12 V separata,
// GND del driver collegato al GND di Arduino.
const int PIN_PWM = 5; // uscita PWM
const int PIN_DIR = 4;
void setup() {
pinMode(PIN_PWM, OUTPUT);
pinMode(PIN_DIR, OUTPUT);
}
// velocita: -255 (indietro tutto) ... 0 (fermo) ... +255 (avanti tutto)
void motore(int velocita) {
velocita = constrain(velocita, -255, 255);
digitalWrite(PIN_DIR, velocita >= 0 ? HIGH : LOW);
analogWrite(PIN_PWM, abs(velocita));
}
void loop() {
motore(128); delay(2000); // avanti a meta
motore(0); delay(500);
motore(-128); delay(2000); // indietro a meta
motore(0); delay(500);
}
Con un L298N gli ingressi sono tre e in cambio ottieni la distinzione tra frenata e ruota libera, esattamente come nella tabella degli stati qui sopra.
const int ENA = 5; // PWM — togli il ponticello ENA dalla scheda
const int IN1 = 7;
const int IN2 = 8;
void setup() {
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
}
void avanti(int pwm) { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); analogWrite(ENA, pwm); }
void indietro(int pwm) { digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); analogWrite(ENA, pwm); }
void frena() { digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); digitalWrite(ENA, HIGH); }
void folle() { digitalWrite(ENA, LOW); }
void loop() {
avanti(200); delay(1500);
frena(); delay(800); // si ferma in pochi giri
indietro(200); delay(1500);
folle(); delay(800); // rallenta per inerzia
}
Passare da +255 a −255 in un istante significa applicare al motore quasi il doppio della tensione di batteria — la sua forza controelettromotrice più la batteria invertita — con una corrente superiore a quella di stallo. Il driver va in protezione, gli ingranaggi prendono un colpo e la batteria cala. Una rampa di qualche centinaio di millisecondi risolve tutto.
int attuale = 0; // velocita applicata ora
const int PASSO = 5; // massimo cambio per ciclo
// Chiamala ogni 10 ms: da 0 a 255 servono circa 0,5 s.
void versoObiettivo(int obiettivo) {
if (attuale < obiettivo) attuale = min(attuale + PASSO, obiettivo);
else if (attuale > obiettivo) attuale = max(attuale - PASSO, obiettivo);
motore(attuale); // la funzione di dc_pwm_dir.ino
}
Tutto quello visto finora è controllo ad anello aperto: chiedi il 50 % e speri. Sotto carico, in salita o con la batteria che si scarica, lo stesso duty cycle dà meno giri, e due motori "uguali" non girano mai esattamente alla stessa velocità — per questo un robot a due ruote comandato a PWM fisso non va mai dritto.
Un motoriduttore con encoder chiude il cerchio. Sull'albero del motore, prima del riduttore, un disco magnetico e due sensori Hall producono due onde quadre, A e B, sfasate di un quarto di periodo. Contando i fronti sai di quanto ha girato l'albero; guardando quale dei due canali arriva prima sai in che verso.
Su Arduino UNO solo i pin 2 e 3 hanno un interrupt dedicato, ed è lì che vanno i due canali: a qualche migliaio di giri al minuto i fronti arrivano troppo in fretta per leggerli nel loop(). Ogni interrupt confronta i due canali e aggiorna un contatore con segno.
const int ENC_A = 2; // pin con interrupt
const int ENC_B = 3;
const float CONTEGGI_GIRO = 537.7; // 28 x 19,2 — albero di uscita
volatile long conteggi = 0;
void fronteA() { conteggi += (digitalRead(ENC_A) != digitalRead(ENC_B)) ? 1 : -1; }
void fronteB() { conteggi += (digitalRead(ENC_A) == digitalRead(ENC_B)) ? 1 : -1; }
void setup() {
Serial.begin(115200);
pinMode(ENC_A, INPUT_PULLUP);
pinMode(ENC_B, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(ENC_A), fronteA, CHANGE);
attachInterrupt(digitalPinToInterrupt(ENC_B), fronteB, CHANGE);
}
long precedente = 0;
void loop() {
delay(100); // finestra di misura: 100 ms
noInterrupts();
long ora = conteggi; // copia atomica del contatore
interrupts();
float giri = (ora - precedente) / CONTEGGI_GIRO;
float rpm = giri * 600.0; // 100 ms -> 1 minuto
precedente = ora;
Serial.print("posizione: "); Serial.print(ora / CONTEGGI_GIRO * 360.0);
Serial.print(" gradi rpm: "); Serial.println(rpm);
}
Con la velocità misurata puoi correggere il PWM: se il motore è più lento dell'obiettivo alzi il duty cycle, se è più veloce lo abbassi. Il frammento qui sotto è la forma più semplice — un regolatore integrale — e basta già a tenere costante la velocità di una ruota quando il carico cambia. Per posizionare un braccio con precisione serve un PID completo, oppure un controller come RoboClaw che lo fa a bordo.
const float OBIETTIVO_RPM = 150.0;
const float KI = 0.4; // guadagno: alzalo finche non oscilla
float pwm = 0;
// Chiamala subito dopo aver calcolato rpm, ogni 100 ms.
void regola(float rpm) {
float errore = OBIETTIVO_RPM - rpm;
pwm = constrain(pwm + KI * errore, -255, 255);
motore((int)pwm);
}
| Sintomo | Causa tipica | Rimedio |
|---|---|---|
| Arduino si resetta quando il motore parte | Arduino alimentato dalla stessa batteria del motore, senza regolatore dedicato | Alimenta Arduino da USB o da un regolatore separato; masse collegate |
| Il motore non si muove, il driver è acceso | Manca la massa comune, o ENA lasciato col ponticello | Collega GND Arduino–driver; togli il ponticello e porta ENA a un pin PWM |
| Ronza ma non parte a basso PWM | Duty cycle sotto la soglia di spunto | Imposta un minimo (es. 40/255) o usa un rapporto di riduzione più alto |
| Fischio acuto continuo | Frequenza PWM nella banda udibile (490–980 Hz) | Alza la frequenza PWM se il driver lo consente |
| Il driver scalda o va in protezione | Corrente di stallo oltre il limite, o inversioni brusche | Driver più robusto, rampa di accelerazione, riduttore più spinto |
| Gira più lento del previsto con l'L298N | Caduta di 2–4 V nei transistor bipolari | Driver a MOSFET |
| L'encoder conta al contrario | Canali A e B scambiati rispetto al verso del motore | Scambia ENC_A ed ENC_B nel codice, o inverti il segno |
| L'encoder perde conteggi | Canali letti nel loop() invece che con interrupt | Usa i pin 2 e 3 con attachInterrupt() |
No. Un pin di Arduino fornisce al massimo 20–40 mA, mentre anche un piccolo motoriduttore assorbe centinaia di milliampere e diversi ampere in stallo. In più il motore, quando gira, genera tensioni inverse che danneggiano il microcontrollore. Serve sempre un driver a ponte H tra Arduino e il motore.
Con il PWM: il driver accende e spegne la tensione di alimentazione migliaia di volte al secondo e il motore, che per la sua inerzia e induttanza non segue le singole commutazioni, si comporta come se ricevesse la tensione media. Con un duty cycle del 50 % su 12 V il motore gira circa come a 6 V.
Invertendo la polarità ai suoi capi. Un ponte H lo fa con quattro interruttori elettronici: chiudendone una coppia diagonale la corrente attraversa il motore in un verso, chiudendo l'altra coppia nel verso opposto. Dal lato Arduino basta un pin di direzione o la combinazione di due ingressi IN1 e IN2.
Guarda la corrente di stallo del motore, non quella a vuoto: è la corrente che il motore assorbe all'avvio e quando si blocca, e il driver deve reggerla almeno per qualche istante. Poi la tensione: il driver deve accettare la tensione della batteria con margine. Un L298N va bene per motorini da 1–2 A; per motoriduttori da 12 V con stallo di 5–10 A serve un driver a MOSFET o un controller come RoboClaw.
In frenata il ponte H cortocircuita i due capi del motore: la forza controelettromotrice genera una corrente che si oppone al moto e l'albero si ferma in fretta. In ruota libera il ponte apre tutti gli interruttori e il motore rallenta solo per attrito. Sul L298N si frena con IN1 = IN2 ed EN alto, si va in folle portando EN basso.
A sapere quanto e quanto velocemente gira davvero l'albero. Il PWM fissa la tensione, non la velocità: sotto carico o con la batteria scarica il motore rallenta. Contando gli impulsi dell'encoder in quadratura si misurano posizione, verso e giri al minuto, e si può chiudere un anello di controllo che corregge il PWM.
Il codice è la parte facile. La parte difficile è scegliere un motore con la velocità giusta all'albero di uscita, un driver che regga il suo stallo e un modo solido per fissarlo alla struttura. A catalogo trovi motoriduttori goBILDA e ServoCity con e senza encoder, planetari e cilindrici, e i controller per pilotarli.
Da pochi giri al minuto a migliaia: scegli il rapporto e lascia al motore la sua zona di lavoro
SfogliaEncoder in quadratura già montato sul motore: posizione, verso e velocità senza aggiungere sensori
SfogliaDue canali da 30 A con lettura encoder e PID a bordo, comandabili da seriale, USB o segnale RC
ScopriStaffe di fissaggio, mozzi e alberi che collegano il motore al resto della struttura goBILDA
SfogliaVelocità a vuoto, coppia e corrente di stallo sono indicate su ogni scheda prodotto. Non sai quale motore o driver serve al tuo progetto? Chiedicelo: rispondiamo con codici prodotto, non con dépliant.