En este tutorial, te proporcionaré toda la información necesaria para controlar la velocidad y dirección de un motor DC con un controlador de motor L293D usando una placa Arduino UNO.
He incluido un diagrama de conexiones y detalles del código Arduino para controlar el motor DC enviando caracteres desde el Monitor Serial del IDE de Arduino con múltiples ejemplos.
Suministros
Componentes de hardware
| Arduino Uno Rev3 | × 1 | Amazon |
| Cable USB tipo A/B | × 1 | Amazon |
| Motor DC con caja de engranajes | × 1 | Amazon |
| Driver IC L293D | × 1 | Amazon |
| Protoboard | × 1 | Amazon |
| Cables jumper | × 15 | Amazon |
| Fuente de alimentación (5V) | × 1 | Amazon |
Software
| Arduino IDE | Arduino_IDE |
Makerguides.com participa en el Programa de Asociados de Amazon Services LLC, un programa de publicidad de afiliados diseñado para proporcionar un medio para que los sitios ganen comisiones publicitarias mediante la publicidad y enlace a productos en Amazon.com.
Acerca del Driver IC L293D
El L293D es un driver IC de media H puente de alta corriente cuádruple, adecuado para controlar motores DC. Puede proporcionar una corriente de conducción bidireccional de hasta 1 A a voltajes de 4.5 V a 36 V. A continuación puedes encontrar la hoja de datos del chip.
Pinout del IC L293D
El L293D es un driver IC de motor de 16 pines, y puedes controlar dos motores DC o un motor paso a paso con una corriente máxima de 600mA.
Pines de alimentación
El pin 8 (VCC_2) y el pin 16 (VCC_1) se usan para alimentar el driver de motor L293D.
VCC_2 suministra la alimentación al puente H interno del IC, y puede ser de 4.5V a 36V. VCC_1 se usa para la lógica interna y debe ser 5 V. Los pines 4, 5, 12 y 13 (GND) son tierra del dispositivo y pines para disipador de calor.
Pines de control de dirección
El pin 2 (Input_1), pin 7 (Input_2), pin 10 (Input_3) y pin 15 (Input_4) controlan los interruptores del circuito puente H dentro del IC L293D.
Input_1 e Input_2 están conectados a dos terminales del motor DC_1 y se usan para controlar la dirección del motor_1. De forma similar, Input_3 e Input_4 controlan la dirección del motor_2.
Usaré un Arduino UNO para generar señales de dirección para todos los pines Input, y según el nivel de estos pines (Alto o Bajo) el motor girará hacia adelante o hacia atrás.
Puedes ver los detalles en la tabla siguiente para el control de dirección del motor.
| Input_1 / Input_3 | Input_2 / Input_4 | Dirección del motor |
| Bajo | Bajo | Freno, motor apagado |
| Bajo | Alto | Hacia atrás (Antihorario) |
| Alto | Bajo | Hacia adelante (Horario) |
| Alto | Alto | Freno, motor apagado |
Pines de control de velocidad
Los motores DC pueden girar a una velocidad especificada según el valor establecido por Arduino UNO en el Pin 1 (Enable_A) para Motor_1 y Pin 9 (Enable_B) para Motor_2.
Una señal activa en alto en el pin enable enciende el canal del driver del IC L293D, permitiendo que el motor funcione a velocidad completa.
Una señal activa en bajo en el pin enable apaga el canal del driver del IC L293D, deteniendo el motor. Para controlar la velocidad del motor DC, debes enviar señales PWM en el pin enable del IC L293D. La velocidad del motor DC cambiará según el ciclo de trabajo de las señales PWM.
Los detalles se explican en la sección de código.
Pines de salida del motor
El driver L293D proporciona una corriente de salida de hasta 600mA al motor DC por el Pin 3 (Output_1), Pin 6 (Output_2) para Motor_1 y Pin 11 (Output_3), Pin 14 (Output_4) para Motor_2.
Especificaciones del motor DC
Voltaje
Hay una variedad de motores DC en el mercado, con voltajes nominales de 3V a 100V; sin embargo, para aplicaciones robóticas, se usan ampliamente motores DC de 6V, 12V o 24V. En este tutorial, consideraremos motores DC con caja de engranajes de 3V a 6V.
Corriente
Debes seleccionar un motor DC con una corriente máxima de 600mA porque por encima de esta corriente, el driver L293D se calentará y podría quemarse.
Torque
El torque del motor es un factor importante cuando se maneja una carga en el motor, y si tienes una aplicación donde necesitas poner más carga, debes comprar un motor con mayor torque. Otra forma de aumentar el torque es usar una caja de engranajes con el motor.
En este tutorial, uso un motor DC con caja de engranajes con una relación de 1:48.
Conexión del driver L293D con Arduino UNO
En esta sección aprenderás cómo conectar los motores DC con el driver L293D y la placa Arduino UNO.
Paso 1: Conexión de motores al IC L293D
Es mejor comenzar conectando los cables de los motores a los pines de salida del IC L293D.
Conecta los cables del Motor_1 a los pines 3 (Output_1) y 6 (Output_2) y los cables del Motor_2 a los pines 11 (Output_3) y 14 (Output_4).
Paso 2: Conexión de Arduino UNO al IC L293D
Ahora conecta el pin digital 10 y 9 de Arduino a los pines 2 (Input_1) y 7 (Input_2) del L293D para Motor_1.
De forma similar, conecta el pin digital 4 y 3 de Arduino a los pines 10 (Input_3) y 15 (Input_4) del L293D para Motor_2.
Además, debes proporcionar señales PWM en los pines Enable para controlar la velocidad de los motores DC.
Conecta el pin PWM 11 de Arduino UNO al pin 1 (Enable_A) del L293D para Motor_1 y conecta el pin PWM 5 de Arduino UNO al pin 9 (Enable_B).
Paso 3: Conexión de la fuente de alimentación al IC L293D
Ahora puedes suministrar 5V al IC L293D conectando el pin 8 (VCC_2) y el pin 16 (VCC_1) a 5V (terminal positivo de la fuente).
Conecta todas las tierras del IC a tierra común en la protoboard.
Todas las conexiones se muestran en la imagen.
Código Arduino – Controlando un motor DC vía terminal serial
Si quieres probar tu motor DC, debes tener control sobre él.
El siguiente código te permite controlar la velocidad y dirección de ambos motores DC individual y simultáneamente enviando caracteres desde el Monitor Serial del IDE de Arduino.
Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código y subirlo a tu placa Arduino UNO.
A continuación, explicaré cómo funciona el código.
// Motor_1 Connection
#define ENABLE_1 11
#define MOTOR_1_A 10
#define MOTOR_1_B 9
// Motor_2 Connection
#define ENABLE_2 5
#define MOTOR_2_A 4
#define MOTOR_2_B 3
// other variables
char serial_data;
int speed_value_m1;
int speed_value_m2;
void setup() {
Serial.begin(9600);
Serial.println("Motor Init..");
motor_1_init();
motor_2_init();
speed_value_m1 = 0;
speed_value_m2 = 0;
}
void loop() {
motor_speed_dir_control();
}
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
void motor_speed_dir_control() {
while (Serial.available()) {
serial_data = Serial.read();
switch (serial_data) {
case 's':
analogWrite(ENABLE_1, 255);
Serial.println("Enable Motor_1");
break;
case 'S':
analogWrite(ENABLE_2, 255);
Serial.println("Enable Motor_2");
break;
case 'h':
analogWrite(ENABLE_1, 0);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
speed_value_m1 = 0;
Serial.println("Stop Motor_1");
break;
case 'H':
analogWrite(ENABLE_2, 0);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
speed_value_m2 = 0;
Serial.println("Stop Motor_2");
break;
case 'f':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Serial.println("Motor_1 Forward Direction");
break;
case 'F':
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
Serial.println("Motor_2 Forward Direction");
break;
case 'b':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
Serial.println("Motor_1 Backward Direction");
break;
case 'B':
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
Serial.println("Motor_2 Backward Direction");
break;
case 'a':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_1, i);
}
Serial.println("Motor_1 acceleration");
break;
case 'A':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_2, i);
}
Serial.println("Motor_2 acceleration");
break;
case 'd':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_1, i);
delay(5);
}
Serial.println("Motor_1 deceleration");
break;
case 'D':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_2, i);
delay(5);
}
Serial.println("Motor_2 deceleration");
break;
case 'i':
if (speed_value_m1 <= 245) {
speed_value_m1 += 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 increased Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'I':
if (speed_value_m2 <= 245) {
speed_value_m2 += 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 increased Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'r':
if (speed_value_m1 >= 10) {
speed_value_m1 -= 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 reduced Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'R':
if (speed_value_m2 >= 10) {
speed_value_m2 -= 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 reduced Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'X':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Forward Direction");
break;
case 'Y':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Backward Direction");
break;
case 'Z':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 0);
analogWrite(ENABLE_2, 0);
Serial.println("Motor_1 and Motor_2 Stop");
break;
default:
break;
}
}
}
Cómo funciona el código
Primero he definido las variables para los pines de Arduino UNO según las conexiones y otras variables para almacenar datos seriales y el valor de velocidad.
//Motor_1 Connection #define ENABLE_1 11 #define MOTOR_1_A 10 #define MOTOR_1_B 9 //Motor_2 Connection #define ENABLE_2 5 #define MOTOR_2_A 4 #define MOTOR_2_B 3 //other variables char serial_data; int speed_value_m1; int speed_value_m2;
Como probaré los motores DC con comandos desde el Monitor Serial, necesito inicializar la conexión serial del Arduino UNO. He configurado la velocidad de comunicación a 9600 baudios.
Serial.begin(9600);
Luego, he configurado la dirección de los pines de Arduino UNO como salida para enviar señales al driver IC L293D, y inicialmente todos los pines están en bajo.
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
Finalmente, en void loop(), que es un bucle infinito, llamo a la función motor_speed_dir_control() para realizar diferentes operaciones en los motores DC según el carácter recibido del Monitor Serial.
He usado la función Serial.read() para leer el pin Rx de Arduino UNO, y este carácter recibido se almacena en serial_data.
Ahora se han escrito diferentes casos para controlar los motores DC en sentencias switch.
Puedes usar los siguientes comandos seriales para el control de velocidad y dirección de los motores DC:
| Motor_1 | Motor_2 | Salida |
| s | S | Habilitar motor DC |
| h | H | Detener motor DC |
| f | F | Establecer dirección hacia adelante para motor DC |
| b | B | Establecer dirección hacia atrás para motor DC |
| a | A | Acelerar motor DC a velocidad máxima desde cero |
| d | D | Desacelerar motor DC a velocidad cero desde máxima |
| i | I | Incrementar velocidad del motor DC en 10 |
| r | R | Reducir velocidad del motor DC en 10 |
| X | Hacer girar ambos motores DC en dirección hacia adelante |
| Y | Hacer girar ambos motores DC en dirección hacia atrás |
| Z | Detener ambos motores DC |
¿Cómo controlar la posición de un motor DC con Arduino?
Para controlar la posición en una dirección particular, primero debes establecer la dirección del motor DC y luego aplicar la señal PWM en los pines enable.
Tomemos el ejemplo de mover el Motor_1 hacia adelante a máxima velocidad. Primero, debes establecer la dirección hacia adelante en el código Arduino.
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Ahora, configura el pin enable en alto para mover el Motor_1 hacia adelante.
analogWrite(ENABLE_1, 255);
De forma similar, puedes establecer diferentes direcciones para ambos motores y cambiar su posición como he hecho en diferentes casos.
¿Cómo controlar la velocidad de un motor DC con Arduino?
Para controlar la velocidad del motor DC, debes proporcionar Modulación por Ancho de Pulso (PWM) en el pin enable.
| Enable_A / Enable_B | Velocidad del motor |
| Bajo | Cero (Parado) |
| Alto | Velocidad máxima |
| PWM | Control de velocidad según el valor de la señal PWM |
analogWrite(pin, value) se usa para establecer PWM en los pines Enable del IC L293D. Con Arduino UNO, puedes establecer la velocidad de cero (0) a máximo (255). Consulta los casos ‘a’, ‘A’, ‘d’, ‘D’, ‘i’, ‘I’, ‘r’ y ‘R’ en el código.
Prueba de motores DC
Una vez que subas el código a la placa Arduino UNO, en el IDE de Arduino, ve a “Tools” y haz clic en “Serial Monitor” o usa el atajo “Ctrl+Shift+M.”
Primero, asegúrate de haber seleccionado la velocidad de baudios correcta, es decir, 9600. Ahora, en el Monitor Serial, puedes probar tu código con los motores DC que has conectado al IDE de Arduino enviando comandos desde el Monitor Serial.
Ejemplo 1: Haz girar el Motor_1 en dirección hacia adelante y luego desacelera, acelera, incrementa, reduce la velocidad, invierte la dirección y finalmente detén el motor.
Envía los siguientes caracteres uno por uno en minúsculas desde el Monitor Serial:
f, s, d, a, i, i, i, i, i, i, i, i, i, i, i, i, r, r, r, r, r, r, r, r, r, r, r, r, b, s, h
De forma similar, también puedes controlar el Motor_2 enviando los caracteres anteriores en mayúsculas. Ten en cuenta que puedes hacer funcionar ambos motores enviando caracteres según tus necesidades.
Ejemplo 2: Haz funcionar Motor_1 y Motor_2 simultáneamente hacia adelante, luego hacia atrás y detén ambos motores.
Envía los siguientes caracteres:
X, Y, Z
Conclusión
Después de este tutorial, podrás aplicar la lógica usada para controlar la velocidad y dirección de motores DC para construir proyectos electrónicos innovadores y creativos con motores DC y la placa Arduino.
Si tienes alguna pregunta, sugerencia o crees que falta algo en este tutorial, por favor deja un comentario abajo.
