Las Pruebas                                                                

Como todos los años, los robots que se presentaban al concurso tenían que competir en dos pruebas diferentes. Al final de la competición, se sumarían los tiempos obtenidos en cada prueba, y el robot que consiguiera el menor tiempo total sería el vencedor de la competición. En concreto, las pruebas eran las siguientes:

•   Cada oveja con su pareja:

En esta prueba, sin duda la más difícil, el robot estaba situado sobre un tablero gigante de ajedrez, formado por casillas negras y blancas. En el centro de algunas de esas casillas estaban colocadas latas de refresco, pintadas de color negro o blanco. En total había 8 latas, 4 blancas y 4 negras. La prueba consistía en que el robot debía rastrear todo el tablero y colocar las latas blancas sobre casillas blancas, y las latas negras sobre casillas negras. Por si esto no era suficientemente difícil, antes de comenzar la prueba no sabíamos ni la posición de las latas ni la casilla de inicio del robot. Otra dificultad añadida era que en el momento de empezar, algunas latas podían estar ya correctamente colocadas, mientras que otras no. Y para terminar de complicar el asunto, otra norma decía que al final de la prueba no podían quedar colocadas dos latas en la misma casilla, ni por supuesto podía quedar ninguna lata fuera del tablero.

•   Velocidad:

Esta era la clásica prueba en la que el robot debe recorrer una línea negra que forma un circuito cerrado con varias curvas sobre un fondo blanco. La novedad de este año consistía en que en un punto del circuito había un atajo, de forma que si el robot era capaz de coger el atajo, evitaría recorrer una parte del circuito con muchas curvas, llegando antes a la meta.

Como veis, en principio la cosa no pintaba nada bien, porque teníamos tan solo 2 meses y medio para diseñar, fabricar y programar los robots que hicieran estas dos pruebas. ¡Así que no teníamos tiempo que perder!

Construyendo el Circuito                            

Lo primero que teníamos que hacer era tener un circuito de pruebas similar al que habría el día de la competición. Así que fuimos a una tienda de bricolaje, compramos dos tableros enormes de aglomerado, unos botes de pintura y nos pusimos manos a la obra!!

Fabricando los Robots                                                            

 Una vez que ya teníamos un circuito de prueba, podíamos empezar a diseñar y fabricar nuestros robots. Lo primero era decidir qué hardware íbamos a utilizar: elegir el microcontrolador, los sensores de línea, los sensores de color, el sensor para detectar la lata, etc. Una vez elegidos los componentes, diseñamos con Orcad la placa que haría de interfaz entre todos ellos. Una vez diseñada, la fabricamos con el método casero de la plancha. Finalmente, tan solo nos quedaba soldar todos los componentes a la placa y añadir las partes mecánicas de robot, como los motores, las ruedas, las pinzas para empujar las latas y la rueda loca. Y así, después de varias semanas trabajando, ya teníamos nuestros robots terminados, preparados para empezar con la programación!

 Programando los Robots                                                            

Aquí comienza la parte más complicada de todas: programar el robot. Lo primero que teníamos que hacer era decidir qué algoritmo queríamos programar en el robot, ya que existían varias formas de afrontar la prueba.

Después de pensarlo mucho, decidimos que para no dejar a nuestro robot en manos del azar, teníamos que hacer un algoritmo para que el robot recorriera el tablero avanzando entre las casillas. Mientras avanzara, el robot tendría que contar las casillas por donde pasase, para de esta forma saber en todo momento dónde estaba. De esta forma podríamos hacer que el robot recorriera todo el tablero de forma precisa, detectando cualquier lata que estuviera en cualquier casilla.

La dificultad de este algoritmo residía en conseguir que el robot avanzara de forma recta entre las casillas,  sin desviarse en ningún momento. Para lograrlo, partimos del algoritmo utilizado para hacer el seguidor de líneas: un regulador proporcional derivativo. Este algoritmo tuvimos que adaptarlo para las condiciones de esta prueba, ya que este caso es mucho más complicado que seguir una línea negra, ya que la disposición de las casillas va cambiando conforme el robot avanza: primero la casilla negra está a la izquierda, luego a la derecha, luego otra vez a la izquierda, etc.

Otra dificultad estaba en que hasta el momento de la competición no sabríamos desde qué casilla tendría que salir nuestro robot, por lo que teníamos que programar un algoritmo que fuera válido para cualquier casilla de inicio. Esto lo resolvimos haciendo que nuestro robot fuera siempre al mismo punto de inicio de rastreo, saliera desde la casilla que saliera.

A continuación os mostramos una de las pruebas que hicimos, en la que el robot Chuck Norris v2.0 recorre todo el tablero sin perderse en ningún momento. Con esto ya habíamos conseguido una parte importante, aunque todavía quedaba lo más importante: detectar y empujar las latas!

Para detectar las latas utilizamos un sensor de distancia de infrarrojos que detecta cualquier objeto que se encuentre a menos de 10cm de distancia. Este sensor estaba instalado en un lateral del robot, y era perfecto para nuestro objetivo, ya que por una parte permitía detectar las latas justo cuando el robot pasaba al lado de ellas, y por otro lado evitaba que el robot detectara otras latas situadas en casillas más lejanas, debido a que el rango de detección era tan sólo de 10cm.

En el algoritmo que programamos, la detección de una lata provocaba la aparición de una interrupción, de forma que el robot dejaba momentáneamente de rastrear el tablero y se aproximaba a la lata para averiguar su color y empujarla en caso de que fuera de color diferente al de la casilla. Para aproximarse a la lata, el robot debía realizar los giros con mucha precisión, ya que un movimiento poco preciso podría hacer que el robot se perdiera, tirara la lata o que no quedara lo suficientemente encarado a ella como para averiguar correctamente su color. Por este motivo nos vimos obligados a utilizar encoders en las ruedas, lo que fue un gran acierto ya que nos permitió realizar los giros de 90º y 180º con mucha precisión.

Una vez que el robot se acercaba con precisión a la lata, para conocer el color de la misma utilizamos un sensor de infrarrojos CNY70 instalado en la parte frontal del robot. Si el color de la lata coincidía con el de la casilla (el color de la casilla se obtiene de los 8 sensores infrarrojos CNY70 que se utilizan para moverse por el tablero), el robot debía retroceder y contiuar con el rastreo. Si el color de la lata era diferente al de la casilla, el robot debía empujar la lata hasta la casilla siguiente, y después retroceder y continuar con el rastreo.
Aquí tenéis un vídeo de las primeras pruebas que hicimos detectando y empujando las latas. Al principio configuramos el robot para que hiciera los movimientos con poca velocidad, para poder configurarlos con precisión.

Pero todavía quedaba un asunto por resolver. El algoritmo que habíamos diseñado empujaba las latas de forma lateral, pero esto no nos servía para las latas que estaban situadas en las casillas exteriores del tablero, ya que si el robot las empujara lateralmente las sacaría del tablero. Por este motivo tuvimos que diseñar otro algoritmo de empuje, que permitiera empujar las latas hacia atrás. Como nuestro robot sabía en todo momento en qué parte del tablero se encontraba, cuando detectara una lata sería capaz de decidir si la tenía que empujar hacia un lado o hacia atrás, dependiendo de si la casilla estaba en el borde del tablero o en el interior del mismo.

Para terminar esta entrada os mostramos otra prueba del robot Chuck Norris v2.0 recorriendo el tablero y empujando las latas. ¡Ya casi estaba terminado, sólo faltaban los ajustes finales!

 Después de muuuuuuchas horas diseñando, soldando y programando, ya teníamos nuestros robots "Xe que bot!" y "Chuck Norris v2.0" preparados para la competición, con un código de más de 1300 líneas en lenguaje C!!