Diseño de microrrobots móviles para laberintos

Robots de Laberinto
Trabajo realizado para la asignatura de Diseo de

Microrrobots Mviles de la Universidad de Alcal
por
Diaz Collazo, Adrin Marcelo (chelo_158@hotmail.com),

Echeanda Snchez, Carlos (ator001@hotmail.com),
Espejo Gmez , Victor (vicespgom@yahoo.es),
Garca Castilla, Fernando (garciacastilla@hotmail.com),
Gude Rodrguez, Isaac (isaacgude@hotmail.com) ,
Lzaro Rubio, Carlos (dj_clr@hotmail.com),
Muoz Babiano, Federico (chagales@gmail.com),
Prez Couso, Alberto (couso@telecosalcala.com)
Noviembre 2006
Introduccin al Diseo de Microrrobots Mviles Trabajos en Grupo
NDICE
1.Introduccin......................................................................................................................... 4
2.Historia de las competiciones .............................................................................................. 5
3.Competiciones ..................................................................................................................... 7
Alcabot e Hispabot ............................................................................................................. 7
Micromouse ........................................................................................................................ 9
4.Anlisis de estructuras y diseos de robots de laberinto ................................................... 10

El chasis ............................................................................................................................ 10
Forma............................................................................................................................ 10
Materiales ..................................................................................................................... 11
Mtodo de manejo y el dar la vuelta ................................................................................ 12
Grados de movimiento ................................................................................................. 12
La traccin .................................................................................................................... 13
Las ruedas ..................................................................................................................... 15
5.Sensores ............................................................................................................................. 16
Sensores de proximidad.................................................................................................... 18
Sensores de distancia ........................................................................................................ 19
6.Motores .............................................................................................................................. 21
Motores C.C. .................................................................................................................... 21
Motores paso a paso ......................................................................................................... 22
Servo motores ................................................................................................................... 22
7.Bateras .............................................................................................................................. 23
8.Anlisis de algoritmia ........................................................................................................ 24

Algoritmos con laberinto conocido. ................................................................................. 24
Algoritmo de DIJKSTRA: ........................................................................................... 26
Bsqueda de BREADTH FIRST.................................................................................. 32
Algoritmo de BELLMAN-FORD ................................................................................ 33
Algoritmos con el laberinto desconocido ......................................................................... 34
Seguir la pared .............................................................................................................. 34
Llenar caminos ............................................................................................................. 35
Algoritmo aleatorio ...................................................................................................... 36
Pgina 1
Algoritmo de la colonia de la hormiga ......................................................................... 36

Gaston Tarry y Edouard Lucas..................................................................................... 37
Recursividad ................................................................................................................. 37
Algoritmo de Microtauro.............................................................................................. 39
Cmo se consigue un control tan perfecto? .................................................................... 41
Diagonales ........................................................................................................................ 41
En lnea recta ................................................................................................................ 42
Las curvas ..................................................................................................................... 44
9.Simuladores ....................................................................................................................... 47
10.Consideraciones a tener en cuenta a la hora del diseo: ................................................. 50
11.Algoritmo para salir del laberinto: .................................................................................. 51
12.Descripcin de estructura y hardware del robot .............................................................. 56

El cerebro ......................................................................................................................... 57
El sistema sensorial .......................................................................................................... 58
Los actuadotes .................................................................................................................. 58
Estructura fsica ................................................................................................................ 59
13.Catia................................................................................................................................. 61
Introduccin a Catia. ........................................................................................................ 61
Sketcher. ........................................................................................................................... 61
Part Desing ....................................................................................................................... 62
Assembly Dessing ............................................................................................................ 63
Diseo de nuestro robot. ................................................................................................... 63
Desarrollo por partes del diseo. ...................................................................................... 64
Base del robot. .............................................................................................................. 64
GP2D12. ....................................................................................................................... 64
Placa ............................................................................................................................. 65
Motor paso a paso......................................................................................................... 65
Bumper ......................................................................................................................... 66
CD ................................................................................................................................ 66
Aguja. ........................................................................................................................... 67
Sub-ensamblaje ................................................................................................................ 67
Montaje completo ............................................................................................................. 68
14.Montaje real del robot: .................................................................................................... 70
Pgina 2
15.Conclusiones. .................................................................................................................. 82
16.Bibliografa. ..................................................................................................................... 84
Pgina 3
1. INTRODUCCION
El documento desarrollado a continuacin trata sobre los Robots de laberinto o Robots
de Micromouse. El trabajo est desarrollado por un grupo de estudiantes de la UAH para
la asignatura de Microrrobots. El fin principal de este trabajo es aportar una base con la que
enfrentarse al desarrollo de un robot de laberinto.
Durante todo el texto abordamos diversos temas relacionados con este tipo de robots.
Para poder desarrollar el tema con la mayor sencillez y amplitud posible hemos dividido el
trabajo en varios aspectos.
Empezamos desarrollando el trabajo dando unas pinceladas de historia acerca de las
competiciones que se han realizado tanto a nivel nacional como internacional. Seguimos
con un anlisis de las estructuras ms usadas con sus ventajas e inconvenientes.
Obviamente necesitamos algn mtodo para salir del laberinto, esto lo abordamos en un
apartado dedicado exclusivamente a la algoritmia, control y simulacin. Para completar el
trabajo desarrollado hemos realizado una propuesta de diseo utilizando herramientas de
diseo en 3 dimensiones y llevando acabo el proyecto.
Finalmente aportamos unas conclusiones y consejos para que quien lo desee pueda
realizar un robot sin tener los mismos problemas que nos ocurrieron a nosotros.
Pgina 4
2. Historia de las competiciones

Las competiciones de micromouse surgieron a finales de los 70, fue a partir de los 80
cuando empieza la forma de competicin que conocemos actualmente.
A continuacin desglosamos la evolucin por aos:
(http://micromouse.cannock.ac.uk/history.htm)
1977
En este ao se introdujo el concepto de microsmouse por el IEEE. En mayo se
anunci la primera competicin de Micromouse que sera celebrada en 1979 en
Nueva York.
1980
El profesor Juan Billinsley, de la escuela politcnica de Portsmouth, introdujo la
primera competicin europea y modific las reglas, consiguiendo que las
competiciones sean parecidas a las de la actualidad.
1981
En la exposicin micro de Pars hubo cinco micromouse, el primer lugar fue para
el ratn Esterlina, alcanzando la meta en menos de 3 minutos.
En la segunda competicin Britnica de micromouse, Dave Woodfield consigui

un tiempo de 47 segundos, proclamndose campen. Esterlina consigui un
segundo lugar con 1min 37sec.
1985
Se llevo a cabo el First World Micromouse Competiton en Tsukuba, Japn.
1986
Los E.E.U.U. hicieron su primera competicin, celebrada en Atlantic City.
1987
Se produjo la primera competicin de Singapur
Pgina 5
1989
Se lanz la primera competicin internacional de Micromouse de Singapur.
1992
Tenemos ya la sptima entrega de competicin anual del micromouse de IEE, en
Londres.
Pgina 6
3. Competiciones
A continuacin presentamos las competiciones ms conocidas.
ALCABOT
o 2000
NORMATIVA: El concurso ser ganado por aqul micro-robot que
consiga salir del laberinto en el menor tiempo. Se dispone de una
nica entrada y una nica salida.
http://www.depeca.uah.es/alcabot/alcabot2000/normativa.htm
N PARTICIPANTES: 5
o 2001
NORMATIVA: El laberinto tiene una entrada y una salida y los
robots tienen que entrar en el laberinto y salir en el menor tiempo
posible.
http://www.depeca.uah.es/alcabot/alcabot2001/normativa.htm
N PARTICIPANTES PRESENTADOS: 10
o 2002
NORMATIVA: La prueba consistir en sacar al robot desde un punto
de partida conocido mediante sorteo, quince minutos antes del
comienzo de cada sesin. Podr salir por cualquiera de las dos
salidas del laberinto. El plano del laberinto es conocido para los
participantes.
http://www.depeca.uah.es/alcabot/alcabot2002/normas_laberinto.htm
o 2003
NORMATIVA: Coincide con Hispabot 2003. Es equivalente a la de
Alcabot 2002.
http://www.depeca.uah.es/alcabot/hispabot2003/laberinto.pdf
Pgina 7
o 2004
NORMATIVA: Se introducen novedades respecto aos anteriores:
Dado que el laberinto es conocido, se primar a los Robots
capaces de incorporar algoritmos de navegacin.
Las salidas del laberinto son dos: una de ellas ser vlida,
mientras que la otra tendr una penalizacin.
El Ratn obtendr bonificacin, si logra introducir una pelota
de ping-pong estndar en esa casilla central.
http://www.depeca.uah.es/alcabot/data/doc/HISPA04_Normativa_La
berinto_v1_0.pdf
Por lo dems la normativa es equivalente a la de los aos 2002 2003.
o 2006
NORMATIVA: Se introducen novedades respecto aos anteriores:
Rampa de entrada
Balizas.
Globos.
La canasta est en el exterior.
El mapa del laberinto no es conocido.
http://www.depeca.uah.es/alcabot/data/doc/HISPA06_Normativa_La
berinto_v2_1.pdf
HISPABOT
La normativa de cada ao de Hispabot es equivalente a la de Alcabot de cada ao
respectivamente.
Pgina 8
COMPETICIONES A NIVEL INTERNACIONAL
MICROMOUSE:
El campeonato de Reino Unido Micromouse es una competicin internacional de la

robtica, que se ha sostenido cada ao en el Reino Unido desde el los aos 80.
Acontecimientos similares tambin se llevan a cabo en los E.E.U.U, Japn, Singapur, Corea
y a otras partes. Los micromouses ratones compite con contra el reloj para buscar el
centro de un laberinto en el tiempo ms corto. El laberinto es desconocido.
El laberinto consiste en 256 cuadrados (clulas) dispuestos en un formato 16 x 16, en una

rejilla de 180mm. Cada pared es 50 mm de alto y 12 mm de grueso, por lo tanto la distancia
mnima de la pared a la pared es 168 mm.
El campeonato ha sido apoyado por una variedad de organizaciones y las instituciones

acadmicas incluyendo Euromicro, el instituto de ingenieros elctricos, la universidad de
Londres del este, el RAC, la universidad de Manchester, universidad de Loughborough, el
BBC, universidad de Exeter, Unversity de Bristol, el departamento de la informtica en
Holloway real, el centro de la innovacin de la tecnologa de la universidad de Inglaterra
central, y otros.
Universidad naciones de Colombia

(http://www.ing.unal.edu.co/eventos/un_robot2006/categorias2.htm)
NORMATIVA: La prueba consiste en entrar y recorrer el laberinto,

desconocido, (siguiendo la lnea negra central o las paredes) y sacar de l un
cubo rojo de 5 cm. x 5 cm., se considera terminada cuando el robot sale del
laberinto con el cubo y entra completamente a la zona de meta. La meta es
un rectngulo de color negro en el piso que marca el final del laberinto. A
continuacin mostramos algunos modelos de posibles laberintos:
N PARTICIPANTES: 11
Pgina 9
4. Anlisis de estructuras y diseos de robots de

laberinto
A priori puede parecer que cualquier estructura es vlida para nuestro robot, que lo
importante es lo que tiene dentro, pero esto no es del todo cierto. Dependiendo de la
funcin de dicho robot ser conveniente utilizar una u otra, incluso una mala eleccin puede
hacer que se compliquen mucho las cosas en un futuro. Por ello, es conveniente utilizar
parte del tiempo en pensar donde colocar las partes del robot y de forma de hacerlo.
A continuacin estudiamos las partes ms importantes de un robot micromouse:
El chasis
El chasis es la estructura que sostiene y aporta rigidez y forma a nuestro robot. Un
buen smil sera el compararlo con el esqueleto humano. Por lo tanto queda justificada la
importancia de una correcta eleccin.
Forma
Imaginemos que hemos decidido hacer el robot con sensores de contacto, es decir, el
micromouse va por el laberinto, se choca contra una pared y da media vuelta. En este caso
la forma es importantsima puesto que tendremos que pensar en que el robot debe ser capaz
de girar sobre si mismo sin que la pared se lo impida, por ejemplo, con un cuadrado pasara
lo que vemos a continuacin:
Sin embargo, si elegimos una forma redondeada no tendramos este problema.
Pgina 10
Ahora bien, Que pasara si utilizamos sensores de distancia?, Ya no sera

importante la forma?, en este caso, la forma seguira siendo igual de importante puesto que,
aunque en un principio pudiramos pensar que el robot nunca tocara las paredes, en
cualquier momento esto podra ocurrir y nos ser mucho ms fcil salir del problema
eligiendo una buena forma para el robot.
Una buena solucin a esto podra ser no preocuparse de la forma del chasis, o no
preocuparse demasiado, y ms tarde colocar una carcasa externa con la forma que
queramos. Esta tcnica es la empleada por ejemplo por el robot PI:
http://www.rbzrobotdesign.com/index.php?module=3&id=21
Materiales
Los micromouse se han construido de diversos materiales: metal, plstico, madera

El mejor criterio para elegir uno u otro ser, en primer lugar, que dicho material este
disponible, ya que de poco nos servir pensar en uno que no podamos conseguir. Y, entre
los que encontremos, habr que elegir entre uno u otro por aspectos como la resistencia,
facilidad de mecanizado y peso.
Las soluciones que se han ido viendo en las competiciones son muy variadas, por
ejemplo en el 2002 el robot AURELIO (a la derecha) utiliz
policarbonato diciendo que: este material es resistente, a la par
que ligero, permite ser cortado y troquelado sin presentar
problemas.
Mientras que robots como TURING (a

la izquierda) aprovecha el propio
circuito impreso como chasis.
Pgina 11
MTODO DE MANEJO Y EL DAR LA VUELTA

En este apartado estudiaremos las distintas tcnicas que se utilizan para conseguir
buenos giros y movimientos. Esto es algo que debemos estudiar especialmente en los
micromouse puesto que tenemos grandes restricciones de movimiento por el laberinto.
Grados de movimiento
Empezaremos viendo los dos tipos de movimiento que podemos tener, en funcin de
los grados de libertad en el giro.
Movimiento en diagonal: Con este tipo de movimiento conseguimos unos

desplazamientos notablemente ms rpidos, puesto que la distancia que
recorremos es menor. A cambio, nos encontramos con varios inconvenientes.
Para empezar, ser ms difcil de construir, ya que para moverse en diagonal
tendremos que tener en cuenta factores que de otro modo no los tendramos,
como por ejemplo estudiar ms a fondo la colocacin de los sensores, adems,
estos deben tener la suficiente precisin como para detectar las zonas en las
que nos podemos mover en diagonal y no chocarnos con las paredes. En
cuanto al control del movimiento, este debe ser muy preciso, ya que un
pequeo desvo en la trayectoria podra hacernos rozar con las esquinas.
BR3 MOUSE
Movimiento en lnea recta: este tipo de movimiento ser mucho ms sencillo

de realizar que el diagonal, pero a cambio los desplazamientos sern ms
lentos al tener que recorrer ms distancia. Con este tipo, nos podemos
encontrar problemas como que alguna rueda patine o que los giros no sean
exactamente de 90-180 haciendo al robot tener un error acumulativo que
puede tener graves consecuencias si no lo corregimos.
Pgina 12
La traccin
Bsicamente la traccin nos importar en funcin del tipo de giro que proporcione.
Para ver el giro que necesita un robot debemos pensar en la funcin que va a desempear,
es decir, es posible que en ciertos casos necesitemos ms estabilidad que maniobrabilidad o
al contrario.
Existen muchos tipos de tracciones, pero en nuestro caso nos va a interesar
fundamentalmente solo una, por ello diferenciamos, a continuacin, dos tipos, la ms
utilizada y la que no debemos utilizar, explicando porqu:
Diferencial
Para el caso que nos ocupa (micromouse) podemos decir que en el 100% de
los robots premia la maniobrabilidad, y por este motivo utilizaremos una traccin
diferencial, gracias a esto conseguiremos hacer giros de 90-180 sin ninguna
complicacin.
Un ejemplo de traccin diferencial podra ser la utilizada por el robot

FLORENCIA:
Pgina 13
Si estudiamos un poco ms detenidamente el movimiento que se genera,

llegamos a la siguiente ecuacin:
D
d= n
c
Donde:
d = distancia recorrida.
D = dimetro de la rueda.
c = nmero de pulsos del encoder por vuelta.
n = nmero de pulsos leidos.
La anterior expresin sera en el caso de que las dos ruedas se moviesen a la

vez.
Si lo que queremos es hacer un giro de x grados la ecuacin sera la

siguiente:
Drueda 360
x= n
c Dbase
Donde:
x = grados girados.
Drueda = dimetro de la rueda.
Dbase = dimetro de la base tomando como limite de la
circunferencia el inicio de las ruedas.
c = nmero de pulsos del encoder por vuelta.
n = nmero de pulsos.
Este movimiento habr que proporcionarlo a ambas ruedas motrices, cada

una en un sentido.
No diferencial
Por otro lado tenemos la traccin no diferencial, en la que las dos ruedas
giran a la vez y el tipo de giro es de la forma en que lo que movemos es un eje que
une ambas ruedas, producindose as el giro de estas.
Si la usramos, el giro sera ms tedioso e incluso podra darnos problemas.

Lo vemos a continuacin:
Pgina 14
Como se ve en la figura, el robot se puede encontrar graves problemas a la hora de

desplazarse por el laberinto, porque es posible que los giros no sean lo suficientemente
cerrados como para pasar de una casilla a otra sin rozar con alguna pared, esto se puede
convertir en un gran problema puesto que nos podra, por ejemplo, desviar de la trayectoria
con los consiguientes efectos.
Las ruedas
Antes de ponernos a montar las ruedas debemos ver dnde deben estar colocadas. En
principio podemos pensar en una colocacin equidistante en la base lo mas separadas
posible para mayor estabilidad, ahora bien, si lo hacemos as debemos tener en cuenta cual
ser el eje de giro, en este caso, significara que el robot no girar entorno al centro del
crculo que forma su planta y por tanto colisionar con el obstculo.
Un ejemplo de esta colocacin sera la utilizada por el robot Charrito
Pgina 15
http://www.sec.upm.es/agustin/charrito/charrito.html
Aqu vemos como las ruedas motrices estn colocadas de tal forma que el robot har
los giros sobre un punto distinto al centro de la base, en concreto, los giros sern los que
vemos en la figura siguiente:
Una forma sencilla de realizar giros sobre el centro de la base sera el adoptado por el
robot Pi de RBZ Robot Design, el cual, como vemos en la fotografa, utiliza dos ruedas
motrices colocadas en el dimetro de la base y dos ruedas locas para la estabilidad:
Pgina 16
El gran inconveniente de este tipo de solucin es que solo nos podremos mover por
zonas completamente lisas, ya que si una de las ruedas locas pasase por algn elevamiento,
por muy pequeo que fuera, alguna rueda motriz dejara de tocar el suelo.
Pgina 17
5. SENSORES
Los micromouse necesitan una manera de detectar las paredes dentro del laberinto,
esto lo harn mediante sensores. Distinguimos dos tipos: de proximidad simples o de
distancia.
Sensores de proximidad
Estos tipos de sensores nos dan informacin sobre si hay o no hay algo, es decir, nos
dan una seal binaria (verdadero o falso). Generalmente se montan en las alas de los
robots, de modo que puedan detectar las paredes mirando los techos de estas. Si hay una
pared directamente debajo del sensor, su valor ser verdadero, mientras que si no la hay el
valor ser falso. Un micromouse de este tipo tendra el siguiente aspecto:
Un ratn con los sensores de proximidad
Un diseo as tendr por lo menos siete sensores, uno mirando al frente y por lo
menos tres a cada lado. El sensor delantero evita que el ratn se estrelle con una pared
prxima al frente, mientras que los laterales permiten que el ratn corrija su trayectoria. En
el caso de la figura anterior, si los sensores izquierdos leen un valor de 010 indica que el
ratn est centrado dentro de la casilla. Si leemos un valor de 100, indicara que el ratn
est descentrado a la derecha y necesita corregir a la izquierda, y al contrario con un valor
001.
Pgina 18
Usar este tipo de sensores tiene otra ventaja. Si por ejemplo leemos el sensor
derecho con un valor de 011, indicara que tenemos una pared perpendicular a la derecha
sin necesidad de desplazarnos a la correspondiente casilla, y por lo tanto invirtiendo menos
tiempo en la exploracin del laberinto
La forma de utilizar estos sensores es la siguiente:
El emisor: En el caso de la figura, polarizamos el diodo a travs de

un resistor, R, este se elige para establecer la corriente apropiada que
pasar a travs del LED. Tambin podemos usar otra opcin en la
que lo conectamos a travs de un transistor controlado para que el
LED emita solo cuando sea necesario, ahorrando as la energa que
del otro modo desperdiciaramos.
El receptor: Este recibir la seal, o no, dependiendo de si

esta rebota en alguna superficie, dando una tensin nula, o
positiva respectivamente.
El emisor y receptor pueden ser componentes separados, o estar contenidos juntos

en un paquete plstico. En la siguiente fotografa los vemos juntos:
Sensores de distancia
Al contrario que los sensores de proximidad, los de distancia no devuelven un simple
verdadero/falso. Estos miden la distancia fsica entre el robot y la pared, y devuelven un
valor, el cual, el microcontrolador pueda interpretar como distancia.
Pgina 19
Una forma de poner este tipo de sensores en funcionamiento es utilizar un circuito

similar al del sensor de proximidad. La gran diferencia es que el fototransistor no es
forzado a la saturacin. El emisor genera una luz que se reflejar en la pared y, cuanto ms
cercano est el robot de esta, ms brillante ser la luz reflejada y por lo tanto mayor seal
recibir el receptor.
Un mtodo bastante popular para medir distancia es utilizando el GP2D12.
Este sensor emiten una luz IR sobre la pared que es reflejada y recibida por el
dispositivo de deteccin de posicin (PSD). Dependiendo del ngulo de reflexin el
microcontrolador obtendr el correspondiente dato para poder actuar. Los sensores de este
tipo suelen ser ms inmunes a variaciones del color y de iluminacin.
Pgina 20
6. MOTORES
Los motores sern los encargados de generar los desplazamientos en el robot, por lo
tanto, la eleccin de estos ser algo determinante para conseguir un buen movimiento, tanto
en aceleracin como en velocidad punta.
A continuacin comentamos, brevemente, los principales motores, que podremos

utilizar.
Motores C.C.
En un motor C.C. la tensin se aplica directamente a los terminales de este
producindose el movimiento. Una vez polarizado, se alcanza, rpidamente, una velocidad
constante que depender dicho voltaje aplicado y de las caractersticas del motor. La
cantidad de fuerza que se puede generar ser funcin de la corriente por las bobinas, siendo
mayor al aumentar esta, es decir, si queremos generar una cierta velocidad, la corriente que
debemos generar ser mayor si el motor tiene una carga que si no.
Generalmente, para polarizar el motor utilizaremos un puente en H, consiguiendo as un

buen control de la tensin aplicada y pudiendo invertir la polaridad, y por tanto el sentido
de giro, si se necesita.
Pgina 21
Puente en H
Motores paso a paso

La principal caracterstica de estos motores es el hecho de poder moverlos paso a
paso aplicando pulsos. Dependiendo del motor, un paso puede ser desde 90 hasta 1.8, es
decir, se necesitaran 4 pasos en el primer caso (90) y 200 en el segundo (1.8), para
completar un giro completo de 360.
La gran ventaja de estos motores es que no necesitamos usar encoders para controlar
el movimiento y saber donde estamos, es decir, seremos capaces de conocer en todo
momento la posicin sin ms que llevar un control de los pulsos aplicados.
Podemos clasificarlos en dos grupos:
Unipolares
Bipolares
Servo motores
Los servos se caracterizan por ser capaces de mantener cualquier posicin, dentro de
su intervalo de operacin, en funcin de la seal de entrada.
Para el caso que nos ocupa, quiz lo ms prctico sera utilizarlo

tras haberle quitado los topes y la electrnica encargada de mantener la
posicin, es decir, lo usaremos como un motor de continua, siendo estos
baratos y con buenas prestaciones.
Esto es lo que utiliza por ejemplo el robot HERTRON:
Pgina 22
HERTRON
7. Bateras
La bateras sern la alimentacin de nuestro robot, sin ellas nuestro robot no sera ms
que un amasijo de hierros que no servira para mucho, por eso habr que pensar
detenidamente cual ser el consumo para conseguir que en un futuro no nos encontremos
problemas como que la energa que tenemos no sea la suficiente. No obstante, un gran
inconveniente es el peso de las mismas, por lo que no conviene poner pilas de ms sino solo
las que sean necesarias.
La tabla siguiente enumera algunas de las caractersticas ms tpicas de los tipos ms

populares de bateras:
Alcalinas NiCad NiMH unidad

Voltaje de la clula 1.5 1.2 1.2 voltio
Capacidad 2000 500 1100 mAh
Densidad de la energa 190 44 53 Wh/kg
Resistencia interna 150 10 30 ohm
Cargador ninguno simple difcilmente
Alcalinas: ste tipo se encuentra fcilmente en cualquier tienda y proporciona un

voltaje mayor que las recargables. Como inconveniente tenemos su alta resistencia
interna, por lo que es posible que no puedan proporcionar mucha corriente en
determinados motores.
NiCad: Como inconveniente nos encontramos con que tienen una menor tensin
que las alcalinas, necesitando un mayor numero para alcanzar un voltaje dado. Sin
embargo, por su baja resistencia interna pueden llegar a proporcionar una mayor
corriente a los motores, por esta razn suelen ser comunes en los micromouse de
alto rendimiento.
NiMH: La nica ventaja que encontramos en este tipo de bateras es que,
manteniendo una buena resistencia interna, tienen mayor capacidad de las de NiCad.
Y como inconveniente la dificultad a la hora de cargarlas.
Pgina 23
8. Anlisis de algoritmia
Para abordar un estudio sobre la algoritmia usada en los robots de laberinto, vamos a
hacer una clasificacin basada en si el laberinto es o no conocido.
Algoritmos con laberinto conocido.

Aunque los posibles algoritmos a utilizar dependen del tipo del laberinto y de las
normas de la competicin, en este apartado se van a explicar los ms utilizados en
competiciones de robots. En el caso de que el robot se encuentre en un laberinto y no
conozca su posicin exacta dentro del mismo, conlleva a que necesariamente debe disponer
en memoria de un plano del laberinto, que le indique la situacin de los muros. Tras la
activacin del robot, su primer objetivo ser analizar su entorno recorriendo las casillas
adyacentes. De esta forma, y con la ayuda de los sensores adecuados, podr reconstruir el
laberinto con el fin de comparar ese resultado con el mapa del laberinto en memoria. Este
mtodo es el que us el robot Fribotte/Cnossos en la competicin Hispabot 2004.
Pgina 24
Se puede observar que dicho robot tiene codificado en memoria la situacin de los
muros horizontales y verticales. Adems, a cada celda le asigna un nmero que le indica la
distancia hasta la salida. De esta manera, en el momento que el robot localice su posicin,
deber desplazarse a la casilla con el nmero ms bajo. Este mtodo es muy utilizado, y
aunque existen diversas variantes, todos se basan en la misma idea:
Con los sensores de distancia, el robot puede detectar los muros a una casilla de
distancia en las cuatro direcciones, y memoriza la informacin.
El robot se mueve hasta encontrar una coincidencia con el mapa en memoria

probando todas las posibilidades, en las cuatro posibles direcciones.
Pgina 25
Una vez que ha localizado su situacin, aplicando el algoritmo adecuado, el robot

calcula el camino ms corto hacia el centro (para marcar un gol), y para llegar a la salida.
En este caso el algoritmo utilizado es el de Dijkstra, explicado a continuacin:
Algoritmo de DIJKSTRA:
Para explicar este algoritmo hemos recurrido al siguiente ejemplo:
Cada uno de los puntos es un nodo, que en nuestro caso puede representar un cruce
del laberinto. El nodo de partida es a, y las distintas flechas nos muestran los posibles
caminos para ir de un nodo a otro, con su longitud.
Pgina 26
Los nodos de color rojo son aquellos que podemos alcanzar desde el nodo inicial
a. La distancia desde a a esos nodos es b=4, d=85. De esta forma, b tiene la distancia
mnima al nodo inicial, ya que cualquier otro camino pasar por ms nodos, y por tanto ser
ms largo. A continuacin, b es coloreado de naranja para indicar que es el camino ms
corto.
Ahora las aristas rojas apuntan a los nodos que ya tienen una distancia final. Las
distancia desde a a los siguientes nodos es de c=22, d=85 y e=16. Como e es el camino
ms corto, lo coloreamos de naranja.
Pgina 27
Continuando con el algoritmo, las distancia de a a los siguientes nodos es c=22,

d=82, f=92, h=49. Se observa que la distancia a d ha cambiado de 85 a 82, ya que se ha
encontrado un camino ms corto a travs de los nodos b y e. El nodo c tiene la distancia
ms corta, y por tanto lo coloreamos de naranja.
El algoritmo se repite buscando de nuevo los nodos ms cercanos a a. La distancia

a los siguientes nodos es d=82, f=92, h=49, j=34. El nodo j es el ms cercano, as que lo
coloreamos de naranja.
Pgina 28
En este caso la distancia a los nodos es d=82, f=42, h=49. La distancia a f ha vuelto
ha cambiado, ya que se ha encontrado otro camino ms corto a travs de los nodos b, c, j.
Coloreamos de naranja el nodo f, ya que tiene la distancia ms corta.
Las distancias son d=82, h=49, i=53. El nodo h tiene la distancia ms corta, as que
lo coloreamos de naranja.
Pgina 29
En esta situacin ya tenemos a la vista todos los nodos del ejemplo. Las distancias
son
d=82, g=51, i=53. Coloreamos de naranja el nodo g pues tiene la distancia mnima.
Pgina 30
La distancia al nodo d ha cambiado, ya que se ha encontrado otro camino ms corto

a travs de los nodos b, e, h y g. Las distancias son d=63, i=53. El nodo con la distancia
mnima es i, que coloreamos de naranja.
Por ltimo, solo nos queda el nodo d, con distancia d=63, as que lo coloreamos de
naranja, y por tanto el algoritmo ha finalizado.
Qu hemos conseguido? Pues si queremos llegar a un nodo determinado partiendo

de a, nicamente tendremos que seguir las aristas naranjas y encontraremos el camino ms
corto a ese nodo.
http://alumnos.unican.es/uc900/Algoritmo.htm
Pgina 31
Bsqueda de BREADTH FIRST
Breadth first es un mtodo pensado para ser aplicado en grafos, pero tambin puede
ser utilizado en un laberinto conocindolo a priori ya que el funcionamiento de ambos es
similar. El mtodo breadth first empieza en un nodo X con un valor 0, en los nodos
circundantes se introducira el valor 1 y con los circundantes del 1 el valor 2, as hasta
completar todos los nodos, donde cada nodo se correspondera con una casilla del laberinto.
Paso 1 Paso 2
Paso 3 Paso 4
Paso 5 Paso 6
Paso 7 Paso 8
Paso 9
Pgina 32
Entonces el primero que llegue al nodo de destino ser el camino ms corto y la

solucin a nuestro laberinto. Entonces lo nico que resta es volver siguiendo los nmeros
inmediatamente inferiores para volver a la casilla de inicio.
Las imgenes del BREADTH FIRST se han extrado de:
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/breadth
Search.htm
Algoritmo de BELLMAN-FORD
Es un algoritmo que se utiliz en un principio para el enrutamiento de redes de

datos, el funcionamiento de ste se basa en el tiempo que se tarda de un nodo hasta el
siguiente. As si partimos de un nodo inicial que tendr un valor 0 y queremos dirigirnos
hacia el siguiente, tendremos que ver el tiempo que demora por esa lnea y sumarlo a
nuestro valor inicial que en este caso es 0, entonces si el valor de la lnea es de 7 el nodo
siguiente ser 7 y si la lnea del siguiente nodo al cual nos dirigimos es 3, el valor del
siguiente nodo ser 10.
La diferencia que posee con respecto al mtodo de Dijkstra es que permite valores
negativos en los arcos del grafo, estos valores se colocarn en los arcos si el prximo nodo
dista menos del nodo origen.
(Floyd-Warshal)
www.cs.umu.se
Pgina 33
ALGORITMOS CON EL LABERINTO DESCONOCIDO
Seguir la pared
Un mtodo muy conocido es el de la mano en la pared. Este algoritmo simula el

comportamiento de un humano que resuelve el laberinto colocando su mano en una de las
paredes (derecha o izquierda), y siguindola. Si se quiere, se pueden marcar los sitios por
donde se ha pasado y los que se han visitado dos veces de manera que al final se pueda
resolver el laberinto pasando por los caminos utilizados una sola vez. Es seguro que se
encontrar la salida, a pesar de que la ruta, con mucha probabilidad, no ser la ms corta.
Este procedimiento tambin funciona en el laberinto tradicional, en el que la meta est en el
interior, pero partiendo de la consideracin de que no hay ruta por la que se pueda caminar
alrededor de la meta y regresar a donde se empez. Si la meta est rodeada por uno o ms
de estos circuitos cerrados, el mtodo de la mano en la pared con seguridad lo llevar por
la ruta ms larga y lo sacar del laberinto; nunca podr llevarlo a la "isla" dentro del
circuito.
A los laberintos que no contienen circuitos cerrados, tales como el laberinto que se
muestra en el siguiente dibujo, se les conoce como "simplemente conectados". Esto
equivale a decir que el laberinto no tiene muros separados. Los laberintos con muros
separados s contienen circuitos cerrados, y se les conoce como laberintos de "conexiones
mltiples"; un ejemplo es el siguiente laberinto.
http://www.astrolog.org/labyrnth/algrithm.htm
La tcnica de la mano en la pared, que se usa slo para laberintos "simplemente

conectados", conduce una sola vez en cada direccin a lo largo de cada sendero, as que es
seguro que en algn momento dentro de la ruta, se encontrar la salida.
Pgina 34
SOLUCION
CAMINO RECORRIDO
SIN SALIDA
SIN RECORRER
Llenar caminos
Un algoritmo muy sencillo es el de llenar los caminos sin salida. Solamente es

necesario examinar el laberinto de forma aleatoria y eliminar los caminos que no tengan
salida. Al final slo quedar la solucin, o las soluciones si hay ms de una. Sin embargo,
hay que tener mucho cuidado de utilizar este algoritmo en el laberinto adecuado, ya que
evidentemente, ser totalmente ineficaz en un laberinto que no tenga caminos sin salida. El
otro inconveniente es que, tal y como muestra el ejemplo, el robot tendr que examinar el
laberinto casi en su totalidad, y por tanto no ser adecuado para laberintos muy complejos
que impliquen mucho tiempo de exploracin.
SOLUCION
CAMINO RECORRIDO
SIN SALIDA
SIN RECORRER
Pgina 35
Algoritmo aleatorio
Este algoritmo se basa en moverse al azar, es decir, desplazarse en una direccin y

seguir el pasadizo hasta el siguiente cruce, sin hacer giros de 180 hasta que no sea
necesario. Simula el comportamiento de un ser humano sin memoria y no recuerda por
donde ha pasado, por lo que no garantiza la llegada al final. En contraposicin, es un
algoritmo muy simple.
Algoritmo de la colonia de la hormiga
La optimizacin de la colonia de la hormiga, ACO (Ant Colony Optomization), la

cual se utiliza en los laberintos desconocidos, est basado en el comportamiento que poseen
las hormigas al encontrar una fuente de alimento y encontrar la trayectoria ms corta. Este
comportamiento es el de dejar un rastro de feromonas por el camino as el resto de
hormigas pueden seguir el rastro. El movimiento de una hormiga es aleatorio pero al
detectar que un camino fue atravesado tienden a seguirlo, as que si a una hormiga A
llega antes a la colonia con alimento que la hormiga B estar reforzando las feromonas
(retroalimenta el camino) que marcan el camino de esta forma aumenta la probabilidad para
que las dems hormigas lo atraviesen, provocando un movimiento colectivo general donde
el camino elegido ser el ms corto.
En el Hispabot de 2006, VIRIATO (robot desarrollado en la Universidad de

Salamanca) que fue el ganador de esta edicin utiliz este algoritmo. En esta ocasin el
laberinto era desconocido, por lo que los desarrolladores del robot optaron por
implementarle el algoritmo de la hormiga.
http://www.ucy.ac.cy/~gracm05/PROCS1/10.pdf
Pgina 36
Imagen del robot Viriato.
Gaston Tarry y Edouard Lucas
Gaston Tarry y Edouard Lucas enumeraron una serie de pasos que debemos
implementar para conseguir resolver un laberinto si estamos dentro de l. Cuando entremos
por primera vez en un pasillo hay que dejar 2 marcas en la entrada. Cuando lleguemos a
una estancia, en la salida del pasillo haremos una marca si ya ha sido visto y en el caso de
que no lo hayamos visitado todava dejaremos 3 marcas. Siempre tenemos que elegir el
camino que no haya sido explorado o que posean una marca (que solo se hayan recorrido en
un sentido)
Edouard Lucas en "Recrations mathmatiques" (volumen 1, 1882), habla de una

forma de salir de un laberinto que consiste en que mientras se va andando por uno hay que
ir marcando la pared derecha del laberinto. Si llega a una interseccin se puede tomar
cualquier camino y si regresa a una unin en donde ya ha estado, o llega a un callejn, tiene
que regresar por donde vino. Si se esta yendo por un camino marcado por la parte
izquierda y llega a un cruce ya visitado, tiene que elegir un camino nuevo, en caso de que
no haya ninguno por descubrir pase otra vez por un camino en el que solo haya ido en una
direccin. Lo ms importante es que nunca se ha de dirigir a un camino que este marcado
por ambos lados del pasillo.
Recursividad
Este mtodo se utiliza para resolver un laberinto haciendo uso de la recursividad.

Esto significa que una funcin se llama continuamente hasta que se resuelva el laberinto,
utilizando las siguientes prioridades, izquierda, derecha, arriba y abajo. x0, y0 indican la
posicin de entrada y xf , yf la de salida. Cada casilla puede tener algunos de los siguientes
valores: muro, camino sin visitar y camino visitado
Pgina 37
Funciones utilizadas:
Funcin vlida:
Se le pasa como datos de entrada la fila y la columna hacia donde se dirige y retorna un
valor booleado indicando si la posicin es correcta.
Algoritmo:
resultado vale VERDADERO

si nos hemos salido del laberinto o si a donde vamos hay pared o ya fue visitada
resultado vale FALSO
Funcin recorrer:
Retorna un valor buleano para as ver si se lleg o no al final, esta es la funcin que utiliza
la recursividad para moverse por el laberinto, los datos de entrada es la posicin actual
donde se encuentra y dentro de la funcin se pasa a si misma los valores en X e Y del
siguiente movimiento, marcando cada casilla por donde ha pasado para no retroceder e
intentando moverse primero a izquierdas, derechas, arriba y finalmente abajo pero
asegurndose antes que la casilla donde se mover ser vlida. La condicin de salida de
esta funcin es ver si se lleg a la salida o ver si nos encontramos en un callejn.
Algoritmo:
Si listo vale falso

Se marca la casilla
Si llegamos al final del laberinto
Devolver verdadera
Si no se resolvi el laberinto y la casilla de la izquierda es un movimiento valido

Se llama a recorrer (recursividad) con el valor de la posicin izquierda
Si no se resolvi el laberinto y la casilla de la derecha es un movimiento valido
Pgina 38

Si no se resolvi el laberinto y la casilla de la arriba es un movimiento valido
Si no se resolvi el laberinto y la casilla de la abajo es un movimiento valido
Si no se resolvi el laberinto listo todava vale FALSO

Quitar marca de la casilla
devolver listo con el valor de verdadero o falso
Funcin main:
Encargado de visualizar el laberinto y la solucin y de llamar a la funcin recorrer
Algoritmo:
Se imprime el laberinto sin resolver

Se llama a ala funcin recorrer pasndole ( x0, y0 )
Si no se pudo resolver
Imprimir en pantalla no hay solucin
Si existe una solucin
Se imprime el laberinto resuelto
La recursividad tiene un potencial problema asociado al diseo de microrrobots, y

es que si se implementa en un micro no demasiado potente puede llegar a saturarlo.
Algoritmo de Microtauro
El laberinto se considera como una gran matriz donde cada cuadrante de ste es una
casilla del array, cada pared se considera como un 1 y el lugar por donde no ha pasado el
robot se considera como 4. Cada vez que llega a una interseccin de 4 caminos transforma
el 4 en un 3(que significara que el robot puede pasar hasta 3 veces por esa casilla), cuando
se encuentra en un camino bidireccional lo transforma en un 2 (que significara que el robot
puede pasar hasta 2 veces) cuando se encuentra en un callejn al retroceder va
disminuyendo una unidad cada casilla entonces las casillas que tenan un 2 (ya que es un
pasillo) se transformar en 1, dejando as imposibilitado el paso ya que se tratara ahora de
una pared. Pero el robot no solo descuenta una unidad en los callejones, sino que lo hace a
medida que va avanzando, entonces si antes haba pasado por una casilla que tenan un
valor de 3 al pasar nuevamente, significar que ya solo puedo pasar 2 veces ms. Es decir,
el programa sabe por donde hemos pasado y por donde hay posibilidades de ir.
Pgina 39
El robot intenta dirigirse hacia el nmero ms alto que lo rodea pero en el caso de
que el nmero ms alto se repita, a la hora de elegir intenta ir por defecto a la derecha del
laberinto, ya que all se encuentra la salida, y a la hora de elegir entre ir arriba o abajo, no
teniendo la posibilidad de seguir avanzando hacia la salida, el robot reconoce en que
direccin se encuentra esta, calcula si se encuentra arriba o debajo de l y se dirige hacia
ella.
Por ltimo el robot posee un sistema de descarte de caminos, que consiste

simplemente en que el robot cuando consigue llegar a una pared establece lo que se ha
llamado puntos de anclaje, entonces cuando el robot consigue llegar a una pared diferente
a sta, se establecera otro punto de anclaje, formando una lnea continua que se
corresponder con el movimiento realizado por el robot. Finalmente observa donde se
encuentra la salida, y dependiendo de si esta se encuentra arriba o abajo de nuestra lnea de
anclaje, se proceder a eliminar la parte en la que esta no se encuentre, ya que si el robot se
pudo mover entre esas 2 paredes, la parte eliminada no ser de ayuda a la hora de encontrar
el camino hacia la salida.
Pgina 40
CMO SE CONSIGUE UN CONTROL TAN

PERFECTO?
Para poder competir en una carrera de Micromouse, o en una prueba de laberinto en
general, hay que desarrollar unos buenos mtodos de exploracin, optimizacin del camino
a seguir mediante algoritmos, pero todos hemos visto en videos de competiciones que,
adems de tardar muy poco tiempo en recorrer el laberinto, los robots realizan unos
movimientos muy precisos al girar, al recorrer largos tramos rectos de laberinto, y lo ms
sorprendente, tomar diagonales. Cmo lo consiguen? Para ello se tienen que tener en
cuenta lo siguiente:
Diagonales
Recorrer el circuito en diagonal es una buena forma de ahorrar tiempo, pero tambin
es muy peligrosa. Los competidores expertos suelen estructurar sus diseos de tal forma
que sus robots puedan identificar y realizar tramos en diagonal, disminuyendo la longitud
total del recorrido y evitando as perder tiempo en realizar giros. Dependiendo de las
dimensiones de cada celda, nuestro laberinto tendr un ancho en diagonal determinado, que
en las pruebas de micromouse suele estar entorno a unos 110-130 mm, y por supuesto, el
robot deber ser ms estrecho que dicha longitud. Como es lgico, cuanto ms grande sea
nuestro robot, ms precisos deberemos ser, aunque tampoco interesa que el robot sea
demasiado estrecho, porque podramos tener problemas en curvas a velocidades altas. Por
ejemplo, si circulamos a una alta velocidad y realizamos un giro sobre una de las ruedas
para entrar en la diagonal, corremos el riesgo de que, por inercia, el cuerpo del robot se
desplace hacia uno de los lados. En definitiva: debemos disponer de una tolerancia mnima
que nos permita recorrer sin problemas el tramo de la diagonal, as como permitir pequeos
movimientos en torno a las posiciones calculadas. No es raro que durante la competicin
preliminar, muchos de los robots se choquen contra alguna de las esquinas del circuito.
Pgina 41
www.robots-dreams.com
Los sensores deben realizar trabajo extra en las diagonales. En el caso de usar
sensores laterales, ahora ya no disponemos de una superficie perpendicular de reflexin. La
variacin de distancia al muro es mayor y asimtrica, por lo que no podemos disponer de
informacin simultnea del lado derecho e izquierdo.
Entonces, cmo se consigue? La respuesta es sencilla, a base de probar y probar, y

realizar los ajustes necesarios. Es en este momento cuando aparecen los beneficios de
disponer de mrgenes seguros desde el comienzo del diseo, para despus modificar el
control y poder correr ms o menos riesgos.
En lnea recta
Recorrer largos tramos rectos puede parecer sencillo, pero estamos seguros de que
el dimetro de las ruedas es el mismo (en el caso de usar motores paso a paso) o que los
bucles de control son los adecuados Qu ocurrira si nuestro robot llegase a chocar contra
una pared del laberinto? Para evitar esto, debemos tener en cuenta los distintos tipos de
errores que podemos cometer para poder actuar convenientemente. Corregir dichos errores
ser una labor necesaria para obtener unos buenos resultados. A continuacin se detallan
algunos de esos errores:
ERROR FRONTAL
http://micromouse.cannock.ac.uk/navigation/straights.htm
Pgina 42
Error de distancia frontal: Se produce cuando nuestro robot se encuentra muy cerca
o muy lejos de la pared frontal. Este error es uno de los ms sencillos de corregir, ya que es
muy comn utilizar sensores de posicin que nos permiten realizar la calibracin con
suficiente antelacin. Sin embargo, algunos aspectos como la reflectividad de las distintas
paredes, la direccin e intensidad de la luz ambiental o simplemente la acumulacin de
otros errores, hace que no haya nada establecido sobre este proceso de recalibracin. Segn
[1] utilizar un sensor IR de corto alcance montado en la parte delantera del robot es un
mtodo muy preciso. Hay que tener mucho cuidado con acumular errores de este tipo. En el
peor de los casos, un error frontal de unos 2 cm cada 15 celdas representa un error del
0.7%, que puede ser suficiente para que se produzca una colisin al llegar a una curva. En
algunos casos, aunque no se haya producido colisin, tendremos un error de offset despus
de un giro de 90. En motores paso a paso, un error de ms o menos un paso representa un
error de unos 0.4 mm, que acumulado durante 15 celdas provoca un error de offset de unos
6 mm al realizar un giro. Este error debera ser corregible. En realidad, grandes
correcciones en el error frontal son sntoma de que hemos podido cometer errores graves en
otras partes del sistema de control del robot.
ERROR DE OFFSET
Error de offset: Se produce cuando nos encontramos demasiado cerca o lejos de uno
de los muros laterales, y que aparece tras cometer un error de distancia frontal en un giro.
Para poder corregir este error, ser inevitable acumular un error frontal, ya que
recorreremos un tramo recto del laberinto en diagonal.
Error en la direccin: Se produce cuando el robot, tras tomar una curva, se

encuentra orientado a los muros laterales, y no al centro de la celda. Si el robot est en
marcha, el corregir este error supondra reducir o aumentar la velocidad de una de las
ruedas, aunque no sera apropiado si el robot ya circula a la mxima velocidad, o si va muy
lento. En estos casos sera conveniente realizar el giro pero con el robot parado.
ERROR DE DIRECCIN
Pgina 43
Un ejemplo de robot que corrige su posicin es Fribotte/Cnossos, ya nombrado

anteriormente. Dicho robot conoce su posicin gracias a dos encoders pticos en sus ruedas
y, aunque consigue una gran precisin, hay pequeos errores que pueden aumentar hasta el
desastre. Para evitar esto, el robot dispone de cuatro sensores de distancia. A grandes
rasgos, el robot realiza las siguientes operaciones:
http://fribotte.free.fr/
Las curvas
El giro ms sencillo que puede hacer un robot se basa en hacer girar las ruedas en
sentido opuesto, y de esta manera rotar sobre su centro. Una vez que se tienen calibrados
los motores se pueden realizar giros de 90 y 180 con gran precisin. Los giros de 180
son necesarios cuando encontramos un camino sin salida y el robot no es bidireccional. Hay
que tener mucho cuidado con los momentos de inercia y para ello, sera conveniente
colocar la masa del robot lo ms cerca posible del centro, y si podemos reducir la masa del
robot, mucho mejor. Los sensores de los muros pueden aumentar de forma sorprendente el
momento de inercia en las ecuaciones, segn [1] en trminos de la distancia al centro al
cuadrado. Si se considera el giro sobre una sola rueda, hay que tener en cuenta que una de
las ruedas recorre ms distancia que la otra, y tal vez no sea provechoso en trminos de
velocidad, adems de que los problemas de inercia son peores en este tipo de giro.
Otro de los aspectos que permiten una velocidad alta en los robots de Micromouse
es el modo en el que se trazan las curvas del laberinto.
En un primer punto, vamos a centrar nuestra atencin en los giros de 180, lo cual
nos lleva a pensar en dos estrategias a seguir a la hora de trazarlos, estas estrategias son las
que vienen representadas en el dibujo inferior. Se puede observa que el dibujo de la
izquierda va asociado a un control ms rudimentario mientras que la forma de afrontar la
Pgina 44
curvas segn el dibujo de la derecha presenta un control ms depurado, ofreciendo as

mejores prestaciones.
http://www.robots-dreams.com
Una de las formas de poder mantener una velocidad tan considerable en un robot es
saber si la siguiente casilla a la que el robot va a acceder tiene o no pared. Para ello se va
obteniendo informacin por unos sensores colocados en la parte frontal del robot. Estos
sensores pueden ser de ultrasonidos o luminosos. Los sensores se colocan como se muestra
en la figura siguiente:
Primeramente podemos ver que hay un sensor que apunta directamente hacia al
frente. Este sensor es, intuitivamente, sencillo de entender. Est colocado para poder
detectar posibles paredes situadas en celdas adyacentes. Esta estrategia de diseo hace tener
que obviar muchos posibles errores en la informacin enviada por los sensores, lo que hace
trabajar de forma aproximada.
Pgina 45
En esta segunda imagen vemos como se comportan los sensores colocados de forma
oblicua. En un primer momento se puede llegar a pensar que la colocacin de los sensores
de esta forma es un poco intil, pero posicionando los 2 emisores con el mismo ngulo
permiten, como se puede observar en la figura, que el ngulo de incidencia y el de reflexin
es el mismo, y as poder conseguir tener informacin sobre paredes laterales en celdas
adyacentes.
De la experiencia de los distintos competidores de Micromouse, se llega a la
conclusin de que el ngulo ptimo para posicionar los sensores, no es de 45 sino un
ngulo algo menor.
Pgina 46
9. Simuladores
En relacin al apartado de simulacin, tras realizar una bsqueda por diferentes
sitios dentro de la Red que podemos hacer uso de diferentes herramientas para poder probar
los distintos algoritmos, es decir, existen soluciones comerciales para responder a tal
necesidad.
Por el contrario, podemos utilizar programas comerciales con el fin de simular el

comportamiento de nuestro robot. Un ejemplo es el programa Matlab. Gracias a que
incorpora la Fuzzy Logic Toolbox, Matlab nos permite disear un controlador borroso para
nuestro robot. A continuacin mostraremos un ejemplo.
El laberinto consiste en un mapa de bits blancos y negros, donde los bits negros
representan las paredes. El robot deber desplazarse continuamente por el laberinto sin
chocarse con las paredes, utilizando para ello dos sensores de distancia colocados a +45 y -
45 con respecto a su eje longitudinal.
Pgina 47
En este ejemplo no se ha utilizado el entorno Simulink de Matlab, sino que se ha

realizado directamente a partir de funciones (archivos.m): una funcin gestiona la
informacin de los sensores, otras dos se encargan del movimiento del robot y de su
representacin sobre el mapa, y por ltimo se encuentra la funcin principal que llama al
resto de funciones. El controlador tiene como entradas las distancias detectadas por los
sensores (distancia hasta el primer pxel negro) y como salidas la velocidad angular y lineal
del robot.
El resultado de la simulacin es el siguiente:
Pero cada desarrollador de microrrobots, adems de poder usar soluciones como las
que se ofertan en MATLAB, se puede realizar su propio simulador mediante cualquier
herramienta de desarrollo, como puede ser el lenguaje C, JAVA, etc. En este trabajo se va a
proponer un posible simulador, implementada en lenguaje C, probndose sobre l, dos de
los algoritmos arriba explicados.
Simulamos los 2 mtodos que nos han parecido los ms destacados pos su sencillez
y eficacia:
El primero es el mtodo de tirar a derechas, este algoritmo es fcil de aplicar, ya

que en su algoritmo solo hay que poner una serie de prioridades que seran: primero tirar a
derechas, en caso contrario, seguir recto, despus tirar a la izquierda, y por ultimo ir hacia
atrs. Con este algoritmo tenemos la certeza de que encontrar la salida.
Pgina 48
El segundo que simulamos fue el de BREADTH FIRST, utilizado en laberintos

conocidos. En la simulacin lo nico que no se puede apreciar son los nodos superiores a 9,
ya que al ser nmeros de 2 cifras necesitan 2 casilleros para representarse. Para utilizar el
algoritmo tenemos que colocar un 1 en la entrada, para as indicarle el comienzo de la
cuenta. Una vez colocado, el programa recorrer el laberinto buscando el nmero 1 y
colocando un 2 (nmero superior al que buscamos) alrededor de este, antes de colocarlo, se
tomar en cuenta si en donde se ubicar existe una pared o ya hay un nmero asignado a
esa casilla, en este caso, no se escribir ningn nmero. Luego se buscar el 2, el 3
etc.;hasta que en la casilla de salida, que est en blanco, se escriba un nmero. Una vez
escrito el nmero en la casilla de salida, el programa empieza a contar hacia atrs hasta
llegar al nmero 1 que se corresponde con el inicio. Mientras se cuenta, se van marcando
las casillas por las que pasa, formando as el camino solucin.
Pgina 49
10. Consideraciones a tener en cuenta a la hora del

diseo:
Para comenzar el diseo de nuestro robot de laberinto es necesario plantearse ciertas
preguntas que nos facilitaran el diseo de nuestro robot. Estas preguntas son:
Cules son las normas del concurso en el que queremos participar?

Cunto presupuesto tenemos?
Qu material podemos reciclar?
Cunto tiempo tenemos?
Cul es nuestra meta?
En nuestro caso las respuestas a estas preguntas no son del todo reales, ya que hemos
creado nuestra propia competicin a la que ajustar el robot. An as las respuestas son las
siguientes:
Viendo la normativa podemos ver como partes importantes que:

1. Las medidas no pueden exceder los 25x25.
2. el objetivo principal es salir del laberinto.
3. El laberinto es conocido a priori pero no la posicin de partida.
4. Se conseguir bonificacin si pinchamos algn globo.
En nuestro caso el presupuesto no queramos que excediese los 100.
Con mucho ahnco hemos conseguido unos motores sacados de unas
disqueteras de 5.25, tambin disponemos de un micro-controlador que
tenemos de una prctica de aos anteriores.
Tiempo no tenamos el suficiente como para llegar con el robot montado y
funcionando, adems de tener ciertos problemas tcnicos lo cual nos ha hecho
no poder traer el modelo pensado inicialmente.
Nuestra meta es poder presentarnos en la siguiente edicin de Alcabot.
Una vez tenemos una base sobre la que poder trabajar debemos empezar a idear una
algoritmia, en nuestro caso y debido a la reutilizacin del microcontrolador debemos saber
que tenemos ciertos limites impuestos a priori. Una vez decidida la algoritmia, tendremos
que establecer los bloques necesarios para aportar datos suficientes al algoritmo, segn
sabemos los sensores que necesitamos realizamos una estructura inicial del robot que
permita manejar dichos sensores con un mnimo de garantas, es decir, que los pulsadores
estn colocados de forma estratgica o que los sensores de distancia estn dentro de su
margen de actuacin sin que se les impida en ningn momento su visin.
Pgina 50
11. Algoritmo para salir del laberinto:

Debido a la naturaleza de la prueba el problema que se nos plantea es conseguir salir
de un laberinto que sabemos conocido, desde una posicin de partida desconocida y con
orientacin aleatoria dentro de la casilla de salida, para ello lo que vamos a intentar es
conocer nuestra posicin dentro del laberinto, para ello nos iremos moviendo por el
laberinto y almacenando la posicin de las paredes de las distintas celdas por las que hemos
pasado.
Dicho as parece una tarea no demasiado complicada, pero debido al problema de que
la salida no es conocida se nos plantean dos problemas:
Dnde estamos?
Hacia dnde vamos?
Estas preguntas suenan un poco existenciales, pero realmente es un problema a la hora

de que el robot sea capaz de encontrar la salida ya que al no tener una entrada y una salida
los posibles caminos para salir dependen de donde nos encontremos en el momento en el
que nos hemos posicionado dentro del laberinto.
Para almacenar tanto el laberinto inicial como los datos recopilados en el laberinto
usaremos matrices bidimensionales.
Debido a que la orientacin inicial no es conocida vamos a encontrar el problema de

que el laberinto conocido no ser nico desde el punto de vista del robot, viendo la
siguiente imagen ser mucho ms fcil comprenderlo:
Pgina 51
Como podemos observar en la imagen anterior el robot no sabe hacia donde est
mirando, es por esto que almacenamos el laberinto con sus cuatro posibles orientaciones:
Debido a lo anterior tendremos 4 formatos de laberinto e intentaremos ir buscando

coincidencias en cada uno de ellos hasta conseguir ubicarnos nicamente en uno de ellos.
Pgina 52
Una vez resuelto el problema de la orientacin nos queda por solucionar el problema
de la casilla de salida. Debido a que el laberinto esta formado por un campo de 9 celdas por
9 celdas lo mximo que podemos movernos hacia un lado u otro son 8 celdas, y debido a
que no queremos perder informacin haremos una matriz de 17 celdas por 17 celdas para
as aun saliendo desde una esquina podamos almacenar todos los datos en nuestra matriz
sin perder ningn valor, para ello empezaremos a guardar los datos desde el centro de la
matriz de datos:
Cada color representa el peor caso dependiendo de la orientacin de la salida y

suponiendo que partimos desde alguna de las esquinas, con ese grfico demostramos que en
el peor de los casos conseguimos almacenar todos los datos. En los casos no tan extremos
nos encontraremos dentro de esa tabla sin llegar a las esquinas de la matriz. Debemos
Pgina 53
destacar que la celda central siempre es comn a cualquiera de los casos as que nuestra
bsqueda siempre partir desde la celda central.
El problema que se nos presenta en este caso es el uso de memoria RAM necesaria
para poder implementar el algoritmo.
Los mapas conocidos a priori se almacenarn siempre en memoria no voltil, de
forma que as siempre estarn disponibles y no ocuparan memoria RAM, es por esto que
necesitaremos nicamente memoria para la matriz de adquisicin de datos, esto implica un
tamao de memoria mnimo de 289 bytes disponibles en la memoria RAM.
Inicialmente las casillas tendrn el valor 0xFF para as poder diferenciar las que se
han recorrido y las que no. Cada byte tendr la siguiente estructura, vlida tanto para los
laberintos grabados inicialmente en ROM como para el que est en RAM:
BIT 7 BIT 6 BIT 5 BIT 4 BIT 3 BIT 2 BIT 1 BIT 0

Posicin de paredes 0-15 Distancia a la salida 0-15
Tabla de posicin de paredes:
Paredes referenciadas con el mapa hacia arriba BIT 7 BIT 6 BIT 5 BIT 6
Sin paredes 0 0 0 0
Pared abajo 0 0 0 1
Pared arriba 0 0 1 0
Pared izquierda 0 1 0 0
Pared derecha 1 0 0 0
Pared abajo y arriba 0 0 1 1
Pared arriba, izquierda, derecha 1 1 1 0
... ...
El algoritmo a seguir es bastante intuitivo, una vez que sabemos en que posicin
estamos lo nico que falta es encontrar un camino mnimo hasta la salida. Para ello
tendremos en cuenta el nmero de casillas hasta la salida, es decir, equivale a usar un mapa
en cualquier ciudad.
La informacin necesaria para salir, la buscaremos en los bytes de las casillas,

guiaremos el camino dndole valores a cada casilla, cuanto ms lejos esta la salida mayor
ser el nmero asignado, de esta forma el robot lo que tiene que hacer es ir hacia la casilla
que tenga un valor menor. A continuacin mostramos un ejemplo segn el mapa que
estamos usando en esta presentacin.
Pgina 54
De esta forma en cuanto sepamos donde estamos solo tenemos que consultar las
casillas que nos rodean y seleccionar la apropiada, pudiendo haber caminos que tengan la
misma distancia hacia la salida. Bien es cierto que en la figura anterior quizs fuese mejor ir
por el camino verde ya que tiene menos giros, en este caso si queremos que solo vaya por el
verde lo nico que deberamos hacer es cambiar el nombre la casilla que inicia el camino
rojo por una de mayor valor, de esta manera evitamos que seleccione ese camino.
Debido a la limitacin que tenemos en la memoria (lo que nos lleva a usar variables
tipo char y no tipo int) no podemos pasar de una distancia 15 la salida, esto nos hace andar
a ciegas durante unas cuantas casillas hasta encontrar casillas con valor menor a 15, en caso
de querer evitar esto deberamos usar variables de tipo int, por lo que necesariamente
tendramos que cambiar de microcontrolador. Como alternativa para no cambiar el micro
controlador es guardar en memoria ROM un mapa con valores y un mapa con las paredes.
Una vez adquirimos los datos debemos encontrar en que matriz la direccin del mapa
en la que estamos y con que orientacin nos encontramos, para ello la idea inicial que
tenemos es empezar a buscar comparando los datos que tenemos por filas, inicialmente
empezaremos a buscar por la casilla central de los datos recogidos tal y como se ha dicho
anteriormente, ya que es la nica celda que tenemos en comn, segn avancemos por el
laberinto iremos recopilando ms datos lo que nos lleva a descartar mapa por mapa y
encontrarnos. Para saber la direccin en la que estamos mirando llevaremos un historial de
los ndices de la matriz de las ltimas celdas recorridas sabiendo de donde venimos, si
aadimos a esto el nmero de giros dados sabemos hacia donde miramos.
Pgina 55
12. Descripcin de estructura y hardware del robot

Para poder ubicarse dentro del laberinto nuestro robot necesita un sistema sensorial no
demasiado complicado, para ello hemos decidido usar sensores de distancia mediante
infrarrojos as como un bumper para detectar el contacto frontal del robot contra el globo.
Nuestro robot sigue el diagrama de bloques mostrado a continuacin:
Pgina 56
El cerebro
Todo robot que tiene que tomar decisiones de forma autnoma necesita un cerebro,
en este caso y por el motivo de aprovechar lo que tenemos hemos decidido usar un
68HC08 que reutilizamos de la prctica del laboratorio de SED de Ingeniera de
Telecomunicacin. Esto nos aporta la ventaja de que al menos alguno de los integrantes
del grupo conoce las herramientas de trabajo.
El uso de este micro no es debido nicamente al ahorro de coste, ya que si no

cumpliese ciertas necesidades este no sera til. Podemos destacar las siguientes
caractersticas tcnicas del microcontrolador:
Microcontrolador de 8 bits
32Kbytes de memoria FLASH
512 bytes de memoria RAM
Velocidad de bus de hasta 8MHz
2 Timers de 16bits
ADC de 8 bits con 8 canales
Admite tanto lenguaje C como lenguaje Ensamblador
Hemos destacado estas caractersticas porque nos resulta necesario el tener un ADC
con una resolucin aceptable y al menos un temporizador.
Debido a la tarjeta de desarrollo tenemos un pequeo impedimento en el ADC, esto es

que el margen dinmico viene fijado entre 0 y 5 voltios
Pgina 57
El sistema sensorial
Para saber en que posicin estamos en cada momento solo necesitamos tener 3
sensores de distancia, colocados de forma que sepamos la distancia hacia el frente,
derecha e izquierda. Con el fin de mejorar el posicionamiento de nuestro robot le
incluimos uno en la parte trasera.
Usamos como sensores de distancia unos GP2D12. Como ya sabemos son sensores de
distancia mediante infrarrojos, la medida que nos aporta estos sensores es una tensin
analgica con un rango de valores de 0.4V a 2.6V.
Con el fin de obtener una mejor resolucin usaremos un circuito que adapte la seal
de manera que amplificaremos de 2.6V a 5V, esto nos da una ganancia de 1.9. En el caso
de querer tener todava ms resolucin, la solucin es tan sencilla como bajar los 0.4V a 0
y luego amplificar
El problema que nos dan estos dispositivos es que distancias menores de 10cm las
medidas no son vlidas. Este inconveniente se tiene en cuenta ya en el diseo de la
estructura.
A los sensores de distancia se les suma un bumper delantero que nos indicara cuando
hemos pinchado un globo.
Los actuadotes
Obviamente necesitamos algn mecanismo que nos permita movernos por el
laberinto, para ello hemos credo conveniente utilizar motores paso a paso, ya que de esta
forma tenemos un control sobre el nmero de vueltas que llevamos dadas, as como giros
parciales con una gran exactitud.
Pgina 58
Para llevar un control sobre la velocidad y el nmero de vueltas de los motores

utilizamos el temporizador del microcontrolador. Concretamente usaremos la interrupcin
de overflow, de esta forma cambiando el valor de la referencia de desbordamiento
podemos crear rampas de aceleracin evitando as la posible prdida de traccin debida a
un arranque brusco de los motores.
Para el acondicionamiento de los motores con el micro hemos utilizados el driver

ULN2003 es cual es un circuito integrado compuesto por una serie de componentes tipo
Darligton. La conexin de acondicionamiento es la siguiente:
Estructura fsica
Nuestra idea es realizar una base con forma elptica con el fin de tener suficiente
espacio, evitar esquinas y poder contener las ruedas dentro del permetro de la base,
Pgina 59
evitando as posibles roces con las paredes que podran hacer que el robot pasease a ser
un robot de escalada, llegando a volcar.
Las ruedas se realizarn con Cds ya que conseguimos un permetro suficientemente

grande, avanzando mucho con pocas vueltas lo que tambin aumenta la velocidad.
Los sensores los hemos colocado estratgicamente para poder conocer la posicin de
las paredes as como la posicin dentro de la celda. Adems en la parte frontal se han
colocado dos sensores, uno ms elevado que otro, el fin de colocar los sensores con esta
configuracin es detectar el globo. En la siguiente figura se demuestra el porque:
Como podemos observar la distancia que ve el sensor superior hacia el globo es

bastante menor que del sensor inferior, esto nos indicara que tenemos un globo delante
por lo que procederamos a pincharlo.
El resto de sensores se colocan formando un ngulo de 90 para ver todas las paredes
que nos rodean.
Con esta posicin de los sensores sabemos en cada momento la distancia en cada
pared, lo que nos indica si estamos posicionados correctamente dentro de la celda, as
podemos conseguir rectificar pequeos errores en el movimiento
Pgina 60
13. Catia.
Para disear el robot nos hemos ayudado del programa Catia, que nos permite realizar
un modelo en 3D, con todo tipo de medidas. Con ello conseguimos saber las cualidades que
va a tener nuestro robot antes de construirlo fsicamente.
Introduccin a Catia.
Catia tiene distintos mdulos, cada uno enfocados a distintos aspectos del diseo. Se
comienza con la generacin de figuras 2D(Sketcher), se crean slidos (Part Desing) y
finalmente se ensamblan(Assembly).
Hay otros muchos ms mdulos que permiten hacer un estudio fsico del producto
realizado, que dan datos sobre costes o precios y hasta pruebas de resistencia.
Debido a que el entorno de Catia era desconocido para todos nosotros, nos hemos
centrado en el modulo de diseo mecnico (Mecanical Desing).
Sketcher.
La base de todo diseo se realiza con esta herramienta. Su funcin es crear unos
planos 2D, que luego podremos dar volumen con la herramienta Part Desing.
Se pueden hacer todo tipo de formas (rectngulos, crculos, elipses, formas libres),
que luego se deben acotar implantando unas constraint. Las constraint son las medidas
de la figura 2d realizada. Es muy importante dar medidas correctas para que luego en el
ensamblado todo siga una misma escala.
Pgina 61
Part Desing
Una vez que tenemos el plano 2D definido, hay que darle volumen. Con el Part
Desing podemos darle volumen, hacer agujeros a un volumen ya creado, rotar una pieza
para formar un volumen de revolucin, hacer contornos
El desarrollo de todas las piezas se hace dentro de Part Desing, entrando en el

Sketcher siempre que se necesite un nuevo volumen; para ello solo hace falta elegir el plano
donde se dibujara la figura 2D.
El gran potencial de esta herramienta es la posibilidad de hacer todo tipo de

volmenes, sin excepcin, a base de figuras simples. Podemos realizar operaciones
booleanas entre piezas para conseguir nuevos volmenes.
No hay que olvidar que hay que seguir dando las medidas de la pieza que queremos
realizar, incorporando todas las constraints necesarias.
Pgina 62
En las primeras sesiones de uso de Catia, moverse entre volmenes es complicado, y

tener una visin espacial de la pieza es importante. Saber que volumen hay que definir,
donde hay que agujerear, que plano es cada uno es la base del desarrollo de piezas.
Hay veces que se necesitan volmenes que son iguales a otros ya creados, para no
volver a realizarlos nos ayudamos de herramientas de simetra, que mueven lo que hay
respecto a un eje de simetra (que define el usuario). Con ellos conseguimos piezas iguales
y simtricas.
Assembly Dessing
Herramienta en donde se unen todas las partes ya creadas. El desarrollo del
ensamblado debe ser ordenado y estructurado por sub-partes, es decir, no se debe intentar
montar todo el conjunto a la vez.
Una vez que aadimos al producto nuevo una de las partes ya hechas en el Part
Desing hay que ir agregando nuevas partes e irlas colocando. Para ello esta herramienta nos
presenta funciones para el movimiento en el espacio de las piezas y el asignamiento de
nuevas constraints.
Definir constraints en esta parte del ensamblado es muy importante. Aqu se definen
los mrgenes del producto creado. Seguir paralelismos, unir caras, unir ejes poco a poco
hacen que se cree un producto ordenado y exacto.
La exactitud es la principal caracterstica que nos brinca Catia, por lo que hay que
explotarla al mximo definiendo toda constraint que veamos necesaria.
El ensamblado final de los sub-ensamblados hay que realizarlo con especial cuidado,
uniendo todas las caras, siguiendo paralelismo(o perpendicularidades), siguiendo medidas,
etc. La precisin es importantsima, una pieza mal colocada o mal diseada nos puede
chocar con otro volumen. Catia da la posibilidad de ver todas las intersecciones de
piezas, con lo que podremos arreglar posibles fallos.
Diseo de nuestro robot.

Para el diseo de nuestro robot comenzamos con un boceto a mano alzada en una
hoja. La base de las ideas estaba ya realizada, faltaba manejar el Catia.
Primero se realizaron las primeras piezas simples (la base, los cds, los GP2D12).
En estos primeros pasos en el Sketcher y en el Part Desing se toma un primer contacto con
las herramientas, que hace que se coja soltura poco a poco.
En cada una de las partes creadas se ha utilizado una forma de dar volumen. No hay una
sola forma de crear una pieza. Por ejemplo, un cilindro puede hacerse como un rectngulo
Pgina 63
girado 360 sobre uno de sus lados o como una circunferencia a la que se le da volumen
vertical (u horizontal). De ah la gran posibilidad de diseos de piezas y figuras.
El ensamblado es una parte extremadamente compleja y debe realizarse paso a paso.

Una vez que se tenan todas las piezas simples, se hace un pre-ensamblado de piezas. Por
ejemplo, los cds se unen o se pone el soporte al motor. A su vez estas piezas compuestas se
vuelven a ensamblar con otras. El ensamblado recursivo nos hace tener un orden de
ensamblado, que hace que el conjunto est ordenado.
El ensamblado final requiere que todos los sub-ensamblados esten correctos. Si es

as, es muy sencillo, ya que todas las medidas han sido previstas y encaja todo. En cuanto
una medida es errnea, el montaje puede dar fallos como la superposicin de piezas.
Los posibles errores se pueden corregir directamente en las piezas simples, y al

guardarlas se actualizar directamente en los conjuntos de piezas.
Esta estructuracin permite simplificar el diseo, que an as es complicado.
Desarrollo por partes del diseo.
Base del robot.
La base sigue una forma elptica, siguiendo los conceptos de estructuras estudiados.
Con esta forma conseguimos hacer los giros con mayor facilidad y evitar atascos con las
paredes. Las ruedas se incluyen dentro del permetro de la elipse base, para que no choquen
directamente contra la pared en caso de haber perdido la referencia. A continuacin se
muestran sus planos:
GP2D12.
Los sensores es una parte fundamental del robot. Se han diseado en catia siguiendo
las medidas de la hoja de caractersticas.
Pgina 64
Placa
Es el cerebro de nuestro robot. Se ha diseado siguiendo las medidas de la placa
original. Con ello conseguimos saber perfectamente donde puede ser ensamblada y su
posicin ideal dentro del conjunto del robot.
Motor paso a paso.

Es el elemento que hace que se mueva el robot. Se hizo un primer modelo de motor
genrico, al que se le agreg el tipo de soporte una vez que se supo de cual se dispona.
Gracias al diseo en Catia, podemos calcular la medida de distancia que debe tener con el
Pgina 65
suelo para que las ruedas locas y los cds toquen el suelo sin perder la horizontalidad de la
base.
Bumper
Dispositivo que gracias a l sabremos si se a explotado el globo por contacto.
CD
Los cds nos servirn como ruedas de nuestro robot.
Pgina 66
Aguja.
Elemento punzante que explotara el globo al contacto. Sencilla manera, pero
efectiva, de explotar los globos.
Sub-ensamblaje
El motor y los cds es una parte esencial que debe estar perfectamente alineada para
que el robot se mueva en linea recta. Para conseguir una mayor perfeccion y que el motor
izquerido tenga las mismas medidas que el derecho se ensamblo como un subconjunto, que
luego se unir al robot por duplicado. As se consigue un perfecto alineamiento.
Pgina 67
Montaje completo
El montaje completo da una perfecta idea del robot a construir. Se ven todas las
piezas perfectamente definidas y su situacin dentro del conjunto.
Pgina 68
Pgina 69
14. Montaje real del robot:

Pensamos que para la prctica nos iba a ser de gran ayuda el montaje de un robot de
laberinto, por eso, aun teniendo poco tiempo, decidimos disearlo intentando que al
menos funcionase su sistema sensorial y motriz.
El primer paso que realizamos fue centrarnos en el funcionamiento software del

sistema, para ello utilizamos el CodeWarrior y como lenguaje de programacin
utilizamos C.
Nuestro primer objetivo era que se moviesen los motores. Al utilizar motores paso a
paso necesitamos llevar una cuenta de los pasos dados, y controlando el tiempo entre
pasos podemos saber la velocidad. Entonces utilizamos uno de los Timer que tenemos, lo
configuramos para que interrumpa cada 3.33ms, de manera que configuramos el sistema
para dar un paso cada 6.66 ms.
Los sensores de distancia los muestreamos cada 100 pasos (cada media vuelta) de
forma continua. As tenemos referencias de todas las paredes cada poca distancia.
Para que nosotros podamos ver los datos hemos instalado un LCD de 4 lneas que nos
muestra los datos ofrecidos por los GP2 y el nmero de vueltas que han dado los motores
paso a paso.
A continuacin mostramos el cdigo implementado:
#include <hidef.h> /* for EnableInterrupts macro */

#include <MC68HC908GP32.h> /* include peripheral declarations */
#define ALANTE 0
#define ATRAS 1
#define DERECH 2
#define IZQUIERD 3
#define ARRIBA 4
#define ABAJO 5
#define SI 0
#define NO 1
#define LCDport PTC

#define RS PTB_PTB7
#define E PTB_PTB6
#define DelayTime 10
#define DATOS 1
#define CONTROL 0
#define ON 1
#define OFF 0
void configTBM(void);
void configADC(void);
Pgina 70
void LCDdelay(void);
void Ctrl8bits(unsigned char codigo);
void Ctrl4bits(unsigned char codigo);
void Datos4bits(unsigned char dato);
void Config_LCD_4bits(void);
void printf_LCD_4bits(unsigned char fila, unsigned char columna, char *texto);
void convertir1 (unsigned char hexa);
char donde=ALANTE,moverse=SI,leer=ARRIBA,derecha=0,izquierda=0,arriba=0,abajo=0,atras=0;
unsigned char transformado1=48, transformado2=48, transformado3=48;
char pasos=0,vueltas=0,datosestables=NO;
void main(void) {
/* include your code here */
DDRA=0xFF; //Configuramos todo de salida

DDRB=0x00; //configuramos los PTB como entrada
DDRB_DDRB6=1;
DDRB_DDRB7=1;
DDRC=0xFF;
DisableInterrupts;
CONFIG1_COPD=1;
Config_LCD_4bits();
configTBM();
configADC();
EnableInterrupts; /* enable interrupts */

CONFIG1=0;
for(;;) {
__RESET_WATCHDOG(); /* kicks the dog */
if(pasos>=200){
vueltas++;
pasos=0;
}
printf_LCD_4bits(1,1,"Pas:");
convertir1(pasos);
Datos4bits(transformado3);
printf_LCD_4bits(1,9,"Vuelt:");
convertir1(vueltas);
printf_LCD_4bits(2,1,"Der:");
convertir1(derecha);
printf_LCD_4bits(2,9,"Izq:");
convertir1(izquierda);
printf_LCD_4bits(3,1,"Arr:");
convertir1(arriba);
printf_LCD_4bits(3,9,"Abj");
convertir1(abajo);
Pgina 71
printf_LCD_4bits(4,1,"Atr:");
convertir1(atras);
} /* loop forever */
}
void configTBM(void){
TBCR_TBR=0; //prescaler para 3.33333ms

TBCR_TBIE=1;
TBCR_TBON=1;
}
void configADC(void){
ADCLK_ADIV=3;//preescaler a 8
ADCLK_ADICLK=0; //coje reloj externo
ADSCR=0b01100000;//inicialmente mira el canal0
}
interrupt 16 void conversionADC(void){
static unsigned char cont=1;
if(leer==DERECH){
derecha=ADR;//derecha+ADR;
ADSCR=0b01100001;
leer=IZQUIERD;
}
else if (leer==IZQUIERD){
izquierda=ADR;
ADSCR=0b01100010;
leer=ARRIBA;
}
else if (leer==ARRIBA){
arriba=ADR;
ADSCR=0b01100011;
leer=ABAJO;
}
else if (leer==ABAJO){
abajo=ADR;
ADSCR=0b01100100;
leer=ATRAS;
}
else if (leer==ATRAS){
atras=ADR;
ADSCR=0;
/*if(cont<=3){
cont=1;
datosestables=SI;
atras=atras/3; //hacemos la media de 3 muestras para que sean
mas estables
abajo=abajo/3;
arriba=arriba/3;
izquierda=izquierda/3;
derecha=derecha/3;
}
else {
ADSCR=0b01000000;
Pgina 72
leer=DERECH;
}*/
}
interrupt 17 void time_base(void){
static char paso=0;

static unsigned char cuenta=0;
TBCR_TACK=1; //Borrar flag
cuenta++;
if(cuenta>=2){ //2*3.33ms=6ms
cuenta=0;
if(moverse==SI){
pasos++;
paso++;
if(donde==ALANTE){
if(paso==1)
PTA=0x33; // OFF OFF ON ON
else if(paso==2)
PTA=0x66; // OFF ON ON OFF
else if(paso==3)
PTA=0xCC; // ON ON OFF OFF
else if(paso==4){
PTA=0x99; // ON OFF OFF ON
paso=0;
}
}
else if(donde==ATRAS){
if (paso==1)
PTA=0x33;
else if (paso==2)
PTA=0x99;
else if (paso==3)
PTA=0xCC;
else if (paso==4){
PTA=0x66;
paso=0;
}
}
else if(donde==DERECH){ //PARTE ALTA LA RUEDA DERECHA
if(paso==1)
PTA=0x33;
else if(paso==2)
PTA=0x96;
else if(paso==3)
PTA=0xCC;
else if(paso==4){
PTA=0x69;
paso=0;
}
}
else if(donde==IZQUIERD){//PARTE BAJOA RUEDA IZQUIERDA
if(paso==1)
PTA=0x33;
else if(paso==2)
PTA=0x69;
else if(paso==3)
PTA=0xCC;
else if(paso==4){
PTA=0x96;
paso=0;
}
Pgina 73
}
}
}
if(pasos>=100){
leer=DERECH;
datosestables=NO;
ADSCR=0b01100000;
/* derecha=0;
izquierda=0;
arriba=0;
abajo=0;
atras=0;*/
//ADSCR=0b01000001;
}
}
///////////////////////////////////LCD/////////////////////////////////////////////////////
void convertir1 (unsigned char hexa){

//utilizamos esta funci ara imprimir datos en el LCD
//este convertir vale para transformar numeros de HEXA a DECIMAL y poder imprimirlos
if(hexa<=99){
transformado2=(hexa/0x0A)+48;//calculamos la decena con el cociente
transformado1=(hexa%0x0A)+48;//calculamos la unidad con el resto
transformado3=48; //Dejamos la centena como 0
}
else{
transformado1=(hexa%0x0A)+48;//calculamos unidades
transformado2=(hexa/0x0A);
transformado3=(transformado2/0x0A)+48; //calculamos centenas
transformado2=(transformado2%0x0A)+48; //calculamos decenas
}
}
void LCDdelay(void)
{
unsigned int j;
for(j=0;j<DelayTime;j++); // t > 40us (Tiempo de ocupaci el LCD)
}
void Ctrl8bits(unsigned char codigo)

{
LCDport = ((LCDport & 0xF0) | (codigo >> 4)); // Si est onectado a la
parte baja del puerto PTx[0:3]
RS = CONTROL;
E = ON;
E = OFF;
RS = CONTROL;
LCDdelay();
}
void Ctrl4bits(unsigned char codigo)

{
/* Trasmito el nibble alto. */
LCDport = ((LCDport & 0xF0) | (codigo >> 4)); // Si est onectado a la parte
baja del puerto PTx[0:3]
RS = CONTROL;
E = ON;
E = OFF;
Pgina 74
LCDdelay();
/* Trasmito el nibble bajo. */
LCDport = ((LCDport & 0xF0) | (codigo & 0x0F));//Si est onectado a la parte
RS = CONTROL;
E = ON;
E = OFF;
LCDdelay();
}
void Datos4bits(unsigned char dato)

{
/* Trasmito el nibble alto. */
LCDport = ((LCDport & 0xF0) | (dato >> 4)); // Si est onectado a la parte
RS = DATOS;
E = ON;
E = OFF;
LCDdelay();
/* Trasmito el nibble bajo. */
LCDport = ((LCDport & 0xF0) | (dato & 0x0F)); // Si est onectado a la parte
RS = DATOS;
E = ON;
E = OFF;
LCDdelay();
}
void Config_LCD_4bits(void)
{
unsigned int cnt;
RS = 0;
E = 0;
for(cnt=0;cnt<4000;cnt++); // Espera m de 15 ms. --> Arranque del display (Despude

alimentar).
Ctrl8bits(0x30); // FunctionSet, interface a 8 bits.

for(cnt=0;cnt<1000;cnt++); // Espera mas de 4.1 ms.
Ctrl8bits(0x30); // FunctionSet, interface a 8 bits.

for(cnt=0;cnt<100;cnt++); // Espera mas de 100 us.
Ctrl8bits(0x30); // FunctionSet, interface a 8

bits.
Ctrl8bits(0x20); // FunctionSet, a partir de

aqu aso a 4 bits.
Ctrl4bits(0x28); // FunctionSet: Interface 4

bits,
//
Ctrl4bits(0x08); // Display Off.

Ctrl4bits(0x01); // Display Clear.
Pgina 75
for(cnt=0;cnt<500;cnt++); // El borrado del display tarda 1.52 ms.
Ctrl4bits(0x06); // Set Entry mode: Incrementar

cursor y no desplazar.
Ctrl4bits(0x0C); // Display on, cursor inactivo y
sin parpadear.
void printf_LCD_4bits(unsigned char fila, unsigned char columna, char *texto)

{
unsigned char adrs;
/* Si estamos en la primera fila la direccion de memoria es igual al

de la columna menos uno...*/
adrs = columna - 1;
/* ...si estamos en la segunda fila hay que sumarle 0x40. */
if(fila == 2)
adrs = adrs | 0x40;
if(fila==3)
adrs = adrs | 0x94;
if(fila==4)
adrs =adrs | 0xD4;
/* El codigo a mandar es el de la direccion con el bit D7 a uno. */
Ctrl4bits(adrs | 0x80);
/* ... y escribimos el texto normalmente. */
while(*texto)
Datos4bits(*texto++);
}
Para controlar los motores paso a paso hemos montado unos ULN2003A que
alimentamos con la tensin que queremos aplicar al motor paso a paso. La conexin se
realiza mediante unas resistencias de pull-up para aplicar mayor corriente a los motores.
La conexin de toda la electrnica realizamos mediante un cable plano que une la placa
del micro-controlador con una placa de grapin donde hemos soldados las conexiones.
Nos resulto imposible encontrar unos conectores para los GP2Y0A21. Por ello
grapinamos directamente los pines. Para darle un poco de rigidez y aislar un poco los
ruidos exteriores hemos usado tubo termo retrctil que aplicndole calor se encoge
adoptando la forma del contenido. Para mejorar la seal de entrada de los sensores
conectamos unos condensadores entre la tensin de salida y masa, evitando as el rizado
de la seal.
A la hora de realizar la estructura, intentamos adaptarnos a los consejos de la parte

que trata ese tema en este mismo trabajo, es decir, escogimos un material que tuviramos
a nuestro alcance teniendo en cuenta que el presupuesto no es elevado, procurando que
sea resistente.
Pgina 76
Inicialmente utilizamos una bandeja corriente que resulta un material muy duro, al
trabajar con el nos dimos cuenta que no lo suficientemente maleable como pensbamos
en un principio, aun as decidimos seguir trabajando con el debido a su dureza. Tras haber
montado los motores e intentar mover el robot nos encontramos con que el par del motor
no nos daba suficiente fuerza para arrancar el robot, intentando reparar este problema
aplicamos mayor potencial al motor paso a paso, aun as no conseguimos que arrancase,
asique decidimos quitar el material de la bandeja, ya que pesaba demasiado.
Como sustituto de la bandeja decidimos usar madera de balsa, un material que se

trabaja muy fcilmente y que es muy ligero, pero como problema presenta que es muy
frgil, de hecho mientras trabajbamos con el se partieron varias piezas.
Adems de esto, para montar la estructura y darle rigidez hemos usado unos listones
de SAMBA, que resultan muy ligeros, por el contrario se astillan con mucha facilidad.
Para trabajar estos materiales usamos una sierra de calar, un taladro, una Dreamel,
lija, abrazaderas, cola blanca, tornillos, etc..
Pgina 77
Pgina 78
Pgina 79
Pgina 80
A continuacin realizamos un presupuesto aproximado sobre el diseo realizado,

teniendo en cuenta que parte del material ha sido reciclado:
Componentes Precio
Bandeja x2 3
Madera de balsa 1,80
Rueda de plstico 0,94
Liston de SAMBA 2m 4,61
Tornillos 1,05
ULN2003 x4 2,5
Resistencias 10K x10 0,20
GP2Y0A21 x5 45,95
Placa de grapin 7
Motores paso a paso 0
Placa con micro controlador 0
Tubo Termo retrctil 0,95
Bobina de grapin 10
Estao 1
Cds/DVD 0
Bolsa de globos 0,90
Bumper ?
Discos de corte Dreamel 3
Zocalos x4 3,60
Aguja 0
Tornillos con tuerca 0,95
Condensadores de 100nf x10 0,60
TOTAL 88,05
Pgina 81
15. CONCLUSIONES
Las conclusiones que podemos sacar de las competiciones de Alcal son que la
participacin siempre a sido baja, incluso descendiendo en cada ao. Se ha visto que el
laberinto desconocido los participantes tenan muchos problemas para alcanzar la salida
por lo que en general, este, suele ser conocido.
Los participantes de las competiciones en general suelen tener luego una trayectoria
acadmica admirable, el participar en competiciones les da mucha experiencia en amplia
variedad de sectores, la robtica ayuda al estudiante a aumentar conocimientos para
posteriormente poder aplicarlos a sus estudios, o simplemente por joby.
En cuanto a la estructura hemos visto que es preferible usar algo ms de tiempo

decidiendo una buena, ya que una mala eleccin podra complicar la salida del laberinto.
Por otro lado, hemos visto que dependiendo del presupuesto que tengamos
conseguiremos un resultado mejor, ya que, por ejemplo, el material de la base ser mejor
o peor y tendremos ms o menos precisin de los sensores.
Respecto al tema de algoritmia, podemos destacar tres conclusiones:
Todos los algoritmos aplicados al enrutamiento de redes para encontrar el camino

ms corto desde un punto hasta otro, son aplicables al diseo de robots de laberinto,
existe poca algoritmia que de forma especfica sirviese para robots.
Otro punto importante a resear, es el de que cuanto ms sofisticado sea el laberinto
a implementar, requiere un control mucho ms complejo.
Por ltimo vamos a hablar de las conclusiones que hemos sacado a la hora de
disear el robot.
Este ha sido el primer robot que hemos intentado montar. Nos hemos encontrado
con muchos problemas que a priori no pensbamos que podran ocurrir.
Para comenzar el diseo de nuestro robot pensamos en utilizar la herramienta Catia, ya que
pareca un programa muy intuitivo y que presentaba grandes resultados. Una vez que nos
pusimos con el desarrollo de las piezas surgen muchas dudas sobre planos, cortes y
superficies. Las herramientas de desarrollo en 2D son las usuales en todo programa grafico,
pero en cuanto se pasa al desarrollo 3D (Part Desing) todo es nuevo. Moverte en 3D no
resulta todo lo sencillo que pueda parecer, y equivocarte de ejes y superficies es algo
normal.
A la hora de montar todas las partes (Assembly Desing) ya se haba conseguido
tomar cierta familiaridad con el entorno lo que ya result algo menos costoso.
Por la falta de tiempo y el total desconocimiento del programa antes de la propuesta del
trabajo, solo hemos trabajado con la parte de diseo mecnico. Hay mltiples herramientas
dentro de Catia que podran habernos ayudado, incluso ms que la parte mecnica, ya que
el peso o el centro de gravedad bien definidos puede hacer un montaje mucho ms sencillo.
Como conclusin, es mejor trabajarse el diseo en Catia en todas sus posibilidades y luego
ponerse con el montaje.
Pgina 82
A la hora de planificar el montaje y ensamblado de un robot resulta un poco intil si

no podemos mandar hacer las piezas o no tenemos presupuesto para ello, a nosotros nos
pas eso, ya que las partes de la estructura las hicimos nosotros con el material disponible,
as que recomendamos mandar construir las piezas con los planos elaborados
anteriormente, as el montaje ser mucho ms sencillo.
Tambin tuvimos problemas con los materiales utilizados, empezamos con la idea
de usar materiales muy resistentes pero a la vez muy pesados, esto lo tuvimos que descartar
ms adelante ya que tuvimos problemas con la potencia de los motores. Posteriormente
usamos madera de balsa, que resultaba ligera y muy fcil de trabajar, como inconveniente
resulta muy frgil y se nos parti varias veces, una solucin a esto es usar resinas para
endurecerlo. Siempre que nos lo puedan fabricarlas piezas es recomendable gastar un poco
ms de dinero y usar buenos materiales (aluminio, metacrilato, etc.).
Otro problema viene de reciclar componentes antiguos, ya que en el caso de los
motores nos ha sido imposible encontrar las hojas caractersticas del modelo utilizado
dando problemas a la hora de saber la alimentacin, par, etc. Tambin tenemos que decir
que a nivel econmico quizs compense usar el reciclado.
Inicialmente pensamos que el uso de cinta termo retrctil iba a ser muy til para endurecer
las conexiones, realmente es muy til para ello pero nosotros pecamos de usar demasiada,
hacindose muy poco maleable, que resulta un grave inconveniente a la hora de montar
todo el robot, es por esto que debimos cortar varios trozos, para solucionar esto recomiendo
usar conectores fabricados para nuestros componentes.
Hay que tener mucho ojo con las ruedas, hay que insertarlas con mucho cuidado y
con mucha precisin.
Se recomienda el uso de muy buenas herramientas para trabajar con ciertas garantas
en el montaje, en el caso de no tener herramientas apropiadas el trabajo puede ser un fiasco.
En la planificacin de diseo del robot no solo tenemos que ver la estructura, debemos
dedicar un apartado importante a la estructuracin electrnica del robot, nosotros hicimos
un pequeo diagrama de bloques, que en un principio pareca suficiente, pero a la hora de
ensamblar todo nos dimos cuenta que la placa de grapin era demasiado grande y que no
estaba del todo bien aprovechada adems la conexin entra la placa de grapin y la placa del
microcontrolador era demasiado costosa debido a la rigidez del cable plano. Nosotros
recomendamos realizar todo el montaje electrnico en la misma placa, ya sea pcb, board o
grapin.
Las bateras es otro punto importante que tenemos que plantearnos, aunque
ayudara mucho a esto tener idea de las caractersticas de los motores.
El peso de los motores es gran parte del peso total del diseo, nosotros hemos usado unos
motores demasiado pesados, tanto que el propio motor no tenia fuerza para moverse as
mismo, esto es porque el motor paso a paso no esta pensado para moverse as mismo, sino
que esta pensado para actuar sobre cabezales, desplazamiento de tornillos, etc.
Pgina 83
16. Bibliografa.
Informacin relacionada con el algoritmo de Dijkstra:
http://www.alumnos.unican.es/uc900/Algoritmo.htm
ALGORITMOS FUNDAMENTALES VOL. I, Donald E.Knuth, EditorialRevert
S.A. 1985
Informacin relacionada con el algoritmo de Breadth-first:
http://www.cs.duke.edu/csed/jawaa/BFSanim.html
http://ccc.inaoep.mx/~emorales/Cursos/Busqueda04/node13.html
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/
breadthSearch.htm
http://www.ics.uci.edu/~eppstein/161/960215.html
Informacin relacionada con la parte de control del robot:
http://micromouse.cannock.ac.uk/navigation/straights.html
[1]http://micromouse.cannock.ac.uk/navigation/straights.htm
http://www.robots-dreams.com/micromouse/index.html
Informacin relacionada con el algoritmo de seguir la pared y llenar caminos:
http://www.aula-ee.com/webs/laberints/castella/res.htm
Informacin relacionada con el algoritmo de Bellman-Ford:

http://neo.lcc.uma.es/evirtual/cdd/tutorial/red/bellman.html
http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html
http://salaam.cs.buap.mx/ADA/Bellman_Ford.ppt#262,7,ejecucion
http://personales.upv.es/arodrigu/grafos/Ford.htm
Informacin relacionada con el algoritmo de la colonota de hormigas:
http://www.ucy.ac.cy/~gracm05/PROCS1/10.pdf
Pgina 84
Informacin relacionada con el algoritmo de Gastn Terry y Eduoard Lucas:
http://topo.math.u-
psud.fr/~slc/TeX/lcs/hodges/Graphs_HodgesWilfried/graphs001a.pdf
http://www.osti.gov/bridge/servlets/purl/10180101-GX4NXg/10180101.PDF
Informacin relacionada con el algoritmo de Recursividad:
http://www2.ing.puc.cl/~iic11021/materia/ejemplos/maze.htm
Informacin complementaria:
Pgina del departamento de Electrnica de la Universidad de Alcal donde se han

consultado diversos archivos en PDF de robots participantes en ediciones de Alcabot e
Hispabot.
http://www.depeca.uah.es
Informacin CATIA:
Manual adjunto en PDF y tutoriales varios.
Pgina 85

Diseño de microrrobots móviles para laberintos

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Diseño de microrrobots móviles para laberintos

Загружено:

Авторское право:

Доступные форматы

Robots de Laberinto

Trabajo realizado para la asignatura de Diseo de

Diaz Collazo, Adrin Marcelo (chelo_158@hotmail.com),

2.Historia de las competiciones .............................................................................................. 5

4.Anlisis de estructuras y diseos de robots de laberinto ................................................... 10

8.Anlisis de algoritmia ........................................................................................................ 24

Algoritmo de la colonia de la hormiga ......................................................................... 36

10.Consideraciones a tener en cuenta a la hora del diseo: ................................................. 50

11.Algoritmo para salir del laberinto: .................................................................................. 51

12.Descripcin de estructura y hardware del robot .............................................................. 56

14.Montaje real del robot: .................................................................................................... 70

2. Historia de las competiciones

En la segunda competicin Britnica de micromouse, Dave Woodfield consigui

COMPETICIONES A NIVEL INTERNACIONAL

El campeonato de Reino Unido Micromouse es una competicin internacional de la

El laberinto consiste en 256 cuadrados (clulas) dispuestos en un formato 16 x 16, en una

El campeonato ha sido apoyado por una variedad de organizaciones y las instituciones

Universidad naciones de Colombia

NORMATIVA: La prueba consiste en entrar y recorrer el laberinto,

4. Anlisis de estructuras y diseos de robots de

A continuacin estudiamos las partes ms importantes de un robot micromouse:

Sin embargo, si elegimos una forma redondeada no tendramos este problema.

Ahora bien, Que pasara si utilizamos sensores de distancia?, Ya no sera

Los micromouse se han construido de diversos materiales: metal, plstico, madera

Mientras que robots como TURING (a

MTODO DE MANEJO Y EL DAR LA VUELTA

Movimiento en diagonal: Con este tipo de movimiento conseguimos unos

Movimiento en lnea recta: este tipo de movimiento ser mucho ms sencillo

Un ejemplo de traccin diferencial podra ser la utilizada por el robot

Si estudiamos un poco ms detenidamente el movimiento que se genera,

La anterior expresin sera en el caso de que las dos ruedas se moviesen a la

Si lo que queremos es hacer un giro de x grados la ecuacin sera la

Este movimiento habr que proporcionarlo a ambas ruedas motrices, cada

Si la usramos, el giro sera ms tedioso e incluso podra darnos problemas.

Como se ve en la figura, el robot se puede encontrar graves problemas a la hora de

Un ejemplo de esta colocacin sera la utilizada por el robot Charrito

Un ratn con los sensores de proximidad

La forma de utilizar estos sensores es la siguiente:

El emisor: En el caso de la figura, polarizamos el diodo a travs de

El receptor: Este recibir la seal, o no, dependiendo de si

El emisor y receptor pueden ser componentes separados, o estar contenidos juntos

Una forma de poner este tipo de sensores en funcionamiento es utilizar un circuito

Un mtodo bastante popular para medir distancia es utilizando el GP2D12.

A continuacin comentamos, brevemente, los principales motores, que podremos

Generalmente, para polarizar el motor utilizaremos un puente en H, consiguiendo as un

Motores paso a paso

Podemos clasificarlos en dos grupos:

Para el caso que nos ocupa, quiz lo ms prctico sera utilizarlo

Esto es lo que utiliza por ejemplo el robot HERTRON:

La tabla siguiente enumera algunas de las caractersticas ms tpicas de los tipos ms

Alcalinas NiCad NiMH unidad

Alcalinas: ste tipo se encuentra fcilmente en cualquier tienda y proporciona un

Algoritmos con laberinto conocido.

El robot se mueve hasta encontrar una coincidencia con el mapa en memoria

Una vez que ha localizado su situacin, aplicando el algoritmo adecuado, el robot

Para explicar este algoritmo hemos recurrido al siguiente ejemplo:

Continuando con el algoritmo, las distancia de a a los siguientes nodos es c=22,

El algoritmo se repite buscando de nuevo los nodos ms cercanos a a. La distancia

La distancia al nodo d ha cambiado, ya que se ha encontrado otro camino ms corto

Qu hemos conseguido? Pues si queremos llegar a un nodo determinado partiendo

Bsqueda de BREADTH FIRST

Entonces el primero que llegue al nodo de destino ser el camino ms corto y la