Introducción

El carro seguidor de línea es un proyecto de robótica educativa muy útil para que los estudiantes comprendan cómo un sistema puede detectar información del entorno y tomar decisiones automáticamente.

Este tipo de robot se desplaza siguiendo una línea trazada en el piso, normalmente de color negro sobre una superficie blanca. Para lograrlo, utiliza sensores infrarrojos que detectan la diferencia entre superficies claras y oscuras, y con esa información Arduino controla los motores para corregir la dirección del carrito.

Es un proyecto excelente para trabajar temas de:

• electrónica básica
• programación con Arduino
• sensores
• control de motores
• robótica educativa
• pensamiento lógico y resolución de problemas

Propósito del proyecto

El propósito de este proyecto es que los alumnos comprendan cómo funciona un sistema automático capaz de detectar una trayectoria y seguirla sin intervención humana, mediante el uso de sensores y programación.

Además, este proyecto permite que los estudiantes:

• relacionen la teoría con una aplicación real
• desarrollen habilidades prácticas de armado y conexión
• entiendan cómo un robot toma decisiones simples
• se introduzcan al mundo de la automatización y la robótica

¿Qué es un carro seguidor de línea?

Un carro seguidor de línea es un pequeño robot móvil diseñado para seguir una ruta marcada en el suelo. Generalmente utiliza dos sensores infrarrojos colocados en la parte inferior del chasis. Estos sensores detectan si debajo de ellos hay una superficie blanca o una línea negra.

Con base en esa lectura:

• si ambos sensores detectan la línea correctamente, el carro avanza
• si un sensor detecta que se está saliendo de la línea, el robot corrige girando
• si ambos sensores pierden la línea, el robot puede detenerse o buscar nuevamente el camino

Materiales

Componentes principales

• 1 Arduino UNO o Arduino Nano
• 1 módulo puente H L298N o L293D
• 2 motores DC con llantas
• 1 rueda loca
• 1 chasis para carrito
• 2 sensores infrarrojos seguidores de línea
• 1 portapilas o batería
• cables de conexión
• interruptor
• tornillos y sujetadores

Material opcional

• protoboard pequeña
• LEDs indicadores
• buzzer
• batería recargable

Funcionamiento del sistema

El sistema trabaja de la siguiente manera:

1. Los sensores infrarrojos se colocan debajo del carro, cerca del piso.
2. Cada sensor emite luz infrarroja y recibe el reflejo.
3. Cuando el sensor está sobre una superficie blanca, la reflexión cambia.
4. Cuando está sobre una línea negra, la reflexión es distinta.
5. Arduino interpreta esa información.
6. Dependiendo de qué sensor detecte la línea, Arduino controla los motores para avanzar, girar a la izquierda o a la derecha.

Lógica básica de control

Supongamos que tenemos dos sensores:

• Sensor izquierdo
• Sensor derecho

Entonces la lógica puede ser:

• Ambos sensores sobre blanco o centrados correctamente → avanzar
• Sensor izquierdo detecta línea negra → girar a la izquierda
• Sensor derecho detecta línea negra → girar a la derecha
• Ambos sensores detectan negro → detenerse o ajustar

Nota: en algunos módulos la salida del sensor cambia según la calibración; por eso al probarlo puede ser necesario invertir la lógica HIGH y LOW.

Conexión básica

Sensores

• Sensor izquierdo → pin 2 de Arduino
• Sensor derecho → pin 3 de Arduino
• VCC de sensores → 5V
• GND de sensores → GND

Módulo L298N

Motor A

• IN1 → pin 8
• IN2 → pin 9

Motor B

• IN3 → pin 10
• IN4 → pin 11

Alimentación

• GND del L298N conectado a GND de Arduino
• batería conectada al módulo de motores
• Arduino alimentado según el diseño del proyecto

Importante: todos los GND deben estar conectados en común.

Código para carro seguidor de línea

// ===== Carro seguidor de línea con Arduino =====

// Sensores
int sensorIzquierdo = 2;
int sensorDerecho = 3;

// Control de motores con L298N
int IN1 = 8;
int IN2 = 9;
int IN3 = 10;
int IN4 = 11;

// Variables para guardar lecturas
int valorIzquierdo;
int valorDerecho;

void setup() {
  // Configurar sensores como entrada
  pinMode(sensorIzquierdo, INPUT);
  pinMode(sensorDerecho, INPUT);

  // Configurar pines de motores como salida
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  // Monitor serial para pruebas
  Serial.begin(9600);
}

void loop() {
  // Leer sensores
  valorIzquierdo = digitalRead(sensorIzquierdo);
  valorDerecho = digitalRead(sensorDerecho);

  // Mostrar valores en monitor serial
  Serial.print("Izquierdo: ");
  Serial.print(valorIzquierdo);
  Serial.print(" | Derecho: ");
  Serial.println(valorDerecho);

  // ===== Lógica del seguidor de línea =====
  // Ajusta HIGH y LOW según el comportamiento real de tus sensores

  if (valorIzquierdo == LOW && valorDerecho == LOW) {
    avanzar();
  }
  else if (valorIzquierdo == HIGH && valorDerecho == LOW) {
    girarIzquierda();
  }
  else if (valorIzquierdo == LOW && valorDerecho == HIGH) {
    girarDerecha();
  }
  else if (valorIzquierdo == HIGH && valorDerecho == HIGH) {
    detener();
  }
}

// ===== Funciones de movimiento =====

void avanzar() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
}

void girarIzquierda() {
  // Motor izquierdo detenido o en retroceso suave
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);

  // Motor derecho avanza
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
}

void girarDerecha() {
  // Motor izquierdo avanza
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);

  // Motor derecho detenido o en retroceso suave
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
}

void detener() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);

  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
}

Explicación del código

1. Declaración de sensores

int sensorIzquierdo = 2;
int sensorDerecho = 3;

Aquí se indican los pines donde están conectados los sensores infrarrojos.

2. Declaración de pines del puente H

int IN1 = 8;
int IN2 = 9;
int IN3 = 10;
int IN4 = 11;

Estos pines controlan los motores mediante el módulo L298N.

• IN1 e IN2 controlan un motor
• IN3 e IN4 controlan el otro motor

3. Configuración inicial

void setup() {
  pinMode(sensorIzquierdo, INPUT);
  pinMode(sensorDerecho, INPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  Serial.begin(9600);
}

En esta parte:

• los sensores se configuran como entradas
• los motores como salidas
• se activa el monitor serial para observar lecturas

4. Lectura de sensores

valorIzquierdo = digitalRead(sensorIzquierdo);
valorDerecho = digitalRead(sensorDerecho);

Arduino lee el estado de ambos sensores para saber dónde está la línea.

5. Toma de decisiones

if (valorIzquierdo == LOW && valorDerecho == LOW) {
  avanzar();
}

Si ambos sensores indican que el carro está bien posicionado, avanza.

else if (valorIzquierdo == HIGH && valorDerecho == LOW) {
  girarIzquierda();
}

Si el sensor izquierdo detecta cambio, el carro corrige hacia la izquierda.

else if (valorIzquierdo == LOW && valorDerecho == HIGH) {
  girarDerecha();
}

Si el sensor derecho detecta cambio, el carro gira hacia la derecha.

else if (valorIzquierdo == HIGH && valorDerecho == HIGH) {
  detener();
}

Si ambos sensores detectan una condición fuera de la línea, el carro se detiene.

6. Funciones de movimiento

Las funciones:

• avanzar();
• girarIzquierda();
• girarDerecha();
• detener();

sirven para ordenar mejor el código y hacerlo más fácil de entender para los alumnos.

Explicación sencilla para alumnos

El robot tiene “ojos” en la parte de abajo, que son los sensores. Estos sensores van leyendo el piso y detectan si están sobre la línea negra o fuera de ella.

Cuando el robot nota que se está saliendo de la línea, corrige el movimiento de sus motores para regresar al camino. De esta forma, puede seguir una ruta de manera automática.

Aplicaciones reales

Los seguidores de línea tienen aplicaciones reales en distintas áreas, por ejemplo:

• robots de almacén
• vehículos de transporte interno en fábricas
• sistemas automáticos de logística
• robots educativos
• automatización de trayectorias en industria

Este proyecto ayuda a que los alumnos comprendan cómo la robótica escolar se relaciona con la tecnología usada en la vida real.

Ventajas educativas del proyecto

Este proyecto permite desarrollar en los alumnos:

• pensamiento lógico
• comprensión del uso de sensores
• programación por condiciones
• análisis de errores
• trabajo en equipo
• creatividad y resolución de problemas

Posibles mejoras del proyecto

Una vez que el proyecto básico funcione, se puede mejorar agregando:

• más sensores para mayor precisión
• control de velocidad con PWM
• chasis más estable
• batería recargable
• sensor ultrasónico para evitar obstáculos
• modo automático y manual
• carcasa diseñada por los alumnos

Recomendaciones para el armado

• probar primero los sensores por separado
• verificar qué valor entrega cada sensor sobre blanco y sobre negro
• revisar que todos los GND estén unidos
• probar un motor a la vez
• calibrar la altura de los sensores respecto al piso
• usar una pista con línea negra bien marcada

Conclusión

El carro seguidor de línea es un proyecto muy completo para introducir a los alumnos en el mundo de la robótica. A través de este desarrollo, los estudiantes aprenden a combinar sensores, programación y control de motores para resolver un problema real: seguir una trayectoria de forma automática.

Es una excelente práctica para fortalecer conocimientos de electrónica y Arduino, además de despertar el interés por la automatización y la ingeniería.