En la última entrada terminé habiendo dejado todo el entorno de desarrollo listo y probando que toda la configuración del PC y el brick estaba correcta.
En esta práctica, tras configurar el entorno de programación, del cual explicaré un poco el proceso, mostraré las primeras aplicaciones que he desarrollado para el Lego NXT. La práctica está formada por varios apartados independientes y para explicar cada una de las partes seguiré la misma estructura: Explicación breve sobre lo que se desea conseguir, señalaré aquellas partes de código que, bajo mi punto de vista, son más creativas o interesantes, y por último mostraré un vídeo con la ejecución de la aplicación (porque una imagen vale más que mil palabras!).
Como he señalado, el paso previo ha sido instalar el IDE con el que vamos a programar todas las futuras aplicaciones, Eclipse (Gavab). El lenguaje elegido ha sido Java, me gustaría señalar que no domino este lenguaje pero gracias a C y a los conceptos de POO me está resultando (de momento) sencillo acoplarme a él. Sobre el IDE, unicamente comentar la necesidad de añadir todo el API de leJOS insertando el fichero "classes.jar" como "External JARs".
*****************************************************************************
Bien, pues vamos con la primera aplicación:
CONTROL BÁSICO DEL MOTOR
Este apartado tiene como objetivo iniciarnos con la clase "Motor" y los métodos que ésta ofrece para el manejo de los diferentes motores de Manué. Además, también se hace uso de algún método de la clase Button, que se utiliza para interactuar con los botones del brick. Para este primer apartado unicamente mostraré un vídeo ya que la ejecución es muy similar en todos. Concretamente se piden 3 clases:
BasicMotor1.java:
Con esta clase, la intención es aprender a utilizar el método forward
Motor.A.forward(); -> Hace avanzar el motor conectado a A.
y el método waitForPress()
Button.waitForPress(); -> Detiene la ejecución hasta que se presiona un botón
BasicMotor2.java:
En este caso, la intención es hacer girar el motor en un ángulo determinado en grados:
Motor.A.rotate(x) -> Donde x es un integer que indica el nº de grados.
BasicMotor3.java:
Por último y muy similar al anterior, hay que girar el motor pero utilizando el método rotateTo, el cual hace girar al motor tomando como referencia una posición absoluta:
Motor.A.rotate(x+angle);
x=x+angle; -> de esta forma avanzará "angle" grados respecto a la última posición.
*****************************************************************************
VISUALIZACIÓN DE LA ODOMETRÍA DEL MOTOR
Una vez que hemos tomado nuestro primer contacto con la API de leJOS basándonos en los métodos de la clase Button y Motor, toca dar paso al LCD. La cuestión principal de esta práctica es aprender las herramientas y restricciones que ofrece la pantalla de Manué. Se puede decir que los mayores problemas que he tenido han sido, por un lado el hecho de que cuando mostramos algo en la pantalla ésta no se borra, con lo que a medida que añades cosas se pueden ir solapando unas a otras, y por otro lado el tamaño, ya que limita el tamaño del contenido que se quiere mostrar.
Lo que se pide concretamente es que la pantalla muestre, a medida que giramos un motor manualmente, los grados que éste lleva girado en todo momento en un rango [0-360º). La mayor complicación ha sido, como cito en el primer párrafo, controlar el hecho de pasar de mostrar un número de "x" cifras a un número con un número de cifras menor. Para ello simplemente he hecho uso de una función longitud, con la que recuerdo el número de cifras que tenía el último número mostrado para, si el siguiente número tiene menos, limpiar la pantalla antes de mostrar el nuevo, algo como:
if (longitud(num_anterior)>longitud(numero_nuevo))
LCD.clearDisplay();
LCD.drawInt(numero_nuevo);
*****************************************************************************
CUADRADO DE CALIBRACIÓN DE MOVIMIENTO
Una vez aprendidos los conceptos básicos para el manejo de los motores y el LCD, el siguiente paso es comenzar a navegar. Para esta tarea la clase elegida es TachoPilot, ya que provee métodos para que realizar un recorrido sea más sencillo que ir comandando continúamente el movimiento de cada uno de los motores. El primer paso para utilizar estos métodos es instanciar un objeto definiendo la configuración del robot por medio del constructor, concrétamente la distancia que hay entre las ruedas y el diámentro de éstas.
 |
| Imagen 1 |
Para las pruebas de precisión, realicé un acople (imagen 1) con el quede precisar mejor el punto final donde finaliza y comienza la trayectoria. De tal modo que el robot pudiese sujetar un bolígrafo y de esta forma dejar marcado el recorrido que va siguiendo el robot a lo largo de los ejes "x" e "y", además de precisar mejor el punto final donde finaliza y comienza la trayectoria.
Aprovecharé este apartado para dar respuesta a dos cuestiones que se nos formulan en el enunciado de la práctica:
- ¿Cual es aproximadamente el rango de error cometido?
Para responder a la pregunta realicé un test de pruebas sobre una cartulina marcando, el propio robot, el recorrido que iba realizando (como se ve en el vídeo). Tras 10 ejecuciones, se podía comprobar que todas los intentos finalizaban en un rango de aprox. 1.5cm², siendo este el rango de error.
- ¿Existe un error sistemático?
Es complicado responder esta cuestión, ya que es me resultó muy difícil hacer que el robot comenzase siempre en exactamente la misma posición y con la misma orientación. Tras las 10 pruebas he de decir que no, ya que finalizaba con bastante precisión pero no fallaba siempre de una misma forma, sino que el error oscilaba en "+-x" y "+-y".
*****************************************************************************
MATRIZ DE COVARIANZA
Este apartado trata de mostrar, por medio de la covarianza, la dependencia que existe entre la distancia recorrida (eje y) y el error que se produce (eje x) al ejecutar un recorrido rectilíneo 20 veces. Ya que los cálculos son simplemente aplicar la fórmula que viene en el enunciado, prefiero omitir todos estos pasos y centrarme en responder la dos cuestiones que se nos plantean:
¿Cómo podr a generalizarse esta matriz para cualquier recorrido en línea recta?
Como ya he señalado, el objetivo de la covarianza es ver la dependencia existente entre dos variables estudiadas, es decir, si existe una relación directa que determine si a medida que aumenta un valor, también aumenta el otro, o bien si a medida que aumenta uno el otro disminuye. Por lo tanto, una vez que tenemos ese valor, podemos generalizar para cualquier otro recorrido, ya que sabemos la relación que tiene nuestro robot entre el error que comete y la distancia que recorre.
¿Cómo podr a generalizarse esta matriz para cualquier recorrido en línea recta?
Como ya he señalado, el objetivo de la covarianza es ver la dependencia existente entre dos variables estudiadas, es decir, si existe una relación directa que determine si a medida que aumenta un valor, también aumenta el otro, o bien si a medida que aumenta uno el otro disminuye. Por lo tanto, una vez que tenemos ese valor, podemos generalizar para cualquier otro recorrido, ya que sabemos la relación que tiene nuestro robot entre el error que comete y la distancia que recorre.
*****************************************************************************
VISUALIZACIÓN DE LA TRAYECTORIA
En esta última aplicación se combinan los métodos aprendidos para programar el recorrido de un robot con los vistos para mostrar en la pantalla determinada información.
El objetivo es conseguir mostrar en el LCD el recorrido (a escala) que realiza el robot. Para ello, he pensado hacer 2 tipos de recorridos, y así ver cómo el mostrado se relaciona directamente con el realizado por el robot. La aplicación queda entonces como un menú, en el que si seleccionamos el botón derecho el robot realizará la figura de un cuadrado, mientras que si seleccionamos el botón izquierdo realizará la figura de un rectángulo.
Para programar esta aplicación, parto del código implementado en el cuadrado de calibración y la base está en establecer dos estados, girando y avanzando, de tal forma que cuando avanza tenemos que saber en que dirección lo hace por medio de senos y cosenos del ángulo hacia el que está orientado, y si gira, debemos actualizar dicho ángulo. A continuación muestro un vídeo sobre como se va mostrando el recorrido que realiza el robot, he de decir que por comodidad lo mantengo sujeto en la mano ya que a medida que avanza sería más complicado poder mostrar la pantalla:
