(+39) 351 838 6453 [email protected]
IT/EN
Home/ Motori/ Controllo di un motore DC
Guida · Controllo del movimento

Come controllare un motore DC

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.

2Fili del motore
4Interruttori del ponte H
0 – 100 %Duty cycle PWM
4×Conteggi per ciclo encoder
Il principio

La tensione fa la velocità, la corrente fa la coppia

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.

zona di lavoro coppia sull'albero → 0 velocità a vuoto coppia di stallo I a vuoto corrente di stallo velocità corrente
Curva caratteristica a tensione costante. Un motore lavora bene, e a lungo, nella fascia evidenziata: non oltre un quarto o un terzo della coppia di stallo. Più a destra la corrente sale, il motore scalda e l'efficienza crolla. Se il carico ti porta lì, la soluzione è un rapporto di riduzione più alto, non un driver più grosso.
Il verso

Quattro interruttori intorno al motore

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.

V+ batteria GND S1 S2 S3 S4 M Avanti — S1 + S4 chiusi V+ batteria GND S1 S2 S3 S4 M Indietro — S2 + S3 chiusi
In verde il percorso della corrente. Nella pratica gli interruttori sono transistor o MOSFET e non li comandi uno per uno: il driver espone due ingressi logici (IN1/IN2, oppure DIR e PWM) e si occupa lui di chiudere la coppia giusta — e di non chiudere mai insieme S1 e S3, che metterebbero la batteria in cortocircuito.

Quattro stati, non due

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:

ENAIN1IN2MotorePonte
PWMHIGHLOWAvanti, velocità = duty cycleS1 + S4
PWMLOWHIGHIndietro, velocità = duty cycleS2 + S3
HIGHLOWLOWFrenata rapidaS3 + S4
HIGHHIGHHIGHFrenata rapidaS1 + S2
LOW××Ruota libera (folle)tutto aperto
La velocità

Accendere e spegnere, migliaia di volte al secondo

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.

1 periodo · 50 µs a 20 kHz duty 25 % ≈ 3 V 3 V duty 50 % ≈ 6 V 6 V duty 75 % ≈ 9 V 9 V alimentazione 12 V · linea tratteggiata = tensione media vista dal motore
Stesso periodo, tre duty cycle. Con analogWrite() Arduino esprime il duty cycle da 0 a 255: 64 ≈ 25 %, 128 ≈ 50 %, 191 ≈ 75 %. La relazione con la velocità è lineare solo a vuoto: sotto carico, e sotto il 10–15 % di duty cycle, molti motori non partono nemmeno.
Il fischio a 490 Hz analogWrite() su Arduino UNO lavora a circa 490 Hz (980 Hz sui pin 5 e 6): funziona, ma il motore fischia in modo udibile e a basse velocità gira a scatti. Se il driver lo permette, alza la frequenza riprogrammando un timer — evitando il Timer0, che usano millis() e delay(), e il Timer1 se usi anche la libreria Servo.
Il driver

Dimensionalo sullo stallo, non sul vuoto

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 driverCorrente tipicaIngressiQuando usarlo
Ponte H bipolare (L298N)2 A per canaleENA + IN1/IN2Motorini per esperimenti. Perde 2–4 V nel ponte e scalda: poco adatto ai motoriduttori da 12 V
Driver a MOSFET10 – 30 APWM + DIRLa scelta normale per motoriduttori da 12 V: caduta trascurabile, PWM fino a 20 kHz
Controller con ingresso servofino a 40 A+Impulso 1–2 ms a 50 HzSi 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 ASeriale, USB, RC, analogicoQuando 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.

Cablaggio

Due circuiti, una sola massa

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.

Arduino UNO alimentata da USB D5 D4 GND D2 · D3 Driver ponte H MOSFET · ≥ I di stallo PWM DIR M+ M− GND VM Batteria 12 V con fusibile M motoriduttore con encoder cavi di potenza massa comune encoder A/B + 5 V + GND → D2, D3 (interrupt)
Configurazione tipica con un driver PWM + DIR. Con un L298N cambiano solo i nomi: ENA al posto di PWM, IN1 e IN2 al posto di DIR. Il motore non ha polarità "giusta": se gira al contrario rispetto al previsto, scambia M+ e M− oppure inverti il segnale DIR nel codice.
Regola da banco Collega e scollega il motore solo a batteria spenta, e non lasciare mai un driver acceso senza un fusibile sulla batteria. Un motore in stallo su un driver senza protezione è il modo più rapido per vedere fumo uscire da un circuito stampato.
Codice

Il lato Arduino

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.

dc_pwm_dir.inoDriver PWM + DIR
// 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.

l298n.inoENA + IN1 / IN2
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
}

Non invertire mai di colpo

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.

rampa.inoAccelerazione limitata
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
}
Retroazione

Il PWM fissa la tensione, non la velocità

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.

A B 1 2 3 4 1 ciclo = 4 conteggi A anticipa B → avanti · B anticipa A → indietro
Contando tutti i fronti di entrambi i canali (decodifica 4×) un encoder da 7 impulsi per giro dà 28 conteggi per giro del motore. Dopo il riduttore si moltiplica per il rapporto: su un motoriduttore 19,2:1 sono circa 537,7 conteggi per giro dell'albero di uscita, cioè due terzi di grado per conteggio.

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.

encoder_rpm.inoQuadratura 4× · giri/min
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);
}

Chiudere l'anello

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.

velocita_costante.inoAnello di velocità
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);
}
Diagnostica

Quando qualcosa non torna

SintomoCausa tipicaRimedio
Arduino si resetta quando il motore parteArduino alimentato dalla stessa batteria del motore, senza regolatore dedicatoAlimenta Arduino da USB o da un regolatore separato; masse collegate
Il motore non si muove, il driver è accesoManca la massa comune, o ENA lasciato col ponticelloCollega GND Arduino–driver; togli il ponticello e porta ENA a un pin PWM
Ronza ma non parte a basso PWMDuty cycle sotto la soglia di spuntoImposta un minimo (es. 40/255) o usa un rapporto di riduzione più alto
Fischio acuto continuoFrequenza PWM nella banda udibile (490–980 Hz)Alza la frequenza PWM se il driver lo consente
Il driver scalda o va in protezioneCorrente di stallo oltre il limite, o inversioni bruscheDriver più robusto, rampa di accelerazione, riduttore più spinto
Gira più lento del previsto con l'L298NCaduta di 2–4 V nei transistor bipolariDriver a MOSFET
L'encoder conta al contrarioCanali A e B scambiati rispetto al verso del motoreScambia ENC_A ed ENC_B nel codice, o inverti il segno
L'encoder perde conteggiCanali letti nel loop() invece che con interruptUsa i pin 2 e 3 con attachInterrupt()
Domande frequenti

Domande frequenti sul controllo dei motori DC

Posso collegare un motore DC direttamente a un pin di Arduino?

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.

Come si regola la velocità di un motore DC?

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.

Come si inverte il verso di rotazione di un motore DC?

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.

Come scelgo il driver per il mio motore DC?

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.

Che differenza c'è tra frenata e ruota libera?

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 cosa serve l'encoder su un motoriduttore?

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.

Motori DC e controller, pronti a spedire

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