xprakt.txt

xprakt.txt — HTML, 33 kB (34.152 bytes)

Dateiinhalt

               Minimalprozessor XPROZ
               ======================
               

Signalbeschreibung:
------------------

A14-A0:  Adressleitungen zur Adressierung von jeweils 32k Worten (=64 kByte) 
         RAM- und ROM-Speicher oder IO-Bereich

D15-D0:  16 Datenleitung

RAMSEL~: falls 0 ist die ausgegebene Adresse RAM-Adresse 
         (Adressbereich $0000-$7fff)

ROMSEL~: falls 0 ist die ausgegebene Adresse ROM-Adresse 
         (Adressbereich $8000-$ffff)

IOSEL~:  falls 0 ist die ausgegebene Adresse IO-Adresse 

rw~:     0: schreiben
         1: lesen

oe~:     0: Speicherausgaenge aktiv
         1: Speicherausgaenge hochohmig

RESET~:  0: Prozessor ruecksetzen (Programmausfuehrung beginnt an der 
            Adresse $8000 im Interrupt-Mode 5 (sr=$00) mit gesperrten 
            Interrupts)
         1: inaktiv

IRQ1~:   0: Interrupt Request 1 (muss mindestens 17*8 Takte anliegen)
         1: inaktiv

IRQ2~:   0: Interrupt Request 2 (muss mindestens 17*8 Takte anliegen)
         1: inaktiv

IRQ3~:   0: Interrupt Request 3 (muss mindestens 17*8 Takte anliegen)
         1: inaktiv

IRQ4~:   0: Interrupt Request 4 (muss mindestens 17*8 Takte anliegen)
         1: inaktiv

IRQ5~:   0: Interrupt Request 5 (muss mindestens 17*8 Takte anliegen)
         1: inaktiv

TAKT:    Prozessortakt (wird intern durch 8 geteilt) (ca. 30 MHz)


















Programm-Counter (pc):
---------------------

Der pc befindet sich nicht als Register im Prozessor sondern im normalen 
RAM-Speicher. Im USER-Mode wird die Speicherzelle mit die Adresse 0 als 
pc verwendet. Im Interruptmodus i wird die Speicherzelle mit der Adresse 
i als pc verwendet. 




Statusregister (sr):
-------------------



  15  14  13  12  11  10  9   8   7   6   5   4   3   2   1   0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| - | - | i5| i4| i3| i2| i1| ie| - | - | - | - | V | N | Z | C |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

ie:  falls 1, sind Interrupts erlaubt

i5:  falls 0, befindet sich Prozessor in Interruptebene 5 
     (d.h.  Speicheradresse 5 wird als Programmzaehler verwendet)

i4:  falls 0 und i5=1, befindet sich Prozessor in Interruptebene 4
     (d.h.  Speicheradresse 4 wird als Programmzaehler verwendet)

i3:  falls 0 und i5=i4=1, befindet sich Prozessor in Interruptebene 3
     (d.h.  Speicheradresse 3 wird als Programmzaehler verwendet)

i2:  falls 0 und i5=i4=i3=1, befindet sich Prozessor in Interruptebene 2
     (d.h.  Speicheradresse 2 wird als Programmzaehler verwendet)

i1:  falls 0 und i5=i4=i3=i2=1, befindet sich Proz. in Interruptebene 1
     (d.h.  Speicheradresse 1 wird als Programmzaehler verwendet)

     d.h. i5 ist der Interrupt mit der hoechsten und i1 der mit der
     niedrigsten Prioritaet.

V: Overflow-Flag
N: Negativ-Flag
Z: Zero-Flag
C: Carry-Flag

i5 - i1 werden durch IRQ5~ - IRQ1~ hardwaremaessig auf 0 gesetzt. Setzen 
(und damit Rueckkehr in den USER-Mode) ist nur durch die Software moeglich. 
Das Umschalten vom USER-Mode in den Interrupt-Mode (bzw. von einem 
niedriger priorisierten zu einem hoeher priorisierten Interrupt-Mode) 
erfolgt jeweils nach der Abarbeitung des Befehls in dem IRQ in der 
Phase 2 aktiv ist. Eine Ausnahme davon ist gegeben, wenn dieser Befehl 
ein bedingter Befehl ist, der aufgrund der Bedingung nicht ausgefuehrt 
wird. In diesem Fall wird das Umschalten in den Interrupt-Modus solange 
verzoegert, bis ein unbedingter Befehl oder ein bedingter Befehl, dessen 
Bedingung erfuellt ist abgearbeitet wurde. (Dadurch konnte bei bedingten 
Befehlen die nicht ausgefuehrt werden ein Taktzyklus eingespart werden.)

Das Statusregister enthaelt nach dem Reset den Wert $00.







Befehlsformat:
-------------


 B15 B14 B13 B12 B11 B10 B9  B8  B7  B6  B5  B4  B3  B2  B1  B0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|xsr|xio|zsr|zio|   |   |       |       |       |               |
+---------------+BED|SF |Z1  Z0 |Y1  Y0 |X1  X0 |ALU ALU ALU ALU|
|      CC       |   |   |       |       |       | 3   2   1   0 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                         x-Adresse                             |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                         y-Adresse                             |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|                         z-Adresse                             |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+


+------+----------------+------+-------------------+
| ALU  |                | ALU  |                   |
| 1  0 |                | 3  2 |                   |
+------+----------------+------+-------------------+
|      |                | 0  0 |    add            |
| 0  0 | arithmetisch   | 0  1 |    sub            |
|      |                | 1  0 |    addc           |
|      |                | 1  1 |    subc           |
+------+----------------+------+-------------------+
|      |                | 0  0 |    nor            |
| 0  1 | logisch        | 0  1 |    and            |
|      |                | 1  0 |    eor            |
|      |                | 1  1 |    or             |
+------+----------------+------+-------------------+
|      |                | 0  0 |    ror            |
| 1  0 | schiebe rechts | 0  1 |    rorc           |
|      |                | 1  0 |    asr            |
|      |                | 1  1 |    lsr            |
+------+----------------+------+-------------------+
|      |                | 0  0 |    rol            |
|      | schiebe links  | 0  1 |    rolc           |
| 1  1 |                | 1  0 |    asl=lsl        |
|      +----------------+------+-------------------+
|      | byte swap      | 1  1 |    bswp           |
+------+----------------+------+-------------------+





1. Operand: x bestimmt durch x1,x0

+-------+----------------------------------------------+---------+
| B5 B4 |  Beschreibung                                | Symbol  |
+-------+----------------------------------------------+---------+
| 0  0  |  kein x-Operand (intern wird 1 verwendet)    |  -      |
| 0  1  |  x ist als Direktoperand angegeben           | #wert   |
| 1  0  |  Adresse von x ist angegeben                 | wert    |
| 1  1  |  Adresse von der Adresse von x ist angegeben | (wert)  |
+-------+----------------------------------------------+---------+








2. Operand: y bestimmt durch y1,y0

+-------+----------------------------------------------+---------+
| B7 B6 |  Beschreibung                                | Symbol  |
+-------+----------------------------------------------+---------+
| 0  0  |  kein y-Operand (intern wird 0 verwendet)    |  -      |
| 0  1  |  y ist als Direktoperand angegeben           | #wert   |
| 1  0  |  Adresse von y ist angegeben                 | wert    |
| 1  1  |  Adresse von der Adresse von y ist angegeben | (wert)  |
+-------+----------------------------------------------+---------+



Ergbnis: z bestimmt durch z1,z0

+-------+----------------------------------------------+---------+
| B9 B8 "  Beschreibung                                | Symbol  |
+-------+----------------------------------------------+---------+
| 0  0  "  kein Ergebnis                               |  -      |
| 0  1  "  Ergebnis hat gleiche Adresse wie y-Operand  |  =      |
| 1  0  "  Adresse von z ist angegeben                 | wert    |
| 1  1  "  Adresse von der Adresse von z ist angegeben | (wert)  |
+-------+----------------------------------------------+---------+

Besonderheit: 

Bei y=(00) und z=(01) (d.h. kein y-Operand und Ergebnis gleich y-Operand) 
wird das Ergebnis im aktuellen PC (0 im USER-Mode, i in der Interrupt-Ebene i)
abgespeichert. Dadurch sind 2-Befehlswort-Spruenge moeglich, die sich immer 
auf den aktuellen PC beziehen.

z.B.    add cs hf #label,-,=


Hinweis:

Bei der Kombination y=(01) und z=(01) (d.h. y-Operand ist als Direktoperand 
angegeben und Ergebnis ist gleich y-Operand) wird der Direktoperand im Befehl 
mit dem Ergebnis ueberschrieben (funktioniert natuerlich  nicht falls Programm 
im ROM steht). Hiermit laesst sich beispielsweise ein Schleifenzaehler 
realisieren:

       add  tr hf  #100,-,lab2+1  ; Zaehler vorbesetzen
lab1:  ...
       ...
       ...
lab2:  sub  tr sf  -,#0,=         ; 1 subtrahieren
       add  ne hf  #lab1,-,=      ; falls nicht 0 springen
       ...

Set Flags:  bestimmt durch SF

+----+----------------------------------------------------+---------+
|B10 |  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Flags werden durch diesen Befehl nicht veraendert  |   hf    |
| 1  |  Flags werden entsprechend dem Ergebnis gesetzt    |   sf    |
+----+----------------------------------------------------+---------+








Bedingt/Unbedingt: bestimmt durch BED

+----+----------------------------------------------------+---------+
|B11 "  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Befehl wird nur ausgefuehrt, wenn die Bedingung   |gt,ne,...|
|    |  CC (B15-B12) erfuellt ist                         | usw.    |
| 1  |  Befehl wird immer ausgefuehrt, B15-B12            |         |
|    |  modifizieren x-Operand und Ergebnisadresse        |   tr    |
+----+----------------------------------------------------+---------+


Condition Code: bestimmt durch CC

+---------------+------+---------------------+----------------------+
|B15 B14 B13 B12|Symbol| Beschreibung        | Funktion             |
+---------------+------+---------------------+----------------------+
| 0   0   0   0 |  me  |  minus or equal     |  Z+N                 |
| 0   0   0   1 |  pe  |  plus and not equal |  (~Z)(~N)            |
| 0   0   1   0 |  hi  |  higher             |  (~C)(~Z)            |
| 0   0   1   1 |  ls  |  lower or same      |  C+Z                 |
| 0   1   0   0 |  cc  |  carry clear        |  ~C                  |
| 0   1   0   1 |  cs  |  carry set          |  C                   |
| 0   1   1   0 |  ne  |  not equal          |  ~Z                  |
| 0   1   1   1 |  eq  |  equal              |  Z                   |
| 1   0   0   0 |  vc  |  overflow clear     |  ~V                  |
| 1   0   0   1 |  vs  |  overflow set       |  V                   |
| 1   0   1   0 |  pl  |  plus               |  ~N                  |
| 1   0   1   1 |  mi  |  minus              |  N                   |
| 1   1   0   0 |  ge  |  greater or equal   |  NV+(~N)(~V)         |
| 1   1   0   1 |  lt  |  less then          |  N(~V)+(~N)V         |
| 1   1   1   0 |  gt  |  greater then       |  NV(~Z)+(~N)(~V)(~Z) |
| 1   1   1   1 |  le  |  less or equal      |  Z+N(~V)+(~N)V       |
+---------------+------+---------------------+----------------------+


Statusregister als x-Operand: bestimmt durch xsr

+----+----------------------------------------------------+---------+
|B15 |  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Der normal adressierte x-Operand wird verwendet   | keines  |
| 1  |  Die Bits 13-8,3-0 des adressierten x-Operanden    |         |
|    |  werden durch die entsprechenden Bits im           |   &     |
|    |  Statusregister ersetzt                            |         |
+----+----------------------------------------------------+---------+


x-Operand aus dem I/O-Adressraum: bestimmt durch xio

+----+----------------------------------------------------+---------+
"B14 |  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Der normal adressierte x-Operand wird verwendet   | keines  |
| 1  |  Die Adresse des x-Operands wir als I/O-Adresse    |         |
|    |  behandelt (keine Wirkung falls kein x-Operand oder|   @     |
|    |  immidiate Wert)                                   |         |
+----+----------------------------------------------------+---------+








Ergebnis ins Statusregister: bestimmt durch zsr

+----+----------------------------------------------------+---------+
|B13 |  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Das Ergebnis wird normal abgespeichert            | keines  |
| 1  |  Ergebnis wird zusaetzlich zur normalen            |         |
|    |  Speicherung auch im Statusregister abgespeichert. |    &    |
+----+----------------------------------------------------+---------+

Bemerkung: 
Die niederwertigen vier Bits (Flags) werden nur dann im Statusregister 
gespeichert, wenn gleichzeitig SF=1 ist. Das hoeherwertige Byte (Interrupt- 
und Interrupt-Enable-Flags) wird nur dann im Statusregister gespeichert, 
wenn im Befehl auch ein normaler Z-Operand (im Speicher oder IO-Bereich) 
angegeben ist. Der aktuelle Programmcounter (d.h. der Sonderfall: kein 
Y-Operand und Z-Operand gleich Y-Operand) zaehlt hierzu jedoch nicht (es 
ist sowieseo wenig sinnvoll, das Statusregister im Programmcounter 
abzuspeichern).

and tr sf   &-,#0,&-     ; loescht C,Z,N,V-Flags
                         ; veraendert Interrupt-Flags nicht

and tr hf   &-,#0,&10    ; veraendert C,Z,N,V-Flags nicht
                         ; loescht Interrupt-Flags 

and tr sf   &-,#0,&10    ; loescht C,Z,N,V-Flags und Interrupt-Flags



Ergbnis in den I/O-Adressraum: bestimmt durch zio

+----+----------------------------------------------------+---------+
|B12 |  Beschreibung                                      | Symbol  |
+----+----------------------------------------------------+---------+
| 0  |  Das Ergebnis wird normal abgespeichert            | keines  |
| 1  |  Die Adresse des Ergebnisses wir als I/O-Adresse   |         |
|    |  behandelt (keine Wirkung falls kein Ergebnis)     |    @    |
+----+----------------------------------------------------+---------+

Sind sowohl & als auch @ angegebnen, so muss & vor @ stehen.


Beschreibung der Befehle:

add  x,y,z

     z = x + y                          C = Carry
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = Overflow 

addc x,y,z

     z = x + y + C                      C = Carry
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = Overflow 

sub  x,y,z

     z = y - x                          C = Carry
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = Overflow 

subc x,y,z

     z = y - x - C                      C = Carry
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = Overflow 

nor  x,y,z

     z = x nor y                        C = 0
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

or   x,y,z

     z = x or y                         C = 0
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

and  x,y,z

     z = x and y                        C = 0
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

eor  x,y,z

     z = x eor y                        C = 0
                                        Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert


rol  x,y,z

     z[0] = x[15]                       C = x[15]
     z[i] = x[i-1]  fuer 1 <= i <= 15   Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

rolc x,y,z

     z[0] = C                           C = x[15]
     z[i] = x[i-1]  fuer 1 <= i <= 15   Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

lsl  x,y,z
asl  x,y,z

     z[0] = 0                           C = x[15]
     z[i] = x[i-1]  fuer 1 <= i <= 15   Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert

ror  x,y,z

     z[i] = x[i+1]  fuer 0 <= i <= 14   C = x[0]
     z[15] = x[0]                       Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert


rorc x,y,z

     z[i] = x[i+1]  fuer 0 <= i <= 14   C = x[0]
     z[15] = C                          Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert


lsr  x,y,z

     z[i] = x[i+1]  fuer 0 <= i <= 14   C = x[0]
     z[15] = 0                          Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert


asr  x,y,z

     z[i] = x[i+1]  fuer 0 <= i <= 14   C = x[0]
     z[15] = x[15]                      Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert


bswp  x,y,z

      z[i] = x[i+8]  fuer 0 <= i <= 7   C = x[15]
      z[i] = y[i-8]  fuer 8 <= i <= 15  Z = nor(z[i])
                                        N = z[15]
                                        V = undefiniert
  

Beispielprogramm:

    add  tr hf #100,xwert,ywert ; addiere 100 zu xwert und speichere
                                ; Ergebnis in ywert; Flags unveraendert
    add  cs sf -,ywert,=        ; addiere 1 zu ywert falls Carry gesetzt
                                ; und setze Flags entsprechend dem
                                ; Ergebnis
    add  mi hf #l1,-,=          ; springe nach l1 falls Negativ-Flag
                                ; gesetzt

    or   tr hf @$20,#$20,(30)   ; unbedingte Oder-Verknuepfung ohne
                                ; Aenderung der Flags; 1. Operand ist 
                                ; Wert der unter der I/O-Adresse   
                                ; hex 20 steht; 2. Operand =hex 20
                                ; (d.h. 32); Ergebnis in die
                                ; Speicherstelle deren Adresse in 
                                ; der Speicherstelle 30 steht
l1: or   tr hf &#$3333,-,xwert  ; ersetze in der Zahl $3333 die Bits 13-8
                                ; und 3-0 durch die entsprechnen Bits des
                                ; Statusregisters und speichere diesen
                                ; Wert in xwert

l2: add  tr hf #l2,-,=          ; Endlosschleife   
                                ;   
xwert: dcw  100                 ; Variable xwert mit 100 belegen   
ywert: dcw  10                  ; Variable xwert mit 10 belegen   


Hinweise zum Assembler:

Die Symbole fuer Statusregister (&) und I/O-Adresse (@) duerfen nur beim 
x-Operanden und dem Ergebnis stehen. Falls beide verwendet werden, muss 
& vor @ stehen.

+-----+--------------------+----------------------------------------------+
|Phase| Funktion           | Beschreibung                                 |
+-----+--------------------+----------------------------------------------+
|  0  | PC -> y            | PC laden                                     |
|  1  | (y) -> Befehlsreg. | Befehl lesen                                 |
|  2  | y+1 -> PC,y        | PC+1                                         |
|  3  | y+1 -> PC          | PC+1                                         |
|  4  | (y) -> y           | Adresse der Adresse von x-Operand lesen      |
|  5  | (y) -> y           | Adresse von x-Operand lesen                  |
|  6  | (y) -> x           | x-Operand lesen                              |
|  7  | PC -> y            | PC laden                                     |
|  8  | y+1 -> PC          | PC+1                                         |
|  9  | (y) -> y           | ((Adresse von) Adresse von) y-Operand lesen  |
| 10  | (y) -> y           | Adresse von y-Operand lesen                  |
| 11  | (y) -> y           | y-Operand lesen                              |
| 12  | ALU -> x           | ALU-Operation ausf., Ergebnis -> x           |
| 13  | PC -> y            | PC laden                                     |
| 14  | y+1 -> PC          | PC+1                                         |
|     |     -> y falls ~CC | PC+1                                         |
| 15  | (y) -> y           | Adresse von Ergebnis lesen                   |
| 16  | (y) -> y           | Adresse von Ergeb. bei indirekter Adr. lesen |
| 17  |  x  -> (y)         | Ergebnis speichern                           |
+-----+--------------------+----------------------------------------------+

x:       X-Register
y:       Y-Register
CC:      1 falls Condition-Code erfuellt
ALU:     ALU-Ausgang
PC:      Programm-Counter 
          = Speicherwort in Adresse 0 fuer User-Mode
                                    i fuer Interruptebene i

+----+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|Phas| EB| EY| EX| GY|GX1|GX0| GA|Ad2|Ad1|Ad0|AL4|AL3|AL2|AL1|AL0| IO|MEM| rw|
+----+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|  0 | - | 1 | - | - | - | - | 0 | f1| f5| f6| - | - | - | - | - | 1 | 0 | 1 |
|  1 | 1 | 0 | - | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
|  2 | 0 | 1 | - | 1 | 1 | 0 | 0 | f1| f5| f6| - | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
|  3 | 0 | 0 | - | 1 | 1 | 0 | 0 | f1| f5| f6| - | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
|  4 | 0 | 1 | - | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
|  5 | 0 | 1 | - | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
|  6 | 0 | - | 1 | - | - | - | 1 | - | - | - | - | - | - | - | - |~f8| f8| 1 |
|  7 | 0 | 1 | 0 | - | - | - | 0 | f1| f5| f6| - | - | - | - | - | 1 | 0 | 1 |
|  8 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | f1| f5| f6| - | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
|  9 | 0 | 1 | 0 | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
| 10 | 0 | 1 | 0 | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
| 11 | 0 | 1 | 0 | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
| 12 | 0 | - | 1 | f2| f3| f4| 0 | f1| f5| f6| f7| B3| B2| B1| B0| 1 |f10| 0 |
| 13 | 0 | 1 | 0 | - | - | - | 0 | f1| f5| f6| - | - | - | - | - | 1 | 0 | 1 |
| 14 | 0 |~CC| 0 | 1 | 1 | 0 | 0 | f1| f5| f6| - | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| 15 | 0 | 1 | 0 | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
| 16 | - | 1 | 0 | - | - | - | 1 | - | - | - | - | - | - | - | - | 1 | 0 | 1 |
| 17 | - | - | - | 0 | 1 | 1 | 1 | - | - | - | - | 0 | 0 | 0 | 0 |~f9| f9| 0 |
+----+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

 f1 =                      f2 = B6 + B7           f3 =             
 f4 =                      f7 = B13 & B11         f8 =               
 f5 =                                             f9 =          
 f6 =                                             f10=                     

Bi = Befehlsbit i
CC = 1 falls Condition-Code erfuellt
In = sr[8+n] (0 falls Interruptebene n)



Ausgangsfunktionen:

Pi = Phase i (Zustand i)
Bi = Befehlsbit i
CC = 1 falls Condition-Code erfuellt
In = sr[8+n] (0 falls Interruptebene n)


EB = P1

EY = 

EX = 

GY =

GX1=

GX0=

GA =

ADR2 =

ADR1 =

Adr0 =

ALU4 =

ALU3 =

ALU2 =

ALU1 =

ALU0 =

rw =

io =

mem= 


Takte:

   .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .
   | |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_|
   
           +---------------+               +---------------+            
t0  -------+               +---------------+               +------------

           +---+                           +---+                        
t1  -------+   +---------------------------+   +------------------------

       +-------+                       +-------+                       +
t2  ---+       +-----------------------+       +-----------------------+








Zustandsuebergangs-Tabelle:

Bi    = Befehlsbit i
C9,C8 = B9,B8  falls  B9,B8 <> 0,1
C9,C8 = B7,B6  falls  B9,B8 = 0,1
CC    = 1 falls Condition-Code erfuellt


P0  --> P1
P1  --> P2
P2  --> P3  falls  B4+B5
    --> P8  falls  (~(B4+B5)) & (B6+B7) & ((~B8)+B9)
    --> P9  falls  (~(B4+B5)) & (B6+B7) & B8 & (~B9)
    --> P12 falls  (~(B4+B5)) & (~(B6+B7))
P3  --> P4  falls  B4 & B5
    --> P5  falls  (~B4) & B5
    --> P6  falls  B4 & (~B5)
P4  --> P5
P5  --> P6
P6  --> P7  falls  B6+B7
    --> P12 falls  ~(B6+B7)
P7  --> P8  falls  (~B8)+B9
    --> P9  falls  B8 & (~B9)
P8  --> P9
P9  --> P10 falls  B6 & B7
    --> P11 falls  (~B6) & B7
    --> P12 falls  (~B7)
P10 --> P11
P11 --> P12
P12 --> P13 falls  C9+C8
    --> P0  falls  (~C9) & (~C8)
P13 --> P14
P14 --> P15 falls  CC & C9
    --> P17 falls  CC & (~C9)
    --> P1  falls  ~CC
P15 --> P16 falls  C8
    --> P17 falls  ~C8
P16 --> P17
P17 --> P0




























                            +---+
                     +----->| 4 |
                     |      +-.-+
                     |        v
                     |      +---+
                     | +--->| 5 |
                     | |    +-.-+
                     | |      v
                    +'-'+   +---+   +---+
               +--->| 3 |-->| 6 |-->| 7 |---+
               |    +---+   +.--+   +-.-+   |
               |             |        v     |
               |             |      +---+   |
               | +-----------+----->| 8 |-+ |
               | |           |      +---+ v v
+---+  +---+  +'-'+          |           +---+  +---+
| 0 |->| 1 |->| 2 +----------+---------->| 9 |->| 10|
+---+  +---+  +-.-+          |           +.-.+  +-.-+
 ^ ^     ^      |            | +----------+ |     |
 | |     |      |            v v            v     |
 | |     |      |           +---+        +---+    |
 | |     |      +---------->| 12|<-------| 11|<---+
 | |     |                  +.-.+        +---+
 | +-----+-------------------+ v
 |       |                  +---+
 |       |                  | 13|
 |       |                  +-.-+
 |       |                    v
 |       |                  +---+
 |       +------------------| 14|-----+
 |                          +-.-+     v
 |                            |     +---+
 |                            |     | 15|
 |                            |     +.-.+
 |                            | +----+ v
 |                            | |    +---+
 |                            | |    | 16|
 |                            v v    +-.-+
 |                           +---+     |
 +---------------------------| 17|<----+
                             +---+



Ansteuertabelle der Flip-Flops:

D0 = P12 & (~C9) & (~C8) + P17
D1 = P0 + P14 & (~CC)
D2 = P1
D3 = P2                                         R3 = P8 + P9 + P12
D4 =                                            R4 =        
D5 =                
D6 =                
D7 =                                            R7 =     
D8 =                                            R8 =        
D9 =                                            R9 =     
D10=                                            R10=          
D11=                                            R11=     
D12=                                                             
D13=                                            R13=   
D14=     
D15=                                            R15=         
D16=                                            R16=    
D17=                                            R17=     

Beschreibung der Funktionsbloecke:

1. XREG

Beschreibung:  16-Bit Register
Eingaenge:      D[15:0], CLK, E
Ausgaenge:      Q[15:0]
Funktion:      falls E=1 werden bei der steigenden Taktflanke die anliegenden 
               Signale D[15:0] in das Register uebernommen
Reset:         nach dem Reset enthaelt das Register den Wert 0


2. YREG

Beschreibung:  16-Bit Register
Eingaenge:      D[15:0], CLK, E
Ausgaenge:      Q[15:0]
Funktion:      falls E=1 werden bei der steigenden Taktflanke die anliegenden 
               Signale D[15:0] in das Register uebernommen
Reset:         nach dem Reset enthaelt das Register den Wert $8000


3. BREG

Beschreibung:  16-Bit Register
Eingaenge:      D[15:0], CLK, E
Ausgaenge:      Q[15:0]
Funktion:      falls E=1 erden bei der steigenden Taktflanke die anliegenden 
               Signale D[15:0] in das Register uebernommen
Reset:         nach dem Reset enthaelt das Register den Wert 0


4. TAKTE

Beschreibung:  Erzeugt aus einem externen 8 MHz Takt CLK die intern benoetigten 
               1 MHz Takte T0, T1, T2
Eingaenge:      CLK
Ausgaenge:      T0, T1, T2
Funktion:      erzeugt folgende Taktsignale:


   .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .-. .
CLK| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_|
   
           +---------------+               +---------------+            
t0  -------+               +---------------+               +------------

           +---+                           +---+                        
t1  -------+   +---------------------------+   +------------------------

       +-------+                       +-------+                       +
t2  ---+       +-----------------------+       +-----------------------+

                           ^
                           Beginn nach Reset

Reset:         Waehrend Reset sind T0, T1 und T2 0; nach dem Reset starten 
               die Signale an der markierten Stelle.


5. XMUX

Beschreibung:  Multiplexer, der wahlweise den Ausgang des XREG, das 
               Statusregister oder den Wert $0001 durchschaltet.
Eingaenge:      A[15:0], B[15:0], S1, S0
Ausgaenge:      C[15:0]


Funktion:       S1 S0 |  C[15:14] | C[13:8] | C[7:4] | C[3:0]
                ---------------------------------------------
                0  0  |     00    | A[13:8] |   0    | A[3:0]
                0  1  |  B[15:14] | A[13:8] | B[7:4] | A[3:0]
                1  0  |     00    |  000000 |  0000  |  0001 
                1  1  |  B[15:14] | B[13:8] | B[7:4] | B[3:0]

6. YGATE

Beschreibung:  Multiplexer, der wahlweise den Ausgang des YREG oder den 
               Wert $0000 durchschaltet.
Eingaenge:      A[15:0], G
Ausgaenge:      C[15:0]

Funktion:      G |  C[15:0]
               ------------
               0 |  $0000  
               1 |  A[15:0]

7. AGATE

Beschreibung:  Multiplexer, der wahlweise den Ausgang des YREG oder die Werte 
               $0000, $0001, $0002, $0003, $0004 oder $0005 durchschaltet.
Eingaenge:      A[15:0], G, S2, S1, S0
Ausgaenge:      C[15:0]

Funktion:      falls G=1 : C[15:0]=A[15:0]
               falls G=0 : Ci=0   fuer 3 <= i <= 15
                           C2=S2
                           C1=S1
                           C0=S0

8. ALU

Beschreibung:  fuehrt die arithmetischen und logischen Operationen aus
Eingaenge:      X[15:0], Y[15:0], CIN, S[4:0]
Ausgaenge:      Z[15:0], SR_OUT[15:0]
Funktion:      

               +------------+------------+---------------------------+
               |s1 s0 s3 s2 |  Z         | CF             VF         |
               +------------+------------+---------------------------+
               | 0  0  0  0 |  X+Y       | C(X+Y)         V(X+Y)     |
               | 0  0  0  1 |  Y-X       | C(Y-X)         V(Y-X)     |
               | 0  0  1  0 |  X+Y+CIN   | C(X+Y+CIN)     V(X+Y+CIN  |
               | 0  0  1  1 |  Y-X-CIN   | C(Y-X-CIN      V(Y-X-CIN) |
               +------------+------------+---------------------------+
               | 0  1  0  0 |  X nor Y   | 0              V(X+Y)     |
               | 0  1  0  1 |  X and Y   | 0              V(Y-X)     |
               | 0  1  1  0 |  X eor Y   | 0              V(X+Y+CIN  |
               | 0  1  1  1 |  X or  Y   | 0              V(Y-X-CIN) |
               +------------+------------+---------------------------+
               | 1  0  0  0 |  ror  X    | X[0]           V(X+Y)     |
               | 1  0  0  1 |  rorc X    | X[0]           V(Y-X)     |
               | 1  0  1  0 |  asr  X    | X[0]           V(X+Y+CIN  |
               | 1  0  1  1 |  lsr  X    | X[0]           V(Y-X-CIN) |
               +------------+------------+---------------------------+
               | 1  1  0  0 |  rol  X    | X[15]          V(X+Y)     |
               | 1  1  0  1 |  rolc X    | X[15]          V(Y-X)     |
               | 1  1  1  0 |  asl  X    | X[15]          V(X+Y+CIN  |
               | 1  1  1  1 |  bswp X,Y  | X[15]          V(Y-X-CIN) |
               +------------+------------+---------------------------+


               falls S4=1: SR_OUT[13:8,3:0]= Z[13:8,3:0]

               falls S4=0: SR_OUT[0]   = CF
                           SR_OUT[1]   = nor (Z[i])  i=0..15
                           SR_OUT[2]   = Z[15]
                           SR_OUT[3]   = VF
                           SR_OUT[13:8] = Z[13:8]