Mostrando entradas con la etiqueta wii. Mostrar todas las entradas
Mostrando entradas con la etiqueta wii. Mostrar todas las entradas

miércoles, 16 de julio de 2008

Nuevo periférico para el Wiimote

Wii Motion PlusDurante esta semana se celebra en Los Ángeles el E3, una convención sobre videojuegos y videoconsolas. Durante estos eventos las compañías acostumbran a mostrar lo que está por venir. Ayer fue el turno de Nintento, que presentó un nuevo accesorio para el Wiimote, se conoce como Motion Plus, y con él aseguran que el mando gana en sensibilidad, pudiendo recoger movimientos mas precisos.

Imagino que este accesorio sustituye al acelerómetro incluido en el mando por otro mas preciso, ya que el uso de la barra de infrarrojos sigue siendo necesario para ciertos movimientos. Llegará en la primavera del 2009, y espero no poder incluirlo en este proyecto, tal vez en otro, pero en este, no...

También se ha presentado un juego de música, no al estilo del Guitar Hero o SingStar, en este se utiliza el mando de la Wii a modo de Saxofón, de batería, de guitarra... El juego se llamará WiiMusic y promete ser uno de esos juegos orientados al público casual.




Actualización [19 / 07 / 2008]:
Nintendo se plantea la posibilidad de incluir el Motion Plus de serie en los nuevos mandos, dependerá de la aceptación que este periférico tenga en el mercado. Los que nos dedicamos a trastear con estas cosas debemos tenerlo en cuenta, ya que en el futuro es posible que los resultados de un trabajo dependa de la versión del mando de la que dispongamos. Visto en Meristation

martes, 15 de julio de 2008

Polygon

En ocasiones olvido que no es necesario reinventar la rueda, que afortunadamente hay mucho trabajo hecho y que funciona mejor del que podamos desarrollar nosotros en una tarde 'bien aprovechada'.

Ayer estuve leyendo 'Programa como un Pythonista: Python Idiomático', de David Goodger y traducido por Raúl González Duque, donde se recuerda que es bueno revisar los paquetes disponibles para python, que ahorra tiempo. Y así es como hace un rato descubrí la clase Polygon.

Con esta clase creo objetos 'poligonales', y entre muchos de sus métodos está Polygon.center() y Polygon.area(), que me ahorra la vida de unas cuantas neuronas

>>> from Polygon import *
>>> poligono = Polygon(((400, 300), (700, 300), (900, 600), (200, 600)))
>>> poligono.center()
(550.0, 470.0)
>>> poligono.area()
150000.0

Por supuesto, existen mas métodos, pero de momento con estos tengo suficiente. Aunque el centro que calcula esta clase es el geográfico, y no el cruce de diagonales, creo que de momento me servirá. De todas formas siempre puedo ampliar la clase, ya que el código para calcular el cruce de diagonales ya está escrito.

Con la nueva información la interfaz gráfica queda como sigue

lunes, 14 de julio de 2008

Buscando el centro

En una de las aplicaciones anteriores, visualizo la cámara de infrarrojos para ofrecer una muestra visual de 'qué ve el robot'. Para que este pueda orientarse y saber hacia donde va el líder (recordad que los infrarrojos van montados en la parte trasera del primer robot, al que llamo mama-pato) necesitamos conocer el centro de la figura formada por los cuatro puntos. Con esta información, en principio, sabremos si debemos desplazarnos a la izquierda o a la derecha.

¿Cómo encontramos ese punto?, la figura que se forma con los cuatro puntos es un cuadrilátero. Conocemos los puntos que lo forman (A, B, C, D) y que las diagonales pasan por los puntos AC y BD.



Primero calculamos las ecuaciones de ambas diagonales a partir de la ecuación general de la recta:
y = m*x + n

Conocemos dos puntos, por lo que tenemos un sistema de dos ecuaciones:

Y_A = m*X_A + n
Y_C = m*X_C + n

De donde obtenemos m_1 y n_1, para m_2 y n_2 utilizamos las mismas ecuaciones con los puntos B y D

Ya tenemos las rectas de las diagonales, para saber donde se cruzan no tenemos mas que formar un nuevo sistema de ecuaciones con ambas rectas y despejar X e Y:

Y = m_1 * X + n_2
Y = m_2 * X + n_2

El nuevo punto (X, Y) representa un punto central que permitirá al robot saber hacia donde debe dirigirse para seguir a 'mama-pato'

En ocasiones creo que el universo está empeñado en llevarme la contraria. He repasado este razonamiento varias veces, lo he contrastado con artículos encontrado a lo largo de internet, he revisado muchas veces 'mis cuentas' y aún así, una vez implementado, el punto central no siempre aparece donde debe... como odio al universo...

jueves, 26 de junio de 2008

Aplicación para el patito

La anterior entrada hacía referencia a una interfaz gráfica para ver de forma mas bonita el robot que hará de guía. Ahora le ha tocado el turno al otro robot. Esta aplicación es muy similar a la anterior, con mínimos cambios:


  • Se ha eliminado la velocidad del robot, pues esta ya no es controlable, será el propio robot quien establezca la velocidad a la que debe moverse.

  • Se ha incluido una imagen que representa un rectángulo con los cuatro puntos 'vistos' por la cámara de infrarrojos del wiimote. Nos da una idea de que está viendo el robot a tiempo real. Él se basará en estos puntos para determinar la distancia con su 'mamapato' y la dirección a tomar.

  • Como tonterías añadidas, se puede cambiar los colores y la resolución del visor

martes, 24 de junio de 2008

Otra aplicación mas

Después de varias intentonas, al fin he conseguido una aplicación gráfica útil para mis propósitos. En esta ocasión es un interfaz gráfico para controlar el robot de cabeza, o "Mama Pato". Una vez han sido conectado Wiimote y Brick por medio de la cruceta del mando puede controlarse el robot como si de un coche teledirigido se tratase.

No tiene nada especial, activar algunas 'pijotadas' para el mando como leds o vibración, controlar la velocidad de movimiento del robot...

lunes, 26 de mayo de 2008

Comienzan a salir las cosas

Bien, después de muchas horas de desesperación creo estar cerca de poder usar el wiimote para conocer la distancia recorrida por el robot, o en otras palabras, tener un sistema de odometría fiable.

Primero unos repasos de la física del instituto. Si disponemos de un objeto que se desplaza a lo largo del espacio (s) y medimos el tiempo (t)que invierte en este desplazamiento, podemos obtener su velocidad (v), con algo tan simple como derivar el espacio respecto del tiempo

v = s / t

Donde s corresponde al incremento del espacio (s1 - s0) y t al incremento del tiempo (t1 - t0). Bien, si derivamos de nuevo la velocidad respecto al tiempo, podremos obtener la aceleración del objeto. Siendo esta aceleración un movimiento conocido por todos como "movimiento uniformemente acelerado".

Para recorrer el camino al contrario, simplemente tenemos que calcular las integrales de estos valores respecto del tiempo, es decir, conociendo la aceleración (a):

v = v0 + a(t - t0)

y el espacio:

s = s0 + v0(t - t0) + 1/2 (a (t - t0))

Ahora el experimento, en un movimiento acotado de 30 cm desplazamos el mando por la horizontal desde una v0 = 0 hasta una velocidad final también 0, los resultados obtenidos son los siguientes:

  • La aceleración tiene errores de lectura


  • La velocidad desciende por debajo de cero (como si el objeto invirtiese la dirección del movimiento)


  • Y el espacio retrocede a lo largo del tiempo aproximándose a cero


Bien, con esto no voy a ninguna parte, así que aplicando el filtro de kalman a la aceleración, los resultados obtenidos son los siguientes:

  • La aceleración se ha suavizado, ahora se ajusta mas a la realidad


  • La velocidad no ha tenido mejoras, seguimos cayendo por debajo de cero


  • Y como era de esperar, el espacio "retrocede"



Así que utilizamos de nuevo el filtro de kalman, pero esta vez aplicado primero a la aceleración y luego a la velocidad. Los resultados son los siguientes:

  • La aceleración filtrada, obtiene una gráfica mas real


  • La velocidad, esta vez si desciende de forma normalizada, sin llegar a 0, pero sin tomar valores negativos


  • Ahora si, el espacio aumenta, pero sobrepasa los 30cm del experimento hasta el doble



Y la última prueba, filtrando el espacio con los datos a su vez filtrados de velocidad y aceleración. Las gráficas correspondientes a estas dos últimas no varían

  • Pero retrocedemos en los resultados esperados para el espacio



Conclusiones: El filtro de kalman resulta tremendamente útil para obtener una información mas cercana a la realidad que la obtenida por medio de las mediciones, ya que nos permite eliminar el ruido. Sin embargo, sólo en una de las pruebas el resultado espacial ha estado cercano a los 30cm del experimento (con un error de 1cm). Así que algo he dejado en el aire, tal vez sean los ajustes del filtro.

¿alguna sugerencia?

viernes, 23 de mayo de 2008

Wiimote GUI

Como ayer era incapaz de mirar el mando de la wii sin sentir deseos de matar a Mario decidí seguir trabajando con ello, pero yendo por la tangente. Así que programé en GTK una interfaz gráfica para ver las lecturas del mando.

La cosa es bastante simple, y no tiene otra misión que pintar en una ventana lo que hasta ahora he visto por consola, pero haciendo las pruebas he visto que un problema que ya apareció se intensifica un poco. Sufro un desbordamiento en la pila de mensajes enviados por el mando, ¿soy lento recogiendo los mensajes?, ¿lento procesando?, ¿será la biblioteca que uso de python?

El caso es que un programa similar creado por los chicos de cwiid no adolece de este desbordamiento y no pone al portatil al borde de la levitación, por lo que me inclino en pensar que es python el culpable (¡no voy a ser yo!)

jueves, 17 de abril de 2008

Aceleraciones y ajustes

Llevo ya muchos días enfrascado trabajando con el acelerómetro del mando de la wii, este dispone de un acelerómetro ADXL330 para medir la fuerza que actúa sobre el mando en los tres ejes. De momento sólo trabajo con la información del eje Y, ya que el mando estará colocado de forma horizontal con los mandos hacia arriba y la cámara de infrarrojos hacia delante.

Con esta información no pretendo determinar la velocidad a la cual se desplaza el robot, sino la distancia que avanza. Si recordamos un poco de la física que estudiamos en el instituto (ha llovido mucho desde entonces...) derivando la distancia recorrido respecto del tiempo obtenemos la velocidad, y derivando de nuevo esta llegamos a la aceleración. Deshaciendo este camino llegamos de nuevo a la distancia.

Las pruebas realizadas no me han dejado muy contento, los datos obtenidos de la realidad distan bastante de los valores esperados, por lo que Javi me sugirió que utilizase el filtro de Kalman para suavizar el impacto de estos. Este filtro utiliza la información de la medición para intentar 'adivinar' con la mayor probabilidad posible el valor que debería tener el siguiente dato (en relación al que ha tenido). Si queréis ahondar un poco más, os dejo el enlace de la socorrida wikipedia.

Una vez implementado este filtro en python he pasado a realizar nuevas mediciones y he podido ver como los datos filtrados se ajustan más a la realidad que los propios datos leídos del mundo real.

Ahora sólo queda saber si con la aceleración filtrada puedo obtener una medida del espacio coherente, que será a lo que dedique los próximos experimentos.

Os dejo un gráfico que representa la aceleración del mando en su eje Y en un tiempo de aproximadamente dos segundos.


miércoles, 2 de abril de 2008

El robot que era tímido

Para que el wiimote y el NXT empiecen a trabajar juntos, he construido un robot muy sencillo que acopla el mando de la wii. El algoritmo de trabajo es muy sencillo a falta de unas cuantas pruebas mas, al recibir una señal de infrarrojos el robot gira 180 grados para "huir" de la señal.

En las pruebas se han producido giros superiores a 180 grados, esto ocurre por que se detectan varios mensajes que indican la presencia de una fuente emisora, por lo que son varios semi-giros los que se producen.

Como viene siendo normal, he utilizado python junto con nxt-python y cwiid, todo servido en una bonita máquina derivada del modelo básico que viene con la caja de lego.


Los ojos de Benito


Estoy haciendo pruebas con la cámara de infrarrojos que incorpora el wiimote, esta cámara nos proporciona una resolución de 1024x768 con una profundidad de color de 1 bit y es capaz de ver hasta cuatro puntos de forma simultánea.

Con la librería pygame de python he escrito un pequeño programa para "ver" tal y como lo hará el robot con la cámara del mando, y este es el resultado


La prueba ha sido hecha con el mando de la minicadena, emitiendo de forma continua (atendiendo a la repetición de la tecla back-track) en línea horizontal con el mando. La verdad, ahora mismo no se como interpretarlo, debo darle aún un par de vueltas para saber como ver con estos ojos nuevos, seguiré informando ;)

jueves, 27 de marzo de 2008

De infrarrojos y pantallas de leds

Seguimos jugando con el mando de la wii. Buscando la mejor forma de aprovechar sus características infrarrojas he dado con el proyecto de Johnny Chung Lee, en él comenta como ha utilizado las capacidades del mando, y me ha parecido muy interesante.

Usa una pantalla de aproximadamente 100 leds emisores de infrarrojo (como los que llevan incorporados las cámaras de visión nocturna) con una batería de 9v (por que si no dudo que funcione). Dentro de esta pantalla aloja el mando y utiliza un material reflectante para que el mando "vea" las señales infrarrojas. Creo que un vídeo ilustrará mucho mejor lo que acabo de contar



Y mi idea es utilizar un modelo similar. Montar una placa de dimensiones apropiadas alrededor del mando, y todo ello acoplado en el robot. Como es lógico, los objetos deberán estar forrados con un material reflectante (como el papel aluminio) y de esta forma el robot en su conjunto podrá identificar el obstáculo y evitarlo

He echo unas pruebas caseras con el mando de la tele y todo ha salido como se esperaba (nunca dejaré de asombrarme cuando las cosas me funcionan a la primera). Ahora probare a dibujar en la pantalla la fuente emisora, algo parecido a lo que hace John en el vídeo. Ya os contaré

Haciendo las pruebas me ha sucedido algo que me ha desconcertado un poco y seguro que alguno de vosotros sabe por qué sucede. Sobre "el taller" tengo un flexo con una bombilla corriente (no es de bajo consumo) y el mando recogía el flexo como fuente emisora al ser reflejada la luz en el papel aluminio. Imagino que sucede por que la luz se descompone en el papel, pero si alguno de vosotros lo sabe con certeza le agradeceré que me lo aclare. He probado con linternas y otras lámparas pero no hubo éxito, sólo con el flexo.

Documentación pyton-cwiid

A raíz de las notas que he tomado y las pruebas realizadas he escrito una breve documentación de la biblioteca cwiid para python. No está completa y seguramente contenga errores y equivocaciones, por lo que si veis alguna cosa rara o tenéis alguna sugerencia no dudéis en comentarlo.

(revisión 1.0)

cwiid.__doc__
CWiid Wiimote Interface

cwiid.__file__
/var/lib/python-support/python2.5/cwiid.so

cwiid.__name__
cwiid

Constantes

BATTERY_MAX
Indica el nivel máximo de batería, se utiliza para determinar el nivel actual de batería

BTN_UP
BTN_DOWN
BTN_LEFT
BTN_RIGHT
BTN_A
BTN_B
BTN_1
BTN_2
BTN_MINUS
BTN_PLUS
BTN_HOME
Botones del Wiimote

CLASSIC_BTN_A
CLASSIC_BTN_B
CLASSIC_BTN_DOWN
CLASSIC_BTN_HOME
CLASSIC_BTN_L
CLASSIC_BTN_LEFT
CLASSIC_BTN_MINUS
CLASSIC_BTN_PLUS
CLASSIC_BTN_R
CLASSIC_BTN_RIGHT
CLASSIC_BTN_UP
CLASSIC_BTN_X
CLASSIC_BTN_Y
CLASSIC_BTN_ZL
CLASSIC_BTN_ZR
CLASSIC_LR_MAX
CLASSIC_L_STICK_MAX
CLASSIC_R_STICK_MAX
Botones del mando clásico

CMD_LED
CMD_RPT_HOME
CMD_RUMBLE
CMD_STATUS
En la biblioteca de Python no tienen aplicación

ERROR_COMM
ERROR_DISCONNECT
Tipos de error

EXT_NONE
EXT_NUNCHUK
EXT_CLASSIC
EXT_UNKNOWN
Las distintas extensiones que soporta el mando

FLAG_CONTINUOUS
Habilita informes continuos del Wiimote

FLAG_MESG_IFC
Habilita el interfaz basado en mensajes (a través de callback)

FLAG_NONBLOCK
Provoca que get_mesg() se falle en lugar de bloquearse esperando un mensaje si la cola está vacia

FLAG_REPEAT_BTN
Se envía un mensaje por cada botón pulsado, aunque este no haya cambiado de estado

IR_SRC_COUNT
IR_X_MAX
IR_Y_MAX
Definiciones para el IR

LED1_ON
LED2_ON
LED3_ON
LED4_ON
Valores para encender/apagar los led

MAX_READ_LEN
Longitus máxima que puede leerse

MESG_ACC
MESG_BTN
MESG_CLASSIC
MESG_ERROR
MESG_IR
MESG_NUNCHUK
MESG_STATUS
MESG_UNKNOWN
Tipos de mensaje recibidos

NUNCHUK_BTN_C
NUNCHUK_BTN_Z
Botones del Nunchuk

RPT_ACC
RPT_BTN
RPT_CLASSIC
RPT_EXT
RPT_IR
RPT_NUNCHUK
RPT_STATUS
Establecen los distintos tipos de informe (reporting mode) del wiimote. Cada uno determina que dispositivo está activo y que datos deben ser enviados al host. Cada flag especifica un bit, por lo que deben establecerse por medio de funciones OR

RW_DECODE
RW_EEPROM
RW_REG
Flags para los registros del wiimote

X
Y
Z
Identificadores de los distintos ejes del wiimote

Métodos

Wiimote(bt_addrs)
Parámetros
bt_addrs: Dirección Bluetooth del wiimote

Descripción
Conecta con el Wiimote especificado o con el primero que encuentre si no se especifica mando

Valor de retorno
Un objeto Wiimote si la conexión ha tenido éxito

Class Wiimote()
Una vez creado un objeto de tipo Wiimote a través de cwiid.Wiimote() disponemos de los siguientes atributos y métodos para esta clase


Atributos
state
Diccionario con el estado actual del mando

mesg_callback
Función para tratar los mensajes enviados por el wiimote. Una vez se pone a funcionar el mando en un modo RPT_XXX este envía mensajes cada vez que sucede un evento. Estos mensajes son tratados con la función indicada en este atributo (La función debe haber sido declarada anteriormente)

rpt_mode
Modo de informes del mando: RPT_ACC, RPT_BTN, RPT_CLASSIC, RPT_IR, RPT_EXT, RPT_NUNCHUK, RPT_STATUS

led
Atributo para activar/desactivar los led
Ej: wiimote.led = cwiid.LED1_ON
wiimote.led = not cwiid.LED1_ON

rumble
Atributo para activar/desactivar la vibración
Ej: wiimote.rumble = 1

Métodos

close()
Descripción
Cierra la conexión con un objeto Wiimote

enable(flags)
Parámetros
FLAG_CONTINUOUS, FLAG_MESG_IFC, FLAG_NONBLOCK, FLAG_REPEAT_BTN

Descripción
Habilita los flags indicados

disable(flags)
Parámetros
FLAG_CONTINUOUS, FLAG_MESG_IFC, FLAG_NONBLOCK, FLAG_REPEAT_BTN

Descripción
Deshabilita los flags indicados

get_acc_cal(extension)
Parámetros
EXT_NONE, EXT_NUNCHUK, EXT_CLASSIC, EXT_UNKNOWN

Descripción
Devuelve una tupla ( (X,Y,Z) , (X,Y,Z) ) con la información sobre la calibración del acelerómetro

Valor de retorno
Tupla ( (X,Y,Z) , (X,Y,Z) )

get_mesg()
Descripción
Devuelve un mensaje de la cola, estos mensajes se recuperan por medio de "callback" o de esta función

Valor de retorno
Mensaje mas antiguo de la cola

read(flags, offset, lenght)
Parámetros
flags: RW_EEPROM, RW_REG, RW_DECODE
offset: Dirección de inicio
lenght: Longitud

Descripción
Lee datos desde el Wiimote, utiliza los flags RW_EEPROM, RW_REG (mutuamente exclusivos)para leer desde la memoria EEPROM o desde el registro. El flag RW_DECODE realiza cualquier decodificación de los datos leídos si es necesario.

Valor de retorno
Los datos leídos

write(flags, offset, buffer)
Parámetros
flags: RW_EEPROM, RW_REG, RW_DECODE
offset: Dirección de inicio
buffer: Información a escribir

Descripción
Escribe datos en el Wiimote, utiliza los flags RW_EEPROM, RW_REG (mutuamente exclusivos)para leer desde la memoria EEPROM o desde el registro. El flag RW_DECODE es ignorado.


request_status()
??


Referencia
http://abstrakraft.org/cwiid/wiki/libcwiid



miércoles, 26 de marzo de 2008

Mi coche de carreras

Tras la desesperación de anoche y la angustia de esta mañana he ido a pasar frío y correr durante un buen rato para aclarar las ideas. Con mucha paciencia y la ayuda de IDLE (el enésimo IDE para python que he probado) he escrito una breve documentación para cwiid. Tengo intención de subirla, por si le resulta útil a alguien.

Gracias a la gente de CRySOL y a la demo escrita en python que viene junto al paquete de cwiid he escrito un pequeño programa para conducir mi propio coche teledirigido utilizando la cruceta del mando. Manejarlo con golpes del mando no es mucho mas complicado, habría que manejar unos eventos en lugar de los otros y los vídeos que he visto con ese manejo no son tan elegantes. Os adjunto un par de vídeos para que veáis el resultado.



En este vídeo se ve la cruceta del mando



Y esta es una foto con parte del taller que tengo montado (no viene a cuento, lo se)



martes, 25 de marzo de 2008

Jugando con la Wii

¡Al fin tengo un mando para la Wii!. después de mucho corretear por Talavera he encontrado una tienda en la que si tenían mandos (de hecho tenían dos mandos, ahora sólo uno). Lleno de alegría e ilusión he puesto camino a casa, con mucho mimo he sacado el mando y le he puesto las pilas (en la caja pone que es un mando, pero a mi me da que esto es un vibrador)

Lo primero, ver si funciona, y como no tengo una Wii, pues a conformarme con el programa de prueba que trae el driver que estoy usando, cwiid (odio profundamente a las personas que desarrollan una API completa y no escriben una puñetera línea de documentación), lo ejecuto y "me llena de orgullo y satisfacción" ver como reconoce el mando a la primera, los botoncitos lucen, el acelerómetro va bien y el infrarrojos... bueno, el infrarrojos no funciona por que no tengo un emisor de infrarrojos, pero a esto ya le encontraremos solución mas adelante.



Ahora que se que funciona el mando, vamos a buscar la biblioteca para python que tengo ganas de caharrear con él. Después de ir y venir, de apt-cachear y pedir ayuda a San Google, encuentro el paquete para ubuntu (python-cwiid) que sólo está disponible para la versión Hardy de Ubuntu, así que toca actualizar algún que otro paquete para poder instalarla.

Bien, ya tenemos la biblioteca, ¡vamos a jugar!, después de fijarme en el código que viene escrito en python para comprobar que el mando funciona, escribo un pequeño script para recuperar la información de acelerómetro. Recuperar... la recupero. Antes dije que odiaba mucho a los desarrolladores que no escriben una jodida (digo jodida por no decir puta, que suena muy mal) línea de documentación para aliviar los sufrimientos del prójimo, pues bien, ahora los odio mucho mas.

Algo que no he contado antes, mas que nada por que no viene a cuento, es que empecé escribiendo código utilizando geany (bueno y ligero), pero le falta completar el código, algo que me resulta enormemente útil cuando no hay documentación alguna (se que los hombres y mujeres de verdad no utilizan estas mariconadas, que con vi es suficiente, pero es que yo no soy ni un hombre ni una mujer de verdad). Luego me pasé a Editra, que mola mazo, pero... le faltan muchas cosas que si ofrece Geany, así que sigo buscando y ahora estoy probando openkomodo, que es muy pesado y me recuerda a mi querido NetBeans. Todo esto, que no tiene mayor importancia, viene por que llevo cerca de dos horas dando vueltas, buscando un método o función que me permita recuperar valores del mando de la wii sin tener que leerme todo el código

Y hoy, hasta aquí. Noto que la neurona patina un poco y creo que será mejor mirar un rato al infinito para que descanse. Mañana volveré a la carga

martes, 26 de febrero de 2008

La partida perfecta

Buscando un poco de información sobre la integración del mando de la wii con el nxt he encontrado este vídeo, así cualquiera gana a los colegas en los bolos...



Podéis encontrar mas información por aquí