In questo articolo imparerai come controllare un motore passo-passo con il L298N driver per motori. Questa scheda driver è solitamente usata per controllare motori DC, ma è anche un’alternativa economica per controllare motori passo-passo! Può controllare sia la velocità che la direzione di rotazione della maggior parte dei motori passo-passo come un NEMA 17.
Ho incluso uno schema di collegamento e molti codici di esempio. Nel primo esempio esamineremo la Stepper.h libreria Arduino. Ti consiglio vivamente di dare un’occhiata anche ai codici di esempio per la AccelStepper libreria alla fine di questo tutorial. Questa libreria è abbastanza facile da usare e può migliorare notevolmente le prestazioni del tuo hardware.
Dopo ogni esempio, spiego come funziona il codice, quindi non dovresti avere problemi a modificarlo per adattarlo alle tue esigenze.
Materiali
Componenti hardware
 | L298N motor driver board | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| 12V power supply | × 1 | Amazon | |
| Jumper wires | × 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informazioni sul L298N Motor Driver
La L298N scheda driver per motori è basata sul driver full-bridge doppio L298 prodotto da STMicroelectronics. Con questo driver puoi controllare motori DC, motori passo-passo, relè e solenoidi. Dispone di due canali separati, chiamati A e B, che puoi usare per pilotare 2 motori DC o 1 motore passo-passo se combinati.
Il L298N è solitamente montato su una scheda breakout (rossa), che rende il cablaggio molto più semplice. La scheda breakout include anche un regolatore di tensione 78M05 a 5 V.
Perché il mio motore passo-passo si surriscalda?
Una cosa molto importante da ricordare è che il L298 non ha un modo semplice per impostare un limite di corrente a differenza di altri driver per motori passo-passo come il A4988. Questo significa che la corrente assorbita dipende dal rapporto tra induttanza e resistenza (L/R) del motore passo-passo collegato. Quando il motore assorbe troppa corrente, puoi danneggiare il driver e il motore si scalderà!
Questo significa che devi fare attenzione nella scelta del motore passo-passo e dell’alimentatore da usare con questo driver.Non tutti i motori passo-passo funzioneranno! La tensione di funzionamento del L298N è compresa tra 4,8 e 46 volt (max 35 V quando montato sulla scheda breakout). Poiché il driver può fornire un massimo di 2 ampere per canale, devi trovare un motore passo-passo che possa essere usato in questo intervallo di tensione e che non superi la corrente massima.
Controlla il datasheet del tuo motore passo-passo e cerca la tensione/corrente assorbita dal motore. Se non trovi il datasheet, puoi misurare la resistenza di uno degli avvolgimenti e usare la seguente formula per stimare la corrente assorbita:
I = U ÷ R oppure Corrente assorbita (A) = Tensione di alimentazione (V) ÷ Resistenza dell’avvolgimento (Ω)
Cercherei un motore che assorba meno di 2 A alla tensione che vuoi usare.
Il motore che ho usato per questo tutorial assorbe circa 1 A a 5 V. Ho anche trovato questo motore passo-passo da Adafruit che funziona bene a 12 V e assorbe solo 350 mA.
Se il motore che vuoi pilotare non funziona con il driver L298N, è meglio usare un driver chopper. Ho scritto tutorial per i A4988 e DRV8825 driver che funzionano molto bene con molti motori passo-passo.
Specifiche del L298N Motor Driver
| Tensione di funzionamento | 5 – 35 V |
| Tensione logica | 4,5 – 7 V |
| Corrente massima | 2 A per canale o 4 A max |
| Controller motore | L298N, pilota 2 motori DC o 1 motore passo-passo |
| Regolatore di tensione | 78M05 |
| Dimensioni modulo | 43 x 43 x 28 mm |
| Dimensioni fori | 3,2 mm, distanza 37 mm |
| Costo | Check price |
Per maggiori informazioni, puoi consultare il datasheet qui sotto:
Pinout L298N
Il L298 è disponibile in diversi package, il pinout per il L298N (Multiwatt15) è riportato di seguito:
| Numero pin | Nome | Funzione |
|---|---|---|
| 1, 15 | Sense A, Sense B | La resistenza di rilevamento deve essere collegata tra questo pin e GND (non usato sulla scheda breakout). |
| 2, 3 | Out 1, Out 2 | Uscite del Ponte A; la corrente che scorre attraverso il carico collegato tra questi due pin è monitorata al pin 1. |
| 4 | Vs | Tensione di alimentazione per le uscite di potenza |
| 5, 7 | Input 1, Input 2 | Ingressi compatibili TTL del Ponte A |
| 6, 11 | Enable A, Enable B | Ingresso di abilitazione compatibile TTL: lo stato LOW disabilita il ponte A (enable A) e/o il ponte B (enable B). |
| 8 | GND | Massa |
| 9 | VSS | Tensione di alimentazione per i blocchi logici. |
| 10, 12 | Input 3, Input 4 | Ingressi compatibili TTL del Ponte B. |
| 13, 14 | Out 3, Out 4 | Uscite del Ponte B; la corrente che scorre attraverso il carico collegato tra questi due pin è monitorata al pin 15. |
Cablaggio – Collegare L298N a motore passo-passo e Arduino
Lo schema di collegamento qui sotto mostra come collegare un motore passo-passo, l’alimentatore e Arduino alla scheda breakout L298N.
Le connessioni sono anche riportate nella tabella seguente:
Connessioni L298N
| L298N | Connessione |
|---|---|
| +12V | Alimentazione 5 – 35 V |
| GND | Massa alimentazione e Arduino |
| Ponticello 12 V | Rimuovere se alimentazione motore > 12 V! |
| 5V+ (opzionale) | 5 V Arduino se il ponticello 12 V è rimosso |
| IN1 | Pin 8 Arduino |
| IN2 | Pin 9 Arduino |
| IN3 | Pin 10 Arduino |
| IN4 | Pin 11 Arduino |
| Ponticelli ENA e ENB | Lasciare installati |
| OUT1 + OUT2 | Avvolgimento A motore passo-passo |
| OUT3 + OUT4 | Avvolgimento B motore passo-passo |
Nota importante: rimuovi il ponticello +12V se usi un alimentatore superiore a 12 V.
Quando il ponticello +12V è inserito, il regolatore di tensione a bordo è abilitato e genera la tensione logica a 5 V. Rimuovendo il ponticello, devi fornire 5 V dalla scheda Arduino.
Devi anche mantenere entrambi i ponticelli ENA e ENB in posizione affinché il motore sia sempre abilitato.
Come determinare il cablaggio del motore passo-passo?
Se non trovi il datasheet del tuo motore passo-passo, può essere difficile capire come collegarlo correttamente. Uso il seguente trucco per identificare come collegare motori passo-passo bipolari a 4 fili:
L’unica cosa da identificare sono le due coppie di fili collegate a ciascuna delle due bobine. Una bobina va collegata a OUT1 e OUT2 e l’altra a OUT3 e OUT4, la polarità non importa.
Per trovare i due fili di una bobina, fai quanto segue con il motore scollegato:
- Prova a far girare l’albero del motore passo-passo a mano e nota quanto è difficile ruotarlo.
- Ora prendi una coppia casuale di fili del motore e tocca insieme le estremità scoperte.
- Poi prova di nuovo a far girare l’albero del motore passo-passo.
- Se senti molta resistenza, hai trovato una coppia di fili della stessa bobina. Se l’albero gira liberamente, prova un’altra coppia di fili.
Ora collega le due bobine ai pin mostrati nello schema di collegamento sopra.
Codice esempio con libreria Stepper.h per driver L298N con motore passo-passo e Arduino
Puoi caricare il seguente codice esempio sul tuo Arduino usando la Arduino IDE.
Questo esempio usa la libreria Stepper.h , che dovrebbe essere preinstallata con l’IDE Arduino. Puoi trovarla andando su Sketch > Include Library > Stepper.
Questo sketch fa ruotare il motore passo-passo di 1 giro in una direzione, si ferma, poi fa 1 giro nell’altra direzione.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and Stepper.h library.
More info: https://www.makerguides.com */
// Include the Stepper library:
#include "Stepper.h"
// Define number of steps per revolution:
const int stepsPerRevolution = 200;
// Initialize the stepper library on pins 8 through 11:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
void setup() {
// Set the motor speed (RPMs):
myStepper.setSpeed(100);
}
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Come funziona il codice:
Lo sketch inizia includendo la libreria Arduino Stepper.h. Maggiori informazioni su questa libreria si trovano su Arduino website.
// Include the Stepper library: #include "Stepper.h"
Successivamente definiamo quanti passi servono al motore per compiere 1 rivoluzione. In questo esempio useremo il motore in modalità full-step. Questo significa che servono 200 passi per ruotare di 360 gradi. Puoi cambiare questo valore se usi un tipo diverso di motore passo-passo o configurazione.
// Define number of steps per revolution: const int stepsPerRevolution = 200;
Dopodiché devi creare una nuova istanza della classe Stepper, che rappresenta un motore passo-passo collegato all’Arduino. Per questo usiamo la funzione Stepper(steps, pin1, pin2, pin3, pin4) dove steps è il numero di passi per rivoluzione e pin1 fino a pin4 sono i pin usati per pilotare il motore passo-passo. Nel nostro caso sono i pin 8, 9, 10 e 11.
// Initialize the stepper library on pins 8 through 11: Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
In questo caso ho chiamato il motore passo-passo ‘myStepper’ ma puoi usare altri nomi, come ‘z_motor’ o ‘liftmotor’ ecc. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 9, 10, 11);. Il nome ‘myStepper’ sarà usato per impostare la velocità e il numero di passi per questo motore specifico. Nota che puoi creare più oggetti stepper con nomi diversi se vuoi controllare più motori.
Nel setup() definiamo la velocità del motore. Puoi impostare la velocità in RPM con la funzione setSpeed(rpm). L’ho impostata a 100, quindi dovremmo vedere circa 1,6 rivoluzioni al secondo.
// Set the motor speed (RPMs): myStepper.setSpeed(100);
Nella sezione loop del codice, chiamiamo semplicemente la funzione step(steps) che fa ruotare il motore di un numero specifico di passi a una velocità determinata dalla funzione setSpeed(rpm) . Passare un numero negativo a questa funzione inverte la direzione di rotazione del motore.
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Nota che la funzione step(steps) è bloccante, cioè aspetta che il motore abbia finito di muoversi prima di passare alla riga successiva dello sketch.
Installazione della libreria AccelStepper
Nei tre esempi seguenti ti mostrerò come controllare velocità, direzione e numero di passi che il motore passo-passo deve compiere. In questo esempio userò la libreria AccelStepper .
La libreria AccelStepper scritta da Mike McCauley è una libreria fantastica per il tuo progetto. Uno dei vantaggi è che supporta accelerazione e decelerazione, ma ha anche molte altre funzioni utili.
Puoi installare la libreria andando su Tools > Manage Libraries… o premendo Ctrl + Shift + I su Windows. Si aprirà il Library Manager e aggiornerà la lista delle librerie installate.
Puoi cercare ‘accelstepper‘ e trovare la libreria di Mike McCauley. Seleziona l’ultima versione e clicca su Install.
1. Codice esempio per rotazione continua con AccelStepper
Il seguente sketch può essere usato per far girare uno o più motori passo-passo continuamente a velocità costante. (Non si usa accelerazione o decelerazione).
/* Example sketch to control a stepper motor with L298N motor driver, Arduino UNO and AccelStepper.h library.
Contiuous rotation.
https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
Come funziona il codice:
Il primo passo è includere la libreria con #include "AccelStepper.h“.
// Include the AccelStepper library: #include "AccelStepper.h"
Il passo successivo è definire il tipo di interfaccia motore. Il tipo di interfaccia deve essere impostato a 4 quando si usa un motore passo-passo a 4 fili in modalità full-step (200 passi/rivoluzione). Puoi trovare gli altri tipi di interfaccia here.
L’istruzione #define serve per dare un nome a un valore costante. Il compilatore sostituirà ogni riferimento a questa costante con il valore definito quando il programma viene compilato. Quindi ovunque menzioni motorInterfaceType, il compilatore lo sostituirà con il valore 4 durante la compilazione.
// Define the AccelStepper interface type: #define MotorInterfaceType 4
Successivamente devi creare una nuova istanza della classe AccelStepper con il tipo di interfaccia motore e i collegamenti appropriati.
In questo caso ho chiamato il motore passo-passo ‘stepper’ ma puoi usare altri nomi, come ‘z_motor’ o ‘liftmotor’ ecc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, 8, 9, 10, 11);. Come hai visto nell’esempio precedente, il nome che dai al motore passo-passo sarà usato per impostare velocità, posizione e accelerazione per quel motore. Puoi creare più istanze della classe AccelStepper con nomi e pin diversi. Questo ti permette di controllare facilmente 2 o più motori passo-passo contemporaneamente.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
Nella setup() sezione del codice definiamo la velocità massima in passi/secondo. Velocità superiori a 1000 passi al secondo possono essere inaffidabili, quindi ho impostato questo valore come massimo. Nota che specifico il nome del motore passo-passo (‘stepper’) per cui voglio definire la velocità massima. Se hai più motori collegati, puoi specificare velocità diverse per ciascuno:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(300);
}
Nella loop() impostiamo prima la velocità a cui vogliamo far girare il motore. Per questo usiamo la funzione setSpeed(). (puoi anche metterla nella sezione setup del codice).
stepper.runSpeed() controlla il motore e quando è il momento di fare un passo esegue 1 passo. Questo dipende dalla velocità impostata e dal tempo trascorso dall’ultimo passo. Se vuoi cambiare la direzione del motore, puoi impostare una velocità negativa: stepper.setSpeed(-400); fa girare il motore nell’altra direzione.
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Codice esempio per controllare numero di passi o rivoluzioni
Con il seguente sketch puoi controllare velocità, direzione e numero di passi/rivoluzioni.
In questo caso, il motore passo-passo compie 2 rivoluzioni in senso orario a 200 passi/sec, poi 1 rivoluzione in senso antiorario a 600 passi/sec, e infine 3 rivoluzioni in senso orario a 400 passi/sec.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
while (stepper.currentPosition() != 400) {
stepper.setSpeed(200);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor backwards at 600 steps/second until the motor reaches -200 steps (1 revolution):
while (stepper.currentPosition() != -200) {
stepper.setSpeed(-600);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 400 steps/second until the motor reaches 600 steps (3 revolutions):
while (stepper.currentPosition() != 600) {
stepper.setSpeed(400);
stepper.runSpeed();
}
delay(3000);
}
Spiegazione del codice:
La prima parte del codice fino alla sezione loop() è esattamente la stessa dell’esempio precedente.
Nel loop uso un while loop in combinazione con la funzione currentPosition() . Prima imposto la posizione corrente del motore passo-passo a zero con stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
Poi usiamo un ciclo while. Un ciclo while ripete continuamente, e all’infinito, finché l’espressione tra parentesi () diventa falsa. Quindi in questo caso controllo se la posizione corrente del motore passo-passo è diversa da 200 passi (!= significa: è diverso da). Finché è così, facciamo girare il motore a velocità costante impostata da setSpeed().
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
while (stepper.currentPosition() != 400) {
stepper.setSpeed(200);
stepper.runSpeed();
}
Nel resto del loop facciamo esattamente lo stesso, solo con velocità e posizione target diverse.
3. Codice esempio con accelerazione e decelerazione
In questo esempio vedremo uno dei principali motivi per usare la libreria AccelStepper.
Con il seguente sketch puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo senza codici complicati. La prima parte di questo sketch è uguale all’esempio 1, ma setup e loop sono diversi.
Il motore farà cinque rivoluzioni avanti e indietro con una velocità di 200 passi al secondo e un’accelerazione di 50 passi/secondo2.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
Acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(200);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(50);
}
void loop() {
// Set target position:
stepper.moveTo(1000);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Come funziona il codice:
Nella setup(), oltre alla velocità massima, dobbiamo definire accelerazione e decelerazione. Per questo usiamo la funzione setAcceleration().
// Set the maximum steps per second: stepper.setMaxSpeed(200); // Set the maximum acceleration in steps per second^2: stepper.setAcceleration(50);
Nella sezione loop del codice, ho usato un modo diverso per far ruotare il motore di un numero predefinito di passi. Prima imposto la posizione target con la funzione moveTo(). Poi usiamo semplicemente la funzione runToPosition() per far muovere il motore verso la posizione target con la velocità e accelerazione impostate. Il motore decelererà prima di raggiungere la posizione target.
// Set target position: stepper.moveTo(1000); // Run to position with set speed and acceleration: stepper.runToPosition();
Infine, impostiamo la nuova posizione target a zero, così torniamo all’origine.
Conclusione
In questo articolo ti ho mostrato come controllare un motore passo-passo con un driver L298N. Abbiamo visto 4 esempi, usando sia le librerie Stepper che AccelStepper.
Se vuoi saperne di più su altri driver per motori passo-passo, gli articoli qui sotto potrebbero esserti utili:
- How to control a stepper motor with A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
Nota che il Arduino Motor Shield Rev3 usa anch’esso un driver L298.
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia pure un commento qui sotto.
