Questo articolo include tutto ciò che devi sapere per controllare un motore passo-passo con il DRV8825 stepper motor drivere 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.
Materiale necessario
Componenti hardware
 | DRV8825 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8.2-45 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ù semplice 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 DRV8825 troverai un chip prodotto da Texas Instruments: il DRV8825 Stepper Motor Controller IC. 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 45 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 un 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 DRV8825 include diverse funzioni di sicurezza integrate come protezione da sovracorrente, cortocircuito, blocco per sottotensione e protezione da surriscaldamento. Puoi trovare ulteriori specifiche nella tabella qui sotto.
Specifiche DRV8825
| Tensione minima di funzionamento | 8.2 V |
| Tensione massima di funzionamento | 45 V |
| Corrente continua per fase | 1.5 A |
| Corrente massima per fase | 2.2 A |
| Tensione logica minima | 2.5 V |
| Tensione logica massima | 5.25 V |
| Risoluzione microstep | intero, 1/2, 1/4, 1/8, 1/16 e 1/32 |
| 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 DRV8825 e A4988
Il DRV8825 è molto simile al A4988 ma presenta alcune differenze chiave:
- Il DRV8825 offre microstepping a 1/32, mentre l’A4988 arriva solo fino 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, mentre l’A4988 ne 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 necessità di 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 con microstepping come il DRV8825 permette risoluzioni più elevate 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 micro passi per rivoluzione usando quattro livelli di corrente differenti.
I pin selettori di risoluzione (M0, M1 e M2) permettono di scegliere una delle sei risoluzioni di passo secondo la tabella seguente.
| M0 | M1 | M2 | 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 |
| Basso | Basso | Alto | 1/16 passo |
| Alto | Basso | Alto | 1/32 passo |
| Basso | Alto | Alto | 1/32 passo |
| Alto | Alto | Alto | 1/32 passo |
Tutti e tre gli ingressi hanno resistenze di pull-down interne da 100 kΩ, quindi lasciare scollegati i tre pin di selezione microstep fa operare il driver in 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 M0 – M2 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 DRV8825 ad Arduino e motore passo-passo
Lo schema sopra mostra come collegare il driver DRV8825 a un motore passo-passo e all’Arduino.
I collegamenti sono anche riportati nella tabella seguente:
Collegamenti DRV8825
| DRV8825 | Collegamento |
|---|---|
| VMOT | 8.2-45 V |
| GND | Massa motore |
| SLP | 5 V |
| RST | 5 V |
| GND | Massa logica |
| STP | Pin 3 |
| DIR | Pin 2 |
| A1, A2, B1, B2 | 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 A1, A2 e B1, B2 (vedi sotto).
- Il pin GND (in basso a destra) è collegato alla 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 il codice di esempio.
- Devi collegare RST (reset) e SLP (sleep) a 5 V, altrimenti il driver non si accende.
- Il pin EN (enable) può essere lasciato scollegato, è tirato verso massa di default. Quando questo pin è alto, il driver è disabilitato.
- Il DRV8825 ha anche un’uscita FAULT che va bassa ogni volta che i FET dell’H-bridge sono disabilitati a causa di protezione da sovracorrente o spegnimento termico. Questo pin è lasciato scollegato in questo tutorial.
Nel resto del tutorial ho lasciato M0, M1 e M3 scollegati, quindi il driver funziona in modalità passo intero. Questo rende più semplice spiegare il codice. Normalmente userei microstepping 1/16 o 1/32 e collegherei i pin appropriati a 5 V (vedi tabella nell’introduzione).
Avvertenza
La scheda carrier DRV8825 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 da identificare sono le due coppie di fili collegate alle due bobine del motore. I fili di una bobina vanno collegati a A1 e A2, l’altra coppia a B1 e B2, 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 di fili. 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. Il DRV8825 necessita solo di alimentazione tramite VMOT (8.2-45 V) e devi applicare 5 V a RST e SLP, altrimenti il driver non si accende. È meglio scollegare il motore passo-passo mentre fai questa operazione.
Se hai già collegato il driver come mostrato prima, puoi lasciare l’Arduino collegato per alimentare i pin RST e SLP.
| DRV8825 | Collegamento |
|---|---|
| VMOT | 8.2-45 V |
| GND | Massa motore |
| SLP | 5V |
| RST | 5V |
| GND | Massa logica |
Formula per il limite di corrente
Il passo successivo è calcolare il limite di corrente con la seguente formula:
Limite Corrente = Vref × 2
Quindi, per un limite di corrente di 1 A, il Vref dovrebbe essere 0,5 V.
Per scegliere il limite di corrente giusto, consulta il datasheet del tuo motore passo-passo. Se non trovi la corrente nominale del motore, ti consiglio di iniziare con un limite di 1A. Puoi sempre aumentarlo in seguito se il motore o il driver perdono passi.
Info extra: Quando usi il driver in modalità passo intero, la corrente attraverso ogni bobina è limitata a circa il 70% del limite di corrente 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.
Se il motore fa molto rumore, prova a ridurre il limite di corrente. È meglio impostare il limite 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 di riferimento 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 riporta quanto segue sul loro sito:
Nota: La corrente nella bobina può essere molto diversa dalla corrente dell’alimentatore, quindi non dovresti usare la corrente misurata all’alimentatore per impostare il limite di corrente. Il posto giusto per mettere l’amperometro è in serie con una delle bobine del motore passo-passo.
Pololu
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 risposta sopra.
Devo girare il potenziometro in senso orario o antiorario per aumentare Vref?
Dipende dal produttore del driver. Se hai una breakout board 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 DRV8825 ha una corrente massima di 2,5 A per bobina ma senza dissipatore può fornire solo circa 1,5 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 acquistare molti piccoli dissipatori su Amazon a basso costo.
Esempio base di codice Arduino per controllare un motore passo-passo
Ora che hai collegato 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 usando l’IDE Arduino. Per questo esempio specifico non è necessario installare librerie.
Questo sketch controlla velocità, numero di rivoluzioni e direzione di rotazione del motore passo-passo.
Puoi copiare il codice cliccando sul pulsante in alto a destra nel campo del codice.
/* Example sketch to control a stepper motor with
A4988/DRV8825 stepper motor driver and
Arduino without a library.
More info: 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 Arduino 3 e 2.
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
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);
}
Nella sezione loop() del codice, facciamo girare il motore di una rivoluzione lentamente in senso orario e una rivoluzione velocemente in senso antiorario. Poi facciamo girare il motore 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 (direction) 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 for loops 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 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 cercare la libreria di Mike McCauley. Seleziona l’ultima versione e clicca su Install.
1. Esempio di codice per rotazione continua
Lo sketch seguente 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
DRV8825 stepper motor driver, AccelStepper library
and Arduino: continuous rotation.
More info: https://www.makerguides.com */
#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 "AccelStepper.h"
Il passo successivo è definire i collegamenti DRV8825-Arduino e il tipo di interfaccia motore. Il tipo di interfaccia deve essere impostato a 1 quando si usa un driver step e direction.
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 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, 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 sezione 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 direzione, 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 while loop 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 DRV8825 stepper motor driver, AccelStepper library
and Arduino: number of steps or revolutions.
More info: https://www.makerguides.com */
#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 ripete continuamente, all’infinito, finché l’espressione dentro le parentesi () diventa falsa. Quindi, in questo caso, controllo se la posizione corrente del motore non è uguale a 400 passi (!= significa: non è uguale a). Finché non è così, facciamo girare il motore a velocità costante come impostato 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. Esempio di codice con accelerazione e decelerazione
Con lo sketch seguente puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo, senza codici complicati. In questo 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 DRV8825 stepper motor driver, AccelStepper library
and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
#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, dobbiamo definire accelerazione e decelerazione. Per questo usiamo la funzione setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
Nella sezione loop ho usato un modo diverso per far ruotare il motore di un numero predefinito di passi. La funzione stepper.moveTo() serve per impostare 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 DRV8825 e Arduino. 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
- TB6600 Stepper Motor Driver with Arduino Tutorial
E se hai commenti, sentiti libero di lasciarli nella sezione commenti.
