Estoy seguro que muchos de vosotros os habéis quedado encantados con los tutoriales de SceneBeta. Y es que eso de dominar vuestra consola favorita es una fantástica experiencia. Pues bien, para aquellos que os habéis quedado con ganas de profundizar en la programación para Wii os propongo que sigáis esta serie de tutoriales especializada en los mandos y sus extensiones.

En estos tutoriales voy a intentar no utilizar ninguna librería en particular, únicamente tener instalado el devkitpro y os recomiendo que sigáis los cuatro tutoriales de programación (Hechos por csar.ale) ya que daré por sabido todo lo que explica en ellos.

También os diré que pasaré por alto toda la inicialización de vídeo agrupándola en una función que es llamada al principio del programa y que podéis considerar como una caja negra. Aunque realmente no tiene mucha complicación y os animo a que le echéis un vistazo.

Al final de este primer tutorial habréis construido un tester de las capacidades extendidas de los WiiMotes incluido el manejo del sensor de infrarrojos, del joystick  y la lectura del ángulo del wiimote y del nunchuck.

En siguientes tutoriales aprenderemos a usar los acelerómetros, el rumble y el sonido del mando.

Si me animo con esto de los tutoriales la idea es haceros una pequeña introducción de las GX (hasta donde yo sé) con gestión de sprites y manejo de transparencias a través del canal alfa.

Pues termino de daros el rollo y comienzo con el tema.

Construcción de un tester de las capacidades extendidas de los wiimotes

Antes que nada, debemos descargar este pack con nuestras herramientas.

Descargar Pack Profundizando mandos de Wii

Preparando el entorno ¿Qué necesitamos?

Para seguir este tutorial necesitaréis los siguientes elementos:

• Instalar el entorno devkitpro (Para saber más de cómo instalarlo leer los tutoriales de programación de SceneBeta).

Descargaros el zip que incluye:

• El programa básico que contiene la estructura general del programa.
• El makefile.
• El archivo ejecuta.bat. Este archivo deberéis modificarlo con la dirección IP de vuestra Wii. No es estrictamente necesario pero os evitará innumerables viajes del sofá a la Wii y viceversa poniendo y quitando la SD.

Adicionalmente necesitaremos:

• El Notepad++ o el Programer’s Notepad que viene con el Devkitpro.
• El programa wiiload.exe que viene en el archivo comprimido del homebrew channel. Usad el correspondiente a la versión que tengáis instalada ya que hay algunas incompatibilidades con las versiones.

Una vez que tengamos todo esto, cread una carpeta nueva y copiad el contenido del zip y el wiiload en dicha carpeta.

Abrid el archivo ejecuta.bat con el Notepad y sustituir la dirección IP que figura ahí por la de vuestra Wii, grabando el archivo una vez modificado.

Si lo habéis modificado correctamente y tenéis cargado el Homebrew Channel ejecutad este archivo después compilar el programa ya que tranferirá automáticamente el .dol a la SD y lo cargará en la memoria de la Wii.

Vamos con el programa

Como ya visteis en el ButtonTester de csar.ale, lo primero que tenemos que hacer a la hora de gestionar los wpads es inicializarlos. Para ello utilizaremos la función WPAD_Init();

En aquel caso utilizamos un solo wpad, entendiendo que necesariamente era el número 0 el que teníamos en nuestras manos. Para manejar más de un mando o buscar cual de todos está encendido utilizaremos la función WPAD_Probe.

s32 WPAD_Probe(s32 chan,u32 *type);

Para utilizar dicha función pasaremos como parámetro el número de wpad que queremos testear y nos devolverá como resultado un valor mayor o igual que cero si ese mando está conectado y en type en tipo de expansión que tenemos conectada en él.

Como ejemplo, si queremos ver cuál es el primer mando que tenemos activado podríamos usar un bucle como el siguiente:

	u32 expansion_type, pad;
 
	int ret = -1;
 
	while (ret < 0) {
 
		for(pad=0;(pad<4)&(ret<0);pad++) 
 
			ret=WPAD_Probe(pad, &expansion_type);
 
	}
 
	pad--;

Una vez sabemos cuál es el mando que vamos a usar deberemos configurar algunas cosas más de los wiimotes:

WPAD_SetVRes(pad, 640, 480);
 
WPAD_SetDataFormat(pad, WPAD_FMT_BTNS_ACC_IR);
 
WPAD_SetIdleTimeout(300);

La  función WPAD_SetVRes asigna la resolución con la que vamos a trabajar con el IR, siendo 0,0 la esquina superior izquierda de la pantalla y (en este caso) 640x480 la esquina inferior derecha.

La función WPAD_SetDataFormat ajusta el modo de operación de los PADS. Como en este programa vamos a utilizar todas las características de los wiimotes utilizaremos WPAD_FMT_BTNS_ACC_IR, que activa el wiimote, los acelerómetros y el IR, aunque podríamos desactivar algunas funciones para ahorrar batería usando las constantes WPAD_FMT_BTNS, o WPAD_FMT_BTNS_ACC.

Por último la función SetIdleTimeout nos permite configurar el tiempo en segundos de inactividad necesarios para que se desactive el wiimote.

A continuación ya entramos en el típico bucle de control del programa en el que estamos leyendo los wiimotes hasta que pulsamos el botón Home.

	while(1) {
 
		……
 
		WPAD_ScanPads();
 
		u32 pressed = WPAD_ButtonsHeld(pad);
 
		……
 
		if ( (pressed & WPAD_BUTTON_HOME) | (ret < 0)) exit(0);
 
		VIDEO_WaitVSync();
 
	}

En dicho bucle llamamos, en cada ciclo, a la función WPAD_ScanPads para leer el estado de los wpads y comprobamos la pulsación de la tecla Home para permitirnos volver al Homebrew Channel.

Al final del bucle llamamos a la función VIDEO_WaitVSync() para sincronizarnos con el refresco de la pantalla y evitar parpadeos.

Partiendo de este bucle básico vamos a añadir funciones adicionales que nos permitan leer las extensiones del wpad:

Para comprobar y mostrar por pantalla si un botón está pulsado podemos utilizar una sentencia como esta:

		if ( pressed & Boton ) {
 
			printf("\x1b[%d;%dH", y, x);
 
			printf(texto);
 
		} else {
 
			printf("\x1b[%d;%dH", y, x);
 
			printf("  ");
 
}

Para facilitar la labor y reducir código en el programa he convertido este fragmento de código en una función ya que lo vamos a utilizar para comprobar todas y cada una de las teclas de los mandos.

int procesaboton(u32 pressed, int x, int y, u32 Boton, char* texto);

A esta función la he llamado procesaboton y tiene como parámetros la variable pressed que contiene el estado de las teclas pulsadas, la posición x e y donde queremos que nos muestre la cadena contenida en la variable texto y la constante correspondiente a la tecla que queremos comprobar.

Ya dentro del bucle llamaremos a la función una vez por cada botón a ser comprobado.

Hasta aquí, aparte de utilizar más de un wiimote no hemos visto nada nuevo en comparación con el clásico button tester. Para poder utilizar todas las características de los mandos podemos utilizar la función WPADData *WPAD_Data(int chan) a la que pasándole el número del wpad que queremos consultar nos devuelve un puntero a una variable tipo WPADData que contiene toda la información que necesitamos.

wmote_data=WPAD_Data(pad);
 
 
 
typedef struct _wpad_data
 
{
	s16 err;
	u32 data_present;
	u8 battery_level;
	u32 btns_h;
	u32 btns_l;
	u32 btns_d;
	u32 btns_u;
	struct ir_t ir;
	struct vec3w_t accel;
	struct orient_t orient;
	struct gforce_t gforce;
	struct expansion_t exp;
 
} WPADData;

La posición a la que apunta el sensor infrarrojo la podemos sacar del par de valores wmote_data->ir.x, wmote_data->ir.y, mientras que la orientación del wiimote la podemos sacar de wmote_data->orient.pitch y wmote_data->orient.roll, donde pitch es el cabeceo del mando y roll el giro del mismo sobre un eje imaginario perpendicular al sensor.

Para mostrar estos valores podríamos escribir lo siguiente:

		// Muestra la posición X,Y del infrarrojo
 
		printf("\x1b[%d;%dH", 1, 0);
 
		printf("IR: ( \%0.0f;\%0.0f )   ", wmote_data->ir.x, wmote_data->ir.y); 
 
 
 
		// Muestra la orientación del wiimote
 
		printf("\x1b[%d;%dH", 2, 0);
 
		printf("Cabeceo: \%0.00f  ", wmote_data->orient.pitch);
 
		printf("\x1b[%d;%dH", 3, 0);
 
		printf("Giro: \%0.00f  ", wmote_data->orient.roll);

Para mostrar el estado de la expansión conectada al wiimote, ya sea el nunchuk, el mando clásico u otro, podemos utilizar la variable expansión_type que previamente nos había devuelto la función WPAD_probe.

La información de la expansión viene en el campo exp de la estructura. Así, la información del Nunchuk la podemos encontrar en wmote_data->exp.nunchuk, teniendo la posibilidad de acceder a los campos, pitch, roll y js entre otros.

Los campos pitch y roll, al igual que en el wiimote, nos devuelven la orientación del nunchuk, mientras que el campo js nos permite el acceso a la información del joystick analógico.

El campo wmote_data->exp.nunchuk.js.ang nos da el ángulo de orientación de la palanca del joystick, mientras que wmote_data->exp.nunchuk.js.mag nos informa de lo alejado que está la palanca de la posición central. 

Podemos observar los rangos de valores de todas estas variables al ver el programa en ejecución. 

Por ejemplo wmote_data->exp.nunchuk.js.ang oscila entre 0 y 360, mientras que la variable wmote_data->exp.nunchuk.js.mag contiene 0 con el joystick en la posición de reposo mientras que contiene un 1 con el joystick en la posición más alejada.

No voy a extenderme con el resto porque la programación es idéntica.

Aquí os dejo el código completo:

#include <stdio.h>
#include <stdlib.h>
#include <gccore.h>
#include <wiiuse/wpad.h>
 
static void *xfb = NULL;
static GXRModeObj *rmode = NULL;
 
int procesaboton(u32 pressed, int x, int y, u32 Boton, char* texto) {
		if ( pressed & Boton ) {
			printf("\x1b[%d;%dH", y, x);
			printf(texto);
		} else {
			printf("\x1b[%d;%dH", y, x);
			printf("  ");
		}
}
 
void Init_Video(void);
 
//---------------------------------------------------------------------------------
int main(int argc, char **argv) {
//---------------------------------------------------------------------------------
 
	u32 expansion_type, pad;
	WPADData * wmote_data;
 
	Init_Video();
 
	// Esta función inicializa los PADs conectados
	WPAD_Init();
 
	// Busca el primer pad encendido y guarda el tipo de su expansión en expansion_type
	int ret = -1;
	while (ret < 0) {
		for(pad=0;(pad<4)&(ret<0);pad++) 
			ret=WPAD_Probe(pad, &expansion_type);
	}
	pad--;
 
 
	// Asigna la resolucion que nos devuelve el IR
	WPAD_SetVRes(pad, 640, 480);
 
	// ajusta el modo de operación de los PADS activando acelerometros y el IR
	WPAD_SetDataFormat(pad, WPAD_FMT_BTNS_ACC_IR);
 
	// tiempo en segundos que aguardará el wiimote hasta apagarse por falta de uso
	WPAD_SetIdleTimeout(300); 
 
	while(1) {
 
 
		// Comprobamos si se conecta o desconecta alguna expansión
		ret=WPAD_Probe(pad, &expansion_type);
 
		// Esto lee el estado de los mandos a cada ciclo del bucle
		WPAD_ScanPads();
 
		// recoge los datos extra del wiimote
		wmote_data=WPAD_Data(pad);
 
		// WPAD_ButtonsHeld nos dice todos los botones pulsados tanto del wiimote como
		// de las expansiones
		// Si en su lugar usaramos WPAD_ButtonsDown solo se activaría una vez y no volveria
		// a activarse hasta que no soltaramos el botón y lo volvieramos a pulsar
		u32 pressed = WPAD_ButtonsHeld(pad);
 
		// Muestra el primer mando detectado
		printf("\x1b[%d;%dH", 0, 0);
		printf("Mando \%d", pad);
 
		// Muestra la posición X,Y del infrarrojo
		printf("\x1b[%d;%dH", 1, 0);
		printf("IR: ( \%0.0f;\%0.0f )   ", wmote_data->ir.x, wmote_data->ir.y); 
 
		// Muestra la orientación del wiimote
		printf("\x1b[%d;%dH", 2, 0);
		printf("Cabeceo: \%0.00f  ", wmote_data->orient.pitch);
		printf("\x1b[%d;%dH", 3, 0);
		printf("Giro: \%0.00f  ", wmote_data->orient.roll);
 
		// Muestra los botones pulsados del wiimote
		procesaboton(pressed, 0, 5, WPAD_BUTTON_1, "1");
		procesaboton(pressed, 0, 6, WPAD_BUTTON_2, "2");
		procesaboton(pressed, 0, 7, WPAD_BUTTON_A, "A");
		procesaboton(pressed, 0, 8, WPAD_BUTTON_B, "B");
		procesaboton(pressed, 0, 9, WPAD_BUTTON_PLUS, "+");
		procesaboton(pressed, 0, 10, WPAD_BUTTON_MINUS, "-");
		procesaboton(pressed, 0, 11, WPAD_BUTTON_LEFT, "<-");
		procesaboton(pressed, 0, 12, WPAD_BUTTON_RIGHT, "->");
		procesaboton(pressed, 0, 13, WPAD_BUTTON_UP, "^");
		procesaboton(pressed, 0, 14, WPAD_BUTTON_DOWN, "v");
 
		// Muestra caracteristicas de la expansión conectada al wiimote
		int i;
 
		switch (expansion_type) {
			case WPAD_EXP_NONE:  // No hay expansión conectada
				for (i=0;i<15;i++){
					printf("\x1b[%d;%dH", i, 20);
					printf("                  ");
 
				}
				break;
			case WPAD_EXP_NUNCHUK: // Conectado el Nunchuck
				printf("\x1b[%d;%dH", 0, 20);
				printf("Nunchuk");
 
				// Muestra la orientación del Nunchuk
				printf("\x1b[%d;%dH", 1, 20);
				printf("Cabeceo: \%0.00f  ", wmote_data->exp.nunchuk.orient.pitch);
				printf("\x1b[%d;%dH", 2, 20);
				printf("Giro: \%0.00f  ", wmote_data->exp.nunchuk.orient.roll);
 
				// Posición del Joystick
				printf("\x1b[%d;%dH", 3, 20);
				printf("Angulo: \%f", wmote_data->exp.nunchuk.js.ang);
				printf("\x1b[%d;%dH", 4, 20);
				printf("Magnitud: \%f", wmote_data->exp.nunchuk.js.mag);
 
				// Botones C y Z
				procesaboton(pressed, 20, 4, WPAD_NUNCHUK_BUTTON_C, "C");
				procesaboton(pressed, 20, 5, WPAD_NUNCHUK_BUTTON_Z, "Z");
 
				break;
			case WPAD_EXP_CLASSIC: // Mando clasico conectado
				printf("\x1b[%d;%dH", 0, 20);
				printf("Mando Clasico");
 
				// Posición del Joystick izquierdo
				printf("\x1b[%d;%dH", 1, 20);
				printf("Angulo: \%f", wmote_data->exp.classic.ljs.ang);
				printf("\x1b[%d;%dH", 2, 20);
				printf("Magnitud: \%f", wmote_data->exp.classic.ljs.mag);
				// Posición del Joystick derecho
				printf("\x1b[%d;%dH", 3, 20);
				printf("Angulo: \%f", wmote_data->exp.classic.ljs.ang);
				printf("\x1b[%d;%dH", 4, 20);
				printf("Magnitud: \%f", wmote_data->exp.classic.ljs.mag);
				procesaboton(pressed, 20, 5, WPAD_CLASSIC_BUTTON_ZL, "1");
				procesaboton(pressed, 20, 6, WPAD_CLASSIC_BUTTON_ZR, "2");
				procesaboton(pressed, 20, 7, WPAD_CLASSIC_BUTTON_A, "A");
				procesaboton(pressed, 20, 8, WPAD_CLASSIC_BUTTON_B, "B");
				procesaboton(pressed, 20, 9, WPAD_CLASSIC_BUTTON_PLUS, "+");
				procesaboton(pressed, 20, 10, WPAD_CLASSIC_BUTTON_MINUS, "-");
				procesaboton(pressed, 20, 11, WPAD_CLASSIC_BUTTON_LEFT, "<-");
				procesaboton(pressed, 20, 12, WPAD_CLASSIC_BUTTON_RIGHT, "->");
				procesaboton(pressed, 20, 13, WPAD_CLASSIC_BUTTON_UP, "^");
				procesaboton(pressed, 20, 14, WPAD_CLASSIC_BUTTON_DOWN, "v");
				break;
			case WPAD_EXP_GUITARHERO3: // Conectado Guitar Hero
				printf("\x1b[%d;%dH", 0, 20);
				printf("Guitar Hero 3");
				break;
			default: // Tipo de expansión desconocida
				printf("\x1b[%d;%dH", 0, 20);
				printf("%d", expansion_type);
		}
 
 
 
 
		// Volvemos al launcher cuando pulsamos el botón Home
		if ( (pressed & WPAD_BUTTON_HOME) | (ret < 0)) exit(0);
 
		// Esperamos al siguiente frame
		VIDEO_WaitVSync();
	}
 
	// Terminamos de trabajar con el wiimote
	WPAD_Shutdown();
 
	return 0;
}
 
 
void Init_Video(void) {
	// Initialise the video system
	VIDEO_Init();
 
 
	// Obtain the preferred video mode from the system
	// This will correspond to the settings in the Wii menu
	rmode = VIDEO_GetPreferredMode(NULL);
 
	// Allocate memory for the display in the uncached region
	xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
 
	// Initialise the console, required for printf
	console_init(xfb,20,20,rmode->fbWidth,rmode->xfbHeight,rmode->fbWidth*VI_DISPLAY_PIX_SZ);
 
	// Set up the video registers with the chosen mode
	VIDEO_Configure(rmode);
 
	// Tell the video hardware where our display memory is
	VIDEO_SetNextFramebuffer(xfb);
 
	// Make the display visible
	VIDEO_SetBlack(FALSE);
 
	// Flush the video register changes to the hardware
	VIDEO_Flush();
 
	// Wait for Video setup to complete
	VIDEO_WaitVSync();
	if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();
}

Si queréis saber más al respecto, podéis investigar vosotros mismos en los ficheros wpad.h y wiiuse.h.

Para la segunda parte del tutorial, tengo previsto pasar a explicar la funcionalidad de la vibración (Rumble), del sonido de los mandos y de los acelerómetros.

Espero que os haya gustado el tutorial, ahora……a disfrutar programando.