Ponte H doppia L298N, 2 motori DC, 5-35V, 2A per canale

Il modulo Doppio ponte H L298N è un driver per motori a corrente continua, costruito attorno al circuito L298N. Può comandare due motori DC in modo indipendente, per senso e velocità, oppure un motore passo-passo bipolare. Lo incontriamo nei robot su ruote, nelle macchinine radiocomandate, nei piccoli nastri trasportatori e in ogni progetto in cui un microcontrollore deve muovere un motore che consuma più di quanto possa erogare un pin della scheda.

In questo tutorial usiamo Arduino Uno R3, perché il modulo ha bisogno di un microcontrollore che gli fornisca i segnali di comando, e la logica a 5 V della scheda Uno si adatta direttamente agli ingressi del modulo. Controlleremo due motori TT con riduttore, alimentati da un alimentatore di rete da 9 VDC.

Come funziona:

Un motore DC gira in un senso o nell'altro in base alla polarità della tensione ai morsetti. Il ponte H è un circuito con quattro interruttori che permette di invertire questa polarità con un segnale logico. Il circuito L298N contiene due di questi ponti, quindi può comandare due motori. Per il motore A si usano gli ingressi IN1 e IN2, mentre per il motore B gli ingressi IN3 e IN4.

Il senso di rotazione si sceglie in base alla combinazione di livelli sui due ingressi del motore. La combinazione HIGH su entrambi gli ingressi non deve mai essere usata, perché può danneggiare il modulo.

La velocità si regola con segnale PWM sui pin ENA (motore A) ed ENB (motore B). Su Arduino Uno, la funzione analogWrite accetta valori da 0 a 255. Il valore 0 significa motore fermo, mentre 255 significa alimentazione continua. La tensione media che arriva al motore è approssimativamente Vmotor = (VS - Vcaduta) x PWM / 255.

Il circuito L298N perde internamente una parte della tensione, circa 1.8 - 3.2 V con una corrente di 1 A e quasi 5 V a 2 A. Nel nostro montaggio VS è 9 V, quindi con PWM 255 un motore che assorbe circa 1 A riceve circa 7 V. I motori TT sono fatti per 3 - 6 V, perciò limitiamo il valore PWM a 200. A 200, la tensione media è circa 7 x 200 / 255 = 5.5 V, cioè nell'intervallo sicuro dei motori.

Il modulo ha anche un regolatore 78M05 che può produrre 5 V per la logica. Con il jumper 5V-EN inserito, il regolatore è attivo e il morsetto +5V diventa un'uscita a 5 V, con una corrente fino a 0.5 A. Questa soluzione si usa solo quando la tensione VS è di al massimo 12 V. Sopra 12 V si toglie il jumper e il morsetto +5V si alimenta dall'esterno.

Collegamento:

Alimentate i motori con un alimentatore di rete da 9 VDC con almeno 1 A, collegato tramite l'adattatore jack con morsetti a vite. La scheda Arduino Uno resta alimentata separatamente, tramite il cavo USB. La massa dell'alimentatore, la massa del modulo e la massa della scheda Uno devono essere unite, altrimenti i segnali di comando non hanno un riferimento comune e i motori non rispondono correttamente. Gli ingressi del modulo accettano direttamente il livello logico a 5 V della scheda Uno, quindi non serve un convertitore di livello.

Rimuovete i jumper da ENA ed ENB prima di alimentare il modulo, così potete regolare la velocità con PWM. Il modulo ha già sulla scheda due condensatori da 220 uF e i diodi di protezione per i motori, quindi non devono essere aggiunti componenti supplementari.

Pulsanti, regolazioni e indicatori:

Jumper 5V-EN: iniziate con il jumper inserito. In questo montaggio VS è 9 V, quindi il regolatore può restare attivo. Il morsetto +5V non si collega ad Arduino, perché la scheda Uno è alimentata tramite USB. Non alimentate mai il morsetto +5V dall'esterno finché il jumper è inserito.

Jumper ENA ed ENB: rimuoveteli entrambi prima del primo avvio. Con il jumper inserito, il motore corrispondente gira sempre alla velocità massima e il comando PWM non ha alcun effetto. La regolazione funziona quando la velocità del motore cambia mentre il programma varia il valore di analogWrite.

LED di alimentazione: dopo aver collegato l'alimentatore, deve accendersi subito. È la prima cosa da verificare quando qualcosa non funziona.

Scheda e librerie:

Nell'IDE di Arduino selezionate Tools > Board > Arduino AVR Boards > Arduino Uno. Il pacchetto Arduino AVR Boards è incluso nell'IDE di Arduino, quindi non deve essere installato separatamente. Il programma usa solo le funzioni di base di Arduino, perciò non è necessario installare alcuna libreria.

Il codice:

Il programma fa girare ciascun motore avanti e indietro, a due velocità, poi fa girare insieme entrambi i motori. Copiatelo nell'IDE di Arduino e caricatelo sulla scheda Uno.

/*
  L298N dual H-bridge motor driver demo
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none, the sketch uses only the core Arduino functions
  Wiring:
    ENA -> D9 (PWM)    IN1 -> D8    IN2 -> D7
    ENB -> D3 (PWM)    IN3 -> D5    IN4 -> D4
    L298N GND -> Arduino GND and the adapter minus
    L298N +12V -> adapter plus (9 VDC, min. 1 A)
    Remove the ENA and ENB jumpers so PWM can control the speed
*/
// Motor A pins
const int ENA = 9;   // Speed of motor A (PWM)
const int IN1 = 8;   // Direction input 1 of motor A
const int IN2 = 7;   // Direction input 2 of motor A
// Motor B pins
const int ENB = 3;   // Speed of motor B (PWM)
const int IN3 = 5;   // Direction input 1 of motor B
const int IN4 = 4;   // Direction input 2 of motor B
// Maximum PWM value, keeps 3-6 V motors in a safe range when VS is 9 V
const int MAX_PWM = 200;
// Run motor A at a given speed, forward or backward
void setMotorA(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN2 : IN1, LOW);
  digitalWrite(forward ? IN1 : IN2, HIGH);
  analogWrite(ENA, speed);                // Apply the speed
  Serial.print("Motor A: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Run motor B at a given speed, forward or backward
void setMotorB(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN4 : IN3, LOW);
  digitalWrite(forward ? IN3 : IN4, HIGH);
  analogWrite(ENB, speed);                // Apply the speed
  Serial.print("Motor B: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Stop motor A
void stopMotorA() {
  analogWrite(ENA, 0);        // No drive
  digitalWrite(IN1, LOW);     // Both inputs LOW
  digitalWrite(IN2, LOW);
  Serial.println("Motor A: stopped");
}
// Stop motor B
void stopMotorB() {
  analogWrite(ENB, 0);        // No drive
  digitalWrite(IN3, LOW);     // Both inputs LOW
  digitalWrite(IN4, LOW);
  Serial.println("Motor B: stopped");
}
void setup() {
  // Configure all control pins as outputs
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  Serial.begin(9600);         // Start the serial monitor
  Serial.println("L298N motor driver test started");
  // Make sure both motors are off at start
  stopMotorA();
  stopMotorB();
  delay(1000);
}
void loop() {
  // Motor A: forward at two speeds, then backward
  setMotorA(120, true);
  delay(2000);
  setMotorA(200, true);
  delay(2000);
  stopMotorA();
  delay(1000);
  setMotorA(200, false);
  delay(2000);
  stopMotorA();
  delay(1000);
  // Motor B: forward, then backward
  setMotorB(200, true);
  delay(2000);
  stopMotorB();
  delay(1000);
  setMotorB(200, false);
  delay(2000);
  stopMotorB();
  delay(1000);
  // Both motors together
  setMotorA(150, true);
  setMotorB(150, true);
  delay(3000);
  stopMotorA();
  stopMotorB();
  delay(3000);            // Pause before the cycle repeats
}

Come funziona il codice:

All'inizio vengono definiti i pin con le costanti ENA, IN1, IN2, ENB, IN3 e IN4, esattamente come nella tabella di collegamento. La costante MAX_PWM ha valore 200 e limita la velocità, così che i motori TT non ricevano più di 6 V.

Nella funzione setup tutti i pin vengono configurati come uscite, il monitor seriale si avvia a 9600 baud e entrambi i motori vengono fermati, così che non parta nulla di indesiderato al reset.

Le funzioni setMotorA e setMotorB ricevono la velocità e il senso. Limitano la velocità con constrain, scrivono prima il livello LOW sull'ingresso che deve restare inattivo e solo dopo HIGH sull'altro. In questo modo i due ingressi dello stesso motore non sono mai HIGH contemporaneamente. Alla fine, analogWrite applica la velocità al pin di enable. Le funzioni stopMotorA e stopMotorB portano entrambi gli ingressi su LOW e la velocità a 0.

La funzione loop esegue la sequenza di test: motore A avanti a due velocità, arresto, motore A indietro, poi gli stessi passaggi per il motore B e infine entrambi i motori insieme. Le pause si fanno con delay, e i messaggi sul monitor seriale indicano ad ogni passo quale comando è stato inviato.

Risultato:

Aprite il Serial Monitor a 9600 baud. Dopo il caricamento del programma vedrete i messaggi sotto, e i motori si muovono nello stesso ordine. Se un motore gira in senso opposto rispetto al messaggio, invertite tra loro i due fili di quel motore sul morsetto OUT.

L298N motor driver test started
Motor A: stopped
Motor B: stopped
Motor A: forward, PWM 120
Motor A: forward, PWM 200
Motor A: stopped
Motor A: backward, PWM 200
Motor A: stopped
Motor B: forward, PWM 200
Motor B: stopped
Motor B: backward, PWM 200
Motor B: stopped

Problemi frequenti:

I motori non si muovono affatto. La causa più comune è l'alimentazione o la massa. Verificate che il LED di alimentazione sia acceso e che il GND della scheda Uno sia unito al GND del modulo. Senza massa comune i segnali di comando non vengono riconosciuti.

Un motore va sempre alla velocità massima, indipendentemente dal valore PWM. Il jumper ENA o ENB è ancora inserito. Toglietelo, così il pin D9 o D3 può controllare la velocità.

Il motore ronza ma non parte alle velocità basse. Sotto un certo valore PWM la tensione media è troppo bassa per vincere gli attriti del riduttore. Aumentate il valore di analogWrite o, se serve, usate una tensione VS più alta.

Il motore gira in senso opposto a quello desiderato. Invertite tra loro i due fili del motore al morsetto OUT, oppure scambiate nel codice i valori HIGH e LOW per quel motore.

La scheda Uno si riavvia quando partono i motori. I motori producono disturbi e cali di tensione sulla massa. Controllate i fili di massa, usate un alimentatore che fornisca almeno 1 A e tenete i fili dei motori lontani da quelli di segnale.

Il dissipatore del modulo si scalda. È normale con correnti elevate, perché una parte della potenza si perde nel circuito L298N. Se è troppo caldo per essere toccato a lungo, riducete il carico o assicurate una ventilazione.

Limiti e consigli:

Il modulo accetta per i motori tensioni da 5 - 35 VDC e può erogare fino a 2 A per canale. A causa della caduta di tensione interna, il motore riceve meno della tensione di alimentazione, quindi scegliete VS con 2 - 3 V in più rispetto alla tensione nominale del motore. Per motori piccoli da 3 - 6 V, un'alimentazione da 9 V con la limitazione PWM a circa 200 è una scelta sicura.

Il circuito L298N non è efficiente, quindi per motori alimentati a batteria e con consumo elevato un driver con transistor MOSFET è più adatto. In compenso il modulo è molto valido per imparare e per piccoli robot. Con lo stesso montaggio potete costruire un robot a due ruote, aggiungendo un sensore di distanza o un telecomando. Non applicate mai HIGH contemporaneamente su IN1 e IN2 oppure su IN3 e IN4.