Este artículo incluye todo lo que necesitas saber sobre cómo controlar un motor paso a paso con el A4988 driver de motor paso a paso 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 encarecidamente 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.
Después de cada ejemplo, desgloso y explico cómo funciona el código, para que no tengas problemas en modificarlo según tus necesidades.
Partes necesarias
Componentes de hardware
 | A4988 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8-35 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 A4988 encontrarás un chip fabricado por Allegro MicroSystems: el A4988 DMOS Microstepping Driver con traductor y protección contra sobrecorriente. 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 35 V y ± 2 A, lo que es ideal para motores paso a paso pequeños y medianos como un NEMA 17 motor paso a paso bipolar.
Si necesitas controlar motores paso a paso más grandes como 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 A4988 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 A4988
| Voltaje mínimo de operación | 8 V |
| Voltaje máximo de operación | 35 V |
| Corriente continua por fase | 1 A |
| Corriente máxima por fase | 2 A |
| Voltaje lógico mínimo | 3 V |
| Voltaje lógico máximo | 5.5 V |
| Resolución de microstepping | completo, 1/2, 1/4, 1/8 y 1/16 |
| ¿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 el A4988 y el DRV8825
El DRV8825 es bastante similar al A4988 pero tiene 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, pero 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 diferente.
- El DRV8825 requiere una duración mínima del pulso STEP de 1.9 µs; 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 microstep
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 de microstepping como el A4988 permite resoluciones más altas al permitir posiciones intermedias de paso. Esto se logra energizando las bobinas con niveles intermedios de corriente.
Por ejemplo, conducir un motor en modo cuarto de paso dará al motor de 200 pasos por revolución 800 microsteps por revolución usando cuatro niveles diferentes de corriente.
Los pines selectores de resolución (MS1, MS2 y MS3) te permiten seleccionar una de las cinco resoluciones de paso según la tabla a continuación.
| MS1 | MS2 | MS3 | Resolución de microstep |
|---|---|---|---|
| Bajo | Bajo | Bajo | Paso completo |
| Alto | Bajo | Bajo | 1/2 paso |
| Bajo | Alto | Bajo | 1/4 paso |
| Alto | Alto | Bajo | 1/8 paso |
| Alto | Alto | Alto | 1/16 paso |
Las tres entradas tienen resistencias pull-down internas de 100 kΩ, por lo que dejar los tres pines de selección de microstep 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 MS1 – MS3 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 HIGH).
Cableado – Conexión del A4988 a Arduino y motor paso a paso
El diagrama de conexiones/esquemático anterior muestra cómo conectar el driver A4899 a un motor paso a paso y al Arduino. Las conexiones también se detallan en la siguiente tabla:
Conexiones del A4988
| A4988 | Conexión |
|---|---|
| VMOT | 8-35V |
| GND | Masa del motor |
| SLP | RESET |
| RST | SLP |
| VDD | 5V |
| GND | Masa lógica |
| STP | Pin 3 |
| DIR | Pin 2 |
| 1A, 1B, 2A, 2B | 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 1A, 1B y 2A, 2B (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.
- El pin SLP es una entrada activa baja. Esto significa que al poner este pin en bajo, el driver entra en modo de suspensión, minimizando el consumo de energía. RST también es una entrada activa baja. Cuando se pone en bajo, se ignoran todas las entradas STEP hasta que se pone en alto. Si no usas este pin, puedes conectarlo al pin SLP/SLEEP adyacente para ponerlo en alto y habilitar el driver.
- El pin EN (enable) puede dejarse desconectado, ya que está tirado a bajo por defecto. Cuando este pin se pone en alto, el driver se desactiva.
En el resto de este tutorial he dejado MS1, MS2 y MS3 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/8 o 1/16 y conectaría los pines correspondientes a 5V (ver la tabla en la introducción).
Advertencia
La placa portadora del A4988 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 sugiere 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 determinar 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 1A y 1B y los de la otra 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 paso a paso a mano y nota lo difícil que es girarlo.
- Ahora toma un par de cables al azar del motor y toca las puntas peladas juntas.
- 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 debes hacer y 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 A4988 solo necesita alimentación vía VDD (5V) y debes 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 tienes el driver cableado, puedes dejar todo conectado excepto el motor paso a paso. Puedes alimentar el Arduino a través del puerto USB.
| A4988 | Conexión |
|---|---|
| VDD | 5V |
| RST | SLP |
| SLP | RESET |
| GND | Masa |
Fórmula del 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)
Rcs es la resistencia de detección de corriente. Si compraste un driver A4988 de Pololu antes de enero de 2017, el Rcs será 0.050 Ω. Los drivers vendidos después de esa fecha tienen 0.068 Ω de resistencias de detección de corriente.
Esto significa que para un límite de corriente de 1A en una placa con resistencias de detección de 0.068 Ω, el Vref debería ser 540 mV.
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 1A. Siempre puedes aumentarlo más tarde si tu motor/driver pierde pasos.
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.
Ten en cuenta que debes recalibrar el límite de corriente si cambias el voltaje de la fuente de alimentación del motor. Si tu motor hace mucho ruido, intenta bajar el límite de corriente. Lo mejor es ajustar el límite de corriente 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 y es medir directamente la corriente que consume el motor paso a paso. Personalmente, encuentro 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 deberías 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.
Preguntas frecuentes sobre el límite de corriente
¿Necesito tener el motor paso a paso conectado o no?
No, no necesitas conectar el motor paso a paso al driver al 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 IC driver A4988 tiene una corriente máxima de 2 A por bobina, pero sin disipador solo puede suministrar alrededor de 1 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 pequeños heat sinks en Amazon por muy poco dinero.
Código básico de ejemplo para controlar un motor paso a paso con Arduino
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 Arduino IDE. 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.
// Example sketch to control a stepper motor with A4988 stepper motor driver
// and Arduino without a library.
// 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 del Arduino.
La instrucción #define se usa para dar un 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á por 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
setup
En la sección setup() del código, todos los pines de control del motor se declaran como OUTPUT digitales con la función pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
loop
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);
}
Control de dirección de giro:
Para controlar la dirección de giro del motor paso a paso, ponemos el pin DIR (dirección) en HIGH o LOW. Para esto usamos la función digitalWrite(). Dependiendo de cómo conectaste el motor paso a paso, poner el pin DIR en alto hará que el motor gire en sentido CW o CCW.
Control del número de pasos o revoluciones:
En este sketch de 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. 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 quieras. for(int i = 0; i < 100; i++) resultaría en 100 pasos, o media revolución.
Control de velocidad:
La velocidad del motor paso a paso está determinada por la frecuencia de los pulsos que enviamos al pin STEP. Cuanto mayor sea la frecuencia, más rápido gira el motor. Puedes controlar la frecuencia de los pulsos cambiando delayMicroseconds() en el código. Cuanto menor 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 descargar la última versión de esta biblioteca haciendo clic en el botón de abajo.
Puedes instalar la biblioteca yendo a Sketch > Include Library > Add .ZIP Library… en el IDE de Arduino.
Otra opción es navegar a Tools > Manage Libraries… o presionar 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 Instalar.
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 A4988 stepper motor driver, AccelStepper library and Arduino: continuous rotation.Homepage*/ // 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 del A4988 al Arduino y el tipo de interfaz del motor. El tipo de interfaz debe establecerse en 1 cuando se usa un driver de paso y dirección. Puedes encontrar los otros tipos de interfaz here.
La instrucción #define se usa para dar un 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á por 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 de motor y las 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 definir 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. Ten en cuenta 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 loop() primero establecemos 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 establecida y del tiempo desde el último paso. Si quieres cambiar la dirección del motor, puedes poner una velocidad negativa: stepper.setSpeed(-400); hace que el motor gire 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. 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 bucle while 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 A4988 stepper motor driver, AccelStepper library and Arduino: number of steps or revolutions.Homepage*/ // 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 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 repite 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 establecida por 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 siguiente ejemplo, el motor girará de un lado a otro a una velocidad de 200 pasos por segundo y una aceleración de 30 pasos por segundo al cuadrado.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // 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 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 A4988 y Arduino. Espero que te haya resultado útil e informativo. Personalmente he usado mucho este driver en varias impresoras 3D y otros proyectos relacionados con CNC.
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 DRV8825 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
También tengo un artículo sobre How To Drive a Stepper Motor using the A4988 driver and ESP32 si quieres trabajar con un microcontrolador ESP32 en su lugar.
Si tienes alguna pregunta o crees que falta algo, por favor deja un comentario abajo.
