Cómo controlar un motor paso a paso con Arduino Motor Shield Rev3

En este tutorial, aprenderás cómo controlar un motor paso a paso con el Arduino Motor Shield Rev3. He incluido un diagrama de conexiones y varios ejemplos de código.

Primero veremos un ejemplo que utiliza la biblioteca Arduino Stepper. Esta biblioteca es ideal para un control básico del motor paso a paso, pero no tiene muchas funciones adicionales.

Te recomiendo encarecidamente que también eches un vistazo a los ejemplos de código para la biblioteca AccelStepper al final de este tutorial. Esta biblioteca es bastante fácil de usar y puede mejorar mucho el rendimiento de tu hardware.

Materiales

Componentes de hardware

	Arduino Motor Shield Rev3	× 1	Amazon
	NEMA 17 stepper motor *	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Power supply (5-12 V)	× 1	Amazon
	USB cable type A/B	× 1	Amazon

En este tutorial usé un motor paso a paso bipolar con 4 cables. Intenta encontrar un motor que funcione entre 5 y 12 V y que no supere el límite de corriente de 2 A. Este  Stepper motor  de Adafruit funciona muy bien a 12 V y no consume demasiada corriente (350 mA).

Software

Arduino IDE

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.

Información sobre el Arduino Motor Shield Rev3

El  Arduino Motor Shield Rev3  está basado en el driver puente completo dual L298, fabricado por STMicroelectronics. Con este shield puedes controlar motores DC, un motor paso a paso, relés y solenoides. Cuenta con dos canales separados, llamados A y B, que puedes usar para manejar 2 motores DC o 1 motor paso a paso cuando se combinan.

Algo muy importante a recordar es que el L298 es un driver de voltaje constante. Esto significa que la corriente depende de la relación entre la inductancia y la resistencia (L/R) del motor que conectes.

Esto implica que debes tener cuidado al seleccionar el motor paso a paso y la fuente de alimentación para usar con este shield.  ¡No todos los motores paso a paso funcionarán!  El voltaje operativo del shield está entre 5 y 12 voltios. Como el shield puede suministrar un máximo de 2 amperios por canal, necesitas encontrar un motor que funcione en este rango de voltaje y que no supere la corriente máxima. El motor que usé para este tutorial consume alrededor de 1A a 5V.

Si el motor que quieres usar no funciona con este shield, te recomiendo usar un driver tipo chopper. Escribí un tutorial para el  A4988  y el driver  DRV8825  que funcionan muy bien con muchos motores paso a paso.

Especificaciones del Arduino Motor Shield Rev3

Voltaje operativo	5 V a 12 V
Controlador de motor	L298P, controla 2 motores DC o 1 motor paso a paso
Corriente máxima	2A por canal o 4A máximo (con fuente de alimentación externa)
Detección de corriente	1.65V/A
Funciones	Funcionamiento libre, parada y freno
Costo	Check price

Para más información puedes consultar las hojas de datos aquí.

Entradas y salidas

Función	Pines Canal A	Pines Canal B
Dirección	D12	D13
PWM	D3	D11
Freno	D9	D8
Detección de corriente	A0	A1

Conexiones – Cómo conectar un motor paso a paso al Arduino Motor Shield Rev3

El diagrama de conexiones/esquemático a continuación muestra cómo conectar un motor paso a paso y la fuente de alimentación al Arduino motor shield.

Las conexiones también se detallan en la tabla siguiente.

Conexiones del Arduino Motor Shield Rev3

Arduino Motor Shield Rev3	Conexión
Vin	5 – 12 V
GND	Masa de la fuente de alimentación
A-	Bobina 1 del motor paso a paso
A+	Bobina 1 del motor paso a paso
B-	Bobina 2 del motor paso a paso
B+	Bobina 2 del motor paso a paso

Advertencia

Es posible alimentar directamente el shield desde el Arduino, pero no se recomienda. Cuando el motor paso a paso consume demasiada corriente, puedes dañar tanto el shield como el Arduino. Por eso recomiendo usar una fuente de alimentación externa para los motores.

Para hacer esto, debes cortar el jumper Vin Connect en la parte trasera del shield. Después de esto, puedes alimentar el Arduino por separado con un cable USB o mediante el conector de alimentación DC de 5.5 mm.

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

Si no encuentras la hoja de datos de tu motor paso a paso, puede ser difícil saber qué cable va a dónde. Yo uso el siguiente truco para identificar cómo conectar motores bipolares de 4 cables:

Lo único que necesitas identificar son los dos pares de cables que corresponden a las dos bobinas del motor. Los cables de una bobina se conectan a A- y A+ y los de la otra a B- y B+, la polaridad no importa.

Para encontrar los dos cables de una bobina, haz lo siguiente con el motor desconectado:

1. Intenta girar el eje del motor paso a paso con la mano y nota la resistencia al girar.
2. Ahora toma un par de cables al azar del motor y toca las puntas peladas juntas.
3. Luego, mientras mantienes las puntas juntas, intenta girar el eje del motor de nuevo.

Si sientes mucha resistencia, has encontrado un par de cables de la misma bobina.  Si aún 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 arriba.

Ejemplo básico de código Arduino para motor paso a paso y Arduino Motor Shield con la biblioteca Stepper.h

Puedes subir el siguiente código de ejemplo a tu Arduino usando el  Arduino IDE.

Este ejemplo usa la biblioteca Stepper.h, que debería venir preinstalada con el IDE de Arduino. Este sketch hace que el motor paso a paso gire 1 revolución en una dirección, se detenga, y luego gire 1 revolución en la dirección opuesta.

/* Example sketch to control a stepper motor with 
   Arduino Motor Shield Rev3, Arduino UNO and Stepper.h library. 
   https://www.makerguides.com */

#include "Stepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);
}


void loop() {
  // Step one revolution in one direction:
  myStepper.step(200);

  delay(2000);

  //Step on revolution in the other direction:
  myStepper.step(-200);

  delay(2000);
}

Explicación del código:

El sketch comienza incluyendo la biblioteca Arduino Stepper.h. Más información sobre esta biblioteca está disponible en  Arduino website.

#include "Stepper.h"

Luego defino cuántos pasos da el motor para completar una revolución. En este ejemplo usaremos el motor en modo paso completo. Esto significa que toma 200 pasos para girar 360 grados. Puedes cambiar este valor si usas otro tipo de motor o configuración.

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

Después definimos las conexiones del motor (ver especificaciones y diagrama de conexiones arriba).

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  pwmA, el compilador lo reemplazará por el valor 3 al compilar el programa.

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

Luego, necesitas crear una nueva instancia de la clase Stepper, que representa un motor paso a paso conectado al Arduino. Para esto usamos la función  Stepper(steps, pin1, pin2)  donde steps es el número de pasos por revolución y pin1 y pin2 son los pines usados para controlar el motor. En nuestro caso son dirA y dirB.

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

En este caso llamé al motor paso a paso ‘myStepper’ pero puedes usar otros nombres como ‘z_motor’ o ‘liftmotor’, etc.  Stepper liftmotor = Stepper(stepsPerRevolution, dirA, dirB);.

En el setup, comenzamos configurando los pines de freno y PWM como salida con la función  pinMode(). Los pines PWM deben estar en HIGH y los de freno en LOW con la función  digitalWrite().

  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

Puedes ajustar la velocidad del motor en rpm con la función  setSpeed(rpm). La configuré en 60, así que deberíamos ver 1 revolución por segundo.

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);

Bucle

En el bucle simplemente llamamos a la función  step(steps)  que gira el motor un número específico de pasos a una velocidad determinada por la función  setSpeed(rpm)  . Pasar un número negativo a esta función invierte la dirección de giro del motor.

void loop() {
  // Step one revolution in one direction:
  myStepper.step(200);

  delay(2000);

  //Step on revolution in the other direction:
  myStepper.step(-200);

  delay(2000);
}

Ten en cuenta que la función step(steps) es bloqueante, esto significa que esperará hasta que el motor termine de moverse para pasar a la siguiente línea del sketch.

Ejemplos de código para Arduino Motor Shield y biblioteca AccelStepper

En los siguientes tres ejemplos te mostraré cómo controlar la velocidad, dirección y número de pasos que debe dar el motor paso a paso. En estos ejemplos usaré la biblioteca AccelStepper.

La biblioteca AccelStepper, escrita por Mike McCauley, es una biblioteca excelente para tu proyecto. Una de sus ventajas es que soporta aceleración y desaceleración, además de muchas otras funciones útiles.

Puedes descargar la última versión de esta biblioteca aquí:

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

Otra opción es ir 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 haz clic en Install.

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

El siguiente sketch puede usarse para hacer girar uno o más motores paso a paso continuamente a velocidad constante. (No se usa aceleración ni desaceleración).

Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.

/* Example sketch to control a stepper motor with
   Arduino Motor Shield Rev3, Arduino UNO and AccelStepper.h library: 
   continuous rotation. More info: https://www.makerguides.com */

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

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

void loop() {
  // Set the speed of the motor in steps per second:
  stepper.setSpeed(500);
  // Step the motor with constant speed as set by setSpeed():
  stepper.runSpeed();
}

Cómo funciona el código:

De nuevo, el primer paso es incluir la biblioteca con  #include <AccelStepper.h>.

#include "AccelStepper.h"

Después de especificar las conexiones como antes, necesitamos definir el tipo de interfaz del motor para la biblioteca AccelStepper. En este caso manejaremos el motor en modo paso completo, con dos cables, así que configuramos el modo en 2. Puedes encontrar otros tipos de interfaz aquí (link).

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

Luego, creas una nueva instancia de la clase AccelStepper con el tipo de interfaz y conexiones apropiadas.

En este caso llamé al motor ‘stepper’ pero puedes usar otros nombres como ‘z_motor’ o ‘liftmotor’, etc.  AccelStepper liftmotor = AccelStepper(MotorInterfaceType, dirA, dirB);.

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

La sección setup del código es casi igual que en el ejemplo anterior, pero también definí la velocidad máxima en pasos/segundo. Velocidades mayores a 1000 pasos por segundo pueden ser poco fiables, así que la configuré en 600 (tendrás que experimentar para ver la velocidad máxima para tu configuración). Nota que especifico el nombre del motor (‘stepper’) para el que quiero definir la velocidad máxima.

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);

Bucle

En el bucle primero establecemos la velocidad a la que queremos que gire el motor con la función  setSpeed(). (también puedes poner esto en la sección setup del código).

La función  stepper.runSpeed()  consulta el motor y cuando toca dar un paso, ejecuta 1 paso. Esto depende de la velocidad establecida y el 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 of the motor in steps per second:
  stepper.setSpeed(500);
  // Step the motor with constant speed as set by setSpeed():
  stepper.runSpeed();
}

2. Sketch para controlar el número de pasos o revoluciones

Con el siguiente sketch puedes controlar la velocidad, dirección y número de pasos/revoluciones. No se usa aceleración ni desaceleración.

En este caso, el motor gira 1 revolución en sentido horario a 400 pasos/seg, luego 1 revolución en sentido antihorario a 200 pasos/seg, y finalmente 3 revoluciones en sentido horario a 600 pasos/seg.

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

#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

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

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

  delay(1000);

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

  // Run the motor backwards at 200 steps/second until the motor reaches -200 steps (1 revolution):
  while (stepper.currentPosition() != -200) {
    stepper.setSpeed(-200);
    stepper.runSpeed();
  }

  delay(1000);

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

  // Run the motor forward at 600 steps/second until the motor reaches 600 steps (3 revolutions):
  while (stepper.currentPosition() != 600) {
    stepper.setSpeed(600);
    stepper.runSpeed();
  }

  delay(3000);
}

Explicación del código

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

En el loop uso un  while loop  en combinación con la función  currentPosition()  . Primero, pongo la posición actual del motor en cero con  stepper.setCurrentPosition(0).

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

Luego usamos un bucle while. Un bucle while se repite continuamente e infinitamente hasta que la expresión dentro de los paréntesis () sea falsa. En este caso compruebo si la posición actual del motor no es igual a 200 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 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

En el resto del loop hacemos exactamente lo mismo, solo que con diferente velocidad y posición objetivo.

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

En este ejemplo veremos una de las principales características de la biblioteca AccelStepper: añadir 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 código complicado. La primera parte de este sketch es igual que en el ejemplo 1, pero el setup y el loop son diferentes.

El motor girará cinco revoluciones de ida y vuelta con una velocidad de 200 pasos por segundo y una aceleración de 50 pasos/segundo ² .

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: acceleration and deceleration 
  More info: https://www.makerguides.com */

#include <AccelStepper.h>

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(200);
  // Set the maximum acceleration in steps per second^2:
  stepper.setAcceleration(50);
}

void loop() {
  // Set target position:
  stepper.moveTo(1000);
  // Run to position with set speed and acceleration:
  stepper.runToPosition();

  delay(1000);

  // Move back to original position:
  stepper.moveTo(0);
  // Run to position with set speed and acceleration:
  stepper.runToPosition();

  delay(1000);
}

Cómo funciona el código

En el setup, además de la velocidad máxima, definimos la aceleración/desaceleración con la función  setAcceleration().

  // Set the maximum steps per second:
  stepper.setMaxSpeed(200);
  // Set the maximum acceleration in steps per second^2:
  stepper.setAcceleration(50);

En el loop, usé una forma diferente para hacer que el motor gire un número predefinido de pasos. Primero establezco la posición objetivo con la función  moveTo(). Luego simplemente usamos la función  runToPosition()  para que el motor se mueva hacia la posición objetivo con la velocidad y aceleración establecidas. El motor desacelerará antes de llegar a la posición objetivo.

  // Set target position:
  stepper.moveTo(1000);
  // Run to position with set speed and acceleration:
  stepper.runToPosition();

Finalmente, establecemos la nueva posición objetivo a 0 para volver al origen.

Conclusión

En este artículo te he mostrado cómo controlar un motor paso a paso con el Arduino Motor Shield Rev3. Hemos visto 4 ejemplos, usando tanto la biblioteca Stepper como AccelStepper.

Espero que te haya resultado útil e informativo. Si quieres aprender más sobre otros drivers (microstepping) como el  A4988, consulta los artículos a continuación.

Otros tutoriales de motores paso a paso:

• Control a stepper motor with L298N motor driver and Arduino
• 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
• How to control a stepper motor with A4988 driver and Arduino
• How to control a stepper motor with DRV8825 driver and Arduino

Si tienes alguna otra pregunta, deja un comentario abajo.