¡Descarga CODIGO DE ARDUINO PARA ROBOT LABERINTO y más Guías, Proyectos, Investigaciones en PDF de Programación Javascript solo en Docsity!
ROBOT QUE RESUELVE LABERINTOS “SHOCOBOT”
Domínguez Ramírez, Sergio Osbaldo; Tovilla Blanco, Kenya; Yamasaki Aguilar Miriam Lenguajes de Interfaz. Instituto Tecnológico de Tuxtla Gutiérrez, Carretera Panamericana Km. 108 0, C.P. 29050 , Apartado Postal: 5 99, Tuxtla Gutiérrez, Chiapas. osbaldo 93 dominguez@gmail.com; miri-xion@hotmail.com ; ktb 1205 @hotmail.com Resumen — El presente proyecto consiste en la construcción de un robot el cual tiene como propósito resolver laberintos; este robot está programado en arduino UNO, por consiguiente, se tiene incluido en los materiales de dicho robot la placa arduino UNO, así como también un Shield L 293 D, con tres sensores ultrasónicos HC_SR04, cuatro motores DC para el funcionamiento de las cuatro ruedas; también se incluye una batería de 12 Volts para el suministro de energía que necesita el robot para su adecuado funcionamiento y conteniendo un sensor de color TCS 3200 el cual ayuda a que el robot se detenga cuando detecte un color en específico (en este caso es amarillo), avance en su camino y posteriormente se detiene. Palabras clave: Robot, laberinto, sensores ultrasónicos, sensor de color, arduino UNO. Abstract — This project involves the construction of a robot which aims to solve mazes; this robot is programmed in Arduino UNO, therefore, it has included in the robot’s materials arduino UNO, as well as, a Shield L2 9 3D, with three HC_SR04 ultrasonic sensors, four DC motors to the operation of the four wheels; also includes a 12 Volts battery to the energy supply by the robot for its proper functioning and containing a color sensor TCS 3200 which helps the robot stops when it detects a specific color (in this case is yellow), progress on its way and then stops. Keywords: Robot, maze, ultrasonic sensors, color sensor, arduino UNO. Introducción En vista de que en los últimos tiempos se ha presentado la necesidad de desarrollar tecnología que reemplace al ser humano principalmente cuando se trabaja en áreas de alto riesgo o poco accesibles para las personas como son encontrar averías en tuberías de oleoductos o en derrumbes, se ha visto la necesidad de la utilización de robots y es aquí donde ingresa el manejo de algoritmos de búsqueda o desplazamiento en diferentes tipos de áreas, así como el manejo de sensores para reconocimiento del entorno en el cual el robot se desplazará. Una de las diferentes formas a las que se puede dar aplicación es con un robot que es capaz de resolver laberintos, siendo un robot autónomo que por medio de sensores detecta cualquier obstáculo o pared que un laberinto tenga. Es así como este proyecto trata acerca de “Shocobot” un robot que soluciona laberintos, así como la descripción de sus componentes físicos y de la lógica que dicho robot contiene.
Instituto Tecnológico de Tuxtla
Gutiérrez
Ciencia y Tecnología con sentido
Materiales Este robot capaz de solucionar un laberinto, el cual está compuesto por los siguientes materiales: 3 sensores ultrasónicos HC_SR 0 4. 1 sensor de color TCS 320 0. 1 Motor Shield L 293 D. 1 Placa de arduino UNO. 4 Motores DC. 1 Batería de 12 Volts. 1 Base de madera de 17 cm x 17 cm 4 ruedas 1 Mini Protoboard 1 switch Desarrollo y diseño Durante el diseño del prototipo se tuvieron en cuenta varias características que fueron detectadas en la implementación exitosa del mismo. Entre las cuestiones que se analizaron en las etapas de diseño se pueden mencionar: la base (chasis), los Componentes Electrónicos: Sensor ultrasónico HC_SR El HC-SR 04 es un sensor ultrasónico de bajo costo que no sólo puede detectar si un objeto se presenta, como un sensor PIR (Pasiva Infra red Sensor), sino que también puede sentir y transmitir la distancia al objeto. Tienen dos transductores, básicamente, un altavoz y un micrófono. Ofrece una excelente detección sin contacto (remoto) con elevada precisión y lecturas estables en un formato fácil de usar. El funcionamiento no se ve afectado por la luz solar o el material negro movimientos a realizar por el robot y los materiales electrónicos (que se mencionarán más adelante). A continuación, se realiza una descripción acerca de los componentes electrónicos que contiene el robot nombrado “Shocobot”: como telémetros ópticos (aunque acústicamente materiales suaves como telas pueden ser difíciles de detectar). La velocidad del sonido en el aire (a una temperatura de 20 °C) es de 343 m/s. (por cada grado centígrado que sube la temperatura, la velocidad del sonido aumenta en 0,6 m/s)
Sensor de color TCR 3200 : El sensor de color TCR 320 0 es un detector de color completo, incluye un chip sensor TAOS TCR 3200 RGB y 4 LEDs blancos de ángulo amplio. El TCR3 200 puede detectar y medir una gama casi ilimitada de colores visibles. Las aplicaciones incluyen clasificación por color, sensor de luz ambiente, calibración y coincidencia de colores, para nombrar algunas pocas. El TCR 3200 tiene una matriz de detectores, cada uno de ellos con filtros rojo, verde y azul o sin filtro (clear). Los filtros de cada color se distribuyen uniformemente a lo largo de la matriz para eliminar el sesgo de ubicación entre los colores. El dispositivo tiene un oscilador que produce una salida de onda cuadrada cuya frecuencia es proporcional a la intensidad del color elegido. Especificación
- Alimentación: 2. 7 V a 5. 5 V
- Interfaz: Digital TTL
- Conversión de alta resolución, de intensidad de luz a frecuencia
- Color y rango de frecuencia de salida programables
- Función de apagado
- Se comunica directamente al microcontrolador
- Tamaño: 28 .4x2 8 .4mm
Instituto Tecnológico de Tuxtla
Gutiérrez
Ciencia y Tecnología con sentido
Arduino UNO: Arduino es una placa con un microcontrolador de la marca Atmel y con toda la circuitería de soporte, que incluye, reguladores de tensión, un puerto USB (En los últimos modelos, aunque el original utilizaba un puerto serie) conectado a un módulo adaptador USB-Serie que permite programar el microcontrolador desde cualquier PC de manera cómoda y también hacer pruebas de comunicación con el propio chip. Un arduino dispone de 14 pines que pueden configurarse como entrada o salida y a los que puede conectarse cualquier dispositivo que sea capaz de transmitir o recibir señales digitales de 0 y 5 V. También dispone de entradas y salidas analógicas. Mediante las entradas analógicas podemos obtener datos de sensores en forma de variaciones continuas de un voltaje. Las salidas analógicas suelen utilizarse para enviar señales de control en forma de señales PWM. Arduino UNO es la última versión de la placa, existen dos variantes, la Arduino UNO convencional y la Arduino UNO SMD. La única diferencia entre ambas es el tipo de microcontrolador que montan.
Motor Shield L2 9 3D: El motor shield con dos L 293 D permite controlar 4 cargas inductivas
- 2 servos conectados al timer dedicado de alta resolución de Arduino para un control sin bíter. Para el caso de motores, en cada canal se puede controlar tanto la velocidad como la dirección de giro independientemente. Posibilita el control desde proyectos sencillos hasta de media complejidad. Características: proporcionando 4 puentes-H completos
- Protección contra sobre carga térmica
- Diodos de protección contra voltajes inversos generados por las cargas inductivas
- 4 canales (M 1 , M 2 , M3 y M4) para controlar igual número de cargas inductivas como motores DC, solenoides, relés, ó 2 motores paso a paso unipolares o bipolares de entre 4. 5 V y 25 V - En el caso de motores es posible controlar tanto su velocidad como su dirección de giro - Control de velocidad de motores DC con resolución de 8 bits - Control de motores paso a paso con 1 y 2 bobinas en modo sencillo, doble (mayor torque), intercalado (medio paso) y micro pasos - 2 conectores independientes para controlar 2 servos pequeños de 5 V (Pines digitales 9 y 10 ) - Corriente máxima continua en cada una de las salidas M 1 , M 2 , M 3 y M 4 : 600 mA (0.6 A) - Corriente máxima pico no repetitivo en cada una de las salidas M 1 , M 2 , M3 y M4: 1. A - Resistores de pull-down que mantienen los motores deshabilitados durante el encendido - Requiere fuente externa para la alimentación de las cargas en las salidas M 1 , M2, M 3 y M 4. Puede empleada la fuente externa conectada a la placa Arduino o a la shield con selección mediante el jumper "PWR" - Bloques de terminales de tornillo para calibres 18 a 26 AWG - Botón de reset para la placa Arduino - Compatibilidad probada con Arduino Diecimila, Duemilanove, UNO y Mega 1280 & 2 560
- Incorpora (^2) circuitos integrados L 29 3D
Componentes Físicos (Diseño del robot): Como todo prototipo de un robot necesita de un diseño, es decir, el material por el que estará compuesto. Es así como este robot está hecho de madera la cual se realizaron dos bases: la primera es el chasis del robot y la segunda es una parte donde están ubicados demás componentes electrónicos de dicho robot. Chasís El diseño del chasís es un factor importante en el éxito o no de la implementación del robot, dado que según su forma permitirá realizar desplazamientos con mayor o menor exactitud al recorrer el laberinto. El robot está compuesto de un chasís de madera de forma rectangular con medidas de 15 cm de ancho por 17 cm de largo, medida sumamente adecuada para el buen desplazamiento y/o movimiento del mismo; en este chasís incluye las uniones de los motores DC con las ruedas, así como también se tiene incrustado el sensor de color TCS 32 00 por la parte de abajo para que pueda detectar el color que se tenga al inicio del recorrido del laberinto. En la parte de arriba, se tienen la placa arduino UNO insertado con el motor Shield, un mini protoboard, una batería de 12 Volts y por consiguiente las conexiones hechas entre el motor shield, la batería con el mini protoboard, para que dicho robot funcione y comience a realizar los movimientos correspondientes. Para la siguiente base o chasís (como se le quiera nombrar) está hecha igualmente de madera solamente con el detalle de tener la forma de una mesa, se realizó de esta forma para darle altura a los demás componentes que hacen falta colocar en el robot, además de colocar los sensores ultrasónicos en una altura adecuada y así detecte los obstáculos que haya en el momento de hacer el recorrido del laberinto.
Algoritmo: Una vez conseguido el armado de las conexiones de “Shocobot” ahora se realiza la parte del entorno de la programación en Arduino, ya que es la parte lógica donde el robot tiene que ir haciendo los movimientos necesarios para que pueda resolver correctamente el laberinto. Para ello, se propuso el siguiente algoritmo: Para que el robot pueda solucionar el camino adecuado de un laberinto, se tienen tres direcciones que debe seguir: Frente, izquierda y derecha, por esta razón se colocaron los tres sensores ultrasónicos. Después de haber definido las tres direcciones, ahora se tiene como punto de referencia la medición de la distancia, siendo esta distancia la forma en que los sensores detectan qué tan cerca están de un obstáculo o pared del laberinto y así poder realizar los movimientos adecuados para evitarlos y finalmente llegar a terminar dicho laberinto. Cada sensor obtiene la medida de la distancia en que esté, tanto de frente o adelante, izquierda y derecha. Una vez medida la distancia, ahora el robot elige el camino a seguir el cual está dado por un rango de medidas definidas; si la distancia medida a la derecha está demasiado cerca, es decir, si una pared del lado derecho se encuentra muy cerca del robot, entonces se alinea hacia la izquierda y se centra, en caso contrario, si está cercano al lado izquierdo, entonces se alinea a la derecha e igualmente se centra. Si no se encuentra muy cerca de los dos lados, entonces el robot sigue su camino. Al igual para detectar los lados que están muy cercanos al robot, también se realiza la cuestión de los giros con rangos específicos de las distancias de cada lado y frente, ya que al cumplir con cada rango definido de distancias el robot retrocede, hace un giro ya sea del lado izquierdo o derecho y sigue hacia adelante. El robot se detendrá hasta detectar el color asignado (en este caso es el negro); al igual desde el inicio del recorrido, al detectar el color (amarillo) el robot queda inmóvil hasta los cinco segundos y comienza con la medición de las distancias en cada lado para comenzar a recorrer el laberinto para así llegar finalmente a la meta.
Código: A continuación, se muestra la parte lógica del robot, la cual es la codificación que se realizó acorde el algoritmo mencionado anteriormente y en el entorno de programación Arduino 1 .6. 7 : //declaración de librerías #Include <AFMotor.h> //librería para control de los motorreductores #include <NewPing.h> //librería para el control del SR 04 sensor ultrasónico //declaración de pines y medidas #define ECHO_PIN_ADELANTE A 5 //el pin echo (el que escucha y mide: micrófono) del sensor delantero se define con el pin A 5 del motor shield #define TRIG_PIN_ADELANTE A 4 //el pin trigger (el que comienza la medición y dispara el pulso: altavoz) del sensor delantero se define con el pin A 4 del motor shield #define ECHO_PIN_DERECHA A 3 //el pin echo del sensor derecho se define con el pin A 3 del motor shield #define TRIG_PIN_DERECHA A 2 //el pin trigger del sensor derecho se define con el pin A 2 del motor shield #define ECHO_PIN_IZQUIERDA A 1 //el pin echo del sensor izquierdo se define con el pin A 1 del motor shield #define TRIG_PIN_IZQUIERDA A 0 //el pin trigger del sensor izquierdo se define con el pin A 0 del motor shield #define DISTANCIA_MAXIMA 400 //se define la distancia máxima de medición de los sensores ultrasónicos #define MAXIMA_VELOCIDAD 90 //se define la velocidad máxima que pueden obtener los motorreductores //inicializaciones de funcionamiento de los sensores //con estas sentencias, con estos constructores, se establece la configuración de trabajo de cada sensor NewPing sonar_adelante (TRIG_PIN_ADELANTE, ECHO_PIN_ADELANTE, DISTANCIA_MAXIMA); //se inicializa la operación "sonar_adelante" usando TRIG_PIN_ADELANTE como el ping trigger del sensor delantero, ECHO_PIN_ADELANTE como el ping echo de ese sensor y DISTANCIA_MAXIMA como la distancia máxima al operar NewPing sonar_derecha (TRIG_PIN_DERECHA, ECHO_PIN_DERECHA, DISTANCIA_MAXIMA); //se inicializa la operación "sonar_derecha" usando TRIG_PIN_DERECHA como el ping trigger del sensor derecho, ECHO_PIN_DERECHA como el ping echo de ese sensor y DISTANCIA_MAXIMA como la distancia máxima al operar NewPing sonar_izquierda (TRIG_PIN_IZQUIERDA, ECHO_PIN_IZQUIERDA, DISTANCIA_MAXIMA); //se inicializa la operación "sonar_izquierda" usando TRIG_PIN_IZQUIERDA como el ping trigger del sensor izquierdo, ECHO_PIN_IZQUIERDA como el ping echo de ese sensor y DISTANCIA_MAXIMA como la distancia máxima al operar //inicialización de funcionamiento de los motorreductores //con estos constructores, se establece la configuración de trabajo de los motorreductores, los cuales fueron
//declaración de funciones //función para medir la distancia de los 3 sensores y guardarlos en variables para su posterior uso y comparación void medir () { distancia_adelante=sonar_adelante. ping_cm (); //se obtiene la distancia en cm del sensor delantero if (¡distancia_adelante! =0) {//se coloca esta condición para evitar errores, ya que, si ocurre un error en la medición de un sensor, devuelve un valor 0; de esta forma, solo se pasará de esta condición si se mide exitosamente pared_adelante=distancia_adelante; //si no hay errores, la variable pared_adelante obtiene la medida almacenada en distancia_adelante Serial.print("\adelante:"); //las siguientes dos sentencias son para imprimir en el serial la medida guardada en pared_adelante Serial.print(pared_adelante); } distancia_derecha=sonar_derecha. ping_cm (); //se obtiene la distancia en cm del sensor derecho if (¡distancia_derecha! =0) {//condición para evitar errores de medición pared_derecha=distancia_derecha; //si no hay errores, la variable pared_derecha obtiene la medida almacenada en distancia_derecha Serial.print("\nDerecha:"); //las siguientes dos sentencias son para imprimir en el serial la medida guardada en pared_derecha Serial.print(pared_derecha); } distancia_izquierda=sonar_izquierda. ping_cm (); //se obtiene la distancia en cm del sensor izquierdo if (¡distancia_izquierda! =0) {//condición para evitar errores de medición pared_izquierda=distancia_izquierda; //si no hay errores, la variable pared_izquierda obtiene la medida almacenada en distancia_izquierda Serial.print("\nIzquierda:"); //las siguientes dos sentencias son para imprimir en el serial la medida guardada en pared_izquierda Serial.print(pared_izquierda); } } //función para elegir el camino al cual ir después de obtener las medidas de los 3 sensores void elegirCamino () { if(pared_adelante> 10 ) {//si la distancia en pared_adelante es mayor a 10 , el robot avanza hacia adelante mas_adelante=true; //se vuelve verdadera esta variable para que cuando elija un giro el robot, avance un poco más antes de realizar el cambio de dirección if(adelante==false) {//si adelante es igual a false, significa que el robot está quieto y ahora se va a mover, acelerando y moviéndose hacia adelante con la función moverAdelante moverAdelante (); //se llama a dicha función
//aquí se cumple una condición o la otra, jamás ambas if(pared_derecha> 0 && pared_derecha<=7) {//si la distancia en pared_derecha es mayor a 0 y menor o igual a 7, significa que el robot está muy pegado a la pared derecha, por lo que se llama a la función alinearIzquierda para alejarlo y centrarlo alinearIzquierda (); //se llama a la función respectiva Serial.print("\n Alinear izquierda"); //se imprime esta oración en el serial para saber qué hace el robot } else if(pared_izquierda> 0 && pared_izquierda<=7) {//si la distancia en pared_izquierda es mayor a 0 y menor o igual a 7, significa que el robot está muy pegado a la pared izquierda, por lo que se llama a la función alinearDerecha para alejarlo y centrarlo alinearDerecha (); //se llama a dicha función Serial.print("\n Alinear derecha"); //se imprime esta oración en el serial para saber qué hace el robot } giros_recto (); //se llama a esta función después de los ifs Serial.print("\nmoverAdelante"); //se imprime esta oración en el serial para saber se entró en la condición de adelante igual a false } else {//si adelante es igual a true, significa que el robot ya se está moviendo motores1.run(FORWARD); //los motores solo siguen avanzando, debido a que ya cuentan con velocidad motores2.run(FORWARD); //aquí se cumple una condición o la otra, jamás ambas if(pared_derecha> 0 && pared_derecha<=7) {//se realizan los mismos alineamientos y acciones vistos en el código superior alinearIzquierda (); Serial.print("\n Alinear izquierda"); } else if(pared_izquierda> 0 && pared_izquierda<=7) { alinearDerecha (); Serial.print("\n Alinear derecha"); } giros_recto (); Serial.print("\nsigueAdelante"); //se imprime esta oración en el serial para saber se entró en la condición de adelante igual a true } } if (pared_adelante<= 10 && pared_adelante>0) {//si pared_adelante es menor o igual a 10 y mayor a 0, se entra en esta condición //aquí se cumple una condición o más if(pared_derecha> 0 && pared_derecha<=8) {//se realizan alineamientos iguales a los vistos anteriormente, con la diferencia que ahora pared_derecha y pared_izquierda sean iguales o menores a 8 alinearIzquierda (); Serial.print("\n Alinear izquierda"); } if(pared_izquierda> 0 && pared_izquierda<=8) { alinearDerecha (); Serial.print("\n Alinear derecha"); }
//si pared_derecha es mayor o igual a 1 4, y es mayor a pared_izquierda y es mayor a pared_adelante, se entra a esta condición if(pared_derecha>= 14 && pared_derecha>pared_izquierda && pared_derecha>pared_adelante) { } girarDerecha (); //se llama a dicha función: el robot gira a la derecha y sigue de frente } Serial.print("\nVa hacia la derecha G"); //se imprime la oración en el serial para saber que //se reinician las variables, para evitar arrastrar valores pared_adelante=0; pared_derecha=0; pared_izquierda=0; mas_adelante=false; } //función para elegir a donde ir antes de colisionar, después de que el robot retrocedió y se detuvo void giros () { //aquí se cumple una condición o más //si pared_adelante es mayor o igual a 14 , y es mayor a pared_izquierda y es mayor a pared_derecha, se entra a esta condición if(pared_adelante>= 14 && pared_adelante>pared_izquierda && pared_adelante>pared_derecha) { moverAdelante (); //se llama a esta función: el robot se mueve hacia adelante Serial.print("\nVa hacia adelante G"); //se imprime esta oración en el serial para saber que el robot se mueve hacia adelante, habiendo usado la función giros, por eso la G al final } el robot gira a la derecha, habiendo usado la función giros, por eso la G al final } //si pared_izquierda es mayor o igual a 14 , y es mayor a pared_derecha y es mayor a pared_adelante, se entra a esta condición if(pared_izquierda>= 14 && pared_izquierda>pared_derecha && pared_izquierda>pared_adelante) { girarIzquierda (); //se llama la función respectiva: el robot gira a la izquierda y sigue de frente Serial.print("\nVa hacia la izquierda G"); //se imprime la oración en el serial para saber que el robot gira a la izquierda, habiendo usado la función giros, por eso la G al final } //si pared_adelante es mayor o igual a 14 y es igual a pared_derecha, se entra en esta condición if(pared_adelante>= 14 && pared_adelante==pared_derecha) { moverAdelante (); //el robot se mueve hacia adelante Serial.print("\nVa hacia adelante G"); //se muestra la oración en el serial } //si pared_adelante es mayor o igual a 14 y es igual a pared_izquierda, se entra en esta condición if(pared_adelante>= 14 && pared_adelante==pared_izquierda) { moverAdelante (); //el robot se mueve hacia adelante Serial.print("\nVa hacia adelante G"); //se muestra la oración en el serial } //si pared_izquierda es mayor o igual a 14 y es igual a pared_derecha, se entra en esta condición if(pared_izquierda>= 14 && pared_izquierda==pared_derecha) {
girarIzquierda (); //el robot gira a la izquierda y sigue de frente Serial.print("\nVa hacia la izquierda G"); //se muestra la oración en el serial } } //función para elegir a donde ir aún en movimiento void giros_recto () { //aquí se cumple una condición o más if(mas_adelante==true) {//si mas_adelante es true, se entra en esta condición delay ( 30 0); //el robot se moverá hacia adelante durante 0. 3 segundos más Serial.print("\nUn poco más"); //se imprime esta oración en el serial para saber si avanza un poco más } //si pared_adelante es mayor a 1 5, y es mayor a pared_izquierda y es mayor a pared_derecha, se entra a esta condición if(pared_adelante> 15 && pared_adelante>pared_izquierda && pared_adelante>pared_derecha) { Serial.print("\nVa hacia adelante GR"); //se imprime esta oración en el serial para saber si se sigue hacia adelante, habiendo usado la función giros_recto, por eso la GR al final delay ( 800 ); //se avanza hacia adelante durante 0. 8 segundos } //si pared_derecha es mayor a 15 , y es mayor a pared_izquierda y es mayor a pared_adelante, se entra a esta condición if(pared_derecha> 15 && pared_derecha>pared_izquierda && pared_derecha>pared_adelante) { girarDerecha (); //se llama a esta función: el robot gira a la derecha y sigue de frente Serial.print("\nVa hacia la derecha GR"); //se imprime esta oración en el serial para saber si gira hacia la derecha, habiendo usado la función giros_recto, por eso la GR al final } //si pared_izquierda es mayor a 15 , y es mayor a pared_derecha y es mayor a pared_adelante, se entra a esta condición if(pared_izquierda> 15 && pared_izquierda>pared_derecha && pared_izquierda>pared_adelante) { girarIzquierda (); //se llama a dicha función: el robot gira a la izquierda y sigue de frente Serial.print("\nVa hacia la izquierda GR"); //se imprime esta oración en el serial para saber si gira hacia la izquierda, habiendo usado la función giros_recto, por eso la GR al final } //si pared_adelante es mayor a 15 y es igual a pared_derecha, se entra en esta condición if(pared_adelante> 15 && pared_adelante==pared_derecha) { delay (1 20 0); //se sigue hacia adelante por 1.2 segundos Serial.print("\nVa hacia adelante GR"); //se imprime la oración en el serial } //si pared_adelante es mayor a 15 y es igual a pared_izquierda, se entra en esta condición if(pared_adelante> 15 && pared_adelante==pared_izquierda) { delay (1 20 0); //se sigue hacia adelante por 1.2 segundos Serial.print("\nVa hacia adelante GR"); //se imprime la oración en el serial
motores1.run(RELEASE); //los motores se detienen motores2.run(RELEASE); } //función para alinear a la derecha; se aleja de la pared izquierda y luego se centra en el camino void alinearDerecha () { motores1.run(FORWARD); //se gira hacia la derecha motores2.run(BACKWARD); delay ( 700 ); //continúa girando durante 0. 7 segundos motores1.run(FORWARD); //se avanza hacia adelante motores2.run(FORWARD); delay ( 65 0); //sigue avanzando por 0. 65 segundos motores1.run(BACKWARD); //se gira a la izquierda motores2.run(FORWARD); delay ( 340 ); //se mantiene girando durante
- 34 segundos motores1.run(FORWARD); //vuelve a avanzar hacia adelante motores2.run(FORWARD); } //función para alinear a la izquierda; se aleja de la pared derecha y luego se centra en el camino void alinearIzquierda () { motores1.run(BACKWARD); //se gira a la izquierda motores2.run(FORWARD); delay (7 00 ); //sigue girando durante 0. segundos motores1.run(FORWARD); //se mueve hacia adelante motores2.run(FORWARD); delay (6 50 ); //continúa avanzando por 0. 65 segundos motores1.run(FORWARD); //gira a la derecha motores2.run(BACKWARD); delay ( 34 0); //mantiene el giro por 0. 34 segundos motores1.run(FORWARD); //vuelve a moverse hacia adelante motores2.run(FORWARD); } //función para obtener los valores de cada componente del color que se encuentre debajo del robot void color () { rojo=leerColor(RED); //la variable rojo almacena el valor que le devuelve la función leerColor respecto a RED verde=leerColor(GREEN); //la variable verde almacena el valor que le devuelve la función leerColor respecto a GREEN azul=leerColor(BLUE); //la variable azul almacena el valor que le devuelve la función leerColor respecto a BLUE limpio=leerColor(CLEAR); //la variable limpio almacena el valor que le devuelve la función leerColor respecto a CLEAR } //función que lee los colores y devuelve un valor entre 0 y 255 byte leerColor (byte color) { switch(color) //dependiendo de lo que reciba en la variable color, se dará un caso específico {
case RED: //en caso de RED, se configuran los leds a manera de leer el valor del componente rojo digitalWrite (s 2 Pin, LOW); //se apagan ambos leds que corresponden a s 2 Pin y s 3 Pin digitalWrite (s 3 Pin, LOW); break; case GREEN: //en caso de GREEN, se configuran los leds a manera de leer el valor del componente verde digitalWrite (s 2 Pin, HIGH); //se encienden ambos leds que corresponden a s 2 Pin y s 3 Pin digitalWrite (s 3 Pin, HIGH); break; case BLUE: //en caso de BLUE, se configuran los leds a manera de leer el valor del componente azul digitalWrite (s 2 Pin, LOW); //se apaga el led que corresponde a s 2 Pin digitalWrite (s 3 Pin, HIGH); //se enciende el led que corresponde a s 3 Pin break; case CLEAR: //en caso de CLEAR, se configuran los leds a manera de leer el color sin filtro alguno digitalWrite (s 2 Pin, HIGH); //se enciende el led que corresponde a s 2 Pin digitalWrite (s 3 Pin, LOW); //se apaga el led que corresponde a s 3 Pin break; } return map (pulseIn (outPin, HIGH), 3 0, 2500 , 255 , 0); //devuelve un valor entre el rango de 255 a 0, en base al valor de pulseIn (outPin, HIGH) que va de 30 hasta 2500 } //función para comparar los valores de rojo, verde, azul y limpio void compararColor () { //si rojo es igual a 2, y verde es igual a 2, y azul es igual a 2 y limpio es mayor a 10 0, se entra a esta condición if (rojo== 2 && verde== 2 && azul== 2 && limpio> 10 0) { sigue_trabajando=false; //sigue_trabajando se vuelve false, lo que significa que el robot encontró el color negro debajo de él, indicando que ha llegado a la meta } }
