Este artículo incluye todo lo que necesitas saber sobre cómo controlar un motor paso a paso con el DRV8825 stepper motor driver y Arduino. He incluido un diagrama de conexiones, un tutorial sobre cómo ajustar el límite de corriente y muchos ejemplos de código.
Aunque puedes usar este driver sin una biblioteca de Arduino, te recomiendo que también eches un vistazo al código de ejemplo para la biblioteca AccelStepper al final de este tutorial. Esta biblioteca es bastante fácil de usar y puede mejorar mucho el rendimiento de tu hardware.
Materiales
Componentes de 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 |
Me gusta usar este driver en combinación con un CNC-shield o expansion board. Este tipo de shield ya incluye condensadores y ofrece una forma sencilla de seleccionar la resolución de microstepping. Facilita mucho el cableado y es una gran opción si necesitas una solución más permanente que una protoboard.
Herramientas
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.
Acerca del driver
En el corazón del driver DRV8825, encontrarás un chip fabricado por Texas Instruments: el DRV8825 Stepper Motor Controller IC. Este driver integrado facilita mucho la conexión con un microcontrolador, ya que solo necesitas dos pines para controlar tanto la velocidad como la dirección del motor paso a paso.
El driver tiene una capacidad máxima de salida de 45 V y ± 2 A, lo que es ideal para manejar motores paso a paso pequeños o medianos como un NEMA 17 motor paso a paso bipolar.
Si necesitas controlar motores paso a paso más grandes como un NEMA 23, echa un vistazo al driver TB6600. Este driver puede usarse con el mismo código que el A4988 y tiene una corriente nominal de 3.5 A.
El chip driver DRV8825 incluye varias funciones de seguridad integradas como protección contra sobrecorriente, cortocircuito, bloqueo por bajo voltaje y protección contra sobretemperatura. Puedes encontrar más especificaciones en la tabla a continuación.
Especificaciones del DRV8825
| Voltaje mínimo de operación | 8.2 V |
| Voltaje máximo de operación | 45 V |
| Corriente continua por fase | 1.5 A |
| Corriente máxima por fase | 2.2 A |
| Voltaje lógico mínimo | 2.5 V |
| Voltaje lógico máximo | 5.25 V |
| Resolución de microstepping | completo, 1/2, 1/4, 1/8, 1/16 y 1/32 |
| ¿Protección contra voltaje inverso? | No |
| Dimensiones | 15.5 × 20.5 mm (0.6″ × 0.8″) |
| Costo | Check price |
Para más información puedes consultar la hoja de datos aquí.
Diferencias entre DRV8825 y A4988
El DRV8825 es bastante similar al A4988 pero hay algunas diferencias clave:
- El DRV8825 ofrece microstepping de 1/32, mientras que el A4988 solo llega hasta 1/16. Un microstepping más alto resulta en un funcionamiento más suave y silencioso, aunque no siempre es necesario.
- El potenciómetro para el límite de corriente está en una ubicación diferente
- La relación entre el voltaje de referencia y el límite de corriente es distinta.
- El DRV8825 requiere una duración mínima del pulso STEP de 1.9 µs, mientras que el A4988 requiere un mínimo de 1 µs.
- El DRV8825 puede usarse con una fuente de alimentación de motor de mayor voltaje (45 V frente a 35 V). Esto significa que es menos susceptible a daños por picos de voltaje LC.
- El DRV8825 puede entregar un poco más de corriente que el A4988 sin necesidad de refrigeración adicional.
Ten en cuenta que el pinout del DRV8825 es exactamente el mismo que el del A4988, ¡por lo que puede usarse como reemplazo directo!
Configuraciones de microstepping
Los motores paso a paso típicamente tienen un tamaño de paso de 1.8° o 200 pasos por revolución, esto se refiere a pasos completos. Un driver con microstepping como el DRV8825 permite resoluciones más altas al permitir posiciones intermedias de paso. Esto se logra energizando las bobinas con niveles intermedios de corriente.
Por ejemplo, manejar un motor en modo cuarto de paso dará al motor de 200 pasos por revolución 800 micro pasos por revolución usando cuatro niveles diferentes de corriente.
Los pines selectores de resolución (M0, M1 y M2) te permiten seleccionar una de las seis resoluciones de paso según la tabla a continuación.
| M0 | M1 | M2 | Resolución de microstepping |
|---|---|---|---|
| Bajo | Bajo | Bajo | Paso completo |
| Alto | Bajo | Bajo | 1/2 paso |
| Bajo | Alto | Bajo | 1/4 paso |
| Alto | Alto | Bajo | 1/8 paso |
| Bajo | Bajo | Alto | 1/16 paso |
| Alto | Bajo | Alto | 1/32 paso |
| Bajo | Alto | Alto | 1/32 paso |
| Alto | Alto | Alto | 1/32 paso |
Los tres pines tienen resistencias internas de pull-down de 100 kΩ, por lo que dejar los tres pines de selección de microstepping desconectados resulta en modo de paso completo.
A menudo uso un CNC-shield o placa de expansión en combinación con estos drivers. La placa de expansión tiene 3 interruptores DIP para configurar M0 – M2 en alto o bajo y en el CNC-shield puedes instalar jumpers. Si usas el driver con una protoboard, puedes simplemente usar cables puente para conectar los pines selectores a 5 V (es decir, ponerlos en ALTO).
Cableado – Conexión del DRV8825 al Arduino y motor paso a paso
El diagrama de conexiones/esquemático anterior muestra cómo conectar el driver DRV8825 a un motor paso a paso y al Arduino.
Las conexiones también se detallan en la siguiente tabla:
Conexiones del DRV8825
| DRV8825 | Conexión |
|---|---|
| VMOT | 8.2-45 V |
| GND | Masa del motor |
| SLP | 5 V |
| RST | 5 V |
| GND | Masa lógica |
| STP | Pin 3 |
| DIR | Pin 2 |
| A1, A2, B1, B2 | Motor paso a paso |
- La fuente de alimentación del motor se conecta a GND y VMOT (arriba a la derecha).
- Las dos bobinas del motor paso a paso se conectan a A1, A2 y B1, B2 (ver más abajo).
- El pin GND (abajo a la derecha) se conecta a la masa del microcontrolador y VDD se conecta a 5V.
- Los pines STP (step) y DIR (dirección) se conectan a los pines digitales 3 y 2 respectivamente. Puedes elegir otros pines digitales si quieres, pero estos son los que usé para este tutorial y el código de ejemplo.
- Necesitas conectar RST (reset) y SLP (sleep) a 5 V, de lo contrario el driver no se encenderá.
- El pin EN (enable) puede dejarse desconectado, está tirado a bajo por defecto. Cuando este pin se pone en alto, el driver se desactiva.
- El DRV8825 también tiene una salida FAULT que se pone en bajo cuando los FETs del puente H se desactivan por protección contra sobrecorriente o apagado térmico. Este pin se deja desconectado en este tutorial.
En el resto de este tutorial he dejado M0, M1 y M3 desconectados, por lo que el driver opera en modo de paso completo. Esto facilita la explicación del código. Normalmente usaría microstepping de 1/16 o 1/32 y conectaría los pines correspondientes a 5 V (ver tabla en la introducción).
Advertencia
La placa portadora del DRV8825 usa condensadores cerámicos de baja ESR, lo que la hace susceptible a picos destructivos de voltaje LC, especialmente cuando se usan cables de alimentación más largos que unos pocos centímetros.
Para proteger el driver puedes conectar un condensador electrolítico entre VMOT y GND. Pololu recomienda un condensador de 47µF o más (yo usé uno de 100 µF).
¿Cómo determinar el cableado correcto del motor paso a paso?
Si no encuentras la hoja de datos de tu motor paso a paso, puede ser difícil saber cómo conectarlo correctamente. Yo uso el siguiente truco para identificar cómo conectar motores paso a paso bipolares de 4 cables:
Lo único que necesitas identificar son los dos pares de cables que están conectados a las dos bobinas del motor. Los cables de una bobina se conectan a A1 y A2 y los de la otra a B1 y B2, la polaridad no importa.
Para encontrar los dos cables de una bobina, haz lo siguiente con el motor desconectado:
- Intenta girar el eje del motor paso a paso a mano y nota qué tan difícil es girarlo.
- Ahora toma un par de cables al azar del motor y toca sus extremos pelados juntos.
- Luego, intenta girar el eje del motor paso a paso de nuevo.
Si sientes mucha resistencia, has encontrado un par de cables de la misma bobina. Si puedes girar el eje libremente, prueba con otro par de cables. Ahora conecta las dos bobinas a los pines indicados en el diagrama de conexiones anterior.
¿Cómo ajustar el límite de corriente?
Antes de empezar a programar tu Arduino y usar el driver, hay una cosa muy importante que mucha gente olvida: ¡ajustar el límite de corriente!
Este paso no es complicado pero es absolutamente necesario para proteger tu motor paso a paso y el driver. Si no ajustas un límite de corriente adecuado, tu motor puede consumir más corriente de la que él o el driver pueden manejar, lo que probablemente dañará uno o ambos.
Para ajustar el límite de corriente necesitas medir un voltaje de referencia y ajustar el potenciómetro a bordo en consecuencia. Necesitarás un destornillador pequeño, un multímetro para medir el voltaje de referencia y cables con pinzas cocodrilo (opcionales pero muy útiles).
Para medir el voltaje de referencia, el driver debe estar alimentado. El DRV8825 solo necesita alimentación vía VMOT (8.2-45 V) y debes aplicar 5 V a RST y SLP, de lo contrario el driver no se encenderá. Es mejor desconectar el motor paso a paso mientras haces esto.
Si ya has cableado el driver como mostré antes, puedes dejar el Arduino conectado para alimentar los pines RST y SLP.
| DRV8825 | Conexión |
|---|---|
| VMOT | 8.2-45 V |
| GND | Masa del motor |
| SLP | 5V |
| RST | 5V |
| GND | Masa lógica |
Fórmula para el límite de corriente
El siguiente paso es calcular el límite de corriente con la siguiente fórmula:
Límite de corriente = Vref × 2
Esto significa que para un límite de corriente de 1 A, el Vref debe ser 0.5 V.
Para seleccionar el límite de corriente adecuado, consulta la hoja de datos de tu motor paso a paso. Si no encuentras la corriente nominal de tu motor, te recomiendo empezar con un límite de corriente de 1 A. Siempre puedes aumentarlo más tarde si tu motor/driver pierde pasos.
Información adicional: Cuando usas el driver en modo de paso completo, la corriente a través de cada bobina se limita aproximadamente al 70% del límite de corriente establecido. Esto significa que deberías ajustar el límite de corriente un 40% más alto, es decir, 1.4 A en modo de paso completo. Cuando usas microstepping, se aplica la fórmula anterior.
Si tu motor hace mucho ruido, intenta bajar el límite de corriente. Lo ideal es ajustar el límite justo lo suficiente para que el motor no pierda pasos.
Midiendo Vref
Ahora necesitas medir el voltaje de referencia (Vref) entre los dos puntos marcados en la imagen abajo (GND y el potenciómetro) y ajustarlo al valor que calculaste.
Recomiendo usar cables con pinzas cocodrilo sujetados al destornillador para ajustar el límite de corriente. Esto te permite ajustar el potenciómetro y medir el voltaje de referencia al mismo tiempo.
Nota: Hay otra forma de medir el límite de corriente, que es medir directamente la corriente que consume el motor paso a paso. Personalmente, encuentro mucho más fácil el método anterior.
Pololu menciona lo siguiente en su sitio web:
Nota: La corriente en la bobina puede ser muy diferente de la corriente en la fuente de alimentación, por lo que no debes usar la corriente medida en la fuente para ajustar el límite de corriente. El lugar adecuado para colocar tu medidor de corriente es en serie con una de las bobinas del motor paso a paso.
Pololu
Preguntas frecuentes sobre el límite de corriente
¿Necesito tener el motor paso a paso conectado o no?
No, no necesitas conectar el motor al driver para ajustar el límite de corriente. Para estar seguro, desconecta tu motor, ya que a veces interfiere con la medición del voltaje Vref.
¿Necesito hacer girar el motor ejecutando el sketch de motor en Arduino?
No, consulta la pregunta anterior.
¿Debo girar el potenciómetro en sentido horario o antihorario para aumentar Vref?
Esto depende del fabricante del driver. Si tienes una placa original Pololu del DRV8825 o A4988, giras el potenciómetro en sentido horario para aumentar Vref y en sentido antihorario para disminuirlo.
Refrigeración del driver
El chip driver DRV8825 tiene una corriente máxima de 2.5 A por bobina, pero sin disipador solo puede suministrar alrededor de 1.5 A por bobina antes de sobrecalentarse.
El driver suele venir con un pequeño disipador adhesivo, que recomiendo instalar de inmediato. También puedes comprar varios disipadores pequeños en Amazon por muy poco dinero.
Código básico de ejemplo para Arduino para controlar un motor paso a paso
Ahora que has cableado el driver y ajustado el límite de corriente, es hora de conectar el Arduino al ordenador y subir algo de código. Puedes subir el siguiente código de ejemplo a tu Arduino usando el IDE de Arduino. Para este ejemplo específico, no necesitas instalar ninguna biblioteca.
Este sketch controla la velocidad, el número de revoluciones y la dirección de giro del motor paso a paso.
Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.
/* 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);
}
Cómo funciona el código:
El sketch comienza definiendo los pines de step y dirección. Los conecté a los pines 3 y 2 del Arduino.
La instrucción #define se usa para dar nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando se compile el programa. Así que donde menciones dirPin, el compilador lo reemplazará con el valor 2 al compilar el programa.
También definí una constante stepsPerRevolution . Como configuré el driver en modo paso completo, la puse en 200 pasos por revolución. Cambia este valor si tu configuración es diferente.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 200
En la sección setup() del código, todos los pines de control del motor se declaran como salidas digitales con la función pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
En la sección loop() del código, dejamos que el motor gire una revolución lentamente en dirección CW y una revolución rápidamente en dirección CCW. Luego, dejamos que el motor gire 5 revoluciones en cada dirección a alta velocidad. ¿Cómo controlas la velocidad, dirección de giro y número de revoluciones?
// 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);
}
Controlar la dirección de giro:
Para controlar la dirección de giro del motor paso a paso, configuramos el pin DIR (dirección) en ALTO o BAJO. Para esto usamos la función digitalWrite(). Dependiendo de cómo conectaste el motor, poner el pin DIR en alto hará que el motor gire en sentido CW o CCW.
Controlar el número de pasos o revoluciones:
En este sketch de ejemplo, el for loops controla el número de pasos que dará el motor paso a paso. El código dentro del bucle for resulta en 1 paso del motor. Como el código en el bucle se ejecuta 200 veces (stepsPerRevolution), esto resulta en 1 revolución. En los dos últimos bucles, el código dentro del for se ejecuta 1000 veces, lo que resulta en 1000 pasos o 5 revoluciones.
Ten en cuenta que puedes cambiar el segundo término en el bucle for al número de pasos que desees. for(int i = 0; i < 100; i++) resultaría en 100 pasos, o media revolución.
Controlar la velocidad:
La velocidad del motor paso a paso está determinada por la frecuencia de los pulsos que enviamos al pin STEP. A mayor frecuencia, más rápido gira el motor. Puedes controlar la frecuencia de los pulsos cambiando delayMicroseconds() en el código. Cuanto más corto sea el retardo, mayor la frecuencia y más rápido gira el motor.
Tutorial de la biblioteca AccelStepper
La biblioteca AccelStepper escrita por Mike McCauley es una biblioteca excelente para usar en tu proyecto. Una de sus ventajas es que soporta aceleración y desaceleración, pero también tiene muchas otras funciones útiles.
Puedes instalar la biblioteca yendo a Tools > Manage Libraries… o presionando Ctrl + Shift + I en Windows. Se abrirá el Library Manager y actualizará la lista de bibliotecas instaladas.
Puedes buscar ‘accelstepper’ y buscar la biblioteca de Mike McCauley. Selecciona la última versión y luego haz clic en Install.
1. Código de ejemplo para rotación continua
El siguiente sketch puede usarse para hacer girar uno o más motores paso a paso continuamente a velocidad constante. (No se usa aceleración ni desaceleración).
/* 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();
}
Cómo funciona el código:
El primer paso es incluir la biblioteca con #include "AccelStepper.h".
#include "AccelStepper.h"
El siguiente paso es definir las conexiones del DRV8825 al Arduino y el tipo de interfaz del motor. El tipo de interfaz debe configurarse en 1 cuando se usa un driver de step y direction.
La instrucción #define se usa para dar nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando se compile el programa. Así que donde menciones dirPin, el compilador lo reemplazará con el valor 2 al compilar el programa.
// 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
Luego, necesitas crear una nueva instancia de la clase AccelStepper con el tipo de interfaz y conexiones apropiadas.
En este caso, llamé al motor paso a paso ‘stepper’ pero puedes usar otros nombres también, como ‘z_motor’ o ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. El nombre que le des al motor paso a paso se usará más adelante para configurar la velocidad, posición y aceleración de ese motor en particular. Puedes crear múltiples instancias de la clase AccelStepper con diferentes nombres y pines. Esto te permite controlar fácilmente 2 o más motores paso a paso al mismo tiempo.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
En la sección setup() del código definimos la velocidad máxima en pasos/segundo. Velocidades superiores a 1000 pasos por segundo pueden ser poco fiables, así que establecí este valor como máximo. Nota que especifico el nombre del motor paso a paso (‘stepper’) para el que quiero definir la velocidad máxima. Si tienes varios motores conectados, puedes especificar una velocidad diferente para cada uno:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(500);
}
En la sección loop() primero configuramos la velocidad a la que queremos que gire el motor. Para esto usamos la función setSpeed(). (también puedes colocar esto en la sección setup del código).
stepper.runSpeed() consulta el motor y cuando toca dar un paso, ejecuta 1 paso. Esto depende de la velocidad configurada y del tiempo desde el último paso. Si quieres cambiar la dirección del motor, puedes poner una velocidad negativa: stepper.setSpeed(-400); hace girar el motor en la dirección contraria.
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. Código de ejemplo para controlar número de pasos o revoluciones
Para hacer que el motor gire un número específico de pasos prefiero usar un while loop en combinación con stepper.currentPosition(). Puedes usar el siguiente código de ejemplo para hacer que el motor gire de un lado a otro.
/*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);
}
Explicación del código:
La primera parte del código hasta la sección loop() es exactamente igual que en el ejemplo anterior.
En el loop uso un bucle while en combinación con la función currentPosition() . Primero, pongo la posición actual del motor paso a paso a cero con stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
Luego usamos el bucle while. Un bucle while se ejecuta continuamente e infinitamente hasta que la expresión dentro del paréntesis, (), se vuelve falsa. Así que, en este caso, compruebo si la posición actual del motor paso a paso no es igual a 400 pasos (!= significa: no es igual a). Mientras esto sea cierto, hacemos girar el motor a una velocidad constante configurada con 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();
}
En el resto del loop hacemos exactamente lo mismo, solo que con una velocidad y posición objetivo diferentes.
3. Código de ejemplo con aceleración y desaceleración
Con el siguiente sketch puedes añadir aceleración y desaceleración a los movimientos del motor paso a paso, sin necesidad de código complicado. En el ejemplo, el motor girará de un lado a otro a 200 pasos por segundo con una aceleración de 30 pasos por segundo al cuadrado.
/* 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);
}
Explicación del código:
En setup(), además de la velocidad máxima, necesitamos definir la aceleración/desaceleración. Para esto usamos la función setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
En la sección loop del código, usé una forma diferente para hacer que el motor gire un número predefinido de pasos. La función stepper.moveTo() se usa para establecer la posición objetivo. La función stepper.runToPostion() mueve el motor (con aceleración/desaceleración) a la posición objetivo y bloquea hasta que llega a ella. Como esta función es bloqueante, no deberías usarla si necesitas controlar otras cosas al mismo tiempo.
// Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Conclusión
En este artículo te he mostrado cómo controlar un motor paso a paso con el driver DRV8825 y Arduino. Si quieres aprender más sobre otros drivers para motores paso a paso, los artículos a continuación pueden ser útiles:
- 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
Y si tienes algún comentario, no dudes en dejarlo en la sección de comentarios.
