HOGESCHOOL ROTTERDAM I N S T I T U U T V O O R C O M M U N I C A T I E, M E D I A E N I N F O R M A T I E T E C H N O L O G I E C M I

Transcriptie

1 HOGESCHOOL ROTTERDAM I N S T I T U U T V O O R C O M M U N I C A T I E, M E D I A E N I N F O R M A T I E T E C H N O L O G I E C M I Practicumhandleiding Computersystemen 1 Auteur C. Stolk Download van: het zip bestand TIRCPS01 Dit bestand bevat alles wat nodig is voor dit vak.

2 Voorblad: de vuurtoren, een historisch digitaal communicatiemedium in de lijn van klopsignalen, rooksignalen, vuurtoren, morsecode en telex. M O D U L E W I J Z E R C O M P U T E R S Y S T E M E N 1

3 Voorwoord Welkom bij het practicum van Computersystemen 1. In dit document staat allerlei informatie om de opdrachten te kunnen maken. 1

4 Inhoudsopgave Blz. 1 Algemene omschrijving Inleiding Fouten in het boek Computers, Organisatie / Architectuur / Communicatie Windows Rekenmachine Aanvullende en verdiepende leerstof Binaire conversietabel Van een binair getal van een n aantal bits het grootste en kleinste getal De Gray code Over talstelsels Representatie van negatieve getallen Floating piont getallen of drijvende kommagetallen De ACSI tabel Over het kloksignaal Over ic`s Een introductie van de ZEP2-simulator Voorbeeldpogramma`s Opdracht: ZEP2 Opdracht_ Voorbeeldtoets Kernbegrippen

5 1 Algemene omschrijving 1.1 Inleiding De microprocessor is zich bewust van zijn denkfout en probeert die te herstellen. (Een student) Het belang van dit vak is dat de student inzicht verkrijgt in de principiële interne werking van een digitaal apparaat zoals een rekenmachine, MP3 speler, fototoestel, computer, enz. En hoe een assembler programma deze hardware aanstuurt. Je krijgt ook meer inzicht in het programmeren. Waarom moet je een datatype declareren? Er wordt een geheugenbereik gereserveerd. Waarom hebben variabelen een naam en geen geheugenadres? Dit maakt het programmeren éénvoudiger. De module handelt over binaire signalen of getalen. Alleen een 0 of een 1. Het belang waarom we hiermee werken is als volgt: Als je het bovenstaande analoge signaal bekijkt dan zie je dat dit continu veranderd en oneindig veel waarden heeft. Als je dit signaal opneemt en weer afspeelt of kopieert dan treed er vervorming op. Wil je dit signaal bijvoorbeeld via een verbinding naar Amerika sturen dan moet het een aantal malen versterkt worden. De vervorming neemt toe. De vervorming van de eerste versterker wordt ook door de tweede versterker versterkt, enz. Ook is het signaal door stoorsignalen te beïnvloeden. Als je bij de bron het signaal omzet in digitale signalen dan is dit signaal vervormingvrij te transporteren, versterken of te kopiëren. Een 0 blijft een 0 en een 1 blijft een 1, alleen grote beïnvloeding kan een 0 een 1 wordt of een 1 een 0. De elektronica hoeft alleen maar te detecteren of het signaal een 0 of een 1 is en niet oneindig veel waarden. De elektronica is eenvoudig van opzet en het aantal bits of functies per mm 2 is groot. Een signaal is bijvoorbeeld maximaal 5 volt. Een 0 is van 0 tot 0,8 volt een 1 van 2,4 tot 5 volt. Van 0,8 volt tot 2,4 volt is verboden. Een digitaal signaal met een stoorsignaal wordt door een elektronische schakeling weer origineel. 3

6 2 Fouten in het boek Computers, Organisatie / Architectuur / Communicatie Wat staat er/ ontbreekt er: Wat moet er staan: Inh. Opgave Direct Memory Access Direct Memory Access 117 Blz. 19 bovenaan Blz. 52 AND-, OR- en EXOR-poorten AND-, OR-, NAND-, NOR- en EXOR-poorten Blz. 57, A + B = C + S A + B = C + S bovenste figuur (geen nr.) Blz. 81, tabel 3.1 Er ontbreekt de aanduidingen Fetch, Decode en Execute. Voor de cijfers 1, 2, 3 een F Voor het cijfer 4 een D Voor het cijfer 5 een E Blz. 82, Er zijn geen in- en uitgangsregisters getekend aan de ALU. De registers A, B en C zoals in figuur 3.8 fig 3.7 Blz. 84, Adresbus bidirectioneel getekend. Adresbus is unidirectioneel fig 3.8 Blz. 84, fig 3.8 SP-register en Flag-register ontbreken. Een register met naam SP verbonden aan de interne data I/O bus bijtekenen Blz. 90 Assemblercode.. is de machinecode Assemblercode.. is de machinecode Blz. 90 Instructielengte We beginnen met een voorbeeld voor de ZEP1. Instructielengte We beginnen met een voorbeeld voor de ZEP2. Blz. 91,.. voor de ZEP1 voor de ZEP2 tabel 3.4 Blz. 91, Dit is het instructieformaat van de ZEP1 in plaats van de fig.3.14 ZEP2 Blz. 92 EXCHANGE register register EXCHANGE register register Blz. 93, Een aantal figuren zijn weggevallen. fig.3.15 Zie de volledige figuur 3.15 na deze tabel. Voeg bij LSL toe: LSL ASL voeg toe de tekening van ROLC (zelf bedenken) Blz. 98 ASR R13 ; R13:=R13/2 R13 moet vervangen door R1 of R2 Blz. 102, De hele bladzij bevat fouten Deze bladzijde is herschreven en te vinden na deze tabel. Blz. 108, fig.3.24 Bij de schuifregisters is Serieel in aan de rechterkant getekend en schuift naar links naar binnen. Blz. 145, inktjetprinter inkjetprinter fig.4.14 Blz. 231 Afstand:= x 2 + y 2 Afstand z:= x 2 + y 2 Blz. 232 Het voorbeeld met doorgave van variabelen via de stack bevat fouten: 1- op deze wijze haalt de eerste POP-instructie de het terugkeeradres van de stack. 2- er staan 2 POP s en 1 PUSH-instructie. Zo wijst de SP voor het betreden van de subroutine niet op hetzelfde adres als na het verlaten van de subroutine. Blz. 240 FOrmula TRANslating FORmula TRANslating Serieel in moet aan de linkerkant getekend. De bits schuiven naar binnen via het Most Significant Bit en worden (evenals de output) doorgeschoven met een Shift Right 4

7 Wat staat er/ ontbreekt er: Wat moet er staan: Blz. 248 SQL (Standard Query Language) SQL (Structured Query Language) Blz. 351, Opg 1.1 Blz. 353, Opg.1.9 Oplossing symbolen: (de uitlijning klopt niet) positie: , 1/5 1/ Oplossing symbolen: positie: , 1/5 1/ Blz. 355, Opg Blz. 357, Opg Opg Nu hebben we de binaire voorstelling gevonden: Dus: 10R 999 = 8R 7747 = 2R grootste = = kleinste = = grootste = = kleinste = = b, de grootste = A = 10 x 4096 = som is Nu hebben we de binaire voorstelling gevonden: Dus: 10R 999 = 8R 1747 = 2R grootste = = kleinste = = grootste = = kleinste = = b, de grootste = A = 10 x 4096 = som is Blz. 360, Opg Blz. 369, Opg Blz. 375, Opg Blz. 375, Opg Blz. 375 Opg Dus: 16R ABCD = 10R a Een floating point. (paragraaf 1.6.3) Dus: 16R ABCD = 10R a Een floating point. (paragraaf 1.5.3) Oplossing 3 e punt Het vierde veld is.. Het derde veld is 2.20 SOM = XOR (A, XOR(Cin, XOR (A,B) SOM = XOR(Cin, XOR (A,B)). 2-operands LOAD R1, A ADD R1, B STORE R1, C 1-operands LOAD A ADD B STORE C 0-operands PUSH A PUSH B ADD POP C 2-operands LOAD R1, B ADD R1, C STORE R1, A 1-operands LOAD B ADD C STORE A 0-operands PUSH B PUSH C ADD POP A 5

8 6

9 3.2.5 De Stack (bladzijde 102 van het boek) De meeste processors ondersteunen het gebruik van een LIFO (last in first out) stack. Deze stack, in het Nederlands stapel genoemd, wordt bijgehouden in het werkgeheugen. Het adres van het eerstvolgende vrije geheugenelement wordt bewaard in de Stack Pointer, een register binnen de CPU (figuur 3.18). We geven deze aan met SP. Figuur 3.18 Stack CPU 375A Stack Pointer Het bijschrijven op de stack heet PUSH en gaat aldus: Stack Adres A 375B 375C 375D 375E. (SP) := data SP := SP 1 ; Het te bewaren item wordt op de stapel gezet ; De stack pointer wijst nu naar de volgende vrije plaats Het terughalen heet POP en gata in omgekeerde volgorde: SP := SP +1 ; Register of (adres) := (SP) ; De stack pointer wijst op deze manier altijd naar de eerstvolgende vrije plek op de stack. Wanneer we bij PUSH vooraf decrementeren en bij POP naderhand incrementeren werkt het mechanisme ook: alleen wijst de SP nu steeds naar de laatst gevulde plaats. Wanneer de machinecode van de processor PUSH en POP bevat, kunnen we eenvoudig met de stack omgaan: PUSH item ; item stack Terughalen gaat als volgt: POP (adres) ; (adres) stack SP is in dat geval een speciaal register, dat bij uitvoering van deze instructies automatisch geïncrementeerd wordt. 7

10 3 Windows Rekenmachine Instellen: Hexadecimaal, Decimaal, Octaal of Binair. De rekenmachine kan ook waarden converteren naar en ander talstelsel en in een ander talstelsel rekenen. De rekenmachine staat nu ingesteld op Binair. Alleen de getallen 0 en de 1 zijn actief. Hoe converteer ik waarden naar een ander talstelsel? Opmerkingen: Klik op Wetenschappelijk in het menu Beeld. Voer het getal in dat u wilt converteren. Klik op het talstelsel waarnaar u wilt converteren. Klik op de weergavegrootte die u wilt gebruiken. Als u een decimaal getal dat decimalen bevat naar een ander talstelsel converteert, wordt het getal ingekort tot een geheel getal. Getallen die van hexadecimaal, octaal of binair naar decimaal zijn geconverteerd, worden weergegeven als positieve gehele getallen. 8

11 4 Aanvullende en verdiepende leerstof 4.1 Binaire conversietabel , /2 1/4 1/8 1/16 1/32 1/64 1/128 1/256 (10) 0,5 0,25 0,125 0,0625 0, , , , V.b: (2) V.b.: bij een 1 het bovenstaande getal optellen: , , = 398, Schuiven naar rechts is het getal delen door twee. Schuiven naar links is het getal keer twee. Voorbeeld: in het werkgeheugen staat het getal 13, binair: ; het getal moet vermenigvuldigd worden met twee; een bepaalde instructie verplaatst het getal in één plaats naar links: , 26 (10). Bij omrekenen van en naar hexadecimaal vanaf de komma groepen van vier bits nemen. Rekenregels machten: Hexadecimaal: a 0 = a 1 = a A -n = 1 / A n A n = 1 / A n a p a q = a p+q a is niet a p : a q = a p-q A B (a p ) q = a p q C D (a b) p = a p b p E F a ½ = a (a 0) a p/q = q a p (a 0) 9

12 4.2 Van een binair getal van een n aantal bits het grootste en kleinste getal Bijvoorbeeld: een drie bits getal, n = 3, het aantal mogelijkheden = 2 3 = 8. Van 0 t/m 7. Unsigned integer 2 n 1 Signed magnitude 2 n t/m - 2 n One`s complement 2 n t/m - 2 n Two`s complement 2 n t/m - 2 n - 1 BCD - unsigned per vier bits één cijfer. Bijvoorbeeld: 16 bits, vier cijfers van 0000 t/m packet decimals per vier bits één cijfer plus de laatste vier bits voor het teken. Bijvoorbeeld: 16 bits,` vier cijfers van 999 t/m unpacked decimals per acht bits één cijfer plus de laatste vier bits voor het teken. Bijvoorbeeld: 32 bits, drie cijfers van 999 t/m

13 4.3 De Gray code Een Gray-code is een binaire codering die als eigenschap heeft dat twee opeenvolgende getallen altijd maar één bit verschillen. In tegenstelling tot een gewogen binaire code is de code niet via een eenvoudige optelsom van machten van twee te herleiden. Ook zijn er meerdere mogelijkheden om Gray-codes samen te stellen. Gray-codes kunnen toegepast worden waar bijvoorbeeld een mechanische positie omgezet moet worden naar een digitale code. Als een van de positiegevers defect is of als niet alle positiegevers exact gelijktijdig schakelen zal de code altijd nog "in de buurt" van de werkelijke waarde zijn. Bij gewogen codes zal bij een fout in een van de meer significante bits de fout aanzienlijk groter kunnen zijn. Bij de overgang tussen stand 7 en 8 wijzigen bij een gewogen-binair gecodeerde gever alle bits. Een windvaan met 16 sectoren en 4-bits codering zal dan, als hij tussen code 7 en 8 staat te twijfelen, misschien een tussenstand 1111 of 0000 (of alle andere mogelijke codes!) kunnen geven, bij een Gray-code is er geen twijfel tussen 0100 en 1100 omdat alleen het linker bit wijzigt. Een algoritme om een Gray-code van een willekeurig aantal bits samen te stellen gaat als volgt: Begin met een 1-bits code die met een 0 begint: Regel : Gray code: Aanwijzingen: Alle combinaties zijn geweest, hierna een 1 (msb) erbij. Spiegelas 3 11 Na de 1 wat er staat bij regel 2. Door de 1 erbij is er 1 bit gewijzigd van regel 2 naar regel Na de 1 wat er staat bij regel 1. Alle combinaties zijn geweest, hierna een 1 (msb) erbij Na de 1 wat er staat bij regel 4. Door de 1 erbij is er 1 bit gewijzigd van regel 4 naar regel 5. Spiegelas Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel 1. Alle combinaties zijn geweest, hierna een 1 (msb) erbij Na de 1 wat er staat bij regel 8. Door de 1 erbij is er 1 bit gewijzigd van regel 8 naar regel 9. Spiegelas Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Na de 1 wat er staat bij regel Enzovoorts 18 1 Alle combinaties zijn geweest, hierna een 1 msb erbij. Spiegelas Van n bit naar n + 1 bit, plaats een 1 (msb) erbij en hierna de voorgaande bitcombinatie gespiegeld. 11

14 4.4 Over talstelsels Computers: meertalig, maar altijd tweetallig Computersystemen. Uit de jaren 50 of modern: beide kennen alleen nul of een Klare taal voor een PC: En voor ons? 12

15 Tweetallig stelsel 1. Hoe zou je tellen als er maar vijf cijfers waren? Maak het volgende rijtje langer. Bedenk dat je alleen de cijfers van 0 t/m 4 mag gebruiken: tellen met 10 cijfers tellen met 5 cijfers Het klinkt misschien idioot, maar een computer kan niet tot tien tellen, niet eens tot vijf. Elke geheugenplek in een Na 4 zijn je cijfers op. In het tientallige begin je na de 9 weer opnieuw: met 10. In het 5-tallige doe je dat ook. computer kent maar twee cijfers: 0 of 1. We gaan zo n systeem met twee cijfers eens wat verder bekijken. Start het computerprogramma binair en doe onderdeel 1 een aantal maal. Schrijf de resultaten hieronder op. Gebruik nullen en enen. Getal Gebruik van het programma onderdeel 2 om de volgende tabel in te vullen. Getal

16 Tweetallig stelsel vervolg1 Op de knoppen in het programma staan de getallen Deze getallen zijn niet toevallig. Zie ook de tabel hiernaast. 128 = 2x2x2x2x2x2x2 = = 2x2x2x2x2x2 = = 2x2x2x2x2 = = 2x2x2x2 = = 2x2x2 = = 2x2 = Beantwoord de volgende vragen a. Wat is het grootste getal dat je in het tweetallig stelsel met acht cijfers (nullen en/of enen!) kan maken? Hoeveel is dat getal in ons gewone tientallige stelsel waard? b. Als je met het programma grotere getallen wilt kunnen maken, dan moet er een negende knop bij. Welke waarde moet er op die negende knop staan? In de huidige computersystemen wordt voornamelijk met bytes gewerkt: acht opslagplaatsen vormen samen een byte. Zo n byte is gevuld met acht bits. Het woord bits is een samentrekking van binary digits. (Digit is engels voor cijfer). Elk bit is een nul of een één. Zo n rijtje van acht bits kun je opvatten als een getal in het tweetallige of binaire stelsel. De getallen die je in de opgaven 2 en 3 hebt ontleed in machten van twee leverden binaire getallen op. 5. Bekijk nog eens de resultaten bij de opgaven 2 en 3. Het rijtje nullen en enen dat ontstond is precies de binaire schrijfwijze van het getal in ons gewone tientallige stelsel. Gebruik het programma (en/of je hersens) om de tabel hiernaast in te vullen. Eventuele begin-nullen zou je weg kunnen laten. Getal in het tientallige Datzelfde getal in stelsel binaire notatie

17 Tweetallig stelsel vervolg2 En nu andersom. Gebruik onderdeel 3 van het programma om te leren hoe het andersom moet. Je krijgt nu een tweetallig getal en jij zoekt uit welk tientallig getal dat is. Schrijf je resultaten op: Tweetallig getal Tientallig getal 6. Eens kijken of je het echt begrijpt. Vul de tabel in. Om de antwoorden te vinden gebruik je de computer niet. Je kunt onderdeel twee van het programma gebruiken om je antwoorden te controleren Binair (=tweetallig) getal Tientallig getal Wat een bepaald binair getal voorstelt hangt er maar net van af: van welke betekenis wij er aan toekennen. Misschien zou je zelfs niet eens meer van binaire getallen moeten spreken, maar van binaire representaties. Het rijtje kan A zijn, of het tientallige getal 65, of de boodschap einde bericht, of een bepaalde instructie voor de microprocessor, of een geheugenadres, of enzovoort. 15

18 Hexadecimale (Zestientallig) stelsel. Voor mensen is het lastig om met rijtjes nullen en enen te werken. Veel te lang en te moeilijk uit elkaar te houden. Vandaar dat zo n byte vertaald wordt. Bij letters wordt vaak ASCI-code gebruikt. Een deel daarvan zie je op de vorige bladzijde. Daar wordt meestal het tientallige getal gebruikt in plaats van de binaire code. Bijvoorbeeld: de ASCI-code van è is 138. De vertaling van binair naar tientallig en andersom is niet echt moeilijk. Toch werken veel ICT-mensen liever met het zestientallig stelsel, omdat de vertaling van tweetallig naar zestientallig erg simpel is. Er is alleen één probleem: Voor zestientallig heb je 16 cijfers nodig en wij kennen er maar tien. Dat probleem is opgelost door er nog 6 hoofdletters bij te nemen: van 0 t/m 9 zijn de cijfers hetzelfde als in het tientallige, daarna tel je verder met A, B, C, D, E en F. (de zestientallige A stelt dus het tientallige getal 10 voor, B=11, C=12, D=13, E=14, F=15 en meer cijfers zijn er niet. ) 8. Hoe moet je het tientallige getal 16 noteren in het zestientallig stelsel? Het schema hierboven is gevonden op: Ook in de muziek spelen tegenwoordig binaire coderingen een rol. 16

19 Hexadecimale stelsel - vervolg. 9. Vul de tabel in: tientallig tweetallig zestientallig tientallig tweetallig zestientallig C C D E F Kijk naar je tabel. Waarom is de vertaling van binair naar zestientallig zo makkelijk? Bij het maken van websites met HTML-code kun je te maken krijgen met hexadecimale codes voor de kleur. De wijze waarop kleuren aangegeven worden bij veel computertoepassingen is echter een verhaal apart. Voor nu is het even genoeg. 17

20 Wie leert rekenen doet dat in het begin vaak met z n vingers erbij: = Elke vinger krijgt een naam : één, twee,.tien. Eigenlijk is er helemaal geen sprake van rekenen, maar van tellen: + = Vanwege die tien vingers gebruiken wij tien symbolen. 0, 1,, 8, 9. Dat lijkt vreemd: 0 doet eigenlijk helemaal niet mee! En die tiende vinger zou best een naam mogen krijgen die uit één symbool bestond, toch? Maar wat is dan: -? De Romeinen kenden geen symbool voor nul. Dat was gewoon een leeg vakje op hun telraam. Wel had nul een naam: NIHIL of: NULLUS. Pas de invloed van de Arabische wereld (met India daarvoor) deed nul tot een getal worden: 3 3 = 0. En wat is dan 10? Die 0 duidt op: geen losse vingers en die 1 duidt op: 1 paar volledig gebruikte handen. De symbolen zijn op, we gaan ze combineren! Wat is dan 73? 7 paar volledig gebruikte handen en 3 losse vingers. Korter: 73 = 7 Х Х 1. Maar na 99 begint een volgend probleem: alle combinaties zijn (weer) op! Nou, op: na 9 komt immers 10! Dus na 9-9 komt 10-0! Oftewel: 99, 100. Ja, en dan kun je echt verder: wat betekent 28184? = = 2 Х Х Х Х Х 1. Of, korter: = 2 Х Х Х Х Х We zeggen, dat een getal is in het tientallig getallenstelsel. Opdracht 1 Noteer op dezelfde manier als dit voorbeeld ook: en Sommige culturen gebruik(t)en het twintigtallig stelsel: wellicht rekenden die ook met hun tenen(?) Je kunt de resten hiervan onder andere zien in Frankrijk: 80 = quatre vingt = 4 Х 20 en 90 = quatre vingt dix = 4 Х (In het Franssprekende deel van Zwitserland spreekt men van octante = 80 en nonante = 90, dus geen 20-tallig stelsel!) 18

21 Maar stel nu eens, dat de mens maar drie vingers aan elke hand had gehad, of zes! Dan hadden we geteld: 0, 1, 2, 3, 4, 5, 10 (zestallig) of: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,, Ц, 10 (twaalftallig, ik verzin voor de tiende en de elfde vinger maar even een symbool.) En dan bestaat in het zestallig stelsel 17 niet eens, want het symbool 7 bestaat daarin niet, net zo als wij het symbool Ц voor elf niet kennen, omdat we niet twaalftallig rekenen. En, nog ingewikkelder, een getal als 43 betekent in het 6-tallig stelsel heel wat anders als 43 in het (ons!) 10-tallig stelsel. Want: 43 (6-tallig) = 4 paar volle handen (met elk 3 vingers) en 3 losse vingers = 4 Х 6 (dit is een 10-tallige 6!) + 3 = 27(10-tallig) Opdracht 2 a. Reken 55 (6-tallig) om naar het 10-tallig stelsel. Ook: 13 (6-tallig) en 105 (6-tallig). b. Reken 19 (10-tallig) en 58 (10-tallig) om naar het 6-tallig stelsel. Nu het tweetallige, of binaire stelsel. Hierin bestaan alleen de symbolen 0 en 1. Onze eerste 11 getallen (0 tot en met 10) worden binair: tientallig binair De rekenregels zijn verbluffend simpel: Х Opdracht 3 a. Tel op: (Aanwijzing: gewoon onder elkaar!) b. Idem: c. Vermenigvuldig: 1101 Х 101 ; net zoals je op de basisschool 472 Х 384 uitrekende:

22 d. Idem: Х Nu gaan we omrekenen: Eerst van binair naar 10-tallig: Een voorbeeld: = = 1 Х Х Х Х Х 2 0 = = 109 Het is handig om de volgende schrijfwijze (notatie) te gaan gebruiken: betekent 101 (10-tallig) en betekent 101(2-tallig). Dus = 1 x = 101 (10-tallig) en = 1 x = 5 (10-tallig) Je ziet: 1 2 = 1 10, 10 2 = 2 10, = 4 10, = 8 10, = 16 10, = 32 10, Opdracht 4 Zet de getallen uit opdracht 3 om in het 10-tallig stelsel en controleer de juistheid van de antwoorden. Hopelijk is de vorige opdracht gelukt, en heb je ook ontdekt dat of je nu zegt = 9 of = 1001, het is allebei juist. Alleen, de getalstelsels verschillen. Nu omrekenen van 10-tallig naar binair: Voorbeeld: rest = Lees: 87 : 2 = 43, rest is 1; 43 : 2 = 21, rest is 1; 21 : 2 = 10, rest is 1; 10 : 2 = 5, rest is 0; enzovoorts. De oplossing lees je van onder naar boven. (volg de pijlen) Opdracht 5 Zet om van 10-tallig naar binair: (gebruik eventueel ook je rekenmachine) a. 147 b c

23 Het hexadecimale (16-tallige) stelsel Alle symbolen, waarvan men rond 1950 vond dat ze een tweetallige code moesten krijgen, vormen de zogenaamde ASCII-codetabel. 127 Tekens (dat werd later uitgebreid naar 255 tekens) werden aan een bepaald getal gekoppeld. En al die ASCII-getallen worden dan ook nog eens tweetallig genoteerd. Tweetallig geschreven taal ziet er heel eentonig en onleesbaar uit: de woorden Tweetallig Stelsel worden (de spaties geven de grenzen van elk symbool aan en horen er niet in thuis, maar dat leest iets makkelijker): ( hierin is de spatie tussen de twee woorden, ASCII-code 32) Merk op dat ik alle codes heb aangevuld tot een 8-cijferig geheel. By eight noemde men dat vroeger, tegenwoordig kortweg: byte. (En dan maar hopen dat ik geen tikfout heb gemaakt, anders vertaalt de PC zoiets rustig in dh llè!!) Onder andere daarom hebben mensen het 16-tallig stelsel ontworpen. 16-Tallig, omdat je dan precies 4 tweetallige symbolen kunt vertalen naar één 16-tallig symbool volgens de tabel hieronder: Binair (tweetallig ) Hexadecimaal (zestientallig) Decimaal (tientallig) A B C D E F 15 Dan wordt die onmogelijke code van zo-even: C 6C C C (na twee tekens een spatie is gebruikelijk) Nog niet bepaald leesbaar maar wel minder lang en minder eentonig! 2 1

24 De ASCII-codes van de letters van het alfabet zijn: A = = 65, B = = 66,, Z = = 90; allemaal 10-tallig. (omdat we elke letter door een byte vervangen wordt de letter A niet geschreven als , want dat zijn 7 bits, maar als , 8 bits) De letters a tm z krijgen ASCII-code = 97 tot en met = 122 Met de combinatie ALT - numeriek toetsenbord kun je dit zichtbaar maken: ALT 80 geeft P, ALT 130 geeft é, enzovoorts. (codes boven 127 horen strikt genomen niet tot de ASCII-code, je vindt dan ook geen eenstemmigheid bij alle PC-fabrikanten) Zet de volgende woorden eerst om in een decimale ASCII-code, daarna binair, tenslotte hexadecimaal: a. BINAIR b. Typewriter Opdracht 7 Probeer de getallen 100, 255 en 17889, allen 10-tallig, om te zetten naar de hexadecimale schrijfwijze op de manier van opdracht 5. Bedenk dat je dan steeds door 16 moet delen en de resten noteren. (Eerst naar binair omzetten kan natuurlijk ook) Opdracht 8 Ga na, hoe kleine en grote letters binnen de binaire ASCII-code in elkaar zijn om te zetten. (dus tweetallig rekenen!) 22

25 Van de omzettingsmethode van decimaal naar binair heb ik niet aangetoond waarom die werkt. Ik zal proberen dat aan de hand van een voorbeeld uit te leggen. Ik maak van 87 een binair getal. Bedenk, dat 87 oneven is. Als je 87 door 2 deelt krijg je 87 : 2 = 43, rest 1; oftewel: 87 = 43 Х Die 1 is belangrijk, het is de achterste1 van Daarna bereken je 43 : 2 Ook dat lukt niet: 43 : 2 = 21, rest 1 Feitelijk heb je nu: 87 = 21 Х Х 2 + 1! Daarna kijk je of er een losse 4 in 21 Х 4 zit. Die is er: 21 = 10 Х 2 + 1, dus 87 = 10 Х Х Х Dan 10 : 2 = 5, rest 0, dus geen losse 8 (van 10 x 8 heb je feitelijk 5 x 16 gemaakt). Je krijgt: 87 = 5 Х Х Х Х Daarna 87 = 2Х Х Х Х Х Zo ga je door. Uiteindelijk deel je 6 keer door 2. Je laatste antwoord is 1. Dat is 1 Х 2 6 = 64 Zodoende wordt 87 gelijk aan: = 1 Х Х Х Х Х Х Х 2 0 = Helemaal uitgeschreven voor een kleiner getal, 45: 45 = Х Х Х Х =

26 4.5 Representatie van negatieve getallen 1e methode: Modulussysteem Is een talstelsel waarin positieve en negatieve getallen worden aangegeven door een teken + of - toe te voegen. De modulus of de absolute waarde van het getal is de waarde van het getal zonder teken. Binair; het meest linkse bit (MSB) is het tekenbit. 0 = positief getal, 1 = negatief getal. Dit tekenbit dient apart behandeld te worden. Complementsysteem (aanvullen tot) De microprocessor is het eenvoudigst als alleen de bewerking optellen uit te voeren is. Een optelling van negatieve getallen is een aftrekking. Dit is te voorkomen negatieve getallen om te zetten in positieve getallen, door het negatieve getal te vermeerderen met een vast afgesproken waarde. Na de optelbewerking trekken we de vaste waarde van het resultaat af, zodat we het juiste resultaat verkrijgen = (+ 100) = 114 ( 100) = is het complement van 18, omdat 82 de aanvulling is van 18 (getal zonder teken) tot = 82 of = 82. Het complement van een negatief getal vinden we door de absolute waarde van dat negatief getal aan te vullen tot een vaste waarde. 10-complements, als de vaste waarde een macht van 10 is. 2e methode: 1 complementsystemen Is een invertering van de bits > de carry vanuit de meest linkse bit optellen bij het meest rechts bit, end-around cary. 3e methode: 2 complementsystemen De constructie van de microprocessor is het eenvoudigst als alleen de bewerking optellen (ADD) uitgevoerd moet worden. Aftrekken wordt met de 2-complements notatie optellen. De 2-compements notatie wordt in veel microprocessors automatisch toegepast. Wanneer we de processor via een SUB instructie (to subtract = aftrekken) opdracht geven om twee getallen van elkaar af te trekken, zal hij dit doen volgens de 2-complements methode. Gaat het niet automatisch, dan met behulp van instructies het 2-complement van het aftrekgetal vormen, en optellen bij het aftrekgetal met behulp van de ADD instructie. De processor hoeft niet van te voren te weten of het getal negatief is. 2-complement, als de vaste waarde een macht van 2 is. Het tekenbit hoeft niet afzonderlijk behandeld te worden. 24

27 Is de woordlengte 3 bits, dan wordt 23 = 1000 als vaste waarde gekozen. Is het vierde bit. - 7 absoluut = 7 = (2) woordbreedte 3 bits, het vaste getal is: (2) (2) (2) is de 2-complements notatie van - 7 Een 2-complements is ook te bepalen door: inverteer de bits, inverteren Is de woordlengte 4 bits, de getallen 8 tot en met 7 zijn voor te stellen. Of: is n de woordbreedte; getallen tussen (2n/2) en (2n/2) 1 = -(2n-1) en 2n-1 1 zijn weer te geven. Registeroverflow (het resultaat is te groot voor de gereserveerde ruimte) treedt op indien de optelling 2 positieve of negatieve getallen betreft en het resultaat van teken veranderd. Getal Met tekenbit 2-complement Overflow Overflow Overflow Tekenbit: 0 = positief getal 1 = negatief getal De getallen van 0 tot en met +oneindig zijn volgens de gewone binaire notatie. Aftrekken is het zelfde als optellen van het omgekeerde: = 17 + (-22) -22 in de 2-complementsnotatie (2) 17 (10) (2) 22 (10) processor kan alleen optellen? (2) 17 (10) 2-complementsnotatie (2) 22 (10) (2) - 5 (10) De eventueel optredende carry vanuit de meest linkse bit weggooien, wordt dus: (-3) complementsnotatie MSB optredende carry weggooien. 25

28 4.6 Floating piont getallen of drijvende kommagetallen Waarom? 2 11 = =? of = Een drijvende kommagetal of een floating-piont getal bevat niet het getal zelf maar de exponent en de restwaarde. De processor kan alleen optellen, de exponent hoeft alleen opgeteld te worden. Ook neemt het getal minder geheugenruimte in zodat er grotere getallen in de geheugenruimte opgeslagen kunnen worden. Het omzetten naar een floating-piont getal is bewerkelijk. De E notatie =,2433 E4. 0,2433 keer is de mantisse, direct als getal achter de komma. Is een drijvende kommavoorstelling. Floating point representation. Waardoor zeer grote en kleine getallen weergegeven kunnen worden. Bij de mantisse wordt vaak gewerkt met de gewichten 2-1 = 1/2, 2-2 = 1/4, enz zodat de mantisse kleiner is als 1. Er zijn diverse formaten, uitvoeringen van floating-point getallen met diverse ingebouwde wiskundige trucs, iedere fabrikant van microprocessors heeft zijn eigen notatie van floating-point getallen. Moet hardwarematig in chipsset geïmplementeerd worden. In de co-processor. Een drijvende kommagetal wordt bijvoorbeeld voorgesteld door 32 bits: (algemeen geldig) 1 e bit tekenbit (van het gehele drijvende kommagetal) 2 e t/m het 8 e bit, de exponent 9 e t/m het 32 e bit, de mantisse. De exponent loopt van 127 tot + 127, (excess code) geeft aan tot welke macht van twee de mantisse vermenigvuldigd moet worden. Excess code: Een unsigned integer noteren tussen 0 en 255, en vervolgens er 128 vanaf trekt, heeft de waarde 128, en de waarde Een floating-point getal kan ook worden voorgesteld als: Tekenbit exponent komma (afspraak niet in bitpatroon plaatsen) mantisse (begint met 2 0 of 1 of 2 ) Het rekenen met floating-point getallen is lastiger en duurt langen dan het rekenen met integers. 1. de exponenten van de twee getallen moeten gelijk gemaakt worden 2. de mantissen moeten worden opgeteld. 3. het resultaat moet zodanig genormaliseerd worden, dat wil zeggen aangeschoven tot er een 1 achter de komma staat. Normaliseren is: een fractie waarvan het meest linkse bit niet nul is. Het proces van naar links schuiven van de meest significante één in de mantisse en het dienovereenkomstige verlagen van de exponent noemen we normalisatie. De getallen worden met een hogere precisie weergegeven, Doordat er meer bits over zijn naar rechts voor de mantisse. Mantisse patroon: schuiven naar links: en de exponent verlagen! 26

29 Enkele getalformaten: tekenbit 2 10 exponent mantisse 2-52 Real *8 (IEEE) + 2, , tekenbit 2 6 exponent mantisse Real *4 (IBM) + 5, , Op de site: h t t p : / / b a b b a g e. c s. q c. e d u / i e e e / d e c i m a l. h t m l is een decimaal getal te converteren naar een IEEE-754 Floating-Point getal naar een 32 bit getal (enkele precisie) en een 64 bit getal met dubbele precisie. In het onderstaande scherm is het getal 1024, 2 10 geconverteerd. De exponent is 137. Wil je bijvoorbeeld het getal 8,75 converteren, typ dan I.p.v. de komma een punt. 27

30 4.7 De ACSI tabel ASCII, spreek uit als ask-ie, is de afkorting voor American Standard Code for Information Interchange. Het is een set tekens die geen speciale formatering kent als vet, lettertype, onderlijnd etc. Een ASCII bestand is een gegevens- of tekstbestand die alleen tekens bevat, gecodeerd volgens de bovengenoemde tekenset. Tekens van omvatten de Standartd ASCII Set, tekens 128 tot 255 worden de Extended (uitgebreide) ASCII Set genoemd. De laatste groep coderingen hoeven niet dezelfde te zijn op elk type computer of op de juiste wijze geconverteerd worden in een ander ASCII-programma. Standard ASCII De eerste 32 tekens zijn (0-31) control codes. 0 NUL Null 33! 65 A 97 a 1 SOH Start of heading 34 " 66 B 98 b 2 STX Start of text 35 # 67 C 99 c 3 ETX End of text 36 $ 68 D 100 d 4 EOT End of transmit 37 % 69 E 101 e 5 ENQ Enquiry 38 & 70 F 102 f 6 ACK Acknowledge 39 ' 71 G 103 g 7 BEL Audible bell 40 ( 72 H 104 h 8 BS Backspace 41 ) 73 I 105 i 9 HT Horizontal tab 42 * 74 J 106 j 10 LF Line feed K 107 k 11 VT Vertical tab 44, 76 L 108 l 12 FF Form feed M 109 m 13 CR Carriage return N 110 n 14 SO Shift out 47 / 79 O 111 o 15 SI Shift in P 112 p 16 DLE Data link escape Q 113 q 17 DC1 Device control R 114 r 18 DC2 Device control S 115 s 19 DC3 Device control T 116 t 20 DC4 Device control U 117 u 21 NAK Neg. acknowledge V 118 v 22 SYN Synchronous idle W 119 w 23 ETB End trans. block X 120 x 24 CAN Cancel Y 121 y 25 EM End of medium 58 : 90 Z 122 z 26 SUB Substitution 59 ; 91 [ 123 { 27 ESC Escape 60 < 92 \ FS Figures shift 61 = 93 ] 125 } 29 GS Group separator 62 > 94 ^ 126 ~ 30 RS Record separator 63? 95 _ US Unit separator 96 ` 32 SP Blank Space (Space Bar) 28

31 Extended ASCII 29

32 4.8 Over het kloksignaal Een kloksignaal bestaat uit elektrische impulsen met regelmatige tussenpozen om te zorgen voor synchronisatie. Het kristal zorgt voor een zeer constante frequentie. Afwijking, enkele seconden per jaar. Het kloksignaal wordt gebruikt om acties in een digitale schakeling te coördineren. Voorbeeld: is op de besturingslijn het kloksignaal hoog dan wordt de DATA IN doorgegeven. Het kloksignaal geeft de maat aan van de snelheid van de computer. Ieder onderdeel zoals de processor, het geheugen heeft een kloksignaal aansluiting. Zo kan de data synchroon ingelezen, bewerkt of op de uitgang komen. Waarom is het niet mogelijk om constant de data in te lezen, te bewerken of op de uitgang te plaatsen? Iedere poort heeft een bepaalde vertraging. Zie in map 08 Over ic`s\datsheets, de datasheet van het ic DM74LS00. De Propagation Delay Time LOW-to-HIGH Level Output is 3 tot 15 nanoseconden. Tijdens deze omklaptijd is de uitgang van de poort niet gedefinieerd. Het kloksignaal zorgt ervoor dat in deze tijd geen andere acties plaatsvinden. De verandering op de uitgang ten gevolge van het veranderd ingangssignaal wordt tijdens een volgende klokpuls op de uitgang gezet. De tweede reden is dat elektrische signalen zich met een snelheid van ongeveer 5,8 picoseconden per millimeter verplaatsen door de printsporen. Als het kloksignaal en de data zich zich niet over dezelfde lengte verplaatsen dan treed er een tijdsverschil op van de aankomst van het signaal bij een ingang. Dit tijdsverschil moet kleiner zijn dan de tijd dat het kloksignaal actief is. Iedere klokpuls kan er een instructie uitgevoerd worden. Het kloksignaal kan toegepast worden van hoog naar laag, tijdens hoog, van hoog naar laag of van laag naar hoog en van hoog naar laag hierbij verdubbeld de snelheid. 30

33 4.9 Over ic`s In de map 08 Over ic`s staat een artikel over geïntegreerde schakeling. Hoe is de hardware uitgevoerd. In de submap Datasheets staan enkel datasheets van ic`s. Er zijn honderden verschillende digitale ic`s. In de datasheet staan alle eigenschappen van het ic vermeld. Bijvoorbeeld het ic sn74ls47, de BCD to 7-segment decoder/driver. 31

34 5 Een introductie van de ZEP2-simulator De ZEP2 is een eenvoudige processor, die geënt is op de processor uit het boek Computers, organisatie, architectuur, communicatie van F.J.Dijkstra. ZEP staat voor Zeer Eenvoudige Processor. Dat slaat vooral op de interne opbouw, die in het boek erg eenvoudig is gehouden om makkelijk te kunnen begrijpen hoe een processor werkt. Deze lijn is voortgezet in het simulatiemodel. De eenvoudige architectuur kan daarmee vrijwel alle standaardinstructies van een echte processor implementeren, zodat de programmering van de ZEP2 vrijwel overeenkomt met die van een gewone processor. Alleen het aantal clockcycli dat nodig is om dit resultaat te bereiken is hoger: hier telt niet de snelheid van de processor, maar veeleer het feit dat alle acties gemakkelijk te definiëren en te volgen zijn. De ZEP-2 niet vanuit de ingepakte (zip file) starten, er komen errors. Ook niet vanuit het Bureaublad! 1. Systeemeisen De simulator is te gebruiken onder Windows. De benodigde schijfruimte is niet veel meer dan enkele Megabytes. Met 64 Mb geheugenruimte kan de simulator goed uit de voeten. Een snelle processor is niet strikt nodig, maar voor enkele opties wel handig. De noodzakelijke simulatorfiles zijn opgenomen in de directory ZEP2 simulator; in de subdirectories sources, include en documents staan voorbeelden en documentatie. Omdat de simulator veel windows tegelijk kan bevatten, verdient het aanbeveling de schermresolutie zo groot mogelijk te maken. Het minimum is 800 * 600, met 1024 * 768 werkt het prettig. 2. Gebruikerseisen Bij de documentatie wordt ervan uitgegaan dat u ten minste hoofdstuk 3 van het boek Computers, organisatie, architectuur, communicatie heeft bestudeerd. Zo niet, lees dit dan eerst door en neem het boek erbij; er wordt regelmatig aan gerefereerd. In hoofdstuk 6 staat een inleiding in het assemblerproces; als u nog nooit met een assembler gewerkt heeft is dit ook nuttige literatuur. Er wordt verder van uitgegaan dat de elementaire beginselen van MS Windows u bekend zijn. 32

35 3. Installatie De simulator staat op de cd in de directory ZEP2-simulator. Hier staat een aantal files die de programmatuur en de helpbestanden bevatten en een drietal subdirectories, include, source en documents, waarin assemblervoorbeelden en documentatie zijn opgenomen. De documentatie bevat onder andere de volledige handleiding van de ZEP2-simulator. Dit is een Word-file, die bestemd is om te worden afgedrukt, maar u kunt die natuurlijk ook on line lezen. Er is niet voorzien in een speciaal installatieprogramma. Omdat de simulator geen veranderingen aanbrengt in de Windows Registry kan de programmatuur eenvoudig gekopiëerd worden van de cd. Doe dit door met behulp van This computer of de Windows verkenner op de cd de directory ZEP2-simulator te zoeken en deze vervolgens naar C:\ (of indien gewenst een andere directory) te slepen. Voor het vervolg is het gemakkelijk als u vervolgens het icoontje dat bij de file ZEP2.exe staat naar het scherm of de starttoets van Windows sleept. U kunt de simulator dan rechtstreeks vanaf het scherm opstarten. U kunt uiteraard ook op het icoontje van de file dubbelklikken. Wanneer u het type van een assembler sourcefile (default met extensie.asm) met de simulator associeert, kunt u de simulator ook starten door op de sourcefile te klikken. Een uninstall facililteit is evenmin nodig: u kunt zelf de betreffende directories weer van de schijf verwijderen; er blijven geen resten in de Registry staan. 4. Eerste acties Start de simulator U krijgt eerst het hoofdvenster. Het lijkt wel wat op een tekstverwerker. In het gebruikelijke menu kunt u via File Open of rechtstreeks via de Open file knop ook inderdaad een tekstfile openen. (Ik gebruik zelf altijd de simulator in plaats van notepad!) Vraag een nieuwe file aan via File New (of met de New File knop). U ziet dat u kunt kiezen uit 3 soorten: een tekst, een assembler source of een microcode source. Dit zijn allemaal tekstfiles, maar verschillen enigszins in layout en in de knoppen die op de werkbalk zitten. Vraag een nieuwe assembler file Als u geen tijd heeft voor wat tikwerk, open dan de file rechtstreeks met Open File. Het bestand intro.asm staat in de map 07 Simulatie programma`s\ ZEP2 (processor, geheugen en assembler programmeren)\sources. Er staat een syntaxfout in deze file: dit is met opzet gedaan om bij actie B het errorwindow te laten verschijnen! 33

36 Bestudeer eerst het volgende programma: Dit programma laadt het getal 1000 in een register en decrementeert (vermindert het getal met 1) tot het gelijk is aan 990; De successieve waarden 1000, 999, 998 etc. worden in het geheugen neergezet vanaf de geheugenplaats 'result'. ## //voorbeeld van een assembler programma voor de ZEP2 begin load R1, 1000; // hier begint het programma load r2, result;// R2 wijst naar een adres dat // later wordt gedefinieerd loop dec R1; // verminder R1 met 1 store R1, (R2); // berg het resultaat op inc R2; // laat R2 de volgende geheugenplaats aanwijzen cmp R1, 990; // vergelijk R1 met 990 bne loop; // als het niet gelijk is, spring naar loop halt; // anders klaar result equ 0x10; end; // resultaten vanaf geheugenplaats 0x10 //(10 hex = 16 decimaal) // signaal voor het assemblerprogramma ## De dubbele kruisjes geven begin en einde van de code aan. Figuur 1: listing van het voorbeeldprogramma intro.asm. Opmerkingen bij dit programma: Op iedere regel staat een assemblerinstructie. Deze instructie bestaat uit <label> <operatie > <operanden> ; Het label is de naam van het betreffende adres, het is niet verplicht. De lijst van toegestane ZEP2 instructies is te vinden in de uitgebreide handleiding. Als operanden kunnen voorkomen: - registers (R1, R2, SP, PC) - getallen - namen van elders gedefinieerde constanten Niet alle instructies hebben een operand nodig. De regels eindigen met een puntkomma. Commentaar begint met een dubbele slash //. Het lettertype voor sourcefiles is Courier New (niet-proportioneel). De assembler is niet case-sensitive. Dit betekent dat geen verschil gemaakt wordt tussen hoofdletters en kleine letters. Voor de instructie ADD kan dus evengoed add of Add geschreven worden. De dubbele kruisjes geven begin en eind van de code aan. Deze worden gebruikt door de assembler en de syntaxcoloring. Voor en achter de dubbele kruisjes kan begeleidende tekst worden geschreven zonder commentaar-slashes. U kunt de kruisjes ook helemaal weglaten, maar dan moeten alle bijschriften als commentaar worden aangegeven en de syntaxcoloring werkt niet. Begin is een speciaal label dat de assembler laat weten dat de uitvoering van het programma hier moet starten. Loop is een adres waaraan later gerefereerd wordt; de assembler zorgt ervoor dat het de waarde krijgt van het adres van de instructie. Wanneer er haakjes om een operand staan, betekent het dat het betreffende getal, dan wel de inhoud van het betreffende register, als een adres moet worden beschouwd (dit heet een indirectie). Nu is het tijd om iets meer te gaan doen. 34

37 A. Intikken Tik het programma in. Door dit te doen leert u de editor kennen; deze is tamelijk eenvoudig. Pas de grootte van het tekstwindow aan naar wens. Gebruik de TAB toets om de instructies op één rij te krijgen. Vergeet de puntkomma's niet. Opvallend is dat instructies en andere keywords herkend en gekleurd worden door de editor; dit maakt het gemakkelijker typefouten te vermijden. Wanneer u een oudere (tragere) computer heeft of het programma te lang wordt, kan het kleuren tot traagheid en een onrustig beeld leiden. Zet in dat geval de syntaxcoloring uit. Dit kan door op het dubbele kruisje te klikken op de editorbalk. Het kan ook via de rechtermuisknop. Kies More in het popup-menu en verwijder het vinkje bij syntaxcoloring. (Voor alle verschillende subwindows van het scherm geldt dat opties kunnen worden geregeld met de rechtermuisknop.) Als u geen tijd heeft voor wat tikwerk, open dan de file rechtstreeks met Open File. Het bestand hoort in de directory sources te staan onder de naam intro.asm. Er staat een syntaxfout in deze file: dit is met opzet gedaan om bij actie B het errorwindow te laten verschijnen! B. Assembleren Boven aan de editor vindt u drie knoppen. De betekenis is achtereenvolgens: - assembleer de source (dit is een test of de code syntactisch correct is), - assembleer en zet in het geheugen (idem, en bovendien wordt de code in het geheugen geladen), - assembleer, zet in het geheugen en voer de code uit. Druk eerst op de linkerknop. U moet een melding krijgen dat de code OK is. Zo niet, dan worden geconstateerde fouten in een hulpwindow onderaan de editor getoond en de betreffende regel in de tekst rood gekleurd. Wanneer de melding aangeeft dat de zaak OK is kunnen we het resultaat opvragen door op de knop Asm output te drukken. De zes knoppen op de knoppenbalk met het gekleurde randje eromheen dienen om de verschillende subwindows in het gesimuleerde systeem te kunnen bekijken (views). De assembler output file is ook een tekstfile. Hij kan worden bekeken en eventueel afgedrukt via File Print in het menu, dan wel via de rechtstreekse knop op de knoppenbalk. De assembler output geeft eerst het adres en dan de instructies. Er is te zien dat de code loopt van adres 0000 tot adres 000B (alle adressen en codes worden hexadecimaal genoteerd). Er valt met enige moeite ook te zien dat result kennelijk de waarde 0010 heeft gekregen en deze waarde ingevuld is in de betreffende instructie. C. De code in het geheugen laden Nu moet de geassembleerde code in het geheugen worden geladen. Om dit fenomeen te kunnen zien moeten we een blik in het geheugen kunnen werpen. Druk op de knop Memory. Wanneer alles goed is krijgt u rechts een kijkje in het geheugen op pagina 0. U vindt oplopende adressen vanaf De inhoud van het geheugen bestaat uit een groot aantal nullen: het gehele geheugen van de simulator wordt bij het opstarten van het programma op 0 gezet. Wanneer u zich niet heeft kunnen beheersen en al op de tweede of derde knop van de editor heeft gedrukt, is het geheugen al gedeeltelijk gevuld. Maak het dan eerst weer schoon door via de rechtermuisknop de option Clear this page te vragen. Druk nu op de tweede knop van de editor (Load program in main memory). Het resultaat ziet u in het geheugen rechtstreeks gebeuren. Vergelijk de inhoud van het geheugen met de assembler output. U ziet dat sommige instructies één, andere twee geheugenwoorden in beslag nemen. Door het geheugenwindow wat breder te maken (trek het naar links), ziet u dat achter de code de instructies staan. Dit komt tot stand door een disassembler die tekst bij de code zoekt. Symbolische adressen komen in dat geval niet voor, dit proces vertaalt alleen maar wat in het geheugen staat en de oorspronkelijke source is in het geheugen niet meer bekend. De geheugenwoorden hebben een grootte van 16 bits. De hexadecimale, decimale en binaire code staan in het window, evenals het ASCII teken dat overeenkomt met de laatste 8 bits van het geheugenwoord. Zonodig kunnen de verschillende representaties worden aan- en uitgezet via de rechtermuisknop. Hiermee kan ook een nieuwe view worden geopend en kan de pagina worden ingesteld waarop het window uitkijkt. De ZEP2 kan 64K geheugenplaatsen van 16 bit aansturen. 35

38 Dit denken we verdeeld in 256 pagina s van 256 woorden. Omdat we geheugenadressen altijd hexadecimaal noteren loopt het paginanummer van 00 tot FF. Er zijn maximaal 3 verschillende pagina s tegelijk zichtbaar te maken. D. Laat de ZEP2 de code uitvoeren Nu is het dan eindelijk tijd de processor aan het werk te zetten. Druk op de knop ZEP2 en de processor verschijnt. Als u een computerscherm 800*600 heeft zal de processor in een iets kleiner formaat opstarten. Voor een eerste bestudering kan de afmeting van de processor beter wat vergroot worden. Gebruik de rechtermuisknop en kies Size:300*400. De getoonde processor is vrijwel gelijk aan de ZEP1-processor uit het boek (figuur 3.8), maar is uitgebreid met twee registers SP en T1 en een extra bitje in het statusregister. Het datapad van de ZEP2 We zien de userregisters R1 en R2, de PC (Program Counter) en SP (Stack Pointer) met witte achergrondkleur. Dit geeft aan dat deze registers op dit moment actief zijn. Daarnaast zien we de ALU met registers A, B en C; het instructieregister IR en een hulpregister T1. Deze vijf zijn alle grijs van kleur, dit dient om aan te geven dat deze registers voor de gebruiker eigenlijk onzichtbaar zijn! De resultaten van de ALU staan in het statusregister dat de bits N, Z, V en C kent. Daarnaast is een bitje Istat zichtbaar dat de interruptstatus aangeeft. Alle registers zijn verbonden via een interne bus. Het MDR en MAR vormen de verbindingen met de databus en de adresbus in de buitenwereld. Hierbij is het MDR dubbel uitgevoerd, zodat het zowel door de binnenbus gelezen en geschreven kan worden als door de buitenbus. De besturing van de ZEP2 Intern wordt de processor gestuurd door opeenvolgende microcodes, die iedere klokslag zorgen voor een registerregister transfer en de instelling van de ALU (dit wordt meer uitgebreid in het gebruikershandboek beschreven). Onder aan de processor is een besturing voor de gebruiker. De knop Reset zorgt dat de Program Counter de waarde aanneemt van het begin-label van het geassembleerde programma. De stackpointer wordt op de default waarde 7FFF gezet. (De twee startadressen zijn in te stellen via het menu via Options Assembler options, maar kunnen ook eenvoudig in het te assembleren programma worden ingesteld.) De knop Go zet de processor aan het werk. De processor begint continu instructies uit te voeren en eindigt pas wanneer hij een HALT instructie tegenkomt dan wel de gebruiker een breakpoint in de code heeft gezet. Op het zetten van breakpoints komen we later terug. De knop Halt onderbreekt het programma en de processor wacht op verdere actie De knop Instruction laat de ZEP2 een enkele instructie uitvoeren De knop Clock laat de ZEP2 een enkele klokslag uitvoeren. Dit betekent dat het microcodeniveau zichtbaar wordt: alle registers worden actief en de microcode die aan de beurt is voor de volgende klokslag wordt zichtbaar. Hierover later meer. Acties Zorg dat de volgende windows tegelijkertijd in beeld zijn: 1. de ZEP2 Processor 2. de Source van het programma (intro.asm) 3. page 0 van het Memory Dit vereist mogelijk enig geschuif. U kunt plaats en afmetingen van de verschillende windows bewaren met het menu via Window Store distribution. Wanneer later, na een en ander veranderd te hebben, de optie Window Distribute gekozen wordt, worden alle windows weer in de oorspronkelijk gekozen opstelling neergezet. 36

39 Druk op knop 2 van de editor zodat de tekstfile geassembleerd wordt en in het geheugen geschreven (als dit niet al eerder gebeurd was). Geef een Reset. Omdat het begin-label op adres 0 staat, zal de PC geladen zijn met De stackpointer staat op 7FFF (maar de stack wordt in dit programma niet gebruikt). Alles staat klaar om de eerste instructie (LOAD R1, 1000) uit te voeren. In de source zien we dat de regel die aan de beurt is te worden uitgevoerd, rood is gekleurd. Ook in het geheugen is de stand van register PC (de program counter) terug te vinden door een dubbele streep vooraan het geheugenadres. U kunt in het geheugen dus altijd zien welke instructie op de nominatie staat uitgevoerd te worden. Druk op de knop Instruction We zien dat instructie uitgevoerd is. In register R1 van de processor verschijnt de waarde 3E8, wat de hexadecimale waarde is van het getal De PC heeft de waarde 0002 aangenomen, dat komt omdat de instructie twee woorden lang was. In de source en het geheugen zien we de volgende instructie aangewezen. Druk weer op Instruction. Op dezelfde manier is nu in register R2 de waarde 0010 verschenen Druk weer op Instruction. R1 wordt gedecrementeerd Druk weer op Instruction. De waarde 3E7 (= 999 decimaal) verschijnt in het geheugen op geheugenplaats 0010 Druk weer op Instruction. Register R2 wordt geïncrementeerd en wijst nu naar het volgende adres Druk weer op Instruction. De waarde van R1 wordt vergeleken met 990. Dit gebeurt door de twee waarden in de ALU van elkaar af te trekken. Gelijkheid wordt geconstateerd wanneer het Z(ero)-bit 0 zou worden. Dit is niet het geval, dus: Druk weer op Instruction. De computer test het Z-bit en maakt een sprong terug naar loop. De terugloop komt tot stand doordat de waarde FFF9 (-7) wordt opgeteld bij de PC! Deze waarde was met de BNE instructie meegegeven. Raadpleeg hiervoor het geheugen of de assembler output. We hebben nu éénmaal de loop doorlopen, de rest gaat net zo, dus druk op Go. De processor doorloopt de loop nog een aantal malen. In het geheugen zien we de waarden 999 tot en met 990 verschijnen. De processor stopt omdat het Zerobit wordt gezet (we zien dit in de eindsituatie nog staan) en hij een HALT-instructie tegenkomt. We zien dus de PC na deze instructie wijzen, en in de source de regel oplichten die op HALT volgt, te weten end. We zien in het geheugen achter de waarden 999 t/m 990 vreemde tekens en instructies verschijnen. Dat vreemde tekens ontstaan omdat de waarden geïnterpreteerd worden als ASCII karakters. De waarden van de laatste 8 bits zijn groter dan 128 en vallen buiten de ASCII tabel, dus de tekens die we hier zien zijn niet standaard. De instructies die erachter staan komen tot stand doordat de disassembler alles, dus ook data, als instructies beschouwt! Omdat er geen instructie is met de waarde 0, staat op lege geheugenplaatsen een streepje, maar bij willekeurige data komen er willekeurige instructies en streepjes te staan. 5. Breakpoints Om te zorgen dat we een programma kunnen onderbreken op een bepaalde plaats, kunnen we één of meer breakpoints zetten. Dat gaat als volgt: Zet in de source-tekst een hekje (#) op de plaatsen waar gestopt moet worden. Druk op de knop Validate Breakpoints (de knop met het hekje, naast de drie assemblerknoppen). Hierna zijn alle breakpoints die in de source staan geldig. Om een breakpoint weer kwijt te raken, moet het hekje uit de sourcefile verwijderd worden en weer op de validate-knop worden gedrukt. Denk erom dat verder aan de tekst niets veranderd wordt, anders moet het programma opnieuw geassembleerd worden (knop 2 of 3) en moet de ZEP2 weer vooraan beginnen. Acties Zet in de sourcetekst een hekje vóór de instructie inc R2;. Zet met behulp van de rechtermuisknop de geheugenpagina op 0 (via Clear this page). Druk op de derde knop van de editor (Load program and run). 37

40 In de editor wordt de regel van het breakpoint rood gekleurd. In het geheugen zien we dat de waarde 999 al opgeslagen is, maar de rest nog niet. Wanneer we enkele malen bij de processor op de Go-knop drukken, zal steeds een volgende 'loop' worden doorlopen en het betreffende getal in het geheugen verschijnen. Als u er eerder genoeg van heeft, verwijder dan het breakpoint op de wijze als boven omschreven en druk opnieuw op Go. Nu wordt de rest van het programma in één slag doorlopen. Vanaf een breakpoint kunnen we met de knoppen Instruction, Clock of Go verder gaan. 6. Clockcycles en microcode Met de knop Clock van de processorbesturing krijgt de processor een klokpuls. Iedere klokpuls staat een microcodewoord klaar in het microcoderegister waarbij een bitje op de juiste plaats de lees- of schrijfacties van een register aangeeft. Er is ook een veldje dat de instelling van de ALU bepaalt. Het microcode-register vinden we onderaan de processor. Dit is leuk om te zien, maar we hebben er niet veel aan! Gelukkig wordt de code vertaald door een microcode-disassembler (een hele mondvol!) die het schrijven van de registers onder woorden brengt. Zo wordt de instructie binnengehaald (fetch) met drie microcodes. Een rijtje microcodes wordt hier een sequence genoemd. Aan de hand van de architectuur van de ZEP2 valt na te gaan welk resultaat de microcodes hebben, maar u kunt dit straks ook in de simulatie zien. De fetch sequence A := PC ; MAR:=PC ; ALU:=_INC; PC:= C ; MDR:=MEM; IR:= MDR; Wanneer de instructie binnen is, worden enkele bitjes in de instructie getest. ls het zogenaamde immediate bit gezet (zie figuur 2), dan moet ook het volgende woord worden binnengehaald. Dit wordt naar het T1 register geloodst. opcode 1 e cijfer opcode 2 e cijfer Operand 1 imm ind operand Figuur 2. Het instructieformaat van de ZEP2 De immediate sequence A :=PC ; MAR:=PC ; ALU:=_INC; PC:=C ; MDR:=MEM; T1:=MDR; Nu is het mogelijk dat we er nog niet zijn, omdat ook het indirect bit van de instructie gezet is. In dat geval moet het woord in het T1 register beschouwd worden als een geheugenadres en het woord dat erbij hoort, worden opgehaald. Dat gebeurt met: De indirect sequence MAR := op2; MDR := MEM; T1 := MDR; Nu wordt de instructie zelf actief en de microcodes voor de binnengehaalde instructie worden uitgevoerd. Als voorbeeld nemen we hier de instructie INC R1. Deze wordt uitgevoerd met A := op2; ALU := _INC; R1 := C ; Wanneer na afloop van de instructie een resultaat naar het geheugen moet worden teruggeschreven (dit geldt voor een beperkte set instructies), volgen na de instructie nog twee extra clockslagen: 38

41 De afterstore sequence MDR := T1 ; MEM := MDR; En het resultaat staat in het geheugen. Voorbeelden van microcode sequences In figuur 3 is een aantal voorbeelden van instructies gegeven. Achter iedere instructie staan de sequences die worden uitgevoerd. instructie fetch immediate indirect opcode afterstore INC R1; X x INC (R1) x x x x INC (0X1234) x x x x x ADD R1, R2 x x ADD R1, (R2) x x x ADD R1, 100 x x x ADD R1, (0X1234) x x x x Opcode is de sequence die bij de opcode van de specifieke instructie hoort. De fetch sequence is altijd nodig. De immediate sequence is nodig wanneer een extra datawoord of adres moet worden binnengehaald (registers passen in het eerste woord). De opcode sequence is altijd nodig en wordt door de instructie bepaald. De indirect sequence is nodig wanneer de meegegeven operand als het adres van de eigenlijke operand moet worden beschouwd. De afterstore is nodig wanneer een indirecte source-destination operand is meegegeven. Zie voor meer informatie de handleiding van de ZEP processor. Acties Zorg dat de sourcefile, de ZEP2 en geheugenpagina 0 in beeld zijn. Maak de geheugenpagina schoon met de rechtermuisknop (Clear this page). Druk op de tweede knop van de editor (Load program in main memory). Druk eerst op Reset. De instructie LOAD R1, 1000 staat nu op de nominatie te worden uitgevoerd. In het statusveld boven de meest linkse knop wordt aangegeven dat de fetch cyclus aan de beurt is. De eerstvolgende microcode is ook af te lezen: A := MAR := PC ALU := _INC (de eerste twee microcodes worden samengetrokken. Het PC register moet dus zowel door het MAR als door het A register worden overgenomen). Druk op de knop Clock en houdt hem ingedrukt. Alle interne registers lichten op: we gaan het microcodeniveau bekijken en daarin zijn alle registers zichtbaar. De PC licht groen op ten teken dat die wordt gelezen en zijn data op de interne bus mag zetten. Laat de knop los. De registers A en MAR worden geel gekleurd: deze hebben op de achterflank van de klokpuls de data op de bus overgenomen. Verder heeft de ALU te kennen gegeven te zijn gezet op de functie _INC. (De underscore dient om de ALU-functie te onderscheiden van de gelijknamige instructie). De volgende microcode staat al klaar in het microcode-register. De uit te voeren sequence is nog steeds de fetch. In het C register staat de output van de ALU al klaar. Geef de volgende klokslag. Wanneer u de memory page hebt open staan ziet u dat in dat geval een geheugenwoord wordt gelezen en via de databus naar het MDR wordt geschreven (acties op de buitenbus worden met blauw aangegeven). Tegelijkertijd wordt via de binnenbus de door de ALU geleverde waarde naar de PC teruggeschreven. Bij de volgende klokslag wordt de data van het MDR over de binnenbus naar het instructieregister IR geschreven. 39

42 Ga na dat inderdaad het eerste gedeelte van de von Neumann cyclus door de processor is uitgevoerd. In het IR wordt onmiddellijk met de decodering van de instructie begonnen. De hexwaarde is 0C30. Het immediate bit (het 5e bit van achteraf) blijkt 1 te zijn. Dit is te controleren in het geheugen, waar immers ook de binaire waarde staat. Dit heeft tot gevolg dat eerst de immediate sequence uit de mc- ROM wordt uitgevoerd. We zien deze sequence al klaar staan, evenals de eerste microcode. Geef 3 klokslagen en controleer de status van de processor. Het blijkt dat de PC nogmaals geïncrementeerd is en het binnengehaalde woord (de waarde 03E8, het tweede woord van de instructie) terecht is gekomen in register T1. Nu is kennelijk de LOAD sequence aan de beurt, dus de instructie zelf is aan zet. De bijbehorende microcode vinden we weer in het mcregister: de waarde in T1 moet naar R1 en bovendien naar het A-register. Dit laatste heeft het voordeel dat de binnengehaalde waarde al meteen een test heeft ondergaan en de resultaten meteen beschikbaar zijn in het N en Z bit van het statusregister. Geef één klokslag en controleer weer de status. Kennelijk is de instructie klaar: de fetchcyclus is alweer klaargezet. De waarde 3E8 staat in register R1, wat de bedoeling van de instructie was. De interne registers MAR, MDR IR, T1, A en C hebben allemaal nog waarden staan, maar die worden niet meer gebruikt: de volgende instructie gaat binnengehaald worden! In de uitgebreide handleiding is het instructieformaat, de mogelijke adresseringswijzen, de mogelijke instructies en dergelijke na te gaan. Alle sequences zijn te vinden in microdefs.mca (zie hiervoor de volgende paragrafen. U laat het microcodeniveau weer in de steek door op de knop Instruction of de knop Go te drukken. In dat geval blijven alleen de vier gebruikersregisters helder: de waarden in de andere registers zijn nog wel te lezen, maar niet meer van belang op het machinecode- of assemblerniveau. De microcode ROM Alle sequences zijn te vinden in de microcode-rom van de ZEP2. We kunnen de inhoud van deze ROM bekijken. Kies in het hoofdmenu View Microcode ROM. De file is voorzien van een randje waar de betekenis van de microcodes is te vinden en van een (microcode-)disassembler. De standaard sequences fetch, immediate, indirect en afterstore vinden we onderaan. Als we de sequence voor de INC instructie opzoeken, zien we dat in de microcode deze instructie niet voor alle registers staat uitgewerkt, maar werkt op een operand die hier op2 wordt genoemd. De instructiedecoder bepaalt welke operand gevraagd is en vertaalt 'on the fly' de operand naar het register dat in de instructie genoemd staat. De file microdefs.mca Alle sequences die in de ZEP2 kunnen voorkomen zijn gedefinieerd in de file microdefs.mca. De extensie mca betekent " microcode assembler". Deze file wordt bij het opstarten van de ZEP2 automatisch gelezen, vertaald naar microcodes en in de microcode ROM geplaatst. Een kopie is opgenomen in de sources directory. Als u File Open Microcode Source (*.mca) kiest, krijgt u hem te zien. Binnen de ZEP2 omgeving kan ook dit bestand geëdit en geassembleerd worden. Het is dan mogelijk zelf instructies bij te maken of zelfs een compleet nieuwe instructieset te ontwerpen. In hoofdstuk 9 wordt hiervan een voorbeeld gegeven. Begin hier pas aan als de werking van de ZEP2 geheel begrepen is! 7. Het Applicatieniveau en Operating System Calls Wanneer de ZEP2 in een compleet microprocessorsysteem is opgenomen, hoort er ook een operating system (OS) bij, dat de belangrijkste interactie met de omgeving verzorgt. De gang van zaken is daarbij als volgt: Gebruikersprogramma s kunnen het Operating System aanroepen via de API (Application Programming Interface). De afkorting API staat voor de verzameling diensten van het OS. Deze diensten worden aangeroepen door speciale instructies, OS-calls genaamd. In eerste instantie gaat het om I/Oopdrachten. Die houden in: 40

43 1) interactie met een terminal ( = toetsenbord en monitor) 2) interactie met het file systeem 3) interactie met randapparatuur als printers In versie 0.1 van de ZEP simulator is een aantal OS-calls op tekstueel gebied geïmplementeerd. In volgende versies van de ZEP2 simulator zullen ook grafische mogelijkheden en filehandling worden toegevoegd. Alle systemcalls worden door een enkele instructie CALL <nr> verzorgd. Deze instructie is een software interrupt, die onder andere de status van de processor verhoogt. Bij een echte processor wordt in zo n geval een vaste interruptvector opgehaald, die wijst naar code in het operating system. Bij de ZEP2 wordt het operating system grotendeels overgelaten aan Windows, zodat het effect van deze instructie niet op ZEP-niveau gevolgd kan worden. Waarschuwing: bij een OS-call die om input vraagt, hangt de processor, totdat de input is geleverd! Het systeem kan dan niet met de Halt knop tot de orde worden geroepen, omdat de instructie niet is afgemaakt. Pas nadat de input is geleverd, wordt de processor gestopt. De Reset knop werkt wel onmiddellijk, maar die is destructief, zodat het programma weer naar het begin wordt teruggezet. Acties We beginnen met een ander voorbeeldprogramma, grondtal.asm, dat een oplossing levert voor een opgave in het boek: Schrijf een programma dat, gegeven een decimale waarde en een grondtal, de juiste code bij dit grondtal afdrukt. Sluit alle (sub)windows die openstaan in de simulator. Als de introfile gewijzigd is kunt u deze bewaren. Open de source-tekst grondtal.asm. Open page 0 van het memory en maak de pagina schoon. Druk nu meteen op de derde knop van de editor (assemble, load en run). Het programma wordt geassembleerd, het ZEP2 window geopend en de processor gestart. Wanneer de processor een CALL tegenkomt die uitvoer of invoer vraagt, wordt automatisch nog een nieuw window geopend: het applicatieniveau. Dit is het monitorscherm voor de ZEP2 processor, dat gebruikt kan worden voor de ZEP2-programma s. Er staat op: Voer een getal in =>. Vul een (niet te groot!) decimaal getal in, bijvoorbeeld het getal 1000, gevolgd door <Enter>. Het programma vraagt nu: en een grondtal => Vul een grondtal in, bijvoorbeeld 16, gevolgd door <Enter> Het programma geeft dan: waarde is: 3E8 en vraagt weer om een volgend getal. Herhaal dit enige malen voor verschillende waarden en grondtallen <=16. Om het programma te stoppen moet op Enter worden gedrukt zonder een getal in te vullen. Op de Reset-knop drukken kan natuurlijk ook altijd. 41

44 Als we het assemblerprogramma bestuderen komen we een aantal nieuwe dingen tegen. Includefiles #include <system calls.asm> Deze regel zorgt ervoor dat het stukje asm programma dat system calls heet, op die plaats in de sourcetekst wordt meegenomen. U kunt deze file ook openen (hij is te vinden in de directory ZEP2\include) en zien dat hier uitsluitend een aantal constanten wordt gedefinieerd: _charout equ 0x01 ; _charin equ 0x02 ; _strout equ 0x03 ; _strin equ 0x04 ; _valout equ 0x05 ; _valin equ 0x06 ; // ASCII chars _RETURN equ 0x0D ; _TAB equ 9 ; _BACK equ 8 ; // backspace Constanten definiëren Het directief equ definieert een constante. De constante _charout krijgt de waarde 0x01 (dit is de waarde 1, hexadecimaal geschreven), enzovoort. De underscore vooraf is gewoon een toegestaan letterteken. Het wordt vaak gebruikt om systeemconstanten te definiëren, zodat ze niet verward worden met andere constanten die we zelf willen definiëren. Hierbij hoort wel de afspraak dat we in onze eigen sources geen constanten definieren die beginnen met een underscore. 42

45 Operating system calls De gedefinieerde constanten zijn de waarden, die bij het aanroepen van het operating systeem moeten worden meegegeven. Om deze aanroep te doen wordt de ZEP2-instructie CALL <nr> gebruikt. Operating system calls zorgen voor de I/O, in dit geval de data-uitwisseling met het monitorscherm van de ZEP2. Zo zorgt de instructie CALL 1 dat de waarde in register R1 als een ASCII teken naar het scherm wordt geschreven. De instructie CALL 2 zorgt ervoor dat het monitorscherm actief wordt, en de eerstvolgende toets die wordt ingedrukt als een ASCII waarde in register R1 verschijnt. De waarden 3 en 4 (_strin en _strout) schrijven of lezen een string waarvan het adres in register R2 staat. De waarden 5 en 6 (_valout en _valin) schrijven of lezen een decimale waarde van of naar R1. Zie voor de precieze protocollen de gebruikershandleiding van de ZEP2. Strings Het operating system van de ZEP2 hanteert de afspraak dat een string een opeenvolging van ASCII tekens is, die wordt afgesloten met de waarde 0. In iedere 16-bit geheugenwaarde wordt een enkel ASCII teken opgeslagen; de eerste 8 bits worden daarbij niet gebruikt. In de assemblercode kunnen we gemakkelijk een string opnemen, zie bijvoorbeeld het directief STR in de code: mess1 str "voer een getal in => " ; Dit zorgt ervoor dat een string in de code wordt opgenomen, waarbij de naam mess1 staat voor het adres van die string. Het resultaat kan gemakkelijk gecontroleerd worden door page 0 van het geheugen te bestuderen. Als we een string willen uitvoeren naar het scherm, moeten we de waarde mess1 laden in register R2 en vervolgens het operating system aanroepen met de waarde 3. Achtereenvolgens: mess1 equ voer een getal in => ; load R2, mess1 ; call _strout ; // ' call 3 ' werkt natuurlijk ook. In het programma wordt de zaak bij wijze van voorbeeld iets anders opgelost: strout (zonder underscore) is hier het adres van een subroutine, die de string afdrukt, alleen gebruikmakend van de oscall _charout. Zo kan het dus ook! Subroutines Dit programma is ook geschikt om het effect van de instructies BSR, JSR en RET te bestuderen. Bij deze instructies wordt de stack gebruikt om het terugkeeradres op te slaan. De regel STACK equ 0x01FF in de source zorgt ervoor dat de stack gevonden wordt onderin page 01; om dit te bekijken kan een extra memoryview worden geopend. Schoon deze pagina op voordat de code wordt uitgevoerd. Zet breakpoints bij de BSR en JSR calls, dan kan het effect van de instructie precies bestudeerd worden. JSR is een absolute, en BSR een relatieve sprong. Ga het verschil na in het geassembleerde programma. Het valt ook na te gaan in de microcode van de betreffende instructies. Deze kan weer bestudeerd worden door vanaf de breakpoints met de Clock-knop door de instructie heen te lopen. Voor meer informatie omtrent #include, strings, operating system calls en software interrupts raadplege men de handleiding van de ZEP2 processor. 8. Zelf instructies maken Als laatste een voorbeeld hoe zelf een instructie te ontwerpen en te implementeren is. Stel we willen de instructie SADD maken. SADD (Stack Add) is een instructie zonder operanden die zorgt dat de twee waarden van de top van de stack gehaald worden, bij elkaar opgeteld en het resultaat weer op de stack gezet (zie het boek, figuur 3.19). Hiervoor moet een groot aantal acties verricht worden. 43

46 Uit het handboek blijkt (we kunnen dit nagaan in de microcode file) dat de stackpointer van de ZEP2 altijd naar de eerste vrije plaats wijst en de stack van boven naar onder in het geheugen loopt (de stapel groeit dus naar benden toe aan). De acties zouden dus moeten zijn: 1. SP wordt verhoogd 2. top van de stack naar het B-register 3. SP wordt verhoogd 4. top van de stack naar het A-register 5. ALU := _ADD 6. C-register naar de stack 7. SP wordt verlaagd. De eerste 2 acties komen ongeveer overeen met de instructie POP. We kunnen in de file microdefs.mca zoeken naar de manier waarop hier de microcodes gedefinieerd zijn. We vinden bij POP: #POP op1; 0X1F // SP incrementeren A := SP; ALU := _INC; SP := C; //stack->op2 MAR := SP; MDR := MEM; op2 := MDR; A:= MDR; ALU := _TST; // om de CC te zetten voor dit item Microcode syntax (zie de handleiding) Op de eerste regel van een instructiedefinitie staat: #<naam> <operanden> ; <opcode> <naam> is de assemblernaam van de instructie, bijvoorbeeld JSR <operanden> hier wordt aangegeven met hoeveeel operanden de instructie werkt. mogelijkheden zijn op1,op2 (2 operanden), op2 (1 operand) en <leeg> (geen operanden) Iedere volgende regel (afgezien van de lege en/of commentaarregels) bevat één microcode, dus wordt in een enkele klokslag verricht. Er zijn twee soorten microcode statements mogelijk: <register> := <register> ; ALU := <alufunctie> ; <register> kan zijn R1, R2, T1, SP, PC, MDR, MAR, A, B, C, en MEM. Daarnaast zijn de symbolische operanden op1 en op2 geoorloofd. <alufunctie> kan zijn _ADD, _DEC, etc (zie hiervoor de tabel in de handleiding). Er mogen meerdere statements in een enkele microcode voorkomen. Het geheugen (register MEM) kan alleen gecombineerd worden met het MDR. Bij meerdere gelijktijdige acties over de binnenbus mag maar 1 register aan de rechterkant van de vergelijking staan: A := R1; B := R1; // dit is toegestaan. A := R1; B := PC; // dit is niet toegestaan. 44

47 NB: de microcode-assembler controleert dit niet en maakt braaf code aan, maar bij twee gelijktijdige READ acties zijn de resultaten op de bus uiteraard niet meer gedefinieerd en de ZEP2 zal de microcodes niet correct kunnen uitvoeren. De ALUfunctie moet gezet worden juist voorafgaande aan de microcode die de functie gaat gebruiken. De symbolische operanden op1 en op2 hebben ieder een bitje in de microcode store, maar worden tijdens de uitvoering van de instructie door de instructiedecoder in de ZEP2 vertaald naar het actuele register. Wanneer bijvoorbeeld de instructie ADD R1, R2 wordt uitgevoerd, worden de R- en W-bits voor de operanden op1 en op2 omgeschakeld naar de R- en W-bits voor de werkelijke operanden R1 en R2. De SADD instructie Nu gaan we onze instructie maken. We hebben geen operanden en daarom luidt de eerste regel #SADD; <opcode> Opcode is een 8-bits waarde (zie figuur 2). Deze waarde zou willekeurig te kiezen zijn, althans voor zover er nog waarden vrij zijn in de bestaande instructieset, maar de filosofie bij de ZEP is dat de instructies verdeeld zijn in groepen met bepaalde kenmerken (zie daarvoor de handleiding). U wordt daarom verzocht een nummertje te kiezen in de groep E: user defined instructions without operands. We kiezen 0XE1 en de eerste regel wordt: #SADD; 0XE1 De eerste twee acties waren 1. SP wordt verhoogd 2. top van de stack naar het B-register, We laten ons inspireren door de code bij POP en schrijven // SP incrementeren A := SP; ALU := _INC; SP := C; // top naar B register MAR := SP; MDR := MEM; B := MDR; We herhalen dit voor het tweede item en stellen dan meteen de ALU in // SP incrementeren A := SP; ALU := _INC; SP := C; // top naar B register MAR := SP; MDR := MEM; A := MDR; ALU := _ADD; Nu moet het C register teruggeschreven worden naar de stack. De Stackpointer staat nog in het MAR zodat we in twee instructies klaar kunnen zijn. // Resultaat weer naar de stack terugschrijven MDR := C; MEM := MDR; En dan moet de stackpointer nog verlaagd worden om weer naar het eerste vrije item te wijzen: A := SP; ALU := _INC; SP := C; Dit heeft 14 microcodes gekost. Het gaat net goed: er geldt een maximum van 16 microcodes per sequence! Vraag: hadden we ook eerst het A- en vervolgens het B-register kunnen vullen? 45

48 Acties Open een nieuwe file voor microdefinities: File New Microcode File We zien dat de file niet nieuw is! Hij heeft weliswaar nog geen naam (noname.mca), maar alle microcodes van de ZEP2 staan er wel al in! De reden is dat het vrijwel nooit nodig zal zijn een complete nieuwe microcode file te schrijven: het gaat altijd om enkele instructies die veranderd, verwijderd of bijgemaakt moeten worden. Ook de standaard sequences staan in deze file, en het lijkt niet echt leuk om die allemaal opnieuw te moeten definiëren! In een nieuw bestand wordt dus de standaardcode uit de file microdefs.mca meteen voor geladen. We gaan een instructie bijvoegen; dat kan op iedere plaats, dus kies het begin van de file, meteen na de twee kruisjes. Tik daar de volgende tekst in: ## #SADD; 0XE1 // de code 0xE1 is nog vrij, groep E is voor 0-operand // instructies bedoeld (zie de handleiding) // SP incrementeren A := SP; ALU := _INC; SP := C; // top naar B register MAR := SP; MDR := MEM; B := MDR; // SP incrementeren A := SP; ALU := _INC; SP := C; // top naar A register MAR := SP; MDR := MEM; A := MDR; ALU := _ADD; // C naar de stack MDR := C; MEM := MDR; // Stackpointer verlagen A := SP; ALU := _DEC; SP := C; Kies vervolgens eerst de linkerknop op het window (Assemble microcode) en kijk of de zaak syntactisch OK is. Zo niet, corrigeer de code. Zo ja, druk op knop 2 (Load microcode to MCROM). Alle sequences worden nu opnieuw geassembleerd en de MCROM wordt opnieuw gevuld. Hiermee is de instructie SADD toegevoegd aan de instructieset van de ZEP2. 46

49 Als al dit werk u nog niet te droevig heeft gestemd, kunt u e.e.a. uitproberen aan de hand van een assembler filetje, bijvoorbeeld: Begin PUSH 0X1111; PUSH 0X2222; SADD; POP R1; HALT; Bij intikken ziet u dat de instructie SADD inderdaad bekend is, althans als u de syntaxcoloring aan heeft staan. Als alles gelukt is, moet dit programmaatje het resultaat 0X3333 in register R1 achterlaten. De gewijzigde microcode file kan nu opgeslagen worden onder een naam (ZEP2 met stack instructie.mca bijvoorbeeld) en later opnieuw geladen, geassembleerd en gebruikt worden. 47

50 5.1 Voorbeeldprogramma`s In de map 07 Simulatie programma`s\ ZEP2 (processor, geheugen en assembler programmeren) \sources en \sources 2 staan enkele voorbeeldprogramma`s. countdown.asm Het volgende is een eenvoudige demonstratie van de werking van de ZEP2 assembler. Het getal FFFF wordt in een register opgenomen en vervolgens leeggeteld tot het decimale getal 500. Het resultaat kan gevolgd worden in de processor en in het geheugen. Verder is het aardig om de werkelijke (klok)snelheid van de simulator te bepalen (hierbij wel de store instructie en/of het geheugen uitzetten!)en om het effect van een breakpoint te bestuderen. ## ORG 0X10; result res 1; dat0 dat 0XFFFF; res 1; // om de disassembler in het goede spoor te krijgen! begin load R1,(dat0); noges dec R1; store R1, (result) ; # cmp R1, 500; bne noges; halt; end; ## 48

51 grondtal.asm Een opgave uit het boek: Vraag decimaal getal en een grondtal < 10 en geef aan hoe het resultaat eruit ziet De cijfers komen in een string te staan ## // OS calls #include <system.asm> // dataruimte reserveren org 0x0000 ; x res 1 ; // voor getal y res 1 ; // voor grondtal string res 16 ; // output max 16 cijfers mess1 str "voer een getal in => " ; mess2 str " en een grondtal => " ; mess3 str ";waarde is: " ; STACK equ 0x0100 ; // stack in page 1 begin load SP, STACK; // eerst de stack ergens situeren load r1, _return ; call _charout ; // begin op nieuwe regel load r2, mess1 ; bsr strout ; call _valin ; cmp r1, 0 ; // escape route beq einde ; store r1, y ; load r2, mess2 ; jsr strout ; call _valin ; cmp r1, 1 ; ble einde ; // 1 of 0 gaat fout. store r1, x ; load r2, mess3 ; call _strout ; // de voorbereidingen zijn voltooid load r2, string ; // vooraan beginnen loop load r1, (y) ; mod r1, (x) ; // rest bepalen store r1,(r2) ; // r2 is adresregister inc r2 ; load r1, (y) ; div r1, (x) ; // quotient bepalen store r1,(y) ; bne loop ; // klaar en nu getal uitvoeren. dec r2 ; uitvoer load r1, (r2) ; //van achter naar voren uitvoeren jsr uitcijf; dec r2 ; cmp r2, string-1; // vooraan de string bne uitvoer ; // volgende cyclus bra begin ; 49

52 uitcijf cmp r1, 9 ; bgt letter ; // letter voor cijfer call _valout ; // moet 1 cijfer zijn ret ; letter add r1, 'A - 10 ; call _charout ; ret ; einde halt ; // uitvoer string waarvan adres in R2 strout load R1,(R2) ; beq ready ; call _charout ; inc R2 ; bra strout ; ready ret ; // invoer string naar adres dat in R2 staat // eindigt met een nul // wanneer de gereserveerde geheugenruimte // afgesloten wordt met FFFF wordt deze marker // niet overschreden en de string evt afgebroken. // in dat geval wordt deze inhoud vervangen door de // afsluitende nul. Omdat de FFFF dus mogelijk verdwijnt // moet die voor de operatie eventueel steeds gezet worden strin load R1, (R2) ; // check de afsluiter cmp R1, 0XFFFF; beq afsluit ; // char van keyboard next call _charin ; cmp R1, _RETURN; beq afsluit ; call _charout ; // en dan afdrukken store R1, (R2) ; inc R2; ; bra strin ; afsluit load r1, 0X0 ; store r1, (R2) ; klaar ret ; ## end ; 50

53 helloworld.asm Druk ^ hier om het programma te starten! De eerste opgave voor iedere nieuwe programmeertaal: ******************* "Hello World!" ***************** // Een dubbel kruisje geeft het begin van het programma aan ## // CONSTANT DEFINITIONS // OS call charuit equ 0x01 ; clrscr equ 0x08 ; // stackpointer at end of first page STACK equ 0XFF ; // Message newworld str "Hello World!" ; // MAIN PROGRAM begin load SP, STACK ; // eerst de stack ergens situeren call clrscr ; // scherm schoon load R2, newworld ; jsr strout ; einde halt ; strout load R1,(R2) ; beq ready ; call charuit ; inc R2 ; bra strout ; ready ret ; ## // en een dubbel kruisje eindigt het programma //SUBROUTINE STROUT // print 0-terminated string at address in R2 51

54 multiply.asm Het algoritme voor vermenigvuldiging van twee getallen, omgezet in een programma dat alleen gebruik maakt van schuiven en optellen. De getallen worden eerst (binair) binnengehaald en opgeslagen in de variabelen x en y. Vervolgens wordt door rechts schuiven (test op 1) en door linksschuiven (met 2 vermenigvuldigen) het resultaat bepaald. Er is voorzien in overflow detectie, maar die zou nog wel wat verbeterd kunnen worden. ## // OS calls getalin equ 0x06 ; getaluit equ 0x05 ; stringuit equ 0x03 ; charuit equ 0x01 ; RETURN equ 13 ; org 0x0000 ; x res 1 ; y res 1 ; result res 2 ; mess1 str "(geef een getal) => " ; mess2 str " maal "; mess3 str " = " ; errmess str "Overflow!" ; endmess str "that's all folks!"; // dataruimte reserveren begin load r1, RETURN ; call charuit ; // begin op nieuwe regel load r2, mess1 ; call stringuit ; call getalin ; cmp r1, 0x0 ; // escape route beq einde ; store r1, y ; load r2, mess2 ; call stringuit ; call getalin ; cmp r1, 0X0 ; beq einde ; // ook hier store r1, x ; load r2, mess3 ; call stringuit ; // en nu de vermenigvuldiging load r1, 0X0 ; // zet som op nul load r2, (x) ; // veremingvuldigtal loop lsr r2 ; // rechtse bit in Carry bcc niet ; add r1, (y) ; // indien carry y bijtellen bvs error ; // overflow! niet cmp r2, 0X0 ; // al klaar? beq klaar ; lsl (y) ; bra loop ; klaar call getaluit ; 52

55 einde // volgende cyclus bra begin ; error load r2, errmess; call stringuit ; bra begin ; load r2, endmess; call stringuit ; halt ; end ; opgave 18a.asm ## // Opgave 18A uit het boek // schrijf een programma dat // vraagt om een binair getal // vervolgens wordt de decimale // waarde opgeleverd. ORG 0X0; charuit equ 1; getaluit equ 5; stringin equ 4; stringout equ 3; // definieer constanten // OS calls RETURN equ 13; // nieuwe regel karakter // ruimte reserveren voor een string van max 16 cijfers + afsluitende 0 bingetal res 17 ; // plaats maken voor het resultaat result res 1 ; // meer dan // boodschappen (strings): mess1 STR "Geef een binair getal => "; mess2 STR ". de decimale waarde is: "; // het eigenlijke programma begin load R1, RETURN; // op nieuwe regel beginnen call charuit ; load R2, mess1 ; call stringout ; load R2, bingetal ; call stringin ; load R1, (R2) ; cmp R1, 0X0 ; // alleen return ingevoerd beq klaar ; // dan einde programma // de string met enen en nullen staat nu in bingetal // eerst het resultaat op nul zetten: load R1, 0 ; store R1, (result) ; 53

56 // We werken van voor naar achter. Voor iedere volgende // positie schuiven we het getal 1 naar links // voor iedere 1 tellen we er 1 bij next load R1, (R2) ; // cijfer in R1 cmp R1, 0x0 ; // einde string? beq afsluiten ; // dan afsluiten asl (result) ; // result := result *2; inc R2 ; // R2 vast opschuiven cmp R1, '0 ; // als het een nul is beq next ; // dan verder niets doen inc (result) ; // anders 1 bijtellen bra next ; // en verder gaan afsluiten load R2, mess2 ; // de decimale waarde is: call stringout ; load R1,(result) ; call getaluit ; // het resultaat bra begin ; klaar halt ; ## N.B. Aan errorhandling is niets gedaan. Dat betekent in dit geval dat het invoeren van een te groot getal het programma beschadigt! opgave 18b.asm ## // Opgave 18B uit het boek // schrijf een programma dat // vraagt om een decimaal getal // vervolgens wordt de binaire // waarde opgeleverd. ORG 0X0 ; // definieer constanten #include <system.asm> // nieuwe regel karakter RETURN equ 13 ; decgetal res 1 ; // plaats maken voor het resultaat // ruimte reserveren voor een string van max 16 cijfers + afsluitende 0 result res 17 ; // 16 tekens + afsluitende 0 teller res 1 ; // ruimte voor een teller dat tot 16 kan tellen // boodschappen (strings): mess1 STR "Geef een decimaal getal => "; mess2 STR ". De binaire waarde is: "; 54

57 // het eigenlijke programma // begin call _clrscr; begin load R1, _RETURN ; // op nieuwe regel beginnen call _charout ; load R2, mess1 ; // message afdrukken call _strout ; call _valin ; // getal invoeren cmp R1, 0 ; // 0 ingevoerd? beq einde0 ; // dan einde programma store R1, (decgetal); // in decgetal staat het ingevoerde getal, maar // in binaire vorm! Nu moet dit vertaald worden // naar een string met de cijfers voor 1 en 0 load R2, mess2 ; // "de binaire waarde is: " call _strout ; load R1, 16 ; store R1, teller ; // we willen geen voorlopende nullen hebben. We gaan dus // naar links schuiven tot we de eerste 1 hebben. // we moeten wel bijhouden hoe vaak we geschoven hebben // in totaal moet het nl precies 16 * gebeuren // zoek de eerste 1 zoekmsb dec (teller) ; beq einde0 ; // als decgetal onverhoopt toch 0 zou zijn lsl (decgetal) ; bpl zoekmsb ; // het eerste bit is nog 0 (positief) // het eerste bit is nu een 1 druk1 bsr uit_1 ; next dec (teller) ; beq begin ; // we zijn kennelijk klaar, nog een? lsl (decgetal) ; bmi druk1 ; // het eerste bit is een 1 bsr uit_0 ; // het eerste bit is een 0 bra next ; einde0 bsr uit_0 ; // getal is 0: afdrukken einde halt ; // en stoppen uit_1 load R1, '1 ; // ASCII waarde van het cijfer 0 call _charout ; ret ; uit_0 load R1, '0 ; // ASCII waarde van het cijfer 1 call _charout ; ret ; ## 55

58 De map \sources 2 Getallen in het memory plaatsen.asm //Doel van het programma: // Dit programma definieert de stand van de programmateller op 0x20. // En bij het laden van het programma worden de getallen 1, 2, 3, 4 en 5 // achtereenvolgens in de geheugenadressen 0x20 t/m 0x24 geplaatst. ## begin // hier staat het programma. // enz. halt; ORG 0x20; // Directief ORG (orgin) definieert de stand van de programmateller. // In het register PC (program counter), staat nu 0x20. 0x20 is een variabele. DAT 1, 2, 3, 4, 5; // Directief DAT reserveert 5 woorden in het memory, woord 1 met inhoud 1 komt in // geheugenplaats 0x20, woord 2 met inhoud 2 komt in geheugenplaats 0x21, enzovoorts. // De getallen worden geplaatst tijdens het laden van het programma. // // DAT is van een label te voorzien bijvoorbeeld: tabel_1 DAT 1, 2, 3, 4, 5; // Het label is tabel_1. Het label is de naam van het adres 0x20 geworden. // Met tabel_1 + 1 wordt er naar het tweede getal gewezen. Bijvoorbeeld ook: tabel_ end // signaal voor het assemblerprogramma. ## 56

59 Programma met een tabel.asm //Naam opgave: Getallen in het memory plaatsen en deze getallen optellen en het resultaat op geheugenadres // adres 0X28 schrijven. //Doel van het programma: // Dit programma definieert de stand van de programmateller op 0x20. Bij het laden van het programma // worden ook de getallen 1, 2, 3, 4 en 5 achtereenvolgens in de geheugenadressen 0x20 t/m 0x24 geplaatst. // De getallen worden opgeteld en het resultaat wordt op adres 0X28 geschreven. ## begin load R1, (tabel_1); // Laad de inhoud van het adres tabel_1 in R1. (immediate, indirect) load R2, (tabel_1 + 1); // Laad de inhoud van het adres tabel_1 + 1 in R2. Geen haken: laad 0x21. add R1, R2; // load R2, (tabel_1 + 2); // add R1, R2; // load R2, (tabel_1 + 3); // add R1, R2; // load R2, (tabel_1 + 4); // add R1, R2; // store R1, result; // halt; ORG 0x20; tabel_1 DAT 1, 2, 3, 4, 5; 1 geheugenplaats ook: // ORG 0x28; result end // Directief ORG (orgin) definieert de stand van de programmateller. // In het register PC (program counter), staat nu 0x20. 0x20 is een variabele. // Directief DAT reserveert 5 woorden in het memory, woord 1 met inhoud // komt in geheugenplaats 0x20, woord 2 met inhoud 2 komt in // 0x21, enzovoorts. // De getallen worden geplaatst tijdens het laden van het programma. // // DAT is van een label te voorzien bijvoorbeeld: tabel_1 DAT 1, 2, 3, 4, 5; // Het label is tabel_1. Het label is de naam van het adres 0x20 geworden. // Met tabel_1 + 1 wordt er naar het tweede getal gewezen. Bijvoorbeeld // tabel_ // signaal voor het assemblerprogramma ## 57

60 Programma met invoer toetsenbord.asm //Benoem een aantal constanten///////////////////////////////////////////////////////////// aantaloptelgetallen res 1; huidiggetal res 1; totaal res 1; info str "Dit programma blijft zichzelf herhalen totdat u 0 invoert."; vraag1 str "Hoeveel getallen wilt u optellen? "; vraag2a str "wat is het "; vraag2b str " e getal? "; antw str "Totaal: "; theend str "Tot de volgende keer ;)"; overflow str "Overflow! Het programma herstart zich"; print equ 0x03; getalin equ 0x06; getaluit equ 0x05; /////////////////////////////////////////////////////////////////////////////////////////// begin // overnw load R1,1; // Zet startwaarden store R1,huidigGetal; // load R1,0; // store R1,aantalOptelGetallen; // store R1,totaal; // load R2,info; // Print wat informatie call print; // over hoe je het jsr ENTER; // programma gebruikt. load R2,vraag1; // Stel de vraag aan de gebruiker call print; // hoeveel getallen hij/zij call getalin; // wil optellen. Controleer cmp R1,0; // of de gebruik verder wil gaan. beq afrond; // Zonee, ga dan verder bij "afrond". store R1,aantalOptelGetallen; // Zoja, sla de gebruiker zijn jsr ENTER; // antwoord op. vraag jsr ENTER; // Stel de vraag aan de gebruiker wat load R2,vraag2a; // volgende getal is om op te tellen. call print; // load R1,(huidigGetal); // call getaluit; // load R2,vraag2b; // call print; // call getalin; // cmp R1,0; // Controleer of de gebruiker beq afrond; // wil stoppen. Zoja, ga dan verder add R1,(totaal); // bij "afrond". Zonee, tel dan het bvs overflw; // getal bij het totaal op. Controleer store R1,totaal; // of er overflow is. Zoja, ga dan verder load R1,(huidigGetal); // bij "overflw". Zonee ga dan verder. inc R1; // Kijk of er nog getallen over zijn store R1,huidigGetal; // om op te tellen. Zoja, ga dan verder load R2,(aantalOptelGetallen); // bij "vraag". Zonee, ga dan verder bij "tant". inc R2; // cmp R1,R2; // beq tant // bra vraag; // 58

61 tant jsr ENTER; // Laat het antwoord zien. load R2,antw; // Ga verder bij "overnw". call print; // load R1,(totaal); // call getaluit; // jsr ENTER; // jsr ENTER; // bra overnw; // afrond jsr ENTER; // Laat een afscheidsberichtje zien. load R2,theEND; // call print; // halt; // Einde van het programma. overflw jsr ENTER; load R2,overflow; // Laat zien dat er een overflow call print; // is opgetreden. bra overnw; // jsr ENTER; // Ga verder bij "overnw". ENTER load r1, 13; // Dit is een handige subroutine call 0x01; // welke de entertoets symboliseert. ret; // ## Programma met overflowcontrole.asm //Doel van het programma: //Het optellen van een inhoud van 5 geheugen locaties, en deze //wegschrijven in een 6e geheugen locatie. Wanneer het antwoord in // de 6e geheugen locatie een overflow is, moet er een waarde '0' // in de 6e geheugen locatie worden gezet. ## org (0x100); // Laad programma vanaf geheugenplaats 0x100 begin load R1, 0; // Laad waarde '0' in R1 load R2, 0x120; // Laad waarde '0x120' in R2 loop add R1, (R2); // Tel waarde van (R2) op bij R1 jvs flow; // Wanneer overflow, spring naar 'flow' inc R2; // Wanneer geen overflow tel 1 op bij R2 cmp R2, 0x125; // Vergelijk R2 met 0x0125 bne loop; // Wanneer niet gelijk, spring naar 'loop' store R1, (0x128); // Sla waarde R1 op in geheugenplaats 0x128 halt; // Klaar flow load R1, 0; // Wanneer overflow, laad waarde '0' in R1 store R1, (0x128); // Sla waarde R1 op in geheugenplaats 0x128 halt; // Klaar org (0x120); // Wijs geheugenplaats 0x120 aan data dat 20001,20002,20003,20004,20005; // Sla waarde op in 0x120, in 0x121, etc... end; ## 59

62 5.2 Opdracht: ZEP2 Opdracht_1 Bestudeer het onderstaande programma: //Naam opgave: ZEP_2_Opdracht_1 //Doel van het programma: //Het optellen van een inhoud van 5 geheugen locaties, en deze //wegschrijven in een 6e geheugen locatie. ## begin load R1, 0; // Laad de waarde 0 in R1 load R2, 0x20; // Laad de waarde 0x20 in R2 loop add R1, (R2); // Tel R1 (0) op bij registerinhoud R2 inc R2; // Tel één op bij 0x20 cmp R2, 0x25; // Vergelijk R2 met 0x25 bne loop; // Als het niet gelijk is, spring naar loop store R1, (0x28); // Wanneer wel gelijk, sla R1 op in 0x28 halt; // Klaar ## org (0x20); // Wijs geheugenplaats 0x20 aan data dat 1,2,3,4,5; // Vul de plaatsen 0x20 met 1, 0x21 met 2, etc... end; Het nadeel van dit programma is dat tussentijdse resultaten niet worden opgeslagen. Soms is dit noodzakelijk, als je bijvoorbeeld een grafiek van alle waarden wil maken. Opdracht: Breidt dit programma uit; ieder tussentijds resultaat en het eindresultaat wordt in een lege geheugenplaats opgeslagen = 1, 1 wordt opgeslagen in leeg geheugenadres = 3. 3 wordt opgeslagen in een leeg geheugenadres, enz. De loop loop moet blijven bestaan. Lees hoofdstuk De Stack van het boek door. Zep2: is niet geprogrammeerd om de StackPointer bij te houden. Maar staat op een vast adres: 7FFF. Zet de SP op het laatste gebruikte geheugenadres: menu Options, Assembler Options. Sla het bestand op met de naam: studentnummer_zep2 Opdracht_1. Het bovenstaande programma staat in de map: 07 Simulatie programma`s\ ZEP2 (processor, geheugen en assembler programmeren)\sources 2. 60

63 6 Voorbeeldtoets In MapleTa staat ook een voorbeeldtoets met de naam: Oefentoets assignment tircps01. Bij het tentamen is een het gebruik van een rekenmachine NIET toegestaan. 1 Wat is het grondtal van het octale talstelsel? A 2 B 8 C 10 D 16 2 Hoeveel bits heeft men nodig om een positief geheel getal kleiner dan 16 te coderen? A 1 B 2 C 4 D 8 3 Wat is de waarde van de meest significante positie in een decimale getal 101? A 0 B 1 C 10 D Reken om van decimaal naar binair: 10R 123 = 2R... A B C D Reken om van hexadecimaal naar binair: 16R 123 = 2R... A B 291 C D 123 is hier geen hexadecimaal getal 6 Vermenigvuldig de binaire getallen en x 1101 = A B C D

64 7 Tel binair op: = A B C D Reken de packed decimal BCD code om naar decimaal. A - 13 B 13 C 103 D wordt na een bewerking Welke bewerking heeft plaats gevonden? A B C D Vermenigvuldigen met vier. Packed decimal BCD code geconverteerd naar unpaked decimal BCD code. Omzetten naar two s complement. Normaliseren. 10 Waneer kan het werkgeheugen data inlezen van de processor? A B C D Als de Data in hoog is. Als de geinverteerde Write laag is. Als het kloksignaal en Write hoog is. Als er een geheugenadres geselcteerd is. 11 I. Een byte heeft twee mogelijke waarden, die we meestal aangeven met 0 en 1 II. Een bit is een groepje van acht bytes. A Beide zijn goed B C D I is goed en II is fout I is fout en II is goed Beide zijn fout 12 Als je het hexadecimale getal 7B omrekent naar een decimaal getal, dan wordt het: A B 18 C 123 D 81 7B is helemaal geen hexadecimaal getal want dan moet je twee letters hebben 13 Welke uitspraak is niet juist: A B C Muziek is analoog Als je een geluidsbestand m.b.v. via de telefoon verstuurt dan zorgt het modem er voor dat de digitale gegevens analoog verstuurd kunnen worden Geluid is digitaal 62

65 D Voor het opnemen van spraak op de computer is een analoog-naar-digitaal-omzetter nodig 14 Wat is het hart van de computer? A B C D De processor Het geheugen De bussen De antwoorden bij a, b en c zijn goed 15 Uit welke onderdelen bestaat de processor? A B C D ALU, Registers, ICU, RAM Klok, PC, IR, Registers, ALU PC, IR, Decoder, Registers, ALU Rekeneenheid, Registers, Besturingseenheid, ROM 16 Het getal -127 wordt met 8 bits als signed magnitud gecodeerd. Wat is juist? A B C Geen van bovenstaande antwoorden D Zowel A als B 17 Het getal -12 wordt met 8 bits als one's complement gecodeerd. Wat is juist? A B C D Tel in 7-bits two's complement gecodeerd op: = A B C D Overflow! 19 Welk getal staat hier als packed decimal gecodeerd? A -265 B +265 C D Dat is zo niet te zeggen 20 Wat zijn respectievelijk de namen van a,b in een getal van de vorm: +a. 10 b A B C Exponent, mantisse Mantisse, exponent Teken, mantisse 63

66 D Teken, exponent 21 Welk symbool hoort bij deze waarheidstabel? A B UIT A B C D 22 Deze poorten heten van boven naar beneden: A NOT, OR, AND B AND, NOT, OR C OR, NOT, AND 64