Escribir un emulador gráfico Z80 en C o C ++ [cerrado]

StackOverflow https://stackoverflow.com/questions/1215777

  •  06-07-2019
  •  | 
  •  

Pregunta

Quiero interesarme en escribir mi propio emulador simple para el procesador Z80 . No tengo experiencia con este tipo de programación. Estoy bien con el uso de lenguajes basados ??en C, ya que son los que mejor conozco.

¿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 descarga de ROM para mi TI-84 Plus calculadora para poder usar su ROM con este emulador.

Otros consejos

Es un viaje secundario, pero como usted dice que no tiene experiencia con este tipo de programación, es posible que desee comenzar creando un emulador para Máquina virtual universal del concurso de programación ICFP 2006 . Esta es una tarea que le toma a un programador experimentado 90 minutos, pero muchos equipos sin experiencia pudieron completarla en pocos días. Cuando termine el emulador, desbloqueará un montón de cosas divertidas, y podría ser un buen calentamiento antes de abordar el Z80.

Algunas cosas para agregar (especialmente para Z80):

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

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

  2. Pruebe el núcleo de su CPU para detectar errores

    Te salvará de muchos dolores de cabeza y confusión más tarde.

Para probar estoy usando tres enfoques:

  1. Paso / rastreo contra código conocido (generalmente desmontaje de ROM comentado)

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

  2. Incluye diferentes núcleos Z80 en tu emulador y procesa todo como doble emulación

    Cree dos emuladores 'separados' con el mismo sistema de pasos, rastreo y ejecución. Ambas CPU deben tener su propio hardware de memoria, etc.

    Ejemplo de mi emulador dual

    • Ejecute el emulador y, después de cada instrucción, compare registros y ubicaciones de memoria inmediatas como [hl], [sp], [sp-1] ...
    • En la primera diferencia, deténgase y vea qué instrucción lo causó.
      Depúrelo y continúe hasta que esté 'libre de errores'. Tenga en cuenta que el segundo núcleo también puede tener errores, por lo tanto, depure con precaución.

  3. Cuando sea más ejecutable use Core Tester

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

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

    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 utilizar ZEXALL tenga cuidado, es realmente una prueba exhaustiva y IIRC en la emulación ~ 50MHz que tomó alrededor de 30-60 min para completar. Y necesita presionar una tecla para desplazarse varias veces ...

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

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

Conjunto de instrucciones

Copiaría mi conjunto de instrucciones aquí, pero tiene 1792 líneas y 121 & nbsp; KB, por lo que no cabe en un límite de 30 & nbsp; KB. En cambio, puedes encontrarlo en un enlace de descarga en esta respuesta mía

Contiene 'todas' las instrucciones ZX con los códigos OP correctos, el tiempo de codificación y los ciclos de la máquina. Me llevó algunos años reunir toda la documentación, por lo 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, por lo que pude cambiar las cosas de manera muy rápida y simple (si se detectó un error) ) ... Me ahorró un lote de tiempo.

Mitch es completamente correcto. Comience por comprender el procesador. Luego juegue un poco escribiendo código para implementar instrucciones particulares. Use C ++ para esto, por cierto, no C, o los conceptos del procesador no se asignarán a clases en su código.

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

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

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

Intenta echar un vistazo a los emuladores Sega Master System y Game Gear (estoy bastante seguro de que algunos son de código abierto). Esas consolas tienen un Z80 como CPU, y ZX Spectrum también lo usó, http://www.worldofspectrum.org/emulators.html .

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

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

Recomiendo que considere comenzar escribiendo un emulador para una CPU un poco más simple pero relacionada, la 8080 . El Z80 es 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 decodificar (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 intentar el Z80, y de hecho debe diseñar la interfaz de usuario para ser simulado independiente del procesador.

Aprendí todo lo que sé sobre el conjunto de calculadora y Z80 aquí: http://www.ticalc.org / programación /

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top