Control de Carro con el driver L298N

La robótica móvil es un campo apasionante que combina la mecánica con la electrónica y la programación. Este proyecto se centra en la implementación de un sistema de control de movimiento robusto para un carro móvil, utilizando la placa Arduino como cerebro lógico y el módulo Driver L298N como la interfaz de potencia esencial. Este sistema permite manipular con precisión la dirección y la velocidad de dos motores de corriente continua (DC), sentando las bases para vehículos autónomos o controlados remotamente.

🔩Funcionamiento

El objetivo principal es controlar el movimiento de un carro accionado por dos motores DC, utilizando la placa Arduino para enviar señales al driver L298N. El driver actúa como intermediario, regulando la dirección y la velocidad de los motores según las instrucciones del Arduino. Este proyecto puede ampliarse para incluir funcionalidades como control remoto, sensores de obstáculos o seguimiento de líneas.

Para lograr el movimiento controlado, se requiere la sinergia de tres componentes principales: el microcontrolador, el controlador de motor y los actuadores.

El Microcontrolador (Arduino Uno)

El Arduino Uno es la unidad central de procesamiento. Su función es:

1. Procesar la Lógica: Contiene el sketch (código) que define los patrones de movimiento (avanzar, retroceder, girar, detenerse).
2. Generar Señales: Produce señales digitales y, lo más importante, señales de Modulación por Ancho de Pulso (PWM) para controlar la velocidad.

El Actuador (Motores DC)

Los motores de Corriente Continua (DC) son los encargados de transformar la energía eléctrica en movimiento mecánico. Son simples y eficientes, pero requieren una corriente y un voltaje que el Arduino por sí solo no puede suministrar.

• El Dilema de la Corriente: Los motores DC, especialmente bajo carga, pueden demandar cientos de miliamperios o incluso amperios de corriente. Los pines digitales del Arduino están limitados a solo unos 40 mA por pin. Conectar un motor directamente a un pin de Arduino dañaría permanentemente el microcontrolador. Aquí es donde entra en juego el driver.

La Interfaz de Potencia (Driver L298N)

El módulo Driver L298N es un puente H doble (Dual H-Bridge) y es el componente más crítico para la seguridad y funcionalidad del carro.

• Función del Puente H: Un puente H es un circuito electrónico que permite aplicar voltaje a través de una carga (el motor) en ambas direcciones, lo que habilita la capacidad de rotar el motor hacia adelante y hacia atrás.
• Aislamiento de Potencia: El L298N opera como un intermediario de potencia. Recibe señales lógicas de bajo voltaje (5V) del Arduino (que indican dirección y velocidad) y utiliza una fuente de alimentación externa de alto voltaje y alta corriente (típicamente 7-12V) para impulsar los motores. Esto protege completamente el Arduino de las demandas de corriente del motor y del ruido eléctrico que estos generan.

El módulo L298N ofrece dos canales de control independientes (Motor A y Motor B), cada uno requiere tres pines de control del Arduino:

_🔨Componentes

🔌Conexiones

• Conexión de motores:
  • Conecta el motor “A” a la salida A del L298N
  • Conecta el motor “B” a la salida B del L298N
  • Conecta el pin VCC del sensor al pin de 5V del Arduino.
• Conexión de batería (5v-12v):
  • Conecta el positivo de la batería a VIN del L298N(NO QUITAR EL JUMPER REGULADOR del L298N)
  • Conecta el negativo de la batería a GND del L298N(NO QUITAR EL JUMPER REGULADOR del L298N)
• Conexión de arduino:
  • Conecta VIN de arduino a 5v(no a VIN) del L298N
  • Conecta GNG de arduino a GND de la bateria.
  • Conecta pin 2 del arduino a IN1 del L298N.
  • Conecta pin 3 del arduino a IN2 del L298N.
  • Conecta pin 5 a EN-A del L298N.
  • Conecta pin 7 del arduino a IN3 del L298N.
  • Conecta pin 8 del arduino a IN4 del L298N.
  • Conecta pin 10 a EN-B del L298N.

NOTA:

No remover el jumper regulador del L298N si vas a usar la salida de 5V.

0️⃣Código

 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

#include <Arduino.h>

void aForward(int vel);
void bForward(int vel);
void aBack(int vel);
void bBack(int vel);
void stop();

int IN1 = 2;			// IN1 a pin digital 2
int IN2 = 3;			// IN2 a pin digital 3
int ENA = 5;			// ENA a pin digital 5
int IN3 = 7;			// IN3 a pin digital 7
int IN4 = 8;			// IN4 a pin digital 8
int ENB = 10;			// ENA a pin digital 10

int Velocity;			// variable velocidad

void setup(){
  pinMode(IN1, OUTPUT);		// IN1 como salida	
  pinMode(IN2, OUTPUT);		// IN2 como salida
  pinMode(ENA, OUTPUT);		// ENA como salida
  pinMode(IN3, OUTPUT);		// IN3 como salida
  pinMode(IN4, OUTPUT);		// IN4 como salida
  pinMode(ENB, OUTPUT);		// ENB como salida
}

void loop(){
  Velocity = 255;		// valor de velocidad   

  aForward(Velocity);		// motor A avanza
  bForward(Velocity);		// motor b avanza
  delay(1000);	// demora 1 seg.
  
  stop();		// detener motores
  delay(1000);			// demora 1 seg.

  aForward(Velocity);		// motor A avanza
  delay(1000);	// demora 1 seg.

  stop();		// detener motores
  delay(1000);	// demora 1 seg.

  aForward(Velocity);		// motor A avanza
  bForward(Velocity);		/// motor B avanza
  delay(1000);	// demora 1 seg.

  stop();		// detener motores
  delay(1000);	// demora 1 seg.

  bForward(Velocity);		// motor B avanza
  delay(1000);	// demora 1 seg.

  stop();		// detener motores
  delay(1000);	// demora 1 seg.

  aBack(Velocity);	// motor A retrocede
  bBack(Velocity);	// motor B avanza
  delay(1000);	// demora 1 seg.

  stop();		// detener motores
  delay(1000);	// demora 1 seg.

  bForward(Velocity);		// motor B avanza
  delay(1000);	// demora 1 seg.

  stop();		// detener motores
  delay(1000);	// demora 1 seg.

}

void aForward(int vel){	// función avance de motor A
  analogWrite(ENA, vel);	
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
}

void bForward(int vel){	// función avance de motor B
  analogWrite(ENB, vel);	
  digitalWrite(IN3, LOW);	
  digitalWrite(IN4, HIGH);	
}

void aBack(int vel){	// función retroceso de motor A
  analogWrite(ENA, vel);	
  digitalWrite(IN1, HIGH);	
  digitalWrite(IN2, LOW);	
}

void bBack(int vel){	// función retroceso de motor B
  analogWrite(ENB, vel);	
  digitalWrite(IN3, HIGH);	
  digitalWrite(IN4, LOW);	
}

void stop(){		// función detener ambos motores
  analogWrite(ENA, 0);		
  analogWrite(ENB, 0);		
}

🖌️Diseños

🎬Videos

📑Conclusión

Este proyecto ha logrado con éxito establecer un sistema de control de movimiento robusto y preciso para un carro accionado por dos motores DC, utilizando la sinergia entre el microcontrolador Arduino Uno y el driver L298N.

La clave del éxito reside en la correcta aplicación del driver L298N como una interfaz de potencia (Puente H). Esto no solo resolvió el problema fundamental de la limitación de corriente del Arduino, sino que también permitió el control bidireccional de los motores (avanzar/retroceder) y, críticamente, la manipulación de la velocidad mediante señales de Modulación por Ancho de Pulso (PWM). La cuidadosa gestión de las señales lógicas por el Arduino y el imprescindible uso de una tierra común entre las fuentes de alimentación garantizaron el funcionamiento estable y la seguridad del microcontrolador.

En resumen, el proyecto constituye una puerta de entrada fundamental a la robótica móvil. La funcionalidad demostrada —control preciso de dirección y velocidad— permite la escalabilidad inmediata. Este sistema puede ser la base para futuros desarrollos más complejos, como la integración de sensores para la navegación autónoma o la implementación de módulos inalámbricos para el control remoto, sentando así las bases para la creación de vehículos robóticos avanzados.