🖥️

Der Von-Neumann-Rechner

Informatik Leistungsfach · Gymnasium Baden-Württemberg · Mikrosim-Assembler

Rechnerarchitektur Leistungsfach Klasse 11-12

🎯 Worum geht's? Klasse 11–13 · 3–4 Unterrichtsstunden

Nach dieser Seite kannst du …

den Aufbau eines Von-Neumann-Rechners beschreiben (Rechenwerk, Steuerwerk, Speicher, Bus)
den Befehlszyklus Holen – Dekodieren – Ausführen an einem Beispiel durchspielen
kurze Assembler-Programme lesen und ihren Ablauf in den Registern verfolgen

Vorwissen: Binärzahlen, einfache Programme

💡 Was ist das Von-Neumann-Prinzip?

John von Neumann beschrieb 1945 eine Rechnerarchitektur, die bis heute die Basis der meisten Computer bildet. Das revolutionäre Konzept: Programme und Daten liegen gemeinsam im selben Speicher und sind beide veränderbar.

                    🔑 Die 5 Kernprinzipien
                    Universalrechner: Beliebige Aufgaben durch Austausch des Programms lösbar
                        
Gemeinsamer Speicher: Befehle und Daten liegen im selben Arbeitsspeicher
                        
Sequentielle Abarbeitung: Befehle werden der Reihe nach ausgeführt
Binärdarstellung: Alle Informationen als Binärzahlen codiert
Binäre Schaltlogik: Verarbeitung durch einfache logische Gatter

                

🔧 Aufbau der Von-Neumann-Architektur

Ein Von-Neumann-Rechner besteht aus 4 Grundkomponenten, die über einen gemeinsamen Bus kommunizieren:

Prozessor

CPU – Central Processing Unit

🧠 Steuerwerk (CU)Holt Befehle, dekodiert sie und koordiniert alle anderen Einheiten

➕ Rechenwerk (ALU)Führt arithmetische (+, −) und logische Operationen durch

📦 RegisterUltraschnelle Speicher direkt in der CPU (AX, BX, IP, SP …)

Speicher

💾 Arbeitsspeicher (RAM)

Enthält sowohl Programm-Befehle als auch Daten – adressierbar über Speicheradressen

Eingabe

⌨️ Eingabewerk

Tastatur, Maus, Sensoren …

⟷

Bus-System

Ausgabe

🖥️ Ausgabewerk

Bildschirm, Drucker …

📡 Das Bus-System Adressbus (welche Adresse?), Datenbus (welche Daten?), Steuerbus (Lesen oder Schreiben?)

📦 Register im Mikrosim-Modell

Register	Name	Funktion	Beispiel
AX	Akkumulator X	Allgemeines Rechenregister – Hauptoperand	`MOV AX, 5`
BX	Basisregister X	Allgemeines Register, oft als Adresszeiger	`ADD BX, AX`
IP	Instruction Pointer	Zeigt auf den nächsten auszuführenden Befehl	Nach Fetch: IP+2
SP	Stack Pointer	Zeigt auf die Spitze des Stacks	Nach PUSH: SP−1
DR	Data Register	Zwischenspeicher für den Operanden (intern)	Automatisch
OP	Opcode Register	Enthält den aktuell geladenen Befehlscode	OP = 0x12
FLAG	Flag-Register	Sign (negativ?) und Zero (null?)	Nach SUB: S/Z

🔄 Der Fetch-Decode-Execute-Zyklus

FETCH

Befehl aus Speicher[IP] → OP; IP erhöhen

FETCH OP

Operand aus Speicher[IP] → DR; IP erhöhen

DECODE

Steuerwerk interpretiert Opcode

EXECUTE

Mikrooperationen ausführen

↩

Wiederholen

Zurück zu 1 – bis HALT

🔍 Konkret in der Mikrosim-Firmware:
Adr 00: MOV OP,[IP] – Opcode laden | Adr 03: INC IP | Adr 04: MOV DR,[IP] – Operand laden | Adr 06: INC IP | Adr 07: EXECUTE

                    📌 Beispiel: MOV AX, 5
                    FETCH: Speicher[IP]=0x12 → OP; IP++
FETCH OP: Speicher[IP]=0x05 → DR; IP++
DECODE: 0x12 = „Direktwert in AX laden"
EXECUTE: AX ← DR = 5

                

💾 Speicherorganisation & Adressierungsarten

Beispielprogramm im Speicher:

Adresse	Inhalt	Bedeutung
00	12	← IP: MOV AX, nn
01	05	Operand: 5
02	24	MOV BX, nn
03	03	Operand: 3
04	2E	ADD AX, nn
05	02	Operand: 2
06	7C	HALT
10	0A	Datenwert 10

🔑 Adressierungsarten

nn Unmittelbar: MOV AX, 5
[nn] Direkt: MOV AX,[10]
[BX] Indirekt: MOV AX,[BX]
BX Register: ADD AX, BX

⚠️ Von-Neumann-Flaschenhals Befehle und Daten teilen sich denselben Bus → kein gleichzeitiger Zugriff möglich.

📋 Befehlssatz (Kurzübersicht)

Opcode	Befehl	Beschreibung
🔀 Datentransfer (MOV)
`12`	`MOV AX, nn`	Lade Direktwert nn in AX
`10`	`MOV AX,[nn]`	Lade Speicher[nn] in AX
`13`	`MOV AX,[BX]`	Lade Speicher[BX] in AX
`24`	`MOV BX, nn`	Lade Direktwert nn in BX
`19`	`MOV [nn],AX`	Speichere AX nach Speicher[nn]
`28`	`MOV AX, BX`	Kopiere BX nach AX
`2A`	`MOV BX, AX`	Kopiere AX nach BX
➕ Arithmetik
`2E`	`ADD AX, nn`	AX = AX + nn
`32`	`ADD AX, BX`	AX = AX + BX
`36`	`SUB AX, nn`	AX = AX − nn
`3C`	`SUB AX, BX`	AX = AX − BX
`5B`	`INC AX`	AX = AX + 1
`5C`	`INC BX`	BX = BX + 1
`5E`	`DEC AX`	AX = AX − 1
`5F`	`DEC BX`	BX = BX − 1
🔁 Sprünge
`63`	`JMP nn`	Unbedingter Sprung zu nn
`67`	`JS nn`	Sprung wenn S-Flag gesetzt (negativ)
`6A`	`JNS nn`	Sprung wenn S-Flag nicht gesetzt (≥ 0)
`6B`	`JZ nn`	Sprung wenn Z-Flag gesetzt (= 0)
`73`	`JNZ nn`	Sprung wenn Z-Flag nicht gesetzt (≠ 0)
📞 Unterprogramme & Stack
`88`	`CALL nn`	Unterprogramm aufrufen
`90`	`RET`	Rückkehr aus Unterprogramm
`97`	`PUSH AX`	AX auf Stack legen
`9B`	`POP AX`	Stack-Top in AX
`7C`	`HALT`	Programm anhalten

💻 Assembler-Beispielprogramme

Assembler
                            ; 7 + 3 = 10
                            start:
                            MOV AX, 7
                            ADD AX, 3
                            MOV [20], AX
                            HALT
                        

Ergebnis: AX = 10, Speicher[0x20] = 10

Assembler
                            ; AX = Summe, BX = Zähler
                            MOV AX, 0
                            MOV BX, 1
                            loop:
                            ADD AX, BX
                            INC BX
                            MOV [30], BX
                            SUB BX, 6
                            MOV BX, [30]
                            JNZ loop
                            MOV [20], AX
                            HALT
                        

Wichtig: SUB setzt ZF – BX muss gesichert/wiederhergestellt werden!

Assembler
                            MOV AX, 4
                            CALL verdopple
                            MOV [20], AX
                            HALT
                            verdopple:
                            ADD AX, AX
                            RET
                        

⚖️ Von-Neumann vs. Harvard-Architektur

Von-Neumann

Befehle & Daten im selben Speicher
Ein gemeinsamer Bus
Einfacher, günstiger
Flaschenhals
PCs, Server

Harvard

Befehle & Daten getrennt
Zwei separate Busse
Gleichzeitiger Zugriff
Schneller, aufwändiger
Mikrocontroller

⚙️ Was ist die Firmware?

Die Firmware (Mikroprogramm) des Mikrosim-Rechners ist das Steuerwerk auf Mikroebene. Sie definiert für jeden Maschinenbefehl (Opcode), welche Mikrooperationen in welcher Reihenfolge ausgeführt werden. Jede Zeile der Firmware-Tabelle entspricht einem Mikroschritt – die Spalten 0–F und FA sind Steuerleitungen (Bits), und die letzte Spalte gibt die nächste Firmware-Adresse an.

📐 Aufbau einer Firmware-Zeile: AD Mnemonic 0 1 2 3 4 5 6 7 8 9 A B C D E F FA

AD – Firmware-Adresse (hexadezimal)
Mnemonic – Name des Makrobefehls, den dieser Schritt implementiert
0–F, FA – Steuerleitungen (Mikrooperationen). Ein Punkt . = inaktiv, eine Ziffer = aktiv
Letzte Spalte – nächste Firmware-Adresse (Sprung im Mikroprogramm)

🔩 Bedeutung der Steuerleitungen (0–F)

0Bus → AX (AX laden)

1AX → Bus

2Bus → BX (BX laden)

3BX → Bus

4Bus → IP (IP laden)

5IP → Bus

6Bus → OP (Opcode laden)

7ALU: INC (Inkrement)

8Speicher lesen (MR)

9Bus → DR (Operand laden)

ASpeicher schreiben (MW)

BAdressbus ← DR

CBus → MAR (Adressregister)

DALU: DEC / NEG (Dekrement)

EFlag-Test (bedingt)

FEXECUTE (Dispatch)

FANächste Firmware-Adresse

Zeige alle Befehle

Alle

Fetch

MOV

Arithmetik

Sprünge

Stack

Sonstige

—

Opcode	Mnemonic	Kategorie	Steuerleitungen (aktiv)	Info

📄 Vollständige Firmware (Rohformat)

Dies ist der originale Firmware-Quelltext der Datei firmware2_vollstaendig.mpd:

AD Befehl 0 1 2 3 4 5 6 7 8 9 A B C D E F FA 00 MOV OP,[IP] . . . . . 5 . . 8 . . . . . . . 01 01 . . . . . . . . . . . . C . . . 02 02 . . . . . . 6 . . 9 . . . . . . 03 03 INC IP . . . . 4 5 . 7 . . . . . . . . 04 04 MOV DR,[IP] . . . . . 5 . . 8 . . . . . . . 05 05 . . . . . . . . . . . . C . . . 06 06 INC IP . . . . 4 5 . 7 . . . . . . . . 07 07 EXECUTE . . . . . . . . . . . . . . . F 00 10 MOV AX,[nn] . . . . . . . . 8 9 . . . . . . 11 11 . . . . . . . . . . . . C . . . 12 12 MOV AX, nn 0 . . . . . . . . 9 . . . . . . 00 13 MOV AX,[BX] . . . 3 . . . . 8 . . . . . . . 14 14 . . . . . . . . . . . . C . . . 15 15 0 . . . . . . . . 9 . . . . . . 00 19 MOV [nn],AX . . . . . . . . 8 9 . . . . . . 1A 1A . 1 . . . . . . . . A . . . . . 1B 1B . . . . . . . . . . . B . . . . 00 1C MOV [BX],AX . . . 3 . . . . 8 . . . . . . . 1D 22 MOV BX,[nn] . . . . . . . . 8 9 . . . . . . 23 24 MOV BX, nn . . 2 . . . . . . 9 . . . . . . 00 28 MOV AX, BX 0 . . 3 . . . . . . . . . . . . 00 2A MOV BX, AX . 1 2 . . . . . . . . . . . . . 00 2C ADD AX,[nn] . . . . . . . . 8 9 . . . . . . 2D 2E ADD AX, nn 0 1 . . . . . . . 9 . . . . . . 00 2F ADD AX,[BX] . . . 3 . . . . 8 . . . . . . . 30 32 ADD AX, BX . . . 3 . . . . . . A . . . . . 33 34 SUB AX,[nn] . . . . . . . . 8 9 . . . . . . 35 36 SUB AX, nn 0 1 . . . . . . . 9 . . . D . . 00 38 SUB AX,[BX] . . . 3 . . . . 8 . . . . . . . 39 3C SUB AX, BX . . . 3 . . . . . . A . . . . . 3D 3F ADD BX,[nn] . . . . . . . . 8 9 . . . . . . 40 41 ADD BX, nn . . 2 3 . . . . . 9 . . . . . . 00 43 ADD BX, AX . 1 . . . . . . . . A . . . . . 44 45 ADD BX,[AX] . 1 . . . . . . 8 . . . . . . . 46 48 SUB BX,[nn] . . . . . . . . 8 9 . . . . . . 49 4A SUB BX, nn . . 2 3 . . . . . 9 . . . D . . 00 4C SUB BX, AX . 1 . . . . . . . . A . . . . . 4D 4E SUB BX,[AX] . 1 . . . . . . 8 . . . . . . . 4F 51 INC [nn] . . . . . . . . 8 9 . . . . . . 52 56 DEC [nn] . . . . . . . . 8 9 . . . . . . 57 5B INC AX 0 1 . . . . . 7 . . . . . . . . 00 5C INC BX . . 2 3 . . . 7 . . . . . . . . 00 5E DEC AX 0 1 . . . . . 7 . . . . . D . . 00 5F DEC BX . . 2 3 . . . 7 . . . . . D . . 00 61 JMP [nn] . . . . . . . . 8 9 . . . . . . 62 63 JMP nn . . . . 4 . . . . 9 . . . . . . 00 65 JS nn . . . . . . . . . . . . . . E . 66 67 . . . . 4 . . . . 9 . . . . . . 00 68 JNS nn . . . . . . . . . . . . . . E . 69 6B JZ nn . . . . . . . . . . . . . . E . 6C 73 JNZ nn . . . . . . . . . . . . . . E . 74 7C HALT . . . . 4 . 6 . . . . . . . . . 7C 7D JR nn . . . . 4 5 . 7 . . . . . D . . 7E 88 CALL nn . . . . 4 5 . 7 . . . . . D . . 89 90 RET . . 2 3 . . . 7 8 . . . . . . . 91 97 PUSH AX . . . 3 . . . . 8 . . . . . . . 98 9B POP AX . . 2 3 . . . 7 8 . . . . . . . 9C 9E ADDSTACK . . 2 3 . . . 7 8 . . . . . . . 9F A6 SUBSTACK . . 2 3 . . . 7 . . . . . . . . A7 B0 NEGSTACK . . . 3 . . . 7 8 . . . . . . . B1 B4 PUSH nn . . . 3 . . . . 8 . . . . . . . B5 B7 PUSH [nn] . . . . . . . . 8 9 . . . . . . B8 BC POP [nn] . . . 3 . . . . 8 . . . . . . . BD CB SWAPSTACK . . . 3 . . . 7 8 . . . . . . . CC D9 SWAPSTACK,AX . . . 3 . . . . 8 . . . . . . . DA E3 JPZ nn . . . . . . . . . . . . . . E . E4 EA JPNZ nn . . . . . . . . . . . . . . E . EB

Richtig

Gesamt

Fortschritt0 %

Grundprinzipien des Von-Neumann-Rechners

Einfach

Welche Aussagen beschreiben korrekte Grundprinzipien der Von-Neumann-Architektur?

Programme und Daten liegen im selben Arbeitsspeicher Die CPU besitzt getrennte Busse für Befehle und Daten Befehle werden sequentiell ausgeführt Der Rechner kann nur eine fest verdrahtete Aufgabe ausführen Alle Informationen werden binär dargestellt

✅ Richtig: a, c, e

a ✓ Gemeinsamer Speicher: das zentrale Prinzip
b ✗ Harvard-Architektur hat getrennte Busse
c ✓ Sequentielle Abarbeitung
d ✗ Universalrechner durch Programmaustausch
e ✓ Binärdarstellung

Funktion des Instruction Pointer (IP)

Einfach

Was ist die Aufgabe des Instruction Pointer (IP)?

Er speichert das Ergebnis der letzten Rechenoperation Er zeigt auf die Adresse des nächsten auszuführenden Befehls Er gibt an, wie viele Befehle bereits ausgeführt wurden Er enthält den aktuell decodierten Befehlscode

✅ b) ist richtig

Der IP enthält die Adresse des nächsten Befehls. Sprungbefehle verändern IP gezielt.

Fetch-Decode-Execute: Reihenfolge

Einfach

Nummeriere die Schritte des Befehlszyklus von 1 (zuerst) bis 5 (zuletzt):

EXECUTE: Mikrooperationen ausführen

FETCH: Befehl aus Speicher[IP] → OP

DECODE: Steuerwerk interpretiert den Opcode

INC IP: IP wird nach Fetch erhöht

FETCH OPERAND: Operand aus Speicher[IP] → DR; IP++

✅ Reihenfolge:

FETCH
INC IP
FETCH OPERAND
DECODE
EXECUTE

Assembler lesen: Was steht in AX?

Einfach

Führe das Programm gedanklich aus. Was steht nach HALT in AX?

AX =

✅ AX = 13

Befehl	AX
MOV AX, 10	10
SUB AX, 3	7
ADD AX, 7	14
DEC AX	13

Trace-Tabelle: Schleife verfolgen

Mittel

Verfolge das Programm schrittweise und fülle die Trace-Tabelle aus (Summe 1+2+3+4+5):

                        MOV AX, 0 ;
                            Summe
                        MOV BX, 1 ;
                            Zähler
                        loop:
                        ADD AX, BX
                        INC BX
                        MOV [30], BX
                        SUB BX, 6 ; ZF
                            setzen
                        MOV BX, [30]
                        JNZ loop
                        HALT
                    

DL	BX vor ADD	AX nach ADD	BX nach INC	BX−6	ZF	Sprung?
1	1
2
3
4
5

✅ Trace-Tabelle:

DL	BX vor	AX nach	BX INC	BX−6	ZF	Sprung
1	1	1	2	−4	0	Ja
2	2	3	3	−3	0	Ja
3	3	6	4	−2	0	Ja
4	4	10	5	−1	0	Ja
5	5	15	6	0	1	Nein

AX = 15 = 1+2+3+4+5

Adressierungsarten identifizieren

Mittel

Ordne zu. Speicher: [10]=42, [11]=7. BX=10.

Befehl	Adressierungsart	AX danach
`MOV AX, 42`
`MOV AX, [10]`
`MOV AX, [BX]`
`MOV AX, BX`

✅ Lösung:

MOV AX, 42 → Unmittelbar | AX = 42
MOV AX, [10] → Direkt | AX = 42
MOV AX, [BX] → Indirekt (Register) | AX = 42 (BX=10)
MOV AX, BX → Register | AX = 10

Programm schreiben: Minimum zweier Zahlen

Mittel

Finde das Minimum von Speicher[10] und Speicher[11]. Ergebnis → [20]. [10]=7, [11]=3.

💡 Tipp: Berechne AX−BX. Ist das Ergebnis negativ (S-Flag), war AX kleiner.

✅ Musterlösung:

                            MOV AX, [10]
                            MOV BX, [11]
                            MOV [31], AX
                            SUB AX, BX ; 7-3=4, S=0
                            JS ax_kleiner
                            MOV AX, BX ; BX ist kleiner
                            JMP ende
                            ax_kleiner:
                            MOV AX, [31]
                            ende:
                            MOV [20], AX
                            HALT
                        

Von-Neumann-Flaschenhals erklären

Mittel

Erkläre in 3–5 Sätzen den Von-Neumann-Flaschenhals und wie die Harvard-Architektur ihn löst.

✅ Musterlösung:

Da Befehle und Daten denselben Speicher und Bus nutzen, kann die CPU nicht gleichzeitig einen Befehl laden und auf den Datenspeicher zugreifen – beide Zugriffe müssen nacheinander erfolgen. Das begrenzt den Durchsatz. Die Harvard-Architektur löst dies durch getrennte Speicher und Busse für Befehle und Daten, sodass gleichzeitige Zugriffe möglich sind.

Maximum in einem Array finden

Schwer

Finde das größte Element aus [10..14]. [10]=3, [11]=8, [12]=2, [13]=9, [14]=5. Ergebnis → [20].

💡 Algorithmus: AX = aktuelles Maximum, BX = Zeiger. Schleife: vergleiche Speicher[BX] mit AX, aktualisiere ggf.

✅ Musterlösung:

                            MOV AX, [10]
                            MOV BX, 11
                            loop:
                            MOV [30], AX
                            MOV [31], BX
                            MOV AX, [BX]
                            SUB AX, [30] ; Element - Max
                            JNS neues_max
                            MOV AX, [30]
                            JMP weiter
                            neues_max:
                            ADD AX, [30]
                            weiter:
                            MOV BX, [31]
                            INC BX
                            MOV [31], BX
                            SUB BX, 15
                            MOV BX, [31]
                            JNZ loop
                            MOV [20], AX ; = 9
                            HALT
                        

CALL / RET und Stack – Analyse

Schwer

Analysiere das folgende Programm:

                        ; Adr 00:
                        MOV AX, 3
                        CALL quad ; Adr 02+03
                        MOV [20], AX ;
                            Adr 04+05
                        HALT
                        quad: ; Adr 07
                        MOV BX, AX
                        ADD AX, BX
                        ADD AX, BX
                        ADD AX, BX
                        RET
                    

a) Was berechnet quad?

b) Speicher[20] nach HALT =

c) Welche Adresse liegt auf dem Stack nach CALL?

✅ Lösung:

a) 4 × AX: BX=AX, dann AX+BX+BX+BX = 4·AX

b) Speicher[20] = 12 (4×3)

c) Adresse 04 – der Befehl nach CALL. RET liest sie und setzt IP=04.

Multiplikation durch wiederholte Addition

Schwer

Implementiere mult: AX × BX → AX. Hauptprogramm: 4 × 6 = 24.

✅ Musterlösung:

                            MOV AX, 4
                            MOV BX, 6
                            CALL mult
                            MOV [20], AX
                            HALT
                            mult:
                            MOV [31], AX
                            MOV [30], BX
                            MOV AX, 0
                            loop:
                            ADD AX, [31]
                            DEC BX
                            MOV [30], BX
                            SUB BX, 0
                            MOV BX, [30]
                            JNZ loop
                            RET
                        

Firmware-Analyse: Fetch-Zyklus

Schwer

Analysiere die Firmware-Zeilen 00–07 und beantworte die Fragen:

                        00 MOV OP,[IP]
                        03 INC IP
                        04 MOV DR,[IP]
                        06 INC IP
                        07 EXECUTE
                    

a) Was passiert bei Befehlen ohne Operanden (z. B. HALT)?

b) Verfolge den IP für MOV AX, 7 → HALT (Speicher: [00]=12, [01]=07, [02]=7C, [03]=00):

Start

→

nach FETCH OP

→

nach FETCH DR

→

2. FETCH OP

→

2. FETCH DR

→

HALT

✅ Lösung:

a) Der Fetch-Zyklus ist für alle Befehle identisch. Bei 1-Byte-Befehlen wie HALT wird der folgende Speicherinhalt als Operand in DR geladen, aber bei der Ausführung ignoriert. IP erhöht sich trotzdem korrekt.

b) 00 → 01 → 02 → 03 → 04 → HALT bei 04