Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- z1013:handbuecher:handbuch_1 [2010/07/21 11:30] – koma
+++ z1013:handbuecher:handbuch_1 [2013/06/25 11:04] (aktuell) – volkerp
@@ Zeile 46: / Zeile 46: @@
 .5.[[#stromversorgung|Stromversorgung]]\\
 .6.[[#bussystem|Bussystem]]\\
-.        Der Befehlssatz des Mikroprozessors U880
+.[[#der_befehlssatz_des_mikroprozessors_u880|Der Befehlssatz des Mikroprozessors U880]]\\
-.1.      Befehlsschluessel
+.1.[[#befehlsschluessel|Befehlsschluessel]]\\
-.1.1.    1-Byte Befehle
+.1.1.[[#byte-befehle|1-Byte Befehle]]\\
-.1.2.    2-Byte Befehle
+.1.2.[[#byte-befehle1|2-Byte Befehle]]\\
-.1.3.    3-Byte Befehle
+.1.3.[[#byte-befehle2|3-Byte Befehle]]\\
-.1.4.    4-Byte Befehle
+.1.4.[[#byte-befehle3|4-Byte Befehle]]\\
-.2.      Adressierung
+.2.[[#adressierung|Adressierung]]\\
-.2.1.    Registeradressierung
+.2.1.[[#registeradressierung|Registeradressierung]]\\
-.2.2.    Direktwertadressierung
+.2.2.[[#direktwertadressierung|Direktwertadressierung]]\\
-.2.3.    Registerindirektadressierung
+.2.3.[[#registerindirektadressierung|Registerindirektadressierung]]\\
-.2.4.    Indexierte Adressierung
+.2.4.[[#indexierte_adressierung|Indexierte Adressierung]]\\
-.3.      Maschinenbefehle und ihre Bedeutung
+.3.[[#maschinenbefehle_und_ihre_bedeutungen|Maschinenbefehle und ihre Bedeutung]]\\
-.3.1.    Ladebefehle
+.3.1.[[#ladebefehle|Ladebefehle]]\\
-.3.2.    Byte- und Doppelbyte-Zaehl-Befehle
+.3.2.[[#byte-_und_doppelbyte-zaehl-befehle|Byte- und Doppelbyte-Zaehl-Befehle]]\\
-.3.3.    Arithmetische Befehle
+.3.3.[[#arithmetische_befehle|Arithmetische Befehle]]\\
-.3.4.    Vergleichsbefehle
+.3.4.[[#vergleichsbefehle|Vergleichsbefehle]]\\
-.3.5.    Logische Befehle
+.3.5.[[#logische_befehle|Logische Befehle]]\\
-.3.6.    Spezielle arithmetische Hilfsoperationen
+.3.6.[[#spezielle_arithmetische_hilfsoperationen|Spezielle arithmetische Hilfsoperationen]]\\
-.3.7.    Befehle zur Bitmanipulation
+.3.7.[[#befehle_zur_bit-manipulation|Befehle zur Bitmanipulation]]\\
-.3.8.    Verschiebebefehle
+.3.8.[[#verschiebebefehle|Verschiebebefehle]]\\
-.3.9.    Sprungbefehle
+.3.9.[[#sprungbefehle|Sprungbefehle]]\\
-.3.10.   Kelleroperationen
+.3.10.[[#kelleroperationen|Kelleroperationen]]\\
-.3.11.   Unterprogrammoperationen
+.3.11.[[#unterprogrammoperationen|Unterprogrammoperationen]]\\
-.3.12.   Ein- und Ausgabebefehle
+.3.12.[[#ein-_und_ausgabebefehle|Ein- und Ausgabebefehle]]\\
-.3.13.   Gruppenoperationen fuer Lade-, Vergleichs- und Ein-/ Ausgabe-Befehle
+.3.13.[[#gruppenoperationen_fuer_lade-_vergleichs-_und_ein-_ausgabe-befehle|Gruppenoperationen fuer Lade-, Vergleichs- und Ein-/ Ausgabe-Befehle]]\\
-.3.14.   Austauschbefehle
+.3.14.[[#austauschbefehle|Austauschbefehle]]\\
-.3.15.   CPU-Steuerbefehle
+.3.15.[[#cpu-steuerbefehle|CPU-Steuerbefehle]]\\
-.3.16.   Bedeutung der Flags
+.3.16.[[#bedeutung_der_flags|Bedeutung der Flags]]\\
-.4.      Unterbrechungsorganisation
+.4.[[#unterbrechungsorganisation|Unterbrechungsorganisation]]
 Bestandteile des Handbuches:
@@ Zeile 1151: / Zeile 1151: @@
 folgende Bedeutung:
-| Xl: | Systembus (Steckverbinder: StL 304-58 TGL 29331/03)\\ //Enthaelt alle Signale des Systembusses und ist elektrisch kompatibel zum K1520-Systembus. (Anlage 6)// |
+| X1: | Systembus (Steckverbinder: StL 304-58 TGL 29331/03)\\ //Enthaelt alle Signale des Systembusses und ist elektrisch kompatibel zum K1520-Systembus. (Anlage 6)// |
 | X2: | Pruefkamm und Tastaturanschlusspunkte\\ //(hier wird entsprechend den Hinweisen von Pkt.1.2.4.1. und 1.4. der Bedienungsanleitung das Tastaturbandkabel oder die Buchsenleiste BuL 202-26 TGL 29331/04 angeloetet)// |
 | X3: | Wechselspannungszufuehrung (Flachsteckverbinder) |
@@ Zeile 1159: / Zeile 1159: @@
 Die genaue Zuordnung der einzelnen Signale zu den jeweiligen Anschluessen ist der Anlage 6 zu entnehmen.
+===== 4. Der Befehlssatz des Mikroprozessors U880 =====
+Dieser Abschnitt soll das Verstaendnis der Arbeitsweise und der
+Programmierung des Mikrorechnerbausatzes Z1013 erleichtern. Anhand von Beispielen erfolgt eine Erlaeuterung der verschiedenen
+Mikroprozessor-Befehle und deren Wirkungsweise und Anwendungsmoeglichkeiten. Der folgende Ueberblick soll prinzipielle Eigenschaften und Besonderheiten des Mikroprozessors U 880 aufzeigen:
+  * 64 K Byte Adressraum fuer Speicher
+  * 256 Ein-/Ausgabekanaele
+  * 3 Doppelregister mit Alternativregistersatz
+  * 2 Indexregister mit je 16 Bit Breite
+  * 1 Refreshregister (ermoeglicht das automatische Auffrischen
+  * externer dynamischer RAM-Speicher)
+  * 1 maskierbarer, 1 nichtmaskierbarer Interrupt
+  * Architektur des Mikroprozessors U 880:<code>
+Bit  76543210 76543210        76543210 76543210
+    -------------------      -------------------
+AF  |   A    |    F   |  AF' |   A'   |   F'   |
+    -------------------      -------------------
+BC  |   B    |    C   |  BC' |   B'   |   C'   |
+    -------------------      -------------------
+DE  |   D    |    E   |  DE' |   D'   |   B'   |
+    -------------------      -------------------
+HL  |   H    |    L   |  HL' |   H'   |   L'   |
+    -------------------      -------------------
+Hauptregistersatz        Alternativregistersatz
+  ...  8  7  ...  0
+-----------------------
+| Stackpointer     SP |
+-----------------------
+| Befehlszaehler   PC |
+-----------------------
+| Indexregister    IX |
+-----------------------
+| Indexregister    IY |
+-----------------------
+|      I  |0|       R |
+-----------------------
+Speicheradressen:    Flagregister F:
+        ________             ---------------------------
+H |________|            | S Z  X  H  X  P/V  N  C |
+H |________| maximal    ---------------------------
+.      | .      | 64 K Byte
+.      | .      | = 65 536   S Signum (Vorzeichen)
+.      | .      | Speicher-  Z Zero
+.      |_.______| plätze     H Half-Carry
+FFFEH |________|            P/V Parity/Overflow
+FFFFH |________|                (Paritaet,Ueberlauf)
+                             C Carry
+                             X nicht verwendet
+
+   Kanaladressen:
+...255  256 Eingaenge
+            oder
+.. .255 256 Ausgaenge
+  Befehlsvorrat:
+Grundbefehle</code>
+==== 4.1. Befehlsschluessel ====
+Der Mikroprozessor erhaelt seine Befehle vom Speicher ueber
+den 8 Bit-Datenbus binaer verschluesselt zugefuehrt. Fuer
+den Programmierer ist diese Darstellung im Binaercode
+meistens zu detailliert und erschwert die Programmierung; es
+werden deshalb Hexadezimalkodes mit entsprechend zugehoeriger
+Mnemonik des Maschinenbefehls verwendet. Als Mnemonik
+bezeichnet man Pseudonamen der Befehle. Diese Pseudonamen
+bzw. Abkuerzungen geben gleichzeitig Auskunft ueber die
+Funktion der Befehle und erleichtern damit die Programmierung.
+Die Uebersetzung in den Maschinenkode erfolgt dann anhand der
+Tabelle der Befehlsliste oder durch ein Programm, genannt
+Assembler.
+<note tip>
+Bemerkung: Bei hexadezimaler Verschluesselung muss der
+fuehrenden Ziffer, falls diese ein Buchstabenzeichen ist,
+eine Null vorangestellt werden. Dadurch wird eine
+Verwechselung mit Bezeichnern vermieden.
+Bei der Programmierung des U 880 werden die Maschinenbefehle
+im allgemeinen hexadezimal verschluesselt, wobei das 'H' und
+die fuehrende '0' vor Buchstabenzeichen innerhalb des Maschinenkodes weggelassen werden.</note>
+<code>z.B.   00 = NOP
+= LD C,H
+       FF = RST 38H</code>
+Wie bereits erwaehnt, koennen Maschinenbefehle aus einem oder
+mehreren Bytes bestehen. Man spricht dann von 1-Byte-,
+-Byte-Befehlen und so weiter. Jedem Byte ist in
+Abhaengigkeit seines Platzes im Befehl und seiner Kodierung
+eine bestimmte Bedeutung zugeordnet worden.
+=== 4.1.1. 1-Byte-Befehle ===
+Diese Befehle bestehen nur aus dem Operationskode (im
+weiteren als OPC bezeichnet). Da es sich fast ausschliesslich
+um Registeroperationen, also Operationen innerhalb der
+Prozessorregister handelt, ist in diesem Byte auch die
+notwendige Registeradresse enthalten. Bei der Behandlung der
+Adressierung wird noch einmal naeher darauf eingegangen.
+<code> 1.  Byte
+     OPC</code>
+Beispiel:
+<code>Befehls- Maschinen- Quellkode   Kommentar
+zaehler  kode
+---------------------------------------------
+     47         LD B,A      ;Lade B mit A
+     23         INC HL      ;HL:=HL+1
+     40         LD B,B
+     81         ADD C</code>
+Die Form des Beispiels soll als Normativ eines Programmprotokolls dienen. Es empfiehlt sich, diese uebersichtliche
+Darstellung bei der Erstellung von Programmen zu nutzen, da
+sich in dieser tabellenartigen Zusammenstellung alle Angaben
+widerspiegeln, die zu einem Programm gehoeren. Die letzte
+Spalte bietet die Moeglichkeit, einen Kommentar unterzubringen, um noch nach laengerer Zeit den Inhalt eines Programms
+nachvollziehen  zu koennen. Kommentarzeilen werden mit einem
+Semikolon gekennzeichnet. Der Inhalt sollte kurz, aber
+eindeutig sein.
+Wird nur ein Byte als Operationskode verwendet, wuerden sich
+Moeglichkeiten ergeben. Man nutzt davon aber nur 252.
+Die verbleibenden vier Kombinationen sind fuer folgende
+Aufgaben reserviert worden:
+Beim U 880 werden zwecks Erweiterung und Ausbau des
+Befehlsumfangs vier Hexadezimalkodes (0CBH, 0DDH, 0EDH, 0FDH)
+der Befehlsliste als sogenannte "Signalbytes" festgelegt.
+Diese Signalbytes stehen grundsaetzlich an erster Stelle des
+Befehls (1.Byte). Sie kennzeichnen aber keinen konkreten
+Befehl, sondern kuendigen eine spezielle Gruppe von Befehlen
+an. Die Konkretisierung des Befehle erfolgt durch zusaetzlich
+ein oder mehrere Bytes. Auf diese Art ist es moeglich, durch
+ein Signalbyte weitere 256 Befehle zu kennzeichnen und somit
+den Befehlsumfang stark zu erweitern. Der U 880 bietet
+folgende Erweiterungen des Befehlsschluessels mit den
+Signalbytes:
+<code>  Signalbyte   CB:    Bitmanipulationen, Verschiebebefehle
+  Signalbyte   DD:    Umschaltung von HL nach IX
+  Signalbyte   ED:    Blocktransport- und Suchbefehle
+  Signalbyte   FD:    Umschaltung von HL nach IY</code>
+=== 4.1.2. 2-Byte-Befehle ===
+Diese Befehle koennen jetzt einen zweiten OPC, einen Direktwert oder eine Sprungweite (s. auch Sprungbefehle) im 2. Byte
+des Befehle enthalten.
+<code>1. Byte 2. Byte
+  OPC     OPC
+  OPC     n      n=Direktwert
+  OPC     c      c=Sprungweite</code>
+Ist das 2. Byte ein OPC, so stellt das 1. Byte das Signalbytedar.
+Beispiele:
+<code>Befehls- Maschinen- Quellkode   Kommentar
+---------------------------------------------
+     DD 23      INC IX      ;IX:=IX+1
+     FD 23      INC IY      ;IY:=IY+1
+     CB 40      BIT 0,B
+     3E 10      LD A,10H    ;Lade A mit 16
+     36 FF      LD(HL),0FFH ;Lade den von HL adres-
+                         ;sierten Speicherplatz mit 255
+A     28 04      JRZ 06       ;Springe, wenn Z=1 ist,
+                    ;um 6 Byte nach vorn, PC: PC + 6 - 2</code>
+Bei der Berechnung der Sprungweite wird die aktuelle Position
+des Befehlszaehlers (PC), der ja bereits auf den naechsten
+Befehl zeigt, durch Subtraktion einer 2 beruecksichtigt. Im
+Quellkode beziehen sich die Sprungweiten immer auf den
+Befehlsanfang, also den PC-Stand, der zum betreffenden
+Befehl gehoert. Es empfiehlt sich, bei der Programmerstellung
+im Quellkode symbolische Sprungmarken zu verwenden, denen
+bei der Uebersetzung in Maschinenkode ein konkreter Wert
+zugewiesen wird. Wie das gemacht wird, zeigen spaetere
+Beispiele.
+=== 4.1.3. 3-Byte-Befehle ===
+Diese Befehle enthalten einen Operationskode und einen 16-Bit-
+Direktwert (nn). Dieser Direktwert stellt einen normalen Datenwert oder eine Adresse dar, wie er z.B. in Lade- oder
+Sprungbefehlen benoetigt wird. Ebenfalls ist eine Kombination
+von Signalbyte und OPC sowie von Signalbyte und 8-Bit-Direktwert (n) fuer einige Befehle moeglich.
+<code>1. Byte 2. Byte 3. Byte
+OPC     N(nn)   H(nn)     (bei Ladebefehlen)
+OPC     N(nn)   H(nn)     (Sprungadresse)
+OPC     OPC       n       (wobei der 1. OPC ein Sig-
+                           nalbyte  DD oder FD
+                           sein kann)</code>
+Die Angabe "N(nn)" bezeichnet den niederwertigen Teil, d.h.
+die letzten 8 Bit des 16-Bit-Direktwertes, "H(nn)" demgemaess
+den hoeherwertigen Teil, d.h. die ersten 8 Bit.
+<code>Wert:  |   H  |  N  |
+...8 7...1</code>
+Beispiele:
+<code>Befehls- Maschinen- Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     21 00 F7   LD HL,0F700H ;Lade HL mit 0F7OCH
+     C3 2D F0   JMP 0F02DH   ;Springe zur Adresse
+                                 ;0F02DH
+     CD B7 E1   CALL OF1B7H  ;Sprung ins Unterprogr.
+     DD 46 3F   LD B,(IX+3FH)
+C     FD 72 00   LD (IY+0),D</code>
+=== 4.1.4. 4-Byte-Befehle ===
+In den 4-Byte-Befehlen sind im wesentlichen Kombinationen
+bereits bekannter Befehle mit einem oder zwei Signalbyte
+enthalten. Eine Uebersicht ueber diese Befehle ist der Anlage
+zu entnehmen. Zwei Beispiele sollen hier genuegen.
+Beispiele:
+<code>Befehls- Maschinen-   Quellkode  Kommentar
+zaehler  kode
+------------------------------------------
+     DD 21 00 00  LD IX,0    ;Lade IX mit 0
+     DD CB 0F 1E  RR (IX+0FH)</code>
+Die im Anhang enthaltene Befehlsliste fuer den Mikroprozessor
+U 880 enthaelt uebersichtlich alle Befehlsschluessel hexadezimal kodiert mit Hinweisen fuer die Verwendung des Signalbytes
+bzw. der Verschiebung 'd' (siehe auch 'Indexierte Adressierung'). Diese Befehlsliste dient bei der manuellen Programmie-
+rung im Maschinenkode als rationelles Hilfsmittel.
+==== 4.2. Adressierung ====
+=== 4.2.1. Registeradressierung ===
+Die Angabe von Registeroperanden (also von Registern des
+Notizblockspeichers im U 880) erfolgt implizit im Operations-
+Byte durch sogenannte Kurzadressen. Fuer die Adressierung von
+maximal acht allgemeinen Registern sind im OPC-Byte zweimal
+-Bit-Stellen (sowohl fuer das Quellregister als auch fuer
+das Zielregister) notwendig. Bei der Angabe der Kurzadressen
+fuer U880-Register gilt also:
+<code>Register     A   B   C   D   E   H   L   (HL)
+Kurz-
+adresse      7   0   1   2   3   4   5   6
+(binaer)    111 000 001 010 011 100 101 110</code>
+<code>Doppelregister     BC     DE    HL    AF oder SP
+(binaer)           00     01    10    11</code>
+Die Angabe von Operanden, die sich im Hauptspeicher befinden,
+kann auf verschiedene Weise erfolgen. Der Zugriff auf eine
+bestimmte Speicherstelle (beim U 880 ist eine 16-Bit-Adresse
+erforderlich) erfolgt durch Bereit stellen der entsprechenden
+Adresse zu dem Zeitpunkt, wo der Maschinenbefehl diese benoetigt.
+=== 4.2.2. Direktwertadressierung ===
+Der Zugriff zum Speicher erfolgt mittels der im Befehl komplett angegebenen Speicheradressen. Diese steht im mnemonischen Befehl immer in Klammern.
+z. B.: Der unbekannte 8-Bit-Wert K soll mittels direkter Adressierung vom Speicherplatz mit der Adresse 3000H in das A-Register geholt werden. Danach soll diese Konstante auf den Speicherplatz mit der Adresse 3010H gebracht werden.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     3A 00 30     LD A,(3000H) ;A:=(3000)
+     32 10 30     LD (3010H),A ;(3010H):=A=K</code>
+=== 4.2.3. Registerindirektadressierung ===
+Bei der indirekten Adressierung erfolgt der Speicherzugriff
+durch Angabe eines Doppelregisters im Maschinenbefehl, wobei
+im Doppelregister die Adresse fuer den Speicherzugriff geladen
+sein muss (Registerpaare HL, BC, DE sind moeglich).
+z. B.: Der unbekannte 8-Bit-Wert K soll wie im oben genannten Beispiel mittels indirekter Adressierung von Speicherplatz 3000H in den Speicherplatz 3010H umgespeichert werden. Zunaechst laedt man die Adresse des Speicherplatzes, von der der Wert K geholt werden soll, in das Registerpaar BC und die Zieladresse in das Registerpaar HL.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     01 00 30    LD BC,3000H ;Quelladresse
+     21 10 30    LD HL,3010H ;Zieladresse
+     OA          LD A,(BC)   ;A:=(3000H)
+     77          LD (HL),A   ;(3010H):=A=K</code>
+Anmerkung: Zur indirekten Adressierung wird gern das Doppel-
+register HL zur Adressenbereitstellung eingesetzt; man
+schreibt auch:
+<code>      (HL)= M (englisch: Memory = Gedaechtnis, Speicher)</code>
+Dann wuerde die letzte Zeile des obigen Beispiels lauten:
+<code>1007     77          LD M,A      ;= LD (HL),A</code>
+=== 4.2.4. Indexierte Adressierung ===
+Soll der Speicherzugriff mittels indexierter Adressierung
+erfolgen, so wird im Maschinenbefehl ein sogenanntes Indexregister (IX, IY) und eine Verschiebung 'd' als vorzeichenbehaftete Konstante angegeben. Die Adressenbildung
+fuer den Speicherzugriff erfolgt durch Summierung der im
+jeweiligen Indexregister enthaltenen Grundadresse und der
+Verschiebung 'd'. Die Verschiebung 'd' kann Werte von
+-128 bis +127 annehmen. Bei Verwendung einer negativen
+Verschiebung wird diese von der Grundadresse subtrahiert.
+z. B.: Der 8-Bit-Wert K soll wie im oben genannten Beispiel mittels indexierter Adressierung umgeladen werden. Ins Indexregister IX wird die Adresse 3000H geladen.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     DD 21 00 30  LD IX,3000H
+     DD 7E 00     LD A,(IX+0)   ;A:=(3000H),d=0
+     DD 77 10     LD (IX+16),A  ;(3010H):=A,
+                      ;da IX=3000H und d=10h=16</code>
+Die indexierte Adressierung wird verwendet, um einen einfachen Zugriff zu in Tabellenform gespeicherten Daten zu er-
+halten. Dazu wird der Anfangspunkt der Tabelle in das Indexregister geladen, die Verschiebung 'd' entspricht dann der
+konkreten Tabellenposition.
+==== 4.3. Maschinenbefehle und ihre Bedeutungen ====
+Im folgenden Abschnitt werden die entsprechenden Befehlsgruppen naeher erlaeutert und an Beispielen die Funktionsweise
+untermauert.
+=== 4.3.1. Ladebefehle ===
+Bei den Ladebefehlen werden prinzipiell die Byte- und Doppelbyte-Ladebefehle unterschieden. Die Datenbewegung erfolgt
+stets nur zwischen Speicher und Prozessor bzw. innerhalb des
+Prozessors zwischen den Registern. Die Flage werden nicht beeinflusst (Ausnahmen bilden nur die Befehle LD A,I und LD
+A,R).
+Allgemeiner Aufbau der Ladebefehle:
+<code>[MARKE:] LD Ziel  ,  Quelle  [;KOMMENTAR]</code>
+Die eingeklammerten Angaben sind wahlfrei, sie koennen vorhanden sein, muessen aber nicht.
+Beispiele fuer Byte-Ladebefehle: (d.h. die transportierten Daten umfassen ein Byte)
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     3E 3A        LD A,3AH    ;A: =3AH
+     57           LD D,A      ;D: =3AH
+     46           LD B,(HL)
+     1A           LD A,(DE)
+     02           LD (BC),A
+     DD 70 00     LD (IX+0),B ;B wird auf
+         ;IX+d adressierten Speicherplatz gela-
+         ;den
+     DD 4E 7F     LD C,(IX+127)
+C     ED 57        LD A,I      ;das Interruptre-
+         ;gister I wird in A geladen, Stand
+         ;von IFF 2 in das Flag P/V
+E     ED 5F        LD A,R        ;das Refreshre-
+         ;gister wird in das A-Register geladen</code>
+Beispiele fuer Doppelbyte-Ladebefehle  (d. h. die transportierten Daten umfassen 2 Byte):
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     01 34 12     LD BC,1234H  ;B:=12H, C:=34H
+     2A 34 12     LD HL,(1234H)
+     ED 43 34 12  LD (1234H),BC
+A     DD F9        LD SP,IX</code>
+Es ist verstaendlich, dass Doppelbyte-Ladebefehle auf Grund
+des 8-Bit-Batenbusses nur byteweise abgearbeitet werden, wobei
+zunaechst das niederwertige und danach das hoeherwertige Byte
+geladen wird.
+Einen Sonderfall der Boppelbyte-Ladebefehle bilden die sogenannten Kelleroperationen, diese werden aber spaeter beschrieben.
+=== 4.3.2 Byte- und Doppelbyte-Zaehl-Befehle ===
+Diese Befehlsgruppe dient dem Erniedrigen bzw. Erhoehen von
+Registerinhalten oder Speicherinhalten um jeweils den Wert 1.
+Beispiele fuer Zaehlbefehle:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     3C           INC A        ;A:=A+1
+     34           INC (HL)     ;(HL):=(HL)+1
+     03           INC BC       ;BC:=BC+1
+     DD 23        INC IX
+     0D           DEC C        ;C:=C-1
+     DD 35 00     DEC (IX+0)   ;(Ix+0):=(1X+0)-1
+     DD 2B        DEC IX       ;IX:=IX-1</code>
+Die Byte-Zaehlbefehle beeinflussen das Z-Flag. Ist das Resultat des Befehls im behandelten Byte identisch 0, so wird das Z-Flag auf "1" gesetzt, sonst bleibt es "0". Die Doppelbytezaehlbefehle boeinflussen keine Flags.
+Beispiel: Laden von 3 Speicherstellen mit 00,01,02 ab Adresse 3000H
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     3E 03        LB A,3       ;Anzahl Speicherpl.
+     21 00 30     LD HL,3000H  ;1. Adresse laden
+     75       Ml: LD (HL),L    ;Speicherpl. laden
+     23           INC HL       ;Adresse und Wert
+                                   ;um 1 erhoehen
+     BD           CMP L        ;Vergleich L mit A
+     20 FB        JRNZ M1-#    ;Ruecksprung zu Ml,
+                                   ;wenn L noch nicht 3</code>
+=== 4.3.3. Arithmetische Befehle ===
+Beim U 880 ist nur die Addition und die Subtraktion von Bytes
+und Doppelbytes (16-Bit-Worte) moeglich.
+Beispiele fuer arithmetische Befehle:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     80           ADD B        ;A:=A+B
+     66 3E        ADD 3EH      ;A:=A+3EH
+     86           ADD (HL)     ;A:=A+(HL)
+     88           ADC B        ;A:=A+B+CY
+     CE 0F        ADC OFH      ;A:=A+0FH+CY
+     92           SUB B        ;A:=A-D
+     DD 9E 04     SBC (IX+4)   ;A:=A-(IX+4)-CY</code>
+Die arithmetischen Operationen laufen prinzipiell in folgender Form ab:
+<code>A := A + Operand s</code>
+Hierbei ist die Konstruktion ":=" als "ergibt sich aus" zu interpretieren: A ergibt sich aus A plus Operand s. Diese Befehlsgruppe beeinflusst das Flagregister vollstaendig. Die
+Wirkungsweise der Flag-Bits laesst sich guenstig bei Zahlenbereichsueberschreitungen nach Ausfuehrung der Operationen zeigen:
+<code>Beispiel:
+            A:= -128
+            ADD B     ;(B=127,-128,-127)
+            B = 127   B = -128    B = -129
+A alt   = 1000 0000   1000 0000   1000 0000
++s      = 0111 1111   1000 0000   1000 0001
+-------------------------------------------
+A alt+s = 1111 1111  10000 0000  10000 0001
+CY-F lag
+neu     = 0          1           1
+Z neu   = 0          1           0
+--------------------------------------------
+A neu   =  1111 1111  0000 0000   0000 0001</code>
+Beim Ueberlauf wird das CY-Flag=1, d. h. das Ergebnis der Addition ist falsch.
+Fuer die Doppelbytearithmetik gilt mit gewissen Besonderheiten das oben genannte.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     09           ADD HL,BC    ;HL:=HL+BC
+     ED 7A        ADC HL,SP    ;HL:=HL+SP+CY
+     19           SBC HL,DE
+     DD 09        ADD IX,BC</code>
+Falls bei der ADD-Operation ein Ueberlauf entsteht, wird das
+Carry-Flag gesetzt (auf "1"). Bei ADC und SBC wird das Flagregister vollstaendig neu bestimmt. Anwendungsgebiet dieser Befehlsgruppe ist insbesondere die sogenannte Adressarithmetik, d. h. wenn mit Adressen gerechnet wird.
+=== 4.3.4. Vergleichsbefehle ===
+Einen Sonderfall der Arithmetik-Befehle bilden die Vergleichsbefehle. Es wird eine Subtraktion des A-Registerinhaltes mit
+dem jeweiligen Operanden ausgefuehrt, allerdings werden im
+Ergebnis der Operation nur die Flags geaendert, der A-Register
+inhalt bleibt unveraendert.
+Beispiele fuer Vergleichsbefehle:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     B8           CMP B        ;A-B=?
+     FE 38        CMP 38H      ;A-38H=?
+     FD BE 05     CMP (IX+5)   ;A-(IX+5)=?</code>
+Die Flagbeeinflussung funktioniert nach folgender Tabelle:
+<code>                          Z   CY
+ist A>s, dann ist A-s>0 : 0   0
+ist A=s, dann ist A-s=0 : 1   0
+ist A<s, dann ist A-s<O : 0   1</code>
+(s ist der entsprechende Operand)
+In der Praxis schliessen sich i.a. an Vergleichsbefehle
+entsprechende Verzweigungsoperationen oder bedingte Unterprogrammaufrufe in Abhaengigkeit vom Z- oder/und vom CY-
+Flag an (siehe unter 'Bedingte Sprungbefehle').
+=== 4.3.5. Logische Befehle ===
+Die logischen Befehle des U 880 umfassen das UND, das ODER und
+das EXKLUSIV-ODER. Die Wirkungsweise wurde im Punkt 2.4 ausfuehrlich erlaeutert. Die logische Verknuepfung erfolgt stets
+mit dem A-Register und kann mit B, C, D, E, H, L, (HL), A, n,
+(IX+d) und (IY+d) erfolgen. Das Ergebnis der logischen Operation steht nach deren Ausfuehrung immer im A-Register.
+Nachfolgend einige Beispiele:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+------------------------------------------
+     A0           AND B        ;A:=A UND B
+     AE           XOR (HL)     ;A:=A XOR (HL)
+     F6 55        OR 55H       ;A:=A OR 55H
+Spezialfall:
+     AF           XOR A        ;CY:=O, Z:=O,
+                      ;P:=1, A:=00H!!!
+</code>
+Das Flag-Register wird bei diesen Operationen neu bestimt:
+  * Carry-Flag ist stets 0
+  * Zero-Flag entsprechend dem A-Registerinhalt
+  * Sign-Flag entsprechend dem Bit 7 des A-Registers
+  * Paritaets-Flag entsprechend der Anzahl der 1-Bits des Ergebnisses (P=1, wenn die Anzahl der 1-Bits geradzahlig ist)
+=== 4.3.6. Spezielle arithmetische Hilfsoperationen ===
+<code>DAA  ; Dezimalkorrektur bei BCD-Verarbeitung
+CPL  ; Komplementieren des A-Registers (Einerkomplement)
+       A:=/A entspricht einer bitweisen Negation
+NEG  ; Negieren des A-Registers (Zweierkomplement>
+       A:=-A entspricht A:=/A+1
+CCF  ; Komplementieren des Carry-Flags, CY:=/CY
+SCF  ; Setzen des Carry-Flags, CY:=1</code>
+Fuer eine effektive Verarbeitung von Dezimalzahlen koennen
+diese direkt durch Addition und Subtraktion verarbeitet
+werden. Dabei koennen, wie dem nachfolgenden Beispiel zu
+entnehmen ist, unkorrekte Ergebnisse auftreten (Pseudoergebnisse). Deshalb wurde der DAA-Befehl zur Erkennung
+von Pseudoergebnissen und zur anschliessenden Korrektur
+nach arithmetischen Operationen bereitgestellt. Der DAA-
+Befehl kann naoh folgenden Befehlen verwendet werden:
+<code>ADD, ADC, INC, SUB, SBC, DEC, NEG</code>
+Fuer die Funktion des DAA-Befehls uebernimmt das Carry-Flag
+CY fuer das hoeherwertige Halbbyte des A-Registers {H(A)}
+und das Half-Carry-Flag H fuer das niederwertige Halbbyte
+des A-Registers {N(A)} die Ueberwachungsfunktion, d. h.
+ein Uebertrag aus dem niederwertigen Halbbyte steht im
+H-Flag, der aus dem hoeherwertigen im CY-Flag.
+Ein Beispiel soll die Wirkungsweise des DAA-Befehls verdeutlichen: In jedem Halbbyte steht eine Dezimalzahl im
+zugelassenen Wertebereich von 0.. .9.
+Die Korrektur nach Additionen erfolgt in der Form:
+<code>   N(A) > 9 oder H =  1 ===> A:=A+06H
+   H(A) > 9 oder CY=  1 ===> A:=A+60H</code>
+Bei Subtraktionen erfolgt die Korrektur in folgender Form:(N-Flag = 1)
+<code>    N(A) > 9 oder H = 1 ===> A:=A-06H
+    H(A) > 9 oder CY= 1 ===> A:=A-60H</code>
+Zahlenbeispiel: Addition zweier zweistelliger Dezimalzahlen
+<code>
+>>>  A:=99, B:=39, A:=A+B ?
+     A:   1001 1001 = 99        99
+     B:   0011 1001 = 39       +39
+----------------------------------
+A:=A+B:   1101 0010 = D2 falsch !!
+          CY=0 H=1!
+DAA: +06H 0000 0110 = 38
+     +60H 0110 0000 = 60
+----------------------------------
+     A:   0011 1000 = 38
+          CY=1  H=0          = 138
+</code>
+Ergebnis: Es entsteht eine dreistellige BCD-Zahl, die sich zu zwei Stellen aus dem A-Registerinhalt und als dritte Stelle aus dem Carry-Bit (CY=1) ergibt: ( CY, H(A), N(A) ) = (138)
+Auf die anderen Hilfsoperationen soll hier nicht weiter eingegangen werden. Ihre Bezeichnung erlaeutert die Funktion genuegend.
+=== 4.3.7. Befehle zur Bit-Manipulation ===
+Diese Befehlsgruppe erlaubt den Einzelbit-Test, das definierte Setzen bzw. Ruecksetzen ausgewaehlter Bits von Registern
+des Prozessors oder der durch den Inhalt der Register HL, IX
+und IY adressierten Speicherplaetze.
+Der Aufbau und die Funktion eines Bit-Test-Befehls laesst
+sich wie folgt allgemein beschreiben:
+<code>BIT i,s;  Bit-Test-Operation, Testergebnis ist ueber
+          Z-Flag auswertbar; Z:=1, wenn das Bit i des
+                                   Registers 's' = 0 ist,
+                             Z:=0, wenn das Bit i = 1 ist
+<= i <= 7
+Operanden 's' = A, B, C, D, E H, L, (HL), (IX+d), (IY+d)</code>
+Befehle zum Ruecksetzen einzelner Bits haben den Aufbau 'RES
+i,s' und Befehle zum Setzen 'SET i,s' . Sie beeinflussen keine
+Flags. Mit dem Befehl 'RES 7,A' wird das Bit 7 des A-Regiter auf den Wert 0 gesetzt, mit 'SET 4,B' das Bit 4 auf den
+Wert 1.
+=== 4.3.8 Verschiebebefehle ===
+Mit den Verschiebebefehlen erfolgt im entsprechenden Register entweder eine Rechts- oder eine Linksverschiebung um
+eine Dualstelle, d. h. um ein Bit. Die Besonderheiten der
+verschiedenen Verschiebebefehle gehen aus den Darstellungen der einzelnen Befehle hervor.
+Fuer alle Operanden 's' gilt:
+<code>s = A, B, C, D, E, H, L, (HL), (IX+d), (IY+d)</code>
+Linksverschieben um eine Dualstelle
+<code>RLC s ; Linksverschieben mit Setzen des Carry-Flag's
+             |---------------------|
+       __    |      _________      |
+      |CY| <-+-----|7       0|<----|
+       --           ---------
+RL s       ; Linksverschieben ueber das Carry-Flag
+|----------------------------------|
+|      __           _________      |
+|<----|CY| <-------|7       0|<----|
+       --           ---------
+SLA s       ; Linksverschieben durch Carry-Flag
+       __           _________
+      |CY| <-------|7       0|<----0
+       --           ---------
+RLCA        ; wie RLC A, aber ausser dem Carry-Flag wird das
+              Flagregister nicht beeinflusst.
+RLA;        ; wie RL A, aber ausser dem Carry-Flag wird das
+              Flagregister nicht beeinflusst.
+Rechtsverschiebung um eine flualstelle
+RRC s       ; Rechtsverschiebung mit Setzen des Carry-Flags
+      |----------------------|
+      |       _________      |      __
+      |----->|7       0|-----+-----|CY|
+              ---------             --
+RR s        ; Rechtsverschiebung ueber das Carry-Flag
+      |------------------------------------|
+      |       _________             __     |
+      |----->|7       0|---------->|CY|--->|
+              ---------             --
+SRA s      ; Rechtsverschieben mit Setzen des Carry-Flags
+             (arithmetische Rechtsverschiebung)
+              _________             __
+       ----->|7       0|---------->|CY|
+      |       |--------             --
+       -------
+SRL s       ; Rechtsverschieben mit Setzen des Carry-Flags
+              (logische Rechtsverschiebung)
+              _________             __
+----->|7       0|---------->|CY|
+              ---------             --
+RRCA        ; wie RRC A, ausser Carry wird aber das Flag-
+              register nicht beeinflusst.
+RRA         ; wie RR A, ausser Carry wird aber das Flag-
+              register nicht beeinflusst.</code>
+Beispiel: Ein beliebiger Inhalt des A-Registers soll nach rechts verschoben werden, bis Bit 0 des A-Registers = 1 ist. Wenn das A-Register geloescht war, sollen keine Verschiebungen stattfinden.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     B0           OR A         ;Z = 1, wenn A = 0
+                                   ;ist
+     28 0D        JRZ END-#    ;Abbruch des
+                      ;Programms, wenn A = 0
+     CB 3F    Ml: SRL A        ;Rechtsverschiebung
+                                   ;durch CY
+     30 FC        JRNC M1-#    ;Ruecksprung zu Ml
+                      ;wenn CY=0 ist, also das herausge-
+                      ;schobene Bit eine 0 enthielt
+     CB 17        RL A         ;wenn Bit 1,
+                      ;muss es aus CY wieder in das A-Regi-
+                      ;ster zurueck
+...
+     76      END: HALT</code>
+Mit einer Verschiebung laesst sich z. B. ein Steuerbit aus dem
+Bit 0 oder Bit 7 ins CY-Flag schieben und abtesten, ohne die
+anderen Bits zu zerstoeren.
+Weitere Anwendungsmoeglichkeiten ergeben sich fuer die Arithmetik. Beispielsweise laesst sich der SRA-Befehl als Division
+durch 2 oder der SLA-Befehl als Multiplikation mit 2 einsetzen.
+Ein Sonderfall der Verschiebungsoperationen ist die Verschiebung um vier Dualstellen.
+Linksverschiebung um vier Dualstellen
+<code>RLD   ;    Der Befehl wirkt zwischen A-Register und dem durch
+           HL indirekt adressierten Speicheroperanden.
+            __________________
+           |                  |
+   ________|__        ________v__
+A:|7   4|3   0| (HL):|7   4|3   0|
+   --------^--        --|-^---|--
+           |            | |   |
+            ------------   ---</code>
+Zahlenbeispiel:
+<code>   A: 3F                A: 33
+         ==> RLD ==>
+(HL): 3C             (HL): CF</code>
+Rechtsverschiebung um vier Dualstellen
+<code>RRD     ; der Befehl wirkt ebenfalls nur zwischen A und (HL)
+            ____________   ___
+           |            | |   |
+   ________|__        __v_|___v__
+A:|7   4|3   0| (HL):|7   4|3   0|
+   --------^--        --------|--
+           |                  |
+            ------------------</code>
+=== 4.3.9 Sprungbefehle ===
+Grundsaetzlich werden bedingte und unbedingte Spruenge unterschieden.
+  * **Unbedingte Spruenge:**\\ Bei Erkennen des Sprungbefehls wird vom Prozessor der Befehlszaehler entweder mit der im Adressteil des Befehl angegebenen Sprungadresse geladen (absolute Sprungadresse) oder der Befehlszaehler wird um eine Konstante e veraendert (realtive Sprungweite). Die Konstante e wird im Befehl mit angegeben und liegt im Wertebereich von -128 <= 127. Die Angabe der absoluten Sprungadresse kann indirekt oder indiziert erfolgen. Relative Sprungbefehle bzw. indirekt adressierte Spruenge benoetigen weniger Speicherraum, sind aber bei manueller Programmierung ohne Assembler schwer zu beherrschen.\\ Allgemein:<code>JMP sadr  ; Befehlszaehler PC nimmt den Wert 'sadr' an.
+JR e      ; Befehlszaehler PC wird um den Wert e veraendert.
+            PC:=PC+e (Vorwaerts- und Rueckwaertsspruenge
+            sind moeglich)
+JMP (xx)  ; Befehlszaehler PC nimmt den Wert an, der im
+            Registerpaar xx enthalten ist.
+Registerpaare 'xx' = HL, IX, IY</code> DieBerechnung der Sprungweite ist mit entsprechender Sorgfalt durchzufuehren.\\ Die Sprungweite ist eine Differenz von Adressen: Zieladresse minus die Adresse des Befehls, der dem Sprungbefehl folgt. Dabei ist zu beachten, dass ein Relativsprungbefehl immer 2 Byte lang ist. Von der CPU wird prinzipiell nach dem Lesen des Befehls der PC auf den Beginn des physisch naechsten, abzuarbeitenden Befehls gestellt, es sei denn, bei der Abarbeitung des eben gelesenen Befehls stellt sich heraus, dass der PC geaendert werden muss (bedingter Sprung). Relativspruenge beziehen sich dann dabei auf die Adresse des nachfolgenden Befehls. Dieser Umstand ist bei der Sprungweitenberechnung unbedingt zu beachten.<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     21 00 10     LD HL,1000H  ;Zaehler laden
+     75       M1: LD M,L
+     2C           INC L
+     20 FC        JRNZ M1-#
+     24           INC H
+...                                ;Programmfort-
+...                                ;setzung</code>Sprungweitenberechnung fuer den Sprungbefehl auf PC = 1005H:<code>
+     Zieladresse:   1003H
+ Absprungadresse: - 1007H
+ ------------------------
+       Differenz:  0FFFCH</code>Es wird nur das niederwertige Byte der Differenz verwendet, also in diesem Falle 0FCH. Man erkennt ausserdem noch folgendes:\\ Der Betrag der Sprungweite ist groesser 7FH (Bit 7 = 1), das heisst, dass rueckwaerts gesprungen werden muss. Rueckwaerts in dem Sinne, dass der PC um den Absolutbetrag der Sprungweite 's' vermindert wird. Die Sprungweite 's' ist eine vorzeichenbehaftete Konstante.
+  * **Bedingte Spruenge:**\\ Bedingte Spruenge beziehen sich auf den Zustand der durch vorangegangene Operationen entsprechend veraenderten Flags. Auch hier gibt es die Moeglichkeit der absoluten und relativen Sprungmarkenangabe. Der Befehlszaehler wird wie bereits oben genannt veraendert.<code>
+JPcc adr   ; wenn die Bedigung 'cc'erfuellt ist, nimmt
+             der PC den Wert 'adr'an, PC:=adr
+  cc kann sein:  C wenn Carry    gesetzt   C=1 ==> JPC  adr
+                NC wenn No Carry   "       C=0 ==> JPNZ adr
+                 Z wenn Zero       "       Z=1 ==> JPZ  adr
+                NZ wenn No Zero    "       Z=0 ==> JPNZ adr
+                 P wenn Plus       "       S=0 ==> JPP  adr
+                 M wenn Minus      "       S=1 ==> JPM  adr
+                PO wenn No Parity  "       P=0 ==> JPPO adr
+                PE wenn Parity     "       P=1 ==> JPPE adr
+JRcc       ;  wenn die Bedingung 'cc' erfuellt ist, wird der
+              PC um den Wert 'e' veraendert (PC:=PC+e)
+              cc  = C , ==> JRC e
+                    NC, ==> JRNC e
+                    Z , ==> JRZ e
+                    NZ, ==> JRNZ e</code>Ein Sonderbefehl ist der Zyklusbefehl mit relativer Adressierung.
+<code>DJNZ e       ;Das B-Register wird dekrementiert (um 1 vermindert).
+              Solange dessen Inhalt groesser Null ist, erfolgt
+              der relative Sprung (PC:=PC+e), sonst wird der
+              diesem Befehl folgende aufgerufen.</code><code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     AF     TIME: XOR A        ;A:=00H
+     47           LD B,A       ;B:=00H
+     10 FE        DJNZ 2       ;B:=B-1,B=0 ?
+                 ;Ruecksprung zum Befehl DJNZ,
+                 ;also um 2 Byte zurueck
+     C9           RET          ;B:=0, Zeit-
+                 ;schleife abgelaufen</code>
+=== 4.3.10. Kelleroperationen ===
+Die Kelleroperationen sind eine spezielle Gruppe von Transportoperationen. Die Inhalte der Doppelregister werden in
+einen Speicherbereich gebracht oder von dort geholt, der
+durch ein spezielles Register (Stackpointer) indirekt adressiert wird. Beim U 880 ist der Kellerspeicherbereich im gesamten Adresebereich sowohl von der Lage als auch von der
+Groesse frei waehlbar. Allerdings kann nur ein RAM verwendet werden. Zu Beginn eines Programmes muss der Stackpointer
+(SP) festgelegt werden. Das geschieht mit dem Ladebefehl
+'LD SP,nn'. Dieser Zeiger ist also eine Adresse und damit
+maximal 16 Bit lang. Sie stellt die Anfangsadresse (den
+Kontrollboden) des gewuenschten Kellerspeicherbereiches dar.
+<code>   Kellern---+         +-------> Entkellern
+             |         |
+             V         |
+        +-------------------+
+nn-6 -> |    4.   :    1.   |
+nn-4 -> |    3.   :    2.   |
+nn-2 -> |    2.   :    3.   |
+nn   -> |    1.   :    4.   |
+        +-------------------+</code>
+Die Anwendung der Kelleroperationen liegt vor allem im Retten
+von Doppelregistern und anschliessendem "Zurueckholen" aus
+dem Keller zwecks Weiterverwendung in anderen Programmteilen.
+Das heisst, die geretteten Register koennen bei der Abarbeitung eines Programmteiles anders verwendet werden, denn ihre
+Inhalte wurden im Keller "sichergestellt".
+Auf Grund des 8-Bit-Datenbusses wird deutlich, dass eine
+Kelleroperation immer in zwei Schritten ablaeuft. Beim Kellern wird zuerst der Stackpointer dekrementiert, das hoeher
+wertige Byte gekellert, der SP wieder dekrementiert und dann
+das niederwertige Byte in den Keller gebracht. Das Entkellern
+erfolgt derart, dass zuerst das niederwertige Byte gelesen
+und der SP inkrementiert wird. Anschliessend wird das hoeherwertige Byte gelesen und der SP erneut inkrementiert. Nach
+Kellern und anschliessendem Entkellern zeigt der Stackpointer
+wieder auf den gleichen Speicherplatz.
+Der Kellerbereich wird auch noch von Unterprogrammspruengen
+und der Interruptorganisation benoetigt, um die erforderlichen Rueckkehradressen aufzubewahren und bereitzustellen.
+<code>Kellern:      PUSH ss  ;ss= BC, DE, AF, HL, IX, IY
+Entkellern:   POP  ss  ;ss= BC, DE, AF, HL, IX, IY</code>
+Beispiel:
+Retten der Register BC, DB, AF und HL in einem Unterprogramm, da diese Register im Unterprogramm benoetigt werden
+und danach ihre alten Inhalte wieder erhalten sollen.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     31 00 00     LD SP,0     ;Kellerzeiger
+                                  ;laden
+     CD F1 10     CALL UP1    ;Unterprogr.-ruf
+             ;PC wird gekellert: (FFFFH):=H(PC)=10h
+             ;                   (FFFBH):=N(PC)=06H
+             ;SP: =FFFEH
+  ...    ;Programmfortsetzung nach der Rueckkehr
+             ;aus dem Unterprogrararn
+             ;Unterprogramm UP1
+F1     C5      UP1: PUSH BC     ;SP:=FFFCH
+                                   (FFFDH):=B
+                                   (FFFCH):=C
+F2     D5           PUSH DE     ;SP=0FFFAH
+                                   (FFFBH):=D
+                                   (FFFAH):=E
+...  ;Unterprogramm
+     Dl           POP DE      ;SP:=FFFCH
+     Cl           POP BC      ;SP:=FFFEH
+     C9           RET         ;Ruecksprung zur
+             ;Adresse, die jetzt im Keller oben
+             ;an steht, in diesem Falle 1006H
+             ;SP:=OOOOH</code>
+Man erkennt, dass das "Zurueckholen" in genau umgekehrter
+Reihenfolge erfolgen muss wie das "Retten". Die Ursache liegt
+darin begruendet, dass der zuletzt gerettete Wert zuerst wieder zurueckgeholt wird und demzufolge der zuerst gerettete
+Wert als letzter im Stack verfuegbar ist. Im Keller werden
+also alle geretteten Werte "aufeinandergestapelt" und von
+diesem Stapel in umgekehrter Reihenfolge wieder herausgeholt.
+=== 4.3.11. Unterprogrammoperationen ===
+Unterprogramme sind Programmteile, die sich bei der Abarbeitung eines Programmes oft wiederholen. Um unnoetige Programmlaengen zu vermeiden, werden solche Teile nur einmal ins Programm eingefuegt und bei Bedarf als UP aufgerufen. Das heisst: Das Hauptprogramm wird an diesen Stellen verlassen, das Unterprogramm abgearbeitet und dann das Hauptprogramm mit dem
+Befehl fortgesetzt, der der Aufrufstelle folgt.
+Der Aufruf von Unterprogrammen kann sowohl unbedingt als auch
+bedingt in Abhaengigkeit vom Flagregister erfolgen. Im wesentlichen ist mit dem Unterprogrammaufruf die definierte
+Aenderung des Befehlszaehlers aehnlich den Sprungbefehlen
+verbunden, allerdings muss bei Rueckkehr aus dem Unterprogramm der Befehlszaehler PC die Adresse des Befehls enthalten, der als unnimittelbarer Nachfolger des Unterprogrammaufrufes gilt, um genau an dieser Stelle im Programm weiterarbeiten zu koennen. Dies wird realisiert, indem vor dem Sprung
+ins Unterprogramm die alte PCAdresse, die auf den folgenden
+Befehl zeigt, gekellert wird und erst dann der Befehlszaehler
+PC die Unterprogrammadresse erhaelt. Bei Rueckkehr aus dem
+Unterprograrnin wird diese im Keller gesicherte Adresse wieder
+in den Befehlszaehler geladen. Das erledigt der Prozessor
+allein durch den Befehl 'RET'.
+<code>CALL adr ;Unterprogrammaufruf, es wird die Adresse des
+          CALL-Befehls +3 in den Keller gebracht (also der
+           nachher notwendige PC-Stand), der PC selbst nimmt
+           den Wert adr an (16-Bit-Adresse). Der Stackpointer
+           wird um 2 erniedrigt.
+RET      ;Unterprogrammrueckkehr, aus dem Keller wird die
+          sichergestellte Adresse in den Befehlszaehler PC
+          geholt, das Hauptprogramm kann weitergehen; der
+          SP wird wieder um 2 erhoeht.
+CAcc adr ;bedingter Unterprogrammaufruf, wenn die Bedingung
+          cc erfuellt ist, sonst nachfolgender Befehl.
+Rcc      ;bedingte Unterprogrammrueckkehr, wenn die Bedin-
+          gung cc erfuellt ist, sonst nachfolgender Befehl.</code>
+Moegliche Bedingungen: cc= NZ, Z, C, NC, P, M, PO, PE
+Die Bedingungen der Unterprogrammrufe sind die gleichen wie bei den bedingten Sprungbefehlen.
+Einen Sonderfall des Unterprogrammrufes bilden die Restart-Befehle. Hier entfaellt die Angabe einer 2-Byte Sprungadres-
+se. Es erfolgen Spruenge zu festen Adressen (0000H, 0008H,
+H, 0018H, 0020H, 0028H, 0030H, 0038H).
+<code>RST hh   ;Unterprogrammruf, der aktuelle PC des RST-Be-
+          fehle (konkret der PC-Stand nach dem RST-Befehl)
+          wird gekellert. Der PC nimmt den Wert 00hhH an.
+          hh=OH, 8H, 10H, ... , 30H, 38H</code>
+Beispiel zur Unterprogrammtechnik:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     3E FF START: LD A,0FFH    ;Start des Haupt-
+                                    programms
+     77           LD (HL),A
+...
+E     CD 34 13     CALL UP1     ;1. Unterprogramm-
+                                   ;ruf
+                                   ;UP1 beginnt bei
+                                   ;Adr.1334H
+     23           INC  HL      ;Fortsetzung des
+                                   ;Hauptprogramms
+     7E           LD A,(HL)
+...
+F     88           ADC  B
+...
+E     CD 34 13     CALL UP1     ;2. Unterprogramm-
+                                   ;ruf
+     23           INC  HL      ;Fortsetzung des
+                                   ;Hauptprogrammes
+...
+A
+B     DD CB 00 DE  SET 3,(IX+0)
+...
+     76           HALT
+     C5      UP1: PUSH BC      ;Beginn des UP
+     CB 4F        BIT 1, A
+..
+     Cl           POP BC
+     C9           RET          ;Rueckkehr ins
+                                   ;Hauptprogramm</code>
+<note tip>Hinweis:
+Es ist unbedingt zu beachten, dass im Unterprogramm die Anzahl der PUSH-Befehle identisch der Anzahl der POP-Befehle
+sein muss, da sonst bei der Entkellerumg bei Unterprogrammrueckkehr ein falscher Wert in den Befehlszaehler kommt und Programm undefiniert und nicht ab der Aufrufstelle wei-
+terlaeuft.
+</note>
+Einde Verschactelung mehrerer Unterprogramme (ein UP ruft ein
+weiteress UP auf ) ist moeglich, die Anzahle der Schachtelungen
+ist theoretisch unbegrenzt.
+=== 4.3.12 Ein- und Ausgabebefehle ===
+Wie bereits erwaehnt, sind beim U 880 maximal 256 Ein- und Ausgabekanaele (Peripherieadressen) adressierbar. Zur Adressierung bei Ein- und Ausgaben wird der niederwertige Teil des
+Adressbusses verwendet. Im Befehl selbst wird die Geraeteadresse (Kanaladresse) entweder direkt ausgegeben oder indirekt
+ueber das C-Register adressiert. Bei direkter Kanaladresse erfolgt der Datentransport immer zwischen dem A-Register und
+der Peripherie, bei indirekter Kanaladresse (C-Register muss
+vorher mit der Kanaladresse geladen werden) kann der Datentransport zwischen einem der Register A, B, C, D, E, H, L, und
+der Peripherie erfolgen.
+<code>IN n      ;Eingabe des Kanals n in das A-Register, A:=(n)
+IN r      ;Eingabe dec Kanals, dessen Adresse im C-Register
+           enthalten ist, nach dem Register 'r'.
+OUT n     ;Ausgabe des A-Registers nach Kanal 'n', (n):=A
+OUT r     ;Ausgabe des Registers 'r' nach dem Kanal, dessen
+           Adresse im C-Register enthalten ist.</code>
+Register 'r' = A, B, C, D, E, H, L
+Einen Sonderfall stellt der Eingabebefehl 'INF' dar. Der Inhalt des von Register C adressierten Kanals wird gelesen und
+danach entsprechend die Flags gesetzt.
+Beispiel: Das Ausgaberegister mit der Adresse 10H soll definiert mit 00, 01 und 02 geladen werden.
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     0E 10        LD  C,10H     ;C:=10H Kanaladres-
+                                    ;se des Registers
+     A8           XOR A         ;A:=00H
+     ED 79        OUT A         ;(C):=00H
+     3C           INC A         ;A:=A+1 = 01H
+     ED 79        OUT A         ;(C):=01H
+     3C           INC A         ;A:=A+1 = 02H
+     ED 79        OUT A         ;(C):=02H
+...
+     76      END: HALT</code>
+=== 4.3.13. Gruppenoperationen fuer Lade-, Vergleichs- und Ein-/Ausgabe-Befehle ===
+Gruppenoperationen in diesem Sinne sind hardwaremaessig im
+Prozessor U 880 installierte Befehlsablaeufe, die vom Programmierer lediglich die Generierung bestimmter Register als
+Parameter verlangen. Diese Befehle vermeiden nicht nur das
+umstaendliche Programmieren mit einzelnen Befehlen, sondern
+fuehren besonders zur Programmbeschleunigung und Einsparung
+von Programmspeicherplaetzen.
+  * **Einfache Gruppenoperationen**<code>LDI   ;inkrementierendes Laden
+      - die Zieladresse ist in DE zu laden
+      - die Quelladresse ist in HL zu laden
+      - die Blocklaenge in BC (=Anzahl der im Speicher auf
+        einanderfolgenden 'zu transportierenden Byte's).
+      Befehlsablauf:  (DE):=(HL)
+                      DB:=DE+1
+                      HL:=HL+1
+                      BC:=BC-1
+                      P/V=0 bei BC-1=0
+bei BC-1<>0
+LDD   ;dekrementierendes Laden
+       wie LDI, nur DE:=DE-1 und HL:=HL-1
+CPI   ;inkrementierendes Vergleichen (Suchbefehl)
+      - die Anfangsadresse ist in HL zu laden
+      - die Blocklaenge ist in BC zu laden
+      Befehlsausfuehrung: A-(HL)=?
+                          HL:=HL+1
+                          BC:=BC-1
+                          Z=1 bei A=(HL)
+bei A<>(HL)
+                          P/V=0 bei BC-1=0
+bei BC-1<>O
+CPD   ;dekrementierendes Vergleichen
+       wie CPI, nur HL:=HL-1
+INI   ;inkrementierende Eingabe
+      - Zieladresse ist in HL zu laden
+      - Kanaladresse ist in C zu laden
+      - Blocklaenge in B (max. 256 Byte)
+      Befehlsausfuehrung: (HL):=(C)
+                          HL:=HL+1
+                          B:=B-1
+                          Z=1 bei B=0
+bei B<>O
+
+IND   ;dekrementierende Eingabe
+       wie INI, nur HL:=HL-1
+OUTI  ;inkrementierende Ausgabe
+      - Zieladresse ist in C zu laden
+      - Kanaladresse ist in Hl zu laden
+      - Blocklaenge in B
+      Befehlsausfuehrung: (C):=(HL)
+                          HL: =HL+1
+                          B:=B-1
+                          Z=1 bei B=0
+bei B<>O
+OUTD  ;dekrementierende Ausgabe
+      wie OUTI, nur HL:=HL-1</code>Bei den einfachen Gruppenoperationen kann der Programmierer gezielt die Flags testen und entsprechende Rueckspruenge bzw. die weitere Programmbearbeitung fordern.\\ Als moegliche Anwendungen ergeben sich: <code>LDI,  LDD  zum Blocktransport
+CPI,  CPD  zur Byte- oder Blocksuche
+INI,  IND  Blockeingabe
+OUTI, OUTD Blockausgabe</code>Die Blocklaenge ist dabei in BC bzw. B anzugeben.
+  * **Repetierende Gruppenoperationen** (sich automatisch wiederholende Gruppenoperationen)\\ Diese Befehle basieren auf den einfachen Gruppenoperationen. Es werden lediglich die Testung der Flags und entspechende Rueckspruenge zur Wiederholung des Befehls automatisch ausgefuehrt. Allerdings ist bei den Ein- und Ausgabegruppenoperationen zu beachten, dass die peripheren Geraete eine gleiche Verarbeitungsgeschwindigkeit haben muessen wie der Prozessor, oder hardwaremaessig ueber die WAIT-Leitung an der CPU eine Angleichung der Verarbeitungsgeschwindigkeit erfolgen muss.<code>LDIR  ; wie LDI, Befehl wird wiederholt bis BC:=00H
+LDDR  ; wie LDD, Befehl wird wiederholt bis BC:=00H
+OPIR  ; wie CPI, Befehl wird wiederholt bis BC:=00H oder A=(HL)
+CPDR  ; wie CPD, wird wiederholt bis BC:=00H oder A=(HL)
+INIR  ; wie INI, wird wiederholt bis B:=0
+INDR  ; wie IND, wird wiederholt tis B:=0
+OTIR  ; wie OVIl, wird wiederholt bis B:=0
+OTDR  ; wie OUTD, wird wiederholt bis B:=0</code>Beispiel: Ein Speicherbereich von Adresse 0D00H bis Adresse 0FFFH soll definiert mit "0E3H" geladen werden.<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     21 00 0D    LD HL, 0D00H  ;Quelladresse
+     3E E3       LD A, 0E3H
+     77          LD  (HL),A    ;(HL):=0E3H,
+                     ;1. Speicherplatz geladen
+     11 01 OD    LD  DE,0D01H  ;1. Zieladresse
+     01 FE 02    LD  BC,2FEH   ;Blocklaenge -1
+                     ;da ein byte schon geladen wurde -
+     ED B0       LDIR          ;Befehl bewirkt
+                     ;das sogenannte Durchschleifen des Wer-
+                     ;tes '0E3H' bis zur Adresse 0FFFH</code>
+=== 4.3.14. Austauschbefehle ===
+<code>EXAF      ; Wechsel des Doppelregisters AF gegen AF'
+EXX       ; Wechsel des Doppelregistersatzes:
+           BC gegen BC'
+           DE gegen DE'
+           HL gegen HL'</code>
+Angewendet wird der Registerwechsel beispielsweise zur Rettung bei Interrupt oder Unterprogramaufruf, da diese Variante
+schneller ist als das Kellern bzw. Entkellern der Register.
+<code>EX DE, HL ; Tausch der Doppelregisterinhalte
+            E-->L und L-->E
+            D-->H und H-->D
+EX (SP), xx; xx=HL, IX, IY
+             Tausch der jeweils obenanstehenden Stackinhalte
+             gegen die Inhalte der Doppelregister xx.
+             (SP)   gegen L, N(IX) oder N(IY)
+             (SP+1) gegen H, H(IX) oder K(IY)</code>
+Beispiel:
+<code>Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     08     INT1: EXAF       ;Register-
+                ;wechsel, da im Interruptprogramm ein
+                ;Grossteil der Register benoetigt wird
+     D9           EXX
+     3E E3        LD   A,3FH
+     ...
+B     D3 04        OUT  04
+D     D9           EXX
+E     08           EXAF
+F     FB           EI
+     ED 4D        RETI</code>
+=== 4.3.15. CPU-Steuerbefehle ===
+<code>NOP  ; Es wird keine Operation ausgefuehrt, nur der Befehle-
+       zaehler um ein Byte weitergestellt.
+HALT ; Prozessor fuehrt intern NOP-Operationen zur Aufrecht-
+       erhaltung des Refresch-Zyklus durch.
+       Der Befehlszaehler erhaelt die Adresse des nachfolgen-
+       den Befehls. Dieser Befehl wird aber erst nach der
+       vollstaendigen Ausfuehrung einer Interruptroutine aus-
+       gefuehrt. Eine Fortsetzung ist auch mit Reset moeglich.</code>
+=== 4.3.16. Bedeutung der Flags ===
+Ein Grossteil aller Mikroprozessorbefehle beeinflusst definiert entweder das gesamte Flag-Register bzw. nur einzelne
+Flag-Bits. Die genaue Kenntnis der Bedeutung der Flag-Bits
+bzw. die Art der Beeinflussung durch verschiedene Befehle ist
+die wichtigste Voraussetzung fuer die fehlerfreie bzw. optimale Programmerstellung. Die allgemeine Bedeutung der Flag-Bits ist folgender Zusammenstellung zu entnehmen:
+<code>
+S:   Vorzeichen (signum)
+     Ist eine Kopie des Bits A7;
+     es repraesentiert das echte Vorzeichen des Resultates
+     nach arithmetischen Operationen mit Operanden in Zweier-
+     komplementdarstellung.
+     S=1, wenn das Ergebnis <0 ist, Abfrage mit cc=M (JPM)
+     S=0, wenn das Ergebnis >=0 ist, Abfrage mit cc=P (JPP)
+Z:   Null (zero)
+     Bei einer Null im A-Register (alle 8 Bitpositionen = 0)
+     nach arithmetischen und logischen Operationen (auch nach
+     CMP) wird Z=1.
+H:   Halbbyteuebertrag (half-carry)
+     Wird bei einem Uebertrag von Bit A3 nach Bit A4 auf "1"
+     gesetzt. (Wird vom DAA-Befehl intern ausgewertet.)
+N:   Subtraktion
+     N=1, wenn der Befehl eine Subtraktion (auch CMP) war.
+     Wird vom DAA-Befehl ebenfalls herangezogen.
+CY:  Uebertrag (Carry)
+     Uebertrag aus dem A-Register nach einer Addition,
+     Mittels SO? und CO? ist das OY-Flag auch setz- und
+     komplement ierbar.
+P/V: Paritaets/Ueberlauf (parity/overflow)
+     Dieses Flag hat verschiedene Funktionen.
+.)  Es zeigt nach logischen und Verschiebeoperationen und
+     nach dem Befehl 'IN r' die Paritaet P an:
+     P=1 bei gerader Anzahl vorhandener Bit-Einsen, die Abfra-
+     ge kann mit JPPE erfolgen
+     Abfrage einer ungeraden Anzahl mit JPPO
+.)  Es zeigt im Gegensatz zu Carry den echten Ueberlauf V
+     des Resultates nach einer arithmetischen Operation mit
+     Operanden an.
+     Abfrage mit JPPE
+.)  Das Flag sichert nach LD A,I und LD A,R das Bit aus IFF2,
+     damit es mit 'LD A,I' wieder in IFF2 gesetzt werden kann.
+     In IFF2 wird eine angemeldete Unterbrechung gespeichert,
+     bis sie vom Prozessor bearbeitet wird.
+.)  Es fixiert nach LD- und CMP-Gruppenoperationen die Aussa-
+     ge, ob der Bytezaehler in BC nach Erniedrigung ungleich
+     Null ist.
+     D. h. P/V=0 bei BC-1=0
+           P/V=1 bei BC-1<>O
+</code>
+Die Abfrage der Flag-Bits bei bedingten Operanden erfolgt
+nach den im jeweiligen Befehl anzugebenden Bedingungen (siehe
+Sprungbefehle) wie folgt:
+<code>
+Bedingung  Frage
+NZ :       Z=0?   ===> JPNZ , JRNZ
+ Z :       Z=1?   ===> JPZ  , JRZ
+NC :       C=0?    usw.
+ C :       C=1?
+PO :     P/V=0?
+PE :     P/V=1?
+ P :       S=0?
+ M :       S=1?
+</code>
+Die komplette Analyse aller Flag-Bits ist jederzeit moeglich
+durch Kellern von AF und anschliessendem Laden der durch den
+SP angezeigten letzten zwei Speicherplaetze in ein Doppelregister.
+Beispiel:
+<code>
+Befehls- Maschinen-   Quellkode    Kommentar
+zaehler  kode
+-----------------------------------------------------
+     F5           PUSK AF      ;Kellern von AF
+     El           POP HL
+                      ;H:=(SP+1)=A,L:=(SP)=F
+     LD  A,L
+</code>
+Die im Anhang beigefuegte Befehlsliste enthaelt Hinweise auf
+die Beeinflussung der Flag-Bits durch die jeweiligen Befehle
+sowie die Kodierung der einzelnen Befehle zur manuellen Programmuebersetzung.
+==== 4.4. Unterbrechungsorganisation ====
+Um auf Signale aus der Umwelt des Prozessors reagieren zu koennen, kann mit
+einem Programm eine Leitung (also ein Signal) zyklisch abgefragt werden. Das
+setzt aber voraus, dass dieses Programm immer dieses Signal abfragt. Eine
+Reaktion des Rechners erfolgt erst, wenn das Signal durch die Abfrage erkannt
+wird. Der U 880 verfuegt ueber die Moeglichkeit eines Interrupts. Das heisst,
+dass ein Signal von einem externen Geraet eine Unterbrechung des laufenden
+Programms zu einem beliebigen Zeitpunkt verursachen kann, um den Prozessor zur
+sofortigen Abarbeitung eines Programms zu zwingen, das diese Unterbrechung
+entsprechend behandelt (Interruptbehandlungsroutine).
+Fuer die effektive und schnelle Bearbeitung von Unterbrechungswuenschen der
+Peripherie stehen beim U 880 ein maskierbarer Interrupt und ein
+nichtmaskierbarer Interrupt zur Verfuegung (der maskierbare Interrupt kann
+verboten werden).
+Wird von der Peripherie ein Signal fuer den nichtmaskierbaren Interrupt erzeugt
+(L-Pegel am Eingang NMI), so fuegt der Prozessor eine RST-Operation mit der
+festen Adresse 0066H ein. Es liegt beim Programmierer, inwieweit er in diesem
+Unterprogramm fuer eine Rettung bestimmter Registerinhalte sorgt. Es gibt keinen
+Befehl, der den nichtmaskierbaren Interrupt verbietet. Die Anwendung liegt meist
+bei der Datenrettung vor Erkennen eines Spannungsausfalis des Rechnersystems.
+Der maskierbare Interrupt kann in 3 unterschiedlichen Betriebsarten auftreten,
+die in der CPU durch einen Befehl eingestellt werden koennen.
+Fuer das Sperren bzw. Freigeben aller drei maskierbaren Interruptarten steht
+jeweils ein Befehl zur Verfuegung.
+Interrupt sperren:  DI \\
+Interrupt erlauben: EI
+Trifft eine Anforderung an den maskierbaren Interrupt ein
+(L-Pegel am Eingang INT), wenn er durch 'DI' gesperrt ist, so
+nimmt der Prozessor diese Anforderung zur Kenntnis und arbeitet diese Anforderung sofort nach dem Wiederfreigeben der Interrupterlaubnis durch den Befehl 'EI' ab.
+**Maskierbare Interruptarten**
+Diese 3 Interruptarten werden durch einen der Befehle 'IM0',
+'IM1' oder 'IM2' gesetzt.
+<code>
+IM0: In dieser Betriebsart wird nach akzeptiertem Unter-
+     brechungswunsch der Interruptquelle der naechste abzu-
+     arbeitende Befehl vom Datenbus geholt und in den Pro-
+     grammlauf eingeschoben.
+     (Es bietet sich hier an, RST-Befehle zu verwenden.
+     Das sind 1-Byte-Befehle, die einem Unterprogrammsprung
+     entsprechen.) Das heisst aber auch, dass durch das in-
+     terruptanfordernde Geraet der Befehl auf den Datenbus
+     gelegt wird.
+IM1:  Nach dem Akzeptieren des Unterbrechungswunsches wird
+      der Befehl 'RST 38H' automatisch ausgefuehrt.
+      Gegebenenfalls muss im Interruptbehandlungsprogramm
+      eine Abfrageroutine eingeleitet werden, welche den
+      "Interrupt-Anmelder" feststellt und danach entsprechen-
+      de Programme aktiviert.
+IM2:  Diese Betriebsart stellt fuer den Prozessor die lei-
+      stungsfaehigste Unterbrechungsbehandlung dar. Man
+      nennt sie auch Vektorinterrupt, weil die Organisation
+      der Behandlungsroutinen ueber Zeiger auf einen Adress-
+      vektor realisiert wird.
+      Bei Unterbrechungsanforderung stellt jede Interrupt-
+      quelle den fuer die gewuenschte Interruptroutine not-
+      wendigen niederwertigen "Zeigerteil" durch Aussenden
+      eines 8-Bit-Wertes auf den Datenbus bereit (sogenann-
+      tes Vektorlesen).
+      Dieser Wert bildet den niederwertigen Teil, der Inhalt
+      des I-Registers den hoeherwertigen Teil einer Adresse
+      einer bestimmten Speicherzelle. Diese und die nachfol-
+      gende Speicherzelle beinhalten dann die Adresse des In-
+      terruptbehandlunnsprogramms. Dies setzt aber natuerlich
+      das vorbereitende Laden des I-Registers und der ent-
+      sprechenden Register der Peripheriebausteine voraus
+      (sogenannte Initialisierung).
+</code>
+Beispiel:
+<code>
+Peripheriebausteine verlangen jeweils eine ande-
+          re Interruptroutine. Die Startadressen fuer die
+          jeweiligen Unterprogramme lauten:
+          INT1:=0FF0H
+          INT2:=0FFFH
+          INT3:=2F00H
+          Aufbau der Startadressentabelle:
+          Zeiger1: 0C00 F0H
+C01 OFH
+          Zeiger2: 0C02 FFH <===   N(INT2):=0FFH
+C03 0FH <===   H(INT2):=0FH
+          Zeiger3: 0C04 00H ===>   0FFFH=Startadresse
+C05 2FH
+C06
+          -  Das I-Register muss mit "0CH" geladen werden.
+             Es stellt den absoluten Zeigerteil dar.
+           - Dem Peripheriebaustein 1 muss fuer das entsprechen-
+             de Register der variable Zeigerteil mit dem Wert
+             "00" mitgeteilt werden. Entspechend gilt "02H" und
+             "04H" fuer Baustein 2 und 3.
+</code>
+Durch Aneinandersetzen des I-Registers als High-Teil und des
+variablen Zeigerteils als Low-Teil entsteht der gesamte Zeiger.
+Das heisst zum Beispiel:
+Peripheriebaustein 2 meldet einen Interrupt an. Der Interrupt 2 wird zu
+gegebener Zeit akzeptiert und der Peripheriebaustein muss jetzt den variablen
+Zeigerteil im Falle des Zahlenbeispiels 02H, auf den Datenbus legen (Vektorlesen
+der CPU). Jetzt erfolgt die Bestimmung des gesamten Zeigers.
+<code>
+I-Register    0CH (High-Teil)
+var. Zeiger   02H (Low-Teil)
+----------------------------
+   Zeiger 2   0C02H
+</code>
+In der Startadresstabelle ist unter der Adresse 0C02H ein
+FFH und unter 0C03H ein 0FH eingetragen, d. h. die Startadresse der zum Peripheriebaustein 2 gehoerenden Interruptbehandlungsroutine lautet 0FFFH.
+Auf diese Art, laesst sich nicht nur sehr schnell aus vielen
+Interruptroutinen die fuer den Peripheriebaustein notwendige
+herausfinden und aktivieren, es wird auch moeglich, fuer ein
+und denselben Peripheriebaustein durch Umprogrammieren des
+"variablen Zeigerteils" eine andere Interruptroutine aufzurufen. Das Akzeptieren einer Interruptanforderung setzt stets
+das Retten der Fortsetzungsadresse voraus. Dies geschieht wie
+beim Unterprogrammruf durch Kellern des Befehlszaehlers. Bei
+Rueckkehr aus der Interruptroutine wird der Befehlszaehler
+wieder entkellert und es erfolgt somit die Fortsetzung der
+Programmabarbeitung an der zuvor verlassenen Stelle. Das Kellern und Entkellern fuehrt der Prozessor automatisch aus.
+Auch hier gilt zu beachten, dass im Interruptprogramm die
+Anzahl der Keller- und Entkelleroperationen gleich sein muss.
+Problematisch ist es, wenn mehrere Peripheriebausteine gleichzeitig eine
+Unterbrechung anmelden. Vorrang hat stets der Baustein, welcher in der
+Prioritaetskette an "weitesten vorn" steht. Diese Kette wird durch die Signale
+'IEI' und 'IEO' gebildet, die durch alle Bausteine hindurchgefuehrt werden.
+Waehrend der Abarbeitung einer Interruptbehandlungsroutine bleibt es dem
+Programmierer ueberlassen, ob er durch Setzen des EI-Befehls die Unterbrechung
+der Interruptbehandlungsroutine vorzeitig durch einen Peripheriebaustein
+hoeherer Prioritaet zulaesst oder nicht, da die Annahme einer Unterbrechung
+weitere Unterbrechungsannahmen ausschliesst. Am Ende einer
+Interruptbehandlungsroutine muss stets, sofern nicht schon erfolgt, mit dem
+Befehl 'EI' die Unterbrechungserlaubnis wieder freigegeben werden. EI wird immer
+erst nach Ausfuehrung des auf EI folgenden Befehls wirksam.
+- Rueckkehrbefehle aus dem Interruptprogramm:
+<code>
+RETI    ; Rueckkehr aus dem maskierbaren Interruptprogramm
+RETN    ; Rueckkehr aus dem nichtmaskierbaren Interruptpro-
+          gramm
+Hinweis:  RETI bewirkt beim Peripheriebaustein, welcher die
+          Interruptroutine ausgeloest hat, das Wiederschlies-
+          sen der Prioritaetskette (IEO--high). Somit koennen
+          nach RETI auch die Peripheriebausteine niedriger
+          Prioritaet einen Interrupt ausloesen.
+</code>