====== 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/|https://www.seolizer.de/asm/]] ===== Hauptfunktionen ===== Der [[https://www.seolizer.de/asm/|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. ^ Funktion ^ Beschreibung ^ | **Vollständige Emulation des [[8080_cpu-emulator_simulator_fuer_lehre_und_unterricht:befehlssatzes|Intel 8080-Befehlssatzes]]** | Der Simulator unterstützt sämtliche offiziellen 8080-Instruktionen – von MOV, MVI und LXI über arithmetische und logische Operationen bis hin zu Sprüngen, CALL/RET und Stackbefehlen. Auch bedingte Varianten (z. B. JZ, JC, RNZ, CNZ) und Rotationen (RLC, RRC, RAL, RAR) sind enthalten. | | **64 KB RAM (0000h – FFFFh)** | Der vollständige 16-Bit-Adressraum des 8080 wird simuliert. Speicherzugriffe sind bytegenau nachvollziehbar. Stack-Operationen (PUSH/POP, CALL/RET) verhalten sich wie im Originalprozessor. | | **Video-RAM (VRAM) ab E000h → Textdisplay 80×25 Zeichen** | Der Bereich E000h–E7FFh ist als Video-RAM reserviert. Jeder Byte-Wert entspricht einem ASCII-Zeichen, das direkt im Bildschirmfenster erscheint. Dadurch lassen sich Texte, Statusanzeigen oder Menüs allein mit Assemblerbefehlen darstellen. | | **Assembler, Step-/Run-Modus, Register- & Flag-Anzeige in Echtzeit** | Der integrierte Zwei-Pass-Assembler übersetzt 8080-Code direkt im Browser. Programme können schrittweise (Step) oder automatisch (Run) ausgeführt werden. Alle Register (A–L, SP, PC) und Flags (S, Z, AC, P, CY) werden live aktualisiert, sodass der gesamte Maschinenzustand jederzeit sichtbar ist. | | **Integriertes BIOS-ROM (F000h – FFFFh)** | Ein kleines BIOS initialisiert den Stack, schreibt beim Start die Meldung *„8080 BIOS READY“* in den VRAM und beendet sich mit HLT. Es demonstriert das korrekte Zusammenspiel von CPU, Speicher und Anzeige und wird bei jedem Reset automatisch geladen. | | **Ausführung von Original-8080-Maschinencode im Browser** | Der Simulator verarbeitet echten 8080-Bytecode – kein Pseudocode, sondern voll kompatible Maschinensprache. Dadurch können historische Beispiele, Lehrprogramme oder eigens geschriebene Assemblerprogramme 1:1 getestet werden. | ---- 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**. ===== Dateistruktur ===== Der [[https://www.seolizer.de/asm/|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. ^ Datei ^ Aufgabe ^ Beschreibung ^ | **index.html** | Benutzeroberfläche & Layout | Enthält die komplette HTML-Struktur des Simulators – Editor, Registeranzeige, Speicher-Dumps, VRAM-Display und Dokumentation. Die Datei bildet das Grundgerüst der Anwendung und bindet alle übrigen Module ein. | | **styles.css** | Design & Darstellung | Definiert das visuelle Erscheinungsbild. Das dunkle Farbthema orientiert sich an klassischen Terminal-Oberflächen. Enthält u. a. VRAM-Farben, Schriften, Abstände, Grid-Layout und Schatteneffekte für Panels. | | **main.js** | Steuermodul (Controller) | Verbindet alle Systemkomponenten: CPU, Assembler, Speicher und Oberfläche. Hier werden z. B. die Eingaben aus dem Editor verarbeitet, das BIOS geladen, die Anzeige aktualisiert und die Step-/Run-Steuerung umgesetzt. | | **cpu.js** | CPU-Kern (Emulation) | Enthält die komplette Simulation der **Intel 8080-CPU**. Implementiert alle Register (A–L, SP, PC), Flags (S, Z, AC, P, CY), den ALU-Bereich, Stack-Mechanismen und sämtliche 8080-Operationen (MOV, ADD, JMP, CALL u. v. m.). | | **assembler.js** | Zwei-Pass-Assembler | Übersetzt den im Editor eingegebenen Quellcode in echten 8080-Maschinencode. Unterstützt Labels, Sprungziele, numerische Werte (dezimal, hexadezimal) und Direktiven wie `ORG` und `DB`. Gibt Listing und Bytecode zurück. | | **bios.js** | Mini-BIOS-ROM (F000h–FFFFh) | Enthält ein fest codiertes Startprogramm mit der Ausgabe *„8080 BIOS READY“* auf dem virtuellen Display. Dient als Funktionsnachweis für Stack, Register und VRAM. Wird beim Start oder Reset automatisch geladen. | ---- ===== Zusammenspiel der Module ===== 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. ===== Speicherorganisation ===== Der [[https://www.seolizer.de/asm/|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. ^ Bereich ^ Adresse (hex) ^ Größe ^ Beschreibung ^ | **RAM** | 0000h – DFFFh | ≈ 56 KB | Hauptspeicher für Programmcode, Daten und Stack. Alle Lade-, Rechen- und Sprungoperationen greifen hier auf den Speicher zu. Der Stack wächst abwärts – beginnend am oberen Ende des RAM. | | **VRAM** | E000h – E7FFh | 2 KB | Video-RAM (Display-Speicher). Jedes Byte entspricht einem ASCII-Zeichen im 80 × 25-Textfenster. Schreiboperationen auf Adressen ≥ E000h erscheinen direkt im **VRAM-Display** des Simulators. | | **BIOS** | F000h – FFFFh | 4 KB | Fest eingebettetes ROM-Segment mit dem Startcode des Simulators. Das BIOS zeigt beim Start die Meldung *„8080 BIOS READY“* im VRAM und dient als Funktionstest für CPU und Speicher. | ---- ===== Speicherarchitektur im Überblick ===== +-----------------------------------------------------------+ 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 ---- ===== Zugriff durch die CPU ===== 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 ===== Register & Flags ===== [[8080_cpu-emulator_simulator_fuer_lehre_und_unterricht:register_flags|→ 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. ^ Register ^ Beschreibung ^ | **A (Akkumulator)** | Hauptregister für arithmetische und logische Operationen. Fast jede Rechenoperation verwendet A automatisch. | | **B, C – D, E – H, L** | Allgemeine 8-Bit-Register, die paarweise als 16-Bit-Register (BC, DE, HL) genutzt werden können. HL dient oft als Speicherzeiger. | | **SP (Stack Pointer)** | 16-Bit-Zeiger auf die oberste Position des Stacks im RAM. Der Stack wächst abwärts (Richtung kleinerer Adressen). | | **PC (Program Counter)** | 16-Bit-Zeiger auf die nächste auszuführende Instruktion im Speicher. Wird automatisch bei jedem Befehl erhöht oder durch Sprünge verändert. | | **F (Flag-Register)** | 8-Bit-Register, das den Zustand des letzten Rechenergebnisses beschreibt (z. B. Null, Übertrag, Vorzeichen). | ^ Flag ^ Bedeutung ^ | **S (Sign)** | = 1, wenn das Ergebnis negativ ist (Bit 7 = 1) | | **Z (Zero)** | = 1, wenn das Ergebnis 0 ist | | **AC (Auxiliary Carry)** | Übertrag von Bit 3 auf Bit 4 – relevant für BCD-Operationen | | **P (Parity)** | = 1, wenn das Ergebnis eine gerade Anzahl 1-Bits enthält | | **CY (Carry)** | = 1, wenn ein Übertrag oder Borrow beim Rechnen auftritt | Zusammen wirken diese Elemente wie das **Kurzzeitgedächtnis der CPU**: Jede Instruktion liest, verändert oder prüft mindestens eines dieser Register. Im [[https://www.seolizer.de/asm/|Online-Simulator]] lassen sich ihre Werte in Echtzeit beobachten – ideal zum Verstehen der internen Abläufe. ===== Benutzeroberfläche ===== Die Benutzeroberfläche des [[https://www.seolizer.de/asm/|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 ---- ===== Steuerleiste & Editor ===== ^ Element ^ Beschreibung ^ | **Editor** | Hier wird der 8080-Assemblercode eingegeben. Unterstützt alle Befehle des Intel 8080 inklusive Labels, Daten und Direktiven (`ORG`, `DB`, …). | | **Assemble** | Übersetzt den eingegebenen Code in Maschinensprache. Das Ergebnis (Bytes, Adressen, Labels) wird im Log ausgegeben. | | **Load** | Lädt das assemblierte Programm ab Adresse **0000h** in den Arbeitsspeicher (RAM). | | **Step** | Führt **eine einzelne Instruktion** aus – ideal zum schrittweisen Nachvollziehen des CPU-Verhaltens. | | **Run** | Startet die CPU im kontinuierlichen Laufmodus. Alle Instruktionen werden automatisch ausgeführt, bis **HLT** erreicht ist. | | **Reset** | Setzt CPU, Register und Speicher auf Anfangszustand zurück. Das BIOS wird erneut gestartet. | | **Throttle** | Legt fest, wie schnell die CPU im Run-Modus taktet (Schritte pro Sekunde). | | **Assemble Log** | Zeigt Statusmeldungen und Fehlermeldungen aus dem Assembler an. | ---- ==== Register- und Flag-Anzeige ==== 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. ---- ==== Speicher- und VRAM-Dumps ==== ^ Bereich ^ Beschreibung ^ | **Speicher-Dump (Mem @)** | Zeigt beliebige Speicherbereiche in Hex- und ASCII-Darstellung. Startadresse, Zeilen und Bytes pro Zeile sind anpassbar. | | **VRAM-Dump (VRAM @)** | Zeigt den Bereich des Video-RAMs (ab E000h), der für Textausgabe verwendet wird. Hier kann nachvollzogen werden, welche Zeichen auf dem Display erscheinen. | | **Refresh-Buttons** | Aktualisieren die Anzeigen manuell – praktisch bei längeren Laufzeiten oder nach manuellen Änderungen. | ---- ==== Virtuelles Display (VRAM) ==== 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 ===== Beispiel: BIOS-Startcode ===== 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.