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

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

Aunque puede utilizar este controlador sin una biblioteca de Arduino, le recomiendo encarecidamente que también eche 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 en gran medida el rendimiento de su hardware.

Después de cada ejemplo, desgloso y explico cómo funciona el código, por lo que no deberías tener problemas para modificarlo y adaptarlo a tus necesidades.

Si quiere saber más sobre otros controladores de motores paso a paso, los artículos siguientes pueden resultarle útiles:

• Cómo controlar un motor paso a paso con el driver DRV8825 y Arduino
• Motor paso a paso 28BYJ-48 con controlador ULN2003 y tutorial de Arduino
• Cómo controlar un motor paso a paso con Arduino Motor Shield Rev3
• Tutorial de TB6600 Stepper Motor Driver con Arduino

I also have an article on How To Drive a Stepper Motor using the A4988 driver and ESP32 if you want to work with an ESP32 microcontroller instead.

Required Parts

Componentes de hardware

	Controlador de motor paso a paso A4988	× 1	Amazon
	Motor paso a paso NEMA 17	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Alimentación (8-35 V)	× 1	Amazon
	Tablero de pruebas	× 1	Amazon
	Condensador (100 µF)	× 1	Amazon
	Cables de puente	~ 10	Amazon
	Cable USB tipo A/B	× 1	Amazon

Me gusta utilizar este controlador en combinación con un escudo CNC o una placa de expansión. Dicho escudo ya incluye condensadores y ofrece una manera fácil de seleccionar la resolución de microdirección. 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 protoboard.

Herramientas

	Destornillador pequeño		Amazon
	Multímetro		Amazon
	Cables de prueba tipo cocodrilo (opcional)		Amazon

Software

Arduino IDE

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.

Sobre el conductor

En el corazón del driver A4988 se encuentra un chip fabricado por Allegro MicroSystems: el A4988 DMOS Microstepping Driver with Translator and Overcurrent Protection. Este driver de motor integrado hace que la interconexión con un microcontrolador sea súper fácil, ya que sólo necesitas dos pines para controlar tanto la velocidad como la dirección del motor paso a paso.

El driver tiene una capacidad de salida máxima de 35 V y ± 2 A, lo que es ideal para accionar motores paso a paso de tamaño pequeño o mediano, como un motor paso a paso bipolar NEMA 17.

Si necesita controlar motores paso a paso más grandes como el NEMA 23, eche un vistazo al controlador de motor paso a paso TB6600. Este driver puede utilizarse con el mismo código que el A4988 y tiene una corriente nominal de 3,5 A.

• Tutorial de TB6600 Stepper Motor Driver con Arduino

El chip controlador A4988 tiene varias funciones de seguridad incorporadas, como protección contra sobrecorriente, cortocircuito, bloqueo por baja tensión y sobretemperatura. Puedes encontrar más especificaciones en la siguiente tabla.

A4988 Especificaciones

Tensión mínima de funcionamiento	8 V
Tensión máxima de funcionamiento	35 V
Corriente continua por fase	1 A
Corriente máxima por fase	2 A
Tensión lógica mínima	3 V
Tensión lógica máxima	5.5 V
Resolución de micropasos	completo, 1/2, 1/4, 1/8 y 1/16
¿Protección contra la tensión inversa?	No
Dimensiones	15,5 × 20,5 mm (0,6″ × 0,8″)
Coste	Comprobar el precio

Para más información, puede consultar la hoja de datos aquí.

Diferencias entre el A4988 y el DRV8825

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

• El DRV8825 ofrece un micropaso de 1/32, mientras que el A4988 sólo llega a 1/16 de paso. Un micropaso más alto permite un funcionamiento más suave y silencioso, pero no siempre es necesario.
• El potenciómetro de límite de corriente está en un lugar diferente
• La relación entre la tensión de referencia y el límite de corriente es diferente.
• El DRV8825 requiere una duración mínima del pulso STEP de 1,9µs; el A4988 requiere 1µs como mínimo.
•  El DRV8825 puede utilizarse con una fuente de alimentación de motor de mayor tensión (45 V frente a 35 V). Esto significa que es menos susceptible a los daños causados por los picos de tensión de la LC.
•  El DRV8825 puede suministrar algo más de corriente que el A4988 sin necesidad de refrigeración adicional.

Tenga en cuenta que la disposición de los pines del DRV8825 es exactamente la misma que la del A4988, por lo que puede utilizarse como sustituto.

Ajustes del micropaso

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 driver de micropasos como el A4988 permite resoluciones más altas al permitir ubicaciones de pasos intermedios. Esto se consigue energizando las bobinas con niveles de corriente intermedios.

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

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

MS1	MS2	MS3	Resolución de micropasos
Bajo	Bajo	Bajo	Paso completo
Alta	Bajo	Bajo	1/2 paso
Bajo	Alta	Bajo	1/4 de paso
Alta	Alta	Bajo	1/8 paso
Alta	Alta	Alta	Paso 1/16

Las tres entradas tienen resistencias pull-down internas de 100 kΩ, por lo que si se dejan desconectados los tres pines de selección de micropasos se obtiene el modo de paso completo.

A menudo utilizo un CNC-shield o una placa de expansión en combinación con estos controladores. La placa de expansión tiene 3 interruptores DIP para ajustar MS1 - MS3 alto o bajo y en el CNC-shield puedes instalar puentes. Si usas el driver con una protoboard, puedes simplemente usar cables de puente para conectar los pines del selector a 5 V (es decir, hacerlos HIGH).

Cableado - Conexión del A4988 al Arduino y al motor paso a paso

The wiring diagram/schematic above shows you how to connect the A4899 driver to a stepper motor and the Arduino. The connections are also given in the following table:

Conexiones A4988

A4988	Conexión
VMOT	8-35V
GND	Tierra del motor
SLP	RESET
RST	SLP
VDD	5V
GND	Tierra lógica
STP	Clavija 3
DIR	Clavija 2
1A, 1B, 2A, 2B	Motor paso a paso

• La 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 1A, 1B y 2A, 2B (ver más abajo).
• El pin GND (abajo a la derecha) se conecta al pin de tierra del microcontrolador y VDD se conecta a 5V.
• Los pines STP (paso) y DIR (dirección) se conectan al pin digital 3 y 2 respectivamente. Puedes elegir un pin digital diferente si quieres, pero estos son los que he utilizado para este tutorial y el código de ejemplo.
• El pin SLP es una entrada activa baja. Esto significa que si se tira de esta clavija hacia abajo, el controlador entra en modo de reposo, lo que minimiza el consumo de energía. RST es también una entrada activa baja. Cuando se tira a bajo, todas las entradas STEP se ignoran hasta que se tira a alto. Si no se utiliza el pin, se puede conectar al pin adyacente SLP/SLEEP para ponerlo en alto y habilitar el driver.
• El pin EN (enable) puede dejarse desconectado, por defecto se pone a nivel bajo. Cuando este pin se pone en alto, el controlador se desactiva.

En el resto de este tutorial he dejado MS1, MS2 y MS3 desconectados, por lo que el controlador funciona en modo de paso completo. Esto hace que la explicación del código sea un poco más fácil. Normalmente usaría el micro paso 1/8 o 1/16 y conectaría los pines apropiados a 5V (ver la tabla en la introducción).

Advertencia

La placa base del A4988 utiliza condensadores cerámicos de baja ESR, lo que la hace susceptible a los destructivos picos de tensión de la LC, especialmente cuando se utilizan cables de alimentación de más de unos pocos centímetros.

Para proteger el driver 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). Me gustan estas cajas de surtido de Amazon, de esta manera siempre tengo a mano algunos condensadores del tamaño adecuado.

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

Si no puedes encontrar la hoja de datos de tu motor paso a paso, puede ser difícil averiguar cómo cablear tu motor correctamente. Yo uso el siguiente truco para determinar cómo conectar motores paso a paso bipolares de 4 hilos:

Lo único que tienes que identificar son los dos pares de cables que se conectan 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, haga lo siguiente con el motor desconectado:

1. Intenta hacer girar el eje del motor paso a paso con la mano y fíjate en lo difícil que es girar.
2. Ahora escoge un par de cables al azar del motor y toca los extremos desnudos entre sí.
3. A continuación, intente hacer girar de nuevo el eje del motor paso a paso.

Si siente mucha resistencia, ha encontrado un par de cables de la misma bobina. Si puede girar el eje libremente, pruebe con otro par de cables. Ahora conecte las dos bobinas a las clavijas mostradas en el diagrama de cableado anterior.

¿Cómo se ajusta el límite de corriente?

Antes de empezar a programar tu Arduino y empezar a usar el driver hay una cosa muy importante que tienes que hacer y que mucha gente olvida: ¡configurar el límite de corriente!

Este paso no es muy complicado, pero es absolutamente necesario para proteger su motor paso a paso y el conductor. Si no estableces un límite de corriente adecuado, tu motor puede consumir más corriente de la que él o tu driver pueden manejar, esto es probable que dañe a uno o a ambos.

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

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

Si ya has cableado el controlador, puedes dejar conectado todo menos el motor paso a paso. Puedes aplicar la alimentación a través del puerto USB del Arduino.

A4988	Conexión
VDD	5V
RST	SLP
SLP	RESET
GND	Tierra

Fórmula de límite de corriente

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

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

La Rcs es la resistencia de detección de corriente. Si compró un controlador A4988 de Pololu antes de enero de 2017, la Rcs será de 0,050 Ω. Los controladores vendidos después de esa fecha tienen resistencias de detección de corriente de 0 ,068 Ω.

Así que esto significa que para un límite de corriente de 1A para una placa con resistencias de detección de corriente de 0,068 Ω, la Vref debería ser de 540 mV.

Para seleccionar el límite de corriente adecuado, echa un vistazo a la hoja de datos de tu motor paso a paso. Si no puedes encontrar la corriente nominal de tu motor, te recomiendo que empieces con un límite de corriente de 1A. Siempre puedes aumentarlo más tarde si tu motor/conductor carece de pasos.

When using the driver in full-step mode, the current through each coil is limited to approximately 70% of the set current limit. This means that you would need to set the current limit 40% higher or 1.4 A in full-step mode. When using microstepping, the formula above applies.

Tenga en cuenta que debe recalibrar el límite de corriente si cambia la tensión de alimentación del motor. Si tu motor hace mucho ruido, intenta bajar el límite de corriente. Es mejor ajustar el límite de corriente lo suficientemente alto para que el motor no pierda pasos.

Medición de Vref

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

Recomiendo utilizar cables de prueba tipo cocodrilo sujetos al destornillador para ajustar el límite de corriente. Esto le permite ajustar el potenciómetro y medir la tensión de referencia al mismo tiempo.

Nota: Hay otra forma de medir el límite de corriente y es medir directamente el consumo de corriente del motor paso a paso. Personalmente encuentro el método anterior mucho más fácil.

Pololu mentions the following on their website:

Nota: La corriente de la bobina puede ser muy diferente de la corriente de la fuente de alimentación, por lo que no 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 paso a paso.

Límite actual FAQ

¿Necesito tener el motor paso a paso conectado o no?
No, no es necesario conectar el motor paso a paso al controlador cuando se ajusta el límite de corriente. Para estar seguro, desconecta el motor, a veces interfiere con la medición de la tensión Vref.

¿Tengo que girar el motor ejecutando el sketch de motor de Arduino?
No, véase la pregunta anterior.

Do I need to turn the potentiometer clock- or counter- clockwise to raise Vref?
This depends on the manufacturer of the driver. If you have a genuine Polulu breakout board of the DRV8825 or A4988 you turn the potentiometer clockwise to raise Vref and counter- clockwise to lower it.

Refrigeración del conductor

El CI del controlador A4988 tiene una corriente máxima de 2 A por bobina, pero sin un disipador de calor sólo puede suministrar aproximadamente 1 A por bobina antes de empezar a sobrecalentarse.

El controlador suele venir con un pequeño disipador de calor con soporte adhesivo, que te recomiendo instalar de inmediato. También puedes comprar un montón de pequeños disipadores de calor en Amazon por muy poco dinero.

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

Ahora que has cableado el controlador y has establecido el límite de corriente, es el momento de conectar el Arduino al ordenador y cargar 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 librería.

Este esquema 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. 
// 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 paso y dirección. Los conecté a los pines 3 y 2 de Arduino.

The statement #define is used to give a name to a constant value. The compiler will replace any references to this constant with the defined value when the program is compiled. So everywhere you mention dirPin, the compiler will replace it with the value 2 when the program is compiled.

I also defined a stepsPerRevolution constant. Because I set the driver to full step mode I set it to 200 steps per revolution. Change this value if your setup is different.

// Define stepper motor connections and steps per revolution
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

In the setup() section of the code, all the motor control pins are declared as digital OUTPUT with the function pinMode().

void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

In the loop() section of the code, we let the motor spin one revolution slowly in the CW direction and one revolution quickly in the CCW direction. Next, we let the motor spin 5 revolutions in each direction with a high speed. So how do you control the speed, spinning direction, and number of revolutions?

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

To control the spinning direction of the stepper motor we set the DIR (direction) pin either HIGH or LOW. For this we use the function digitalWrite(). Depending on how you connected the stepper motor, setting the DIR pin high will let the motor turn CW or CCW.

Controla el número de pasos o revoluciones:

En este ejemplo, los bucles for controlan 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 paso a paso. 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 bucle for se ejecuta 1000 veces, lo que resulta en 1000 pasos o 5 revoluciones.

Note that you can change the second term in the for loop to whatever number of steps you want. for(int i = 0; i < 100; i++) would result in 100 steps, or half a revolution.

Velocidad de control:

The speed of the stepper motor is determined by the frequency of the pulses we send to the STEP pin. The higher the frequency, the faster the motor runs. You can control the frequency of the pulses by changing delayMicroseconds() in the code. The shorter the delay, the higher the frequency, the faster the motor runs.

Tutorial de la biblioteca AccelStepper

La librería AccelStepper escrita por Mike McCauley es una librería impresionante para usar en tu proyecto. Una de las ventajas es que soporta la aceleración y la desaceleración, pero tiene un montón de otras funciones agradables también.

Puede descargar la última versión de esta biblioteca aquí o hacer clic en el botón de abajo.

Puedes instalar la librería yendo a Sketch > Incluir librería > Añadir librería .ZIP ... en el IDE de Arduino.

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

Puedes buscar 'accelstepper ' y buscar la biblioteca de Mike McCauley. Seleccione la última versión y luego haga clic en Instalar.

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

El siguiente esquema se puede utilizar para hacer funcionar uno o más motores paso a paso de forma continua 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. 
  More info: https://www.makerguides.com 
*/

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

The first step is to include the library with #include "AccelStepper.h".

// Include the AccelStepper library:
#include "AccelStepper.h"

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

The statement #define is used to give a name to a constant value. The compiler will replace any references to this constant with the defined value when the program is compiled. So everywhere you mention dirPin, the compiler will replace it with the value 2 when the program is compiled.

// 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 del motor y las conexiones adecuadas.

In this case, I called the stepper motor ‘stepper’ but you can use other names as well, like ‘z_motor’ or ‘liftmotor’ etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. The name that you give to the stepper motor will be used later to set the speed, position, and acceleration for that particular motor. You can create multiple instances of the AccelStepper class with different names and pins. This allows you to easily control 2 or more stepper motors at the same time.

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

In the setup() section of the code we define the maximum speed in steps/second. Speeds of more than 1000 steps per second can be unreliable, so I set this as the maximum. Note that I specify the name of the stepper motor (‘stepper’), for which I want to define the maximum speed. If you have multiple stepper motors connected, you can specify a different speed for each motor:

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

In the loop() we first set the speed that we want the motor to run at. For this, we use the function setSpeed(). (you can also place this in the setup section of the code).

stepper.runSpeed() polls the motor and when a step is due, executes 1 step. This depends on the set speed and the time since the last step. If you want to change the direction of the motor, you can set a negative speed: stepper.setSpeed(-400); turns the motor the other way.

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

To let the motor rotate a specific number of steps I prefer to use a while loop in combination with stepper.currentPosition(). You can use the following example code, to let the motor run back and forth.

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

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

In the loop I make use of a while loop in combination with the currentPosition() function. First, I set the current position of the stepper motor to zero with stepper.setCurrentPosition(0).

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

Next we make use of the while loop. A while loop will loop continuously, and infinitely, until the expression inside the parenthesis, () becomes false. So, in this case, I check if the current position of the stepper motor is not equal to 400 steps (!= means: is not equal to). While this is not the case, we run the stepper motor at a constant speed as set by 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 una posición de destino diferentes.

3. Código de ejemplo de 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 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. 
   More info: https://www.makerguides.com 
*/

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

In the setup(), besides the maximum speed, we need to define the acceleration/deceleration. For this we use the function setAcceleration().

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

In the loop section of the code, I used a different way to let the motor rotate a predefined number of steps. The function stepper.moveTo() is used to set the target position. The function stepper.runToPostion() moves the motor (with acceleration/deceleration) to the target position and blocks until it is at the target position. Because this function is blocking, you shouldn’t use this when you need to control other things at the same time.

  // 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 de motor paso a paso A4988 y Arduino. Espero que lo hayas encontrado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas!

I have personally used this driver a lot for a bunch of 3D printers and other CNC related projects. But I would love to know what projects you plan on building (or have already built) with this driver. If you have any questions or if you think that things are missing, please leave a comment down below.