ZONA DE PRUEBAS

Con los fuentes del emulador Fuse va un programa de test llamado, como no, fusetest. Utiliza un programa muy simple para ir ejecutando las instrucciones una a una y comparar los resultados contra un archivo de idem que también va con el test.

Como no ejecuta ninguna ROM, sino que es externo e independiente del Spectrum, solo tendrías que crearte el programa que use tu core Z80 y hacer que vaya ejecutando test a test. Yo lo usé bastante cuando programé mi primer core Z80 en Java.

Descargado el fuse de aquí (el source, vaya): https://sourceforge.net/projects/fuse-emulator/

y no hay ningún archivo ni carpeta llamada fusetest. Sólo una carpeta test, pero está en C, y creo que es para probar este emulador, no el Z80. ¿Tú me podrías pasar un enlace donde venga el fusetest?

donde pone "Code"

https://sourceforge.net/p/fuse-emulator/code/HEAD/tarball?path=/trunk/fusetest

Nada. Al compilar el fusetest.asm da error en el archivo tests.asm pues se define 2 veces la misma etiqueta: _data


Ya podían haber distribuido el fusetest.z80 compilado, y no el fuente pa tener que compilarlo, leñe.

Ains, es lo que pasa por contestar de memoria. Está aquí: https://sourceforge.net/p/fuse-emulator ... /tree/z80/

y se llama coretest.c, y el fichero de pruebas está en el subdirectorio "test" con el nombre "tests.in".

El fusetest.asm forma parte de otros programas de test para el Spectrum, pero el coretest solo evalúa el core Z80, sin Spectrum que valga.

I'm sorry....

Pero, torpedo, el coretest.c está en C, no en Z80. Lo que yo ando buscando es un pograma en lenguaje ensamblador del Z80 (un pograma en .z80, vaya) de tal manera que se lo trague direstamente el emulador que sea, y que en pantalla me diga si está emulando bien las instrucciones z80 o no.

Bubu escribió:Pero, torpedo, el coretest.c está en C, no en Z80. Lo que yo ando buscando es un pograma en lenguaje ensamblador del Z80 (un pograma en .z80, vaya) de tal manera que se lo trague direstamente el emulador que sea, y que en pantalla me diga si está emulando bien las instrucciones z80 o no.

https://github.com/chernandezba/zesarux ... trum/tests
Los que empiezan con el nombre z80*

Mi preferido es el z80tests.tap
https://github.com/chernandezba/zesarux ... 0tests.tap

Bubu escribió:Pero, torpedo, el coretest.c está en C, no en Z80. Lo que yo ando buscando es un pograma en lenguaje ensamblador del Z80 (un pograma en .z80, vaya) de tal manera que se lo trague direstamente el emulador que sea, y que en pantalla me diga si está emulando bien las instrucciones z80 o no.

A ver, perlita de Huelva, olvídate del Spectrum de momento. Lo que tú necesitas ahora es algo que te permita probar tu core Z80 con independencia de todo lo demás. Casi todos los test basados en el Spectrum necesitan la ROM del Spectrum y si ni siquiera te arranca la ROM mal lo tienes.

La idea que te daba es que convirtieras el coretest de C a BASIC y que usaras el test.in para comprobar instrucción a instrucción, con independencia total de tu emulación básica del Spectrum, que a saber si está bien o no.

Otra opción es esta: https://github.com/jsanchezv/z80cpp/tree/master/example

Es un núcleo mínimo que permite ejecutar un programa de test escrito para CP/M... sin CP/M. Y con él ejecutas el programa ZEXALL.BIN que es un binario de Z80 tal y como lo necesita CP/M. Tendrías que convertir el programa z80sim.cpp de C++ a BASIC, unirlo a tu core Z80 y ejecutar el ZEXALL.BIN. Eso sí, te advierto que el test de Patrick Rak intenta ser (y es) una mejora sustancial al ZEXALL y su pareja ZEXDOC, siendo más fino y rápido. Pero el z80sim.cpp es muy simple, puedes implementarlo en BASIC en un pis-pas y al menos te dará una idea de en qué bloques de instrucciones tienes problemas. Una vez tengas un core Z80 mínimamente depurado, quizás puedas intentarlo con el test de Patrick.

O aislas las fuentes de los problemas o te volverás loco, avisado estás.

Para probar todos los posibles resultados de DAA:

org 30000
ld bc,0
ld de,0
loop:
push bc
pop af
daa
ld e,a
djnz loop
ret

Para ver las variantes con los flags C y H habria que cambiar el "ld bc,0" a 1 para C, a 16 para H y a 17 para C y H.

Buenas,
Refloto este hilo por si alguien me puede echar un cable. Resulta que estoy intentando hacer un emulador básico, muy básico de Zx Spectrum en java, y estoy a ver si puedo terminar el tema del procesador z80, pero se resisten algunas instrucciones y al pasarle el test z80doc me salen varios errores, y uno de ellos que me trae por el camino de la amargura, que por más que reviso no veo donde está el fallo, es la instrucción Bit(número de bit , registro). Veo que aquí en el foro hay gente competente, que ya ha hecho un emulador de Spectrum y seguramente sepan orientarme que puede fallar.

El método es el siguiente:
// Verifica el bit b del registro r
public void bit(int bit, int registro) {
int reg = 0;
switch (registro) {
case A:
reg = leeA();
break;
case B:
reg = leeB();
break;
case C:
reg = leeC();
break;
case D:
reg = leeD();
break;
case E:
reg = leeE();
break;
case H:
reg = leeH();
break;
case L:
reg = leeL();
break;
case HL:
reg = Memoria.romRam[hl];
break;
case IX_D:
reg = Memoria.romRam[ix + desp];
break;
case IY_D:
reg = Memoria.romRam[iy + desp];
break;
}
flagsXY(reg);
for (int n = 0; n < bit; n++) {
reg = reg >> 1;
}
reg = reg & 1;
if (reg == 0) {
setZFlag();
setPVFlag();//Flag P/V efecto no documentado manual Sean Young
} else {
ceroZFlag();
ceroPVFlag();//Flag P/V efecto no ducumentado manual Sean Young
}
setHFlag();
ceroNFlag();
}



Gracias.