Turbo Toolbox/Turbo_Toolbox.iso/emulator/zx80/z80.doc

Text File | 1992-07-26 | 157.3 KB | 3,150 lines

Sinclair ZX Spectrum Emulator V1.41 - 27/7/92  -  door G.A. Lunter



INHOUD:

        1.    INLEIDING
        1.1   Inleiding
        1.2   Over de emulator
        1.3   Over de documentatie
        1.4   Sourcecode, extra utilities en registratie
        1.5   Puntjes op de i
        1.6   Bedankt!

        2.    KENMERKEN VAN DE SPECTRUM
        2.1   Het toetsenbord
        2.2   Spectrum en joysticks
        2.3   De SamRam en het Sam Operating System
        2.4   Basic uitbreiding van de SamRam
        2.5   De kraaksoftware van de SamRam
        2.6   De ingebouwde schermeditor
        2.7   De ingebouwde Z80 disassembler

        3.    DE EMULATOR
        3.1   Overzicht
        3.2   Command line syntax
        3.3   Hoe goed is de Emulator?
        3.4   Scherm emulatie
        3.5   Geluid emulatie
        3.6   Toetsenbord emulatie
        3.7   Het hoofdmenu van de Emulator
        3.8   De Tape interface en Real Mode
        3.9   Overzetten van Spectrum programma's
        3.10  Overzetten vanaf Spectrum floppy's
        3.11  Welke programma's zijn te gebruiken op de Emulator?
        3.12  De utility Convert
        3.13  De utility ConvZ80
        3.14  De utility DISCiPLE
        3.15  Een digitale joystick voor de PC

        4.    TECHNISCHE INFORMATIE
        4.1   Overzicht hardware kenmerken standaard Spectrum
        4.2   Overzicht hardware kenmerken Interface 1
        4.3   Overzicht hardware kenmerken SamRam
        4.4   Interne opbouw van de Emulator
        4.5   De werking van de Emulator
        4.6   Onofficiële en extra instructies
        4.7   Beveiligingsmethoden op de Spectrum
        4.8   Tips en truuks
        4.9   Struktuur van een .Z80 programmabestand
        4.10  De sourcecode van de Spectrum Emulator




1. INLEIDING


1.1 Inleiding

           Sinds Alan Turing dit in de 50er jaren bewees weten we,
        dat elke computer in essentie precies even krachtig is. Van
        de ZX-80 tot de Cray, van een programmeerbare rekenmachine
        tot de duurste '486, in feite kunnen ze precies hetzelfde.
        De een is alleen wat sneller dan de ander, heeft meer of
        minder geheugen, andere input/output apparaten, maar het
        zijn manifestaties van een en dezelfde abstractie: de
        Computer.

           Wat dit betekent is, dat je (in principe) een programma
        dat op computer A draait, zo op computer B kunt zetten.
        Natuurlijk is er wel een vertaalslag nodig, maar elke
        elementaire instructie van computer A is te beschrijven in
        de elementaire instructies van computer B. Programma's die
        deze vertaalslag uitvoeren worden emulatoren genoemd.
        Emulatoren zijn interpreters van niet-eigen machinecode, net
        zoals GWBASIC een interpreter is van de code die BASIC heet,
        die niet zonder meer herkend wordt door de 8088 processor.

           Emuleren is overigens wat anders dan simuleren, hoewel
        het verschil subtiel is. Simuleren is de werkelijkheid
        nabootsen, maar deze nabootsing is echt iets anders dan
        de werkelijkheid. Een voorbeeld is het model dat het KNMI
        gebruikt voor het weer. Een storm kan door dit model worden
        gerepresenteerd en gesimuleerd, maar dat maakt de
        gesimuleerde storm nog geen werkelijkheid: het zal in de
        computer waarop het model loopt nergens hard waaien. Simuleren
        is ook vaak niet perfect: de gesimuleerde storm gaat na verloop
        van tijd afwijken van wat er in de werkelijkheid gebeurd.

           Emuleren is een nieuwe werkelijkheid creëren. Vanuit het
        oogpunt van het programma, dat oorspronkelijk geschreven was
        voor computer A, maakt het absoluut niet uit of dit
        programma echt loopt op computer A, of dat het loopt op de
        emulator, die loopt op computer B. Het programma 'ziet' zelf
        geen enkel verschil. Een buitenstaander ziet ook geen
        verschil: bij gelijke inputs produceert het programma op
        computer A dezelfde output als het programma + de emulator
        op computer B. Er is dus geen enkel functioneel verschil
        tussen computer A en B. Als je de emulator opstart op
        computer B dan LIJKT computer B niet alleen op A, dan IS
        computer B computer A geworden!

           (Je kunt theoretisch nog volhouden dat nergens 'in'
        computer B de computer A 'gematerialiseerd' is, 'werkelijkheid'
        is geworden. Computer B reageert wel hetzelfde, maar is toch
        van een afstand bekeken duidelijk anders dan computer A.
        De functionaliteit is dan wel aanwezig, maar de 'geest' van
        computer A is afwezig. Inderdaad, je zou niet verwachten
        dat weldenkende mensen op zo'n manier zouden redeneren.
        Dit soort redeneringen kom je echter vaak tegen, in een
        andere (maar niet fundamenteel andere) context, namelijk het
        zogenaamde lichaam-geest probleem. Maar we dwalen af!)

           In de praktijk zijn de zaken natuurlijk minder zwart-wit.
        Computer B moet veel sneller zijn dan computer A, anders
        worden programma's te traag om praktisch bruikbaar te zijn.
        Computer B moet ook meer geheugen hebben dan computer A:
        heel het geheugen van computer A (zowel Rom als Ram als
        eventueel geheugen verstopt in de randapparatuur) moet erin
        passen, samen met de emulator. Verder moet, als het even kan,
        computer B meer input en output mogelijkheden hebben dan
        computer A. De beeldschermresolutie van A moet bijvoorbeeld
        kleiner zijn dan die van B. Als aan deze voorwaarden is
        voldaan, kun je computer A niet alleen theoretisch maar ook
        praktisch heel goed emuleren op B.

           Het koppel Sinclair ZX Spectrum 48K / IBM PC voldoet aan
        deze praktische voorwaarden. Een PC is veel sneller dan een
        ZX Spectrum, heeft veel meer geheugen tot zijn beschikking,
        heeft dezelfde geluidsmogelijkheden en heeft veel meer
        grafische mogelijkheden. Vandaar dat ik op het idee kwam een
        Spectrum Emulator voor de PC te schrijven.


1.2 Over de emulator

           Deze Spectrum Emulator emuleert de gewone ZX Spectrum,
        met de Interface 1. Alles wordt op het allerlaagste niveau
        geëmuleerd, wat betekend dat er geen veranderingen in de ROM
        nodig waren, en dat alle programma's zonder problemen op de
        Emulator draaien. Alle ins en out, alle timing-rariteiten,
        alle Z80 instructies, zowel gewone als onofficiële, het
        beeldscherm, het geluid, het toetsenbord, de RS232 (COM)
        interface, en niet te vergeten de tape interface: alles is
        aanwezig.

           Deze emulator is natuurlijk om te beginnen leuk speelgoed
        voor ZX Spectrum fanaten die nu een PC hebben. Maar de
        emulator is ook erg leuk voor alle andere mensen die een
        redelijk snelle PC of AT hebben. Je krijgt dan toegang tot
        de enorm uitgebreide verzameling van ZX Spectrum spellen,
        waarvan er letterlijk duizenden en nog eens duizenden zijn
        gemaakt. Vele van deze spellen zijn kwalitatief heel erg
        goed, en kunnen ook tegenwoordig nog de vergelijking met het
        gemiddelde PC-spel gemakkelijk doorstaan.


1.3 Over de documentatie

           En dan nu de eigenlijke documentatie. Deze bestaat uit
        drie delen. Het eerste gedeelte, dat begint met hoofdstuk
        2, behandelt in het kort de Spectrum. Dit gedeelte is
        speciaal bedoeld voor die mensen die (vrijwel) geen
        ervaring met de ZX Spectrum hebben. De Spectrum is een vrij
        eigenzinnige machine; vooral het toetsenbord is nogal
        ongebruikelijk ingedeeld. Als dit toetsenbord wordt geëmu-
        leerd op een afwijkend toetsenbord, zoals bijvoorbeeld dat
        van een PC of AT, is dat dus extra problematisch. In dit
        deel worden ook de uitbreidingen van de SamRam software
        beschreven, zoals de ingebouwde disassembler, de extra
        commando's en de ramdisk.

           Het tweede deel van de documentatie (hoofdstuk 3) gaat
        over de emulator zelf. Het overzetten van programma's van
        de Spectrum naar de PC komt aan bod. Ook de mogelijkheden
        van communicatie tussen de Spectrum en de 'buitenwereld'
        (lees: de PC) worden besproken.

           Het laatste hoofdstuk behandelt de technische details
        van de Emulator, met een uitgebreide beschrijving van vele
        bekende en minder bekende hardware kenmerken van de
        Spectrum, die van belang zijn voor de juiste emulatie van
        vele van de ingewikkelder Spectrum programma's.


1.4 Sourcecode, extra utilities en registratie

           Dit is een shareware-programma. Dit programma mag vrij
        verspreid worden, mits het pakket VOLLEDIG en ONGEWIJZIGD
        wordt gelaten. Niets is zo vervelend een half programma te
        krijgen, of een niet goed werkend programma omdat er
        ondeskundige wijzigingen in zijn aangebracht. Laat dit dus
        achterwege! Het programma wordt verspreid in de vorm van een
        zichzelf uitpakkend archiefbestand. Heeft de het bestand
        dat je kreeg niet de naam SPEC140.ARJ dan heeft iemand er
        aan zitten morrelen!

           De Spectrum Emulator mag een tijdje gratis uitgeprobeerd
        worden, laten we zeggen een maand. Als je na deze periode
        overtuigd bent van de kwaliteit van het programma en het
        programma langer wil gebruiken, moet je je registreren.
        Registratie kost f 25,--, en hiervoor ontvang je de utili-
        ties Convert, ConvZ80, DISCIPLE en Z80dump, en de sourcecode
        van de Spectrum Emulator. Bovendien krijg je de geregistreerde
        versie van Z80.EXE waarmee je Spectrum-programma's direct
        van cassette in kunt laden. Bovendien word je op de hoogte
        gehouden van eventuele nieuwe updates.

           Met Convert kun je allerhande Spectrum-formaten omzetten
        in gangbare PC-formaten, bijvoorbeeld Spectrum schermpjes
        naar .GIF formaat, Spectrum BASIC naar ASCII en omgekeerd,
        enzovoorts. Het programma Z80dump is een kleine utility om
        de header van een .Z80 bestand te bekijken. Met DISCIPLE
        kunnen Spectrum DISCiPLE diskettes worden gelezen, en met
        ConvZ80 tenslotte kunnen de .Z80 bestanden worden omgezet in
        .SP bestanden (gebruikt door VGASPEC, een Spaanse Spectrum
        emulator) en .SNA bestanden (gebruikt door JPP) en omgekeerd.
        Zie de paragrafen 3.12 en 3.13 voor een uitgebreidere
        beschrijving van Convert en ConvZ80.

           Voor bedrijven, winkels, scholen e.d. is registratie ook
        verplicht als men besluit het programma te gaan gebruiken.
        Net als particulieren mag men het programma 1 maand uitpro-
        beren en testen. Registratie kost nu echter f 100,-- per
        kopie. Men ontvangt na registratie ook bovengenoemde extra
        programma's en bestanden, en ontvangt ook de nieuwe updates.
        Bovendien wordt men telefonisch ondersteund bij eventuele
        problemen.

           Verkoop van de shareware-versie van de Spectrum Emulator
        aan derden is nadrukkelijk NIET TOEGESTAAN! Wel is het in
        principe mogelijk geregistreerde versies te verkopen,
        waarbij de koper dan meteen geregistreerd gebruiker wordt.
        Indien men geïnteresseerd is in het verkopen van de Spectrum
        Emulator wordt men verzocht hierover kontakt met de auteur
        op te nemen.

           Registratie vindt plaats door het verschuldigde bedrag
        (25 of 100 gulden) over te maken op:

                giro 5945263
        t.n.v.  G.A. Lunter
                Aweg 11a
                9718 CT  Groningen

        Vermeld duidelijk je adres, en welk floppy-formaat gewenst
        wordt (3,5'' of 5.25''). Je kunt ook een getekende Eurocheque
        of girobetaalkaart opsturen naar bovenstaand adres. Zet dan
        in een begeleidend briefje je volledige adres en het
        gewenste floppy-formaat.


1.5 Puntjes op de i

        1. Uiteraard garandeer ik niet dat de Emulator helemaal goed
           werkt. Eventuele rampen ten gevolge van fouten in de
           Emulator zijn het risico van de gebruiker.
        2. De Spectrum ROM zit in de Emulator ingebouwd. De ROM is
           een auteursrechtelijk beveiligd stuk software. Ik ga er
           van uit dat gebruikers van de Spectrum Emulator in het
           bezit zijn van een Sinclair ZX Spectrum. Zo niet dan mag
           de Spectrum Emulator 'Z80' niet gebruikt worden!!
        3. Sinclair Research blijft te allen tijde copyright-houder
           van de ROM, ook indien men zich registreert voor de Emulator.
        4. De auteur van de Spectrum Emulator blijft eigenaar hiervan
           en van de broncodes en van de machinecode voor de SamRam,
           ook als men zich registreert.


1.6 Bedankt!

           De Spectrum Emulator is het resultaat van een lange tijd
        zeer intensief werken met de ZX Spectrum. Johan Muizelaar en
        ik hebben samen in die tijd de Spectrum heel goed leren kennen.
        Johan heeft tijdens het maken van de Spectrum Emulator veel
        opbouwende kritiek geleverd, en als het programma er
        professioneel en 'af' uitziet is dat helemaal zijn verdienste!

           En dan zijn er nog een heleboel mensen die, ook door te
        reageren nadat de Spectrum Emulator uitkwam, hebben
        meegeholpen aan (deze versie van) de Spectrum Emulator. Zonder
        deze mensen was de Emulator ongetwijfeld een minder groot
        succes geworden.

        Rudy Biesma, voor het debuggen van DISCiPLE.EXE,
        Ronald Gorter en Peter Kelders, voor het vinden van enkele
           bugs,
        Leonard en Johan Monderman, voor het testen van de Spectrum
           Emulator op vele spelletjes,
        Dick Pluim, voor het geheel belangeloos ter beschikking stel-
           len van zijn BBS als Support-BBS voor de Emulator,
        De Spectrum gebruikers groep in Groningen voor de enthousiaste
           reakties, en met name Tonnie Stap die mij de essentiële
           informatie over het DISCiPLE schijfformaat leverde,
        Dhr. T.J.H.M. Trum, voor het mij opmerkzaam maken op een
           storende fout in de documentatie, en een nog veel
           storender fout in het introscherm,
        Martin van der Werff, die de macro's in EMUL.8 subtiel
           aanpaste zodat ze ook in A86 versie 3.20 werkten,
        Ruud Zandbergen voor zijn prima uitgewerkte idee voor een
           digitale joystickinterface voor de PC, die nu ook
           ondersteund wordt door de Emulator,
        en verder alle andere geregistreerde gebruikers voor hun
           vele brieven.





2. KENMERKEN VAN DE SPECTRUM


2.1 Het toetsenbord.

           Om in BASIC te werken op de Spectrum, zul je moeten
        wennen aan het toetsenbord. Dit is sterk afwijkend van de
        meeste toetsenborden. Dit komt door het gebruik van
        Keywords, waar Sir Clive, ver terug in het verleden (in '82
        ergens) zo gek op was. Het werkt inderdaad ook wel snel en
        makkelijk, maar niet voordat je er veel tijd en moeite in
        gestoken hebt om ze te leren. Op een PC of AT toetsenbord
        zijn de keywords helemaal lastig, want ze staan natuurlijk
        niet op de toetsen voorgedrukt.

           De spectrum heeft één toets die op geen enkele andere
        computer voorkomt, namelijk de Symbol Shift. (De rode
        shifttoets op de Spectrum). De CTRL en de ALT toetsen nemen
        op de Emulator de functie van Symbol Shift waar.

           Hieronder staat een lijst met de verschillende keywords,
        plus hoe ze ingetikt moeten worden. Hier staat K voor een
        gewoon keyword (witgedrukt op het originele Spectrum
        toetsenbord). Dit moet in 'K' mode ingetikt worden, dus als
        de cursor een K is. Dit is altijd het geval aan het begin
        van een statement.

           Een E staat voor 'E' mode. Deze mode wordt bereikt door
        de symbol-shift en de gewone shift tegelijk even in te
        drukken. De cursor verandert dan van een K (of een L,C of G)
        in een E. Hierna wordt de lettertoets ingedrukt die erachter
        staat aangegeven.

           Een SE staat ook voor 'E' mode, maar nu moet de
        lettertoets tegelijk met de symbol-shift ingedrukt worden.
        Een S tenslotte staat voor symbol-shift (De letter moet in
        K, L of C mode met ALT of CTRL ingetikt worden)

           Ook de 1 letter karakters staan soms ergens anders dan
        waar ze 'horen' te staan, oftewel waar ze staan op het PC
        toetsenbord. (zie tabel hieronder). Sommige toetsen op het
        PC toetsenbord zijn echter geëmuleerd, zoals de grijze + en
        -, en de karakters , . / < > / ; : ' " _ en =. De karakters
        die overblijven zijn de karakters die op het PC toetsenbord
        met Shift en een cijfertoets bereikbaar zijn. De volgorde op
        het PC toetsenbord is !@#$%^&*() ,op het Spectrum
        toetsenbord is het !@#$%&'()_ .De meeste veranderde tekens
        zijn op een makkelijker manier direct in te tikken; alleen
        de & en de tekens ( en ) zijn 1 plaats naar links
        opgeschoven. De & wordt niet zo vaak gebruikt, maar bij de (
        en de ) moet je even oppassen; dat doe je snel fout. Zie de
        tweede tabel.

        Keyw.    Code | Keyw.    Code | Keyw.    Code | Keyw     Code

        ABS      E g    DIM      K d    LPRINT   E c    RND      E t
        ACS      SE w   DRAW     K w    MERGE    SE t   RUN      K r
        AND      S y    ERASE    SE 7   MOVE     SE 6   SAVE     K s
        ASN      SE q   EXP      E x    NEW      K a    SCREEN$  SE k
        AT       S i    FLASH    SE v   NEXT     K n    SGN      E f
        ATN      SE e   FN       SE 2   NOT      S s    SIN      E q
        ATTR     SE l   FOR      K f    OPEN #   SE 4   SQR      E h
        BEEP     SE z   FORMAT   SE 0   OR       S u    STOP     S a
        BIN      E b    GO SUB   K h    OUT      SE o   STR$     E y
        BORDER   K b    GO TO    K g    OVER     SE n   TAB      E p
        BRIGHT   SE b   IF       K u    PAPER    SE c   TAN      E e
        CAT      SE 9   IN       SE i   PAUSE    K m    THEN     S g
        CHR$     E u    INK      SE x   PEEK     E o    TO       S f
        CIRCLE   SE h   INKEY$   E n    PI       E m    USR      E l
        CLEAR    K x    INPUT    K i    PLOT     K q    VAL      E j
        CLOSE #  SE 5   INT      E r    POINT    SE 8   VAL$     SE j
        CLS      K v    INVERSE  SE m   POKE     K o    VERIFY   SE r
        CODE     E i    LEN      E k    PRINT    K p    <=       S q
        CONTINUE K c    LET      K l    RANDOMIZE K t   >=       S e
        COPY     K z    LIST     K k    READ     E a    <>       S w
        COS      E w    LLIST    E v    REM      K e
        DATA     E d    LN       E z    RESTORE  E s    DEC      SE q
        DEF FN   SE 1   LOAD     K j    RETURN   K y    HEX      SE w


        Karakter   Spectrum kbrd   Op PC keyboard

        &          S 6             ALT (of CTRL) 6
        '          S 7             ALT 7 of '/"
        (          S 8             ALT 8
        )          S 9             ALT 9
        _          S 0             ALT 0 of SHFT _/-
        <          S r             ALT r of SHFT </,
        >          S t             ALT t of SHFT >/,
        ;          S o             ALT o of :/;
        "          S p             ALT p of SHFT "/'
        ^          S h             ALT h
        -          S j             ALT j of _/-
        +          S k             ALT k of SHFT +/= of GREY +
        =          S l             ALT l of +/=
        :          S z             ALT z of SFHT :/;
        ?          S c             ALT c of SHFT ?//
        /          S v             ALT v of ?//
        *          S b             ALT b of GREY PRTSC/*
        ,          S n             ALT n of </,
        .          S m             ALT m of >/.

           Nog een belangrijke opmerking: De Spectrum heeft geen
        aparte Break-toets. Hiervoor gebruikt men Shift-Spatiebalk.
        Een BASIC programma kan dus met Shift-Spatie afgebroken
        worden. Met de combinatie CTRL-BREAK kun je de Emulator
        verlaten.


2.2 Spectrum en joysticks

           Voor de Spectrum zijn in de loop der tijden zeer veel
        programma's geschreven, en ook veel spelletjes. Toen de
        Spectrum net was uitgekomen, waren er geen joysticks
        verkrijgbaar. De oudere spellen werken dus alleen met het
        toetsenbord. Voor de besturing werden vaak de cursor-toetsen
        gebruikt, dwz de toetsen 5 t/m 8. Deze toetsen hadden de
        volgende functies: 5 links, 6 onder, 7 boven, 8 rechts.

           Later kwamen de joystick-interfaces. Sinclair kwam zelf
        met een zeer eenvoudige interface, de Sinclair Joystick.
        Deze gebruikte de toetsen 1 t/m 5, en 6 t/m 0. Een pro-
        gramma dat de Sinclair Joystick ondersteunt, is dus ook
        met het toetsenbord te besturen! De meeste PC-spelletjes
        die van het toetsenbord gebruik maken, gebruiken de
        spatiebalk als vuurtoets. Bij de Spectrum wordt meestal de
        0 toets gebruikt; dit is ook de vuurtoets bij cursor-
        besturing.

           Omdat veel programma's al werkten met de cursortoetsen
        voor de besturing, kwam Protek met een interface die de
        joystick de cursortoetsen liet besturen. Een protek joystick
        optie bij een programma is dus equivalent aan een cursor
        optie. Ook een AGF-joystick werkt met dezelfde cursortoetsen.

           De enige joystick die echt opgang heeft gemaakt en niet
        met het toetsenbord werkte, is de Kempston joystick. Deze
        joystick geeft zijn informatie door via IN-poort 31.

           De geëmuleerde Spectrum joystick wordt bestuurd met de
        pijltjestoetsen op het PC toetsenbord, of met een analoge IBM
        joystick (die op joystickpoort A aangesloten moet worden), of
        met een digitale joystick. Als een digitale joystick wordt
        gebruikt, moet deze op een speciale manier aangesloten worden;
        hoe dit precies moet kun je lezen in paragraaf 3.15.

          Je kunt een cursor-, sinclair- of kempstonjoystick laten
        emuleren; de meeste spelletjes zijn op deze manier te
        besturen met de gewone pijltjestoetsen of een echte joystick.
        Welke joystickstandaard je wilt gebruiken kun je bij het
        opstarten aangeven (standaard is cursor, met -j1, -j2 en -k
        worden respectievelijk Sinclair 1 (toetsen 1-5), Sinclair 2
        (toetsen 6-0) en Kempston ingesteld), maar je kunt de keuze
        ook via het hoofdmenu veranderen: F10, en dan menukeuze
        "Change Settings", of direct via F4.

           Als joystick-vuurtoets kunnen vier toetsen van het
        PC-toetsenbord gebruikt worden. Allereerst 5, 0 en . op het
        cijferblokje. Omdat je vingers elkaar op dat blokje al snel
        in de weg zitten, kun je ook de TAB-toets als vuurtoets
        gebruiken.

           In de BASIC regel-editor van de Spectrum kun je je cursor
        besturen met Shift en de cursor-toetsen. Om het programmeren
        in BASIC makkelijker te maken kan de Emulator dit ook
        automatisch voor je doen: als de joystick-emulatie op Cursor
        staat, en je drukt op NumLock, dan wordt er automatisch op
        Shift gedrukt als je op een pijltjestoets drukt.



2.3 De SamRam en het Sam Operating System

           De SamRam is een hardware uitbreiding die ik heb gemaakt
        voor mijn Spectrum. Het bestaat uit drie delen; een 32K
        statische RAM uitbreiding, geschakeld in het romgebied; een
        electronische schakelaar voor het schakelen van een 32K
        dynamische ram-bank bovenin het geheugen en een Kempston
        joystick interface.

           De Emulator ondersteunt de SamRam. Alles is geëmuleerd.
        Voor een gedetailleerde beschrijving van de SamRam hardware,
        zie hoofdstuk 4. Normaal emuleert de Emulator de standaard
        Spectrum met interface 1. Als je de Emulator echter opstart
        met optie -s wordt ook de SamRam geëmuleerd. Het grote
        voordeel van de SamRam is vooral dat je elk programma kunt
        onderbreken. Op de Emulator is dit voordeel minder
        duidelijk, maar ook dan is de SamRam handig wegens de
        ingebouwde disassembler die je op elk punt tijdens elk
        programma kunt aanroepen. Een belangrijke mogelijkheid van
        de SamRam is dat elk programma naar tape geschreven kan
        worden, in een voor gewone Spectrums leesbaar formaat.
        Zie paragraaf 2.5 voor een uitleg hiervan.

           De SamRam software, het Sam Operating System, bestaat
        grofweg uit twee delen. Ten eerste zijn er een paar
        commando's toegevoegd aan het standaard Spectrum BASIC
        arsenaal. Ten tweede, het belangrijkste, is er de
        kraaksoftware, waarmee programma's gestopt en weggesaved
        kunnen worden. Hierbij zitten ook een kleine scherm-editor
        en een disassembler.

           De kraaksoftware wordt geactiveerd door een NMI,
        geëmuleerd door een druk op F9. Er verschijnt een menu met
        ikonen; de uitleg staat hieronder. Als nogmaals op NMI
        gedrukt wordt, terwijl de kraaksoftware nog aktief is, heeft
        dit een reset van de Spectrum tot gevolg. Een 'geneste'
        aanroep van de kraaksoftware is dus niet mogelijk.


2.4 Basic uitbreiding van de SamRam

           Er zijn vier commando's toegevoegd aan de normale BASIC
        commando's, te weten *RS, *MOVE, *SAVE en *SPECTRUM. Syntax:
        (I0, I1 etc. stelt een integer expressie voor)

           *RS I0,I1,I2,....,In
           *MOVE I0,I1,I2
           *SAVE I0,I1,I2
           *SPECTRUM

           *RS stuurt bytes naar de Interface-1 RS232 poort. Dit is
        vooral gemakkelijk om even snel een printer te
        initialiseren, zonder daarvoor apart een RS232 kanaal te
        hoeven openen met bijvoorbeeld OPEN #3;"b", FORMAT "b",9600.

           *MOVE is een geheugenblok-verplaats routine. I0 is het
        begin van het geheugenblok, I1 is het adres waar het blok
        naartoe moet en I2 is de lengte van het blok. *MOVE gebruikt
        LDIR of LDDR als het blok omlaag resp. omhoog verschoven
        moet worden, om ervoor te zorgen dat overlappende blokken
        niet gaan 'interfereren'.

           *SAVE is hetzelfde als *MOVE, behalve dat tijdens de LDIR
        of de LDDR de shadowrom van de SamRam is ingeschakeld. Ik
        gebruik *SAVE altijd als ik een update van de shadowrom wil
        installeren. Dit lukt echter niet op de Emulator, omdat de
        Emulator een ROM-poke altijd onderschept. *SAVE is wel te
        gebruiken om een kopie van de shadowrom in de RAM te zetten,
        om hem te bekijken met een disassembler. Dit kan
        bijvoorbeeld met het commando *SAVE 0,32768,16384. De SamRam
        shadowrom kan nu bekeken worden vanaf adres #8000.

           *SPECTRUM is een zeer eenvoudig commando; het schakelt de
        SamRam uit en start de standaard spectrum op.

           Buiten deze 4 commando's zijn er ook nog enkele andere
        faciliteiten ingebouwd, te weten een ramdisk van 25K, een
        snelsave/snellaad routine en decimaal/hexadecimaal conversie
        functies. De snellaad routines zijn in de Emulator niet te
        gebruiken, omdat de gebruikte OUT-instructies naar adres 31
        (bankswitch) teveel tijd kosten.

           De ramdisk routines zijn echter prima te gebruiken. De
        syntax is gelijk aan die, gebruikt bij de Spectrum 128. Alle
        cassette statements zijn te gebruiken, zoals LOAD, SAVE,
        MERGE en VERIFY. Na het keyword moet een uitroepteken
        geplaatst worden. Voorbeelden:

        SAVE !"a"               Zet een basic programma in ramdisk
                                onder de naam 'a'
        SAVE !"scherm" SCREEN$  Save een scherm onder de naam
                                'scherm'
        MERGE !"a"              Merge een programma uit de ramdisk
        LOAD !"scherm" CODE     Laad een codeblok uit de ramdisk

           De foutmeldingen bij gebruik van de ramdisk zijn gelijk
        aan die bij gebruik van de tape. "R Tape loading error" zal
        echter nooit optreden. Als een programma niet gevonden
        wordt, verschijnt de errormelding "8 End of file".

           Andere commando's voor gebruik met de ramdisk zijn:

        CAT !                   Geeft een inhoudsopgave van de
                                ramdisk met aantal vrije bytes.
        FORMAT !                Maakt de ramdisk helemaal leeg
        ERASE !"naam"           Verwijdert de file 'naam' uit
                                de ramdisk.

           Nog een paar opmerkingen betreffende de ramdisk:

        - Als een file gevonden wordt, maar het is niet van het
          gevraagde type, dan wordt ook error 8 gegeven
        - CAT ! geeft bij elke file een extensie, gekozen uit de
          volgende vier:
          .COD voor code files en schermen
          .BAS voor basic programma's
          .CHR voor character array's
          .NMB voor number array's
        - Bij ERASE ! mag geen type (CODE, DATA, SCREEN$ of LINE)
          gegeven worden.

           Tenslotte zijn er de hexadecimaal conversie functies, te
        weten DEC en HEX. Deze zitten onder de toetsen q en w (zie
        de tabel hierboven). Als de SamRam ingeschakeld is ben je dus
        de functies ACS en ASN, die normaal onder SE q en SE w zitten,
        kwijt. De functies HEX en DEC kunnen getallen van 0 tot 65535
        aan. Ze worden als volgt gebruikt:

           DEC "hexadecimaal getal"     geeft een getal
           HEX getal                    geeft een string



2.5 De kraaksoftware van de SamRam

           Zoals gezegd wordt de kraaksoftware van de SamRam
        opgestart met een druk op NMI. Een NMI wordt geëmuleerd
        wanneer op F5 gedrukt wordt. Er verschijnt een window met
        ikonen, en een aanwijspijltje. Er zijn 8 ikonen, die hier-
        onder een voor een, van linksboven naar rechtsonder,
        behandeld worden.

           Helemaal linksboven in de hoek staat een pijl met een N
        erin. De N is geschreven in de gewone Spectrum
        karakterset. Met deze optie keer je terug naar de normale
        Spectrum, dus met de standaard Spectrum ROM ingeschakeld.

           Daarnaast staat precies zo'n pijl, maar dan met een E
        erin, geschreven in de SamRam karakterset. Deze optie doet
        precies hetzelfde als N, alleen keer je terug naar de
        extended Spectrum, dus met ingeschakelde SamRom.

           Hier weer naast staat de optie 'disassembler', een loepje
        met 'mc' van machinecode erin. Deze optie wordt hieronder in
        een apart hoofdstuk uitgelegd. De disassembler is ook te
        activeren met een druk op D.

           Helemaal rechts staat de ikoon voor de schermeditor. Zie
        hieronder voor een uitleg hiervan. De schermeditor is ook op
        te roepen met een druk op 1.

           Linksonder staat de optie voor scherm 2. Scherm 1 is het
        scherm, zoals deze op het beeld stond bij de NMI; scherm 2
        wordt bewaard als je uit de kraaksoftware terugkeert, en kan
        een volgende keer opnieuw gebruikt worden. Deze optie is
        gemaakt om makkelijk schermpjes uit programma's te kunnen
        vissen.

           Hiernaast staat de 'print scherm' optie. Deze heb ik voor
        mijzelf gemaakt; het stuurt een kopie van het scherm via de
        RS232 poort naar de printer, in het STAR GEMINI-10X formaat.
        Ik ondersteun lekker geen andere printers. De 'scherm print'
        optie zit onder de P toets. Om een Spectrum schermpje op een
        andere printer dan de STAR GEMINI-10X af te drukken, of om
        een schermpje in een PC-tekenprogramma binnen te halen, kun
        je het volgende doen:

          1-  Leid de RS232 output om naar disk
          2-  Als het huidige scherm bewaard moet worden, terwijl je
              in BASIC zit, is het voldoende SAVE *"b" SCREEN$ te
              typen.
          3-  Anders: Als het scherm dat je wil bewaren zichtbaar is,
              druk op F5 voor NMI, type '2' en daarna '1' (scherm 1
              opslaan). Druk op ALT F6 om de Spectrum te resetten.
              Typ in BASIC:

                 CLEAR 32000
                 OUT 31,11
                 SAVE *"b" CODE 51200,6912

              (De CLEAR is ervoor om de stack naar beneden te halen,
              met de OUT wordt de bovenste RAM-bank omgeschakeld, en
              met het SAVE-statement wordt het schermpje, dat op
              adres 51200 of #c800 is opgeslagen, weggeschreven)
          3'- In plaats van de procedure beschreven bij 3 is het ook
              mogelijk in te tikken:
              PAUSE 0: SAVE *"b" SCREEN$
              (De pause 0 zorgt ervoor dat de Spectrum op een toets
              wacht). Druk daarna op F9, type '2' en daarna '3' (voor
              schermen verwisselen), druk dan op 'E' om terug te gaan
              naar BASIC, en druk op een toets.

           Als het plaatje in een PC programma geladen moet worden is
        er een andere methode, die een .GIF bestand oplevert. Het op
        het moment van wegschrijven van het .Z80 bestand zichtbare
        scherm kan met de utility CONVERT direct omgezet worden. Zie
        paragraaf 3.12 voor meer informatie hierover.

           Naast deze optie zit de optie 'save programma', de belang-
        rijkste optie op mijn gewone Spectrum. Ook voor de Emulator is
        deze optie handig: elk .Z80 bestand kan eenvoudig op tape
        gezet worden. Dit gaat als volgt: laad het programma in als
        .Z80 bestand en druk op een geschikt punt op F5, NMI.
        Eventueel kun je eerder een laadschermpje in de buffer voor
        scherm twee zetten, met de hierboven beschreven methode. Als
        je op 'S' van 'save programma' drukt, krijg je een window te
        zien waarin je drie dingen kan instellen: of het programma
        moet opstarten met SamRam of met de gewone Spectrum ROM, of er
        een laadscherm bijgesaved moet worden en of het programma naar
        tape of microdrive geschreven moet worden. Van deze opties is
        alleen de tweede van belang; de eerste is alleen belangrijk
        voor mijn eigen Spectrum, en de microdrive wordt niet
        ondersteund zodat hier überhaupt niet naar geschreven kan
        worden. Nadat je een filenaam hebt ingetikt wordt het
        programma naar tape geschreven. Dit zou dan weer op een gewone
        Spectrum ingeladen kunnen worden.

           Belangrijke opmerking: de instellingen kunnen worden
        veranderd door op de ikonen te klikken met het pijltje. Het
        aktieve ikoon wordt dan helder, met BRIGHT 1. Op CGA en
        Hercules is dit echter niet zichtbaar!

           Tenslotte zit helemaal rechtsonder de overige opties,
        vijf in totaal, in een menu onder de toetsen A t/m E:

           A: Directory.
        Hiermee krijgt men een inhoudsopgave van de microdrive op
        het scherm. In de huidige versie van geen belang.
           B: Save normaal
           C: Save snel
           D: Keuze opslaan
        Met bovenstaande drie opties is de snelheid van het tape-
        systeem in te stellen, en eventueel op te slaan in de
        battery backed-up CMOS RAM. Standaard staat de SamRam van de
        Emulator ingesteld op normale save-snelheid; de snelle save
        werkt niet wegens het gebruik in de snelle save routine van
        zeer trage OUT-instructies naar poort 31. Deze opties hebben
        dus geen functie in de Emulator.
           E: Basic.
        Met deze optie wordt het lopende programma onderbroken,
        worden enkele belangrijke systeemvariabelen op de juiste
        waarde gezet (Voor de liefhebbers: de stack wordt schoon-
        gemaakt; ERRSP wordt gereset, DFSZ wordt 2, IY wordt op
        23610 en de interrupt mode op 1 gezet.) en wordt naar de
        BASIC ROM gesprongen. Met deze optie kun je de Spectrum
        soms weer tot leven brengen als 'ie gecrasht is.


2.6 De ingebouwde schermeditor.

           Met de ingebouwde schermeditor kunnen schermpjes
        aangepast worden. De editor is speciaal gemaakt om enigszins
        verminkte laadschermpjes weer op te kalefateren. Voor de
        emulator is de editor niet bijzonder handig. Ik zal
        hieronder in het kort de commando's uit de doeken doen.

           In de editor kun je met de cursor in de vorm van een
        plus-teken aanwijzen waar een bepaalde bewerking moet worden
        uitgevoerd. Deze cursor is met de cursortoetsen (5 t/m 8),
        of met de pijltjestoetsen op het PC toetsenbord (die immers
        de cursortoetsen emuleren) te verplaatsen. De volgende
        toetsaanslagen zijn mogelijk:

           H: Haal de kleur op van de plaats waar de cursor nu
        staat, en zet dit in het geheugen. Deze opgeslagen kleur kan
        gebruikt worden bij de volgende opdracht:
           Z: Zet de kleur die in het geheugen staat op het scherm.
           G: Haal ('Get') een karakter van het scherm.
           P: Zet ('Put') een karakter op het scherm.
        Met bovenstaande vier opties kunnen stukken van het scherm
        bijvoorbeeld leeggemaakt worden, of een andere kleur gegeven
        worden.
           R: Verwijder ('remove') alle beeldscherminformatie die
        niet te zien is. Als de Paper en Ink kleur hetzelfde zijn,
        is de beeldscherminformatie niet te zien. Deze optie haalt
        deze onnodige informatie van het scherm.
           L: Bekijk ('look') het scherm, door alle kleurinformatie
        er (tijdelijk!) af te halen. Zo is te zien wat voor een
        onzichtbare informatie op het scherm staat.
           T: Ga terug naar het hoofdmenu. Doet hetzelfde als een
        druk op EDIT (=Shift 1, of ESC in de Emulator).
           B: Verander border-kleur
           V: Wis beeldscherm (Het Basic CLS commando zit op de V
        toets.)

           Als je in de scherm-editor op nul (0) drukt, wordt het
        teken onder de cursor uitvergroot linksboven in beeld gezet,
        en kun je het pixel voor pixel veranderen. De cursor is nu
        weer met de toetsen 5 t/m 8 te verplaatsen. Een druk op nul
        zet een pixel op de plaats als er geen stond, en haalt er
        een weg als er wel een stond. Met Enter of Edit (of ESC) kom
        je weer op het gewone scherm van de editor.

           In deze mode zijn er twee extra commando's: met C wis je
        het blokje; alle pixels gaan uit, en met I inverteer je het
        blokje.


2.7 De ingebouwde Z80 disassembler

           Het belangrijkste in de SamRam software is eigenlijk de
        disassembler, althans, deze gebruik ik het meest. Deze
        disassembler lijkt wat zijn uiterlijk betreft nogal op MONS,
        maar is wat mogelijkheden betreft wat simpeler: je kunt bij-
        voorbeeld niet single-steppen.

           Nadat in het hoofdmenu op D is gedrukt, verschijnt het
        scherm van de disassembler in beeld. Deze bestaat uit drie
        delen. Bovenaan staan de eerste 8 instructies gedisassembelt
        vanaf de geheugenpointer, vanaf hier genoemd MP. Daaronder
        staat de waarde van de stack pointer, kortweg SP, met daar-
        achter de eerste negen adressen op de stack. Daar weer onder
        staat de waarde van de Program Counter of PC (Vergelijkbaar
        met de IP van de 8088/86). Op dit punt is het programma
        gestopt toen op NMI (F5) werd gedrukt.

           Naast de PC staan de drie MP-geheugens. Hierin kunnen tot
        drie pointers worden opgeslagen, die weer snel opgeroepen
        kunnen worden. Vooral handig om even te stoppen met het
        disassemblen van een hoofdroutine, de huidige plaats op te
        slaan, en even een subroutine disassemblen. Als dit gebeurd
        is, kan de draad weer snel opgepikt worden door de oude MP
        terug te vragen.

           Hieronder staan 24 adressen, met de inhoud van de
        adressen, van 11 voor de MP tot 12 na de MP. Onder deze hele
        zaak staat een underscore als cursor te wachten op input.
        Er kunnen nu eenlettercommando's ingegeven worden.

           Als er bytes of adressen als operand gegeven moeten
        worden, gebeurt dit in het default type, dus of decimaal of
        hexadecimaal. Het default type is bij het begin hex, zodat
        alle bytes en adressen op het scherm in hex gegeven worden.
        Met een druk op #, dus op ALT-3 wissel je tussen hex en
        decimaal. Als het default type dec is, verschijnen ook alle
        getallen op het beeld in decimale notatie.

           Met $ en # kun je het default type omzeilen. Dus:

        ffff    =       65535 decimaal, als def.type hex is
        8000    =       32768 dec. als def.type hex is
        8000    =       8000 dec. als def.type dec is
        81de    =       error als def.type dec is
        $8000   =       8000 dec, ongeacht het def.type
        #8000   =       32768 dec, ongeacht het def.type
        #32768  =       error, ongeacht def.type

           Als je een getal in moet voeren, zijn er ook nog de
        volgende drie mogelijkheden. Met een druk op Enter op een
        lege regel wordt de bewerking/actie afgebroken, en een 'm'
        representeert de huidige waarde van de memory pointer.
        Als de regel begint met " (aanhalingstekens), dan is de
        waarde van het getal de ascii waarde van het teken dat
        direct achter het aanhalingsteken staat. Dus: "0
        representeert de waarde #30 ($48); "A de waarde $65.

           Hieronder volgt een korte beschrijving van alle
        commando's van de disassembler:

           Q: Met Q wordt de memory-pointer 1 kleiner; je verschuift
        een adres naar boven.

           A: Met A doe je precies het tegenovergestelde: de
        memory-pointer wordt 1 groter, je verschuift een adres naar
        beneden.

           <ENTER>: Met een druk op de Enter- of Return-toets
        verschuif je 1 instructie naar beneden. Dit heeft dus
        hetzelfde effect als 1 tot 4 keer op A drukken. De 8 regels
        disassembly bovenaan het scherm schuiven 1 regel naar boven;
        de bovenste instructie verdwijnt uit het beeld.

           M: Met M kun je de memory-pointer instellen. Er moet een
        getal ingetikt worden (zie opm. hierboven)

           P: (Put). Hierachter moet een getal ingevoerd worden.
        Dit getal wordt opgeslagen in de eerste van de drie memory
        pointer geheugenplaatsen. Meestal gebruik je 'm' (zie opm.
        hierboven) om de huidige waarde van de memory pointer op
        te slaan. De twee laatst ingevoerde waarden schuiven 1
        plaats naar rechts, en de waarde in het derde geheugen
        verdwijnt.

           G: (Get). Hierachter verwacht de disassembler een cijfer
        van 1 tot 3. Hiermee wordt de waarde van een van de drie
        memory pointer geheugenplaatsen in de actieve memory pointer
        gezet.

           B: (Byte). De disassembler vraagt nu om een byte. Deze
        zal, op de plaats van de memory pointer, in het geheugen
        gepoked worden, en de memory pointer wordt 1 plaats
        doorgeschoven.

           I: (Insert). Deze optie is hetzelfde als optie B, alleen
        blijft de disassembler bytes vragen en achter elkaar in het
        geheugen zetten, totdat een Enter gegeven wordt op een lege
        regel.

           #: Hiermee wordt het default type veranderd: Was het Hex,
        dan is het nu decimaal, en omgekeerd. Alle adressen worden
        nu ook in het default type op het scherm gezet.

           F: (Find). De ingebouwde zoek-optie. Je kunt nu tot
        maximaal tien bytes invoeren, waarna de disassembler vanaf
        de memory-pointer zal zoeken totdat de gevraagde byte of
        rij bytes gevonden wordt. Als de byte of de rij bytes niet
        gevonden wordt, zal het zoeken stoppen op adres 0. De gege-
        vens moeten regel voor regel ingevoerd worden. Is bijvoor-
        beeld een byte ingevoerd, dan moet een enter gegeven
        worden, waarna vervolgd kan worden met het invoeren van
        gegevens. Bij een druk op enter op een lege regel, of als er
        al tien bytes zijn ingevoerd, zal het zoeken beginnen. Er
        zijn vier verschillende typen gegevens bij deze optie.
        Ten eerste kun je gewoon een byte invoeren, hexadecimaal of
        decimaal volgens de normale regels. Als het getal dat je
        invoert groter is dan 255 (#FF), wordt een woord
        verondersteld. Er wordt dan gezocht naar de twee bytes die
        samen het woord vormen, met de lsb voorop, en daarachter de
        msb (most significant byte). Je kunt ook een string karakters
        invoeren. Als de eerste karakter " is, wordt de rest van de
        regel verondersteld een string te zijn, en wordt hiernaar
        gezocht. (Dus niet afsluiten met ". Als je "tekst" intikt,
        wordt naar tekst" gezocht!)
           Tenslotte is er het gegeven 'x'. Dit is een speciaal
        geval; het betekent 'alle gegevens'. Met een of meer x'en
        kun je dus 'gaten' in je zoekstring maken. Dit maakt het
        zoeken een stuk flexibeler.

           Voorbeelden: (voor een komma moet je een enter lezen:)

        "Tekst          Zoekt naar de string: Tekst
        #cd, x, #00     Zoekt naar een Call instructie (#cd) naar
                        een routine in de onderste 256 bytes. (#0000
                        tot #00FF)
        x, #8101        Zoekt naar de rij bytes #01,#81, en als deze
                        gevonden zijn wijst de memory-pointer 1 byte
                        voor dit woord.
        #0081           Zoekt naar de byte #81, NIET naar het woord
                        #0081! (Een woord is pas een woord als het
                        groter dan 255 is)

          N: (Next). Hiermee wordt verder gezocht naar de laatst
        ingevoerde zoekstring.

          $: Hiermee krijg je een pagina disassembly op je scherm.
        In deze mode zijn de volgende toetsaanslagen mogelijk:
          $: Terug naar hoofdscherm disassembler.
          7 of Shift 7 (Cursor omhoog, dus): Ga een bladzijde terug.
        De disassembler onthoudt de adressen van de laatste acht
        pagina's; je kunt dus maximaal acht pagina's terug.
          Q: Een byte terug
          A: Een byte vooruit.
          Z: Maak een hardcopy van het scherm. Deze optie stuurt het
        scherm naar de RS232 poort, in ASCII formaat.
          Elke andere toets heeft tot gevolg dat je een scherm
        verder gaat.

          K: (List). Je komt in dezelfde mode als met '$' het geval
        is. Je krijgt echter geen disassembly, maar een geheugendump
        met ascii-codes op het scherm. Deze optie is vooral
        gemakkelijk voor het snel zoeken naar tekst in een
        programma.

          C: (Clear). Hiermee zijn stukken geheugen te wissen, of te
        vullen met bytes. De disassembler komt met de prompts 'First',
        'Last' en 'With'. Hierachter moeten respectievelijk het
        eerste en laatste adres, en de bytewaarde ingevuld worden
        waarmee de adressen moeten worden opgevuld. Het laatste
        adres is inclusief!

          D: (Dump). Dump een disassembly naar de RS232 poort. De
        disassembler komt met de prompts 'First' en 'Last',
        waarachter het eerste en het laatste adres dat moet worden
        gedisassembled moet worden ingevuld. ('Last' weer
        inclusief). Met deze optie kun je gemakkelijk een disassem-
        bly naar de PC 'porten', door de RS232-output om te leiden
        naar een bestand. (In deze file wordt het einde van de regel,
        op de normale Spectrum manier, aangegeven door CR's. Om dit in
        het voor PC's gebruikelijke formaat met CR/LF's om te zetten
        kun je CONVERT gebruiken.)

          R: (Registers). Deze optie is op twee verschillende
        manieren te gebruiken. Als je achter 'R' op enter drukt,
        krijg je de registers te zien, zoals die waren toen er op
        NMI gedrukt werd. Als je een registernaam intikt, te kiezen
        uit A,B,C,D,E,H,L,A',B',C',D',E',H',L',I,R (de 8 bit
        registers) en AF,BC,DE,HL,AF',BC',DE',HL',IX,IY,SP,PC (de
        16 bit registers en registerparen), kun je de waarde van dat
        register veranderen.

          V: (Verplaats). De disassembler vraagt 'From', 'To' en
        'Length'. Al naar gelang de richting waarin verschoven wordt
        (naar boven of naar beneden in het geheugen), zal een LDIR
        of een LDDR instructie gebruikt worden om het geheugenblok
        te verplaatsen.

          Ten slotte zijn er nog drie instructies die voor gebruik
        op de emulator niet zo belangrijk zijn. Het zijn S (Save), L
        (Load) en H (Header read). Ik laat het aan de lezer over om
        uit te zoeken hoe ze precies werken.





3. DE EMULATOR


3.1 Overzicht

           In deze paragraaf zal ik proberen een kort overzicht van
        het functioneren en het bedienen van de Emulator te geven.
        Meer gedetailleerde informatie staat verderop in het
        hoofdstuk.

           Standaard staat de Emulator zo ingesteld, dat bijna alle
        programma's op de hoogst mogelijke snelheid gedraaid worden.
        Deze snelheid kan, indien gewenst, met tot iets meer dan een
        factor 4 teruggebracht worden. De emulatie van de Spectrum is
        bijna perfect, maar er zijn enkele aspecten die onder controle
        van de gebruiker staan en die de emulatie nog beter maken, ten
        koste van de snelheid. Dit zijn de R-register emulatie en de
        LDIR-emulatie, beide belangrijk bij (erg goed) beveiligde
        programma's.

           De instellingen kunnen gewijzigd worden in het hoofdmenu,
        dat tevoorschijn komt met een druk op F10. De meeste
        functietoetsen hebben een functie; een overzicht staat in
        een hulp-schermpje dat je oproept met F1.

           Een Reset van de Spectrum wordt gegenereerd met ALT-F6,
        en een NMI met F5. Dat laatste is alleen handig als je de
        SamRam gebruikt (zie 2.4).

           De Emulator ondersteunt de Spectrum tape interface. Als
        je een voldoende snelle computer hebt waar de Emulator op
        zo'n 100% of sneller loopt, kun je in Real mode alle
        programma's (ook snellaad!) inladen. Op alle computers
        kunnen programma's ingeladen worden die op de gewone manier
        zijn gesaved; hiervoor hoeft de Emulator niet in Real mode
        te staan.

           De Emulator wordt in Real mode gezet met F7. In deze mode
        wordt het beeldscherm niet meer periodiek bijgewerkt, en
        kan ook het toetsenbord niet meer gebruikt worden. Hier
        staat tegenover dat de Emulator heel gelijkmatig loopt,
        waardoor van snellaad en -save gebruik gemaakt kan worden, en
        muziekjes beter klinken.

           De output naar het geëmuleerde RS232 kanaal van de
        Interface-I, en de input hier vandaan, kan worden gekoppeld
        met PC-randapparatuur en bestanden. Dit gaat ook via het
        hoofdmenu. Op deze manier kunnen Spectrum programma's
        communiceren met de PC-omgeving.

           Niet onbelangrijk: er is ook voor joystick emulatie
        gezorgd. Met de PC-pijltjestoetsen bestuur je de Spectrum
        joystick. Dit kun je ook doen met een analoge IBM-joystick
        of een digitale joystick; in het laatste geval moet er een
        kleine hardware-interface gebouwd worden. De Spectrum
        joystick die je bestuurt kun je kiezen uit Cursor, Kempston,
        en Sinclair 1,2.


3.2 Command line syntax

        De Sinclair ZX Spectrum Emulator moet als volgt opgestart worden:

        Z80 [{/|-}opties ...] [filenaam[.Z80]]

        In woorden: de opties moeten beginnen met een / of een -, en
        er mogen meerdere van zijn (niet gescheiden door spaties,
        anders moet er weer een / of - voor.) Ze mogen ook weggelaten
        worden. Na de opties mag de naam van een .Z80 bestand gegeven
        worden, dat direct zal worden ingeladen. Hierbij is de extensie
        .Z80 niet nodig.

           In plaats van een .Z80 bestand kan ook alleen een pad naar
        een directory met .Z80 bestanden opgegeven worden. Als je dit
        doet zal de Emulator bij het opstarten je de mogelijkheid
        geven uit de bestanden te kiezen en er eentje in te laden.

           Met de opties kunnen alle dingen ingesteld worden die ook
        in het hoofdmenu te wijzigen zijn plus enkele andere die na
        het opstarten vastliggen. De volgende opties zijn mogelijk:

         -h        Hercules graphics
         -x        Extended Hercules graphics
         -c        CGA graphics
         -e        EGA/VGA graphics
         -p        Plantronics graphics
         -q        Plantronics (grijstinten)
         -n        Standaard Spectrum (zonder IF1)
         -s        Spectrum met SamRam
         -jk       Kempston joystick (ipv Cursor)
         -j1, -j2  Sinclair joystick 1,2 (ipv Cursor)
         -kk       Gebruik geen digitale of analoge joystick
         -kz       Gebruik Digitale Zandbergen joystick
         -d        Dubbele interruptfrequentie
         -l        LDIR/LDDR emulatie
         -f        Snellere FLASH emulatie
         -r        R register emulatie
         -w        16K IF1 bankswitch
         -2        Emuleer Issue-2 Spectrum
         -g        Geen geluid
         -bN       Tape I/O via LPTn
         -yl, -yh  Lage, hoge video sync.
         -aN       Spec RS232 output naar LPTn
         -oN       Spec RS232 output naar COMn
         -iN       COMn naar Spec RS232 input
         -tF       Spec RS232 output naar file F
         -uF       File F naar Spec RS232 input
         -znnn.n   Maak rel. snelheid nnn.n%
         -?        Hulppagina


           Met de optie -h maakt de Emulator gebruik van de hercules
        kaart om het spectrum scherm af te beelden. Als een hercules
        interface aanwezig is, en deze wordt gedetecteerd, is deze
        optie niet nodig; het programma zal dan automatisch hercules
        gebruiken. Ook de opties -c en -e, voor respectievelijk CGA
        en EGA, zijn meestal niet nodig; in bijna alle gevallen zal
        de software de betreffende grafische kaart kunnen detecteren.
        Merk op dat er geen aparte VGA-optie is. EGA biedt de resolutie
        en alle kleuren die nodig zijn om het ZX Spectrum beeldscherm
        volledig te laten zien. Met een hogere resolutie en/of meer
        kleuren wordt niks gewonnen.

           De optie -x zorgt er ook voor dat het spectrum scherm op
        Hercules wordt afgebeeld. De herculeskaart wordt nu echter
        iets anders, op een niet-standaard manier ingesteld, zodat
        de resolutie 384*84 pixels wordt, in plaats van de gewone
        348*90 pixels. Hierdoor kan er een veel mooiere (en grotere)
        afbeelding gemaakt worden. Het kan echter zijn dat de
        monitor deze mode niet aankan; daarom wordt standaard de
        mode behorende bij optie -h gebruikt.

          De plantronics videokaart wordt in de meeste gevallen niet
        bij het opstarten herkend, omdat er vaak ook CGA aanwezig
        is. Voor het gebruik van deze videokaart zijn de opties -p
        en -q nodig. Optie -p is de standaard; op monochroom moni-
        toren is het resultaat met -q vaak mooier.

          Met de optie -n wordt de emulator in zijn meest
        uitgeklede vorm opgestart. De emulator heeft nu ongeveer
        200K vrij geheugen nodig. (64K voor de Spectrum en 136K voor
        de emulator en data). Normaal wordt de emulator opgestart
        als gewone Spectrum met interface 1. In deze vorm heeft de
        emulator zo'n 240K geheugen nodig. Met de optie -s wordt,
        indien mogelijk, de meest complete Spectrum opgestart, met
        interface 1 en SamRam. De emulator heeft dan zo'n 272K vrij
        geheugen nodig. Als er onvoldoende vrij geheugen
        beschikbaar is, zal de emulator eerst proberen een
        standaard spectrum op te starten. Als dit ook niet lukt
        keert de emulator naar DOS terug.

          De opties -jk, -j1 en -j2 besturen de joystick-emulatie.
        Standaard zijn de PC-pijltjestoetsen en de eventuele IBM
        analoge joystick of de digitale joystick 'aangesloten' op de
        cursortoetsen en de 0 als vuurtoets. Veel spelletjes werken
        (ook) samen met de Kempston of de Sinclair joysticks. Met
        optie -jk wordt de Kempston-joystick geëmuleerd, met optie
        -j1 en -j2 worden respectievelijk de Sinclair joystick 1 en
        2 (resp. toetsen 1-5 en 6-0) gebruikt.

          Een analoge IBM joystick wordt, indien deze is aangesloten,
        herkend en werkt dan verder als Spectrum Cursor, Kempston of
        Sinclair joystick. Als dit niet de bedoeling is, of het
        programma denkt een joystick te zien terwijl er geen is
        aangesloten kan optie -kk worden gebruikt. Ook een digitale
        joystick (zie paragraaf 3.15) zal worden herkend. Mocht dit
        niet goed gaan dan kan een digitale joystick geforceerd worden
        herkend met optie -kz.

          Met de optie -d wordt er tweemaal zo vaak een software
        Z80 interrupt gegenereerd. Het is voor het geëmuleerde
        programma nu net alsof er niet 50 keer maar 100 keer per
        seconde een interrupt voorkomt. Sommige spellen worden
        hierdoor sneller. Ook reageert het toetsenbord sneller,
        omdat de Spectrum ROM het toetsenbord via interrupts
        afscant. Wees echter voorzichtig met deze optie; er zijn
        spellen die door gebruik van deze optie juist langzamer
        worden; sommige lopen zelfs helemaal in de soep en crashen.
        Als je echter wat in Spectrum BASIC wil doen, is het sterk
        aan te raden deze optie te gebruiken, vooral op wat
        langzamere computers, omdat het toetsenbord dan veel beter
        reageert. Ook is het nuttig om bij elk spel even te proberen
        welk effect deze optie heeft.

           De optie -l heeft tot gevolg dat de Emulator de LDIR en
        LDDR instructies beter gaat emuleren. Door goed beveiligde
        programma's zoals programma's die van SPEEDLOCK gebruik maken,
        worden ongewone eigenschappen van de LDIR instructie gebruikt.
        (Zie hoofdstuk 4 voor details.) Met de -l optie worden deze
        programma's goed uitgevoerd. Zonder deze optie kunnen sommige
        programma's echter beduidend sneller lopen (probeer b.v.
        Jetset Willy en Manic Miner).

           De Z80 LDIR en LDDR instructies worden relatief snel uit-
        gevoerd door de emulator (als optie -l niet aktief is). Als
        je een programma draait dat veel van de LDIR instructie ge-
        bruikt maakt, en je bovendien een snelle computer hebt, kan
        het zijn dat het programma veel te snel gaat lopen. (B.v.
        Jetset Willy). Ook dan is optie -l te gebruiken, alleen dan
        om de emulator te vertragen.

           Als in de command line -f staat, wordt de FLASH functie
        van de spectrum 2 keer zo snel als normaal geëmuleerd. Op
        langzame computers is deze optie handig om een natuurlijker
        lijkende Flash te krijgen.

           De optie -r is bijna nooit nodig. Sommige
        beveiligingsmethoden berusten op het decoderen van
        programma's met behulp van het refresh-register. Om deze
        programma's goed te kunnen draaien, moet het refresh-
        register na elke instruktie verhoogd worden. Dit resulteert
        in een vertraging van bijna 30%. Niet gebruiken dus, deze
        optie, tenzij het noodzakelijk is (zoals bij veel programma's
        die van snellaad gebruik maken!)

           In een gewone Spectrum met Interface 1 beslaat het ROM
        gebied van deze interface de volle 16K, hoewel er maar een
        8K ROM in de interface zit. De bovenste 8K van de 16K bevat
        dezelfde informatie als de onderste 8K, maar wordt nooit
        gebruikt. Om de Interface 1 wat sneller te laten omschakelen
        schakel ik normaalgesproken alleen de onderste 8K in. Dit
        is met optie -w te veranderen. (Er zou een programma kunnen
        zijn die dit controleert....!)

           Sommige oude programma's, zoals Spinads en Scrambler, gaan
        ervan uit dat als je geen toets indrukt, poort 254 de waarde
        255 teruggeeft. Dit gebeurde op Issue-2 Spectrum, terwijl op
        Issue-3 Spectrums de waarde 191 wordt teruggegeven. Om deze
        problemen op te vangen maakt optie -2 van de Emulator een
        Issue-2 Spectrum.

           De optie -g zorgt ervoor dat de Spectrum OUT instructies
        voor de luidspreker onderschept worden. Een programma zal
        dus geen geluid kunnen maken.

           Met optie -bN, met N=1,2,3,4 wordt aangegeven aan welke
        parallelle printerpoort de cassette-interface is aangesloten.
        Zie paragraaf 3.8 voor uitgebreide uitleg over loaden en
        saven van programma's.

           Vanaf versie 1.30 zijn de optie -yl en -yh toegevoegd,
        die staan voor lage en hoge video synchronisatie. Deze opties
        hebben te maken met een subtiel verschil tussen de manier waarop
        de gewone Spectrum en de Spectrum Emulator de informatie in het
        beeldschermgeheugen presenteren. Bij de modernste Spectrum
        spellen, zoals Uridium en Ghosts & Goblins, geeft dit verschil
        aanleiding tot een onrustig beeld, of flikkerende 'sprites'.
        Als dit gebeurt is -yl vaak voldoende om het tegen te gaan. Ik
        ben nog geen spel tegengekomen die -yh nodig had, maar voor de
        volledigheid heb ik 'm er toch maar bijgedaan. Zie hoofdstuk 4,
        paragraaf 5, voor een meer technische beschrijving van deze
        optie.

           Met optie -a wordt de output van de Spectrum naar het
        Spectrum RS232 kanaal (het "b" of "t" kanaal van de inter-
        face 1) omgeleid naar een parallelle poort van de PC.
        Bijvoorbeeld -a2 leidt de output om naar LPT2. Standaard
        (dus zonder opgegeven omleiding) wordt de output omgeleid
        naar LPT1.

           Optie -o is net zo'n optie; alleen wordt nu de informatie
        naar de betreffende COM-poort gestuurd. Zorg er wel voor dat
        de poort goed staat ingesteld, doe dit anders door middel
        van het MODE commando. Voorbeeld: met -o2 wordt de output
        van het SAVE *"b" SCREEN$ commando (alleen met Interface 1)
        naar COM2 gestuurd.

           Voor optie -i geldt hetzelfde, alleen nu wordt de COM-
        poort voor input gebruikt. Zorg ook nu dat de betreffende
        poort juist staat ingesteld.

           De opties -t en -u spreken voor zich. Als het bestand dat
        gespecificeerd is bij optie -u niet bestaat zal er een
        errormelding volgen; als het bestand bij optie -t bestaat,
        zal deze verwijderd worden. Voorbeelden:
           -t output.txt
           -u c:\myfile.fil
        De spatie tussen de optie en de filenaam is niet nodig.

           Op erg snelle computers kan de Spectrum Emulator zo snel
        lopen, dat spelletjes volkomen onspeelbaar worden, het
        toetsenbord onhandelbaar, melodietjes onhoorbaar, enzovoorts.
        Hoewel eigenaren van dit soort computers ongetwijfeld geld
        genoeg hebben om gewoon een ZX Spectrum te kopen, en dus de
        Spectrum Emulator helemaal niet nodig hebben, kom ik deze
        mensen toch tegemoet met de optie -z. Als deze optie gegeven
        wordt, met achter de -z de snelheid van de Spectrum in
        procenten, relatief ten opzichte van de gewone Spectrum, dan
        zal de Emulator proberen deze snelheid zo goed mogelijk te
        benaderen. B.v. op een gewone PC heeft het hoopvolle '-z100.0'
        geen zin, en wordt de Emulator in de snelste stand gezet. Aan
        de andere kant wordt met '-z 0' de traagste stand gekozen.
        Maar voor 80486-computers en snelle '386-computers is '-z 100'
        een aan te raden instelling.
           De optie -z werkt alleen in de geregistreerde versie van de
        Spectrum Emulator.

           Als een filenaam gegeven is, wordt deze file als Spectrum
        programma ingeladen en uitgevoerd. Voor meer informatie over
        het bewaren van Spectrum programma's zie in dit hoofdstuk
        paragraaf 7, over het hoofdmenu van de Emulator. De struktuur
        van een .Z80 bestand wordt beschreven in hoofdstuk 4.

           Bijna alle instellingen die bij het opstarten gemaakt
        zijn kunnen tijdens de uitvoering van het programma
        gewijzigd worden. Alleen de scherm-mode opties en de
        configuratie van de Spectrum (Interface 1, SamRam) liggen
        vanaf het opstarten van de Emulator vast.


3.3 Hoe goed is de Emulator?

           Deze versie emuleert de volledige standaard Spectrum,
        met alle standaard I/O mogelijkheden (geluid, toetsenbord,
        beeldscherm, cassette i/o), de Interface 1 zonder microdrive
        en netwerk (dus alleen de software en de RS232 aansluiting),
        en de SamRam met bijbehorende software.

           Het is natuurlijk duidelijk dat programma's die meer
        hardware vragen dan wat hierboven staat niet zullen werken.
        Gelukkig zijn er maar weinig van zulke programma's. Bijna
        alle programma's gaan uit van een standaard Spectrum, zonder
        extra hardware.

           Nu is de vraag: hoeveel Spectrum programma's, die genoeg
        hebben aan de gewone Spectrum met eventueel een Interface 1,
        werken op de Spectrum Emulator. Ik heb de emulator uitgebreid
        getest en geprobeerd op een heleboel programma's, en tot nu
        toe werkten ze vrijwel allemaal goed. Uitzonderingen zijn:
        Fireman, die raar doet als je aan de linkerkant van iets
        afvalt, en Tomahawk, waarvan de speedlock-loader crasht,
        waarschijnlijk door een vreemd gebruik van de Z80 flags. Op
        deze kleine probleempjes na werken vrijwel alle programma's
        die draaien op een gewone Spectrum (met eventueel interface 1)
        ook op de Emulator, inclusief de programma's die voor
        beveiligingsdoeleinden gebruik maken van het R register.

           (Overigens: het probleem 'Fireman' is opgelost, maar de
        oplossing implementeren zou betekenen dat veel andere
        programma's langzamer gaan lopen. Dit is onacceptabel.)

           Nog een ander aspect is van belang, namelijk de snelheid.
        De Z80 emulator, die een belangrijk onderdeel is van de
        Spectrum emulator, is (vrijwel) optimaal. HET KAN NIET
        SNELLER! De Z80 emulator is de snelste die mogelijk is voor
        de PC. Alle andere emulatoren (in de vorm van CP/M, ZX81
        en ZX Spectrum emulatoren) die ik heb gezien waren allemaal
        duidelijk langzamer dan deze.

           Op mijn PC, een Philips P3105 met V20 (=8 bits bus) en
        8 MHz klok, loopt de emulator op ongeveer 19.5% van de
        snelheid van een normale Spectrum. Dit komt overeen met
        een Z80 klokfrequentie van .195*3.5 MHz = ongeveer 700 kHz.
        Deze frequentie is inclusief de ondersteunende software, dus
        beeldscherm emulatie, keyboard emulatie etc. Met deze
        snelheid zijn zeker niet alle programma's bruikbaar, maar
        een heleboel lopen, soms met enige aanpassingen, op een heel
        aanvaardbare snelheid. Zie hoofdstuk 3.11 voor suggesties.
        Op een 12 MHz NEC Powermate 1+ (AT) loopt de emulator op 62%.
        Dit lijkt weinig, maar het blijkt dat de vertraging
        nauwelijks opvalt. Vanaf een 12 MHz AT heb je gewoon het
        gevoel dat je op een Spectrum zit te werken (of te spelen).
        Op 25 MHz AT's en 80386's loopt de Emulator meestal ruim
        boven de 100%, maar vertragen is nog niet echt nodig. Op
        snelle 386's en alle 486's is vertragen een must. Ik heb
        de Spectrum Emulator één keer op dik 400% zien lopen. Mooi
        gezicht, dat wel, maar spelen wil niet meer zo. Hier is de
        vertraagoptie -z een must (en een geregistreerde versie dus
        ook!)

           Twee concurrerende Spectrum emulatoren wil ik hier bij
        name noemen: VGASPEC en JPP. De eerste werkt, zoals de naam
        al zegt, alleen met VGA-kaarten. Hij is een flink stuk
        trager dan Z80, en loopt ook op veel programma's vast die
        wel goed op Z80 lopen. Het enige voordeel van VGASPEC is dat
        het geluid minder 'rasperig' klinkt dan dat van Z80, maar
        daar moet je nog eens een flink stuk snelheid voor
        inleveren. (Z80 kan ook dit mooie geluid produceren, in Real
        Mode, maar dan kan er niet van het toetsenbord gebruik
        gemaakt worden.)

           De tweede, JPP, is op het moment dat ik dit schrijf nog
        in de ontwikkelingsfase. JPP kan nog niet met alle Spectrum
        programma's overweg, en lijdt ook nog aan een aantal bugs.
        De interne organisatie is radicaal anders dan die van Z80:
        JPP maakt gebruik van registers die alleen de '386 processor
        heeft. Het resultaat van de ontegenzeggelijk vernuftige
        opbouw is echter niet dat JPP sneller is dan Z80. Verder
        verfrist JPP het beeldscherm niet vaak genoeg, zodat
        bewegende poppetjes zich schokkerig over het beeld bewegen.


3.4 Scherm emulatie

           Het spectrum beeldscherm is opgebouwd uit een bit-mapped
        beeldschermgeheugen van 6144 bytes, en 768 bytes kleuren-
        attributen. 1 kleurenbyte specificeert de kleur van 1 blokje
        van 8 schermbytes, van 64 puntjes dus.

           Op de PC komt geen van de beeldschermformaten hiermee ook
        maar enigszins overeen. Om het Spectrumscherm op een PC
        grafisch scherm af te beelden zal dus een vertaalslag nodig
        zijn. Dit is nogal traag, dus het is voordelig niet telkens
        het hele scherm naar PC-formaat te 'vertalen'. Alleen als er
        veranderingen optreden zal deze verandering op het scherm
        gezet worden; anders gebeurt er niets.

           Het beeldscherm wordt elke keer als een interrupt gegeven
        wordt bekeken op veranderingen. Hierdoor is het voor het
        programma of het beeldscherm 50 keer per seconde afgebeeld
        wordt. Sommige programma's maken hier gebruik van,
        bijvoorbeeld de beroemde Monty-spellen: de 'sprites' worden
        telkens uitgewist en weer opgebouwd, maar het programma
        zorgt ervoor dat als het beeldscherm 'langskomt' de sprite
        keurig op het beeld staat. Bij deze spellen is het dus ook
        van belang wat de fase is tussen de 50 Hz Z80 interrupt en
        het opbouwen van het beeld. Deze fase is met de opties -yl
        en -yh te regelen.

           De Spectrum heeft 8 kleuren, als je de bright kleuren
        meerekent 16. Deze 16 kleuren kunnen niet in alle modes
        allemaal afzonderlijk worden weergegeven. Als de emulator
        bijvoorbeeld gebruikt maakt van CGA kunnen er maar 4 kleuren
        worden weergegeven. De bright kleuren hebben dan dezelfde
        intensiteit als de gewone kleuren, en de 8 kleuren zijn
        verdeeld in 4 groepen van 2 kleuren. Dit kan problemen geven
        bij sommige programma's, maar meestal kun je duidelijk zien
        wat er gebeurt. Alleen met een EGA of VGA kaart kunnen alle
        16 kleuren afgebeeld worden.

           Als standaard Hercules gebruikt wordt is het probleem nog
        groter, want in dat geval zijn de streepjespatronen voor
        kleuren 2-3 en 4-5 bijna niet uit elkaar te houden. Daarom
        kan beter gebruik gemaakt worden van Extended Hercules. In
        deze mode wordt elke Spectrum pixel opgebouwd uit 4 Hercules
        pixels. In dat geval zijn alle 8 kleuren onderscheidbaar.

           De rand van het scherm, de border, kan ook een kleur
        krijgen. Deze wordt 1 keer per interrupt op het scherm
        gezet, omdat het anders veel te langzaam zou worden.
        Het gevolg is dat er geen patronen in de border geschreven
        kunnen worden. Echter, als je EGA of VGA gebruikt, en de
        Emulator staat in Real-mode, dan worden de patronen wel in
        de overscan geschreven. Bij het saven en laden in Real mode
        zie je dus wel de bekende strepen in de border. (In externe
        mode, zie paragraaf 3.8 over de Tape interface, zie je ze
        ook, maar dan worden ze door de Emulator zelf gegenereerd,
        en niet door een Spectrum programma.)


3.5 Geluid emulatie

           De Spectrum heeft heel simpele geluidsmogelijkheden; je
        kunt de luidspreker eigenlijk alleen maar aan of uit zetten.
        Dit komt echter precies overeen met wat een standaard PC aan
        geluidsmogelijkheden aan boord heeft; ook de PC kan de
        luidspreker slechts aan of uit zetten. Dit komt dus mooi
        overeen.

           In mijn SamRam zit een bieper ingebouwd, die aan en uit
        gezet kan worden. Deze is ook geëmuleerd. (Zie hoofdstuk 4
        voor details over de aansturing van de bieper).


3.6 Toetsenbord emulatie

           Bij het indrukken en loslaten van een toets op het PC
        toetsenbord stuurt het toetsenbord een code naar de PC. De
        Emulator houdt intern bij welke toetsen zijn ingedrukt en
        welke niet, en vertaalt deze informatie naar de Spectrum
        toetsenbord matrix. Ook enkele niet op de Spectrum
        voorkomende toetsen worden geëmuleerd:

        - komma, punt, kleiner/groter dan, deelstreep, vraagteken,
          asterisk (op PrtSc), dubbele punt en puntkomma, dubbele
          en enkele aanhalingstekens, plus en min, = en underscore,
          backspace en CapsLock (wordt geëmuleerd als Shift-2).

           De escape toets wordt als EDIT (Shift-1) geëmuleerd. EDIT
        wordt namelijk op de Spectrum vaak gebruikt als een soort
        escape toets. De ALT en CTRL toetsen worden beide als
        Symbol Shift geëmuleerd.

           Dan de pijltjestoetsen. De pijltjestoetsen op het
        cijferblokje (8,4,6 en 2) worden geëmuleerd als de
        cursortoetsen op de Spectrum (5,6,7 en 8). In de regeleditor
        van de Spectrum moeten de cursortoetsen samen met Shift
        ingedrukt worden; als je NumLock indrukt wordt samen met 1
        van de cursortoetsen direct ook de Shift toets ingedrukt.

           De pijltjestoetsen kunnen ook gebruikt worden als
        joystickbesturing, voor spelletjes. Normaal worden de
        pijltjestoetsen geëmuleerd als de cursortoetsen, maar je
        kunt ze ook laten functioneren als een van de Sinclair
        joysticks (toetsen 1 t/m 5, of 6 tot en met 0) of een
        Kempston joystick (IN-poort 31). De mogelijkheden kunnen
        met de opties -j1, -j2 en -jk ingesteld worden, en ook via
        het hoofdmenu veranderd worden. Als vuurtoets worden de
        toetsen 5, 0 en . op het cijferblokje, en de TAB-toets
        gebruikt.

           Omdat het toetsenbord van de Spectrum in een matrix is
        geschakeld, kan er, als er meer dan 2 toetsen tegelijk
        worden ingedrukt, foute informatie binnenkomen. Zoals van
        alle eigenschappen van de Spectrum wordt ook hier door
        sommige programma's gebruik van gemaakt. (B.v. Zynaps: Door
        alle cursortoetsen in te drukken pauzeert het programma,
        maar eigenlijk checkt Zynaps op een toets in de rij 1-4).
        Ook deze 'fout' wordt geëmuleerd. Als je nu bijvoorbeeld op
        Shift, B en V tegelijk drukt, lijkt het voor de Spectrum of
        je ook de spatiebalk indrukt, en reageert de Spectrum door
        een 'Break into Program' error te geven.

           Tenslotte een aantal toetsen die een speciale functie
        hebben voor de emulator, en die niet direct gekoppeld
        zijn aan een Spectrum toets of toetsencombinatie. De eerste
        is Ctrl-Break. Hiermee keer je terug naar DOS.

           Dan de functietoetsen. Met een druk op F1 verschijnt
        een hulpschermpje, waarin in het kort alle ongewone
        toetsen staan uitgelegd. Met F2 wordt het huidige Spectrum
        programma geSAVEd, en met F3 wordt een .Z80 bestand
        ingeladen. Met F4 spring je direct naar het submenu waar de
        instellingen van de Emulator veranderd kunnen worden.

           De functietoets F5 genereert een NMI. (In de vorige
        versies van de Emulator deed F1 dit.) Als de SamRam is
        opgestart wordt de kraaksoftware hiermee aktief; zonder
        SamRam heeft een NMI een reset tot gevolg, of helemaal
        niets. Als je op ALT-F6 drukt, genereer je een gewone Z80
        reset. (Het indrukken van ALT voorkomt dat je per ongeluk de
        Emulator reset.) Met functietoets F7 zet je de Emulator in
        Real-mode (zie paragraaf 3.8 over de cassette-interface.)

           Tenslotte functietoets F10. Hiermee aktiveer je het
        hoofdmenu van de Emulator. Vanuit elk submenu kun je met F10
        altijd direct weer naar het hoofdmenu terugkeren. (Dit is
        handiger dan ESC gebruiken; hiermee ga je slechts een niveau
        hoger.) Vanuit het hoofdmenu kun je programma's laden en
        saven (ook met functietoetsen F2 en F3), instellingen
        veranderen (ook met functietoets F4), en terugkeren naar
        DOS. Voor een uitgebreidere beschrijving zie de volgende
        paragraaf.

           Nog een praktische tip m.b.t. het gebruik van het
        toetsenbord in de Emulator op trage PC's. Op de PC is het
        genoeg een toets heel licht en heel kort aan te slaan om
        hem door te laten komen. Het toetsenbord is namelijk
        interruptgestuurd. Bij de Spectrum gebeurt het
        toetsenscannen door polling. Dit gaat op de gewone Spectrum
        erg goed, maar omdat de geëmuleerde Spectrum soms vrij
        langzaam is, geeft dat toch enkele problemen. Je moet de
        toetsen vrij nadrukkelijk indrukken, en ook nadrukkelijk
        loslaten (dus niet gelijk de volgende toets indrukken) om
        de Spectrum tijd te geven even bij te komen. Als je een
        Basic programma intikt in de Emulator is optie -d, dubbele
        interruptsnelheid, handig om te gebruiken. Omdat de toets
        scan routine interruptgestuurd is, maakt deze optie het
        toetsenbord een stuk sneller.


3.7 Het hoofdmenu van de Emulator

           Dit menu wordt opgeroepen met een druk op F10. Je hebt
        hier 8 opties: terug naar emulator, naar Real-mode, een
        programma laden of saven, de RS232 input of output omleiden,
        andere instellingen veranderen, naar DOS shellen of stoppen.

           De meeste van deze mogelijkheden kunnen ook direct worden
        opgeroepen door een functietoets: F2 voor saven, F3 voor
        laden, F4 voor het veranderen van instellingen, en F7 voor
        Real mode. Met F1 verschijnt een hulpscherm waar de speciale
        toetsen (onder andere deze functietoetsen) kort worden
        uitgelegd.

           De Real mode wordt uitgelegd in paragraaf 3.8, waar ook
        de tape interface wordt behandeld.

           Als je het programma wegschrijft op disk, wordt de gehele
        inhoud van het Spectrum geheugen (48K) plus alle registers
        en dergelijke van de Z80 weggeschreven. Je bevriest het
        programma dus, en je kunt verdergaan waar je gebleven was
        door het programma weer in het geheugen te laden. Ook enkele
        instellingen van de Emulator worden in de .Z80 file opgeslagen.
        Dit zijn de instelling van de interruptsnelheid (dubbel of
        gewoon), of de Emulator een Issue-2 of een Issue-3 Spectrum
        emuleert, de instelling van de videosynchronisatie (hoog,
        normaal of laag) en welke joystickinterface geëmuleerd wordt.

           Als de menukeuze Laad programma gekozen wordt, moet je
        een bestandsnaam intikken. Geef je een Return op een lege
        regel, dan verschijnt een lijst van alle .Z80 files die in
        de huidige directory staan, gesorteerd op voorletter. Met de
        pijltjestoetsen, PgUp, PgDn, Home en End kun je door deze
        lijst lopen. Als je op een lettertoets drukt springt de
        keuzebalk naar het eerste programma dat met die letter
        begint, om het zoeken in een uitgebreide lijst programma's
        te vergemakkelijken. Als je deze lettertoets nog een keer
        indrukt springt de balk naar het volgende programma,
        enzovoorts. Als het programma ingeladen is, en de
        instellingen die in de .Z80 file zijn opgeslagen komen niet
        overeen met de instellingen van de Emulator, dan zal een
        tabel met de nieuwe instellingen verschijnen. Met een druk
        op een toets worden de instellingen gewijzigd; als op de
        ESCape toets gedrukt wordt worden de instellingen niet
        veranderd.

           Met de optie Save programma bewaar je alleen het normale,
        standaard Spectrum geheugen. De inhoud van de ramdisk van
        de SamRam wordt niet bewaard; ook de 'stand' van de ROMs
        niet. Je kunt dus alleen programma's bewaren die in het
        normale geheugen zitten; als je op NMI gedrukt hebt, en je
        bent bezig in bijvoorbeeld de disassembler, kun je dat niet
        bewaren. (Bewaard dus ook geen programma's die misschien
        bezig zijn met de Interface-I; deze lopen dan vast als je ze
        opnieuw inlaadt.)

           Met "Change Settings" kun je verschillende
        instellingen van de Spectrum Emulator wijzigen. Je kunt de
        dubbele interruptsnelheid, de LDIR-emulatie, de R-register
        emulatie en de snelle flash aan- of uitzetten; je kunt het
        geluid van de geëmuleerde Spectrum aan- of uitzetten, de
        snelheid van de emulator veranderen, de 'video-synchronisa-
        tie-mode' wijzigen om flikkerende sprites rustig te krijgen,
        de Issue-2 of Issue-3 emulatie instellen, en je kunt hier de
        joystick-emulatie kiezen, uit Cursor, Sinclair 1 en 2, en
        Kempston. Tenslotte kan de LPT-poort gekozen worden die voor
        tape i/o gebruikt wordt. De instellingen die je hier kunt
        maken zijn ook door 'switches' bij het opstarten van de
        Emulator te maken. Zie paragraaf 3.2 voor een uitgebreidere
        uitleg van de functies van de verschillende instellingen.

           Via de menu-keuzes "Redirect RS232 input" en "Redirect
        RS232 output" is de geëmuleerde RS232-poort te koppelen aan
        verschillende PC input/ouput kanalen. Je kunt de poort
        koppelen aan een diskfile, maar ook aan een COM-poort, zodat
        je bijvoorbeeld een verbinding met een echte Spectrum kunt
        maken via de Interface-I RS232 poort, of je kunt de output
        omleiden naar de printerpoort (LPT). Als de in- of uitvoer
        gekoppeld wordt aan een diskfile komt achter de filenaam
        een tellertje te staan, dat aangeeft hoeveel bytes er al
        gelezen of geschreven zijn.

           Bij output naar de Spectrum RS232 poort (en dus naar
        disk, COM of LPT) wordt gebruik gemaakt van een
        output-buffer van 256 bytes. Als er iets fout gaat
        (bijvoorbeeld de printer staat uit terwijl je toch iets
        print) is het handig deze buffer schoon te kunnen maken. Dit
        kan door na "Redirect RS232 output" te kiezen "Clear output
        buffer". Eventueel in de buffer achtergebleven tekens zullen
        nu niet verzonden worden.

           Als er bij het lezen van de Spectrum RS232 poort iets
        fout gaat moet je opnieuw beginnen. De zendende partij moet
        dan opnieuw zijn boodschap versturen. Als er een disk-file
        gebruikt wordt als input, is dit te bewerkstelligen met de
        keuze "Reset Disk Input". Als deze functie gekozen wordt,
        begint het lezen van de aktieve disk-file weer van voren af
        aan. Deze mogelijkheid verschijnt alleen in het menu
        "Redirect RS232 input" als er inderdaad een file aan de
        input is gekoppeld.


3.8 De Tape interface en Real Mode

           Vanaf versie 1.40 is het dan eindelijk zover: op iedere
        PC kunnen nu direct Spectrum programma's van cassette
        ingeladen worden!

           Allereerst is er natuurlijk een hardware interface nodig
        om de cassetterecorder aan te kunnen sluiten op de PC.
        Hiervoor wordt een klein schakelingetje gebruikt dat wordt
        aangesloten op een LPT-poort. Er zijn twee schema's, een
        hele simpele en een iets ingewikkelder met een OpAmp. De
        eerste is gevoelig voor de instelling van het volume maar
        werkt in het algemeen uitstekend. De tweede kan in zeldzame
        gevallen problemen geven (als aan de ingangen van de LPT-
        poort erg kleine pull-up weerstanden hangen). De schema's
        staan in het Spectrum-programma DIAGRAMS.Z80. In dit
        programma is ook een klein testprogrammaatje opgenomen,
        waarmee de simpele cassette-interface afgeregeld kan worden.

           De Emulator moet weten aan welke printerpoort de
        interface is gekoppeld. Dit kun je bij het opstarten aangeven
        met optie -bN, waar N=1,2,3,4 de printerpoort aangeeft, of
        via het hoofdmenu.

           Er zijn twee manieren van inladen; deze noem ik (vrij
        willekeurig) extern en intern. Bij de eerste manier is het
        in feite een kleine routine in de Emulator die het
        eigenlijke inladen bewerkstelligt. Hierdoor werkt dit op
        elke computer, ongeacht of deze nu bloedsnel of tergend
        traag is, maar kan het geen snellaad aan. Alleen programma's
        die op de normale manier zijn gesaved kunnen zo worden
        ingeladen.

           Bij tweede manier, die ik de 'interne' manier noem,
        is het de geëmuleerde Spectrum zelf die het programma aan
        het laden is. Het enorme voordeel hiervan is dat de
        Emulator in deze mode ook in staat is snellaad programma's
        in te laden. Hiervoor is nodig dat de Emulator zo'n beetje
        'real time' loopt. Deze manier is dus alleen bruikbaar op
        snelle computers. Als je deze manier gebruikt moet de
        Emulator in de zgn. Real mode staan. Deze kun je aanzetten
        door op F7 te drukken. In deze mode wordt het beeldscherm
        niet meer bijgewerkt; hierdoor kan de Z80-emulator onafge-
        broken en soepeltjes doorwerken, wat noodzakelijk is bij
        tijdkritische zaken als het inladen en het saven van
        programma's. Nadeel is wel dat ook het toetsenbord niet meer
        gebruikt kan worden. Ook timing-interrupts worden niet meer
        gegenereerd als de Z80 in DI staat; als de Z80 interrupts
        ge-enabled zijn, worden deze wel gegenereerd.

           Hoe gaat het inladen nu precies? Als je een gewoon
        programma wilt inladen is het het makkelijkst van de externe
        manier gebruik te maken. Typ eenvoudig LOAD "", en je ziet
        een windowtje op het scherm verschijnen. In dit window staat
        het type van het in te laden blok (0=header, 255=datablok,
        en iets anders is iets anders), de plaats waar dit blok in
        het geheugen zal worden gezet en de lengte ervan. Als je een
        EGA of VGA kaart gebruikt moet de border nu gaan knipperen,
        en je moet het programma op de gewone manier in kunnen
        laden. Tape loading errors worden op de gebruikelijke manier
        gemeld. Een druk op een willekeurige toets geldt als een
        Break. Als je geen EGA of VGA videokaart hebt zie je niets
        gebeuren. Na het inladen (met of zonder tape-error) van elk
        datablokje (=header of echt datablok) moet het windowtje
        verdwijnen (en evt. weer verschijnen). Gebeurt dit niet dan
        weet je zeker dat er iets mis is gegaan.

           Het wordt ingewikkelder als er snellaad gebruikt wordt.
        Deze programma's kunnen alleen in Real mode worden
        ingeladen. Zet eventueel de R-register emulatie en de
        LDIR-emulatie aan (vele met snellaad gesavede programma's
        zijn beveiligd) en stel de snelheid van de Emulator zo dicht
        mogelijk bij de 110% in. (Iets meer dan 100%, want de
        IN-instructie die nogal vaak gebruikt wordt is relatief
        traag.) Typ LOAD "", en druk op F7 om naar Real mode te
        gaan. Vanaf nu wordt het beeldscherm niet meer bijgewerkt.
        Als je een EGA of VGA videokaart gebruikt kun je aan de
        border zien hoe het met het laden gaat; in andere gevallen
        kun je tijdens de pauzes tussen de blokken door op de 'U'
        van Update Screen drukken om te kijken hoe het laden
        verloopt. Als het programma helemaal is ingeladen druk je op
        'B' van Back to Normal Mode, en je kunt beginnen.

           Een truuk die je kunt gebruiken als je de Emulator niet
        helemaal op de 110% kunt krijgen, is het vertragen van de
        cassetterecorder. Als de computer niet sneller wil, moet het
        bandje maar trager! Hoe ver je hiermee kunt gaan heb ik niet
        uitgeprobeerd, maar als je op 90% loopt moeten met deze truuk
        toch heel wat snellaad programma's ingeladen kunnen worden.

           Het saven van programma's gaat op een zelfde manier. Ook
        hier kun je gebruik maken van de Real mode, maar dit heeft
        alleen zin als je een snelsave-programma hebt. Meestal is
        het het eenvoudigst en het best om gebruik te maken van de
        externe save-routine. Als je van de interne routine gebruikt
        wilt maken, in Real mode, moet de snelheid ongeveer 100%
        zijn (dus geen 110% zoals bij het laden!)

           Bij sommige videokaarten is het mogelijk dat tijdens het
        laden er storing ('ruis') op de monitor verschijnt, vooral
        als er strepen in de overscan verschijnen. Dit is niet erg,
        maar is helaas niet te voorkomen.

           Er is nog een heel interessant punt met betrekking tot de
        SamRam. Origineel is deze interface als 'kraakkastje'
        gebouwd. Je kon er programma's heel makkelijk mee kopiëren,
        door het programma in te laden en het in het normale
        Spectrum formaat (dus geen snellaad) te saven. Maar met de
        SamRam is het nu ook mogelijk elk .Z80 programma weer naar
        tape te saven! Dit gaat als volgt: start de Emulator op met
        optie -s, om de SamRam te emuleren. Laad het Spectrum
        programma in de geëmuleerde Spectrum via het hoofdmenu, en
        druk op F5, NMI. Kies optie 'S', en druk vervolgens nogmaals
        op 'S'. Nu kun je een filenaam invoeren. Als je nu op Enter
        drukt, wordt het programma op tape gezet, in een formaat dat
        ook voor gewone Spectrums begrijpelijk is. (Je kunt ook
        laadschermpjes toevoegen; zie hiervoor paragraaf 2.5 waar
        deze manier van saven uitgebreider wordt behandeld.)

        HET SPREEK VOOR ZICH DAT DEZE MOGELIJKHEID NIET GEBRUIKT MAG
              WORDEN VOOR HET ILLEGAAL KOPIEREN VAN SOFTWARE!


3.9 Overzetten van Spectrum programma's

           Om de Emulator echt goed te kunnen gebruiken, zul je
        Spectrum programma's moeten overzetten naar de PC. Een groot
        nadeel is dat de standaard interfaces van de PC niet
        standaard zijn op de Spectrum (RS232, diskdrive), en dat de
        enige standaard interface van de Spectrum niet standaard is
        op de PC (Cassette interface). Op een van beide computers zal
        dus een interface geïnstalleerd moeten worden. Er zijn twee
        veel voorkomende Spectrum-interfaces, waarmee het
        gemakkelijk is Spectrum programma's over te zetten naar de
        PC, namelijk de Interface-I en de DISCiPLE disk interface.
        Bij het geregistreerde Emulator-pakket zit een utility voor
        het lezen van Snapshots en gewone bestanden van DISCiPLE
        schijven. Een korte uitleg van dit programma staat in
        paragraaf 3.14, en meer algemene opmerkingen betreffende disk
        interfaces voor de Spectrum staan in paragraaf 3.10 hieronder.
        Voor bezitters van een Interface-I staat in deze paragraaf
        uitgelegd hoe je programma's moet overzetten.

           Verder zijn er nog een aantal Spectrum emulators voor de
        PC, zoals VGASPEC en JPP. De door deze programma's gebruikte
        formaten zijn verschillend van het formaat van .Z80
        bestanden, maar voor geregistreerde gebruikers bestaat er
        een utility die de formaten .SP en .SNA in .Z80 bestanden
        kan omzetten, en omgekeerd. Zie paragraaf 3.13.

           De interface 1 bestaat onder andere uit een RS232
        interface. Een nul-modem kabel tussen de Spectrum en de PC is
        dan nog het enige dat je nodig hebt. Ikzelf gebruik een
        eenrichtings nulmodemkabel, met de volgende aansluitingen:

          Spectrum                                  'AT'      'PC'
          (9 pens)                                (9 pens)  (25 pens)

            3 TxD   ------------------------- RxD     2         3

            4 DSR   ------------------------- DTR     4        20

                                        +---- CTS     7         4
                                        +---- RTS     8         5

            7 GND   ------------------------- GND     5         7

        (Pennen 8 en 7, of 4 en 5, moeten dus verbonden worden!) Met
        deze kabel kun je data van de Spectrum naar de PC versturen,
        niet andersom.

           Heb je het programma gestopt, en weet je hoe je het
        opnieuw kunt starten, dan kun je het programma overzenden.
        Zie hiervoor het programma SAVESPEC.BAS dat ook bij de
        emulator te vinden is. Dit programma zal op de gewone
        Spectrum ingetikt of -geladen moeten worden. Dit gaat op de
        volgende manier. Start de emulator op met

        Z80 /u savespec.bas

        De input van de geëmuleerde RS232 poort is nu verbonden met
        het bestand savespec.bas. Tik op de geëmuleerde Spectrum in:

        LOAD *"b"

        Het basic-programma wordt nu via de (geëmuleerde) RS232
        poort ingeladen. Druk op ENTER om een listing te krijgen, en
        tik het programma in de Spectrum in. Als je een echte (2-
        richtings) nulmodemkabel hebt, kun je ook de RS232 output
        van de emulator omleiden naar COM1, en LOAD *"b" op de
        Spectrum intikken, en SAVE *"b" op de emulator.

           Laat het programma lopen (op de echte Spectrum). Het
        programma maakt een stukje machinecode aan op adres 23296,
        en schrijft het dan weg naar cassette met het SAVE-commando.

           Laad nu het programma in dat overgezet moet worden, en
        stop het. Laad het stukje code dat je met het BASIC-
        programmaatje geproduceerd hebt, in op een veilig adres. Het
        mooiste is als het in de gewone RAM geladen wordt, maar je
        bent nooit zeker dat je het niet over iets belangrijks
        heenlaadt. De veiligste manier is het laden van de code in het
        scherm. Typ:

        LOAD "RS232" CODE 16384

        en laad de code in. Typ nu (op de gewone Spectrum nog
        steeds):

        OPEN #3,"b": RANDOMIZE USR 16384: RANDOMIZE USR adres

        Als je het programma in RAM hebt ingeladen, moet je
        het adres van de eerste RAND USR natuurlijk veranderen.
        In bovenstaande regel is 'adres' het startadres van het
        programma. Ook kun je natuurlijk ipv RANDOMIZE USR adres
        gebruiken:

        GOTO xxxx

        als het programma een BASIC-programma is, of vanuit BASIC
        wordt opgestart. Druk echter nog niet op ENTER, de PC moet
        nog klaar staan. Stel met het commando MODE com1:96,n,8,1
        (of com2, natuurlijk) de RS232 COM-poort in op de juiste
        baudrate, en typ:

        GETRS filenaam.z80

        (GETRS.COM wordt bijgeleverd bij de emulator). Gebruik de
        optie /2 als je van COM2 gebruik maakt, etc. De PC is nu
        klaar voor ontvangst. Druk bij de Spectrum op ENTER, en het
        zenden begint. Op het scherm verschijnt nu een tellertje dat
        het aantal overgezonden bytes aangeeft. Na ongeveer 1 minuut
        (bij 9600 baud) zijn de 49182 bytes overgestuurd, en kan het
        programma gedraaid worden met de Emulator.

           De met SAVESPEC.BAS overgezonden .Z80 bestanden zijn
        altijd 49182 bytes lang. Om ze om te zetten in het gewone,
        gecomprimeerde .Z80 formaat moet je ze inladen in de
        Emulator en direct weer wegschrijven.

           In plaats van op bovenbeschreven manier is het natuurlijk
        ook mogelijk om met SAVE *"b" CODE x,y meteen blokken code
        over de RS232 verbinding te sturen, en ze met een dergelijk
        statement direct in de Emulator te laden, om ze daarna in
        definitieve vorm op schijf te krijgen (als .Z80 bestand).
        Dit is ook bruikbare methode; ik vind de eerste, met
        SAVESPEC.BAS het gemakkelijkst, maar als je een beetje weet
        hoe het programma dat je wilt overzetten in elkaar steekt
        kun je het ook op de laatste manier sneller overzetten.


3.10 Overzetten vanaf Spectrum floppy's

           Bij de introduktie in 1982 was de Spectrum een zeer kale
        machine: de cassette-interface was de enige manier om
        programma's op te slaan. In die tijd had men de floppy-drive
        al uitgevonden, maar het prijskaartje dat eraan hing (het
        kostenplaatje dat erbij hoorde) was zo hoog dat ze alleen in
        professionele systemen gebruikt werden. Later kwam Sinclair,
        als vanouds, met een redelijk werkend maar goedkoop
        alternatief: de microdrive.

           Er zijn echter ook 'echte' disk-interfaces gemaakt voor
        de ZX Spectrum, en enkele waren redelijk populair, zoals de
        DISCiPLE, de Discovery, en BetaDisk. Zoals hierboven al
        gezegd is zit bij het geregistreerde Emulator pakket een
        leesprogramma voor DISCiPLE schijven (zie 3.14), dus
        bezitters van de DISCiPLE interface hebben het gemakkelijk.

           Ook voor de Betadisk-interface is een conversieprogramma
        geschreven, door J.L. Bezemer. Het programma heet BDDE; de
        huidige versie gaat onder de naam BDDE10A rond op BBS'en.
        Het programma is voorzien van een goede handleiding.
        Waarschijnlijk is het programma op elk redelijk gesorteerd
        BBS op te halen; het staat in ieder geval op het Spectrum
        Emulator Support BBS (zie de README).

           Voor de Discovery bestaat er bij mijn weten nog geen
        conversieprogramma. Als ik tegen dergelijke programma's
        aanloop zal ik zorgen dat ze in ieder geval op het support
        BBS verschijnen.



3.11 Welke programma's zijn te gebruiken op de Emulator?

           Een antwoord op deze vraag is makkelijk te geven: Op een
        of twee uitzonderingen na werken alle programma's die ik tot
        nu toe heb geprobeerd naar behoren (en ik heb meer dan
        duizend Spectrum programma's..). Als de Emulator echter op
        een gewone PC wordt gebruikt is de snelheid te laag voor
        echt flitsende aktiespellen. Deze spellen zijn eigenlijk
        alleen leuk te spelen vanaf een 12 MHz AT of sneller. Maar er
        zijn programma's die wel goed op PC's te gebruiken zijn.

           Sommige programma's hebben tijdens de uitvoering vrijwel
        niets te doen. Ze vullen de tijd met HALT instructies, of
        met interruptgestuurd geluid. Deze programma's kunnen met
        toepassing van de optie -d, dubbele interruptsnelheid, goed
        speelbaar blijken, zelfs op gewone, vrij langzame PC's
        (zoals de mijne). Een voorbeeld is Splitting Images, een
        spel dat in de normale uitvoering al razendsnel is, en ook
        nog interruptgestuurd is, zodat het op de Emulator heel goed
        speelbaar is.

           Een andere klasse spellen, die echter helaas niet zo vaak
        voorkomt, is het Jetset Willy type. Jetset Willy gebruikt
        bijna 80% van de speeltijd de LDIR instructie, en dit is de
        enige instructie die geëmuleerd sneller is dan het
        origineel. Het gevolg is dat Jetset Willy op mijn vrij
        langzame PC sneller loopt dan de originele Spectrum versie!
        Zeer goed speelbaar, dus. Ook Manic Miner valt in deze
        categorie. Ook sommige flightsimulatoren blijken de LDIR
        instructie vaak te gebruiken; deze worden ook sneller dan
        normaal.

           Ten slotte is er de categorie spellen die niet snel
        hoeven te zijn, zoals adventures. The Hobbit, een
        klassieker, is bijvoorbeeld goed te spelen, als je niet let
        op de oer-trage fill-routine (die op de normale Spectrum al
        tergend langzaam was...). Ook de Adventure A t/m E
        adventures zijn goede voorbeelden. Deze adventures, die in
        de begintijd van de Spectrum uitkwamen, zijn text-only en
        zeer snel, dus prima om te emuleren.

           Zelf heb ik een bescheiden PCtje, en in de tijd dat ik
        begon met de Spectrum Emulator waren AT's nog heel wat, en
        een 16 MHz AT was helemaal onbereikbaar snel. Tegenwoordig
        heeft elke zich enigszins respecterende compuyup minstens
        zo'n 16 MHz machine, en eigenlijk liever een '386. Vele
        computergebruiker hebben razendsnelle machines (en draaien
        Windows om hier in godsnaam toch maar niks van te merken).
        Voor deze computerbezitters kan ik kort zijn: alle Spectrum
        spellen zijn uitstekend speelbaar. Let alleen op voor Manic
        Miner en Jetset Willy, die hebben echt optie -l
        (LDIR-emulatie) nodig om niet helemaal bovenaards snel te
        lopen.



3.12 De utility Convert

           De gebruikte formaten van gegevensoverdracht bij de
        Spectrum zijn niet compatibel met die, gebruikt in de
        PC-wereld. Om toch wat zinnigs met de Spectrum te kunnen
        doen, zul je Spectrum-formaten en PC-formaten in elkaar
        moeten kunnen overzetten. Dit is precies wat de utility
        Convert doet.

           Het kan op een aantal manieren werken. Ten eerste kan
        het een Spectrum BASIC programma in ASCII omzetten, zodat
        het bijvoorbeeld in GWBASIC geladen kan worden. Het zal
        dan nog niet direct uitgevoerd kunnen worden, maar het
        kan in ieder geval bewerkt worden. Ook kan een ASCII-
        bestand makkelijk worden uitgeprint.

           Wat Convert in deze mode doet, is vergelijkbaar met wat
        de Spectrum doet als je een LIST-commando geeft. Het is
        zelf precies na te doen met de Emulator, mits je er wat
        tijd voor neemt:

                Z80 /tbasic.txt
                OPEN #3,"t":REM open kanaal 3 voor RS232 text output
                LIST #3:REM stuur de listing naar kanaal 3

           De Emulator stuurt nu de gegevens van het RS232 kanaal
        door naar het bestand BASIC.TXT.

           Convert kan ook het omgekeerde; dus het omzetten van
        ASCII naar Spectrum BASIC. Dit kan de Spectrum niet
        standaard, en het kan je een hoop intikwerk schelen! Ook
        listings die je op bovenstaande manier, via het RS232-tekst
        kanaal "t", naar een file hebt geschreven kunnen terugver-
        taald worden, ondanks het feit dat de Interface-I er
        standaard na elke 80 karakters een CR/LF tussenvoegt.
        Deze mogelijkheid van CONVERT is handig als je in grote
        BASIC-programma's veranderingen wilt aanbrengen. De gewone
        Spectrum line-editor is niet de handigste...!

           Dan kan Convert ook nog Spectrum schermpjes omzetten in
        het zogenaamde GIF formaat. GIF staat voor Graphic
        Interchange Format, en in elk goed tekenprogramma zijn dit
        soort bestanden wel in te laden en te bewerken. Ook zijn er
        vele (public domain) print-programma's die GIF plaatjes uit
        kunnen printen.

           Tenslotte kan Convert in een ASCII-file de CR's omzetten
        in CR/LF's. Het eerste is standaard bij tekstoverdracht
        tussen Spectrum programma's, terwijl de PC ook een Line Feed
        (LF) na elke CR verwacht.

           De conversiemode van Convert wordt gekozen door het
        formaat van de input- en dat van de outputfile op te geven.
        Convert zoekt dan zelf uit wat hij moet doen om de bestanden
        te vertalen. De input- en outputmode kunnen gekozen worden
        uit de volgende mogelijkheden:

        Inmode:  A: Ascii- pure tekst
                 B: Bytes- pure code of schermdata
                 S: Save *"b" formaat - code, schermdata of BASIC
                 Z: .Z80 bestand

        Outmode: C: Ascii, met als lijnovergang CR [.TXT]
                 L: Ascii, met CR/LF (PC standaard) [.TXT]
                 B: Bytes- pure code of schermdata [.BIN]
                 S: Save *"b" formaat - 'bytes' (code) [.SAV]
                 P: Save *"b" formaat - 'program' (BASIC) [.SAV]
                 G: GIF formaat (Graphics Interchange Format) [.GIF]

        In het onderstaande tabelletje staan de mogelijke
        combinaties. Een 'v' staat voor een goede combinatie, een
        spatie voor een illegale, en een 'x' voor een combinatie
        waarbij er niks zou gebeuren.

               in: C   L   B   S   P   G
         uit:
          A        v   v       v   v

          B                x   v       v

          S        v   v   v   x   x   v

          Z                v           v

           Indien als outputmode .GIF wordt gekozen, moet de inputfile
        precies 6912 bytes lang zijn (of 6912+9 voor SAVE *"B"),
        behalve indien als input een .Z80 bestand gebruikt wordt.

           Een .Z80 bestand kan worden omgezet in een bestand van
        precies 48K lang: de exacte geheugeninhoud van de Spectrum
        die in het .Z80 bestand zit opgeslagen. De registers e.d.
        gaan verloren bij deze conversie.

           De utility Convert zit niet bij de ongeregistreerde
        versie van de Emulator. Als je je registreert krijg je het
        programma toegestuurd. Lees de file README.DOC voor details
        over het registreren voor de Spectrum Emulator, of lees de
        inleiding, paragraaf 4.



3.13 De utility ConvZ80

           Net als Convert is ConvZ80 een utility die alleen bij het
        geregistreerde pakket zit inbegrepen. Met ConvZ80 kunnen
        'snapshots' van de Spectrum emulatoren VGASPEC en JPP
        omgezet worden in de .Z80 bestanden van Z80, en omgekeerd.

           ConvZ80 werkt heel simpel: je geeft twee bestandsnamen met
        extensies .Z80, .SP (voor VGASPEC) of .SNA (voor JPP), en
        ConvZ80 zet het bestand om in het gewenste formaat.

           VGASPEC is een Spectrum emulator die alleen op AT's
        werkt, zoals de naam al doet vermoeden een VGA-kaart nodig
        heeft, en flink wat trager is dan Z80. Positief is dat
        VGASPEC een minder 'rasperig' geluid geeft dan Z80. Dit komt
        door de fundamenteel andere manier waarop de auteur van
        VGASPEC zijn Z80 emulator in elkaar heeft gezet. Het grote
        verschil in snelheid heeft hier ook mee te maken.

           JPP werkt alleen op '386 computers en hoger. JPP is ook
        langzamer dan Z80, en doet ook op andere punten in meer of
        mindere mate onder voor Z80.


3.14 De utility DISCIPLE

           Voor de Spectrum zijn een aantal diskinterfaces ontwikkelt.
        De meest populaire is de zogenaamde DISCiPLE disk interface.
        Deze standaard gebruikt gewone 3,5 inch diskettes. Met de
        alleen voor geregistreerde gebruikers beschikbare utility
        DISCIPLE kunnen deze diskettes gelezen worden.

           Op een DISCiPLE disk kunnen gewone bestanden staan, zoals
        BASIC, CODE, DATA en SCREEN$ files, en zogenaamde Snapshots.
        Door op een knopje op de diskinterface te drukken wordt de
        inhoud van het Spectrum geheugen automatisch in zo'n bestand
        opgeslagen.

           De utility DISCIPLE kan gewone bestanden van disk afhalen
        en omzetten in bestanden die in de Emulator geladen kunnen
        worden alsof ze met SAVE *"b" bewaard waren. Een van disk
        geladen BASIC programma kan dus aan de RS232 input van de
        Emulator gekoppeld worden, waarna het met LOAD *"b" ingeladen
        kan worden.

           De Snapshots kunnen worden omgezet in .Z80 bestanden, die
        weer in de Emulator geladen kunnen worden. Op deze manier
        kunnen programma's dus erg snel en eenvoudig overgezet worden
        van Spectrum naar PC.

           Het programma is menugestuurd en eenvoudig van opzet, zodat
        bediening volkomen voor zich spreekt zodat ik er hier niets
        over hoef te zeggen.


3.15 Een digitale joystick voor de PC

           Als er al een joystick op de PC kan worden aangesloten, is
        dit standaard een analoge. Analoge joysticks zijn niet zo
        handig in het gebruik, en bovendien werden voor de Spectrum
        alleen digitale joysticks gebruikt. Dus je hebt waarschijnlijk
        nog een digitale joystick in de kast staan. Deze kun je vrij
        eenvoudig op de PC aansluiten met een eenvoudig schakelingetje
        dat is ontworpen door Ruud Zandbergen. Ik ben zo vrij deze
        digitale joystick interface voor de PC de 'Zandbergen
        Interface' te dopen. Als deze interface op de analoge
        joystickingangen van de PC wordt aangesloten zal de Emulator
        deze automatisch herkennen.

           De beschrijving van de interface volgt nu.

        Benodigdheden voor de digitale joystickinterface:

        1 x 9 pens D plug, male
        1 x 15 pens D plug, male
        4 x 1KΩ , ¼ Watt weerstandjes
        1 x 47 Ω, ¼ Watt weerstandje
        stukje 7-aderig kabel (onafgeschermd)

        Alles kan ondergebracht worden in de 15-pens plug. Let er op
        dat de weerstandjes geen contact maken met andere blootliggende
        aansluitingen.


15 pen male  (pc)                           9 pen male (joystick)


1+9  >──────────┬───────────┬────────────┬─────────────┬──> 7 (5V)
               ┌┴┐         ┌┴┐          ┌┴┐           ┌┴┐
     4 x 1 KΩ  │ │ ¼ Watt  │ │          │ │           │ │
               └┬┘         └┬┘          └┬┘           └┬┘
3    >──────────┴──> 4 (up) │            │             │
                            │            │             │
6    >──────────────────────┴──> 3 (dwn) │             │
                                         │             │
13   >───────────────────────────────────┴──> 1 (rght) │
                                                       │
11   >─────────────────────────────────────────────────┴──> 2 (lft)
                     ┌────────────────────┐
2    >───────────────┤    47 Ω ¼ Watt     ├───────────────> 6 (fire)
                     └────────────────────┘
4+5+14  >─────────────────────────────────────────────────> 8 (0V)


        4+5+14 betekend: verbind pen 4, 5 en 14 door. Voor pen 1 en 9
        geldt hetzelfde.

           Op deze interface kunnen alle gewone digitale joysticks
        aangesloten worden, met of zonder autofire (dus de joysticks
        die ook op een Kempston Joystickinterface passen, of op een
        Commodore 64/Amiga of Atari). De joysticks die bij de Spectrum
        +2 of +3 horen werken helaas niet, de pen-layout is iets
        anders. Dit is gemakkelijk aan te passen.

           De digitale joystickinterface heeft een analoge PC-joystick-
        interface nodig waarop twee analoge joystick op kunnen worden
        aangesloten (op één plug!). Dit is bij de meeste kaarten wel
        het geval, maar niet altijd (bijvoorbeeld bij sommige multi
        in-out kaarten). Bekijk de documentatie van de kaart om te
        zien of de joystickpoort geschikt is. De joystickpoort van
        een Soundblaster werkt prima. Een analoge joystick werkt in
        principe op elke joystickpoort. Denk er aan dat bij
        aanwezigheid van meerdere joystick-poorten in een PC
        conflicten kunnen optreden. Een van beide moet dan
        uitgeschakeld worden.

           Een aantal pc-spellen gaan moeilijk doen als de digitale
        joystick-interface aangesloten is. Het resultaat is traag
        werkende of vastlopende programma's. Verwijder in dat geval
        de connector van de joystickpoort (en niet alleen de
        joystick!).




4. TECHNISCHE INFORMATIE


4.1 Overzicht hardware kenmerken standaard spectrum

           De Spectrum is qua hardware een zeer eenvoudige machine.
        Afgezien van het echte 'computer' gedeelte, dus de
        microprocessor, de ROM en de RAM, en natuurlijk de (zeer
        simpel gehouden) video logica, is er slechts een cassette
        interface, een bijzonder eenvoudige geluids interface, en
        een toetsenbord interface. Samen vormen deze elementen de
        totale standaard ZX Spectrum!

           De communicatie tussen deze i/o devices verloopt via
        slechts 1 poort, te weten poort 254. (Eigenlijk kunnen deze
        devices via elke even poort bestuurd worden, want ook de
        adresdecoderings logica is erg simpel. Er wordt namelijk
        maar op 1 adreslijn, A0, gedecodeerd)

           Als poort 254 voor output gebruikt wordt, heeft de
        verstuurde byte de volgende betekenis:

        Bit:  7   6   5   4   3   2   1   0
            +---+---+---+---+---+---+---+---+
            |   |   |   | E | M |  border   |
            +---+---+---+---+---+---+---+---+

           De hoogste 3 bits hebben geen betekenis. De laagste drie
        vormen samen de border kleur. Bit 3 geeft de MIC-output aan.
        De emulator maakt geen gebruik van deze bit. Bit 4 geeft de
        output naar de luidspreker aan. Een 1 betekent luidspreker
        aan, een 0 uit.

           Als van poort 254 gelezen wordt, wordt tevens naar de
        hoogste 8 bits van het in-adres gekeken. Een 0 op zo'n
        adreslijn geeft aan welke rij toetsen bekeken moet worden.
        Een 0 op één van de laagste 5 bits van de teruggekregen
        waarde geeft aan in welke kolom van de gevraagde rij een
        toets werd ingedrukt. In de laagste 5 bits staan nullen als
        de corresponderende toets (of een van de corresponderende
        toetsen, als meerdere adreslijnen laag gemaakt zijn)
        ingedrukt zijn. Concreet:

        IN:    Leest toetsen: (van bit 0 tot en met bit 4)

        #FEFE  SHIFT, Z, X, C, V     #EFFE  0, 9, 8, 7, 6
        #FDFE  A, S, D, F, G         #DFFE  P, O, I, U, Y
        #FBFE  Q, W, E, R, T         #BFFE  ENTER, L, K, J, H
        #F7FE  1, 2, 3, 4, 5         #7FFE  SPACE, SYM SHFT, M, N, B

           Dus: Als IN #BFFE de waarde 190 teruggeeft, (binair
        10111110), was de ENTER-toets ingedrukt. Bit 6 geeft bij het
        INnen van poort 254 de waarde van de EAR-ingang aan. Door
        dit bitje ontvangt de Spectrum zijn informatie bij het laden
        van programma's van tape. Bij een Issue-2 Spectrum is de
        waarde van dit bit 1 als er geen signaal op de EAR-ingang
        staat. Vanaf de Issue-3 Spectrum wordt er een andere ULA in
        de Spectrum toegepast, die tot gevolg heeft dat deze bit bij
        geen signaal op 0 staat. Sommige oude programma's gaan er
        vanuit dat als je geen toets indrukt poort 254 de waarde 255
        heeft; deze werken dus niet goed op een Issue-3 Spectrum.
        (Voorbeelden van deze programma's zijn Spinads en
        Scrambler.) Als je optie -2 geeft bij het opstarten emuleert
        de Spectrum Emulator een Issue-2 Spectrum, en werken deze
        programma's ook.

           Het is niet verboden bij het lezen van poort 254 meerdere
        adreslijnen (van de bovenste byte) tegelijk nul te maken. Een
        IN van adres #00FE levert bijvoorbeeld het resultaat van alle
        rijen. Hiermee is snel te kijken of een toets is ingedrukt (De
        laagste 5 bits zijn dan niet allemaal 1).

           Als je een in-operatie uitvoert, en je specificeert een
        niet-bestaand in/out adres, dan vraag je eigenlijk
        informatie op van een 'zwevende' bus. Normaal zou dit de
        waarde 255 terug moeten geven. Dit gebeurt ook vaak, maar
        niet altijd. Naast de Z80 is namelijk ook de ULA constant
        bezig uit het geheugen te lezen. Dit gebeurt parallel met
        de Z80. De ULA en Z80 bussen zijn gescheiden door middel van
        weerstandjes, zodat ze elkaar niet hinderen, maar wel van
        elkaars bus gebruik kunnen maken. Hierdoor kan het gebeuren,
        dat als je van de Z80 bus leest, en niemand zet hier wat op,
        je eigenlijk de ULA-bus uitleest. De ULA leest uit het
        beeldschermgeheugen, dus het INnen van niet-bestaande
        adressen geeft soms beeldscherminformatie (in gelijke
        verhoudingen uit het ATTR- en het bit-mapped gebied).

           Ik nam aan dat geen enkel programma van zoiets vreemds
        gebruik zou maken, maar dat bleek wel zo te zijn. Arkanoid
        leest van poort #FF, en als hij een tijdje alleen 255's
        terugkrijgt, weet het programma dat de ULA bezig is in de
        beeldterugslagtijd. Hiermee wordt het spel gesynchroniseerd
        met de 50 Hz frequentie waarmee het beeld wordt opgebouwd!
        Om Arkanoid goed te laten werken heb ik dit rare gedrag van
        niet-bestaande in-poorten toch maar geëmuleerd. De helft van
        de tijd krijgt het programma op IN's van niet-bestaande
        adressen de waarde 255 terug, en de andere helft een
        willekeurig mix van 255's, attribuutbytes en schermbytes.
        Op deze manier werkt Arkanoid ook op de Emulator goed.


4.2 Overzicht hardware kenmerken Interface 1

           De Interface 1 is eigenlijk veel gecompliceerder dan de
        Spectrum. Ik zal er hier niet uitvoerig op ingaan, en alleen
        de details vermelden die van belang zijn voor de Emulator.
        De Emulator ondersteunt geen Microdrive, en ook het netwerk
        wordt niet ondersteund. Alleen de seriële (RS-232) poort
        wordt geheel geëmuleerd.

           De Interface 1 kent drie i/o poorten, die alledrie als
        input- en als outputkanaal gebruikt worden. De eerste is
        poort #E7, dec. 231. Deze poort wordt gebruikt om data van
        en naar de Microdrive te transporteren. Het lezen van of
        schrijven naar deze poort, terwijl de Microdrive niet draait
        (of draait zonder een (geformatteerde) cartridge erin) leidt
        tot de beruchte 'Interface 1 crash' of 'IN 0 crash' (het
        lezen poort 0 heeft namelijk hetzelfde resultaat). De
        interface 1 blijft dan wachten tot er data van de Microdrive
        komt, en tot die tijd houdt hij de Spectrum stil door de WAIT
        lijn laag (=aktief) te maken. De hele boel loopt dan dus vast,
        en er is alleen met een reset uit te komen. De emulator meldt
        deze crash als een 'IN 0 crash'. Deze poort wordt verder
        niet gebruikt, omdat de Microdrive niet geëmuleerd is.

           De tweede poort van de Interface 1 is poort #EF, dec.
        239. Dit is een zeer belangrijke poort. Via deze poort wordt
        de RS232, Microdrive en het Netwerk gestuurd. De layout van
        deze poort is:

        BIT   7   6    5       4       3       2       1       0
            +---+---+------+-------+-------+-------+-------+-------+
        READ|   |   |      | busy  |  dtr  |  gap  | sync  | write |
            |   |   |      |       |       |       |       | prot. |
            +---+---+------+-------+-------+-------+-------+-------+
        WRITE   |   | wait |  cts  | erase | r/_w  | comms | comms |
            |   |   |      |       |       |       |  clk  | data  |
            +---+---+------+-------+-------+-------+-------+-------+

           De bits DTR en CTS zijn voor de RS232 poort. Deze twee
        bits, DTR en CTS, worden op dit moment gebruikt in de
        emulator. De andere bits zijn voor het functioneren van het
        netwerk en de microdrive. Deze zijn zo geëmuleerd, dat de
        Interface 1 software ziet dat er geen Microdrive aan de
        interface zit. Tenslotte poort #F7:

        BIT      7     6   5   4   3   2   1      0
            +--------+---+---+---+---+---+---+---------+
        READ| txdata |   |   |   |   |   |   |   net   |
            |        |   |   |   |   |   |   |  input  |
            +--------+---+---+---+---+---+---+---------+
            |        |   |   |   |   |   |   |   net   |
        WRITE        |   |   |   |   |   |   | output/ |
            |        |   |   |   |   |   |   | rxdata  |
            +--------+---+---+---+---+---+---+---------+

           Zoals gezegd bepaalt COMMS DATA de functie van bit 0
        output. Net output en input worden niet gebruikt in de
        Emulator; TXDATA en RXDATA echter wel. De Emulator
        'onderschept' elke OUT naar poort #F7, en bouwt intern de te
        versturen byte op. Bij elke IN van poort #F7 gebeurt precies
        het tegenovergestelde. De Emulator heeft de byte, en geeft
        het bit voor bit door aan het geëmuleerde Spectrumprogramma
        via poort #F7.


4.3 Overzicht hardware kenmerken SamRam

           De SamRam is een vrij eenvoudig apparaat. Naast een 32K
        statische CMOS RAM zit er alleen wat adresdecoderings en
        in/out logica, en een NMI aanstuur schakelingetje in. De
        communicatie met de SamRam gaat via poort 31. Als van deze
        poort gelezen wordt, geeft de SamRam de stand van de
        joystick terug. Dit komt overeen met het gewone Kempston
        joystick protocol, die ook op poort 31 zit. Als naar deze
        poort geschreven wordt, ligt de zaak wat ingewikkelder.
        De informatie wordt dan aangeboden aan een 74ls259 chip,
        een 'programmable latch'. De poortlayout is als volgt:

        BIT   7   6   5   4   3   2   1   0
            +---+---+---+---+---+---+---+---+
        WRITE   |   |   |   |   adres   |bit|
            +---+---+---+---+---+---+---+---+

           Met 'adres' wordt 1 van de acht uitgangen van de 74ls259
        aangegeven. De waarde van 'bit' geeft de nieuwe waarde van
        de gespecificeerde uitgang aan. De acht uitgangen hebben
        allemaal een verschillende functie. In onderstaande tabel
        staan de uitgangen, bijbehorende OUT-waarden en het
        resultaat:

        OUT 31,   | UITGANG | RESULTAAT
        ----------+---------+---------------------------------------
            0     |    0    | Write protect CMOS RAM aan
            1     |    "    | Schrijven in CMOS RAM toegestaan
            2     |    1    | CMOS RAM aan (voor bank, zie 6/7)
            3     |    "    | CMOS RAM uit (standaard spectrum)
            4     |    2    | -
            5     |    "    | Maak '259 inaktief, reageert niet meer
            6     |    3    | CMOS bank 0 inschakelen (standaard 'ROM')
            7     |    "    | CMOS bank 1 inschakelen (schaduw 'SamRom')
            8     |    4    | Schakel interface 1 aan
            9     |    "    | Schakel interface 1 uit
           10     |    5    | Schakel ram bank 0 in (32768-65535)
           11     |    "    | Schakel ram bank 1 in (32768-65535)
           12     |    6    | Bieper uit
           13     |    "    | Bieper aan
           14     |    7    | -
           15     |    "    | -

           De standaardwaarden bij aanschakelen, na een RESET en na
        een NMI zijn de even waarden. Alle uitgangen zijn dus
        inaktief, of laag. (Dus: Write protect aan, CMOS RAM aan,
        etc.)

           In mijn originele SamRam is voor een schrijfoperatie in
        de CMOS RAM ook nog het omzetten van een schakelaartje
        nodig. Dit om te voorkomen dat de inhoud door een crash
        verloren gaat. Bij de Emulator is het sowieso onmogelijk te
        schrijven in de ROM, zodat een OUT 31,1 geen effect heeft.

           Uitgang 1 spreekt voor zich; het *SPECTRUM commando doet
        een OUT 31,3 om de standaard Spectrum in te schakelen. Druk
        na zo'n commando op NMI om terug te keren naar de SamRam, of
        tik OUT 31,2 in.

           Uitgang 3 is een buitenbeentje. Een OUT 31,5 zorgt
        ervoor dat de Chip Select lijn van de '259 nooit meer aktief
        kan worden. Hierdoor worden alle OUT operaties onmogelijk.
        Alleen een reset kan de '259 weer normaal krijgen. Een OUT
        31,4 heeft dus nooit effect: Of uitgang 3 was al laag, en
        dan was OUT 31,4 niet nodig, of uitgang 3 is hoog, en dan
        komt de OUT 31,4 nooit bij de chip aan.

           Uitgang 4 wordt door de SamRam software nooit gebruikt.
        Een OUT 31,9 zorgt er voor (in mijn echte Spectrum) dat de
        interface 1 nooit een M1 signaal te zien krijgt. Dit signaal
        gebruikt de interface 1 om te zien of hij zich in moet
        schakelen. Dit gebeurt dan dus niet meer.

            Uitgang 5 is simpel: deze schakelt de bovenste 32K
        dynamische rambank om. Zorg er bij het experimenteren met
        deze OUT-waarden wel voor dat de stack in de onderste 16K
        zit (van ongeveer 25000 tot 32767 zijn mogelijke waarden),
        anders is er na de OUT opeens de stack weg, wat niet
        bevorderlijk is voor het correct functioneren van de
        Spectrum.


4.4 Interne opbouw van de Emulator

        Hieronder de geheugenindeling van de Emulator in werking:

             +--------+
             |        |     Het hoofdmenu van de Emulator, en onder-
             |   C    |     steunende routines
             |  prog  |
             |        |
             +--------+
             |        |     Het hoofdprogramma. Vanuit hier wordt de
             |        |     Emulator opgestart. Hier zitten ook de
             |  Main  |     video, de interrupt, de disk i/o en een
             |        |     groot deel van de Z80 IN/OUT emulatie
             |        |     routines.
             |        |
             +--------+
             | stack  |     1K
             +--------+
             |        |
             |   E    |     De Z80 emulator. Het is een brij van
             |   M    |     een heleboel korte routinetjes, met
             |   U    |     heel veel vrije tussenruimte. Dit is
             |   L    |     vooral met het oog op de snelheid
             |   A    |     gedaan. (Vergeleken met de 'compacte'
             |   T    |     versie is deze 2x zo snel!) Op disk
             |   O    |     neemt dit deel 22K in beslag.
             |   R    |     64K
             |        |
             +--------+
             |        |     De standaard Spectrum ROM. Deze zit
             |        |     ingebouwd in de Emulator; de andere
             |  ROM   |     ROMs worden eventueel ingeladen.
             |        |
             |        |
             +--------+     Tot hier zat alles in Z80.EXE. Hier-
                            onder is het gewoon gealloceerd RAM.
             +--------+
             |        |
             | extra  |     Hier zitten de 2 banken van de CMOS
             | ROMs   |     SamRam ROM, en de 8K interface 1 ROM.
             |        |     40K (de file ROMS.BIN) (Alleen als de
             |        |     if.1 en/of SamRam opgestart zijn)
             +--------+
             | scherm |     Hiermee kan gekeken worden of er ver-
             | buffer |     anderingen zijn in het scherm. 8K
             +--------+
             |        |
             | 32K    |     Hier wordt de inhoud van de niet-
             | dyn.   |     aktieve 32K Ram-bank in opgeslagen
             | RAM-   |     (alleen als SamRam opgestart is)
             | bank   |     32K
             |        |
             +--------+
             |        |
             |        |     Dit is het domein van de Z80 emu-
             |Spectrum|     lator. De eerste 16K is 'ROM',
             |segment |     daarna is 6912 bytes 'scherm'
             |        |     en daarna ongeveer 40K vrije
             |        |     RAM.
             |        |     64K
             +--------+


4.5 De werking van de Emulator

           De 8088/8086 instructieset is een uitbreiding op de 8080
        set. Deze laatste stond ook model bij het ontwerp van de
        Z80. Bijna alle Z80 instructies hebben een equivalent in de
        8088/8086 instructieset. Hierdoor waren er wat de
        instructieset betrof vrij weinig kunstgrepen nodig bij het
        maken van de Emulator. De laagste 8 bits van de 8086 flags
        komen (bijna) overeen met de flagbits van de Z80. Ook hier
        waren dus weinig tijdvretende conversies nodig.

            Er waren echter ook uitzonderingen. De DAA (Decimal
        Adjust Accumulator) instructie heeft bijvoorbeeld geen
        evenbeeld bij de 8088/86. De Z80 houdt zelf bij of er een
        conversie voor optellen dan wel aftrekken nodig is; de 8088
        doet dit niet en kent dus verschillende instructies voor
        deze operaties: DAA en DAS, Decimal Adjust after Addition
        en Decimal Adjust after Substraction. Na elke optel of
        aftrek instructie zet de Z80 een flagje. Dit zou de Emulator
        ook moeten doen dus. Deze flag is echter alleen van
        praktische betekenis als het optellen of aftrekken betrekking
        had op de accumulator (het A register). In alle andere
        gevallen zet de Emulator dit flagje dus niet. Dit scheelt
        weer flink in snelheid, en tot nu toe werken alle programma's
        die ik heb geprobeerd naar behoren.

           Ook de overflow flag heeft bij de 8088/8086 een aparte
        plaats gekregen, in de hoge byte van het flagregister. Bij
        de Z80 heeft 1 flag 2 functies, namelijk de
        Pariteit/Overflow flag. De flag op deze plaats bij de
        8088/8086 heeft alleen de Pariteit functie. De overflow flag
        moet dus na elke berekening in de pariteitsflag gezet
        worden. Dit kost helaas wat tijd, maar is onvermijdelijk.

          In Sabre Wulf heb ik een programmeerfout, en een Z80
        rariteit, ontdekt tijdens het debuggen van de Emulator. Het
        bleek dat de buffel, die in de gang boven de startgrot heen
        en weer zou moeten lopen, in een hoekje bleef staan en zich
        telkens omkeerde. De fout bleek te zitten in de volgende
        instructies in Sabre Wulf:

                AD86    DD CB 06 7E        BIT 7,(IX+6)
                AD89    F2 8F AD           JP P,#AD8F

        Een programmeerfoutje van Ultimate! In de tweede regel is
        natuurlijk een JR Z bedoeld, het doet hetzelfde en het is
        korter. Het boek van Rodnay Zaks, Programming the Z80, zegt
        dat de BIT instructie de P flag op een ongedefiniëerde
        waarde zet. Blijkbaar zet de BIT-instructie de P flag naar
        gelang bit 7 van het argument! Dat is de reden dat
        bovenstaande constructie werkt.

           De meeste Z80 registers zitten tijdens de uitvoering in
        de 8088 registers: in AL, CX, DX, SI, DI en BP zitten
        respectievelijk de Z80 register A, BC, HL, DE, PC en SP. De
        flags zitten in AH. De overige registers, I, R, IX, IY en
        de 'exchanged registers' AF', BC', DE' en HL' worden gewoon
        als geheugenvariabelen opgeslagen.

           Het BX register, waar logischerwijs DE zou moeten zitten,
        wordt gebruikt om de jumpvector naar de nieuwe instructie te
        berekenen. Hiervoor gebruik ik de volgende drie instructies:

           MOV BH,[DI]          ;Haal opcode in BH
           XOR BL,BL            ;Maak BL leeg
           JMP BX               ;Spring naar emulatieroutine

           Het zal nu duidelijk zijn dat de emulator een volledig
        64K segment nodig heeft, en dat het daar maar een deel van
        gebruikt. De benodigde 'INC DI' om de program counter (PC)
        op te hogen zit aan het begin van de emulatieroutine. Dit is
        gedaan om nog een kleine snelheidswinst te behalen: soms is
        deze 'INC DI' namelijk niet nodig, denk aan de return (RET)
        instructie.

           Het R register van de Spectrum Emulator werkt normaal als
        een random-generator. Zo wordt dit register ook meestal
        gebruikt. In feite doet de Z80 het volgende: bij elke
        instructie wordt het R register met 1 verhoogd. Bij
        instructies die met een 'shift' beginnen, dat wil zeggen met
        DD, FD, CB of ED, wordt het R register met twee verhoogd. En,
        verrassing: bij DDCB en FDCB instructies wordt het R register
        ook met twee verhoogd! De onofficiële NOP-instructie DD00
        verhoogt het R register met twee; de instructie DDDD00
        verhoogt het met drie, enzovoorts. Een LDI verhoogt R met
        twee, en een LDIR verhoogt R met 2 x BC, net zoals een LDDR
        enzovoorts. En om het verhaal compleet te maken: een LD R,A /
        LD A,R achter elkaar heeft hetzelfde effect als A met twee
        ophogen (afgezien van de verandering van het R register, en
        afgezien van het feit dat het met-één-ophogen alleen betrekking
        heeft op de laagste 7 bits; bit 8 van het R register verandert
        nooit. Dit heeft te maken met de opbouw van de tijdens de
        ontwikkeling van de Z80 gangbare geheugenchips die 128 x 128 =
        16 Kbit konden onthouden en [dus] een refreshcyclus ter lengte
        128 kenden). Deze functionaliteit heeft de Emulator ook als de
        R register emulatie aanstaat; dit is belangrijk voor beveiligde
        programma's.

           De Z80 kent, net als de 8088, interrupts. Bij de Spectrum
        wordt er 50 keer per seconde een interrupt gegeven. De
        interrupts zijn dus niet programmeerbaar, zoals bij PC's het
        geval is. Het zou erg veel tijd kosten als de Emulator na
        iedere instructie zou moeten controleren of er een interrupt
        uitgevoerd moet worden. Dit levert per Z80 instructie twee
        8088 instructies extra op, wat flink zou vertragen. Dit
        gebeurt dus niet: de Z80 emulator trekt zich nergens wat van
        aan, en sjeest lekker door. Maar natuurlijk moeten
        interrupts wel geëmuleerd worden! Dit wordt op de volgende
        manier opgelost.

           De beeldscherm emulatie van de Spectrum Emulator is
        (8088)-interrupt gestuurd. Nadat het beeldscherm is
        opgebouwd, wordt de 8088 in Debug mode gezet, en wordt de
        Z80-emulator gesinglestept, net zolang totdat het einde van
        de Z80 instructie is bereikt. Dan zorgt de interrupt routine
        ervoor dat de Z80 interrupt gegenereerd wordt (of een reset,
        of een NMI, indien nodig). Op deze manier kent de
        geëmuleerde Z80 toch interrupts, hoewel de Z80 emulator hier
        niet veel tijd aan kwijt is.

           Het opbouwen van het beeldscherm op de echte Spectrum
        gebeurt met een frequente van 50 Hz. Het opbouwen zelf heeft
        ook tijd nodig, ongeveer 1/100 seconde. Bij de Spectrum
        Emulator gebeurt het anders: 50 keer per seconde (effectief)
        wordt er een 'snapshot' van het beeldschermgeheugen gemaakt,
        en afgebeeld. Dit subtiele verschil is voor sommige
        programma's belangrijk: sommige spellen bouwen het
        beeldscherm synchroon met de 50 Hz interrupt op, zodat ze
        bijvoorbeeld de sprites periodiek kunnen wissen en opnieuw
        kunnen tekenen, terwijl het wissen gebeurt in de tijd dat het
        beeldscherm niet 'langskomt'. Voor deze spellen is de fase
        tussen de Z80 interrupt en het opbouwen van het beeldscherm
        belangrijk. Omdat de echte Spectrum en de Spectrum Emulator
        het beeldscherm anders afbeelden is er geen eenduidig juiste
        oplossing voor deze fase. Sommige spellen hebben een iets
        andere fase nodig dan andere, bijvoorbeeld BC's Quest for
        Tires werkt alleen goed met de standaard fase, terwijl
        Ghosts & Goblins alleen goed werkt als het beeldscherm iets
        later na de Z80-interrupt afgebeeld wordt.

           Deze fase kan worden veranderd met de opties -yl en -yh.
         Met -yl, 'Lage Video Synchronisatie', komt de
         beeldschermopbouw iets later na de Z80-interrupt, en met
         Hoge Video Synchronisatie komt hij iets eerder.


4.6 Onofficiële en extra instructies

           De Z80 kent een heleboel onofficiële instructies:
        instructies die je op een bepaalde plaats, vanwege de
        regelmaat, zou verwachten, maar waarvan niet is opgegeven
        dat ze daar ook werkelijk zitten, omdat er een andere
        (meestal kortere) variant is, die precies hetzelfde doet.
        Een voorbeeld van dit soort onofficiële instructies is de
        instructie

        ED 6B n n               LD HL,(nn)

           Deze instructie werkt prima, maar wordt niet gebruikt
        omdat er een variant is, namelijk

        2A n n                  LD HL,(nn)

           Ik kan zo snel geen voordeel van de eerste instructie
        bedenken, maar voor de zekerheid heb ik hem toch maar
        geëmuleerd.

           Een tweede, belangrijker soort onofficiële instructies
        vormen die, die een operatie uitvoeren op alleen de bovenste
        of de onderste helft van een indexregister. Een voorbeeld is

        DD 44                   LD B,IXh

           Met deze instructie wordt het hoogste deel van het IX
        register gekopieerd naar het B register. De logica achter
        deze onofficiële instructies komt naar voren, als je bedenkt
        wat de normale betekenis is van opcode 44:

        44                      LD B,H

           De opcode DD is dus alleen een shift instructie: Na DD
        wordt het H register geïnterpreteerd als IXh, het L register
        als IXl, het HL registerpaar als IX en (HL) als (IX+d),
        waarbij d een 8 bit verplaatsing (met teken) aangeeft. (Behalve
        overigens bij JP (HL), wat gewoon JP (IX) wordt. Een logischer
        mnemonic zou ook JP HL geweest zijn.) Iets dergelijks geldt
        voor de FD opcode, die hetzelfde effect heeft als de DD opcode
        alleen dan voor het IY indexregister.

           Verder zijn er nog 8 onofficiële CB-instructies, nl. CB30
        tot en met CB37, b.v.

        CB 30                   SLL B           ;Shift Left Logical

        Deze instructie voert een gewone shift naar links uit, met bit
        7 naar de Carry, zoals gebruikelijk. Het ongebruikelijke zit
        in bit 0: deze wordt altijd 1! Vanaf versie 1.25 zijn deze 8
        instructies goed geëmuleerd: Bounder en Enduro Racer maken er
        gebruik van.

           Hoewel ZiLOG deze soort onofficiële instructies niet
        ondersteunt, blijken ze op alle Z80's te werken. Machinetaal
        programma's op de Spectrum maken dan ook veel gebruik van
        deze instructies. Het was dan ook belangrijk dat deze
        instructies goed geëmuleerd zouden worden. Hier heb ik veel
        tijd en moeite in gestoken, en ik heb nu alle gebruikelijke
        onofficiële instructies geëmuleerd. Mocht iemand meer
        vreemde onofficiële instructies kennen, laat mij het dan
        weten, dan bouw ik ze alsnog in!

           De overige onofficiële instructies, zoals ED 00 en andere
        niet-bestaande ED-instructies, doen gewoon niets. Dit zou
        wel eens anders kunnen zijn dan de Z80 doet, maar ik weet
        hier gewoon te weinig vanaf. Ik ben trouwens ook nog nooit
        een programma tegengekomen dat gebruik maakte van deze
        niet-bestaande ED-instructies. Mocht iemand echter
        interessante onofficiële ED-instructies kennen, dan hoor ik
        dat graag.

           De Emulator kent ook een aantal opcodes, die op een
        gewone Z80 geen effect hebben. Deze heb ik ingebouwd om
        bepaalde speciale zaken te regelen, zoals communicatie met
        de 'buitenwereld' etc. De opcodes zijn:

        ED F9           FastPrint
        ED FA           LD A,RAMBANK:(HL)
        ED FB           LD RAMBANK:(HL),A
        ED FC           GET RS232 byte
        ED FD           SEND RS232 byte
        ED FE           LD ACTIVE_ROM:(HL),A
        ED FF           Keer terug naar DOS

           De extra opcodes zijn vooral bedoeld om de SamRam te
        versnellen. Voor sommige dingen moest er vaak een rambank
        omgeschakeld worden. Dit is op de gewone Spectrum een kwestie
        van microseconden, op de geëmuleerde Spectrum moeten hele
        lappen geheugen verschoven worden. Zo moest voor elk karakter
        dat de SamRam op het scherm zette, de ROM twee maal
        omgeschakeld worden. Door opcode ED F9 hoeft dit niet meer.

           Opcode ED F9 is equivalent aan de Z80 instructies
                LD A,(DE)
                LD (HL),A
                INC E
                INC H
        met dien verstande dat de eerste instructie zijn informatie
        haalt uit de standaard SamRam ROM, dus de ROM waar de
        karakterset zit opgeslagen, en niet de op dat moment aktieve
        ROM.

           Met opcodes ED FA en ED FB kan snel een byte in de op dat
        moment niet-aktieve 32K dynamische RAM-bank gelezen of
        geschreven worden. Hiervoor waren anders twee omschakelingen
        van de 32K Rambanken nodig, iets dat erg veel tijd nam.

           De opcodes ED FC en ED FD staan in de interface 1 ROM.
        Met deze opcodes is de gegevensoverdracht over de
        geëmuleerde RS232 poort veel sneller; anders duurde het vele
        tientallen OUT's per verstuurde byte, nu gaat het in 1 in-
        structie. Deze veranderingen zijn de enige die ik in de twee
        standaard ROM's heb gemaakt. In de standaard Spectrum ROM is
        helemaal niets veranderd, in de interface 1 ROM dus alleen
        deze twee dingen. Onderaan dit hoofdstuk staan de precieze
        veranderingen.

           Met opcode ED FE kan een byte in de dan aktieve ROM
        veranderd worden. De verandering is semi-permanent, dat wil
        zeggen dat de verandering stand houdt, maar niet wordt
        weggeschreven in de file ROMS.BIN. Een volgende keer is de
        verandering dus verdwenen.

           De laatste opcode, ED FF, wordt nooit gebruikt. Ik heb
        hem helemaal in het begin toegevoegd voor het debuggen, en
        ik heb hem voor de grap maar laten zitten. Je kunt de
        Emulator dus verlaten door in Spectrum BASIC in te
        tikken:

        POKE 40000,237:POKE 40001,255:RANDOMIZE USR 40000

        Veranderingen in de Interface 1 ROM:

        ADRES: OUD: NIEUW:           ADRES: OUD: NIEUW:

        0B9E   ED   ED               0D2A   37   ED
        0B9F   5B   FC               0D2B   F3   FD
        0BA0   C3   F5               0D2C   CE   18
        0BA1   5C   C3               0D2D   00   10
        0BA2   21   34
        0BA3   20   0C               0D4C   FB   00

        0D20   FB   00


4.7 Beveiligingsmethoden op de Spectrum

           Ook voor de Spectrum zijn, om de kopieerwoede van de
        gebruikers wat tegen te gaan, door de jaren heen
        verscheidene beveiligingsmethoden ontwikkeld. Het begon
        allemaal met de bekende Horace-spelletjes, die met een
        simpele POKE 23659,0 waren 'beveiligd'. Hier was simpel
        omheen te komen door het programma niet met LOAD "", maar
        met MERGE "" in te laden. Het laatste commando doet het
        BASIC-programma namelijk niet automatisch starten.

           Daarna kwamen de programma's die alleen met LOAD waren in
        te laden, en niet met MERGE. Ook hier was omheen te komen.

           Tenslotte, (en nu sla ik enkele jaren over) kwamen de
        snelladers, met als hoogtepunt SPEEDLOCK, samen met
        LENSLOCK. Dit waren ingenieuze vondsten, die zeer moeilijk
        te kraken waren (op de conventionele manier, wel te
        verstaan). Het kostte mij weken om SPEEDLOCK te kraken. Nu
        met de SamRam zou het een kwestie van minuten zijn.

           Om SPEEDLOCK te gebruiken op de Emulator, moet je de -r
        en de -l optie gebruiken. De -r optie zorgt ervoor dat na
        elke instructie het R-register met 1 verhoogd wordt. Dit
        doet de Z80 ook, maar wordt eigenlijk nooit gebruikt, alleen
        soms voor een simpele willekeurige-getallen-generator. Als
        je de -r optie niet gebruikt, wordt de inhoud van het R-
        register bij de Emulator bepaald door een eenvoudige random-
        generator.

           De -l optie zorgt ervoor dat een LDIR of LDDR instructie
        niet ineens wordt afgeraffeld. De instructie wordt nu stapje
        voor stapje gedaan, precies zoals de Z80 het zelf ook doet.
        Als de LDIR-instructie zichzelf nu overschrijft, doet de
        Emulator precies hetzelfde als de Z80. Je moet er maar op
        komen! SPEEDLOCK maakte gebruik van deze mogelijkheid,
        waarschijnlijk om krakers zand in de ogen te strooien.


4.8 Tips en Truuks

        - Het bekijken van de SamRam ROM

          Druk op NMI (=F9), druk op 'D' (=disassembler), en typ
        '$'. Je ziet nu de eerste bladzijde van de SamRam ROM. Voor
        verdere uitleg over de disassembler, zie hoofdstuk 2.7.

        - Het bekijken van de Shadow SamRam ROM

          Typ in Spectrum BASIC in: *SAVE 0,32768,16384. Ga naar de
        disassembler, typ 'M:8000', en '$'.

        - Het bekijken van de Interface 1 ROM

          Ga naar de disassembler. Typ 'M:5B00' en 'I'. Je kunt nu
        data invoeren. Typ de volgende hexbytes in, na elke byte op
        Enter drukken:

                F3 21 0C 5B E5 21 00 00 E5 C3 08 00 21 00 00
                11 00 80 01 00 40 ED B0 CD 00 07 FB C9

        Typ weer 'M:5B00' en '$' om de code te bekijken. Druk weer
        op '$', en dan op EDIT (=Shift 1) of ESC om naar het
        hoofdmenu te gaan. Druk op 'E', en typ in Spectrum BASIC in:
                RANDOMIZE USR 23296
           De interface 1 ROM staat nu op adres 32768, hex 8000,
        klaar om bekeken te worden.

        - Het 'vangen' van schermpjes met de SamRam software

           Druk op NMI (F9) zodra het schermpje dat je wil vangen
        zichtbaar is. Druk op '2', en dan op '1' (Sla scherm 1 op).
        Druk nogmaals op F9, of op ALT-F9 (reset). Tik in Spectrum
        BASIC in:

                CLEAR 32000:OUT 31,11:*move 51200,16384,6912

           Het schermpje wordt nu verplaatst van adres 51200 in de
        2e rambank naar het beeldschermgeheugen. Typ OUT 31,10 om de
        gewone bank weer in te schakelen.

           Schermpjes kunnen worden omgezet in .GIF bestanden. Dit
        is beschreven in hoofdstuk 2. Als je een Spectrum-schermpje om
        wil zetten in GIF-formaat kan dat ook eenvoudiger: de utility
        CONVERT is in staat om het schermpje in een .Z80 bestand te
        vertalen in een .GIF bestand. Het enige dat je hoeft te doen is
        dus het Spectrum-programma op het juiste moment te stoppen en
        weg te schrijven (en je registreren om de utility CONVERT te
        krijgen!)


4.9 Struktuur van een .Z80 programmabestand

           Alle informatie van een lopend Spectrum programma kan
        worden opgeslagen in een .Z80 bestand. Een volgende keer kan
        dit bestand dan weer worden ingeladen, en kan vanaf dat punt
        worden verdergegaan.

           Zo'n .Z80 bestand bestaat uit informatie over de
        registers, en andere 'omgevingsvariabelen', en 48K Spectrum
        geheugen. De data in het Spectrum geheugen wordt een beetje
        verkort opgeslagen: herhalingen van 1 bytewaarde worden met
        een code opgeslagen.

        Offset: Lengte: Omschrijving:

        0       1       A register
        1       1       F register
        2       2       BC register paar (LSB, dus C, eerst)
        4       2       HL register paar
        6       2       Program counter
        8       2       Stack pointer
        10      1       Interrupt register
        11      1       Refresh register (Bit 7 geen betekenis)
        12      1       Bit 0  : Bit 7 van het R register
                        Bit 1-3: Border kleur
                        Bit 4  : 1=SamRom ingeschakeld
                        Bit 5  : 1=Datablok verkort opgeslagen
                        Bit 6-7: Geen betekenis
        13      2       DE register paar
        15      2       BC' register paar
        17      2       DE' register paar
        19      2       HL' register paar
        21      1       A' register
        22      1       F' register
        23      2       IY register
        25      2       IX register
        27      1       Interrupt flipflop, 0=DI, anders EI
        28      1       IFF2
        29      1       Bit 0-1: Interrupt mode (0, 1 of 2)
                        Bit 2  : 1=Issue 2 emulatie
                        Bit 3  : 1=Dubbele interruptsnelheid
                        Bit 4-5: 1=Hoge video synchronisatie
                                 3=Lage video synchronisatie
                                 0,2=Normaal
                        Bit 6-7: 0=Cursor/Protek/AGF joystick
                                 1=Kempston joystick
                                 2=Sinclair 1 joystick
                                 3=Sinclair 2 joystick


           Voor de eerste sharewareversie gebruikte ik een formaat
        voor de .Z80 bestanden waarin het datablok niet verkort werd.
        Het .Z80 bestand was dus altijd precies 49182 bytes lang. De
        flagbyte 12 had altijd de waarde 0 of 255, en omdat de utility
        SAVESPEC.BAS nog altijd zo'n soort .Z80 bestand produceert kan
        ook versie 1.40 nog overweg met dit formaat. Dus: als byte 12
        nul of 255 is, is het datablok NIET verkort opgeslagen (en
        moet de flagbyte als effectief 1 gelezen worden, dat wil
        zeggen bit 7 van R is 1, border 0, etc.)

           Tot versie 1.30 zat er in byte 29 altijd een 0, 1 of 2.
        Vanaf versie 1.40 hebben bits 2-7 ook betekenis gekregen.
        Omdat ze in de vorige versies altijd de waarde nul hadden,
        zijn .Z80 bestanden die met de oude versie bewaard zijn ook
        goed te gebruiken in versie 1.40 van de Emulator.

           Na het 30-byte blokje volgt het werkelijke codeblok. Als
        het rijtje "ED ED xx yy" in de code voorkomt, met xx en yy
        willekeurige waarden, wordt dit omgezet in xx keer de byte
        yy. Dus:

                ED 00 44 ED ED 05 00 02

        wordt terugvertaald in:

                ED 00 44 00 00 00 00 00 02

           Als er in de originele file al rijtjes ED ED voorkomen,
        worden deze omgezet in ED ED 02 ED, in overeenstemming met
        bovenstaande interpretatie. Ook moet er worden gelet op
        rijtjes als

                ED 00 00 00 00 00 00 88 ...

        die zonder speciale behandeling vertaald zou worden in

                ED ED ED 06 00 88 ...

        wat bij terugvertaling iets heel verkeerds zou opleveren.
        Routines voor dit eenvoudige codeer- en decodeer algoritme
        zijn te vinden in de sourcefiles DISCIPLE.C, CONVZ80.8 en
        MISC.8.


4.10 De sourcecode van de Spectrum Emulator

           De sourcecode is niet bij het shareware-pakket
        bijgeleverd, omdat het het pakket erg groot zou maken, en
        omdat er (helaas) veel mensen zijn die er toch niet in
        geïnteresseerd zijn. Omdat ik het zelf wel altijd leuk vind
        om de source van een mooi programma te kunnen bekijken vind
        ik het wel zo netjes om anderen nu ook een blik in mijn
        keuken te gunnen. Daarom krijgen geregistreerde gebruikers
        de sourcecode opgestuurd. In deze paragraaf wil ik uitleggen
        wat globaal de functies zijn van de routines in de veertien
        verschillende sourcefiles.

           De Spectrum Emulator is bijna helemaal geschreven in
        assembleertaal. Hiervoor heb ik de shareware-assembler A86
        gebruikt. Deze is niet compatibel met de Microsoft
        assembler: de macro-taal wijkt vooral nogal af, en er zijn
        in A86 handige afkortingen ingebouwd die in MASM niet
        aanwezig zijn. Meestal kan hiervoor wel een macro geschreven
        worden, maar soms niet.

           De segment-opbouw van de Emulator is als volgt: eerst
        komen de segmenten XTRA_TEXT, _DATA en _BSS die bij de
        C-sourcefile xtra.c horen, dan komt het segment STARTUP
        waarin alle code zit dit niet bij xtra.c of de z80-emulator
        horen, vervolgens het segment EMULATOR waarin de
        z80-emulator zit, en tenslotte EDOC waarin de Spectrum-ROM
        zit.

           De routines in xtra.c zorgen voor de communicatie met de
        gebruiker, via het hoofdmenu. Er zit weinig interessante
        code bij, eigenlijk. De ingang bestaat uit de routine ENTRY,
        die aangeroepen wordt vanuit de assemblyroutines. De routine
        ENTRY krijgt bij aanroep als parameter een 'aktie-code' die
        vertelt wat de reden van de aanroep is: een druk op F10
        of een DI/HALT crash bijvoorbeeld.

           In de file z80.8 zijn de meeste geheugenvariabelen
        gedeclareerd. De opstartroutine zit hierin, die nogal veel
        te doen heeft en dus ook redelijk wat ruimte inneemt. Hierna
        komen nog wat kleine routinetjes, en ten slotte zit hierin
        de routine die het bestand Z80.EXE bij de eerste keer
        opstarten inpakt.

           De kleine routinetjes die eerst allemaal in z80.8 zaten,
        maar er later uit moesten omdat A86 alleen sourcefiles tot
        64K aankan, zitten nu in de file misc.8. De RS232-emulatie
        routines zitten hier, de routines voor het inpakken van .Z80
        bestanden, de toetsenbord-afhandeling en de code voor het
        maken van het introscherm.

           De videoroutines zitten zoals te verwachten was in de
        file video.8. Het eerste blok routines zorgt voor de
        herkenning van de verschillende videokaarten en de
        initialisatie daarvan, en wordt 'bestuurd' door de routine
        INIT_VIDEO. Daarna volgt het blok routines die voor de
        werkelijke video-emulatie van het Spectrum-beeldscherm
        zorgen, en die begint met de routine VIDEO_UPDATE. Deze
        routine kijkt of er veranderingen zijn opgetreden sinds de
        laatste bijwerking door het huidige beeldschermgeheugen te
        vergelijken met een 'schaduw'-schermgeheugen, en als die er
        zijn wordt deze op het beeldscherm gezet. Deze routines zijn
        geoptimaliseerd op snelheid en niet op grootte, vandaar dat
        er nogal wat routines zijn die erg op elkaar lijken. De
        video-routines maken, ook weer met het oog op snelheid,
        gebruik van grote tabellen om eenvoudige maar tijdrovende
        bit-manipulaties snel te kunnen uitvoeren. Deze tabellen
        zitten in de file vidtab.8.

           De routines om met de C procedures te kunnen samenwerken
        zitten in het bestand cif.8 (C-interface). De eerste
        belangrijke routine in dit bestand, ENTER_C, zorgt ervoor
        dat de gewone DOS-omgeving weer in ere wordt hersteld (alle
        omgeleide vectoren, zoals bijvoorbeeld van het toetsenbord
        en de timer worden teruggezet) en roept de routine _ENTRY
        aan, en initialiseert tenslotte alle vectoren weer voor de
        emulator. Daarna komen een groot aantal routines die door
        het C programma gebruikt worden, zoals het lezen van het
        toetsenbord, het printen op het beeldscherm, het werken
        met de diskdrive en ander klein grut. Meestal zijn ze vrij
        kort: ze bestaan uit een aanroep van een DOS-functie of een
        functie die al in een andere assembly-file is gedefinieerd.

           In de file tables.8 zitten wat tabellen voor de
        z80-emulator en de toetsenbord routine. Niet erg
        interessant, dus ik zal er niet teveel woorden aan vuil
        maken.

           Verder met de interessantere bronbestanden: die van de
        z80-emulator. De complete z80-emulator wordt gevormd door de
        bestanden emul.8, ddfd.8, dd.8, fd.8, cb.8 en ed.8.
           In de eerste zitten om te beginnen enkele macro's,
        waarvan JX de belangrijkste is. Deze macro staat aan het
        eind van elke stukje code dat een Z80-instructie emuleert.
        De macro is een afkorting voor de instructies MOV BH,[DI] /
        XOR BL,BL / JMP BX, en vervolgens vijf NOP's. Deze
        instructies halen de volgende Z80 opcode op, en springen
        naar de juiste emulatie-routine. De vijf NOP's zijn bedoeld
        om ruimte open te houden voor het invoegen van de instructie
        INC BYTE ES:[RR], waarbij RR staat voor de geheugenplaats
        waar de waarde van het R-register is opgeslagen.
           De rest van de file emul.8 bestaat uit emulatieroutines
        voor de gewone z80-opcodes, dus alle behalve de opcodes die
        beginnen met DD, FD, ED of CB.

           In de files dd.8 en fd.8 zitten de routines voor de
        z80-instructies met een dd- of fd-prefix. Alleen voor de
        instructies die iets met het H, L of HL register doen heeft
        de DD of FD prefix effect. Doet een instructie niets met
        deze registers dan heeft de prefix geen invloed.
        Bijvoorbeeld 00 is NOP, maar DD 00 is ook NOP, en DD DD 00
        ook. Daarom zijn in deze file ook alle instructies die niets
        met het H/L register doen ongewijzigd uit emul.8
        overgenomen.

           De emulatie-routines voor instructies met een CB-prefix
        zitten natuurlijk in cb.8. Dit is een vreselijk saaie file,
        omdat de instructies met een CB-prefix zo op elkaar lijken.
        De routines voor instructies met een DDCB of FDCB prefix
        tenslotte zitten in ddfd.8.


<*** Einde Z80.Doc ***>