Handbuch zum Rechner-Simulationsprogramm ReSim - HS-Harz M ...

ReSim 2A
Handbuch zum
Rechner-Simulationsprogramm
ReSim
Version 3.10
HS Harz
Fachbereich
Automatisierung und Informatik
von
Dipl. Inf., Dipl.-Ing. (FH) Michael Wilhelm
http://mwilhelm.hs-harz.de
mwilhelm@hs-harz.de
Version 15. Oktober 2011

Inhaltsverzeichnis -2-
Inhaltsverzeichnis
1 Einführung ......................................................................................................................... 5
1.1 Eigenschaften der Version 3 5
1.1.1 Farbdarstellung 5
1.2 Löschen der Register 5
1.3 Löschen des Speichers 5
1.4 Debugger 5
1.5 Temp-Dateien 6
1.6 John von Neumann 6
1.7 Steuerwerk 7
1.8 Rechenwerk 8
1.9 Ein- und Ausgabeeinheit 8
1.10 Register 8
1.11 Datenbus 8
1.12 Adressbus 8
2 Aufbau des Programms..................................................................................................... 9
2.1 Oberfläche 9
2.1.1 Menüstruktur 9
2.1.1.1 Menü Datei 9
2.1.1.2 Ansicht 10
2.1.1.3 Befehle 10
2.1.1.4 Reset 10
2.1.1.5 Start 10
2.1.1.6 Optionen 11
2.1.1.7 Hilfe 12
2.1.2 Schalterleiste 12
2.2 Grafische Elemente 13
2.2.1.1 Ein- und Ausgabeeinheit 13
2.2.1.2 Speicher 14
2.2.1.3 Register 15
2.2.1.4 Steuerwerk 15
2.2.1.5 Programmbemerkungen 16
2.2.1.6 Rechenwerk 16
2.3 Befehlsliste von ReSim 16
2.3.1 Transportbefehle 17
2.3.2 Arithmetikbefehle 17
2.3.3 Logikbefehle 18
2.3.4 Schiebebefehle 18
2.3.5 Sprungbefehle 19
2.3.6 E/A-Befehle 19
2.3.7 Steuerbefehle 20
2.4 Befehlseingabe 21
2.4.1 Transportbefehle 21
2.4.2 Arithmetikbefehle 21
2.4.3 Logikbefehle 22

Inhaltsverzeichnis -3-
2.4.4 Schiebebefehle 22
2.4.5 Sprungbefehle 22
2.4.6 E/A-Befehle 23
2.4.7 Steuerbefehle 23
3 Befehlsgruppen ................................................................................................................ 24
3.1 Einlesen einer Zahl 24
3.2 Register mit einem Wert belegen 24
3.3 Operation auf einem Register und die Speicherung 24
3.4 Sprung, wenn Akku größer Null 25
4 Beispiele ............................................................................................................................ 26
4.1 Einfache Beispiele 26
4.1.1 Kopieren einer Konstante in den Akkumulator (Bsp1) 26
4.1.2 Kopieren und addieren von Konstanten (Bsp2) 26
4.1.3 Einlesen einer Zahl, kopieren ins Register Null (Bsp3) 29
4.1.4 Berechnen einer Formel (Bsp4) 31
4.1.5 Bestimmen des Maximum dreier Zahlen 32
4.1.6 Bestimmen des Maximum beliebiger Zahlen 33
4.1.7 Setzen von Bits (Bsp5) 34
4.1.8 Abfragen von Bits (Bsp6) 34
4.1.9 Maximal Bestimmung (Bsp7) 36
4.2 Komplexere Beispiele 38
4.2.1 Berechnen einer Summe (Bsp8) 38
4.3 Schwere Beispiele 40
5 Debugger........................................................................................................................... 42
5.1 Eigenschaften 42
5.2 Vorgehensweise 42
6 Grundlagen....................................................................................................................... 44
6.1 Logische Verknüpfungen 44
6.1.1 Beispiele 44
6.2 Zahlendarstellungen 45
6.2.1 Zahlenkonvertierung zwischen 2, 8 und 16er-System 46
6.3 Einer-Komplement 47
6.4 B-Komplement 47
7 Literatur ........................................................................................................................... 48
8 Indexverzeichnis .............................................................................................................. 49

Abbildungsverzeichnis -4-
Abbildungsverzeichnis
Abbildung 1 Prinzip-Skizze eines John-von-Neumann-Rechners 7
Abbildung 2 Oberfläche von Resim 9
Abbildung 3 Einstellungsfenster bzgl. der Zeiten 11
Abbildung 4 Einstellungsfenster der Profi-Optionen 11
Abbildung 5 Einstellungsfenster bzgl. der Farben 12
Abbildung 6 E/A-Einheit 13
Abbildung 7 Speicher 14
Abbildung 8 Ändern der Sprungadresse 14
Abbildung 9 Register 15
Abbildung 10 Dialogfenster für ein Register 15
Abbildung 11 Steuerwerk 15
Abbildung 11 Programmbemerkungen 16
Abbildung 12 Rechenwerk 16
Abbildung 13 Eingabe einer Zahl in die Eingabeeinheit 20
Abbildung 14 Eingabe mit Radiobutton 20
Abbildung 15 Bild der Transportbefehle 21
Abbildung 16 Bild der Arithmetikbefehle 21
Abbildung 17 Bild der Logikbefehle 22
Abbildung 18 Bild der Schiebebefehle 22
Abbildung 19 Bild der Sprungbefehle 22
Abbildung 20 Bild der E/A-Befehle 23
Abbildung 21 Bild der Steuerbefehle 23
Abbildung 22 Sprung, wenn Akku > 0 25
Abbildung 23 Konstante 122 in den Akku 26
Abbildung 24 Konstante 122 in den Akku 27
Abbildung 25 Adieren einer Konstante zum Akkumulator 27
Abbildung 26 Wert des Akkumulators ins Register Null kopieren 28
Abbildung 27 Bezeichnung in ein Register eintragen 28
Abbildung 28 Ergebnis des zweiten Beispiels 29
Abbildung 29 Auswahl des Befehls „Lies Zahl in E/A-Einheit" 29
Abbildung 30 Wert des Akkumulators ins Register Null kopieren 30
Abbildung 31 Bezeichnung in ein Register eintragen 30
Abbildung 32 Programm bsp4 32
Abbildung 33 Debugger Ansicht 42
Abbildung 34 Debugfenster 43

Einführung -5-
1 Einführung
Das vorliegende Programm dient dazu, die John-von-Neumann-Architektur an Hand von
Beispielen näher zu erläutern. Dieses Programm wurde als erstes von Herr Meißner als
Abschlussarbeit entwickelt. Danach als MFC-Programm portiert. Die aktuelle Fassung wurde
mit Delphi programmiert und hat etliche Erweiterungen erfahren. Eine Java-Version ist auch
auf meiner Homepage unter der Rubrik „Download/Resim“ zu finden
1.1 Eigenschaften der Version 3
1.1.1 Farbdarstellung
• Es gibt nun bei den Zuweisungen Akku zu Register unterschiedliche Farben. Damit
kann man die Richtung besser unterscheiden. Der Befehl „Mov Reg, Akku“ wird in
roter Farbe, der Befehl „Mov Akku, Register“ wird in blauer Farbe dargestellt.
• Des Weiteren gibt es jetzt einen Debugger, mit dem man Schleifenabläufe stoppen
kann. danach kann man im Einzelschrittmodus weiterlaufen. Details siehe Kapitel 5,
Seite 42.
• Im Menü Ansicht ruft man das Fenster „Programm-Bemerkungen“ auf. In diesem
kann man Kommentare und Bemerkungen eintragen.
• Mit einem Doppelklick in einer Adresse des Speichers kann man diese Adresse nun
einfacher ändern.
Hinweis:
In den Optionen kann man aber die Farben Individuell setzen.
1.2 Löschen der Register
Beim Löschen der Register werden nur die Inhalte der Register gelöscht. Die Namen bleiben
erhalten.
1.3 Löschen des Speichers
Der Speicher wird erst nach einer Sicherheitsabfrage gelöscht.
1.4 Debugger
Man konnte schon in den vorherigen Versionen mit dem Befehl „0“ das Programm anhalten.
Der Start war mit dem Schalter „Start von IP“ möglich. Beim Löschen des „0“-Befehls
änderten sich aber die Sprungadressen. Mit Version 3 gibt nun einen Debugger. Man gibt in
einem Fenster die Haltepunkte als Zeilennummern ein.

Einführung -6-
Details siehe Kapitel 5, Seite 42.
1.5 Temp-Dateien
Das automatische Speichern wurde deaktiviert. Ab Version 3 wird nach jeder Änderung nun
das Programm eine Temp-Datei gespeichert. Die Dateien haben die Namen „Temp01.cpu“ bis
„Temp99.cpu“. Damit kann man besser Versionen verwalten. Gespeichert wird in einem
Ordner namens „Temp“.
Hinweis:
• Die Dateien werden mit dem Aufrufen von „Datei Neu“ bzw. Datei Öffnen“ gelöscht.
• Beim Beenden werden die Dateien nicht gelöscht.
1.6 John von Neumann
Die klassische von-Neumann-Architektur wurde im Jahre 1946 von John von Neumann als
Konzept zur Gestaltung eines universellen Rechners für technische, wissenschaftliche und
wirtschaftliche Problemstellungen vorgeschlagen. Bis auf wenige Ausnahmen sind die
heutigen Rechenanlagen Weiterentwicklungen dieses Universalrechners.
Nach [1] ist ein Rechner nach in der von-Neumann-Architektur aufgebaut [1], wenn er
folgende Kriterien erfüllt:
• Der Rechner besteht aus fünf Komponenten,
o dem Steuerwerk
o dem Rechenwerk
o dem Speicher
o dem Eingabewerk
o dem Ausgabewerk
• Die Struktur des Rechners ist unabhängig von der Art der Problemstellung. Dem
Rechner muss ein Programm als Bearbeitungsvorschrift vorliegen, ansonsten ist er
arbeitsunfähig
• Programm und Daten sind in einem Speicher untergebracht
• Der Speicher ist in gleich große, durchnummerierte Zellen (Speicherzellen) unterteilt.
• Aufeinanderfolgende Programmbefehle werden in aufeinander folgenden Speicherzellen
gespeichert
• Durch Sprungbefehle kann die Bearbeitung dieser Reihenfolge verlassen werden
• Es gibt mindestens folgende Befehlsarten:
o Arithmetikbefehle, Logikbefehle, Transportbefehle
o bedingte Sprünge und Befehle für Unterbrechungen
o Warten-, Ein- /Ausgabe- und Schiebeoperationen
• Alle diese Befehle können in verschiedenen Adressierungsarten ausgeführt werden
• Alle Befehle und Daten sind binär kodiert, so dass eine Unterscheidung nicht möglich
ist. Geeignete Schaltwerke im Steuerwerk decodieren die Daten und sorgen für die
richtige Entschlüsselung

Einführung -7-
Die Rechnerarchitektur des von-Neumann-Rechners bezeichnet man nach M. Flynn als SISD-
Architektur 1 . Das bedeutet, dass immer nur ein Befehl auf ein Datum angewandt werden
kann. Im Gegensatz dazu gibt es Architekturen, die mehrere Befehle auf ein Datum anwenden
(MISD), die einen Befehl auf mehrere Daten anwenden (SIMD) und Architekturen, die
mehrere Befehle gleichzeitig auf mehrere Daten anwenden können (MIMD). Die Tätigkeit
eines von-Neumann-Rechners besteht im Wesentlichen im Transportieren von Daten
zwischen dem Rechenwerk und dem Speicher bzw. Ein-/Ausgabewerk. Dies geschieht alles
auf nur einem Datenkanal. Aus diesem Grunde nennt man diesen Pfad auch den "von-
Neumann-Flaschenhals". Hier können die oben genannten Architekturen Abhilfe schaffen.
Die heutigen Rechnerarchitekturen benutzen mehrere unabhängige Bus-Systeme, zum
Beispiel den PCI-Bus mit der North- und South-Bridge.
Die Abbildung 1 zeigt den prinzipiellen Aufbau eines John-von-Neumann-Rechners. Die
Befehle, Daten und Adressen sind im Speicher.
Abbildung 1 Prinzip-Skizze eines John-von-Neumann-Rechners
Die Daten und Programme werden durch das Betriebssystem von Festplatte in den
Hauptspeicher geladen. Prinzipiell besteht der Speicher nur aus Nullen und Einsen. Welche
Bytes Daten bzw. Programmbefehle sind, kann man ohne Analyse nicht entscheiden. Der
zweite wichtige Aspekt ist das Steuerwerk. Dieses liest die Befehle aus dem Speicher. Dazu
benutzt es den Adressbus zur Auswahl des Befehls bzw. der Daten. Im zweiten Schritt werden
über dem Datenbus die Datenbits in das Steuerwerk transportiert. Dort wird der Befehle
analysiert, und es werden gegebenenfalls noch weitere Operanden aus dem Speicher geholt.
Danach werden die Daten in das Rechenwerk bzw. der ALU 2 transportiert und der Befehl
ausgeführt. Das Ergebnis wird dann in Register oder in einem Speicher zurückkopiert. Nach
Abarbeitung des Befehls wird der nächste Befehl zur Ausführung geholt.
1.7 Steuerwerk
Das Steuerwerk ist für die Zerlegung der Befehle, der Dekodierung der Daten und die
Generierung der Steuersignale zuständig. Von hier aus werden die Speicherzellen und die
Register adressiert sowie die Schreib- und Leseleitungen aktiviert.
1 SISD: Single Instruction, Single Data
2 ALU = Arithmetic Logical Unit

Einführung -8-
Zuerst werden die Befehle in Mikrocode Befehle, auch Nanobefehle genannt, zerlegt, danach
werden die einzelnen Steuerleitungen geschaltet. Hier werden die Bitkombinationen der
Befehle in elektrische Impulse umgewandelt.
1.8 Rechenwerk
Das Rechenwerk besteht aus den beiden Operandenregistern und dem AKKU als Zielregister.
Außerdem gibt es noch ein Übertrag-Flag und die ALU, in der die eigentliche Verknüpfung
der Daten geschieht. Die "Programmierung" der ALU geschieht über den Operandenbus OP.
Der Datenspeicher besteht aus acht Speicherzellen und dient der Speicherung von Daten, die
nicht unmittelbar verarbeitet werden sollen. Wenn das geschehen soll, müssen die Daten erst
in den AKKU oder in eines der acht Register transportiert werden. Die Zugriffszeiten heutiger
Datenspeicher liegen zwischen 1 bis 100 ns. Die Speichergröße kann bis zu einigen GByte
betragen.
1.9 Ein- und Ausgabeeinheit
Die Ein-/Ausgabeeinheit besteht aus zwei Daten-Kanälen, im Programm aus 8-Bit, wobei
einer als Eingabekanal und einer als Ausgabekanal dient. Hier können Daten eingelesen oder
ausgegeben werden. Aktuell werden die Daten in einem Dialogfenster eingegeben.
1.10 Register
Die Registerbank besteht aus acht Registern und dient der Aufnahme von Operanden und
Zwischenergebnissen. Von hier aus können Daten direkt mit dem AKKU verknüpft werden.
Die Zugriffszeiten sind aufgrund der einfacheren Adressierung und anderem hardwaremäßigen
Aufbau bedeutend kürzer als bei Datenspeichern. Die heutigen Prozessoren haben
zwischen 16 und 128 Register mit bis zu 128 Bit Datenbreite.
1.11 Datenbus
Über den Datenbus werden die Daten zwischen den einzelnen Komponenten transportiert. Er
verbindet den Speicher, das Rechenwerk, die Ein-/Ausgabeeinheit und die Registerbank
miteinander.
1.12 Adressbus
Über den Adressbus werden die einzelnen Speicherzellen und Register angesprochen. Die
Adresse wird vom Steuerwerk generiert und auf den Adressbus ausgegeben. Jede Speicherzelle
und jedes Register ist mit dieser Adresse eindeutig identifizierbar. Die Steuerleitungen
wie z.B. IORD oder WR legen fest, ob eine Information gelesen oder geschrieben werden
soll. Sie werden ebenfalls vom Steuerwerk generiert.

Aufbau des Programms -9-
2 Aufbau des Programms
2.1 Oberfläche
Abbildung 2 Oberfläche von Resim
Die Abbildung 2 zeigt das Hauptfenster von Resim. Das Programm -arbeitet mit Menüs, einer
Schalterleiste und grafischen Elementen zur Anzeige der Inhalte.
2.1.1 Menüstruktur
2.1.1.1 Menü Datei
Eintrag Beschreibung
Neu Erstellen einer neuen Datei, der Speicher
und das Register werden gelöscht
Öffnen Öffnet eine vorhandene Datei
Speichern Speichert den aktuellen Inhalt in die
angegebene Datei
Speichern unter Inhalt unter einem anderem Namen
speichern
Drucken Drucken der Befehle
Druckereinrichtung Aufruf der Druckereinrichtung
Export der Befehle in die Zwischenablage Exportiert die Befehle in die
Zwischenablage
Neue Instanz des Programms Das Programm wird neu aufgerufen. Es ist
kein MDI-Programm.
Beenden Beendet das Programm.

Aufbau des Programms -10-
2.1.1.2 Ansicht
Eintrag Beschreibung
Programm-
Bemerkungen
Anzeige eines Fensters, indem man Bemerkungen eintragen kann.
Es ist ein Top-of-the-stay Fenster, es bleibt also immer oberhalb
aller Fenster.
Befehlsfenster Anzeige des Befehlsdialogs. Es ist ein Top-of-the-stay Fenster, es
bleibt also immer oberhalb aller Fenster.
Ausgabefenster Öffnet das Ausgabefenster an der letzten bekannten Position. Dieses
Fenster zeigt die Eingaben und Ausgaben der Ein- und Ausgabeeinheit.
Debugger Öffnet das Debuggerfenster mit den Haltepunkten.
Symbolleiste An- und Ausschalten der Symbolleiste
2.1.1.3 Befehle
Eintrag Beschreibung
Transportbefehle Zeigt direkt das Dialogfenster für die Transportbefehle
Arithemetikbefehle Zeigt direkt das Dialogfenster für die Arithmetikbefehle
Logikbefehle Zeigt direkt das Dialogfenster für die Logikbefehle
Schiebebefehle Zeigt direkt das Dialogfenster für die Schiebebefehle
Sprungbefehle Zeigt direkt das Dialogfenster für die Sprungbefehle
E/A-Befehle Zeigt direkt das Dialogfenster für die E/A-Befehle
Steuerbefehle Zeigt direkt das Dialogfenster für die Steuerbefehle
2.1.1.4 Reset
Eintrag Beschreibung
Speicher Reset Löscht den Speicher
Register Reset Löscht die Register
System Reset Löscht den Speicher und die Register
2.1.1.5 Start
Eintrag Beschreibung
Programmstart (F9) Startet das Programm vom ersten Speicher, IP=0
Einzelschritt Stellt den Einzelschrittmodus ein. Mit den Befehl „Takt“ kann
man den nächsten Schritt bei der Befehlsabarbeitung ausführen
Takt (F8) Mit den Befehl „Takt“ kann man den nächsten Schritt bei der
Befehlsabarbeitung ausführen
Programmlauf beenden Beendet den Ablauf, entspricht dem Schalter „Stop“

Aufbau des Programms -11-
2.1.1.6 Optionen
Eintrag Beschreibung
Taschenrechner Ruft den Taschenrechner auf. Bitte beachten, man muss dann die
wissenschaftliche Ansicht einstellen.
Einstellungen Zeigt ein Dialogfenster mit den Einstellungen des Programms
Speicherbelegung Anzeige des aktuellen Speichers des Rechners
Eintrag Einstellungen:
Abbildung 3 Einstellungsfenster bzgl. der Zeiten
In der oberen Einstellung kann man die Zeit der Animationen einstellen. Je kleiner der Wert,
desto schneller läuft das Programm ab. Um Datenverluste zu vermeiden, speichert das
Programm automatisch die Inhalte des Speichers und der Register. Dabei werden bis zu 99
Varianten im Verzeichnis „Temp“ gespeichert.
Abbildung 4 Einstellungsfenster der Profi-Optionen
Nach dem Befehl „Einlesen einer Zahl“ kann man zwei Abkürzungen in der Eingabe
vornehmen. In der letzten Einstellungen kann man das gewünschte Register im E/A-Dialog
auswählen.

Aufbau des Programms -12-
Abbildung 5 Einstellungsfenster bzgl. der Farben
2.1.1.7 Hilfe
Eintrag Beschreibung
Info Anzeige der Programmsinfo
2.1.2 Schalterleiste
Datei öffnen
Neue Datei
Speichern der Daten in eine Datei
Speicher löschen
Register löschen
Bestimmt die Anzeige im Ausgabefenster. Mögliche Optionen;
• Binäre Darstellung
• Hexadezimale Darstellung
• Die Werte werden als ASCII-Zeichen dargestellt
Start des Programms ab Position Null

Aufbau des Programms -13-
2.2 Grafische Elemente
Start des Programms ab der aktuellen Position
Einschalten des Einzelschrittmodus
Abarbeiten des aktuellen Befehls. Jeder befehl besteht aus mehreren Teilen
Beendet den Einzelschrittmodus und den autom. Ablauf
Setzt den Interrupt (Wird aber nicht weiter verwendet)
Anzeige des Befehlsfensters
Folgende Grafische Elemente sind im Dialogfenster vorhanden:
2.2.1.1 Ein- und Ausgabeeinheit
Abbildung 6 E/A-Einheit
Zeigt die Ein- und Ausgabeeinheit. Mit dem rechten Editor kann eine Zahl eingestellt werden.

Aufbau des Programms -14-
2.2.1.2 Speicher
Abbildung 7 Speicher
Zeigt den Speicher, also die Befehle des Programms. Mit der rechten Maustaste kann man
Zeilen löschen bzw. einfügen. Man sollte aber beachten, dass manche Befehle zwei Zeilen
benötigen!
Mit einem Doppelklick im Speicher kann man die Adresse nun einfacher ändern. Man muss
direkt Positioniert man den Mausklick in eine Zeile
Abbildung 8 Ändern der Sprungadresse

Aufbau des Programms -15-
2.2.1.3 Register
Abbildung 9 Register
Zeigt die Register. Mit einem Doppelklick kann man den Inhalt bzw. die Bezeichnung ändern.
Abbildung 10 Dialogfenster für ein Register
2.2.1.4 Steuerwerk
Abbildung 11 Steuerwerk

Aufbau des Programms -16-
2.2.1.5 Programmbemerkungen
Ab Version 3,1 gibt es auch ein Fenster, indem man Erläuterungen zum Programm eingeben
kann. Diese Texte werden in der Resim-Datei gespeichert und beim Laden wieder angezeigt.
Mit dem Menüeintrag „Ansicht“, Eintrag „Programmbemerkungen“ wird der Text in einem
Editor angezeigt:
Abbildung 12 Programmbemerkungen
2.2.1.6 Rechenwerk
Zeigt das Rechenwerk. Im Akku steht immer der erste Operand. Hat man zwei Operanden, so
wird die Anzeige „Operand“ benutzt. Die ALU ist hier nur als Panel angedeutet.
Abbildung 13 Rechenwerk
Das Ergebnis des Befehls wird wieder in den Akkumulator eingetragen. Dazu werden die
beiden Flags Z und Carry gesetzt. Das Zero-Flag wird gesetzt, wenn das Ergebnis Null ist.
Das Carry-Flag, Übertragungbit, wird gesetzt, wenn das Ergebnis größer als 255 ist. Es dient
dazu, Ketten von Operationen korrekt abzubilden. Das Carry-Bit wird dann in der nächsten
Operation benutzt.
Ein Beispiel ist die Multiplikation mittels ROR, SHL und dem Carry-Flag.
2.3 Befehlsliste von ReSim
Diese Liste beinhaltet eine Zusammenfassung aller Befehle für die Rechnersimulation. Zu
jedem Befehl wird eine kurze syntaktische und funktionale Beschreibung angegeben, die in
ähnlicher Form auch in der Online Hilfe im Programm zu finden ist.

Aufbau des Programms -17-
Reihenfolge:
Die Reihenfolge der Befehle orientiert sich am 8086-Assembler. Es muss also immer von
rechts nach links gelesen werden.
Beispiel:
MOV Akku, Reg1 Kopiert den Inhalt von Register 1 in den Akkumulator
2.3.1 Transportbefehle
Die Transportbefehle dienen zum Kopieren der Daten vom Akkumulator zum Register bzw.
zum Speicher.
Befehl Beschreibung
MOV Akku, Reg? Kopiert den Wert des ausgewählten Registers in den
Akkumulator.
MOV Akku, Konstante Kopiert den Wert einer Konstanten in den Akkumulator. Eine
Konstante kann nicht direkt in ein Register kopiert werden.
MOV Reg?, Akku Kopiert den Wert des Akkumulator in ausgewählten Register.
MOV Akku, Speicher Kopiert den Wert des ausgewählten Speichers in den
Akkumulator.
MOV Speicher, Akku Kopiert den Wert des Akkumulator in die Speicherzelle.
Hinweis:
Die Adressen der Register werden in den jeweiligen Befehlen in den Bits 0 bis 2 gespeichert.
Beispiel: 01001001 Add Akku, Register
Die Bitfolge „01001“ bestimmt den Befehl
Die Bitfolge „001“ bestimmt das Register
2.3.2 Arithmetikbefehle
Die Arithmetikbefehle dienen der Addition, Subtraktion und Division resp. Modulo-Berechnung.
Das Ergebnis wird wieder in den Akkumulator geschrieben.
Befehl Beschreibung
ADD Akku, Reg? Berechnet die Summe des Akkumulators mit dem ausgewählten
Register.
ADD Akku, Konstante Berechnet die Summe des Akkumulators mit der Konstanten.
SUB Akku, Reg? Berechnet die Summe des Akkumulators mit dem ausgewählten
Register.
SUB Akku, Konstante Berechnet die Differenz des Akkumulators mit der Konstanten.
MOD Akku, Reg? Berechnet die Differenz des Akkumulators mit dem ausgewählten
Register.
MOD Akku, Konstante Berechnet den Modulo-Wert, Restwert, des Akkumulators mit

Aufbau des Programms -18-
der Konstanten. 7 mod 3 ist 1
DIV Akku, Reg? Berechnet die Division des Akkumulators mit dem ausgewählten
Register.
DIV Akku, Konstante Berechnet die Division des Akkumulators mit der Konstanten.
2.3.3 Logikbefehle
Die Logikbefehle werden zum Setzen, Maskieren und Löschen von Bits benutzt. Das Ergebnis
wird wieder in den Akkumulator geschrieben.
Befehl Beschreibung
AND Akku, Reg? Berechnet das logische UND des Akkumulators mit dem
ausgewählten Register
AND Akku, Konstante Berechnet das logische UND des Akkumulators mit der
Konstanten
OR Akku, Reg? Berechnet das logische ODER des Akkumulators mit dem
ausgewählten Register
OR Akku, Konstante Berechnet das logische ODER des Akkumulators mit der
Konstanten
NOT Akku Bildet das EINER-Komplement des Akkumulators, also die
einfache Negation (bitweise)
Der XOR-Befehl kann mittels folgender Abfolge simuliert werden:
a XOR b = ( !a AND b ) OR (a AND !b)
2.3.4 Schiebebefehle
Die Schiebebefehle dienen zum einfachen Multiplizieren bzw. Dividieren. Das Ergebnis wird
wieder in den Akkumulator geschrieben.
Befehl Beschreibung
SHL Akku, Konstante Führt eine Verschiebung des Akkumulators um eine Stelle
nach links aus. Das höchstwertigste Bit (MSB) wird dabei nach
links herausgeschoben und das niederwertigste Bit (LSB) wird
mit einer Null aufgefüllt. Dies entspricht einer Multiplikation
mit dem Faktor zwei, falls keine Eins im MSB stand.
SHR Akku, Konstante Führt eine Verschiebung des Akkumulators um eine Stelle
nach rechts aus. Das niederwertigste Bit (LSB) wird dabei nach
rechts herausgeschoben und das höchstwertigste Bit (MSB)
wird mit einer Null aufgefüllt. Dies entspricht einer Division
durch zwei.
ROL Akku, Konstante Führt eine Verschiebung des Akkumulators um eine Stelle
nach links aus. Das höchstwertigste Bit (MSB) wird dabei nach
links herausgeschoben und in das Carry-Flag geschrieben. Das
niederwertigste Bit (LSB) wird mit dem Inhalt des Carry-Flag,

Aufbau des Programms -19-
alter Wert, aufgefüllt.
ROR Akku, Konstante Führt eine Verschiebung des Akkumulators um eine Stelle
nach rechts aus. Das niederwertigste Bit (LSB) wird dabei nach
rechts herausgeschoben und in das Carry-Flag geschrieben. Das
höchstwertigste Bit (MSB) wird mit dem Inhalt des Carry-Flag,
alter Wert, aufgefüllt.
Beispiele:
• 00011001 SHL ergibt 00110010
• 00011001 SHR ergibt 00001100
• 00011001 ROL ergibt 00110010 wenn Carry nicht gesetzt
• 00011001 ROL ergibt 00110011 wenn Carry gesetzt
• 00011001 ROR ergibt 00001100 wenn Carry nicht gesetzt
• 00011001 ROR ergibt 10001100 wenn Carry gesetzt
2.3.5 Sprungbefehle
Die Sprungbefehle dienen zum Ändern der linearen Programmabfolge. Es wurden nicht alle
möglichen Varianten implementiert. Insbesondere fehlt der Sprungbefehl mit einem
Konstantenvergleich. Man kann aber stattdessen die Konstante in ein Register speichern.
Befehl Beschreibung
Jump Adresse Unbedingter Sprung. Es wird immer zur angegebenen Adresse
gesprungen.
Jump Akku Zero zu Wenn der Inhalt des Akkumulators Null ist, wird zur
Adresse
angegebenen Adresse gesprungen.
Jump Akku GT Zero zu Wenn der Inhalt des Akkumulators größer Null ist, wird zur
Adresse
Jump Akku LT Reg(i) zu
Adresse
Jump Akku LE Reg(i) zu
Adresse
angegebenen Adresse gesprungen.
Wenn der Inhalt des Akkumulators kleiner als der Inhalt des
Registers i ist, wird zur angegebenen Adresse gesprungen.
WICHTIG:
Dieser Befehl ändert den Inhalt des Akkumulators
Wenn der Inhalt des Akkumulators kleiner gleich dem Inhalt
des Registers i ist, wird zur angegebenen Adresse gesprungen.
WICHTIG:
Dieser Befehl ändert den Inhalt des Akkumulators
Jump Carry zu Adresse Wenn das Carry-Flag gesetzt ist, wird zur angegebenen Adresse
gesprungen.
2.3.6 E/A-Befehle
Die Ein- und Ausgabebefehle dienen zur besseren Ein- und Ausgabe. Aus der E/A-Einheit
kann nur der Transport zum Akkumulator programmiert werden.
Eingelesen wird mittels eines Eingabefensters:

Aufbau des Programms -20-
Abbildung 14 Eingabe einer Zahl in die Eingabeeinheit
Die numerische Eingabe kann direkt in die Zeile eingetragen werden. Diese Zahl darf aber nur
einen Bereich von null bis 255 haben. Für weitere Eingaben steht auch das zweite Register
zur Verfügung.
Abbildung 15 Eingabe mit Radiobutton
Hier kann man die einzelnen Bits direkt angeben. Das Eingabefenster fügt dann die korrekte
Zahl in die Eingabeeinheit.
Befehl Beschreibung
IN Akku Kopiert den Wert in der E/A-Einheit in den Akkumulator
OUT Akku Kopiert den Wert des Akkumulators in die E/A-Einheit
OUT Newline Ausgabe einer Leerzeile im Ausgabefenster
Lies Zahl in E/A-Einheit Liest eine Zahl ein und trägt diese in die E/A-Einheit ein.
Optional kann man hier auch das Register eingeben. dazu muss
man im Optionsfenster die Einstellung setzen.
2.3.7 Steuerbefehle
Die unten aufgeführten Befehle werden bei Sprungbefehlen bzw. bei Schiebebefehlen
benutzt.

Aufbau des Programms -21-
Befehl Beschreibung
CLR Carry Löscht das Carry-Flag. Siehe auch den ROL bzw. ROR-Befehl
GoSub Sprung zu einem Unterprogramm. Der Rücksprung erfolgt mit
einem IRet
IRET Rücksprung eines Unterprogramms.
NOP Keine Aktion (No Operation)
2.4 Befehlseingabe
Hier werden die einzelnen Fenster der Befehlsgruppen aufgelistet:
2.4.1 Transportbefehle
Abbildung 16 Bild der Transportbefehle
2.4.2 Arithmetikbefehle
Abbildung 17 Bild der Arithmetikbefehle

Aufbau des Programms -22-
2.4.3 Logikbefehle
Abbildung 18 Bild der Logikbefehle
2.4.4 Schiebebefehle
Abbildung 19 Bild der Schiebebefehle
2.4.5 Sprungbefehle
Abbildung 20 Bild der Sprungbefehle

Aufbau des Programms -23-
2.4.6 E/A-Befehle
Abbildung 21 Bild der E/A-Befehle
Wenn die Option „Nach "Lies Zahl" automatisch "Mov Reg, Akku"“ gesetzt ist, kann man
hier bequem das Zielregister eingeben. Dann werden drei Befehle eingefügt:
• Lies Zahl
• In Akku
• Mov Reg(i), Akku
2.4.7 Steuerbefehle
Abbildung 22 Bild der Steuerbefehle

Befehlsgruppen -24-
3 Befehlsgruppen
Dieses Kapitel zeigt, wie man die einzelnen Befehle in sinnvolle Gruppen resp. Aufgaben,
einteilen kann. Es gibt immer wieder „Teilaufgaben“, die in den Programmen gelöst werden
müssen.
3.1 Einlesen einer Zahl
• Lies Zahl in E/A-Einheit
• IN Akku
• Move Reg(i), Akku
Das Register muss ausgewählt werden
3.2 Register mit einem Wert belegen
Diese Aufgabe kann man nur über den Akkumulator realisieren:
• Mov Akku, Kostante
• Move Reg(i), Akku
Das Register muss ausgewählt werden
3.3 Operation auf einem Register und die Speicherung
Diese Aufgabe kann man nur über den Akkumulator realisieren:
• Mov Akku, Reg(i) // Register in den Akkumulator
• Operation Akku, Reg(j) // add, sub, div, mod
• Mov Akku, Reg(k) // Wert in das Zielregister schreiben
Die Register i,j,k müssen ausgewählt werden. Können aber auch teilweise identisch sein

Aufbau des Programms -25-
3.4 Sprung, wenn Akku größer Null
Befehle:
• Mov Akku, Reg(i)
• Jump Akku GT Zero zu Adresse
Abbildung 23 Sprung, wenn Akku > 0

Beispiele -26-
4 Beispiele
4.1 Einfache Beispiele
4.1.1 Kopieren einer Konstante in den Akkumulator (Bsp1)
a) Neue Datei anklicken und speichern unter Bsp1
b) Öffnen des Befehlsdialog
Anklicken des Schalters „Transportbefehle“
c) Auswahl des Eintrags „Move Akku, Konstante“
Eintragen der Konstante 122
Schalter „Ok“ betätigen
Abbildung 24 Konstante 122 in den Akku
Folgender Befehl ist nun im Speicher:
Adr Binärwert Befehl / Daten
000 00111111 Move Akku, Konstante
001 01111010 122
d) Starten des Programms mit der Taste F9 oder mit dem Schalter
e) Der Akkumulator enthält den Wert 12210 bzw. 011110102
4.1.2 Kopieren und addieren von Konstanten (Bsp2)
a) Neue Datei anklicken und speichern unter Bsp2
b) Öffnen des Befehlsdialog

Beispiele -27-
Anklicken des Schalters „Transportbefehle“
c) Auswahl des Eintrags „Move Akku, Konstante“
Eintragen der Konstante 122
Schalter „Ok“ betätigen
Abbildung 25 Konstante 122 in den Akku
d) Wechseln zum Befehlsdialog
Anklicken des Schalters „Arithmetikbefehle“
e) Auswahl des Eintrags „Add Akku, Konstante“
Eintragen der Konstante 35
Schalter „Ok“ betätigen
Abbildung 26 Adieren einer Konstante zum Akkumulator
f) Wechseln zum Befehlsdialog
Anklicken des Schalters „Transportbefehle“
g) Auswahl des Eintrags „Move Register, Akku“
Eintragen des Registers 0
Schalter „Ok“ betätigen

Beispiele -28-
Abbildung 27 Wert des Akkumulators ins Register Null kopieren
Folgende Befehle sind nun im Speicher:
Adr Binärwert Befehl / Daten
000 00111111 Move Akku, Konstante
001 01111010 122
002 01011000 Add Akku, Konstante
003 00100011 35
004 00110000 Move Reg, Akku
g) Setzen eines Registers
Doppelklick auf das Register Null
In der unteren Zeile Summe eintragen
Schalter „Ok“ betätigen
Abbildung 28 Bezeichnung in ein Register eintragen
h) Starten des Programms mit der Taste F9 oder mit dem Schalter
i) Der Akkumulator bzw. das Register Null enthalten den Wert 15710 bzw. 100111012

Beispiele -29-
Abbildung 29 Ergebnis des zweiten Beispiels
4.1.3 Einlesen einer Zahl, kopieren ins Register Null (Bsp3)
a) Neue Datei anklicken und speichern unter Bsp3
b) Öffnen des Befehlsdialog
Anklicken des Schalters „E/A-Befehle“
c) Auswahl des Eintrags „Lies Zahl in E/A-Einheit“
Schalter „Ok“ betätigen
Abbildung 30 Auswahl des Befehls „Lies Zahl in E/A-Einheit"
d) Wechseln zum Befehlsdialog
Anklicken des Schalters „Transportsbefehle“
e) Auswahl des Eintrags „Move Register, Akku“
Eintragen des Registers 0
Schalter „Ok“ betätigen

Beispiele -30-
Abbildung 31 Wert des Akkumulators ins Register Null kopieren
Folgende Befehle sind nun im Speicher:
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit
001 11000000 IN Akku
002 00110000 Move Reg, Akku
003 00110000 Move Reg, Akku
g) Setzen eines Registers
Doppelklick auf das Register Null
In der unteren Zeile „Eingegeneber Wert“ eintragen
Schalter „Ok“ betätigen
Abbildung 32 Bezeichnung in ein Register eintragen
f) Starten des Programms mit der Taste F9 oder mit dem Schalter
g) Der Akkumulator bzw. das Register Null enthalten den eingegebenen Wert

Beispiele -31-
4.1.4 Berechnen einer Formel (Bsp4)
Dieses Beispiel zeigt die Berechnung einer Multiplikation und einer Addition. Folgende
Formel soll berechnet werden:
c = a + 4·b
a) Im ersten Schritt werden nun die Register verteilt
a Register 0
b Register 1
c Register 2
b) Nun wird der Algorithmus entwickelt.
In einer Hochsprache kann man die obige Gleichung direkt eingeben. In Assembler bzw.
ReSim ist das nicht möglich. Da ReSim keine Punkt- vor Strichrechnung berücksichtigt,
muss man erst den Ausdruck „4 mal b“ berechnen und dann a dazu addieren.
c) Neue Datei anklicken und speichern unter Bsp4
Einlesen von a:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 0
Einlesen von b:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 1
Berechnen:
• „Move Akku, Register“, Registernummer 1 b !
• SHL 2 // Damit wird die Zahl b um zwei Bits nach links verschoben,
also 2 2 = 4
• Add Akku, Register“, Registernummer 0 a !
Ergebnis speichern:
• „Move Register, Akku“, Registernummer 2 b !
• OUT Akku // Damit wird das Ergebnis ausgegeben

Beispiele -32-
Abbildung 33 Programm bsp4
Im Programm bsp4 wurden die Register null bis zwei mit Bezeichnungen versehen. Da diese
mit in der Datei gespeichert werden, existiert nun eine einfache Dokumentation des
Algorithmus.
Hinweis:
Die Adressen der Register werden in den jeweiligen Befehlen in den Bits 0 bis 2 gespeichert.
Weitere Aufgabe:
Erstellen eines ReSim-Programms mit Einlesen und Speichern von sechs Zahlen und Berechnen
folgender Formel
a + b a − b
g = −
c + d e + f
4.1.5 Bestimmen des Maximum dreier Zahlen
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit
001 11000000 IN Akku
002 00110000 Move Reg, Akku 1. Zahl in Register 0
003 10111100 Lies Zahl in E/A-Einheit
004 11000000 IN Akku
005 00110001 Move Reg, Akku 2. Zahl in Register 1
006 10111100 Lies Zahl in E/A-Einheit
007 11000000 IN Akku
008 00110010 Move Reg, Akku 3. Zahl in Register 2

Beispiele -33-
009 00101000 Move Akku, Register 1. Zahl holen
010 11110001 Jump Akku LT Reg(i) zu Adresse Abfrage mit Reg(1)
011 00010000 16 wenn Reg(0) < Reg(1) dann jump 16
012 00101000 Move Akku, Register Reg(0) ist >= Reg(1)
013 00110011 Move Reg, Akku Maximum speichern in Reg(3)
014 10111000 Jump zu Adresse Sprung zu 18
015 00010010 18
016 00101001 Move Akku, Register Maximum speichern in Reg(3)
017 00110011 Move Reg, Akku Nun “jump” zu 18
018 00101010 Move Akku, Register Abfrage mit Maximum und Reg(2)
019 11110011 Jump Akku LT Reg(i) zu Adresse wenn Reg(2) < Reg(3) dann jump 25
020 00011001 25
021 00101010 Move Akku, Register Reg(2) ist >= Reg(3)
022 11001000 OUT Akku Ausgabe
023 10111000 Jump zu Adresse Jump zu 27
024 00011011 27
025 00101011 Move Akku, Register Ausgabe
026 11001000 OUT Akku
Optional kann man den Wert noch im zweiten Teil ins Register 3 speichern
4.1.6 Bestimmen des Maximum beliebiger Zahlen
Registerbelegung:
Reg 0: Maximum
Reg 1: Aktuelle Zahl
Adr Binärwert Befehl / Daten
000 00111111 Move Akku, Konstante
001 00000000 0
002 00110000 Move Reg, Akku
003 10111100 Lies Zahl in E/A-Einheit
004 11000000 IN Akku
005 00110001 Move Reg, Akku
006 10111001 Jump Akku Zero zu Adresse
007 00001110 14
008 11011000 Jump Akku LE Reg(i) zu Adresse
009 00001011 11
010 00101001 Move Akku, Register
011 00110000 Move Reg, Akku
012 10111000 Jump zu Adresse
013 00000011 3
014 00101000 Move Akku, Register
015 11001000 OUT Akku

Beispiele -34-
4.1.7 Setzen von Bits (Bsp5)
Dieses Beispiel zeigt die Bit-Manipulationsmöglichkeiten. Folgende Aufgabe besteht:
• Einlesen einer Zahl in Register 0
• Setzen des vierten Bits 3
• Speichern in Register 1
a) Erst wird der Algorithmus entwickelt.
Um das vierte Bit zu setzen, muss man die Oder-Verknüpfung aufrufen. Der Wert ermittelt
sich aus der Nummer, indem man die Zweier-Potenz ausrechnet. Zwei hoch vier ist 16.
b) Neue Datei anklicken und speichern unter Bsp4
Einlesen von X:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 0
Berechnen:
• „Move Akku, Register“, Registernummer 0
• „ODER Akku mit Konstante 16“
Ergebnis speichern:
• „Move Register, Akku“, Registernummer 1
• „OUT Akku“ // Damit wird das Ergebnis ausgegeben
Programm:
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit
001 11000000 IN Akku
002 00101000 Move Akku, Register
003 01111111 OR Akku, Konstante
004 00010000 16
005 00110001 Move Reg, Akku
006 11001000 OUT Akku
4.1.8 Abfragen von Bits (Bsp6)
Dieses Beispiel zeigt die Bit-Manipulationsmöglichkeiten. Folgende Aufgabe besteht:
• Einlesen einer Zahl in Register 0
• Testen, ob das dritte Bit gesetzt ist
3 Informatiker zählen von Null, das 4. Bit ist „normal“ das fünfte Bit

Beispiele -35-
• Falls ja, wird eine eins ins Register 1 gespeichert
• Falls nein, wird eine 1 ins Register 0 gespeichert
• Ausgabe des Register 1
a) Erst wird der Algorithmus entwickelt.
Um das dritte Bit zu selektieren, muss man die Und-Verknüpfung aufrufen. Alle Bits, die
nicht interessant sind, erhalten eine Null, alle interessanten eine Eins. Für die obige
Aufgabe ermittelt man den Wert Acht.
b) Neue Datei anklicken und speichern unter Bsp5
Einlesen von X:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 0
Berechnen:
• „Move Akku, Register“, Registernummer 0
• „UND Akku mit Konstante 8“
Sprung:
Nun muss der Akkumulatorwert abgefragt werden. Ist er größer als Null, so ist das Bit
gesetzt, und man muss eine Eins ins Register 1 eintragen. Sonst eine Null. Da es keine
Einrückungen à la Java oder C gibt, muss man zweimal „springen“
Algorithmus:
UND Akku, 8
Jump to Adresse L1, wenn Akku größer als Null ist
mov Akku, Konstante Null
Jump zur Adresse L2, ein unbedingter Sprung
L1: mov Akku, Konstante Eins
L2: mov Register 1, Akku // kann für beide Fälle programmiert werden
out Akku
Hinweise:
• Die L1 und L2 sind Sprungmarken (Label). In ReSim müssen sie mit Nummern
versehen werden
• Im Programm kann man die genaue Adresse nicht immer genau voraus ermitteln.
Dann gibt man einfach eine ungefähre Zahl ein, z. B. plus fünf. Das bedingt
natürlich, dass man diesen Befehl noch einmal eingeben muss. Man kann nicht nur
die Adresse ändern (jeweils noch nicht)
Programm:
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit

Beispiele -36-
001 11000000 IN Akku
002 00110000 Move Reg, Akku
003 00101000 Move Akku, Register
004 01111000 AND Akku, Konstante
005 00001000 8
006 10111011 Jump Akku GT Zero zu Adresse
007 00001100 12
008 00111111 Move Akku, Konstante
009 00000000 0
010 10111000 Jump zu Adresse
011 00001110 14
012 00111111 Move Akku, Konstante
013 00000001 1
014 00110001 Move Reg, Akku
015 11001000 OUT Akku
123 liefert eine eins
37 liefert eine null
Weitere Aufgaben:
• Eingabe einer Zahl, Löschen von Bit fünf
• Eingabe einer Zahl, setzen von Bit drei und fünf
• Eingabe einer Zahl, testen der Bits zwei und sechs
2) Max-Bestimmung
Einlesen zweier Zahlen
Ausgabe der größeren Zahl (out)
4.1.9 Maximal Bestimmung (Bsp7)
Dieses Beispiel zeigt Abfrage-Techniken. Folgende Aufgabe besteht:
• Einlesen einer Zahl in Register 0
• Einlesen einer Zahl in Register 1
• Ausgabe der größeren Zahl
a) Neue Datei anklicken und speichern unter Bsp5
Einlesen von X:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 0
Einlesen von Y:
• „Lies Zahl in E/A-Einheit“
• „In Akku“

Beispiele -37-
• „Move Register, Akku“, Registernummer 1
Berechnen:
• „Move Akku, Register“, Registernummer 0„
Sprung:
Nun muss der Akkumulatorwert mit dem Register 1 überprüft werden. Ist der Akku größer
als Register 1, so wird der Akku ausgegeben, sonst Register 1. Da es keine Einrückungen à
la Java oder C gibt, muss man zweimal „springen“
Algorithmus:
Mov Akku, Register 0
Jump to Adresse L1, wenn Akku größer als Register 1 ist // Akku, Reg0 ist Max
mov Akku, Register 2
mov Register 2, Akku // Register 2 beinhaltet das Maximum
Jump zur Adresse L2, ein unbedingter Sprung
L1: mov Akku, Register 0
mov Register 2, Akku // Register 2 beinhaltet das Maximum
L2: mov Akku, Register 2 // kann eventuell entfallen
out Akku
Programm:
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit
001 11000000 IN Akku
002 00110000 Move Reg, Akku
003 10111100 Lies Zahl in E/A-Einheit
004 11000000 IN Akku
005 00110001 Move Reg, Akku
006 00101000 Move Akku, Register
007 11110001 Jump Akku LT Reg(i) zu Adresse
008 00001101 13
009 00101000 Move Akku, Register
010 00110010 Move Reg, Akku
011 10111000 Jump zu Adresse
012 00001111 15
013 00101001 Move Akku, Register
014 00110010 Move Reg, Akku
015 00101010 Move Akku, Register
016 11001000 OUT Akku
Weitere Aufgaben:
Summen-Bestimmung
Einlesen zweier Zahlen
Ausgabe der Summen beider Zahlen (out)

Beispiele -38-
Mittelwert-Bestimmung
Einlesen zweier Zahlen
Ausgabe des Mittelwertes, ganzzahlige Division (out)
4.2 Komplexere Beispiele
4.2.1 Berechnen einer Summe (Bsp8)
Dieses Beispiel zeigt die Schleifen-Technik. Folgende Aufgabe besteht:
• Einlesen einer Zahl n in Register 0 // n
• Aufsummieren der Zahlen von 1 bis n
• Ausgabe der Summe
a) Algorithmus erstellen
Bei dieser Aufgabe muss man als erstes die Register zuordnen. Danach bedingt die
verwendete Schleife die Initialisierung der Zählvariablen.
Grobe Skizze des Algorithmus:
• Einlesen einer Zahl
• Kopieren ins Register 0
• Addieren um eins
• Kopieren ins Register 1 // Abfrageregister jump Akku < Reg(1)
• Löschen des Registers 2 // Summenregister
• Setzen des Register 3 auf eins // Zähler
// Schleife L1:
• kopiere Register 3 in den Akku // summe = summe + Zähler
• Addiere Register 2 zum Akku
• Speichere Akku in Register 2
• Kopiere Zähler in den Akku
• Addiere um Eins
• Kopiere Akku in den Zähler
• Abfrage und Sprung: Wenn Zähler
b) Neue Datei anklicken und speichern unter Bsp5
Einlesen von N:
• „Lies Zahl in E/A-Einheit“
• „In Akku“
• „Move Register, Akku“, Registernummer 0
• „Addiere Akku“ um eins
• „Move Register, Akku“, Registernummer 1

Beispiele -39-
Initialisierung der Summe und des Zählers:
• „Mov Akku, Konstante“, Null
• „Move Register, Akku“, Registernummer 2
• „Mov Akku, Konstante“, Eins
• „Move Register, Akku“, Registernummer 3
Schleife: (Adresse 12)
• L1: „Move Akku, Register“, Registernummer 2“ // Zähler
• „OUT Akku“ // Kontrolle
• „Add Akku, Register“, Registernummer 3“ // summe
• „Move Register, Akku“, Registernummer 2 // summe=summe+Zähler
• „Move Akku, Register“, Registernummer 3“
• „Add Akku, Konstante“, Eins
• „Move Register, Akku“, Registernummer 3 // Zähler = Zähler+1
Sprung:
Nun muss der Akkumulatorwert mit dem Register 1 (n+1) überprüft werden.
• „Jump zur Adresse, wenn Akku < Register“, Registernummer 2“ // summe
o Jump Akku LT Reg(i)
o Adresse 12
o Register 1
Programm:
Adr Binärwert Befehl / Daten
000 10111100 Lies Zahl in E/A-Einheit
001 11000000 IN Akku
002 00110000 Move Reg, Akku
003 01011000 Add Akku, Konstante
004 00000001 1
005 00110001 Move Reg, Akku
006 00111111 Move Akku, Konstante
007 00000000 0
008 00110010 Move Reg, Akku
009 00111111 Move Akku, Konstante
010 00000001 1
011 00110011 Move Reg, Akku
012 00101011 Move Akku, Register
013 11001000 OUT Akku
014 01001010 Add Akku, Register
015 00110010 Move Reg, Akku
016 00101011 Move Akku, Register
017 01011000 Add Akku, Konstante
018 00000001 1
019 00110011 Move Reg, Akku
020 11110001 Jump Akku LT Reg(i) zu Adresse
021 00001100 12
022 00101010 Move Akku, Register

Beispiele -40-
023 11001000 OUT Akku
Weitere Aufgaben:
Mittelwert-Bestimmung
Einlesen einer Zahl n
Berechnen der Summe von 1 bis n
Ermitteln des Mittelwertes
Ausgabe des Mittelwertes
Teiler einer Zahl
Einlesen einer Zahl x
Berechnen und Ausgabe aller echten Teiler der Zahl x
Test auf vollkommene Zahl
Einlesen einer Zahl x
Berechnen der Summe aller echten Teiler der Zahl x
Ist die Summe gleich der Zahl x
dann Ausgabe einer 1
sonst Ausgabe einer 0
Lösung: 33 Zeilen
4.3 Schwere Beispiele
Fibonacci-Folge:
Einlesen einer Zahl N
Ermitteln der Fibonacci-Folge bis die n-te Zahl ausgegeben wurde
Lösung: 27 Zeilen
Maximal kann n den Wert 13 haben
Mögliche Registerbelegeung:
Register 0: N // wie viele Folgenglieder werden ausgegeben
Register 1: a
Register 2: b
Register 3: ??
Register 4: Zähler
Die Fibonacci-Folge fängt bei 0 und 1 an.
Die nächste Zahl ergibt sich aus der Summe der vorherigen beiden Zahlen
Primzahl-Test:
Einlesen einer Zahl x
Wenn x eine Primzahl ist
dann Ausgabe von 1
sonst Ausgabe von 0

Beispiele -41-
Primzahl-Ausgabe:
Einlesen einer Zahl x
Bestimmen und Ausgabe aller Primzahlen von zwei bis zur Zahl x
Fakultät:
Einlesen einer Zahl x
Ausgabe der Fakultät
Maximal darf aber fünf eingeben werden
33 Zeilen mit der einfachen Lösung
Teiler einer Zahl:
Einlesen einer Zahl x
Berechnen und Ausgabe aller echten Teiler der Zahl x
Hier muss die Multiplikation die Modulo-Funktion ersetzen, da die Modulo-Funktion nur mit
einer Konstanten implementiert wurde.

Debugger -42-
5 Debugger
Ab Version 3,00 ist ein Debugger integriert. Damit kann man Haltepunkte setzen und bis zu
diesen das Programm automatisch ablaufen lassen. Die Haltepunkte werden in einem
separaten Fenster verwaltet.
5.1 Eigenschaften
• Anzeige der Breakpoints in einem Fenster
• Anschalten aller Breakpoints
• Setzen von Breakpoints im laufenden Programm !
• Trace-Modus mit Einzelschritt
• Automatischer Weiterlaufen mit dem Schalter „Start mit IP“
5.2 Vorgehensweise
• Schreiben des Programms
• Öffnen des Debuggerfenster mit dem Menü „Ansicht“, Eintrag „Debugger“
• Eintragen der Haltepunkt. Eingefügt werden die Nummer
• Starten mit der Taste „F9“ oder dem Schalter „Starte von IP 0“
Abbildung 34 Debugger Ansicht
In der Abbildung wurde ein Haltepunkt mit der Zeilenummer 25 eingegeben. Im
Speicherfenster sieht man, dass das Programm genau beim Befehlszeiger 25 anhält. Der
Befehl wurde aber noch nicht ausgeführt.
Das Programm prüft nach jedem Befehl, ob ein gültiger Haltepunkt im Editor eingetragen ist.
Wurde ein Haltepunkt gefunden, stoppt das Programm. Nun kann man sich die Inhalte der
Register ansehen. Mit dem Schalter „Einzelschritt“ kann man nun das Programm nacheinander
abarbeiten. Der Schalter „Start von IP“ startet nun bei Bedarf das Programm in den
automatischen Modus. Gestoppt wird, wenn ein Haltepunkt erkannt wird.

Beispiele -43-
Abbildung 35 Debugfenster
Wenn die aktuelle IP-Adresse im Fenster in einer beliebigen Zeile steht, muss nicht sortiert
sein, so hält das Programm an, und man muss im Einzelschrittverfahren weitermachen.
Danach kann man mit dem Schalter weiterlaufen.

Grundlagen -44-
6 Grundlagen
6.1 Logische Verknüpfungen
Oder Verknüpfung:
ODER 0 1
0 0 1
1 1 1
Und Verknüpfung:
UND 0 1
0 0 0
1 0 1
Negation:
0 1
NOT 1 0
Exklusives Oder:
XOR 0 1
0 0 1
1 1 0
XOR ergibt eine 1, wenn die Bits unterschiedlich sind!
6.1.1 Beispiele
Diese logischen Verknüpfungen werden auch auf Bitfolgen angewandt.
0001 ODER 1000 = 1001
0001 OR 1000 = 1001
0001 ∨ 1000 = 1001
0001 | 1000 = 1001
1011 UND 1000 = 1000
1011 AND 1000 = 1000
1011 ∧ 1000 = 1000
1011 & 1000 = 1000
NOT 1010 = 0101

Beispiele -45-
NICHT 1010 = 0101
¬ 1010 = 0101
! 1010 = 0101
1011 XOR 1000 = 0011
1010 XOR 1111 = 0101
0101 XOR 1111 = 1010
6.2 Zahlendarstellungen
Neben dem Dezimalsystem sind alle weiteren Zahlensysteme, die vor allem
in der Informatik verwendet werden, sogenannte Stellenwertsysteme.
Definition - Stellenwertsystem:
Jede reelle Zahl wird durch eine Folge von Ziffern beschrieben:
Wie eine Ziffer zum Wert der Zahl beiträgt, hängt von ihrer Position bezüglich des Kommas
ab. Sie wird dazu mit (B = Basis des Zahlensystems multipliziert. Für den Wert der Zahl
ergibt sich damit:
X = ± ( ZmB
X = ±
+ ∞
∑
μ=
−∞
m
ZμB
+ Z
μ
m − 1
B
≈ ±
m−1
+ n
∑
μ=
−m
1
+ ... + Z1B
+ Z 0B
ZμB
Beispiel:
123,4 = 1⋅102 + 2⋅101 + 3⋅100 + 4⋅10-1
μ
0
+ Z
Zahlensystem Zahlenbasis Ziffern Beispiel
Dualsystem B=2 0, 1 11111001100
Fünfersystem B=5 0, 1, 2, 3, 4 30441
Siebenersystem B=7 0, 1, 2, 3, 4, 5, 6 5551
Oktalsystem B=8 0, 1, 2, 3, 4, 5, 6, 7 3714
Dezimalsystem B=10 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 1996
Hexadezimalsystem B=16 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 7CC
A, B, C, D, E, F
Divisionsrestverfahren:
13 zur Basis 10 = 1101 zur Basis 2
denn:
13:2=6 Rest 1
6:2= 3 Rest 0
3:2= 1 Rest 1
1:2= 0 Rest 1
− 1
B
−1
+ Z
− 2
B
−2
...)

Beispiele -46-
Das Konvertieren (Umwandeln) von Dezimalzahlen in Zahlen eines anderen Zahlensystems
bzw. umgekehrt, oder zwischen den anderen Zahlensystemen, basiert auf der Definition der
Stellenwertsysteme. Daraus wurde ein Konvertierungsverfahren, das „Divisions-Restwert-
Verfahren“, entwickelt, das allgemein einsetzbar ist (es beruht darauf, dass man nach
Abspalten von Resten sukzessive versucht, den neuen Basiswert aus der verbliebenen Zahl
„auszuklammern“ und dann nach Potenzen des neuen Basiswertes zusammenfasst).
Beispiel - Umwandlung Dezimalzahl in Dualzahl: 4510 = X2 ?
45 : 2 = 22 Rest: 1, also 45 = 22 · 2 + 1
22 : 2 = 11 Rest: 0, also 45 = (11 · 2 + 0) · 2 + 1
11 : 2 = 5 Rest: 1, also 45 =
= ((5 · 2 + 1) · 2 + 0) · 2 + 1
= 5 · 23 + 1 · 22 + 0 · 21 + 1 · 20
5 : 2 = 2 Rest: 1
2 : 2 = 1 Rest: 0
1 : 2 = 0 Rest: 1
Ergebnis: 4510 = 1011012
6.2.1 Zahlenkonvertierung zwischen 2, 8 und 16er-System
Berechnung des Binärsystems: 471110 = 10010011001112
Damit ist es trivial, aus der Binär-Lösung sofort die weiteren Zahlen zu berechnen. Man fasst
drei oder vier Bits zusammen:
a) Dual nach Hexadezimal
- Berechnen der Dualzahl
- Zusammenfassen von 4 Bits, von rechts beginnend
- 00010010011001112 = 1 0010 0110 01112 = 0001 0010 0110 01112
- Alle „vier Bits“ in eine hexadezimale Zahl umwandeln
- 1 2 6 7 16
b) Dual nach Oktal
- Berechnen der Dualzahl
- Zusammenfassen von 3 Bits, von rechts beginnend
- 00010010011001112 = 1 001 001 100 1112 = 001 001 001 100 1112
- Alle „drei Bits“ in eine hexadezimale Zahl umwandeln
- 1 1 1 1 4 7 8

Beispiele -47-
6.3 Einer-Komplement
Regeln zur Umwandlung:
• Die Subtraktion einer positiven Zahl wird auf die Addition des Komplements
zurückgeführt.
• Das Komplement einer Zahl ist die bitweise Vertauschung von Nullen und Einsen.
• Falls ein Überlauf stattfindet, muss diese „Eins“ zum Ergebnis hinzuaddiert werden.
Beispiel:
+43 01010112
- 27 00110112
---------------------------------
+43 01010112
+ -27 11001002
---------------------------------
+ 1 0001111
1
---------------------------------
Σ 16 00100002
6.4 B-Komplement
Regeln zur Umwandlung:
• Die Subtraktion einer positiven Zahl wird auf die Addition des 2-Komplements
zurückgeführt.
• Das Komplement einer Zahl ist die bitweise Vertauschung von Nullen und Einsen.
Danach die Addition von Eins.
• Ein Überlauf wird ignoriert.
Beispiel:
+43 01010112
- +27 00110112
---------------------------------
+43 01010112
+ -27 11001012
---------------------------------
+ 1 0010000
---------------------------------
Σ 16 00100002

Literatur -48-
7 Literatur
[1] Duden der Informatik Dudenverlag Mannheim
[2] Giloi, Wolfgang K. Rechnerarchitektur, Springer-Verlag, Berlin
[3] Oberschelp, W. Vossen, G. Rechneraufbau und Rechnerstruktur, Oldenbourg-Verlag
[4] http://de.wikipedia.org/wiki/Von-Neumann-Architektur
[5] Heinz-Peter Gumm und Manfred Sommer, Einführung in die Informatik
(Gebundene Ausgabe - 20. Oktober 2008), Verlag: Oldenbourg; Auflage: 8., vollst. überarb.
Auflage. (20. Oktober 2008), ISBN-10: 3486587242, ISBN-13: 978-3486587241
[6] Script der Vorlesung

Indexverzeichnis -49-
8 Indexverzeichnis
A
Adressbus................................................................................................................................................................................... 8
Arithmetikbefehle .................................................................................................................................................................... 17
Aufbau des Programms .............................................................................................................................................................. 9
Ausgabeeinheit........................................................................................................................................................................... 8
B
Befehlseingabe ......................................................................................................................................................................... 21
Befehlsgruppen ........................................................................................................................................................................ 24
Einlesen einer Zahl ............................................................................................................................................................. 24
Operattion auf einem Register und die Speicherung........................................................................................................... 24
Register mit einem Wert belegen ........................................................................................................................................ 24
Sprung, wenn der Akku größer Null ................................................................................................................................... 25
Befehlsliste............................................................................................................................................................................... 16
Beispiele................................................................................................................................................................................... 26
Abfragen von Bits............................................................................................................................................................... 34
Berechnen einer Formel ...................................................................................................................................................... 31
Berechnen einer Summe ..................................................................................................................................................... 38
Bestimmen Maximum beliebiger Zahlen ............................................................................................................................ 33
Bestimmen Maximum dreier Zahlen................................................................................................................................... 32
Einlesen einer Zahl, kopieren ins Register Null.................................................................................................................. 29
Kopieren einer Konstante in den Akkumulator................................................................................................................... 26
Kopieren und addieren von Konstante ................................................................................................................................ 26
Maximal Bestimmung......................................................................................................................................................... 36
Setzen von Bits ................................................................................................................................................................... 34
B-Komplement......................................................................................................................................................................... 47
Breakpoint................................................................................................................................................................................ 42
D
Datenbus..................................................................................................................................................................................... 8
Debugger.................................................................................................................................................................................. 42
Divisionsrestverfahren ............................................................................................................................................................. 45
E
E/A-Befehle ............................................................................................................................................................................. 19
Ein- und Ausgabeeinheit .......................................................................................................................................................... 13
Einer-Komplement................................................................................................................................................................... 47
Einführung ................................................................................................................................................................................. 5
Eingabeeinheit............................................................................................................................................................................ 8
G
Grundlagen............................................................................................................................................................................... 44
H
Haltepunkt................................................................................................................................................................................ 42
J
John von Neumann..................................................................................................................................................................... 6

Literatur -50-
L
Literatur.................................................................................................................................................................................... 48
Logikbefehle ............................................................................................................................................................................ 18
Logische Verknüpfungen ......................................................................................................................................................... 44
M
Menüstruktur.............................................................................................................................................................................. 9
O
Oberfläche.................................................................................................................................................................................. 9
P
Programmbemerkungen ........................................................................................................................................................... 16
R
Rechenwerk.......................................................................................................................................................................... 8, 16
Register ................................................................................................................................................................................ 8, 15
Reihenfolge .............................................................................................................................................................................. 17
S
Schalterleiste ............................................................................................................................................................................ 12
Schiebebefehle ......................................................................................................................................................................... 18
Speicher.................................................................................................................................................................................... 14
Sprungbefehle .......................................................................................................................................................................... 19
Steuerbefehle............................................................................................................................................................................ 20
Steuerwerk ........................................................................................................................................................................... 7, 15
T
Transportbefehle ...................................................................................................................................................................... 17
V
Version 3.................................................................................................................................................................................... 5
Debugger............................................................................................................................................................................... 5
Farbdarstellung ..................................................................................................................................................................... 5
Löschen der Register............................................................................................................................................................. 5
Löschen des Speichers .......................................................................................................................................................... 5
Tempdateien.......................................................................................................................................................................... 6
Z
Zahlendarstellungen ................................................................................................................................................................. 45
Zahlenkonvertierung zwischen 2, 8 und 16er-System.............................................................................................................. 46
Zweier-Komplement ................................................................................................................................................................ 47