Ik “zet CHIP-8 naar voren.

Dit systeem is in wezen een virtuele machine die om de een of andere reden is ontwikkeld. Er zijn spellen geschreven voor de CHIP-8. Het heeft een paar opcodes, een stapel, een paar timers en een bitmapweergave met lage resolutie, maar het is eenvoudig genoeg dat de eerste paar emulators passen in een paar kilobytes op vroege 8-bit computers.

Er zijn meer dan een paar referentie-implementaties die je zou kunnen gebruiken.

Er zijn games en dergelijke die in het openbaar zijn domein al, zoals hier , zodat u “niet uw eigen games hoeft aan te leveren.

Reacties

• Ayy voor Chip 8. Het ‘ is gemakkelijk om implementaties in vele talen te vinden en de architectuur is eenvoudig.
• CHIP-8 is geweldig idee voor een introductie tot emu lation vanwege zijn eenvoud.Nu ik eerder een NES-emulator heb geschreven, kan ik je vertellen dat het schrijven van de CPU extreem tijdrovend en vervelend was – en de 6502 is eenvoudig wat betreft CPUs. CHIP-8 daarentegen heeft slechts 35 zeer eenvoudige instructies. Bovendien vertrouwden veel systemen op nauwkeurig timinggedrag tussen de CPU en de rest van de hardware, terwijl CHIP-8 zon vereiste niet heeft.
• Opmerkingen zijn niet voor uitgebreide discussie; dit gesprek is verplaatst naar chat .
• Ik ‘ ben een ervaren programmeur, maar Ik heb nooit een emulator geschreven. Na dit antwoord dacht ik: ” Hé, deze chip8 ziet er eenvoudig genoeg uit, ik ‘ zal er misschien een paar uur aan besteden “. Drie weken later ben ik ‘ hier nog steeds aan het proberen uit te zoeken waarom programmas steeds uit de geheugenruimte springen. Veel plezier, ook veel ” wat de hel “.
• Ik vraag me af of die er geweest zouden zijn belemmering om de vblank wait uit de plot-sprite routine te verwijderen en een expliciete vblank-wait instructie toe te voegen? De CDP1802 is geen ‘ een snelheidsduivel, maar het zou vrijwel zeker meer dan één sprite per frame kunnen tekenen zonder de vblank-wachttijd.

Oh. Goede vraag. Ik zal proberen een paar hints te geven, maar ik zou het probleem veel te breed vinden om hier te worden beantwoord in plaats van een zinvoller gesprek. Niettemin:

---

[…] de leerlingen opdragen een emulator voor een ouder systeem te maken

Best gaaf.

helemaal opnieuw,

Als dit echt vanaf nul en in software zou moeten zijn, zou het niet echt beschouw het als een taak die geschikt is voor eerstejaarsstudenten in zon beperkte tijd. Tenzij er een manier is om real-time vereisten te verwijderen (die nog relevanter zijn voor games), zou ik liever voorzichtig zijn.

In feite, aangezien het om EE gaat, waarom geen echte hardware gebruiken? Het is nog steeds gemakkelijk om (sommige) klassieke CPUs en aanverwante apparaten te krijgen. Gecombineerd met als een moderne LCD is de hardware-inspanning in een paar weken tot in detail uitvoerbaar.

als een groepsproject dat moet worden afgerond tot het einde van de klas (die, zoals gezegd, 2 semesters lang is).

Wat misschien wel de meest krappe voorwaarde is.

Ik probeer een goed doelsysteem voor dit project te kiezen, met als belangrijkste doel dat het vrij eenvoudig te emuleren moet zijn. Hoe minder randapparatuur er moet worden geëmuleerd, hoe beter. minder eigenaardigheden en bugs die moeten worden gerepliceerd, ook hoe beter.

Klinkt als een goede poging. En nog belangrijker, het verwijdert enkele ogenschijnlijk eenvoudige systemen (zoals singleboarders) uit de lijst, omdat ze afhankelijk zijn van complexe verwerking van I / O-apparaten (zoals realtime toegang tot poorten om LED-segmenten schijnbaar continu aan te sturen).

Ik wil de studenten kennis laten maken met de belangrijke concepten van assemblage taal, instructiecodering, adresseringsmodi, CPU-registers, geheugen toegewezen hardwareregisters, enz.,

Iets dat kan worden gedaan met echte hardware zoals net zo goed als een emulatie, is het niet?

Idealiter zou het systeem in kwestie geen cyclus-nauwkeurige emulatie of trucs nodig hebben, zoals het achterna zitten van de scanline.

Samen met de impliciete vereiste voor een video-uitvoer, vereist dit een eenvoudige niet-versnelde bitmaplogica.

Een tweede vereiste heeft betrekking op prestaties. De studenten zijn zeker “niet bekend met software-optimalisatietechnieken, dus als je probeert zelfs de eerste Playstation of de Nintendo 64 te emuleren, krijg je waarschijnlijk prestatieproblemen (misschien zelfs de SNES en Genesis).

Ik zou hier niet veel bang voor zijn, aangezien de daadwerkelijke pc-hardware vrij snel is. De echte problemen hier zijn niet de snelheid van emulatie, maar real-time aspecten – het synchroniseren van verschillende emulatiedelen – die een zeer zorgvuldig en nauwkeurig afgesteld softwareontwerp vereisen. Hier niet te verwachten. Nogal het “racing the beam” -gedeelte dat je noemde.

Op dit punt hoeven de leerlingen zich alleen maar zorgen te maken over het correct implementeren van de emulator, niet efficiënt. CPU-emulatie zal zeker worden geïmplementeerd door een tolk, niet door een vertaler / recompiler.

Toch is zelfs voor de meest primitieve, real-time synchronisatie nodig om speel een spelletje. Synchronisatie van schermterugloop is in ieder geval een must – niet in ieder geval om de simulatie zelf snel om te schakelen.

De inherente behoefte van games om timingeffecten te gebruiken – en gesynchroniseerde schermmanipulatie op een fijner niveau dan frames – is iets dat het spelen van een echte game op de voorgestelde emulator een uitdaging zal maken.

Ik “zou graag een systeem willen kiezen waarvoor games zijn gemaakt, zelfs als dat systeem geen speciale videogameconsole was. Ik denk dat het erg motiverend zou zijn om games op de emulator te draaien.

Ik ben het hier van harte mee eens. Een groot deel van het succes van Andre LaMothe “s experiment- en leersystemen is gebaseerd op het belangrijkste vermogen om games te doen.

Op dit moment kijk ik bijvoorbeeld naar de NES, maar het voelt nog steeds een beetje ingewikkeld aan, vooral de PPU. Zijn er eenvoudigere opties?

Het wordt moeilijk omdat de basisvereisten elkaar tegenspreken. Alleen succesvolle consoles / computers hebben een grote selectie aan games, maar deze hebben ook een complexere hardwarestructuur waardoor geweldige games mogelijk zijn.

Laten we eens kijken naar enkele bekende systemen. Ik zou ze graag willen scheiden in “eenvoudige” en “complexe” systemen samen met de complexiteit van hun videologica (* 1)

Simpele systemen

In eerste instantie zijn dit alle systemen zonder een speciale VDC / CRTC.

• Atari VCS – uiteindelijk het ultieme systeem om te leren assembleren, werken op een extreem basisniveau zonder er tussenin en er is niet veel om voor te zorgen. “is de naamgenoot van de term” racing the beam “.

  Dat gezegd hebbende, kan het nog steeds een systeem zijn om naar te zoeken, aangezien de timing-afhankelijke onderdelen goed gedefinieerd zijn en (in vergelijking met andere videos) extreem eenvoudig en gemakkelijk te emuleren – behalve dat het geen eerstejaars-dingen zijn. Het is ook buitengewoon goed gedocumenteerd op algemeen beschikbare bronnen.

• Commodore PET – Een vrij eenvoudig systeem, Vooral sinds het hele videogedeelte kan vrij abstract worden geëmuleerd, maar de VIAs moeten, althans gedeeltelijk, worden geëmuleerd. Het belangrijkste dat het slechts twee timingbronnen bevat (naast de klok).

  Een groot pluspunt voor de PET (en follow-ups) is de goede documentatie (ook vanwege de eenvoud). Hoewel het een CRTC bevat, heeft bijna geen enkele game (of andere software) het helemaal opnieuw geprogrammeerd, waardoor een eenvoudige en onvolledige (abstracte) emulatie mogelijk is.

  Aan de achterkant is er wel slechts een vrij klein aantal spellen en de meeste zijn geschreven in BASIC, wat misschien wat onderzoek vereist om de hoeveelheid abstractie versus detail in emulatie te vinden.

• Apple II – Nogmaals, een ongelooflijk goed gedocumenteerd systeem met veel software. Veel ervan is gebaseerd op assemblage. Hoewel de hardware volledig is gedocumenteerd en alleen is opgebouwd uit TTL, is de werking ervan niet echt eenvoudig en aangezien sommige games sterk afhankelijk zijn van eigenaardigheden en het tellen van loops voor exacte timing, kan emulatie veel gecompliceerder worden dan op het eerste gezicht wordt aangenomen.

  Een pluspunt voor jou zou kunnen zijn dat de Apple II behoorlijk populair was in Brazilië (toen lang geleden).

• TRS-80 – Ook hier de videologica is opgebouwd uit TTL maar veel eenvoudiger dan op de Apple. Vergelijkbare andere I / O is vrij eenvoudig. Aan de negatieve kant is wederom een vrij klein aantal spellen.

Tot dusver kunnen de echte ouden, maar ook enkele latere systemen als eenvoudig worden geclassificeerd:

• Sinclair Spectrum – Hoewel de logica een paar trucs biedt, klokken & fluitjes, is het een rechttoe rechtaan betegeld bitmapontwerp. Tot dusverre zijn de kansen op een emulatie goed, behalve dat, zoals gewoonlijk, games erg afhankelijk waren van timing, iets wat de emulatie weer compliceerde.

  Evenals bij de Apple II waren er nogal wat klonen in Brazilië .

• Een soortgelijk argument kan worden aangevoerd voor de ORIC-familie

• Atari ST – Het kan een verrassing zijn vanaf het punt van vandaag uitzicht, maar de Atari ST had geen geavanceerde videohardware. Slechts 3 grafische resoluties en een 9 bit CLUT voor maximaal 16 gelijktijdige kleuren. Een paar synchronisatiepunten en een enkele timer. Plus een modernere CPU en een speciale geluidschip. Klinkt als een match made in heaven, als, nou ja, het zou niet weer voor de programmeurs van games zijn. Ook hier impliceerde software een hele reeks trucs om geweldige games te maken (* 2).

Een eerste conclusie voor “eenvoudige” systemen is dat hoewel de hardware misschien minder complex is, software er veel moeite voor heeft gedaan om dit te verhelpen. Als gevolg daarvan kan worden gezegd dat minder complexe systemen een emulatie niet noodzakelijkerwijs minder complex maken, aangezien er niet meer verschillende hardware moet worden geëmuleerd, maar de eenvoudige hardware moet qua timing zeer nauwkeurig worden gevolgd om de bestaande spelcode te laten draaien.

Complexe systemen

Dit zijn in het algemeen alle systemen met een geavanceerde VDC

• 9918 ff .- Dit gaat niet zozeer om een enkel systeem, maar uiteindelijk om de meest gebruikte VDC (TI noemde het VDP). Hoewel ontworpen voor de TI 99/4, verkocht TI het wel aan iedereen die geïnteresseerd was. Het resulteerde in de meerderheid van alle systemen (* 3) met een 9918 of een van de vervolgontwerpen (9928/38/58 / …).

  Spelconsoles zoals Coleco Vision , Sega SG-1000 helemaal tot aan het Master System een put en computers van TI 99/4 of Memotech MTX helemaal tot aan de de hele wereld van MSX -machines heeft deze familie gebruikt.

  Klinkt goed, nietwaar? Nou, er zijn zeker veel spellen om te gebruiken. Verder helpt een dergelijke VDP om de emulatie te vereenvoudigen, aangezien het een duidelijke scheiding biedt tussen CPU en scherm en beperkt welke “trucs” een game kan gebruiken tot wat de VDP biedt, wat op zijn beurt duidelijk is gedefinieerd. En nogmaals, het is de bestaande software die emulatie moeilijk maakt, aangezien programmeurs natuurlijk timing-trucs gebruikten om het scherm op het juiste moment te manipuleren. Heeft iemand “Racing the Beam” genoemd?

• Commodore VC20, C64, C16, etc. – Hetzelfde geldt voor alle Commodores homecomputers. Hoewel ze verschillen in complexiteit door sprites te hebben of niet, timers aanbieden of niet en geluid of niet, probleem is hetzelfde als bij de 9918-familie: software die bepaalde timing-situaties gebruikt om game-effecten te creëren.

• 6847 Systems – Tandy CoCo, Matra Alice en dergelijke hebben hetzelfde probleem.

Ik zou door kunnen gaan met spelsystemen zoals NES of MegaDrive, maar ik zal die lijst hier beëindigen, aangezien het principe nu duidelijk zou moeten zijn: hoewel sommige systemen lijken op complexer om te emuleren, het echte probleem is niet de complexiteit van videohardware, maar wanneer een programmeur “verbetert” wat kan worden gedaan door slim te programmeren (* 4). Het echte probleem voor uw project is dus niet “niet (zozeer) de hardware (* 5), maar” de software, , vooral de trucs en tools die in echt bestaande games worden gebruikt .

Dat is vooral erg, aangezien je (zoals ik het gelezen heb) bestaande games als motivatie wilt gebruiken. Er zullen er niet veel op draaien een minder moeilijke real-time emulatie.

Door deze afhankelijkheid te verkleinen, zal het aantal spellen dat correct wordt uitgevoerd, verminderen. Door het terug te brengen tot een niveau waarop het kan worden afgehandeld in een tijdslimiet, wordt het bijna onmogelijk om geschikte spellen te vinden.

Conclusie: Het vinden van de juiste afweging is een manier, maar een die veel onderzoek zal vergen, terwijl de bruikbaarheid nog steeds wordt beperkt.

---

Nu is het misschien mogelijk om aan te vallen dit vanuit een iets andere hoek. Laten we wat proberen:

• Gebruik van bestaande oude hardware:

  Hoewel dit is bewezen (* 6) om te werken, de hoogste compatibiliteit en gebruiksgemak biedt vanwege open ontwikkelomgevingen, kan het de aantrekkingskracht van EE-studenten missen.

• Gebruik bestaande educatieve spelsystemen:

  Systemen zoals Andre LaMothe “s XGS zijn geweldige tools om in het bouwen en programmeren van gedetailleerde hardware te duiken. Zeker, wat solderen vereist (er zijn kant-en-klare versies beschikbaar), het zijn bijna complete software-gedefinieerde systemen, overal gedocumenteerd en bieden een enorme bibliotheek met spellen. Om nog maar te zwijgen van zijn boeken over het programmeren van games.

  Een geweldige bonus is dat studenten het systeem misschien mee naar huis kunnen nemen en kunnen spelen, zelfs nadat de cursus is afgelopen.

• Bouw je eigen eenvoudige systeem:

  Neem een klassieke CPU (bijvoorbeeld 6502), wat RAM, FLASH en een VIA plus een FPGA om een heel eenvoudige CRTC te implementeren en klaar. Studenten zullen het solderen, kunnen leren over de componenten en hun interactie, inclusief FPGA-gebruik (wat sowieso toch een must is) en vervolgens hun software op echte hardware laten draaien. Zelfs met kleine aantallen zou het mogelijk moeten zijn om zon bord te produceren rond de 50 euro of minder. Net als het XGS-idee zal het werken nadat de cursus is afgelopen – inclusief het gevoel van eigenaarschap als hun systeem.

  Natuurlijk zullen studenten hun eigen spellen moeten schrijven, maar eenvoudige spellen kunnen in vrij korte tijd worden gedaan – om nog maar te zwijgen van het feit dat vervolgcursussen net zo goed spellen kunnen gebruiken die de vorige klas heeft geschreven.

• Doe een emulatie van “je eigen” systeem

  Net als voorheen, behalve dat alles virtueel is. Het had het voordeel dat het een put was gedefinieerd en sluit systeem, vooral een waar er geen beperkingen zijn vanwege een minder “perfecte” emulatie – de emulatie is per definitie perfect en al zijn eigenaardigheden zijn degene die het systeem heeft.Nadeel is opnieuw het softwaregedeelte.

• Gebruik “zachte” hardware:

  Er is een project van Neil Franklin dat een aantal algemene systeemcomponenten creëert zoals klassieke computers hadden, maar met behulp van microcontrollers in plaats van speciale chips. Het combineert emulatie met echte hardware. Hoewel componenten nog steeds als emulatie worden ontwikkeld, zijn deze bedoeld om in een microcontroller te draaien en net als “echte” chips te worden gebruikt. Eén systeem kan worden opgezet door een SoftCPU-module te gebruiken die bijvoorbeeld een 6502 emuleert met wat RAM en ROM, gecombineerd met een SoftVGA die een terminalachtige video-interface levert en een SoftPS2-emulerend toetsenbord en muis. Ze zijn allemaal verbonden via een parallelle of seriële (SPI) bus waardoor andere componenten kunnen worden toegevoegd die ook aan de emulatie kunnen worden gepresenteerd.

  Behalve dat het helemaal om emulatie gaat, bevat het ook een beperkte hoeveelheid hardware die kan worden gedaan op een breadboard (maar het is nooit te vroeg om te beginnen met solderen), het toont ook een vrij typische taak van de hedendaagse engineering – het vervangen van traditionele logica door microcontrollers – in praktisch gebruik.

  De resultaat is een systeem dat de touch en feel van een echte (oude) computer biedt terwijl het wordt gebouwd met moderne hardware die parallelle emulaties uitvoert.

• Gebruik van een configureerbare emulator:

  Nee, dit gaat niet over MAME of iets dergelijks, maar over een emulator-framework geschreven in JavaScript, dat de generieke delen afhandelt (inclusief timing), waar je leerlingen hun emulaties zullen toevoegen (wat een doel was, nietwaar?) om een heel systeem te vormen. Aangezien JS in de broncode wordt geleverd, kan zelfs het Framework zelf worden gewijzigd.

  Afhankelijk van de kwaliteit van elke emulatie, kan dit bruikbaar zijn voor alles, van een eenvoudig demonstratiesysteem tot een volledig berekende recreatie van een jaren 80 computer.

Dus, misschien kunnen sommige van de bovenstaande variaties een goed begin zijn?

---

* 1 – Ik zal me alleen concentreren op video (en CPU) om het simpel te houden. Ook video alleen zal al goed werken om uit te wieden tot complete systemen. Geluid zal een andere dimensie toevoegen en het kan het ver buiten het bereik hiervan compliceren.

* 2 – Kijk maar eens naar Xenon. Een baanbrekende verticale scroller met meerdere verschuivende lagen en veel geanimeerde objecten, allemaal super soepel in software. In feite was het zo fijn afgesteld, dat het porten naar de (meestal) meer capabele Amiga (grafisch gezien) behoorlijk wat tijd in beslag nam en resulteerde in een wat mindere game.

* 3 – Systemen ontworpen niet nodig verkochte eenheden. Maar nogmaals, sommige gameconsoles waren meer dan alleen succesvol, dus het kan zelfs de meerderheid in cijfers krijgen.

* 4 – De blogposts van de hoofdontwikkelaar van de Glide64 renderer-plug-in voor N64-emulators heeft een meerdelige serie geschreven ( Intro , P .1 , P.2 , P.3 ) van blogberichten over de hindernissen die hij moest nemen om het video-emulatiegedeelte te laten werken – allemaal niet over de complexiteit van het emuleren van de hardware, maar alle vereiste manieren waarop de CPU de uitvoer heeft aangepast en aangepast naast de videologica. Dit is des te opmerkelijker gezien het feit dat de N64 al een nogal absract en gesloten systeem is.

* 5 – In feite zou ik complexere videohardware beschouwen als een geweldige les voor EE-studenten, omdat het goed laat zien wat kan worden gedaan met een paar poorten in plaats van stapels software – temeer daar ze later hardware gaan doen, nietwaar?

* 6 – Stefan Höltgen van FU Berlin gebruikt bijvoorbeeld oude spelsystemen in zijn lessen om (niet-EE) studenten kennis te laten maken met echte hardware en echt programmeren en hun implicaties voor alledaagse taken (en games).

Reacties

• @Tommy Nou, ik zou dit graag willen vermijden, want er is geen eenvoudig antwoord. Het belangrijkste hier is misschien dat, hoewel de Z80 enigszins ” eigenzinnig “, de 68k is allesbehalve eenvoudig. Met alle uitbreidingswoorden (tot CPU32) kan een enkele instructie maximaal 11 woorden (22 bytes) bevatten en het decoderen ervan is een serieuze puinhoop. Maar nogmaals, het hangt allemaal af van de manier waarop de emulator is gemaakt. De Z80 is een vrij rechttoe rechtaan 8080, gemakkelijk te emuleren, met een paar modificatoren, die gemakkelijk kunnen worden gehanteerd. Voor de 68k, zelfs alleen de originele, zal het veel meer werk zijn.
• ” taak geschikt voor eerstejaars in zon beperkte tijd. ” Hij zei dat dit derdejaarsstudenten zijn, geen eerstejaars, en dat ze ‘ al aan verschillende voorwaarden hebben voldaan.
• @ wizzwizz4 Nou, wat onze persoonlijke mening ook is, JS is de wettige erfgenaam van BASIC. Serieus en in elk opzicht! Denk er gewoon over na.Het draait niet alleen n naast elke echte computer, het ‘ wordt zelfs standaard geïnstalleerd, en er is bijna geen manier om er vanaf te komen zonder veel functionaliteit te verliezen. Sterker nog, bedenk eens hoeveel slechte en ongelooflijk trage software er in JS wordt geschreven – het perfecte bewijs, is het niet ‘?
• @Raffzahn It ‘ s compleet anders Ten eerste had BASIC verschillende incompatibele implementaties … Ohhh! Het is de opvolger van BASIC!
• Ze ‘ zijn nog steeds geen eerstejaarsstudenten, dat zijn eerstejaarsstudenten. En ik denk dat je het OP het voordeel van de twijfel moet geven dat hij het project niet ‘ zou toewijzen als de studenten ‘ niet hebben de vereiste achtergrond.

Er zijn tot nu toe enkele goede ideeën.

Maar iets om over na te denken.

Als je zoiets doet als een CP / M-machine, zijn ze echt vrij eenvoudig en eenvoudig, vooral omdat alles geïsoleerd is door niet alleen het BIOS, maar ook de IN / OUT-aard van de 8080 / Z80-familie.

Het lijkt me niet ongewenst om een CP / M-machine het doel van het eerste semester te hebben. (Ik ken je syllabus niet)

Maar, bijvoorbeeld, een standaard CP / M-machine heeft geen cyclusnauwkeurigheid nodig, het heeft geen onderbrekingen nodig, het meest gecompliceerde wat het moet doen is het toetsenbord pollen om te zien of een toets is ingedrukt. (In tegenstelling tot het monitoren van keydown en keyup of iets anders.)

Vervolgens kunt u in het tweede semester de vereisten zoals interfacing toevoegen aan een grafische chip. Het bovenstaande exemplaar van de SG-1000 zou gemakkelijk een CP / M-machine kunnen zijn in het eerste semester, en dan gemakkelijk worden omgezet in de SG-1000 in het tweede (aangezien je het Z80-gedeelte helemaal hebt gedaan in het eerste semester) .

Ten slotte denk ik dat het goed is voor uw klas om een acceptatieprogramma te hebben dat studenten kunnen uitvoeren om hun CPU te verifiëren. Er zijn maar weinig dingen spannender dan het opsporen van fouten in een slechte CPU, vooral met machinetaal die u misschien niet kent .

De 6502-gemeenschap heeft testprogrammas die kunnen controleren of een CPU alle instructies correct uitvoert. Ik weet niet zeker wat er beschikbaar is voor de andere CPUs.

En of het is een troost voor de reikwijdte, ik heb zowel een simulator als een bijbehorende assembler af en toe geschreven gedurende een kerstvakantie van twee weken, als dat je helpt bij hoe groot de eigenlijke projecten zijn. Basis-CPUs zijn vrij eenvoudig.

Opmerkingen

• Op de Z80 biedt FUSE tests, hoewel ze niet allemaal algemeen of noodzakelijk correct zijn wat betreft de exacte cyclus timing; ze ‘ hebben ook een ad-hoc-tekstindeling, maar ik ‘ heb ze getranscribeerd naar JSON: github.com/TomHarte/CLK/tree/master/OSBindings/Mac/… – gebruik tests.in.json om initiële statussen in te stellen en uit te vinden hoe lang moet je rennen, dan tests.expected.json om de resultaten te verifiëren. Er zijn ‘ ook zexall en zexdoc, oorspronkelijk CP / M-bestanden, maar breed aangepast en erg traag. Het doorgeven van de eerste vereist een aantal ongedocumenteerde dingen om correct te zijn, het doorgeven van de laatste niet ‘ t.
• … en het enige dat ik ‘ die ooit is gevonden voor de 6809, ervan uitgaande dat iemand dacht een Vectrex of Coco / Dragon te suggereren, bevindt zich in een bredere Williams arcade machine-testsuite op seanriddle.com/wetsold.html . Voor de 6502 ben ik erg blij met de tests van Klaus Dormann, Wolfgang Lorenz en AllSuiteA, die allemaal veel prominenter lijken te zijn dan de Z80- of 6809-tests.
• @Tommy Wat betreft Ik ‘ ben me ervan bewust dat alle tests van Fuse ‘ cyclusnauwkeurig zijn. Dien bugs in als ze ‘ niet 🙂
• @PhilipKendall zie mijn e-mail van 29/5/2017 naar fuse-emulator-devel re: DJNZ en of de offset wordt gelezen bij een laatste iteratie. Conclusie van Alan Cox over de vraag of het geteste gedrag van FUSE ‘ correct is, was dat het ‘ s ” open voor interpretatie ” gebaseerd op de beschikbare bronnen. Dus ik dacht dat ” niet noodzakelijk correct ” eerlijk was. Ik had waarschijnlijk wel duidelijk moeten zijn: ik vond slechts een handvol afwijkingen in de ‘ interpretatie van bewijs van uw team en die van mijzelf. Excuses voor een slechte vorm hierover.
• @Tommy – ” Conclusie van Alan Cox over of FUSE ‘ s is getest gedrag correct is, was dat het ‘ s ” open stond voor interpretatie ” op basis van de beschikbare bronnen ” …hoewel ik veel respect heb voor veel van wat Alan doet, is het ‘ vrij eenvoudig om te verifiëren of het geteste gedrag hetzelfde is als een echte Z80 CPU (vooral voor CMOS-versies die kan worden uitgevoerd op een breadboard met lage kloksnelheden om heel eenvoudig gedetailleerde tests op te zetten), dus dit is zeker een geval waarbij als hij denkt dat er ‘ iets mis zou moeten zijn in staat om het heel gemakkelijk te demonstreren.

Mag ik de SG-1000 ?

Het systeem is weinig meer dan een groep van drie standaardchips – de Z80, de TMS9928A voor grafische afbeeldingen en de SN76489 voor geluid, met de controllers als domme groepen GEEN (normaal open) schakelaars.

In software of hardware zou je elk deel hiervan afzonderlijk of allemaal samen kunnen simuleren of emuleren om het complete systeem te produceren.

systeem gebruikt eenvoudige niet-bankgeschakelde ROMs voor zijn spellen, en dat zijn ze meestal Vertrouw niet op trucs zoals onderbrekingen op het middenscherm of het tellen van cycli om hun effecten te produceren. Slechts een enkele tegelkaart en een aantal sprites er bovenop. Ik stel voor dat dit veel eenvoudiger is dan een systeem met veel interactieve interne componenten en intelligente cartridges zoals de NES.

Je zou je eigen spellen moeten aanbieden om te emuleren in plaats van ongelicentieerde auteursrechtelijk beschermd materiaal natuurlijk.

Reacties

• … en, voor de goede orde, de ColecoVision is exact dezelfde verzameling componenten, met verschillende logica en iets meer gecompliceerde joypads. Dus een SG-1000-emulator is meestal gemakkelijk uit te breiden om beide te ondersteunen.
• Ook opmerkelijk dat de 9918 een complexe chip is, met sprites, complexe modi en gegevens, zoals hij deed ‘ niet willen gebruiken. Isn ‘ T it?

Een simpele, rechttoe rechtaan computer zoals de ZX Spectrum klinkt redelijk – maar er zijn gewoon al te veel goede emulators in de buurt om dit een nuttige optie te maken. Ik denk ook dat de 6502 gemakkelijker te emuleren is.

Een mogelijke optie zou dus de Oric-1 of Atmos by Tangerine-systemen kunnen zijn , die een 6502 geheugen zonder bank gebruikte, geen aangepaste chips behalve eenvoudige video, en een relatief eenvoudige framebuffer. Het is ook lang niet zo bekend als de Spectrum, maar er is software (games) beschikbaar om enkele eenvoudige compatibiliteitstests mee te nemen (ik denk dat een bepaald “gevoel van prestatie” buitengewoon belangrijk is voor studenten). Er zijn al een aantal emulators beschikbaar voor de Atmos (drie, voor zover ik weet), maar hun aantal is beperkt, waardoor het gemakkelijk is om erachter te komen of iemand vals heeft gespeeld en eenvoudig code heeft gekopieerd.

Geen van de Oric-spellen waren zo geavanceerd voor zover ik weet dat je een 100% cyclus-exacte emulatie nodig zou hebben om de spellen uit te voeren.

Reacties

• I ‘ d beweren dat de Oric-architectuur rasterracen ontmoedigt door geen zijkanaal van videobesturingsregisters te hebben en niet zo opgezet te zijn dat racen mogelijk je kleurresolutie zou kunnen verhogen (in tegenstelling tot een Spectrum). Als het echter maar twee HIRES-buffers had, zou ik ‘ d zeggen dat met meer vertrouwen. Bent u het daarmee eens?
• @Tommy Ik ‘ ben niet zo bekend met de Oric videocircuits. Wat ik in ieder geval zou willen zeggen, is dat de Oric zon korte levensduur had en zon beperkt gebruikersbestand dat geavanceerde technieken om de video te tweaken zoals we die kennen van de ZX Spectrum ‘ t ontwikkeld (althans niet tijdens het actieve leven van de computer, er ‘ een aantal interessante demos hier demozoo.org/platforms/ 49 )
• Oh, dan geef ik ‘ een betere redenering: de Oric-videochip heeft een modale status, inclusief tekst- of grafische modus, maar nee blootgestelde registers. Alles wordt ingesteld door besturingsbytes in de videostream – inclusief voorgrond- en achtergrondattributen. Mensen hebben de neiging daarover te klagen, omdat het betekent dat als je gapless graphics wilt, je ‘ beperkt bent tot vier kleuren per regel, waarvan er twee de bitsgewijze aanvullingen zijn van de andere twee. Sommige van de moderne games zien er echter nog steeds erg goed uit, bijv. Stormlord youtube.com/watch?v=QSDy-BC580M
• @Tommy De seriële attributen maken het programmeren een beetje lastiger, ik ‘ denk ik, maar de hoeveelheid attribuutclash is zelfs beter dan op het ZX Spectrum, denk ik.
• Xenon 1 heeft een exacte cyclus nodig, anders loopt het vast wanneer het schip explodeert (disclaimer: ik schreef een oric-emulator voor de amiga genaamd amoric en kwam dit probleem tegen, maar alleen over dit spel)

Op basis van uw criteria en de noodzaak om het project interessant te houden voor uw studenten, zou ik aanraden serieus rekening houdend met het Vectrex Arcadesysteem, dat begin jaren tachtig door Milton Bradley werd verkocht.

Omdat de Vectrex uniek is in het gebruik van een vectorweergave in plaats van een rasterweergave, doet hij dat niet vereisen dat gecompliceerde videohardware wordt geëmuleerd. Het scherm wordt beheerd door de CPU en het scherm zelf is eenvoudig te emuleren op een modern systeem en met goede prestaties.

Naast het emuleren van het vectorscherm, kan de CPU ( Motorola 6809) en de I / O-chip (MOS 6522) vertegenwoordigen niet te veel Het is een uitdaging aangezien het eenvoudige 8-bit delen zijn die zeer goed gedocumenteerd zijn.

Het geheugenmodel is ook erg eenvoudig, zonder bankschemas waarvan ik op de hoogte ben. Er zit een gewone PSG-geluidschip in de Vectrex, maar het emuleren ervan zou kunnen worden beschouwd als “Extra Credit”.

In tegenstelling tot andere eenvoudige gameconsoles uit de vroege jaren 80, hebben de Vectrex-games het redelijk goed gedaan, gezien de mogelijkheid om vloeiende monochrome afbeeldingen weer te geven, inclusief 3D-draadframe. Dit wordt verder bewezen door de populariteit van de moderne “home brew” -ontwikkeling, waarin ontwikkelaars doorgaan met het maken van nieuwe Vectrex-spellen.

Een laatste voordeel van de Vectrex is dat het originele systeem-ROM vrijelijk verspreid kan worden.

Reacties

• Behalve dat de vectrex ook goed past bij de ‘ Racing the Beam ‘ cathegory, ‘ niet?
• @Raffzahn, zoals ik het begrijp, bestuurt de Vectrex CPU de elektronenbundel – precies het tegenovergestelde van een ” racen door de straal ” situatie waarin software nauwkeurig getimede toestandswijzigingen moet aanbrengen in houd een extern getimede rasterscanweergave bij.
• @Mark It ‘ is hetzelfde met de VCS. Ook hier wordt de straal aangestuurd door de CPU. Zonder dat de CPU elke regel toegang heeft tot WSYNC en voordat de regel klaar is, zal het scherm haperen. En voor zover ik het OP begrijp, gaat het ‘ precies over niet het opnieuw creëren van een systeem met strikte timingvereisten – die essentieel zijn voor de Vectrex.
• @Raffzahn: De CPU in de VCS controleert de verticaal, maar niet de horizontale. Het ‘ is niet ongebruikelijk dat een spel tientallen of zelfs honderden scanregels uitvoert zonder tussenkomst van WSYNC. Als er geen WSYNC is, bevindt de straal zich elke 76e cyclus in dezelfde horizontale positie. Het opslaan van WSYNC is vaak de gemakkelijkste manier om te wachten tot de straal de rechterkant van het weergegeven gebied bereikt, maar ‘ is niet de enige manier. Een programmeur die zo geneigd was, kon de ingewikkelde details van de beweging en het gedrag van een sprite exploiteren om een spel te schrijven dat nog nooit WSYNC gebruikte.
• Eh, mensen, we hebben het hier over een emulator. Er zal geen probleem zijn met het vervagen van de fosforen terwijl de geëmuleerde CPU te lang duurt om het volgende frame te tekenen. Er is geen ” straal ” en er is zeker geen reden waarom de emulator ” race ” aangezien de emulatorweergave vrij statisch zal blijven zolang als nodig is tussen frames.

Het creëren van een geheel nieuwe emulator is een relatief grote taak, vooral voor onervaren studenten, en kan problematisch blijken te zijn. Je moet dus echt voorzichtig zijn met welk platform je wilt emuleren en welke informatie je moet delen / gebruiken. Voor mij is de beste keuze een ZX 48K-platform terwijl ik erop groeide en bekend ben met de innerlijke werking ervan, dus het antwoord zal daardoor bevooroordeeld zijn … Maar we moeten in gedachten houden dat studenten het tegenwoordig meestal niet zo veel zien / gebruiken / kenden als wij … Wat je moet bereiken is:

1. correcte CPU iset-emulatie

   zelfs als er talloze instructiesets-documenten beschikbaar zijn Je moet voorzichtig zijn, want op de Z80 bevat bijvoorbeeld 99,99% fouten. Dus je zou een geteste referentie-set voor hen moeten kiezen, want nu is het correct (of in ieder geval fundamenteel functioneel).

   Hier is bijvoorbeeld de mijne Z80 die ZEXAL met 100% succes doorgeeft:

   • mijn Zilog Z80A complete instructieset met timing van machinecycli

   Z80-platform heeft één groot voordeel en dat is dat er uitgebreide testers voor zijn, zoals ZEXALL Sporter die veel kan helpen bij het debuggen van de emulator.

   Ik denk dat er ook versies zijn voor i8080, maar ik ken geen dergelijke testers voor verschillende CPU-familie.

2. Timing

   goed voor basisemulatie is de clock tics-methode (of throttling) voldoende, die bekend is en wordt gebruikt … Ik zie hier geen probleem. Tegenwoordig hebben computers een relatief goede resolutie voor timing (op pc: RDTSC, op Windows PerformanceCounter, …).

   De basisemulator kan de INHOUD van het geëmuleerde platform negeren, maar pas op voor sommige OS / games / apps onbruikbaar worden gemaakt als ze niet correct worden geëmuleerd. Dit geldt niet alleen voor demos. De gebruikelijke timing op oude computers was afgeleid van enige onderbreking (meestal video-verversing) en een beperkt aantal cycli die eerder konden worden uitgevoerd. Maar met onenigheid kan het aantal instructies dat voor dezelfde tijd wordt uitgevoerd heel verschillend zijn en kunnen sommige programmas overlopen en zichzelf beschadigen of vastlopen. De CONTENTIE is het moeilijkste om te implementeren met kloktics, dus je moet het koste wat het kost vermijden … Aan de andere kant is het met de timing op MC-niveau heel gemakkelijk en slechts een paar regels code.

3. Geluid

   dit is een platformafhankelijk probleem en u moet de API kiezen die wordt gebruikt voor geluidsinvoer / -uitvoer correct. Op Windows is bijvoorbeeld de enige bruikbare optie WAvEIN / WAVEOUT vanwege de lage latentie en het eenvoudige gebruik. DirectX is onbruikbaar (ik probeerde het tenminste voor een dergelijke taak te gebruiken) vanwege HOGE latenties en niet werkende callbacks.

   Ik zou een gebufferde benadering gebruiken in plaats van directe luidsprekeraandrijving, zodat je emulatie kan barsten de uitvoeringstijd in plaats van MC-niveau correcte uitvoering (wat ik toch doe, maar ik betwijfel of studenten het in de huidige tijd zouden kunnen doen).

4. Video

   Deze is ook platformafhankelijk. .. en je moet een API gebruiken die je studenten kennen. Zelfs bundeltracering is relatief eenvoudig te implementeren met een eenvoudige bitmap … Op computers zoals ZX heeft de Scanline-volgorde een speciale betekenis en kan deze erg storend zijn voor beginnende codeerders, dus het is beter om LUT-vertaaltabellen te gebruiken die tussen adres en y-coördinaten heen en weer converteren.

   De meeste oudere platforms gebruikten een vernieuwingsfrequentie van 50Hz / 60Hz en een relatief kleine resolutie, dus tegenwoordig zouden computers, zelfs met niet goed geoptimaliseerde emulatie, er nog steeds snel genoeg voor moeten zijn. Als dit niet het geval is, is het overslaan van frames ook een optie …

5. andere hardware en randapparatuur

   Het absolute minimum is RAM / ROM-geheugen en toetsenbord. Geheugen is meestal erg eenvoudig, alleen een statische array en of wat pagina-omschakeling … Het toetsenbord kan worden geëmuleerd door de I / O in te stellen volgens de ingedrukte toetsen. De I / O kan ook geheugen worden toegewezen aan een array, net als geheugen. Trapping ISR routine is ook een optie, maar dat maakt het toetsenbord onbruikbaar voor custom key handlers.

   Ik zou geen moeite doen met FDC, AY, etc randapparatuur aangezien de emulator zo simpel mogelijk gehouden moet worden. Maar als je geluk hebt, zijn er misschien studenten die anderen ver voor zijn met dit project. Voor degenen die je zou kunnen voorstellen om opwindende functies te implementeren zoals FDC, DMA, zelfs echt geluidskaartgeluid (voor echte banden of andere audiospelers), maakt veel leuke functies mogelijk, zie bijvoorbeeld:

   • Z8410 DMA-chip als GPU?

6. Files

   Ik zou gaan voor Z80 / SNA-bestandsindelingen op Het gebruik van TAP / TZX is prettig, maar vanaf het begin zou de emulator behoorlijk buggy zijn, vandaar dat het laden van routines mogelijk niet goed werkt, wat het gebruik en debuggen erg moeilijk maakt.

7. ROM

   dit is het meest problematische deel aangezien veel platform-ROMs nog steeds niet gratis zijn en door ze te extraheren / downloaden / gebruiken voor emulatie riskeert u juridische problemen.

   Uit sommige opmerkingen hier lijkt het erop dat ZX ROMs nu het publieke domein zijn … en er zijn ook ROM-pri nts die het veel gemakkelijker maken om de eerste stappen van de emulator te debuggen (als er nog niets werkt).

   Maar je moet altijd Emulatie en legale zaken overwegen, vooral als de emulators ergens op internet worden geplaatst.

Hier enkele gerelateerde QA-links van mij:

• CPU- en andere hardware-specificaties verkrijgen voor emulatorontwikkeling
• Een grafische Z80 schrijven emulator in C of C ++ Ik raad ten zeerste aan om deze te lezen (vooral voor uw studenten) zal hen veel tijd en zenuwen besparen
• Wat is de juiste implementatie voor hardware-emulatie?

Bent u op zoek naar een Ik raad aan om binnen 8-bit computers te blijven (of vroege simpele 16/32 bit computers), ZX Spectrum 48k is zon relatief eenvoudig systeem – zeer goed gedocumenteerd, geen sprites, geen audiochip, nee RAM-banken, eenvoudige I / O, si mple graphics (hoewel met een rare lay-out), geen cyclus-perfecte emulatie vereist, welbekende CPU, eenvoudige cassettebehandeling (kan nog gemakkelijker worden gemaakt door ROM-traps). Er zijn tonnen spellen, waarvan vele met toegestane licenties.

Het nadeel: er is een enorm aantal beschikbare emulators, waarvan vele in de retro-categorie, en veel met broncode beschikbaar, dus het gevaar van bedrog en het kopiëren van andere code is groot.

En natuurlijk zou het werken aan een emulator van een voorheen niet geëmuleerd systeem een extra voordeel opleveren van het gevoel van voldoening.

Reacties

• Ik had hetzelfde instinct, maar zou uitbreiden door te suggereren dat SNA en Z80 en goed gedefinieerde voldoende snapshot-indelingen die je nodig hebt ‘ maak je zelfs geen zorgen over de tape-emulatie. En, laat ‘ s eerlijk zijn, TZX is op dit moment een beetje een miasma.
• Ik geloof dat de Spectrum ROM nu in het publieke domein is, wat kan helpen (of dingen te gemakkelijk maken)
• De ZX Spectrum is een geweldig voorbeeld van eenvoudige hardware, maar ook een van vrij complexe, cyclustellingsprogrammering (Racing the Beam) om bruikbare game-effecten te verkrijgen.
• @Tommy Oh, ik zou de ZX80 / 81 nooit om dezelfde reden aanraden. En hoewel ik geen echte Spectrum-fan ben, heb ik er een goede timing-afhankelijke code voor gezien. De meeste prominet-schermmanipulaties nadat dat deel is weergegeven, maar voordat het eenmaal ronddraait. Het ‘ is een heel eenvoudig probleem dat op heel veel systemen wordt aangetroffen. Geen groot probleem, maar afhankelijk van de timing. Bijvoorbeeld eenvoudige emulatieschemas die alleen snelheid op frameniveau verdraaien, zullen rotzooi produceren op snellere emulatiehosts … enzovoort.
• @Stormcloud De Spectrum-ROM bevindt zich niet in het publieke domein, hoewel toestemming is verleend verleend om het te distribueren voor gebruik met emulators. De ZX80- en ZX81-ROMs zijn vrijgegeven onder de GPL.

Mag ik voorstellen om een kijkje te nemen naar enkele vroege arcadespellen? Specifiek deze twee 8080 / Z80-platforms:

• Midway 8080 – Ontwikkeld in 1975 en ondersteunt Space Invaders . Gebruikt een 256x224x1 bit zwart-wit framebuffer in RAM.

• VIC Dual – Sega / Gremlin “s platform ontworpen in 1977 – de bekendste game is Carnival . De video is een 32×28 array van 8×8 tekens (allemaal in RAM) en ondersteunt een eenvoudige kleurenpalet, toegewezen aan een PROM.

Deze zijn heel eenvoudig te emuleren als de Z80-emulatie eenmaal werkt. Er zijn geen grappige scanline-trucs of rare CPU-wachttoestanden. Speler besturingselementen zijn beschikbaar via bitmap I / O-poorten.

Je kunt interactief met deze platforms spelen op http://8bitworkshop.com/ (Volledige openbaarmaking: ik beheer deze site en ben de auteur van de boeken waarnaar op de site wordt verwezen en die deze platforms beschrijven)

The Apple] [is ook een goede keuze voor een op 6502 gebaseerd platform, hoewel het videosubsysteem ingewikkelder is dan op de twee arcadeplatforms.

Reacties

• Voor wat het ‘ waard, ik denk dat Space Invaders een geïnspireerde suggestie is. Als het geheugen het bedient ‘ is slechts een 8080 met een 1bpp bitmapped scherm, wat poort-IO voor de besturing, geen poging om tegen het raster te racen, audio in de vorm ” trigger noise X nu “, zeer ontspannen nauwkeurigheidseisen, en het produceert een spel dat ze nu nog steeds af en toe proberen te verkopen. Het ‘ is alleen het legaliteitsprobleem dat een pauze zou kunnen geven, hoewel ik ‘ altijd onduidelijk ben over academische uitzonderingen.
• Dat ‘ klopt vrijwel, er is ‘ ook een externe chip die helpt bij de 8080 ‘ s gebrek aan een barrel shifter. Er mag geen ‘ een legaliteitsprobleem zijn bij het emuleren van de hardware (er ‘ s geen auteursrechtelijk beschermde BIOS of andere code) en het is ‘ is vrij eenvoudig om uw eigen game te schrijven, bijvoorbeeld: 8bitworkshop.com/v3.2.0/?platform=mw8080bw& file = game2.c

PET of TRS80 werkt mogelijk goed. Eenvoudige hardware met tekst op het scherm, zodat ze kunnen worden geëmuleerd met gewone tekst, maar in eerste instantie code voor hun oneven tekensets later toevoegen en waarschijnlijk niet veel exacte cyclustellingscode bevatten.

Bonusidee daarna als je ga voor een PET, het toevoegen van C64-ondersteuning zou graphics opleveren.

De 6502 is waarschijnlijk eenvoudiger te emuleren.

De laatste gedachte zou de Ohio Scientific Superboard II kunnen zijn of in zijn Britse incarnatie de UK101 aangezien ik niet denk dat het herprogrammeerbare videohardware heeft.

Reacties

• Ja, alle drie (PET, TRS, Superboard (ik was het helemaal vergeten over de latere)) zijn geweldige eenvoudige machines en geweldig voor emulaties. Maar mist ook een goede selectie aan kant-en-klare spellen. Om nog maar te zwijgen van kleur en dergelijke die mensen vandaag kunnen verwachten.

De Digital PDP-8 is een zeer eenvoudige architectuur waarvoor gemakkelijk een emulator kan worden geschreven. Enkele redenen hiervoor zijn:

• Slechts 8 basisinstructies
• Geen video-interface etc. om te emuleren, alleen terminal I / O
• Geen behoefte aan cyclusnauwkeurigheid, de feitelijke reeks machines zelf garandeerde niet hetzelfde gedrag voor de verschillende implementaties
• Kan beginnen met een eenvoudige installatie (bijv. een 4Kword-machine met FOCAL-69), en geleidelijk de emulator meer complex (bijv. een 32Kword-machine met uitgebreide rekenkunde, OS / 8 draaiend vanaf een RK05-schijf)
• Veel handleidingen online beschikbaar
• De MAINDEC-diagnostiek en hun instructies zijn online beschikbaar, die worden gebruikt om te testen of de emulatie correct werkt

Dit dekt misschien niet al uw vereisten, bijv. geheugen-toegewezen I / O, maar het omvat zeker zaken als instructiedecodering en adresseringsmodi. van de documentatie gaat helemaal naar het basis hardwareniveau dat geschikt zou kunnen zijn voor een EE-cursus.

Opmerkingen

• Een interessant punt is dat de meeste van de hierboven genoemde systemen ofwel Z80 of 6502 CPUs hebben, die beide enigszins ontbreken in termen van ondersteunde adresseringsmodi. Als dekking van adresseringsmodi belangrijk is, heeft de PDP-8 een veel betere selectie ervan om te demonstreren.
• Voor het ” spel ” aspect van de vraag, ik geloof dat Adventure nog steeds wordt onderhouden / herrezen voor PDP-architecturen (maar controleer dat – ik heb het misschien mis).
• @TobySpeight You ‘ klopt, het wordt behouden of herrezen, maar voor de PDP-10 , die totaal niet compatibel is met de PDP-8.

De ZX Spectrum-optie is al verteld: de kracht ervan is de volkomen simplistische IO-hardware en het feit dat veel bestaande games GEEN nauwkeurige, cyclische -correcte emulatie van alle eigenaardigheden met de enige uitzondering van geluid (niets dat in de buurt komt van correct geluid zonder cyclus-exacte emulatie van de CPU en correcte downsampling van de tussenliggende 1-bit geluidsstroom geproduceerd door de CPU).

Elke andere optie van gaminghardware zoals NES, G enesis en alle soortgelijke op sprite gebaseerde machines is natuurlijk geen optie, aangezien er veel tijd nodig is om de complexe hardware te leren, manieren te ontwikkelen om deze te emuleren, tekortkomingen in de emulatie te omzeilen, enz. Bijvoorbeeld, zelfs simpele Super Mario spel op NES zal niet werken tenzij de sprite botsingsbit in PPU correct is geëmuleerd.

De resterende IMHO-opties zijn de volgende:

1. IBM-pc op basis van vroege tekstmodus
2. een van de bestaande CP / M-machines
3. (exclusief “grote” machines vóór het “micro” -tijdperk)

Het belangrijkste punt hier is een tekstmodusweergave, die niet zo moeilijk te emuleren is en veel eenvoudiger te tonen op de hostcomputer (zelfs geen noodzaak om grafische afbeeldingen weer te geven, werk met venstersysteem / SDL / enz.!).

Er is echter nog wat onderzoek nodig om de juiste programmas te verzamelen om mee te werken, inclusief games. Er zijn enkele tekstmodus-spellen in CP / M, en dat zouden er ook enkele moeten zijn voor IBM PC.

Opmerkingen

• Met een potentieel voordeel van een CP / M-machine is dat er ‘ s ongetwijfeld ten minste één zal zijn waarvoor slechts 8080-emulatie voldoende is?
• Leuk, maar ja, er zijn niet veel games voor de IBM in tekstmodus, toch?
• @Raffzahn – er hoeft er maar één te zijn .
• @Jules Hehehe … ja goed. Maar dan zou ik ‘ zeggen dat een minimum van 8080 voldoende is.

Stel dat het een bijdrage is, dan zijn dit mijn directe aantekeningen over de machines waarvoor ik emulators heb geschreven, in chronologische volgorde van lancering, hopelijk om wat kleur te bieden aan bestandsindelingen, enz.:

Atari 2600

Het onderscheidende kenmerk van de Atari 2600 is de synergie tussen processor en grafische uitvoer; games hebben een real-time functie geïmplementeerd die grafische componenten levert aan de video-uitvoer terwijl het raster wordt uitgevoerd. Dus ik denk dat dit een slechte keuze is voor het aangegeven doel – het echte harde werk van het schrijven van een 2600-emulator is de timing en het samenspel buiten de microprocessor.

Apple II

Relatief eenvoudige hardware, maar zeer genuanceerd, met meerdere grafische modi, en je moet naar het leren van NTSC-video gaan om decodeer de kleurenuitvoer. Het emuleren van de Disk II is ook een must, maar dat is een beetje een zoektocht op zich, aangezien de meest voorkomende bestandsindelingen verwachten dat je een Apple GCR-encoder levert.

ZX80 / 81

Waarschijnlijk ook overdreven gecompliceerd voor het genoemde doel, is de centrale verwaandheid het hergebruiken van de verversingscyclus van de CPU en een subset van instructie-ophaalacties om video te scannen. Als je ervoor kiest om dat mechanisme niet opnieuw te implementeren zoals het origineel, “zou je eindigen met alleen de ROM-standaard tekstmodus.

Commodore Vic-20

Dit is een gewone bitmap-machine met een eenvoudige processor in de 6502 en een behoorlijke hoeveelheid games, waarvan sommige op cartridge werden geleverd, waardoor je niet meer een tape- of diskdrive hoeft te emuleren. De enige vlieg in de zalf is de 6522s; dit zijn combinatie timer / shifter / input / output-chips met een hele reeks eigenaardigheden. Maar een mooi voordeel van de Vic-20 is dat hij tot aan de BASIC-prompt opstart zonder 6522s te laten werken, en BASIC zelf zal werken met alleen de timers van de geïmplementeerde 6522 , zelfs onnauwkeurig.

Zijn korte tijd als marktleider vóór de komst van de C64 beperkt ook het aantal titels dat geavanceerd gebruik maakt van de hardware – er zijn gelijktijdige voorbeelden van rasterracen zoals de Imagic-titels , maar ze zijn in de minderheid.

De bestandsindelingen waarin de gegevens worden bewaard, zijn een puinhoop , maar jezelf beperken tot cartridge-ondersteuning en voorzichtig zijn om alleen die titels te gebruiken die op cartridge zijn geleverd, zou dat probleem moeten voorkomen.

ZX Spectrum

Elders behandeld; Ik denk dat het een goede keuze is. Vooral als je je aan de snapshot-bestandsformaten houdt.

Oric 1 / Atmos

Elders behandeld; een goede keuze, maar er zit nog een van die vervelende 6522s in. De meeste spellen zijn beschikbaar op tape, je zult dat allemaal moeten ondersteunen.

Acorn Electron

Bitmapped, een 6502 plus relatief eenvoudige externe logica, maar zes verschillende grafische modi en timing zou een gedoe zijn – de kosten van elke cyclus zijn een functie van het gebied waartoe toegang wordt verkregen (ROM versus RAM), de grafische modus (40 kolommen versus 80 kolommen modi) en mogelijk de huidige grafische uitvoerstatus (modi met 80 kolommen blokkeren RAM-toegang tijdens het pixelgebied; modi met 40 kolommen niet). Maar je kunt het voor de meeste games gewoon modelleren als een 1Mhz-machine, en meestal wegkomen met een lijncentrische versie van grafische uitvoer.

Er is een klein aantal spellen beschikbaar op ROM, maar gelukkig zal de tape-hardware meestal een emulatie van zeer lage kwaliteit toestaan: het is van de soort die een onderbreken bij byte-ontvangst, met slechts twee titels die ik kan bedenken om diepere introspectie te doen dan dat.

Amstrad CPC

Waarschijnlijk een om te vermijden voor het aangegeven doel – het heeft een 6845 CRTC, wat zorgt voor zeer configureerbare grafische uitvoer en daarom veel titels die tegen het raster racen. Schijfgebruik was ook vrij wijdverbreid, maar de 8272 schijfcontroller is een heel extra niveau van kopzorgen vergeleken met de WD1770 die je vaak elders zult zien.

MSX en / of ColecoVision / SG1000

Verschillende geluidschips, dezelfde CPU en video.Ik denk eigenlijk dat je behoorlijk ver kunt komen door het samenspel van timing te negeren, omdat de videochip zijn eigen RAM op armlengte houdt. Maar het zijn tegels en sprites en vier verschillende grafische modi, wat waarschijnlijk een te grote onderneming is voor een cursus microprocessing.

Master System

Technisch gezien een verbeterde SG1000, zijnde alles wat de machine doet plus een extra grafische modus, maar de extra grafische modus is zo veel beter dan de andere dat slechts één titel iets gebruikt anders. Dus het vereenvoudigt de zaken eigenlijk enigszins als je tevreden bent met het negeren van de timing.

Maar je hebt het nog steeds over het in rekening brengen van sprite-prioriteiten, controleren op botsingen per pixel, enz. Waarschijnlijk te veel .

Voetnoot: valsspelen met tape-toegang

Voor een aantal van de hierboven genoemde thuiscomputers kun je tape-emulatie eigenlijk overslaan voor alles dat is gecodeerd in het standaard ROM-formaat door gewoon een geschikte trap in het systeem-ROM en spooling in vanuit het bronbestand. Veel, maar niet alle, titels zijn volledig afhankelijk van het ingebouwde ROM voor tape-IO, zodat veel titels kunnen worden geladen zonder echte hardwarepogingen.

In elk geval is het een bodge-job hack, maar het zal doen als die kant van emulatie niet belangrijk voor je is – je verwijdert het liever gewoon uit de vergelijking en negeert wat niet werkt.

Specifiek:

Vic-20:

• als de programmateller op 0xf7b2 komt, kopieer dan de volgende tape-header naar de locatie aangegeven door b3: b2, zero out 0x90 en 0x93, en ga verder vanaf 0xf7b5 (aangezien je een JSR vermijdt);
• trap 0xf90b, controleer op X = 0xe, zo ja, dan haal de volgende bandgegevensbody op en schrijf naar het geëmuleerde geheugen van c2: c1 maar niet verder dan af: ae ongeacht de grootte van de body, stel bit 6 in op 0x90, wis de carry- en interruptvlaggen en ga verder vanaf 0xfccf. / li>

Oric:

Voor ROM 1.0, val de pc op op adres 0xe630. Voor 1.1, let op adres 0xe6c9.

Als je dat hebt opgevangen, laad je A met de volgende byte van de tape en stel je de nulvlag in op basis van zijn waarde.

Dan RTS.

Er is ook een vlag op 0x67 op de originele ROM, of 0x24d die onderscheid maakt tussen de snelle en langzame tape-coderingen van de machine, maar het gebruikelijke tape-bestandsformaat heeft alleen de gedecodeerde bytes, dus voor een snelle en vuile emulatie maak je er geen zorgen over.

Electron:

Installeren NOPs op 0xf4e5, 0xf6de, 0xf6fa en 0xfa51 om de tape-vertakkingen uit te schakelen. Het besturingssysteem zal nu proberen tapedata te laden alsof het op een serieel ROM staat.

Cat de pc op 0xf0a8 en controleer of de X register is gelijk aan 14 en de waarde op adres 0x247 is nul. Dan weet je dat de ROM probeert de volgende byte van tape op te halen.

Zet de volgende byte in Y, zet A op 0 en RTS.

Met het primaire tape-bestandsformaat kunt u meestal bytes rechtstreeks uit het bestand spoolen (na wat triviale stukjes navi gation, en via ZLib of een andere GZ-decompressor, hoewel je van tevoren gewoon kunt gunzippen).

ZX Spectrum:

(Deze is getranscribeerd van zeer oude notities; het zou de moeite waard kunnen zijn om te bevestigen tegen een ROM-demontage)

Trap de pc die 0x056c bereikt in de 48kb ROM. Pak het volgende blok van tape (als je een TAP-bestand gebruikt, krijg je het direct; ik zou zeggen dat je niet de moeite moet nemen om TZX te ondersteunen in dit soort projecten).

Als de lengte is kleiner dan de waarde in DE, reset carry en return.

Vergelijk de eerste byte van het blok met de waarde B. Als ze niet overeenkomen, reset dan carry en return.

Anders spool je de eerste DE-bytes die je hebt gekregen naar het adres waarnaar wordt verwezen door IX en stel je de lage bit van C in en stel je carry in.

Voer dan direct een RET uit of sla de pc gewoon over voor 0x05e2, wat de RET is die normaal gesproken het laden van de tape beëindigt.

De 128kb-machines gaan over in de 48kb ROM voor het laden van de tape, dus dezelfde hack is van toepassing op voorwaarde dat wordt gecontroleerd wat er wordt opgeroepen.

Reacties

• Goed geschreven. Ik ben het eens met alles wat gezegd is – misschien met twee kleine add-ons voor de Apple II. Hoewel het waar is dat de videohardware behoorlijk wat aandacht vereist, zijn finesse kan volledig worden genegeerd in emulatie, zoals alleen de gelijkwaardigheid van bepaalde bitpatronen moeten in kleur worden vertaald – of helemaal niet, omdat A2 vaak wordt uitgevoerd met een monochroom scherm, waarmee het kan worden geëmuleerd als gewone bitmap zonder verdere details. Ten tweede, zolang de te spelen Gemes ProDOS-gebaseerd zijn, is er geen gedetailleerde Disk II-emulatie nodig, omdat deze werkt met veel verschillende hardware.
• @Raffzahn wat zou de eenvoudigste vorm van een opzoektabel zijn voor kleur output zijn?Terugkomend vanuit NTSC, en alles beschrijvend als ontleedbaar tot dubbele hoge resolutie, kan ik me een tabel voorstellen die wordt geïndexeerd door een drie-bits teller die de fase vertegenwoordigt plus een vijf-bits schuifregister van video-uitvoer om een halve kleurencyclus met een middelpunt te krijgen. Dus een tafel met 256 ingangen. Maar dat ‘ is een erg naïeve redenering; hebben mensen het beter gedaan?
• @Tommy: een eenvoudige benadering is om gewoon een herhalende reeks van vier kleuren te gebruiken (denk ik (rood, donkergeel, groen, blauw) voor pixels met dubbele hoge resolutie en vervaging het scherm een beetje. Dat zal uiteindelijk kleurverschillen achterlaten, maar echte monitoren deden dat hoe dan ook. Aangezien de Apple]

  Answer

  Ik heb twee en een beetje vanaf nul emulaties gedaan voor de Mac met Swift. Dit zijn mijn persoonlijke observaties gebaseerd op mijn ervaring.

  Geen van mijn emulaties is volledig cyclusnauwkeurig, wat tot een paar problemen leidt.

  Commodore PET

  Dit was de eerste emulatie die ik schreef. Je hebt minimaal een 6502-emulatie, een PIA-emulatie, een VIA-emulatie en een video-emulatie nodig.

  De 6502 is heel eenvoudig en een uitstekende processor om mee te beginnen. Het is ook redelijk goed gedocumenteerd. De Visual6502-site was van onschatbare waarde voor het uitwerken van het exacte gedrag van instructies waar de documentatie dubbelzinnig was. Even terzijde, ik schreef een emulatie van een iets latere processor (ik ben vergeten welke) die enkele van de hiaten in de instructieset. Dit maakte het schrijven van 6502-testcode een stuk eenvoudiger (zelfs PHX en PHY maken sommige dingen eenvoudiger. Op aan de andere kant zal alle software die de “ongedocumenteerde instructies” van de originele 6502 gebruikte, breken op mijn emulatie.

  De PIA en VIA zijn relatief eenvoudige IO-chips om te emuleren. Het videostuurprogramma kan zo simpel zijn als het scherm-RAM lezen, vertalen naar ASCII of een goede benadering en de resulterende tekst in een venster tekenen. Uiteindelijk heb ik een set bitmaps gemaakt die nauwkeurige kopieën waren van de PET-tekenset.

  Mijn belangrijkste bron voor de PET was “Programming the PET / CBM” door Raeto West. Ik heb een origineel exemplaar, maar er zijn PDF ver sions online. Belangrijk is ook de beschikbaarheid van BASIC en KERNAL ROMS.Je wilt het besturingssysteem niet herschrijven.

  Het emuleren van de tapedrive was een PITA. Mijn softwareversie was minder betrouwbaar dan de echte, waarvan PET-eigenaren weten dat het echt iets zegt. probleem, dacht ik, is dat het afhankelijk is van cyclus-nauwkeurige timingpulsen en, hoewel mijn emulator klokpulsen telt, hoefde hij de timer-interrupt niet per se op precies het juiste moment aan te roepen.

  Ik had meer succes met schrijven een emulatie van de dubbele schijfstations. Dit vereiste ook een robuuste IEEE 488-emulatie, maar de emulatie van de diskdrive was vrij eenvoudig. Het is geen hardware-emulatie, het neemt alleen de opdrachten die door de PET zijn verzonden en voert ze uit met platte bestanden op de harde schijf van de Mac.

  Uiteindelijk schreef ik wat code die de emulator, injecteert u direct een programmabestand in het geheugen en start u de emulator opnieuw. Dit bleek zoveel handiger te zijn dan het emuleren van schijven of tapes dat ik ermee stopte.

  Mijn emulator werkt goed genoeg met de meeste PET-code. Helaas is er een probleem met PET Space Invaders – waarschijnlijk veroorzaakt door de toetsenbordcode – zodat het toetsaanslagen niet goed herkent. Ik heb ook niet geprobeerd om het genereren van geluid aan te pakken.

  Sinclair ZX Spectrum

  In sommige opzichten is dit zelfs gemakkelijker dan de PET. U moet een Z80-emulator schrijven die complexer is dan de 6502, maar er is een CPM-testsuite die u kunt gebruiken om veel van zijn functionaliteit te verifiëren. U hoeft alleen de CPM-subroutine voor tekenuitvoer te emuleren om het werkbaar te maken. / p>

  De enige andere chips die je nodig hebt om te emuleren, zijn de ULA en je hoeft daar niet veel van te doen als je bereid bent af te zien van een tapedrive. Ook de videogenerator, wat een beetje raar is in de manier waarop het het scherm-RAM adresseert.

  Het leuke van de Spectrum is dat het scherm altijd in bitmap-modus is en het besturingssysteem tekens creëert door rechtstreeks het schrijven van de schrijfpixelpatronen. U hoeft zich geen zorgen te maken over een karakterset, want deze is er magisch als u de emulator opstart met de Spectrum ROMs geladen.

  Ik heb de Spectrum zover gekregen dat ik Manic Miner kon laden en uitvoeren en het was afspeelbaar, zij het zonder geluid. Het kostte ongeveer drie maanden werken, misschien wel acht uur per week, van begin tot eind.

  Commodore 64

  Dit is een work in progress. Het is duidelijk dat ik al een 6502 had, die ik heb aangepast om me de IO-poort van de 6510 te geven. Tot nu toe doet het de bank correct schakelen, is een deel van de CIA-functionaliteit geïmplementeerd en wordt er voldoende VIC II-functionaliteit geëmuleerd om me een PET-equivalent te geven, dwz dat de normale tekstmodus werkt. Ook het geheugen voor rand- en tekenkleuren werkt.

  Ik heb de meer gecompliceerde grafische modi om te emuleren en sprites en ik zou iets met het geluid moeten kunnen doen, want dat is een aparte chip, ik ben niet afhankelijk van nauwkeurige CPU-timing.

  TL; DR

  De eenvoudigste emulatie, afgezien van de CPU, was het spectrum. Ik zou daar waarschijnlijk mee beginnen, hoewel een oude op CP / M 8080 gebaseerde computer misschien nog gemakkelijker zou zijn als je CP / M te pakken kunt krijgen.

  Verdere observaties

  Waarschijnlijk heb je een goede cross-assembler nodig voor je doelplatform. Het wordt erg saaie handmatige assemblagecode voor unit-tests.

  Ook zal een disassembler handig zijn. Ik hoefde de Commodore BASIC ROMs niet te demonteren omdat demontage gratis beschikbaar is op internet. Maar toen ik probeerde Space Invaders aan het werk te krijgen, werkte het in eerste instantie niet en de demontage was van onschatbare waarde voor het oplossen van problemen.

  Om deze reden maakt cc65 suite een sterk pleidooi om te beginnen met een op 6502 gebaseerde machine. Er zit een goede assembler en een uitstekende demontage bij. De situatie van de Z80 was niet zo goed, maar ik vond uiteindelijk wel een redelijke assembler genaamd z80asm. Ik denk dat ik het echter vanaf de bron moest compileren.

  Ook heb je goede, solide documentatie nodig. Ook hier is de documentatie van de 6502 online vrijwel ongeëvenaard. Documenten zijn minder beschikbaar voor de Spectrum, maar het is zo eenvoudig, je kunt wegkomen met een nogal slordige ULA-emulatie.

  Answer

  Samen met alle andere goede suggesties, zoals een alternatief voor Z-80 en CP / M, zou u een generiek Motorola 6809 -systeem kunnen overwegen om FLEX of mogelijk OS-9 , beide Unix-geïnspireerd. Als een op CLI gebaseerd systeem is het niet nodig om de timing nauwkeurig te krijgen.

  Als je de simulator aan het bouwen bent, lijkt het ook op het bouwen van de hardware; het porten van het besturingssysteem was een echte taak – die ik in de jaren tachtig deed – in tegenstelling tot een taak voor het klonen van iets voor het onderwijs.”Start het het besturingssysteem op en voert het de programmas uit?” is een zeer realistisch doelwit.

  Omdat het een draagbaar besturingssysteem draait dat op hardware van veel verschillende fabrikanten draaide, betekent dit dat de studenten niet slechts één manier hebben om het te doen. Student A zou kunnen bouwen een bitmapweergave; leerling B kan een UART maken en een seriële interface hebben. Sommigen proberen misschien elke cyclus goed te krijgen; sommigen proberen misschien gewoon elke bewerking correct te krijgen. Daarom in plaats van gewoon iets te kopiëren zonder noodzakelijkerwijs het origineel te begrijpen ontwerpbeperkingen, de studenten zijn bezig met een goede technische vraag: wat is een goede manier om dit te doen?

  CPU

  • De 6809 was destijds uniek omdat het mogelijk was om volledig positieonafhankelijke code te schrijven, die overal identiek zou werken in het geheugen.
  • De instructieset was bijna volledig orthogonaal
  • Als een 8-bits CPU met 16-bits adresbus is het vrij eenvoudig
  • Het uitzonderingsmechanisme en effectief -adresmanipulatie lijkt veel op moderne processors
  • Als Motorola-ontwerp had het IO met geheugen toegewezen in plaats van speciale IO-instructies
  • Makkelijker te doen dan Z-80 (veel minder instructies ) of 6502 (minder speciale gevallen)
  • Materiaal via https://en.wikipedia.org/wiki/Motorola_6809

  FLEX is ontworpen als een Unix-geïnspireerd systeem voor 8-bit CPUs

  • Het was specifiek ontworpen voor draagbaarheid, en om het op te starten waren er maar heel weinig systeemaanroepen nodig om te worden geïmplementeerd – ik denk dat alleen het lezen / schrijven van tekens, het lezen / schrijven van floppyblokken en een soort opstartprocedure
  • Hardware-agnostisch voor deze basisfuncties, wat simulatie veel gemakkelijker maakt
  • Het is opwindend om slechts een paar functies te schrijven en een heel besturingssysteem op te starten
  • Geen afbeeldingen om je zorgen over te maken (wat positief of negatief is, afhankelijk van je mening)
  • Veel beschikbaar materiaal, f ind via https://en.wikipedia.org/wiki/FLEX_(operating_system)

  OS-9 vergelijkbaar in opzet

  • Meer Unix-achtig dan FLEX, iets moeilijker te porten, voor zover ik me herinner
  • Later geport naar 68000
  • Veel beschikbaar materiaal, vind via https://en.wikipedia.org/wiki/OS-9