Schreiben eines grafischen Z80 -Emulators in C oder C ++ [geschlossen

https://stackoverflow.com/questions/1215777

06-07-2019
|

Frage

Ich möchte mich dafür interessieren, meinen eigenen einfachen Emulator für die zu schreiben Z80 Prozessor. Ich habe keine Erfahrung mit dieser Art von Programmierung. Mir ist meistens in Ordnung, wenn ich C-basierte Sprachen benutze, da sie diejenigen sind, die ich am besten kenne.

Was muss ich erreichen und was sind einige gute Tutorials/Referenzen, die mir in diesem Projekt helfen könnten?

Ich möchte auch ein Tutorial für die Codierung einer ROM-Dumping-Anwendung für meine Ti-84 Plus Taschenrechner, damit ich sein ROM mit diesem Emulator verwenden kann.

Lösung

Vielleicht schauen Sie sich diese an:

Hier finden Sie ein gutes Tutorial: Unabhängiger Z80 -Assemblerhandbuch

Z80 -Dokumentation

Der undokumentierte Z80 dokumentierte V0.91 (PDF)

Die vollständige Z80 -Befehlsreferenz

Z80 -Mikroprozessor -Befehlssatz Zusammenfassung

Andere Tipps

Es ist ein bisschen eine Nebenreise, aber da Sie sagen, Sie haben keine Erfahrung mit dieser Art von Programmierung, möchten Sie vielleicht zunächst einen Emulator für die erstellen Universelle virtuelle Maschine von dem 2006 ICFP -Programmierwettbewerb. Dies ist eine Aufgabe, die einen erfahrenen Programmierer 90 Minuten erfordert, aber viele Teams ohne Erfahrung konnten sie in wenigen Tagen abschließen. Wenn Sie den Emulator beenden, schaltet er ein paar lustige Sachen frei, und es könnte ein gutes Aufwärmen sein, bevor Sie den Z80 angehen.

Einige Dinge, die hinzugefügt werden müssen (besonders für Z80):

Vertrauen Sie nicht, dass die Dokumentation 100% fehlerfrei ist

Ich habe keine ohne Fehler gesehen, einschließlich der hier erwähnten.
Testen Sie Ihren CPU -Kern für Fehler ordnungsgemäß

Es wird Sie später vor vielen Kopfschmerzen und Verwirrung ersparen.

Zum Testen verwende ich drei Ansätze:

Schritt/Verfolgung gegen bekannten Code (Normalerweise kommentierte ROM Demontage)

Es ist der erste Schritt, wenn noch nichts funktioniert. Sie werden schlecht (de) codierte Anweisungen sehen.
Fügen Sie verschiedene Z80 -Kerne in Ihren Emulator ein und verarbeiten Sie alles als Doppelemulation

Machen Sie zwei 'getrennte' Emulatoren mit dem gleichen Schritt, Verfolgung und Laufsystem. Beide CPUs sollten eine eigene Speicherhardware usw. haben.
- Führen Sie den Emulator aus und vergleichen Sie nach jeder Anweisung Register und sofortige Speicherorte wie [hl],[sp],[sp-1]...
- Beim ersten Unterschied stoppen Sie, welche Anweisung sie verursacht hat.
  Debuggen Sie es und fahren Sie fort, bis Sie "fehlerfrei" sind. Vorsicht, der zweite Kern kann auch fehlerhaft sein, also debuggen Sie mit Vorsicht.

Wenn Sie mehr laufbar sind, verwenden Sie den Kerntester

Verwenden Zexall Tainer. Es ist das Beste auf Z80 (Zumindest aus meiner Erfahrung). Es hat mir bei sehr vielen Dingen geholfen (mein Kern ist jetzt zu 100% zexall kompatibel). Es wird gegen echte Hardware durchgeführt, sodass es keine Fehler enthält. Es ist von CP/m Einige Versionen brauchen also 64K RAM -Modus laufen. Anders OS/ROM Oder was auch immer einige Anweisungen bei Speicherzugriff zu Fehlschlägen verursachen kann. Für diejenigen, die Sie für korrigierte CRCs finden oder mit echten Hardware verglichen werden.

Zum Beispiel roh Zexall scheitert viele Dinge an ZX -Spektrum (wie es getan wird für MSX und 64K RAM ohne Rom), aber es werden Versionen wirklich erledigt ZX -Spektrum Und sie sind 100% OK an ZX -Spektrum (Und auf meinem Emulator auch :))

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

Falls Sie kurz davor sind, zu verwenden Zexall Vorsicht, es ist wirklich umfassender Test und Iirc an ~ 50 MHz Nachahmung, die es brauchte, 30-60 min zu vervollständigen. Und es muss eine Taste drücken, um einige Male zu scrollen ...

Wenn Sie ein Streitmodell benötigen, fügen Sie die richtigen Tests hinzu. Dann finden Sie einen. Zum ZX -Spektrum Es gibt viele schwimmende Bus-, Interrupt- und Screen -Tester. Zum Ti Ich habe keine Ahnung ... (Ich bin kein Ti Taschenrechner Benutzer)

Übrigens: Wie lief es mit Ihrem Emulator? (Hast du es gemacht?)

Befehlssatz

Ich würde meinen Anweisungssatz hier kopieren, aber es hat 1792 Zeilen und 121 kb, so dass es nicht in ein 30 -kb -Grenze passt. Stattdessen finden Sie es in einem Download -Link in meiner Antwort von mir

Was ist die richtige Implementierung für die Hardwareemulation.

Es enthält 'alle' ZX Anweisungen mit korrekt Op Codes, Codieren des Timings und Maschinenzyklen. Ich habe einige Jahre gebraucht, um alle Dokumentationen zusammenzustellen, also bin ich vorbei Zexall 100% korrekt. Mein Emulator lädt diese Textdatei (1792 Anweisung) in den Kern des Kerns init und konfiguriert den Anweisungsdecoder und den Prozessor zur Laufzeit, sodass ich die Dinge sehr schnell und einfach genug ändern konnte (wenn ein Fehler erkannt wurde) ... es hat mir eine gespeichert. viel von Zeit.

Mitch ist völlig korrekt. Beginnen Sie damit, den Prozessor zu verstehen. Spielen Sie dann ein bisschen herum, indem Sie Code schreiben, um bestimmte Anweisungen zu implementieren. Verwenden Sie C ++ dafür, übrigens, nicht C, oder die Konzepte des Prozessors werden nicht den Klassen in Ihrem Code abbilden.

Bei der Implementierung von Anweisungen müssen Sie Dinge wie die Flags und den Anweisungszeiger definieren. Das sollte Sie irgendwann dorthin bringen, wo Sie das Speichermodell und sogar das I/A -Modell implementieren müssen.

Sie müssen irgendwann herausfinden, wie Sie Code und Daten in den Speicher laden und möglicherweise wieder auf die Festplatte abgeladen werden.

Nur dann müssen Sie bei einem bestimmten Befehlszeiger die Ausführung von Code ausführen, die in den Speicher geladen werden.

Versuchen Sie, das Sega -Master -System und die Game Gear -Emulatoren auszusehen (ich bin mir ziemlich sicher, dass einige Open Source sind). Diese Konsolen haben einen Z80 als CPU undZX -Spektrum benutzte es auch, http://www.worldofspectrum.org/emulators.html.

Sie möchten einen Emulator für mehr als einen Prozessor, aber für eine komplette Maschine. Sie werden auch die Aufgabe haben, den Rest der Hardware zu emulieren und die Dokumentation dafür zu finden, könnte die schwierigere Aufgabe sein, die Sie warten.

Abhängig von Ihrem Ziel möchten Sie möglicherweise mit einem bereits vorhandenen Emulator für Z80 beginnen. Eine schnelle Suche gibt einige von ihnen, aber keinen Emulator für TI-84. Simh, Ein Rahmen für alte Computeremulation hat bereits die Nachahmung eines Z80 -Prozessors, der die Nachahmung des Restes Ihrer Hardware einfacher sein sollte, als von vorne zu beginnen. Selbst wenn Sie diese Straße nicht gehen, gibt es dort einige Designdokumente, die Ihnen helfen könnten.

Ich würde empfehlen, dass Sie in Betracht ziehen, einen Emulator für eine etwas einfachere, aber verwandte CPU zu schreiben, die 8080. Der Z80 ist eigentlich ziemlich kompliziert (Multi-Byte-Anweisungen, mehr Adressierungsmodi, Indexregister usw.), während 8080 Anweisungen sehr einfach zu dekodieren sind (Sie können einfach eine 256-Eingang-Nachschlagetabelle als Lösung erster Ordnung verwenden). .

Der gesamte Code, den Sie schreiben, um das Programm zu steuern (Anzeige, Dateneingabe, Speicher-Dumps usw.), sollten wiederverwendbar sein, wenn Sie sich dann entscheiden, um den Z80 zu versuchen, und Sie sollten tatsächlich die Benutzeroberfläche als simuliertes Prozessor entwerfen -unabhängig.

Ich habe hier alles über die Z80- und Taschenrechnerbaugruppe gelernt: http://www.ticalc.org/programming/

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow