Página principal
Z80
Simulador
 xsetaseta@gmail.com
Después de haber programado un ensamblador y un desensamblador de procesador Z80, el siguiente paso era crear un simulador.
El entorno de trabajo es Debian 10, y como base para la representación gráfica la librería SDL, y programación en C.

Para entender lo que es un simulador de un Z80, es un intérprete de cada uno de los códigos de tiene el Z80.
Por ejemplo:
    LD   A,B     Corresponde al opcode 78 en hexadecimal o en decimal 120
El intérprete lo que hace es:
    alu=bc.b.h;
   af.b.h=alu;
Incrementa el contador de programa y vuelve a buscar la siguiente instrucción para ejecutarla.

En este caso la orden es bastante simple, pero existen otros opcode (código de operaciones) que son mas complejas.
En el caso de:
    INC A
Debe comprobar los diferentes flags, como puede ser el Z (si resultado es cero).

Como no quería hacer un emulador perfecto, es bastante complicado, no he incluido el contador de tiempos de cada operación.
Tampoco has he diseñado para que sean rápida la interpretación del código.
No es un simulador bueno, simplemente un simulador para los que empiezan a aprenden con el Z80.





El programa tiene bastantes argumentos de entrada.

./sima file.bin   -t 0   -vi 300  -p1 -p2 -port 0 -nmi -int   -me -sp


El primero y único imprescindible es el fichero binario, fichero de programa.
-t 0 ,tiempo entre operaciones, si no se especifica es cada segundo, pero si se tienen interrupciones puede que se generen interrupciones continuamente sin ejecutar ningún programa. El tiempo mas rápido es -t 0.
-vi 300 , tiempo entre actualizaciones de gráficos, si es pequeño puede que no tenga el ordenador tiempo para el emulador, depende del programa que estemos probando.
-nmi , genera interrupciones no enmascarables cada 1 segundo.
-int , genera interrupciones  enmascarables cada 0.1 segundo.
-me 1000 , visualiza posiciones de memoria en la dirección 1000.
-sp 4000  , visualiza posiciones de memoria de registro SP posición 4000.
-port 0 ,visualiza valor del puerto 0.
-p1 y -p2 , visualiza en consola la secuencia de ejecución de las operaciones, y los valores de los registros. Es muy útil en depuración.

Debemos tener cuidado con la depuración y las interrupciones, pueden entrar en bucle si los tiempos se solapan.

Ejemplo de un programa sencillo.
/ejemplo.asm
;./sima file.bin  -p1 

    org &0
#empezar
    ld a,&4
#bucle   
    dec a
    jr nz,#bucle
    jr #empezar
    end
./ensam ejemplo.asm

Ensamblador corez80 V3
=======================
--- Preprocesador ---
--- Fin preprocesador ---
Num NEMOS= 698
--- Paser 0 ===Ensamblador===
_FIN__Parser 0
--- Paser 1 ===Ensamblador===
001 /ejemplo.asm     
002 ;./simaV2 file.bin       -me 16384 -t 1   -nmi -vi 100 
003 /seta43          
004                  
005  ORG &0              00000_______ORG_0
006 #EMPEZAR         
007  LD A,&4             00000_ 062 004
008 #BUCLE           
009  DEC A               00002_ 061
010  JR NZ,#BUCLE        00003_ 032 253
011  JR #EMPEZAR         00005_ 024 249
012  END                 00007__FIN__Parser 1

==Variables== NUM=1
00-#EMPEZAR=0        01-#BUCLE=2       
Salvando codigo en fichero file.bin   SIZE=7
./sima file.bin -p1
00000 062 LD A n          PC=0000 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=04 IX=0000 IY=0000 S0Z0C0P0
00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=03 IX=0000 IY=0000 S0Z0C0P1
00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=03 IX=0000 IY=0000 S0Z0C0P1
00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=02 IX=0000 IY=0000 S0Z0C0P0
00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=02 IX=0000 IY=0000 S0Z0C0P0
00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=01 IX=0000 IY=0000 S0Z0C0P0
00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=01 IX=0000 IY=0000 S0Z0C0P0
00002 061 DEC A           PC=0002 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1
00003 032 JR NZ,-3        PC=0003 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1
00005 024 JR -7           PC=0005 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=00 IX=0000 IY=0000 S0Z1C0P1
00000 062 LD A n          PC=0000 SP=0000 BC=FFFF DE=FFFF HL=FFFF A=04 IX=0000 IY=0000 S0Z1C0P1

Este es el programa mas sencillo que se puede crear, sin interrupciones ni llamadas a rutinas donde no se hace uso de SP.
Para salir de la emulación debemos pulsar ESC en la interface gráfica, parará la emulación, y con la tecla Q saldremos del programa.
La definición de gráficos de las fuentes, las he sacado del Spectrum.
Cuando se esta emulado, si se pulsa cualquier tecla, el emulador coloca el código ASCII en el puerto 0 del emulador.

La representación gráfica se hace en dos modos a la vez:
-modo carácter  2x16 caracteres.
-modo gráfico , gráfico de 128x128 puntos.
La representación gráfica se hace a partir de la dirección 16384.

He creado varios programas de ejemplo para demostrar el funcionamiento del programa.
Se pueden ver su funcionamiento en el siguiente vídeo:

VIDEO



No es el mejor simulador del Z80, pero he de reconocer que me lo he pasado bien.
He tenido que volver aprender ensamblador del Z80, el ensamblador siempre es duro, y tienes que cambiar muchos malos hábitos de otros lenguajes.
Como no estoy habituado al ensamblador, he intentado en algunas funciones guardar todos los registros antes de hacer una llamada CALL , pero esto produce una ralentización del programa.
Existen personas que son muy hábiles en este lenguaje y hacen cosas increíblemente rápidas y buenas, yo no soy de esos ;).
   
Para emular el Spectrum, debemos crear un emulador del Z80, en esta página describen bastantes emuladores:
    https://magazinezx.speccy.org/03/emulacion.html

También para el ordenador Amstrad CPC existen muchos emuladores del Z80
    https://auamstrad.es/software/guia-emuladores-amstrad-cpc/

Los emuladores que me han sorprendido son:

FUSE .- Para muchas plataformas.
ZXBaremulator es el primer emulador del ZX Spectrum para la Raspberry PI.
Bacteria. -El emulador mas pequeño escrito en ensamblador.

Lista de códigos de operación del Z80
opcodes.txt
z80_code.txt

Espero que sea un principio para que realicéis vuestro propio simulador.


PROGRAMAS

 Saludos.
 Juan Galaz


Bibliografía:

 http://www.z80.info/decoding.htm
 https://espamatica.com/
 http://map.grauw.nl/resources/
https://magazinezx.speccy.org/03/emulacion.html
https://github.com/jsanchezv
https://auamstrad.es/software/guia-emuladores-amstrad-cpc/