Fase 5 Robot seguidor de linea

-


FASE 5







Robot seguidor de línea




Introducción

La presente fase, corresponde a la entrega final del robot SCARAB seguidor de línea. En esta fase se muestra el esquema de bloques final, el esquema de conexión, el flujograma y programación del robot funcional y finalmente, evidencia del robot con su pista.

Diagrama de bloques y conexión

El diagrama de bloques es el mismo que en la anterior presentación, puesto que no ha variado, de igual forma se presenta el esquema de conexión que continua sin cambios.

Imagen 1. Diagrama de bloques


Imagen 2. Esquema de conexión

Tabla de posibilidades

Recordamos la tabla de posibilidades, que contempla 11 posibilidades para que el carrito siga la línea sin desviarse.

Tabla 1. Tabla de posibilidades

Flujograma


A modo de complementación, a continuación se enseñara el flujograma del funcionamiento de la programación del carro seguidor de línea que será presentada también más adelante. 


Imagen 3. Flujograma principal

Nota: Debido a que la imagen del flujograma principal es demasiado grande por la complejidad del diseño, en su lugar estará un enlace al drive donde podrá descargar y ver la imagen.


Como se puede observar en el flujograma principal, hay otras 3 pestañas que son "lectura", "izq_adelante" y "der_adelante". Estos serán presentados a continuación.

Lectura


Imagen 4. Flujograma/Lectura

Der_adelante


Imagen 5. Flujograma Der_adelante

Izq_adelante


Imagen 6. Flujograma Izq_adelante
En el siguiente enlace puedes descargar el archivo del flujograma diseñado en raptor para su respectiva ejecución.


Programación


Se seguirá trabajando con la programación presentada en la anterior fase. Dando clic aquí podrá descargar también la programación.
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);


  


}



Conclusión



Como consecuencia de lo expuesto durante todas las fases, determinamos que este proyecto fue más que simplemente comprar los materiales y armar un robot, hicimos un análisis, seleccionamos qué instrumentos electrónicos nos servirían, además de comprender su funcionamiento, aprendimos más de lo que nosotros como estudiantes pensábamos al inicio, y lo descubrimos con la importancia de lo que son los diagramas de flujo, bloques y hasta el de conexión, incluso, con la importancia que es hacer un seguimiento del robot, ya que se pueden determinar cambios a última hora que pueden afectar todo en cadena.



Nombre de los integrantes:


Fabian Alexander Diaz Pava - 2122301 
Javier Rosero Muñoz - 2127202 
Laura Stefany Viveros Paredes - 2127740

Comentarios

Publicar un comentario

Entradas populares de este blog

Robot laberinto Kastelean

-
Imagen
    KASTELAN-   FASE 3 PROYECTO FINAL ROBOT LABERINTO   UNI VERSIDAD DEL VALLE INTRODUCCIÓN A LA INGENIERÍA ELECTRÓNICA     CHRISTIAN HOMERO ERAZO- 2127953 NICOLAS MOLINA SANCHEZ- 202128387 JULIAN COTACIO CASTRO -202126044 Sensor ultrasónico.   para medir las distancias con arduino lo podemos hacer de diferentes maneras nosotros escogimos el ultrasónico arduino que utiliza las propiedades del sonido para medir distancias.   El funcionamiento de los sensores sería el siguiente: el sensor envía una onda ultrasónica que rebota contra el objeto y el receptor detecta la onda y toma las decisiones que se han programado para seguir avanzando.     Para nuestro Robot para laberinto se van utilizar 4 Sensores ultrasónico HC-SR04   Características del sensor ultrasónico HC-SR04 ●       Alimentación de 5 volts. ●       Interfaz de cuatro hilos (vcc, t...
Leer más

Fase 4 Robot seguidor de linea

-
Imagen
FASE 4   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 bloq...
Leer más

FASE 2 ROBOT SEGUIDOR DE LINEA

-
Imagen
SCARAB FASE 2 ROBOT SEGUIDOR DE LINEA Introducción Para este segundo informe pondremos en funcionamiento un programa que controla dos leds por medio de dos botones, uno en función de pulsador y el otro como interruptor, todo ello sobre la estructura diseñada del robot. Adicionalmente, se detalla el sistema de alimentación del trabajo final y los argumentos sobre los cuales se seleccionaron los elementos. SIMULACIÓN PROGRAMA CONTROLA LEDS Gráfica 1. Circuito dos leds Para la simulación del programa que controla los leds, tuvimos en cuenta la Gráfica 1 y respectivamente los componentes detallados en la tabla 1. Tabla 1. Consumo programa control de leds Para hallar el valor de las resistencias recurrimos a la ley de Ohm, por la cual, se tiene en cuenta que los pines del Arduino tienen una salida de 5V, al estar en paralelo, a cada bloque de series le llega 5V y la corriente se divide, a cada serie le debe llegar 10mA que circulara igualmente entre los componentes que van ...
Leer más