Werking van de processor miep leren over de processor, met de processor Meta-Instructionele Educatieve Processor



Dovnload 154.91 Kb.
Datum22.08.2016
Grootte154.91 Kb.

pag. (van )

werking van de processor MIEP

leren over de processor, met de processor

Meta-Instructionele Educatieve Processor

software: MIEP © A.B.H.Bos, nov.2002

1. inleiding


In deze syllabus willen we je kennis laten maken met de werking van een processor. Dit doen we door middel van een programma dat de werking van de processor nabootst: dit heet een simulatie. Daarvoor nemen we een kunstmatige (virtuele) processor, die we MIEP noemen.

wat te doen?


Jullie gaan doen, wat in de begintijd van de computers voor computergebruikers heel gewoon was: rechtstreeks in het geheugen van de computer kijken en werken. De programmeertaal die je hiervoor gebruikt, is in eerste instantie gemaakt om je te laten inzien, hoe de processen in een computer in principe verlopen. Deze taal is een sterk vereenvoudigde afgeleide van talen die ook nu nog door een handvol specialisten gebruikt worden om processoren in computers te laten werken. Het merendeel van de miljarden computergebruikers heeft geen weet van deze processen. Jullie krijgen hier de kans om een kijkje te nemen in het hart van de computer.

waar maak je mee kennis?


je raakt o.a. vertrouwd met de volgende zaken: processor, instructie, programma, geheugen, geheugenadres en instructie.

Door zelf te programmeren, en de werking van de processor van dichtbij te volgen, leer je dat de werking van de computer gebaseerd is op 3 stappen: de instructiecyclus. Deze cyclus wordt eindeloos herhaald.

Ook ga je beter begrijpen wat het verschil is tussen een lagere en een hogere programmeertaal.

hoe begin je?


Om de kennismaking met het programma MIEP te laten slagen, vragen we je om eerst hoofdstukken 2 en 3 te lezen over de processor en instructies (samen 2 pagina’s).
Daarna kun je met de processor MIEP gaan werken in hoofdstuk 4, en zul je de termen die daarbij gebruikt worden beter begrijpen.

Alvast veel succes gewenst!


2. de processor

wat is een processor?


De processor zit op het moederbord, en is de grootste, duurste, intelligentste en snelste chip van de computer. Hij is ook de belangrijkste, want alle processen binnen in de computer worden gestart vanuit de Centrale Processor. Ondanks het feit dat in een moderne computer ook andere hulpprocessoren te vinden zijn, zullen we de centrale processor voor het gemak “de processor” noemen.

De processor staat in verbinding met het interne geheugen. In dit geheugen liggen de instructies en de data (gegevens) opgeslagen waar de computer op dat moment mee werkt. Deze instructies worden van de harde schijf naar het interne geheugen gecopieerd, en blijven daar tijdelijk bewaard totdat ze niet meer nodig zijn.

Processor en intern geheugen werken intensief samen.

Alle andere onderdelen van de computer zoals de harde schijf, grafische kaarten enz. zijn slechts een soort buitenwereld: de rand­appa­ratuur. De processor staat in contact met het interne geheugen én met de randapparatuur, via de “bus”: een stel parallelle draden op het moederbord.


wat doet de processor?


De processor kan vooral snel berekeningen uitvoeren. Ook is de processor de enige die gegevens van de randapparatuur over kan brengen naar het interne geheugen en omgekeerd. Dus al het verkeer binnen de computer gaat via de processor, en wordt aangestuurd dóór de processor.

hoe weet de processor wat hij moet doen?


De processor kan lezen wat er in het interne geheugen staat. Nu staan er behalve data (getallen) ook instructies in het interne geheugen.

Zowel data als instructies worden bewaard in binaire vorm (nullen en enen). Voor het werken met de processor MIEP, maken we deze vorm iets gemakkelijker: met deze simulatie kun je instructies selecteren in de Nederlandse taal, en deze instructies krijgen een decimale code. Ook de data staan in de vorm van een gewoon decimaal getal.

Op zeker moment, nadat de computer is opgestart, krijgt de processor de opdracht om zijn eerste instructie uit het interne geheugen op te halen.


  • deze instructie wordt door de processor “gelezen” én geïnterpreteerd: d.w.z. de processor “snapt” wat voor soort opdracht dit is, en wat hij daarmee moet gaan doen.

  • de processor zorgt er vervolgens voor dat de instructie gedaan of “uitgevoerd” wordt.

  • tijdens het lezen van de eerste instructie heeft de processor alweer het nieuwe geheugenadres (plaats in het interne geheugen) berekend, waar straks de volgende instructie gevonden kan worden.

Daarna deze volgende instructie lezen, enzovoort. De processor gaat eeuwig door met deze 3 stappen, en wordt van de ene plek in het interne geheugen naar de andere plek gestuurd. Maar de processor houdt controle over het geheel.
De drie stappen samen heten de “instructiecyclus”.

welke onderdelen heeft de processor?


Op de processor zit de Control Unit die de instructies interpreteert (begrijpt wat te doen).

Ook beschikt de processor over een eigen geheugen, de zgn. registers waar de processor tijdelijk getallen kan opslaan.

Tevens kan de processor optellingen en vermenigvuldigingen uitvoeren met de getallen in die registers: dit gebeurt in de rekeneenheid of ALU (= Arithmetic Logic Unit) , die op de processor zit. Als laatste ontvangt/zendt de processor alle gegevens via de “bus” van/naar het interne geheugen en de rand­apparatuur (bus = stel parallelle draden, met één bit per draad).

3. instructies en data

wat zijn instructies?


De processor heeft op zeker moment een instructie “gelezen” op een plaats ergens in het interne geheugen. Voordat er gekeken wordt om wat voor soort opdracht het gaat, wordt de instructie eerst in de processor zelf opgeslagen.
Op de processor zijn daarvoor zijn 3 aparte plaatsen gereserveerd:

  • het opdrachtregister
    waar de opdracht bewaard wordt, die op dát moment uitgevoerd gaat worden

  • een rekenregister
    waar een getal opgeslagen wordt, waarop de instructie een bepaalde bewerking moet uitvoeren (bijv. een optelling): dit getal noemen we de “operand”

  • de opdrachtwijzer
    het geheugenadres waar de processor zijn volgende instructie kan vinden

In de simulatie van de processor MIEP gebruiken we iets eenvoudiger namen:
het rekenregister heet “accu” en de opdrachtwijzer heet “volgende job”.
Het opdrachtregister zelf is niet te zien, immers: de opdracht wordt zo snel uitgevoerd, dat je direct de volgende opdracht te zien krijgt.

wat is een operand?


Stel dat er twee soorten instructies zijn: HAAL_VAN en BRENG_NAAR, en er zijn adressen waar iets naar toe kan, bijv. Vlier-1 en Vlier-3,

dan noemen we de opdracht “BRENG_NAAR Vlier-3” een instructie.

De instructie bevat een “operatie” en een “operand”:
de operatie is BRENG_NAAR, en de operand is Vlier-3

ander voorbeeld:


in de instructie “TEL_OP 5”, is TEL_OP de operatie, en is 5 de operand.

  • de “operatie” vertelt wat voor soort opdracht er uitgevoerd moet worden (TEL_OP)

  • de “operand” is de waarde waarmee de instructie uitgevoerd moet worden (getal 5)

De operand is soms een gewoon getal (5) en soms een adres (Vlier-1).

Er zijn ook instructies die meer dan één operand nodig hebben. Maar dit soort instructies zullen wij hier voor het gemak niet gebruiken.


Ook zijn er instructies die geen operand nodig hebben, zoals de instructie: “stoppen”.

het interne geheugen


In het interne geheugen staan heel veel instructies. Maar er zijn ook plekken in het interne geheugen waar alleen maar gewone getallen staan, deze noemen we “data”. Bijvoorbeeld getallen voor het coderen van een plaatje. Instructies en data kunnen op verschillende plekken in het interne geheugen staan.
Bij de processor MIEP plaatsen we voor het gemak de instructies aan het begin van het interne geheugen, en de data daarachter.

4. de processor MIEP

een kijkje in het geheugen


Instructies, data, adressen, operanden worden allemaal weergegeven door getallen. Deze getallen zelf bestaan weer uit nullen (0) en enen (1). Als je zomaar een kijkje neemt in het interne geheugen, zie je een grote wirwar van binaire getallen: je weet zo niet gauw waar je aan toe bent.

De simulatie van de processor MIEP biedt je een goede gelegenheid om eens binnen in de computer te kijken, want de interface voor het werken met MIEP is heel gebruiks­vriendelijk.

Bij het werken met MIEP gebruiken we gewone decimale getallen, en instructies met herkenbare namen, zoals “copieer” of “verdubbel”, en decimale geheugenadressen (00 tot 99). En je ziet geheugen­vakjes met decimale getallen erin, waarvan je de betekenis hieronder gemakkelijk leert kennen.


  • start miep.exe

Eerst kom je in het tabblad Programma.

Links zie je dat er in het programma nog geen enkele actie staat.


En rechts zie dat het Intern Geheugen (00 t/m 99) nog leeg is, en alleen maar nullen bevat.

4.1 ons eerste programma


  • klik in de middelste kolom Instructieset op instructie-1: 1 Maak getal ### in A

Links onder(midden) in het veld Opcode zie je 1 ingevuld (van operatie of instructie 1).

Ook zie je dat het veld Operand rechtsonder geselecteerd is.



  • vul bij Operand in het getal: 6 , en klik daarna op Invoeren (of geef Enter)

Je ziet nu links bij Programma dat programmastap 1 gevuld is met: Maak getal 6 in A

Ook zie je dat de volgende programmastap op 2 komt te staan.


We zullen een opdracht voortaan “job” noemen. De volgende opdracht is dus job 2.

In het intern geheugen zie je de in de geheugenplaatsen 00 en 01, de volgende getallen staan:

dit betekent: instructie 1, operand 6 ofwel: Maak getal 6 in A.

Een instructie, zoals [ 1, 6 ] , noemen we “machinetaal”: instructies in de vorm van getallen, in werke­lijkheid binaire getallen, dus [ 0001 , 0110 ]
In de begintijd schreven programmeurs programma’s ook echt in de vorm van binaire of hexadecimale codes: onleesbaar en moeilijk te controleren (1-e generatietaal)

Dezelfde instructie: “ Maak getal 6 in A “ is geschreven in een soort Assembleertaal (2-e generatietaal). Dit is een taal die beter leesbaar is dan binaire of hexadecimale code, maar toch onoverzichtelijk blijft omdat de instructies maar heel kleine stapjes maken. Assembleertaal wordt volop gebruikt door specialisten die programma’s schrijven voor technische toepassingen.

Een geheugenplaats zullen we voor het gemak een “hok” noemen. Hierboven zie je dus de inhoud van de hokken 00 en 01 (decimaal).


  • klik op het tweede tabblad Uitvoeren

Je ziet rechtsboven de accu A, het enige zichtbare register van de processor MIEP.
Ons programma bestaat maar uit één job: de accu A moet gevuld gaan worden met het getal 6.

We gaan het programma nu runnen.


In het kader RUN staat de optie Stap voor stap : deze staat al ingevuld.

  • ga met de cursor over de pijl in het midden: deze wordt GROEN, en klik hierop

Na uitvoeren van de eerste job zie je in de accu A de waarde 6 staan.
Ons programma heeft dus een getal in een register van de processor geplaatst.

Hierna doe je een paar oefenopdrachten:

    • klus 1 maak het getal 33 in A

    • klus 2 maak het getal 60 in A

? vraag waar blijft het getal 33 bij het uitvoeren van klus 2?

4.2 programma dat getal in intern geheugen zet


De processor kan getallen opslaan en tevoorschijn halen uit het Intern Geheugen.

Dit geheugen bestaat uit een verzameling “hokken”, waarbij in elk hok een geheel getal wordt opgeslagen.

De processor kan ieder hok afzonderlijk “aanspreken”:

opslaan in geheugen instructie 2: Copieer A in hok ##

tevoorschijn halen instructie 3: Copieer hok ## in A

De processor heeft daarbij zelf een accu A, die wordt gebruikt om een getal uit het geheugen tijdelijk in op te slaan.

Het rechtstreeks toegankelijke geheugentype heet RAM (Random Access Memory).

Een hokje waarin een getal van 0 t/m 255 kan worden opgeborgen, heet een “byte”.

De bruikbaarheid van een computer hangt sterk samen met de grootte van het RAM. De grootte wordt meestal uitgedrukt in kilobytes of in megabytes:

1 Kilobyte = 1 kB = 1024 bytes

1 Megabyte = 1 MB = 1024 * 1024 bytes = 1.048.576 byte

De processor MIEP beschikt over een intern geheugen van slechts 100 hokken.


In elk hok komt een getal te staan van ten hoogste 255, overeenkomend met een binaire waarde, vanaf 00000000 tot en met 11111111, ofwel 1 byte.
Het intern geheugen is in deze simulatie dus 100 byte groot, dus minder dan 0,1 kB !

Met instructie 2: Copieer A in hok ## , kan een getal vanuit de accu A in het geheugen worden gecopieerd. Wanneer in hok 50 het getal 111 moet komen, gaat dat in twee stappen:

eerst wordt het getal 111 in A geplaatst

vervolgens wordt het gecopieerd in hok 50



  • ga naar het tabblad Programma, en klik op Clr Pgm (clear program)

  • voer job 1 in: Maak getal 111 in A

In het programma wordt nu job-2 aangewezen, nu nog: Geen actie.

  • klik bij instructieset op instructie-2: Copieer A in hok ##

  • vul voor de Operand in: 50

Je hebt nu ingevoerd job-2: “Copieer A in hok 50”.

Het effect van dit kleine programma zal zijn dat het getal 111 via A in hok 50 van het Intern Geheugen wordt gecopieerd.


Kortom: we hebben een programmaatje geschreven dat een getal op een bepaalde plaats van het Intern Geheugen neer kan zetten. Eens kijken of het programma werkt ……….

4.3 programma runnen


We gaan verder met het laatste programma.

  • klik op het tabblad Uitvoeren

Je ziet in het tabblad Uitvoeren dat in het Intern Geheugen de hokken 00, 01, 02 en 03 gevuld zijn met twee jobs. Elke job beslaat twee hokjes (geheugenplaatsen).

Je ziet (midden boven) dat Volgende job staat op (job) 1 Maak getal in A.


Ook zie je (links onder) het Nummer volgende job nog op 1 staan,
terwijl het Adres volgende job al op 2 staat.

Het programma moet nu bij job-1 gestart worden (RUN). En we laten daarbij elke volgende job afzonderlijk uitvoeren (doen).



  • kies in het window RUN de optie: Stap voor stap (deze staat al ingevuld)

  • ga met de cursor over de pijl in het midden: deze wordt GROEN, en klik hierop

De groene pijl betekent “uitvoeren”.
Job-1 wordt nu uitgevoerd, en het getal 111 staat opgeslagen in de accu A.

Intussen staan Volgende job, Nummer volgende job, en Adres volgende job ook al weer aangegeven.



  • klik nogmaals op de groene “uitvoerknop”

Kijk wat er in hok 50 staat.
Het programma is correct uitgevoerd: in het Intern Geheugen staat nu in hok 50 een getal.

4.4 programmageheugen, videogeheugen en werkgeheugen


Voor de 20 job’s in het Programma reserveren we 40 geheugenplaatsen: de hokken 00 tot en met 39. Dit noemen we het programmageheugen. Elke job beslaat twee hokken.

De hokken 40 en hoger kunnen we nu naar wens vullen met getallen: hier staan de “data”.

Het datageheugen is onderverdeeld in het:


  • videogeheugen: hok 40 tot en met hok 49 (wissen met de knop Clr video)

  • werkgeheugen: hok 50 tot en met hok 99 (wissen met de knop Clr workmem)

De geheugenplaatsen van 40 tot en met 49 worden gereserveerd voor het “videogeheugen”: daarover meer in een volgende paragraaf.
Getallen die we nodig hebben voor berekeningen, zetten we in het “werk­geheugen” in hok 50 of hoger.

Bij een gewone computer is er geen strikte scheiding tussen programmageheugen en datageheugen. Normaal mogen stukjes programma en data door elkaar heen staan in het interne geheugen.

Maar bij de simulatie van MIEP maken we, voor de overzichtelijkheid, deze scheiding wél:


  • ga naar het tabblad Programma en klik bovenaan op de knop Clr workmem (clear workmemory)

Het effect is dat de getallen in hok 50 en hoger worden gewist, maar het programmageheugen blijft staan.

  • ga naar het tabblad Uitvoeren en run het hele programma opnieuw

  • ga vervolgens terug naar het tabblad Programma en klik op de knop Clr pgm

Je ziet nu dat het programmageheugen, tot en met hok 39, is gewist, maar dat het getal 111 in hok 50 blijft staan.

  • klik op Clr All (deze knop wist het hele interne geheugen)

4.5 oefeningen (1)


job

Opcode

(instructie-nr.)



Operand

1

1

80

2

2

60

3

1

85

4

2

61

? vraag kun je in eigen woorden omschrijven wat het programma nu gedaan heeft?

  • klus 4 Schrijf een programma dat in de hokken 70 tot en met 74

de tafel van 3 schrijft: 3, 6, 9, 12, 15

Door in een geheugenplaats een 0 (nul) neer te zetten, kun je ook een deel van het geheugen wissen.

Voor hackers: je kunt een programma zelfs een deel van datzelfde programma laten wissen.


  • klus 5 Schrijf een programma (bestaande uit meer dan één job), dat in de eerste job het getal 45 in de accu plaatst, en dat vervolgens de eerste job weer wist

Als het programma goed werkt, zie je nullen ontstaan in de hokken 00 en 01, en zie je dat in het Programma job-1 vervangen is door Geen actie.

4.6 rekenen


Net als iedere processor kent MIEP de volgende rekenkundige bewerkingen: optellen, aftrekken, verdubbelen en halveren.

Het optellen kan alleen door een getal vanuit het geheugen op te tellen bij het getal dat al in de accu staat.

We gebruiken daarvoor uit de instructieset instructie 6: Tel hok ## op bij A

voorbeeld:



  • in hok 50 wordt het getal 5 geplaatst [gebruik hiervoor instructies 1 en 2]

  • maak getal 6 in de accu [gebruik instructie 1]

  • tel hok 50 op bij de accu [gebruik instructie 6]

  • copieer de inhoud van de accu in hok 51


  • klus 6 voer bovenstaand programma in, door middel van de Opcode’s en de Operanden, en run het programma Stap voor stap.

Als je dit goed gedaan hebt, is het resultaat in het programmageheugen:

1

5

2

50

1

6

6

50

2

51

en in het werkgeheugen, vanaf hok 50, staat

5

11

  • klik in het tabblad Programma op de knop Clr workmem
    hiermee wordt het werkgeheugen vanaf hok 50 gewist

  • Run het “optelprogamma” opnieuw Stap voor stap, en kijk hoe het werkgeheugen opnieuw wordt gevuld.

4.7 binair rekenen


de bewerkingen verdubbelen en halveren hebben geen Operand nodig, bijvoorbeeld:

  • Verdubbel de accu A [instructie 8]

  • Halveer de accu A [instructie 9]

De reden dat de processor deze bijzondere handelingen kan uitvoeren is, dat de processor in werkelijkheid binair rekent:


zo is het het dubbele van 1111 (binair) gelijk aan 11110 (binair). De processor schuift de ‘enen’ naar links en zet er een 0 achter.

Op dezelfde manier kan een even getal gehalveerd worden:


zo wordt het even getal 8 (decimaal) als volgt gehalveerd: 1000 (bin) wordt 100 (bin).
Er gaat dus een 0 af. Dit wordt het getal 4 (dec)

  • klus 7a schrijf een programma (van drie instructies) dat het getal 8 in de accu maakt, en de helft hiervan in hok 50 plaatst.

Je kunt een oneven getal, dat op een 1 eindigt, dus niet halveren. Of toch wel?
Eens kijken of we dit met MIEP kunnen testen:

  • klus 7b wijzig het programma met 9 in de plaats van 8. Wat doet MIEP?

? vraag Wat is 9 (dec) binair?
En wat doet de processor met het binaire getal 1001, om het te halveren?

4.8 oefeningen (2)


In een eerder voorbeeld hebben we het getal 6 opgeteld, door 6 als Operand in de accu te plaatsen.

We hadden natuurlijk ook het getal 6 ergens van tevoren in het werkgeheugen kunnen klaar zetten, om het later op te tellen bij de accu.



  • klus 8 voer een programma in dat het volgende doet:
    de getallen 2, 3, 4 en 5 worden in de hokken 50 tot en met 53 geplaatst.
    In hok 54 moet de som komen van de vier getallen.
    Met hoeveel instructies kun je dit programma schrijven?

  • klus 9 zet de getallen 65, 15 en 10 in het werkgeheugen,
    en bereken: 65 – 15 + 10

De processor kan alleen binair rekenen: alleen verdubbelen of halveren.


Daarnaast optellen en aftrekken.
Een vermenigvuldiging met een getal groter dan 2, dus bijvoorbeeld een vermenigvuldiging met 3 of 5, is een speciale opdracht. Hoe zou je dat aanpakken?

  • klus 10 voer een programma in dat het volgende doet:
    bijvoorbeeld het getal 15 wordt in het werkgeheugen zet,
    dit getal moet met 5 vermenigvuldigd worden,
    het resultaat komt in hok 60 te staan

  • hoe zou je een vermenigvuldiging met 2,5 aanpakken?

4.9 transport van tekst naar videogeheugen


In onderstaand voorbeeld gaan we een woord van 3 letters invoeren in de Buffer in het tabblad Programma. De buffer kunnen we zien als het toetsenbord waar de gebruiker gegevens invoert.
We gaan kijken hoe een programma zorgt voor uitvoer op het beeldscherm:

In het tabblad Uitvoeren zien we een stukje “beeldscherm” bij Video.


De symbolen die in Video komen te staan, komen overeen met de codes in het videogeheugen. Het video­geheugen bestaat uit de hokken 40 t/m 49.

Hoe maken we een programma dat gegevens van de Buffer naar het Videogeheugen brengt?


eerst enkele ASCII codes (zie ook de bijlage met ASCII-tabel):

spatie: 32, en cijfer 0: 48, 1: 49, …… 9: 57

A heeft code 65, B: 66, C: 67, …… Z: 90, …….. , a: 97, ….. z: 122

Om te lezen wat er in de buffer staat, wordt het meest linkse teken uit de Buffer gehaald met instructie 14: “Haal byte uit buffer”



  • typ in de buffer het woord: AZ

    • klus 11 Klik eerst op Clr all, maak het volgende programma, en voer het Stap voor stap uit.

  1. Haal byte uit buffer [ASCII code van eerste letter wordt in accu geplaatst]

  2. Copieer A in hok 40 [ zet ASCII-code in videogeheugen]

3. Haal byte uit buffer [ASCII code van volgende letter wordt in accu geplaatst]

  1. Copieer A in hok 41 [ zet ASCII-code in videogeheugen]

Je ziet dat de ASCII-codes in de hokken 40 en 41 worden geplaatst, en direct vertaald worden naar zichtbare symbolen in het “video-scherm”.

De ASCII-codes worden opgeslagen als gewone getallen. De processor kan er dus ook iets nuttigs mee doen, bijvoorbeeld:


als er in een tekst naar letters A gezocht moet worden, gaat de processor kijken of er een getal 65 in het intern geheugen te vinden is. Dit kan een letter A zijn, maar natuurlijk ook een gewoon getal.

  • klus 12 maak een programma, dat een letter uit het alfabet (B of hoger) terugrekent naar de letter ervoor.
    Dus bij invoer in de buffer van één letter, bijv. de letter L, moet de letter K in het videoscherm te zien zijn.



    1. oefeningen (3)

4.10 a een getal tussen 0 en 10 als ASCII invoeren in de buffer, en na bijv. een bewerking als ASCII uitvoeren in het videogeheugen


  • zet de tekst "4+3" in de buffer.




  • klus 13 maak een programma dat het volgende doet:

    • zet het getal 48 in hok 50

    • haalt byte uit buffer, trekt van ASCII-waarde 48 af, en zet resultaat in hok 60

    • haalt byte uit buffer ( het “+” teken)

    • haalt byte uit buffer, trekt van ASCII-waarde 48 af, en zet resultaat in hok 61

    • zet het resultaat van 4+3 in hok 70

    • tel hier 48 bij op, en zet het resultaat in hok 40 van het videogeheugen

Je ziet nu de som 7 in het video-scherm staan.

? vraag Welk probleem doet zich voor, als je de getallen 5 en 8 in de buffer invoert?

4.10b woorden coderen door terugschuiven in het alfabet: bijv. ALS wordt ZKR
Z wordt Y, Y wordt X, ..... , B wordt A, en A gaat weer over in Z.


Dit programma wordt te groot voor 20 instructies, daarom splitsen we het in twee verschillende programma’s.

Omdat de A met ASCII-waarde 65 door moet schuiven naar de Z met ASCII-waarde 90 en niet naar 64, zetten we deze twee waarden eerst in het geheugen:



  • klus 14a Maak eerst het hele geheugen leeg met Clr All, en maak vervolgens een programma dat de getallen 64 en 90 in de hokken 50 en 51 plaatst
    - run het programma
    - en maak alleen het programmageheugen leeg met Clr pgm

  • typ in de buffer in het woord: ALS (woord van 3 letters)

Omdat elke letter in het alfabet één plaats kan terugschuiven, behalve de A, moeten we een uitzondering maken. Als de ASCII-waarde na terugschuiven op 64 (onder A) komt, moeten we hem vervangen door 90 (Z).
Hiervoor gebruiken we de instructies 15 (vergelijk A met hok ...) en 18 (job ... als A>hok)

  • klus 14b Maak het volgende programma:
    1. Haal byte uit buffer
    2. Trek 1 af [ de teruggeschoven ASCII-waarde staat in de accu ]
    3. Vergelijk A met hok 50 { daar staat het getal 64 (A) ]
    4. Job 6 als A > hok [ sla volgende job over, als accu > 64 ]
    5. Copieer hok 51 in A { daar staat het getal 90 (Z) ]
    6. Copieer A in hok 40 [ doorgeschoven letter komt in video hok 40 ]
    7. t/m 18.
    herhaal deze instructies voor de tweede en derde letter uit de buffer, en breng de gecodeerde letters naar video hokken 41 en 42.

Voer in de buffer een woord in van 3 hoofdletters, en test het programma.

4.10c een decimaal getal invoeren, en omzetten naar een binaire waarde


Om te snappen hoe dit programma werkt nemen we bijvoorbeeld het decimale getal 13.

1310 is binair 1101, want 13 = 1*8 + 1*4 + 0*2 + 1*1

We gaan met behulp van het decimale getal 13 proberen om de cijfers 1, 1, 0 en 1 eruit te krijgen, zonder gebruikmaking van de machten van twee (1, 2, 4, 8, ... ).
Daar is een methode voor:

MIEP berekent de “helft” van 13 als 6 (naar beneden afgerond).


Door 13 – 2*6 te berekenen houden we 1 over: dit is juist de laatste 1 van 1101. Dit klopt want een oneven getal eindigt binair op een 1.
Het getal 6 dat je over houdt is binair 110 (dit zijn juist de overgebleven drie cijfers)

Van het overgebleven getal 6 kun je opnieuw kijken of het even of oneven is:


door de helft van 6 te nemen (is afgerond 3), en 6-2*3 te berekenen, krijg je 0:
deze 0 betekent dat 6 even is, en dit is weer het laatste cijfer 0 in 110.

Zo kun je van 3 weer de “helft” nemen , enzovoort:

helft van 1101 wordt 110 laatste bit 1 ( helft van 13 is 6 met rest 1 )
helft van 110 wordt 11 laatste bit 0 ( helft van 6 is 3 met rest 0 )
helft van 11 wordt 1 laatste bit 1 ( helft van 3 is 1 met rest 1 )
helft van 1 wordt 0 laatste bit 1 ( helft van 1 is 0 met rest 1 )

De “resten” zijn precies de bits in het getal 13: 1, 1, 0 en 1. Dus 1310 = 11012



  • formule: laatste bit = getal – 2*(helft van getal, naar beneden afgerond)

  • herhaal dit met de helft van getal , enzovoort

Dit is een oeroud en snel algoritme. Een “algoritme” is een rekenwijze. We laten MIEP hiervoor het werk doen.

  • klus 15 Maak het volgende programma, en run Stap voor stap, totdat je vier keer in hok 60 een bit hebt gevonden (noteer ze). Breek af met Esc

    1. Maak getal 13 in A [ neem als startgetal 13 ]


    2. Copieer A in hok 50 [ in hok 50 komt het startgetal 13 te staan ]
    3. Halveer A { helft naar beneden afgerond ]
    4. Copieer A in hok 51 [ in hok 51 komt de afgeronde helft te staan ]
    5. Verdubbel A
    6. Copieer A in hok 52 [ hier komt de dubbele afgeronde helft ]
    7. Copieer hok 50 in A [ zet het startgetal weer in de accu ]
    8. Trek hok 52 af van A [ trek 2*afgeronde helft af van begingetal ]
    9. Copieer A in hok 60 [ hier komt het meest rechtse bit te staan ]
    10. Copieer hok 51 in A [ neem afgeronde helft als nieuw startgetal ]
    11. Copieer A in hok 50
    12. Spring naar job 3 [ herhaal de procedure voor het volgende meest rechtse bit ]

  • herhaal het programma met een ander startgetal (maximaal 255) als operand in job 1:
    noteer achtereenvolgens de bits in hok 60 (van rechts naar links), en controleer de uitkomst met de regel …*128 + …*64 + ...*32 + ...*16 + ...*8 + ...*4 + ...*2 + ...*1

4.11 extra problemen


  1. algoritme voor 1+2+3+4+ .....
    eeuwige lus, met afbreken (Esc) na overflow
    tips:
    gebruik een hok voor een oplopende waarde beginnend met 1
    en gebruik een hok waar de totale som wordt bijgehouden, beginnend met 0
    herhaal met Tel 1 bij A op , en met: Spring naar job ##

  2. reeks van Fibonacci: 1+1=2, 1+2=3, 2+3=5, 3+5=8, ......
    tip:
    gebruik drie hokken, en herhaal steeds dezelfde berekening
    zet in de eerste twee hokken de getallen 1 en 1

  3. binair naar decimaal , met het algoritme ( (1*2 + 1)*2 + 0 )*2 + 1=13
    dit berekent hetzelfde als: 1*23 + 1*22 + 0*21 +1 = 13
    De bits 1101 worden in de buffer van links naar rechts uitgelezen, aan het eind staat het getal 13 in hok 50.
    de bits worden als volgt bewerkt:
    1) bit uit buffer en opslaan in hok 50,
    2) getal in hok 50 keer 2, volgende bit uitlezen en bij hok 50 optellen
    3) stap 2 nog twee keer herhalen, totdat alle vier bits zijn uitgelezen
    test het algoritme door andere series van vier bits in te voeren.

  4. tellen van het aantal letters van een woord in de buffer
    voer in de buffer een woord in, en laat in hok 50 de totale lengte van het woord berekenen.
    Het programma bestaat uit het herhaald uitlezen van één letter uit de buffer,
    daarbij moet het programma zelf ontdekken waar en hoe het programma moet worden beëindigd.
    tips:
    de eerste “lege” letter aan het einde van het woord heeft ASCII-waarde 0, dit is iets anders dan een spatie, deze heeft ASCII-waarde 32
    laat in hok 50 het aantal letters in het woord bijhouden met een “tellertje”
    gebruik de instructie Job nummer ## als A=0

  5. getal vermenigvuldigen met 7
    voer via de buffer een getal in onder de 10, en laat in hok 50 het zevenvoud van dit getal verschijnen.
    tips:
    bewaar het te vermenigvuldigen getal in hok 51, en tel in hok 50 steeds dit zelfde getal op (7 keer herhaald).
    plaats een “teller” in hok 60, beginnend met 6, trek hier bij iedere herhaling 1 af, en gebruik “Job nummer ## als A=0” , als stopcriterium.

( zie laatste blad: bijlage ASCII-tabel )



EINDE

Bijlage: ASCII-tabel


ASCII-codes








































ASCII

letter

ASCII

letter

ASCII

letter

ASCII

letter

code

 

code

 

code

 

code

 

0

¤

32

spatie

64

@

96

`

1

¤

33

!

65

A

97

a

2

¤

34

"

66

B

98

b

3

¤

35

#

67

C

99

c

4

¤

36

$

68

D

100

d

5

¤

37

%

69

E

101

e

6

¤

38

&

70

F

102

f

7

¤

39

'

71

G

103

g

8

¤

40

(

72

H

104

h

9

¤ TAB

41

)

73

I

105

i

10

¤ LF

42

*

74

J

106

j

11

¤

43

+

75

K

107

k

12

¤ FF

44

,

76

L

108

l

13

¤ CR

45

-

77

M

109

m

14

¤

46

.

78

N

110

n

15

¤

47

/

79

O

111

o

16




48

0

80

P

112

p

17




49

1

81

Q

113

q

18




50

2

82

R

114

r

19




51

3

83

S

115

s

20

µ

52

4

84

T

116

t

21

§

53

5

85

U

117

u

22




54

6

86

V

118

v

23




55

7

87

W

119

w

24




56

8

88

X

120

x

25




57

9

89

Y

121

y

26




58

:

90

Z

122

z

27

ESC

59

;

91

[

123

{

28




60

<

92

\

124

|

29




61

=

93

]

125

}

30




62

>

94

^

126

~

31




63

?

95

_

127

 DEL




SyllabusMIEP © F.W. de Bruijn, A.B.H.Bos, nov.2003





De database wordt beschermd door het auteursrecht ©opleid.info 2019
stuur bericht

    Hoofdpagina