Jugando con un Wiimote

Una vez puesto en marcha nuestro robot procedimos a dar el paso final uniendo la librería de reconocimiento a la aplicación gráfica encargada de conectarse con la placa Arduino para transmitirle la información. Para ello, simplemente tuvimos que implementar los métodos encargados de capturar los eventos lanzados por nuestra librería y enviar el mensaje de qué movimiento debía realizar nuestro robot.

En el siguiente vídeo se puede ver a Alberto controlando el robot con el mando:

El sistema electrónico que controla el robot está basado en un Arduino Duemilanova. Es una pequeña placa basada en un micro controlador ATmega168 o ATmega328 x(en nuestro caso la placa lleva el 328). Esta placa cuenta con una memoria flash de 32 KB de los cuales 2KB son usados como bootloader. Cuenta con una SRAM de 2KB , una EEPROM de 1KB y trabaja a una frecuencia de reloj de 16MHz.El robot funciona mediante tres ruedas de las cuales dos son las que ejercen la fuerza motora que se encuentran situadas en la reductora. La tercera rueda está en la parte delantera que es controlada por el servo para ir variando la dirección. Para hacer control de la reductora hemos añadido un componente eléctrico extra para el control de los motores basado en un puente en H mediante el circuito integrado L293D con diodos integrados.

Simplemente en nuestro caso, hemos conectado varios pines del arduino configurados como salidas digitales para poder controlar los motores. La alimentación de los motores la hemos conectado al pin de 5V para que lo alimente la propia placa. La reductora esta compuesta por dos motores de continua que dependiendo de la tensión y corriente en sus bornas tendrá mayor o menor potencia.

Para controlar el servomotor hemos conectado el pin 9 configurándolo como un servo mediante el uso de la librería servo que viene implementada en el entorno de desarrollo de Arduino (en este caso servo.attach(pin) para establecer el pin que es usado como servo).

Aqui os dejamos un video donde explicamos en directo las conexiones hardware de nuestro dispositivo.

Una vez que habiamos depurado y terminado la aplicación que se iba a encargar de procesar los gestos pasamos a desarrollar el código del robot que ibamos a usar en este caso.  Pudimos reciclar parte del código del robot que empleamos para la competición ya que los estados que se encargan de realizar los movimientos del robot estaban ya implementados.

Reconfiguramos los estados del robot de tal forma que las condiciones necesarias para realizar los movimientos fuesen a partir de los datos recibidos por el puerto USB en lugar de los sensores.

Como en el caso del Coldfire, hacemos uso de un loop donde residirá el programa de control robot y que se estará ejecutando constantemente. En el programa principal podemos apreciar que se dan cinco estados distintos que representan el reposo, movimiento a la izquierda, movimiento a la derecha, movimiento hacia adelante y movimiento hacia atrás.

// Indicamos que estamos en reposo

valordefecto=10;

// Comprobamos si tenemos datos en el puerto serie

if(Serial.available()>0){

// Obtenemos los datos del puerto

// Escribimos por pantalla (Para depuracion)

valordefecto= Serial.read();

delay(10);

Serial.println(valordefecto);

}

Al principio del bucle, hemos realizado una comprobación para ver sí el sistema ha recibido datos por el puerto USB. Los datos recibidos son almacenados en una variable auxiliar para luego comprobar si corresponde al inicio de uno de los movimientos. Una vez realizado esto pasamos a hacer los saltos entre estados mediante un switch.

switch(valordefecto){

case 119:

grados = 90;

servo.write(grados);

delay(100);

digitalWrite(motorDer0, HIGH);

digitalWrite(motorDer1, 0);

digitalWrite(motorIzq0, HIGH);

digitalWrite(motorIzq1, 0);

delay(700);

break;

Continue reading

Una vez integrado el método DTW en la lógica de nuestra librería de reconocimiento de gestos comprobamos que su funcionamiento era el correcto gracias a la aplicación gráfica que hemos desarrollado de forma conjunta para simplificar las cosas y como ejemplo de la librería.

La versión final de la interfaz será la siguiente:

Como se indicaba en la anterior entrada, ya tenemos la conexión con nuestra placa Arduino y el robot construido. Falta depurar el movimiento del mismo para que sea correcto y podremos dar por concluido el desarrollo del reconocedor de gestos así como la dos mejoras.

Una vez finalizada la parte del reconocedor de gestos y siguiendo con las pautas descritas en nuestra practica, pasamos a desarrollar la comunicación serie de nuestra aplicación con una placa Arduino.

En este caso vamos a reutilizar uno de los robots que presentamos a un concurso de robótica en la Xuventude Galiza Net que se celebró recientemente. Nuestra intención es usar el reconocedor para que el robot velocista actúe en función de nuestros gestos.

Para ello tuvimos que investigar cómo podemos hacer la comunicación entre una aplicación en C# y el propio robot. En un principio no hubo muchas complicaciones para configurar el robot para que obtuviese los datos del puerto USB.

Para el envío de datos recurrimos a usar un ejemplo de una comunicación serie en C# configurada para que usara el puerto que usaba el robot para enviarle los datos. En este caso se hacía que tomara el carácter que se pulsaba en el teclado una vez establecida la comunicación y se le enviase al robot.

En el programa que se implementó en el robot, dependiendo del carácter recibido se haría un movimiento u otro.  Se probó esto y observamos que el robot respondió correctamente a los datos que enviábamos.

Una vez probado esto pasamos a implementarlo en nuestra práctica.

Una vez que tenemos el sistema corriendo sin problemas con el mando de la wii, pasamos a implementar el algoritmo que íbamos a usar para poder identificar los gestos con los patrones que tendríamos registrados.
Para ello con ayuda de las diapositivas del departamento y una vez que Juancho nos explicara el funcionamiento de este pasamos a implementar el algoritmo.
El algoritmo empleado es el mismo al explicado en las diapositivas para el reconocimiento de voz. Se hace una matriz en el cual vamos a ir calculando unos puntos a partir de los datos del patrón en nuestra base de datos y las muestras capturadas. El sistema primero necesita hacer los cálculos de la primera fila y la primera columna. Una vez calculados pasamos a calcular el resto de puntos internos hasta llenar completamente la matriz.

Esto se ve reflejado en la diapositiva que podemos encontrar en la presentación de reconocimiento de voz de LSED.

Las ejes, como se muestran en la imagen, se calculan haciendo la distancia euclídea entre el punto muestra y el del patrón sumándole el punto calculado anteriormente. En el caso de los puntos internos se hace lo mismo pero en este caso se le suma el punto más pequeño de los más cercanos.

Una vez calculada toda la matriz, el valor más pequeño será el que se encuentre en la esquina opuesta al origen. Con este valor vamos comparando el resto de patrones almacenados y devuelve como resultado aquel patrón con el que guarda la mínima distancia.

Aquí dejo una captura de imagen del debug del algoritmo

En la segunda revisión del proyecto por parte del profesorado y del resto de alumnos de prácticas especiales, presentamos el avance que habíamos realizado en nuestro proyecto, qué errores habíamos encontrado, los cambios en la interfaz gráfica y, por sorpresa, el proyecto funcionando de forma completa tras haber añadido lo que faltaba la noche anterior.

Podéis descargaros la presentación a continuación:

Presentación del proyecto

Aquí tenemos una pequeña demostración de qué es lo que hemos conseguido hasta el momento presentado por Alberto.

Una vez  implementados los estados del sistema reconocedor de gestos hicimos una serie de comprobaciones con el mando de la wii para ver si el flujo de la maquina de estados era el correcto.
Nos dimos cuenta que tras varios pruebas con el mando el sistema reaccionaba de manera inesperada. El gesto capturado no correspondía en algunos casos con el gesto que realizábamos. El error en este caso era mínimo pero peculiar, al parecer al dibujar la señal había muestras que no se dibujaban como debía (primordialmente las primeras muestras del gesto).

Para poder analizar este fallo con mayor detalle, se implementaron unas trazas dentro de del programa para ver cómo reaccionaba el flujo de ejecución de la aplicación.

Para ello abríamos un fichero de texto plano en el cual se irían guardando las muestras capturábamos y a su vez fuese indicando en qué estado nos encontrábamos.

Tras muchas pruebas, se podía observar por los datos obtenidos en el fichero que el fallo ocurría en la ventana entre el umbral 1 y el umbral 2. Esto se debía a que al registrarse el gesto parte de este era desechado por el sistema considerándose como un “falso gesto”. Esto se debía a que la señal en esta zona no evolucionaba con suficiente rapidez como para alcanzar el 2 umbral. Debido a esto se alcanzaba el margen de tramas antes de decidir si era un “falso gesto” y por lo tanto las tramas recolectadas hasta ahora eran eliminadas.

Esto se recoge de manera más clara en el gráfico que recoge los datos del fichero que se muestra a continuación.

Nuestra máquina de estados tiene dos modos de funcionamiento: el modo reconocedor y el modo entrenamiento.

• Modo entrenamiento: Para poder generar la base de patrones con los que comparar los gestos que realicemos es necesario introducirlos en el sistema. En este modo la máquina de estados funciona como se indicó en la entrada anterior lo único que cuando se llega a Fin de Gesto los datos son almacenados en el fichero de patrones almacenados.

• Modo reconocimiento: en este modo, la máquina de estados obtiene los datos del gesto y cuando llega a Fin de Gesto procede a detectar el gesto a partir de los datos almacenados previamente en el fichero de patrones.

Para cambiar de modo únicamente es necesario seleccionarlo en la opción disponible en la interfaz gráfica:

Cambio de modos

También se muestran en un ListBox los gestos almacenados en el fichero de patrones para que el usuario sepa cuál han sido guardados.