Logikgatter und HACK-Computer: Ein praxisnaher Leitfaden für COMP1027 Coursework 1

Einführung in die Welt der Logikgatter und des HACK-Computers

Willkommen zu diesem Tutorial, das dich Schritt für Schritt durch die zentralen Konzepte des COMP1027 Coursework 1 führt. In diesem Kursbaustein geht es um den Aufbau digitaler Schaltungen – von einfachen Logikgattern bis hin zum vollständigen HACK-Computer. Du wirst nicht nur die Theorie verstehen, sondern auch praktische HDL- und Assembler-Codes schreiben. Die Aufgaben sind als Mini-Gruppenarbeit konzipiert, sodass du gemeinsam mit Kommilitonen effizient lernen kannst. Stell dir vor, du entwickelst die Steuerung für eine smarte Kaffeemaschine, die auf verschiedene Tageszeiten reagiert – genau solche Problemstellungen lösen wir hier.

Teil 1: Elementare Logikgatter – Tessas Café-Projekt

Im ersten Teil des Courseworks modellieren wir eine Entscheidungslogik für Tessas Café-Eröffnung. Tessa möchte 2025 ihr eigenes Café eröffnen und benötigt dafür einen Standort, Möbel, Personal und eine Speisekarte. Sie ist zufrieden, wenn mindestens zwei der vier Bedingungen erfüllt sind – darunter zwingend Standort und entweder Möbel oder Speisekarte. Dieses Szenario lässt sich perfekt mit Logikgattern abbilden.

Wahrheitstabelle und boolesche Algebra

Zunächst erstellst du eine Wahrheitstabelle für die vier Eingangsvariablen (Standort, Möbel, Personal, Speisekarte). Die Ausgabe ist 1, wenn Tessas Bedingungen erfüllt sind. Anschließend notierst du den vorvereinfachten booleschen Ausdruck und vereinfachst ihn mithilfe der grundlegenden Identitäten der booleschen Algebra (z. B. Absorptionsgesetz, Distributivgesetz). Die vereinfachte Funktion implementierst du dann als HDL-Chip „Tessa.hdl“. Dabei verwendest du ausschließlich 1-Bit-Eingänge.

// Beispiel: Vereinfachter Ausdruck (nicht vollständig)
CHIP Tessa {
    IN standort, moebel, personal, speisekarte;
    OUT entscheidung;
    PARTS:
    // Hier deine Logikgatter
}

Teil 2: Kombinatorische und sequenzielle Schaltungen – MyALU

Im zweiten Teil baust du eine arithmetisch-logische Einheit (ALU) mit 5 Steuerbits (C4–C0). Die ALU führt 19 verschiedene Funktionen aus, darunter Addition, Subtraktion, bitweise UND/ODER/XOR und mehr. Du erhältst ein HDL-Skelett und musst die fehlenden Logikgatter ergänzen. Zudem erstellst du eigene Test- und Vergleichsdateien (.tst und .cmp).

Funktionsweise der ALU

Die ALU verarbeitet zwei 16-Bit-Eingänge X und Y. Die Steuerbits legen fest, welche Operation ausgeführt wird. Beispielsweise liefert die Kombination C4C3C2C1C0 = 00000 den Wert 0, während 00011 den Wert -1 ergibt. Du musst die Logik so entwerfen, dass alle 19 Funktionen korrekt abgebildet werden. Ein gutes Verständnis von Multiplexern und Addierern ist hier hilfreich.

// Ausschnitt aus MyALU.hdl
CHIP MyALU {
    IN x[16], y[16], c4, c3, c2, c1, c0;
    OUT out[16];
    PARTS:
    // Implementierung der ALU-Funktionen
}

Teil 3: Der HACK-Computer – Vom Speicher zur CPU

Im dritten Teil setzt du den gesamten HACK-Computer zusammen. Dies ist der Höhepunkt des Courseworks: Du implementierst den Speicher (Memory), die CPU mit Steuerwerk und schließlich den vollständigen Computer. Zusätzlich schreibst du zwei Assembler-Programme zur Berechnung von Potenzen und Fakultäten.

Abschnitt 3.1: Assembler-Programmierung

Du schreibst zwei Programme in HACK-Assembler:

• Power.asm: Berechne m^e. Die Basis m steht in RAM[0], der Exponent e in RAM[1]. Das Ergebnis wird in RAM[2] gespeichert. Falls e = 0, speichere 1 in RAM[2].
• Factorial.asm: Berechne n! für n in RAM[0]. Das Ergebnis kommt in RAM[1].

Beide Programme nutzen Schleifen und bedingte Sprünge – grundlegende Konzepte der Assembler-Programmierung. Ein typischer Ansatz für die Potenz ist die wiederholte Multiplikation in einer Schleife, die e-mal durchlaufen wird.

// Beispiel: Schleife für Potenz (Pseudocode)
@R0
D=M
@base
M=D      // Basis speichern
@R1
D=M
@exp
M=D      // Exponent speichern
@result
M=1      // Ergebnis initialisieren
(LOOP)
@exp
D=M
@END
D;JEQ   // Wenn exp=0, Ende
@base
D=M
@result
M=M*D   // Ergebnis multiplizieren
@exp
M=M-1   // Exponent dekrementieren
@LOOP
0;JMP   // Zurück zur Schleife
(END)
@result
D=M
@R2
M=D     // Ergebnis speichern

Abschnitt 3.2: Memory-Chip

Der Speicher des HACK-Computers besteht aus RAM16K, einem Bildschirm-Speicher (Screen) und einer Tastatur-Schnittstelle (Keyboard). Du implementierst den Memory-Chip, der je nach Adresse die entsprechenden Komponenten ansteuert. Die Adressierung folgt der HACK-Architektur: RAM belegt die Adressen 0–16383, Screen 16384–24575 und Keyboard 24576.

// Memory.hdl (Ausschnitt)
CHIP Memory {
    IN in[16], load, address[15];
    OUT out[16];
    PARTS:
    // Adressdecodierung und RAM/Screen/Keyboard-Auswahl
}

Abschnitt 3.3: CPU und Steuerwerk

Die CPU ist das Herzstück des Computers. Sie holt Befehle aus dem Speicher, dekodiert sie (A- oder C-Instruktion) und führt sie aus. Das Steuerwerk (Control Unit) erzeugt die nötigen Signale für ALU, Register und Speicherzugriffe. Du implementierst die CPU gemäß dem Schaltplan aus Kapitel 5 der nand2tetris-Ressourcen. Ein wichtiger Schritt ist die Dekodierung des 16-Bit-Befehls: Das höchste Bit (Bit 15) unterscheidet zwischen A-Instruktion (0) und C-Instruktion (1).

// CPU.hdl (Ausschnitt: Instruktionsdekodierung)
CHIP CPU {
    IN instruction[16], inM[16], reset;
    OUT outM[16], writeM, addressM[15], pc[15];
    PARTS:
    // Dekodierung und Ausführung
}

Praktische Tipps und häufige Fehler

Damit du bei deinem Coursework erfolgreich bist, hier einige Hinweise:

• Testen, testen, testen: Nutze die bereitgestellten .tst-Dateien und erstelle eigene Tests. Ein Fehler in einem Gatter kann sich durch die gesamte Schaltung ziehen.
• Gruppenarbeit effizient gestalten: Teilt die Aufgaben auf – einer kümmert sich um Logikgatter, ein anderer um die ALU, der dritte um den Assembler. Kommuniziert regelmäßig, um Schnittstellen abzustimmen.
• Dokumentation nicht vergessen: Für Teil 1 musst du eine Wahrheitstabelle und Vereinfachung abgeben. Halte deine Arbeitsschritte nachvollziehbar fest.
• Häufige Fallstricke: Achte auf die korrekte Bitbreite (16-Bit), verwende die richtigen Gatter (z. B. NAND statt AND) und achte auf die Reihenfolge der Steuerbits bei der ALU.

Zusammenfassung und Ausblick

In diesem Tutorial hast du die drei Hauptteile des COMP1027 Coursework 1 kennengelernt: elementare Logikgatter am Beispiel von Tessas Café, die ALU mit 19 Funktionen sowie den Aufbau des HACK-Computers inklusive Assembler-Programmierung. Diese Konzepte sind grundlegend für das Verständnis moderner Computerarchitektur. Wer weiß – vielleicht entwickelst du bald die Steuerung für den nächsten viralen KI-Trend oder optimierst die Hardware deiner Gaming-Station. Viel Erfolg bei deinem Projekt!