Fase 4 Robot seguidor de linea
Robot seguidor de linea
Introducción
En la presente fase, describiremos el driver elegido para el respectivo
control de los motores que conforman el robot seguidor de línea, diagramas
de conexión correspondientes y la programación para que los motores se
muevan hacia adelante, hacia atrás y hacia los lados de acuerdo a la
información capturada por los sensores CNY70.
Para la presente fase se realizó un cambio en las baterías previamente
seleccionadas por 2 baterías Li-po de 3.7V y 500mAh cada una, ya que las
baterías alcalinas si bien nos proporcionaban el voltaje y corriente que
necesitábamos, tendían a descargarse muy rápidamente.
Imagen 1. Baterias Li-po
Diagrama de bloques
El diagrama de bloques presentado a continuación corresponde a la
representación interna del robot seguidor de línea en la presente fase y
la relación de los componentes que lo integran.
Imagen 2. Diagrama de bloques
Esquema de conexión
El siguiente esquema solo se enfoca en la conexión del carrito de una manera organizada, no obstante, se mantendrá la organización o ubicación en el mismo presentada en la primera fase del proyecto.
Driver controlador de motores L298N
El driver seleccionado para el control de los 2
motorreductores fue el L298N, ya que dicho circuito
integrado al estar compuesto de 4 transistores de potencia
para el manejo de los 2 motores de corriente continua, forma
un doble puente H, lo que nos permite controlar el sentido
de giro de éstos, ya sea en un sentido u otro, de forma
independiente, esto al invertir el sentido de la corriente.
Adicionalmente, este driver permite que los motores
funcionen con la potencia que necesitamos para el
robot.
Código
En el siguiente apartado aparecerá el código que será usado en este caso para que los motores vayan hacia adelante, atrás, a la derecha o a la izquierda por medio de la información capturada de los sensores CNY70.
En la primera parte del código encontramos los pines de los sensores que están ubicados desde el 22 hasta el 27, dándonos un total de 6 sensores, además de 6 variables que serán de lectura para los mismos. Seguimos con un float que será la variable para la lectura del estado del potenciómetro. También contamos con const int salida, que son los que irán a los transistores para que encienda el diodo emisor del sensor, estos transistores los añadimos a cada sensor con el fin de que no haya interferencia entre ellos y sea más eficiente la detección del sensor. Los const int tanto de izquierda como derecha, son pines que controlan las velocidades de los motores y, que están ubicados en el arduino mega en la parte PWM siendo los pines 2 y 3. Para que los motores puedan funcionar, las dos líneas de cada motor irán desde el pin 40 al 43.
Continuando se establecen variables de velocidad o rangos de velocidad, siendo la velocidad máxima hasta 255 y el mínimo de velocidad como 80. En la siguiente parte del código tendremos un void setup que es donde se definen los datos de entrada y salida, los de entrada siendo los de los sensores y los de salida siendo los de los transistores, junto con las salidas a los motores.
En el Voip loop llamamos a las funciones de lectura para los diferentes sensores. Se tuvieron en cuenta 4 sensores para hacer que los casos posibles no sean tan amplios, ello sin omitir la exactitud al momento de identificar la posición del robot. Los condicionales que se tomaron fueron 11 y están expresados en el código. Podemos observar en esta misma parte del código unos analogWrite de izquierda a derecha luego de los izq_adelante y der_adelante, esto hace referencia hacia donde tiene que moverse el carro para que todos los sensores estén ubicados en la línea negra, teniendo a su vez en cuenta la velocidad a aplicar en cada motor, ya sea para retornar a la línea negra o mantenerse.
El void de lectura nos indicará que pasara con cada sensor, si estos están en la línea negra o no, para así apagar el led emisor y así no haya interferencia con el otro sensor y, seguir haciendo las respectivas lecturas. Al final lo que tenemos las funciones del comportamiento de los motores, hacia hacia adelante y hacia atrás respectivamente.
Cabe decir frente a la lectura de los sensores, que para esta programación cuando el sensor detecta 0 es porque se encuentra sobre la línea negra y, por lo tanto, sólo cambiará a 1 cuando esté por fuera de ésta.
const int sensor_1=22;
const int sensor_2=23;
const int sensor_3=24;
const int sensor_4=25;
const int sensor_5=26;
const int sensor_6=27;
int lectura_1=0;
int lectura_2=0;
int lectura_3=0;
int lectura_4=0;
int lectura_5=0;
int lectura_6=0;
float lectura_pot=0; //lectura del potenciometro
const int salida_1=30; //salidas a transistores para encender el led del emisor CNY70
const int salida_2=31;
const int salida_3=32;
const int salida_4=33;
const int salida_5=34;
const int salida_6=35;
const int izquierda=2; //son pines para control de velocidad por PWM
const int derecha=3;
const int izq_1=40;
const int izq_2=41;
const int der_1=42;
const int der_2=43;
int velocidad_maxima=255; //rangos de velocidad
int velocidad_alta=180;
int velocidad_media=130;
int velocidad_baja=80;
void setup() {
pinMode(sensor_1, INPUT);
pinMode(sensor_2, INPUT);
pinMode(sensor_3, INPUT);
pinMode(sensor_4, INPUT);
pinMode(sensor_5, INPUT);
pinMode(sensor_6, INPUT);
pinMode(salida_1, OUTPUT);
pinMode(salida_2, OUTPUT);
pinMode(salida_3, OUTPUT);
pinMode(salida_4, OUTPUT);
pinMode(salida_5, OUTPUT);
pinMode(salida_6, OUTPUT);
pinMode(izquierda, OUTPUT);
pinMode(derecha, OUTPUT);
pinMode(izq_1, OUTPUT);
pinMode(izq_2, OUTPUT);
pinMode(der_1, OUTPUT);
pinMode(der_2, OUTPUT);
}
void loop() {
//llamamos funcion lectura
lectura();
//condicionales para avance
// 1
if (lectura_1==0 and lectura_2==1 and lectura_3==1 and lectura_4==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_maxima);
analogWrite(derecha, velocidad_baja);
}
// 2
if (lectura_1==0 and lectura_2==0 and lectura_3==1 and lectura_4==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_alta);
analogWrite(derecha, velocidad_baja);
}
// 3
if (lectura_1==0 and lectura_2==0 and lectura_3==0 and lectura_4==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_media);
analogWrite(derecha, velocidad_baja);
}
// 4
if (lectura_1==1 and lectura_2==0 and lectura_3==0 and lectura_4==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_alta);
analogWrite(derecha, velocidad_media);
}
// 5
if (lectura_1==1 and lectura_2==0 and lectura_3==0 and lectura_4==0 and lectura_5==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_maxima);
analogWrite(derecha, velocidad_alta);
}
// 6
if (lectura_2==1 and lectura_3==0 and lectura_4==0 and lectura_5==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_maxima);
analogWrite(derecha, velocidad_maxima);
}
// 7
if (lectura_2==1 and lectura_3==0 and lectura_4==0 and lectura_5==0 and lectura_6==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_alta);
analogWrite(derecha, velocidad_maxima);
}
// 8
if (lectura_3==1 and lectura_4==0 and lectura_5==0 and lectura_6==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_media);
analogWrite(derecha, velocidad_alta);
}
// 9
if (lectura_3==1 and lectura_4==0 and lectura_5==0 and lectura_6==0){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_baja);
analogWrite(derecha, velocidad_media);
}
// 10
if (lectura_3==1 and lectura_4==1 and lectura_5==0 and lectura_6==0){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_baja);
analogWrite(derecha, velocidad_alta);
}
if (lectura_3==1 and lectura_4==1 and lectura_5==1 and lectura_6==0){
izq_adelante();
der_adelante();
analogWrite(izquierda, velocidad_baja);
analogWrite(derecha, velocidad_maxima);
}
if (lectura_1==1 and lectura_2==1 and lectura_3==1 and lectura_4==1 and lectura_5==1 and lectura_6==1){
izq_adelante();
der_adelante();
analogWrite(izquierda, 0);
analogWrite(derecha, 0);
}
}
void lectura(){
// Se leen los sensores, se enciende la salida del emisor del sensor, se realiza la lectura del receptor,
// la lectura se guarda en la variable lectura ,
//se apaga el emisor y se espera un tiempo para hacer la lectura en el siguiente sensor.
//lectura sensor 1
digitalWrite(salida_1, HIGH);
delay(3);
lectura_1=digitalRead(sensor_1);
digitalWrite(salida_1, LOW);
delay (3);
//lectura sensor 2
digitalWrite(salida_2, HIGH);
delay(3);
lectura_2=digitalRead(sensor_2);
digitalWrite(salida_2, LOW);
delay (3);
//lectura sensor 3
digitalWrite(salida_3, HIGH);
delay(3);
lectura_3=digitalRead(sensor_3);
digitalWrite(salida_3, LOW);
delay (3);
//lectura sensor 4
digitalWrite(salida_4, HIGH);
delay(3);
lectura_4=digitalRead(sensor_4);
digitalWrite(salida_4, LOW);
delay (3);
//lectura sensor 5
digitalWrite(salida_5, HIGH);
delay(3);
lectura_5=digitalRead(sensor_5);
digitalWrite(salida_5, LOW);
delay (3);
//lectura sensor 6
digitalWrite(salida_6, HIGH);
delay(3);
lectura_6=digitalRead(sensor_6);
digitalWrite(salida_6, LOW);
}
// en las siguientes funciones programamos el comportamiento de los motores
void der_atras(){
digitalWrite(der_1, LOW);
digitalWrite(der_2, HIGH);
}
void der_adelante(){
digitalWrite(der_1, HIGH);
digitalWrite(der_2, LOW);
}
void izq_atras(){
digitalWrite(izq_1, HIGH);
digitalWrite(izq_2, LOW);
}
void izq_adelante(){
digitalWrite(izq_1, LOW);
digitalWrite(izq_2, HIGH);
}
Tabla de posibilidades
En la siguiente tabla se muestra como fueron sacados las 11 posibilidades de los sensores, puestas en el código.
Evidencia conexión
- Placa resistencias - sensores:
- Driver cableado:
- Interruptor y fusible instalados:
Imagen 9. Interruptor y fusible
Funcionamiento
En el siguiente video se mostrara el funcionamiento del robot seguidor de linea al detectar la linea negra.
Video 1. Robot funcionando
Comentarios
Publicar un comentario