2009-08-01 25 views
12

Desidero interessarmi alla scrittura del mio emulatore semplice per il processore Z80. Non ho esperienza con questo tipo di programmazione. Sto principalmente bene con l'utilizzo di linguaggi basati su C in quanto sono quelli che conosco meglio.Scrittura di un emulatore grafico Z80 in C o C++

Cosa mi serve per realizzare questo e quali sono alcuni buoni tutorial/riferimenti che potrebbero aiutarmi in questo progetto?

Vorrei anche un tutorial per la codifica di un'applicazione di dumping ROM per il mio calcolatore TI-84 Plus in modo da poter utilizzare la sua ROM con questo emulatore.

+2

Z80 è stato fantastico !! – MadH

risposta

5

Mitch è completamente corretto. Inizia comprendendo il processore. Quindi giocare un po 'scrivendo il codice per implementare istruzioni particolari. Usa C++ per questo, BTW, non C, oppure i concetti del processore non verranno associati alle classi del tuo codice.

Nel processo di implementazione delle istruzioni, è necessario definire elementi come i flag e il puntatore dell'istruzione. Questo dovrebbe alla fine portarti dove hai bisogno di implementare il modello di memoria, e persino il modello I/O.

Alla fine dovrai capire come caricare il codice e i dati in memoria, e magari come scaricarlo su disco.

Solo allora è necessario arrivare al punto di emulare l'esecuzione del codice, caricato in memoria, a un dato puntatore di istruzioni.

+0

Voglio ringraziare anche per il tuo consiglio. –

16

È un po 'un viaggio secondario, ma dal momento che si dice di non avere esperienza con questo tipo di programmazione, si potrebbe voler iniziare creando un emulatore per il 2006 ICFP programming contest . Questo è un compito che richiede un programmatore esperto 90   minuti, ma molti team senza esperienza sono riusciti a completarlo in pochi giorni. Quando finisci l'emulatore, sblocca un sacco di cose divertenti, e potrebbe essere un buon riscaldamento prima di affrontare lo Z80.

+0

+1 Grazie per il link al concorso. – AraK

+4

+1 per il link al concorso! – TarkaDaal

3

Sembra che tu voglia un emulatore per più di un processore, ma per una macchina completa. Avrai anche il compito di emulare il resto dell'hardware e trovare la documentazione potrebbe essere il compito più difficile che ti aspetta.

A seconda dell'obiettivo, è possibile iniziare con un emulatore già esistente per Z80. Una rapida ricerca fornisce molti di loro ma nessun emulatore per TI-84. simh, un framework per l'emulazione di vecchi computer ha già l'emulazione di un processore Z80, l'aggiunta dell'emulazione del resto dell'hardware dovrebbe essere più facile che partire da zero. Anche se non segui questa strada, ci sono alcuni documenti di progettazione che potrebbero aiutarti.

3

Si consiglia di prendere in considerazione l'avvio scrivendo un emulatore per una CPU leggermente più semplice, ma correlata, 8080. Lo Z80 è in realtà piuttosto complicato (istruzioni multi-byte, più modalità di indirizzamento, registri indice, ecc.), mentre le 8080 istruzioni sono molto facili da decodificare (si può semplicemente usare una tabella di ricerca a 256 voci, come soluzione di primo ordine).

Tutto il codice che si scrive per controllare il programma (visualizzazione, inserimento dati, dump della memoria, ecc.) Dovrebbe essere riutilizzabile se si decide di provare a Z80, e in effetti si dovrebbe progettare l'interfaccia utente essere simulato indipendentemente dal processore.

+1

Non sono d'accordo sulla decodifica.Le istruzioni di Z80 sono facilmente decodificate, dividendole in campi di bit {2, 3, 3}. L'ho fatto. –

+0

Lo Z80 ha opcode sia a byte singolo sia a byte doppio (escluse le informazioni sull'editore). L'8080 (che ha solo codici opzionali a byte singolo) è quindi più semplice da decodificare. Inoltre, il numero di modalità di indirizzamento che è necessario trattare è inferiore su 8080. Pertanto, la scrittura di un emulatore 8080 è più semplice. Ho scritto entrambi, a proposito. –

8

Alcune cose da aggiungere (in particolare per Z80):

  1. Non fidarti della documentazione è di 100 % senza bug

    Non ho visto nessuno senza bug compresi quelli menzionati qui.

  2. prova il vostro core della CPU per i bug correttamente

    Essa vi salverà da molti mal di testa e confusione in seguito.

Per la prova che sto usando tre approcci:

  1. Stepping/tracciamento contro codice noto (smontaggio ROM di solito commentato)

    E 'il primo passo quando niente funziona ancora . Vedrete istruzioni malamente (de) codificate.

  2. includere diversi nuclei Z80 nel vostro emulatore ed elaborare tutto come doppia emulazione

    fare due emulatori 'separati', con lo stesso passo, il rintracciamento, e il sistema di esecuzione. Entrambe le CPU dovrebbero avere il proprio hardware di memoria, ecc

    My dual emulator example

    • Eseguire l'emulatore e dopo ogni istruzione confrontare i registri e locazioni di memoria immediati come [hl],[sp],[sp-1] ...
    • Alla prima fermata differenza e vedere quale istruzione lo ha causato.
      Esegui il debug e continua fino a quando non sei "privo di bug". Attenzione, il secondo core può anche essere bacato, quindi eseguire il debug con cautela.
  3. Quando si è più in grado di run-uso nucleo tester

    Usa ZEXALL Exerciser. È il migliore su Z80 (almeno dalla mia esperienza).Mi ha aiutato con molte cose (il mio core è ora compatibile al 100% con ZEXALL). È fatto contro hardware reale quindi non ci sono bug in esso. È da CP/M quindi alcune versioni necessitano di 64K modalità RAM da eseguire. Diversi sistemi operativi OS/ROM o qualsiasi altra cosa può causare l'impossibilità di alcune istruzioni con accesso alla memoria, quindi per quelli è necessario trovare i CRC corretti o confrontarli con l'hardware reale.

    Per esempio, crudo ZEXALL fallisce molte cose su ZX Spectrum (come si è fatto per MSX e 64K RAM senza ROM), ma ci sono le versioni fatte per davvero ZX Spectrum e sono al 100% OK su ZX Spectrum (e sul mio emulatore troppo :))

    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 
    

    Nel caso in cui si sta per usare ZEXALL state attenti che si è prova davvero esaustivo e IIRC su ~ 50MHz emulazione ci sono voluti circa 30-60 minuti per completare. E ha bisogno di premere un tasto per scorrere alcune volte ...

    Se hai bisogno di un modello di contesa, aggiungi i test appropriati. Quindi trovane uno. Per ZX Spectrum ci sono molti tester di bus, interrupt e schermi mobili. Per TI ho idea ... (io non sono un TI utente calcolatrice)

BTW: Come è andata con il tuo emulatore? (Avete fatto?)

Set di istruzioni

vorrei copiare il mio set di istruzioni qui ma ha 1792 linee e 121 KB   in modo da non rientrare in un limite di 30 KB  . Invece puoi trovarlo in un link per il download in questa mia risposta

Contiene 'tutto' ZX istruzioni con corrette OP codici, i tempi di codifica e cicli macchina. Mi ci sono voluti alcuni anni per mettere insieme tutta la documentazione, quindi sto passando correttamente ZEXALL al 100%. Il mio emulatore carica questo file di testo (1792 istruzioni) sul core su init e configura il decodificatore di istruzioni e il processore in fase di runtime, quindi sono stato in grado di modificare le cose in modo veramente veloce e semplice (se è stato rilevato un errore) ... Mi ha salvato a lotto di tempo.