Cómo controlar un motor paso a paso con el A4988 y Arduino

Cómo controlar un motor paso a paso con A4988

Este artículo incluye todo lo que necesitas saber sobre cómo controlar un motor paso a paso con el conductor del motor paso a paso A4988 y Arduino. He 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 recomendamos 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.

Lo qué vas a necesitar

Componentes de hardware

  • Conductor de motor a pasos A4988
  • Motor paso a paso NEMA 17
  • Arduino Uno Rev3
  • Protoboard
  • Cables
  • Condensador (100 µF)
  • Fuente de alimentación (8-35 V)

Te puede ser útil usar este controlador en combinación con un Shield CNC o una placa de expansión. Tal escudo ya incluye condensadores y ofrece una forma fácil de seleccionar la resolución de micro-pasos. Hace que el cableado sea mucho más fácil y es una gran opción si necesitas una solución más permanente que una placa de expansión.

Herramientas

  • Pequeño destornillador
  • Multímetro
  • Cables de prueba de cocodrilo (opcional)

Software

  • Arduino IDE Arduino IDE

Qué es  el controlador A4988

En el corazón del controlador A4988 encontrarás un chip hecho por Allegro MicroSystems: el controlador de micropasos DMOS A4988 con traductor y protección contra sobrecorriente. Este controlador de motor integrado hace que la interfaz con un microcontrolador sea muy fácil, ya que sólo necesita dos pines para controlar tanto la velocidad como la dirección del motor de pasos.

El controlador tiene una capacidad máxima de salida de 35 V 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, echa 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 A4988

Voltaje mínimo de funcionamiento8 V
Voltaje máximo de funcionamiento35 V
Corriente continua por fase1 A
Corriente máxima por fase2 A
Voltaje lógico mínimo3 V
Máximo voltaje lógico5.5 V
Resolución de micropasosfull, 1/2, 1/4, 1/8 and 1/16
¿Protección de voltaje inverso?No
Dimensiones15.5 × 20.5 mm (0.6″ × 0.8″)

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

Diferencias entre el A4988 y el DRV8825

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 del pulso de STEP 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.

diferencias A4988 y DRV8825 - Cómo controlar un motor paso a paso con el A4988 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 A4988 permite resoluciones más altas al permitir ubicaciones de pasos intermedios. Esto se logra energizando las bobinas con niveles de corriente intermedios.

Por ejemplo, si se impulsa un motor en 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.

A4988 pinout - Cómo controlar un motor paso a paso con el A4988 y Arduino

Las clavijas de selección de resolución (tamaño del paso) (MS1, MS2 y MS3) permiten seleccionar una de las cinco resoluciones de paso según la tabla siguiente:

MS1MS2MS3Microstep resolution
LowLowLowFull step
HighLowLow1/2 step
LowHighLow1/4 step
HighHighLow1/8 step
HighHighHigh1/16 step

Las tres entradas tienen resistencias internas 100kΩ pull-down, por lo que dejar los tres pines de selección de micropasos desconectados resulta en un modo de paso completo.

A menudo se puede usar un shield CNC o una placa de expansión en combinación con estos controladores. La tarjeta de expansión tiene 3 interruptores DIP para ajustar MS1 – MS3 alto o bajo y en el escudo CNC se pueden instalar puentes. Si utilizas el controlador con una placa de expansión, puedes usar cables de puente para conectar los pines del selector a 5V.

Cableado. Conectando el A4988 a Arduino y el motor paso a paso

controlar un motor de pasos con el A4988 - Cómo controlar un motor paso a paso con el A4988 y Arduino

El diagrama de cableado/esquema de arriba muestra cómo conectar el controlador del A4899 con un motor a pasos y el Arduino.

Las conexiones también se ven en la siguiente tabla:

A4988Conexión
VMOT8-35V
GNDMotor ground
SLPRESET
RSTSLP
VDD5V
GNDLogic ground
STPPin 3
DIRPin 2
A1, A2, B1, B2Stepper motor
  • 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 he usado para este tutorial y el código de ejemplo.
  • El pin SLP es una entrada baja activa. Es decir, al tirar de este pin bajo se pone al conductor en modo de espera, minimizando el consumo de energía. RST también es una entrada baja activa. Cuando se
  • tira de baja, todas las entradas de STEP se ignoran hasta que se tira de alta. Si no está usando la clavija, puede conectarla a la clavija SLP/SLEEP adyacente para ponerla en alto y activar el controlador.
  • El pin EN (habilitar) puede dejarse desconectado, por defecto se tira de él hacia abajo. Cuando esta patilla se pone en alto, el controlador se desactiva.

En el resto de este tutorial hemos dejado desconectados 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 utilizaríamos 1/8 o 1/16 de micropasos y conectaríamos los pines apropiados a 5V (ver tabla en la introducción).

Advertencia

La placa portadora A4988 utiliza un condensador cerámico de baja ERS, lo que la hace susceptible a picos de tensión LC destructivos, 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 (yo usé 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. Puedes usar 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. También puede encontrar más información en el wiki RepRap.org.

¿Cómo establecer el límite actual?

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).

limite corriente A4988 - Cómo controlar un motor paso a paso con el A4988 y Arduino

Para medir el voltaje de referencia, el conductor necesita ser alimentado. El A4988 sólo necesita alimentación a través de VDD (5V) y necesita conectar RST y SLP juntos, de lo contrario el driver no se encenderá. Es mejor desconectar el motor de pasos mientras se hace esto.

Si ya has conectado el conductor, puedes dejar todo menos el motor de pasos conectado. Puedes aplicar la energía a través del puerto USB del Arduino.

Conexiones necesarias para establecer el límite de corriente
A4988Connection
VDD5V
RSTSLP
SLPRESET
GNDGround

Fórmula del límite de corriente

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

Límite de corriente = Vref ÷ (8 × Rcs)

El Rcs es la actual resistencia sensorial. Si compraste un controlador A4988 de Pololu antes de enero de 2017, el Rcs será 0.050 Ω. Los drivers vendidos después de eso tienen 0,068 Ω resistencias sensibles a la corriente.

Esto significa que para un límite de corriente de 1A para una placa con 0,068 Ω resistencias con sentido de la corriente, el Vref debería ser de 540 mV.

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

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.

Ten en cuenta que necesitas recalibrar el límite de corriente si cambias el voltaje de la fuente de alimentación del motor. Si el motor hace mucho ruido, intente reducir el límite de corriente. Es mejor establecer el límite de corriente lo suficientemente alto para que el motor no se salte los pasos.

Medición de 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.

limite de corriente resitencia - Cómo controlar un motor paso a paso con el A4988 y Arduino

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 mucho más fácil.

Pololu menciona lo siguiente en su sitio web:

“Nota: La corriente de la bobina puede ser muy diferente de la corriente de la fuente de alimentación, por lo que no se debe utilizar la corriente medida en la fuente de alimentación para establecer el límite de corriente. El lugar apropiado para poner su medidor de corriente es en serie con una de las bobinas de su motor de paso”.

Preguntas sobre límite de corriente

  • ¿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, desconecte su motor, a veces interfiere con la medición del voltaje Vref.
  • ¿Necesito encender el motor ejecutando el sketch del motor de Arduino? No, mira 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 controlador IC A4988 tiene una corriente máxima de 2 A por bobina, pero sin un disipador de calor sólo puede suministrar alrededor de 1 A por bobina antes de que comience a sobrecalentarse.

El driver suele venir con un pequeño disipador de calor con adhesivo, que recomiendo 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 su 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.

/*Example sketch to control a stepper motor with A4988 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 conectamos 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 stepsPerRevolution. Como pusimos el controlador en modo de pasos completos lo puse 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);
}

Controla 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.

Controla el número de pasos o revoluciones:

En este código 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.

Controla 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 delayMicroseconds() 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.

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.

instalar libreria accelerate - Cómo controlar un motor paso a paso con el A4988 y Arduino

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

instalar libreria accelerate con Arduino IDE - Cómo controlar un motor paso a paso con el A4988 y Arduino

1. Código de ejemplo de rotación continua

El siguiente esquema 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 A4988 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 de la A4988 a Arduino y el tipo de interfaz del motor. El tipo de interfaz del motor debe estar configurado en 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 llamamos 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 he establecido esto como el máximo. Date cuenta de que especificamos el nombre del motor de pasos (‘stepper’), para el cual quiero definir la velocidad máxima. Si tienes varios motores paso a paso conectados, puedes 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();
}

2. Ejemplo de código para controlar el número de pasos o revoluciones

Para dejar que el motor gire un número específico de pasos preferimos usar un bucle while en combinación con stepper.currentPosition(). Puedes usar el siguiente código de ejemplo, para dejar que el motor gire de un lado a otro.

/*Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: number of steps or revolutions. */

// 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);
}

Explicación del código:

La primera parte del código hasta la sección loop() es exactamente la misma que en el ejemplo anterior.

En el bucle utilizamos un bucle while en combinación con la función currentPosition(). Primero, ponemos la posición actual del motor de pasos a cero con stepper.setCurrentPosition(0).

// Set the current position to 0:
stepper.setCurrentPosition(0);

A continuación utilizamos el loop while. El loop while se repetirá continuamente, e infinitamente, hasta que la expresión dentro del paréntesis, () se vuelva falsa. Así que en este caso comprobamos si la posición actual del motor de pasos no es igual a 400 pasos (!= significa: no es igual a). Mientras que este no es el caso, hacemos funcionar el motor a pasos a una velocidad constante como se establece en 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 bucle, hacemos exactamente lo mismo, sólo que con una velocidad y posición del objetivo diferentes.

3. Código de ejemplo de aceleración y desaceleración

Con el siguiente código 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 A4988 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, utilizamos 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 de la A4988 y Arduino. Espero que lo hayas encontrado útil e informativo. Si es así, por favor compártelo con un amigo que también le guste la electrónica y arduino.

Última actualización el 2020-05-31 / Enlaces de afiliados / Imágenes de la API para Afiliados

Pin It on Pinterest

Shares