El KIT – 1212 Seguidor de Línea Velocista V2 es un proyecto diseñado para quienes desean dar un paso más en el mundo de la robótica móvil programable. Este vehículo utiliza tres sensores infrarrojos para detectar y seguir una línea con mayor precisión y rapidez, permitiendo un desplazamiento ágil y estable. A través de su programación, el robot interpreta las señales de los sensores y ajusta el movimiento de los motores. Es una excelente herramienta para aprender sobre control, lógica de programación y optimización del movimiento, combinando velocidad, precisión y aprendizaje práctico.
KIT – 1212 Seguidor de línea velocista V2
Seguidor de Línea Velocista V2.
El funcionamiento de un seguidor de línea programable se basa en la detección del contraste entre una línea y la superficie sobre la que se desplaza. En este caso, los sensores infrarrojos emiten y reciben luz reflejada, permitiendo identificar si el robot se encuentra sobre la línea o fuera de ella. Al contar con tres sensores, el sistema obtiene una lectura más precisa de la posición, lo que mejora la estabilidad y la capacidad de reacción del vehículo, especialmente a mayor velocidad.
La información captada por los sensores es procesada mediante la programación del controlador, el cual toma decisiones en tiempo real para ajustar la velocidad y dirección de los motores. Este proceso introduce conceptos clave como lógica condicional, control de movimiento y respuesta dinámica del sistema. Dependiendo del algoritmo utilizado, el robot puede realizar correcciones suaves o rápidas, optimizando su desempeño para seguir la línea de forma eficiente.
El KIT – 1212 Seguidor de Línea Velocista V2 permite aplicar de forma práctica los conocimientos de sensores, programación y control de movimiento. Al trabajar con tres sensores infrarrojos y ajustar el comportamiento del vehículo mediante código, se comprende cómo las decisiones lógicas influyen directamente en la velocidad y precisión del robot. Es una excelente herramienta para desarrollar habilidades en robótica móvil, pensamiento lógico y optimización de sistemas, todo a través de la experimentación y el aprendizaje activo.
¿Como se arma?
Ensamble
Para ensamblar del robot observa el siguiente video en donde explicamos paso a paso el armado.
- Notas:
- No retirar los cinchos que sujetan los cables de los motores ya que estos evitan que se rompan sus terminales con el movimiento.
Video de Ensamble
Video de Funcionamiento
Manual de Ensamble
Nota importante
No pases a la siguiente sección hasta que verifiques que tu Kit esta correctamente ensamblado y cableado.
La tarjeta de tu Kit ya viene programada con el código de 2 en 1
Comportamiento del programa
Este es un programa que compila los 2 programas. Seguidor de Linea Blanca y Seguidor de Linea Negra.
¿Cómo cambiar entre programas?
Seguidor de Linea Blanca
Para acceder al Seguidor de Linea Blanca coloca el selector de la siguiente manera:
Seguidor de Linea Negra
Para acceder al Seguidor de Linea Negra coloca el selector de la siguiente manera:
Instalación Programa Arduino
Antes de cargar el programa de tu elección, instala el entorno de programación con el cual podrás subir los códigos a tu robot.
Para esta sección preparamos un PDF el cual podrás descargar con el siguiente botón con las instrucciones detalladas de cada uno de los pasos con imágenes.
(El siguiente PDF incluye el paso 1, 2 y 3)
En caso de que ya conozcas un poco de este proceso te dejamos a continuación la explicación corta.
Paso 1.- Descargar de driver CH341
Como uno de los pasos para la instalación de nuestro entorno será el de descargar e instalar el driver necesario para que nuestra computadora pueda reconocer el dispositivo Arduino.
Paso 2.- Descarga e instalación de Arduino
Descarga la aplicación de Arduino con el cual podrás editar, subir y abrir los códigos.
Paso 3.- Subir un código
En esta parte podrás subir nuestros programas al Kit Seguidor de Línea Velocista V2.
Seguidor de Linea Blanca
Comportamiento del programa.
El Seguidor de Línea Velocista V2 deberá seguir una Linea Blanca en un fondo negro a través de los sensores de línea.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM
int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;
long cont1 = 0;
int l1 = 0;
int l2 = 0;
int l3 = 0;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int f4 = 0;
int f5 = 0;
int f6 = 0;
void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
}
void loop()
{
l3=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);
if ((l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550 ) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;//decremento de ciclos para salir de la memoria
}
////////////////////////////////////////////////////////////////////////////
if (l2 > 550)
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}else if (l1 > 550)
{
derecha();
}
else if (l3 > 550)
{
izquierda();
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3;
}
void alto()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 1);
}
void adelanter()
{
digitalWrite(motA1, 1);
digitalWrite(motA0, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}
void izquierda()
{
digitalWrite(motA1, 1);
analogWrite(motA0, 0); //PWM
analogWrite(motB1, 25); //PWM
digitalWrite(motB0, 0);
}
void derecha()
{
analogWrite(motB1, 0); //PWM
digitalWrite(motB0, 1);
digitalWrite(motA1, 0);
analogWrite(motA0, 25); //PWM
}Seguidor de Linea Negra
Comportamiento del programa.
El Seguidor de Línea Velocista V2 deberá seguir una Linea Negra en un fondo blanco a través de los sensores de línea.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM
int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;
long cont1 = 0;
int l1 = 0;
int l2 = 0;
int l3 = 0;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int f4 = 0;
int f5 = 0;
int f6 = 0;
void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
}
void loop()
{
l3=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);
if ((l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550 ) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;//decremento de ciclos para salir de la memoria
}
////////////////////////////////////////////////////////////////////////////
if (l2 < 550)
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}else if (l1 < 550)
{
derecha();
}
else if (l3 < 550)
{
izquierda();
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3;
}
void alto()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 1);
}
void adelanter()
{
digitalWrite(motA1, 1);
digitalWrite(motA0, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}
void izquierda()
{
digitalWrite(motA1, 1);
analogWrite(motA0, 0); //PWM
analogWrite(motB1, 25); //PWM
digitalWrite(motB0, 0);
}
void derecha()
{
analogWrite(motB1, 0); //PWM
digitalWrite(motB0, 1);
digitalWrite(motA1, 0);
analogWrite(motA0, 25); //PWM
}Programa 2 en 1
Comportamiento del programa.
Se integran el seguidor Linea Negra y el seguidor de Linea Blanca en un solo código. Para alternar entre los programas coloca el selector del Seguidor de Línea Velocista V2 en las siguientes posiciones.
Seguidor de Linea Blanca
Para acceder al Seguidor de Linea Blanca coloca los cables de la siguiente manera:
Seguidor de Linea Negra
Para acceder al Seguidor de Linea Negra coloca los cables de la siguiente manera:
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM
int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;
long cont1 = 0;
int lec0=A2;
int lec1=A1;
int l1 = 0;
int l2 = 0;
int l3 = 0;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int f4 = 0;
int f5 = 0;
int f6 = 0;
int a = 550;
void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
pinMode(lec0,INPUT_PULLUP);
pinMode(lec1,INPUT_PULLUP);
}
void loop()
{
l3 = analogRead(sensorleft); // A7 (izq)
l2 = analogRead(sensorcenter); // A6 (centro)
l1 = analogRead(sensorright); // A5 (der)
if(digitalRead(lec0)==0 && digitalRead(lec1)==0){
if ((l1 > a && l2 > a && l3 > a || l1 < a && l2 < a && l3 < a ) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1 = cont1 - 1;//decremento de ciclos para salir de la memoria
}
////////////////////////////////////////////////////////////////////////////
if (l2 < a)
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
} else if (l1 < a)
{
derecha();
}
else if (l3 < a)
{
izquierda();
}
else
{
if(l1 > a && l2 > a && l3 > a || l1 < a && l2 < a && l3 < a) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3;
}
else if (digitalRead(lec0)==1 && digitalRead(lec1)==1){
if ((l1 > a && l2 > a && l3 > a || l1 < a && l2 < a && l3 < a ) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1 = cont1 - 1;//decremento de ciclos para salir de la memoria
}
////////////////////////////////////////////////////////////////////////////
if (l2 > a)
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
} else if (l1 > a)
{
derecha();
}
else if (l3 > a)
{
izquierda();
}
else
{
if(l1 > a && l2 > a && l3 > a || l1 < a && l2 < a && l3 < a) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3;
}
}
void alto()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 1);
}
void adelanter()
{
digitalWrite(motA1, 1);
digitalWrite(motA0, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}
void izquierda()
{
digitalWrite(motA1, 1);
analogWrite(motA0, 0); //PWM
analogWrite(motB1, 25); //PWM
digitalWrite(motB0, 0);
}
void derecha()
{
analogWrite(motB1, 0); //PWM
digitalWrite(motB0, 1);
digitalWrite(motA1, 0);
analogWrite(motA0, 25); //PWM
}