Interferencia entre wrj4P5 y los eventos de mouseMoved con Processing en GNU/Linux Ubuntu 10.10

Introducción.

En días anteriores escribí acerca de como utilizar el wiimote en sketches de Processing bajo GNU/Linux Ubuntu 10.10.  El método detallado funciona bastante bien al menos para el manejo del evento de la presión de los botones del dispositivo, sin embargo he encontrado un problema molesto con el uso de esta librería y del cual no he podido encontrar mayor información.

Si en un sketch en el cual se está manejando el evento de movimiento del ratón (mouse moved) se empareja un wiimote utilizando la librería wrj4P5 se empiezan a generar múltiples eventos sugiriendo que el ratón se está moviendo aunque sus coordenadas no varian!

Aplicación de demostración.

Aplicación de demostración uso de Wiimote con Processing
Aplicación de demostración uso de Wiimote con Processing

Para experimentar con el problema sugerido he creado un sketch muy simple que utiliza la librería mencionada y además maneja el evento de movimiento del ratón.

Este problema ha sido probado en tres equipos, dos portátiles y uno de escritorio, con GNU/Linux Ubuntu 10.10 y 9.10 respectivamente.  Aún no he tenido la oportunidad de experimentar con la aplicación de demostración en Windows.

Una solución temporal.

Por ahora la única solución, para nada elegante, que he encontrado es el verificar si efectivamente el puntero del ratón ha sido movido para garantizar que el supuesto evento si sucedió en realidad.

int lastX;
int lastY;

void mouseMoved()
{
  if(mouseX == lastX && mouseY == lastY)    // There was no movement: avoid this "event"!
  {
    return;
  }
  else    // There WAS movement, update "last" positions.
  {
    lastX = mouseX;
    lastY = mouseY;
  }

  // ... do some stuff ...
}

El sketch puede ser descargado del sitio de demostraciones con la modificación para evitar el problema desactivada.  Para activarla remueva los comentarios al rededor del condicional if(mouseX == lastX && mouseY == lastY) aproximadamente en la línea 66.

Enlaces.

Laberinto 0.2 controlado por wiimote

Introducción.

Preparando un mejor ejemplo para el uso del wiimote con Processing decidí actualizar la versión procedimiental del Laberinto que utilicé como demostración en una charla hace un par de meses.

Con esta mejora es posible conectar el wiimote al sketch y controlar con él al caballero en busca de su tesoro mas preciado: la princesa 🙂  Adicionalmente el wiimote vibrará cuando el caballero se encuentre con ella.

El movimiento del caballero es controlado por el d-pad mientras que el botón de inicio (home) lo teletransporta y el botón #1 reinicia el juego.

Implementación.

Como primera instancia es necesario tener instaladas las librerías requeridas para el uso del wiimote con Processing.

A continuación se realizan las siguientes modificaciones al código base del sketch.

Se importa el paquete de las clases relacionadas con el wiimote.

import lll.wrj4P5.*;

Se establece una referencia global al control.

Wrj4P5 wii;

En el setup se establece la conexión con el wiimote.

void setup()
{
    // ...
    wii = new Wrj4P5(this);
    wii.connect();
}
Se implementa el método buttonPressed para manejar los eventos provenientes del control con la lógica que se mencionó anteriormente: d-pad controla la dirección, home teletransporta al jugador y el botón #1 reinicia el juego.
void buttonPressed(RimokonEvent evt, int rid)
{
  if (evt.wasPressed(RimokonEvent.LEFT))
    moverJugador(LEFT);

  if (evt.wasPressed(RimokonEvent.RIGHT))
    moverJugador(RIGHT);

  if (evt.wasPressed(RimokonEvent.DOWN))
    moverJugador(DOWN);

  if (evt.wasPressed(RimokonEvent.UP))
    moverJugador(UP);

  if (evt.wasPressed(RimokonEvent.ONE))
    reset();

  if (evt.wasPressed(RimokonEvent.HOME))
    teletransportarJugador();
}

La verificación del encuentro entre la princesa y el caballero se realiza en el método moverJugador y sucede cuando la nueva ubicación del caballero no es una pared && es un tesoro, en ese momento se ejecuta la siguiente instrucción para hacer vibrar el control.

wii.rimokon.vibrateFor(400);

Enlaces.

Utilizar el wiimote con Processing en Ubuntu 10.10

Introducción.

En el presente artículo se describen las librerías necesarias para acceder a la información proveniente de un wiimote desde sketches desarrollados en Processing y se implementa un sketch simple para verificar su funcionamiento.

Obtener e instalar las librerías requeridas.

Obtener los siguientes archivos.

wrj4P5 (alpha-011) http://sourceforge.jp/projects/wrj4p5/releases/ wrj4P5.jar
Loc (beta-005) http://sourceforge.jp/projects/wrj4p5/releases/ Loc.jar
WiiRemoteJ (1.6) http://www.world-of-cha0s.hostrocket.com/WiiRemoteJ/ WiiRemoteJ v1.6.zip.gz
BlueCove (2.1.0) http://code.google.com/p/bluecove/downloads/list bluecove-gpl-2.1.0.jar
bluecove-2.1.0.jar

Crear el directorio libraries/wrj4P5/library bajo el directorio de los sketches del usuario.  En mi caso, bajo ~/sketchbook.

$ mkdir ~/sketchbook/libraries/wrj4P5/library

Copiar los siguientes archivos a la ruta recién creada.

  1. bluecove-2.1.0.jar
  2. bluecove-gpl-2.1.0.jar (requerido para Linux)
  3. Loc.jar
  4. WiiRemoteJ.jar
  5. wrj4P5.jar

Con las versiones utilizadas el contenido del directorio queda de la siguiente manera.

$ ls -l ~/sketchbook/libraries/wrj4P5/library

-rw-r–r– 1 jimezam jimezam 547156 2010-12-08 21:27 bluecove-2.1.0.jar
-rw-r–r– 1 jimezam jimezam  89022 2010-12-08 21:26 bluecove-gpl-2.1.0.jar
-rw-r–r– 1 jimezam jimezam  34765 2010-12-08 21:44 Loc.jar
-rw-r–r– 1 jimezam jimezam  91091 2009-03-12 12:00 WiiRemoteJ.jar
-rw-r–r– 1 jimezam jimezam  39825 2010-12-08 21:40 wrj4P5.jar

Además es necesario contar (en mi caso) con las siguientes librerías del repositorio de Ubuntu.

  • bluez
  • libbluetooth3
  • libbluetooth3-dev

Crear un sketch de demostración.

Para esto se utiliza el código fuente del sketch MyFirstWii.

Sketch de demostración
Sketch de demostración

Crear un nuevo sketch en el PDE (File > New) y copie el código fuente de demostración.  Ejecute el sketch para probar el código (Sketch > Run).

Para conectar el wiimote al sketch presione al tiempo los botones 1 y 2 del wiimote por un momento.

Conclusiones iniciales.

  • Sería interesante tener mas control e información acerca del proceso de conexión con el wiimote.
  • La lectura de los botones del wiimote funciona muy bien.
  • La lectura del acelerómetro parece ser incorrecta y el cubo de la demostración gira sin control.
  • Será necesario hacer mas pruebas con estas librerías, incluyendo otras versiones de las mismas.

Enlaces.

Instalación de WiiPresent 0.7.5.2 en GNU/Linux Ubuntu 10.04

Introducción.

Casualmente hoy, hace exactamente un año estaba probando la instalación de WiiPresent 0.7.2 en Ubuntu 9.04, recuerdo que fue terrible, identificar cuales eran las librerías necesarias fue una odisea y compilar, instalar y hacer funcionar las versiones correctas fue un caos.  No tengo buenos recuerdos de ese software.

Ahora para honrrar esos recuerdos, hoy 20 de julio, decidí volver a probar con la versión mas reciente de WiiPresent para ver que tanto ha evolucionado.  Por suerte ya no estan presentes los problemas de librerías y todo es fácil de instalar mediante aptitude.

WiiPresent es una aplicación simple pero muy útil que nos permite manipular las funciones mas utilizadas de los programas de presentaciones (OpenOffice Presentations o Microsoft PowerPoint) mediante el wiimote.  Adicionalmente tiene otras funcionalidades que lo complementan de manera elegante, como la capacidad de controlar el ratón con el acelerómetro o el indicar cuanto tiempo ha pasado de presentación mediante los leds del control y la vibración cada 10 minutos.

Desde el punto de vista funcional tiene una cobertura muy específica: dar soporte a la realización de presentaciones; mientras que otros aplicativos de los que he publicado en anteriormente permiten una mayor flexibilidad y configuración.

Instalación.

Instalar las librerías necesarias.

$ sudo aptitude install libcwiimote3 libcwiimote-dev libx11-dev libxtst-dev

Descargar la última versión disponible de WiiPresent de la siguiente ubicación.

http://dag.wieers.com/home-made/wiipresent/

En este caso, la última versión disponible es la 0.7.5.2.

$ wget http://dag.wieers.com/home-made/wiipresent/wiipresent-0.7.5.2.tar.bz2

Descomprmir las fuentes.

$ bzip2 -d wiipresent-0.7.5.2.tar.bz2

$ tar xvf wiipresent-0.7.5.2.tar

Compilar el software.

$ make

Instalar el software.  Este paso es opcional, es posible ejecutar el software desde la misma ubicación donde acaba de ser compilado.

$ sudo make install prefix=”/usr/local”

Ejecutar el software.

Hay varias opciones interesantes que se pueden utilizar al momento de ejecutar la aplicación.

Modo presentación, se reconecta automáticamente si hay algún problema con la conexión.

$ wiipresent —reconnect –verbose

Especifica la dirección del wiimote, de lo contrario es necesario presionar los botones 1 y 2 del mismo para emparentarlo.  La dirección del wiimote se puede obtener mediante el comando hcitool scan.

$ wiipresent –verbose —bluetooth=XXXXXXX

Utiliza el sensor infrarrojo y una barra sensora para mover el cursor.

$ wiipresent –verbose —infrared

Utiliza el acelerómetro para mover el cursor.

$ wiipresent –verbose —tilt

Indica la duración de la presentación.

$ wiipresent –verbose —length=minutos

La mayoría de estas opciones puede combinarse para lograr una mayor interacción con el wiimote.

Manipulación de la presentación.

Estas son las acciones que permite ejecutar WiiPresent para interactuar con la presentación.

Siguiente slide A ó FLECHA_DERECHA
Slide anterior FLECHA_IZQUIERDA
Poner/Quitar pantalla completa BOTON_1
Aumentar/disminuír zoom/volúmen BOTON_+ / BOTON_-
Cambiar entre aplicaciones BOTON_B + FLECHA_DERECHA
Pantalla negra + silencio BOTON_B + BOTON_2
Escritorio siguiente BOTON_B + BOTON_+
Escritorio anterior BOTON_B + BOTON_-

Enlaces.

Instalación de Wiican 0.2.1 en GNU/Linux Ubuntu 10.04

Introducción.

Después de probar hace un tiempo con wiipresent y CWiid ahora he encontrado a un nuevo contendor: Wiican que tiene un poco mas de GUI y varias promesas para la futura versión 0.3, la cual aparentemente está en progreso.  En su propio sitio web se describen de la siguiente forma.

WiiCan assists on configuration and management of your wiimote under GNU/Linux. It tracks bluetooth connectivity and allows to use and create mappings to adapt your wiimote for use on any application.

Esta sencilla aplicación que se integra a la barra de tareas y ha sido desarrollada en Python, permite de igual manera establecer perfiles para relacionar los botones y movimientos del Wiimote con eventos de la interfaz del sistema operativo, para con ellos controlar las diversas aplicaciones que se ejecutan.

La última versión disponible es la 0.2.1 que fue liberada el 2 de febrero del 2010.

Instalación.

Agregar el repositorio de Wiican a Ubuntu.

$ sudo add-apt-repository ppa:wiicanteam/ppa

Actualizar la lista de paquetes conocida.

$ sudo aptitude update

Instalar Wiican desde el nuevo repositorio.

$ sudo aptitude search wiican

Iniciar automáticamente el módulo de udev con el sistema operativo (si aún no se cuenta con él).

$ sudo -i “echo udev >> /etc/modules”

Iniciar manualmente (necesario únicamente por esta vez gracias al paso anterior) el servicio de udev.

$ sudo service udev start

Iniciar la aplicación.

Seleccione el menú Applications > Accessories > Wiican o ejecute el siguiente comando en el shell.

$ /usr/bin/wiican

Uso.

Al ejecutarse la aplicación agrega un nuevo ícono en la barra de tareas.

Ícono de la barra de tareas asociado a Wiican

Si se hace clic izquierdo sobre el ícono de Wiican se obtendrá la posibilidad de desconectar el wiimote (si hubiera uno conectado previamenta) y un listado de los perfiles disponibles.  Inicialmente se cuenta con dos perfiles: uno para controlar el ratón con el acelerómetro y otro para controlar el juego de Neverball.

Opciones del clic izquierdo.

Haga clic sobre uno de los perfiles para activarlo y presione los botones 1 y 2 del wiimote para emparentar el control y utilizar la aplicación.

Si hace clic derecho sobre el ícono de Wiican tendrá acceso a la opción de configuración y a terminar la aplicación.

Opciones del clic derecho

Enlaces.

Controlar presentaciones con el wiimote en Windows utilizando GlovePIE

Introducción.

De manera análoga a como hace un tiempo expliqué como manipular las presentaciones de OpenOffice Impress con el wiimote desde Linux utilizando CWiid, ahora el turno es hacerlo desde Windows, en este caso la prueba la realicé utilizando Windows 7 RC1 y su funcionamiento puede ser igualmente personalizado según los requerimientos de la presentación y por ende es totalmente compatible con Microsoft PowerPoint.

Hay varias formas de implementar este tipo de solución con el wiimote para este artículo preferí la mas “universal”, es decir, una en la que se utilizara el software mas difundido posible.

Al igual que con la versión de Linux lo que se busca es emular la presión de teclas específicas según el botón del control presionado.  Para este artículo se utiliza entonces GlovePie que es una herramienta muy útil que nos permite implementar lo que requerimos e incluso más aún al incluír un lenguaje elaborado para la preparación de scripts.

Implementación.

1. Descargue GlovePie de la siguiente ubicación.

http://carl.kenner.googlepages.com/glovepie_download

Para este caso se utilizó la versión 0.29.

2. Descomprima el archivo descargado y ubíquelo en su ruta destino.

3. Con un editor de texto (Bloc de notas) edite el siguiente contenido según sus necesidades.  Verifique que el archivo guardado tenga efectivamente la extensión .PIE y no la .txt que agrega automáticamente el editor de texto.  De ser así, corrija este problema antes de continuar.

PageDown = Wiimote.A
PageUp = Wiimote.B

up = Wiimote.Up
down = Wiimote.Down
left = Wiimote.Left
right = Wiimote.Right

Key.NumpadMinus = Wiimote.Minus
Key.NumpadPlus = Wiimote.Plus
Key.Home = wiimote.Home
Key.f5 = wiimote.One
Key.Esc = wiimote.Two

4. Grábelo con un nombre conocido, por ejemplo: Presentaciones.PIE y ubíquelo en una carpeta de su preferencia, que puede ser la misma <ruta>GlovePIEXXXWiimoteScripts.

5. Emparente su wiimote con el sistema operativo.  Para hacer esto haga click sobre el ícono de Bluetooth en su barra de tareas y elija la opción Agregar un nuevo dispositivo (Add a device).

6. Presione simultáneamente los botones 1 y 2 del wiimote para ponerlo en modo de descubrimiento.

7. En el computador seleccione el wiimote tan pronto como sea reconocido: Nintendo RVL-CNT-01.

8. Seleccione la opción de realizar el emparentamiento sin utilizar contraseña alguna (Pair without using a code).

9. Inicie GlovePIE: <ruta>GlovePIEXXXGlovePie.exe.

10. En GlovePIE seleccione el menú File > Open y elija el script recién creado.

11. Para verificar el script (opcional) seleccione el menú Run! > Check for errors.

12. Para ejecutar el script seleccione el menú Run! > Run!.

13. Abra una presentación y utilice el wiimote para manipularla.

Uso.

El script propuesto puede ser totalmente manipulado para ajustarse a los gustos y necesidades de la presentación, sin embargo esta es la funcionalidad básica que yo busco para realizar mis presentaciones.

  • Teclas del cursor: mover la diapositiva / opciones del menú.
  • Botón A: siguiente slide.
  • Botón B: slide anterior.
  • Botones + y –: aumentar y disminuír el acercamiento (no aplica para modo presentación -F5).
  • Botón home: ir al primer slide.
  • Botón 1: entrar en modo presentación.
  • Botón 2: salir del modo presentación / cancelar.

Enlaces.

Experimentando con WiiUseJ en Linux Ubuntu 9.04

Introducción.

WiiUseJ es otra de las prometedoras librerías para manipular la información proveniente del Wiimote desde java que el día de hoy estoy probando después de una primera experiencia con WiiRemoteJ.

Una diferencia importante de esta librería frente a otras probadas anteriormente es que no necesita del complemento de terceras librerías de soporte como Avetana o BlueCove ya que se basa en WiiUse el cual incluye librerías nativas (para Windows y Linux) lo que le permite acceder directamente a la pila de bluetooth del sistema operativo.

Esto es regularmente un punto a favor sin embargo puede llegar a ser una desventaja ya que las librerías al ser nativas deben, especialmente en Linux, corresponder con las versiones correctas de otras librerías a las se enlazan como sucede efectivamente en este momento cuando el release 0.12 fue compilado para libbluetooth 2.0 y esta librería fue actualizada  a la versión 3.0 en Ubuntu 8.10 y posteriores, obligando a que se deban actualizar o compilar nuevamente.

Implementación.

Es necesario importar los siguientes paquetes para la conexión con el wiimote y el manejo de los eventos generados por él.

 import wiiusej.*;
 import wiiusej.wiiusejevents.*;
 import wiiusej.wiiusejevents.utils.*;
 import wiiusej.wiiusejevents.physicalevents.*;
 import wiiusej.wiiusejevents.wiiuseapievents.*;

La clase encargada de manejar los eventos deberá implementar la interfaz WiimoteListener lo que le obligará a implementar los siguientes métodos.

 public void onButtonsEvent(WiimoteButtonsEvent arg0) {}
 public void onClassicControllerInsertedEvent(ClassicControllerInsertedEvent e) {}
 public void onClassicControllerRemovedEvent(ClassicControllerRemovedEvent e) {}
 public void onIrEvent(IREvent arg0) {}
 public void onMotionSensingEvent(MotionSensingEvent arg0) {}
 public void onExpansionEvent(ExpansionEvent arg0) {}
 public void onStatusEvent(StatusEvent arg0) {}
 public void onDisconnectionEvent(DisconnectionEvent arg0) {}
 public void onNunchukInsertedEvent(NunchukInsertedEvent arg0) {}
 public void onNunchukRemovedEvent(NunchukRemovedEvent arg0) {}
 public void onGuitarHeroInsertedEvent(GuitarHeroInsertedEvent e) {}
 public void onGuitarHeroRemovedEvent(GuitarHeroRemovedEvent e) {}

Para la demostración se hizo uso del método onButtonsEvent el cual permite a través del parámetro que recibe de tipo WiimoteButtonsEvent verificar que botón del control fue presionado mediante los métodos isButtonXXXPressed donde XXX puede ser los botones A, B, One, Two, Minus, Plus, Home, Up, Down, Left y Right.

Ejecución.

Se obtuvo la última versión disponible de WiiUseJ, en este caso era la 0.12.

$ wget http://wiiusej.googlecode.com/files/wiiusej%200.12b.zip

$ wget http://wiiusej.googlecode.com/files/WiiuseJ%200.12a%20Javadoc.zip

La segunda descarga es opcional y corresponde con la documentación del API de la librería.

Coo se mencionó en la introducción, las librerías nativas para Linux incluídas en la versión binaria 0.12 se encuentran obsoletas ya que fueron compiladas con libbluetooth 2.0 mientras que las distribuciones actuales ya incluyen la versión 3.0.  Para hacer esto se descarga el siguiente archivo, se descomprime y se reemplaza el archivo libwiiuse.so con la nueva versión.

$ wget http://wiiusej.googlecode.com/files/libwiiuse.zip

Asegúrese de copiar las librerías nativas incluídas con WiiUseJ al directorio raíz de la nueva aplicación.

  • Para Windows: wiiuse.dll y WiiUseJ.dll.
  • Para Linux: libwiiuse.so y libWiiuseJ.so.

De igual manera es necesario contar con el archivo wiiusej.jar en una ubicación conocida.

Para compilar el programa de demostración invocamos el siguiente comando.

$ javac -classpath wiiusej.jar:. WiiUseJTest.java

Para ejecutar el progrmaa de instalación utilizamos el siguiente comando.

$ java  -classpath ../wiiusej.jar:. -Djava.library.path=. WiiUseJTest

Enlaces.

Experimentando con WiiRemoteJ en Linux Ubuntu 9.04

Introducción.

Hace un tiempo (parte 1 y parte 2) hice algunas pruebas acerca de como utilizar el control del Wii (wiimote) desde el PC desarrollando aplicaciones con C# utilizando la librería WiimoteLib de Brian Peek.  Desafortunadamente ni esta librería ni ninguna otra de C# que pudiera encontrar son de plataforma cruzada y por lo tanto no se pueden utilizar desde Linux así que me vi obligado a cambiarme nuevamente a mi lenguaje preferido: Java.

Después de revisar las librerías disponibles obtuve tres candidatos: WiiRemoteJ, WiiUseJ, MoteJ y WiiMote-Simple.

A pesar de que la página de WiiRemoteJ parece haber desaparecido es una de las mas mencionadas y parece ser una de las mas estables.  Requiere de una pila Bluetooth como Avetana o Bluecove para ejecutarse sobre ella.

Implementación.

Básicamente el uso de la librería se basa en la manipulación de un objeto WiiRemote y en la implementación de la interfaz WiiRemoteListener encargada de manejar los eventos provenientes del Wiimote y de sus extensiones.

Las clases se encuentran almacenadas en los siguientes paquetes.

import wiiremotej.*;
import wiiremotej.event.*;

Al implementar la mencionada interfaz es necesario especificar la implementación de los siguientes métodos.

Método Evento
buttonInputReceived Se presionó un botón del wiimote.
disconnected Se desconectó el wiimote.
extensionConnected Se conectó una extensión al wiimote.
extensionPartiallyInserted La extensión recién conectada quedó mal insertada.
extensionUnknown La extensión recién conectada es desconocida.
extensionInputReceived La extensión envía datos al wiimote.
extensionDisconnected La extensión ha sido desconectada del wiimote.
accelerationInputReceived El wiimote ha generado información de aceleración.
IRInputReceived El wiimote ha generado información de su cámara infrarroja.
statusReported Ha sucedido un reporte de estado.
combinedInputReceived Suceso de eventos combinados.

Evento de presión de botones.

 public void buttonInputReceived(WRButtonEvent evt)
 {
     // boolean     isAnyPressed(int buttonMask)    Returns true if any of the given buttons are pressed; otherwise false.
     // boolean     isOnlyPressed(int buttonMask)   Returns true if all of the given buttons are pressed and no others are; otherwise false.
     // boolean     isPressed(int buttonMask)       Returns true if all of the given buttons are pressed; otherwise false.
     // boolean     wasOnlyPressed(int buttonMask)  Returns true if all of the given buttons were pressed and no others are; otherwise false.
     // boolean     wasPressed(int buttonMask)      Returns true if all of the given buttons were pressed; otherwise false.
     // boolean     wasReleased(int buttonMask)     Returns true if one of the given buttons was released; otherwise false.

     if (evt.wasPressed(WRButtonEvent.TWO))
         this.log("2");

     if (evt.wasPressed(WRButtonEvent.ONE))
         this.log("1");

     if (evt.wasPressed(WRButtonEvent.B))
         this.log("B");

     if (evt.wasPressed(WRButtonEvent.A))
         this.log("A");

     if (evt.wasPressed(WRButtonEvent.MINUS))
         this.log("Minus");

     if (evt.wasPressed(WRButtonEvent.HOME))
         this.log("Home");

     if (evt.wasPressed(WRButtonEvent.LEFT))
         this.log("Left");

     if (evt.wasPressed(WRButtonEvent.RIGHT))
         this.log("Right");

     if (evt.wasPressed(WRButtonEvent.DOWN))
         this.log("Down");

     if (evt.wasPressed(WRButtonEvent.UP))
         this.log("Up");

     if (evt.wasPressed(WRButtonEvent.PLUS))
         this.log("Plus");
 }

Evento de desconexión del control.

 public void disconnected()
 {
     this.log("The remote controller was disconnected.");
     wiimote = null;
 }

Eventos de la extensión.

 public void extensionConnected(WiiRemoteExtension extension)
 {
     this.log("An extension has been connected! (" +
     extension.getCode() + "): " +
     this.getExtensionTypeName(extension));

     try
     {
         wiimote.setExtensionEnabled(true);
     }
     catch(Exception e)
     {
         this.log(e.getMessage());
     }
 }

 public void extensionPartiallyInserted()
 {
     this.log("An extension was partially inserted, push it harder next time");
 }

 public void extensionUnknown()
 {
     this.log("The extension is unknown, what are you putting into me ?");
 }

 public void extensionInputReceived(WRExtensionEvent evt)
 {
     // this.log("The extension is sending me some kind of data ... ");
 }

 public void extensionDisconnected(WiiRemoteExtension extension)
 {
     this.log("An extension has been disconnected! (" +
     extension.getCode() + "): " +
     this.getExtensionTypeName(extension));
 }

Evento de aceleración.

 public void accelerationInputReceived(WRAccelerationEvent evt)
 {
     // double     getPitch()         Returns the pitch of the remote, in radians from -PI to PI.
     // double     getRoll()          Returns the roll of the remote, in radians from 0 to 2PI.
     // double     getXAcceleration() Returns the X-Acceleration of the remote, in terms of G's.
     // double     getYAcceleration() Returns the Y-Acceleration of the remote, in terms of G's.
     // double     getZAcceleration() Returns the Z-Acceleration of the remote, in terms of G's.
     // boolean    isStill()          Returns true if the remote is not being moved; otherwise false.
 }

Evento de la cámara infrarroja.

 public void IRInputReceived(WRIREvent evt)
 {
     // IRLight[] getIRLights()       Returns the array of IR lights seen by the IR sensor.
     // int          getMode()        Returns the mode of the IR sensor.    
 }

Evento de reporte de estado.

 public void statusReported(WRStatusEvent evt)
 {
     // double      getBatteryLevel()       Returns the battery level of the remote.
     // boolean[]   getLEDStatus()          Returns the status of the LED lights.
     // boolean     getLEDStatus(int light) Returns the status of the specified light.
     // boolean     isContinuousEnabled()   Returns the status of continuous reporting.
     // boolean     isExtensionConnected()  Returns the status of the extension port.
     // boolean     isSpeakerEnabled()      Returns the status of the speaker.    
 }

Reporte de recepción combinada de eventos.

 public void combinedInputReceived(WRCombinedEvent evt)
 {
     // WRAccelerationEvent getAccelerationEvent()  Returns the acceleration event of this combined event.
     // WRButtonEvent       getButtonEvent()        Returns the button event of this combined event.
     // WRExtensionEvent    getExtensionEvent()     Returns the extension event of this combined event.
     // WRIREvent           getIREvent()            Returns the IR event of this combined event.
 }

Ejecución.

Para el desarrollo de esta aplicación de demostración se utilizó la librería de BlueCove, en este caso en la versión 2.10.  Es obligatorio obtener el paquete bluecove-*.jar mientras que bluecove-gpl-*.jar sólo es requerido bajo Linux.

$ wget http://bluecove.googlecode.com/files/bluecove-2.1.0.jar

$ wget http://bluecove.googlecode.com/files/bluecove-gpl-2.1.0.jar

Además se requiere de la librería WiiRemoteJ.jar, en este caso en la versión 1.6.

$ wget http://www.world-of-cha0s.hostrocket.com/WiiRemoteJ/WiiRemoteJ%20v1.6.zip.gz

$ cp WiiRemoteJ v1.6/WiiRemoteJ.jar .

Se compila el programa de demostración.

$ javac -classpath bluecove-2.1.0.jar:bluecove-gpl-2.1.0.jar:WiiRemoteJ.jar:. WiiRemoteJTest.java

Se ejecuta.

$ java  -classpath bluecove-2.1.0.jar:bluecove-gpl-2.1.0.jar:WiiRemoteJ.jar:. WiiRemoteJTest

Al iniciar la aplicación se debe presionar el botón que dice “Buscar Wiimote” y presionar los botones 1 y 2 del control para ponerlo en modo de descubrimiento.  Después de encontrado los eventos (botón, extensión y desconexión) generados en él deberán ser documentados en la ventana de la aplicación.

WiiRemoteJTest 0.1
WiiRemoteJTest 0.1

Enlaces.

http://www.world-of-cha0s.hostrocket.com/WiiRemoteJ/WiiRemoteJ%20v1.6.zip.gz
http://www.world-of-cha0s.hostrocket.com/WiiRemoteJ/WiiRemoteJ%20v1.6.zip.gz

Controlar presentaciones con el wiimote en Linux Ubuntu 9.04 utilizando CWiid

Introducción.

Otra forma de controlar las aplicaciones desde el wiimote al relacionar botones del control con teclas que afectan las aplicaciones es utilizando la librería CWiid.  Esta opción es mucho mas simple aunque puede llegar a ser mas limitada en su funcionalidad que la basada en WiiPresent.

Instalación.

Instalación de CWiid.

$ sudo apt-get install libcwiid1 lswm wmgui wminput

Los paquetes principales son libcwiid1, wminput y wmgui.

Instalación de LibWiimote.

Realice los pasos para tal fin enunciados en el artículo Instalación de wiipresent en Linux Ubuntu 9.04.

Cargar el módulo del kernel.

$ sudo modprobe uinput

Si se desea que el cambio surta efecto para siempre, es decir, perdure después de reiniciar el sistema operativo realice los siguientes pasos.

  1. $ gksudo gedit /etc/modules
  2. Agregue el nombre del módulo uinput en una línea nueva al final de /etc/modules.

Crear un archivo de configuración para OpenOffice Presentation/Microsoft Powerpoint.

$ sudo vi /etc/cwiid/wminput/Presentations

#########################################################

Wiimote.A       = KEY_PAGEDOWN
Wiimote.B       = KEY_PAGEUP

Wiimote.Up      = KEY_UP
Wiimote.Down    = KEY_DOWN
Wiimote.Left    = KEY_LEFT
Wiimote.Right   = KEY_RIGHT

Wiimote.Minus   = KEY_MINUS
Wiimote.Plus    = KEY_KPPLUS
Wiimote.Home    = KEY_HOME
Wiimote.1       = KEY_F5
Wiimote.2       = KEY_ESC

#########################################################

Las constantes de las teclas pueden consultarse en la siguiente ubicación.

http://abstrakraft.org/cwiid/browser/trunk/wminput/action_enum.txt

Con la configuración propuesta en OpenOffice Presentation/Powerpoint se tienen las acciones siguientes.

  1. Flechas (arriba, abajo, izquierda y derecha): Control del cursor/posición de la imagen.
  2. B: retroceder una imagen.
  3. A: avanzar una imagen.
  4. (menos): disminuye el acercamiento.
  5. + (mas): aumenta el acercamiento.
  6. Home (inicio): va a la primera imagen de la presentación.
  7. 1: inicia el modo presentación.
  8. 2: finaliza el modo presentación/cancelar.

Ejecutar.

Identificar la dirección del wiimote.

$ hcitool scan

Presionar los botones 1 y 2 del wiimote hasta obtener un mensaje similar al siguiente.

00:17:AB:39:DC:B0 Nintendo RVL-CNT-01

Invocar la aplicación.

$ sudo wminput -d -c Presentations <DIRECCIÓN DEL WIIMOTE>

Presionar los botones 1 y 2 del wiimote.

Enlaces.

Instalación de wiipresent en Linux Ubuntu 9.04, un largo camino

Introducción.

Wiipresent es una aplicación muy interesante que nos permite controlar las aplicaciones de Linux desde el Wiimote mediante la conversión entre botones y movimientos del control a combinaciones de teclas.  Es decir, algo análogo a lo que las aplicaciones de Jason Smith e IndyProject le proveen al mundo de Windows.

La aplicación que estoy probando se llama WiiPresent y fue desarrollada por Dag Wieers.  Su instalación fue un tanto truculenta así que amerita ser documentada.

Instalación.

Instalación de libwiimote.

Libwiimote es una librería desarrollada en C que permite el acceso al control del Wiimote desde Linux.  Su código fuente puede descargarse desde la siguiente ubicación.

http://libwiimote.sourceforge.net/

Para la instalación de WiiPresent es necesaria la versión 0.3 o superior de LibWiimote, desafortunadamente la última versión disponible que encontré en Launchpad era la 0.2 por lo cual fue necesario compilar e instalar las fuentes.

Instalar BlueZ si es que no se cuenta con él aún.

$ sudo aptitude install bluez bluez-compat

Descargar la última versión disponible de LibWiimote de la siguiente ubicación.  En este caso se utilizó la 0.4.

http://sourceforge.net/projects/libwiimote/files/

Descomprimir las fuentes.

$ tar zxvf libwiimote-0.4.tgz

$ cd libwiimote-0.4/

Debido a un cambio reciente en el API de HCI es necesario reemplazar la invocación de la función hci_remote_name por su nuevo nombre hci_read_remote_name en las siguientes ubicaciones.

  1. vi src/wiimote_link.c
  2. vi configure.in

Configurar, compilar e instalar la librería.

$ autoconf

$ ./configure

$ make

$ sudo make install

$ sudo ln -s /usr/local/lib/libcwiimote.so.0.4.0 /usr/local/lib/libcwiimote.so

$ sudo ldconfig

Instalación de wiipresent.

Descargar la última versión disponible de la siguiente ubicación.

http://dag.wieers.com/home-made/wiipresent/

Para este caso se utilizó la versión 0.7.2.

$ wget http://dag.wieers.com/home-made/wiipresent/wiipresent-0.7.2.tar.bz2

$ bunzip2 wiipresent-0.7.2.tar.bz2

$ tar xvf wiipresent-0.7.2.tar

$ cd wiipresent-0.7.2

Actualizar el archivo Makefile con la ubicación donde se instaló la librería libwiimote.

$ vi Makefile

Reemplazar la cadena /usr/include/libcwiimote por /usr/local/include/libcwiimote-0.4.0/libcwiimote.

Instalar otras librerías necesarias.

$ sudo aptitude install libxtst-dev

$ sudo apt-get install asciidoc

asciidoc es opcional para la generación de la documentación de la aplicación.  De cualquier manera esta puede accederse desde el sitio web de la librería.

Compilar e instalar la aplicación.

$ make

$ sudo make install

Uso.

Primer paso: conocer la dirección del wiimote.

  1. Abrir una consola.
  2. Ejecutar el comando hcitool scan.
  3. Presionar los botones 1 y 2 del wiimote.
  4. Tomar nota de la dirección del wiimote la cual deberá ser algo similar a la siguiente.

    00:17:AB:39:DC:B0 Nintendo RVL-CNT-01

Segundo paso: ejecutar wiipresent.

  1. Ejecutar la aplicación.

    $ wiipresent -b <DIRECCIÓN DEL WIIMOTE> -r &

  2. Presionar los botones 1 y 2 del wiimote.

Tercer paso: abrir una aplicación como OpenOffice Presentation y controlarla con el wiimote.

  • Izquierda/Derecha: adelantan y retroceden.
  • A: siguiente.
  • Home: va al incio de la presentación.
  • +/-: aumenta y disminuye el volúmen.
  • 1: entra y sale del modo pantalla completa.

Enlaces.