Introducción
En este tutorial te mostraremos cómo puedes utilizar un puente H L298N con Arduino para controlar pequeños motores de corriente directa. Aprenderemos a controlar la velocidad y dirección de los motores mediante el uso de señales PWM.
El L298N es un circuito integrado que tiene en su interior dos puentes H que pueden manejar motores que consumen hasta 2 amperes y con un voltaje de hasta 30 volts. En nuestro caso utilizaremos el módulo basado en el L298N para facilitar las conexiones.
Controlar motores es indispensable en cualquier proyecto de robótica y sabemos que Arduino es un cerebro genial para cualquier proyecto de este tipo, por lo que este tutorial puede ser la base para el tren motriz de tu próximo robot.
Materiales
Para realizar los ejercicios en esta página debemos adquirir los siguientes materiales:
- Arduino Uno Rev3 (también funciona con tarjeta compatible con Arduino Uno)
- Módulo puente H L298N
- Cables dupont para conexiones
- Motor de corriente directa o motorreductor de plástico
- Cable calibre 22 para conexiones
Recomendamos revisar detalladamente la página de cada producto para encontrar información útil, como sus especificaciones y recomendaciones de operación.
Conexión de módulo puente H doble L298N con Arduino Uno
Para la conexión de un puente H L298N con Arduino vamos a requerir de 4 a 6 pines digitales, dependiendo de si solamente queremos controlar la dirección de giro del motor o también deseamos controlar su velocidad.
El L298N es necesario debido a que los pines digitales de Arduino a penas pueden proporcionar unos 40 miliamperes a cualquier cosa que conectemos, mientras que la mayoría de los motores convencionales requerirán de 100 a 500 miliamperes o quizá más. El L298N funciona como una interfaz de potencia para nuestro Arduino.
En la siguiente imagen podemos apreciar el circuito completo para el módulo L298N.
Código para control de motores usando L298N con Arduino
Control de dirección de giro del motor
El programa más sencillo nos permitirá cambiar la dirección de giro de los motores. Para este caso podemos dejar colocados los jumpers en los pines ENA y ENB ya que no utilizaremos las señales de control PWM.
Este programa solamente alterna la dirección de giro de los motores cada 5 segundos. Este programa esta pensado para validar el funcionamiento del puente H L298N y su funcionamiento es muy sencillo de forma intencionada.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO PUENTE H L298N BÁSICO Descripción: Este programa hace girar los motores en un sentido y luego en el otro. El programa está pensado para NO usar los pines de control de PWM por lo que los jumpers correspondientes deben estar en su posición en el módulo L298N. Las conexiones a realizar son las siguientes: * IN1 - pin 9 * IN2 - pin 8 * IN3 - pin 7 * IN4 - pin 6 */ // pines de señales PWM const int ena = 10; const int enb = 5; // pines de control de dirección const int in1 = 9; const int in2 = 8; const int in3 = 7; const int in4 = 6; /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // iniciar puerto y mostrar mensaje Serial.begin(9600); Serial.println(F("----------------------------------------------------")); Serial.println(F(" L298N - CONTROL DE MOTORES ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // configurar los pines de control de motores como salidas // pines de control del motor A // pin de control de velocidad motor A pinMode(ena, OUTPUT); // control de dirección motor A pinMode(in1, OUTPUT); pinMode(in2, OUTPUT); // pines de control del motor B // pin de control de velocidad motor B pinMode(enb, OUTPUT); // control de dirección motor B pinMode(in3, OUTPUT); pinMode(in4, OUTPUT); // configurar el estado de las salidas del puente H para detener los // motores y en caso de que tengamos conectados los pines ENA Y ENB, // habilitar los puentes H colocando las señales correspondientes en // nivel alto. En este ejemplo las señales ENA y ENB no se usarán // para el control de velocidad. digitalWrite(ena, HIGH); digitalWrite(enb, HIGH); // motor A digitalWrite(in1, LOW); digitalWrite(in2, LOW); // motor B digitalWrite(in3, LOW); digitalWrite(in4, LOW); delay(1000); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { // motor A adelante digitalWrite(in1, HIGH); digitalWrite(in2, LOW); // motor B atrás digitalWrite(in3, LOW); digitalWrite(in4, HIGH); // los motores permanecen encendidos en la dirección actual por 5 segundos delay(5000); // luego invertimos el sentido de giro // motor A atras digitalWrite(in1, LOW); digitalWrite(in2, HIGH); // motor B adelante digitalWrite(in3, HIGH); digitalWrite(in4, LOW); // esperamos antes de volver a cambiar el sentido de giro delay(5000); } |
Control de velocidad de motor
Para controlar la velocidad del motor es necesario conectar las entradas ENA y ENB a pines que tengan la capacidad de generar señales PWM. En la tarjeta Arduino Uno los pines capaces de generar señales PWM son: 3, 5, 6, 9, 10, 11. En este ejemplo utilizaremos los pines 5 y 10 para controlar la velocidad del motor.
Este programa lleva los motores desde apagado hasta su máxima velocidad progresivamente y luego disminuye la velocidad hasta llegar nuevamente a apagado. La velocidad de giro se invierte en cada llamada a la función loop().
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO PUENTE H L298N PARA CONTROL DE VELOCIDAD Descripción: Este programa hace girar los motores en un sentido y luego en el otro. El programa acelera gradualmente los motores y luego disminuye la velocidad hasta detenerlos por completo, a continuación repite lo mismo, cambiando el sentido de giro. Las conexiones a realizar son las siguientes: * ENA - pin 10 * IN1 - pin 9 * IN2 - pin 8 * IN3 - pin 7 * IN4 - pin 6 * ENB - pin 5 */ // pines de señales PWM const int ena = 10; const int enb = 5; // pines de control de dirección const int in1 = 9; const int in2 = 8; const int in3 = 7; const int in4 = 6; // variable para alternar el sentido de giro bool giro = true; /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // iniciar puerto y mostrar mensaje Serial.begin(9600); Serial.println(F("----------------------------------------------------")); Serial.println(F(" L298N - CONTROL DE MOTORES ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // configurar los pines de control de motores como salidas // pines de control del motor A // pin de control de velocidad motor A pinMode(ena, OUTPUT); // control de dirección motor A pinMode(in1, OUTPUT); pinMode(in2, OUTPUT); // pines de control del motor B // pin de control de velocidad motor B pinMode(enb, OUTPUT); // control de dirección motor B pinMode(in3, OUTPUT); pinMode(in4, OUTPUT); // configurar el estado de las salidas del puente H para detener motores digitalWrite(ena, LOW); digitalWrite(enb, LOW); // motor A digitalWrite(in1, LOW); digitalWrite(in2, LOW); // motor B digitalWrite(in3, LOW); digitalWrite(in4, LOW); delay(1000); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { if (giro) { Serial.println(F("Motores hacia adelante!")); // motor A adelante digitalWrite(in1, HIGH); digitalWrite(in2, LOW); // motor B adelante digitalWrite(in3, HIGH); digitalWrite(in4, LOW); giro = false; } else { Serial.println(F("Motores en reversa!")); // motor A adelante digitalWrite(in1, LOW); digitalWrite(in2, HIGH); // motor B adelante digitalWrite(in3, LOW); digitalWrite(in4, HIGH); giro = true; } Serial.println(F("Acelerando!")); // acelerar motores hasta alcanzar la máxima velocidad for (int i = 0; i <= 255; i += 17) { delay(100); Serial.print(F("Valor analogWrite: ")); Serial.println(i); analogWrite(ena, i); analogWrite(enb, i); Serial.println(i); } // los motores permanecen encendidos en la dirección actual por 5 segundos delay(5000); Serial.println(F("Desacelerando!")); // desacelerar el motor hasta detenerlo totalmente for (int i = 255; i >= 0; i -= 17) { delay(100); Serial.print(F("Valor analogWrite: ")); Serial.println(i); analogWrite(ena, i); analogWrite(enb, i); Serial.println(i); } // los motores permanecen encendidos en la dirección actual por 5 segundos delay(5000); } |
Control de velocidad del motor mediante botones
El objetivo de este programa es controlar la velocidad de giro de un motor así como su dirección mediante botones que se conectan a las entradas digitales de Arduino. El comportamiento del programa es el siguiente:
- El botón conectado en D2 cambia el sentido de giro
- D3 disminuye la velocidad
- D4 aumenta la velocidad
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO PUENTE H L298N CONTROL DE VELOCIDAD CON BOTONES Descripción: Este programa permite controlar la dirección de giro y velocidad de un motor de corriente directa mediante botones. El botón conectado en el pin digital 2 alterna el sentido de giro, mientras que los botones conectados en D3 y D4 disminuyen y aumentan la velocidad de giro del motor respectivamente. Las conexiones a realizar son las siguientes: * ENA - pin 10 * IN1 - pin 9 * IN2 - pin 8 * IN3 - pin 7 * IN4 - pin 6 * ENB - pin 5 * btnDir - pin 2 * btnDisminuir - pin 3 * btnAumentar - pin 4 */ #include "GFButton.h" // pines de señales PWM const int ena = 10; const int enb = 5; // pines de control de dirección const int in1 = 9; const int in2 = 8; const int in3 = 7; const int in4 = 6; // variable para alternar el sentido de giro bool giro = false; // variable para almacenar la velocidad de los motores int velocidad = 0; // botones para cambiar la velocidad y dirección del motor GFButton btnDireccion(2); // cambia la dirección GFButton btnDisminuir(3); // disminuye la velocidad GFButton btnAumentar(4); // aumenta la velocidad /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // iniciar puerto y mostrar mensaje Serial.begin(9600); Serial.println(F("----------------------------------------------------")); Serial.println(F(" L298N - CONTROL DE MOTORES ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // configurar los pines de control de motores como salidas // pines de control del motor A // pin de control de velocidad motor A pinMode(ena, OUTPUT); // control de dirección motor A pinMode(in1, OUTPUT); pinMode(in2, OUTPUT); // pines de control del motor B // pin de control de velocidad motor B pinMode(enb, OUTPUT); // control de dirección motor B pinMode(in3, OUTPUT); pinMode(in4, OUTPUT); // detener motores con los pines PWM analogWrite(ena, 0); analogWrite(enb, 0); // motor A y B giran hacia adelante digitalWrite(in1, HIGH); digitalWrite(in2, LOW); digitalWrite(in3, HIGH); digitalWrite(in4, LOW); delay(1000); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { // alternar la dirección de giro con cada pulsación del botón if (btnDireccion.wasPressed()) { if (giro) { Serial.println(F("Motores hacia adelante!")); // motor A adelante digitalWrite(in1, HIGH); digitalWrite(in2, LOW); // motor B adelante digitalWrite(in3, HIGH); digitalWrite(in4, LOW); giro = false; } else { Serial.println(F("Motores en reversa!")); // motor A adelante digitalWrite(in1, LOW); digitalWrite(in2, HIGH); // motor B adelante digitalWrite(in3, LOW); digitalWrite(in4, HIGH); giro = true; } } // si se presiona el boton para aumentar la velocidad // incrementamos la variable hasta llegar a 255 if (btnAumentar.wasPressed() && velocidad < 255) { // cambiar la variable y escribirla al monitor serial velocidad += 17; Serial.print(F("Valor analogWrite: ")); Serial.println(velocidad); // cambiar el valor de la señal PWM analogWrite(ena, velocidad); analogWrite(enb, velocidad); } // si se presiona el boton para disminuir la velocidad // decrementamos la variable hasta llegar a 0 if (btnDisminuir.wasPressed() && velocidad > 0) { // cambiar la variable y escribirla al monitor serial velocidad -= 17; Serial.print(F("Valor analogWrite: ")); Serial.println(velocidad); // cambiar el valor de la señal PWM analogWrite(ena, velocidad); analogWrite(enb, velocidad); } } |
Conclusión
- En este tutorial aprendimos sobre la conexión de motores de corriente directa (CD) a la tarjeta Arduino mediante el puente H L298N.
- Aprendimos que Arduino puede requerir etapas de potencia para manejar dispositivos como un motor, ya que el microcontrolador no puede manejar por si mismo la corriente.
- Aprendimos a controlar la dirección de giro de los motores mediante los pines digitales de la tarjeta Arduino y el puente H aplicando la correcta combinación de señales en las entradas del módulo puente H.
- Experimentamos con el control de velocidad de un motor de corriente directa mediante señales PWM y realizamos un ejemplo completo que ilustra el control simultaneo de velocidad y dirección.
- Elaboramos un control digital de motores que permite elegir la dirección de giro y la velocidad de un motor mediante una interfaz con botones o pulsadores.
Y como alimentamos al Arduino si solo hemos puenteado la tierra?
Hola, Camilo, no conozco la respuesta a tu pregunta pero yo lo conecté como muestran y funcionó perfectamente.