Questo articolo include tutto ciò che devi sapere per controllare un motore passo-passo con il A4988 driver per motori passo-passo e Arduino. Ho incluso uno schema di collegamento, un tutorial su come impostare il limite di corrente e molti esempi di codice.
Anche se puoi usare questo driver senza una libreria Arduino, ti consiglio vivamente di dare un’occhiata anche al codice di esempio per la libreria AccelStepper 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, così non avrai problemi a modificarlo secondo le tue esigenze.
Componenti necessari
Componenti hardware
 | A4988 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8-35 V) | × 1 | Amazon | |
| Breadboard | × 1 | Amazon | |
 | Capacitor (100 µF) | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Mi piace usare questo driver in combinazione con uno CNC-shield o expansion board. Uno shield del genere include già i condensatori e offre un modo semplice per selezionare la risoluzione del microstepping. Rende il cablaggio molto più facile ed è un’ottima opzione se ti serve una soluzione più permanente rispetto a una breadboard.
Strumenti
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 driver
Al cuore del driver A4988 troverai un chip prodotto da Allegro MicroSystems: l’A4988 DMOS Microstepping Driver con Translator e protezione da sovracorrente. Questo driver integrato rende l’interfacciamento con un microcontrollore molto semplice, poiché servono solo due pin per controllare sia la velocità che la direzione del motore passo-passo.
Il driver ha una capacità massima di uscita di 35 V e ± 2 A, ideale per pilotare motori passo-passo di piccole e medie dimensioni come un NEMA 17 motore passo-passo bipolare.
Se devi controllare motori passo-passo più grandi come i NEMA 23, dai un’occhiata al driver TB6600. Questo driver può essere usato con lo stesso codice dell’A4988 e ha una corrente nominale di 3,5 A.
Il chip driver A4988 ha diverse funzioni di sicurezza integrate come protezione da sovracorrente, cortocircuito, blocco per sottotensione e protezione da surriscaldamento. Puoi trovare altre specifiche nella tabella qui sotto.
Specifiche A4988
| Tensione minima di funzionamento | 8 V |
| Tensione massima di funzionamento | 35 V |
| Corrente continua per fase | 1 A |
| Corrente massima per fase | 2 A |
| Tensione logica minima | 3 V |
| Tensione logica massima | 5.5 V |
| Risoluzione microstep | intero, 1/2, 1/4, 1/8 e 1/16 |
| Protezione da tensione inversa? | No |
| Dimensioni | 15.5 × 20.5 mm (0.6″ × 0.8″) |
| Costo | Check price |
Per maggiori informazioni puoi consultare il datasheet qui.
Differenze tra A4988 e DRV8825
Il DRV8825 è molto simile all’A4988 ma presenta alcune differenze chiave:
- Il DRV8825 offre microstepping fino a 1/32, mentre l’A4988 arriva solo a 1/16. Un microstepping più alto garantisce un funzionamento più fluido e silenzioso, ma non è sempre necessario.
- Il potenziometro per il limite di corrente si trova in una posizione diversa
- La relazione tra la tensione di riferimento e il limite di corrente è differente.
- Il DRV8825 richiede una durata minima dell’impulso STEP di 1,9µs; l’A4988 richiede almeno 1µs.
- Il DRV8825 può essere usato con un’alimentazione motore a tensione più alta (45 V contro 35 V). Questo lo rende meno suscettibile a danni da picchi di tensione LC.
- Il DRV8825 può erogare una corrente leggermente superiore rispetto all’A4988 senza raffreddamento aggiuntivo.
Nota che il pinout del DRV8825 è esattamente lo stesso dell’A4988, quindi può essere usato come sostituto diretto!
Impostazioni microstep
I motori passo-passo tipicamente hanno un passo di 1,8° o 200 passi per rivoluzione, riferendosi ai passi interi. Un driver microstepping come l’A4988 permette risoluzioni più alte consentendo posizioni intermedie del passo. Questo si ottiene alimentando le bobine con livelli di corrente intermedi.
Ad esempio, pilotare un motore in modalità quarto di passo darà a un motore da 200 passi per rivoluzione 800 microstep per rivoluzione usando quattro livelli di corrente differenti.
I pin selettori di risoluzione (MS1, MS2 e MS3) permettono di scegliere una delle cinque risoluzioni di passo secondo la tabella qui sotto.
| MS1 | MS2 | MS3 | Risoluzione microstep |
|---|---|---|---|
| Basso | Basso | Basso | Passo intero |
| Alto | Basso | Basso | 1/2 passo |
| Basso | Alto | Basso | 1/4 passo |
| Alto | Alto | Basso | 1/8 passo |
| Alto | Alto | Alto | 1/16 passo |
Tutti e tre gli ingressi hanno resistenze di pull-down interne da 100 kΩ, quindi lasciare i pin di selezione microstep scollegati imposta la modalità passo intero.
Spesso uso uno CNC-shield o una scheda di espansione in combinazione con questi driver. La scheda di espansione ha 3 dip switch per impostare MS1 – MS3 su alto o basso e sul CNC-shield puoi installare jumper. Se usi il driver con una breadboard, puoi semplicemente usare jumper per collegare i pin di selezione a 5 V (cioè portarli in HIGH).
Cablaggio – Collegare A4988 ad Arduino e motore passo-passo
Lo schema sopra mostra come collegare il driver A4899 a un motore passo-passo e all’Arduino. Le connessioni sono anche riportate nella tabella seguente:
Connessioni A4988
| A4988 | Connessione |
|---|---|
| VMOT | 8-35V |
| GND | Massa motore |
| SLP | RESET |
| RST | SLP |
| VDD | 5V |
| GND | Massa logica |
| STP | Pin 3 |
| DIR | Pin 2 |
| 1A, 1B, 2A, 2B | Motore passo-passo |
- L’alimentazione del motore è collegata a GND e VMOT (in alto a destra).
- Le due bobine del motore passo-passo sono collegate a 1A, 1B e 2A, 2B (vedi sotto).
- Il pin GND (in basso a destra) è collegato al pin di massa del microcontrollore e VDD è collegato a 5V.
- I pin STP (step) e DIR (direzione) sono collegati rispettivamente ai pin digitali 3 e 2. Puoi scegliere pin digitali diversi se vuoi, ma questi sono quelli che ho usato per questo tutorial e per il codice di esempio.
- Il pin SLP è un ingresso attivo basso. Significa che portare questo pin a livello basso mette il driver in modalità sleep, minimizzando il consumo di energia. RST è anch’esso un ingresso attivo basso. Quando è basso, tutti gli ingressi STEP sono ignorati finché non viene portato alto. Se non usi questo pin, puoi collegarlo al pin SLP/SLEEP adiacente per portarlo alto e abilitare il driver.
- Il pin EN (enable) può essere lasciato scollegato, è tirato a basso di default. Quando questo pin è alto, il driver è disabilitato.
Nel resto di questo tutorial ho lasciato MS1, MS2 e MS3 scollegati, quindi il driver funziona in modalità passo intero. Questo rende più semplice spiegare il codice. Normalmente userei microstepping 1/8 o 1/16 e collegherei i pin appropriati a 5V (vedi tabella nell’introduzione).
Avvertenza
La scheda carrier A4988 usa condensatori ceramici a basso ESR, che la rendono suscettibile a picchi di tensione LC distruttivi, specialmente usando cavi di alimentazione più lunghi di pochi centimetri.
Per proteggere il driver puoi collegare un condensatore elettrolitico tra VMOT e GND. Pololu suggerisce un condensatore da 47 µF o più (io ho usato un condensatore da 100 µF).
Come determinare il cablaggio corretto del motore passo-passo?
Se non trovi il datasheet del tuo motore passo-passo, può essere difficile capire come collegarlo correttamente. Io uso questo trucco per identificare come collegare motori passo-passo bipolari a 4 fili:
L’unica cosa che devi identificare è il coppie di fili collegate alle due bobine del motore. I fili di una bobina vanno collegati a 1A e 1B, quelli dell’altra a 2A e 2B, la polarità non conta.
Per trovare i due fili di una bobina, fai così con il motore scollegato:
- Prova a 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 girare l’albero del motore.
Se senti molta resistenza, hai trovato una coppia di fili della stessa bobina. Se l’albero gira liberamente, prova un’altra coppia. Ora collega le due bobine ai pin mostrati nello schema sopra.
Come impostare il limite di corrente?
Prima di iniziare a programmare il tuo Arduino e usare il driver, c’è una cosa molto importante che molti dimenticano: impostare il limite di corrente!
Questo passaggio non è complicato ma è assolutamente necessario per proteggere il motore passo-passo e il driver. Se non imposti un limite di corrente adeguato, il motore può assorbire più corrente di quella che lui o il driver possono gestire, rischiando di danneggiarli.
Per impostare il limite di corrente devi misurare una tensione di riferimento e regolare il potenziometro a bordo di conseguenza. Ti serviranno un piccolo cacciavite, un multimetro per misurare la tensione di riferimento e cavi con pinze a coccodrillo (opzionali ma molto comodi).
Per misurare la tensione di riferimento, il driver deve essere alimentato. L’A4988 ha bisogno solo di alimentazione tramite VDD (5V) e devi collegare insieme RST e SLP, altrimenti il driver non si accende. È meglio scollegare il motore passo-passo mentre fai questa operazione.
Se hai già cablato il driver, puoi lasciare tutto collegato tranne il motore passo-passo. Puoi alimentare tramite la porta USB dell’Arduino.
| A4988 | Connessione |
|---|---|
| VDD | 5V |
| RST | SLP |
| SLP | RESET |
| GND | Massa |
Formula per il limite di corrente
Il passo successivo è calcolare il limite di corrente con la seguente formula:
Limite Corrente = Vref ÷ (8 × Rcs)
Rcs è la resistenza di rilevamento corrente. Se hai acquistato un driver A4988 da Pololu prima di gennaio 2017, Rcs sarà 0.050 Ω. I driver venduti dopo quella data hanno 0.068 Ω come resistenze di rilevamento corrente.
Quindi, per un limite di corrente di 1A su una scheda con resistenze da 0.068 Ω, Vref dovrebbe essere 540 mV.
Per scegliere il limite di corrente giusto, consulta il datasheet del tuo motore passo-passo. Se non trovi la corrente nominale, ti consiglio di iniziare con un limite di 1A. Puoi sempre aumentarlo in seguito se il motore o il driver perdono passi.
Quando usi il driver in modalità passo intero, la corrente attraverso ogni bobina è limitata a circa il 70% del limite impostato. Questo significa che dovresti impostare il limite di corrente al 40% in più, cioè 1,4 A in modalità passo intero. Con il microstepping, vale la formula sopra.
Nota che devi ricalibrare il limite di corrente se cambi la tensione di alimentazione del motore. Se il motore fa molto rumore, prova a ridurre il limite di corrente. È meglio impostare il limite di corrente appena sufficiente affinché il motore non perda passi.
Misurare Vref
Ora devi misurare la tensione di riferimento (Vref) tra i due punti segnati nella foto qui sotto (GND e il potenziometro) e regolarla al valore calcolato.
Consiglio di usare cavi con pinze a coccodrillo fissati al cacciavite per regolare il limite di corrente. Questo ti permette di regolare il potenziometro e misurare la tensione contemporaneamente.
Nota: Esiste un altro modo per misurare il limite di corrente, cioè misurare direttamente la corrente assorbita dal motore passo-passo. Personalmente trovo il metodo sopra molto più semplice.
Pololu menziona quanto segue sul loro sito:
Nota: La corrente nella bobina può essere molto diversa dalla corrente assorbita dall’alimentatore, quindi non dovresti usare la corrente misurata all’alimentatore per impostare il limite di corrente. Il posto giusto per mettere il tuo amperometro è in serie con una delle bobine del motore passo-passo.
FAQ sul limite di corrente
Devo avere il motore passo-passo collegato o no?
No, non è necessario collegare il motore al driver quando imposti il limite di corrente. Per sicurezza, scollega il motore, a volte interferisce con la misura della tensione Vref.
Devo far girare il motore eseguendo lo sketch motore su Arduino?
No, vedi la domanda sopra.
Devo girare il potenziometro in senso orario o antiorario per aumentare Vref?
Dipende dal produttore del driver. Se hai una scheda originale Pololu del DRV8825 o A4988, gira il potenziometro in senso orario per aumentare Vref e in senso antiorario per diminuirlo.
Raffreddamento del driver
Il driver A4988 ha una corrente massima di 2 A per bobina, ma senza dissipatore può fornire solo circa 1 A per bobina prima di surriscaldarsi.
Il driver di solito viene fornito con un piccolo dissipatore adesivo, che ti consiglio di installare subito. Puoi anche comprare diversi piccoli heat sinks su Amazon a prezzi molto bassi.
Esempio base di codice Arduino per controllare un motore passo-passo
Ora che hai cablato il driver e impostato il limite di corrente, è il momento di collegare l’Arduino al computer e caricare un po’ di codice. Puoi caricare il seguente esempio sul tuo Arduino usando il Arduino IDE. Per questo esempio specifico non è necessario installare librerie.
Questo sketch controlla la velocità, il numero di rivoluzioni e la direzione di rotazione del motore passo-passo.
// Example sketch to control a stepper motor with A4988 stepper motor driver
// and Arduino without a library.
// https://www.makerguides.com
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000);
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
//Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
}
Come funziona il codice:
Lo sketch inizia definendo i pin step e direction. Li ho collegati ai pin 3 e 2 di Arduino.
L’istruzione #define serve a 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 dirPin, il compilatore lo sostituirà con il valore 2 durante la compilazione.
Ho anche definito una costante stepsPerRevolution . Poiché ho impostato il driver in modalità passo intero, l’ho settata a 200 passi per rivoluzione. Cambia questo valore se il tuo setup è diverso.
// Define stepper motor connections and steps per revolution #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 200
setup
Nella sezione setup() del codice, tutti i pin di controllo motore sono dichiarati come OUTPUT digitali con la funzione pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
loop
Nella sezione loop() del codice, facciamo girare il motore lentamente per una rivoluzione in senso orario e poi velocemente per una rivoluzione in senso antiorario. Poi facciamo girare il motore per 5 rivoluzioni in ogni direzione ad alta velocità. Come si controllano velocità, direzione di rotazione e numero di rivoluzioni?
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for(int i = 0; i < stepsPerRevolution; i++)
{
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
Controllo della direzione di rotazione:
Per controllare la direzione di rotazione del motore passo-passo impostiamo il pin DIR (direzione) su HIGH o LOW. Per questo usiamo la funzione digitalWrite(). A seconda di come hai collegato il motore, impostare il pin DIR alto farà girare il motore in senso orario o antiorario.
Controllo del numero di passi o rivoluzioni:
In questo sketch di esempio, i cicli for controllano il numero di passi che il motore farà. Il codice dentro il ciclo for corrisponde a 1 passo del motore. Poiché il ciclo viene eseguito 200 volte (stepsPerRevolution), questo corrisponde a 1 rivoluzione. Negli ultimi due cicli, il codice dentro il for viene eseguito 1000 volte, cioè 1000 passi o 5 rivoluzioni.
Nota che puoi cambiare il secondo termine nel ciclo for con qualsiasi numero di passi desideri. for(int i = 0; i < 100; i++) darebbe 100 passi, o mezza rivoluzione.
Controllo della velocità:
La velocità del motore passo-passo è determinata dalla frequenza degli impulsi inviati al pin STEP. Più alta è la frequenza, più veloce gira il motore. Puoi controllare la frequenza degli impulsi cambiando delayMicroseconds() nel codice. Più breve è il delay, più alta è la frequenza e più veloce gira il motore.
Tutorial 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 scaricare l’ultima versione di questa libreria cliccando il pulsante qui sotto.
Puoi installare la libreria andando su Sketch > Include Library > Add .ZIP Library… nell’IDE di Arduino.
Un’altra opzione è andare su Tools > Manage Libraries… o premere Ctrl + Shift + I su Windows. Si aprirà il Library Manager e aggiornerà la lista delle librerie installate.
Puoi cercare ‘accelstepper’ e cercare la libreria di Mike McCauley. Seleziona l’ultima versione e clicca su Install.
1. Esempio di codice per rotazione continua
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 A4988 stepper motor driver, AccelStepper library and Arduino: continuous rotation.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed in steps per second: stepper.setMaxSpeed(1000); } void loop() { // Set the speed in steps per second: stepper.setSpeed(400); // Step the motor with a 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 le connessioni A4988-Arduino e il tipo di interfaccia motore. Il tipo di interfaccia deve essere impostato a 1 quando si usa un driver step e direction. Puoi trovare gli altri tipi di interfaccia here.
L’istruzione #define serve a 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 dirPin, il compilatore lo sostituirà con il valore 2 durante la compilazione.
// Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1
Poi devi creare una nuova istanza della classe AccelStepper con il tipo di interfaccia motore e le connessioni appropriate.
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, stepPin, dirPin);. Il nome che dai al motore passo-passo sarà usato più avanti per impostare velocità, posizione e accelerazione di 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, stepPin, dirPin);
Nella sezione setup() del codice definiamo la velocità massima in passi al 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 (‘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(500);
}
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 in steps per second:
stepper.setSpeed(400);
// Step the motor with a constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Esempio di codice per controllare il numero di passi o rivoluzioni
Per far ruotare il motore di un numero specifico di passi preferisco usare un ciclo while in combinazione con stepper.currentPosition(). Puoi usare il seguente esempio per far muovere il motore avanti e indietro.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: number of steps or revolutions.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed in 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 del precedente esempio.
Nel loop uso un ciclo while in combinazione con la funzione currentPosition() . Prima imposto la posizione corrente del motore a zero con stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
Poi usiamo il ciclo while. Un ciclo while continua a ripetere il codice finché l’espressione tra parentesi () è vera. Qui controllo se la posizione corrente del motore non è uguale a 400 passi (!= significa: non è uguale a). Finché è vero, 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, ma con velocità e posizione target diverse.
3. Esempio di codice con accelerazione e decelerazione
Con questo sketch puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo senza codifica complicata. Nell’esempio il motore gira avanti e indietro a 200 passi al secondo con un’accelerazione di 30 passi al secondo quadrato.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed and acceleration: stepper.setMaxSpeed(200); stepper.setAcceleration(30); } void loop() { // Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition(); delay(1000); // Move back to zero: stepper.moveTo(0); stepper.runToPosition(); delay(1000); }
Spiegazione del codice:
Nel setup(), oltre alla velocità massima, definiamo accelerazione e decelerazione con la funzione setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
Nel loop uso un metodo diverso per far ruotare il motore di un numero predefinito di passi. La funzione stepper.moveTo() imposta la posizione target. La funzione stepper.runToPostion() muove il motore (con accelerazione/decelerazione) alla posizione target e blocca l’esecuzione finché non arriva. Poiché questa funzione è bloccante, non dovresti usarla se devi controllare altre cose contemporaneamente.
// Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Conclusione
In questo articolo ti ho mostrato come controllare un motore passo-passo con il driver A4988 e Arduino. Spero ti sia stato utile e informativo. Personalmente ho usato molto questo driver per diverse stampanti 3D e altri progetti CNC.
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 DRV8825 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- TB6600 Stepper Motor Driver with Arduino Tutorial
Ho anche un articolo su How To Drive a Stepper Motor using the A4988 driver and ESP32 se vuoi lavorare con un microcontrollore ESP32 invece.
Se hai domande o pensi che manchi qualcosa, lascia pure un commento qui sotto.
