Robots Laberinto Grupo E

Robots de Laberinto Trabajo realizado para la asignatura de Diseño de Microrrobots Móviles de la Universidad de Alcalá por Diaz Collazo, Adrián Marcelo ([email protected]), Echeandía Sánchez, Carlos ([email protected]), Espejo Gómez , Victor ([email protected]), García Castilla, Fernando ([email protected] ( [email protected]), ), Gude Rodríguez, Isaac ([email protected]) , Lázaro Rubio, Carlos ([email protected]), Muñoz Babiano, Federico ([email protected]), Pérez Couso, Alberto ([email protected])

…

Noviembre 2006

Introducción al Diseño de Microrrobots Móviles

Trabajos en Grupo

ÍNDICE 1.Introducción............................................ ................................................................... ............................................. ............................................ ................................ .......... 4 2.Historia de las competiciones.......................................... ................................................................. ............................................. ............................. ....... 5 3.Competiciones 3.Competiciones ........................................... ................................................................... ............................................... ............................................ ........................... ...... 7 Alcabot e Hispabot ................................................... .......................................................................... ............................................. ................................... ............. 7 Micromouse.............................................. ..................................................................... ............................................... ............................................... ........................... .... 9 4.Análisis de estructuras y diseños de robots de laberinto .......................................... ................................................... ......... 10 El chasis........................................... ................................................................. ............................................. ............................................. .................................... .............. 10 Forma...................................... Forma............................................................ ............................................. ............................................. ......................................... ................... 10 Materiales ........................................... ................................................................. ............................................ ............................................. .............................. ....... 11 Método de manejo y el dar la vuelta .............................................................. ................................................................................ .................. 12 12 Grados de movimiento .......................................................... ................................................................................ ....................................... ................. 12 La tracción ................................................. ........................................................................ ............................................. ............................................ ...................... 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.Baterías ............................................. ................................................................... ............................................ ............................................. ..................................... .............. 23 8.Análisis de algoritmia........................................... .................................................................. .............................................. ...................................... ............... 24 Algoritmos con laberinto conocido. .................................... ........................................................... ............................................. ...................... 24 Algoritmo de DIJKSTRA : .......................................... ................................................................ ............................................ ........................... ..... 26 Búsqueda 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 — Página 1 —


Trabajos en Grupo

Algoritmo de la colonia de la hormiga .............................................. ...................................................................... ........................... ... 36 Gaston Tarry y Edouard Lucas............................................. .................................................................... ........................................ ................. 37 Recursividad ........................................... ................................................................. ............................................ ............................................. .......................... ... 37 Algoritmo de Microtauro........................................... .................................................................. .............................................. ............................ ..... 39 ¿Cómo se consigue un control tan perfecto? .............................................. .................................................................... ...................... 41 Diagonales ......................................... ................................................................ ............................................. ............................................ .................................. ............ 41 En línea recta ............................................ .................................................................... ............................................... ............................................ ..................... 42 Las curvas.......................................... ................................................................ ............................................. ............................................. .............................. ........ 44 9.Simuladores ............................................ ................................................................... .............................................. .............................................. ............................. ...... 47 10.Consideraciones 10.Consideraciones a tener en cuenta a la hora del diseño: ................................................. ................................................. 50 50 11.Algoritmo para salir del laberinto: l aberinto: ................................................. ........................................................................ ................................. .......... 51 12.Descripción de estructura y hardware del robot ............................................. .............................................................. ................. 56 El cerebro ........................................... .................................................................. ............................................. ............................................ ................................. ........... 57 El sistema sensorial ........................................................ ............................................................................... ............................................. ........................... ..... 58 Los actuadotes .............................................................. .................................................................................... ............................................. .............................. ....... 58 Estructura física .................................. ........................................................ ............................................. ............................................. ................................. ........... 59 13.Catia............................................ ................................................................. ............................................ ............................................. ......................................... .................. 61 Introducción a Catia. ............................................ ................................................................... ............................................. ..................................... ............... 61 Sketcher. ............................................ ................................................................... ............................................. ............................................ .................................. ............ 61 Part Desing ............................................ .................................................................. ............................................. ............................................. .............................. ........ 62 Assembly Dessing ........................................... ................................................................. ............................................ ........................................... ..................... 63 Diseño de nuestro robot. .......................................... ................................................................ ............................................. ................................... ............ 63 Desarrollo por partes del diseño. ........................................... ................................................................. ........................................... ..................... 64 Base del robot. ............................... ..................................................... ............................................ ............................................. ................................... ............ 64 GP2D12. ............................................ ................................................................... ............................................. ............................................ .............................. ........ 64 Placa ........................................... .................................................................. ............................................. ............................................ ..................................... ............... 65 Motor paso a paso.................................... paso........................................................... ............................................. ............................................ .......................... 65 Bumper .............................................. ..................................................................... .............................................. .............................................. ............................. ...... 66 CD .......................................... ................................................................ ............................................. ............................................. ......................................... ................... 66 Aguja. ............................................ ................................................................... ............................................. ............................................ .................................. ............ 67 Sub-ensamblaje ........................................... .................................................................. ............................................. ............................................ .......................... 67 Montaje completo ............................................... ...................................................................... ............................................. ....................................... ................. 68 14.Montaje real del robot: ..................................................... ............................................................................. ............................................... ....................... 70 — Página 2 —


Trabajos en Grupo

15.Conclusiones. 15.Conclusiones. ........................................... ................................................................. ............................................ ............................................. ........................... .... 82 16.Bibliografía............................................ .................................................................. ............................................. ............................................ ............................. ....... 84

— Página 3 —


Trabajos en Grupo

1. INTRODUCCION El documento desarrollado a continuación 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 análisis de las estructuras más usadas con sus ventajas e inconvenientes. Obviamente necesitamos algún método para salir del laberinto, esto lo abordamos en un apartado dedicado exclusivamente a la algoritmia, control y simulación. Para completar el trabajo desarrollado hemos realizado una propuesta de diseño utilizando herramientas de diseño 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.

— Página 4 —


Trabajos en Grupo

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 competición que conocemos actualmente. A continuación desglosamos la evolución por años: (http://micromouse.cannock.ac.uk/history.htm)

1977 En este año se introdujo el concepto de microsmouse por el IEEE. En mayo se anunció la primera “competición de Micromouse” que sería celebrada en 1979 en Nueva York.

1980 El profesor Juan Billinsley, de la escuela politécnica de Portsmouth, introdujo la primera competición europea y modificó las reglas, consiguiendo que las competiciones sean parecidas a las de la actualidad.

1981 En la exposición micro de París hubo cinco micromouse, el primer lugar fue para el ratón Esterlina, alcanzando la meta en menos de 3 minutos. En la segunda competición Británica de micromouse, Dave Woodfield consiguió un tiempo de 47 segundos, proclamándose campeón. Esterlina consiguió un segundo lugar con 1min 37sec.

1985 Se llevo a cabo el “First World Micromouse Competiton” en Tsukuba, Japón.

1986 Los E.E.U.U. hicieron su primera competición, celebrada en Atlantic City.

1987 Se produjo la primera competición de Singapur

— Página 5 —


Trabajos en Grupo

1989 Se lanzó la primera competición internacional de Micromouse de Singapur.

1992 Tenemos ya la séptima entrega de competición anual del micromouse de IEE, en Londres.

— Página 6 —


Trabajos en Grupo

3. Competiciones A continuación presentamos las competiciones más conocidas.

ALCABOT o 2000 



NORMATIVA: El concurso será ganado por aquél 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 sesión. 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



Nº PARTICIPANTES PRESENTADOS: 35

o 2003 

NORMATIVA: Coincide con Hispabot 2003. Es equivalente a la de Alcabot 2002. http://www.depeca.uah.es/alcabot/hispabot2003/laberinto.pdf — Página 7 —




Trabajos en Grupo


o 2004 

NORMATIVA: Se introducen novedades respecto años anteriores: Dado que el laberinto es conocido, se primará a los Robots capaces de incorporar algoritmos de navegación. Las salidas del laberinto son dos: una de ellas será válida, mientras que la otra tendrá una penalización. El Ratón obtendrá bonificación, si logra introducir una pelota de ping-pong estándar en esa casilla central. •

•

•

http://www.depeca.uah.es/alcabot/data/doc/HISPA04_Normativa_La berinto_v1_0.pdf Por lo demás la normativa es equivalente a la de los años 2002 2003. 


o 2006 

NORMATIVA: Se introducen novedades respecto años 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 año de Hispabot es equivalente a la de Alcabot de cada año respectivamente.

— Página 8 —


Trabajos en Grupo

COMPETICIONES A NIVEL INTERNACIONAL MICROMOUSE: El campeonato de Reino Unido Micromouse es una competición internacional de la robótica, que se ha sostenido cada año en el Reino Unido desde el los años 80. Acontecimientos similares también se llevan a cabo en los E.E.U.U, Japón, Singapur, Corea y a otras partes. Los micromouses “ratones” compite con contra el reloj para buscar el centro de un laberinto en el tiempo más corto. El laberinto es desconocido. El laberinto consiste en 256 cuadrados (células) 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 mínima de la pared a la pared es 168 mm. El campeonato ha sido apoyado por una variedad de organizaciones y las instituciones académicas incluyendo Euromicro, el instituto de ingenieros eléctricos, 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 informática en Holloway real, el centro de la innovación de la tecnología 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 línea 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 rectángulo de color negro en el piso que marca el final del laberinto. A continuación mostramos algunos modelos de posibles laberintos: Nº PARTICIPANTES: 11

— Página 9 —


Trabajos en Grupo

4. Análisis de estructuras y diseños de robots de laberinto A priori puede parecer que cualquier estructura es válida para nuestro robot, que lo importante es lo que tiene dentro, pero esto no es del todo cierto. Dependiendo de la función de dicho robot será conveniente utilizar una u otra, incluso una mala elección 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 continuación estudiamos las partes más importantes de un robot micromouse:

El chasis El chasis es la estructura que sostiene y aporta rigidez y forma a nuestro robot. Un buen símil sería el compararlo con el esqueleto humano. Por lo tanto queda justificada la importancia de una correcta elección.

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 importantísima 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 pasaría lo que vemos a continuación:

Sin embargo, si elegimos una forma redondeada no tendríamos este problema.

— Página 10 —


Trabajos en Grupo

Ahora bien, ¿Que pasaría si utilizamos sensores de distancia?, ¿Ya no sería importante la forma?, en este caso, la forma seguiría siendo igual de importante puesto que, aunque en un principio pudiéramos pensar que el robot nunca tocaría las paredes, en cualquier momento esto podría ocurrir y nos será mucho más fácil salir del problema eligiendo una buena forma para el robot. Una buena solución a esto podría ser no preocuparse de la forma del chasis, o no preocuparse demasiado, y más tarde colocar una carcasa externa con la forma que queramos. Esta técnica 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, plástico, 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.

— Página 11 —


Trabajos en Grupo

MÉTODO DE MANEJO Y EL DAR LA VUELTA En este apartado estudiaremos las distintas técnicas 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 función de los grados de libertad en el giro. •

Movimiento en diagonal: Con este tipo de movimiento conseguimos unos desplazamientos notablemente más rápidos, puesto que la distancia que recorremos es menor. A cambio, nos encontramos con varios inconvenientes. Para empezar, será más difícil de construir, ya que para moverse en diagonal tendremos que tener en cuenta factores que de otro modo no los tendríamos, como por ejemplo estudiar más a fondo la colocación de los sensores, además, estos deben tener la suficiente precisión 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 pequeño desvío en la trayectoria podría hacernos rozar con las esquinas.

BR3 MOUSE •

Movimiento en línea recta: este tipo de movimiento será mucho más sencillo de realizar que el diagonal, pero a cambio los desplazamientos serán más lentos al tener que recorrer más 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.

— Página 12 —


Trabajos en Grupo

La tracción Básicamente la tracción nos importará en función del tipo de giro que proporcione. Para ver el giro que necesita un robot debemos pensar en la función que va a desempeñar, es decir, es posible que en ciertos casos necesitemos más 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 continuación, dos tipos, la más 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 tracción diferencial, gracias a esto conseguiremos hacer giros de 90-180º sin ninguna complicación.

Un ejemplo de tracción diferencial podría ser la utilizada por el robot FLORENCIA:

— Página 13 —


Trabajos en Grupo

Si estudiamos un poco más detenidamente el movimiento que se genera, llegamos a la siguiente ecuación: d =

D

π ⋅

c

⋅

n

Donde: d = distancia recorrida. D = diámetro de la rueda. c = número de pulsos del encoder por vuelta. n = número de pulsos leidos. La anterior expresión sería 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 ecuación sería la siguiente: x

=

Drueda

⋅

360

c ⋅ Dbase

⋅

n

Donde: x = grados girados. Drueda = diámetro de la rueda. D base = diámetro de la base tomando como limite de la circunferencia el inicio de las ruedas. c = número de pulsos del encoder por vuelta. n = número de pulsos. Este movimiento habrá que proporcionarlo a ambas ruedas motrices, cada una en un sentido. •

No diferencial

Por otro lado tenemos la tracción 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, produciéndose así el giro de estas. Si la usáramos, el giro sería más tedioso e incluso podría darnos problemas. Lo vemos a continuación:

— Página 14 —


Trabajos en Grupo

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 podría, por ejemplo, desviar de la trayectoria con los consiguientes efectos.

Las ruedas Antes de ponernos a montar las ruedas debemos ver dónde deben estar colocadas. En principio podemos pensar en una colocación 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, significaría que el robot no girará entorno al centro del círculo que forma su planta y por tanto colisionará con el obstáculo.

Un ejemplo de esta colocación sería la utilizada por el robot Charrito

— Página 15 —


Trabajos en Grupo

http://www.sec.upm.es/agustin/charrito/charrito.html

Aquí vemos como las ruedas motrices están colocadas de tal forma que el robot hará los giros sobre un punto distinto al centro de la base, en concreto, los giros serán los que vemos en la figura siguiente:

Una forma sencilla de realizar giros sobre el centro de la base sería el adoptado por el robot Pi de RBZ Robot Design, el cual, como vemos en la fotografía, utiliza dos ruedas motrices colocadas en el diámetro de la base y dos ruedas locas para la estabilidad:

— Página 16 —


Trabajos en Grupo

El gran inconveniente de este tipo de solución es que solo nos podremos mover por zonas completamente lisas, ya que si una de las ruedas locas pasase por algún elevamiento, por muy pequeño que fuera, alguna rueda motriz dejaría de tocar el suelo.

— Página 17 —


Trabajos en Grupo

5. SENSORES Los micromouse necesitan una manera de detectar las paredes dentro del laberinto, esto lo harán mediante sensores. Distinguimos dos tipos: de proximidad simples o de distancia.

Sensores de proximidad Estos tipos de sensores nos dan información sobre si hay o no hay algo, es decir, nos dan una señal 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 tendría el siguiente aspecto:

Un ratón con los sensores de proximidad

Un diseño 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 ratón se estrelle con una pared próxima al frente, mientras que los laterales permiten que el ratón corrija su trayectoria. En el caso de la figura anterior, si los sensores izquierdos leen un valor de 010 indica que el ratón esté centrado dentro de la casilla. Si leemos un valor de 100, indicaría que el ratón está descentrado a la derecha y necesita corregir a la izquierda, y al contrario con un valor 001.

— Página 18 —


Trabajos en Grupo

Usar este tipo de sensores tiene otra ventaja. Si por ejemplo leemos el sensor derecho con un valor de 011, indicaría 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 exploración del laberinto La forma de utilizar estos sensores es la siguiente: •

•

El emisor: En el caso de la figura, polarizamos el diodo a través de un resistor, R, este se elige para establecer la corriente apropiada que pasará a través del LED. También podemos usar otra opción en la que lo conectamos a través de un transistor controlado para que el LED emita solo cuando sea necesario, ahorrando así la energía que del otro modo desperdiciaríamos.

El receptor: Este recibirá la señal, o no, dependiendo de si esta rebota en alguna superficie, dando una tensión nula, o positiva respectivamente.

El emisor y receptor pueden ser componentes separados, o estar contenidos juntos en un paquete plástico. En la siguiente fotografía 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 física entre el robot y la pared, y devuelven un valor, el cual, el microcontrolador pueda interpretar como distancia. — Página 19 —


Trabajos en Grupo

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 saturación. El emisor genera una luz que se reflejará en la pared y, cuanto más cercano esté el robot de esta, más brillante será la luz reflejada y por lo tanto mayor señal recibirá el receptor. Un método 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 detección de posición (PSD). Dependiendo del ángulo de reflexión el microcontrolador obtendrá el correspondiente dato para poder actuar. Los sensores de este tipo suelen ser más inmunes a variaciones del color y de iluminación.

— Página 20 —


Trabajos en Grupo

6. MOTORES Los motores serán los encargados de generar los desplazamientos en el robot, por lo tanto, la elección de estos será algo determinante para conseguir un buen movimiento, tanto en aceleración como en velocidad punta. A continuación comentamos, brevemente, los principales motores, que podremos utilizar.

Motores C.C. En un motor C.C. la tensión se aplica directamente a los terminales de este produciéndose el movimiento. Una vez polarizado, se alcanza, rápidamente, una velocidad constante que dependerá dicho voltaje aplicado y de las características del motor. La cantidad de fuerza que se puede generar será función 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 tensión aplicada y pudiendo invertir la polaridad, y por tanto el sentido de giro, si se necesita.

— Página 21 —


Trabajos en Grupo

Puente en H

Motores paso a paso La principal característica 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 necesitarían 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 posición sin más 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 posición, dentro de su intervalo de operación, en función de la señal de entrada. Para el caso que nos ocupa, quizá lo más práctico sería utilizarlo tras haberle quitado los topes y la electrónica encargada de mantener la posición, 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:

— Página 22 —


Trabajos en Grupo

HERTRON

7. Baterías La baterías serán la alimentación de nuestro robot, sin ellas nuestro robot no sería más que un amasijo de hierros que no serviría 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 energía 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 más sino solo las que sean necesarias. La tabla siguiente enumera algunas de las características más típicas de los tipos más populares de baterías: Alcalinas Voltaje de la célula 1.5 Capacidad 2000 Densidad de la energía 190 Resistencia interna 150 Cargador ninguno

•

•

•

NiCad NiMH unidad 1.2 1.2 voltio 500 1100 mAh 44 53 Wh/kg 10 30 ohm simple difícilmente

Alcalinas: Éste tipo se encuentra fácilmente 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 tensión 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 razón suelen ser comunes en los micromouse de alto rendimiento. NiMH: La única ventaja que encontramos en este tipo de baterías es que, manteniendo una buena resistencia interna, tienen mayor capacidad de las de NiCad. Y como inconveniente la dificultad a la hora de cargarlas. — Página 23 —


Trabajos en Grupo

8. Análisis de algoritmia Para abordar un estudio sobre la algoritmia usada en los robots de laberinto, vamos a hacer una clasificación basada basada en si el laberinto es o no conocido. conocido.

Algoritmos con laberinto conocido. Aunque los posibles algoritmos a utilizar dependen del tipo del laberinto y de las normas de la competición, en este apartado se van a explicar los más utilizados en competiciones de robots. En el caso de que el robot se encuentre en un laberinto y no conozca su posición exacta dentro del mismo, conlleva a que necesariamente debe disponer en memoria de un plano del laberinto, que le indique la situación de los muros. Tras la activación del robot, su primer objetivo será analizar su entorno recorriendo las casillas adyacentes. De esta esta forma, y con la ayuda de los sensores sensores adecuados, adecuados, podrá reconstruir el laberinto con el fin de comparar ese resultado con el mapa del laberinto en memoria. Este método es el que usó el robot Fribotte/Cnossos en la competición Hispabot 2004.

— Página 24 —


Trabajos en Grupo

Se puede observar que dicho robot tiene codificado en memoria la situación de los muros horizontales y verticales. Además, a cada celda le asigna un número que le indica la distancia hasta la salida. De esta manera, en el momento que el robot localice su posición, deberá desplazarse a la casilla con el número más bajo. Este método 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 información.

El robot se mueve hasta encontrar una coincidencia con el mapa en memoria probando todas todas las posibilidades, posibilidades, en las cuatro posibles posibles direcciones. direcciones.

— Página 25 —


Trabajos en Grupo

Una vez que ha localizado su situación, aplicando el algoritmo adecuado, el robot calcula el camino más 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 continuación:

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.

— Página 26 —


Trabajos en Grupo

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. =85. De esta forma, b tiene la distancia mínima al nodo inicial, ya que cualquier otro camino pasará por más nodos, y por tanto será más largo. A continuación, b es coloreado de naranja para indicar que es el camino más corto.

Ahora las aristas rojas apuntan a los nodos que ya tienen una distancia final. Las distancia desde a a los siguientes siguientes nodos nodos es es de c=22, d =85 =85 y e=16. Como e es el camino más corto, lo coloreamos de naranja.

— Página 27 —


Trabajos en Grupo

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 más corto a través de los nodos b y e. El nodo c tiene la distancia más corta, y por tanto lo coloreamos de naranja.

El algoritmo se repite buscando de nuevo los nodos más cercanos a a. La distancia a los siguientes nodos es d =82, f =92, h=49, j=34. El nodo j es el más cercano, así que lo coloreamos de naranja.

— Página 28 —


Trabajos en Grupo

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 más corto a través de los nodos b, c, j. Coloreamos de naranja el nodo f , ya que tiene la distancia más corta.

Las distancias son d =82, h=49, i=53. El nodo h tiene la distancia más corta, así que lo coloreamos de naranja.

— Página 29 —


Trabajos en Grupo

En esta situación 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 mínima.

— Página 30 —


Trabajos en Grupo

La distancia al nodo d ha cambiado, ya que se ha encontrado otro camino más corto a través de los nodos b, e, h y g. Las distancias son d =63, i=53. El nodo con la distancia mínima 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 más corto a ese nodo.

http://alumnos.unican.es/uc900/Algoritmo.htm — Página 31 —


Trabajos en Grupo

Búsqueda de BREADTH FIRST Breadth first es un método pensado para ser aplicado en grafos, pero también puede ser utilizado en un laberinto conociéndolo a priori ya que el funcionamiento de ambos es similar. El método breadth first empieza en un nodo X con un valor 0, en los nodos circundantes se introduciría el valor 1 y con los circundantes del 1 el valor 2, así hasta completar todos los nodos, donde cada nodo se correspondería con una casilla del laberinto.

Paso 1

Paso 2

Paso 3

Paso 4

Paso 5

Paso 6

Paso 7

Paso 8

Paso 9

— Página 32 —


Trabajos en Grupo

Entonces el primero que llegue al nodo de destino será el camino más corto y la solución a nuestro laberinto. Entonces lo único que resta es volver siguiendo los números inmediatamente inferiores para volver a la casilla de inicio. Las imágenes del BREADTH FIRST se han extraído 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 línea y sumarlo a nuestro valor inicial que en este caso es 0, entonces si el valor de la línea es de 7 el nodo siguiente será 7 y si la línea del siguiente nodo al cual nos dirigimos es 3, el valor del siguiente nodo será 10. La diferencia que posee con respecto al método de Dijkstra es que permite valores negativos en los arcos del grafo, estos valores se colocarán en los arcos si el próximo nodo dista menos del nodo origen. (Floyd-Warshal)

www.cs.umu.se

— Página 33 —


Trabajos en Grupo

ALGORITMOS CON EL LABERINTO DESCONOCIDO Seguir la pared Un método 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 siguiéndola. 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 más corta. Este procedimiento también funciona en el laberinto tradicional, en el que la meta está en el interior, pero partiendo de la consideración 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 más de estos circuitos cerrados, el método de “la mano en la pared” con seguridad lo llevará por la ruta más 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 múltiples"; un ejemplo es el siguiente laberinto.

http://www.astrolog.org/labyrnth/algrithm.htm

La técnica de la mano en la pared, que se usa sólo para laberintos "simplemente conectados", conduce una sola vez en cada dirección a lo largo de cada sendero, así que es seguro que en algún momento dentro de la ruta, se encontrará la salida.

— Página 34 —


Trabajos en Grupo

SOLUCION CAMINO RECORRIDO SIN SALIDA SIN RECORRER

http://www.astrolog.org/labyrnth/algrithm.htm

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 sólo quedará la solución, o las soluciones si hay más 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 exploración.

SOLUCION CAMINO RECORRIDO SIN SALIDA SIN RECORRER

http://www.astrolog.org/labyrnth/algrithm.htm — Página 35 —


Trabajos en Grupo

Algoritmo aleatorio Este algoritmo se basa en moverse al azar, es decir, desplazarse en una dirección 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 contraposición, es un algoritmo muy simple.

Algoritmo de la colonia de la hormiga La optimización 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 más 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 demás hormigas lo atraviesen, provocando un movimiento colectivo general donde el camino elegido será el más corto. En el Hispabot de 2006, VIRIATO (robot desarrollado en la Universidad de Salamanca) que fue el ganador de esta edición utilizó este algoritmo. En esta ocasión 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 — Página 36 —


Trabajos en Grupo

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 todavía 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 "Recréations mathématiques" (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 intersección se puede tomar cualquier camino y si regresa a una unión en donde ya ha estado, o llega a un callejón, 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 dirección. Lo más importante es que nunca se ha de dirigir a un camino que este marcado por ambos lados del pasillo.

Recursividad Este método se utiliza para resolver un laberinto haciendo uso de la recursividad. Esto significa que una función se llama continuamente hasta que se resuelva el laberinto, utilizando las siguientes prioridades, izquierda, derecha, arriba y abajo. x0, y0 indican la posición de entrada y xf , yf la de salida. Cada casilla puede tener algunos de los siguientes valores: muro, camino sin visitar y camino visitado

— Página 37 —


Trabajos en Grupo

Funciones utilizadas: Función “válida”: Se le pasa como datos de entrada la fila y la columna hacia donde se dirige y retorna un valor booleado indicando si la posición 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 Función recorrer: Retorna un valor buleano para así ver si se llegó o no al final, esta es la función que utiliza la recursividad para moverse por el laberinto, los datos de entrada es la posición actual donde se encuentra y dentro de la función 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 asegurándose antes que la casilla donde se moverá será válida. La condición de salida de esta función es ver si se llegó a la salida o ver si nos encontramos en un callejón. 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 posición izquierda Si no se resolvió el laberinto y la casilla de la derecha es un movimiento valido — Página 38 —


Trabajos en Grupo

Se llama a recorrer (recursividad) con el valor de la posición izquierda Si no se resolvió el laberinto y la casilla de la arriba es un movimiento valido Se llama a recorrer (recursividad) con el valor de la posición izquierda Si no se resolvió el laberinto y la casilla de la abajo es un movimiento valido Se llama a recorrer (recursividad) con el valor de la posición izquierda Si no se resolvió el laberinto listo todavía vale FALSO Quitar marca de la casilla devolver listo con el valor de verdadero o falso Función main: Encargado de visualizar el laberinto y la solución y de llamar a la función recorrer Algoritmo:

Se imprime el laberinto sin resolver Se llama a ala función recorrer pasándole ( x0, y0 ) Si no se pudo resolver Imprimir en pantalla “no hay solución” Si existe una solución Se imprime el laberinto resuelto

La recursividad tiene un potencial problema asociado al diseño 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 intersección de 4 caminos transforma el 4 en un 3(que significaría que el robot puede pasar hasta 3 veces por esa casilla), cuando se encuentra en un camino bidireccional lo transforma en un 2 (que significaría que el robot puede pasar hasta 2 veces) cuando se encuentra en un callejón al retroceder va disminuyendo una unidad cada casilla entonces las casillas que tenían 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 había pasado por una casilla que tenían un valor de 3 al pasar nuevamente, significará que ya solo puedo pasar 2 veces más. Es decir, el programa sabe por donde hemos pasado y por donde hay posibilidades de ir.

— Página 39 —


Trabajos en Grupo

El robot intenta dirigirse hacia el número más alto que lo rodea pero en el caso de que el número más 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 dirección 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 establecería otro punto de anclaje, formando una línea 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 línea 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.

— Página 40 —


¿CÓMO SE CONSIGUE PERFECTO?

Trabajos en Grupo

UN

CONTROL

TAN

Para poder competir en una carrera de Micromouse, o en una prueba de laberinto en general, hay que desarrollar unos buenos métodos de exploración, optimización del camino a seguir mediante algoritmos, pero todos hemos visto en videos de competiciones que, además 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 más sorprendente, tomar diagonales. ¿Cómo 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 también es muy peligrosa. Los competidores expertos suelen estructurar sus diseños 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 más estrecho que dicha longitud. Como es lógico, cuanto más grande sea nuestro robot, más precisos deberemos ser, aunque tampoco interesa que el robot sea demasiado estrecho, porque podríamos 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 mínima que nos permita recorrer sin problemas el tramo de la diagonal, así como permitir pequeños movimientos en torno a las posiciones calculadas. No es raro que durante la competición preliminar, muchos de los robots se choquen contra alguna de las esquinas del circuito.

— Página 41 —


Trabajos en Grupo

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 reflexión. La variación de distancia al muro es mayor y asimétrica, por lo que no podemos disponer de información simultánea del lado derecho e izquierdo. Entonces, ¿cómo 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 márgenes seguros desde el comienzo del diseño, para después modificar el control y poder correr más o menos riesgos.

En línea recta Recorrer largos tramos rectos puede parecer sencillo, pero ¿estamos seguros de que el diámetro 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é ocurriría 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 continuación se detallan algunos de esos errores:

ERROR FRONTAL

http://micromouse.cannock.ac.uk/navigation/straights.htm

— Página 42 —


Trabajos en Grupo

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 más sencillos de corregir, ya que es muy común utilizar sensores de posición que nos permiten realizar la calibración con suficiente antelación. Sin embargo, algunos aspectos como la reflectividad de las distintas paredes, la dirección e intensidad de la luz ambiental o simplemente la acumulación de otros errores, hace que no haya nada establecido sobre este proceso de recalibración. Según [1] utilizar un sensor IR de corto alcance montado en la parte delantera del robot es un método 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 colisión al llegar a una curva. En algunos casos, aunque no se haya producido colisión, tendremos un error de offset después de un giro de 90º. En motores paso a paso, un error de más 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 debería ser corregible. En realidad, grandes correcciones en el error frontal son síntoma 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 dirección: 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 supondría reducir o aumentar la velocidad de una de las ruedas, aunque no sería apropiado si el robot ya circula a la máxima velocidad, o si va muy lento. En estos casos sería conveniente realizar el giro pero con el robot parado.

ERROR DE DIRECCIÓN

— Página 43 —


Trabajos en Grupo


Un ejemplo de robot que corrige su posición es Fribotte/Cnossos, ya nombrado anteriormente. Dicho robot conoce su posición gracias a dos encoders ópticos en sus ruedas y, aunque consigue una gran precisión, hay pequeños 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 más 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 precisión. 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, sería conveniente colocar la masa del robot lo más 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, según [1] en términos 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 más distancia que la otra, y tal vez no sea provechoso en términos de velocidad, además 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 atención 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 más rudimentario mientras que la forma de afrontar la — Página 44 —


Trabajos en Grupo

curvas según el dibujo de la derecha presenta un control más 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 información 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:

http://www.robots-dreams.com

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 diseño hace tener que obviar muchos posibles errores en la información enviada por los sensores, lo que hace trabajar de forma aproximada.

— Página 45 —


Trabajos en Grupo

http://www.robots-dreams.com

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 colocación de los sensores de esta forma es un poco inútil, 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 reflexión es el mismo, y así poder conseguir tener información sobre paredes laterales en celdas adyacentes. De la experiencia de los distintos competidores de Micromouse, se llega a la conclusión de que el ángulo óptimo para posicionar los sensores, no es de 45º sino un ángulo algo menor.

— Página 46 —


Trabajos en Grupo

9. Simuladores En relación al apartado de simulación, tras realizar una búsqueda 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 diseñar un controlador borroso para nuestro robot. A continuación 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.

— Página 47 —


Trabajos en Grupo

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 función gestiona la información de los sensores, otras dos se encargan del movimiento del robot y de su representación sobre el mapa, y por último se encuentra la función principal que llama al resto de funciones. El controlador tiene como entradas las distancias detectadas por los sensores (distancia hasta el primer píxel negro) y como salidas la velocidad angular y lineal del robot.

El resultado de la simulación es el siguiente:

Pero cada desarrollador de microrrobots, además 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, probándose sobre él, dos de los algoritmos arriba explicados. Simulamos los 2 métodos que nos han parecido los más destacados pos su sencillez y eficacia: El primero es el método de tirar a derechas, este algoritmo es fácil de aplicar, ya que en su algoritmo solo hay que poner una serie de prioridades que serían: primero tirar a derechas, en caso contrario, seguir recto, después tirar a la izquierda, y por ultimo ir hacia atrás. Con este algoritmo tenemos la certeza de que encontrará la salida.

— Página 48 —


Trabajos en Grupo

El segundo que simulamos fue el de BREADTH FIRST, utilizado en laberintos conocidos. En la simulación lo único que no se puede apreciar son los nodos superiores a 9, ya que al ser números 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 número 1 y colocando un 2 (número 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 número asignado a esa casilla, en este caso, no se escribirá ningún número. Luego se buscará el 2, el 3 etc.;hasta que en la casilla de salida, que está en blanco, se escriba un número. Una vez escrito el número en la casilla de salida, el programa empieza a contar hacia atrás hasta llegar al número “1” que se corresponde con el inicio. Mientras se cuenta, se van marcando las casillas por las que pasa, formando así el camino solución.

— Página 49 —


Trabajos en Grupo

10.Consideraciones a tener en cuenta a la hora del diseño: Para comenzar el diseño de nuestro robot de laberinto es necesario plantearse ciertas preguntas que nos facilitaran el diseño de nuestro robot. Estas preguntas son: • • • • •

¿Cuáles son las normas del concurso en el que queremos participar? ¿Cuánto presupuesto tenemos? ¿Qué material podemos reciclar? ¿Cuánto tiempo tenemos? ¿Cuál es nuestra meta?

En nuestro caso las respuestas a estas preguntas no son del todo reales, ya que hemos creado nuestra propia competición a la que ajustar el robot. Aún 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 posición de partida. 4. Se conseguirá bonificación si pinchamos algún globo. En nuestro caso el presupuesto no queríamos que excediese los 100€. Con mucho ahínco hemos conseguido unos motores sacados de unas disqueteras de 5.25”, también disponemos de un micro-controlador que tenemos de una práctica de años anteriores. Tiempo no teníamos el suficiente como para llegar con el robot montado y funcionando, además de tener ciertos problemas técnicos lo cual nos ha hecho no poder traer el modelo pensado inicialmente. Nuestra meta es poder presentarnos en la siguiente edición 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 reutilización 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, según sabemos los sensores que necesitamos realizamos una estructura inicial del robot que permita manejar dichos sensores con un mínimo de garantías, es decir, que los pulsadores estén colocados de forma estratégica o que los sensores de distancia estén dentro de su margen de actuación sin que se les impida en ningún momento su visión.

— Página 50 —


Trabajos en Grupo

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 posición de partida desconocida y con orientación aleatoria dentro de la casilla de salida, para ello lo que vamos a intentar es conocer nuestra posición dentro del laberinto, para ello nos iremos moviendo por el laberinto y almacenando la posición 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: • •

¿Dónde estamos? ¿Hacia dónde 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 orientación 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 más fácil comprenderlo:

— Página 51 —


Trabajos en Grupo

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.

— Página 52 —


Trabajos en Grupo

Una vez resuelto el problema de la orientación 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 máximo que podemos movernos hacia un lado u otro son 8 celdas, y debido a que no queremos perder información 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 ningún 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 orientación de la salida y suponiendo que partimos desde alguna de las esquinas, con ese gráfico 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 — Página 53 —


Trabajos en Grupo

destacar que la celda central siempre es común a cualquiera de los casos así que nuestra búsqueda 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 almacenarán siempre en memoria no volátil, de forma que así siempre estarán disponibles y no ocuparan memoria RAM, es por esto que necesitaremos únicamente memoria para la matriz de adquisición de datos, esto implica un tamaño de memoria mínimo de 289 bytes disponibles en la memoria RAM. Inicialmente las casillas tendrán el valor 0xFF para así poder diferenciar las que se han recorrido y las que no. Cada byte tendrá la siguiente estructura, válida tanto para los laberintos grabados inicialmente en ROM como para el que está en RAM:

BIT 7

BIT 6 BIT 5 BIT 4 Posición de paredes 0-15

BIT 3

BIT 2 BIT 1 BIT 0 Distancia a la salida 0-15

Tabla de posición de paredes:

Paredes referenciadas con el mapa hacia arriba Sin paredes Pared abajo Pared arriba Pared izquierda Pared derecha Pared abajo y arriba Pared arriba, izquierda, derecha …

BIT 7 0 0 0 0 1 0 1 …

BIT 6 0 0 0 1 0 0 1 ...

BIT 5 0 0 1 0 0 1 1 ...

BIT 6 0 1 0 0 0 1 0 …

El algoritmo a seguir es bastante intuitivo, una vez que sabemos en que posición estamos lo único que falta es encontrar un camino mínimo hasta la salida. Para ello tendremos en cuenta el número de casillas hasta la salida, es decir, equivale a usar un mapa en cualquier ciudad. La información necesaria para salir, la buscaremos en los bytes de las casillas, guiaremos el camino dándole valores a cada casilla, cuanto más lejos esta la salida mayor será el número asignado, de esta forma el robot lo que tiene que hacer es ir hacia la casilla que tenga un valor menor. A continuación mostramos un ejemplo según el mapa que estamos usando en esta presentación.

— Página 54 —


Trabajos en Grupo

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 quizás 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 deberíamos 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 limitación 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 deberíamos usar variables de tipo int, por lo que necesariamente tendríamos 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 dirección del mapa en la que estamos y con que orientación 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 común, según avancemos por el laberinto iremos recopilando más datos lo que nos lleva a descartar mapa por mapa y encontrarnos. Para saber la dirección en la que estamos mirando llevaremos un historial de los índices de la matriz de las últimas celdas recorridas sabiendo de donde venimos, si añadimos a esto el número de giros dados sabemos hacia donde miramos.

— Página 55 —


Trabajos en Grupo

12.Descripción 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 continuación:

— Página 56 —


Trabajos en Grupo

El cerebro Todo robot que tiene que tomar decisiones de forma autónoma necesita un “cerebro”, en este caso y por el motivo de aprovechar lo que tenemos hemos decidido usar un 68HC08 que reutilizamos de la práctica del laboratorio de SED de Ingeniería de Telecomunicación. 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 sería útil. Podemos destacar las siguientes características técnicas 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 características porque nos resulta necesario el tener un ADC con una resolución aceptable y al menos un temporizador. Debido a la tarjeta de desarrollo tenemos un pequeño impedimento en el ADC, esto es que el margen dinámico viene fijado entre 0 y 5 voltios

— Página 57 —


Trabajos en Grupo

El sistema sensorial Para saber en que posición 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 tensión analógica con un rango de valores de 0.4V a 2.6V.

Con el fin de obtener una mejor resolución usaremos un circuito que adapte la señal de manera que amplificaremos de 2.6V a 5V, esto nos da una ganancia de 1.9. En el caso de querer tener todavía más resolución, la solución 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 válidas. Este inconveniente se tiene en cuenta ya en el diseño de la estructura. A los sensores de distancia se les suma un bumper delantero que nos indicaría cuando hemos pinchado un globo.

Los actuadotes Obviamente necesitamos algún mecanismo que nos permita movernos por el laberinto, para ello hemos creído conveniente utilizar motores paso a paso, ya que de esta forma tenemos un control sobre el número de vueltas que llevamos dadas, así como giros parciales con una gran exactitud.

— Página 58 —


Trabajos en Grupo

Para llevar un control sobre la velocidad y el número de vueltas de los motores utilizamos el temporizador del microcontrolador. Concretamente usaremos la interrupción de overflow, de esta forma cambiando el valor de la referencia de desbordamiento podemos crear rampas de aceleración evitando así la posible pérdida de tracción 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 conexión de acondicionamiento es la siguiente:

Estructura física Nuestra idea es realizar una base con forma elíptica con el fin de tener suficiente espacio, evitar esquinas y poder contener las ruedas dentro del perímetro de la base, — Página 59 —


Trabajos en Grupo

evitando así posibles roces con las paredes que podrían hacer que el robot pasease a ser un robot de escalada, llegando a volcar. Las ruedas se realizarán con Cd´s ya que conseguimos un perímetro suficientemente grande, avanzando mucho con pocas vueltas lo que también aumenta la velocidad. Los sensores los hemos colocado estratégicamente para poder conocer la posición de las paredes así como la posición dentro de la celda. Además en la parte frontal se han colocado dos sensores, uno más elevado que otro, el fin de colocar los sensores con esta configuración 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 indicaría que tenemos un globo delante por lo que procederíamos a pincharlo. El resto de sensores se colocan formando un ángulo de 90º para ver todas las paredes que nos rodean.

Con esta posición 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 pequeños errores en el movimiento — Página 60 —


Trabajos en Grupo

13.Catia. Para diseñar 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 físicamente.

Introducción a Catia. Catia tiene distintos módulos, cada uno enfocados a distintos aspectos del diseño. Se comienza con la generación de figuras 2D(Sketcher), se crean sólidos (Part Desing) y finalmente se ensamblan(Assembly). Hay otros muchos más módulos que permiten hacer un estudio físico 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 diseño mecánico (Mecanical Desing).

Sketcher. La base de todo diseño se realiza con esta herramienta. Su función es crear unos planos 2D, que luego podremos dar volumen con la herramienta Part Desing. Se pueden hacer todo tipo de formas (rectángulos, círculos, 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.

— Página 61 —


Trabajos en Grupo

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 revolución, 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 volúmenes, sin excepción, a base de figuras simples. Podemos realizar operaciones booleanas entre piezas para conseguir nuevos volúmenes. No hay que olvidar que hay que seguir dando las medidas de la pieza que queremos realizar, incorporando todas las constraints necesarias.

— Página 62 —


Trabajos en Grupo

En las primeras sesiones de uso de Catia, moverse entre volúmenes es complicado, y tener una visión 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 volúmenes que son iguales a otros ya creados, para no volver a realizarlos nos ayudamos de herramientas de simetría, que mueven lo que hay respecto a un eje de simetría (que define el usuario). Con ellos conseguimos piezas iguales y simétricas.

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 añadimos 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 márgenes 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 característica que nos brinca Catia, por lo que hay que explotarla al máximo 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 precisión es importantísima, una pieza mal colocada o mal diseñada nos puede “chocar” con otro volumen. Catia da la posibilidad de ver todas las intersecciones de piezas, con lo que podremos arreglar posibles fallos.

Diseño de nuestro robot. Para el diseño 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 cd’s, 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 rectángulo — Página 63 —


Trabajos en Grupo

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 diseños de piezas y figuras. El ensamblado es una parte extremadamente compleja y debe realizarse paso a paso. Una vez que se tenían todas las piezas simples, se hace un pre-ensamblado de piezas. Por ejemplo, los cd’s 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 errónea, el montaje puede dar fallos como la superposición 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 estructuración permite simplificar el diseño, que aún así es complicado.

Desarrollo por partes del diseño. Base del robot. La base sigue una forma elíptica, 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 perímetro de la elipse base, para que no choquen directamente contra la pared en caso de haber perdido la referencia. A continuación se muestran sus planos:

GP2D12. Los sensores es una parte fundamental del robot. Se han diseñado en catia siguiendo las medidas de la hoja de características. — Página 64 —


Trabajos en Grupo

Placa Es el “cerebro” de nuestro robot. Se ha diseñado siguiendo las medidas de la placa original. Con ello conseguimos saber perfectamente donde puede ser ensamblada y su posición 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 genérico, al que se le agregó el tipo de soporte una vez que se supo de cual se disponía. Gracias al diseño en Catia, podemos calcular la medida de distancia que debe tener con el — Página 65 —


Trabajos en Grupo

suelo para que las ruedas locas y los cd’s 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 cd’s nos servirán como ruedas de nuestro robot.

— Página 66 —


Trabajos en Grupo

Aguja. Elemento punzante que explotara el globo al contacto. Sencilla manera, pero efectiva, de explotar los globos.

Sub-ensamblaje El motor y los cd’s 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.

— Página 67 —


Trabajos en Grupo

Montaje completo El montaje completo da una perfecta idea del robot a construir. Se ven todas las piezas perfectamente definidas y su situación dentro del conjunto.

— Página 68 —


— Página 69 —

Trabajos en Grupo


Trabajos en Grupo

14.Montaje real del robot: Pensamos que para la práctica nos iba a ser de gran ayuda el montaje de un robot de laberinto, por eso, aun teniendo poco tiempo, decidimos diseñarlo 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 programación 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 líneas que nos muestra los datos ofrecidos por los GP2 y el número de vueltas que han dado los motores paso a paso. A continuación mostramos el código implementado: #i ncl ude / * f or Enabl eI nt err upt s macr o */ #i ncl ude / * i ncl ude per i pher al decl ar at i ons */ #def i #def i #def i #def i #def i #def i

ne ne ne ne ne ne

ALANTE ATRAS DERECH I ZQUI ERD ARRI BA ABAJ O

0 1 2 3 4 5

#def i ne SI #def i ne NO #def i #def i #def i #def i #def i #def i #def i #def i

ne ne ne ne ne ne ne ne

0 1

LCDpor t PTC RS PTB_PTB7 E PTB_PTB6 Del ayTi me DATOS 1 CONTROL 0 ON OFF

10 1 0

voi d conf i gTBM( voi d) ; voi d conf i gADC( voi d) ;

— Página 70 —


voi voi voi voi voi voi voi

d d d d d d d

Trabajos en Grupo

LCDdel ay( voi d) ; Ct r l 8bi t s( unsi gned char codi go) ; Ct r l 4bi t s( unsi gned char codi go) ; Datos4bi t s( unsi gned char dat o); Conf i g_LCD_4bi t s( voi d) ; pr i nt f _LCD_4bi t s( unsi gned char f i l a, unsi gned char col umna, char *t exto) ; conver t i r 1 ( unsi gned char hexa) ;

char donde=ALANTE, mover se=SI , l eer =ARRI BA, der echa=0, i zqui er da=0, ar r i ba=0, abaj o=0, at r as=0; unsi gned char t r ansf or mado1=48, t r ansf or mado2=48, t r ansf or mado3=48; char pasos=0, vuel t as=0, dat osest abl es=NO; voi d mai n( voi d) { / * i ncl ude your code here */ DDRA=0xFF; / / Conf i gur amos t odo de sal i da DDRB=0x00; / / conf i gur amos l os PTB como ent r ada DDRB_DDRB6=1; DDRB_DDRB7=1; DDRC=0xFF; Di s abl eI nt er r upt s ; CONFI G1_ COPD=1; Conf i g_LCD_4bi t s( ) ; conf i gTBM( ) ; conf i gADC( ) ; Enabl eI nt er r upt s; / * enabl e i nt er r upt s */ CONFI G1=0; f or ( ; ; ) { _ _RESET_WATCHDOG( ) ; / * ki cks t he dog */ i f ( pasos>=200) { vuel t as++; pasos=0; } pr i nt f _ L CD_ 4bi t s ( 1 , 1, " Pas : " ) ; conver t i r 1( pasos) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ; pr i nt f _ L CD_ 4bi t s ( 1 , 9, " Vuel t : " ) ; c onver t i r 1( vuel t as ) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ; pr i nt f _ L CD_ 4bi t s ( 2 , 1, " Der : " ) ; conver t i r 1( der echa) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ; pr i nt f _ LCD_ 4bi t s ( 2, 9, " I z q: " ) ; c onver t i r 1( i z qui er da) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ; pr i nt f _ LCD_ 4bi t s ( 3, 1, " Ar r : " ) ; c onver t i r 1( ar r i ba) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ; pr i nt f _ L CD_ 4bi t s ( 3 , 9, " Abj " ) ; c onver t i r 1( abaj o) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ;

— Página 71 —


Trabajos en Grupo

Datos4bi t s( t r ansf ormado1) ; pr i nt f _ LCD_ 4bi t s ( 4, 1, " At r : " ) ; c onver t i r 1( at r as ) ; Datos4bi t s( t r ansf ormado3) ; Datos4bi t s( t r ansf ormado2) ; Datos4bi t s( t r ansf ormado1) ;

} / * l oop f or ever */ } voi d conf i gTBM( voi d) { TBCR_TBR=0; / / pr esc al er par a 3. 33333ms TBCR_TBI E=1; TBCR_TBON=1; } voi d conf i gADC( voi d) { ADCLK_ADI V=3; / / pr eescal er a 8 ADCLK_ADI CLK=0; / / coj e rel oj ext er no ADSCR=0b01100000; / / i ni ci al ment e mi r a el canal 0 } i nt err upt 16 voi d conver si onADC( voi d) { st ati c unsi gned char cont =1; i f ( l eer ==DERECH) { der echa=ADR; / / der echa+ADR; ADSCR=0b01100001; l eer =I ZQUI ERD; } el se i f ( l eer ==I ZQUI ERD) { i zqui er da=ADR; ADSCR=0b01100010; l eer =ARRI BA; } el se i f ( l eer==ARRI BA) { ar r i ba=ADR; ADSCR=0b01100011; l eer =ABAJ O; } el se i f ( l eer==ABAJ O) { abaj o=ADR; ADSCR=0b01100100; l eer =ATRAS; } el se i f ( l eer ==ATRAS) { at r as=ADR; ADSCR=0; / *i f ( cont <=3) { cont =1; dat osest abl es=SI ; at r as=at r as/ 3; / / hacemos l a medi a de 3 muest r as par a que sean mas est abl es abaj o=abaj o/ 3; ar r i ba=ar r i ba/ 3; i zqui er da=i zqui er da/ 3; der echa=der echa/ 3; } el se { ADSCR=0b01000000;

— Página 72 —


Trabajos en Grupo

l eer =DERECH; }* / } } i nt err upt 17 voi d t i me_base( voi d) { st ati c char paso=0; st at i c unsi gned char cuent a=0; TBCR_TACK=1; / / Bor r ar f l ag cuent a++; i f ( cuent a>=2) { / / 2*3. 33ms=6ms cuent a=0; i f ( mover se==SI ) { pasos ++; paso++; i f ( donde==ALANTE) { i f ( paso==1) PTA=0x33; / / OFF OFF ON ON el se i f ( paso==2) PTA=0x66; / / OFF ON ON OFF el se i f ( paso==3) PTA=0xCC; / / ON ON OFF OFF el se i f ( paso==4) { PTA=0x99; / / ON OFF OFF ON paso=0; } } el se i f ( donde==ATRAS) { i f ( paso==1) PTA=0x33; el se i f ( paso==2) PTA=0x99; el se i f ( paso==3) PTA=0xCC; el se i f ( paso==4) { PTA=0x66; paso=0; } } el se i f ( donde==DERECH) { / / PARTE ALTA LA RUEDA DERECHA i f ( paso==1) PTA=0x33; el se i f ( paso==2) PTA=0x96; el se i f ( paso==3) PTA=0xCC; el se i f ( paso==4) { PTA=0x69; paso=0; } } el se i f ( donde==I ZQUI ERD) {/ / PARTE BAJ OA RUEDA I ZQUI ERDA i f ( paso==1) PTA=0x33; el se i f ( paso==2) PTA=0x69; el se i f ( paso==3) PTA=0xCC; el se i f ( paso==4) { PTA=0x96; paso=0; }

— Página 73 —


Trabajos en Grupo

} } } i f ( pasos>=100) { l eer =DERECH; dat osest abl es=NO; ADSCR=0b01100000; /* der echa=0; i zqui erda=0; arr i ba=0; abaj o=0; at r as=0; */ / / ADSCR=0b01000001; } } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / LCD/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / voi d conver t i r 1 ( unsi gned char hexa) { / / ut i l i zamos esta f unci ar a i mpr i mi r dat os en el LCD / / est e conver t i r val e par a t r ansf or mar numer os de HEXA a DECI MAL y poder i mpr i mi r l os i f ( hexa<=99) { t r ansf or mado2=( hexa/ 0x0A) +48; / / cal cul amos t r ansf or mado1=( hexa%0x0A) +48; / / cal cul amos t r ansf or mado3=48; } el se{ t r ansf or mado1=( hexa%0x0A) +48; / / cal cul amos t r ansf or mado2=( hexa/ 0x0A) ; t r ansf or mado3=( t r ansf or mado2/ 0x0A) +48; t r ansf or mado2=( t r ansf or mado2%0x0A) +48;

l a decena con el coci ent e l a uni dad con el r est o / / Dej amos l a cent ena como 0 uni dades / / cal cul amos cent enas / / cal cul amos decenas

} } voi d LCDdel ay( voi d) { unsi gned i nt j ; f or ( j =0; j 40us ( Ti empo de ocupaci el LCD) } voi d Ct r l 8bi t s( unsi gned char codi go) { LCDpor t = ( ( LCDpor t & 0xF0) | ( codi go >> 4) ) ; par t e baj a del puert o PTx[ 0: 3] RS = CONTROL; E = ON; E = OFF; RS = CONTROL; LCDdel ay( ) ; } voi d Ct r l 4bi t s( unsi gned char codi go) { / * Tr as mi t o el ni bbl e al t o. LCDpor t = baj a del puert o PTx[ 0: 3] RS E E

/ / Si est onect ado a l a

*/

( ( LCDpor t & 0xF0) | ( codi go >> 4) ) ; / / Si est onect ado a l a par t e = = =

CONTROL; ON; OFF;

— Página 74 —


Trabajos en Grupo

LCDdel ay( ) ; / * Tr as mi t o el ni bbl e baj o. LCDpor t = baj a del puert o PTx[ 0: 3] RS E E LCDdel ay( ) ; }

( ( LCDpor t & 0xF0) | ( codi go & 0x0F) ) ; / / Si est onect ado a l a par t e = = =

CONTROL; ON; OFF;

voi d Datos4bi t s( unsi gned char dato) { / * Tr as mi t o el ni bbl e al t o. LCDpor t = baj a del puert o PTx[ 0: 3] RS E E LCDdel ay( ) ;

*/

( ( LCDpor t & 0xF0) | ( dat o >> 4) ) ; / / Si est onect ado a l a par t e = = =

DATOS; ON; OFF;

/ * Tr as mi t o el ni bbl e baj o. LCDpor t = baj a del puert o PTx[ 0: 3] RS E E LCDdel ay( ) ; }

*/

*/

( ( LCDpor t & 0xF0) | ( dat o & 0x0F) ) ; / / Si est onect ado a l a par t e = = =

DATOS; ON; OFF;

voi d Conf i g_LCD_4bi t s( voi d) { unsi gned i nt cnt ; RS = 0; E = 0;

f or ( cnt =0; cnt <4000; cnt ++) ; al i ment ar ) .

/ / Esper a m de 15 ms. - - > Ar r anque del di spl ay ( Despu鳠de

Ct r l 8bi t s ( 0x30) ; f or ( cnt =0; cnt <1000; cnt ++) ;

// Func t i onSet , i nt er f ac e a 8 bi t s . / / Esper a mas de 4. 1 ms.

Ct r l 8bi t s ( 0x30) ; f or ( cnt =0; cnt <100; cnt ++) ;

// Func t i onSet , i nt er f ac e a 8 bi t s . / / Esper a mas de 100 us.

Ct r l 8bi t s( 0x30) ; bi t s .

//

Functi onSet , i nt er f ace a 8

Ct r l 8bi t s ( 0x20) ; aqu as o a 4 bi t s .

//

Func t i onSet , a par t i r de

Ct r l 4bi t s ( 0x28) ; bi t s ,

//

Func t i onSet :

// Ct r l 4bi t s ( 0x08) ; Ct r l 4bi t s ( 0x01) ;

// //

— Página 75 —

Di s pl ay Of f . Di s pl ay Cl ear .

I nt er f ac e 4


f or( cnt =0; cnt <500; cnt ++) ;

Trabajos en Grupo

/ / El borr ado del di spl ay t arda

Ct r l 4bi t s( 0x06) ; cur sor y no despl azar . Ct r l 4bi t s( 0x0C) ; si n parpadear .

1. 52 ms.

//

Set Ent r y mode: I ncr ement ar

//

Di spl ay on, cur sor i nacti vo y

} voi d pr i nt f _LCD_4bi t s( unsi gned char f i l a, unsi gned char col umna, char * t ext o) { unsi gned char adrs ; / * Si est amos en l a pr i mera f i l a l a di r ecci on de memori a es i gual al de l a col umna menos uno. . . */ adr s = col umna - 1; / * . . . si est amos en l a segunda f i l a hay que sumarl e 0x40.

*/

i f ( f i l a == 2) adr s = adr s | 0x40; i f ( f i l a==3) adr s = adr s | 0x94; i f ( f i l a==4) adr s =adr s | 0xD4; / * El codi go a mandar es el de l a di r ecci on con el bi t D7 a uno. */ Ct r l 4bi t s ( a dr s | 0x80) ; / * . . . y escri bi mos el t exto nor mal ment e.

*/

whi l e( *t ext o) Datos4bi t s( *t ext o++) ; }

Para controlar los motores paso a paso hemos montado unos ULN2003A que alimentamos con la tensión que queremos aplicar al motor paso a paso. La conexión se realiza mediante unas resistencias de pull-up para aplicar mayor corriente a los motores. La conexión de toda la electrónica 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 retráctil que aplicándole calor se encoge adoptando la forma del contenido. Para mejorar la señal de entrada de los sensores conectamos unos condensadores entre la tensión de salida y masa, evitando así el rizado de la señal. 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 tuviéramos a nuestro alcance teniendo en cuenta que el presupuesto no es elevado, procurando que sea resistente. — Página 76 —


Trabajos en Grupo

Inicialmente utilizamos una bandeja corriente que resulta un material muy duro, al trabajar con el nos dimos cuenta que no lo suficientemente maleable como pensábamos 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 fácilmente y que es muy ligero, pero como problema presenta que es muy frágil, de hecho mientras trabajábamos con el se partieron varias piezas. Además 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..

— Página 77 —


— Página 78 —

Trabajos en Grupo


— Página 79 —

Trabajos en Grupo


— Página 80 —

Trabajos en Grupo


Trabajos en Grupo

A continuación realizamos un presupuesto aproximado sobre el diseño realizado, teniendo en cuenta que parte del material ha sido reciclado:

Componentes

Precio

Bandeja x2 Madera de balsa Rueda de plástico Liston de SAMBA 2m Tornillos ULN2003 x4 Resistencias 10K x10 GP2Y0A21 x5 Placa de grapin Motores paso a paso Placa con micro controlador Tubo Termo retráctil Bobina de grapin Estaño Cd´s/DVD Bolsa de globos Bumper Discos de corte Dreamel Zocalos x4 Aguja Tornillos con tuerca Condensadores de 100nf x10 TOTAL

3€ 1,80€ 0,94€ 4,61 1,05€ 2,5€ 0,20€ 45,95€ 7€ 0€ 0€ 0,95€ 10€ 1€ 0€ 0,90€ ¿? 3€ 3,60€ 0€ 0,95€ 0,60€ 88,05€

— Página 81 —


Trabajos en Grupo

15. CONCLUSIONES Las conclusiones que podemos sacar de las competiciones de Alcalá son que la participación siempre a sido baja, incluso descendiendo en cada año. Se ha visto que el laberinto desconocido los participantes tenían 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 académica admirable, el participar en competiciones les da mucha experiencia en amplia variedad de sectores, la robótica 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 más de tiempo decidiendo una buena, ya que una mala elección podría 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 más o menos precisión de los sensores. Respecto al tema de algoritmia, podemos destacar tres conclusiones: ‐

‐

Todos los algoritmos aplicados al enrutamiento de redes para encontrar el camino más corto desde un punto hasta otro, son aplicables al diseño de robots de laberinto, existe poca algoritmia que de forma específica sirviese para robots. Otro punto importante a reseñar, es el de que cuanto más sofisticado sea el laberinto a implementar, requiere un control mucho más complejo.

Por último vamos a hablar de las conclusiones que hemos sacado a la hora de diseñar el robot. Este ha sido el primer robot que hemos intentado montar. Nos hemos encontrado con muchos problemas que a priori no pensábamos que podrían ocurrir. Para comenzar el diseño de nuestro robot pensamos en utilizar la herramienta Catia, ya que parecía 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 había 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 diseño mecánico. Hay múltiples herramientas dentro de Catia que podrían habernos ayudado, incluso más que la parte mecánica, ya que el peso o el centro de gravedad bien definidos puede hacer un montaje mucho más sencillo. Como conclusión, es mejor trabajarse el diseño en Catia en todas sus posibilidades y luego ponerse con el montaje. — Página 82 —


Trabajos en Grupo

A la hora de planificar el montaje y ensamblado de un robot resulta un poco inútil 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 más sencillo. También 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 más adelante ya que tuvimos problemas con la potencia de los motores. Posteriormente usamos madera de balsa, que resultaba ligera y muy fácil de trabajar, como inconveniente resulta muy frágil y se nos partió varias veces, una solución a esto es usar resinas para endurecerlo. Siempre que nos lo puedan fabricarlas piezas es recomendable gastar un poco más 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 características del modelo utilizado dando problemas a la hora de saber la alimentación, par, etc. También tenemos que decir que a nivel económico quizás compense usar el reciclado. Inicialmente pensamos que el uso de cinta termo retráctil iba a ser muy útil para endurecer las conexiones, realmente es muy útil para ello pero nosotros pecamos de usar demasiada, haciéndose 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 precisión. Se recomienda el uso de muy buenas herramientas para trabajar con ciertas garantías en el montaje, en el caso de no tener herramientas apropiadas el trabajo puede ser un fiasco. En la planificación de diseño del robot no solo tenemos que ver la estructura, debemos dedicar un apartado importante a la estructuración electrónica del robot, nosotros hicimos un pequeño diagrama de bloques, que en un principio parecía 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 además la conexión 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 electrónico en la misma placa, ya sea pcb, board o “grapin”. Las baterías es otro punto importante que tenemos que plantearnos, aunque ayudaría mucho a esto tener idea de las características de los motores. El peso de los motores es gran parte del peso total del diseño, 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.

— Página 83 —


Trabajos en Grupo

16. Bibliografía. Información 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 Información 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 Información 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 Información relacionada con el algoritmo de seguir la pared y llenar caminos: http://www.aula-ee.com/webs/laberints/castella/res.htm http://www.astrolog.org/labyrnth/algrithm.htm Información 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 Información relacionada con el algoritmo de la colonota de hormigas: http://www.ucy.ac.cy/~gracm05/PROCS1/10.pdf

— Página 84 —

Robots Laberinto Grupo E

Recommend Documents