Si rezaron toda la semana para que la segunda entrega de estos magníficos tutoriales saliera pronto, pues han sido escuchados, ya que tienen enfrente a sus ojos la "Segunda" entrega de los tutoriales aplicados de GRRLIB, disponibles solo en Wii.SceneBeta.com a disfrutar entonces de esta segunda entrega de puro conocimientos.

Empezando a programar

Hola a todos de nuevo. Después de la tediosa instalación de la entrega anterior, en esta entrega, vamos a hacer nuestro primer programa. Éste será un sencillo programa que nos enseñará a aplicar la estructura más simple de un programa basado en GRRLIB.

Pero no nos podemos poner a programar directamente, empezaremos explicando algunas ideas sobre C, aunque como dije en el capitulo anterior mi intención no es hacer un curso de C. Si no sabemos absolutamente nada sobre C, os recomiendo que primero sigáis alguno de los muchos cursos que circulan por Internet, como por ejemplo estos.

También necesitamos explicar algunos conceptos básicos de GRRLIB y las funciones fundamentales que utilizaremos en el programa.

Un poco sobre C

El lenguaje C es uno de los más rápidos y potentes de hoy en día, está presente en todas partes y en contra de la opinión de algunos, está más vigente que nunca. Sin ir más lejos cosas como el Linux están programadas en C.

El lenguaje C, pese a que se aproxima, no es un lenguaje totalmente estructurado como lo es Pascal, pero a cambio le da al programador toda la libertad que necesita.

C es un lenguaje compilado, esto implica ventajas e inconvenientes respecto de los lenguajes interpretados.

Como un pequeño inconveniente podemos citar algo más de dificultad a la hora de depurar el programa, ya que está separada la ejecución de la compilación.

Una gran ventaja es la rapidez de ejecución. Mientras un interprete tiene que traducir el programa y ejecutarlo todo al mismo tiempo y en la misma máquina, un compilador tiene todo el tiempo del mundo para traducir y optimizar un programa mientras compila, ejecutándose después en la misma o en otra máquina totalmente optimizado y a la máxima velocidad.

Una cosa que debéis saber y que os puede traer problemas hasta que os acostumbréis, es que el C es sensible a mayúsculas, es decir que no es lo mismo poner printf que Printf.

En C todo se basa en funciones, de hecho hasta el propio programa principal es una función que devuelve un valor al sistema operativo desde el que es llamado.

La llamada a una función en C se realiza de la siguiente forma:

Nombre_funcion(parametro1, parametro2,.....);

Es decir empezamos con el nombre de la función, seguida de los parámetros entre paréntesis y separados por coma.

Como en casi todos los lenguajes, combinando operadores, variables, constantes y funciones podemos escribir expresiones. En C todas las expresiones terminan en ";". Un ejemplo de expresión es el siguiente:

total = a+sumatorio(b);

En el ejemplo, asignamos a la variable total el valor de a + el resultado que devuelve la función sumatorio pasandole como parámetro b.

En C podemos agrupar expresiones para indicar que pertenecen a un bloque determinado encerrándolas entre llaves.

{
	funcion(1, 1, 3);
	funcion2();
	funcion3(3,4 5);
}

Esto último es muy importante, ya que nos servirá, por ejemplo,  para la definición del cuerpo de las funciones o un bloque de funciones que debe o no debe ejecutarse. 

Estructura de un programa en C

Un programa en C lo más simple posible sería como sigue:

#include <stdio.h>
 
int main() {
    printf("Hola mundo\n");
    return 0;
}

Al principio incluiremos todas las bibliotecas de utilidades que vayamos a utilizar. En el ejemplo anterior incluimos sólo que es la biblioteca estándar stdio, que implementa las funciones de entrada/salida por consola (teclado/pantalla).

El formato a seguir es:

#include <nombre de biblioteca.h> 

ó

#include "nombre de biblioteca.h"

dependiendo de donde queremos que busque la biblioteca el compilador.

Seguidamente vendrá el cuerpo de nuestro programa que tendrá tantas definiciones de funciones como sea necesario, pero como mínimo deberá tener la definición de la función "main" que es el cuerpo principal del programa, osea la función que se llama desde el sistema operativo al comenzar la ejecución.

A la hora de definir una función, seguiremos la misma estructura que podemos ver en el siguiente ejemplo:

int suma(int a, int b) {
    return a+b;
}

Es decir:

1. lo primero que tenemos que definir es el tipo de datos que devuelve la función (tipoint o entero en el ejemplo).
2. Después el nombre de la función ("suma" en nuestro ejemplo)
3. Entre paréntesis declaramos todos los parámetros con sus correspondientes tipos de datos. (En nuestro ejemplo tenemos dos parámetros de tipo entero que se llaman a y b)
4. Definimos un bloque de expresiones entre llaves que será el código que se ejecute cuando llamemos a dicha función. Dentro de dicho bloque deberemos utilizar la sentencia "return valor" que nos permite devolver el valor de la función. En nuestro ejemplo devolvemos el valor de la suma de a + b.

Estructura básica de un programa usando GRRLIB

Todo programa en C para Wii hecho con GRRLIB, tiene la estructura conceptual siguiente:

Repetir hasta que pulsemos la tecla home
 
	Leer mandos
 
	Acción 1
	Acción 2
	Acción 3
	......	
	......	
	......	
	......	
	Acción n
 
	Refrescar pantalla

Este "pseudocódigo" indica que para cualquier programa necesitaremos un bucle que se repetirá hasta que pulsemos la tecla home que por convenio en Wii se utiliza para salir del programa.

Dentro de dicho bucle realizaremos todas las acciones que queramos que realice y finalmente refrescaremos la pantalla para que se visualicen los mensajes.

Este código traducido a un programa en C quedaría algo parecido a esto:

#include <grrlib.h>
#include <stdlib.h>
#include <wiiuse/wpad.h>
 
int main(int argc, char **argv) {
    // Inicializar gráficos
    GRRLIB_Init();
 
    // Inicializar wiimotes
    WPAD_Init();
 
    // Bucle sin fin
    while(1) {
 
        WPAD_ScanPads();  // Leer mandos
 
        // Si pulsamos home salimos del bucle
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;
 
        // ---------------------------------------------------------------------
        // Acciones
        // ---------------------------------------------------------------------
 
        GRRLIB_Render();  // Refrescamos la pantalla
    }
 
    GRRLIB_Exit(); // Liberamos memoria
 
    exit(0);  // Usar exit para salir del program (no usar return desde el main)
}

Empezaremos explicando cada una de las estructuras utilizadas en este simple programa.

Uso de las bibliotecas

• #include <grrlib.h> - Esta es la línea que nos permitirá usar todas las funciones de grrlib
• #include <stdlib.h> - Esta es la libreria de las funciones estándar de C, simplemente debéis incluirla.
• #include <wiiuse/wpad.h> - Cualquier programa de Wii necesitará interactuar con los wiimotes, por lo que deberéis incluir esta biblioteca en todos vuestros programas.

El cuerpo de la función main:

La primera función que debemos llamar con cualquier programa que use GRRLIB es GRRLIB_Init(), dicha función inicializa la biblioteca.

Seguidamente inicializaremos la biblioteca WPAD. Como hemos dicho antes WPAD es la biblioteca que gestiona la comunicación con los wiimotes.

Para inicializar WPAD llamaremos a la función WPAD_Init();

Siguiendo el programa nos encontramos con la estructura while.

While es una estructura de C que nos permite ejecutar repetidamente una serie de instrucciones.

La sintaxis de While es:

	while(condicion) {
		expresión1;
		expresión2;
		expresión3;
		.....
		expresiónN;
	}
 
 

While repetirá las expresiones encerradas entre llaves siempre y cuando la condición entre paréntesis sea cierta.

En nuestro caso entre paréntesis hemos puesto un 1, que en C es equivalente a una condición siempre cierta, por lo que repetiremos el bucle para siempre.

Ya dentro del bucle la primera instrucción que nos encontramos es WPAD_ScanPads(). Dicha instrucción es una llamada a la función de WPAD que nos permite leer el estado de los mandos.

Como esta llamada está situada dentro del bucle While, el programa leerá el estado de los wiimotes a cada vuelta de bucle.

La siguiente linea que nos encontramos tiene como misión permitirnos salir del programa pulsando home en el wiimote 0. Para ello haremos uso de la función if:

       if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

La función if es una función básica de C estándar que nos permite ejecutar una o más expresiones en caso de que una condición sea cierta.

La sintaxis de if es la siguiente:

if (condicion) Bloque_de_expresiones1
else Bloque_de_expresiones2

Si  se cumple la condición se ejecuta el Bloque_de_expresiones1 y si no se cumple se ejecuta el Bloque_de_expresiones2.

Cuando hablamos de bloques de expresiones siempre podemos utilizar bien una expresión simple, o bien un bloque de expresiones encerrado entre llaves.

La parte else es opcional.

En nuestro caso concreto la condición que estamos evaluando es "WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME":

- La función WPAD_ButtonsDown(0) devuelve el estado de los botones del wiimote 0.

La sintaxis es: WPAD_ButtonsDown(número de wiimote).

- La constante WPAD_BUTTON_HOME es el valor que devuelve WPAD_ButtonsDown(0) cuando pulsamos el botón Home.

- El operador & hace un "Y" bit a bit entre ambos valores.

El resultado será cierto (es decir distinto de 0) sí y sólo sí hemos pulsado Home en el wiimote 0.

Si es cierta la condición ejecutamos la función break que en C sale incondicionalmente del bucle que lo contiene. En nuestro caso saldrá del bucle while.

En todo programa que use GRRLIB necesita que realicemos una llamada a la función GRRLIB_Render(), que entre otras actualiza el buffer de video. Si no llamaramos a esta función no se visualizaría nada.

Ya saliendo del bucle llamamos a la función GRRLIB_Exit(); que libera la memoria utilizada por GRRLIB y por último llamamos a la función exit(0); que en C sale del programa devolviendo el valor 0 al sistema operativo.

Preparando el programa y compilando

Después de haber visto paso por paso el fuente de nuestro primer programa vamos a ver que es lo que necesitamos para poder compilar nuestro programa.

Por una cuestión de orden lo primero que debemos hacer cuando comenzamos un nuevo programa es crear una carpeta en nuestro disco duro en la que guardaremos todo lo relacionado con este.

Es conveniente que en esta carpeta tengamos únicamente los archivos de dicho programa, ya que sino al final no sabremos qué pertenece a qué.

Dentro de dicha carpeta deberemos copiar el archivo "makefile", que viene en el archivo zip que se adjunta, y que podremos utilizar, con ligeras variaciones, para los distintos ejemplos del curso.

Crearemos también una subcarpeta llamada source en donde pondremos el archivo con el fuente de nuestro programa. Dicho archivo fuente tendrá extensión ".c".

Para editar nuestro archivo fuente, utilizaremos la utilidad "Programmers Notepad" o "PN" que se instala junto al devkitpro en la carpeta "c:\devkitpro\Programmers Notepad".

El Programmers Notepad basa su uso en proyectos. Cada proyecto contiene toda la información necesaria para compilar nuestro programa.

Cargaremos el programa desde el menú de Inicio/Todos los programa/devkitpro/Programmers Notepad.

Una vez en el programa deberemos crear nuestro primer proyecto. Para ello seleccionaremos "File/New/Project"

Clic en la imagen para ver en grande.

Nos aparecerá una ventana como la que sigue:

Clic en la imagen para ver en grande.

En dicha ventana escribiremos el nombre de nuestro proyecto en el campo Name y seleccionaremos la carpeta que previamente habíamos creado pulsando el botón de los puntos suspensivos al lado del campo folder.

Clic en la imagen para ver en grande.

Una vez seleccionada la carpeta pulsaremos Aceptar y tendremos creado nuestro proyecto vacío.

Ahora debemos añadirle la carpeta source que previamente habíamos creado. Para ello pulsaremos el botón derecho del ratón sobre el nombre de nuestro proyecto y seleccionaremos la opción "Add Magic Folder...."

Clic en la imagen para ver en grande.

buscaremos la carpeta source en nuestro disco duro y pulsaremos siguiente:

Clic en la imagen para ver en grande.

Por último pulsaremos Finalizar.

Clic en la imagen para ver en grande.

Ya dentro de nuestra carpeta crearemos el archivo del programa que en nuestro caso llamaremos "Holamundo.c". Para ello seleccionaremos en el menú "File/New/C /C++" y nos aparecerá una ventana con un archivo en blanco.

Clic en la imagen para ver en grande.

Clic en la imagen para ver en grande.

En este archivo pegaremos el texto de nuestro programa y lo grabaremos dentro de la carpeta source seleccionando "File/Save As.." y buscando dicha carpeta en nuestro disco duro y finalmente dándole al archivo el nombre "holamundo.c" y pulsando "Guardar".

Clic en la imagen para ver en grande.

Llegados a este punto ya tenemos todo lo necesario para compilar nuestro primer programa.

Para ello seleccionaremos la opción "make" en el menú "Tools" o bien pulsaremos "Alt+1".

Clic en la imagen para ver en grande.

Si todo va como está previsto nos aparecerá en la ventana "Output" el texto "Process Exit Code: 0".

Adicionalmente el compilador nos habrá creado una subcarpeta build y los archivos "holamundo.dol" y "holamundo.elf". El archivo que nos interesa es el archivo "holamundo.dol" que es el archivo que podremos ejecutar desde nuestra Wii. 

Ejecutando el programa en nuestra Wii

Tenemos tres maneras de ejecutar nuestro programa recién compilado:

       1. Copiandolo manualmente a la tarjeta SD y buscándolo con el wiiexplorer.

Este método es muy sencillo, pero requiere tener instalado el WiiExplorer y además tiene la incomodidad de tener que andar copiando los archivos manualmente a la SD.

Consiste en copiar el archivo .dol recién creado a cualquier carpeta de la SD y luego buscarlo con el WiiExplorer para ejecutarlo desde este.

       2. Copiandolo manualmente a la tarjeta SD y ejecutándolo desde el HBC.

Éste método es también manual, pero tiene la ventaja de que nos permitirá incluir nuestra aplicación en el menú del HBC. Para ello debemos crear una nueva carpeta dentro de la carpeta "apps" de nuestra SD. Dentro de esa carpeta copiaremos nuestro archivo .dol y le cambiaremos el nombre llamándolo "boot.dol".

Adicionalmente necesitaremos otros dos archivos que son:

• icon.png: debe ser una imagen png de 128x48 píxeles y que es el icono que aparecerá en el menú.
• meta.xlm: es un archivo en formato xlm en el que deberemos escribir todos los datos del programa, incluyendo nombre, descripción, número de versión, etc....Este archivo lo podemos editar con un editor de texto convencional.

Para facilitar la tarea ahora mismo, he incluido estos dos archivos en el pack que hay adjunto a esta publicación.

Si observamos ahora el menú del HBC veremos que ha aparecido una nueva entrada con nuestro programa. Simplemente seleccionando dicha entrada se ejecutará nuestra aplicación.

Este es el método que utilizaremos cuando ya tengamos preparada nuestra aplicación lista para distribuir.

       3. Enviandolo a traves de red con Wiiload.

Es sin duda el método más cómodo y el que os aconsejo para depurar un programa. Con este método no necesitaremos estar sacando y metiendo la tarjeta SD continuamente en nuestra Wii.

Sólo necesitamos dos cosas para poder utilizarlo: 1. Tener la conexión de red de nuestra Wii configurada y 2. Asignar la variable de entorno WIILOAD con la dirección IP de nuestra Wii.

Vamos a suponer que tenéis configurada la conexión de red de vuestra Wii y os voy a explicar el segundo paso.

Para asignar correctamente la variable WIILOAD en Windows 7 pulsaremos el botón derecho de nuestro sobre el icono de "Mi PC" y seleccionaremos la opción "Propiedades" y dentro de esta "Configuración avanzada del sistema".

Clic en la imagen para ver en grande. 

En la ventana que nos aparecerá seleccionaremos Variables de entorno.

Clic en la imagen para ver en grande.

Y en dicha ventana pulsaremos el botón "Nueva" para añadir la variable de entorno WIILOAD, que deberá contener exactamente el texto "tcp:" (sin las comillas) seguido de la dirección IP de nuestra Wii.

Clic en la imagen para ver en grande.

Tras tener esta variable de entorno configurada, podemos usar la opción "Ejecutar" del menú "Tools" del Programmers Notepad, que vía red enviará y ejecutará nuestro programa recién compilado. También podemos utilizar la combinación de teclas Alt+R.

Y hasta aquí esta segunda entrega. En la próxima entrega aprenderemos a mostrar texto por pantalla y escribiremos nuestro primer "Hola mundo". Así que no desesperéis y esperad a la próxima entrega.