En este artículo aprenderás cómo controlar un motor paso a paso con el L298N driver de motor. Esta placa controladora se usa normalmente para controlar motores DC, ¡pero también es una alternativa económica para controlar motores paso a paso! Puede controlar tanto la velocidad como la dirección de giro de la mayoría de los motores paso a paso como un NEMA 17.
He incluido un diagrama de conexiones y muchos códigos de ejemplo. En el primer ejemplo veremos la Stepper.h biblioteca de Arduino. Te recomiendo también echar un vistazo a los códigos de ejemplo para la AccelStepper biblioteca 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.
Materiales
Componentes de hardware
 | L298N motor driver board | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| 12V power supply | × 1 | Amazon | |
| Jumper wires | × 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
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.
Información sobre el L298N Motor Driver
La L298N placa controladora de motor está basada en el driver puente completo dual L298, fabricado por STMicroelectronics. Con este driver puedes controlar motores DC, motores 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.
El L298N suele montarse en una placa breakout (roja), que facilita mucho el cableado. La placa breakout también incluye un regulador de potencia 78M05 de 5 V.
¿Por qué mi motor paso a paso se calienta?
Una cosa muy importante a recordar es que el L298 no tiene una forma sencilla de limitar la corriente a diferencia de otros drivers para motores paso a paso como el A4988. Esto significa que la corriente que consume depende de la relación entre la inductancia y la resistencia (L/R) del motor paso a paso que conectes. Cuando el motor consume demasiada corriente, puedes dañar el driver y el motor se calentará.
Lo que esto significa para ti es que debes tener cuidado al seleccionar el motor paso a paso y la fuente de alimentación para usar con este driver.¡No todos los motores paso a paso funcionarán! El voltaje operativo del L298N está entre 4.8 y 46 voltios (máximo 35 V cuando está montado en la placa breakout). Como el driver puede suministrar un máximo de 2 amperios por canal, necesitas encontrar un motor paso a paso que pueda usarse en este rango de voltaje y que no supere la corriente máxima permitida.
Consulta la hoja de datos de tu motor paso a paso y busca el voltaje/corriente que consume. Si no encuentras la hoja de datos, puedes medir la resistencia de uno de los bobinados y usar la siguiente fórmula para estimar la corriente consumida:
I = U ÷ R o Corriente (A) = Voltaje de alimentación (V) ÷ Resistencia del bobinado (Ω)
Intentaría encontrar un motor que consuma menos de 2 A al voltaje que quieres usar.
El motor que usé para este tutorial consume alrededor de 1 A a 5 V. También encontré este motor paso a paso de Adafruit que funciona muy bien a 12 V y solo consume 350 mA.
Si el motor que quieres manejar no funciona con el driver L298N, es mejor usar un driver tipo chopper. Escribí tutoriales para los A4988 y DRV8825 drivers que funcionan muy bien con muchos motores paso a paso.
Especificaciones del L298N Motor Driver
| Voltaje operativo | 5 – 35 V |
| Voltaje lógico | 4.5 – 7 V |
| Corriente máxima | 2 A por canal o 4 A máximo |
| Controlador de motor | L298N, controla 2 motores DC o 1 motor paso a paso |
| Regulador de voltaje | 78M05 |
| Dimensiones del módulo | 43 x 43 x 28 mm |
| Dimensiones de los orificios | 3.2 mm, separación 37 mm |
| Costo | Check price |
Para más información, puedes consultar la hoja de datos a continuación:
Pinout del L298N
El L298 viene en varios paquetes diferentes, el pinout para el L298N (Multiwatt15) se muestra a continuación:
| Número de pin | Nombre | Función |
|---|---|---|
| 1, 15 | Sense A, Sense B | La resistencia de detección debe conectarse entre este pin y GND (no se usa en la placa breakout). |
| 2, 3 | Out 1, Out 2 | Salidas del puente A; la corriente que fluye a través de la carga conectada entre estos dos pines se monitorea en el pin 1. |
| 4 | Vs | Voltaje de alimentación para las etapas de salida de potencia |
| 5, 7 | Input 1, Input 2 | Entradas compatibles TTL del puente A |
| 6, 11 | Enable A, Enable B | Entrada de habilitación compatible TTL: el estado BAJO deshabilita el puente A (enable A) y/o el puente B (enable B). |
| 8 | GND | Tierra |
| 9 | VSS | Voltaje de alimentación para los bloques lógicos. |
| 10, 12 | Input 3, Input 4 | Entradas compatibles TTL del puente B. |
| 13, 14 | Out 3, Out 4 | Salidas del puente B; la corriente que fluye a través de la carga conectada entre estos dos pines se monitorea en el pin 15. |
Cableado – Conexión del L298N al motor paso a paso y Arduino
El diagrama de cableado/esquemático a continuación muestra cómo conectar un motor paso a paso, fuente de alimentación y Arduino a la placa breakout L298N.
Las conexiones también se detallan en la tabla a continuación:
Conexiones del L298N
| L298N | Conexión |
|---|---|
| +12V | Fuente de alimentación de 5 – 35 V |
| GND | Tierra de la fuente de alimentación y Arduino |
| Jump de 12 V | ¡Retirar si la alimentación del motor es > 12 V! |
| 5V+ (opcional) | 5 V de Arduino si se retira el jumper de 12 V |
| IN1 | Pin 8 de Arduino |
| IN2 | Pin 9 de Arduino |
| IN3 | Pin 10 de Arduino |
| IN4 | Pin 11 de Arduino |
| Jumpers ENA y ENB | Dejar instalados |
| OUT1 + OUT2 | Bobina A del motor paso a paso |
| OUT3 + OUT4 | Bobina B del motor paso a paso |
Nota importante: retira el jumper +12V si usas una fuente de alimentación mayor a 12 V.
Cuando el jumper +12V está puesto, el regulador de voltaje a bordo se activa y crea el voltaje lógico de 5 V. Al retirar el jumper, debes suministrar 5 V a la placa desde el Arduino.
También debes mantener ambos jumpers ENA y ENB en su lugar para que el motor esté siempre habilitado.
¿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 cómo conectarlo correctamente. Yo uso el siguiente truco para identificar 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 cada una de las dos bobinas. Una bobina se conecta a OUT1 y OUT2 y la otra a OUT3 y OUT4, 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 qué tan difícil 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 nuevamente.
- 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 cableado arriba.
Código de ejemplo con la biblioteca Stepper.h para driver L298N con motor paso a paso y Arduino
Puedes subir el siguiente código de ejemplo a tu Arduino usando la Arduino IDE.
Este ejemplo usa la Stepper.h biblioteca, que debería venir preinstalada con el IDE de Arduino. Puedes encontrarla yendo a Sketch > Include Library > Stepper.
Este sketch hace girar el motor paso a paso 1 revolución en una dirección, pausa, y luego gira 1 revolución en la dirección opuesta.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and Stepper.h library.
More info: https://www.makerguides.com */
// Include the Stepper library:
#include "Stepper.h"
// Define number of steps per revolution:
const int stepsPerRevolution = 200;
// Initialize the stepper library on pins 8 through 11:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
void setup() {
// Set the motor speed (RPMs):
myStepper.setSpeed(100);
}
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);
}
Cómo funciona el código:
El sketch comienza incluyendo la biblioteca Stepper.h de Arduino. Más información sobre esta biblioteca se puede encontrar en la Arduino website.
// Include the Stepper library: #include "Stepper.h"
Luego necesitamos definir cuántos pasos toma el motor para girar 1 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 paso a paso o configuración.
// Define number of steps per revolution: const int stepsPerRevolution = 200;
Después de esto, debes 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, pin3, pin4) donde steps es el número de pasos por revolución y pin1 a pin4 son los pines usados para manejar el motor paso a paso. En nuestro caso son los pines 8, 9, 10 y 11.
// Initialize the stepper library on pins 8 through 11: Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
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, 8, 9, 10, 11);. El nombre ‘myStepper’ se usará para establecer la velocidad y el número de pasos para este motor en particular. Nota que puedes crear múltiples objetos stepper con diferentes nombres si quieres controlar más de un motor.
En el setup() definimos la velocidad del motor. Puedes establecer la velocidad en RPM con la función setSpeed(rpm). La puse en 100, así que deberíamos ver alrededor de 1.6 revoluciones por segundo.
// Set the motor speed (RPMs): myStepper.setSpeed(100);
En la sección loop del código, 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 al siguiente comando en tu sketch.
Instalando la 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 este ejemplo usaré la AccelStepper biblioteca.
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 instalar la biblioteca yendo a Tools > Manage Libraries… o presionando 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 con AccelStepper
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 L298N motor driver, Arduino UNO and AccelStepper.h library.
Contiuous rotation.
https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
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:
El primer paso es incluir la biblioteca con #include "AccelStepper.h«.
// Include the AccelStepper library: #include "AccelStepper.h"
El siguiente paso es definir el tipo de interfaz del motor. El tipo de interfaz debe ser 4 cuando se usa un motor paso a paso de 4 cables en modo paso completo (200 pasos/revolució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 motorInterfaceType, el compilador lo reemplazará por el valor 4 al compilar el programa.
// Define the AccelStepper interface type: #define MotorInterfaceType 4
Luego, debes crear una nueva instancia de la clase AccelStepper con el tipo de interfaz y conexiones apropiadas.
En este caso llamé al motor paso a paso ‘stepper’ pero puedes usar otros nombres, como ‘z_motor’ o ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, 8, 9, 10, 11);. Como viste en el ejemplo anterior, el nombre que le des al motor paso a paso se usará para establecer 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, 8, 9, 10, 11);
En la setup() sección del código definimos la velocidad máxima en pasos/segundo. Velocidades mayores a 1000 pasos por segundo pueden ser poco fiables, así que establecí este valor como máximo. Nota 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 definir una velocidad diferente para cada uno:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(300);
}
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 poner 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 el tiempo desde el último paso. Si quieres cambiar la dirección del motor, puedes poner una velocidad negativa: stepper.setSpeed(-400); hace girar el motor 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. Código de ejemplo para controlar número de pasos o revoluciones
Con el siguiente sketch puedes controlar la velocidad, dirección y número de pasos/revoluciones.
En este caso, el motor paso a paso gira 2 revoluciones en sentido horario a 200 pasos/seg, luego gira 1 revolución en sentido antihorario a 600 pasos/seg, y finalmente gira 3 revoluciones en sentido horario a 400 pasos/seg.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum 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 igual que en el ejemplo anterior.
En el loop uso un while loop en combinación con la función currentPosition() . Primero, establezco 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 de los paréntesis () sea falsa. Así que en este caso verifico si la posición actual del motor paso a paso 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 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 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 razones para usar la biblioteca AccelStepper.
Con el siguiente sketch puedes añadir aceleración y desaceleración a los movimientos del motor paso a paso sin codificación complicada. 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/segundo2.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
Acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// 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, necesitamos definir la aceleración/desaceleración. Para esto usamos 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 la sección loop del código, 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 hasta 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 un driver L298N. Hemos visto 4 ejemplos, usando tanto las bibliotecas Stepper como AccelStepper.
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 A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
Ten en cuenta que el Arduino Motor Shield Rev3 también usa un driver L298.
Si tienes alguna pregunta, sugerencia, o crees que falta algo en este tutorial, por favor deja un comentario abajo.
