Thuis
Contacten

    Hoofdpagina


A. C. Verschueren, 25 oktober 2001 Inhoud: 1 Introductie 2 2 Adresruimten 4

Dovnload 180.08 Kb.

A. C. Verschueren, 25 oktober 2001 Inhoud: 1 Introductie 2 2 Adresruimten 4



Datum29.10.2018
Grootte180.08 Kb.

Dovnload 180.08 Kb.

Instructieset Architectuur (ISA)
en input/output connecties
van de OGO 1.2 processor


A.C. Verschueren, 25 oktober 2001

Inhoud:

1 Introductie 2

2 Adresruimten 4

2.1 Programmageheugen 4

2.2 Datageheugen 4

3 Interne registers 4

3.1 Werkregisters 4

3.2 Programma Status Woord 5

3.3 Stack Pointer 5

3.4 Program Counter 5

4 Interrupts 5

5 Instructieset 6

5.1 Introductie 6

5.2 Instructies op alfabetische volgorde 7

5.3 Instructies op binaire code volgorde 13

6 Speciale directe adressen 14

6.1 Interne processor registers 14

6.2 Input/output besturing 14

7 Input/output signalen 15

7.1 Test ingangen 15

7.2 Input/output bus 15

8 Instructiematrix 17


  1. Introductie


Dit documentje beschrijft de instructieset architectuur (ISA) en de verbin-dingen met de ‘buitenwereld’ van de processor die ontworpen moet worden tijdens de OGO opdracht van trimester 1.2.

De instructieset architectuur legt vast hoe de processor geprogrammeerd moet worden. Alle processoren ontworpen volgens de ‘gedragsregels’ gegeven in hoofdstukken 2 t/m 6.1 kunnen in principe elkaars programma’s draaien. Dit geldt echter alleen voor programma’s die niet afhankelijk zijn van de preciese timing van de instructies – op dit gebied zijn hier geen voorschrif-ten gegeven! Hoofdstuk 8 geeft nog een keer een samenvatting van alle instructies en hun codering in de vorm van een ‘instructiematrix’.

De verbindingen van de processor met zijn input/output modulen worden gegeven in hoofdstuk 7. De preciese vorm van de verbindingen en hun timing wordt hier vastgelegd om uitwisseling van processoren en input/output modulen mogelijk te maken. De ISA laat een maximum van 16 bytes aan input/output poorten toe, hoofdstuk 6.2 geeft een voorstel voor de plaatsing van de verschillende voorziene poorten (die nodig zijn voor het totale OGO 1.2 project) in deze 16 bytes ‘adresruimte’. Het is aan te raden om één 8 bits parallelle input poort en één 8 bits parallelle output poort op de daar gegeven adressen te implementeren omdat hiervan dan gebruik gemaakt kan worden door een standaard ‘ISA-test’ programma.

Er is bij het ontwerpen van deze ISA getracht een zo eenvoudig mogelijk te implementeren processor te ontwerpen, zonder hierbij de programmeerbaar-heid uit het oog te verliezen. Er is bewust niet voor gekozen om de ‘practi-cumprocessor’ (hier even afgekort tot ‘PP’) die gebruikt wordt bij het vak com-puterarchitectuur na te bouwen – deze heeft een véél te complexe instructie-set. Wel is geprobeerd zo veel mogelijk concepten en (instructie/register) namen over te nemen. De verschillen en overeenkomsten worden hieronder kort weergegeven:



  • De OGO processor is verzonnen om ingezet te worden in eenvoudige regelsystemen waar veel met continue waarden wordt gewerkt. De PP is daarentegen ontworpen voor besturingen waar de nadruk ligt op discrete (vaak één bit brede) waarden en het nemen van beslissingen. De bit-operaties van de PP zijn afwezig bij de OGO processor, deze kent echter wel enkele schuif-operaties die afwezig zijn bij de PP. Het interrupt mechanisme dat bij besturingen gebruikt wordt om belangrijke taken voorrang te geven is afwezig bij de OGO processor, deze hoeft alleen maar te synchroniseren met de omgeving en kent daarvoor speciale ‘WAIT’ instructies (met bijbehorende ‘test’ ingangen).

  • Om implementatie te vereenvoudigen heeft de OGO processor veel minder instructies dan de PP en is de instructie-codering veel ‘regelma-tiger’ (vergelijk de instructiematrix in hoofdstuk 8 maar eens met de matrix in de practicumhandleiding van computerarchitectuur!).

  • Beide processoren hebben gescheiden programma en data geheugens (‘Harvard architectuur’). Het standaard programmageheugen van de OGO processor is slechts 1 kilobyte tegen de 64 kilobyte van de PP. De ‘MOVC’ instructies van de PP zijn afwezig bij de OGO processor, er kunnen dus geen tabellen met constante waarden in het programma-geheugen worden geplaatst. De OGO processor is veel eenvoudiger in de indeling van het data geheugen – alleen echte (byte) gegevens en de stack worden hierin geplaatst, géén werkregisters en bit adresseer-bare bytes zoals bij de PP.

  • De PP heeft 8 werkregisters (R0..R7), de OGO processor heeft er 4 (R0..R3). Bij beide processoren kunnen registers R0 en R1 gebruikt worden voor indirecte adressering (@R0, @R1) in het werkgeheugen.

  • De PP heeft een apart ‘accumulator’ register (A) dat vrijwel steeds bron en/of bestemming van een operatie is. De OGO processor heeft zo’n register niet, gebruikt in plaats hiervan zijn vier werkregisters als vier onafhankelijke ‘accumulatoren’. Het is gebleken dat dit de halvering van het aantal werkregisters meer dan goed maakt: voor eenvoudige functies heeft de OGO processor minder instructies nodig.

  • Beide processoren hebben een ‘programma status woord’ (PSW), de indeling is echter anders. De OGO processor kent alleen de standaard vlaggen Carry, oVerflow, Zero en Sign, kan al die vlaggen testen met conditionele sprongen. De PP pariteitsvlag is afwezig bij de OGO processor.

  • Beide processoren plaatsen de stack in het datageheugen, met een ‘stack pointer’ (SP) register wijzend naar het laatste gePUSHte byte. Ook ‘groeit’ de stack naar hogere adressen bij PUSH en CALL instruc-ties. Bij de OGO processor moet de SP geïnitialiseerd worden door de programmeur, de automatische initialisatie (naar een onhandige waar-de) zoals bij de PP is achterwege gelaten.

  • Het idee achter de direct adresseerbare ‘Special Function Registers’ bij de PP is overgenomen bij de OGO processor – hier zijn echter niet de hoogste 128 bytes adresruimte voor genomen doch slechts de hoogste 32 bytes (0E0h..0FFh). Hiervan zijn 16 bytes opzij gezet voor de aan-sturing van input/output modulen. De hoogste 16 bytes zijn gereser-veerd voor processor-interne registers (waarvan nu alleen de SP en PSW gebruikt zijn).

De logische OR en logische XOR instructies (‘ORL’ en ‘XRL’ bij de PP) zijn afwezig bij de OGO processor – de verwachting is dat zij niet nodig zullen zijn bij de programma’s die op de OGO processor gedraaid worden. De logische AND instructie is wèl aanwezig, deze is nodig om bits te kunnen ‘maskeren’ in een byte. De PP’s ADDC (‘add with carry’) en SUBB (‘subtract with borrow’) zijn afwezig bij de OGO processor maar kunnen worden vervangen door het conditioneel uitvoeren van een INC/DEC instructie in combinatie met een normale ADD/SUB.
  1. Adresruimten

    1. Programmageheugen


De basis-instructieset ondersteund een programmageheugen (ROM) van maximaal 1024 bytes met 10 bits adressen voor de (onconditionele) 2 bytes lange JUMP en CALL instructies.

Er is coderingsruimte overgelaten voor 3 bytes lange JUMP en CALL instructies met 16 bits adressen zodat het programmageheugen kan worden uitgebreid tot maximaal 64 KiloByte. Hiervoor moet het ‘Program Counter’ register ‘opgerekt’ worden van 10 bits naar 16 bits.


    1. Datageheugen


Een datageheugen (RAM) van maximaal 256 bytes wordt ondersteund met 8 bits adressen. Directe en register-indirecte adressering is allebei mogelijk. Een stack wordt in het datageheugen geïmplementeerd met behulp van een 8 bits stack pointer register (een vorm van register-indirecte adressering).

Bij directe adressering worden de bovenste 32 bytes van de adresruimte gebruikt voor het lezen en schrijven van speciale processor registers (16 gereserveerde adressen op 0F0h..0FFh) en input/output besturingsregisters (16 gereserveerde adressen op 0E0h..0EFh).
  1. Interne registers

    1. Werkregisters


Vier werkregisters van 8 bits genaamd ‘R0’..’R3’ kunnen worden gebruikt als ‘rekenregister’, er is dus niet één centrale ‘accumulator’. Twee van hen (R0 en R1) kunnen gebruikt worden voor indirecte adressering in het datageheugen. De werkregisters zijn niet direct adresseerbaar en hoeven bij het opstarten van de processor niet op een bepaalde waarde te worden gezet.
    1. Programma Status Woord


Een ‘programma status woord’ (‘PSW’) van 8 bits bevat de standaard status ‘vlaggen’, moet bij het opstarten van de processor automatisch op 0 worden gezet en is direct adresseerbaar op adres 0FFh:

Bit 0: de carry vlag (‘C’), gebruikt als ‘borrow’ na een aftrek-operatie


Bit 1: de overflow vlag (‘V’)
Bit 2: de zero vlag (‘Z’)
Bit 3: de sign vlag (‘S’)

Bits 4..7 zijn gereserveerd – zij moeten wel opgeslagen worden maar worden niet door normale instructies veranderd. Om problemen te voorkomen moeten programma’s er voor zorgen dat deze bits altijd geschreven worden met 0000b.


    1. Stack Pointer


Een ‘stack pointer’ (‘SP’) van 8 bits wijst steeds naar het laatst op de stack (in het datageheugen) ge-‘PUSH’-te byte. De SP is direct adresseerbaar op adres 0FEh. De stack ‘groeit’ omhoog; CALL en PUSH instructies verhogen de SP terwijl POP en RET instructies de SP verlagen.

De SP moet door het programma geladen worden met het adres één byte lager dan het begin van de stack voordat er voor het eerst gebruik van kan worden gemaakt (SP wordt niet automatisch geïnitialiseerd bij opstarten).


    1. Program Counter


Een ‘program counter’ (‘PC’) van 10 bits wijst steeds naar de volgende uit te voeren instructie en wordt bij het opstarten van de processor met 0 geladen. Bij een CALL worden eerst bits 0..7 van de PC op de stack ge-PUSH-ed, daarna bits 8..9 (met de overgebleven bits in dat byte op 0). De PC is niet direct adresseerbaar.

Het is mogelijk om de PC uit te breiden tot 16 bits, maar dit is niet verplicht (en waarschijnlijk ook niet noodzakelijk voor dit project).


  1. Interrupts


Deze worden niet ondersteund. Om toch op een eenvoudige manier te kunnen wachten op het optreden van gebeurtenissen in de ‘buitenwereld’ heeft de processor vier (4) één bit ingangen de getest kunnen worden met een speciale ‘WAIT’ instructie. Bij uitvoering van deze instructie wacht de processor met het ophalen van de volgende instructie tot de aangewezen test ingang op logische 1 staat. Als die ingang bij het uitvoeren van de ‘WAIT’ al op 1 stond, dan wordt direct gestart met het ophalen van de volgende instructie.
  1. Instructieset

    1. Introductie


De instructieset is relatief eenvoudig gehouden en bestaat uit één of twee bytes lange instructies (alleen als de PC wordt ‘opgerekt’ naar 16 bits zijn twee 3 bytes lange instructies nodig). De plaatsing van bit-velden in de instructiecodes is zodanig dat het decoderen geen problemen hoeft op te leveren (zo zijn de bits voor het adresseren van werkregisters en statusvlag-gen steeds op dezelfde plek in de instructie te vinden).

Voor de assembleertaal is zoveel mogelijk gebruik gemaakt van dezelfde notaties als gebruikt bij de practicumprocessor (een Intel 8051 afgeleide):



Rs wijst één van de vier werkregisters aan als bron-operand (source), s = 0..3. In de instructie worden dit nummer simpelweg als 2 bits binair getal gecodeerd (‘ss’).

Rd wijst één van de vier werkregisters aan als bestemmings-operand (destination), d = 0..3. In de instructie worden dit nummer simpelweg als 2 bits binair getal gecodeerd (‘dd’). Voor echte 2-operand instructies is dit register ook een van de bron-operanden!

@Ri wijst één van de twee laagst genummerde werkregisters aan voor indirecte adressering in het datageheugen, i = 0..1. In de instructie wordt dit nummer gecodeerd als een enkel bit (‘i’).

dir geeft een 8 bits direct adres aan voor adressering van het datageheugen of de speciale registers, dir = 0..255. Dit adres is altijd te vinden in het 2e byte van de instructie. De adressen van SP en PSW zijn bekend bij de assembler, gebruik namen ‘SP’ en ‘PSW’ voor dir.

imm geeft een 8 bits immediate waarde voor gebruik bij twee-operand instructies, imm = 0..255 (of –128..+127 bij interpretatie als two’s complement getal, de assembler laat –128..255 toe als waarde). Deze waarde is altijd te vinden in het 2e byte van de instructie.

adr8 geeft een 8 bits sprong-adres aan voor gebruik bij conditionele sprongen, adr8 = 0..255. Deze waarde wordt bij het uitvoeren van de sprong in bits 0..7 van de PC geladen nà het ophogen van de PC om naar de volgende instruciete te wijzen, hetgeen betekend dat een conditionele sprong alleen kan springen naar een adres dat ligt in de 256 bytes ‘pagina’ programmageheugen waarin de instructie volgend op de conditionele spronginstructie zich bevind. Bij de assembler moet het complete adres (label!) worden gegeven, de assembler controleert of dit adres bereikbaar is. Dit 8 bits adres is altijd te vinden in het 2e byte van de instructie.

adr10 geeft een 10 bits sprong-adres aan voor gebruik bij (onconditionele) sprongen en de CALL instructie, adr10 = 0..1023. Deze waarde wordt als geheel in de PC geladen (bits 0..9 van de PC als deze ‘opgerekt’ is tot 16 bits, springt binnen een ‘pagina’ programmageheugen van 1024 bytes zoals bij adr8). Bits 0..7 van dit adres zijn altijd te vinden in het 2e byte van de instructie, bits 8..9 zijn te vinden in bits 0..1 van het 1e byte van de instructie (gecodeerd met ‘aa’ daar).

adr16 geeft een 16 bits sprong-adres aan voor gebruik bij de optionele ‘lange’ sprong en CALL als de PC is ‘opgerekt’ tot 16 bits, adr16 = 0..65535. Bits 0..7 zijn te vinden in het 2e byte van de instructie, bits 8..15 bevinden zich in het 3e byte.

flag geeft aan welke vlag getest of veranderd wordt, gecodeerd met de bitpositie van die vlaggen in het PSW als 2 bits code ‘ff’. De assembler vertaalt vlag namen ‘C’, ‘V’, ‘Z’ en ‘S’ respectievelijk naar codes 00b, 01b, 10b en 11b.

test wijst één van de vier test ingangen van de processor aan om te wachten met het ophalen van de volgende instructie totdat deze ingang de waarde 1 heeft – als de ingang al de waarde 1 heeft bij het uitvoeren van de WAIT instructie dan wordt er niet gewacht! test = 0..3, binair gecodeerd met ‘tt’ in de instructiecode.
    1. Instructies op alfabetische volgorde


  • Bij het weergeven van de door een instructie uitgevoerde operaties wordt met [..] het lezen of schrijven van het datageheugen bedoeld (waarbij bij [dir] rekening gehouden moet worden met het feit dat de hoogste 32 adressen speciale processor of input/output besturingsregisters adres-seren).

  • Het verhogen van de PC wordt alleen aangegeven als dit voor het begrip noodzakelijk is.

  • Indien niet anders aangegeven, blijven alle status vlaggen intact bij het uitvoeren van een instructie. Let op dat status vlaggen via direct adres 0FFh te schrijven zijn!

  • Het teken ‘||’ geeft aan dat de operatie op die regel tegelijk wordt uitgevoerd met de operatie op de volgende regel.

  • De binaire codering van de instructies wordt steeds als laatste gegeven in courier lettertype.

ADD telt twee waarden op, veranderd alle status vlaggen op de standaard manier.

ADD Rd,Rs
Rd := Rd + Rs 0100ssdd

ADD Rd,@Ri
Rd := Rd + [Ri] 01010idd

ADD Rd,#imm
Rd := Rd + immediate 010110dd

ADD Rd,dir
Rd := Rd + [dir] 010111dd

ANL (ANd Logical) voert een bitsgewijze (parallelle) logische AND operatie tussen twee waarden uit, veranderd alleen de status vlaggen sign en zero op de standaard manier (carry en overflow veranderen niet).

ANL Rd,Rs
Rd := Rd AND Rs 0010ssdd

ANL Rd,@Ri
Rd := Rd AND [Ri] 00110idd

ANL Rd,#imm
Rd := Rd AND immediate 001110dd

ANL Rd,dir
Rd := Rd AND [dir] 001111dd

CALL slaat het adres van de volgende instructie op op de stack en springt daarna onconditioneel naar een opgegeven label, gebruik makend van een 10 bits adres in de instructie. Bij een 10 bits PC zijn er dus geen begrenzingen, bij ‘oprekken’ van de PC tot 16 bits worden alleen de laagste bits van de PC geladen (bits 0..9) en kan alleen gesprongen worden binnen de 1 KiloByte ‘pagina’ waar de volgende instructie in begint.

CALL adr10
PC := PC + 2 (tijdens ophalen instructie)
SP := SP + 1
[SP] := PC (bits 0..7)
SP := SP + 1
[SP] := PC (bits 8..9 aangevuld met 0-en òf bits 8..15)
PC (bits 0..9) := adr10
101100aa

CLR
(CLeaR) zet één van de vier statusvlaggen op 0.

CLR flag
flag := 0 111000ff

CPL
(ComPLement) laadt één van de vier werkregisters OF een van de vier statusvlaggen met het (bitsgewijze) logische complement van het oorspronkelijke werkregister/vlag.

CPL flag
flag := NOT flag 111010ff

CPL Rd
Rd := NOT Rd 110111dd

DEC
(DECrement) verlaagt de waarde van één van de vier werkregisters met 1. Van de statusvlaggen wordt alleen de zero vlag veranderd.

DEC Rd
Rd := Rd - 1 110011dd

INC
(INCrement) verhoogt de waarde van één van de vier werkregisters met 1. Van de statusvlaggen wordt alleen de zero vlag veranderd.

INC Rd
Rd := Rd + 1 110010dd

JF (Jump False) springt conditioneel naar een opgegeven label als de opgegeven statusvlag niet gezet is (binair 0), gebruik makend van een 8 bits adres in de instructie. Alleen de laagste bits van de PC worden geladen (bits 0..7), er kan alleen gesprongen worden binnen de 256 byte ‘pagina’ waar de volgende instructie in begint.

JF flag,adr8
PC := PC + 2 (tijdens ophalen instructie)
IF flag = 0b THEN PC (bits 0..7) := adr8 ENDIF
101010ff

JMP springt onconditioneel naar een opgegeven label, gebruik makend van een 10 bits adres in de instructie. Bij een 10 bits PC zijn er dus geen begrenzingen, bij ‘oprekken’ van de PC tot 16 bits worden alleen de laagste bits van de PC geladen (bits 0..9) en kan alleen gesprongen worden binnen de 1 KiloByte ‘pagina’ waar de volgende instructie in begint.

JMP adr10
PC := PC + 2 (tijdens ophalen instructie)
PC (bits 0..9) := adr10 101000aa

JT (Jump True) springt conditioneel naar een opgegeven label als de opgegeven statusvlag gezet is (binair 1), gebruik makend van een 8 bits adres in de instructie. Alleen de laagste bits van de PC worden geladen (bits 0..7), er kan alleen gesprongen worden binnen de 256 byte ‘pagina’ waar de volgende instructie in begint.

JT flag,adr8
PC := PC + 2 (tijdens ophalen instructie)
IF flag = 1b THEN PC (bits 0..7) := adr8 ENDIF
101011ff

LCALL
(Long CALL, OPTIONEEL, alleen bij ‘oprekken’ van de PC tot 16 bits!) slaat het adres van de volgende instructie op op de stack en springt daarna onconditioneel naar een opgegeven label, gebruik makend van een 16 bits adres in de instructie.

LCALL adr16
PC := PC + 3 (tijdens ophalen instructie)
SP := SP + 1
[SP] := PC (bits 0..7)
SP := SP + 1
[SP] := PC (bits 8..15)
PC := adr16
10110100

LJMP (Long JuMP, OPTIONEEL, alleen bij ‘oprekken’ van de PC tot 16 bits!) springt onconditioneel naar een opgegeven label, gebruik makend van een 16 bits adres in de instructie.

LJMP adr16
PC := adr16 10100100

MOV kopieert een bronwaarde naar de bestemming, veranderd geen status vlaggen. Een ‘No-OPeration’ (‘NOP’) instructie wordt gemaakt met ‘MOV R0,R0’ en heeft als binaire codering 00000000b).

MOV Rd,Rs
Rd := Rs 0000ssdd

MOV Rd,@Ri
Rd := [Ri] 00010idd

MOV Rd,#imm
Rd := immediate 000110dd

MOV Rd,dir
Rd := [dir] 000111dd

MOV @Ri,Rs
[Ri] := Rs 10010iss

MOV dir,Rs
[dir] := Rs 100111ss

POP haalt één van de vier werkregisters van de stack.

POP Rd
Rd := [SP]
SP := SP - 1 110001dd

PUSH
slaat één van de vier werkregisters op op de stack.

PUSH Rs
SP := SP + 1
[SP] := Rs 110000ss

RET (RETurn) ‘POP’t de PC van de stack als afsluiting van een subroutine om weer door te gaan met de instructie volgend op de CALL of LCALL waarmee die subroutine werd aangeroepen.

RET
PC (bits 8..9 òf bits 8..15) := [SP]
SP := SP - 1
PC (bits 0..7) := [SP]
SP := SP - 1 10111000

RRC (Rotate Right with Carry) schuift één van de vier werkregisters naar rechts over 1 bit, waarbij bit 7 geladen wordt met de carry vlag. De carry vlag wordt geladen met het oorspronkelijke bit 0 van het aangewezen werkregister.

RRC Rd
C := Rd bit 0 ||
Rd bits 0..6 := Rd bits 1..7 ||
Rd bit 7 := C 110110dd

SETB
(SET Bit) zet één van de vier statusvlaggen op 1.

SETB flag
flag := 1 111001ff

SRA (Shift Right Arithmetic) schuift één van de vier werkregisters naar rechts over 1 bit, waarbij bit 7 niet veranderd wordt. De carry vlag wordt geladen met het oorspronkelijke bit 0 van het aangewezen werkregister. Dit is een deling door 2 voor two’s complement getallen.

SRA Rd
C := Rd bit 0 ||
Rd bits 0..6 := Rd bits 1..7 110101dd

SRL (Shift Right Logical) schuift één van de vier werkregisters naar rechts over 1 bit, waarbij bit 7 gevuld wordt met een 0. De carry vlag wordt geladen met het oorspronkelijke bit 0 van het aangewezen werkregister. Dit is een deling door 2 voor getallen zonder teken.

SRL Rd
C := Rd bit 0 ||
Rd bits 0..6 := Rd bits 1..7 ||
Rd bit 7 := 0 110100dd

SUB (SUBtract) trekt twee waarden af, veranderd status vlaggen overfow, zero en sign op de standaard manier. Carry wordt geladen met het complement van de eigenlijk gegenereerde carry en geeft hiermee ‘Borrow’ (‘lenen’) aan.

SUB Rd,Rs
Rd := Rd - Rs 0110ssdd

SUB Rd,@Ri
Rd := Rd – [Ri] 01110idd

SUB Rd,#imm
Rd := Rd - immediate 011110dd

SUB Rd,dir
Rd := Rd – [dir] 011111dd

WAIT
wacht met het ophalen van de volgende instructie totdat de aangewe-zen test ingang van de processor op 1 staat.

WAIT test
REPEAT UNTIL test = 1 111100tt
    1. Instructies op binaire code volgorde


Van links naar rechts is steeds gegeven de instructie naam, eventuele operanden, vlaggen die veranderd worden en de bit codering. ‘x’ bits zijn hier ‘don’t care’ bits (mogen 0 of 1 zijn).

NOP - 00000000

MOV Rd,Rs - 0000ssdd

MOV Rd,@Ri - 00010idd

MOV Rd,#imm - 000110dd

MOV Rd,dir - 000111dd

ANL Rd,Rs ZS 0010ssdd

ANL Rd,@Ri ZS 00110idd

ANL Rd,#imm ZS 001110dd

ANL Rd,dir ZS 001111dd

ADD Rd,Rs CVZS 0100ssdd

ADD Rd,@Ri CVZS 01010idd

ADD Rd,#imm CVZS 010110dd

ADD Rd,dir CVZS 010111dd

SUB Rd,Rs CVZS 0110ssdd

SUB Rd,@Ri CVZS 01110idd

SUB Rd,#imm CVZS 011110dd

SUB Rd,dir CVZS 011111dd

(reserved) - 1000xxxx



MOV @Ri,Rs - 10010iss

(reserved) - 100010xx



MOV dir,Rs (1) 100111ss

JMP adr10 - 101000aa

(reserved, includes:) - 101001xx



LJMP adr16 (OPTIONAL) - 10100100

JF flag,adr8 - 101010ff

JT flag,adr8 - 101011ff

CALL adr10 - 101100aa

(reserved, includes:) - 101101xx



LCALL adr16 (OPTIONAL) - 10110100

RET - 10111000

(reserved) - 10111001

(reserved) - 1011101x

(reserved) - 101111xx



PUSH Rs - 110000ss

POP Rd - 110001dd

INC Rd Z 110010dd

DEC Rd Z 110011dd

SRL Rd C 110100dd

SRA Rd C 110101dd

RRC Rd C 110110dd

CPL Rd - 110111dd

CLR flag (CVZS) 111000ff

SETB flag (CVZS) 111001ff

CPL flag (CVZS) 111010ff

(reserved) - 111011xx



WAIT test - 111100tt

(reserved) - 111101xx

(reserved) - 11111xxx

(1): veranderd alle vlaggen als dir = 0FFh (assembler kent ‘PSW’!)


(CVZS): één van de vlaggen wordt veranderd
  1. Speciale directe adressen

    1. Interne processor registers


Op dit moment zijn er slechts twee direct adresseerbare adressen in gebruik voor processor-interne registers:

0FEh Stack Pointer


0FFh Programma Status Woord
    1. Input/output besturing


Er zijn 16 (zestien) direct adresseerbare adressen (0E0h..0EFh) gereserveerd voor input/output besturings registers.

In principe is er volledige vrijheid deze adressen zelf in te vullen. Toch stellen we de eis dat er één 8 bits parallelle input poort (op adres 0EAh) en één 8 bits parallelle output poort (op adres 0E5h) aanwezig moeten zijn. Dit maakt het mogelijk om een redelijk compleet test programma te schrijven dat test of de processor aan de instructieset architectuur voldoet.

Er zijn allerlei mogelijkheden om ‘zuinig’ te zijn met hardware door het combineren van functies in de input-output modulen (bijvoorbeeld één enkele teller gebruiken voor de timer én de pulsbreedte modulatoren). Omdat de hardware toch speciaal voor deze OGO-opdracht wordt ontwikkeld is het niet noodzakelijk om van alles instelbaar te maken. Instellingen (zoals bijvoor-beeld het aantal kloktikken tussen het periodiek aflopen van de timer) kunnen in de hardware vastgelegd worden, dat scheelt weer een paar lees/schrijfbare registers. Hieronder is een voorbeeld gegeven van een stel input/output be-sturings registers waar wél vrijwel alles instelbaar is:

0E0h Telregister voor de timer (timer uitgang koppelen aan test ingang)


0E1h Instelling snelheid van timer
0E2h Instelling cyclustijd van PWM generatoren
0E3h Pulsbreedte instelling PWM uitgang voor lamp
0E4h Pulsbreedte instelling PWM uitgang voor ventilator motor
0E5h Aansturing parallelle output poort voor D/A converter
(ook als normale output poort te gebruiken, verplicht voor test)
0E6h Data input adres van A/D converter 1 (temperatuur instelling)
0E7h ‘Handshake’ adres A/D converter 1 (om conversie te starten en te
testen of die nog bezig is – indien nodig!)
0E8h Data input adres van A/D converter 2 (temperatuur meting)
0E9h ‘Handshake’ adres A/D converter 2 (om conversie te starten en te
testen of die nog bezig is – indien nodig!)
0EAh Parallelle input poort (verplicht voor test)
  1. Input/output signalen

    1. Test ingangen


Voor de vier ‘WAIT’ instructies dienen 4 ingangen van één bit breed aanwezig te zijn. Bij het uitvoeren van een van die instructies stopt de processor indien de aangewezen ingang binair 0 is, en haalt de volgende instructie op wanneer die ingang gedurende minimaal één klokperiode binair 1 is geworden. De ‘WAIT’ instructie stopt de processor niet als de aangewezen ingang al binair 1 was.

De processor moet gewoon kunnen werken als een niet getestte test ingang een onbekende waarde (‘UNKnown’) heeft, bijvoorbeeld als die ingang niet aangesloten is. Het is raadzaam om de test ingangen binnen de processor in één bit brede registers ‘op te vangen’ – beter voor de timing van het systeem en makkelijker te testen voor de besturing.


    1. Input/output bus


Voor het koppelen van de processor met input/output modulen moet een stan-daard bus worden gebruikt. Net zoals het vastleggen van een instructieset architectuur er voor zorgt dat programma’s uitwisselbaar worden, zorgt het vastleggen van deze bus specificatie er voor dat input/output modulen uitwis-selbaar worden!

De eigenlijke input/output bus bestaat uit vier aparte signalen:



  • Eén data input bus van 8 bits breed voor datatransport van de omgeving naar de processor. Deze hoeft alleen een bekende waarde te voeren tijdens een leesactie (uitvoering van een ‘MOV Rd,dir’, ‘ADD Rd,dir’, ‘SUB Rd,dir’ of ‘ANL Rd,dirinstructie met dir in het interval 0E0h..0EFh).

  • Eén data output bus van 8 bits breed voor datatransport van de processor naar de omgeving. Hoeft alleen een bekende waarde te voeren tijdens een schrijfactie (uitvoering van een ‘MOV dir,Rs’ instructie met dir in het interval 0E0h..0EFh).

  • Eén ‘adres’ bus van 4 bits breed om de juiste input/output poort te selecteren. Hierop moeten tijdens een lees- of schrijfactie de laagste vier bits van het directe adres worden gezet.

  • Een ‘controle’ bus van 2 bits breed. Deze bus mag nooit een onbeken-de waarde krijgen en moet als er niet gelezen of geschreven wordt de waarde 00b hebben. Bit 0 is het ‘lezen’ bit, waarde 01b op deze bus geeft een leesactie aan. Bit 1 is het ‘schrijven’ bit, waarde 10b op deze bus geeft een schrijfactie aan. Tegelijk lezen en schrijven is niet mogelijk, waarde 11b zou dus nooit mogen voorkomen.

Lees- en schrijfacties moeten precies één klokcyclus duren. De controle en adres bussen moeten zo vroeg mogelijk in zo’n klokcyclus stabiel zijn om de input/output logica voldoende tijd te geven te reageren. Om diezelfde reden moet de data output ook zo vroeg mogelijk stabiel zijn, en moet de processor toelaten dat de data input pas laat in de klokcyclus stabiel wordt (het is geen goed idee om een gelezen waarde direct in de ALU te laten verwerken).
  1. Instructiematrix





0x0h

0x1h

0x2h

0x3h

0x4h

0x5h

0x6h

0x7h

0x8h

0x9h

0xAh

0xBh

0xCh

0xDh

0xEh

0xFh

00xh

MOV
R0,R0

MOV
R1,R0

MOV
R2,R0

MOV
R3,R0

MOV
R0,R1

MOV
R1,R1

MOV
R2,R1

MOV
R3,R1

MOV
R0,R2

MOV
R1,R2

MOV
R2,R2

MOV
R3,R2

MOV
R0,R3

MOV
R1,R3

MOV
R2,R3

MOV
R3,R3

01xh

MOV
R0,@R0

MOV
R1,@R0

MOV
R2,@R0

MOV
R3,@R0

MOV
R0,@R1

MOV
R1,@R1

MOV
R2,@R1

MOV
R3,@R1

MOV
R0,#d8


MOV
R1,#d8


MOV
R2,#d8


MOV
R3,#d8


MOV
R0,dir


MOV
R1,dir


MOV
R2,dir


MOV
R3,dir


02xh

ANL
R0,R0

ANL
R1,R0

ANL
R2,R0

ANL
R3,R0

ANL
R0,R1

ANL
R1,R1

ANL
R2,R1

ANL
R3,R1

ANL
R0,R2

ANL
R1,R2

ANL
R2,R2

ANL
R3,R2

ANL
R0,R3

ANL
R1,R3

ANL
R2,R3

ANL
R3,R3

03xh

ANL
R0,@R0

ANL
R1,@R0

ANL
R2,@R0

ANL
R3,@R0

ANL
R0,@R1

ANL
R1,@R1

ANL
R2,@R1

ANL
R3,@R1

ANL
R0,#d8


ANL
R1,#d8


ANL
R2,#d8


ANL
R3,#d8


ANL
R0,dir


ANL
R1,dir


ANL
R2,dir


ANL
R3,dir


04xh

ADD
R0,R0

ADD
R1,R0

ADD
R2,R0

ADD
R3,R0

ADD
R0,R1

ADD
R1,R1

ADD
R2,R1

ADD
R3,R1

ADD
R0,R2

ADD
R1,R2

ADD
R2,R2

ADD
R3,R2

ADD
R0,R3

ADD
R1,R3

ADD
R2,R3

ADD
R3,R3

05xh

ADD
R0,@R0

ADD
R1,@R0

ADD
R2,@R0

ADD
R3,@R0

ADD
R0,@R1

ADD
R1,@R1

ADD
R2,@R1

ADD
R3,@R1

ADD
R0,#d8


ADD
R1,#d8


ADD
R2,#d8


ADD
R3,#d8


ADD
R0,dir


ADD
R1,dir


ADD
R2,dir


ADD
R3,dir


06xh

SUB
R0,R0

SUB
R1,R0

SUB
R2,R0

SUB
R3,R0

SUB
R0,R1

SUB
R1,R1

SUB
R2,R1

SUB
R3,R1

SUB
R0,R2

SUB
R1,R2

SUB
R2,R2

SUB
R3,R2

SUB
R0,R3

SUB
R1,R3

SUB
R2,R3

SUB
R3,R3

07xh

SUB
R0,@R0

SUB
R1,@R0

SUB
R2,@R0

SUB
R3,@R0

SUB
R0,@R1

SUB
R1,@R1

SUB
R2,@R1

SUB
R3,@R1

SUB
R0,#d8


SUB
R1,#d8


SUB
R2,#d8


SUB
R3,#d8


SUB
R0,dir


SUB
R1,dir


SUB
R2,dir


SUB
R3,dir


08xh

--

--

--

--

--

--

--

--

--

--

--

--

--

--

--

--

09xh

MOV
@R0,R0

MOV
@R0,R1

MOV
@R0,R2

MOV
@R0,R3

MOV
@R1,R0

MOV
@R1,R1

MOV
@R1,R2

MOV
@R1,R3

--

--

--

--

MOV
dir,R0


MOV
dir,R1


MOV
dir,R2


MOV
dir,R3


0Axh

JMP
0xxh


JMP
1xxh


JMP
2xxh


JMP
3xxh


LJMP
addr16


--

--

--

JF
C,addr8


JF
V,addr8


JF
Z,addr8


JF
S,addr8


JT
C,addr8


JT
V,addr8


JT
Z,addr8


JT
S,addr8


0Bxh

CALL
0xxh


CALL
1xxh


CALL
2xxh


CALL
3xxh


LCALL
addr16


--

--

--

RET

--

--

--

--

--

--

--

0Cxh

PUSH
R0

PUSH
R1

PUSH
R2

PUSH
R3

POP
R0

POP
R1

POP
R2

POP
R3

INC
R0

INC
R1

INC
R2

INC
R3

DEC
R0

DEC
R1

DEC
R2

DEC
R3

0Dxh

SRL
R0

SRL
R1

SRL
R2

SRL
R3

SRA
R0

SRA
R1

SRA
R2

SRA
R3

RRC
R0

RRC
R1

RRC
R2

RRC
R3

CPL
R0

CPL
R1

CPL
R2

CPL
R3

0Exh

CLR
C

CLR
V

CLR
Z

CLR
S

SETB
C

SETB
V

SETB
Z

SETB
S

CPL
C

CPL
V

CPL
Z

CPL
S

--

--

--

--

0Fxh

WAIT
0

WAIT
1

WAIT
2

WAIT
3

--

--

--

--

--

--

--

--

--

--

--

--

Lettertype geeft lengte aan: een, twee of drie bytes (de laatste alleen bij ‘opgerekte’ PC)

OGO 1.2 processor ISA pagina

  • Adresruimten Programmageheugen
  • Interne registers Werkregisters
  • Instructieset Introductie
  • Instructies op alfabetische volgorde
  • Instructies op binaire code volgorde
  • Speciale directe adressen Interne processor registers
  • Input/output signalen Test ingangen

  • Dovnload 180.08 Kb.