User Tools

Site Tools


tutorial_sms

**This is an old revision of the document!** ----

A PCRE internal error occured. This might be caused by a faulty plugin

====== Tutorial de programación de la Sega Master System ====== No pretendo con esto hacer un tutorial paso a paso de programación de la SMS, sino partir de un programa de ejemplo e ir explicando sobre la marcha el programa y las características de la SMS, explicando además la programación del z80 que se va viendo en el ejemplo. Empezamos con el código fuente de nuestro pequeño programa de ejemplo: {{:tutorial-sms1.asm|}} Que muestra por pantalla el logo de vieju.net, espera que pulsemos el boton 1 del pad y borra la pantalla. Para generar una rom binaria a partir de este código, con el wla-dx: <code> wla-z80 -oi prueba.asm wlalink prueba.link prueba.sms </code> Necesitaremos un archivo prueba.link con el siguiente contenido: <code> [objects] prueba.o </code> Además necesitaremos los archivos de tiles, mapa y paleta: ===== Explicación ===== Vamos diseccionando el programa parte por parte. Para empezar, comentar que en ensamblador los numeros decimales se escriben tal cual, los hexadecimales precedidos por $ ($12he) y los binarios precedidos por % (%10011011). <code asm> .MEMORYMAP DEFAULTSLOT 0 SLOTSIZE $8000 SLOT 0 $0000 .ENDME .ROMBANKMAP BANKSTOTAL 1 BANKSIZE $8000 BANKS 1 .ENDRO ; sdsc tag al inicio de la rom .sdsctag 1.0,"Prueba","Prueba ASM SMS","zako" </code> Primero las directivas .MEMORYMAP y .ROMBANKMAP. Estas son directivas del ensamblador wla-dx que nos permiten definir cuestiones relacionadas con la rom que estamos creando. No es código z80, simplemente le dicen al ensamblador como crear el mapa de memoria y los bancos que vamos a usar en nuestro programa. En este caso, le decimos que solo tenemos un slot, de $0 a $8000 (32K) y solo un banco de memoria, tambien solamente de 32K. Luego el tag .sdsctag nos permite definir una versión un nombre, descripción y autor del programa. Sencillo. <code asm> ; Boot .bank 0 slot 0 .org $0000 di im 1 jp main </code> Empezamos, usamos la directiva .bank del compilador para decirle que empezamos a definir el primer banco y el primer slot de memoria. Solo tenemos este, asi que solamente nos hará falta definirlo aqui. Luego con .org le decimos que el programa comienza en $0000, el primer banco de ROM. Vamos con las primeras instrucciones de código; //di// deshabilita las interrupciones, no las usaremos en un ejemplo tan sencillo. Luego con //im 1//, le decimos al z80 que active el modo 1 de manejo de interrupciones, con él, una instrucción //rst $0038// será generada cuando se reciba una interrupción. Y para terminar con //jp main//, saltamos al inicio del programa, dejando espacio entre aquí y nuestro código principal para meter manejo de interrupciones, etc, como vamos a ver. <code asm> ; Pausa .org $0066 ; de momento no hacemos nada retn </code> Aquí definimos el origen $0066, que es el lugar normal para poner la rutina de interrupción del botón de pausa. De momento no hacemos nada y solo retornamos de la funcion con //retn// <code asm> ; Programa principal ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; main: ; pila al final de la RAM ld sp, $dff0 ; inicializamos el VDP ld hl,vdp_data ld b,vdp_data_end-vdp_data ld c,$bf ; puerto del VDP otir </code> Ya empieza lo interesante. Para comenzar, apuntamos la pila a una de las últimas direcciones de la RAM interna. La SMS tiene 8KB ($1fff) de RAM entre las direcciones $c000-$dfff. Asi que apuntamos la pila a $dff0, dejando 16 bytes al final para otras cosas. //sp// es el registro de pila, que contiene la dirección actual del último elemento apuntado en la pila. Como la pila es decreciente (cuando insertas un valor, SP decrece), no tendremos problemas en que se desborde (a no ser que metamos mas de 8192-16 bytes en ella!). Ahora vamos con algo más complicado. Inicializar el VDP, el chip gráfico de la SMS. Al final del programa tenemos una tabla con los valores de configuración del VDP entre dos etiquetas, vdp_data y vdp_data_end, de momento vamos a asumir que tenemos que usar estos datos para iniciarlo. Bien, entonces empezamos; cargamos el registro de 16 bit //hl//, con la dirección del primero de los datos a cargar. Cargamos en el registro //b// (8 bits) el número de datos a cargar. ¿Cómo se hace esto? pues diciéndole al ensamblador que reste el numero de bytes entre las etiquetas vdp_data_end y vdp_data. Sencillo, ¿no?. Y ahora cargamos en el registro //c// (también de 8 bits), la dirección del puerto de configuración del VDP, que si miramos la documentación, es el puerto $bf. Y ahora vamos con una compleja instrucción del z80, //otir//. //otir// es una instrucción de salida de bloque con incremento. ¿quéeee? Bien, en el z80 hay un conjunto de órdenes para usar los puertos de entrada/salida, como //out ($de), a//, que envía el contenido del registro //a//, al puerto $de. Pues esta instrucción sirve para enviar un bloque de datos a un puerto de manera automática. ¿Cómo funciona? Pues espera que carguemos la dirección inicial de los datos en el registro //hl//, el número de datos a mandar en el registro //b//, y el puerto a usar en el registro //c//. Entonces, //otir// coge el primer dato apuntado por la dirección en //hl//, y lo envia al puerto que le decimos en //c//. Ahora decrementa //b//, nuestro contador de datos. Si //b// es igual a cero, la instrucción termina y la cpu pasa a la siguiente instrucción. En caso de que no fuera cero, pues incrementa la dirección en //hl//, con lo que apunta al siguiente dato a copiar, y sigue el proceso. Genial ¿no? Cuando termina esta instrucción ya hemos enviado todos los datos de configuración al VDP, vamos a por acción. <code asm> ; borramos la vram ld hl,$4000 call vram_to_hl call clear_vram </code> Bueno, aqui lo que hacemos es poner toda la vram a cero. La ram puede tener valores arbitrarios al encender la consola, asi que no podemos asumir que siempre es cero, muchos emuladores lo hacen y esto es incorrecto, de hecho hay juegos que usan esto para obtener datos aleatorios o cosas asi. Entonces lo primero que hacemos es limpiarla Para ello vamos a usar dos rutinas que están definidias más adelante, asi que tocará explicarlas también. Por lo que se ve en el código, cargamos el registro //hl// con el valor $4000 y luego llamamos a dos rutinas con la instrucción //call//. Las rutinas se invocan asi, tan simple, //call etiqueta//. Vamos entonces a explicar las subrutinas: <code asm> vram_to_hl: push af ld a,l out ($bf),a ld a,h out ($bf),a pop af ret </code> Esta rutina es muy útil, como veremos. El VDP no está mapeado en la memoria principal, y como vimos antes, nos comunicamos con él usando los puertos de entrada y salida del z80. Al ser las instrucciones de E/S limitadas (además sólo podemos usar datos de 8 bits), se puede hacer tedioso escribir ciertos bloques de código, como por ejemplo en este caso. Quememos decirle al VDP que vamos a usar la dirección $4000 de la VRAM. Para ello, usando la instrucción normal de salida, //out (puerto), a//, tenemos que cargar en //a//, el valor $00 (el byte menos significativo), enviarlo con //out// al puerto $bf, cargar //a// con $40 (byte más significativo) y volver a enviarlo al puerto $bf, con lo que ahora el VDP ha recibido nuestra dirección de 16 bits. Bien, para ahorrarnos escribir todo eso cada vez que queramos pedir una dirección al VDP, (que en un juego será muy amenudo), pues creamos esta rutina. ¿Qué hace? pues lo mismo que describimos anteriormente, pero carga los valores en //a// sacándolos de los registros //l// y //h//, que juntos forman el registro //hl// de 16 bits. Entonces hace esto, primero mete el registro //af// en la pila (como vamos a usar //a// así no perdemos su contenido al llamar a esta rutina, y asi tampoco perdemos el registro de flags //f//). Luego cargamos en //a// el contenido de //l// (byte menos significativo de //hl//), lo mandamos al VDP, cargamos //a// con //h// (byte más significativo de //hl//), lo mandamos al VDP, y antes de volver con //ret//, sacamos af de la pila con //pop af// para restaurar los valores que tenian antes de llamar a la rutina. Asi, como vimos antes, solo tenemos que meter el //hl// la dirección que queremos pedirle al VDP, y llamar a esta rutina, y asi ya vemos también como se pasan parámetros en ensamblador, usando los registros :-) Ahora vamos con la siguiente: <code asm> ; limpia la vram clear_vram: push af push bc ld bc,$4000 ; toda la vram ld a,$00 ; con ceros bclrvram: out ($be),a dec c jp nz,bclrvram dec b jp nz,bclrvram pop bc pop af ret </code>

tutorial_sms.1259521980.txt.gz · Last modified: 2009/11/29 20:13 by xzakox