Écrire un émulateur graphique Z80 en C ou C ++ [fermé]

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

  •  06-07-2019
  •  | 
  •  

Question

Je souhaite m'intéresser à l'écriture de mon propre émulateur simple pour le processeur Z80 . Je n'ai aucune expérience avec ce type de programmation. L’utilisation des langages basés sur le langage C me convient le mieux, car ce sont ceux que je connais le mieux.

De quoi ai-je besoin pour cela et quels sont quelques bons tutoriels / références qui pourraient m'aider dans ce projet?

J'aimerais aussi un tutoriel pour coder une application de suppression de ROM pour mon TI-84 Plus pour pouvoir utiliser sa ROM avec cet émulateur.

Autres conseils

C’est un peu une erreur, mais puisque vous dites que vous n’avez aucune expérience de ce type de programmation, vous voudrez peut-être commencer par créer un émulateur pour le Machine virtuelle universelle du concours de programmation 2006 de l'ICFP . C’est une tâche qui prend 90 minutes à un programmeur expérimenté, mais de nombreuses équipes n’ayant aucune expérience ont été en mesure de la terminer en quelques jours. Lorsque vous avez terminé l'émulateur, vous obtenez une foule de choses amusantes et vous aurez peut-être besoin d'un bon échauffement avant de vous attaquer au Z80.

Quelques éléments à ajouter (en particulier pour le Z80):

  1. Ne croyez pas que la documentation est 100% sans bug

    Je n'en ai pas vu sans bogues, y compris ceux mentionnés ici.

  2. Testez correctement les bugs de votre cœur de processeur

    Cela vous évitera de nombreux maux de tête et confusion plus tard.

Pour tester, j'utilise trois approches:

  1. Marche / recherche par rapport au code connu (désassemblage de la ROM généralement commenté)

    C'est la première étape quand rien ne fonctionne encore. Vous verrez des instructions mal codées.

  2. Incluez différents cœurs Z80 dans votre émulateur et traitez le tout en double émulation

    Créez deux émulateurs "séparés" avec le même système de progression, de traçage et d'exécution. Les deux processeurs doivent avoir leur propre matériel de mémoire, etc.

    Mon exemple d'émulateur double

    • Lancez l'émulateur puis, après chaque instruction, comparez les registres et les emplacements de mémoire immédiats, tels que [hl], [sp], [sp-1] ...
    • À la première différence, arrêtez-vous et voyez quelle instruction l’a provoquée.
      Déboguez-le et continuez jusqu'à ce que vous soyez «sans bug». Attention, le second noyau peut aussi être bogué, donc corrigez avec prudence.

  3. Lorsque vous êtes plus en mesure d'utiliser un testeur de noyau

    Utilisez ZEXALL Exerciser . C’est le meilleur sur Z80 (du moins de par mon expérience). Cela m'a aidé avec beaucoup de choses (mon coeur est maintenant compatible à 100% avec ZEXALL). C'est fait contre du vrai matériel, donc il n'y a pas de bugs. C'est à partir de CP / M , certaines versions nécessitent donc Mode RAM 64K à exécuter. Différents OS / ROM ou tout autre élément peuvent entraîner l'échec de certaines instructions d'accès à la mémoire. Vous devez donc rechercher les CRC corrigés ou les comparer à du matériel réel.

    Par exemple, ZEXALL brut échoue beaucoup de choses sur ZX Spectrum (comme pour MSX et 64K de RAM sans ROM ), mais certaines versions ont été créées pour de véritables ZX Spectrum et elles sont 100% OK sur ZX Spectrum (et sur mon émulateur aussi:)) 

    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

    Si vous êtes sur le point d'utiliser ZEXALL , le test est exhaustif et IIRC sous ~ 50 MHz , il a fallu environ . 30-60 min à compléter. Et il faut appuyer sur une touche pour faire défiler plusieurs fois ...

    Si vous avez besoin d'un modèle de conflit, ajoutez les tests appropriés. Alors trouvez-en un. Pour ZX Spectrum , il existe de nombreux testeurs de bus, d'interruptions et de tests flottants. Pour TI , je n'ai aucune idée ... (je ne suis pas un TI utilisateur de la calculatrice)

BTW: Comment cela s'est-il passé avec votre émulateur? (L'avez-vous fait?)

Jeu d'instructions

Je copierais mon jeu d'instructions ici, mais il comporte 1792 lignes et 121 Ko. Il ne correspond donc pas à une limite de 30 Ko. Au lieu de cela, vous pouvez le trouver dans un lien de téléchargement dans cette réponse

Il contient toutes les instructions ZX avec les codes OP corrects, le minutage de codage et les cycles de la machine. Il m'a fallu plusieurs années pour rassembler toute la documentation. Je passe donc correctement ZEXALL 100% . Mon émulateur charge ce fichier texte (1792 instructions) au cœur de init et configure le décodeur d’instruction et le processeur au moment de l’exécution, ce qui m’a permis de changer les choses très rapidement et assez simplement (si un bogue était détecté ) ... Cela m'a fait gagner un lot de temps.

Mitch a parfaitement raison. Commencez par comprendre le processeur. Puis jouez un peu en écrivant du code pour implémenter des instructions particulières. Utilisez C ++ pour cela, BTW, pas C, sinon les concepts du processeur ne mapperont pas sur les classes de votre code.

Lors de la mise en œuvre des instructions, vous constaterez que vous devez définir des éléments tels que les indicateurs et le pointeur d’instruction. Cela devrait éventuellement vous amener là où vous devez implémenter le modèle de mémoire, et même le modèle d'E / S.

Vous devrez éventuellement comprendre comment charger le code et les données dans la mémoire, et peut-être comment le vider sur disque.

Vous devez alors arriver au point d'émuler l'exécution de code, chargé en mémoire, à un pointeur d'instruction donné.

Essayez de regarder les émulateurs Sega Master System et Game Gear (je suis sûr que certains sont open source). Ces consoles ont un processeur Z80, et ZX Spectrum l'a également utilisée, http://www.worldofspectrum.org/emulators.html .

Vous semblez vouloir un émulateur pour plus qu'un processeur, mais pour une machine complète. Vous devrez également émuler le reste du matériel, et trouver la documentation à ce sujet pourrait bien être la tâche la plus difficile qui vous attend.

En fonction de votre objectif, vous souhaiterez peut-être commencer avec un émulateur déjà existant pour Z80. Une recherche rapide en donne plusieurs mais pas d'émulateur pour la TI-84. simh , un cadre pour l'émulation d'anciens ordinateurs dispose déjà de l'émulation d'un processeur Z80, en ajoutant une émulation du reste de votre le matériel devrait être plus facile que de partir de zéro. Même si vous ne suivez pas cette route, certains documents de conception pourraient vous aider.

Je vous recommanderais de commencer par écrire un émulateur pour un processeur légèrement plus simple, mais apparenté, le . 8080 . Le Z80 est en fait assez compliqué (instructions sur plusieurs octets, plusieurs modes d'adressage, registres d'index, etc.), alors que les instructions 8080 sont très faciles à décoder (vous pouvez simplement utiliser une table de conversion de 256 entrées, comme solution de premier ordre) .

Tout le code que vous écrivez pour contrôler le programme (affichage, saisie de données, vidage de la mémoire, etc.) doit être réutilisé si vous décidez ensuite de tenter le Z80, et vous devez en fait concevoir l'interface utilisateur pour: être simulé indépendamment du processeur.

J'ai appris tout ce que je sais sur le Z80 et l'ensemble de la calculatrice ici: http://www.ticalc.org / programmation /

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top