Siguiendo con la lista de aparatos que usaban este chip, y tras repasar los juegos arcade aquí, paso a buscar ordenadores con este chip.

Sólo hay dos líneas de equipo que de serie vinieran con este chip. La primera es un equipo de 8 bits, el Sharp X1, que contaba con nuestro querido Z80. Además del repaso técnico de la Wikipedia, os recomiendo leer esta entrada del blog de SH2Central sobre este curioso equipo.

El Sharp X1

El otro equipo que usó este chip fue el famoso Sharp X68000. De nuevo SH2Central le da un repaso a este sistema que os recomiendo. Este sistema lleva un YM2151 pero en las fotografías de la placa base que he visto por internet no he podido encontrarlo. Quizá se encontraba en una placa hija o estaba integrado dentro de otro chip (me extrañaría). Os dejo una foto de la placa del misterio.

Sharp X68000, placa base

¿Hasta qué punto podría resultar útil un clon del YM2151 en Verilog? Para responder a esa pregunta inicio una serie de tres entradas con datos exhaustivos de uso de este chip. Empezamos por los reyes de la casa: los videojuegos arcade.

El YM2151 fue ampliamente usado en los salones recreativos, sobre todo 1988 y 1998, la época del tandem M68000/Z80 en las placas arcade.

La siguiente lista está extraída a partir de los juegos emulados en MAME 173. En total 1012 juegos, sin contar clones ni versiones.

El ruido que oímos en los juegos, normalmente usado para simular explosiones, golpes, etc. es generado de forma aleatoria en el interior del chip. ¿Aleatoria de verdad? Bueno, aunque los procesadores modernos sí suelen llevar un verdadero generador de números aleatorios basado en propiedades físicas de los circuitos, en el pasado y en muchas aplicaciones modernas se usa un tipo de circuito llamado registro de desplazamiento con realimentación lineal, LFSR por sus siglas en inglés (wikipedia).

En el código fuente del emulador del MAME (ym2151.c) encontramos la siguiente tabla para emular el ruido:


/*
Noise LFO waveform.
Here are just 256 samples out of much longer data.
It does NOT repeat every 256 samples on real chip and I wasnt able to find
the point where it repeats (even in strings as long as 131072 samples).
I only put it here because its better than nothing and perhaps
someone might be able to figure out the real algorithm.
Note that (due to the way the LFO output is calculated) it is quite
possible that two values: 0x80 and 0x00 might be wrong in this table.
To be exact:
some 0x80 could be 0x81 as well as some 0x00 could be 0x01.
*/
static UINT8 lfo_noise_waveform[256] = {
0xFF,0xEE,0xD3,0x80,0x58,0xDA,0x7F,0x94,0x9E,0xE3,0xFA,0x00,0x4D,0xFA,0xFF,0x6A,
0x7A,0xDE,0x49,0xF6,0x00,0x33,0xBB,0x63,0x91,0x60,0x51,0xFF,0x00,0xD8,0x7F,0xDE,
0xDC,0x73,0x21,0x85,0xB2,0x9C,0x5D,0x24,0xCD,0x91,0x9E,0x76,0x7F,0x20,0xFB,0xF3,
0x00,0xA6,0x3E,0x42,0x27,0x69,0xAE,0x33,0x45,0x44,0x11,0x41,0x72,0x73,0xDF,0xA2,
0x32,0xBD,0x7E,0xA8,0x13,0xEB,0xD3,0x15,0xDD,0xFB,0xC9,0x9D,0x61,0x2F,0xBE,0x9D,
0x23,0x65,0x51,0x6A,0x84,0xF9,0xC9,0xD7,0x23,0xBF,0x65,0x19,0xDC,0x03,0xF3,0x24,
0x33,0xB6,0x1E,0x57,0x5C,0xAC,0x25,0x89,0x4D,0xC5,0x9C,0x99,0x15,0x07,0xCF,0xBA,
0xC5,0x9B,0x15,0x4D,0x8D,0x2A,0x1E,0x1F,0xEA,0x2B,0x2F,0x64,0xA9,0x50,0x3D,0xAB,
0x50,0x77,0xE9,0xC0,0xAC,0x6D,0x3F,0xCA,0xCF,0x71,0x7D,0x80,0xA6,0xFD,0xFF,0xB5,
0xBD,0x6F,0x24,0x7B,0x00,0x99,0x5D,0xB1,0x48,0xB0,0x28,0x7F,0x80,0xEC,0xBF,0x6F,
0x6E,0x39,0x90,0x42,0xD9,0x4E,0x2E,0x12,0x66,0xC8,0xCF,0x3B,0x3F,0x10,0x7D,0x79,
0x00,0xD3,0x1F,0x21,0x93,0x34,0xD7,0x19,0x22,0xA2,0x08,0x20,0xB9,0xB9,0xEF,0x51,
0x99,0xDE,0xBF,0xD4,0x09,0x75,0xE9,0x8A,0xEE,0xFD,0xE4,0x4E,0x30,0x17,0xDF,0xCE,
0x11,0xB2,0x28,0x35,0xC2,0x7C,0x64,0xEB,0x91,0x5F,0x32,0x0C,0x6E,0x00,0xF9,0x92,
0x19,0xDB,0x8F,0xAB,0xAE,0xD6,0x12,0xC4,0x26,0x62,0xCE,0xCC,0x0A,0x03,0xE7,0xDD,
0xE2,0x4D,0x8A,0xA6,0x46,0x95,0x0F,0x8F,0xF5,0x15,0x97,0x32,0xD4,0x28,0x1E,0x55
};


Jarek Burczynski, el autor del emulador del YM2151 usado en MAME y casi en cualquier otro sitio, habla sobre cómo estas medidas de la salida del YM2151 no son periódicas, incluso después de más de cien mil muestras. También dice que algunos valores podrían estar mal debido a la forma de extraer los datos y su relación con el oscilador de baja frecuencia del chip (el LFO).

Asumiendo que estos valores debían de provenir de un LFSR y que lo más lógico era tener un LFSR por cada bit, apliqué el algoritmo de Berlekamp-Massey (wikipedia) para obtener ese supuesto registro de desplazamiento. Y este fue el resultado:

 Para todos los bits, salvo el 0 y el 4, de la secuencia de Jarek B. existe un LFSR de orden 19 y realimentación en las etapas 0, 1, 14, 15, 17 y 18.

Así que los bits que no se extrajeron bien en algunos casos fueron el 0 y el 4 y no el 0 y el 8 como pensaba Jarek. Fijaos que es la misma secuencia pseudoaleatoria para todos los bits de la palabra de ruido pero como cada LFSR está iniciado en un punto distinto de la secuencia, no van a coincidir nunca. La secuencia completa de cada bit tiene una longitud de 2^18, mucho mayor que los cien mil valores que Jarek tomó del chip. Además para ver una repetición tiene que coincidir que todas las secuencias se estén repitiendo. No voy a hacer el cálculo, pero el periodo de la secuencia es mucho mayor que 2^18.

Con estos datos ya es posible usar el mismo circuito que el original para producir el mismo ruido. Esto se puede aplicar a corregir el fichero ym2151.c de MAME o a seguir escribiendo el clón en verilog, que es lo que me ocupa a mí.

En la próxima entrada escribiré los valores con los que hay que iniciar cada LFSR para obtener la secuencia de ruido.

Después de prepararme para controlar un YM2151 a través de MAME (explicación). Aquí va mi primera nota, no sin esfuerzo. Para ello escribo los siguientes valores en los registros:

Sólo con esto ya se consigue sonido… una vez. Para repetirlo hay que volver a escribir a YM_KEYON ($78), esta vez con un $00 y luego volver a escribir un $78 para que empiece el sonido de nuevo. La repetición la hago en el código usando los temporizadores del YM2151 para esperar aproximadamente medio segundo.

A continuación está el código completo en ensamblador del 6809. Este código lo ensamblo y corro con el MAME.


; YM Registers
YM_KEYON EQU $08
YM_TIMERB EQU $12
YM_TIMER_CTRL EQU $14
YM_CT EQU $1B
YM_CONNECTION EQU $20
YM_KEY_CODE EQU $28
YM_KEY_FRACTION EQU $30
YM_PMS EQU $38
YM_PHASE_MUL EQU $40
YM_DETUNE2 EQU $C0
YM_ATTACK_RATE EQU $80
YM_DECAY1_RATE EQU $A0
YM_DECAY2_RATE EQU $C0
YM_RELEASE_RATE EQU $E0
; YM LOCATION IN THE MEMORY MAP
YM_ADR EQU $2000
YM_DATA EQU $2001
ORG $8000
RESET LDD #$6800
TFR D,S
; SET TOTAL LEVEL TO 00 FOR ALL CHANNELS
LDA #$60
STA $6000
TL_NXT: LDA $6000
CMPA #$80
BEQ PLAY
LDB #$00
JSR WRITE_YM
INC $6000
BRA TL_NXT
PLAY JSR WAIT
LDB #$C7
LDA #YM_CONNECTION
JSR WRITE_YM
LDB #$4A ; A 440Hz
LDA #YM_KEY_CODE
JSR WRITE_YM
LDB #1
LDA #YM_PHASE_MUL
JSR WRITE_YM
CLRB
LDA #YM_DETUNE2
JSR WRITE_YM
CLRB
LDA #YM_PMS
JSR WRITE_YM
; Envelope
CLRA
EG58 STA $6000
LDA #YM_ATTACK_RATE
ADDA $6000
LDB #$10
JSR WRITE_YM
LDA #YM_DECAY1_RATE
ADDA $6000
LDB #$10
JSR WRITE_YM
LDA #YM_DECAY2_RATE
ADDA $6000
LDB #$10
JSR WRITE_YM
LDA #YM_RELEASE_RATE
ADDA $6000
LDB #$8
JSR WRITE_YM
LDA $6000
INCA
CMPA #4
BNE EG58
KEYON:
LDB #$78
LDA #YM_KEYON
JSR WRITE_YM
; Wait for 0.5s before starting again
LDA #7
STA $6000
L59 LDA #YM_TIMERB
LDB 0
JSR WRITE_YM
LDA #YM_TIMER_CTRL
LDB #$2A
JSR WRITE_YM
L60 LDA YM_DATA
ANDA #2
BEQ L60
LDA #YM_TIMER_CTRL
LDB #$30 ; Reset flags
JSR WRITE_YM
DEC $6000
BNE L59
; key off
LDB #$00
LDA #YM_KEYON
JSR WRITE_YM
LBRA PLAY ; play it again, Sam
WAIT LDA #$FF
LOOP DECA
BNE LOOP
RTS
WRITE_YM:
JSR WAIT_YM
STA YM_ADR
JSR WAIT_YM
STB YM_DATA
RTS
WAIT_YM:
PSHS A ;
LDA YM_DATA
ANDA #$80
BNE WAIT_YM
PULS A ;
RTS
IRQ_SER RTI
TopMem EQU $FFF8
FILL $FF,TopMem-*
FDB IRQ_SER ; $FFF8
FDB $FFFF, $FFFF
FDB RESET


Después de más de un año de parada retomo la labor de clonar el YM2151 en FPGA. Los chips FM de Yamaha siguen sin estar disponibles en Verilog/VHDL y son una parte crucial si algún día queremos ver equipos de 16 bits (Megadrive, X68000, CPS1, SEGA System 16, etc.) recreados en FPGA y librarnos de los problemas de temporización e inexactitudes de la emulación.

El problema del YM2151 es su pésima documentación. No sólo porque el documento que circula escaneado por internet esté borroso y contenga partes ilegibles, sino porque en sí era un mal documento. El mapa de registros no está bien explicado y no hay ni un puñetero ejemplo de cómo generar sonidos. Esto en Japón, con los ingenieros de Yamaha al lado no sería gran problema. O quizá en su momento había herramientas de generación de sonidos que facilitaban la labor de programación de estos chips. Pero hoy en día, con sólo la documentación es imposible aclararse.

Jarek Burczynski además de lograr escribir su propio apellido, escribió el emulador de YM2151 usado en MAME. Cuenta en los créditos (en el ym2151.h) que contó con la colaboración de Shigeharu Isoda, un ingeniero de sonido de SEGA que conocía bien el chip. Shigeharu le pasó la documentación en japonés (ficheros que no han visto la luz de internet, por cierto) y sobre todo contestó a muchas preguntas. Algo fundamental si esa documentación en japonés es tan pobre como la que existe en inglés. También contó con la ayuda de otros con acceso a un chip real, quienes le tomaron medidas.

Pues bien, dada la escasez de documentación útil del YM2151, el emulador de Jarek B. va a ser una pieza fundamental para desentrañar este chip. Primero trataré de hacer funcionar las cosas en el emulador y luego de replicarlas en el chip real. Compararé los resultados y, por supuesto, trataré de replicar el chip real en Verilog, no el emulador.

Podría coger los ficheros ym2151.c, ym2151.h de MAME, adaptarlos a mi propio programa en C y explorarlos así. Sin embargo, prefiero un mecanismo más fiel a la época. He tomado como referencia el juego Gryzor. De él, la ROM 633e01.12a contiene el código del procesador 6809 que dirigía el sonido. El procesador principal escribía el código del sonido en un registro al que tenía acceso también este coprocesador. Según el código, este 6809 mandaba instrucciones al YM2151 para reproducir la melodía o el efecto sonoro adecuado.

MAME permite ejecutar un juego con ROMs alternativas. Lo que he hecho es ensamblar mi propia versión de la ROM de sonido de Gryzor, donde ejecuto mi propio código, y correrla con MAME. De esta forma puedo escuchar la salida de sonido rápidamente. MAME advierte de que la ROM no contiene lo esperado pero reproduce el juego bien.

En la siguiente entrada explicaré cómo conseguí el primer sonido del YM2151 usando este método.