Arduino UNO Breadboard-Computer-Programmer – Bauen & Programmieren Ihres 8-Bit-Systems

Komponenten und Zubehör

Arduino UNO

×

1

Über dieses Projekt

Was ist dieses Projekt?

Dieses Projekt ist eine Erweiterung von Ben Eaters 8-Bit-Breadboard-Computer. Ich habe seine Videos zum Bau eines Breadboard-Computers begeistert verfolgt und meine eigene Version gebaut. Falls du Ben's Serie noch nicht kennst, empfehle ich dringend, seine Videos anzusehen – ohne diesen Kontext wird dieses Projekt schwer verständlich sein.

Nach dem Bau wurde schnell klar, dass das manuelle Eintasten von Programmen über DIP-Schalter bei jedem Neustart unpraktisch ist. Selbst 16 Bytes wiederholt einzugeben, wird schnell mühsam. Zudem plante ich, den Speicher auf 256 Bytes zu erweitern, was nur sinnvoll ist, wenn Programme geladen und gespeichert werden können.

Was kann ich damit machen?

• Ein Programm aus dem RAM des Breadboard-Computers speichern
• Ein Programm in den RAM des Breadboard-Computers laden
• Ein gespeichertes Programm beim Start automatisch ausführen
• Speicherinhalte über eine serielle Verbindung inspizieren und verändern
• Den Breadboard-Computer in Assemblersprache programmieren
• Speicherinhalte disassemblieren
• Schrittweise Einzelschritt-Ausführung (Single-Stepping)
• Breakpoints setzen und bis zum Breakpoint laufen lassen

Ein Video demonstriert diese Funktionen (bitte die Videoqualität entschuldigen – ich bin kein professioneller Videoproduzent).

Wie funktioniert es?

Meine Ziele waren:

• So wenig Hardware wie nötig
• So wenige Änderungen am Breadboard-Computer wie möglich

Zunächst dachte ich an ein EEPROM zum Speichern von Programmen und Logik zum Transfer in den RAM. Die Transferlogik erwies sich jedoch als zu komplex. Da ich Arduino-Fan bin, kam ich auf die Idee, die Transferlogik durch einen Arduino zu ersetzen. Zwar ist der Arduino UNO leistungsfähiger als der Breadboard-Computer selbst, aber das Ergebnis überzeugt mich.

Der Arduino muss Daten aus dem Speicher lesen und hineinschreiben können. Der einfachste, wenig invasive Weg ist die Nutzung der vorhandenen Bus- und Steuersignale des Speichermoduls. Die digitalen I/O-Pins des Arduino sind bidirektional; 8 davon direkt an den Bus angeschlossen ermöglichen Lesen und Schreiben. Um das RAM-Modul zum Lesen/Schreiben zu bringen, müssen die Signale MI/RI/RO entsprechend gesetzt werden. Normalerweise werden diese von den Steuerlogik-EEPROMs getrieben. Würde der Arduino sie auch steuern, entstünden Konflikte. Die AT28C16 EEPROMs haben jedoch einen Chip-Enable-Eingang (CE), der alle Datenausgänge in High-Z versetzt – so kann der Arduino die Signale übernehmen.

Um den RAM auszulesen, führt der Arduino folgende Schritte aus:

1. EEPROM-CE-Signal auf High setzen (Steuerlogik deaktivieren)
2. Erste zu lesende Adresse auf den Bus legen
3. MI-Signal auf High setzen und auf Clock Low-High-Transition warten
4. MI auf Low, RO auf High setzen und auf Clock Low-High-Transition warten
5. Datenbyte vom Bus lesen
6. Schritte 2–5 für alle 16 Adressen wiederholen
7. EEPROM-CE-Signal auf Low setzen (Steuerlogik wieder aktivieren)

Das Schreiben funktioniert analog: Daten auf den Bus legen und RI statt RO setzen. Einige technische Details sind zu beachten, aber der Kernmechanismus ist wie beschrieben.

Welche Änderungen am Breadboard-Computer sind nötig?

Zwei Änderungen sind erforderlich:

• Pull-Down-Widerstände an den Datenausgängen der Steuerlogik-EEPROMs
• Ringzähler während der EEPROM-Deaktivierung zurücksetzen (oder kontinuierlich resetten)

Pull-Down-Widerstände

Sobald das EEPROM deaktiviert ist, ziehen die Pull-Up-Widerstände der angeschlossenen Logikgatter (z. B. AO, AI, EO…) die Steuersignale auf High. Das würde dazu führen, dass mehrere Register gleichzeitig auf den Bus schreiben – Konflikte entstehen. Die Pull-Ups an 74LS-Eingängen sind ca. 10 kΩ. Die Pull-Downs müssen klein genug sein, um die Spannung in den Low-Bereich zu ziehen. Für die meisten Signale verwendete ich 3,3 kΩ. Zwei Ausnahmen:

• Das Signal „SU“ (Subtrahieren) ist an 8 XOR-Gatter angeschlossen → effektiver Pull-Up ≈ 1,25 kΩ. Ein Pull-Down müsste < 1 kΩ sein. Da SU keine Bus-Interaktion steuert, kann man darauf verzichten.
• CE (Counter Enable) benötigte einen 1 kΩ Pull-Down – größere Werte verursachten zufälliges Programmzähler-Verhalten.

Am einfachsten lassen sich die Pull-Downs auf dem Breadboard mit den blauen LEDs anbringen (zwischen LED-Anoden/EEPROM-Ausgängen und GND). Für HLT/MI/RI passten die Widerstände nicht dorthin; ich platzierte sie an anderen Stellen.

Ringzähler-Reset

Dies ist nicht zwingend für Speichern/Laden, ermöglicht aber eine saubere Übergabe der Kontrolle vom Arduino zurück an die Steuerlogik. Ziel: Ringzähler bei 0 halten, solange CE High ist (Steuerlogik deaktiviert). Wenn der Arduino CE wieder auf Low schaltet, startet der Breadboard-Computer mit dem nächsten Befehl.

In meinem Aufbau nutze ich einen EEPROM-Ausgang zum Reset des Ringzählers. Das verbessert die Performance (Reset sofort nach Instruktion) und gibt automatisch den Reset beim Deaktivieren des EEPROMs (Pull-Down zieht Signal auf Low).

Falls du Bens festen 5-Schritt-Ringzähler nutzt, sollte folgende Erweiterung seines Reset-Schaltkreises funktionieren (3 zusätzliche NAND-Gatter = ein weiteres 74LS00). Ich habe dies nicht getestet, aber es sollte funktionieren. Diese Modifikation ist optional – ohne sie funktionieren Laden/Speichern, Monitor, Assembler, Disassembler. Aber Aktionen, die Kontrolle an die Steuerlogik übergeben (Auto-Start, Single-Stepping, Debugger-Run), gehen nicht.

Wie richte ich den Arduino ein?

Lade den Sketch aus dem Git-Archiv hoch und verbinde den Arduino wie folgt:

• Arduino 5V-Pin (nicht Vin!) → 5V-Schiene am Breadboard
• Arduino GND → GND am Breadboard
• Arduino Digitalpins 2–9 → Bus 0–7
• Arduino Digitalpin 10 → Steuerlogik-EEPROM-Ausgang für RO
• Arduino Digitalpin 11 → Steuerlogik-EEPROM-Ausgang für RI
• Arduino Digitalpin 12 → Steuerlogik-EEPROM-Ausgang für MI
• Arduino Analogpin 0 → CLOCK-Signal
• Arduino Analogpin 3 → CE (Pin 18) aller Steuerlogik-EEPROMs und über 10 kΩ-Widerstand an +5V

Zusätzlich müssen Analogpin 1 und 2 an DIP-Schalter und Taster gemäß Schaltplan angeschlossen werden (Details in der Fritzing-Datei).

Minimale, funktionsfähige Version:

• 3,3 kΩ Pull-Downs an EEPROM-Ausgängen für AO, CO, EO, IO, RO
• Ringzähler-Reset weglassen
• Verdrahtung wie oben (10 kΩ-Widerstand an Analogpin 3 optional)
• Analogpin 1 und 2 auf GND legen

Für Load/Save-Buttons: Buttons, DIP-Schalter und Widerstände gemäß Schaltplan an Analogpin 1/2 anschließen.

Für Autostart: Arduino muss Programmzähler und Ringzähler während Reset und Transfer auf 0 halten. Der Pull-Up an Analogpin 3 hält Steuerlogik deaktiviert (PC=0) während Arduino-Reset. Ringzähler-Reset wie oben beschrieben.

Wie lade und speichere ich Programme?

Die Minimalausstattung ermöglicht Steuerung über die serielle Schnittstelle. Benötigt: Terminalprogramm (Putty, TeraTerm) – 9600 Baud, 8N1. Arduino Serial Monitor funktioniert, ist aber umständlich.

1. Breadboard-Computer einschalten
2. PC per USB mit Arduino verbinden
3. Terminal starten, 9600 8N1 einstellen
4. ESC drücken → Monitor-Modus (Prompt „.“)
5. „h“ + Enter → Befehlsliste

Mit Minimal-Setup sind Befehle „m“, „M“, „C“, „l“, „s“ nutzbar (Speicher anzeigen/ändern, laden/speichern).

Per Button speichern/laden:

1. Takt des Breadboard-Computers stoppen
2. DIP-Schalter auf Dateinummer einstellen
3. „Save“- oder „Load“-Button drücken → CE-LED leuchtet (Arduino hat Kontrolle)
4. Takt wieder einschalten → Adressregister-LEDs laufen durch
5. Warten bis Bus-LEDs aufhören zu blinken und Adressregister 1111 anzeigt
6. Takt ausschalten → CE-LED erlischt (Kontrolle zurück an Steuerlogik)

Autostart: DIP-Schalter auf Programmnummer stellen und Computer einschalten (oder Reset drücken). Spezialfälle: Alle DIPs aus → normaler Start. Alle DIPs an → direkt in Monitor-Modus starten.

Wie nutze ich Assembler und Disassembler?

Dafür muss der Arduino-Sketch an dein Setup angepasst werden. Finde die Struktur opcodes_4bit im Quellcode:

struct opcodes_struct opcodes_4bit [] = {
  {"NOP ", B00000000, 0, false},
  {"LDA ", B00010000, 2, true},
  ...
  {".OR ", B11111110, 0, true}, // Startadresse setzen
  {".BY ", B11111111, 0, true}, // Ein Datenbyte definieren
  {NULL, 0, 0, false}
};

Jede Zeile definiert einen Opcode:

• Feld 1: Mnemonik (z. B. „LDA“). Für Immediate-Adressierung „#“ in der Mnemonik (Bens „LDI“ = „LDA #“).
• Feld 2: Opcode selbst (untere 4 Bits immer 0, außer .OR/.BY).
• Feld 3: Anzahl Zyklen zusätzlich zum Fetch-Zyklus (z. B. LDA: 2 → gesamt 4 Zyklen). Bei Bens 5-Zyklus-Design immer 3.
• Feld 4: Ob ein Argument nötig ist (LDA ja, OUT nein).

Passe die Liste an deine Opcodes an. Die letzten zwei Zeilen (.OR, .BY) für den Assembler unverändert lassen. Sketch hochladen, Terminal verbinden, Monitor-Modus (ESC oder alle DIPs an). Disassemblieren: „d“ ab Adresse 0. Assembler: „a“ ab Adresse 0.

Assembler-Konventionen:

• Zeile ohne führenden Whitespace → Labeldefinition (alphabetisch, max 3 Zeichen, case-sensitive).
• Nach erstem Whitespace: Mnemonik (LDA, STA, OUT…).
• Spezial: „.BY“ = Datenbyte, „.OR“ = neue Adresse.
• Argument beginnt mit Buchstabe → Label.
• Zahlen = dezimal; Hex mit „$“ (z. B. „LDA #$FF“).
• Alles nach „;“ = Kommentar.

Beispiel Fibonacci-Code:

rst LDA #0 ; x = 0
STA x
LDA #1 ; y = 1
STA y
lp  ADD x ; z = y + x
STA z
JC rst ; restart if overflow
OUT ; print z
LDA y ; x = y
STA x
LDA z ; y = z
STA y
JMP lp ; loop
x .BY 0
y .BY 0
z .BY 0

Einschränkungen

Um RAM auf dem Arduino zu sparen, arbeitet der Assembler als 1-Pass-Assembler (sonst müsste er gesamten Quellcode puffern). Er schreibt Opcodes direkt in den Breadboard-Speicher während der Eingabe. Das verlangsamt das Assemblieren durch die Taktgeschwindigkeit des Breadboard-Computers. Copy-Paste in das Terminal kann zu Zeichenverlust führen (Arduino kommt bei 9600 Baud nicht hinterher, da er auf Breadboard-Clock wartet). Abhilfe: Baudrate reduzieren, TeraTerm mit Zeichenverzögerung nutzen, oder Breadboard-Takt erhöhen. Mein Takt geht bis 160 kHz – damit klappt Copy-Paste bei 9600 Baud.

Standardmäßig verträgt der Sketch Breadboard-Takte bis ~1–2 kHz (Bens Standard: 500 Hz). Für höhere Takte: #ifdef FAST_IO im Code aktivieren → bis 250 kHz (getestet 160 kHz). Höhere Geschwindigkeiten wären nur mit Assembler-Optimierung möglich, aber 160 kHz fühlt sich auf dem Breadboard schon sehr schnell an. Vor Aktivierung Code-Kommentare lesen!

Der Arduino hat 1 kB EEPROM → 1024/16 = 64 Programme (eigentlich 63, 16 Bytes für Konfiguration reserviert). Nur Programme 0–15 per DIP-Schalter wählbar (1–14 für Autostart), aber Befehle „s“/„l“ funktionieren mit 0–62.

Sieht etwas unordentlich aus – kann man das aufräumen?

Ja! In meiner finalen Version nutze ich den nackten Atmega328P (mit 16 MHz Quarz/Kondensatoren) statt Arduino UNO. Der Spannungsregler entfällt, da der Arduino direkt die 5V der Versorgung nutzt. Einziger Nachteil: separater USB-Seriell-Wandler (FTDI) nötig. Das passt optisch besser zum Breadboard-Computer.

Eine weitere Optimierung: Bootloader entfernen → keine 2-Sekunden-Verzögerung beim Start. Anleitung folgt bei Interesse – Kommentar hinterlassen!

Code

Breadboard-Computer-Programmer

Arduino-Sketch: https://github.com/dhansel/programmer

Schaltpläne

drive_pD8k28E85v.fzz