Programación de la GameBoy 
A lo largo de este post desgranaremos, paso a paso y desde cero, cómo programar en C para esta mítica consola de mano. Usaremos como base el compilador cruzado SDCC y la documentación que hay disponible.

Instalación del SDCC

Lo primero que hay que hacer es instalar o compilar el compilador SDCC. En caso de que vayamos a compilarlo para Linux o para algún Unix, nos descargaremos el código fuente de http://sdcc.sourceforge.net y compilaremos con:

./configure --prefix=/opt/sdcc --disable-pic14-port --disable-pic16-port
make
make install

De esta forma tendremos instalado el compilador cruzado SDCC (se deshabilitan los targets pic14 y pic16 para evitar la dependencia con "gputils"). En nuestro caso sólo necesitamos los target "z80" y "sm83" (el chip SM83 es la CPU de 8 bits que trae la GameBoy, una variante del Z80 en la que cambian sólo algunas instrucciones).

Documentación sobre el estándar

No es mi intención detallar en este post todos los entresijos de la arquitectura de la GameBoy ni de su modelo de programación. Toda la información al respecto la he extraido básicamente de aquí y de aquí, así como de otras fuentes de fácil acceso en internet. Me centraré en lo principal y necesario para obtener una ROM funcional para GameBoy.

Estructura de la ROM de un cartucho y del resto de memoria

Para empezar nos centraremos en el uso de una ROM básica de 32 Kbytes sin conmutación de bancos de memoria (hay otros tipos de ROM, pero este es el más básico):

Después de arrancar, la ROM de arranque comprueba el logo y el checksum del cartucho insertado y, si es correcto, salta a la dirección de memoria 0x0100, que es donde debe residir la primera instrucción del cartucho. Como se puede apreciar en la estructura del cartucho, en esta zona apenas caben 4 bytes (a partir de 0x0104 vienen los datos del logo de Nintendo, el nombre del juego, la licencia, el checksum, etc.), por lo que lo habitual es colocar ahí una instrucción de salto hacia una dirección donde esté el resto del código: por ejemplo 0x0150 u otra. Aquí puede verse con detalle todo el mapa de memoria de la GameBoy. La zona de los vectores de interrupción, que está antes de 0x0100, la veremos más adelante, cuando usemos las interrupciones.

Código de arranque

Lo que haremos será definir nuestro propio código de arranque "crt0gb.s" que genere los bytes específicos de la cabecera de un cartucho GameBoy (de 0x0100 a 0x014F) y que, a continuación, defina las áreas donde deben estar alojado tanto el código y los datos de sólo lectura (de 0x0150 a 0x7FFF, 32 KBytes de ROM) como los datos de lectura y escritura (0xC000 a 0xDFFF, 8 KBytes de RAM).

    .module crt0gb
    .globl _main
    .area _HEADER (ABS)

    .org 0x0100

    nop
    jp init

    ; nintendo logo
    .db 0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B, 0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D, 0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E, 0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99, 0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC, 0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E
    ; game title (16 bytes)
    .ascii "PRUEBA"
    .db 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    ; licensee code (0 for non super gameboy games)
    .db 0x00, 0x00, 0x00
    ; cartridge type (0 for ROM only)
    .db 0x00
    ; ROM size (0 for 32 KBytes)
    .db 0x00
    ; RAM size (0 for none)
    .db 0x00
    ; country code (1 for non japanese)
    .db 0x01
    ; licensee code (0xA4 for Konami)
    .db 0xA4
    ; version number
    .db 0x00
    ; header checksum (run "header_checksum_calc < main.gb" to get this value)
    .db 0x83   ; PUT HERE THE VALUE CALCULATED BY header_checksum_calc AND RECOMPILE
    ; checksum of all cartridge (GameBoy ignores this)
    .db 0x00, 0x00

    .org 0x0150

init:
    call gsinit
    call _main
exit_loop::
    jp exit_loop

    .area _HOME
    .area _CODE
    .area _GSINIT

gsinit::
    .area _GSFINAL
    ret

    .area _DATA
    .area _BSS
    .area _HEAP

Los diferentes campos de la cabecera de un cartucho de GameBoy (entre las direcciones 0x0100 y 0x014F) se detallan aquí. Como se puede ver en la posición 0x0100 se ponen las instrucciones "nop" y "jp init", a continuación se definen todos los campos de la cabecera del cartucho y es a partir de la posición de memoria 0x0150 donde se pone el resto del código y se aloja la etiqueta "init". "call gsinit" es la parte encargada de inicializar variables globales y a continuación se hace un "call _main" para que se invoque la función "main" que se haya definido.

El trabajo con el SDCC es más artesanal que con el GCC ya que en SDCC no existe el concepto de "linker script" como en GCC y los processos de compilación y enlazado están algo más entremezclados. Ahora podemos definir un "main.c" que simplemente pinte la valdosa (tile) 0 en el extremo superior izquierdo de la pantalla:

#include <stdint.h>

#define  IE        *((uint8_t *) 0xFFFF)
#define  LCDC      *((uint8_t *) 0xFF40)
#define  STAT      *((uint8_t *) 0xFF41)
#define  BGP       *((uint8_t *) 0xFF47)
#define  BG_TILES  ((uint8_t *) 0x8800)
#define  BG_DATA   ((uint8_t *) 0x9800)

const uint8_t TILE0[16] = {
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011
};

void memcpy(void *dest, void *src, uint16_t n) {
    uint8_t *d = (uint8_t *) dest;
    uint8_t *s = (uint8_t *) src;
    while (n > 0) {
        *d = *s;
        d++;
        s++;
        n--;
    }
}

void main() {
    // disable LCD before accessing VRAM
    while ((STAT & 0x03) != 0x01)
        ;
    LCDC = 0x00;
    // copy tile data to tile data VRAM
    memcpy(BG_TILES, TILE0, 16);
    // disable all LCD interrupts
    STAT = 0x00;
    // disable interrupts
    IE = 0x00;
    // configure palette
    BGP = 0b11100100;     // 0b11 for full black, 0b10 for dark gray, 0b01 for light gray and 0b00 for white
    // enable LCD, disable window, background tile data at 0x8800, background tile indices at 0x9800, obj not displayed, background display on
    LCDC = 0x81;
    // with LCD enabled, wait vblank before accessing VRAM
    while ((STAT & 0x03) != 0x01)
        ;
    BG_DATA[0] = 0x80;
    // halt
    while (1)
        ;
}

Para hacer este código sí hay que echar más mano de la documentación sobre el controlador gráfico de la GameBoy. En este caso se ha optado por un ejemplo muy simple:

1. Se deshabilita el controlador gráfico en el registro LCDC. Para hacerlo es necesario esperar a un retrazo vertical (vblank). Nintendo recomienda encarecidamente hacer esta espera previa antes de apagar el controlador LCD ya que, de lo contrario, puede dañarse la pantalla LCD (!).

2. Copiamos los 16 bytes de la baldosa (tile) 0 desde el array TILE0 a la VRAM que alberga los datos de las baldosas. La baldosa son simplemente 8 rayas verticales con las diferentes tonalidades de gris.

3. Se deshabilitan todas las interrupciones (registros STAT e IE a 0x00). Por ahora no estamos usando el mecanismo de interrupciones.

4. Configuramos la paleta (registro BGP).

5. Habilitamos de nuevo el controlador gráfico LCD.

6. Esperamos al siguiente retrazo vertical (vblank).

7. Escribimos en la VRAM encargada de indexar las valdosas que queremos mostrar, la baldosa 0 en la esquina superior izquierda.

8. Terminamos: bucle infinito.

Como se puede ver, se trata de un ejemplo muy simple y minimalista, pero que funciona. Ya tenemos preparado nuestro entorno de desarrollo para GameBoy.

Como emulador recomiendo el VisuaBoyAdvance-M, que es open source y muy estable. Aunque también nos podemos llevar la ROM a cualquier otro emulador o a un cartucho Flash que tengamos conectado a nuestra GameBoy física.


Interrupciones

De cara a hacer desarrollos más serios se hace necesario el uso y el aprovechamiento de las interrupciones en el Z80. El sistema de interrupciones en el Z80 depende de la implementación y, en el caso concreto del procesador SM83 y de la GameBoy, disponemos de las siguientes fuentes de interrupción (detalladas aquí):

- Int 0x40: VBlank.
- Int 0x48: Interrupción asociada al registro STAT del LCD.
- Int 0x50: Interrupción de timer.
- Int 0x58: Interrupción de puerto serie.
- Int 0x60: Interrupción de botones.

El valor "int 0xNN" hace referencia a la dirección de memoria del vector. En este caso, la dirección a la que salta el procesador cuando se produce una interrupción de retrazo vertical (VBlank) es la dirección 0x0040. Recordemos en la imagen del mapa de memoria, que las posiciones de memoria que están entre 0x0000 y 0x00FF se corresponden con los vectores de interrupción.

Modificaremos el ejemplo anterior para que el pintado de las baldosas se realice en la interrupción de retrazo vertical (VBlank). Para habilitar y trabajar con la interrupción VBlank hacemos lo siguiente:

1. Definimos en "crt0gb.s" el vector de interrupciones en la ubicación correcta (0x0040).

2. Habilitamos las interrupciones a nivel de sistema mediante la escritura en el registro IE (Interrupt Enable, dirección 0xFFFF).

3. Habilitamos las interrupciones a nivel de CPU mediante la instrucción ensamblador "ei".

En nuestro caso, para que la generación de código sea más cómoda, se define el nombre "vblankISR" como nombre que debe tener la función encargada de ejecutarse cada vez que haya un retrazo vertical. Dicho nombre se declara en "crt0gb.s" y se pone una instrucción "call _vblankISR" seguida de una instrucción "reti" en la posición de memoria 0x0040.

    .module crt0gb
    .globl _main
    .globl _vblankISR
    .area _HEADER (ABS)

    .org 0x0040

    call _vblankISR
    reti

    .org 0x0100

    nop
    jp init
    ...

Esto nos obliga a que tenemos que tener una función llamada "vblankISR" en C (con el atributo "__interrupt" para que guarde todos los registros al entrar y los restaure al salir) que se encargue de servir la interrupción de retrazo vertical (VBlank):

void vblankISR() __interrupt {
    // access VRAM here
    // ...
}

La interrupción de retrazo vertical nos proporciona, además, una base de tiempo razonable, puesto que se ejecuta 60 veces por segundo. Aquí puede verse un ejemplo final de pintado mediante interrupción VBlank que cambia la ubicación de las valdosas una vez por segundo (cada 60 interrupciones):
#include <stdint.h>

#define  IE        *((uint8_t *) 0xFFFF)
#define  LCDC      *((uint8_t *) 0xFF40)
#define  STAT      *((uint8_t *) 0xFF41)
#define  BGP       *((uint8_t *) 0xFF47)
#define  BG_TILES  ((uint8_t *) 0x8800)
#define  BG_DATA   ((uint8_t *) 0x9800)

const uint8_t TILE0[16] = {
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011,
    0b01010101, 0b00110011
};

const uint8_t TILE1[16] = {
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000,
    0b11111111, 0b00000000
};

const uint8_t TILE2[16] = {
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111,
    0b00000000, 0b11111111
};

const uint8_t TILE3[16] = {
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111,
    0b11111111, 0b11111111
};

void memcpy(void *dest, void *src, uint16_t n) {
    uint8_t *d = (uint8_t *) dest;
    uint8_t *s = (uint8_t *) src;
    while (n > 0) {
        *d = *s;
        d++;
        s++;
        n--;
    }
}

volatile uint8_t frameCounter;
volatile uint8_t frameIndex;

void vblankISR() __interrupt {
    if (frameCounter == 0) {
        // show tiles
        BG_DATA[0] = 0x80 + frameIndex;
        BG_DATA[1] = 0x80 + ((frameIndex + 1) & 0x03);
        BG_DATA[2] = 0x80 + ((frameIndex + 2) & 0x03);
        BG_DATA[3] = 0x80 + ((frameIndex + 3) & 0x03);
        frameIndex = (frameIndex + 1) & 0x03;
        frameCounter = 60;
    }
    else
        frameCounter--;
}

void main() {
    // disable LCD before accessing VRAM
    while ((STAT & 0x03) != 0x01)
        ;
    LCDC = 0x00;
    // copy tile data to tile data VRAM
    memcpy(BG_TILES, TILE0, 16);
    memcpy(BG_TILES + 16, TILE1, 16);
    memcpy(BG_TILES + 32, TILE2, 16);
    memcpy(BG_TILES + 48, TILE3, 16);
    // disable all LCD interrupts
    STAT = 0x00;
    // enable only vblank interrupt
    frameCounter = 0;
    frameIndex = 0;
    IE = 0x01;
    __asm__ ("ei");
    // configure palette
    BGP = 0b11100100;     // 0b11 for full black, 0b10 for dark gray, 0b01 for light gray and 0b00 for white
    // enable LCD, disable window, background tile data at 0x8800, background tile indices at 0x9800, obj not displayed, background display on
    LCDC = 0x81;
    // halt
    while (1)
        ;
}



Checksum de la cabecera

El valor del byte de la posición de memoria 0x014D de la ROM del cartucho se calcula mediante un algoritmo de suma de control entre los bytes 0x0134 y 0x14C (ambos inclusive) de la misma ROM. El código para calcular este valor es el siguiente:

#include <iostream>
#include <iomanip>

using namespace std;

int main() {
    cin.ignore(0x0134);
    uint8_t x = 0;
    for (int i = 0x0134; i <= 0x014C; i++)
        x = x - ((uint8_t) cin.get()) - 1;
    cout << "0x" << hex << setw(2) << setfill('0') << ((int) x) << endl;
    return 0;
}

Una vez generada una ROM se realiza este cálculo y el valor generado debe ser colocado en la posición 0x014D de la propia ROM. Como se puede ver, los campos que afectan al valor de esta suma de control no dependen del código principal de la ROM con lo que no será un valor que se modifique con frecuencia.

Proceso de compilación

A modo de resumen, el proceso de compilación sería entonces el siguiente:
# ensamblamos crt0gb.s
/opt/sdcc/bin/sdasgb -o crt0gb.rel crt0gb.s
# compilamos main.c
/opt/sdcc/bin/sdcc -msm83 -c -o main.rel main.c
# enlazamos para generar la ROM “casi-final” indicando que la RAM está en 0xC000
/opt/sdcc/bin/sdcc -msm83 --data-loc 0xC000 --no-std-crt0 -o main.ihx crt0gb.rel main.rel
/opt/src/Hex2bin-2.5/hex2bin -s 0 -e gb main.ihx
# ahora tenemos la ROM “casi-final” en el fichero “main.gb”
# compilamos en el host el generador de suma de control
g++ -std=c++11 -o header_checksum_calc header_checksum_calc.cc
# lo ejecutamos con el "main.gb" para que nos diga el valor de la suma de control
./header_checksum_calc < main.gb
0x83
# este valor 0x83 es el que debo poner en el fichero crt0gb.s como checksum (dirección 0x014D de la ROM)
# si al poner este valor, se modifica el fichero crt0gb.s, hay que recompilar desde el principio
# Nótese que este valor se calcula a partir de la cabecera, no a partir de toda la ROM, por lo que en circunstancias normales apenas cambia

Como se puede apreciar, uso la utilidad Hex2bin (http://hex2bin.sourceforge.net) para generar el fichero .gb (la ROM) a partir del fichero Inte Hex que genera el compilador SDCC.

Todo el código fuente puede descargarse de la sección soft.

[ añadir comentario ] ( 742 visualizaciones )   |  [ 0 trackbacks ]   |  enlace permanente
  |    |    |    |   ( 3 / 234 )

<Anterior | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | Siguiente> >>