De La Emulación de Las Máquinas Recreativas - JOSÉ TEJADA GÓMEZ - (147págs)

De la emulacin de mquinas recreativas
Jos Tejada Gmez
De la emulacin
de mquinas recreativas
Jos Tejada Gmez

jotego@iespana.es

Jos Tejada Gmez
Introduccin ................................................................................................................................6
Objetivos ......................................................................................................................................8
1 parte..........................................................................................................................................9
Los sistemas de las mquinas recreativas de vdeo...............................................................9
Descripcin general: El mueble, las palancas y el monedero...........................................9
El monitor..............................................................................................................................14
Conexin de una mquina recreativa a un televisor domstico ...............................14
La placa..................................................................................................................................16
El sistema de vdeo de una mquina de videojuegos..........................................................18
Almacenamiento de las imgenes......................................................................................18
Composicin de los fondos.................................................................................................18
Movimiento de los objetos ..................................................................................................21
El sistema de audio de una mquina de videojuegos .........................................................22
Introito histrico ...................................................................................................................22
Diagrama de bloques de un sintetizador basado en MIC ..............................................23
Bloques de un sintetizador FM...........................................................................................25
Los operadores .................................................................................................................25
Funciones posibles ...........................................................................................................25
Conexionado de los operadores.....................................................................................27
Efectos aadidos: El enventanado .................................................................................27
Estudio de algunos circuitos integrados comerciales. ....................................................28
El YM-2149, sintetizador MIC ........................................................................................28
Caractersticas ..............................................................................................................28
Descripcin de funciones............................................................................................28
Modelo de programacin del YM-2149....................................................................29
El YM-2203 ........................................................................................................................30
Caractersticas ..............................................................................................................30
Modelo de programacin ...........................................................................................31
El YM-2151, sintetizador FM de varios operadores. ...................................................32
Caractersticas ..............................................................................................................32
Circuito de ejemplo .....................................................................................................34
La arquitectura del sistema .....................................................................................................35
Bloques fundamentales .......................................................................................................35
Esquema elctrico de Gryzor..............................................................................................39
Las palancas de juego y las monedas............................................................................39
Los microinterruptores DIP............................................................................................40
Los cuentamonedas .........................................................................................................40
El oscilador........................................................................................................................41
El procesador principal ...................................................................................................41
Los circuitos grficos .......................................................................................................42
Procesador de audio ........................................................................................................43
Circuito de sonido............................................................................................................44
Mecanismos de proteccin contra copias .........................................................................45
2 Parte........................................................................................................................................49
Modelo de un emulador ..........................................................................................................49
Diagrama principal ..............................................................................................................49
El arranque ............................................................................................................................50
Bucle de la emulacin ..........................................................................................................51
2

Jos Tejada Gmez
El bucle de la mquina real.............................................................................................52
Ingeniera inversa: investigacin del equipo ........................................................................53
Investigacin de Gryzor ......................................................................................................53
Fichero g-1.rom ................................................................................................................54
Fichero G-2.rom................................................................................................................56
Fichero G-3.rom................................................................................................................58
Ficheros G-4, G-5, G-6... ..................................................................................................59
Anlisis del cdigo...........................................................................................................59
Uso .....................................................................................................................................65
El men Procesador.................................................................................................66
El men Memoria ....................................................................................................67
El men Ver..............................................................................................................68
El men Ventana......................................................................................................68
La emulacin del procesador ..................................................................................................69
El Motorola 6809...................................................................................................................72
Juego de instrucciones .........................................................................................................74
El compilador de un emulador...........................................................................................78
Anlisis de algunas instrucciones y su compilacin...................................................83
Ficheros que componen el emulador del 6809.............................................................84
Programacin de la funcin Exg (intercambio de registros) .................................85
El direccionamiento indexado ...................................................................................86
Registros y variables del emulador ...............................................................................88
La funcin Ejecuta ............................................................................................................89
Emulacin interna del registro de banderas ................................................................90
Disparo de la interrupcin IRQ......................................................................................91
El emulador del 6809 de Larry Bank .................................................................................92
La sincrona ...............................................................................................................................93
Sincronizacin mediante promediado de imgenes .......................................................94
Sincronizacin cronometrada .............................................................................................96
La emulacin del sonido..........................................................................................................97
Descripciones tcnicas detalladas de las mquinas emuladas...........................................98
Ghosts & Goblins..................................................................................................................98
Paginacin y mapa de memoria.....................................................................................99
Codificacin de los grficos en las memorias ROM..................................................100
Funcionamiento del circuito grfico............................................................................101
Formato de los octetos de atributos de los caracteres ..........................................101
Formato de los octetos de atributos de los fondos................................................101
Formato de los octetos de atributos de los objetos ...............................................101
Paleta ...........................................................................................................................102
Contenido ...................................................................................................................102
Interruptores DIP ...........................................................................................................103
El modo de pruebas.......................................................................................................105
Miscelnea.......................................................................................................................106
Gryzor ..................................................................................................................................107
Contenido de los ficheros ROM...................................................................................107
Paginacin y mapa de memoria...................................................................................107
Caracteres y fondos ...................................................................................................109
Objetos.........................................................................................................................109
El primer fondo..........................................................................................................110
3

Jos Tejada Gmez
El segundo fondo.......................................................................................................111
Los objetos ..................................................................................................................111
La paleta grfica.........................................................................................................111
Interruptores DIP ...........................................................................................................113
Primer microinterruptor ...........................................................................................113
Segundo microinterruptor........................................................................................114
Tercer microinterruptor ............................................................................................114
Miscelnea.......................................................................................................................116
Combat School ....................................................................................................................117
Contenido de los ficheros ROM...................................................................................117
Descripcin .................................................................................................................117
Paginacin y mapa de memoria...................................................................................118
Registro 500h ..............................................................................................................118
Los fondos...................................................................................................................119
Los objetos ..................................................................................................................120
Miscelnea.......................................................................................................................122
Conexin de una palanca normal............................................................................122
Salto de los retardos iniciales...................................................................................122
Los emuladores .......................................................................................................................123
Mapefer3, emulador de Ghosts & Goblins .....................................................................123
Plataforma de desarrollo...............................................................................................123
Diagramas de flujo fundamentales..............................................................................125
Funcin main ..............................................................................................................125
Preparacin y bucle de la emulacin ......................................................................126
Explicacin del cdigo fuente ......................................................................................127
main..............................................................................................................................127
OpIlegal.......................................................................................................................129
Inicia6809 ....................................................................................................................129
prepara_memoria ......................................................................................................130
teclado .........................................................................................................................131
escribe_mensaje..........................................................................................................131
dibuja_pantalla...........................................................................................................132
Fondo y dibuja_fondo...............................................................................................132
Resumen de las funciones.............................................................................................134
Diamond Run y Makaimura ............................................................................................135
Grytra , emulador de Gryzor y Contra............................................................................136
vuelca_ram .................................................................................................................137
muestra_mapa............................................................................................................137
salva y carga.................................................................................................................137
muestra_muecos......................................................................................................137
Escuela de combate, emulador de Combat School........................................................138
WinMain .....................................................................................................................139
Arranca........................................................................................................................140
4

Jos Tejada Gmez
ArrancaGraficos.........................................................................................................141
WindowFunc..............................................................................................................141
Emula6809...................................................................................................................143
Teclado ........................................................................................................................143
Conclusin e investigaciones ulteriores ..............................................................................144
Juego ............................................................................................................................144
Bibliografa ..........................................................................................................................146

Jos Tejada Gmez
Introduccin
Durante los aos ochenta el sector del videojuego
profesional vivi su poca dorada. Era un tiempo en
que los sistemas domsticos eran muy inferiores a los
sistemas especializados que ofrecan los salones
recreativos. Los xitos se sucedan para las compaas
desarrolladoras que integraban en su plantilla
ingenieros electrnicos y de programacin para
confeccionar a medida cada nuevo ttulo. Las empresas
que hoy son punta de lanza en el sector del videojuego
domstico comenzaron su andadura diseando estos
completos sistemas donde se cuidaban desde los
aspectos electrnicos de circuitos integrados
especficos para cada juego, hasta el prosaico mueble
de madera.
En 1987 haba en las casas ordenadores Spectrum, Amstrad, Commodore, Dragn... todos
ellos con un ancho de bus de un octeto y frecuencias de reloj en torno a 4 MHz. Las
mquinas que poblaban los salones recreativos portaban, por lo general, los mismos
procesadores que los ordenadores domsticos; sin embargo llevaban muchsima
circuitera adicional especializada en sonido y vdeo. La distancia tcnica era enorme,
el precio tambin: Una placa de vdeo profesional costaba unas 150 000 pesetas (unos
1000) cuando un ordenador completo, compuesto por monitor, placa, teclado y lectora
de cintas costaba unas 50000 Ptas. (unos 300). Al precio de la placa de vdeo haba que
aadir el del mueble, monitor y fuente de alimentacin. Las partidas solan pagarse a
25 Ptas. (unos 15 cntimos), el mismo juego poda comprarse para ordenador por unas
875 Ptas. (poco ms de 5); el precio de 35 partidas. La diferencia, sin embargo, entre la
versin original, de recreativa y la conversin a ordenador era abismal.
Gryzor, versin de Amstrad CPC (1987)
Gryzor, versin original (1987)
En las imgenes vemos la primera fase de Gryzor (Konami, 1987) en sus versiones de
mquina recreativa y de ordenador. Pese a la obvia superioridad de la mquina, estas
imgenes no descubren todos los mbitos de stas: El juego original ofreca un suave
desplazamiento de fondos, con dos planos distintos para aportar sensacin de
profundidad; la versin domstica presentaba una sucesin de pantallas fijas, sin
movimiento. El original ofreca msica y efectos sonoros simultneamente; en el
ordenador, haba que elegir entre uno u otro, estando disponible la msica slo para
los poseedores del equipo de gama alta: CPC 6128 (128 koct de memoria en vez de 64)

Jos Tejada Gmez
Pero el tiempo pas, la electrnica aument su capacidad de integracin y

procesadores y equipos cada vez ms potentes fueron abaratndose y ocupando un
lugar en las casas. Un equipo moderno barato es varias veces superior en cualquier
aspecto a cualquiera de esas mquinas de los aos ochenta, viejas reinas del videojuego.
Con los nuevos equipos surge una nueva posibilidad: en vez de reprogramar el juego
original (conversin), aprovechar la potencia del ordenador y simular el entorno donde
se ejecutaba el programa original: emular la mquina.
La emulacin consiste en tomar la parte intangible del juego: cdigo del programa,
grficos y sonido (toda ella almacenada en memorias ROM) e interpretarla en un
equipo distinto a travs de un programa llamado emulador, pues emula al sistema
original sin serlo.
Podemos entender la emulacin como una traduccin instantnea que hara, por
ejemplo, un intrprete en el Parlamento Europeo: escucha el mensaje original y va
produciendo otro adecuado al oyente. Antiguamente, estos juegos se llevaban al
ordenador mediante conversiones que, siguiendo el smil, seran como resumir un
libro escrito en otro idioma usando para ellos slo unas pocas hojas y perdiendo
multitud de detalles por el camino.
La programacin de un emulador tiene dos retos: desentraar el sistema a emular, y
escribir el emulador en s. Dado que estos juegos son propiedad intelectual de las
compaas desarrolladoras, la informacin disponible sobre su funcionamiento interno
es escassima; incluso la que se ofreca al servicio tcnico sera insuficiente para nuestro
propsito. La forma de averiguar el funcionamiento del equipo es tomar el cdigo
mquina de las memorias ROM esparcidas por el equipo y analizarlo con sumo
cuidado. El estudio detallado de ste, apoyado por conocimientos suficientes de
electrnica digital y computadores, ir desvelando poco a poco el funcionamiento de la
circuitera que estaba originalmente conectada en la placa. Con esta informacin se
puede empezar a imitar el comportamiento del juego en el ordenador, las pruebas de
lo ya simulado con el cdigo original ir descubriendo anomalas y abriendo nuevas
formas de investigacin. De forma iterativa aunque nada mecnica se harn converger
lo que espera el cdigo original y lo que ofrece el emulador hasta que la discrepancia
sea inapreciable. Nunca se emula toda la circuitera, slo aquella que es apreciable
durante el juego; por ejemplo, el circuito de autoarranque (usado para arrancar la
mquina de nuevo si se hubiese colgado) no suele simularse pues carece de sentido en
un ordenador.
Entre la emulacin de una mquina recreativa y la ejecucin de cdigo Java hay
muchas similitudes. El cdigo Java est formado por instrucciones mquina que
corresponden a un equipo imaginario: la mquina Java. Cualquier ordenador
disponible de una mquina virtual Java puede ejecutar un programa Java. La mquina
virtual no es ms que un emulador que recrea las circunstancias que espera encontrar el
cdigo.
En este proyecto de final de carrera, se va a explicar el funcionamiento de las clsicas
mquinas recreativas con sistemas grficos de mosaico (en contraposicin a las actuales,
con grficos tridimensionales) y se van a presentar tres emuladores distintos
7

Jos Tejada Gmez
explicando con detalle el proceso de anlisis y el posterior diseo y redaccin del
programa.
La primera parte describir las generalidades sobre los equipos y manifestar adems
las diferencias con un ordenador moderno y con otros sistemas electrnicos, actuales y
de la poca; tratando de poner en perspectiva al lector.
La segunda parte cubre el anlisis completo de las tres mquinas emuladas: Gryzor,
Combat School y Ghosts & Goblins; y el desarrollo de los emuladores desde el
punto de vista informtico, se destacarn las optimizaciones efectuadas para elevar el
rendimiento de los programas y se comentarn las exigencias que impone el sistema
operativo para el cual se desarrolle el programa.
Finalmente, se presentan los resultados que son los tres emuladores en s. stos pueden
probarse de antemano pues estn grabados en el mismo disco que esta presentacin.
Objetivos
Este proyecto de final de carrera pretende documentar con gran detalle el
funcionamiento de los sistemas recreativos de vdeo especialmente en cuanto sistemas
electrnicos aunque tambin se comentarn aspectos mecnicos y comerciales de los
mismos. La labor de documentacin persigue el mantenimiento y conservacin del
patrimonio tcnico que estos equipos constituyen como parte de la historia de la
electrnica. Ahora que ya parecen llegar a su ocaso, las mquinas recreativas
constituyen un conjunto cerrado y coherente cuya evolucin es menester que sea
escrita y guardada.
Mas para dotar a este trabajo de mayor vala tcnica, nos proponemos utilizar todos los
datos descritos a lo largo del presente documento para elaborar varios programas
emuladores- que simularn el entorno electrnico etolgicamente1 y harn posible que
el cdigo mquina original que antao estaba grabado en memorias ROM se ejecute en
nuestros modernos ordenadores de manera fidedigna, siendo, por tanto, facsmiles de
las mquinas verdaderas. El desarrollo de estos emuladores implica aunar dotes de
ingeniera inversa y directa , de electrnica y de informtica, de induccin y de
deduccin; constituyendo, por tanto, una labor cuya realizacin satisface enormemente
al ingeniero que encuentra en ella la resolucin de problemas de naturaleza lgica y la
ordenacin de lo hallado en pro de la construccin de un nuevo ingenio.
Resumidamente los objetivos son:
Describir los componentes de una mquina

Explicar el funcionamiento de los sistemas grfico y sonoro
Mostrar cmo se realiza la investigacin mediante ingeniera inversa
Escribir un emulador del procesador 6809 con un compilador intermedio
Realizar los emuladores de tres mquinas: Ghosts&Goblins, Gryzor y Combat
School.
De etologa estudio del comportamiento. Hemos preferido este cultismo frente al barbarismo
behavioural.

Jos Tejada Gmez
1 parte
Los sistemas de las mquinas recreativas de vdeo
Las mquinas recreativas de vdeo son sistemas electrnicos especializados en proporcionar una
partida a un videojuego a cambio de un pago previo. El caso ms habitual es la mquina de
diseo a medida: una placa, unas palancas y botones, un armario y en ocasiones hasta una
fuente de alimentacin especficas para el juego en s y que no sirven para ningn otro.
La mquina recreativa se compone de un mueble de madera, donde se montan las
dems partes; de luces, que iluminan el espacio en torno al equipo; de unas palancas y
botones, para accionar el juego; de un monedero y cofre, que filtra las monedas que
entran y las almacena; de una placa de circuito impreso, donde est el juego en s; de
altavoces, para la msica y efectos sonoros; y de una fuente de alimentacin que
proporciona potencia elctrica a todo lo dems: luces, monedero y placa (los altavoces
y las palancas se alimentan desde la placa)
Descripcin general: El mueble, las palancas y el monedero

El mueble da robustez al equipo y ha de soportar los malos tratos de nios y adultos.
Existen dos modelos bsicos: vertical y de mesilla. El vertical es el ms popular por
ocupar menos espacio y tener el cristal menos expuesto. El monitor va en horizontal y
un espejo se encarga de reflejarlo para que al jugador le parezca tenerlo enfrente, de
esta forma se ahorra profundidad, pues el largo tubo de rayos va hacia abajo;
quedando adems ms protegido de esta forma. En las mesillas el monitor tambin
est horizontal pero no hay espejo, sino un cristal plano sobre la pantalla que acta de
protector; los jugadores utilizan el espacio plano que se forma para depositar las
bebidas o apoyarse mientras ven a otros jugar. Las mesillas favorecen la sociabilidad
del juego y la exhibicin del mismo, pero ocupan mucho espacio en comparacin con
los muebles verticales que terminaron imponindose.
Ms Pac-Man , mueble normal

2
Ms Pac-Mac, mueble mesilla
Midway/Namco, 1982

Jos Tejada Gmez
Las placas llevaban normalmente un conmutador para seleccionar el tipo de mueble
donde estaban instaladas y la orientacin del monitor. Si el monitor estuviese
enfrascado en un armario vertical la imagen habra que mostrarla girada e invertida
para que al reflejarse en el cristal sta se viese correctamente. Los conmutadores de
reflejo horizontal y vertical de los grficos son muy comunes en todas las placas y
constituyen un ejemplo de lo que no se suele emular por carecer de sentido: Para qu
ver el juego al revs en un ordenador? No simular esta circuitera es inocuo pues
aunque el procesador lea el conmutador para averiguar como debe pintar los grficos
realmente no los pinta l uno a uno, sino que ordena a la circuitera grfica que los
pinte invertidos. El lazo no se cierra y el procesador no tiene forma de averiguar si los
grficos salen del derecho o del revs, por lo que no emular este comportamiento
ahorra trabajo y no tiene efectos en el juego. Pese a esto, recientemente ha comenzado a
ser habitual incluir esta funcin, pues se ha popularizado el uso de muebles de
mquina recreativa conectados a ordenadores; en esa circunstancia vuelve a tener
sentido el incluir esta caracterstica.
En la cabeza del armario, por encima del jugador, se forma una pequea techumbre
(marquesina) donde muchas veces se colocan los altavoces (pues a los lados de un
mueble suele ir otro) y tras un cristal va un dibujo que se ilumina con un tubo por
detrs. En algunos equipos este tubo est conectado a la placa y es controlable por el
juego para manejarlo segn la accin.
Marquesina de Contra (Apodo de Gryzor en Europa)
10

Jos Tejada Gmez
1
2
3
4
5
6
7
8
9
10
11
12
tubo fluorescente de la marquesina

plstico de la marquesina
pareja de altavoces de 8
soporte de la marquesina
espuma protectora del monitor
plstico tintado
cristal
panel de control de madera
cierre del panel (dos piezas)
13
14
15
16
17
18
19
20
21
soporte del monitor (dos posiciones)

3
monitor RGB
paredes de madera
placa del juego
interruptor de encendido
contador de monedas
cable de red
fuente de alimentacin con cuatro
salidas
puertas de los monederos
22
fusibles
23
transformador
pernos del monitor
24
filtro de red
elementos de un mueble de mquina recreativa
Ya en la mitad inferior del armario, sobre una repisa se colocan las palancas y los botones. La
calidad de estos suele ser muy elevada, pese a lo cual no son irrompibles y solan acabar
sucumbiendo ante la furia de jugadores insatisfechos. Los botones y la palanca no son ms que
interruptores que llevan su seal por un cable cada uno (sin ninguna multiplexacin) hasta la
placa, que es adems quin suministra la tensin elctrica necesaria para su funcionamiento.
La placa puede colocarse verticalmente en uno de los laterales de la mquina o en
horizontal sobre unas baldas disponibles al efecto. La placa tiene por lo general un
conector normalizado llamado jamma, al que llega la manguera de cables
provenientes de altavoces, tubo, palancas, monitor y fuente.
La alimentacin est colocada al fondo del mueble y es la nica conexin con el
exterior. Suele proveer de +5V y +12V, el primero para la lgica digital y el segundo
RGB, rojo verde y azul; hace referencia a que la seal llega al monitor separada por tres
canales y no en forma de crominancia y luminancia como en un televisor
3
11

Jos Tejada Gmez
para los componentes analgicos (por ejemplo, los amplificadores de audio sitos en la
placa)
El monedero 4 bsico se conecta tan slo a la
alimentacin y a la placa para hacer llegar la seal
que indica la insercin de monedas, sta se activa
a nivel bajo (0V). Otra conexin comn va desde
el monedero hasta un contador que registra el
nmero y tipo de monedas insertadas. Esta
funcin est a veces realizada en la propia placa
del juego, se puede acceder a la contabilidad
activando el modo de servicio. La imagen a la
izquierda muestra la pantalla de contabilidad de
Crater5 en ella los apartados Chute indican cuntas
monedas han entrado por cada tobera. Los otros
datos, como puntuacin mxima y partida ms
larga sirven para decidir si hay que subir el nivel de dificultad del juego o bajarlo
segn la audiencia.
Los monederos se componen de una ranura por la que se introduce la moneda y que
conduce a un pasaje en cuyo final hay una pieza mvil controlada por un rel. Si la
moneda es aceptada el rel la dejar pasar a la siguiente etapa y si no la devolver al
cliente. No es habitual que en las mquinas de vdeo halla un sistema de clasificacin
de monedas puesto que no es necesario, slo en las tragaperras de premio se incluye
una etapa posterior al monedero que, siguiendo las rdenes de este, har pasar la
moneda por una u otra tobera hasta la caja o el monedero para pagar premios.
Cuando la moneda est cayendo por la ranura unos fotodiodos detectan su paso y se
toma una medida de la permitividad magntica de la misma y del tiempo que tarda la
moneda en caer. En algunos monederos, una galga trata de medir adems el peso.
Todas estas medidas se digitalizan y se contrastan con unas tablas grabadas en la
EPROM del microcontrolador donde hay cotas para cada valor.
Con el tiempo, el monedero empieza a errar la medida debido al envejecimiento de los
componentes; los valores tomados comienzan a caer fuera de los intervalos permitidos
y se rechazan muchas de las monedas. Cuando esto ocurre es necesario reprogramar el
monedero. Para ello basta con volver a calibrarlo insertando monedas vlidas y
midiendo los mximos y los mnimos que causan. Acto seguido se modifican los
valores de las tablas en la EPROM y el monedero ya est listo otra vez.
Las tablas limitan a su vez el nmero mximo de monedas distintas que aceptar el
monedero, pues el nmero de filas de estas tablas est limitado en cada modelo; lo
normal es diecisis. Para cada moneda hay, por tanto, una fila en la tabla de medidas
pero tambin otras filas en otras tablas para indicar el nmero de pulsos que enviar el
monedero, el canal por el que saldrn y cada cuantas monedas. Dos ejemplos de
programacin vlidos seran:
Tipo de moneda
25
4
5
Canal
1
Pulsos
1
N de monedas
1
La empresa navarra Azkoyen es la principal suministradora de monederos en Espaa

Bally Midway, 1984
12

Jos Tejada Gmez
100
500
1
1
4
20
1
1
Para partidas a 25 Ptas. usando un solo canal

Tipo de moneda
25
100
500
Canal
1
1
1
Pulsos
1
2
10
N de monedas
2
1
1
Para partidas a 50 Ptas. usando dos canales.

Las placas de vdeo siempre tienen al menos dos canales para aceptar monedas aunque
suele usarse slo uno por simplicidad, mandando sencillamente ms o menos pulsos.
El nmero de partidas que da la mquina por cada moneda se controla mediante
microinterruptores DIP siendo lo ms comn dar una partida por moneda en el primer
canal y cuatro por moneda en el segundo (si es que se usa)
monedero real, desmontaje
13

Jos Tejada Gmez
El monitor
El monitor de las mquinas recreativas funcionaba con una frecuencia horizontal de 15
kHz y una vertical de 60 Hz. La manera de conectarlo a la placa y al mueble se describe
en otros apartados, en ste vamos a ocuparnos de valernos de un televisor como
monitor.
Conexin de una mquina recreativa a un televisor domstico6

Con el advenimiento de televisores con euroconector es posible enchufar la placa al
televisor sin necesidad de ningn circuito intermedio. El televisor debe estar preparado
para aceptar una entrada separada en el triplete bsico: rojo, verde y azul (RGB). Esta
exigencia no se cumple en muchos televisores que slo admiten vdeo compuesto.
fotografa de un cable euroconector-euroconector
El conexionado es como sigue:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
salida del canal de sonido B

entrada del sonido B
salida del sonido A
masa de los canales de sonido
masa del canal del color azul
entrada del sonido A
azul
conmutacin de funciones
masa del verde
2 lnea de comunicaciones
verde
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
1 lnea de comunicaciones
masa del rojo
masa de las comunicaciones
rojo
blanco
masa del vdeo compuesto
masa del blanco
salida de vdeo compuesto
entrada de vdeo compuesto
masa comn (carcasa del conector)
Esta seccin est basada en el trabajo de Jonathan Dawes
14

Jos Tejada Gmez
Segn la norma Jamma, hay que hacer:
placa
rojo
verde
azul
masa
sincrona
+5V
patilla del euroconector

rojo
verde
azul
masas
entrada de vdeo
blanco
nmero de la patilla
15
11
7
5,9,13,18 y 21
20
16
Adems las patillas 8 y 16 sirven para seleccionar el tipo de seal de entrada, en

nuestro caso ambas deben estar activadas.
De esta forma habremos conseguido la imagen, el sonido se puede obtener en algunas
mquinas a travs del conector jamma y en otras como Gryzor- mediante una
conexin aparte. Para enchufarlos en este caso tampoco hace falta ninguna interfaz, un
cable directo bastar.
Una vez conectada la placa al televisor se puede utilizar una fuente de alimentacin de
ordenador y una palanca de juegos normal (que no sea USB) para completar el equipo.
Las fuentes de ordenador comnmente suministran +5V y +12V, algunas placas
requieren adems de estas dos tensiones las mismas en negativo, si bien son las menos.
En cuanto a la palanca ser necesario desmontarla y cablear directamente cada
interruptor con la placa de videojuegos.
15

Jos Tejada Gmez
La placa
La placa contiene el videojuego en s, la descripcin de los circuitos que la componen se
realizar ms adelante; en este apartado nos ocuparemos de la interconexin de sta
con el resto del sistema.
posicin de la placa en el
mueble normal
posicin de la placa en el mueble mesilla
La placa suele ir atornillada verticalmente al mueble en la parte inferior del mismo,

aunque a veces se encuentran placas en posicin horizontal, sobre todo si estas tienen
varios pisos.
La conexin de la placa con el resto del sistema se realiza con un conector normalizado
llamado jamma, la imagen en la pgina siguiente detalla el conexionado de la mquina
recreativa Gryzor, que es un ejemplo muy representativo al tratarse de la tpica interfaz
para dos palancas y cuatro botones. El conector jamma se encuentra en uno de los
bordes de la placa y se compone de 56 contactos, 28 por cada cara e incluye
alimentacin, controles (palancas y monederos) , monitor y audio. En ocasiones el
sonido tiene un conector aparte para evitar la parafona y el ruido inducidos por la
circuitera digital.
La alimentacin era originalmente bipolar, 5V y 12V; pero ya por mediados de los
aos ochenta lo comn era utilizar nicamente alimentacin positiva +5V para la lgica
y ocasionalmente 12V para la etapa de audio. Las patillas de alimentacin estn
separadas de las dems por una muesca que indica tambin el sentido del conector.
Tras la muesca vienen las salidas del contador de monedas. Cada vez que se introduce
una, la placa genera un pulso (activo a nivel bajo, como todas las dems seales) que
informa al contador de monedas. Estos contadores sirven para conocer la recaudacin
del equipo y llevar la contabilidad.
16

Jos Tejada Gmez
conexionado de Gryzor
Como se indica en la imagen superior, todas las entradas son activas a nivel bajo y no
existe ninguna multiplexacin de las seales; aunque esto eleva el nmero de cables
simplifica la circuitera de las palancas a la mnima expresin posible: un interruptor;
facilitando, por tanto, las reparaciones posteriores.
17

Jos Tejada Gmez
El sistema de vdeo de una mquina de videojuegos

Almacenamiento de las imgenes
Composicin de los fondos
Dibujar un fondo de 256x256 puntos con un octeto por punto representa mover 64ko
de memoria. Para un procesador de 8 dgitos esta cantidad representa toda la memoria
direccionable y un tiempo de proceso muy elevado. En el caso del 6809 suponiendo un
direccionamiento indexado para leer y escribir los datos seran precisos
aproximadamente (6+8)*65536=917504 ciclos de reloj, a 1MHz eso implica casi un
segundo, siendo optimista7; una animacin suave exige al menos 24 fotogramas por
segundo, esta cantidad es imposible de alcanzar con los datos presentados.
Para solventarlo las mquinas de vdeo
disponen de un circuito grfico encargado de
hacer la labor citada, lo nico que necesita
este dispositivo para funcionar es saber qu
pintar. En el caso de los fondos esta
informacin viene en forma de mosaico de
octetos. Los fondos del juego se almacenan
cortados en bloques numerados. El circuito
grfico dispone de una memoria mapeada en
el espacio direccionable del procesador
principal. ste escribir en ella los nmeros
de los bloques a dibujar. El ahorro es enorme:
para pintar un bloque de 16x16 puntos basta
con escribir un nico octeto, la ventaja es de
64 a 1. Esta memoria adems funciona de forma secuencial, es decir, desde donde
empieza cada octeto equivale a un bloque de 16x16 en la pantalla, de forma lineal. Esto
evita la necesidad de tener que escribir la posicin del bloque en el dibujo, pues est
implcita segn el orden que ocupa en la memoria grfica.
Asociado a cada bloque de la pantalla hay, por lo menos, otro octeto que da
informacin adicional como:
Ha de dibujarse girado horizontalmente?

Ha de dibujarse girado verticalmente?
Qu paleta grfica utilizar?
Ha de tapar a los objetos?
Estos datos suelen codificarse en un solo dgito cada uno salvo la paleta que
habitualmente ocupa entre dos y cuatro dgitos. El asociar una paleta cambiable a los
grficos permite efectos como el de la famosa cascada, cuya agua no se mueve sino que
sus colores ciclan; es decir, lo nico que el procesador toca son los dgitos que indican
con que paleta se pinta el bloque, el efecto ocurre por s mismo.
El optimismo reside en no contar el tiempo invertido en descontar la variable que formara el
bucle y en realizar el salto al final de cada iteracin
18

Jos Tejada Gmez
La memoria de fondos tiene habitualmente una correspondencia lineal con la pantalla.
Si suponemos una imagen de 256x256 puntos, que ser dibujada usando bloques de
8x8 puntos (32x32 bloques); la memoria de fondos estara organizada de forma que los
primeros 32 octetos estaran relacionados con la primera fila a pintar, los siguientes 32
octetos con la segunda, etc. La relacin entre la memoria de fondos y la pantalla es por
lo tanto directa y no hay que precisar en qu posicin se pintar cada bloque puesto
que esta informacin est implcita en la direccin de memoria en que se ha escrito el
cdigo del bloque.
Funcionamiento de la memoria de fondos
La operacin de dibujar una imagen es costosa, sin embargo, una vez dibujada no ha
terminado el trabajo: es necesario desplazarla. El escenario sobre el que se juega es
esencialmente mvil, ha de avanzar cuando el personaje avanza, puesto que si fuese al
contrario (un escenario inmvil y un personaje ambulante) el jugador acabara
rebasando los lmites de la pantalla obligando a un cambio brusco de fondo; esta
situacin siempre trata de evitarse. Lo habitual es que el jugador ocupe siempre una
situacin prxima al centro del monitor y que sea el fondo el que refleje los
movimientos del personaje.
Desplazar la imagen costara tanto como volver a pintarla si fuese el procesador el
encargado de hacer el trabajo. Habra que tomar cada punto del fondo y repintarlo en
otras coordenadas, la labor para un procesador de 8 dgitos es inmensa.
Los circuitos grficos tienen unos registros en los que se indica el desplace de la
imagen en coordenadas. De esta forma si se desea mover el fondo cinco puntos a la
izquierda bastar con almacenar un cinco (o menos cinco) en el registro de desplace
horizontal, dem para los casos verticales.
Si pintamos todo desplazado cinco puntos a la izquierda estaremos empezando cinco
puntos ms tarde a pintar y estaremos acabando cinco puntos despus: de dnde
salen esos puntos adicionales a la derecha? La solucin viene de trabajar con una
pantalla virtual habitualmente cuatro veces mayor que la real, de forma que lo que se
nos presenta no es ms que una ventana dentro de un espacio mayor. La esquina
superior de esa ventana por la que nos asomamos al fondo constituyen los registros de
desplace mencionados.
19

Jos Tejada Gmez
Funcionamiento de la pantalla virtual
Las mquinas que llegaron a partir de 1986 comenzaron a incluir varios planos de
fondo en lugar de uno slo, para dar as profundidad a la imagen. La tcnica consiste
en colocar debajo del fondo que hemos estudiado otro de idnticas caractersticas, pero
que se desplazar a una velocidad inferior. Se trata de imitar las lneas de fuga que
tienen las imgenes reales tridimensionales. Cuando vamos en un tren y miramos por
la ventanilla, los postes de la catenaria pasan raudos ante nosotros, pero las distantes
montaas se desplazan con lentitud, entre nuestra posicin y el horizonte cada punto
parece moverse a una velocidad.
Incluir dos planos de fondo se convirti pronto en una necesidad, sin embargo los
juegos con ms de dos planos fueron pocos, aunque hay casos donde se lleg a incluir
ms de una decena de planos, a veces formados por finas bandas horizontales para
mostrar nubes o montaas lejanas, el caso ms renombrado fue el juego Shadow of
the Beast.
Aadir un segundo plano es ms una sobrecarga para la memoria que para el
procesador, pero en ambos casos supone poco esfuerzo adicional. Al ser un plano ms
lento no es necesario actualizar los bloques que lo componen de forma tan frecuente y
generalmente se permite que la animacin sea cclica de manera que la montaa o nube
que sale por un lado de la pantalla aparece por el opuesto. El tiempo de proceso
requerido es escaso y la memoria tambin ha de serlo, puesto que la variedad de
imgenes a almacenar es considerablemente menor.
Desde el punto de vista de la circuitera s que se aade una complicacin considerable.
El dibujado del fondo ha de hacerse ahora en paralelo, duplicando la circuitera y
utilizando una puerta lgica al final que dejar pasar el punto del segundo plano slo
cuando el del primero sea cero.
20

Jos Tejada Gmez
Movimiento de los objetos

Entenderemos por objetos todos aquellos pequeos elementos mviles sobre el fondo
(escenario) en el que se desarrolla la accin; es decir, los personajes que maneja el
jugador o que controla la mquina. Estos objetos se enfrentan a la misma problemtica
de ineficiencia que los fondos: demasiados puntos y dgitos por punto para un
procesador tan lento. La solucin esta vez no puede venir en forma de mosaico, ya que
los objetos pueden ocupar cualquier posicin de la pantalla, por lo que el
planteamiento de memoria direccionada segn el orden de la pantalla ya no es vlido.
En su lugar los objetos se controlan con una estructura que contiene, al menos, la
siguiente informacin:
bloque grfico en la ROM que representa al objeto

coordenadas en la pantalla
est girado (horizontalmente)?
paleta
Los bloques son en general de 16x16 puntos, pero eso no implica un problema a la hora
de dibujar objetos mayores, ya que puede pintarse un bloque junto a otro para
componer objetos mayores. En ocasiones la misma circuitera grfica dispone de
aceleracin para este caso, por ejemplo, en la mquina Gryzor hay un dgito asociado a
los objetos que indica si habr de pintarse el siguiente objeto almacenado en la ROM
grfica justo debajo del objeto pintado.
El nmero mximo de objetos dibujables depende de la circuitera grfica, siendo lo
habitual una cifra entre 16 y 64. Como habitualmente slo se trabaja con un pequeo
nmero de objetos muy inferior a las capacidades de la circuitera, las estructuras de
los objetos inutilizados se rellenan de forma que sus coordenadas de dibujado indican
la esquina inferior derecha de la pantalla, por lo que se pintarn fuera del rea visible
por el jugador.
21

Jos Tejada Gmez
El sistema de audio de una mquina de videojuegos

En esta seccin aprenderemos por qu la msica basada en modular la frecuencia de
un tono es una eleccin comn en las mquinas recreativas, as como la forma en que
se consigue generar melodas, con especial atencin al modelo real de sintetizador de
F.M.
Introito histrico
Los circuitos que vamos a estudiar surgen de la necesidad de tener sonido a bajo coste
en sistemas donde la msica no es el objetivo principal. Ejemplos de aparatos que
cumplen este requisito son:
Los ordenadores personales: aunque en ocasiones escuchamos msica en ellos, no es su
principal funcin; por tanto, son candidatos a soluciones de bajo coste.
Las mquinas recreativas tipo A y B: En este grupo se incluyen las denominadas
tragaperras, los pitufos8 y las mquinas de videojuegos. En todas ellas, la msica, los
sonidos o las voces son elementos importantes para atraer al cliente; pero no la funcin
primordial9
Telfonos: hoy da se usan en telefona mvil, aunque no es un modelo basado en MF
sino en MIC10 por lo general.
Electrodomsticos y juguetes electrnicos.
La problemtica en estos aparatos es conseguir una calidad de sonido aceptable a un
coste pequeo (orientativamente, menor del 5% del costo total). Las primeras
soluciones, en los albores de la electrnica integrada, fue digitalizar el sonido para
reproducirlo posteriormente. El inconveniente es el tamao de las memorias ROM
necesarias; para solventarlo se recurra (all por 1980) a bajas frecuencias de muestreo y
codificaciones de alta relacin seal-ruido, como la modulacin diferencial y
adaptativa de pulsos codificados (ADPCM). Esto se traduce en baja calidad, mxime
hace veinte aos, cuando el precio de una ROM de 4kB era prohibitivo.
El remedio pasa por generar la msica sobre la marcha11, a travs de un sistema que a
modo de instrumentista, reproduce adecuadamente la composicin. De esta forma la
informacin a guardar sera slo de notas y tiempo, mucho menor que antao. Aunque
ahora es necesario un director, un procesador que indicase qu nota tocar en cada
Son mquinas destinadas a los nios de menor edad. En general son algn tipo de mvil sobre
el que el nio se sienta. Al insertar el dinero ste se mover y producir sonidos.
9 La funcin primordial de estos ejemplos sera, respectivamente: el premio aleatorio, el
movimiento mecnico y el juego en s.
10 Modulacin de Impulsos Codificados, bsicamente son trenes de pulsos de frecuencia
programable
11 En el mercado de los videojuegos se habla de cuatro generaciones: la primera se basaba en
grficos, sonido y comportamiento predeterminados; la segunda generacin incluy el sonido
desarrollado en tiempo real (usando sintetizadores); la tercera la vivimos en la actualidad,
donde los grficos del videojuego tambin se calculan conforme se necesitan sin dibujarse
previamente; la cuarta pretende que el comportamiento de las entelequias (enemigos, etc...) del
juego tambin se calculen sobre la marcha, es decir, busca un comportamiento ms inteligente
de los rivales.
8
22

Jos Tejada Gmez
momento, y por cunto tiempo. Una configuracin tpica en mquinas recreativas (que
aun en diseos actuales12 se sostiene) es un procesador Z80 con una EPROM de 32kB
(con cdigo y datos), acompaando a algn sintetizador. Como vemos, las necesidades
del director son pequeas.
Diagrama de bloques de un sintetizador basado en MIC

Como hemos visto en el apartado anterior, es necesario un circuito que pueda
configurarse para producir distintas notas. Bsicamente esto significa que el espectro
de la seal de salida es deslizable, pudiendo centrarse en un conjunto de frecuencias
distintas; produciendo as msica.
Dado que estos circuitos sintetizadores son digitales, parece natural que la primera
forma de onda que se escogiese (sin ningn criterio musical) fuese el tren de pulsos.
De l podemos modificar dos parmetros: la amplitud y la frecuencia13. El primero ser
importante a la hora de mezclar varios canales de sonido. La frecuencia es fundamental,
pues marcar la nota que estamos reproduciendo.
tren de pulsos, se indican el perodo y la amplitud
Tenemos una ltima forma de modificar la seal: envolverla. Hay muchos tipos de
ventana14, es decir: funciones con las que multiplicamos la seal. La ms comn en
estos circuitos es la mostrada en la figura inferior; se trata de una trapezoide que
introduce el sonido y ms tarde lo atena. Su utilidad es evidente; permite introducir
las notas con suavidad y apagarlas con naturalidad.
Aunque este enfoque puede parecer a priori ineficaz por su excesiva sencillez, la
realidad es que estamos rodeados de l, en formas incluso ms simplificadas (sin
envolvente); es el tpico pitido electrnico. Si bien ha sido la base sonora de sistemas
antiguamente tan potentes como el Atari ST15.
envolvente tpica de una nota

En el ao de 1999, aun encontramos placas de mquinas recreativas nuevas que usan
procesadores tan antiguos como el Z80; si bien son las ms econmicas y su diseo no es
innovador en ningn aspecto.
13 Ciertamente, el ciclo de trabajo podra haber sido modificado tambin. Esto hubiese afectado
al espectro ensanchndolo o comprimindolo. Sin embargo, no he encontrado ningn circuito
real que permita modificar esta caracterstica.
14 Utilizar el trmino ventana, que se aplica en la disciplina de proceso digital con un
significado distinto, pero similar a ste.
15 El Atari ST fue un ordenador basado en el M68000, su interfaz de usuario era grfica.
12
23

Jos Tejada Gmez
Recapitulando, el diagrama de bloques genrico para estos circuitos sera:
Diagrama de bloques de un sintetizador MIC
Externamente se colocara un filtro paso bajo, como complemento al convertidor D/A;

aunque este filtro puede realizar ms labores y en general su forma no ser plana en la
banda de paso, sino que introducir alguna ecualizacin o realce.
24

Jos Tejada Gmez
Bloques de un sintetizador FM
El sintetizador FM es notablemente ms complejo que el MIC, huelga decir que una
modulacin en frecuencia es ya de por s conceptualmente mucho ms complicada que
una seal MIC.
Los operadores
El subsistema fundamental dentro un sintetizador de MF es el operador. Un operador es
un circuito electrnico digital que genera una seal binaria representacin de una
forma de onda peridica programable, generada internamente, relacionada
matemticamente con la seal presente a su entrada.
La combinacin de operadores permite conseguir seales discretas complicadas, el
parecido de estas secuencias a lo que se obtendra digitalizando el sonido de un
instrumento musical es lo que dotar una meloda de realismo. El objetivo se cifra
entonces en la semejanza de dos seales temporales o de dos espectros; si bien el
resultado debe ser evaluado auditivamente, por lo que secuencias diferentes a las
reales pueden ser vlidas en ciertos contextos.
Funciones posibles
Un operador responde en general a la siguiente expresin:
E (t ) = A(t ) sen[( N c + Dc )wt + B (t ) sen( N m + Dm )wt ]

Vemos que A(t) es la envolvente de volumen, y B(t) la envolvente de tono. Los
parmetros Nx y Dx, controlan la tonalidad asociada a sus senoidales. Cuando B(t) es
mayor que cero la salida ya no es senoidal, sino una forma con gran componente
armnica. Veamos algunos ejemplos:
1
0.8
0.8
0.6
0.6
0.4
0.4
0.2
0.2
-0.2
-0.2
-0.4
-0.4
-0.6
-0.6
-0.8
-0.8
-1
200
400
600
800
1000
1200
1400
1600
-1
200
400
Fig. 1 B(t)=0, (Nc+Dc)=1, A(t)=1

1
1
0.8
0.6
0.6
0.4
0.4
0.2
0.2
-0.2
-0.2
-0.4
-0.4
-0.6
-0.6
-0.8
-0.8
0
200
400
600
800
1000
1200
Fig. 3 B(t) = 1
1400
1600
800
1000
1200
1400
1600
1400
1600
Fig.2 B(t)=0.5
0.8
-1
600
-1
200
400
600
800
1000
1200
Fig. 4 B(t)=1.5
25

Jos Tejada Gmez
0.8
0.8
0.6
0.6
0.4
0.4
0.2
0.2
-0.2
-0.2
-0.4
-0.4
-0.6
-0.6
-0.8
-0.8
-1
200
400
600
800
1000
1200
1400
1600
-1
200
Fig. 5 B(t) = 2
Fig. 6
1
0.8
0.8
0.6
0.6
0.4
0.4
0.2
0.2
-0.2
-0.2
-0.4
-0.4
-0.6
-0.6
-0.8
-0.8
-1
200
Fig. 7
400
600
800
1000
1200
1400
N c + Dc
= 0.5; B(t ) = 1.0
N m + Dm
Vemos que el cociente
1600
-1
200
Fig. 8
400
600
800
1000
1200
1400
1600
N c + Dc
= 0.5; B(t ) = 0.5
N m + Dm
400
600
800
1000
1200
1400
1600
N c + Dc
= 0.5; B(t ) = 1.5
N m + Dm
N c + Dc
determina dnde va a ser ms influyente la
N m + Dm
modulacin. As si vale la unidad el efecto es ms claro en los puntos donde la

modulada corta el eje de abscisas; y si vale 0.5 es ms notorio el efecto en los mximos
y mnimos de la modulada.
26

Jos Tejada Gmez
Conexionado de los operadores

Siendo cada operador bsicamente el generador de una seal peridica funcin de su
entrada; la forma en que interconectemos estos elementos determinar totalmente el
sonido. La conexin bsica en MF es en cascada, donde la salida del primer operador (o
modulador) domina la entrada del segundo (o modulado).
Una situacin comn consiste en que el primer modulador tambin se realimente de s
mismo; aumentando as la complejidad de la modulacin.
Configuraciones interesantes son tambin aquella en que un operador modula a otros
tres, cuyas salidas se suman; consiguiendo as efectos de eco y coro. O por ejemplo,
cuatro operadores sumados directamente, imitando el comportamiento de los
sintetizadores MIC.
Efectos aadidos: El enventanado

Una envolvente habitual est compuesta de cuatro segmentos que contribuirn a hacer
sonar la nota de forma ms realista:
TA
TD1 TD2 TR
Tasa de ataque: Determina la duracin del tiempo de Ataque. (TA). Durante el

tiempo de ataque el sonido pasa desde la mxima atenuacin hasta la mnima
Primer tiempo de cada: La amplitud decrece con mucha pendiente
Segundo tiempo de cada: La amplitud cae ms lentamente
Tiempo de liberacin: La nota deja definitivamente de sonar
27

Jos Tejada Gmez
Estudio de algunos circuitos integrados comerciales.

El YM-2149, sintetizador MIC
El YM-2149 es un antiguo sintetizador 16 de la casa Yamaha. En la documentacin
suministrada por el fabricante vemos que lo llama SSG, acrnimo de Software Sound
Generator y lo describe como la solucin final para los equipos que precisen sonido.
Como veremos, sus caractersticas hoy da nos parecen casi ridculas, pero no debemos
despreciar este integrado, tan capaz hoy como antes de generar msica.
Caractersticas
Circuito fabricado con tecnologa NMOS LSI
Facilidad de conexin a CPUs de 8 y 16-dgitos.
Dos puertos de 8-dgitos de propsito general para conectar a sistemas externos.
Ancho de banda musical de ocho octavas.
Suave atenuacin producida por un generador de envolvente de 5-dgitos
Convertidor D/A de 5-dgitos integrado
Compatible conexin a conexin con el AY-3-891017
De entre estas caractersticas destaca la curiosa inclusin de los dos puertos de 8dgitos. Eso aade un valor adicional al integrado en una poca en la que el diseo de
computadoras estaba dominado por procesadores de 8-dgitos como el Z80 o el M6809.
Descripcin de funciones
El YM2149 se controlaba programando sus diecisis registros internos, tras lo cual la
CPU quedaba libre para trabajar en otras tareas. Sus posibilidades son:
Generador de msica: Produce ondas cuadradas de distintas frecuencias para cada
uno de sus canales (A,B, y C)
Generador de ruido: Formas de onda seudo-aleatorias por el canal de ruido.
Mezclador: La salida es la suma de los tres canales de msica y el de ruido.
Control de nivel: El volumen global de cada canal lo controla la CPU externa. El
volumen final vendr dado tambin por el generador de envolvente.
Convertidor D/A: Ahorra la necesidad de un convertidor externo.
Su fecha de salida al mercado est en torno a 1986, quiz finales de 1985.

El AY-3-8910 fue un integrado fabricado por GI de caractersticas similares al presente, pero
ms antiguo. Fue un autntico xito y se convirti en el estndar de facto hasta la llegada de los
sintetizadores basados en FM.
16
17
28

Jos Tejada Gmez
Modelo de programacin del YM-2149
Toda la programacin de este integrado consiste en escribir los parmetros de cada
canal de ondas cuadradas, del generador de ruido y del generador de envolvente en el
mapa de registros del circuito. A continuacin se expone este mapa:
R0
R1
R2
R3
R4
R5
R7
R8
R9
RA
RB
RC
RD
RE
RF
B7
B6
B5
B4
B3
B2
B1
Ajuste de tono fino con 8-dgitos
Frecuencia del canal A
Sin usar
Ajuste grueso, 4 dgitos
Frecuencia del canal B
Sin usar
Frecuencia del canal C
Sin usar
Mezclador y puertos de E/S
Ruido
Tono
E/S
ES/B ES/A C
B
A
CB
A
Sin
M
L3
L2
L1
L0
Volumen del canal A
usar
Volumen del canal B
Sin usar
M
L3
L2
L1
L0
Volumen del canal C
Sin usar
M
L3
L2
L1
L0
Frecuencia
de
la Ajuste grueso de 8-dgitos
envolvente
Ajuste fino de 8-dgitos
Forma de la envolvente
Sin usar
CONT ATT ALT
HOLD
Puerto de E/S de datos A 8-dgitos de datos
Puerto de E/S de datos B 8-dgitos de datos
Como vemos, la simple descripcin es ya bastante intuitiva. Cabe explicar las distintas
formas de envolvente admitidas:
B3
CONT
0
0
1
1
1
1
1
1
1
1
B2
ATT
0
1
0
0
0
0
1
1
1
1
B1
ALT
X
X
0
0
1
1
0
0
1
1
B0
HOLD
X
X
0
1
0
1
0
1
0
1
29

Jos Tejada Gmez
El YM-2203
El YM-2203 representa la transicin entre los sintetizadores basados en MIC y los
puramente de FM Vemos como pese a introducir la nueva tecnologa de FM la
compatibilidad con los circuitos existentes basados en MIC se consider bsica en su
diseo.
Caractersticas
El sistema de sonido FM produce tres sonidos distintos al mismo tiempo.

Uno de los tres sonidos anteriores puede colocarse en un modo bajo el cual
pueden realizarse efectos sonoros especficos, denominado de onda senoidal
compuesta.
Dos temporizadores programables incorporados.
Dos puertos de E/S de propsito general.
Adems de los sonidos FM pueden producirse tres seales cuadradas y un
ruido seudo-blanco.
Niveles compatibles con TTL
Tecnologa MOS; LSI.
Alimentacin entre 0V y +5V.
Compatible con programas para YM2149; AY-3-8910 y el 8912 producido por
GI. 18
El YM-2203 se controla en base a los datos escritos en sus registros. As el

microprocesador est despreocupado del sonido salvo, por enviar las rdenes a los
registros.
El generador de sonido FM determina el sonido por la modulacin de ondas senoidales.
Se permiten los sistemas de simple FM, mltiple FM y FM realimentada. En cuanto al
generador de onda cuadrada es compatible con el YM2149, el AY-3-8910 y el 8912
(conocido como PSG GI) en cuanto a programacin.
Cada bloque del YM-2203 funciona como sigue:
18
Generador de envolvente (EG)

Determina el ndice de modulacin de la envolvente y de la onda de modulacin de
la fuente FM.
Generador de fase (PG)
Determina la fase de la onda senoidal en cada paso temporal del generador de
msica FM.
Operador (OP)
Calcula el valor E*sen(theta) sobre la base de la amplitud del generador de
envolvente y la fase proveniente del generador de fase.
Acumulador (ACC)
Suma la salida del operador de cada canal para mezclar el sonido FM y atacar el
convertidor D/A
Generador de onda cuadrada y de ruido.
Genera tres ondas cuadradas diferentes y ruido seudo-blanco. Puede mezclar el
Yamaha tambin tena su propio 8912
30

Jos Tejada Gmez
ruido y las ondas cuadradas. En cuanto al volumen puede ser fijo o determinado
por diez envolventes distintas. Existe un convertidor D/A por cada sonido.
Puerto de control de Entrada / salida
Son de nuevo dos puertos de propsito general de Entrada / salida
Temporizador
Se proveen dos tipos de temporizadores.
Modelo de programacin
Comparte el mismo modelo que el YM-2149; y aade un nuevo conjunto de registros.

grosso modo el mapa de registros es el siguiente:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
$00 ~
Frecuencia de las ondas senoidales.
$05
$06 Frecuencia de la fuente de ruido.
$07 Control de los puertos de E/S.
$08 ~
Volumen. Puede ser fijo (por CPU) o variable (por el generador de envolvente)
$0A
$0B ~
Controla el ciclo de envolvente en el sistema de volumen variable
$0C
$0D Especifica la forma de la envolvente.
$0E ~
Dos puertos de 8-dgitos de propsito general
$0F
$21 Informacin de prueba, siempre vale 0
$24 ~
Tiempo de disparo de los temporizadores A y B
$26
$27 Controla la operacin de los temporizadores.
$2D
Especifica por cuanto se divide la seal de reloj de entrada.
~ $2F
$30 ~
Controla la relacin entre el tono principal y el primer armnico.
$3E
$40 ~
Controla el nivel total. Es el ndice de modulacin para la envolvente.
$4E
$50 ~
Controles de clave y escala. Control del tiempo de ataque de la envolvente.
$5E
$60 ~
Tiempo de cada de la envolvente.
$6E
$70 ~
Tasa de mantenimiento de la envolvente.
$7E
$80 ~
Nivel de mantenimiento de la envolvente.
$8E
$90 ~
Generacin del patrn de la envolvente.
$9E
$A0
Nmero de frecuencia de cada canal
~
$A6
31

Jos Tejada Gmez
$A8
Nmero de frecuencia de los canales en el modo especial (CSW)
(20) ~
$AE
$B0 ~
(21)
Sistema de conexin de los operadores
$B2
Se han aadido nuevos registros para controlar las operaciones de FM pero adems
ahora hay dos temporizadores que ayudarn al procesador a controlar ms
adecuadamente el sonido que ha de orquestar.
El YM-2151, sintetizador FM de varios operadores.

El YM-2151 representa uno de los sintetizadores profesionales ms extendidos. Ahora
el integrado ya est plenamente dedicado a sonido FM y existen ms operadores as
como nuevas posibilidades (estreo, seales primitivas asenoidales)
Con el terminamos este breve paseo por los sintetizadores FM y para culminarlo
ofreceremos un circuito donde se muestra la forma de conectar este integrado.
Caractersticas
Genera hasta ocho notas simultneamente

Produce ruido
El timbre puede ser cambiado temporalmente.
El armnico superior puede ser extrado de la frecuencia base.
Desarmonizacin entre octavas.
Configuracin de intervalos de hasta 1.6 centsimas de segundo.
Aade vibrato y modulacin de amplitud.
Genera una amplia variedad de efectos a travs de la desarmonizacin del
armnico superior de la frecuencia base, vibrato masivo y modulacin de
amplitud.
El mapa de registros ocupa 256 octetos; y sirve para configurar los circuitos que
producen el sonido. Vamos a ver qu significan algunos de estos registros.
B: WRITE BUSY FLAG (Slo lectura). Por primera vez aparece un elemento de
sincronizacin. Cuando sea necesario escribir continuamente en el integrado hay que
consultar este dgito y comprobar que sea cero antes de continuar.
KON: KEY ON Activa la salida de un canal.
Generador de fase: Utiliza la combinacin de los siguientes valores:
KC: KEY CODE( Octava, nota) Se guarda la nota en 7-dgitos, tres para la octava y
cuatro para la nota.
KF: KEY FRACTION Compuesto por 6-dgitos permite separar la informacin de fase
dividiendo el intervalo de nota
MUL: PHASE MULTIPLY Sirve como factor que multiplica a KC y KF
DT1 (DETUNE 1) Se utiliza para desemparejar la informacin de fase con la de
frecuencia.
DT2 (DETUNE 2) Idntico al interior. Cuando se desincroniza fase y frecuencia se
producen efectos sonoros tiles.
32

Jos Tejada Gmez
PMS: PHASE MODULATION SENSITIVITY Sirve para obtener sonido vibrantes y
temblantes.
Operador FM: Lee la informacin de fase del generador de fase y recorre la tabla
senoidal. La seal leda se multiplica por la informacin de envolvente.
CON (CONNECTION) Define cmo se conectan los operadores
FL: SELF FEEDBACK LEVEL La salida del operador puede realimentarle as s mismo.
Este parmetro indica en qu grado lo hace.
Generador de envolvente Su comportamiento se define por los cuatro segmentos que
componen la envolvente. La forma de la envolvente comienza a producirse cuando se
da el valor KEY ON
Tasa de ataque
Tasa de primera cada
Tasa de segunda cada
Tasa de liberacin (o desaparicin)
TL: TOTAL LEVEL Representa el volumen mximo para la nota.
AMS: AMPLITUDE MODULATION SENSITIVITY Define si la nota se ve modulada
en amplitud, y en qu medida.
Generador de ruido: El ruido tambin est controlado por el generador de envolvente,
slo que aqu el ataque ya no es logartmico, sino exponencial.
NE: NOISE ENABLE Caso de activarse sonar el ruido
NFRQ: NOISE FREQUENCY La relacin entre NFRQ y la frecuencia de ruido es
f noise (kHz ) =
M (kHz )
donde M = 3579.545kHz Y puede variar entre 3.5 kHz hasta
32 * NFRQ
111.9 kHz
LFO: Low Frequency OSC Provee de sonido a la modulacin de frecuencia y de
amplitud.
LFRQ: LOW FREQUENCY Se fija la frecuencia de oscilacin con 8-dgitos
W: WAVE FORM Se elige entre ocho formas de onda, variantes de seales en rampa,
triangulares, cuadradas y ruido.
PMD/MAD: PHASE MODULATION DEPTH/AMPLITUDE MODULATION DEPTH:
Representa los ndices de modulacin.
Temporizadores El circuito dispone de dos temporizadores programables, uno de 10dgitos y otro de 8-dgitos. Provocan una interrupcin cuando su cuenta ha terminado.
33

Jos Tejada Gmez
Circuito de ejemplo
En la figura siguiente se muestra cmo se conecta el YM-2151 al convertidor D/A
compaero YM-3012. A este se le conectan seguidamente cuatro operacionales que
proporcionan tensiones de referencia o hacen de seguidores de tensin para la salida
de los canales de audio.
Circuito recomendado del YM2151
34

Jos Tejada Gmez
La arquitectura del sistema

Vamos a explicar en esta seccin la arquitectura electrnica bsica de una mquina
recreativa con varios diagramas de bloques para luego analizar con los esquemas
reales el diseo electrnico de los juegos Ms Pacman y Gryzor.
Bloques fundamentales
Una mquina de videojuegos se compone bsicamente de un sistema de proceso, un
sistema de vdeo y un sistema de entrada de datos:
Bloques fundamentales
el sistema de entrada tiene dos labores:
comienzo de la partida: monedero y botn de comienzo

juego: palanca y botones
el sistema de proceso realiza las funciones de:
presentacin del videojuego hasta que comienza una partida

anlisis de la entrada del usuario
desarrollo del juego
ordenar cmo se ha de dibujar la pantalla
y el sistema de vdeo:
dibujo de la pantalla en una memoria RAM

uso de esa memoria para dibujar la imagen en un monitor de rayos catdicos
35

Jos Tejada Gmez
Si reducimos un nivel la abstraccin; la entrada es un conjunto de interruptores, el
sistema de proceso se descompone en UCP ms memorias y el sistema de vdeo en dos
secciones:
diagrama bsico de una placa de videojuegos
36

Jos Tejada Gmez
El diagrama superior representa lo que ocurre bsicamente en el sistema, pero aun es
demasiado abstracto. Las mquinas tambin tienen sonido y ste se produce por un
circuito especializado que se conecta tambin al procesador y cuya salida ha de ser
convertida a seal analgica y amplificada. El siguiente diagrama representa esta
situacin.
diagrama bsico de una placa de videojuegos con sonido
37

Jos Tejada Gmez
Sin embargo esta situacin dej pronto de darse, los juegos eran cada vez ms
complicados y requeran ms potencia de clculo, por lo que la funcin de dirigir la
orquesta pas a ser desempeada por un segundo procesador que reciba rdenes a
travs de un registro, de un octeto de longitud.
diagrama bsico de una placa de videojuegos con sonido y dos procesadores
38

Jos Tejada Gmez
Esquema elctrico de Gryzor

Para seguir profundizando en el conocimiento de los sistemas de mquinas recreativas
vamos a analizar el esquema de Gryzor repasando los bloques fundamentales y
estudiando la conexin entre ellos.
En todas las imgenes, las lneas remarcadas en verde indican el bus de datos y las
anaranjadas el de direcciones. Todos los integrados que comiencen por 00 (doble cero)
son circuitos propios de Konami.
Las palancas de juego y las monedas
Conexin de las entradas
Todas las seales procedentes del usuario: movimientos de palanca, pulsaciones de

botones e insercin de monedas siguen el mismo esquema que el mostrado en la figura.
En ella podemos ver las siguientes seales, de arriba abajo: arriba del 1er jugador, del 2
jugador, 2 moneda, derecha del 1er jugador, del 2, 1 moneda, izquierda del 1er jugador y del 2.
Todas ellas pasan por un integrado de Konami numerado 005273 y que no es ms que
un eliminador de rebotes. A continuacin se introducen en un LS253, que como se lee
en la figura es un multiplexor dual de palabras de cuatro dgitos con salida triestado.
Las entradas B y A provienen de las patillas A1 y A0 del bus de direcciones del 6809 y la
s entradas de habilitacin 1G y 2G se atacan con la seal I0EN (Input Enable,
habilitacin de las entradas)
39

Jos Tejada Gmez
Los microinterruptores DIP
conexin de los microinterruptores

Los microinterruptores se conectan a travs de bferes triestado controlados por el bus
de direcciones, se utilizan las tpicas resistencias a nivel alto para limitar la corriente
que circula cuando los interruptores se cierran. El procesador accede a estos
interruptores como si se tratase de un registro de slo lectura. Ntese adems que no es
necesaria la presencia de antirrebotes puesto que estos interruptores se modifican slo
durante la puesta a punto del equipo.
Los cuentamonedas
b
cuentamonedas
Los cuentamonedas son los que llevan la caja, es decir, la contabilidad del juego. Cada
vez que la mquina acepta una moneda ha de enviar una seal a estos para que
contabilicen la partida. La forma de hacerlo en Gryzor es a travs de un registro LS174
que sigue los cambios de las seales provenientes del monedero y de un circuito
propio, el 005924 que ataca a los cuentamonedas (externos a la placa)
40

Jos Tejada Gmez
El oscilador
Oscilador a 24MHz
El oscilador usado en Gryzor es un cristal a 24MHz que sufre varias divisiones de

frecuencia para servir a cada circuito.
El procesador principal
Conexin del procesador principal y las memorias
El procesador responsable del juego, un 6809E, va conectado a dos memorias ROM de

64koct cada una y a una RAM de 8koct. Los buses del sistema van conectados adems
de a las entradas, a los circuitos grficos y al registro de sonido (que comunica a este
procesador con el responsable del sonido)
41

Jos Tejada Gmez
Los circuitos grficos
Parte superior del primer circuito grfico
En Gryzor hay dos circuitos grficos 007121, que posibilitan la existencia de dos fondos
simultneos en la imagen. Slo hemos mostrado una parte de estos en la figura puesto
que se trata de integrados inmensos con ms de 200 conexiones. En la placa ocupan un
tamao notable por lo que seguramente, debajo del encapsulado cermico se
encuentren no uno sino varios circuitos integrados.
Hemos querido destacar en la imagen el hecho de que estos circuitos se conectaban a
memorias ROM (donde estaban los dibujos) y a memorias RAM (donde se pintaba la
pantalla)
generador de color
Los circuitos grficos desembocaban al final en un convertidor digital analgico que,

visto en la placa, era una especie de plano con conexiones slo por un lado. En su
interior podan palparse componentes y su aspecto era como el de una serpiente debajo
de cuya piel pudieran verse sus vctimas. Todo esto parece indicar que se trataba de un
conversor resistivo realizado con componentes discretos. Esta pieza era muy sensible.
42

Jos Tejada Gmez
Procesador de audio
procesador de audio
El segundo 6809E era responsable del sonido del equipo. La comunicacin se realizaba
a travs de un registro donde el procesador principal escriba y ste lea tras responder
a la interrupcin que le haca llegar el principal (ver el registro 13D en la figura).
Podemos ver tambin que este procesador tena un oscilador separado a 3,58MHz y
contaba slo con una memoria RAM de 1koct y una memoria ROM de 32koct. Las
lneas de este subsistema siguen hasta la circuitera de msica FM.
43

Jos Tejada Gmez
Circuito de sonido
Esquema de los circuitos generadores de sonido y de la etapa analgica
Un YM-2151 es utilizado para generar la msica y un YM-3012 es el convertidor digital

analgico usado. El circuito es bastante similar al recomendado por Yamaha, salvo por
la inclusin de un filtrado (activo) de paso bajo adicional. El circuito LA4445 es un
amplificador de potencia que en la placa requera de un disipador.
44

Jos Tejada Gmez
Mecanismos de proteccin contra copias

Pese a que una placa de circuito impreso no es tan fcilmente copiable como un
programa de ordenador, en la prctica el precio de los equipos originales provocaba
muchas veces la piratera de los grandes xitos.
El gran problema de las mquinas piratas era replicar la circuitera de diseo del
equipo original, es decir los integrados a medida para el videojuego. Mediante un
proceso de ingeniera inversa -similar al desarrollado para la programacin de los
emuladores presentados- se desentraaba el funcionamiento de la circuitera de diseo
y se sustitua por lgica discreta. Las placas piratas eran, por tanto, mucho mayores
que las originales; estaban formadas en general por dos placas, una para el procesador
principal, el de sonido y las memorias de programa y otra exclusiva para vdeo puesto
que el vdeo era normalmente el nico componente a medida de la placa.
portada de Double Dragon
partida de Double Dragon
Hubo casos escandalosos como el de Double Dragon19, en Valencia era prcticamente

imposible encontrar una placa original de este juego. La pirata no slo era la ms
popular sino que adems, debido a fallos en el diseo, se colgaba con mucha facilidad
algo raro en este tipo de equipos. El caso de Double Dragon es tambin paradigmtico
por su dificultad de pirateo. Un microcontrolador 63701 era el encargado de gestionar
los objetos del juego y tena la peculiaridad de tener el cdigo encriptado. No era
posible leer el contenido de la memoria de programa interna- de este
microcontrolador, por lo que la mquina se supona incopiable. El xito de este juego
acrecent la voluntad de copiarlo y finalmente se descifr no el cdigo del programa en
s, sino lo que el procesador principal esperaba de l. Habiendo deducido las
especificaciones se sustituy el componente en el juego pirata por un 6809 y as qued
la placa con tres procesadores 6809 en lugar de los dos originales.
La facilidad en copiar un juego de mquina recreativa estribaba en que el cdigo de los
procesadores, los grficos y el sonido; es decir, el alma del juego; resida en memorias
ROM fcilmente lebles por cualquiera. La dificultad estribaba en los componentes de
diseo, no disponibles en las tiendas, que contena la placa. La situacin era, como ya
se ha dicho, pareja a la programacin de un emulador: se tenan los datos, de ellos se
19
1987 Tecmos
45

Jos Tejada Gmez
deducan las frmulas y los artificios que realizasen esas frmulas con esos datos se
diseaban desde cero con lgica discreta (en un emulador, se programan); los piratas
disponan, sin embargo, de una ventaja frente a los programadores de emuladores:
tenan una placa original y los recursos para probarla e investigarla a fondo, de esa
forma podan reemplazar el cdigo del procesador principal en la placa autntica y
utilizarlo para desentraar el funcionamiento de los circuitos de diseo con ms
facilidad que tan slo mirando el cdigo, como hace un programador de emuladores.
Los intentos de codificar las memorias ROM tampoco fueron siempre exitosos. Se
basaban en aplicar alguna operacin lgica reversible bien a los datos, bien al cdigo
del programa. Esta operacin se deshaca en un circuito de diseo; sin embargo la
disponibilidad de la placa original y todos sus circuitos por parte de los piratas hacan
que se pudiera investigar la encriptacin y deshacerla.
portada de Haunted Castle
partida de Haunted Castle
Dado que el tener componentes de diseo y microcontroladores encriptados no bast

para parar la piratera, la empresa japonesa Konami dio un paso ms all y en 1988
comenz a introducir juegos donde el procesador principal era un componente de
diseo: bajo un encapsulado cermico negro y sujeto por ms de cuarenta patillas se
esconda una UCP propia, de la que nadie conoca el juego de instrucciones. Las
tcnicas tradicionales de pirateo ya no podan aplicarse, porque si bien puede
reemplazarse un circuito grfico con lgica discreta, no puede realizarse un procesador
con los mismos medios, mxime cuando ni se sabe cmo es el procesador por tratarse
de un modelo privado sin venta al pblico. Este procesador se us en juegos como
Super Contra, Haunted Castle, Chequered Flag y Typhoon; todos ellos de Konami,
desarrolladora del procesador privado.
El tiempo todo lo cura, as recientemente el procesador privado de Konami fue
desentraado por Manuel Abada y los juegos que lo utilizaban incorporados al
multiemulador MAME. El procesador de Konami result ser un 6809 modificado: se
haban cambiado los cdigos de las instrucciones y se haban aadido algunos nuevos
registros y operaciones. La forma en que Abada descubri el funcionamiento del
procesador de Konami se bas en la observacin del cdigo mquina buscando una
lgica en l: unas ciertas operaciones al inicio de la mquina, cdigos de operacin
muy repetidos. Se esperaba que el procesador fuera en el fondo un 6809 as que eso
ayud, el esquema electrnico siguiente contiene la gua de descodificacin de
instrucciones del procesador de Konami.
46

Jos Tejada Gmez
codificacin del procesador de Konami.

Las lneas P, representan al procesador; las A,
el bus de memoria y las D el bus de datos
He aqu un extracto del cdigo fuente del multiemulador MAME20, que codifica el
circuito mostrado:
unsigned char decodebyte( unsigned char opcode, unsigned
address )
{
/*
> CPU_D7 = (EPROM_D7 & ~ADDRESS_1) | (~EPROM_D7 & ADDRESS_1) >
> CPU_D6 = EPROM_D6
> CPU_D5 = (EPROM_D5 & ADDRESS_1) | (~EPROM_D5 & ~ADDRESS_1) >
> CPU_D4 = EPROM_D4
> CPU_D3 = (EPROM_D3 & ~ADDRESS_3) | (~EPROM_D3 & ADDRESS_3) >
> CPU_D2 = EPROM_D2
> CPU_D1 = (EPROM_D1 & ADDRESS_3) | (~EPROM_D1 & ~ADDRESS_3) >
> CPU_D0 = EPROM_D0 */
unsigned char xormask;
short
xormask = 0;
if (address & 0x02) xormask |= 0x80;
else xormask |= 0x20;
if (address & 0x08) xormask |= 0x08;
else xormask |= 0x02;
return opcode ^ xormask;
}
20 El proyecto MAME es un intento de emular con un nico programa todas las mquinas
diseadas. El autor colabor con informacin tcnica sobre Combat School y Gryzor. Videre
www.mame.net
47

Jos Tejada Gmez
La compaa espaola Gaelco utilizaba tambin microcontroladores para proteger sus
juegos. El dispositivo que usaron fue el Dallas DS500, que no permita el acceso al
cdigo una vez grabado. Gaelco recubra toda la porcin de la placa alrededor del
Dallas con una carcasa negra, a modo de integrado de diseo, y amenazaba con anular
la garanta si sta se quitaba.
Microcontrolador empleado por Gaelco
En los aos 90 la piratera comenz a dejar de ser rentable y fue decayendo como poco
despus caera toda la industria del videojuego de saln. El uso de circuitos grficos
ms complicados, que ya no podan realizarse con lgica discreta, el tamao creciente
de las memorias ROM que dificultaba su compra a pequea escala y la prdida de
mercado en pro de las consolas domsticas fue haciendo desaparecer la industria pirata
que goz a mediados de los aos 80 de su cenit.
48

Jos Tejada Gmez
2 Parte
Tras haber descrito la construccin de los sistemas de mquinas recreativas en la
primera parte; en esta segunda vamos a explicar cmo se realiza la emulacin de estos
equipos, teniendo en mente la plataforma PC como emuladora.
Modelo de un emulador
Vamos a presentar en esta seccin modelos UML que describen el funcionamiento de
un emulador, estos diagramas ilustran con sencillez el funcionamiento de los
programas desarrollados.
Diagrama principal
Las dos funciones bsicas que ejecuta un emulador consisten en la preparacin del
entorno y en la ejecucin en un bucle continuo- de la emulacin.
diagrama principal de un emulador
Arranque: incluye el anlisis de la lnea de comandos, la reserva de memoria, la

carga de los ficheros ROM en ella y el arranque del procesador virtual
Bucle de emulacin: ejecuta un lapso de instrucciones del juego emulado,
interpreta la memoria grfica para pintar la pantalla y actualiza los puertos de
entrada virtuales para reflejar las pulsaciones de teclado del jugador.
49

Jos Tejada Gmez
El arranque
Las operaciones de arranque preparan el programa para ejecutar la emulacin y
configuran algunos aspectos de la misma
procedimientos de arranque
21
Anlisis de la lnea de comandos: el usuario puede escribir opciones cuando

ejecuta el emulador para modificar aspectos como el directorio donde estn los
ficheros ROM, la resolucin de pantalla a utilizar, activar o desactivar el
sincronismo con la seal de barrido vertical del monitor21
Carga de las memorias ROM: el emulador en s no contiene el juego en
absoluto, no es ms que en conjunto de rutinas que simulan el comportamiento
de un circuito controlado por un programa. Ese programa estaba contenido en
memorias ROM cuyo volcado en ficheros binarios se carga al comienzo de la
emulacin
Descodificacin de los grficos: las imgenes almacenadas en las memorias
ROM estn en un formato apto para la circuitera grfica original pero que no
resulta prctica para los circuitos de un ordenador moderno; por lo tanto hay
que reordenar los dgitos y los puntos de forma que resulten manejables por el
ordenador.
Preparacin del procesador virtual: para que ste sea capaz de ejecutar el juego
hay que colocar las memorias ROM tal y como estaban en el original y hay que
iniciar los registros internos con los valores adecuados (posicin del vector de
arranque, de la pila...)
Sobre este sincronismo se hablar ms adelante en el apartado de Sincrona
50

Jos Tejada Gmez
Bucle de la emulacin
Tras el arranque del sistema, el programa entra en bucle sin fin como sigue:
diagrama del bucle de la emulacin
Ejecucin de N instrucciones: el procesador virtual recibe la orden de emular

N instrucciones, siendo N el nmero de operaciones ejecutables en el lapso que
hay entre dos refrescos de pantalla. Si el monitor de la mquina funcionaba a
60Hz, ese lapso ser de 16,7ms virtuales. Naturalmente ese tiempo virtual
necesita ser simulado en muchos menos milisegundos para dar tiempo al
ordenador a realizar otras funciones.
Dibujado de la pantalla: despus del lapso anterior el procesador virtual ha
debido de dejar rdenes en los registros de la circuitera grfica (mapeados en
memoria) para pintar la pantalla. Estas rdenes se interpretan en este paso para
dibujar en el ordenador el fotograma del juego.
Lectura del teclado: se comprueba el estado de las palancas de juego y de las
teclas para informar al procesador virtual a travs de sus puertos de entrada
(mapeados en memoria)
Interrupcin del sincronismo: Cada vez que se produca un refresco vertical en
la mquina, se disparaba una interrupcin; de esta forma el procesador tena
conciencia del tiempo transcurrido y utilizaba la interrupcin como
sincronizacin. El monitor slo refleja los cambios en la imagen cada vez que el
haz recorre el tubo as que el tiempo de retraza vertical es en el que se puede
modificar la imagen con seguridad de no provocar particiones (media pantalla
del fotograma anterior y la otra media del nuevo)
51

Jos Tejada Gmez
De este bucle slo se puede salir por imperativo del usuario, habitualmente a travs de
la tecla de escape, en caso contrario el bucle es infinito, como lo sera en una mquina
real.
El bucle de la mquina real

Existe un gran paralelismo entre el bucle de emulacin y el bucle de juego que ejecuta
el procesador virtual internamente. Podemos entender el videojuego como una
mquina de estados en la que las pulsaciones del usuario la hacen conmutar de uno a
otro estado. Cuando se encuentra en medio de una partida, de una fase determinada, la
mquina ejecuta constantemente este bucle:
bucle principal del juego (procesador virtual)
Como vemos las acciones son esencialmente las mismas: lectura de las entradas,
ejecucin de unas instrucciones (en este caso para mover al jugador, a los enemigos, el
fondo, etc.), esperar la interrupcin que dar va libre a la pantalla sin que el usuario
note que se est modificando la imagen y el pintado en s.
El contenido de la casilla Desarrollo de la accin es lo que realmente cambia de una fase
del juego a otra o del estado de atraccin de jugadores (el famoso introduzca una
moneda) al estado de juego; las otras acciones son las mismas siempre.
52

Jos Tejada Gmez
Ingeniera inversa: investigacin del equipo

Cuando se va a realizar el emulador de una mquina se dispone nicamente de un
conjunto de ficheros binarios obtenidos a partir de las memorias EPROM y ROM de la
placa original. Si uno ha realizado el volcado por s mismo tendr al menos una idea a
partir de la posicin que ocupaban las memorias de su utilidad, pero lo normal es que
el volcado provenga de una persona desconocida o que haya sido descargado de
alguna pgina de intern.
El punto de partida es, por lo tanto, un juego de ficheros de contenido desconocido y
un amasijo de recuerdos sobre como era el original. Con un poco de suerte, ser posible
conseguir por intern fotografas de la mquina que nos orienten mnimamente en
cuanto a la paleta grfica.
En este captulo vamos a estudiar el caso de Gryzor, cmo se realiz el anlisis de los
ficheros y de su contenido hasta extraer suficiente informacin como para realizar el
emulador. Posteriormente se comentar el desarrollo de un programa llamado
Analizador y que sirvi para investigar Combat School. Sobre Ghosts & Goblins no
diremos nada puesto que la informacin tcnica de esta mquina fue suministrada por
Paul Leaman y Roberto Ventura; quienes desarrollaron emuladores por su cuenta para
este juego.
Investigacin de Gryzor
Nada ms recibir el volcado de la ROM procedente de Lewin Edwards (Australia) lo
nico que se poda ver era:
Directorio de C:\pfc\gryzor\Rom
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
20/09/1997
18:33
32.768 G-1.ROM
18:48
65.536 G-10.ROM
18:49
65.536 G-11.ROM
18:50
65.536 G-12.ROM
18:51
65.536 G-13.ROM
18:51
65.536 G-14.ROM
18:52
65.536 G-15.ROM
18:53
65.536 G-16.ROM
18:54
65.536 G-17.ROM
18:55
65.536 G-18.ROM
18:35
65.536 G-2.ROM
18:37
65.536 G-3.ROM
18:39
65.536 G-4.ROM
18:43
65.536 G-5.ROM
18:44
65.536 G-6.ROM
18:46
65.536 G-7.ROM
18:47
65.536 G-8.ROM
18:47
65.536 G-9.ROM
18 archivos
1.146.880 bytes
0 dirs
1.827.024.896 bytes libres
Un total de 18 archivos y algo ms de 1Moct, comparado con los escasos 300 koct de
G&G el juego prometa! Afortunadamente algo se saba de la placa: llevaba dos
53

Jos Tejada Gmez
procesadores 6809. As que entre esos ficheros deba haber algunos que, pasados por
un desensamblador, tuviesen sentido. Por intern circulan varios desensambladores de
este procesador, el escogido fue el d6809.
Fichero g-1.rom
Al ejecutar d6809 g-1.rom > g-1.s y leer la salida vemos:
ORG $0000
0000: F7 60
0003: F6 20
0006: C4 80
0008: 26 F9
000A: B7 20
000D: F6 20
22
01
STB
$6022
LDB
$2001
ANDB #$80
BNE
$0003
00
STA
$2000
01
LDB
$2001
0010: C4 80
0012: 26 F9
0014: F6 60 22
0017: F7 20 01
001A: 39
001B:
001E:
0020:
0023:
0025:
0028:
CC
8D
CC
8D
CC
20
14 39
E0
12 F9
DB
14 3B
D6
ANDB
BNE
LDB
STB
RTS
#$80
$000D
$6022
$2001
LDD
BSR
LDD
BSR
LDD
BRA
#$1439
$0000
#$12F9
$0000
#$143B
$0000
etc.
La secuencia de instrucciones tiene sentido: primero salva el valor en B, entonces carga

el valor en 2001h22 le aplica una operacin y segn el resultado salta a una posicin u
otra. Tras unas cuantas lneas se termina con un retorno desde subrutina (RTS). Todo
tiene sentido.
Si abrimos el fichero G-1.ROM con un editor hexadecimal veremos que los dos ltimos
octetos son 802A. Eso, en un 6809, indica la posicin de arranque del cdigo. Sin
embargo el fichero no tiene una longitud tan grande (slo ocupa 8000h octetos) as que
la lgica implica que esta memoria ocupaba los 32koct superiores de un procesador
6809, de esa forma la posicin 802A sera la 002A del fichero. Desensamblando a partir
de ah:
002A:
002E:
002F:
0031:
0035:
0037:
003B:
003D:
003F:
0041:
0044:
10
4F
A7
10
26
10
86
1F
1C
BD
86
8E 60 00 LDY
CLRA
A0
STA
8C 67 FF CMPY
F8
BNE
CE 68 00 LDS
60
LDA
8B
TFR
EF
ANDCC
82 B5
JSR
07
LDA
#$6000
,Y+
#$67FF
$002F
#$6800
#$60
A,DP
#$EF
$82B5
#$07
Es importante tomar nota de posiciones explcitas de memoria pues indican puertos de E/S
(dispositivos mapeados en memoria)
22
54

Jos Tejada Gmez
0046:
0049:
004B:
004E:
0050:
0053:
0055:
0058:
0059:
etc.
B7
86
B7
8D
CC
8D
F6
5C
C1
60
08
60
CB
08
AB
60
31
34
00
22
08
STA
LDA
STA
BSR
LDD
BSR
LDB
INCB
CMPB
$6031
#$08
$6034
$001B
#$0800
$0000
$6022
#$08
Para que este cdigo sea coherente ha de cumplir que no presuponga nada, puesto que
suponemos que es el de arranque del procesador. Si seguimos las instrucciones vemos
que efectivamente el cdigo comienza a construir el proceso sin suponer ningn valor
conocido en registros ni en memoria. As que aceptamos la hiptesis: este fichero
corresponde a un 6809 y ocupa los 32koct superiores de la memoria.
Siguiendo con el desensamblado llegamos a puntos tales como:
0698:
069B:
069D:
069F:
06A1:
06A3:
06A5:
06A7:
06A8:
06AA:
06AB:
06AD:
06AE:
06B0:
06B1:
06B3:
06B6:
06B9:
etc.
FE
0F
1F
00
00
1F
00
01
90
12
00
01
90
12
00
CE
BD
CC
00 00
0A
00
F8
8C
16
F8
1F
F8
1F
F8
86 98
83 FC
07 50
LDU
$0000
CLR
$0A
TFR
D,D
NEG
$F8
NEG
$8C
TFR
X,inv
NEG
$F8
Illegal Opcode
SUBA $1F
NOP
NEG
$F8
Illegal Opcode
SUBA $1F
NOP
NEG
$F8
LDU
#$8698
JSR
$83FC
LDD
#$0750
Estos tramos de desensamblado con cdigos de operacin ilegales corresponden a

datos y no a programa por eso su desensamblado no tiene sentido. Un vistazo al resto
de este fichero muestra algo imprevisto: esta casi vaco. No parece, por tanto, probable
que sea el programa principal pero por otra parte contiene cdigo de arranque. La
conclusin es que este fichero pertenece al procesador de sonido.
55

Jos Tejada Gmez
Fichero G-2.rom
Al comenzar a desensamblar este fichero lo primero que encontramos es desolador:
0000:
0002:
0004:
0006:
0008:
000A:
000C:
000E:
etc.
00
00
00
00
10
10
10
10
00
00
00
00
00
00
00
00
NEG
$00
NEG
$00
NEG
$00
NEG
$00
Illegal Opcode
Illegal Opcode
Illegal Opcode
Illegal Opcode
Sin embargo, si seguimos escudriando encontramos secciones como esta:

EF56:
EF58:
EF5A:
EF5C:
EF5E:
EF60:
EF62:
EF64:
EF66:
A6
84
E6
EA
C4
26
8A
A7
39
10
BF
13
03
01
02
40
10
LDA
ANDA
LDB
ORB
ANDB
BNE
ORA
STA
RTS
$FFF0,X
#$BF
$FFF3,X
$0003,X
#$01
$EF64
#$40
$FFF0,X
Esta rutina es completamente coherente e indica la existencia de cdigo en el fichero. Si

miramos los dos ltimos octetos en busca del vector de arranque- encontramos 8000h,
como este fichero tiene 64koct (10000h octetos) desensamblamos desde la posicin
8000h (32koct) para descubrir:
8000:
8001:
8004:
8006:
8009:
4F
B7
97
B7
7E
00 07
F0
70 00
61 11
CLRA
STA
STA
STA
JMP
$0007
$F0
$7000
$6111
Estas simples instrucciones entraan mucha informacin de valor: comienzan

borrando el registro A, lo cual es importante porque implica que el programa no espera
un valor de antemano cosa imposible en un arranque; a continuacin almacena ese
valor nulo en tres posiciones de memoria concretas -lo que indica su importancia- y
ms tarde salta a la posicin 6111h.
Esta posicin es importante porque es menor que 8000h que era la de arranque. Si
hacemos cuentas tenemos que
Esta memoria parece vlida para arrancar desde ella

Para ello los ltimos 32koct de este fichero han de ocupar la mitad superior de
la memoria del 6809, esto es as porque el vector de arranque est al final del
fichero y la posicin que ste indica est 32koct antes
En consecuencia quedan slo 32koct para el resto de elementos: RAM, pginas
de ROM, memoria de vdeo y otros puertos de E/S
56

Jos Tejada Gmez
A partir de estos datos, y de la experiencia acumulada con el Ghosts&Goblins, la
conclusin es que la memoria paginada ocupa probablemente desde 6000h hasta
7FFFh y adems el registro de paginacin est en una de estas posiciones: 0007h, 00F0h
o bien 7000h. Por qu desde 6000h? Porque el cdigo de arranque salta a la posicin
6111h, sera viable que las pginas empezaran en la posicin 6111h pero parece algo
caprichoso. La opcin ms sistemtica, ms ingenieril es 6000h. Por qu hasta 7FFFh?
Porque el cdigo de arranque empieza en la posicin 8000h. Y por qu esas tres
posibles direcciones para el registro de paginacin? Porque son las tres iniciadas antes
de saltar a la memoria paginada.
Existe todava otro argumento a rebatir: Por qu no aceptar que el cdigo en 6111h es
sencillamente el que precede en el fichero al que est en 8000h, es decir, sin paginacin,
el fichero tal cual? La respuesta es indiscutible: si desensamblamos la posicin 6111h
del fichero G-2.rom encontramos:
6111:
6114:
6116:
6118:
611A:
611B:
611D:
6120:
etc.
70
06
06
00
61
1C
70
06
06 80
70
60
01
06
06 80
90
NEG
$0680
ROR
$70
ROR
$60
NEG
$01
Illegal Opcode
ANDCC #$06
NEG
$0680
ROR
$90
cdigo absurdo y con instrucciones ilegales. Hemos obtenido adems otra informacin
adicional: el segmento 6000h-7FFFh de G-2.rom no corresponde a la pgina nmero
cero, sea cual sea el registro de paginacin. Cmo sabemos que no es la pgina cero?
Porque el proceso seleccion la pgina cero antes de saltar a 6111h, si este segmento no
contiene nada vlido en esa posicin es porque no es la respuesta.
Dnde esta el cdigo correspondiente a 6111h? Antes de responder esta pregunta,
echemos un vistazo al siguiente archivo.
57

Jos Tejada Gmez
Fichero G-3.rom
El comienzo del desensamblado de este fichero no podra ser ms halageo:
0000:
0002:
0005:
0007:
0009:
000B:
000E:
0011:
0014:
0016:
0018:
001B:
001D:
001F:
0021:
0023:
0025:
etc.
8D
CE
96
84
26
CE
BD
BD
86
97
CC
A7
E7
33
0A
26
39
24
30
F1
08
03
38
60
60
11
54
F0
42
44
45
54
F6
00
00
B5
AE
08
BSR
LDU
LDA
ANDA
BNE
LDU
JSR
JSR
LDA
STA
LDD
STA
STB
LEAU
DEC
BNE
RTS
$0026
#$3000
$F1
#$08
$000E
#$3800
$60B5
$60AE
#$11
$54
#$F008
$0002,U
$0004,U
$0005,U
$54
$001B
Una rutina completa y con sentido. Las sorpresas no acaban aqu, si cargamos el
fichero con un editor hexadecimal encontramos resultados como el mostrado en la
imagen inferior:
Vista de G-3.rom con un editor hexadecimal
Como vemos aparecen multitud de palabras legibles en ASCII, tales como: COIN1,
COIN2,DEMO SOUND, DIFFICULTY, FIRST AT, EASY,TEST, DIP, SERVICE, etc.
Sin lugar a dudas nos encontramos ante un nuevo fichero de cdigo de 6809, otros
64koct ms de programa. Antes de seguir investigando el funcionamiento del juego
veamos qu hay en los otros archivos.
58

Jos Tejada Gmez
Ficheros G-4, G-5, G-6...

El desensamblado de los restantes ficheros no arroja ninguna informacin congruente;
sin embargo, su volcado hexadecimal muestra patrones repetitivos lo que sugiere que
estos archivos contienen los grficos del juego. El desentraado de la codificacin
grfica es una labor costosa pero generalmente asequible tras varios intentos, no hay
un mtodo definido para realizarla pero si que debemos tener algunas ideas en mente:
Los grficos se almacenarn como mezcla de puntos, planos de color y bloques

Los elementos anteriores pueden combinarse bien en un solo fichero, bien en
varios de ellos
Cada tipo de grficos puede tener una cantidad de planos y rea de los bloques
distinta
Los grficos pueden estar almacenados girados 90, 180 o 270 grados
Obviamente, no se dispondr de los colores reales hasta que se avance en la
emulacin. Al contrario de los formatos modernos de imgenes, en las
mquinas recreativas no se inclua la paleta grfica junto a la imagen, sino que
sta estaba mezclada con el programa
Sobre la codificacin de estos ficheros consltese la seccin dedicada a las memorias

grficas de Gryzor ms adelante.
Anlisis del cdigo

Anteriormente habamos llegado a la conclusin de que el juego arrancaba con los
32koct superiores de G-2.rom y que entonces saltaba a una rutina sita en 6111h, pero
en qu fichero est esa rutina? Siguiendo con la hiptesis de que las pginas son de
8koct (2000h octetos) debemos buscar esa rutina en las posiciones x111h de los ficheros
G-2.rom y G-3.rom donde x es una cifra par (porque al mapear ese fichero en la
memoria comenzar a partir de 6000h, luego para que x111h se convierta en 6111h,
dadas pginas de longitud 2000h; x ha de ser par)
Comenzamos a buscar en G-2.rom. En la posicin 0111h encontramos cdigo en
principio vlido:
0111: B7 60 2C
0114: 39
STA
RTS
$602C
Almacena A, cuyo valor era cero, y vuelve... realmente no tiene sentido puesto que la
llamada a 6111h era en realidad un salto y no una invocacin a subrutina. Descartamos,
por tanto, el bloque 0000-1FFFh de G-2. rom como pgina cero. Veamos el siguiente:
2000h-3FFFh:
2111:
2113:
2115:
2117:
23
23
23
23
2A
2D
05
04
BLS
BLS
BLS
BLS
$213D
$2142
$211C
$211D
59

Jos Tejada Gmez
El desensamblado no tiene sentido, por qu hacer un salto condicional nada ms
comenzar la emulacin, en base a qu? Adems cerca de estas instrucciones hay
operaciones ilegales. Queda descartado 2000h-3FFFh, veamos 4000h-5FFFh:
4111: 33 33
LEAU
$FFF3,Y
No cabe discusin alguna sobre sta: utiliza el registro Y pero ste no haba sido
iniciado antes, no puede ser, por tanto, la que buscamos. Aun queda el bloque 6000h7FFFh:
6111:
6114:
6116:
6118:
611A:
70
06
06
00
61
06 80
70
60
01
NEG
$0680
ROR
$70
ROR
$60
NEG
$01
Illegal Opcode
Una vez ms hemos fracasado en la bsqueda. Vayamos ahora al siguiente fichero: g3.rom, comenzando desde el principio:
0111:
0113:
0115:
0118:
011B:
011D:
011F:
0120:
etc.
86
C6
8E
B7
30
26
5A
26
01
05
80 00
00 1E
1F
F9
F3
LDA
LDB
LDX
STA
LEAX
BNE
DECB
BNE
#$01
#$05
#$8000
$1E
$FFFF,X
$0118
$0115
El fragmento mostrado tiene doble lgica: no presupone valores en los registros como
corresponde al arranque- y es un bucle de espera. Qu mejor hacer al arrancar el
equipo que esperar a que el monitor se encienda completamente? En el interior del
doble bucle (resaltado en verde) vemos insistentes escrituras del valor 1 en la posicin
001E, lo que indica con pocas dudas- que esa es la posicin del registro de
autoarranque23.
Ya estamos tras la pista correcta, ahora queda seguir leyendo el cdigo fuente con ojos
crticos para ir averiguando ms y ms. Tras la espera, el programa sigue su labor
iniciando diversas posiciones de memoria con valores conocidos hasta que llega a24:
6182:
6183:
6186:
6189:
618C:
618E:
6190:
6192:
6195:
4F
CE
8E
B7
A7
30
26
CE
8E
10
10
00
C0
1F
F7
10
10
00
00
1E
00
00
CLRA
LDU
LDX
STA
STA
LEAX
BNE
LDU
LDX
#$1000
#$1000
AUTOARRANQUE
,U+
$FFFF,X
$6189
#$1000
#$1000
El registro de autoarranque se incrementaba automticamente por la circuitera externa al

procesador, en caso de llegar a cero provocaba el arranque del sistema. Serva para solucionar
cuelgues inesperados en la mquina.
24 En el cdigo siguiente se ha adaptado la numeracin a la posicin real en memoria: 0182h ha
pasado a ser 6182h, adems a la direccin 001E se le llama AUTOARRANQUE, en base al
razonamiento anterior.
23
60

Jos Tejada Gmez
6198: A1 C0
619A: 10 26 01 4F LBNE $62ED
619E: 30 1F
61A0: 26 F6
61A2: 8B 55
61A4: 81 54
61A6: 26 DB
CMPA
,U+
LEAX
BNE
ADDA
CMPA
BNE
$FFFF,X
$6198
#$55
#$54
$6183
Este fragmento es muy significativo: se realizan escrituras y verificaciones de lo escrito

con los siguientes valores: 00h, 55h, AAh, FFh. Dicho as no dice mucho, pero y en
binario?
Hexadecimal
00
55
AA
FF
Binario
00000000
01010101
10101010
11111111
La secuencia de valores cumple la condicin de haber hecho pasar a todos los dgitos
por 1 y por 0. Estamos, por tanto, ante un fragmento de cdigo que verifica el
funcionamiento correcto en cuanto a lectura y escritura de todos los dgitos desde
1000h hasta 1FFFh. Lo que se deduce de esto es que la regin 1000h-1FFFh es una
memoria RAM de 4koct. Esta informacin es fundamental a la hora de ir elaborando el
mapa de memoria de la mquina.
Si lo anterior era una verificacin de la RAM, qu ocurra si sta fallaba? Siguiendo la
rutina vemos que en caso de error se salta a 62ED, busquemos ese procedimiento:
62ED:
62F0:
62F3:
62F4:
62F6:
62FA:
62FE:
6300:
6303:
8E
CE
5F
A6
10
E7
A7
30
20
26 49
63 05
LDX
LDU
CLRB
C0
LDA
27 1D 06 LBEQ
89 FC 00 STB
84
STA
88 E0
LEAX
EF
BRA
#$2649
#$6305
,U+
$8000
$FC00,X
,X
-$20,X
$62F4
Este sucinto fragmento encierra muchsima informacin sobre la mquina si se lee

adecuadamente: se trata de un bucle que lee valores desde 6305 y los copia en 2649 y,
paralelamente, escribe ceros en 2249 (STB $FC00,X). Tras llegar a un nulo reinicia la
mquina saltando a 8000. Los valores en 6305 son: 01,03,14,10,10,12,11,14,00 (todos en
hexadecimal); a bote pronto esto no nos dice mucho, lamentablemente no son cdigos
ASCII; sin embargo a estas alturas disponamos de los bloques grficos en formato
visible y aunque no sepamos la correspondencia entre estos nmeros y los bloques
podemos echar un vistazo al orden en que aparecen en la ROM los bloques
alfanumricos para ver si le encontramos algn sentido:
61

Jos Tejada Gmez
Caracteres de Gryzor
Cada fila tiene 16 bloques, interpretando la secuencia anterior podemos leer: 13D BAD.
Es bien sabido que en las placas electrnicas se nombran los componentes siguiendo
una matriz de nmeros y letras para filas y columnas. Este escueto mensaje nos indica
que el integrado en la posicin 13D no funciona.
Aun hay ms informacin de valor en ese fragmento de cdigo. Para escribir el
mensaje en pantalla se han realizado escrituras en 2649 y 2249, adems las hechas en
2249 han sido siempre ceros. De aqu se colige la siguiente hiptesis: hay un circuito
grfico mapeado desde las posiciones 2000 hasta 27FF que se descompone en dos, uno
ocupa 2000-23FF y contiene los atributos de los bloques y otro ocupa 2400-27FF y
contiene el nmero de bloque. Un tamao de 400h octetos equivale a 322, es decir 32
filas por 32 columnas, rellenos con bloques de 8x8 puntos equivale a 256x256 puntos.
Hemos deducido la resolucin de la pantalla!
Aun no acaba aqu, esas nueve lneas de cdigo nos van a decir algo ms: el monitor
est girado. Ya sabamos que los grficos estaban girados 90 (vide codificacin grfica
de Gryzor) pero ahora vemos adems que el programa ha escrito el mensaje de abajo a
arriba: cada carcter est 20h bloques antes que el anterior, es decir 32 bloques, que
segn nuestra hiptesis equivale a una fila. La mquina esta imprimiendo cada
mensaje encima del siguiente, sin embargo han de verse en posicin horizontal en el
monitor: conclusin, el monitor est volcado 90. Esto es de capital importancia a la
hora de realizar las rutinas grficas.
Cabe preguntarse, por qu usar el monitor tumbado? Bien, Gryzor tena una pantalla
algo ms larga que ancha, pese a que de momento trabajamos con la hiptesis de
256x256 puntos eso slo atae a este circuito grfico; la resolucin total aun est por
hallar. Otra pregunta vlida sera Por qu suponemos que esta todo girado en la
placa: los grficos, la pantalla... no podra ser ese su funcionamiento normal? La
realidad es que la circuitera grfica de un videojuego sola utilizarse en otros, lo ms
sensato es pensar que estos circuitos se disearon para monitores horizontales y aqu
se usan con uno en vertical, a costa de complicar la programacin y de girar los
grficos.
Tras ese cdigo verificador se suceden ms secuencias del mismo estilo, comprobando
cada vez distintas reas; como la [C00,D00[ (correspondiente a la paleta grfica); la
[2000,4000[ (los circuitos grficos) y la [4000,6000[. Acto seguido el programa vuelve a
la posicin 800C, justo despus de la llamada a 6111 ya comentada.
62

Jos Tejada Gmez
800C:
800F:
8012:
8014:
8017:
8019:
801C:
801E:
8020:
8022:
8025:
8027:
8029:
802B:
802D:
8030:
8034:
8037:
8039:
803C:
803E:
8041:
8043:
8045:
8047:
804A:
804C:
804E:
8050:
8052:
CE
CC
DD
CC
DD
BD
0C
0A
26
10
27
96
8A
97
8E
10
BD
DD
CC
DD
BD
0C
0A
26
10
27
96
8A
97
4F
80
00
5C
00
5E
80
5E
5F
F7
A3
06
58
80
58
80
8E
80
5C
08
5E
80
5E
5F
F7
A3
06
59
80
59
E6
00
LDU
LDD
STD
08
LDD
STD
D3
JSR
INC
DEC
BNE
C1
CMPD
BEQ
LDA
ORA
STA
00
LDX
00 00 LDY
C5
JSR
STD
04
LDD
STD
D3
JSR
INC
DEC
BNE
C1
CMPD
BEQ
LDA
ORA
STA
CLRA
#$80E6
#$0000
$5C
#$0008
$5E
$80D3
$5E
$5F
$8019
,U++
$802D
$58
#$80
$58
#8000
#$0000
$80C5
$5C
#$0804
$5E
$80D3
$5E
$5F
$803E
,U++
$8052
$59
#$80
$59
Este bloque de cdigo es fundamental, ya que es una comprobacin de las memorias

ROM que permite identificar las pginas. El programa hace llamadas a una rutina sita
en 80D3 (que no mostramos) que suma todos los valores de la memoria y compara el
resultado con los precalculados y guardados en la posicin 80E6, de esta forma se
determina si alguna de las ROM est corrupta. Como la verificacin incluye las pginas
obtenemos ahora los datos definitivos: 12 pginas de 8koct ubicadas en el rea
[6000,8000[ Con un pequeo programa en C se puede obtener el valor correspondiente
a cada bloque de 8koct de las memorias G-2.ROM y G-3.ROM para compararlo con lo
predicho en 80E6 emparejando de esta forma el cdigo almacenado en el registro de
pgina con el bloque que ha de copiarse en [6000,8000[.
Siguiendo el cdigo pueden verse rutinas de impresin en pantalla en 65EB donde se
muestra el mensaje de RAM OK y de las que se puede extraer informacin adicional
sobre el funcionamiento del vdeo.
Cabe destacar que a estas alturas, con la paginacin ya conocida, puede arrancarse el
programa dentro del emulador sin que se cuelgue y de esta forma tener un banco de
ensayo mucho mejor. Utilizando el emulador aun en desarrollo y volcados de memoria
reales del proceso emulado se puede seguir desentraando el funcionamiento de la
mquina. Para esta labor se desarroll una herramienta especifica a utilizar con el juego
Combat School: el Analizador.
63

Jos Tejada Gmez
El Analizador de Combat School

Con el propsito de facilitar la investigacin de Combat School se desarroll un
programa para Windows utilizando las MFC 25 que permita un estudio cmodo y
evolutivo de la mquina. Cmodo porque la emulacin del procesador estaba
integrada en el programa y evolutivo porque aceptaba modificaciones segn se fuera
descubriendo cmo funcionaba el equipo.
Pantalla de inicio del Analizador
Las posibilidades del Analizador eran:
emular el procesador y la memoria

mostrar un volcado de la memoria y el desensamblado de las instrucciones
mostrar el contenido de los registros del 6809
dibujar las diferentes memorias grficas
reconfigurar las pginas de la mquina
disparar interrupciones y reiniciar el procesador
aadir comentarios al cdigo y guardarlo para ulterior referencia.
En muchos aspectos el Analizador se pareca a un depurador de cdigo mquina como

el usado en los laboratorios de SED26, aunque su objetivo era bien distinto.
De entre las posibilidades mostradas la reconfiguracin de las pginas era realmente
importante al principio del proyecto, cuando no se saba ni la posicin del registro de
paginacin ni la equivalencia entre unas posiciones y otras.
A continuacin se detalla el uso de este programa que fue de gran utilidad para
desarrollar el emulador Escuela de Combate; pese a que se invirti bastante tiempo en su
desarrollo, la ventaja de tener una plataforma de investigacin robusta y fiable aadi
rigor al proyecto y enriqueci el resultado final.
Microsoft Foundation Classes (Clases Bsicas de Microsoft). Las MFC son un conjunto de clases
de C++ que ofrecen una base para desarrollar aplicaciones ms rpidamente que con C puro.
26 Sistemas Electrnicos Digitales, antigua asignatura del tercer ao de Ingeniera de
Telecomunicaciones en la UPV
25
64

Jos Tejada Gmez
Uso
Cuando se ejecuta el Analizador, tras una pantalla de presentacin, se nos ofrece una
ventana tpica de una aplicacin MDI27. Los elementos se describen a continuacin:
Partes de la ventana de Analizador
1. La barra de ttulo: Se compone del nombre del programa (Analizador)

seguido del nombre del documento activo, en el ejemplo Arcade2
2. La barra de men: Permite acceder a todas las posibilidades del programa.
Adems de las opciones habituales hay dos mens (Procesador y Memoria)
que centran el uso de la aplicacin
3. La barra de herramientas: Es una va rpida a las acciones del men. Destacan
los botones de traza, ejecucin hasta el cursor y ejecucin hasta el PC que sern
explicados ms tarde
4. Los documentos: Las ventanas de documento contienen una mquina virtual
que emula a la recreativa, son independientes entre s y se puede tener tantas
como se quiera simultneamente. Posteriormente se explicar con detalle esta
ventana
5. El documento activo: La ventana seleccionada aparece con el ttulo remarcado
6. La barra de estado: Presenta informacin sobre las opciones de los mens y la
barra de herramientas
Multiple Document Interface (Interfaz de Mltiples Documentos -pluridocumento), este
acrnimo se refiere a las aplicaciones que albergan ms de un documento a la vez en contraste
con las SDI (Single Documente Interface, Interfaz monodocumento). Un ejemplo de aplicacin
monodocumento es Ms Paint y uno de pluridocumento Ms Excel.
27
65

Jos Tejada Gmez
El men Procesador
Las acciones disponibles son:
Reiniciar: ejecuta la rutina de arranque del procesador devolviendo la mquina

al estado inicial
Traza: emula una instruccin del 6809, actualiza la memoria y los registros y
devuelve el control al usuario
Ejecutar hasta PC: el usuario introduce a travs de un cuadro de dilogo la
direccin hasta la que se emular el procesador
Configurar pginas: a travs de un cuadro de dilogo el usuario establece la
relacin entre el nmero escrito en cierta posicin de memoria considerada el
registro de paginacin y la pgina que se conmuta en la memoria del 6809. Esta
opcin se elimin del programa cuando el funcionamiento de la paginacin
estuvo claro
Dilogo de configuracin de las pginas
Prxima imagen: ejecuta IPI instrucciones, lanza una interrupcin y dibuja la

pantalla (en la ventana de vista grfica)
Cargar / salvar estado: almacena o restaura el estado de la mquina, es decir:
memoria RAM y registros. Permite continuar el anlisis donde se dejase
anteriormente
Disparar IRQ: inicia el proceso de interrupcin del procesador. Las operaciones
del 6809, sin embargo, no comenzarn a evaluarse hasta que no se procese
alguna de las rdenes de ejecucin de instrucciones explcitamente desde el
men
Comentar direccin: una de las capacidades ms tiles del Analizador es el
comentario de direcciones. Mediante un sencillo cuadro de dilogo se pueden
aadir notas que aparecern al lado del desensamblado o marcar zonas de
memoria como datos y, por lo tanto, evitar que sean desensambladas
66

Jos Tejada Gmez
cuadro de dilogo para aadir comentarios
Ejemplo de comentario de texto y comentario de datos.

El intervalo de datos se marca con el comentario en vez de desensamblarse
Borrar el comentario: basta pulsar suprimir para eliminar el comentario, del tipo
que fuere, del desensamblado
El men Memoria
Las acciones disponibles son:
Ir a: a travs de un cuadro de dilogo permite ir a la posicin de memoria

especificada. El contenido de la ventana de volcado cambiar
consecuentemente
Cambiar la pgina: fuerza un cambio en la pgina seleccionada. Esto resultaba
til cuando se investigaba el funcionamiento de la paginacin
Configurar la vista de la memoria (grfica): Combat School tena dos circuitos
grficos superpuestos en la misma posicin de memoria. Un registro situado en
500h elega a cul de los dos se dirigan las operaciones del procesador
opciones de configuracin de la vista de memoria
67

Jos Tejada Gmez
El men Ver
Aparte de las habituales opciones de ocultar o mostrar las barras de estado y
herramientas, se incluye la posibilidad de activar la vista de registros. En caso de
hacerlo obtendramos el siguiente cuadro de dilogo sin modo28 :
cuadro de registros
Cuando la ventana activa es una vista grfica, el men ver se ampla a las siguientes
opciones:
Grupos: a travs de un cuadro de dilogo permite configurar de forma similar a

lo hecho con la paginacin, la relacin existente entre el cdigo de grupo a
pintar y el grupo en la memoria ROM
1er fondo (volcado): muestra en la vista grfica el volcado de la memoria ROM
del fondo. Este es un grfico esttico (ya que la ROM no puede cambiar) y sirve
para identificar cdigos de bloques y grupos
2 fondo (volcado): dem con el 2 fondo
1er juego de objetos: dem con el primer juego de objetos
2 juego de objetos: dem con el 2 juego de objetos
2000-27FF: analiza esta porcin de la RAM grfica y la dibuja
2800-2FFF: dem con este otro intervalo
Objetos: dem con la memoria de objetos
El men Ventana
Obviando las omnipresentes entradas de cascada, mosaico y organizar iconos,

hay dos acciones disponibles en est men: crear nueva vista mixta y crear nueva vista
grfica. Ambas abren nuevas ventanas para observar la misma mquina. Es decir, no
emulan otro equipo adicional, sino que nos permiten ver desde ms ngulos un mismo
sistema. Esto permite, por ejemplo, tener en una ventana la memoria RAM mientras en
otra se observa la memoria del circuito grfico, ambas del mismo procesador. En el
caso de la vista grfica permite, por ejemplo, ver en una ventana el dibujo del 2 fondo
mientras que en la otra se ven slo los objetos.
Sin modo se refiere a que el cuadro de dilogo no interrumpe la operacin de la aplicacin

principal. No existe un dilogo sncrono entre este tipo de dilogos y el programa. El trmino
ingls modeless, algo obscuro, seguramente no est bien recogido en esta traduccin (comn
en los libros) y otras soluciones como cuadro de dilogo asncrono seran ms intuitivas
28
68

Jos Tejada Gmez
La emulacin del procesador

El procesador es el ncleo vital de la mquina y donde sucede el juego en s. La emulacin de
ste es la pieza inicial en la programacin del emulador y la que determinar en gran medida el
rendimiento del programa.
Un procesador est compuesto, a nivel lgico, por un conjunto de operaciones que
afectan a un juego de registros y a una memoria externa. Estos son, por tanto, los tres
elementos a simular.
Resulta sencillo imaginar un boceto del emulador como sigue:
struct _registros
{
unsigned char a,b;
/* etc. */
} registros;
char mem[64*1024*1024]; /* 64 kOct de memoria */
void emula_ucp()
{
do{
ejecuta_op( mem[registros.ip] );
registros.ip++;
}while();
}
La idea del cdigo anterior es simular los registros con una estructura, la memoria con
un vector y el conjunto de operaciones por una funcin (ejecuta_op). Se ha representado
tambin el uso del registro de puntero de instruccin (IP), como se sabe este registro
apunta a la siguiente instruccin a ejecutar; despus de procesarla, el contenido del
registro ha de incrementarse para pasar a la siguiente29.
Cmo podemos realizar la funcin ejecuta_op? Lo ms obvio es utilizar la
construccin case:
#define SUMAR 0x12 /*Cdigo mquina de la suma */
#define RESTAR 0x13 /* dem de la resta */
switch( op )
{
case SUMAR: haz_suma(); break;
case RESTAR:haz_resta(); break;
}
Este enfoque con un compilador adecuado puede producir cdigo muy rpido. Para
ello es necesario que la direccin de memoria donde salta el cdigo est relacionada
con el nmero de la operacin. Es decir, queremos que la direccin donde salta el
programa a partir de la instruccin switch se componga de:
29
Salvo cuando existan saltos.
69

Jos Tejada Gmez
DIRECCIN = BASE + FACTOR*OPERACIN
De esa forma se puede codificar el salto de forma muy eficiente. Esto, sin embargo, es
difcil de conseguir directamente sin fraccionar la memoria ya que cada operacin
emulada se resuelve con un cdigo diferente y, por tanto, no siempre ocupa la misma
memoria, sin ese requisito no es posible saber el FACTOR a usar en la frmula
anterior. Muchos compiladores utilizan una tabla intermedia para aprovechar la
velocidad de la frmula anterior. As el abanico de sendas que se abre con la
instruccin swift se codifica de forma eficiente a travs de dos saltos:
Instruccin swift codificada con una tabla intermedia asociada a op
En el caso de que el compilador no sea capaz de generar esta tabla de forma automtica se
puede realizar utilizando un vector de punteros a funcin de la siguiente forma:
void haz_suma();
void haz_resta();
...
void (*funciones())[256];
funciones[0] = haz_suma;
funciones[1] = haz_resta;
(funciones[op])(); /* Llama a la funcin en la posicin op*/
La realizacin anterior es muy eficiente ya que no es necesario comparar el valor de la

operacin, el salto es directo. Internamente, el compilador genera un cdigo paralelo al
mostrado en la figura anterior.
Cada operacin emulada responde al siguiente modelo:
void operacin_emulada()
{
carga_operando
ejecuta_operacin
actualiza_sealizadores
}
70

Jos Tejada Gmez
La carga del operando traer a una variable el dato sobre el que se ejecuta la operacin.
Esta carga depende directamente del modo de direccionamiento (inmediato, directo,
indexado, etc.) y se estudiar con detalle en el caso del 6809. La revisin de los
sealizadores (o banderas) es distinta segn cada operacin, pues algunas afectan al
acarreo y al desbordamiento, mientras que otras afectarn al de cero. Pese a que cada
una afecte de una manera, son pocas las operaciones que no afectan a ningn
sealizador. La ejecucin de la operacin misma es la nica parte que difiere
radicalmente en cada caso, desde no hacer nada (nop u operacin nula) hasta una
multiplicacin, toda una baraja de casos distintos se despliega en este apartado.
Debido a que el coste de ejecucin de una operacin es elevado en cuanto a coste fijo:
entrar en la funcin que evala cul se ejecuta y salir de ella; trataremos de reducir ese
coste ejecutando lotes de operaciones en un bucle, se ahorran as apilaciones y
desempilaciones de datos. El inconveniente es que las interrupciones no son emuladas
de forma muy realista, ya que en lugar de parar la ejecucin del programa en cualquier
instante lo harn slo en medio de uno de estos paquetes. En la prctica no se aprecia
la diferencia, en especial porque la nica interrupcin que ocurre habitualmente en una
mquina de vdeo proviene del sistema de vdeo y dada la estructura del juego, el
cdigo debe estar en un bucle de espera de la interrupcin cuando sta llega; no
importa, por tanto, realmente que se interrumpa el hilo de ejecucin en un punto u otro.
71

Jos Tejada Gmez
El Motorola 6809
El procesador M6809 es una UCP de 8 dgitos, CISC, con un juego de registros
reducido:
Nombre
A
B
X
Y
U
S
CC
DP
PC
Tamao (octetos)
1
1
2
2
2
2
1
1
2
Descripcin
acumulador
acumulador
ndice
ndice
ndice
ndice para la pila
banderas
ndice directo
puntero de operacin
Adems de estos registros, existe otro ms formado por la unin de A y B: El registro D,

de dos octetos de longitud.
Las operaciones se ejecutan siempre sobre los acumuladores, llevando luego los
resultados a memoria con otra instruccin. El ancho del bus de direcciones es de 16
dgitos, por tanto, los punteros (X,Y,U,S y PC) abarcan toda la memoria direccionable
(64 koct). Los ndices se utilizan segn el modo de direccionamiento:
Inmediato: El operando viene en el siguiente octeto apuntado por PC

Directo: La direccin del operando se construye uniendo el siguiente octeto
apuntado por PC al contenido del registro DP
Indexado: Este modo sirve para indexar tablas y est basado en utilizar el
operando dado como ndice respecto al contenido del registro de puntero X o
de otro registro. Las posibilidades son:
o Post1: Lee de donde X indique y a continuacin lo incrementa en uno.
o Post2: dem pero incrementando en dos.
o Pre1: Primero se incrementa en uno y luego se lee
o Pre2: dem pero incrementando en dos.
o Slo registro: se lee de X sin modificarlo
o Acumulador A: se lee de la posicin X+A
o Acumulador B: dem de X+B
o Desplazamiento de un octeto: se suma el siguiente octeto (apuntado
por el registro de instruccin, PC) a X, y se lee de la memoria indicada
por el resultada
o Desplazamiento de dos octetos: dem, salvo que el operando a sumar
ocupa ahora dos octetos y permite, por tanto, indexar toda la memoria
o Acumulador D: Se lee de X+D, recurdese que D es el registro de 16
dgitos compuesto por la concatenacin de A y B
o Relativo a PC+8: La lectura no depende de X sino del puntero de
instruccin PC, a ste se le aade un desplazamiento de 8 dgitos de
longitud
o Relativo a PC+16: La lectura es desde el PC pero el desplazamiento
ocupa ahora dos octetos
72

Jos Tejada Gmez
Extendido indirecto: Se lee el valor de 16 dgitos apuntado por PC, a
continuacin se usa ese dato como puntero para leer de memoria otros
16 dgitos que indican la posicin final del operando
Extendido: La direccin del operando viene en los dos siguientes octetos
apuntados por PC
o
Las instrucciones tienen habitualmente una versin para cada modo de

direccionamiento, por ejemplo la operacin LDA (LoaD A, cargar un dato en A) admite,
entre otras, las siguientes versiones:
86 12 LDA 12h
;A=12h
96 12 LDA #12
;A=(DP*256+12)
B6 12 00
LDA $1200h;A=(1200h)
73

Jos Tejada Gmez
Juego de instrucciones
Banderas
(CC)
Modo de direccionamiento
Immediat
Directo
o
Instrucci Nemnic
Op ~
n
o
# Op
Indexado
Extendid
Inherente
o
~ # Op ~ # Op ~ #
ABX
A = A+M+C
+
+
+ ++ +
+ ++ +
ADCB
C9 2
2 D9
4 2 E9
4
2+ F9 5 3
+
B = B+M+C
+ ++ +
ADDA
8B 2
2 9B
4 2 AB
4
2+ BB 5 3
+
A = A+M
+ ++ +
ADDB
CB 2
2 DB
4 2 EB
4
2+ FB 5 3
+
B = B+M
+ ++ +
ADDD
C3 4
3 D3
6 2 E3
6
2+ F3 7 3
+
D = D+M:M+1
+ ++ +
84 2
2 94
4 2 A4 4 2+ B4 5 3
+
A = A && M
+ +0
C4 2
2 D4
4 2 E4 4 2+ F4 5 3
+
B = B && M
+ +0
1C 3
C = CC &&
?
INM
? ? ? ?
ANDB
ASLB
08
6 2 68
48 2
58 2
6
2+ 78 7 3
+
ASRA
47 2
ASRB
57 2
ASR
07
6 2 67
6
2+ 77 7 3
+
8
desplazamient
o aritmtico a 8
la izquierda
8
8
desplazamient
o aritmtico a 8
la derecha
8
+ ++ +
+ ++ +
+ ++ +
+ +
+ +
+ +
BITA
85 2
2 95
4 2 A5
4
2+ B5 5 3
+
probar dgito
en A (M&&A)
+ +0
BITB
C5 2
2 D5
4 2 E5
4
2+ F5 5 3
+
probar dgito
en B (M&&B)
+ +0
BIT
CLRA
4F 2
A=0
0 1 0 0
CLRB
5F 2
B=0
0 1 0 0
M=0
0 1 0 0
0F
CLR
CMP
X = B+X (sin
signo)
4
2+ B9 5 3
+
ASL
CLR
NZV C
4 2 A9
ASLA
ASR
3
3
A
2 99
ANDCC
ASL
Descripcin
89 2
ANDA
AND
3 2 1 0
ADCA
ADC
ADD
O
~
p
6 2 6F
6 2+ 7F 7 3
+
CMPA
81 2
2 91
4 2 A1 4 2+ B1 5 3
+
compara M con 8
A
+ ++ +
CMPB
C1 2
2 D1
4 2 E1 4 2+ F1 5 3
+
compara M con 8
B
+ ++ +
CMPD
10 5
83
4 10
93
7 3 10 7 3+ 10 8 4
A3 +
B3
compara
M:M+1 con D
+ ++ +
CMPS
11 5
8C
4 11
9C
7 3 11 7 3+ 11 8 4
AC +
BC
compara
M:M+1 con S
+ ++ +
CMPU
11 5
83
4 11
93
7 3 11 7 3+ 11 8 4
A3 +
B3
compara
M:M+1 con U
+ ++ +
74

Jos Tejada Gmez
COM
CMPX
8C
3 9C
6 2 AC 6 2+ BC 7 3
+
compara
M:M+1 con X
+ ++ +
CMPY
10 5
8C
4 10
9C
7 3 10 7 3+ 10 8 4
AC +
BC
compara
M:M+1 con Y
+ ++ +
COMA
43 2
A
=
complemento(
A)
+ +0 1
COMB
53 2
B
=
complemento(
B)
+ +0 1
M
=
complemento(
M)
+ +0 1
COM
CWAI
03
3C
6 2 63
6
2+ 73 7 3
+
CC = CC ^
INM;
espera hasta la 7
prxima
interrupcin
=>
2
20
19 2
ajuste decimal
A
+ +0 +
DECA
4
2
A
A=A 1
+ ++
DECB
5
2
A
B=B 1
+ ++
DAA
DEC
DEC
0A
6 2 6A
6
2+ 7A 7 3
+
M=M 1
+ ++
EORA
88 2
2 98
4 2 A8
4
2+ B8 5 3
+
A = A XOR M
+ +0
EORB
C8 2
2 D8
4 2 E8
4
2+ F8 5 3
+
B = M XOR B
+ +0
R1,R2
1E 8
EOR
EXG
Intercambia
R1,R2
INCA
INC
INCB
4C 2
A=A+1
+ ++
5C 2
B=B+1
+ ++
M=M+1
+ ++
0C
6
6 2 6C
2+ 7C 7 3
+
JMP
0E
3 2 6E
3
2+ 7E 4 3
+
pc = EA
JSR
9D
7 2 AD
7
2+ BD 8 3
+
salto
subrutina
INC
LD
LDA
86 2
2 96
4 2 A6 4+ 2 B6 5
+
LDB
C6 2
2 D6
4 2 E6 4+ 2 F6 5
+
LDD
CC
3 DC
5 2 EC 5+ 2 FC 6
+
LDS
10 4
CE
4 10
DE
6 3 10 6+ 3 10 7
EE
+ FE
LDU
CE
3 DE
5 2 EE 5+ 2 FE 6
+
LDX
8E
3 9E
5 2 AE 5+ 2 BE 6
+
LDY
10 4
8E
4 10
9E
6 3 10 6+ 3 10 7
AE
+ BE
A=M
B=M
a
++0
++0
D = M:M+1
++0
S = M:M+1
++0
U = M:M+1
++0
X = M:M+1
++0
Y = M:M+1
++0
75

Jos Tejada Gmez
LEA
LSL
LEAS
32 4+ 2
+
S = EA
LEAU
33 4+ 2
+
U = EA
LEAX
30 4+ 2
+
X = EA
LEAY
31 4+ 2
+
Y = EA
LSLA
48 2
LSLB
58 2
LSL
LSR
08
6 2 68 6+
2
78 7
+
LSRA
44 2
LSRB
54 2
LSR
04
6 2 64 6+
2
74 7
+
3
3
11
D
MUL
NEG
D = A*B (sin
signo)
+++ +
0 +
0 +
0 +
A = !A + 1
8+++ +
B = !B + 1
8+++ +
M = !M + 1
8+++ +
00
6 2 60 6+
2
70 7
+
3
12 2
ORB
No hace nada
8A 2
2 9A
4 2 A 4+ 2 BA 5
A
+
A = A || M
++0
CA 2
2 DA
4 2 EA 4+ 2 FA 5
+
B = B || M
++0
1A 3
C =
IMM
CC
PSHS
34 5+ 2
Meter en S
PSHU
36 5+ 2
Meter en U
PULS
35 5+ 2
Sacar de S
PULU
37 5+ 2
Sacar de U
ROLA
49 2
ROLB
59 2
ROL
09
6 2 69 6+
2
79 7
+
RORA
ROR
Desplazamient
o a la derecha
+++ +
50 2
ORCC
ROL
Desplazamient
o a la izquierda
40 2
ORA
PUL
+++ +
NEGB
NOP
PSH
NEGA
NEG
OR
RORB
ROR
06
2
6 2 66 6+
76 7
+
46 2
56 2
||
Rotar
a
la
izquierda con
acarreo
Rotar
a
la
derecha
con
acarreo
?? ? ? ?
+++ +
+++ +
+++ +
0 +
0 +
0 +
RTI
3B 6/15 1
Retorno
de
?? ? ? ?
interrupcin
RTS
39 5
Retorno
subrutina
SBCA
SBC
SBCB
2 92
4 2 A2 4+ 2 B2 5
+
A=A-M-C
8+++ +
C2 2
2 D2
4 2 E2 4+ 2 F2 5
+
B=B-M-C
8+++ +
1
2
D
STA
de
82 2
SEX
ST
97
4 2 A7 4+ 2 B7 5
+
Extender
el
signo de A en B
M=A
++0
++0
76

Jos Tejada Gmez
STB
D7
4 2 E7 4+ 2 F7 5
+
DD
5 2 ED 5+ 2 FD 6
+
10
DF
6 3 10 6+ 3 10 7
EF
+ FF
DF
5 2 EF 5+ 2 FF 6
+
9F
5 2 AF 5+ 2 BF 6
+
10
9F
6 3 10 6+ 3 10 7
AF
+ BF
80 2
2 90
4 2 A0 4+ 2 B0 5
+
C0 2
2 D0
4 2 E0 4+ 2 F0 5
+
83 4
3 93
6 2 A3 6+ 2 B3 7
+
STD
STS
STU
STX
STY
SUBA
SUB
SUBB
SUBD
SWI
TST
++0
M:M+1 = S
++0
M:M+1 = U
++0
M:M+1 = X
++0
M:M+1 = Y
++0
A=A-M
8+++ +
B=B-M
8+++ +
D = D - M:M+1
1
interrupcin
por programa 1
SWI2
10 20
3F
interrupcin
por programa 2
SWI3
11 20
3F
interrupcin
por programa 3
SYNC
TFR
M:M+1 = D
3F 19
SWI
13
R1,R2
1F 6
++0
M=B
>=
4
+++ +
sincronizarse
con
la
interrupcin
R2 = R1
TSTA
4
2
D
prueba A
++0
TSTB
5
2
D
prueba B
++0
prueba M
++0
TST
0D
6 2 6D 6+
2
7D 7
+
Leyenda
! Complemento de M
+ afectado
OP cdigo de la operacin
(hexadecimal)
= asignacin
- no se afecta
~ Number of MPU Cycles
H semiacarreo (del dgito CC banderas (cdigos de

3)
condicin)
# nmero de octetos
N bandera de signo
: Concatenation
+ suma aritmtica
Z cero
|| o lgica
- resta aritmtica
V desbordamiento,
complemento a 2
&& y lgica
* multiplicacin
C acarreo de la UAL
EOR o xclusiva
EA direccin efectiva: w
77

Jos Tejada Gmez
El compilador de un emulador
El emulador del procesador es una pieza clave en la velocidad del conjunto del
programa y su fiabilidad imprescindible ya que quando caput dolet caetera membra
dolent30, es decir, si el director de la orquesta presenta fallos la emulacin no funcionar.
Durante el desarrollo del emulador de Ghosts & Goblins descubrimos accidentalmente
una situacin curiosa relacionada con la importancia de un procesador bien emulado.
Cuando haca las primeras pruebas del juego funcionando con la UCP emulada todo
pareca ir bien hasta que programamos las rutinas de entrada de monedas y pudimos
comenzar la partida. En la escena de introduccin aparece un vampiro enorme que
secuestra a la doncella y da comienzo a la accin, en su ataque, el vampiro recorre una
lnea recta oblicua desde el cielo hasta el suelo, donde yace la dama. Curiosamente si la
operacin de rotacin con acarreo de los dgitos est implementada como
desplazamiento a secas31 el vampiro no es capaz de atrapar a la doncella y queda
eternamente dando vueltas alrededor de la pantalla quedndose colgado el juego.
introduccin de Ghosts & Goblins
Como vemos una instruccin mal emulada puede detener completamente el proceso,
la relacin entre el error visual (el vampiro dando vueltas) y el error real (desplazar por
rotar) no es obvia y su depuracin puede llevar varias horas o no encontrarse nunca.
Teniendo en cuenta el nmero de instrucciones a codificar la probabilidad de cometer
errores es enorme, mxime si se pretende escribir el emulador en ensamblador para
maximizar su velocidad.
Tras un par de tentativas fracasadas ante erratas imposibles de encontrar se lleg a la
conclusin de que la mejor forma de escribir un emulador era no escribindolo,
compilndolo.
Todas las rdenes del procesador tienen una gran simetra entre s: todas cargan datos
de memoria, todas operan sobre ellos y todas alteran las banderas. La forma de cargar
los datos y de afectar las banderas es tambin comn: todas las rdenes que cargan de
modo indexado lo hacen igual, todas las que modifican la bandera de cero lo hacen por
Cuando duele la cabeza, duelen el resto de los miembros
Rotacin implica que no se pierde informacin, que el dgito que sale por un extremo entra
por el otro; en el desplazamiento se pierden dgitos que se sustituyen por cero
30
31
78

Jos Tejada Gmez
la misma razn. Slo la operacin sobre los operandos vara de un caso a otro y aun as
es comn para cada variante de una instruccin con distinto modo de
direccionamiento. Acaso no habra una forma de sacar ventaja de esto?
Se escribi un pequeo fichero que describa todas las instrucciones del 6809 de forma
concisa, con un formato estricto y que minimizaba la posibilidad de error. Al ser slo
unas cuantas lneas la depuracin era muy sencilla y la perfeccin por diseo estaba
prcticamente garantizada. Con este fichero escrito, slo haca falta un compilador que
lo transformase en cdigo ensamblador Intel para luego ensamblarlo y enlazarlo al
resto del emulador.
Las rdenes se describen utilizando el siguiente formato:
nombre,direccionamiento, OP, banderas, cdigo, comentario
nombre: es el nemnico de la instruccin, nombrar a las rutinas en

ensamblador que ejecutarn esta orden
direccionamiento: cada orden puede leer los operandos de distintas formas,
una letra indica que modos estn permitidos:
o i: inmediato
o d: directo
o x: indexado
o e: extendido
o b: salto corto (slo en las operaciones de salto)
o lb: salto largo (slo en las operaciones de salto)
o nada: la operacin es inherente a la UCP, no necesita operandos
OP: cdigo de operacin para el direccionamiento inmediato. Debido al modo
de funcionamiento de la unidad de descodificacin del 6809, los cdigos OP
aumentan en 10h segn el direccionamiento as: 89h para inmediato, 99h para
directo, A9 para indexado y B9 para extendido; por ejemplo
banderas: banderas afectas por la orden. Cada letra indica que ha de evaluarse
su condicin y alterar su respectiva bandera segn sea el resultado:
o H: acarreo entre cuartetos
o N: resultado negativo
o Z: resultado nulo
o V: desbordamiento
o C: acarreo entre octetos
cdigo: esta es la parte distinta en cada operacin y comn entre distintos
modos de direccionamiento de una misma operacin. Est escrita en cdigo
ensamblador Intel y utiliza la arroba (@) para hacer referencia al operando
(cuyo registro o posicin diferir segn el modo de direccionamiento)
comentario: una breve lnea para recordar qu se hizo y por qu
A continuacin se detalla el fichero crea.gen32 que contiene todas las instrucciones, tras
l se analizarn algunas instrucciones de cada tipo y la codificacin que genera el
compilador por nosotros programado- de ellas.
Se decidi nominar la extensin como gen en alusin a que este fichero era la gnesis del
emulador
32
79

Jos Tejada Gmez
abx,,3a,-,"mov %bl,%al\nmovb $0,%ah\naddw %ax,_x"
adca, idxe,
adcb, idxe,
adda, idxe,
addb, idxe,
addd,idxe0,
89,
c9,
8B,
CB,
c3,
HNZVC,
HNZVC,
HNZVC-,
HNZVC-,
hnzvc-,
"adcb @,%bh"
"adcb @,%bl"
"addb @,%bh"
"addb @,%bl"
"add %ax,%bx"
Aade
Aade
Aade
Aade
Aade
el
el
el
el
el
valor
valor
valor
valor
valor
a
a
a
a
a
A con acarreo
b con acarreo
A
B
D
anda, idxe, 84, nzv-, "andb

@,%bh" V=0 siempre
andb, idxe, c4, nzv-, "andb
@,%bl"
andcc,i,1c,-,"call _de_CCF_a_cc\nand %al,_cc\ncall _de_cc_a_CCF"
asla,,48,hnzvc-,"salb $1,%bh"
aslb,,58,hnzvc-,"salb $1,%bl"
asl,dxe+,8,hnzvc-,"salb $1,(%ebp,%eax)"
asra,,47,hnzvc-,"sarb $1,%bh"
asrb,,57,hnzvc-,"sarb $1,%bl"
asr,dxe+,7,hnzvc-,"sarb $1,(%ebp,%eax)"
dgitoa, idxe, 85, nzv-, "testb
dgitob, idxe, c5, nzv-, "testb
@,%bh" V=0 siempre

@,%bl"
clra,
, 4F, N0 Z1 V0 C0 -, "xor
clrb,
, 5F, N0 Z1 V0 C0 -, "xor
clr, dxe+,
f, n0 z1 v0 c0 -, "movb
%bh,%bh" Borra A
%bl,%bl" Borra B
$0,(%ebp,%eax)" Borra el octeto
cmpa,idxe ,81,hnzvc-,"cmpb @,%bh"

cmpb,idxe ,c1,hnzvc-,"cmpb @,%bl"
cmpd,idxe0,1083,nzvc-,"cmpw %ax,%bx"
cmps,idxe0,118c,nzvc-,"cmpw %ax,_s"
cmpu,idxe0,1183,nzvc-,"cmpw %ax,_u"
cmpx,idxe0,8c,nzvc-,"cmpw %ax,_x"
cmpy,idxe0,108c,nzvc-,"cmpw %ax,_y"
coma,,43, nzvc-,"not
%bh\naddb $0,%bh\nstc" V=0,C=1 siempre.
comb,,53, nzvc-,"not
%bl\naddb $0,%bl\nstc"
com,dxe+,3,nzvc-,"notb
(%ebp,%eax)\naddb $0,(%ebp,%eax)\nstc"
daa,,19,nzvc,"mov %bh,%al\ndaa\nmov %al,%bh"
deca,,4a,nzv-,"dec
%bh"
decb,,5a,nzv-,"dec
%bl"
dec,dxe+,a,nzv-,"decb (%ebp,%eax)"
eora,idxe,88,nzv-,"xorb
eorb,idxe,c8,nzv-,"xorb
@,%bh" V=0 siempre

@,%bl"
inca,,4c,nzv-,"inc
%bh"
incb,,5c,nzv-,"inc
%bl"
inc,dxe+,c,nzv-,"incb
(%ebp,%eax)"
jmp, dxe+, 0E,-,"movw
%ax,%si" Salto incondicional
jsr,
dxe+,
9d,-,"mov
%si,%dx
\nxchg
%dh,%dl
\
subw
\nxor %ecx,%ecx\nmovw _s,%ecx \nmovw %dx,(%ebp,%ecx) \nmov %ax,%si"
lda, idxe, 86,
ldb, idxe, c6,
ldd,0idxe, cc,
lds,0idxe,10CE,
ldu,0idxe, ce,
nzv-,
nzv-,
nzv-,
nzv-,
nzv-,
"movb
"movb
"movw
"movw
"movw
$2,_s
@,%bh\naddb
$0,%bh" Carga el valor en A
@,%bl\naddb
$0,%bl" Carga el valor en B
%ax,%bx\naddw
$0,%bx" Carga el valor en D
%ax,_s \naddw
$0,%ax" Carga el valor en S
%ax,_u \naddw
$0,%ax" Carga el valor en U
80

Jos Tejada Gmez
ldx,0idxe, 8e, nzv-, "movw
ldy,0idxe,108e, nzv-, "movw
%ax,_x \naddw
%ax,_y \naddw
$0,%ax" Carga el valor en X

$0,%ax" Carga el valor en Y
leas, x+, 32, -, "movw

%ax,_s"
leau, x+, 33, -, "movw
%ax,_u"
leax,
x+,
30,
-,"movw
%ax,_x\ncmpw
$0xffffffbf,CCF\nret\nleax_z:orl $0x40,CCF"
leay,
x+,
31,
-,"movw
%ax,_y\ncmpw
$0xffffffbf,CCF\nret\nleay_z:orl $0x40,CCF"
$0,%ax\nje
leax_z\nandl
$0,%ax\nje
leay_z\nandl
lsra,,44,nzc-,"shrb $1,%bh" N=0 siempre

lsrb,,54,nzc-,"shrb $1,%bl"
lsr,dxe+,4,nzc-,"shrb $1,(%ebp,%eax)"
mul,,3d,zc,"mov %bl,%al\nmulb %bh\nmov %ax,%bx\naddw $0,%bx\nbt $0x7,%ebx"
nega,,40, hnzvc-,"neg %bh"
negb,,50, hnzvc-,"neg %bl"
neg,dxe+,0, hnzvc-,"negb (%ebp,%eax)"
nop,,12,-,"" No hace nada
ora,idxe,8a,nzv-,"orb @,%bh" V=0 siempre pues el or del x86 lo hace as
orb,idxe,ca,nzv-,"orb @,%bl"
orcc, i,1a,-,"call _de_CCF_a_cc\nor %al,_cc\ncall _de_cc_a_CCF"
rola,,49,vc!,"rclb $1,%bh\nmov %bh,%al"
rolb,,59,vc!,"rclb $1,%bl\nmov %bl,%al"
rol,dxe+,9,vc!,"rclb $1,(%ebp,%eax)\nmovb (%ebp,%eax),%al"
rora,,46,c!,"rcrb $1,%bh\nmov %bh,%al"
rorb,,56,c!,"rcrb $1,%bl\nmov %bl,%al"
ror,dxe+,6,c!,"rcrb $1,(%ebp,%eax)\nmovb (%ebp,%eax),%al"
rts,,39,-,"xor %eax,%eax\nmovw
\nmov %ax,%si \naddw $2,_s"
_s,%ax
\nmovw
(%ebp,%eax),%ax\nxchg
%ah,%al
sbca,idxe,82,hnzvc,"sbbb @,%bh"
sbcb,idxe,c2,hnzvc,"sbbb @,%bl"
sex,,1d,nz-,"mov
%bl,%al\ncbw\nmov %ah,%bh\naddw $0,%ax"
sta,dxe+,97,nzv-,"movb %bh,(%ebp,%eax)\ncall pagina\naddb $0,%bh"

stb,dxe+,d7,nzv-,"movb %bl,(%ebp,%eax)\ncall pagina\naddb $0,%bl"
std,dxe+,dd,nzv-,"movw
%bx,%cx\nxchg
%ch,%cl\nmovw
%cx,(%ebp,%eax)\naddw
$0,%bx"
sts,dxe+,10df,nzv-,"movw
_s,%cx\nxchg
%ch,%cl\nmovw
$0,_s"
stu,dxe+,df,nzv-,"movw _u,%cx\nxchg %ch,%cl\nmovw %cx,(%ebp,%eax)\naddw $0,_u"
stx,dxe+,9f,nzv-,"movw _x,%cx\nxchg %ch,%cl\nmovw %cx,(%ebp,%eax)\naddw $0,_x"
sty,dxe+,109f,nzv-,"movw
_y,%cx\nxchg
%ch,%cl\nmovw
$0,_y"
suba,idxe,80,hnzvc-,"subb @,%bh"
subb,idxe,c0,hnzvc-,"subb @,%bl"
subd,idxe0,83,hnzvc-,"subw %ax,%bx"
sync,,13,-,"" nihil facit.
tsta, ,4d,nzv-,"addb
tstb, ,5d,nzv-,"addb
tst,dxe+,d,nzv-,"addb
$0,%bh" V = 0 siempre
$0,%bl" V = 0 siempre
$0,(%ebp,%eax)" V = 0 siempre
81

Jos Tejada Gmez
Las instrucciones de salto tienen siempre una equivalencia exacta en los procesadores
x86, de forma que la traduccin es muy sencilla. Para su codificacin se han aadido
dos nuevos tipos de direccionamiento: el b (del ingls branch, rama, todas las
instrucciones de salto del 6809 comienzan por est letra) y el lb (de long branch, rama
larga; las instrucciones que implican un salto demasiado largo para caber en un octeto
comienzan por lb).
Los saltos cortos se basan en la idea de almacenar la diferencia entre la posicin actual
y la deseada en un octeto que se almacena siguiendo al OP; los saltos largos precisan
de dos octetos pese a que el valor sigue siendo relativo a la posicin actual.
Se podra haber rizado el rizo en el compilador y haberle exigido que generase
automticamente los saltos largos a partir de los cortos ya que, como puede verse en el
cdigo adjunto, hay una regularidad en cuanto a los cdigos OP: los saltos largos
tienen el mismo cdigo OP que su correspondiente corto aunque precedido por el
prefijo 10h.
En todos los saltos que impliquen leer una palabra de 16 dgitos es preciso invertir el
orden de los octetos antes de realizar ninguna operacin con ellos.
bra,i,20,-,"cbw\nadd
%ax,%si" Salta siempre
brn,i,21,-,"" No salta
bhi,b,22,,"ja"ZoC=0
bls,b,23,,"jna" jna=jbe C o Z = 1
bcc,b,24,,"jnc" Si C=0
bcs,b,25,,"jc" Si C=1
bne,b,26,,"jnz" Si Z=1
beq,b,27,,"jz" Si Z=0
bvc,b,28,,"jno" Si V=0
bvs,b,29,,"jo" Si V=1
bpl,b,2A,,"jns" Si N=0
bmi,b,2B,,"js" Si N=1
bge,b,2c,,"jge" Si N==V
blt,b,2d,,"jl" Si N!=V
bgt,b,2e,,"jnle" Z=0 y N==V
ble,b,2f,,"jle" Z=1 N!=V
lbra,i0,16,-,"add
%ax,%si" Salta siempre
lbrn,i0,1021,-,"" No salta
lbhi,lb,1022,,"ja"
lbls,lb,1023,,"jna"
lbcc,lb,1024,,"jnc"
lbcs,lb,1025,,"jc"
lbne,lb,1026,,"jne"
lbeq,lb,1027,,"je"
lbvc,lb,1028,,"jno"
lbvs,lb,1029,,"jo"
lbpl,lb,102A,,"jns"
lbmi,lb,102B,,"js"
lbge,lb,102c,,"jge"
lblt,lb,102d,,"jl"
lbgt,lb,102e,,"jnle"
lble,lb,102f,,"jle"
bsr,i,8d,-,"mov
%si,%dx \nxchg %dh,%dl \ subw $2,_s \nxor %ecx,%ecx\nmovw
_s,%cx \nmovw %dx,(%ebp,%ecx) \ncbw\nadd %ax,%si"
lbsr,i0,17,-,"mov
%si,%dx \nxchg %dh,%dl \ subw $2,_s \nxor %ecx,%ecx\nmovw
_s,%cx \nmovw %dx,(%ebp,%ecx) \nadd %ax,%si"
82

Jos Tejada Gmez
Anlisis de algunas instrucciones y su compilacin

Para mejorar la comprensin de cmo funciona el compilador del emulador vamos a
presentar ahora varios ejemplos de instrucciones segn se describen en crea.gen y
segn quedan compiladas en cdigo ensamblador por el compilador (crea.exe)
adca, idxe, 89, HNZVC,
"adcb
@,%bh" Aade el valor a A con acarreo
La instruccin adca est codificada como adcb @,%bh en cdigo Intel, representando
que se aadir al registro A (emulado con el registro bh del 8086) el valor del operando
representado por @, ste se obtendr segn el modo de direccionamiento: inmediato,
directo, indexado o extendido. Adems las banderas de cuarteto, de signo, de cero, de
desbordamiento y de acarreo resultarn afectadas. Para optimizar la velocidad, cada
modo de direccionamiento se codifica con una funcin distinta; el cdigo que genera el
compilador es:
.align 4
_adcaI:
#adca Inmediato
pushl
CCF
popfl
inc %si
#cdigo singular
adcb -1(%ebp,%esi),%bh
#final
pushfl
popl
CCF
ret
adca, inmediato
.align 4
_adcaX:
#adca Indexado
xor %eax,%eax
movb (%ebp,%esi),%al
lea _index,%ecx
incw %si
call (%ecx,%eax,4)
pushl
CCF
popfl
#cdigo singular
adcb (%ebp,%eax),%bh
#final
pushfl
popl
CCF
ret
adca, indexado
.align 4
_adcaD:
#adca Directo
xor %eax,%eax
#carga en EAX el octeto de desplazamiento
inc
%si #ajusta el PC
movb
_dp,%ah # Pone en AH DP
pushl
CCF
popfl
#cdigo singular
#final
pushfl
popl
CCF
ret
adca, directo
.align 4
_adcaE:
#adca Extendido
xor %eax,%eax
movw (%ebp,%esi),%ax
addw
$2,%si #ajusta el PC
xchgb %ah,%al #direccin en EAX
pushl
CCF
popfl
#cdigo singular
#final
pushfl
popl
CCF
ret
adca, extendido
El modo de direccionamiento decide como empieza cada funcin, en el caso de direcc.

inmediato hay que incrementar el puntero de instrucciones (IP, emulador por SI) para
que apunte al operando que ser cargado usando la combinacin: -1(%ebp,%esi). Para
los dems casos el desarrollo es ms complicado pero obvio salvo en el direcc.
83

Jos Tejada Gmez
indexado que es tan complejo que requiere una llamada a una funcin para cargar el
operando. Sobre este tema volveremos un poco ms adelante.
Tras resolver el modo de carga del operando se realiza la operacin en s. La arroba se
ha sustituido por un expresin cuyo resultado es el operando, est marcada en azul en
el cuadro superior.
Queda por decidir como se vern afectados las banderas. Aqu se ha empleado un
truco muy eficiente que no siempre es vlido. Coincide que el 8086 modifica las
banderas como el 6809 tras esta instruccin luego sera ideal utilizar el mecanismo
interno del 8086 para realizar esa tarea. Esto se consigue cargando el registro de
banderas del 6809 (CCF) en el del 8086, ejecutando la instruccin y copiando las
banderas resultantes del 8086 en el 6809. Este esquema es muy eficiente y compacto
pero exige que las banderas afectadas y los criterios para modificarlas sean las mismas
en los dos procesadores.
La directiva .align 4 que encabeza cada funcin indica al ensamblador que escoja un
mltiplo de 32 para la posicin en memoria de estas funciones, esto acelera el salto a
ellas en procesadores de 32 dgitos.
Como vemos la ventaja de usar el compilador es evidente, a partir de una sola lnea ha
generado un cdigo pulcro, eficiente y sin errores. El desarrollo del compilador lleva
un poco de tiempo, pero mucho menor que el que llevara la codificacin de todas estas
instrucciones a mano. El ahorro es mximo si se considera que la depuracin necesaria
es mnima.
Ficheros que componen el emulador del 6809

Ya hemos descrito la estrategia seguida para emular el procesador, ahora vamos a
explicar qu ficheros son necesarios para ensamblar el programa, cmo se generan y su
contenido. Estos archivos son los utilizados en los emuladores Mapefer3 y Grytra.
En total se programaron ocho compiladores y generadores de cdigo:
Nombre
crea
EXG
TFR
Index
Pshs, Pshu
Puls, Pulu
Descripcin
Es el compilador del fichero gnesis descrito
anteriormente
Genera el cdigo de la operacin de intercambio
EXG
dem con la instruccin de transferencia, TFR
Genera el cdigo del direccionamiento indexado
dem de la instruccin de apilar con el registro S o
con el U
dem de la instruccin de desempilar con el
registro S o con el U
Ficheros resultantes
6809.s
ops.s
rellena.s
Exg.s, exg.re
Tfr.s, tfr.re
Index.s, index.re
Pshs.s, pshs.re
pshu.s, pshu.re
Puls.s, puls.re
Pulu.s, pulu.re
84

Jos Tejada Gmez
El nico compilador es crea puesto que interpreta el contenido de un fichero (crea.gen) y
genera a partir de l otros. Los restantes programas son especficos para un problema y
no leen ningn dato externo.
Los generadores (Exg, Tfr, Index, etc.) escriben cdigo para una sola funcin. No vamos
a detallar cada caso, puesto que son mimos unos de otros, explicaremos slo dos
ejemplos: El programa Exg y el programa Index
Programacin de la funcin Exg (intercambio de registros)
La funcin exg del 6809 intercambia el contenido de dos registros. Se compone de dos
octetos: el cdigo de operacin 1Eh y un octeto que indica que dos registros se
intercambian. Pese a que la instruccin es conceptualmente muy sencilla su emulacin
de forma eficiente es complicada. El problema reside en que para saber qu hacer hay
que descifrar el operando y eso implica varios saltos condicionados; como ya se sabe,
los saltos son lentos puesto que pueden forzar la limpieza de la memoria cach del
procesador y, por tanto, interrumpir el flujo natural de instrucciones. Este argumento
genrico no siempre est justificado puesto que si la cach es suficientemente grande el
salto no es tan grave. Aun omitiendo el problema de la cach existe otra razn: en los
procesadores con unidades de descodificacin paralelas la cola de instrucciones ha de
borrarse en caso de saltos. Una vez ms el argumento es discutible, puesto que los
procesadores que disponen de anticipacin de instrucciones son capaces de prevenir
esta situacin y actuar en consecuencia. La nica forma de llegar a un acuerdo es
delimitar el problema a un procesador concreto: el 80386. El emulador mapefer3 se
desarroll teniendo como objetivo que fuera jugable en un 386DX a 40MHz, para ese
procesador en concreto merece la pena programar la funcin EXG no en base a varios
saltos condicionados sino como un pilago de rutinas distintas para cada caso posible.
El cdigo de la funcin EXG queda descompuesto, por tanto, en rutinas como la que se
muestra a continuacin:
.align 4
_exgA8:
xchgb %bh,_cc
ret #finito
.align 4
_exgA9:
xchgb %bl,_cc
ret #finito
.align 4
_exgAB:
movb _dp,%al
movb _cc,%ah
movb %al,_cc
movb %ah,_dp
ret #finito
donde el nombre se compone del prefijo _exg seguido del cdigo del operando en
hexadecimal.
Cuando el procesador encuentra una operacin EXG salta en primer lugar al siguiente
cdigo en ensamblador (extrado de 6809.s):
85

Jos Tejada Gmez
.align 4
_exg:
xor %eax,%eax
lea
_exgTabla,%ecx
incw %si
jmp
(%ecx,%eax,4)
#salta a la instruccin apropiada
Desde aqu se realiza un nuevo salto en base al operando que se utiliza como ndice de
la tabla de punteros _exgTabla. Ntese que no se realiza una llamada a subrutina sino
un salto incondicional jmp, de esta forma la orden de retorno sita al final de cada rutina
_exgXX volver no a esta rutina si no a la que llam a sta. El resultado: el procesador
evita la ejecucin de una instruccin ret adicional y un posible borrado de cach. Esta
idea y otras similares se han usado hasta el agotamiento en todo el emulador.
Los restantes programas: TFR, y los cuatro relacionados con la pila PSHU/S, PULU/S;
generan ficheros similares a ste y se basan en la misma optimizacin de cambiar
espacio en memoria por velocidad de ejecucin.
El direccionamiento indexado
Como ya se vi cuando se explicaron los modos de direccionamiento, bajo la
denominacin de direccionamiento indexado se esconden muchsimos casos distintos y
la lgica aplicable a EXG tiene validez aqu tambin: en lugar de analizar el operando
cada vez, es ms rpido tener rutinas separadas para ocasin. El fichero ensamblador
generado por este programa contiene ms de 1500 lneas de cdigo y desmenuza
absolutamente este modo de direccionamiento.
Vamos a mostrar someramente el programa en C encargado de generar ese cdigo
ensamblador. La funcin main es sencillamente un bucle que evala los 256 posibles
casos y segn cada uno invoca a una funcin encargada de escribir esa operacin
concreta.
void main()
{
/
for( con=0; con<=255; con++ ) {
modo = con; /* lo convertimos a 8-dgitos */
if ( (modo&0x80)==0 ) desp5();
else
switch( modo & 0xf ) {
case 0: post1(); break;
case 1: post2(); break;
case 2: pre1(); break;
case 3: pre2(); break;
case 4: solo_reg(); break;
case 5: accB();
break;
case 6: accA();
break;
case 8: desp8();
break;
case 9: desp16();
break;
case 11:accD();
break;
case 12:pc8();
break;
case 13:pc16();
break;
case 15:extI();
break;
}}}
86

Jos Tejada Gmez
Cada una de las funciones est muy basada en el uso de macros, tanto en C como en
ensamblador:
void desp8()
{
ALIGN;
registro();
if ( modo & 0x10 ) fprintf(s,"_desp8%s_I:\n",reg );
else fprintf(s,"_desp8%s:\n",reg );
carga_registro2();
carga_i8();
fputs("\taddw %cx,%ax\n",s);
if ( modo & 0x10 )
{
indirecto();
fprintf(r,"RELLENA _desp8%s_I,0x%X\n",reg,modo );
}
else fprintf(r,"RELLENA _desp8%s,0x%X\n",reg,modo );
FIN;
}
Por ejemplo, la macro ALIGN est definida como

#define ALIGN fputs("\t.align 4\n",s)
y es la responsible de que todas las funciones comiencen en direcciones de memoria

mltiplos de 32.
El cdigo generado invoca a la macro RELLENA, definida como:
.macro RELLENA nombre,codigo
lea
\nombre,%eax
movl
%eax,\codigo*4(%ebx)
.endm
Esta macro se utiliza en ensamblador para rellenar las tablas con las direcciones de las
funciones. Todos los generadores crean ficheros con extenin re cuyo contenido son
invocaciones a esta macro, por ejemplo la anterior funcin en C genera entradas como:
RELLENA _desp8_y_I,0xB8
Que van rellenando la tabla de punteros elemento a elemento. En la rutina Inicia6809,

escrita en ensamblador, se ejecuta cada uno de estos ficheros rellenantes cargando
previamente la direccin de la tabla a completar en el registro ebx.
lea
_exgTabla,%ebx
.include "exg.re"
87

Jos Tejada Gmez
Registros y variables del emulador

En el fichero principal, 6809.s, hay un conjunto de variables definidas directamente en
ensamblador y que son una componente esencial del simulador. Dado que su nmero
es escaso y su importancia grande las comentaremos en esta seccin.
.data
.align 4
_ram:.globl _ram
.long 0
.align 4
contador:
.long 0
.align 4
msj_ilegal: .string "Op ilegal = %X\n"
#registro de concidiciones
.align 4
CCF: .long 0
#registros
.align 4
_pc: .word 0
.align 4
_x : .word 0
.align 4
_y : .word 0
.align 4
_u : .word 0
.align 4
_s : .word 0
.align 4
_dp: .byte 0
.align 4
_cc: .byte 0
.align 4
_b : .byte 0
.align 4
_a : .byte 0
.global _pc
.global _x
.global _y
.global _u
.global _s
.global _dp
.global _cc
.global _b
.global _a
Especifica que comienza un segmento de

datos.
ram es un puntero a los 64koct de memoria
virtual.
contador se utiliza para llevar la cuenta de las
instrucciones.
msj_ilegal sirve para indicar la alarma cuando

no se reconoce un cdigo OP.
A continuacin van los registros del 6809,
pese a que algunos ocupan slo un octeto,
todos ellos estn colocados en posiciones de
memoria mltiplos de 32 (.align 4) para que
sea ms rpido el acceso a los mismos.
Las directivas .global permiten que el

enlazador comparta estos smbolos con el
resto de mdulos a enlazar.
Variables usadas por el emulador del 6809
88

Jos Tejada Gmez
La funcin Ejecuta
Esta es la funcin que une al emulador del procesador con el resto del programa. ste
dir ejecuta(10) y diez instrucciones sern simuladas. Algunos registros del 6809 se
colocan en el interior del x86 para acelerar la emulacin, a esto lo llamaremos registro
emulado internamente, estos son:
Registro 6809
A
B
PC + puntero a la RAM
Operando
Puntero a la RAM
Registro x86
Bh
Bl
ESI
AX
EBP
Adems el registro de banderas tambin se emula internamente, siguiendo el

procedimiento detallado en la siguiente seccin.
.align 4
_ejecuta:.globl _ejecuta
pushl %esi
pushl %edi
pushl %ebp
movl
movl
movb
movb
movl
xor
movw
Apila los registros que se modificarn
16(%esp),%eax
%eax,contador
_a,%bh
_b,%bl
_ram,%ebp
%esi,%esi
_pc,%si
otra_instruccion:
xor %eax,%eax
lea
_ops,%ecx
inc %si
call
(%ecx,%eax,4)
decl
contador
jnz
otra_instruccion
movb
movb
movw
%bh,_a
%bl,_b
%si,_pc
Nmero de instrucciones a emular

Registros del 6809 simulados internamente
Carga el cdigo de la instruccin. El registro

ecx contiene la tabla de cdigos de operacin
Invoca a la rutina encargada de su gestin
Salva los registros emulados internamente
Restaura los registros originales y devuelve el
control
popl %ebp
popl %edi
popl %esi
ret
Cdigo fuente de la funcin ejecuta
En esta rutina se puede apreciar la sencillez obtenida gracias al esquema de tablas de

punteros. La descodificacin de la instruccin no es ms que leer el valor de una tabla e
invocar a la rutina que ese valor indica.
89

Jos Tejada Gmez
Emulacin interna del registro de banderas

Todos los procesadores tienen un registro destinado a anotar el resultado de las
ltimas operaciones. En el 6809 las situaciones que se registran son:
Semiacarreo (H): Indica que se ha producido acarreo desde el cuarteto inferior

de A al cuarteto superior.
Acarreo (C): Al realizar una operacin aritmtica de ocho dgitos, el resultado
excedi la capacidad del registro destino por un dgito, ese dgito se deja
almacenado en el registro C.
Desbordamiento (V): Las multiplicaciones o divisiones pueden exceder
totalmente la capacidad de los registros. En ese caso se activa el dgito de
desbordamiento.
Cero (Z): Si el resultado de la operacin ha sido nulo, se activa el dgito de cero.
Negativo (N): dem si el resultado fue negativo.
Cada instruccin del 6809 afecta a todos, algunos o ninguno de estos indicadores. Por
ejemplo la instruccin daa (ajuste decimal, utilizada con nmeros codificados en BCD)
no altera ninguna de las banderas pero la instruccin asl (desplazamiento a la
izquierda) las modifica todas.
Evaluar cada condicin posible al final de cada instruccin es simultneamente un
engorro de programar, una fuente de errores y una considerable prdida de tiempo de
proceso. Si la capacidad para realizar esta comprobacin est ya imbuida en el
procesador x86 por qu no utilizarla? Nada ms ejecutar una instruccin el x86
modifica sus propias banderas en funcin del resultado as que parecera que no hay
ms que copiar su valor a la variable que simula el registro del 6809; sin embargo hay
que tomar algunas precauciones:
1. Muchas instrucciones no slo modifican las banderas sino que requieren de su
valor para operar correctamente.
2. No todas las rdenes del 6809 afectan los mismos dgitos que sus homnimas
del x86, en algunos casos no hay ninguna correspondencia. Estas excepciones
son muy peligrosas.
3. El tamao del registro del 6809 es de un octeto, el del x86 de cuatro. Esto se
soluciona realizando una conversin cuando alguna orden lo requiere.
La 2 cuestin no es en s muy grave, entraa el riesgo de poder causar errores debidos
a despistes, pero teniendo claros los diferentes casos basta hacer un cdigo especfico
para las pocas ocasiones en que esto ocurre. Una de estas instrucciones es la de carga
del acumulador (lda), en el 6809 modifica las banderas N,Z y V; sin embargo en el x86
no afecta absolutamente a ninguna. Esto puede solucionarse fcilmente aadiendo una
suma tras la carga: qu valor sumar? Ninguno:
movb
addb
-1(%ebp,%esi),%bh
$0,%bh
De esta forma se fuerza una modificacin del registro de banderas del x86.
Lamentablemente addb tambin cambia el dgito de acarreo y para evitar su
modificacin en el 6809 es necesario filtrar el resultado con operaciones lgicas and y or.
90

Jos Tejada Gmez
El mecanismo que se sigue para emular internamente el registro de banderas consisten
en cargar si la instruccin as lo requiriese- el registro de banderas virtual del 6809 en
el real del x86, ejecutar la operacin y copiar el registro real del x86 al virtual del 6809.
Dado que los procesadores Intel no disponen de instrucciones para manipular el
registro de banderas directamente, su copia hay que hacerla a travs de la pila. A
continuacin se muestra cmo se realiza este proceso en la rden ADCA (suma con
acarreo)
pushl CCF
popfl
#cdigo singular
#final
pushfl
popl
CCF
Se copia el CCF (6809) al registro del x86

Se ejecuta la suma con acarreo
Se copia el registro del x86 a la variable CCF
(6809)
Algunas instrucciones del 6809 operan directamente con el registro de banderas,

concretamente las rdenes de apilado y desempilado. stas necesitan el registro con el
tamao verdadero: un octeto, y no la versin de 32 dgitos (la variable CCF) que hemos
manejado hasta ahora. Para convertir del registro real (llamado CC) al largo (CCF) se
utiliza una pareja de funciones llamadas de_cc_a_CCF y de_CCF_a_CC.
Disparo de la interrupcin IRQ

La interrupcin irq hace falta para todos los juegos, puesto que el retrazado vertical del
monitor de la mquina la provocaba. Al ser un cdigo sencillo y directo est
programada en C, cabe destacar que en esta ocasin es necesaria la conversin de la
variable CCF (de 32 dgitos) al formato corto (variable CC, un octeto) para apilarla.
void irq()
{
if ( (cc & CC_I )== 0)
{
METES16( pc );
METES16( u );
METES16( y );
METES16( x );
METES8( dp );
METES8( b );
METES8( a );
cc |= CC_E;
de_CCF_a_cc();
METES8( cc );
cc |= CC_I;
pc = LEE16( 0xfff8 );
}
}
Apila todos los registros del 6809
Convierte el registro de banderas CCF al

formato corto y lo apila
El puntero de programa se carga con el
vector de interrupcin
91

Jos Tejada Gmez
El emulador del 6809 de Larry Bank

Para el Escuela de combate se utiliz un emulador diferente programado por Larry Bank.
ste tena la ventaja de ser compatible con Win32 y de tener un enfoque ms genrico.
Su principal inconveniente es la lentitud, pese a estar escrito en ensamblador, es ms
rpido que la mayora de emuladores del 6809 disponibles, pero ms lento que el
enfoque discutido anteriormente.
Para utilizar este emulador hay que enlazar el cdigo objeto A6809.obj y definir la
funcin TRACE6809 en el programa principal de C. Esta funcin slo se utilizar si
quisiramos depurar el programa; si no, basta definirla vaca:
TRACE6809()
{
return 0;
}
El emulador se arranca invocando a la funcin ARESET6809 que precisa de un puntero

al mapa de memoria del 6809 y otro a la estructura de registros:
ARESET6809(pMem6809, &regs6809 );
El mapa de memoria es una regin de 3x64 kilo octetos, cada parte de 64koct contiene
un tipo de informacin: la primera tiene la ROM de la mquina, la segunda la RAM y
la ltima un mapa sobre cmo interpretar cada octeto: un cero indica RAM; un uno,
ROM; y cualquier nmero mayor que dos implica que para acceder a esa posicin hay
que hacer una llamada a una funcin definida por el usuario. Una determinada
estructura contiene los punteros a estas funciones en un orden tal que segn sea el
valor escrito en el mapa de memoria se llamar a una u otra. En Escuela de combate esta
estructura se inicia de la siguiente forma:
static EMUHANDLERS emuh[3] ={
LeePagina,EscribePagina,
LeeVideo,EscribeVideo,
Lee500,Escribe500 };
Luego el mapa de memoria se modifica como en este ejemplo:

pMem6809[ MEM_FLAGS + 0x500 ] = 4; // registro de selecciones
Esto significa que si se accediese a la posicin 500h, el emulador ejecutar las funciones
que ocupen la tercera posicin (4-1=3) de la estructura; en este caso, las funciones:
Lee500 y Escribe500.
Durante el desarrollo de Escuela de combate, el emulador de Larry Blank demostr ser
un programa rpido, estable y fiable; no se encontr ningn error de programacin ni
comportamiento anmalo durante todo el proceso.
92

Jos Tejada Gmez
La sincrona
Los mquinas de videojuegos no disponan normalmente de reloj interno. El
mecanismo empleado para medir el tiempo consista en contar el nmero de
sincronismos verticales de la imagen. Como cada uno produca una interrupcin,
sabiendo la frecuencia de los mismos y el nmero de interrupciones que haba pasado
se saba el paso del tiempo con suficiente exactitud. El caso ms habitual era el de
monitores a 60 Hz, lo que implica sesenta interrupciones por segundo.
Cuando se emula el juego no se puede tener un control preciso sobre el tiempo pero
tampoco es necesario. Pese a que se sepa exactamente cunto tardara una determinada
instruccin en ejecutarse en el procesador, no tiene utilidad el emularla justo en ese
tiempo. Lo nico que percibe el usuario son las imgenes del juego y la msica del
mismo, slo en estos dos apartados la sincrona es importante.
Nuestra preocupacin es, por lo tanto, dibujar imgenes cada sesentavo de segundo.
Sin embargo esto implica una primera preocupacin: cuntas instrucciones hay que
ejecutar entre pantalla y pantalla? Si llevsemos a cabo una cuenta exhaustiva de los
ciclos de reloj acaecidos en el procesador podramos replantear la pregunta a cuntos
ciclos de reloj han de pasar entre pantalla y pantalla? La respuesta entonces sera
inmediata: el producto de la frecuencia de reloj por el intervalo entre imgenes, as
para un procesador a 1 MHz operando con una pantalla a 60 Hz deberamos de
ejecutar 16,666 ciclos. Este enfoque, aunque riguroso, es poco prctico pues implica
aadir cdigo adicional a la emulacin del procesador que enlentecera la operacin.
Una solucin aproximada es tomar la media de ciclos por instruccin como medida
para ejecutar no un nmero de ciclos sino de instrucciones: por ejemplo, el 6809 tiene
una ejecucin media de una instruccin por cada dos ciclos, luego el intervalo
propuesto es aproximadamente equivalente a 33,333 ciclos.
Lamentablemente la solucin anterior no funciona a la perfeccin produciendo
situaciones en las que el emulador dispara una interrupcin antes de cuenta,
provocando un funcionamiento anmalo que causa retardos en la animacin. La forma
de solventar este problema es operar con exceso: Cuando el bucle del videojuego llega
a la fase de espera no importa cuntas instrucciones se ejecuten, puesto que la accin ya
no avanzar hasta que se dispare una interrupcin.
La solucin final es por tanto, emular entre imgenes un nmero de instrucciones
superior (en torno a un 10%) al nmero de instrucciones ejecutables durante ese tiempo,
basado en el promedio de ciclos por operacin.
Desde un punto de vista bsico: una vez ejecutadas las IPI 33 correspondientes, el
emulador dibuja la pantalla y lee la entrada del teclado; acto seguido el bucle vuelve a
empezar. De ser as, sin embargo, en un ordenador moderno el juego se desplazara a
tal velocidad que sera injugable; y en un equipo lento la accin se vera retardada. Es
necesario incluir un mecanismo de ajuste de la velocidad para no pecar ni por exceso ni
por defecto. En las prximas secciones se estudian los dos mecanismos bsicos de
sincrona.
33
IPI: Instrucciones Por Imagen
93

Jos Tejada Gmez
Sincronizacin mediante promediado de imgenes

Este mecanismo de sincronizacin se basa en contar cuntas imgenes se han dibujado
ya y cuntas deberan haberse dibujado. Para realizarlo se programa una funcin
temporizada que se ejecute cada sesentavo de segundo y que se encargue de
incrementar un contador al que llamaremos IPS34 ideal. Durante la ejecucin del bucle
de emulacin, se incrementar una variable a la que llamaremos IPS real, de esta forma
podremos comparar si el programa va ms rpido o ms lento de lo necesario.
En caso de que el emulador no sea capaz de mantener una tasa de IPS reales semejante
a las ideales ser sntoma de que el equipo en el que se est ejecutando el programa no
es suficientemente rpido para esta labor. Existe, sin embargo, una sencilla forma de
acelerar la emulacin en detrimento de la suavidad de las animaciones: consiste en
cancelar el dibujado de algunas de las sesenta imgenes a procesar por segundo. La
cifra de 60 Hz no surge de la necesidad de tener animaciones fluidas, sino para evitar
que el ojo perciba parpadeo. La mquina original deba dibujar a un ritmo de 60 Hz
para mantener el refresco de la pantalla, pero en el ordenador la circuitera grfica ya
se encarga de que no haya parpadeo aunque la imagen presente sea siempre la misma.
Podemos, por tanto, reducir las IPS mostradas hasta dgitos tan bajas como 30 IPS sin
que la calidad del juego se vea notablemente afectada. El no dibujar la imagen no
implica no calcularla, la emulacin de las IPI instrucciones hay que realizarla siempre o
el juego se enlentecer; el ahorro temporal proviene de evitar transformar la memoria
de vdeo de la mquina emulada en imgenes visibles por el ordenador, el ritmo de
emulacin del procesador hay que mantenerlo siempre.
Existen circunstancias en las que este recorte de imgenes ser obvio para el jugador:
tradicionalmente el estado de invulnerabilidad35 del jugador se ha marcado mediante un
parpadeo del mismo y la forma ms sencilla de conseguir ste efecto es no dibujar al
jugador en las imgenes pares (o nones) y hacerlo en las nones (o pares). Supongamos
que el mecanismo de promediado de imgenes saltndose una de cada dos imgenes
para poder alcanzar la meta de emular el procesador al 100% de velocidad; ocurrir
entonces que el personaje se dejar de ver completamente durante el tiempo de
invulnerabilidad o se ver siempre (sin notarse el parpadeo), segn haya coincidido el
pintado del personaje por parte del videojuego con el dibujado de la pantalla por parte
del programa. Las tasas de dibujado que no sean potencias de dos (como por ejemplo,
dibujar dos de cada tres imgenes) evitan este problema.
Puede ocurrir el caso contrario: el ordenador es tan rpido que las IPS reales exceden a
las ideales. En tal circunstancia el promediado de imgenes producir un videojuego
acelerado ya que nada impide que se emule y procese un segundo de tiempo virtual en
menos de un segundo real; el aumento de velocidad puede hacer el juego injugable. La
forma ms sencilla y efectiva de evitar este problema es utilizar el sincronismo vertical
del ordenador. Al igual que la mquina recreativa, el ordenador consta de un monitor
Imgenes Por Segundo
La invulnerabilidad hace referencia a un estado en el que el hroe del videojuego no puede
morir, generalmente este es el estado inicial tras perder una vida, recibir un golpe o empezar un
nivel. La invulnerabilidad dura habitualmente unos tres segundos, pasados los cuales el
jugador vuelve a ser mortal.
34
35
94

Jos Tejada Gmez
que ha de refrescarse peridicamente; desde el programa podemos saber cundo se
produce dicho refresco. El procedimiento de sincrona consiste en, una vez emuladas
las IPI instrucciones y dibujada la pantalla, esperar a la llegada del refresco antes de
iniciar un nuevo ciclo del bucle de emulacin. En un procesador suficientemente
rpido como para acabar a tiempo siempre, este mecanismo produce la emulacin ms
fluida posible; sin embargo si el ordenador se retrasa a veces36 puede ocurrir que llegue
al punto de espera nada ms ocurrir el refresco y tenga que esperar 17ms hasta el
siguiente. Cuando eso pasa, el retardo es evidente y produce una animacin brusca.
El siguiente extracto de cdigo, procedente de mapefer337 muestra cmo se realiza el
sincronismo por promediado de imgenes.
En primer lugar se crea una funcin temporizada:
void temporizador()
{
ips_ideal++;
}
Esta funcin se ejecutar sesenta veces por segundo automticamente, el sistema
operativo se encargar de ello. Durante el bucle de la emulacin se ejecuta
simplificadamente- lo siguiente:
for(;;)
{
ejecuta( ipi );
irq();
if ( ips_real > ips_ideal )
dibuja_pantalla( ant_munecos );
if ( ips_ideal >= 59 )
{
ips_ideal=0;
ips_real = 0;
}
ips_real++;
}
La pantalla se dibuja nicamente si el emulador va ms rpido de lo necesario, sin

embargo la instrucciones se simulan siempre. Dentro de la funcin dibuja_pantalla se
encuentra la espera de la seal de refresco.
Cuando el contador de IPS ideales sobrepasa el valor 60 se reinicia a cero, sta
operacin es necesaria porque da la oportunidad a ips_real de pillar a ips_ideal por lo
menos una vez por segundo y elimina el retardo acumulado; sin esta puesta a cero, en
un ordenador lento se podra llegar a tal desfase entre las dos variables que nunca se
dibujase ninguna imagen.
Al final del bucle el contador de IPS reales se incrementa.
36 No todos los ciclos son iguales. Las rutinas de optimizacin del vdeo son las mximas
responsables de que unos ciclos sean ms lentos o rpidos que otros.
37 El emulador de G&G
95

Jos Tejada Gmez
Sincronizacin cronometrada
Cuando el equipo emulante es suficientemente rpido se hace necesario buscar una
forma eficaz de sincronizar el proceso de emulacin y pintado de imgenes. Por una
parte, al sobrar tiempo entre uno y otro fotograma, sera recomendable desocupar el
procesador para que el sistema operativo d ese lapso a otros procesos. Por otra parte,
los monitores actuales suelen operar con refrescos muy superiores a 70Hz lo que
ocasiona que la tcnica de sincrona con el retrazado del monitor no funcione;
necesitamos un mecanismo vlido para frecuencias de la pantalla emulada distintas de
la emulante.
El mtodo de sincronizacin cronometrada se basa en cronometrar lo que se tarde en
emular el procesador y dibujar la pantalla para esperar despus hasta que se cumple
un perodo38. Llegado ese momento el ciclo vuelve a empezar.
ciclo de emulacin cronometrado
En el grfico superior se ejemplifica esta situacin. Se supone que la emulacin del

procesador tarda 3ms; es decir, que en 3ms reales pasan ~20ms (50Hz) virtuales; a
continuacin en 2,5ms se interpreta la memoria de vdeo y se pinta en la pantalla real la
imagen. Han transcurrido realmente 5,5ms pero en el sistema emulado ya han pasado
20ms, es necesario esperar sin hacer nada hasta que lleguen realmente esos 20ms.
Siguiendo el mismo ejemplo, si se le devuelve el control al sistema operativo durante
los 14,5 ms restantes eso significara que el emulador est ocupando el ordenador un
5,5
100 = 27,5% y el restante 72,5% queda libre para otras tareas.
20
En el caso de que se emulase una mquina a 50 o 70 Hz bastara con cambiar el tiempo
lmite de espera de 16,6ms a 20ms o 14,3ms. Conceptualmente este mtodo es muy
sencillo pero a la hora de realizarlo puede ser laborioso segn la plataforma de
desarrollo ya que el sistema operativo provee habitualmente de medidas del tiempo en
unidades de un milisegundo.
Para el caso de Windows hay un juego de funciones pensadas para aplicaciones
multimedia entre las que se incluyen algunas para sincronizacin precisa.
38
inversa de la frecuencia de refresco. Para 60Hz el perodo de emulacin es de 16.6 ms
96

Jos Tejada Gmez
La emulacin del sonido

Pese a que la emulacin de los circuitos sonoros no se realiz como parte del proyecto,
vamos a disertar en esta seccin sobre cmo acometerla.
La problemtica de la emulacin sonora reside en la sincronizacin: del procesador del
juego con el del sonido, de ste con el circuito sonoro y del circuito sonoro emulado
con el del ordenador. La idea de fondo es sintetizar una onda en la memoria del
ordenador con la salida que generara el circuito emulado y mandarla al convertidor de
digital a analgico del ordenador. Este esquema presenta una serie de retos, todos ellos
relacionados con el tiempo: En la realidad, el procesador principal puede mandar en
cualquier instante una orden al procesador de sonido para solicitar que una
determinada meloda o efecto se reproduzca; ste a su vez transformar esa peticin en
una cadena de rdenes (notas musicales codificadas) que enviar al circuito sonoro que
a su vez generar una seal binaria con la msica en formato digital, sta ser
convertida a una seal analgica audible por el convertidor. Cada una de estas
operaciones se desarrollan en pasos discretos de longitud mnima igual al perodo del
procesador ms lento, podemos suponer que ese tiempo es de 1s (el ms lento
funcionara a 1MHz).
Para realizar la emulacin es necesario simular primero el procesador principal, acto
seguido el sonoro, posteriormente el circuito de sonido y para acabar, enviar la seal al
convertidor de digital a analgico del ordenador. Todos estos pasos no pueden
realizarse en incrementos de 1s, puesto que supondra una sobrecarga (debida a
llamadas y retornos de funciones y a operaciones lentas, como la conversin) que
entorpecera toda la emulacin. Adems, incluso si pudiera efectuarse todo lo anterior
a la celeridad adecuada; el sonido no es algo que se lance sin ms, cada fragmento de
1s hay que hilarlo convenientemente con el siguiente, si no el resultado es cacofnico.
En la prctica basta escoger un perodo de tiempo suficientemente largo como para
facilitar la unin de un intervalo con el siguiente, sin que esto requiera una
sincronizacin demasiado sensible. Lo habitual es trabajar con perodos del orden de
decenas de milisegundos. Un criterio para escoger el perodo exacto puede ser tomar
un mltiplo del perodo de refresco del monitor, para poder as entremezclar
adecuadamente las emulaciones de todas las partes del sistema. Con un monitor a
60Hz, esta cifra estara en torno a los 16ms.
Si la comunicacin de los dispositivos es unidireccional: es decir, el procesador
principal puede hablarle al sonoro, y ste no puede responder; no es necesario
intercalar ciclos de emulacin cortos de un procesador y otro, sino que basta con
almacenar las rdenes que el procesador principal mand en una pila e ir
introducindoselas adecuadamente al procesador de sonido emulado. El mismo
principio puede aplicarse con aquellos circuitos sonoros que no enven seales al
procesador director.
97

Jos Tejada Gmez
Descripciones tcnicas detalladas de las mquinas

emuladas
Ghosts & Goblins
Procesador
Cometido
Frecuencia (MHz)
6809
Z80
YM2203 (dos)
Juego
Sonido
Sonido
1.5
3
Memoria
ROM (koct)
32
Volcados de las memorias ROM:

Nombre
GG1
GG2
GG3
GG4
Tamao
(koct)
16
32
32
16
GG5
GG6
GG7
GG8
GG9
GG10
GG11
GG12
GG13
GG14
GG15
GG16
GG17
32
16
16
16
16
16
16
16
16
16
16
16
16
Descripcin
Caracteres
Memoria de sonido (Z80)
Memoria sin paginar del juego (6809)
Los primeros ocho kilo octetos son
memoria paginada del 6809, los
siguientes ocho kilo octetos no se
paginan.
Memoria paginada del 6809
Juegos 3 y 4 del fondo
Animaciones
Animaciones
Animaciones
Animaciones
Animaciones
Animaciones
98

Jos Tejada Gmez
Paginacin y mapa de memoria

Existen cinco pginas de 8 koct que se eligen a travs de un registro direccionado en la
posicin 3E00h. El cdigo que define los punteros en el emulador es:
paginas[0]=rom39[4];
paginas[1]=rom[4]+8*1024;
paginas[2]=rom[4]+8*1024*2;
paginas[3]=rom[4]+8*1024*3;
paginas[4]=rom[3];
Posicin
(hexadecimal)
0000-1DFF
1E00-1F80
2000-23FF
2400-27FF
2800-2BFF
2C00-2FFF
3000
3002
3800-39FF
3A00
3B08
3B09
3B0A
3B0B
3C00
3E00
4000
6000
8000
Descripcin
ROM asociada
Memoria RAM, 7679 octetos

Animaciones, 384 oct.
Objetos, 1 koct.
Atributos de los objetos, 1koct
Fondos, 1 koct
Atributos de los fondos, 1koct
Registro de entrada de monedas
Registro de la palanca
Paleta grfica
comunicacin con el Z80
Desplace del fondo horizontal
Desplace del fondo horizontal, dgito
mayor
Desplace del fondo vertical
Desplace del fondo vertical, dgito mayor
Registro de autoarranque
Registro de paginacin
Programa paginado
GG4 y GG5
ltimos 8ko
Programa sin paginar
GG4
Programa sin paginar
GG3
de
Los registros se activan a nivel bajo:

Descripcin
3000,
monedas
3002,
palanca
3003,
DIP 2 A
3004,
DIP 1 A
39
Dgito 7
2
moneda,
100 ptas.
Dgito 6
1
moneda,
25 ptas.
Dgito 5 Dgito 4
Salto
Disparo
Dgito 3
Arriba
Dgito 2 Dgito 1
Comienzo
del 2
jugador
Abajo
Izquierda
Dgito 0
Comienzo
del 1er
jugador
Derecha
ver la seccin de los microinterruptores
Como en C los ndices de los vectores empiezan desde cero, rom[4] apunta a gg5
99

Jos Tejada Gmez
Ya en el espacio de memoria del Z8040, el registro de comunicacin con la UCP de
sonido est en la direccin C800. Hay dos circuitos sonoros YM-2203 cuyos registros
ocupan las posiciones desde E000 hasta E003, inclusive.
Codificacin de los grficos en las memorias ROM

Los caracteres se componen de bloques de 8x8 puntos con dos dgitos por punto,
permitiendo, por tanto, cuatro colores distintos y ocupando 16 octetos. En total hay 512
caracteres cuyo formato en la ROM es:
Octeto n
Octeto n+1
er
1 cuarteto
2 cuarteto
1er cuarteto
2 cuarteto
Puntos del 1 al 4, Puntos del 1 al 4, Puntos del 5 al 8, Puntos del 5 al 8,
primer plano
segundo plano
primer plano
segundo plano
Esto se repite ocho veces, una por cada lnea del carcter, al adaptar estos grficos a los
requisitos grficos de un PC hay que poner cada punto con sus dos planos en un nico
octeto; pasando a ocupar entonces 8*8=64 octetos cada carcter.
Existen cuatro juegos de bloques para formar los fondos del juego, cada uno
compuesto por 256 bloques de 16 por 16 puntos y tres dgitos por punto, lo que
permite ocho colores. Estos cuadrados estn almacenados como rectngulos de 8x16 en
la ROM, durante la descodificacin se reorganizan los datos en cuadrados de 16x16
octetos. Como slo se usan tres dgitos por punto, los cinco dgitos superiores de cada
octeto estn sin utilizar; ms adelante se aprovecharn para incorporar sobre ellos la
paleta grfica.
Para las animaciones (u objetos) existen tres juegos de 256 bloques de 16x16 puntos
cada uno. Los objetos tiene cuatro dgitos por punto, lo que contabiliza 16 posibles
colores. La organizacin en memoria es totalmente lineal, ocupando cada bloque
16x16x2 dgitos seguidos en una ROM (dos planos) y otros 16x16x2 en otra ROM (los
restantes dos planos). Cuando se decodifican en el emulador se reorganizan para
ocupar 16x16 octetos, en cada octeto slo se usa el cuarteto inferior.
40
procesador responsable del sonido
100

Jos Tejada Gmez
Funcionamiento del circuito grfico

La circuitera grfica de G&G permite representar un fondo compuesto por bloques de
16x16 puntos que encajan como un mosaico, un nmero limitado de objetos sobre
cualquier regin del fondo y por encima de todo esto; un nuevo mosaico compuesto
por caracteres que servirn para dar informacin sobre la puntuacin y desarrollo del
juego.
Los caracteres no requieren registros de desplace pues se proyectan directamente sobre
la pantalla. Adems del octeto que indica el nmero del carcter a pintar hay otro
adicional, de atributos cuyo contenido es:
Formato de los octetos de atributos de los caracteres
5
4
3
2
1
pgina
sin uso
paleta
sin uso conocido
de ROM conocido
7
Con el dgito quinto puede seleccionarse cualquiera de las dos pginas disponibles, de
256 bloques cada una. Hay diecisis paletas de cuatro colores disponibles para los
caracteres.
Tanto los cdigos de los fondos como sus atributos se componen de cuatro pantallas
que se cierran sobre s mismas cuando se proyectan a travs de la ventana virtual del
juego. Es decir, es el funcionamiento bsico descrito en la seccin de fondos.
Cuando se interpreta el contenido de los fondos hay que tener en cuenta que en esta
mquina concreta, los fondos internamente se indican con su cdigo- girados 90, por
lo que cada incremento de un octeto en la memoria de fondo no indica avanzar en las
abscisas, sino en las ordenadas.
Formato de los octetos de atributos de los fondos
5
4
3
2
1
giro
giro
pgina de ROM
prioridad
paleta
vertical horizontal
7
Los dgitos sexto y sptimo indican cul de los cuatro juegos de fondos disponibles en
las memorias ROM se seleccionarn; en total hay cuatro pginas de 256 bloques.
Cuando el tercer dgito, de prioridad, est marcado significa que el bloque de fondo se
dibuja sobre los objetos. Con los tres dgitos de menor peso pueden seleccionarse ocho
paletas, cada una de ocho colores.
Los objetos mostrables simultneamente en pantalla son 96, cada uno requiere cuatro
octetos cuyo orden es el siguiente: cdigo del objeto, atributos, abscisa y ordenada.
Formato de los octetos de atributos de los objetos
7
6
5
4
3
2
1
0
giro
giro
sin uso
recorte
pgina de ROM
paleta
vertical horizontal conocido horizontal
101

Jos Tejada Gmez
Cuando el objeto alcanza el borde izquierdo o derecho de la pantalla el dgito cero se
activa y se combina junto con el dgito mayor de la abscisa para seleccionar dos
columnas de la pantalla donde el objeto se dibujar con el desplace indicado por los
restantes siete dgitos de las abscisas. Con los dgitos quinto y cuarto pueden
seleccionarse cuatro paletas de diecisis colores. Con los dgitos sexto y sptimo se
selecciona la pgina de ROM, en total hay tres pginas con 256 objetos cada una.
Al dibujar los objetos la prioridad est invertida: los objetos en las posiciones de
memoria mayores han de pintarse antes que los otros. Otra precaucin a tomar es que
la memoria de objetos lleva un retraso de una imagen con respecto a la de fondos, as
que para pintar cada nueva imagen hay que mezclar la informacin de fondos actual
con la previa de objetos.
Paleta
La paleta tiene un cuarteto por cada color: es decir, cuatro dgitos para el rojo, cuatro
para el azul y cuatro para el verde. En total la paleta suma doce dgitos por entrada,
por lo que hay un total de 4096 colores disponibles.
La distribucin en memoria es como sigue:
Posicin
Contenido
3800-38FF cada octeto contiene el rojo y el verde
3900-39FF Los cuartetos superiores contienen el azul, los inferiores estn a cero
Dentro de cada banda (38xx o 39xx) se encuentran las paletas de cada grupo de
grficos:
Posicin
xx00-xx3F
xx40-xx7F
xx80-xxBF
xxC0-xxFF
Contenido
paletas de fondo
paletas de objetos
paletas de caracteres
duplicado (?)
Colores
8
16
16
Paletas
8
4
4
102

Jos Tejada Gmez
Interruptores DIP
Esta mquina tena dos microinterruptores DIP que permitan configurar algunas de
las caractersticas del juego.
Uso
ninguno
dificultad
bonificacin
mueble
vidas iniciales
Accin
ninguna
fcil
normal
difcil
dificilsimo
1
X
NO NO
NO SI
SI NO
SI
SI
20.000,
70.000 y
cada 70.000
30.000,
80.000 y
cada 80.000
slo a los
20.000 y a
los 70.000
slo a los
30.000 y a
los 80.000
mesita
de pie
1
2
3
4
NO NO
NO
SI
SI
NO
SI
SI
NO
SI
NO NO
NO SI
SI NO
SI
SI
microinterruptor 1A
La bonificacin es una vida adicional y por tanto est relacionada con la dificultad del
juego. En G&G es habitual haber conseguido 20.000 puntos al terminar la primera fase
y obtener los 70.000 al llegar a la tercera fase; de esa forma el jugador obtiene una
pequea recompensa con sus progresos. Alcanzar los 140.000 puntos mnimos
necesarios para una tercera vida extra exiga un juego muy orientado a puntuar que era
a la par peligroso y aburrido.
En el segundo microinterruptor se define si la pantalla se girar vertical y
horizontalmente para el caso en que la imagen se vea a travs de un reflejo.
Hay adems un microinterruptor que permite operar el equipo en el modo de pruebas
para detectar algunos errores, esto se detallar en el apartado siguiente.
Esta mquina slo permita utilizar una de las dos entradas de monedas instaladas,
para ella se defina la relacin entre nmero de partidas y monedas deseada.
103

Jos Tejada Gmez
Uso
Accin
1
2
3
4
5
6
7
8
normal NO
pantalla
invertida SI
normal
NO
funcionamiento
de
SI
pruebas
siempre
SI
sonido
juego
NO
primero
NO
monedero a
usar
segundo
SI
1/1
NO NO NO NO
1/2
NO NO NO SI
1/3
NO NO SI NO
1/4
NO NO SI
SI
1/5
NO SI NO NO
1/6
NO SI NO SI
1/7
NO SI
SI NO
monedas
/
2/1
NO SI
SI
SI
partidas
2/2
SI NO NO NO
2/5
SI NO NO SI
3/1
SI NO SI NO
3/2
SI NO SI
SI
3/4
SI
SI NO NO
4/1
SI
SI NO SI
4/3
SI
SI
SI
SI
microinterruptor 2A
104

Jos Tejada Gmez
El modo de pruebas
modo de pruebas de G&G
Cuando el tcnico activa el modo de pruebas aparece una pantalla de informacin que
sirve para saber el estado de los microinterruptores y para hacer una pruebas mnimas.
Las tablas mostradas en el apartado anterior encuentran su correspondencia aqu y
puede verse fcilmente la correspondencia entre los interruptores y este modo.
Pese a que existen dos lneas de equivalencias entre monedas y partidas slo una de
ellas es ajustable, como se indic anteriormente. El acrnimo ATS significa ATraction
Sound y hace referencia al interruptor de sonido, su funcin es si habr o no sonidos y
msica cuando no est jugando nadie; si los hubiese, serviran para atraer clientes.
Las columnas de ceros bajos los acrnimos 1P y 2P se tornan en unos cuando la palanca
o los botones adecuados se pulsan, de esta forma se puede comprobar su
funcionamiento.
Bajo Sound Code (cdigo de sonido) se encuentra un nmero que puede cambiarse
usando derecha e izquierda, al pulsar el botn de disparo el sonido se reproduce. Esto
sirve para detectar fallos de sonido, el siguiente diagnstico puede aplicarse:
Problema
No se oye ningn sonido
Posible causa
Acciones recomendadas
Fallo grave en el -Comprobar la conexin
altavoces
sistema de audio.
de
los
-Comprobar la etapa de amplificacin

-Sustituir el Z80 por otro
-Sustituir la ROM por otra
-Sustituir el registro por otro
-Sustituir la RAM por otra
-Sustituir los generadores de FM
Los sonidos se oyen Fallo en la etapa de -Cambiar altavoz
-Cambiar el amplificador operacional
aunque con distorsin
audio analgica
-Revisar los condensadores
-Cambiar los convertidores DAC
Slo algunos sonidos se Fallo en el sistema -Cambiar el registro por otro
-Cambiar la ROM por otra
oyen
de audio digital
105

Jos Tejada Gmez
Miscelnea
La comprobacin de las memorias que hace la mquina al arrancar puede saltarse, en
la versin estadounidense de G&G, evitando la llamada a la rutina mediante la
colocacin oportuna de tres operaciones nulas nop. El cdigo del mapefer3 que realiza
esto es:
if (juego == GNG_USA) ram[0x607a] = ram[0x607b] = ram[0x607c] = 0x12; /*nop*/
de esta forma cuando la mquina llega a la posicin 607Ah en vez de encontrarse un

salto a subrutina no haya ms que tres nop, evitando la verificacin del sistema y
arrancando mucho antes.
pantallas del arranque evitables
106

Jos Tejada Gmez
Gryzor
Contenido de los ficheros ROM
Contenido
Fichero
Tipo de EPROM Lugar en la placa41
G-1.ROM
27256 - 32kOct
P5
Cdigo de sonido
G-2.ROM
27512 64kOct
H2
Cdigo de juego
G-3.ROM
27512 64kOct
J2
Cdigo de juego
G-4.R.ROM OM 27512 64kOct
A17
Fondo lejano
G-5.ROM
27512 64kOct
C17
Fondo lejano
G-6.ROM
27512 64kOct
D17
Fondo lejano
G-7.ROM
27512 64kOct
F17
Fondo prximo
G-8.ROM
27512 64kOct
H17
Fondo prximo
G-9.ROM
27512 64kOct
J17
Fondo prximo
G-10.ROM
27512 64kOct
K17
Fondo prximo
G-11.ROM
27512 64kOct
L17
Objetos
G-12.ROM
27512 64kOct
M17
Objetos
G-13.ROM
27512 64kOct
P17
Objetos
G-14.ROM
27512 64kOct
Q17
Objetos
G-15.ROM
27512 64kOct
R17
Objetos
G-16.ROM
27512 64kOct
T17
Objetos
G-17.ROM
27512 64kOct
V17
Objetos
G-18.ROM
27512 64kOct
W17
Objetos
La posicin que ocupa en la placa est descrita en forma de coordenadas. Es muy
habitual nombrar las columnas y las filas en las placas de circuito impreso con letras y
nmeros para filas y columnas, a cada componente se le asigna una combinacin de
ambos y esa referencia se utiliza en las reparaciones cuando se encargan componentes
al fabricante.

Posicin (hexadecimal)
0010
0011
0012
0014
0015
0016
0018
001A
Descripcin
Insertar monedas y comenzar
entrada del 1er jugador
entrada del 2 jugador
DIP 0
DIP 1
DIP 2
Contador de monedas
Disparador de interrupciones
Estas ROM se volcaron de una placa Gryzor (Contra) japonesa de contrabando etiquetada
712-47, fueron una aportacin del australiano arcade@zws.com; que tambin ayud durante el
proyecto con fotografas e informacin de primera mano sobre el funcionamiento real del
equipo.
41
107

Jos Tejada Gmez
001E
0C00-0D00
1000-1FFF
2000-23FF
2400-27FF
2800-2BFF
2C00-2FFF
3000-37FF
3800-3FFF
3B31
4000-47FF
47FF-4800
5000-57FF
5800-5FFF
7000
6000-7FFF
8000-FFFF
Registro de autoarranque
Paleta grfica
Memoria RAM, 4 koct
Atributos del fondo 1, lneas 5-25h
Fondo 1, lneas 5-25h
Atributos del fondo 1, lneas 0-5
Fondo 1, lneas 0-5
Objetos
Objetos, Reflejo de 3000-37FF?
Desplace del 2 fondo
Fondo 2, atributos
Fondo 2, bloques
Objetos
Reflejo de 5000-57FF (?)
Registro de paginacin
Memoria paginada
32 koct de ROM, son los superiores de G2.ROM
Se da la extraa circunstancia de que el registro de paginacin (de slo escritura) est

mapeado en medio de la memoria ROM paginada (de slo lectura). Para que esto fuera
posible el circuito de seleccin de memoria tena que inspeccionar la patilla R/W del
procesador.
La UCP de sonido:
Posicin (hexadecimal)
0000
2000
2001
6000-67FF
8000-FFFF
Descripcin
Comunicacin con la otra UCP
Registro del YM2151, slo lectura
Datos del YM2151, lectura y escritura
RAM
ROM
108

Jos Tejada Gmez
Codificacin de los grficos en las memorias ROM42

Caracteres y fondos
Los caracteres de Gryzor son bloques de 8x8 puntos con cuatro dgitos por punto, y por
lo tanto diecisis colores posibles por punto. La codificacin es muy sencilla puesto que
los cuatro dgitos correspondientes a cada punto aparecen en la ROM de forma
consecutiva agrupados en cuartetos. Cada octeto tiene, por consiguiente, dos puntos;
cada bloque ocupa 32 octetos.
Ejemplo de caracteres de Gryzor
Hay dos detalles curiosos con los caracteres de Gryzor:
Aunque la mquina es capaz de realizar la funcin de reflejo horizontal y

vertical de los caracteres, muchos de ellos aparecen ya girados en la ROM.
Gryzor era una mquina de monitor vertical, es decir la imagen era ms alta
que larga, por lo que los caracteres aparecen en la ROM ya girados 90 grados
para su presentacin en vertical.
Objetos
Los objetos se componen de bloques de 16x16 puntos, pero cada uno de estos bloques
se almacena en la ROM como cuatro de 8x8 puntos, cuya codificacin es anloga a la
de los caracteres. Para formar el bloque de 16x16 a partir de los de 8x8 hay que seguir
el siguiente orden: en la memoria ROM los cuatro bloques aparecen como ABCD, si se
reconstruyen se puede formar el bloque:
A B
C D
Pero ste est girado 90 grados, que es lo que necesitaba la circuitera de Gryzor. Para
la emulacin necesitamos que el bloque est horizontal, luego lo giramos 90
quedando:
C A
D B
Hay que agradecer a Roberto Ventura su colaboracin excepcional en el descifrado de los

grficos
42
109

Jos Tejada Gmez
Objetos de Gryzor, en la imagen puede

apreciarse como cada bloque de 16x16
corresponde a una posicin del jugador.

El primer fondo
Este el plano ms cercano a la accin, est separado en dos partes. La primera son slo
cinco lneas de bloques (40 puntos de altura en total) y la siguiente son 32 lneas (256
puntos de altura). Las primeras lneas van sobre un fondo negro en la parte superior de
la pantalla aunque en Grytra hemos preferido montarlas en la parte lateral derecha
para que el conjunto quede ms ancho que largo y poder as utilizar una resolucin
menor de vdeo que muestre grficos proporcionalmente mayores.
En las primeras lneas se obtiene el valor del bloque a pintar explorando la memoria
2C00h, 400h por debajo estn los atributos de los que se extrae la paleta grfica a usar.
for( x=0x1F; x>=0; x--, explo+=0x20-5 )
for( y=0; y<5; y++,explo++ )
{
attr = ram[explo-0x400];
color = ((attr)&3);
pon_bloque_bruto( fondo[3],ram[explo], x<<3, y<<3,tabla[color]<<4 );
}
Para la 2 parte del fondo se examinan la memoria en 2400h. La mecnica es la misma

con la salvedad de que ahora es necesario descodificar adems los dgitos superiores
del nmero de bloque. sta informacin est en el atributo y se obtiene a travs de
unas operaciones lgicas:
attr = ram[explo-0x400];
color = ((attr)&3);
attr = (attr&0xf8)>>3;
b3 = (attr & 0x8)<<1;
b2 = (attr & 0x4)<<2;
aux = (attr&0x10) >> 4;
attr = ((attr<<1)+aux)&0x1f;
attr &= 0xf;
110

Jos Tejada Gmez
attr |= (b3^b2);
pon_bloque_bruto( fondo[3],ram[explo]+(attr<<8), x<<3, y<<3,
tabla[color]<<4 );
El segundo fondo
ste fondo est en la posicin 4400h (4000h para los atributos) y parece utilizar siempre
la misma paleta. Ocupa un rea de 256x256, en Grytra se pinta de la siguiente manera
attr = (attr&0xf8)>>3;
aux = (attr&0x10) >> 4;
attr = ((attr<<1)+aux)&0x1f;
pon_bloque_bruto( fondo[0], ram[explo]+/*bloque[attr]*/(attr<<8), x<<3,
y<<3, 6<<4 );
Los objetos
Los objetos en Gryzor ocupan cuatro zonas de memoria distintas, stas son: 3000h,
3800h, 5000h y 5800h; sin embargo parece que unas son una imagen de las otras luego
basta con pintar dos de ellas. El emulador programado dibuja las zonas 3800h y 5000h.
Estas zonas se componen de estructuras de cinco octetos donde el antepenltimo y el
penltimo son las coordenas; abscisas y ordenadas respectivamente, y los dos primeros
los atributos. La posicin en la memoria ROM del bloque a dibujar se obtiene a partir
de la siguiente frmula:
explo es la posicin de la estructura de objeto

analizada
attr = (ram[explo+1]&0x7)<<8;
bloque = (ram[explo]+attr)<<2;
Adems cada pareja de zonas grficas corresponde a un conjunto de memorias ROM

diferente, as que cuando ponemos todas las ROM consecutivas en memoria para
hallar el nmero del bloque hay que sumar 8192 si analizamos las zonas 3x00h:
if ( con_zona<2) bloque+=2048*4;
Por ltimo, si el dgito 6 del quinto octeto est activado hay que sumar 4096 al nmero
de bloque:
if ( ram[ explo+4 ] &0x40 ) bloque+=1024*4;
Para saber si el bloque ha de invertirse es necesario realizar la exclusiva de dos dgitos:

if ( (ram[explo+4]&0x20) ^ ((ram[explo+4]&0x10)<<1) )
Por ltimo Gryzor tiene una peculiaridad: hay un determinado dgito que, caso de estar
activo, nos indica que hay que dibujar un objeto no de 16x16 sino de 32x32, en ese caso
los nmeros de bloque restantes son consecutivos.
La paleta grfica
Hay ocho paletas grficas sitas en 0C00h, cada una de 32 octetos de longitud. Cada
color est compuesto por tres primarios (rojo, verde y azul) de cinco dgitos cada uno
(25*3=2048 colores). Vistos en memoria los colores estn escritos en parejas de dos
111

Jos Tejada Gmez
octetos, si situamos primero el que ocupa la posicin mayor de memoria se puede leer
azul, rojo y verde consecutivamente:
aux =
rgb.r
rgb.g
aux =
rgb.b
rgb.g
ram[con+0xc00+paleta*32];
= aux&0x1f;
= (aux&0xE0)>>5;
ram[con+0xc01+paleta*32];
= (aux&0x7c)>>2;
|= (aux&0x3)<<3;
Octeto inferior,
ah estn el rojo
y parte del verde
en el octeto superior estn el azul y el resto
del verde
Como la paleta de la VGA trabaja con colores de 6 dgitos, es necesario aadir una cifra
adicional al color. Lo ideal sera hacer una transformacin lineal multiplicando por 63
y dividiendo por 31, pero es ms rpido hacer sencillamente un desplazamiento de una
posicin a la izquierda; el error cometido es muy pequeo y bsicamente en la
luminancia de la imagen:
rgb.r <<= 1;
rgb.g <<= 1;
rgb.b <<= 1;
112

Jos Tejada Gmez
Interruptores DIP
Primer microinterruptor
Uso
Accin
1/1
1/3
1/4
1/5
1/6
1/7
primer monedero
2/1
2/3
2/5
3/1
3/2
3/4
4/1
4/3
precio
gratis
1/1
1/2
1/3
1/4
1/5
1/6
1/7
segundo monedero
2/1
2/3
2/5
3/1
3/2
3/4
4/1
4/3
Sin uso
Invlido
1
NO
NO
NO
NO
NO
NO
NO
NO
SI
SI
SI
SI
SI
SI
SI
SI
2
NO
NO
NO
NO
SI
SI
SI
SI
NO
NO
NO
NO
SI
SI
SI
SI
3
NO
NO
SI
SI
NO
NO
SI
SI
NO
NO
SI
SI
NO
NO
SI
SI
4
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
NO
NO
NO
NO
NO
NO
NO
SI
SI
SI
SI
SI
SI
SI
SI
NO
NO
NO
NO
SI
SI
SI
SI
NO
NO
NO
NO
SI
SI
SI
SI
NO
NO
SI
SI
NO
NO
SI
SI
NO
NO
SI
SI
NO
NO
SI
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
NO
SI
113

Jos Tejada Gmez
Segundo microinterruptor
Uso
vidas
Bonificacin
Dificultad
Sonido de
captacin
Accin
2
3
5
7
a los 30.000 y
cada 70.000
a los 40.000 y
cada 80.000
slo a los 40.000
slo a los 50.000
fcil
normal
difcil
dificilsimo
NO
SI
1
NO
NO
SI
SI
2
NO
SI
NO
SI
NO
NO
NO
SI
SI
SI
NO
SI
NO
NO
SI
SI
NO
SI
NO
SI
Tercer microinterruptor
Uso
Accin
1 2 3
4 5 6 7 8
Giro de la pantalla normal
NO
invertido SI
normal
NO
funcionamiento
SI
pruebas
estreo
NO
tipo de sonido
SI
mono
La explicacin de estas opciones es la misma que en el caso del G&G. La configuracin
por defecto del equipo era: una moneda por partida ambos monederos, tres vidas con
bono a los 30.000 y cada 70.000 puntos, dificultad normal, sin girar la pantalla, modo
de juego y sonido estreo43.
43
Datos sacados del manual de servicio de Contra
114

Jos Tejada Gmez
El modo de pruebas
Gryzor incluye un modo de pruebas ms completo que el de G&G, consta de seis
pantallas por las cuales se navega pulsando simultneamente 1P y 2P.
1. Prueba de entradas
2. Prueba de contadores
3. Interruptores DIP
4. Ortogonalidad del monitor
5. Prueba de color
6. Prueba de sonido
1. La primera pantalla es similar a la del G&G y permite evaluar si las entradas

funcionan correctamente: el estado de las palancas, botones e interruptores DIP
se muestra en pantalla.
2. La siguiente prueba enva pulsos para los contadores de monedas, de esta
forma se comprueba si los registros de salida funcionan.
3. A continuacin, se muestra el estado de los interruptores DIP no de forma
numrica sino conceptual; as se puede programar el comportamiento de la
mquina ms fcilmente.
4. Para medir si los gradientes aplicados al tubo de rayos catdicos son los
adecuados se usa la prueba de ortogonalidad. La mquina muestra una rejilla
115

Jos Tejada Gmez
perfecta, el tcnico debe ajustar el monitor para que las intersecciones formen
ngulos rectos.
5. Tambin relacionada con el monitor, la siguiente pantalla muestra gradientes
de colores que sirven para comprobar si alguno de los tubos de color falla, ya
sea completamente o por un error de ganancia que se podr ajustar. En
ocasiones basta desmagnetizar el monitor para solucionar el problema.
6. Finalmente, la prueba de sonido es anloga a la del G&G. Sobre posibles fallos
y soluciones consulte la seccin del G&G.
Miscelnea
Al igual que en el caso de G&G, es posible saltarse las rutinas iniciales de verificacin
del equipo para acelerar el arranque de la mquina. El cdigo empleado en Grytra es:
/* parche para saltarse la comprobacin de la RAM/ROM */
ram[ 0x800a] = 0x63;
ram[ 0x800b] = 0xe7;
y se basa en variar la direccin del salto inicial que hace el sistema.
Imgenes del arranque de Gryzor evitables modificando la ROM
116

Jos Tejada Gmez
Combat School
Combat School funcionaba en una placa con dos procesadores: un 6809 para el juego,
que funcionaba a 3MHz; y un Z80 para el sonido, a 15MHz. El responsable de la
msica era el integrado de Yamaha YM2203 y el encargado de reproducir las voces
digitalizadas era el UPD7759.
Contenido de los ficheros ROM

El volcado que se describe en la tabla siguiente procede de una placa pirata de Combat
School y es el que utiliza el emulador Escuela de combate. Todos los ficheros pesan 64
koct.
Nombre
Descripcin
del fichero
combat.001 cdigo de la UCP de sonido
los 32koct. superiores ocupan la memoria superior del 6809,
combat.002
los 32 koct. inferiores son memoria paginada.
combat.003 pginas, de la 10h a la 17h
combat.004 pginas, de la 18h a la 1Fh
combat.005 Fondos, segundo grupo
combat.006 Fondos, primer grupo
combat.013 Objetos, primer grupo
combat.014 Objetos, segundo grupo
Codificacin de los grficos en las memorias ROM

Los bloques de fondos estn separados en cuatro memorias ROM, en cada una de ellas
hay uno de los planos de color. De forma que si tomamos nicamente una de las
memorias obtenemos un bloque monocromtico; combinando dos, cuatricolor; tres,
octicolor y al juntar los cuatro, bloques de diecisis colores.
Cada bloque, de 8x8 puntos, ocupa ocho octetos consecutivos de memoria. En cada
octeto, cada cifra corresponde a un punto. La codificacin es sencilla y directa.
117

Jos Tejada Gmez
Los objetos estn almacenados de una forma menos intuitiva. Son bloques de 16x16
puntos, tambin de cuatro planos (diecisis colores) pero estn codificados como si
fuesen de 8x16, de tal forma que uno de 16x16 est guardado como dos de 8x16
seguidos. Los bloques de 8x16 se componen de 16 octetos seguidos que almacenan
ocho puntos cada uno.

Posicin
00C0-00C3
0400
0500
600-6FF
0800-1FFF
2000-2FFF
3000-3FFF
4000-7FFF
8000-FFFF
Longitud
(octetos)
4
1
1
256
4608 (?)
4096
4096
16384
32768
Descripcin
Lmite de los objetos44
Orden de escritura (prioridad) de los grficos
Paginacin de la ROM y seleccin del circuito grfico
Paleta grfica
Memoria RAM
Circuitos grficos, fondos
Circuitos grficos, objetos
Memoria paginada, registros de E/S y de vdeo
Memoria ROM
En la posicin 500h hay un registro de ocho dgitos que controla qu pgina de ROM
est seleccionada y qu circuito grfico (de los dos disponibles) est seleccionado.
Registro 500h
Dgito 7 Dgito 6 Dgito 5 Dgito 4 Dgito 3 Dgito 2 Dgito 1 Dgito 0
Circuito
Pgina de ROM seleccionada
grfico
La mquina tiene dos circuitos grficos de 8192 octetos de longitud situados en la
posicin 2000h, cada uno de ellos es capaz de dibujar fondos y objetos sobre ellos.
Las pginas no siguen un orden natural ya que hay una algn tipo de codificacin en el
nmero que se escribe en 500h; de hecho, hay 32 posibles pginas segn 500h pero slo
18 de ellas son reales.
Nmero
de pgina
00
01
10
12
14
16
18
1A
1C
1E
44
Fichero
Posicin en el fichero
ROM
Combat.002
0
Combat.002
4000h
Combat.003
0
Combat.003
2000h
Combat.003
4000h
Combat.003
6000h
Combat.004
0
Combat.004
2000h
Combat.004
4000h
Combat.004
6000h
Ver la seccin de grficos para una explicacin de ste registro
118

Jos Tejada Gmez
1F
Combat.002
4000h
Los ltimos 32 kilo octetos de combat.002 corresponden a la mitad superior de la

memoria del 6809 y no estn paginados. En ellos reside el cdigo de arranque.

Como ya se ha dicho, hay dos circuitos grficos idnticos mapeados en 2000h-3FFFh ,
con el registro 500h se selecciona uno u otro a la hora de realizar operaciones de
escritura.
En la zona de memoria paginada (4000-7FFF) hay algunos registros de vdeo de slo
lectura. De forma que cuando se accede a esa rea para lectura, los datos provienen de
la ROM y cuando se escribe en ella, los datos van a los registros de vdeo.
Los fondos
El fondo grfico est compuesto por tres capas, dos de ellas susceptibles de
desplazamiento y una ltima formada por caracteres. Las dos primeras se dividen en
32 bandas horizontales, cada una correspondiente a una altura en la pantalla y con un
desplace horizontal diferente de la siguiente. Al conjunto de las 32 filas le corresponde
un nico valor de desplace vertical. Un fondo puede tapar al otro o viceversa segn el
valor de un registro de prioridad, situado en la posicin 400h, pero la superposicin es
total: o bien un fondo oculta a otro, o bien el otro al primero; pero no puede ocurrir que
una seccin tape a otra sin que afecte al resto.
No existe una pantalla virtual, como en el caso del Ghosts and Goblins; y el espacio
reservado para pintar la imagen es tan slo de una columna (ocho puntos de ancho).
Los registros de desplace horizontal ocupan desde la posicin 0x4040 hasta la 0x408F,
los primeros 32 (20h) corresponden a un circuito grfico y los siguientes a otro. En las
posiciones 0x4000 y 0x4020 estn los registros de desplace vertical, de un octeto cada
uno y que se aplican al conjunto de las filas.
La razn de este peculiar fondo, compuesto por filas desplazables individualmente est
en la primera fase del juego, en ella los dos jugadores compiten en una carrera: la
pantalla se divide en dos, la mitad superior corresponde a un jugador y la inferior al
otro. Aunque corren en el mismo escenario cada uno puede estar en una zona distinta e
incluso muy alejado del otro; adems cada uno se mueve a una velocidad. Esta
circunstancia requiere que media pantalla se mueva a un ritmo independiente de la
otra media y que, por lo tanto, necesite registros de desplace diferentes. Por qu uno
para cada fila de la pantalla y no para cada mitad? Seguramente se prefiri un diseo
ms flexible en caso de que en otro juego que utilizase el mismo integrado pudiera ser
til un control a nivel de fila. En la prctica slo hay dos ocasiones en el juego en que se
utilice esta caracterstica tan peculiar: una es en la presentacin de los jugadores donde
el movimiento de los rostros se consigue de esta forma, la otra es la mencionada
primera fase.
119

Jos Tejada Gmez
Primera fase, emulada con Escuela de

Combate
Los retratos estn compuestos en el fondo y se

mueven independientemente
Los objetos
Los objetos, bloques de 16x16 puntos, estn mapeados en la zona 3000-3FFFh. All una
estructura de cinco octetos de longitud contiene la informacin sobre qu, dnde y
cmo pintarlos.
Octeto 0
Nmero de
bloque
Octeto 1
Octeto 2
Octeto 3
Octeto 4
Abscisa
Ordenada
Atributos
paleta
El nmero completo del bloque a pintar, una vez colocadas todas las ROM linealmente
en memoria se obtiene mezclando la informacin de los atributos con el nmero dado
en el primer octeto:
int pagina = (color & 0x03) | ((atributos & 0x40) >> 4);
bloque = ((bloque & 0x02) << 1) | ((bloque & 0x04) >> 1) | (bloque & (~6));
bloque += 256*pagina;
Como vemos, es necesario desenredar un cierto galimatas con los dgitos binarios para
poder obtener un nmero de bloque lineal.
Las coordenadas requieren tambin una pequea transformacin antes de ser
utilizables:
unsigned x = contador[2] - 71 + (atributos & 0x01)*256;
unsigned y = 242 - contador[1];
Las ordenadas se almacenan contando desde abajo, para invertirlas basta restarlas de la
altura de la pantalla (242 puntos). Las abscisas tambin estn tomadas al revs, pero
adems falta el dgito de mayor peso que se obtiene de los atributos.
El quinto dgito de los atributos (mscara: 10h) indica si hay que girar horizontalmente
el objeto al pintarlo.
120

Jos Tejada Gmez
El modo de pruebas
Las pruebas de Combat School son muy parecidas a las de Gryzor, por tanto slo se
explicarn las diferencias, remitimos a la seccin sobre Gryzor para una explicacin
ms detallada.
1. Ortogonalidad de la pantalla
2. Prueba de sonido
3. Prueba de color
4. Prueba de las entradas
5. Prueba de los contadores
6. Interruptores DIP
Volvemos a encontrarnos con un completo modo de pruebas dividido en seis pantallas.

De ellas la novedad es la cuarta, en la que las entradas son algo ms complicadas que
anteriormente. Esto se debe a que Combat School se distribua en versiones para palanca
y esfera. Cuando se jugaba con la esfera se gozaba de una sensibilidad adicional y en
vez de tener el espacio dividido en cuatro direcciones y cuatro diagonales haba otras
ocho semidiagonales adicionales: diecisis posiciones posibles en total.
El resto de las secciones: ortogonalidad, sonido, color, contadores e interruptores son
similares a las de Gryzor.
121

Jos Tejada Gmez
Miscelnea
Conexin de una palanca normal
Como ya se ha comentado anteriormente, Combat School funcionaba con una especie de
semiesfera que dotaba al jugador de diecisis direcciones posibles de movimiento
frente a las ocho de una palanca normal. El requisito de la semiesfera limitaba el uso de
la placa con muebles convencionales (distintos al original de Konami) sin embargo
haba una forma de utilizar esta placa con una palanca normal.
conexin del 74LS245 para utilizar una palanca normal
Las seales procedentes de la semiesfera llegan al conector jama y de l hasta un

integrado a medida. Si sustituimos ese circuito por el juego de bferes normal 74LS245
siguiendo el conexionado indicado podremos utilizar una palanca normal conectada
de la forma habitual al jama.
Salto de los retardos iniciales
Al comienzo del programa hay unos retardos considerablemente largos que en
principio servan para permitir que otros dispositivos ms lentos se encendiesen
completamente. Como en el juego emulado esos problemas no existen, puede
ningunearse la rutina de espera mediante el siguiente cdigo:
pPagina[1][0x6145-0x4000]=0x39; // para evitar la rutina de retardo
Donde la pgina 1 corresponde a los segundos 8 kilo octetos de la ROM combat.002, el

nmero 6145h es la posicin en memoria del octeto a cambiar y el 4000h convierte de
direcciones de RAM a direcciones en el interior de la pgina.
122

Jos Tejada Gmez
Los emuladores
En este ltimo apartado presentaremos detalladamente el resultado del proyecto: los
emuladores de las tres mquinas recreativas estudiadas, Ghosts & Goblins, Gryzor y
Combat School.
Mapefer3, emulador de Ghosts & Goblins

Este emulador fue el primero que se hizo. La labor de investigacin, aunque existente,
estuvo muy aminorada, pues pronto apareci un emulador funcional de un italiano,
Roberto Ventura. El Sr. Ventura colabor con informacin de la mquina recreativa al
desarrollo de nuestro emulador, si bien todo el cdigo es ntegramente nuestro y la
solucin final es ms rpida que la codificada por el Sr. Ventura pese a estar la suya
codificada totalmente en ensamblador.
Este emulador recibi el nombre de mapefer3, en honor a la novia del programador,
pues su direccin de correo de la UPV era sa precisamente.
El objetivo de este emulador era conseguir que el juego funcionase fluidamente en un
equipo lento: un 486 DX 100 MHz.
Plataforma de desarrollo
Se evaluaron varias alternativas: Turbo C, ensamblador 8086, ensamblador 80386,
Watcom C/C++, Borland C 4.5 y el gratuito GCC. La decisin final fue GCC y los
motivos fueron:
Turbo C generaba nicamente cdigo de 16 dgitos y permita acceder slo a

640 koct. La limitacin de memoria era tolerable, pero los 16 dgitos y el modo
real planteaban dudas sobre si el rendimiento sera aceptable
Ensamblador 8086: Era posible optimizar mucho ms el cdigo, pero quedaba
patente al escribir que las instrucciones del 80386 aceleraran mucho el proceso.
Ensamblador 80386: Esta posibilidad si se tom en serio y se hicieron varios
conatos de emulacin llegando algunos moderadamente lejos. El problema
resida en que era muy difcil depurar el cdigo de emulacin del procesador,
pues era demasiado extenso y repetitivo. A esto haba que sumarle el tedio de
tener que programar todas las rutinas desde cero.
Watcom C/C++: se daba el caso de que disponamos de una copia legal de este
compilador por lo que se estudi su posible uso. Era factible generar cdigo de
32 dgitos con facilidad, pero el compilador era incompatible con Windows 95,
as que se desestim su uso.
Borland C 4.5: No era sencillo generar cdigo de 32 dgitos y no permita
escribir acentos ni ees entre los comentarios del cdigo, este aspecto aunque
tolerable tcnicamente era inadmisible lingsticamente en cuanto que supona
un desprecio de nuestro idioma y de todos los que no son anglfonos.
Gcc (djgpp): El compilador gratuito de GNU generaba cdigo de 32 dgitos y
era legal. Estas dos circunstancias lo alzaron al podio.
123

Jos Tejada Gmez
Gcc, sin embargo, no es ms que una utilidad de lnea de comandos por lo que haba
que complementarla con algn entorno de desarrollo ms cmodo. Despus de buscar
entre las alternativas disponibles para Windows45 encontramos RHIDE46,
Pantalla de presentacin de RHIDE
La gran ventaja de RHIDE consiste en que la interfaz que presenta est calcada de la
del Turbo Pascal y el Turbo C por lo que el uso es inmediato si se tiene experiencia en
alguna de las herramientas de Borland.
El sistema an no estaba completo pues si se quera evitar direccionar directamente la
memoria de vdeo del PC, con el engorro que ello conlleva, haca falta una biblioteca
grfica. La eleccin fue Allegro, biblioteca de 32 dgitos para Gcc, de sencillo manejo y
gran versatilidad.
As que Rhide se utiliz para escribir el proyecto, Gcc para compilarlo tanto el cdigo
en C como el cdigo de ensamblador incrustado y Allegro como interfaz con el sistema
grfico del PC.
El compilador de C gnu en su versin para PC puede descargarse de
http://www.delorie.com/djgpp
Gcc es mucho ms popular en Linux as que casi todos los entornos disponibles son para este
sistema operativo.
46 El nombre RHIDE, est formado por las iniciales del autor ms el acrnimo IDE (Integrated
Development Enviroment, entorno de desarrollo integrado)
45
124

Jos Tejada Gmez
Diagramas de flujo fundamentales

En esta seccin vamos a presentar los diagramas de flujo bsicos para poder entender
con ms facilidad el cdigo fuente en la siguiente seccin
Funcin main
Funcin main
El cdigo se separa en dos partes: la lectura de las memorias ROM y descodificacin de

los grficos que implica una posibilidad de error, caso de no encontrarse los ficheros; y
la emulacin propiamente dicha, compuesta de una primera preparacin y del bucle de
la emulacin en s. Estas dos partes se detallan a continuacin.
125

Jos Tejada Gmez
Preparacin y bucle de la emulacin
Preparacin
Bucle de la emulacin
La preparacin consiste en colocar las memorias ROM en las posiciones adecuadas de

la memoria virtual del 6809 simulado, realizar la llamada de arranque que precisa la
biblioteca grfica utilizada (Allegro), instalar el temporizador encargado de actualizar
cada 20ms la variable ips_ideal de promediado de imgenes, capturar la entrada del
teclado y de la palanca de juego y cambiar la resolucin del monitor a 256x256 puntos
y 256 colores. Se reserva adems un rea de memoria, denominada fondo virtual donde
se compondr la imagen de fondo segn lo explicado anteriormente.
El bucle de la emulacin responde al modelo ya explicado, aunque aqu est algo ms
detallado. En el caso de que el jugador haya pausado el juego, el bucle se reduce a
dibujar la pantalla y mostrar sobre ella mensajes informativos (tales como el
rendimiento, medido en imgenes pintadas por segundo). Si el juego funciona con
normalidad, sin la pausa, es preciso emular las instrucciones correspondientes a 20ms
y disparar una interrupcin del tipo IRQ, a continuacin, segn lo explicado en el
captulo de sincronizacin, se dibuja la pantalla si da tiempo a hacerlo y si no se omite
este paso. Finalmente se actualizan las variables de promediado y se salvaguarda la
memoria de objetos pues en Ghosts & Goblins esta memoria funciona un fotograma
adelantada respecto de la de fondo.
126

Jos Tejada Gmez
Explicacin del cdigo fuente

En esta seccin vamos a diseccionar el funcionamiento del emulador tomando
porciones del cdigo y explicando sus funciones y cmo se enlazan con toda la teora
vista. Las funciones Ejecuta e irq, pertenecientes a la emulacin del procesador se
omiten en este anlisis, pues ya se han revisado anteriormente.
El cdigo se presentar separado por secciones coloreadas y con explicaciones
intercaladas con el siguiente formato:
esto es un comentario.
main
int main(int argc, char *argv[])
{
/* variables */
char ant_munecos[96*4];
int error; unsigned scroll_x, scroll_y;
int pintadas[2] = {0,0}; /* im genes pintadas */
RGB blanco = { 63,63,63 };
/* sonidos */
SAMPLE *gng2b;
/* programa */
presentacion();
strcpy( directorio,".");
ipi = IPI;
/* inicia el vector mostrar */
for(error=0; error < MOSTRAR; error++)
con_mostrar[error]=0;
/* lnea de par metros */
cmdline( argc, argv );
error = carga_rom( rom, directorio );
if ( error == 0 )
{
error = decodifica_graficos( rom );
if ( error == 0 )
{
if ( Inicia6809() == 0 ) { error = NO_RAM;
imprime_error( error ); return -1; }
prepara_memoria();
allegro_init();
LOCK_VARIABLE( ips_ideal );
LOCK_FUNCTION( temporizador );
install_timer();
install_int( temporizador, 1.0/60*1000 );
prepara_sonido();
install_keyboard();
initialise_joystick();
/* prepara la pantalla*/
if ( set_gfx_mode( GFX_AUTODETECT,
res_x,res_y,0,0 ) < 0 ) goto final;
set_clip( screen,0,0,0,0 );
127

Jos Tejada Gmez
bmp = create_dgitomap(256, 256);
fondo_virtual = create_dgitomap(512,512);
clear( fondo_virtual );
fondo_vir = fondo_virtual->line[0];
memoria = bmp->line[0];
reset();
ram[0x3000] = ram[0x3001] = ram[0x3002] =
0xff;
set_color( 255,&blanco );
for(;;)
{
if ( pausa )
{
if ( teclado() ) break;
muestra_mensajes( pintadas );
blit(bmp, screen, (SCREEN_H-256)>>1,
desplazamiento, 0, 0, 320, 224);
continue;
}
ejecuta( ipi );
irq();
if ( ips_real > ips_ideal )
{
pintadas[0]++;
muestra_mensajes( pintadas );
blit(bmp, screen, (SCREEN_H-256)>>1,
desplazamiento, 0, 0, 320, 224);
if ( teclado() ) break;
toca_sonidos();
}
if ( ips_ideal >= 59 )
{
ips_ideal=0;
ips_media += ips_real; ips_media >>=1;
ips_real = 0;
pintadas[1] = pintadas[0];
pintadas[0] = 0;
}
if
(
ips_real++
>=
ips_ideal
)
memcpy( ant_munecos, ram+0x1e00, 96*4 );
}
final:
destruye_sonidos();
remove_keyboard();
set_gfx_mode( GFX_TEXT, 256,256,512,256 );
libera_rom( rom );
/* libera la memoria reservada para los
grficos */
free( car ); free( anim ); free( fondo );
despedida();
return 0;
}else imprime_error( error );
Bucle de emulacin
Si el juego est pausado slo se comprueba el
teclado y se redibuja la pantalla. No se avanza
la simulacin.
Se
ejecutan
IPI
(Instrucciones Por
Interrupcin) instrucciones y se dispara una
interrupcin despus.
El control de la velocidad se realiza mediante
promediado
Se actualizan las variables de promediado
Si la siguiente imagen se va a mostrar se copia

la memoria de objetos
Se puls Esc: hay que salir del programa

dejando el ordenador impoluto.
Se libera toda la memoria reservada y se
muestra un mensaje de despedida.
128

Jos Tejada Gmez
}
else imprime_error( error );
return -1;
/* ha habido algn error */
}
OpIlegal
void ilegalC()
{
printf("Op ilegal = %X",ram[pc-1]);
vuelca_regs();
exit( ram[pc-1] );
}
Esta sencilla funcin se ejecutar cuando se encuentre una instruccin del 6809 sin
emular. En la actualidad, con una emulacin del procesador acabada y fiable, est
funcin no es llamada jams, sin embargo, durante el desarrollo inicial del emulador
fue muy til para detectar errores
Inicia6809
Esta rutina est programada en ensamblador (fichero 6809.s) y su objetivo es preparar
las tablas de memoria que se utilizan como ndice de salto para las operaciones
emuladas.
.align 4
_Inicia6809:.globl _Inicia6809
pushl
$0x10000
call
_malloc
add
$4,%esp
cmpl
$0,%eax
jne
reser
ret
reser:
movl
%eax,_ram
movl
%eax,%edi
#Rellena la
RAM con ceros
movl
$0x10000/4,%ecx
movl
$0,%eax
rep
stosl
# operaciones
movl
$256,%ecx
lea
opIlegal,%eax
lea
_ops,%edi
rep
stosl
.../...
Se reservan 64koct de memoria invocando a

la funcin de C malloc.
La memoria reservada ser la memoria virtual

del 6809. Se inicia a ceros
El vector ops contiene las direcciones de las

rutinas que emulan las operaciones del
procesador. Se inicia con la direccin de la
funcin de operacin ilegal.
La rutina contina rellenando ahora las tablas con los valores de las operaciones
emuladas. Los cdigos de operacin que no estn reconocidos por el programa
quedarn con la llamada a opIlegal, establecida por defecto.
Cuando todas las tablas estn completadas, la emulacin del procesador est a punto y
puede comenzar a ejecutar instrucciones. Hay ms informacin sobre este proceso en la
seccin dedicada al procesador.
129

Jos Tejada Gmez
prepara_memoria
Est funcin coloca la ROM fija en la posicin que le corresponde en la memoria segn
sea el juego a emular
void prepara_memoria()
{
/* prepara el juego */
Configura la dificultad del juego
ram[ 0x3003 ] = 0xCF; /* DIP 2A */
ram[ 0x3004 ] = 0xFF & ~ 0x20; /* DIP 1A
dificultad normal */
Copia la memoria fija a la posicin que
le toca
memcpy( ram+0x6000, rom[3]+0x2000, 0x2000 );
memcpy( ram+0x8000, rom[2], 32*1024 );
if ( juego == GNG_USA )
Prepara la memoria del procesador de
{ /* sonido */
sonido (sin emular)
z80_ram = malloc( 64*1024 );
if (!z80_ram ) { puts("Faltan 64k de RAM.");
exit(1); }
memset( z80_ram, 32*1024, 32*1024 );
memcpy( z80_ram, rom[1], 0x8000 );
free( rom[1] ); /* la libera pues no la usar ms */
}
if ( juego != DIAMOND )
Si el juego es el G&G coloca
{
if (juego == GNG_USA) ram[0x607a] = instrucciones nop para evitar las rutinas
ram[0x607b] = ram[0x607c] = 0x12; /* nop */
de comprobacin del sistema del
paginas[0]=rom[4];
arranque
paginas[2]=rom[4]+8*1024*2;
paginas[3]=rom[4]+8*1024*3;
paginas[4]=rom[3];
}
else
{ /* pginas de diamond Run */
paginas[0]=rom[4]+0x4000;
Si el juego a emular es Diamond Run,
paginas[1]=rom[11];
las pginas que han de usarse son
paginas[2]=rom[11] + 2*0x4000;
distintas
paginas[3]=rom[11] + 3*0x4000;
paginas[4]=rom[11] + 4*0x4000;
}
}
130

Jos Tejada Gmez
teclado
Esta rutina inspecciona las teclas que estn pulsadas para actuar en consecuencia. Hay
dos tipos de teclas:
Las que tienen efecto en la mquina simulada: los cursores que mueven el
personaje, la tecla 3 que inserta monedas
Las que actan en el emulador en s: como la P para pausa y la tecla Esc para
salir del programa
Dentro del primer tipo el cdigo es similar al de este ejemplo:

if ( key[0x4d] || joy_right )
{ ram[0x3001]&=0xfe; ram[0x3002]&=0xfe; }
else { ram[0x3001]|=1; ram[0x3002]|=1; } // derecha
Se evala el estado de una tecla y de la palanca, si este es el deseado se anula una

determinada cifra del octeto de memoria RAM que representa al puerto de entrada de
la placa original; si no fuera as, esa misma cifra se coloca a uno.
Como ejemplo del segundo grupo veamos la tecla V que sirve para activar o desactivar
la sincronizacin con el retrazo de la pantalla:
if ( key[0x2f] )
{
while( key[0x2f] );
vsinc = !vsinc;
if ( vsinc ) { con_mostrar[VSINC_SI] = 60; }
else { con_mostrar[VSINC_NO] = 60; }
}
Si se ha pulsado dicha tecla, se espera primero a que se suelte y a continuacin se

invierte el valor de la variable vsinc, segn el nuevo valor de esta se mostrar un
mensaje en pantalla informativo del cambio que prevalecer durante 60 segundos.
escribe_mensaje
Esta funcin escribe texto informativo sobre la pantalla del juego. Dado que el texto ha
de permanecer slo durante un breve tiempo y que el nmero de mensajes distintos es
muy pequeo se opt por tener un vector de tiempos llamado con_mostrar (contador
para mostrar) donde cada entrada indica el nmero de fotogramas que el mensaje ha
de ser visible. En cada llamada a la funcin ese nmero se decrementa y si fuese
positivo, se muestra el mensaje. Por ejemplo, el cdigo para el texto de pausa es:
if ( con_mostrar[PAUSA] != 0 ) {
sprintf( frase, "PAUSA" );
textout( bmp, font, frase, 256 - 8*strlen(frase) ,altura, 255 );
altura+=ESPACIO; }
La variable altura controla que cada mensaje se escriba sin mezclarse con el anterior.
131

Jos Tejada Gmez
dibuja_pantalla
Esta funcin coordina el dibujado de la pantalla en cuatro pasos: fondo grfico, objetos,
caracteres y paleta. Cuando la rutina termina la pantalla est lista para ser copiada al
circuito grfico y mostrada en el monitor; este paso se realiza fuera de esta rutina, en la
funcin main.
void dibuja_pantalla( char *ant_munecos)
{
sx = ram[0x3b08] + ( (ram[0x3b09]&1) <<8);
sy = ram[0x3b0a] + ( (ram[0x3b0b]&1) <<8);
dibuja_fondo();
Munecos_Color( ant_munecos );
Caracteres_Color( ram )
if ( vsinc ) vsync();
if ( paleta_verdadera ) Paleta();
else PaletaR();
}
Obtiene las variables de desplace a partir

de los registros de la mquina
Dibuja el fondo, sobre l los objetos
(muecos) y sobre todos, los caracteres.
Espera el retrazado y actualiza la paleta
Cdigo de dibuja_pantalla
Existen dos formas de calcular la paleta grfica del PC a partir de la original. Cada
color primario puede tener diecisis niveles (del 0 al 15) o equivalentemente, cada color
est codificado en un cuarteto. Para pasar el color a PC es necesario que ocupe seis
dgitos (64 niveles). La funcin PaletaR (R de rpida) realiza la conversin
multiplicando por cuatro el color original desplazando dos dgitos a la izquierda. Esta
operacin es muy rpida pero tiene el inconveniente de que los resultados son
inexactos; por ejemplo el color de mxima intensidad originalmente es el 1111b, tras la
conversin ste queda como 111100b que en decimal equivale a 60, un 666% menor de
lo que debera ser (111111b 64). As todos los colores presentan un pequeo error que
slo puede corregirse escalando el valor adecuadamente: multiplicando por 63 y
dividiendo el resultado por 15. Como esta operacin es ms lenta y el objetivo del
emulador era la rapidez se dej como una opcin: el jugador puede elegir qu paleta
ver pulsando la tecla espacio. Alternando la paleta durante el juego se puede apreciar la
diferencia que es ms notable en cuanto a luminancia que en cuanto a crominancia.
Fondo y dibuja_fondo
Esta pareja de funciones son las responsables de construir el fondo virtual (Fondo) y de
copiar la ventana activa a la pantalla (dibuja_fondo). No vamos a detallar el cdigo de
Fondo, pues es demasiado extenso, pero s vamos a hacer notar su principal
optimizacin.
Dado que Fondo ha de construir la imagen virtual formando un mosaico con los
bloques de 8x8 que componen los grficos de la mquina; puede comprobar
rpidamente, sin ms que comparar el cdigo del bloque ya pintado con el cdigo que
la mquina pide en el nuevo fotograma, si ese cuadrado ha cambiado desde la ltima
vez que se pint. Si no hubiese cambiado no es necesario volver a pintarlo y por lo
tanto se ahorra la operacin de copiar 64 octetos. En la prctica, la mquina slo
renueva el fondo virtual totalmente al cambiar de nivel; durante el juego el fondo se
actualiza muy lentamente y se emplean las variables de desplace para pintar
nicamente el rea visible que est lista.
132

Jos Tejada Gmez
La funcin dibuja_fondo ha de copiar una ventana desde el fondo virtual a la pantalla en
construccin. Se dan varios casos posibles segn el valor de los desplaces, pero el ms
genrico es aquel en que la imagen ha tenido que formarse a partir de cuatro esquinas
del fondo virtual. El cdigo en ese caso es:
blit(
blit(
blit(
blit(
fondo_virtual,bmp,
fondo_virtual,bmp,
fondo_virtual,bmp,
fondo_virtual,bmp,
sx,sy+16,0,16, 512-sx, 512-sy );

0,sy+16, 512-sx,16, sx-256 ,512-sy );
0,0, 512-sx,512-sy, sx-256 ,256-512+sy-16 );
sx,0, 0,512-sy, 512-sx ,256-512-16+sy );
sup. izq.
sup. der.
inf. der.
inf. izq.
Cdigo de ejemplo de dibuja_fondo
La funcin blit pertenece a la biblioteca grfica Allegro y sirve para copiar rectngulos
entre imgenes.
Esta vez no hemos optado por optimizar la copia. Es posible, una vez ms, controlar
qu partes de la imagen destino han cambiado desde la ltima vez y omitirlas del
proceso; sin embargo, este caso es bastante ms complicado que el anterior:
El fondo, aun siendo el mismo, ha sido emborronado por los personajes que se
mueven sobre l, luego los bloques afectados deberan ser copiados otra vez.
Cuando la pantalla se desplaza los bloques, pese a ser los mismos, ya no
ocupan la misma posicin, as que hay que volver a pintarlos.
Si quisiramos optimizar la copia habra que resolver estos dos problemas. El primero
es sencillo y su solucin se basa en tener una matriz que indica que bloques han sido
afectados por los objetos o caracteres. El segundo problema es ms complicado aunque
la solucin es muy elegante: en las tarjetas grficas VGA puede reproducirse el mismo
esquema de gran pantalla virtual y ventana visible. Habra que utilizar toda la
memoria grfica de una VGA convencional (1Moct) para dibujar ah todo el fondo
virtual, luego puede escogerse qu regin visualizar a travs de unos registros internos
de la VGA. Se trata pues, de repetir el enfoque de la mquina original. Esta
programacin es ms complicada que la actual aunque es la que ofrece el mejor
rendimiento. No se lleg a realizar porque la velocidad alcanzada por el emulador era
ya suficiente.
133

Jos Tejada Gmez
Resumen de las funciones

Se presentan a continuacin las funciones escritas en lenguaje C y que forman parte del
flujo normal del programa. El pilago de rutinas en ensamblador que constituyen la
emulacin del procesador no se detalla aqu, puesto que su orden de llamada depende
de la mquina en s. Pueden consultarse, de todas formas, en el apartado sobre
emulacin del procesador.
Nombre
carga
carga_rom
Fichero
Descripcin
gng_dir.c restaura la memoria RAM para continuar una partida antigua

gng.c
carga en memoria todos los ficheros ROM
gng_dir.c analiza el contenido de la lnea de rdenes

transforma el formato de almacenamiento de los grficos en uno
decodifica_graficos gng_dir.c apropiado para el emulador
despedida
gng.c
imprime unas lneas al terminar el programa
cmdline
destruye_sonidos
gng.c
libera la memoria empleada en los sonidos
dibuja_fondo
dibuja_pantalla
segn las variables de desplace, copia una ventana desde el fondo virtual
gng_dir.c al real
gng.c
interpreta la memoria grfica de la mquina para dibujar la pantalla.
Sincronizacin con el trazado vertical
6809c.c
se encontr una operacin del 6809 ilegal
gng.c
rutina de gestin centralizada de errores
irq
libera_rom
6809c.c
gng.c
dispara una interrupcin

libera la memoria empleada en los ficheros ROM
main
gng.c
arranque del emulador, contiene el bucle de emulacin
mensaje
gng.c
imprime un mensaje usando la circuitera grfica de la mquina
ilegalC
imprime_error
muestra_mensajes gng.c
imprime mensajes sobre la pantalla del videojuego
prepara_memoria
prepara_sonido
gng_dir.c valores iniciales del 6809 para que arranque adecuadamente

gng.c
lee los ficheros .wav utilizados para simular el sonido
presentacin
gng.c
salva
teclado
gng_dir.c salva la memoria RAM del juego para poder continuar la partida ms tarde
gng.c
lee el teclado e informa a la mquina
temporizador
gng.c
ejecutada a 60Hz, aumenta contadores relacionados con el sincronismo
toca_sonidos
gng.c
reproduce los sonidos
vuelca_regs
6809c.c
muestra el contenido de los registros
imprime unas lneas al arrancar el programa
134

Jos Tejada Gmez
Diamond Run y Makaimura

Cuando el emulador de Ghosts & Goblins estaba casi terminado apareci en la intern el
volcado de las memorias de otro juego, Diamond Run, que funcionaba en la misma
mquina que G&G, sin ms que sustituir unas EPROM por otras. En el cdigo del
emulador slo hubo que aadir una opcin para cargar unos ficheros en vez de otros y
hacer que los punteros de las pginas apuntasen a otras posiciones. Al mismo tiempo
se aadi soporte para la versin japonesa de G&G cuya nica diferencia es,
aparentemente, la portada del juego donde en vez de decir Ghosts&Goblins (Fantasmas
y duendes) dice
, que se lee ma-kai-mura. Esta palabra esta compuesta por
tres ideogramas: el primero significa maldad mgica, el segundo lmite y el tercero
pueblo. La combinacin de los dos primeros significa infierno, luego el ttulo del
juego en la versin japonesa es pueblo del infierno.
if ( juego != DIAMOND )
{
if (juego == GNG_USA) ram[0x607a] = ram[0x607b] = ram[0x607c] = 0x12; /*nop
se salta las comprobaciones del arranque*/
paginas[0]=rom[4];
paginas[2]=rom[4]+8*1024*2;
paginas[3]=rom[4]+8*1024*3;
paginas[4]=rom[3];
}
else
{ /* pginas de diamond Run */
paginas[0]=rom[4]+0x4000;
paginas[1]=rom[11];
paginas[2]=rom[11] + 2*0x4000;
paginas[3]=rom[11] + 3*0x4000;
paginas[4]=rom[11] + 4*0x4000;
}
}
El truco para saltarse el arranque slo se aplica en el juego G&G norteamericano

porque en los otros el cdigo es ligeramente distinto y habra que buscar la posicin de
memoria que modificar.
Portada de DR
Juego (DR)
Makaimura
135

Jos Tejada Gmez
Grytra , emulador de Gryzor y Contra

Tras terminar mapefer3 el bachillerato de emulacin haba sido superado y llegaba el
momento de hacer un emulador desde cero, realizando toda la investigacin e
ingeniera inversa por uno mismo. A travs de una pgina de internet localizada en
Australia dimos con un volcado de una placa pirata de Gryzor, tras copiar el fichero al
ordenador; comenz la investigacin que desemboc en el primer emulador mundial
de Gryzor.
Dado que este emulador se escribi poco tiempo despus de acabar mapefer3, la
plataforma escogida fue la misma: el compilador gcc, el entorno Rhide y la biblioteca
grfica Allegro. A ello se una el ya veterano emulador del 6809 programado para
mapefer3.
En esta ocasin no haba ningn dato sobre el funcionamiento del equipo as que hubo
que investigarlo todo. Eso convirti al emulador en un diseo mixto: analizador y
emulador, a la vez que favoreci el desarrollo pero dio lugar a un programa lento e
ineficiente para jugar, al contrario que mapefer3 que era rapidsimo.

Grytra est basado en el cdigo de mapefer3 y utiliza el mismo emulador para el
procesador. Los diagramas de flujo son idnticos a los ya mostrados y no se repetirn.
La nica diferencia es que Grytra incluye mucho cdigo adicional para ayudar al
desarrollo y depuracin del emulador, puesto que ste se program conforme se iba
descubriendo el funcionamiento de la mquina mediante ingeniera inversa.
A continuacin detallaremos algunas de las funciones usadas durante la investigacin,
mostrando fragmentos de su cdigo y explicando su finalidad y funcionamiento. Las
funciones que cumplen el mismo propsito en ambos emuladores como la de
dibujado de objetos- se omiten en esta explicacin, aunque obviamente stas difieren
entre los dos programas, puesto que emulan circuitera diferente.
El cdigo de Grytra utiliza compilacin condicional; es decir, hay unas macros que
seleccionan qu partes del programa se compilarn y enlazarn, stas son:
MAPA: Esta versin de Grytra genera un mapa de memoria indicando dnde

ha habido lecturas y escrituras. Sirve para localizar puertos de E/S ya que si en
una posicin de memoria slo ha habido lecturas o slo ha habido escrituras ha
de tratarse de una regin especial. Por ejemplo, de las palancas slo hay
lecturas y del registro de sonido slo hay escrituras
DEPURA: Si est habilitada, esta compilacin ejecuta el juego en 320x240 para
poder mostrar un volcado de la memoria RAM mientras funciona la emulacin.
MUESTRA_SI: Se superpone una lnea en la pantalla con el valor de las
variables usadas durante la depuracin (SI, N y N2)
136

Jos Tejada Gmez
vuelca_ram
Dadas las caractersticas grficas de Gryzor, puede utilizarse el modo grfico de
320x240 para mostrar en un cuadrado de 240x240 el juego a la izquierda y utilizar el
rectngulo derecho de 80x240 para mostrar informacin de depuracin, etc.
La presente funcin utiliza ese rectngulo para hacer un volcado hexadecimal de la
memoria virtual del 6809. La direccin inicial depender del valor de la variable global
n, utilizada de forma genrica en todas las rutinas de investigacin. Esta variable se
modifica utilizando las teclas + y del teclado numrico mientras se pulsa ALT.
El volcado de la memoria virtual es importante porque permite encontrar los registros
de E/S del sistema. As por ejemplo, cuando el desplace de los fondos todava no
estaba programado se pudo encontrar la posicin de los registros de desplace gracias a
la observacin de las escrituras en la memoria de vdeo y las posiciones de memoria
que variaban solidariamente.
void vuelca_ram()
{
int c1,c2;
char frase[255];
int c;
c=n;
for( c1 = 0; c1 < (SCREEN_H-24)/16; c1++ )
{
sprintf( frase, "%4X ",c1*16+c );
textout( screen, font, frase, 280, c1*8+24, 255 );
for( c2 = 0; c2 < 0x10; c2++ )
{
sprintf( frase, "%2X ", ram[c+c1*16+c2]);
textout( screen, font, frase, 280+c2*8*3+8*6, c1*8+24, 255 );
}
}
}
muestra_mapa
Esta funcin imprime el vector mapa, que contiene la informacin sobre las posiciones
de memoria que han sido accedidas durante la emulacin y sobre el modo del acceso:
lectura, escritura o ambas.
salva y carga
Estas funciones, tambin disponibles en mapefer3, vuelcan la memoria virtual a un
fichero binario y viceversa. Sirven para almacenar el estado del juego y poder as
continuar la partida ms tarde.
muestra_muecos
Durante la investigacin es preciso descifrar el formato de la memoria de objetos. Esta
funcin vuelca esa memoria para poder evaluarla en un momento dado o ver cmo se
modifica durante el transcurso del juego.
137

Jos Tejada Gmez
Escuela de combate, emulador de Combat School

Cuando se program Escuela de combate, los emuladores comenzaban a ser realmente
populares y estaban ya disponibles muchos de los juegos de 8 dgitos; sin embargo,
aun haba lagunas importantes y la emulacin de un ttulo tan emblemtico de los aos
80 como Combat School todava no haba sido acometida. En este emulador colaboraron
Cesreo Gutirrez y sobre todo Manuel Abadia, ambos estudiantes de la Universidad
de Murcia.
Para aumentar el inters en la programacin se decidi utilizar Microsoft Visual C++ 5.0
comprando una licencia de estudiante por unos 100 euros, dando as el salto a Windows.
Esto tuvo grandes repercusiones:
el antiguo emulador del 6809 dejaba de ser til, puesto que era difcil
ensamblarlo para Win32, se aprovech para la ocasin un mdulo
preensamblado llamado A6809.obj y desarrollado por Larry Bank para simular
el procesador.
la biblioteca grfica usada anteriormente: Allegro, no funcionaba con Windows
as que tuvimos que utilizar las aun imberbes DirectX para toda la gestin
grfica. Esto aada una nueva dificultad, ya que el modelo de programacin de
DirectX basado en COM47, no nos era familiar en absoluto.
el mero hecho de programar para Windows hizo sencillo dotar al programa de
una interfaz de usuario ms amigable, por lo que se invirti ms tiempo en ella
que anteriormente.
Visual C++ con el proyecto Escuela de combate
COM es una tecnologa de Microsoft basada en dotar a los programas de interfaces a travs
de las cuales se puedan comunicar entre s. COM es la base de, por ejemplo, los objetos ActiveX,
la tecnologa OLE, de DirectX y del acceso a datos OLEdB.
47
138

Jos Tejada Gmez
Al programar en C/C++ para Windows existen dos caminos posibles: las ya
comentadas MFC y la API48 , se opt por la segunda dada la mayor flexibilidad y
velocidad de sta. Paralelamente al emulador se desarroll el Analizador, como la
prioridad ah era el desarrollo rpido y no la celeridad de ejecucin del ulterior
proceso; se prefirieron las MFC.

En esta seccin comentaremos brevemente las funciones bsicas del emulador.
WinMain
Esta funcin es el punto de entrada de todo programa para el sistema Windows. En ella
se realizan dos labores diferenciadas: el proceso de mensajes mediante el
acostumbrado bucle y el arranque y apagado de la emulacin en s.
while ( GetMessage( &msg, NULL, 0,0 ) )
{
TranslateMessage( &msg ); /* Se permite el uso del teclado */
DispatchMessage( &msg ); /* devuelve el control a Windows */
}
Bucle de mensajes
if ( Arranca() != 0 )
{
MessageBox(
NULL,"No
fatal",MB_ICONEXCLAMATION | IDOK
return 0;
}
if ( ArrancaGraficos() != 0 )
{
MessageBox(
NULL,"No
fatal",MB_ICONEXCLAMATION | IDOK
return 0;
}
se
);
encuentran
se
);
encuentran
las
las
ROM
ROM
1-4","Error
5-20","Error
Arranque del equipo emulado
Durante el arranque es preciso leer las memorias ROM, proceso que naturalmente
puede fallar y cuyo error causa el fin del programa. Estas funciones sern explicadas
posteriormente.
Apaga();
ApagaGraficos();
Apagado del equipo
Apagar el equipo es realmente liberar la memoria reservada y detener la hebra que

procesa la emulacin del procesador.
Interfaz para el Programador de Aplicaciones. Son las llamadas al sistema de bajo nivel que
prove Windows
48
139

Jos Tejada Gmez
Arranca
El objetivo de esta funcin es preparar el procesador virtual.
Arranca()
{
int iError;
Carga las cuatro ROM de procesadores

pROM[0]
pROM[1]
pROM[2]
pROM[3]
=
=
=
=
CargaROM(
CargaROM(
CargaROM(
CargaROM(
Prepara el mapa de memoria
"roms\\combat.001");
if ( pROM[0] && pROM[1] && pROM[2] && pROM[3] )

{
int i;
pMem6809 = malloc( 64*1024*3 ); /* prepara la memoria del 6809 */
Los circuitos grficos tienen su propia memoria

pVideo0 = malloc( 0x4000 );
pVideo1 = malloc( 0x4000 );
El mapa del procesador hay que especificarlo como aqu se indica, la explicacin de este
procedimiento se encuentra en la seccin del 6809.
grficos
memset( pMem6809+MEM_FLAGS, 0, 64*1024 );

memset( pMem6809+MEM_RAM, 0xff, 64*1024 );
memset( pMem6809+MEM_FLAGS+0x4000, 2, 0x4000 ); // pginas
memset( pMem6809+MEM_FLAGS+0x2000, 3, 0x2000 ); // circuitos
pMem6809[ MEM_FLAGS + 0x500 ] = 4; // registro de selecciones
memset( pMem6809+MEM_FLAGS+0x8000, 1, 0x8000 ); // ROM
memcpy( pMem6809+MEM_ROM+0x8000, pROM[1]+0x8000,0x8000 );
reinicia el procesador:
ARESET6809(pMem6809, &regs6809 );
La paginacin de memoria se hace a travs de unos vectores de punteros. Su valor correcto se

carga en los siguientes bucles
retardo
for(i=0;i<32;i++ )
pPagina[i] = pROM[1]; // para no provocar ningn error
for( i=0;i<2;i++)
pPagina[0x0+i] = pROM[1]+i*2*0x2000;
for( i=0;i<8;i+=2)
{
pPagina[0x10+i] = pROM[2]+i*0x2000;
pPagina[0x18+i] = pROM[3]+i*0x2000;
}
pPagina[1][0x6145-0x4000]=0x39; // para evitar la rutina
de
pPagina[0x1f] = pPagina[0x1];
/* fin */
iError = 0;
}
else iError = 1;
return iError;
140

Jos Tejada Gmez
ArrancaGraficos
Esta funcin descodifica el formato de la mquina y prepara el mapa de puntos que
utiliza Windows para visualizar imgenes.
int ArrancaGraficos()
{
int i;
BITMAPINFOHEADER biInfo;
Carga las memorias ROM que contienen grficos
pROM[4]=CargaROM("roms\\combat.005");
/
pROM[19]=CargaROM("roms\\combat.020");
for ( i = 4; i<20; i++ )
if ( !pROM[i] ) return 1; // error
prepara el mapa de puntos con la informacin adecuada
memset( &biInfo, 0, sizeof( BITMAPINFOHEADER ) );

biInfo.biSize = sizeof( BITMAPINFOHEADER );
ancho y alto
biInfo.biWidth= 256;
biInfo.biHeight = -256;
biInfo.biPlanes = 1;
biInfo.biBitCount = 8; // 256 colores
biInfo.biSizeImage = 256*256;
biInfo.biClrUsed = 128;
La estructura BITMAPINFO se completa de una forma peculiar, que no est bien

documentada por Microsoft:
pbiInfo = (BITMAPINFO *) malloc (sizeof(BITMAPINFOHEADER)
+(128*sizeof(RGBQUAD)) );
pbiInfo->bmiHeader = biInfo; // copiamos la cabecera
pPaleta = (RGBQUAD *) ((char *)pbiInfo+sizeof(BITMAPINFOHEADER) );
memset( pPaleta,PC_NOCOLLAPSE,128*sizeof(RGBQUAD) );
Ahora se hacen llamadas a Decodifica que hace lo propio con los grficos adaptndolos a un
formato manejable por el programa.
for(i=0;i<4;i++) Decodifica(i); // 0,1 => caracteres del fondo; 2 y 3
=>objetos
memset( pPantalla, 0, 256*256 ); // limpia el fondo
return 0; // todo bien.
}
WindowFunc
Esta funcin maneja el flujo del proceso respondiendo a los eventos de Windows, por
claridad se omite parte del cdigo para destacar lo importante.
Windows 95 llama a esta funcin que recibe mensajes de la cola de mensajes.
LRESULT CALLBACK WindowFunc( HWND hwnd,UINT message, WPARAM wParam, LPARAM
lParam )
{
.../... (declaracin de variables locales)

Segn el mensaje que llegue:
switch( message )
{
case WM_CREATE:
cuando se crea la ventana se inicia la hebra que procesa la emulacin del procesador.
141

Jos Tejada Gmez
h6809
CreateThread(
NULL,0,Emula6809,(LPVOID)hwnd,0,
&Hebra6809 );
.../...
El evento hEmula indica si la hebra del procesador ha de esperarse o puede seguir con su
labor
hEmula = CreateEvent( NULL, FALSE, TRUE, "Emula" );
.../...
ConfiguraTeclado( &cfgTeclas );
/* configura la paleta, esto es diferente con DirectX */
/* Promediado de la velocidad */
ips.tiempo0 = timeGetTime();
ips.pintadas=0;
break;
case WM_PAINT:
Aqu se pinta la pantalla cada 16ms, esto se hace en dos pasos: primero en una imagen virtual
y luego copindola al dispositivo grfico que el usuario puede ver.
hdc = BeginPaint( hwnd, &ps );
PintaPantalla();
if ( SetDIBitsToDevice( hdc,
0,0, // coordenadas destino
255, 240,
0,0, // coordenadas origen
16, 240, // inicio y final de las lneas
pPantalla, pbiInfo, DIB_RGB_COLORS ) == 0 )
{
MessageBox( hwnd, "Error al volcar la pantalla","",IDOK );
PostQuitMessage(1);
}
EndPaint( hwnd, &ps );
El proceso de emulacin puede continuar con su trabajo ahora:

SetEvent(hEmula);
.../...
break;
Pulsaciones del teclado:

case WM_KEYUP:
ucTecla[wParam ] = 0; /* activa esa tecla */
Teclado(&cfgTeclas,ucTecla); // gestiona las teclas
break;
case WM_KEYDOWN:
ucTecla[ wParam ] = 1; /* activa esa tecla */
Teclado(&cfgTeclas,ucTecla); // gestiona las teclas
break;
case WM_DESTROY: /* finalizacin del programa */
PostQuitMessage(0);
break;
default: /*Se permite a Windows 95 que procese todos los mensajes no
especificados
en la anterior sentencia "switch". */
return DefWindowProc( hwnd, message, wParam, lParam);
}
return 0;
}
142

Jos Tejada Gmez
Emula6809
Esta funcin ejecuta el nmero preciso de instrucciones del 6809 entre dos imgenes sin
que por ello el bucle de mensajes de Windows se interrumpa; para ello, ha de estar en
una hebra separada. La sincronizacin entre ambas se realiza de forma muy sencilla
con un evento:
DWORD WINAPI Emula6809(LPVOID hwnd1)
{
RECT Rect= {0,0,256,256 };
HANDLE hSuceso;
HWND hwnd;
hSuceso = OpenEvent( EVENT_ALL_ACCESS, FALSE, "Emula" );
hwnd = (HWND) hwnd1;
do
{
WaitForSingleObject( hSuceso, INFINITE );
CalculaImagen();
InvalidateRect( hwnd, &Rect, FALSE );
}while(1);
return 0;
}
Teclado
El teclado es configurable a travs de la estructura STeclas. El cdigo de la tecla leda
por Windows se compara con los valores de dicha estructura y la cifra adecuada de la
memoria del 6809 se cambia consecuentemente. Para hacer ms legible el cdigo se ha
utilizado una macro.
void Teclado(struct STeclas *sTeclas, unsigned char ucTeclas[256])
{
static unsigned char uc4400=0xff, uc4401=0xff, uc4402=0xff, uc4403=0xff;
#define TECLA( a,b,c ) if( ucTeclas[a] ) b &= ~c; else b |= c;
// Echar monedas
TECLA( sTeclas->ucMoneda1, uc4400, 8 );
TECLA( sTeclas->ucMoneda2, uc4400, 0x10 );
// Comenzar la partida
TECLA( sTeclas->uc1P, uc4400, 4 );
TECLA( sTeclas->uc2P, uc4400, 0x80 );
// controles del primer jugador
TECLA( sTeclas->arriba[0], uc4401, 0x80 );
TECLA( sTeclas->abajo[0] , uc4401, 0x40 );
TECLA( sTeclas->izquierda[0], uc4401, 0x20 );
TECLA( sTeclas->derecha[0], uc4401, 0x10 );
TECLA( sTeclas->saltar[0], uc4400, 0x2 );
TECLA( sTeclas->correr[0], uc4400, 0x1 );
// controles del segundo jugador
TECLA( sTeclas->arriba[1], uc4401, 0x8 );
TECLA( sTeclas->abajo[1] , uc4401, 0x4 );
TECLA( sTeclas->izquierda[1], uc4401, 0x2 );
TECLA( sTeclas->derecha[1], uc4401, 0x1 );
TECLA( sTeclas->saltar[1], uc4400, 0x40 );
TECLA( sTeclas->correr[1], uc4400, 0x20 );
ucPuerto[0] = uc4400; // asigna el valor
ucPuerto[1] = uc4401;
}
143

Jos Tejada Gmez
Conclusin e investigaciones ulteriores

En este proyecto se ha expuesto el funcionamiento de los sistemas de mquinas
recreativas y se han desarrollado, con xito, tres emuladores diferentes de otros tantos
sistemas, consiguindose resultados plenamente fidedignos a las mquinas originales;
que se detallan en la siguiente tabla:
Emulador
Juego
Mapefer3 Ghosts&Goblins
Grytra
Escuela
de
combate
Gryzor/Contra
Combat School
Velocidad (%)
Fidelidad
486DX PentiumIII
de los
100MHz 600 MHz
colores
Objetos
grficos
Dispositivos
de entrada
Falta la
prioridad
de
Perfectos
fondos
sobre
objetos
Todos, el
usuario
puede elegir
la
configuracin
de los DIP
Palancas
bien, slo son
configurables
algunos DIP
100
100
60
100
Faltan
algunos Perfectos
parpadeos
100
Las
Palancas
regiones
Faltan
lmites de bien, slo son
algunos Perfectos
la pantalla configurables
parpadeos
son
algunos DIP
mejorables
100
Perfecta
Fondos
grficos
Perfectos
En cuanto al primer objetivo del proyecto: la documentacin; sta se ha elaborado

cubriendo en diversos captulos: los componentes del sistema, el funcionamiento
electrnico de la placa y del circuito sonoro, la descripcin del comportamiento de los
circuitos grficos. Se han incluido adems extractos de esquemas reales de mquinas
recreativas explicando la interconexin de los elementos tanto con dichos esquemas
como con diagramas de bloques.
El nico apartado abandonado ha sido el sonido, pese a que se ha explicado cual sera
el enfoque a seguir, no se lleg a desarrollar un emulador del circuito sonoro. En la
actualidad esta opcin est ya muy investigada y hay cdigos fuente de simuladores
de sonido disponibles pblicamente. En caso de querer incluir el sonido, habra que
aadir tambin la emulacin de un segundo procesador; esto complicara un poco el
bucle de la emulacin, pero esencialmente seguira igual.
Un campo ms interesante es el de las mquinas tridimensionales. Estos equipos tienen
una circuitera grfica basada no en dibujar mosaicos sino tringulos; su
funcionamiento es, por lo tanto, muy diferente y presenta adems el resto de tratar de
emularlos utilizando los recursos que ofrecen las tarjetas aceleradoras 3D de los
ordenadores convencionales.
Otra rea interesante es la recompilacin, siendo sta posible de dos formas: esttica y
dinmica. Recompilar es el proceso por el que se obtiene cdigo nativo de una
144

Jos Tejada Gmez
mquina a partir del cdigo mquina de otra; para ello es necesario analizar y traducir
el programa. Esto proceso necesita un programa especial al efecto: el recompilador.
Cada juego tiene una E/S distinta y un circuito grfico diferente, por lo que estos
efectos tambin han de ser tenidos en cuenta.
Si la recompilacin es esttica ha de recorrerse el programa incluyendo todas las
posibles bifurcaciones condicionales y saltos por interrupcin; al mismo tiempo se
traducen las instrucciones con especial atencin a las posiciones de memoria.
Finalmente se aade el cdigo de emulacin de la circuitera grfica, sonora y de la E/S
y se obtiene un nuevo ejecutable que contiene el juego traducido a la nueva plataforma.
La recompilacin dinmica es ms flexible y pretende convertir en tiempo real las
instrucciones primitivas a las del nuevo procesador y ejecutarlas en l de forma nativa.
Hace falta tener tambin un cuidado especial con las direcciones de memoria. Las
variables a manejar durante la recompilacin dinmica son muchas, puesto que si la
operacin se hace instruccin a instruccin resulta demasiado lenta y si se hace de
largos bloques es difcil mantener la sincronizacin. Las mquinas virtuales de Java
utilizan esta arquitectura hoy en da.
La emulacin permite rescatar programas antiguos, ldicos o productivos para su uso
en las mquinas modernas. Pese a que es difcil saber si la recreacin es plenamente
fidedigna al original es posible adoptar soluciones intermedias, que cumplan hasta lo
necesario haciendo viable el aprovechamiento de la inmensa cantidad de programas
existentes para las plataformas ya desaparecidas.
145

Jos Tejada Gmez
Bibliografa
Videogames on Alternative Monitors FAQ, Jonathan Dawes, jond@videologic.com
Devastators, Instruction Manual, Konami, 1988
Contra, Instruction Manual, Konami, 1987
YM2151 FM Operator Type-M, Yamaha Corporation, 1991
YM3012 2-Channel Serial Input Floating D/A Converter, Yamaha Corporation, 1992
YM3014B Serial Input Floating D/A Converter, Yamaha Corporation, 1994
Ms Pacman Parts and Operating Manual, Midways/Namco, 1982
Arcade Emulation How-To, Michael Adcock, adcock@menudo.uh.edu
146

Jos Tejada Gmez
Y|| vt
Este documento fue editado durante el verano de 2002, en Lmeri (Irlanda)
y
se remat en diciembre del mismo ao en Valencia (Espaa)
147

De La Emulación de Las Máquinas Recreativas - JOSÉ TEJADA GÓMEZ - (147págs)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

De La Emulación de Las Máquinas Recreativas - JOSÉ TEJADA GÓMEZ - (147págs)

Enviado por

Direitos autorais:

Formatos disponíveis

De la emulacin de mquinas recreativas

Jos Tejada Gmez

Jos Tejada Gmez

De la emulacin de mquinas recreativas

De la emulacin de mquinas recreativas

De la emulacin de mquinas recreativas

De la emulacin de mquinas recreativas

De la emulacin de mquinas recreativas

Gryzor, versin de Amstrad CPC (1987)

Gryzor, versin original (1987)

De la emulacin de mquinas recreativas

Pero el tiempo pas, la electrnica aument su capacidad de integracin y

De la emulacin de mquinas recreativas

Describir los componentes de una mquina

De la emulacin de mquinas recreativas

Descripcin general: El mueble, las palancas y el monedero

Ms Pac-Man , mueble normal

Ms Pac-Mac, mueble mesilla

De la emulacin de mquinas recreativas

Marquesina de Contra (Apodo de Gryzor en Europa)

De la emulacin de mquinas recreativas

tubo fluorescente de la marquesina

soporte del monitor (dos posiciones)

De la emulacin de mquinas recreativas

La empresa navarra Azkoyen es la principal suministradora de monederos en Espaa

De la emulacin de mquinas recreativas

Para partidas a 25 Ptas. usando un solo canal

Para partidas a 50 Ptas. usando dos canales.

monedero real, desmontaje

De la emulacin de mquinas recreativas

Conexin de una mquina recreativa a un televisor domstico6

fotografa de un cable euroconector-euroconector

El conexionado es como sigue:

salida del canal de sonido B

Esta seccin est basada en el trabajo de Jonathan Dawes

De la emulacin de mquinas recreativas

patilla del euroconector

Adems las patillas 8 y 16 sirven para seleccionar el tipo de seal de entrada, en

De la emulacin de mquinas recreativas

posicin de la placa en el mueble mesilla

La placa suele ir atornillada verticalmente al mueble en la parte inferior del mismo,

De la emulacin de mquinas recreativas

De la emulacin de mquinas recreativas

El sistema de vdeo de una mquina de videojuegos

Ha de dibujarse girado horizontalmente?

De la emulacin de mquinas recreativas

Funcionamiento de la memoria de fondos

De la emulacin de mquinas recreativas

Funcionamiento de la pantalla virtual

De la emulacin de mquinas recreativas

Movimiento de los objetos

bloque grfico en la ROM que representa al objeto

De la emulacin de mquinas recreativas

El sistema de audio de una mquina de videojuegos

De la emulacin de mquinas recreativas

Diagrama de bloques de un sintetizador basado en MIC

tren de pulsos, se indican el perodo y la amplitud

envolvente tpica de una nota

De la emulacin de mquinas recreativas

Recapitulando, el diagrama de bloques genrico para estos circuitos sera:

Diagrama de bloques de un sintetizador MIC

Externamente se colocara un filtro paso bajo, como complemento al convertidor D/A;

De la emulacin de mquinas recreativas