C贸mo controlar un motor de pasos con el conductor DRV8825 y Arduino

Todo lo que necesitas saber del DRV8825

Este artículo incluye todo lo que necesitas saber sobre el control de un motor paso a paso con el conductor del motor paso a paso DRV8825 y Arduino. Hemos incluido un diagrama de cableado, un tutorial sobre cómo establecer el límite de corriente y muchos códigos de ejemplo.

Aunque puedes usar este controlador sin la biblioteca de Arduino, te recomiendamos encarecidamente que también eches un vistazo al código de ejemplo de la biblioteca AccelStepper al final de este tutorial. Esta biblioteca es bastante fácil de usar y puede mejorar enormemente el rendimiento de tu hardware.

Después de cada ejemplo, desglosamos y explicamos cómo funciona el código, por lo que no deberías tener problemas para modificarlo según tus necesidades.

Driver DRV8825

En el corazón del controlador DRV8825 encontrarás un chip hecho por Texas Instruments: el controlador de motor a pasos DRV8825 IC. Este controlador de motor integrado hace que la interfaz con un microcontrolador sea muy fácil, ya que sólo se necesitan dos pines para controlar tanto la velocidad como la dirección del motor a pasos.

El controlador tiene una capacidad máxima de salida de 45V y ± 2 A, lo que es ideal para controlar motores paso a paso pequeños y medianos como un motor paso a paso bipolar NEMA 17.

Si necesitas controlar motores paso a paso más grandes como el NEMA 23, deberías echar un vistazo al conductor del motor paso a paso TB6600. Este controlador puede ser usado con el mismo código que el A4988 y tiene una corriente nominal de 3.5 A.

El chip tiene varias funciones de seguridad incorporadas como la protección contra sobrecorriente, cortocircuito, bloqueo por bajo voltaje y sobre temperatura. Puedes encontrar más especificaciones en la tabla de abajo.

Especificaciones del DRV8825

  • Tensión mínima de funcionamiento, 8,2 V
  • Máximo voltaje de funcionamiento, 45 V
  • Corriente continua por fase, 1,5 A
  • Corriente máxima por fase, 2,2 A
  • Tensión lógica mínima, 2,5 V
  • Máximo voltaje lógico, 5.25 V
  • Resolución de micropasos completa, 1/2, 1/4, 1/8, 1/16 y 1/32
  • ¿Protección de voltaje inverso? No
  • Dimensiones, 15,5 × 20,5 mm (0.6″ × 0.8″)

Para más información puede consultar la hoja de datos o datasheet en este enlace aquí.

Diferencias entre DRV8825 y A4988

El DRV8825 es bastante similar al A4988 pero hay algunas diferencias clave:

  • El DRV8825 ofrece 1/32 micro-pasos, mientras que el A4988 sólo baja a 1/16-pasos. Los micro-pasos más altos resultan en una operación más suave y silenciosa, pero no siempre son necesarios.
  • El potenciómetro de límite de corriente está en un lugar diferente
  • La relación entre el voltaje de referencia y el límite de corriente es diferente.
  • El DRV8825 requiere una duración mínima de pulso de PASO de 1,9µs, el A4988 requiere un mínimo de 1µs.
  • El DRV8825 puede ser usado con una fuente de alimentación de motor de mayor voltaje (45 V vs 35 V). Esto significa que es menos susceptible de sufrir daños por los picos de tensión del LC.
  • El DRV8825 puede suministrar 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, así que puede ser usado como un sustituto.

A4899 vs DRV8825 - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

Ajustes de micropasos

Los motores paso a paso suelen tener un tamaño de paso de 1,8° o 200 pasos por revolución, esto se refiere a pasos completos. Un motor de micro-pasos como el DRV8825 permite resoluciones más altas permitiendo ubicaciones de pasos intermedios. Esto se logra energizando las bobinas con niveles de corriente intermedios.

Por ejemplo, al impulsar un motor en el modo de cuarto de paso, el motor de 200 pasos por revolución dará 800 micropasos por revolución utilizando cuatro niveles de corriente diferentes.

DRV8825 Motor Driver Pinout

DRV8825 Pinout - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

  • Los pines VMOT y la GND MOT suministran la energía para el motor, que puede ser de 8,2V a 45V. El módulo no tiene ninguna clavija de alimentación lógica ya que el DRV8825 obtiene su energía del regulador de voltaje interno de 3V3.  Sin embargo, debe compartir la tierra del microcontrolador con el pin lógico GND. Según la hoja de datos, la alimentación del motor requiere un condensador de desacoplamiento apropiado cerca de la placa, capaz de sostener 4A.
  • El controlador DRV8825 tiene tres entradas selectoras de tamaño (resolución) de paso, a saber, M0, M1 y M2. Al establecer los niveles lógicos apropiados para estas clavijas podemos configurar los motores a una de las seis resoluciones de paso. Estos tres pines de selección de micro-pasos son tirados LOW por las resistencias internas, así que si los dejamos desconectados, el motor funcionará en modo de paso completo.
  • La entrada STEP controla los micropasos del motor. Cada pulso HIGH enviado a esta clavija hace avanzar el motor por el número de micropasos establecidos por las clavijas de selección de micropasos. Cuanto más rápidos sean los pulsos, más rápido girará el motor.
  • La entrada DIR controla la dirección de giro del motor. Al tirar de él en HIGH , el motor gira en el sentido de las agujas del reloj, y al tirar de él en LOW , el motor gira en el sentido contrario a las agujas del reloj.
  • El pin EN está activa en la entrada baja, cuando se tira de ella LOW (lógica 0) se activa el controlador DRV8825. Por defecto, este pin se tira de baja para que el controlador esté siempre habilitado, a menos que lo tire de HIGH.
  • El pin SLP está activo en la entrada baja. Significa que al tirar de este pin LOW se pone el driver en modo de espera, minimizando el consumo de energía. Puedes utilizar esto especialmente cuando el motor no está en uso para conservar la energía.
  • RST también es una entrada baja activa. Cuando se tira de LOW, todas las entradas STEP son ignoradas, hasta que se tira de HIGH. También reinicia el controlador ajustando el traductor interno a un estado Home predefinido. El estado inicial es básicamente la posición inicial desde la que el motor arranca y es diferente dependiendo de la resolución de los micro pasos.
  • El DRV8825 también cuenta con una salida de FAULT que impulsa a LOW cuando los FET del puente H se desactivan como resultado de una protección de sobrecorriente o de un apagado térmico. En realidad, el pin de la falla está en cortocircuito con el pin de SLEEP, por lo que cuando el pin de la falla se activa en BAJA, todo el chip se desactiva. Y permanece deshabilitado hasta que se reajuste o se retire el VMOT de voltaje del motor y se vuelva a aplicar.
  • Los canales de salida del motor DRV8825 se rompen hasta el borde del módulo con los pines B2, B1, A1 y A2. Se puede conectar a estas clavijas cualquier motor de paso bipolar con voltajes entre 8,2V y 45 V. Cada clavija de salida del módulo puede entregar hasta 2,2A al motor. Sin embargo, la cantidad de corriente suministrada al motor depende de la fuente de alimentación del sistema, el sistema de refrigeración y el ajuste de limitación de corriente.

Los pinesde selección de resolución (tamaño del paso) (M0, M1 y M2) ye permiten seleccionar una de las seis resoluciones del paso según la tabla siguiente.

M0M1M2Microstep Resolution
LowLowLowUn paso
HighLowLowMedio Paso
LowHighLow1/4 Paso
HighHighLow1/8 Paso
LowLowHigh1/16 Paso
HighLowHigh1/32 Paso
LowHighHigh1/32 Paso
HighHighHigh1/32 Paso

Cableado, conectando el DRV8825 a Arduino y el motor paso a paso

El diagrama de cableado/esquema de arriba muestra cómo conectar el conductor DRV8825 a un motor de pasos y al Arduino.

DRV8825 stepper motor - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

Las conexiones también las podemos ver en la siguiente tabla:

DRV8825Conexión
VMOT8.2-45V
GNDMotor ground
SLP5V
RST5V
GNDLogic ground
STPPin 3
DIRPin 2
A1, A2, B1, B2Motor paso a paso
  • La fuente de alimentación del motor está conectada a GND y VMOT (arriba a la derecha).
  • Las dos bobinas del motor paso a paso están conectadas a A1, A2 y B1, B2 (ver abajo).
  • La clavija GND (abajo a la derecha) está conectada a la clavija de tierra del microcontrolador y VDD está conectada a 5V.
  • La clavija STP (paso) y DIR (dirección) están conectadas a las clavijas digitales 3 y 2 respectivamente. Puedes elegir un pin digital diferente si quieres, pero estos son los que hemos usado para este tutorial y el código de ejemplo.
  • Necesitas conectar RST (reset) y SLP (sleep) a 5V, de lo contrario el conductor no se encenderá.
  • La clavija EN (habilitar) puede dejarse desconectada, se tira de ella por defecto. Cuando esta clavija se pone en alto, el controlador se desactiva.
  • El DRV8825 también cuenta con una salida de FAIL que se activa en bajo cuando los FET del puente H se desactivan como resultado de la protección contra sobrecorriente o el apagado térmico. Este pin se deja desconectado para este tutorial.

En el resto de este tutorial hemos dejado desconectados los MS1, MS2 y MS3, por lo que el controlador funciona en modo de paso completo. Esto hace que explicar el código sea un poco más fácil. Normalmente usarías 1/16 o 1/32 micro-pasos y conectarías los pines apropiados a 5V.

Advertencia

La placa del DRV8825 utiliza un condensador cerámico de baja energía, lo que la hace susceptible a los picos de voltaje destructivos de LC, especialmente cuando se utilizan cables de alimentación de más de unos pocos centímetros.

Para proteger el conductor puedes conectar un condensador electrolítico entre VMOT y GND. Pololu sugiere un condensador de 47µF o más (puedes usar un condensador de 100 µF).

¿Cómo determinar el cableado correcto del motor de paso a paso?

Si no puedes encontrar la hoja de datos de tu motor de paso a paso, puede ser difícil averiguar cómo cablear tu motor correctamente. Utilizamos el siguiente truco para determinar cómo conectar motores de 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 1A y 1B y el otro a 2A y 2B, 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 de pasos a mano y nota lo difícil que es de girar.
  • Ahora escoge un par de cables al azar del motor y toca los extremos desnudos.
  • A continuación, intenta girar el eje del motor de pasos de nuevo.

Si sientes mucha resistencia, has encontrado un par de cables de la misma bobina. Si puedes girar el eje libremente, intenta con otro par de cables. Ahora conecta las dos bobinas a los pines que se muestran en el diagrama de cableado anterior.

¿Cómo establecer el límite de corriente?

Antes de empezar a programar tu Arduino y empezar a usar el driver hay una cosa muy importante que debes hacer y que mucha gente olvida: establecer el límite de corriente.

Este paso no es muy complicado pero es absolutamente necesario para proteger tu motor de pasos y el conductor. Si no estableces un límite de corriente apropiado, tu motor puede consumir más corriente de la que puede soportar o tu conductor, lo que puede dañar a uno o a ambos.

Para establecer el límite de corriente es necesario medir un voltaje de referencia y ajustar el potenciómetro de a bordo en consecuencia. Necesitarás un pequeño destornillador, un multímetro para medir el voltaje de referencia y cables de prueba de cocodrilo (opcionales pero muy prácticos).

DRV8825 conexión con Arduino - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

Para medir el voltaje de referencia, el conductor necesita ser alimentado. El DRV8825 sólo necesita alimentación a través de VMOT (8,2-45V) y hay que aplicar 5V a RST y SLP, de lo contrario el conductor no se encenderá. Es mejor desconectar el motor de pasos mientras se hace esto.

Si ya has conectado el driver como he mostrado antes, puedes dejar el Arduino conectado para alimentar los pines RST y SLP.

Fórmula del límite de corriente

GND y potenciómetro - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

El siguiente paso es calcular el límite actual con la siguiente fórmula:

Límite de corriente = Vref × 2

Esto significa que para un límite de corriente de 1A el Vref debería ser de 0,5V.

Para seleccionar el límite de corriente correcto, echa un vistazo a la hoja de datos de su motor de pasos. Si no puedes encontrar la capacidad de corriente de tu motor, te recomiendamos que empieces con un límite de corriente de 1A. Siempre puedes aumentarlo más tarde si a su motor/conductor le faltan pasos.

Información adicional: Cuando se utiliza el conductor en el modo de pasos completos, la corriente que pasa por cada bobina se limita a aproximadamente el 70% del límite de corriente establecido. Esto significa que necesitarías ajustar el límite de corriente un 40% más alto o 1,4 A en el modo de paso completo. Cuando se utiliza el micropaso, se aplica la fórmula anterior.

Si tu motor hace mucho ruido, trate de bajar el límite de corriente. Es mejor establecer el límite de corriente lo suficientemente alto para que el motor no pierda pasos.

Medición del Vref

Ahora tendrás que medir el voltaje de referencia (Vref) entre los dos puntos marcados en la imagen de abajo (GND y el potenciómetro) y ajustarlo al valor que has calculado.

DRV8825-Puntos de sonda de límite de corriente
Puntos de la sonda Vref (GND y potenciómetro).

Recomendamos usar cables de prueba de cocodrilo sujetados al destornillador para fijar el límite de corriente. Esto permite ajustar el potenciómetro y medir el voltaje de referencia al mismo tiempo.

Hay otra forma de medir el límite de corriente y es medir directamente el consumo de corriente del motor de pasos. El método anterior es mucho más fácil.

¿Necesito tener el motor de pasos conectado o no?
No, no es necesario conectar el motor de pasos al conductor cuando se establece el límite de corriente. Para estar seguros, desconecta tu motor, a veces interfiere con la medición del voltaje Vref.

¿Necesito encender el motor ejecutando el sketch del motor de Arduino?
No, vea la pregunta anterior.

¿Necesito girar el potenciómetro en el sentido de las agujas del reloj o en sentido contrario para elevar el Vref?
Esto depende del fabricante del conductor. Si tienes placas de arranque Polulu genuinas del DRV8825 o A4988 giras el potenciómetro en el sentido de las agujas del reloj para subir el Vref y en el sentido contrario para bajarlo.

Enfriar el conductor

El DRV8825 driver IC tiene una corriente máxima de 2,5 A por bobina, pero sin un disipador de calor sólo puede suministrar alrededor de 1,5 A por bobina antes de que empiece a recalentarse.

El controlador normalmente viene con un pequeño disipador de calor con adhesivo, que recomiendamos que se instale de inmediato. También puedes comprar un montón de pequeños disipadores de calor de Amazon a un precio realmente barato.

Código de ejemplo básico de Arduino para controlar un motor de pasos

Ahora que has conectado el controlador y establecido el límite de corriente, es hora de conectar el Arduino al ordenador y subir algún código. Puedes cargar el siguiente código de ejemplo en tu Arduino utilizando el IDE de Arduino. Para este ejemplo específico no necesitas instalar ninguna biblioteca.

Este código controla tanto la velocidad, el número de revoluciones y el sentido de giro del motor paso a paso.

Puedes abrir el código en una nueva ventana haciendo clic en el botón de la esquina superior derecha.

/*Example sketch to control a stepper motor with A4988/DRV8825 stepper motor driver and Arduino without a library.
// 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 con la definición de los pines de paso y dirección. Los conecté a los pines 3 y 2 de Arduino.

La frase #define se usa para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando el programa sea compilado. Así que en cualquier lugar que se mencione dirPin, el compilador lo reemplazará con el valor 2 cuando el programa sea compilado.

También hemos definido una constante de pasos por revolución. Como pusimos el controlador en modo de pasos completos lo pusimos a 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 OUTPUT digital 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. A continuación dejamos que el motor gire 5 revoluciones en cada dirección con una alta velocidad. Entonces, ¿cómo se controla la velocidad, la dirección de giro y el 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 el sentido de giro del motor de paso, ponemos el pin de dirección en HIGH o LOW. Para ello utilizamos la función digitalWrite(). Dependiendo de cómo hayas conectado el motor de paso, al poner la clavija DIR en alto, el motor girará en CW o en CCW.

Controlar el número de pasos o revoluciones

En este boceto de ejemplo, los bucles de for controlan el número de pasos que el motor de pasos dará. El código dentro del bucle for resulta en 1 paso del motor de pasos. Debido a que 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 bucle para 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 por el número de pasos que quieras. for(int i = 0; i < 100; i++) resultaría en 100 pasos, o media revolución.

Controlar la velocidad

La velocidad del motor de pasos está determinada por la frecuencia de los pulsos que enviamos a la clavija STEP. Cuanto más alta es la frecuencia, más rápido funciona el motor. Puedes controlar la frecuencia de los pulsos cambiando delayMicrosegundos() en el código. Cuanto más corto el retraso, más alta la frecuencia, más rápido funciona el motor.

Tutorial de la biblioteca AccelStepper

La biblioteca AccelStepper escrita por Mike McCauley es una biblioteca impresionante que puedes usar en tu proyecto. Una de sus ventajas es que soporta la aceleración y la desaceleración, pero también tiene muchas otras buenas funciones.

Puede descargar la última versión de esta biblioteca aquí.

Puedes instalar la librería yendo a Sketch > Include Library > Add .ZIP Library… en el IDE de Arduino.

instalar libreria arduino - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

Otra opción es ir a Herramientas > Gestionar Bibliotecas… o escribir Ctrl + Shift + I en Windows. El Administrador de Bibliotecas abrirá y actualizará la lista de bibliotecas instaladas.

Puedes buscar “accelstepper” y buscar la biblioteca de Mike McCauley. Selecciona la última versión y haz clic en Instalar.

instalar libreria arduino IDE - Cómo controlar un motor de pasos con el conductor DRV8825 y Arduino

 

Código de ejemplo de rotación continua

El siguiente código puede ser usado para hacer funcionar uno o más motores paso a paso continuamente a una velocidad constante. (No se utiliza ninguna aceleración o desaceleración).

/*Example sketch to control a stepper motor with DRV8825 stepper motor driver, AccelStepper library and Arduino: continuous rotation.
// 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();
}

Cómo funciona el código:

El primer paso es incluir la biblioteca con #include <AccelStepper.h>.
// Include the AccelStepper library:
#include <AccelStepper.h>

El siguiente paso es definir las conexiones DRV8825 a Arduino y el tipo de interfaz del motor. El tipo de interfaz del motor debe estar configurado a 1 cuando se utiliza un controlador de paso y dirección. Puedes encontrar los otros tipos de interfaz aquí.

La sentencia #define se utiliza para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando el programa sea compilado. Por lo tanto, en cualquier lugar que se mencione dirPin, el compilador lo reemplazará con el valor 2 cuando el programa sea compilado.

// 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

A continuación, hay que crear una nueva instancia de la clase AccelStepper con el tipo de interfaz de motor y las conexiones apropiadas.

En este caso llamé al motor paso a paso “stepper” pero también puedes usar otros nombres, como “z_motor” o “liftmotor” etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. El nombre que se le dé al motor paso a paso se utilizará más adelante para establecer la velocidad, la posición y la 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 de más de 1000 pasos por segundo pueden ser poco fiables, por lo que establezco esto como el máximo. Note que especifico el nombre del motor de pasos (‘stepper’), para el cual quiero definir la velocidad máxima. Si tienes varios motores paso a paso conectados, puede especificar una velocidad diferente para cada motor:

void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(500);
}

En el loop() primero fijamos la velocidad a la que queremos que funcione el motor. Para ello utilizamos la función setSpeed(). (también puedes colocarla en la sección de configuración del código).

stepper.runSpeed() sondea el motor y cuando se debe dar un paso, ejecuta 1 paso. Esto depende de la velocidad establecida y del tiempo transcurrido desde el último paso. Si quieres cambiar la dirección del motor, puedes establecer una velocidad negativa: stepper.setSpeed(-400); gira el motor en sentido contrario.

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ódigo de ejemplo de aceleración y desaceleración

Con el siguiente boceto se puede añadir aceleración y desaceleración a los movimientos del motor de pasos, sin ninguna codificación complicada. En el siguiente ejemplo, el motor irá de un lado a otro con una velocidad de 200 pasos por segundo y una aceleración de 30 pasos por segundo por segundo.

/*Example sketch to control a stepper motor with DRV8825 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.
// 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);
}

Explicación del código:

En el setup(), además de la velocidad máxima, necesitamos definir la aceleración/desaceleración. Para ello utilizamos la función setAcceleration().

void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}

En la sección de bucle del código, utilicé una forma diferente de dejar que el motor gire un número predefinido de pasos. La función stepper.moveTo() se utiliza para establecer la posición del objetivo. La función stepper.runToPostion() mueve el motor (con aceleración/desaceleración) a la posición objetivo y lo bloquea hasta que se encuentra en la posición objetivo. Debido a que esta función bloquea, no deberías usarla cuando 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 os hemos mostrado cómo controlar un motor de pasos con el motor de pasos DRV8825 y Arduino. Esperamos que lo hayas encontrado útil e informativo.

Este tipo de controlador se puede usar para un montón de impresoras 3D y otros proyectos relacionados con CNC.

Pin It on Pinterest

Shares