Cómo controlar un motor de corriente continua con L293D Driver IC usando Arduino

En este tutorial, te daré toda la información necesaria sobre el control de la velocidad y la dirección de un motor de corriente continua con un IC controlador de motor L293D utilizando una placa Arduino UNO.

He incluido un diagrama de cableado y detalles del código de Arduino para controlar el motor de corriente continua mediante el envío de caracteres desde el Monitor Serial de Arduino IDE con múltiples ejemplos.

Suministros 

Componentes de hardware

Arduino Uno Rev3	× 1	Amazon
Cable USB tipo A/B	× 1	Amazon
Motor de la caja de cambios de CC	× 1	Amazon
IC del controlador L293D	× 1	Amazon
Tablero de pruebas	× 1	Amazon
Cables de puente	× 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 honorarios de publicidad mediante la publicidad y los enlaces a productos en Amazon.com.

Acerca del controlador de motor IC L293D

The L293D is a quadruple high current half-H driver IC suitable for controlling DC motors. It can provide a bidirectional drive current up to 1 A at voltages from 4.5 V to 36 V. Below you can find the datasheet for the chip.

Pinout of the L293D IC

El L293D es un IC controlador de motor de 16 pines, y puede controlar dos motores de corriente continua o un motor paso a paso bajo una corriente de 600mA.

Pines de la fuente de alimentación

Los pines 8 (VCC_2) y 16 (VCC_1) se utilizan para alimentar el CI del controlador del motor L293D.

VCC_2 provides the power supply to the internal H-Bridge of IC, and it can be from 4.5V to 36V.  VCC_1 is used for internal logic translation, and it should be 5 V. Pin 4, 5, 12, and 13 (GND) are the device ground and heat sink pins.

Clavijas de control de dirección

El Pin 2 (Input_1), el Pin 7 (Input_2), y el Pin 10 (Input_3), el Pin 15 (Input_4) controlan los interruptores del circuito H-Bridge dentro del CI L293D.

La entrada_1 y la entrada_2 tienen conectados dos terminales del motor_1 de corriente continua que se utilizan para controlar la dirección del motor_1. Del mismo modo, Input_3 y Input_4 se utilizan para controlar la dirección del motor_2.

Utilizaré un Arduino UNO para generar señales de dirección para todos los pines de entrada, y en base al nivel de estos pines (alto o bajo) el motor funcionará hacia adelante o hacia atrás.

Puede ver los detalles en la siguiente tabla para el control de la dirección del motor.

Entrada_1 / Entrada_3	Entrada_2 / Entrada_4	Dirección del motor
Bajo	Bajo	Pausa, motor apagado
Bajo	Alta	Hacia atrás (en sentido contrario a las agujas del reloj)
Alta	Bajo	Hacia delante (en el sentido de las agujas del reloj)
Alta	Alta	Pausa, motor apagado

Clavijas de control de velocidad

Los motores de corriente continua pueden girar a una velocidad determinada según el valor establecido por Arduino UNO en el pin 1 (Enable_A) para Motor_1 y el pin 9 (Enable_B) para Motor_2.

La señal activa alta permite que la clavija ponga en marcha el canal del controlador del CI L293D, lo que permite que el motor funcione a plena velocidad.

Active Low signal on enable pin turns OFF the driver channel of L293D IC, which will stop the motor. To control the speed of the DC motor, you need to send PWM signals on enable pin of L293D  IC. Speed of DC motor will change as per the duty cycle of PWM signals.

The details are explained in the code section.

Pines de salida del motor

El IC del controlador de motor L293D proporciona una corriente de salida de hasta 600mA al motor de corriente continua mediante el Pin 3 (Salida_1), el Pin 6 (Salida_2) para el Motor_1 y el Pin 11 (Salida_3), el Pin 14 (Salida_4) para el Motor_2.

Especificación del motor de CC

Tensión

A variety of DC motors are available in the market, rated from 3V to 100V; however, for robotic applications, 6V, 12V, or 24V DC motors are widely used. In this tutorial, we will consider 3V to 6V Gearbox DC motors.

Actual

Es necesario seleccionar el motor de corriente continua con una corriente máxima de 600mA porque por encima de esta corriente, el IC del controlador L293D se calentará y puede quemarse.

Par de apriete

Motor torque is an important factor when dealing with a load on the motor, and if you have an application where you need to put more load on the motor, you need to buy a  motor with higher torque.  Another way to increase the torque is to use a gearbox with a  motor.

En este tutorial, estoy utilizando un motor de corriente continua con una caja de cambios con una relación de transmisión de 1:48.

Cableado del IC controlador de motor L293D con Arduino UNO

En esta sección, usted aprenderá acerca de la interconexión de los motores de corriente continua con el IC de accionamiento L293D y la placa Arduino UNO. 

Paso 1: Conexiones del motor al CI L293D

Lo mejor sería comenzar con la conexión de los cables de los motores a los pines de salida del CI L293D.

Conecte los cables del Motor_1 al Pin 3 (Output_1) y al Pin 6 (Output_2) y los del Motor_2 al Pin 11 (Output_3) y al Pin 14 (Output_4).

Paso 2: Conexiones de Arduino UNO a L293D IC

Ahora, conecta los pines 10 y 9 de la salida digital del Arduino al pin 2 (Input_1) y al pin 7 (Input_2) del L293D para el Motor_1.

Del mismo modo, conecta los pines digitales del Arduino 4 y 3 al pin 10 (Input_3) y al pin 15 (Input_4) del L293D para el Motor_2.

Además, es necesario proporcionar señales PWM en los pines de habilitación para el control de la velocidad de los motores de CC.

Conecta el pin 11 de PWM del Arduino UNO al pin 1 (Enable_A) del L293d para el Motor_1 y conecta el pin 5 de PWM del Arduino UNO al pin 9 (Enable_B).

Paso 3: Alimentación del CI L293D Conexiones

Ahora puedes proporcionar una alimentación de 5V al CI L293D conectando el pin 8 (VCC_2) y el pin 16 (VCC_1) a 5V (terminal positivo de la alimentación).

Conecta todas las tierras del CI a la tierra común de la protoboard.

Todas las conexiones se muestran en la imagen.

Código Arduino - Control de un motor de corriente continua a través de un terminal serie

Si quieres probar tu motor de corriente continua, deberías tenerlo controlado.

El siguiente código permite controlar la velocidad y la dirección de ambos motores de corriente continua de forma individual y simultánea mediante el envío de caracteres desde el Monitor Serial de Arduino IDE.

Puedes copiar el código haciendo clic en el botón de la esquina superior derecha del campo de código y cargarlo en 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 los datos en serie y el valor de la 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 voy a probar los motores de corriente continua con comandos de Serial Monitor, necesito inicializar la conexión serie de la placa Arduino UNO. He establecido la tasa de baudios para la comunicación como 9600. 

Serial.begin(9600);

A continuación, he configurado la dirección de los pines del Arduino UNO como salida para proporcionar señales al driver IC L293D, e inicialmente, todos los pines están configurados como Low.

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 el void loop(), que es un bucle infinito, estoy llamando a la función motor_speed_dir_control() para realizar una operación diferente en los motores de corriente continua según el carácter recibido del Monitor Serial.

He utilizado la función Serial.read() para leer el pin Rx del Arduino UNO, y este carácter recibido se va a almacenar en serial_data.

Ahora se escriben diferentes casos para controlar los motores de corriente continua en los casos de conmutación.

Puede utilizar los siguientes comandos en serie para el control de velocidad y dirección de los motores de CC:

Motor_1	Motor_2	Salida
s	S	Habilitar el motor de CC
h	H	Parar el motor de CC
f	F	Ajustar la dirección de avance del motor de CC
b	B	Ajustar la dirección de retroceso para el motor de CC
a	A	Acelerar el motor de corriente continua hasta la velocidad máxima desde cero
d	D	Desacelerar el motor de corriente continua hasta la velocidad cero desde la máxima
i	I	Aumenta la velocidad del motor de CC en un 10
r	R	Reducir la velocidad del motor de CC en un 10

X	Haga funcionar los dos motores de CC en dirección de avance
Y	Haga funcionar los dos motores de CC en sentido inverso
Z	Parar los dos motores de corriente continua

¿Cómo se controla la posición de un motor de corriente continua en Arduino?

Para controlar la posición en una dirección determinada, primero hay que fijar la dirección del motor DC y luego aplicar la señal PWM en los pines de habilitación.

Tomemos un ejemplo de mover el Motor_1 hacia adelante a toda velocidad. Así que, en primer lugar, es necesario establecer la dirección de avance en el código de Arduino.

digitalWrite(MOTOR_1_A, HIGH); 

digitalWrite(MOTOR_1_B, LOW);

Ahora, pon el pin de habilitación como Alto para mover el Motor_1 hacia adelante.

analogWrite(ENABLE_1, 255);

Del mismo modo, se puede establecer una dirección diferente para ambos motores y cambiar su posición como he hecho en diferentes casos.

¿Cómo se controla la velocidad de un motor de corriente continua con un Arduino?

Para controlar la velocidad del motor de corriente continua, es necesario proporcionar la modulación de ancho de pulso (PWM) en el pin de habilitación.

Habilitar_A / Habilitar_B	Velocidad del motor
Bajo	Cero (Stop)
Alta	A toda velocidad
PWM	Control de velocidad según el valor de la señal PWM

analogWrite(pin, value) se utiliza para configurar el PWM en los pines de habilitación del IC L293D. Con Arduino UNO, se puede establecer la velocidad de cero (0) a la máxima (255). Consulte el caso 'a', 'A', 'd', 'D', 'i, 'I', 'r' y 'R' en el código.

Pruebas de los motores de CC

Una vez que hayas cargado el código en la placa Arduino UNO, en el IDE de Arduino, ve a "Herramientas" y haz clic en "Monitor Serial" o utiliza el atajo "Ctrl+Mayús+M".

En primer lugar, asegúrese de que ha seleccionado la tasa de baudios correcta, es decir, 9600. Ahora, en Serial Monitor, puedes probar tu código con los motores DC que has interconectado con Arduino IDE enviando comandos desde Serial Monitor.

Ejemplo 1: Haga funcionar el Motor_1 en dirección de avance y luego desacelere, acelere, aumente, reduzca la velocidad, invierta la dirección y finalmente detenga el motor.

Envíe los siguientes caracteres uno a uno en minúsculas desde el Monitor Serial:

f, s, d, a, i, i, i, i, i, i, i, i, i, i, i, r, r, r, r, r, r, r, r, r, r, r, b, s, h

Del mismo modo, también puede controlar el Motor_2 enviando los caracteres anteriores en mayúsculas. Tenga en cuenta que puede hacer funcionar ambos motores enviando los caracteres según sus necesidades.

Ejemplo 2: Haga funcionar el Motor_1 y el Motor_2 simultáneamente en avance, luego en retroceso, y detenga ambos motores.

Envíe los siguientes caracteres: 

X, Y, Z

Conclusión

Después de este tutorial, puedes aplicar la lógica utilizada para controlar la velocidad y la dirección de los motores de corriente continua para construir proyectos electrónicos innovadores y creativos con motores de corriente continua y la placa Arduino.

Espero que este tutorial te haya resultado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas! 

Me encantaría saber qué proyecto tenéis pensado construir o habéis hecho ya con motores de corriente continua y el Arduino.

Si tienes alguna sugerencia, o crees que faltan cosas en este tutorial, por favor deja un comentario abajo.