Arduino DC Motor Control Tutorial - L298N | PWM | H-Bridge

En este tutorial de Arduino, aprenderemos cómo controlar los motores de CC con Arduino. Examinamos
bien algunas técnicas básicas para controlar los motores de CC y hacemos dos ejemplos a través de los
cuales aprenderemos cómo controlar los motores de CC con el controlador L298N y la placa Arduino.

Visión de conjunto

Podemos controlar la velocidad del motor de CC simplemente controlando el voltaje de entrada al motor
y el método más común de hacerlo es mediante el uso de señal PWM.

Control de motor PWM DC

PWM, o modulación de ancho de pulso es una técnica que nos permite ajustar el valor promedio de la
tensión que va al dispositivo electrónico al encender y apagar la potencia a una velocidad rápida. El
voltaje promedio depende del ciclo de trabajo, o la cantidad de tiempo que la señal está activada en
función de la cantidad de tiempo que la señal está desactivada en un único período de tiempo.

Entonces, dependiendo del tamaño del motor, simplemente podemos conectar una salida Arduino PWM a
la base del transistor o la puerta de un MOSFET y controlar la velocidad del motor controlando la salida
PWM. La señal Arduino PWM de baja potencia enciende y apaga la puerta en el MOSFET a través de la
cual se acciona el motor de alta potencia.
 Nota: Arduino GND y la fuente de alimentación del motor GND deben conectarse juntas.

Control de motor de CC H-Bridge

Por otro lado, para controlar la dirección de rotación, solo necesitamos invertir la dirección del flujo de
corriente a través del motor, y el método más común de hacerlo es mediante el uso de un H-Bridge. Un
circuito H-Bridge contiene cuatro elementos de conmutación, transistores o MOSFET, con el motor en el
centro formando una configuración tipo H. Al activar dos interruptores en particular al mismo tiempo,
podemos cambiar la dirección del flujo de corriente, y así cambiar la dirección de rotación del motor.

Entonces, si combinamos estos dos métodos, el PWM y el H-Bridge, podemos tener un control completo
sobre el motor de CC. Hay muchos controladores de motor DC que tienen estas características y el
L298N es uno de ellos.

Driver L298N
El L298N es un controlador de motor H-Bridge dual que permite el control de velocidad y dirección de
dos motores de CC al mismo tiempo. El módulo puede conducir motores de CC que tengan voltajes entre
5 y 35 V, con una corriente máxima de hasta 2A.
Echemos un vistazo más de cerca al pinout del módulo L298N y explique cómo funciona. El módulo
tiene dos bloques de terminales de tornillo para el motor A y B, y otro bloque de terminales de tornillo
para el pin de tierra, el VCC para el motor y un pin de 5V que puede ser una entrada o salida.

Esto depende del voltaje utilizado en los motores VCC. El módulo tiene un regulador de 5V incorporado
que se habilita o deshabilita usando un puente. Si la tensión de alimentación del motor es de hasta 12 V,
podemos habilitar el regulador de 5 V y el pin de 5 V se puede utilizar como salida, por ejemplo para
alimentar nuestra placa Arduino. Pero si la tensión del motor es superior a 12V, debemos desconectar el
puente porque esos voltajes causarán daños en el regulador de 5V incorporado. En este caso, el pin de 5V
se utilizará como entrada, ya que necesitamos conectarlo a una fuente de alimentación de 5V para que el
IC funcione correctamente.

Aquí podemos observar que este CI produce una caída de voltaje de aproximadamente 2V. Entonces, por
ejemplo, si usamos una fuente de alimentación de 12V, el voltaje en los terminales de los motores será de
aproximadamente 10V, lo que significa que no podremos obtener la máxima velocidad de nuestro motor
de 12V DC.
A continuación están las entradas de control lógico. Los pines Habilitar A y Habilitar B se utilizan para
habilitar y controlar la velocidad del motor. Si un jumper está presente en este pin, el motor estará
habilitado y funcionará a la velocidad máxima, y si eliminamos el jumper, podemos conectar una entrada
PWM a este pin y de esa manera controlar la velocidad del motor. Si conectamos este pin a tierra, el
motor se desactivará.

A continuación, los pines Input 1 y Input 2 se utilizan para controlar la dirección de rotación del motor A,
y las entradas 3 y 4 para el motor B. Con estos pines, realmente controlamos los interruptores del H-
Bridge dentro del IC L298N. Si la entrada 1 está BAJA y la entrada 2 está ALTA, el motor avanzará y
viceversa, si la entrada 1 es ALTA y la entrada 2 es BAJA, el motor retrocederá. En caso de que ambas
entradas sean iguales, ya sea BAJO o ALTO, el motor se detendrá. Lo mismo aplica para las entradas 3 y
4 y el motor B.
 Arduino y L298N
Ahora hagamos algunas aplicaciones prácticas. En el primer ejemplo, controlaremos la velocidad del
motor usando un potenciómetro y cambiaremos la dirección de rotación con un botón. Aquí están los
esquemas del circuito.

Entonces, necesitamos un controlador L298N, un motor de CC, un potenciómetro, un botón y una placa
Arduino.

Puede obtener los componentes necesarios para este tutorial de Arduino en los siguientes enlaces:

 L298N Driver ................................................... .. Amazon / Aliexpress

 Motor de CC de alto par de 12 V .............................. Amazon / Aliexpress
 Arduino Board ................................................ .. Amazon / Aliexpress
 Potenciómetro ................................................... Amazon / Aliexpress
* Tenga en cuenta: estos son enlaces de afiliado. Puedo hacer una comisión si compra los componentes a
través de estos enlaces.
Apreciaría su apoyo de esta manera!

Código Arduino
Aquí está el código de Arduino:

Here’s the Arduino code:

1. /* Arduino DC Motor Control - PWM | H-Bridge | L298N - Example 01

2.
3. by Dejan Nedelkovski, www.HowToMechatronics.com
4. */
5.
 6. #define enA 9
7. #define in1 6
8. #define in2 7
9. #define button 4
10.
11. int rotDirection = 0;
12. int pressed = false;
13.
14. void setup() {
15. pinMode(enA, OUTPUT);
16. pinMode(in1, OUTPUT);
17. pinMode(in2, OUTPUT);
18. pinMode(button, INPUT);
19. // Set initial rotation direction
20. digitalWrite(in1, LOW);
21. digitalWrite(in2, HIGH);
22. }
23.
24. void loop() {
25. int potValue = analogRead(A0); // Read potentiometer value
26. int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0 to 255
27. analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin
28.
29. // Read button - Debounce
30. if (digitalRead(button) == true) {
31. pressed = !pressed;
32. }
33. while (digitalRead(button) == true);
34. delay(20);
35.
36. // If button is pressed - change rotation direction
37. if (pressed == true & rotDirection == 0) {
38. digitalWrite(in1, HIGH);
39. digitalWrite(in2, LOW);
40. rotDirection = 1;
41. delay(20);
42. }
43. // If button is pressed - change rotation direction
44. if (pressed == false & rotDirection == 1) {
45. digitalWrite(in1, LOW);
46. digitalWrite(in2, HIGH);
47. rotDirection = 0;
48. delay(20);
49. }
50. }

Descripción: Primero, debemos definir los pines y algunas variables necesarias para el programa. En la
sección de configuración, necesitamos establecer los modos de pin y la dirección de rotación inicial del
motor. En la sección de bucle comenzamos leyendo el valor del potenciómetro y luego mapeamos el valor
que obtenemos de él que es de 0 a 1023, a un valor de 0 a 255 para la señal PWM, o que es 0 a 100% del
ciclo de trabajo de la Señal de PWM Luego, utilizando la función analogWrite (), enviamos la señal
PWM al pin Enable de la placa L298N, que realmente impulsa el motor.

A continuación, comprobamos si hemos presionado el botón, y si eso es cierto, cambiaremos la dirección

de rotación del motor ajustando inversamente los estados de Entrada 1 y Entrada 2. El botón pulsador
funcionará como botón de alternar y cada vez que lo presione, cambiará la dirección de rotación del
motor.
Arduino Robot Car Control con el controlador L298N
Entonces, una vez que hemos aprendido esto, ahora podemos construir nuestro propio auto robot
Arduino. Aquí está el esquema del circuito:

Todo lo que necesitamos es 2 DC Motors, el controlador L298N, una placa Arduino y un joystick para el
control. En cuanto a la fuente de alimentación, elegí utilizar tres baterías de iones de litio de 3.7 V, que
proporcionan un total de 11V. Hice el chasis de madera contrachapada de 3 mm, lo conecté a los motores
utilizando soportes metálicos, las ruedas adheridas a los motores y al frente adjunto una rueda giratoria.

Ahora echemos un vistazo al código Arduino y veamos cómo funciona. (Abajo puede encontrar el código
completo)
 1. int xAxis = analogRead ( A0 ) ; // Leer el eje X de Joysticks
2. int yAxis = analogRead ( A1 ) ; // Leer el eje Y de los joysticks

Después de definir los pines, en la sección de bucle, comenzamos con la lectura de los valores de los ejes
X e Y del joystick. El joystick está hecho de dos potenciómetros que están conectados a las entradas
analógicas del Arduino y tienen valores de 0 a 1023. Cuando el joystick permanece en su posición central,
el valor de ambos potenciómetros o ejes es de alrededor de 512.

Añadiremos un poco de tolerancia y consideraremos los valores de 470 a 550 como centro. Entonces, si
movemos el eje Y del joystick hacia atrás y el valor baja a 470, estableceremos la dirección de rotación de
los dos motores hacia atrás utilizando los cuatro pines de entrada. Luego, convertiremos los valores
decrecientes de 470 a 0 en valores de PWM crecientes de 0 a 255, que en realidad es la velocidad del
motor.

1. // Y-axis used for forward and backward control

2. if (yAxis < 470) {
3. // Set Motor A backward
4. digitalWrite(in1, HIGH);
5. digitalWrite(in2, LOW);
6. // Set Motor B backward
7. digitalWrite(in3, HIGH);
8. digitalWrite(in4, LOW);
9. // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the
motor speed
10. motorSpeedA = map(yAxis, 470, 0, 0, 255);
11. motorSpeedB = map(yAxis, 470, 0, 0, 255);
12. }

Similarmente, si movemos el eje Y del joystick hacia adelante y el valor va por encima de 550,
configuraremos los motores para avanzar y convertiremos las lecturas de 550 a 1023 en valores de PWM
de 0 a 255. Si el joystick permanece en su centro, la velocidad de los motores será cero.

A continuación, veamos cómo usamos el eje X para el control izquierdo y derecho del automóvil.

1. // X-axis used for left and right control

2. if (xAxis < 470) {
 3. // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
4. int xMapped = map(xAxis, 470, 0, 0, 255);
5. // Move to left - decrease left motor speed, increase right motor speed
6. motorSpeedA = motorSpeedA - xMapped;
7. motorSpeedB = motorSpeedB + xMapped;
8. // Confine the range from 0 to 255
9. if (motorSpeedA < 0) {
10. motorSpeedA = 0;
11. }
12. if (motorSpeedB > 255) {
13. motorSpeedB = 255;
14. }
15. }

De nuevo, primero tenemos que convertir las lecturas del eje X en valores de velocidad de 0 a 255. Para
mover hacia la izquierda, usamos este valor para disminuir la velocidad del motor izquierdo y aumentar la
velocidad correcta del motor. Aquí, debido a las funciones aritméticas, usamos dos declaraciones "if"
adicionales para limitar el rango de la velocidad del motor de 0 a 255.

El mismo método se usa para mover el automóvil a la derecha.

Dependiendo de la tensión aplicada y del propio motor, a velocidades más bajas, el motor no puede
comenzar a moverse y produce un zumbido. En mi caso, los motores no podían moverse si el valor de la
señal PWM estaba por debajo de 70. Por lo tanto, al utilizar estos dos enunciados if realmente me limité
al rango de velocidad de 70 a 255. Al final solo enviamos las velocidades finales del motor o Señal PWM
a los pines de habilitación del controlador L298N.

1. // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value
of 70)
2. if (motorSpeedA < 70) {
3. motorSpeedA = 0;
4. }
5. if (motorSpeedB < 70) {
6. motorSpeedB = 0;
7. }
8. analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
9. analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
Aquí está el código completo del ejemplo de Arduino robot car:

1. /* Arduino DC Motor Control - PWM | H-Bridge | L298N

2. Example 02 - Arduino Robot Car Control
3. by Dejan Nedelkovski, www.HowToMechatronics.com
4. */
5.
6. #define enA 9
7. #define in1 4
8. #define in2 5
9. #define enB 10
10. #define in3 6
11. #define in4 7
12.
13. int motorSpeedA = 0;
14. int motorSpeedB = 0;
15.
16. void setup() {
17. pinMode(enA, OUTPUT);
18. pinMode(enB, OUTPUT);
19. pinMode(in1, OUTPUT);
20. pinMode(in2, OUTPUT);
21. pinMode(in3, OUTPUT);
22. pinMode(in4, OUTPUT);
23. }
24.
25. void loop() {
26. int xAxis = analogRead(A0); // Read Joysticks X-axis
27. int yAxis = analogRead(A1); // Read Joysticks Y-axis
28.
29. // Y-axis used for forward and backward control
30. if (yAxis < 470) {
31. // Set Motor A backward
32. digitalWrite(in1, HIGH);
33. digitalWrite(in2, LOW);
34. // Set Motor B backward
35. digitalWrite(in3, HIGH);
36. digitalWrite(in4, LOW);
37. // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the
motor speed
38. motorSpeedA = map(yAxis, 470, 0, 0, 255);
39. motorSpeedB = map(yAxis, 470, 0, 0, 255);
40. }
41. else if (yAxis > 550) {
42. // Set Motor A forward
43. digitalWrite(in1, LOW);
44. digitalWrite(in2, HIGH);
45. // Set Motor B forward
46. digitalWrite(in3, LOW);
47. digitalWrite(in4, HIGH);
48. // Convert the increasing Y-axis readings for going forward from 550 to 1023 into 0 to 255 value for the PWM signal for increasing
the motor speed
49. motorSpeedA = map(yAxis, 550, 1023, 0, 255);
50. motorSpeedB = map(yAxis, 550, 1023, 0, 255);
51. }
52. // If joystick stays in middle the motors are not moving
53. else {
54. motorSpeedA = 0;
55. motorSpeedB = 0;
 56. }
57.
58. // X-axis used for left and right control
59. if (xAxis < 470) {
60. // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
61. int xMapped = map(xAxis, 470, 0, 0, 255);
62. // Move to left - decrease left motor speed, increase right motor speed
63. motorSpeedA = motorSpeedA - xMapped;
64. motorSpeedB = motorSpeedB + xMapped;
65. // Confine the range from 0 to 255
66. if (motorSpeedA < 0) {
67. motorSpeedA = 0;
68. }
69. if (motorSpeedB > 255) {
70. motorSpeedB = 255;
71. }
72. }
73. if (xAxis > 550) {
74. // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
75. int xMapped = map(xAxis, 550, 1023, 0, 255);
76. // Move right - decrease right motor speed, increase left motor speed
77. motorSpeedA = motorSpeedA + xMapped;
78. motorSpeedB = motorSpeedB - xMapped;
79. // Confine the range from 0 to 255
80. if (motorSpeedA > 255) {
81. motorSpeedA = 255;
82. }
83. if (motorSpeedB < 0) {
84. motorSpeedB = 0;
85. }
86. }
87. // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value
of 70)
88. if (motorSpeedA < 70) {
89. motorSpeedA = 0;
90. }
91. if (motorSpeedB < 70) {
92. motorSpeedB = 0;
93. }
94. analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
95. analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
96. }

Así que eso sería todo para este tutorial, y en mi próximo video actualizaremos este auto robot Arduino,
agregando un dispositivo Bluetooth y Radio para habilitar el control de teléfonos inteligentes e
inalámbricos.

No dude en hacer cualquier pregunta en la sección de comentarios a continuación y no olvide consultar

mi colección de Proyectos Arduino .

JLCPCB: prototipos de PCB por $ 2 + envío gratis en primer pedido

El fabricante de prototipos de PCB más grande de China, más de 290,000 clientes y más de 8,000 pedidos
en línea por día

Precio de 10 PCB: $ 2 para 2 capas, $ 15 para 4 capas, $ 74 para 6 capas