8080 CPU Simulator – Übersicht

Der 8080 CPU Simulator ist ein interaktives Lern- und Entwicklungswerkzeug, das die Intel 8080-CPU aus den 1970er-Jahren vollständig im Browser emuliert. Er dient dem Verständnis von Mikroprozessorarchitekturen, Assembler-Programmierung und Speicherorganisation.

👉 Starte den Simulator hier: https://www.seolizer.de/asm/

Der 8080 CPU Simulator bildet den kompletten Intel 8080-Mikroprozessor in moderner, browserbasierter Form nach. Er vereint Assembler, Emulator und Lernwerkzeug in einer einzigen Oberfläche – ohne Installation, direkt im Browser nutzbar. Alle Komponenten (CPU, Speicher, Register, Flags, Anzeige) arbeiten live zusammen und sind in Echtzeit beobachtbar.

Insgesamt bietet der Simulator eine vollständige, interaktive Lernumgebung, die zeigt, wie eine CPU intern arbeitet – vom Fetch-Cycle über Registertransfers bis zur Anzeige im Video-RAM. Er eignet sich ideal für Unterricht, Ausbildung und Selbststudium im Bereich Mikroprozessoren, Informatik und Assembler-Programmierung.

Der 8080 CPU Simulator besteht aus einer Reihe klar voneinander getrennter Dateien. Jede erfüllt eine bestimmte Aufgabe – von der grafischen Oberfläche bis zur eigentlichen CPU-Logik. Diese Struktur macht den Simulator leicht verständlich, erweiterbar und ideal für Unterrichtszwecke.

Die Komponenten sind modular aufgebaut und greifen wie in einem echten Computersystem ineinander. Die folgende Darstellung zeigt, wie HTML, JavaScript und BIOS-Code im Simulator zusammenwirken.

+----------------------------+
|        index.html          |  <- Benutzeroberfläche (Layout, Panels, Editor)
+-------------+--------------+
              |
              | lädt
              v
+-------------+--------------+
|             main.js        |  <- Zentrale Steuerung (UI ↔ CPU ↔ Assembler)
+-------------+--------------+
        |             |             |
        |             |             |
        v             v             v
+-----------+   +-----------+   +-----------+
|  cpu.js   |   |assembler.js|  |  bios.js  |
| (CPU-Kern)|   | (Assembler)|  | (ROM-Code)|
+-----------+   +-----------+   +-----------+

* main.js fungiert als Zentrale:

– Initialisiert den CPU-Kern  
– Übergibt den übersetzten Code des Assemblers  
– Aktualisiert die Anzeigen (Register, Speicher, VRAM) bei jedem Schritt  

* cpu.js ist der eigentliche Prozessor. Jede Instruktion wird dort wie in der Hardware ausgeführt. * assembler.js ermöglicht es, eigenen 8080-Assemblercode direkt im Browser zu schreiben und zu testen. * bios.js dient als Startprogramm – damit ist das System sofort lauffähig, auch ohne eigenen Code. * index.html und styles.css bilden die sichtbare Oberfläche – das „Cockpit“ des Simulators.

Damit ist das gesamte Projekt klar strukturiert und leicht erweiterbar. Neue Komponenten (z. B. Diskettencontroller, I/O-Schnittstellen oder Debugger-Funktionen) können als eigenständige Module eingebunden werden, ohne den Kern des Systems zu verändern.

Der 8080 CPU Simulator bildet – wie der originale Intel 8080 – einen durchgehenden 16-Bit-Adressraum ab, der von 0000h bis FFFFh reicht. Damit stehen insgesamt 64 KB Arbeitsspeicher zur Verfügung, die in drei Hauptbereiche aufgeteilt sind:

• RAM für Programme, Daten und Stack
• VRAM für die Bildschirmausgabe (Textmodus)
• BIOS-ROM für den Startcode

Diese Aufteilung ist festgelegt und wird beim Start des Simulators automatisch initialisiert.

+-----------------------------------------------------------+  FFFFh
|                       BIOS-ROM (4 KB)                     |  ←  F000h
|                "8080 BIOS READY" – Startprogramm           |
+-----------------------------------------------------------+  E7FFh
|                    Video-RAM (2 KB)                       |  ←  E000h
|             Textdarstellung 80×25 Zeichen                 |
+-----------------------------------------------------------+  DFFFh
|                                                           |
|                       RAM (56 KB)                         |
|       Programme · Daten · Stack (wächst nach unten)       |
|                                                           |
+-----------------------------------------------------------+  0000h

Die CPU kann auf den gesamten Speicher byteweise direkt zugreifen. Adressierungen erfolgen meist über das Registerpaar HL, das als Zeiger auf Speicherstellen dient.

Beispiele:

```asm
LXI H,2000h    ; HL zeigt auf Speicheradresse 2000h
MOV M,A        ; schreibt den Inhalt von A in [2000h]

LXI H,E000h    ; HL zeigt auf Beginn des Video-RAM
MVI A,'H'
MOV M,A        ; schreibt 'H' ins Display

→ Detaillierte Registerbeschreibung anzeigen

Die Register bilden das Herzstück der CPU – sie sind die internen Speicherzellen, in denen Daten, Adressen und Zwischenergebnisse verarbeitet werden. Beim Intel 8080 stehen insgesamt 7 Hauptregister und ein Flag-Register zur Verfügung. Während die Register Werte direkt speichern, zeigen die Flags an, welchen Zustand eine Rechenoperation hinterlässt (z. B. „Ergebnis = 0“ oder „Übertrag aufgetreten“).

Die Register werden in zwei Hauptgruppen unterteilt:

• Allgemeine Register (A, B, C, D, E, H, L) – für Datenoperationen, Berechnungen und Adressierung.
• Spezialregister (SP, PC, F) – für Stack, Programmsteuerung und Statusverwaltung.

Zusammen wirken diese Elemente wie das Kurzzeitgedächtnis der CPU: Jede Instruktion liest, verändert oder prüft mindestens eines dieser Register. Im Online-Simulator lassen sich ihre Werte in Echtzeit beobachten – ideal zum Verstehen der internen Abläufe.

Die Benutzeroberfläche des 8080 CPU Simulators ist bewusst übersichtlich gestaltet, um den Lernprozess zu unterstützen. Sie zeigt Code, CPU-Zustand, Speicher und Displayausgabe gleichzeitig an – alle Bereiche sind live miteinander verknüpft. Jede Änderung im Speicher oder Register ist sofort sichtbar, sobald ein Befehl ausgeführt wird.

Die Oberfläche besteht aus drei Hauptbereichen:

• Links: Assembler-Editor, Steuerleiste und Log-Ausgabe
• Mitte: Register, Flags und Speicher-Dumps
• Rechts: Virtuelles Display (VRAM) mit Textausgabe, VRAM-Dump und Eingabekonsole

Die mittlere Spalte zeigt alle wichtigen Register (A, B, C, D, E, H, L, SP, PC) sowie die fünf Status-Flags (S, Z, AC, P, CY). Die Werte werden nach jeder Instruktion automatisch aktualisiert. So lässt sich nachvollziehen, welche Auswirkungen jede einzelne Operation auf den internen Zustand der CPU hat.

Das VRAM-Display ist das simulierte Ausgabegerät des Prozessors – vergleichbar mit einem Textmonitor (80×25 Zeichen). Schreibt ein Programm in den Speicher ab 0xE000, erscheinen die Bytes automatisch als Textzeichen auf dem Bildschirm. So lassen sich einfache Texte, Laufbänder oder Menüs darstellen – ganz ohne moderne Grafikroutinen.

Beispiel:

```asm
LXI H,E000h
MVI A,'H'
MOV M,A
INX H
MVI A,'I'
MOV M,A
HLT

Beim Start des Simulators wird automatisch ein kleines BIOS-ROM in den Speicherbereich F000h–FFFFh geladen. Dieses BIOS dient als einfache Startsequenz – vergleichbar mit einem Boot-ROM in echten Rechnern – und demonstriert, dass die CPU korrekt arbeitet, Speicherzugriffe funktionieren und der Video-RAM (VRAM) aktiv ist.

Das BIOS führt nur wenige Instruktionen aus: Es initialisiert den Stackpointer, zeigt eine Textmeldung auf dem virtuellen Display an und stoppt dann mit `HLT`.

LXI SP, FFFFh     ; Stackpointer auf oberes Ende des RAM setzen
LXI H, E000h      ; HL zeigt auf Beginn des Video-RAM
MVI A,'8'         ; ASCII-Zeichen '8' laden
MOV M,A           ; Zeichen in VRAM schreiben
INX H             ; VRAM-Zeiger erhöhen
MVI A,'0'         ; '0'
MOV M,A
INX H
MVI A,'8'         ; '8'
MOV M,A
INX H
MVI A,'0'         ; '0'
MOV M,A
INX H
MVI A,' '         ; Leerzeichen
MOV M,A
INX H
MVI A,'B'         ; Beginn von "BIOS READY"
MOV M,A
INX H
MVI A,'I'
MOV M,A
INX H
MVI A,'O'
MOV M,A
INX H
MVI A,'S'
MOV M,A
INX H
MVI A,' '
MOV M,A
INX H
MVI A,'R'
MOV M,A
INX H
MVI A,'E'
MOV M,A
INX H
MVI A,'A'
MOV M,A
INX H
MVI A,'D'
MOV M,A
INX H
MVI A,'Y'
MOV M,A
HLT               ; CPU anhalten

Beim Start erscheint im VRAM-Display die Meldung:

8080 BIOS READY

Damit zeigt der Simulator, dass:

• der Video-RAM korrekt mit Adresse E000h eingebunden ist,
• der Instruktionsfluss (PC, HL, SP) funktioniert,
• und die CPU-Basisoperationen (LXI, MOV, INX, MVI, HLT) erfolgreich ausgeführt werden.

Das BIOS ist im Simulator fest integriert und wird bei jedem Reset automatisch erneut geladen. So steht immer ein funktionierendes Minimalprogramm bereit, das den Grundzustand des Systems überprüft.