Robot autónomo para recorrer un laberinto

Instituto Tecnológico de Tuxtla Gutiérrez
Ciencia y Tecnología con sentido Humano
Ingeniería en Sistemas Computacionales
ROBOT AUTÓNOMO PARA RECORRER UN LABERINTO
Autores:
Moguel Jiménez, Luis Fernando luisfermj@hotmail.com; Pérez Nango, Manuel de Jesús
manuelpereznango@hotmail.com; Reyes Palacios, Shanel Daniela isc_shanel_reyes@hotmail.com;
Molina Sosa, Benjamín molinasb.94@gmail.com.
Instituto Tecnológico de Tuxtla Gutiérrez, Carretera Panamericana Km. 1080, C.P. 29050, Apartado
Postal: 599, Tuxtla Gutiérrez, Chiapas.
Resumen--- El objetivo de este trabajo es presentar los detalles principales del diseño del
hardware y software de un robot autónomo que es capaz de desplazarse a través de un
laberinto prediseñado, siguiendo trayectorias rectilíneas con desviaciones a 90 o 180º ante
la detección de un borde o pared del laberinto, cuando se interpone en su camino recto.
El robot integra sensores de línea, con los cuales será capaz de seguir con autonomía un
laberinto de líneas negras sobre una superficie blanca, en este se mostrarán caminos
correctos e incorrectos, por eso mismo el robot debe corregirlo.
El diseño y la construcción de un prototipo de este robot se realizaron como parte del
proyecto de grado de la materia “Lenguaje de Interfaz” correspondiente al sexto semestre
de la carrera de Ingeniería en Sistemas Computacionales del Instituto Tecnológico de Tuxtla
Gutiérrez.
-----------------------------------------------------------------------------------------------------------------------------------
Palabras clave: Robot autónomo, laberinto, sensores ultrasónicos, sensor de linea, placa
Arduino.
Abstract--- The objective of this document is to present the main details about the design of
hardware and software of an autonomous robot that is able to go over a predesign maze,
following rectilineals ways with 90 or 180° deflections, detecting edges and maze walls.
The prototype includes several line sensors in order to be able to follow with autonomy the
black lines in a maze with a white surface. Obviously there gonna be corrects an incorrects
ways that the robot should analyze.

The design and build of this prototype was a part of a final project in “Lenguaje de interfaz”,
that is a school subject in the sixth semester of Engineering on Computerized Systems in the
Tuxtla Gutierrez Institute of Technology.
------------------------------------------------------------------------------------------------------------------------------------
Keywords: Autonomous Robot, maze, ultrasonic sensors, line sensors, arduino board
I.- INTRODUCCIÓN
El proyecto para la creación de un robot
autónomo capaz de recorrer los pasillos
de un laberinto surgió como el desafío de
presentar un trabajo de desarrollo
novedoso y ambicioso para lo que es un
proyecto de una materia de semestre.
Se diseñó un prototipo basado en
“Arduino”, plataforma electrónica abierta
(código y hardware abiertos) que permite
la creación de prototipos basados en
software y hardware flexibles. (Arduino,
2016)
En particular, para la construcción del
sistema de control del robot se utilizó una
placa Arduino Uno, sensores de linea y
servomotores para lograr el
desplazamiento del robot dentro del
laberinto.
El prototipo emplea una serie de sensores
de luminosidad con los cuales es capaz
de seguir una línea. El sensor de luz emite
permanentemente una luz y recibe su
reflejo, con el cual midiendo la
luminosidad del reflejo, es capaz de
interpretar la luminosidad de la superficie
que está recibiendo, aquí el concepto
físico a resaltar es que los colores claros
reflejan más luz que los colores oscuros.
Siguiendo esta idea principal, nuestra
estrategia será que el robot sea capaz de
detectar contrastes, así cuando este
detecte zonas blancas no realizara
ninguna acción de corrección y así mismo
al toparse con la línea negra, sea capaz
de corregir su dirección y seguir con su
camino.
II.- DESARROLLO Y DISEÑO
Al momento del diseño del prototipo se
tuvieron en cuenta varias características
que afectarían a la implementación
exitosa del mismo. Entre las cuestiones
que se analizaron en la etapa de diseño
se pueden mencionar: el chasis, los

movimientos a realizar por el robot, los
tipos de sensores, y la alimentación
necesaria para el funcionamiento de los
componentes electrónicos.
A. Chasis
Para este caso se diseñó un chasis pre-
fabricado de forma alargada en forma de
“T”, acompañado con otras características
de implementación, que nos permitiría
realizar mejores movimientos.
B. Movimientos
La trayectoria que realiza el robot es en
línea recta con giros de 90º o 180°
cuando detecta un obstáculo.
La tracción (fig. 1) utilizada es diferencial
(se usan dos servomotores
independientes), lo que hace que los giros
sean más sencillos y además permite
realizar los movimientos sin más espacio
que el que está ocupando (gira sobre su
propio eje).
Fig. 1 Tracción diferencial
Otro aspecto del diseño que se definió fue
la ubicación de las ruedas, dado que esto
también impacta, en el prototipo se
ubicaron en la parte de adelante para una
mayor tracción.
Para las ruedas se utilizaron un par de
ruedas de plástico para servomotor y
como eje se le añadió uno de los brazos
que viene con el servo.
C. Sensores
Debido a que este sensor capta grados de
luminosidad, no es capaz de distinguir
colores, sólo captando la existencia del
blanco (claridad), negro (oscuridad) y los
tonos de grises que corresponden a los
distintos porcentajes de luz existentes en
el medio.
Para los sensores de línea (fig. 2), por
cada se sensor (en este caso se usaron
4), se usaron un LED ultra brillante verde
+ una fotorresistencia + 1 resistencias de
330 ohms + 1 resistencia de 10k.
Fig. 2 Sensores de línea

El diodo emisor de luz (LED) envía un
constante haz de luz (fig. 3) hacia el suelo.
Esta luz se refleja de nuevo a la LDR.
Dependiendo del color, la fotorresistencia
recibe cantidades variables de luz
reflejada.
Fig. 3 Reflejo de la luz
D. Motores
Para el movimiento de las ruedas se
usaron servomotores. El tamaño reducido
del servo MG90 (fig. 4) lo hace ideal para
la construcción del prototipo (Arduino,
2016)
Fig. 4 Servomotor MG90
Los servomotores hacen uso de la
modulación por ancho de pulsos (PWM)
para controlar la dirección o posición de
los motores de corriente continua. La
mayoría trabaja en la frecuencia de los
cincuenta hercios, así las señales PWM
tendrán un periodo de veinte
milisegundos.
E. Alimentación
Para lograr un prototipo autónomo se
utilizó una fuente de alimentación, en este
caso, se usó una batería LI-PO de 7.4v a
4500 mAh (fig. 5), la cual alimentaba a la
placa Arduino, los servos y los sensores
de línea.
Fig. 5 Batería LI-PO
La batería se ubicó en la parte de enfrente
del robot para que las llantas se acercaran
lo más posible al suelo, logrando así gran
estabilidad y mayor tracción.
III.- CONEXIONES
Se hicieron las conexiones
correspondientes de todos los elementos
anteriormente mencionados para el buen
funcionamiento del robot. Primeramente
hicimos las conexiones del puente H

(L298N) y de los servomotores con el
Arduino uno (fig. 6).
Fig. 6 Conexión de los motores y puente
H
Tabla 1. Pines usados en el Arduino
para la conexión del puente H
Tabla 2. Conexión de los Servos al
puente H
Después de hacer las conexiones del
puente H, procedimos a hacer las
conexiones de los sensores de línea al
Arduino, en este caso, fueron hechas con
LED´s ultrabrillantes y fotorresistencias
(fig. 7).
Fig. 7 Conexión de los sensores de línea
Tabla 3. Conexión de los Servos al
puente H
Una vez tenido todos las conexiones
hechas de nuestros componentes
pasamos a agregar la fuente de
Pines Arduino Pines Puente H
11 ENA
12 IN1
13 IN2
2 IN3
4 IN4
3 ENB
Salida Puente H Servomotores
OUT2 Servo Izquierdo
OUT3 Servo Derecho
Pines
Arduino
Salida de las
Fotorresistencias
A0 Salida
Fotorresistencias 1
A1 Salida
Fotorresistencias 2
A2 Salida
Fotorresistencias 3
A3 Salida
Fotorresistencias 4

alimentación que fue una batería LIPO de
7.4v a 450mAh (fig. 8) con su interruptor
correspondiente, y todo esto fue montado
al chasis de nuestro robot (fig. 9)
Fig. 8 Conexión completa del circuito
Fig. 9 Circuito montado al Chasis del
robot
Descripción de la lógica utilizada
Se añadió a nuestro código, una función
“calibrar” que se utilizaría para poder
obtener ciertos valores (muestreo) que
nos servirían para referencia a nuestros
sensores de línea y así poder tener un
mejor control en el robot, ya que en
algunas ocasiones, el color varía por la
cantidad de luz que incide en la superficie
en un momento determinado. Todos estos
valores de referencia se guardan en la
EEPROM para hacer uso de ellas cuando
el robot entre en funcionamiento.
Primeramente se colocó en el código
instrucciones para que el robot camine
hacia adelante mientras se encuentra
dentro de la zona de salida.
Tomamos de forma obvia, que el robot al
ser colocado correctamente, ira hacia
adelante sin ninguna desviación.
Después de ello, el robot se guiara por las
líneas del fondo del laberinto al igual que
los cruces.
Se consultó detalladamente el reglamento
de este concurso, y se observó que en
ninguno de sus puntos se prohibía la
programación de los cruces para que el

robot se guiara y llegara rápidamente a la
meta, es por ello que como equipo,
decidimos irnos por esta vía, y se le
programa al robot con números de cruces
y sentidos (derecha o izquierda).
Por lo anteriormente mencionado, se le
ingresa al código dos vectores, uno para
llevar el control de cruces y el otro para los
sentidos. Después de haber llegado a un
cruce, el robot se detiene y verifica en el
vector, si el número de cruce en el cual
esta, es igual al dato que esta contenido
dentro de esta fila el robot girara en el
sentido del dato correspondiente a su
vector.
Al llegar al número total de datos en el
vector, se le informa al robot para que este
se encuentre preparado para localizar la
meta y no seguir buscando cruces.
Aplicación en la vida real.
El prototipo que hemos desarrollado como
un robot de laberinto puede ser aplicado
en la vida real, con apenas algunas
modificaciones.
Un uso que podemos darle seria usarlo
como un detector de explosivos mediante
alguna situación de suma importancia o
que ponga en peligro vidas humanas.
Como ejemplo podemos mencionar las
minas, nuestro robot sería capaz de
detectar si hay explosivos dentro
mediante el uso de tecnologías como el
rayo X, que calcula la densidad de los
objetos que se encuentren dentro de la
mina, y leerá la radiación gama para
determinar la composición química
(MsRobotics, 2016) y de esta manera
identificar si existen o no explosivos y
enviará toda la información recabada al
encargado de la operación.
Código
Se declaran todas las variables que se
utilizaran y la librería correspondiente
para el uso de la EEPROM.
#include <EEPROM.h>
// pines del puente H
#define IN1 12
#define IN2 13
#define motorIzq 11
// viendo de frente al robot
#define IN3 2
#define IN4 4
#define motorDer 3
#define minVelocidadIzq 38
// velocidad minima (pwm)

#define minVelocidadDer 38
// velocidad minima (pwm)
#define velGiroIzq_Der 40
// velocidad GiroIzquierda (pwm)
#define velGiroIzq_Izq 40
// velocidad GiroIzquierda (pwm)
#define velGiroDer_Der 40
// velocidad GiroDerecha (pwm)
#define velGiroDer_Izq 40
// velocidad GiroDerecha (pwm)
#define velAtras 33
// velocidad atras (pwm)
// pines de los sensores de line
#define sensorLineaDer A0
// viendo de frente al robot
#define sensorLineaIzq A1
#define sensorCruceDer A2
#define sensorCruceIzq A3
#define izquierda 1
#define derecha 0
#define timeInterrup 49535 //
interrupcion cada 1ms
int umb_crucemeta_Der,
umb_crucemeta_Izq;
int lineaDer, lineaIzq,
promedioDer, promedioIzq;
int sp_linea_Der, sp_linea_Izq,
umb_linea_Der, umb_linea_Izq;
int lineaCruceDer, lineaCruceIzq,
promedioCruceDer, promedioCruceIzq;
int sp_cruce_Der, sp_cruce_Izq,
umb_cruce_Der, umb_cruce_Izq;
int errorDer = 0, last_errorDer =
0, derivativoDer = 0, salida_pwm;
int errorIzq = 0, last_errorIzq =
0, derivativoIzq = 0;
float kpDer = 10.6, kdDer = 40.5
, kpIzq = 10.6, kdIzq = 40.5;
byte i, muestras, cruce
,numeroCruces;
char c;
unsigned long duracion, timeout;
// lectura max 30cm (1740us)
unsigned int distanciaIzq;
unsigned int distanciaCentro;
unsigned int distanciaDer;
byte lineaCruces[] = {1,2};
byte lineaSentido[] =
{izquierda,derecha}; // viendo de
frente al robot
Después tenemos la función calibrar, que
nos sirve para realizar un muestreo de los
colores de la superficie y tener menos
probabilidad de error al momento de
analizar nuestro piso. También tenemos
la función sensores de líneas que nos va
tomando los valores actuales de la
superficie del robot. Y la función control
para hacer ciertos movimientos si se
detecta un cruce.
/**********************************
***********************************
**********************/
/*** CALIBRAR ***/
void calibrar(void)
{
while(c != 's')
{
Serial.println("1.-Calibrar
linea (l)");
pista (p)");
inicio (i)");
meta (m)");
Serial.println("5.-Leer
EEPROM (r)");
Serial.println("6.-Salir
(s)");

while(!Serial.available());
c = 0; c = Serial.read();
if(c == 'l' || c == 'p' || c
== 'i' || c == 'm' )
{
promedioDer = 0;
promedioIzq = 0; promedioCruceDer =
0; promedioCruceIzq = 0;
for(i = 0; i < muestras;
i++)
{
lineaDer =
(analogRead(sensorLineaDer))/4;
// valores de 0 - 255
lineaIzq =
(analogRead(sensorLineaIzq))/4;
lineaCruceDer =
(analogRead(sensorCruceDer))/4;
lineaCruceIzq =
(analogRead(sensorCruceIzq))/4;
promedioDer += lineaDer;
promedioIzq += lineaIzq;
promedioCruceDer +=
lineaCruceDer; promedioCruceIzq +=
lineaCruceIzq;
Serial.print("linea ");
Serial.print(lineaIzq);
Serial.print('t');
Serial.println(lineaDer);
Serial.print("cruce ");
Serial.print(lineaCruceIzq);
Serial.print('t');
Serial.println(lineaCruceDer);
delay(500);
}
Serial.print("promedioLinea
");
Serial.print(promedioIzq/muestras);
Serial.print('t');
Serial.println(promedioDer/muestras
);
Serial.print("promedioCruce
");
Serial.print(promedioCruceIzq/muest
ras); Serial.print('t');
Serial.println(promedioCruceDer/mue
stras);
if(c == 'l')
{
EEPROM.write(0, (byte)
(promedioDer/muestras) );
(promedioIzq/muestras) );
(promedioCruceDer/muestras) );
(promedioCruceIzq/muestras) );
}
if(c == 'p')
{
}
if(c == 'm')
{
}
Serial.println("*** echo
***");
}
if(c == 'r')
{
Serial.println("Izquierda
Derecha");

Serial.println("--- Linea -
--");
Serial.print(EEPROM.read(1));
Serial.print('t');
Serial.println(EEPROM.read(0));
Serial.println("--- Linea
Cruce ---");
Serial.print('t');
Serial.println("--- Pista -
--");
Serial.print('t');
Serial.println("--- Pista
Cruce---");
Serial.print('t');
Serial.println("--- Meta --
-");
Serial.print('t');
Serial.println("--- Meta
Cruce---");
Serial.print('t');
}
}
}
/**********************************
***********************************
**********************/
/*** SENSORES LINEA ***/
void sensoresLinea(void)
{
lineaDer =
analogRead(sensorLineaDer);
lineaIzq =
analogRead(sensorLineaIzq);
lineaCruceDer =
analogRead(sensorCruceDer);
lineaCruceIzq =
analogRead(sensorCruceIzq);
}
/*******************************
********************************
****************************/
/*** CONTROL ***/
void control(void)
{
sensoresLinea();
if( lineaDer < umb_linea_Der &&
lineaIzq < umb_linea_Izq ) // sin
linea
{
errorDer = 0; last_errorDer =
0; derivativoDer = 0;
errorIzq = 0; last_errorIzq =
0; derivativoIzq = 0;
adelante();
analogWrite(motorDer,minVelocidadDe
r);
analogWrite(motorIzq,minVelocidadIz
q);
c = 'y'; // habilitar
deteccion de cruce, despues de cada
giro y deteccion sin linea linea
do
{
lineaDer =
lineaIzq =
}while(lineaDer <
umb_linea_Der && lineaIzq <
umb_linea_Izq);
}
else
{

if( lineaDer < umb_linea_Der)
controlDer(); // se inclina a la
derecha
if( lineaIzq < umb_linea_Izq)
controlIzq(); // se inclina a la
izquierda
if( lineaDer > umb_linea_Der
&& lineaIzq > umb_linea_Izq ) //
sobre la linea
{
errorDer = 0; last_errorDer
= 0; derivativoDer = 0;
errorIzq = 0; last_errorIzq
= 0; derivativoIzq = 0;
r);
q);
}
if( (lineaCruceDer >
umb_cruce_Der) && (lineaCruceIzq >
umb_cruce_Izq) && (c == 'y') ) //
cruce de linea
{
do // permitir k salga un
tanto del cruce
{
lineaCruceDer =
lineaCruceIzq =
analogRead(sensorCruceIzq);
}while( !(lineaCruceDer <
umb_cruce_Der && lineaCruceIzq <
umb_cruce_Izq) );
motoresApagados();cruce =
1; c = 'x';
}
else { cruce = 0;}
}
}
Después de ello tenemos dos funciones
que hacen lo posible por corregir la mala
posición del prototipo.
/*** CONTROL DERECHA ***/
void controlDer()
{
lineaDer =
errorDer = sp_linea_Der -
lineaDer;
derivativoDer = errorDer -
last_errorDer;
salida_pwm = (kpDer * errorDer)
+ ( kdDer * derivativoDer);
last_errorDer = errorDer;
if( salida_pwm >
minVelocidadDer ) salida_pwm =
minVelocidadDer; //limitamos la
salida de pwm
if( salida_pwm < -
minVelocidadDer ) salida_pwm = -
minVelocidadDer;
if (salida_pwm > 0)
{
analogWrite(motorDer,salida_pwm);
analogWrite(motorIzq,minVelocidadDe
r-salida_pwm);
}
if (salida_pwm < 0)
{
r+salida_pwm);
analogWrite(motorIzq,-
salida_pwm);
}
}
/**********************************

***********************************
**********************/
/*** CONTROL IZQUIERDA ***/
void controlIzq()
{
lineaIzq =
errorIzq = sp_linea_Izq -
lineaIzq;
derivativoIzq = errorIzq -
last_errorIzq;
salida_pwm = (kpIzq * errorIzq)
+ ( kdIzq * derivativoIzq);
last_errorIzq = errorIzq;
if( salida_pwm >
minVelocidadIzq ) salida_pwm =
minVelocidadIzq;
if( salida_pwm < -
minVelocidadIzq ) salida_pwm = -
minVelocidadIzq;
if (salida_pwm > 0)
{
analogWrite(motorDer,minVelocidadIz
q-salida_pwm);
analogWrite(motorIzq,salida_pwm);
}
if (salida_pwm < 0)
{
analogWrite(motorDer,-
salida_pwm);
q+salida_pwm);
}
}
También se programó una función
denominada giro, la cual nos sirve para
controlar nuestro robot al momento del
cruce determinado para poder hacer
girarlo sobre su propio eje.
/*** GIRO ***/
void giro(byte sentido)
{
if(sentido == izquierda)
{
giroIzquierda();
analogWrite(motorDer,
velGiroIzq_Der); // velocidades
diferentes para
analogWrite(motorIzq,
velGiroIzq_Izq); // compensar el
giro
delay(500);
do // permitir que los
sensores salgan de la linea
{
lineaDer =
}while(lineaDer >
umb_linea_Der);
// cruce de linea
do
{
lineaIzq =
}while(lineaIzq <
(umb_linea_Izq+10));
do
{
lineaDer =
}while(lineaDer <
(umb_linea_Der+10));
}
if(sentido == derecha)
{
giroDerecha();
velGiroDer_Der); // velocidades
diferentes para

velGiroDer_Izq); // compensar el
giro
delay(500);
do // permitir que los
sensores salgan de la linea
{
lineaIzq =
}while(lineaIzq >
umb_linea_Izq);
// cruce de linea
do
{
lineaDer =
}while(lineaDer <
(umb_linea_Der+10));
do
{
lineaIzq =
}while(lineaIzq <
(umb_linea_Izq+10));
/*
do // caso especial del giro
a la derecha
{
lineaCruceDer =
}while(lineaCruceDer <
umb_cruce_Der);
*/
delay(200);
}
motoresApagados();
delay(500);
}
La siguiente función es la que verifica si el
robot esta fuera de posición para mandar
a llamar a las funciones correspondientes
y corregirlo.
/*** CENTRAR SENSORES LINEA***/
void centrarSensoresLinea(void)
{
sensoresLinea();
if( !(lineaDer > umb_linea_Der
&& lineaIzq > umb_linea_Izq) )
{
if( lineaDer < umb_linea_Der)
{
giroIzquierda();
delay(500);
velGiroIzq_Der);
velGiroIzq_Izq);
do
{
lineaDer =
}while(lineaDer <
umb_linea_Der);
}
else if( lineaIzq <
umb_linea_Izq)
{
giroDerecha();
delay(500);
velGiroIzq_Der);
velGiroIzq_Izq);
do
{
lineaIzq =
}while(lineaIzq <
umb_linea_Izq);
}

motoresApagados();
delay(500);
}
}
/**********************************
***********************************
**********************/
/*** CENTRAR SENSORES CRUCE***/
void centrarSensoresCruce(void)
{
sensoresLinea();
if( (lineaCruceDer <
umb_cruce_Der) && (lineaCruceIzq <
umb_cruce_Izq) )
{
atras();
do
{
sensoresLinea();
}while( !(lineaCruceDer >
umb_cruce_Der && lineaCruceIzq >
umb_cruce_Izq) );
motoresApagados();
delay(500);
}
}
/**********************************
***********************************
**********************/
/*** GIRO IZQUIERDA ***/
void giroIzquierda()
{
digitalWrite (IN1, LOW);
digitalWrite (IN2, HIGH);
}
/**********************************
***********************************
**********************/
/*** GIRO DERECHA ***/
void giroDerecha()
{
}
/**********************************
***********************************
**********************/
/*** ADELANTE ***/
void adelante()
{
}
/**********************************
***********************************
**********************/
/*** ATRAS ***/
void atras()
{
delay(300);
velAtras); analogWrite(motorIzq,
velAtras);
}
/**********************************
***********************************
**********************/ /***
MOTORES APAGADOS ***/
void motoresApagados(void)
{
// Motores apagados
analogWrite (motorIzq, 0);

analogWrite (motorDer, 0);
}
Hay ciertas funciones en la parte anterior
que se usan para diversos objetivos
específicos ya que se desgloso
demasiado las partes de nuestra lógica
para tener un mejor control de
programación.
Aquí tenemos por fin la parte principal de
nuestro código.
void setup()
{
// PinMode para los
ULtrasonicos
pinMode(trigIzq,OUTPUT);
pinMode(trigCentro,OUTPUT);
pinMode(trigDer,OUTPUT);
pinMode(echoIzq,INPUT);
pinMode(echoCentro,INPUT);
pinMode(echoDer,INPUT);
// PinMode control Puente H
motores
pinMode (IN4, OUTPUT); pinMode
(IN3, OUTPUT);
pinMode (IN2, OUTPUT); pinMode
(IN1, OUTPUT);
muestras = 20;
cruce = 0;
numeroCruces = 0;
c = 0;
duracion = 0;
timeout = 1740; // lectura
max ultrasonicos 30cm (1740us)
distanciaIzq = 0;
distanciaCentro = 0;
distanciaDer = 0;
motoresApagados();
Serial.begin(9600);
}
void loop()
{
//calibrar();
//Serial.println("*** Preparado
***");
sp_linea_Der = EEPROM.read(0) *
4; //
setpoint valor calibrado linea
sp_linea_Izq = EEPROM.read(1) *
4;
umb_linea_Der = ( sp_linea_Der
+ (EEPROM.read(2) * 4) )/2; //
umbral de la linea lado derecho
umb_linea_Izq = ( sp_linea_Izq
+ (EEPROM.read(3) * 4) )/2;
sp_cruce_Der = EEPROM.read(4) *
4; //
setpoint valor calibrado linea
sp_cruce_Izq = EEPROM.read(5) *
4;
umb_cruce_Der = ( sp_cruce_Der
+ (EEPROM.read(6) * 4) )/2; //
umbral cruce linea lado derecho
umb_cruce_Izq = ( sp_cruce_Izq
+ (EEPROM.read(7) * 4) )/2;
umb_crucemeta_Der = (
EEPROM.read(10) + EEPROM.read(6) )
* 2 ; // umbral meta cruce /
pista cruce
umb_crucemeta_Izq = (
EEPROM.read(11) + EEPROM.read(7) )
* 2 ;
for(i = 0; i < 5; i++)
delay(1000);
cruce = 0; muestras = 0;
numeroCruces = 0;
adelante();

while(1)
{
if(cruce == 1)
{
motoresApagados(); cruce =
0; numeroCruces++;
delay(300);
centrarSensoresLinea();
delay(300);
if( lineaCruces[muestras]
== numeroCruces)
{
if(
lineaSentido[muestras] ==
izquierda)
{
centrarSensoresCruce();
for(i = 0; i < 2; i++)
// pausas
{
digitalWrite(IN2,!digitalRead(IN2))
; delay(500);}
giro(izquierda);
}
else if(
lineaSentido[muestras] == derecha )
{
centrarSensoresCruce();
for(i = 0; i < 2; i++)
// pausas
{
; delay(500);}
giro(derecha);
}
for(i = 0; i < 2; i++)
// pausas
{
; delay(500);}
centrarSensoresLinea();
delay(300);
muestras++; numeroCruces
= 0;
}
adelante();
control();
}
else control();
if( muestras ==
sizeof(lineaCruces)) // buscando
la meta
{
sensoresLinea();
// la condicional cambia
segun el color meta / pista
if( lineaCruceDer <
umb_crucemeta_Der && lineaCruceIzq
< umb_crucemeta_Izq )
{
motoresApagados();
for(i = 0; i < 10; i++)
// pausas
{
; delay(500);}
}
}
}
}
Resultados obtenidos
En la etapa final del proyecto, en la
creación de un robot autónomo capaz de
descifrar laberintos, se suscitaron
demasiados contratiempos para las
pruebas finales y el ir experimentando que
tanta inteligencia adquiría el robot de
acuerdo a las correcciones que
constantemente se le realizaban después
de cada prueba hecha en laberintos

provisionales ya que el final aún no estaba
disponible.
Existieron detalles como las pruebas en
laberintos no idóneos, es decir, se
hicieron pruebas en materiales como
azulejo, piso firme y terracería lo cual no
beneficio la adherencia de nuestras
llantas al piso por lo que por cada tipo de
piso, el robot se comportaba con distintas
velocidades lo cual nos causó
contratiempos.
Otro inconveniente fue lo de la
arquitectura del robot, al ser un poco
grande, necesitaba un poco más de
espacio que las distancias entre paredes
del laberinto, así que se tuvieron que
implementar nuevas llantas y motores
para un giro más rápido.
En algunas ocasiones los problemas eran
más técnicos, por ejemplo cuando se
prendía el robot a veces un motor prendía
y el otro no o viceversa, pero causaba
problemas ya que hacía falta una
coordinación para iniciar al mismo tiempo.
El problema más grande y grave al que
nuestro equipo se enfrentó fue a la
pérdida del robot dentro de la superficie
(en el cruce) cuando tenía cierta
desviación que ponía en riesgo muy alto
la lógica pensada para que el robot
pudiera resolver el laberinto, ya que al
salirse de las líneas, perdida totalmente el
control que se tenía sobre él.
Conclusión
Una de las mejores experiencias que
hemos tenido fue la realización de este
proyecto, ya que demando una exhausta
búsqueda de información acerca de cómo
armar y programar nuestro prototipo,
además de ser la primera vez en
adentrarnos en esta área.
Otro aspecto importante es que aunque
se tenga la mejor arquitectura, no
garantiza un óptimo funcionamiento del
robot, ya que el componente más
importante es el código lo que en realidad
controla a la parte mecánica.
Para finalizar, la placa arduino es un
componente muy básico pero con muchas
utilidades dentro de todos los ámbitos ya
que como vimos anteriormente tiene
aplicaciones prácticas que ayudan a
solucionar o servir como apoyo a una
necesidad que se tenga.

Referencias
Arduino. (2016). Obtenido de https://www.arduino.cc/en/main/arduinoBoardUno
Arduino. (2016). Obtenido de Arduino: http://forum.arduino.cc/index.php?topic=157831.0
MsRobotics. (2016). Obtenido de http://msrobotics.net/index.php/laboratorio-ard/87-control-
remoto-infrarrojo-con-arduino

Robot autónomo para recorrer un laberinto

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Robot autónomo para recorrer un laberinto

Similar a Robot autónomo para recorrer un laberinto (20)

Más de Extensión del Instituto Tecnológico de Tuxtla Gutiérrez sede Bochil

Más de Extensión del Instituto Tecnológico de Tuxtla Gutiérrez sede Bochil (20)

Último

Último (20)

Robot autónomo para recorrer un laberinto