Een computer coderen en testen in machinetaal: 6 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

In deze Instructable laat ik je zien hoe je een computerprogramma codeert en test in machinetaal. Machinetaal is de moedertaal van computers. Omdat het is samengesteld uit reeksen van enen en nullen, is het niet gemakkelijk te begrijpen door mensen. Om dit te omzeilen, coderen we programma's eerst in een taal op hoog niveau, zoals C++ of Java, en gebruiken dan speciale computerprogramma's om ze te vertalen naar de 1s en 0s die computers wel begrijpen. Leren coderen in een taal op hoog niveau is zeker een no-brainer, maar een korte introductie in machinetaal kan waardevol inzicht geven in hoe computers werken en de waardering voor deze zeer belangrijke technologie vergroten.

Om een machinetaalprogramma te coderen en te testen, hebben we toegang nodig tot een eenvoudige computer waarvan de machinetaal gemakkelijk te begrijpen is. Personal computers zijn veel te complex om zelfs maar te overwegen. De oplossing is om Logisim te gebruiken, een logische simulator die op een pc draait. Met Logisim kunnen we een computer simuleren die aan onze behoeften voldoet. Bovenstaande video geeft u een idee van wat we met Logisim kunnen bereiken.

Voor het computerontwerp heb ik er een uit mijn Kindle-e-book Build Your Own Computer - From Scratch aangepast. Ik ben begonnen met de daar beschreven BYOC-computer en heb deze teruggebracht tot de verschillende basis-BYOC-I (I voor Instructable) die we in deze Instructable zullen gebruiken.

De machinetaal van BYOC-I is eenvoudig en gemakkelijk te begrijpen. Je hebt geen speciale kennis van computers of programmeren nodig. Alles wat nodig is, is een onderzoekende geest en leergierigheid

Verder lezen

Je vraagt je misschien af waarom we 'machine' gebruiken om een computer te beschrijven als het geen mechanisch apparaat is. De reden is historisch; de eerste computerapparaten waren mechanisch bestaande uit tandwielen en wielen. De tekst van Allan Sherman, "It was all gears going clickety-clack…" was pas over een eeuw of twee. Lees hier meer over early computing.

Stap 1: Onderdelenlijst

De onderdelenlijst is kort. Alleen deze twee items zijn vereist, beide gratis te downloaden:

1. "Logisim-win-2.7.1.exe" - Logisim is een populaire en gebruiksvriendelijke logische simulator. Download hier het uitvoerbare bestand van Logisim en maak vervolgens een snelkoppeling op een handige plaats zoals uw bureaublad. Dubbelklik op het Logisim-pictogram om het te starten. Opmerking: Logisim gebruikt Java Runtime Package dat hier te vinden is. Mogelijk wordt u gevraagd om het te downloaden.
2. BYOC-I-Full.cir" - Download het onderstaande Logisim-circuitbestand.

Start Logisim en klik vervolgens op "Bestand openen" en laad het bestand BYOC-I-Full.cir. Bovenstaande afbeelding toont de Logisim werkomgeving. De BYOC-I wordt weergegeven door het subcircuitblok. Extern zijn twee ingangen, Reset en Run, en hexadecimale displays voor de registers en het programmageheugen van de BYOC-I aangesloten.

Het programmageheugen van de BYOC-I is vooraf geladen met een eenvoudig programma dat van 1 tot 5 telt in het A-register. Volg deze stappen om het programma uit te voeren (Uitvoeren).

Stap 1 - Klik op de Poke Tool. De cursor moet veranderen in de stekende "vinger". Stap 2 - Poke de Reset-ingang twee keer, verander het eenmaal in "1" en nogmaals om het terug te veranderen naar "0". Hiermee wordt de BYOC-I gereset om het programma op adres 0 te starten. Stap 3 - Druk eenmaal op de Run-invoer om deze in "1" te veranderen. Het A-register zou moeten laten zien dat de telling verandert van 1 naar 5 en vervolgens wordt herhaald. Stap 4 - Als het programma niet wordt uitgevoerd, drukt u op Ctrl-K en het zou moeten starten.

Als u de mogelijkheden van Logisim wilt verkennen, klikt u op de link Help in de menubalk. Van daaruit kunt u de Logisim "Tutorial", "Gebruikershandleiding" en "Bibliotheekreferentie" verkennen. Een uitstekende video-introductie is hier te vinden.

Stap 2: Machinetaalhiërarchie en codes

De BYOC-I-computer voert taken uit op basis van programma's die in machinetaal zijn geschreven. BYOC-I-programma's zijn op hun beurt samengesteld uit instructies die in een goed gedefinieerde volgorde worden uitgevoerd. Elke instructie is gemaakt van codes met een vaste lengte die verschillende operationele componenten van de BYOC-I vertegenwoordigen. Ten slotte bestaan deze codes uit reeksen van enen en nullen die de machinetaal vormen die de BYOC-I daadwerkelijk uitvoert.

Ter verduidelijking beginnen we met codes en werken we ons op naar het programmaniveau. Vervolgens coderen we een eenvoudig programma, laden het in het geheugen van de BYOC-I en voeren het uit.

Codes bestaan uit een vast aantal binaire (1 en 0) cijfers of bits, kortweg. De onderstaande tabel toont bijvoorbeeld alle mogelijke codes (16 in totaal) voor een code van 4 bits breed. Naast de code is het hexadecimale (grondtal 16) en decimale equivalent. Hexadecimaal wordt gebruikt om naar binaire waarden te verwijzen, omdat het compacter is dan binair en gemakkelijker te converteren van binair dan decimaal. Het voorvoegsel "0x" laat u weten dat het volgende nummer hexadecimaal of kortweg "hex" is.

Binair - Hexadecimaal - Decimaal0000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000E 121101 0x000E 131111 0x000E

De breedte van een code bepaalt hoeveel items kunnen worden weergegeven. Zoals opgemerkt, kan de 4-bit brede code hierboven maximaal 16 items (0 tot 15) vertegenwoordigen; dat wil zeggen, 2 keer 2 vier keer genomen of 2 tot de 4e macht is gelijk aan 16. In het algemeen is het aantal representeerbare items 2 tot de nde macht. Hier is een korte lijst van n-bit codecapaciteiten.

n - Aantal items1 22 43 84 165 326 647 1288 256

De breedtes van de BYOC-I computercodes worden gekozen om rekening te houden met het aantal items dat door de code moet worden weergegeven. Er zijn bijvoorbeeld vier Instructie Types, dus een 2-bit brede code is geschikt. Hier zijn de BYOC-I-codes met een korte uitleg van elk.

Instructietypecode (tt) Er zijn vier soorten instructies: (1) MVI - Verplaats een directe 8-bit constante waarde naar een geheugenregister. Het geheugenregister is een apparaat dat gegevens bevat die voor een berekening moeten worden gebruikt, (2) MOV - gegevens van het ene register naar het andere verplaatsen, (3) RRC - een register-naar-registerberekening uitvoeren, en (4) JMP - springen naar een andere instructie in plaats van verder te gaan bij de volgende instructie. De BYOC-I Instructie Type Codes die zijn aangenomen zijn als volgt:

00 MVI01 MOV10 RRC11 JMP

Registercode (dd en ss) De BYOC-I heeft vier 8-bits registers die waarden van 0 tot 255 kunnen opslaan. Een 2-bits code is voldoende om de vier registers aan te duiden:

00 F register01 E register10 D register11 Een register

Rekencode (ccc) De BYOC-I ondersteunt vier rekenkundige/logische bewerkingen. Om toekomstige uitbreiding naar acht berekeningen mogelijk te maken, wordt een 3-bits code gebruikt:

000 ADD, voeg twee 8-bits waarden toe in aangewezen registers en sla het resultaat op in een van de registers 001 SUB, trek twee 8-bits waarden af in aangewezen registers en sla het resultaat op in een van de registers 010 - 011 Gereserveerd voor toekomstig gebruik100 AND, logisch EN twee 8-bits waarden in aangewezen registers en sla het resultaat op in een van de registers101 OF, logisch OF twee 8-bits waarden in aangewezen registers en sla het resultaat op in een van de registers110 tot 111, Gereserveerd voor toekomstig gebruik

Sprongcode (j) Een 1-bits code die aangeeft of de sprong onvoorwaardelijk is (j = 1) of afhankelijk is van een niet nul berekeningsresultaat (j = 0).

Gegevens/adrescode (v…v)/(a…a) 8-bits gegevens kunnen worden opgenomen in bepaalde instructies die waarden vertegenwoordigen van 00000000 tot 11111111 of 0 tot 255 decimaal. Deze gegevens zijn 8-bits breed voor opslag in de 8-bits registers van BYOC-I. Met decimale rekenkunde tonen we geen voorloopnullen. Bij computerrekenkunde tonen we voorloopnullen, maar deze hebben geen invloed op de waarde. 00000101 is numeriek hetzelfde als 101 of 5 decimaal.

Voorgestelde referenties

Binaire notatie - https://learn.sparkfun.com/tutorials/binaryHexadecimale notatie -

Verder lezen

Het idee om codes te gebruiken om een proces aan te sturen, gaat ver terug. Een fascinerend voorbeeld is de Jacquard Loom. Het geautomatiseerde weefgetouw werd bestuurd door een ketting van houten kaarten waarin gaten werden geboord die codes voor verschillende gekleurde garens voor het weven voorstelden. Ik zag mijn eerste in Schotland, waar het werd gebruikt om kleurrijke tartans te maken. Lees hier meer over Jacquard Looms.

Stap 3: Anatomie van BYOC-I-instructies

Gezien de codes van de BYOC-I, gaan we naar het volgende niveau, instructies. Om een instructie voor de BYOC-I te maken, plaatsen we de codes bij elkaar in een bepaalde volgorde en op specifieke locaties binnen de instructie. Niet alle codes verschijnen in alle instructies, maar als ze dat doen, nemen ze een specifieke locatie in beslag.

Het MVI-instructietype vereist de meeste bits, 12 in totaal. Door het instructiewoord 12 bits lang te maken, accommoderen we alle instructies. Ongebruikte (zogenaamde "don't care") bits krijgen de waarde 0. Hier is de BYOC-I Instruction Set.

1. Move Immediate (MVI) - 00 dd vvvvvvvvFunctie: Verplaats een 8-bit datawaarde V = vvvvvvvv naar het bestemmingsregister dd. Na uitvoering zal register dd de waarde vvvvvvvv hebben. Afkorting: MVI R, V waarbij R A, D, E of F is. Voorbeeld: 00 10 00000101 - MVI D, 5 - Verplaats de waarde 5 naar het D-register.
2. Verplaats register naar register (MOV) - 01 dd ss 000000Functie: Verplaats gegevens van bronregister ss naar bestemmingsregister dd. Na uitvoering hebben beide registers dezelfde waarde als het bronregister. Afkorting: MOV Rd, Rs waarbij Rd het bestemmingsregister A, D, E of F is en Rs het bronregister A, D, E of F is. Voorbeeld: 01 11 01 000000 - MOV A, E - Verplaats de waarde in register E naar register A.
3. Register to Register Calculation (RRC) - 10 dd ss ccc 000Functie: Voer toegewezen berekening ccc uit met behulp van bronregister ss en bestemmingsregister dd en sla het resultaat op in het bestemmingsregister. Afkortingen: ADD Rd, Rs (ccc=000 Rd + Rs opgeslagen in weg); SUB Rd, Rs (ccc=001 Rd - Rs opgeslagen in Rd); AND Rd, Rs (ccc=100 Rd AND Rs opgeslagen in Rd); OR Rd, Rs (ccc=101 Rd OR Rs opgeslagen in Rd). Voorbeeld: 10 00 11 001 000 - SUB F, A - Trek de waarde in het A-register af van het F-register met als resultaat het F-register.
4. Ga naar een andere instructie (JMP) - 11 j 0 aaaaaaaaFunctie: Verander de uitvoering in een andere instructie op adres aaaa aaaa(a) Onvoorwaardelijk (j=1) -11 1 0 aaaaaaaaAfkorting: JMP L waarbij L het adres is aaaa aaaaVoorbeeld: 11 1 0 00001000 - JMP 8 - Uitvoering wijzigen in adres 8.(b) Voorwaardelijk (j=0) wanneer de vorige berekening resulteerde in een resultaat dat niet nul was - 11 0 0 aaaaaaaaAfkorting: JNZ L waarbij L adres aaaa aaaa is. Voorbeeld: 11 0 0 00000100 JNZ 4 Als de laatste berekening een niet-nulwaarde opleverde, wijzig dan de uitvoering naar adres 4.

Instructiewoordbits zijn genummerd van links (meest significante bit MSB) naar rechts (minst significante bit LSB) van 11 tot 0. De vaste volgorde en locaties van de codes zijn als volgt:

Bits - Code11-10 Instructietype9-8 Bestemmingsregister7-6 Bronregister5-3 Berekening: 000 - optellen; 001 - aftrekken; 100 - logisch EN; 101 - logisch OR7-0 Constante waarde v…v en a…a (0 tot 255)

De instructieset is samengevat in de bovenstaande afbeelding. Let op de gestructureerde en ordelijke weergave van de codes in elke instructie. Het resultaat is een eenvoudiger ontwerp voor de BYOC-I en het maakt instructies voor mensen gemakkelijker te begrijpen.

Stap 4: Een computerinstructie coderen

Laten we, voordat we naar het programmaniveau gaan, enkele voorbeeldinstructies maken met behulp van de BYOC-I-instructieset hierboven.

1. Verplaats de waarde 1 naar register A. BYOC-I-registers kunnen waarden van 0 tot 255 opslaan. In dit geval heeft register A de waarde 1 (00000001 binair) na uitvoering van de instructie.

Afkorting: MVI A, 1 Vereiste codes: Type MVI - 00; Bestemmingsregister A - 11; Waarde - 00000001Instructiewoord: 00 11 00000001

2. Verplaats de inhoud van register A naar register D. Na uitvoering zullen beide registers de waarde hebben die oorspronkelijk in register A stond.

Afkorting: MOV D, A (Vergeet niet dat de bestemming de eerste is en de bron de tweede in de lijst) Vereiste codes: Type MOV - 01; Bestemmingsregister D - 10; Bronregister A - 11Instructiewoord: 01 10 11 000000

3. Voeg de inhoud van register D toe aan register A en sla op in register A. Na uitvoering is de waarde van register A de som van de oorspronkelijke waarde van register A en register D.

Afkorting: ADD A, D (Resultaat wordt opgeslagen in bestemmingsregister) Vereiste codes: Type RRC - 10; Bestemmingsregister A - 11; Bronregister D - 10; Berekening optellen - 000Instructiewoord: 10 11 10 000 000 (ccc is eerste 000 - optellen)

4. Spring op niet nul naar adres 3. Als het resultaat van de laatste berekening niet nul was, wordt de uitvoering gewijzigd in de instructie op het opgegeven adres. Indien nul, wordt de uitvoering hervat bij de volgende instructie.

Afkorting: JNZ 3 Vereiste codes: Type JMP - 11; Sprongtype - 0; Adres - 00000003Instructiewoord: 11 0 0 00000003 (Springtype is eerste 0)

5. Spring onvoorwaardelijk naar adres 0. Na uitvoering verandert de uitvoering in de instructie op het opgegeven adres.

Afkorting: JMP 0Code vereist: Type JMP - 11; Sprongtype - 1; Adres - 00000000Instructiewoord; 11 1 0 00000000

Hoewel machinecodering enigszins vervelend is, kunt u zien dat het niet onmogelijk moeilijk is. Als je echt machinaal codeert, zou je een computerprogramma, een assembler genaamd, gebruiken om de afkorting (die assemblagecode wordt genoemd) naar machinecode te vertalen.

Stap 5: Anatomie van een computerprogramma

Een computerprogramma is een lijst met instructies die de computer uitvoert vanaf het begin van de lijst en doorloopt tot het einde. Instructies zoals JNZ en JMP kunnen veranderen welke instructie vervolgens wordt uitgevoerd. Elke instructie in de lijst neemt één adres in het geheugen van de computer in beslag, beginnend bij 0. Het BYOC-I-geheugen kan een lijst van 256 instructies bevatten, meer dan genoeg voor onze doeleinden.

Computerprogramma's zijn ontworpen om een bepaalde taak uit te voeren. Voor ons programma kiezen we een eenvoudige taak, tellend van 1 tot 5. Het is duidelijk dat er geen "tel"-instructie is, dus de eerste stap is om de taak op te splitsen in stappen die door de BYOC-I's kunnen worden afgehandeld. beperkte instructieset.

Stap 1 Verplaats 1 naar register AStap 2 Verplaats register A naar register DStap 3 Voeg register D toe aan register A en sla het resultaat op in register AStap 4 Verplaats 5 naar register EStap 5 Trek register A af van register E en sla het resultaat op in register EStap 6 Als het aftrekresultaat was niet nul, ga terug naar stap 4 en ga verder met tellen Stap 7 Als het aftrekresultaat nul was, ga terug en begin opnieuw

De volgende stap is om deze stappen te vertalen naar BYOC-I instructies. BYOC-I programma's starten op adres 0 en nummeren opeenvolgend. Jump-doeladressen worden als laatste toegevoegd nadat alle instructies zijn ingevoerd.

Adres:Instructie - Afkorting;Beschrijving0:00 11 00000001 - MVI A, 1;Verplaats 1 naar register A1:01 10 11 000000 - MOV D, A;Verplaats register A naar register D2:10 11 10 000 000 - ADD A, D;Voeg register D toe aan register A en sla het resultaat op in register A3:00 01 00 00000101 - MVI E, 5;Verplaats 5 register E4:10 01 11 001 000 - SUB E, A;Trek register A af van register E en sla de resultaat in register E5:11 0 0 00000010 - JNZ 2;Als het aftrekresultaat niet nul was, ga dan terug naar adres 3 en ga verder met tellen6:11 1 0 00000000 - JMP 0;Als het aftrekresultaat nul was, ga dan terug en begin opnieuw

Voordat het programma naar het geheugen wordt overgebracht, moet de binaire instructiecode worden gewijzigd in hexadecimaal voor gebruik met de Logisim Hex Editor. Splits eerst de instructie in drie groepen van elk 4 bits. Vertaal de groepen vervolgens naar hexadecimaal met behulp van de tabel in stap 2. Alleen de laatste drie hexadecimale cijfers (hieronder vetgedrukt) worden gebruikt.

Adres - Instructie Binair - Instructie Binair Split - Instructie (Hex)0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101 - 0x01054 100111001000 1001 1100 000 - 0100 111000000010 1110 0000 0000 - 0x0E00

Het is tijd om het programma over te zetten naar het geheugen van de BYOC-I om het te testen.

Stap 6: Het programma overbrengen naar het geheugen en testen

Kijkend naar het Logisim "hoofd"-circuit, is het getoonde BYOC-I-blok het symbool voor het eigenlijke computercircuit met het label "BYOC-I" in het Explorer-venster. Om een programma in het BYOC-I-geheugen in te voeren:

1. Klik met de rechtermuisknop op het BYOC-I-blok (een "subcircuit" genoemd) en selecteer (beweeg over en klik met de linkermuisknop) "Bekijk BYOC-I".
2. Het BYOC-I-circuit verschijnt in het werkgebied. Klik met de rechtermuisknop op het symbool "Program Memory" en selecteer "Inhoud bewerken…".
3. Gebruik de Logisim Hex Editor om de hexadecimale code in te voeren (alleen vetgedrukt) zoals hierboven weergegeven.

U bent nu klaar om het programma uit te voeren. Keer terug naar het hoofdcircuit door te dubbelklikken op "BYOC-I" in het Explorer-venster. De ingangen Run en Reset moeten "0" zijn om te starten. Gebruik de Poke Tool, verander eerst Reset naar "1" en vervolgens terug naar "0". Dit maakt het startadres 0x0000 en bereidt het BYOC-I-circuit voor op uitvoering. Steek nu de Run-invoer naar "1" en het programma wordt uitgevoerd. (Opmerking: je moet vooral eenmaal op Control-K tikken om de Logisim-klok te starten. Dit is een functie waarmee je de Logisim-klok kunt stoppen en door een programma kunt bladeren door herhaaldelijk op Control-T te tikken. Probeer het eens!)

De Logisim-klok is instelbaar voor een breed scala aan frequenties. Zoals gedownload is het 8 Hz (8 cycli per seconde). Zoals de BYOC-I-computer is ontworpen, duurt het vier klokcycli om elke instructie te voltooien. Dus om de BYOC-I-snelheid te berekenen, deelt u de klokfrequentie door 4. Bij 8 Hz is de snelheid 2 instructies per seconde. U kunt de klok wijzigen door op "Simuleren" op de werkbalk te klikken en "Tick Frequency" te selecteren. Het mogelijke bereik is 0,25 Hz tot 4100 Hz. De lage snelheid op 8 Hz werd gekozen zodat je de telling in het A-register kon volgen.

De maximale snelheid van de BYOC-I simulatie (~1000 instructies per seconde) is erg traag in vergelijking met moderne computers. De hardwareversie van de BYOC-computer die in mijn boek wordt beschreven, voert meer dan 12 miljoen instructies per seconde uit!

Ik hoop dat deze Instructable machinetaalprogrammering heeft ontraadseld en je inzicht heeft gegeven in hoe computers op hun meest basale niveau werken. Probeer de twee onderstaande programma's te coderen om uw begrip te bevestigen.

1. Schrijf een programma dat begint bij 5 en aftelt tot 0. (ANS. Count5to0.txt hieronder)
2. Begin bij 2, tel met 3 totdat het aantal groter is dan 7. Je zou een beetje hoofdrekenen kunnen doen, controleren op 8, wetende dat het daar zou landen en opnieuw beginnen. Schrijf je programma op een meer algemene manier die echt test of het aantal een bepaald aantal "overschrijdt". Hint: Onderzoek wat er gebeurt als een aftrekking een negatieve waarde oplevert, bijvoorbeeld 8 - 9= -1. Experimenteer vervolgens met de logische AND om te testen of de MSB in een 8-bits getal "1" is. (ANS. Overschrijdt Count.txt)

Kun je andere uitdagende problemen bedenken voor de BYOC-I-computer? Wat kan het nog meer doen, gezien zijn beperkingen? Deel je ervaringen met mij op [email protected]. Als je geïnteresseerd bent in het coderen van microprocessors, kijk dan op mijn website www.whippleway.com. Daar draag ik machinecodering over naar moderne processors zoals de ATMEL Mega-serie die in Arduinos wordt gebruikt.