Escrevendo um emulador gráfico de Z80 em C ou C ++ [fechado

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

  •  06-07-2019
  •  | 
  •  

Pergunta

Eu quero interessar em escrever meu próprio emulador simples para o Z80 processador. Não tenho experiência com esse tipo de programação. Estou bem com o uso de idiomas baseados em C, pois são os que eu sei melhor.

O que preciso para conseguir isso e quais são alguns bons tutoriais/referências que poderiam me ajudar neste projeto?

Eu também gostaria de um tutorial para codificar um aplicativo ROM-Dumping para o meu Ti-84 Plus Calculadora para que eu possa usar sua ROM com este emulador.

Outras dicas

É uma viagem lateral, mas como você diz que não tem experiência com esse tipo de programação, convém começar construindo um emulador para o Máquina virtual universal de 2006 Concurso de programação ICFP. Esta é uma tarefa que leva um programador experiente por 90 minutos, mas muitas equipes sem experiência conseguiram concluí -la em alguns dias. Quando você termina o emulador, ele desbloqueia um monte de coisas divertidas, e pode ser um bom aquecimento antes de você enfrentar o Z80.

Algumas coisas a acrescentar (especialmente para Z80):

  1. Não confie na documentação é 100% livre de bugs

    Não vi nenhum sem bugs, incluindo os mencionados aqui.

  2. Teste seu núcleo de CPU para bugs corretamente

    Isso o salvará de muitas dores de cabeça e confusão mais tarde.

Para testes, estou usando três abordagens:

  1. Pisando/rastreamento contra código conhecido (geralmente comentado ROM Desmonting)

    É o primeiro passo em que nada funciona ainda. Você verá mal (DE) instruções codificadas.

  2. Inclua diferentes núcleos Z80 em seu emulador e processe tudo como emulação dupla

    Faça dois emuladores 'separados' com o mesmo sistema de passo, rastreamento e corrida. Ambas as CPUs devem ter seu próprio hardware de memória, etc.

    My dual emulator example

    • Execute o emulador e depois de cada instrução compare registros e locais imediatos de memória como [hl],[sp],[sp-1]...
    • Na primeira diferença, pare e veja que instrução causou.
      Debugá-lo e continue até que você esteja 'livre de insetos'. Cuidado com o segundo núcleo também pode ser buggy, então depure com cautela.

  3. Quando você é mais executável, use o principal testador

    Usar Zexall Exerciser. É o melhor em Z80 (pelo menos da minha experiência). Isso me ajudou com muitas coisas (meu núcleo agora é 100% compatível com o Zexall). É feito contra hardware real, para que não haja bugs. É de Cp/m Então, algumas versões precisam 64K Modo RAM para correr. Diferente OS/ROM Ou o que quer que possa causar algumas instruções com o acesso à memória, portanto, para aqueles que você precisa encontrar CRCs corrigidos ou comparar com hardware real.

    Por exemplo, cru Zexall falha muitas coisas em Espectro ZX (como é feito para Msx e 64K RAM sem ROM), mas há versões feitas de verdade Espectro ZX E eles são 100% OK sobre Espectro ZX (e no meu emulador também :))

    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

    Caso você esteja prestes a usar Zexall Cuidado, é realmente um teste exaustivo e Iirc sobre ~ 50MHz Emulação que levou ao redor 30-60 min para concluir. E precisa pressionar uma tecla para rolar algumas vezes ...

    Se você precisar de um modelo de contenção, adicione testes adequados. Então encontre um. Por Espectro ZX Existem muitos testadores flutuantes de ônibus, interrupção e tela. Por Ti Eu não tenho ideia ... (eu não sou um Ti Usuário da calculadora)

POR FALAR NISSO: Como foi com seu emulador? (Voce fez?)

Conjunto de instruções

Eu copiaria meu conjunto de instruções aqui, mas possui 1792 linhas e 121 kb para que não se encaixem em um limite de 30 kb. Em vez disso, você pode encontrá -lo em um link de download nesta resposta minha

Contém 'tudo' Zx instruções com correto Op Códigos, tempo de codificação e ciclos de máquina. Levei alguns anos para montar toda a documentação, então estou passando Zexall 100% corretamente. Meu emulador carrega este arquivo de texto (1792 Instruções) no núcleo em init e configura o decodificador e o processador de instruções em tempo de execução, então pude mudar as coisas muito rápido e simples o suficiente (se um bug foi detectado) ... ele me salvou um muito de tempo.

Mitch está completamente correto. Comece entendendo o processador. Em seguida, brinque um pouco escrevendo código para implementar instruções específicas. Use C ++ para isso, BTW, não C, ou os conceitos do processador não serão mapeados para as classes do seu código.

No processo de implementação de instruções, você verá que precisa definir coisas como as bandeiras e o ponteiro de instruções. Isso deve eventualmente levá -lo para onde você precisa implementar o modelo de memória e até o modelo de E/S.

Você terá que descobrir como carregar código e dados na memória e talvez como despejá -lo novamente no disco.

Somente então você precisa chegar ao ponto de imitar a execução do código, carregado na memória, em um determinado ponteiro de instrução.

Tente dar uma olhada nos emuladores do Sistema Mestre da Sega e do jogo (tenho certeza de que alguns são de código aberto). Esses consoles têm um Z80 como CPU eEspectro ZX usei também, http://www.worldofspectrum.org/emulators.html.

Você parece querer um emulador para mais de um processador, mas para uma máquina completa. Você também terá a tarefa de imitar o restante do hardware e encontrar a documentação para isso poderia muito bem ser a tarefa mais difícil esperando você.

Dependendo do seu objetivo, convém começar com um emulador já existente para o Z80. Uma pesquisa rápida dá a vários deles, mas nenhum emulador para TI-84. Simh, uma estrutura para a emulação de computadores antigos já tem a emulação de um processador Z80, adicionar a emulação do restante do seu hardware deve ser mais fácil do que começar do zero. Mesmo se você não seguir esse caminho, existem alguns documentos de design que podem ajudá -lo.

Eu recomendo que você considere começar escrevendo um emulador para uma CPU um pouco mais simples, mas relacionada, o 8080. O Z80 é realmente bastante complicado (instruções de vários bytes, mais modos de endereçamento, registros de índice etc.), enquanto as instruções 8080 são muito fáceis de decodificar (você pode usar apenas uma tabela de pesquisa de 256 entradas, como solução de primeira ordem) .

Todo o código que você escreve para controlar o programa (exibição, entrada de dados, despejos de memória etc.) deve ser reutilável se você decidir continuar tentando o Z80 e, de fato -independente.

Aprendi tudo o que sei sobre o Z80 e a montagem da calculadora aqui: http://www.ticalc.org/programming/

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top