2009-08-01 56 views
12

Quiero interesarme en escribir mi propio emulador simple para el procesador Z80. No tengo experiencia con este tipo de programación. En general, estoy bien con el uso de lenguajes basados ​​en C, ya que son los que mejor conozco.Escribiendo un emulador gráfico Z80 en C o C++

¿Qué necesito para lograr esto y cuáles son algunos buenos tutoriales/referencias que podrían ayudarme en este proyecto?

También me gustaría un tutorial para codificar una aplicación de eliminación de ROM para mi calculadora TI-84 Plus para que pueda usar su ROM con este emulador.

+2

Z80 was great !! – MadH

Respuesta

5

Mitch es completamente correcto. Comience por entender el procesador. Luego juegue un poco escribiendo código para implementar instrucciones particulares. Use C++ para esto, BTW, no C, o los conceptos del procesador no se correlacionarán con las clases de su código.

En el proceso de implementación de instrucciones, encontrará que necesita definir elementos como las banderas y el puntero de instrucción. Eso eventualmente lo llevará a donde necesita implementar el modelo de memoria, e incluso el modelo de E/S.

Eventualmente tendrá que averiguar cómo cargar el código y los datos en la memoria, y tal vez cómo volcarlos en el disco.

Solo entonces necesita llegar al punto de emular la ejecución del código, cargado en la memoria, en un puntero de instrucción dado.

+0

Quiero agradecerle por su consejo también. –

16

Es un poco un viaje lateral, pero como dice que no tiene experiencia con este tipo de programación, puede empezar por construir un emulador para el Universal Virtual Machine del 2006 ICFP programming contest. Esta es una tarea que requiere un programador experimentado 90   minutos, pero muchos equipos sin experiencia pudieron completarla en unos pocos días. Cuando terminas el emulador, desbloqueas un montón de cosas divertidas, y podría ser un buen calentamiento antes de enfrentarte al Z80.

+0

+1 Gracias por el enlace del concurso. – AraK

+4

+1 para el enlace del concurso – TarkaDaal

3

Parece que desea un emulador para más de un procesador, pero para una máquina completa. También tendrás la tarea de emular el resto del hardware, y encontrar la documentación para esa podría ser la tarea más difícil que te espera.

Dependiendo de su objetivo, es posible que desee comenzar con un emulador ya existente para Z80. Una búsqueda rápida da varios de ellos, pero no un emulador para TI-84. simh, un marco para la emulación de computadoras viejas que ya tiene la emulación de un procesador Z80, agregar emulación del resto de su hardware debería ser más fácil que comenzar desde cero. Incluso si no sigue ese camino, hay algunos documentos de diseño que podrían ayudarlo.

3

Te recomiendo que consideres comenzar escribiendo un emulador para una CPU ligeramente más simple pero relacionada, la 8080. El Z80 es realmente bastante complicado (instrucciones de varios bytes, más modos de direccionamiento, registros de índice, etc.), mientras que las instrucciones 8080 son muy fáciles de descodificar (puede usar una tabla de búsqueda de 256 entradas, como una solución de primer orden).

Todo el código que escriba para controlar el programa (pantalla, entrada de datos, volcados de memoria, etc.) debe ser reutilizable si luego decide continuar con el Z80, y de hecho debe diseñar la interfaz de usuario ser simulado independiente del procesador.

+1

No estoy de acuerdo con la decodificación.Las instrucciones Z80 se decodifican fácilmente, dividiéndolas en campos de bits {2, 3, 3}. Lo he hecho. –

+0

El Z80 tiene códigos de operación de un solo byte y de dos bytes (sin incluir la información de referencia). El 8080 (que solo tiene códigos de operación de un solo byte) es, por lo tanto, más fácil de decodificar. Además, la cantidad de modos de direccionamiento con los que debe lidiar es menor en el 8080. Por lo tanto, escribir un emulador 8080 es más fácil. He escrito ambos, por cierto. –

8

Algunas cosas a añadir (en especial para Z80):

  1. No confíe en la documentación es 100 % libre de errores

    No he visto ninguno sin errores, incluidos los mencionados aquí.

  2. a prueba tu núcleo de la CPU para los insectos correctamente

    Se le ahorrará muchos dolores de cabeza y de confusión posteriores.

Para la prueba de que estoy usando tres enfoques:

  1. Stepping/trazado contra el código conocido (desmontaje ROM generalmente comentado)

    Es el primer paso cuando nada funciona todavía . Verá instrucciones mal (de) codificadas.

  2. incluir diferentes núcleos Z80 en su emulador y procesar todo el doble de emulación

    Hacer dos emuladores 'separados' con el mismo paso a paso, la localización, y el sistema funcionando. Ambas CPUs deben tener su propio hardware de memoria, etc.

    My dual emulator example

    • Ejecutar el emulador y después de cada operación Comparar registros y posiciones de memoria inmediata como [hl],[sp],[sp-1] ...
    • En la primera parada y ver la diferencia qué instrucción lo causó.
      Debug y continúa hasta que estés 'libre de errores'. Ten en cuenta que el segundo núcleo también puede tener fallas, por lo que debes depurar con precaución.
  3. Cuando esté más probador de uso básico de ejecución capaces

    Uso ZEXALL Exerciser. Es el mejor en Z80 (al menos según mi experiencia).Me ayudó con muchas cosas (mi núcleo ahora es 100% compatible con ZEXALL). Está hecho contra hardware real por lo que no hay errores en él. Es de CP/M por lo que algunas versiones necesitan 64K Modo RAM para ejecutar. Diferentes OS/ROM o lo que sea, pueden causar algunas fallas en el acceso a la memoria, por lo que para aquellos que necesitan encontrar CRC corregidos o compararlos con hardware real.

    Por ejemplo, crudo ZEXALL falla muchas cosas en ZX Spectrum (como se hace para MSX y 64 K de RAM sin ROM), pero hay versiones hechas de verdad ZX Spectrum y son 100% OK en ZX Spectrum (y en mi emulador también :))

    Z80all instruction exerciser 
    
    <adc,sbc> hl,<bc,de,hl,sp>...OK 
    add hl,<bc,de,hl,sp>.........OK 
    add ix,<bc,de,ix,sp>.........OK 
    add iy,<bc,de,iy,sp>.........OK 
    aluop a,nn...................OK 
    aluop a,<b,c,d,e,h,l,(hl),a>.OK 
    aluop a,<ixh,ixl,iyh,iyl>....OK 
    aluop a,(<ix,iy>+1)..........OK 
    bit n,(<ix,iy>+1)............OK 
    bit n,<b,c,d,e,h,l,(hl),a>...OK 
    cpd<r>.......................OK 
    cpi<r>.......................OK 
    <daa,cpl,scf,ccf>............OK 
    <inc,dec> a..................OK 
    <inc,dec> b..................OK 
    <inc,dec> bc.................OK 
    <inc,dec> c..................OK 
    <inc,dec> d..................OK 
    <inc,dec> de.................OK 
    <inc,dec> e..................OK 
    <inc,dec> h..................OK 
    <inc,dec> hl.................OK 
    <inc,dec> ix.................OK 
    <inc,dec> iy.................OK 
    <inc,dec> l..................OK 
    <inc,dec> (hl)...............OK 
    <inc,dec> sp.................OK 
    <inc,dec> (<ix,iy>+1)........OK 
    <inc,dec> ixh................OK 
    <inc,dec> ixl................OK 
    <inc,dec> iyh...............OK 
    <inc,dec> iyl................OK 
    ld <bc,de>,(nnnn)............OK 
    ld hl,(nnnn).................OK 
    ld sp,(nnnn).................OK 
    ld <ix,iy>,(nnnn)............OK 
    ld (nnnn),<bc,de>............OK 
    ld (nnnn),hl.................OK 
    ld (nnnn),sp.................OK 
    ld (nnnn),<ix,iy>............OK 
    ld <bc,de,hl,sp>,nnnn........OK 
    ld <ix,iy>,nnnn..............OK 
    ld a,<(bc),(de)>.............OK 
    ld <b,c,d,e,h,l,(hl),a>,nn...OK 
    ld (<ix,iy>+1),nn............OK 
    ld <b,c,d,e>,(<ix,iy>+1).....OK 
    ld <h,l>,(<ix,iy>+1).........OK 
    ld a,(<ix,iy>+1).............OK 
    ld <ixh,ixl,iyh,iyl>,nn......OK 
    ld <bcdehla>,<bcdehla>.......OK 
    ld <bcdexya>,<bcdexya>.......OK 
    ld a,(nnnn)/ld (nnnn),a....OK 
    ldd<r> (1)...................OK 
    ldd<r> (2)...................OK 
    ldi<r> (1)...................OK 
    ldi<r> (2)...................OK 
    neg..........................OK 
    <rrd,rld>....................OK 
    <rlca,rrca,rla,rra>..........OK 
    shf/rot (<ix,iy>+1)..........OK 
    shf/rot <b,c,d,e,h,l,(hl),a>.OK 
    <set,res> n,<bcdehl(hl)a>....OK 
    <set,res> n,(<ix,iy>+1)......OK 
    ld (<ix,iy>+1),<b,c,d,e>.....OK 
    ld (<ix,iy>+1),<h,l>.........OK 
    ld (<ix,iy>+1),a.............OK 
    ld (<bc,de>),a...............OK 
    Tests complete 
    

    En caso de que esté a punto de usar ZEXALL ten en cuenta que es prueba muy exhaustiva y IIRC en la emulación ~ 50MHz tardó alrededor de 30-60 minutos en completarse. Y necesita presionar una tecla para desplazarse pocas veces ...

    Si necesita un modelo de contención, agregue las pruebas adecuadas. Luego encuentra uno. Para ZX Spectrum hay muchos probadores de bus flotante, interrupción y pantalla. Para TI no tengo ni idea ... (no soy un usuario TI calculadora)

Por cierto: ¿Cómo te fue con el emulador? (¿Lo ha hecho?)

Juego de instrucciones

Me gustaría copiar mi conjunto de instrucciones aquí pero tiene 1792 líneas y 121 KB   por lo que no se ajusta a un límite de 30 KB  . En su lugar, puede encontrarlo en un enlace de descarga en esta respuesta a la mía

Contiene 'all' ZX instrucciones con correctas OP códigos, el momento de codificación y ciclos de máquina. Me tomó algunos años reunir toda la documentación, así que estoy pasando ZEXALL 100% correctamente. Mi emulador carga este archivo de texto (instrucción 1792) en el núcleo en init y configura el decodificador de instrucciones y el procesador en tiempo de ejecución, así que pude cambiar cosas muy rápido y lo suficientemente simple (si se detectó un error) ... Me salvó un lote de tiempo.

Cuestiones relacionadas