ALU Schaltplanerfassung in ISE – Tutorial für CDA 4203L Lab 1

Einleitung: Warum eine ALU in ISE? – Von der Theorie zur Schaltung

Die Arithmetic Logic Unit (ALU) ist das Herz jeder CPU. Im Lab 1 von CDA 4203L geht es darum, eine 4-Bit-ALU mit den Funktionen Invertieren, Addieren, Subtrahieren und Verdoppeln zu entwerfen. Du wirst den ISE Schematic Entry-Tool verwenden, um die Schaltung zu zeichnen und zu simulieren. Dieses Tutorial führt dich durch den gesamten Prozess – von der Schaltplanerfassung bis zur Testbench-Erstellung. Die fertige ALU wird in späteren Laboren weiterverwendet, also hebe dein Projekt gut auf!

Stell dir vor, du entwickelst eine KI-gestützte App, die Echtzeit-Daten verarbeitet – die ALU übernimmt dort die grundlegenden Rechenoperationen. Oder denk an aktuelle Gaming-Trends: In Spielen wie Fortnite oder Call of Duty berechnen ALUs millionenfach Positionen und Schadenswerte. Dein Design ist der erste Schritt, solche Hochleistungsberechnungen zu verstehen.

Grundlagen der ALU-Funktionen im Zweierkomplement

Bevor du mit der Schematic Capture beginnst, musst du die geforderten Funktionen verstehen. Die ALU arbeitet mit 4-Bit-Zahlen im Zweierkomplement. Der Funktionstabelle zufolge wählst du mit den Select-Leitungen S1 und S0 die Operation:

00: Invertieren – alle Bits von A werden invertiert (z.B. 1101 -> 0010).
01: Addieren – A + B (z.B. 0110 + 0001 = 0111). Achte auf Überlauf: 0111 + 0001 = 1000 ist ein overflow und wird nicht verwendet.
10: Subtrahieren – A – B (z.B. 1111 – 1110 = 0001). Auch hier Überlauf vermeiden.
11: Verdoppeln – 2*A (entspricht A um ein Bit nach links verschieben, mit Nullen auffüllen).

Im ISE Schematic Entry wirst du die Volladdierer, Multiplexer (MUX) und Inverter aus der Bibliothek platzieren und verbinden. Der Überlauf wird ignoriert, aber du musst trotzdem die Schaltung so entwerfen, dass sie korrekte Ergebnisse liefert, solange kein Überlauf auftritt.

Schritt 1: Projekt anlegen und Bibliotheken einrichten

Starte ISE Design Suite und erstelle ein neues Projekt. Wähle als Device Family z.B. Spartan-6 und ein passendes Bauteil (z.B. XC6SLX16). Gib dem Projekt einen Namen wie „ALU_Lab1“. Wichtig: Du musst die Schematic-Einstellung wählen, nicht VHDL oder Verilog. Nachdem das Projekt angelegt ist, öffnest du den Schematic Editor.

Füge die benötigten Komponenten hinzu: ADD4 (4-Bit-Addierer), INV (Inverter), M2_1E (2-zu-1-Multiplexer) und GND/VCC für Konstanten. Für den Subtractor nutzt du den Addierer mit einem Zweierkomplement von B: B' = invert(B) + 1. Das realisierst du durch einen Inverter pro Bit und einen Carry-In von 1 am Addierer.

Ein Tipp für Anfänger: Ziehe die Komponenten per Drag & Drop auf die Leinwand und verbinde sie mit Wires. Nutze die Bus-Funktion für 4-Bit-Leitungen (z.B. A[3:0]).

Schritt 2: Top-Level-Schematic der ALU

Das Top-Level-Schematic zeigt die ALU als Blackbox mit den Ports: A[3:0], B[3:0], S[1:0] als Eingänge und Y[3:0] als Ausgang. Platziere die I/O Marker (IBUF/OBUF) für alle Ports. Verbinde die Eingänge mit den internen Blöcken.

Im Inneren der ALU baust du vier Funktionsblöcke:

Invert-Block: Ein 4-Bit-Inverter (vier einzelne INV-Gatter oder ein INV4 aus der Bibliothek).
Add-Block: Ein 4-Bit-Addierer (ADD4) mit Carry-In = 0.
Subtract-Block: Ein 4-Bit-Addierer mit Carry-In = 1 und invertiertem B (über INV4).
Double-Block: Einfach A[2:0] auf Y[3:1] legen und Y[0] auf GND setzen (oder einen Schiebeoperator nachbilden).

Die Ausgänge aller vier Blöcke gehen an einen 4-zu-1-Multiplexer (aus drei 2-zu-1-MUX aufgebaut oder einem M4_1E). Die Select-Leitungen S[1:0] steuern den MUX. So wird je nach Funktion der passende Wert an Y ausgegeben.

Vergiss nicht, die Netze zu benennen (z.B. „inv_out“, „add_out“), damit die Simulation später übersichtlich bleibt.

Schritt 3: Sub-Block: Volladdierer und Multiplexer detailliert

Für die Dokumentation musst du die inneren Schaltungen aller Blöcke zeigen. Erstelle für den Volladdierer (Full Adder) ein separates Schematic: Ein XOR für die Summe, ein AND und OR für den Carry. Oder du verwendest den vorgefertigten ADD4, der bereits aus Volladdierern besteht – dann reicht ein Screenshot der Hierarchie.

Der Multiplexer (MUX) lässt sich aus UND-ODER-Gattern aufbauen: Für jeden Ausgangsbit ein MUX aus vier Eingängen. Zeige die Gatterebene in einem Sub-Schematic. Das ist zwar aufwändig, aber für die Bewertung wichtig.

Ein praktischer Tipp: Nutze die Bus-Taps, um einzelne Bits aus einem Bus herauszugreifen. Das vereinfacht die Verbindungen.

Schritt 4: Testbench erstellen und Simulation durchführen

Erstelle eine Testbench im ISE Simulator (oder ModelSim). Du kannst eine VHDL-Testbench schreiben oder die Waveform-Editor-Methode nutzen. Wichtig: Mindestens zwei Testvektoren pro Funktion.

Beispiele für Testfälle:

Invert: A=0010 (2) -> Y=1101 (-3) (denn 2 invertiert ist -3 im Zweierkomplement).
Add: A=0110 (6), B=0001 (1) -> Y=0111 (7). Kein Überlauf.
Subtract: A=1111 (-1), B=1110 (-2) -> Y=0001 (1).
Double: A=0011 (3) -> Y=0110 (6).

Gib die Testvektoren in die Waveform-Datei ein und führe die Simulation aus. Überprüfe die Ausgänge auf Korrektheit. Achte auf Überlauf-Fälle – sie sollen nicht vorkommen, aber du kannst trotzdem testen, ob die Schaltung das erwartete Ergebnis liefert (z.B. 7+1=8 -> 1000, was -8 ergibt – das ist ein overflow, aber die Schaltung gibt trotzdem den Bitwert aus). In der Aufgabenstellung heißt es, solche Fälle zu vermeiden, also wähle Testvektoren ohne Überlauf.

Ein Trend-Beispiel: Stell dir vor, du entwickelst eine KI für Aktienhandel, die ständig Kursdifferenzen berechnet. Deine ALU würde hier subtrahieren – und ein Überlauf könnte zu falschen Entscheidungen führen. Deshalb ist das Vermeiden von Überläufen so wichtig.

Schritt 5: Ergebnisse dokumentieren und Report erstellen

Der Report muss folgende Teile enthalten:

Deckblatt mit Name, Kurs, Datum (9. Mai 2026).
ALU-Schematic: Screenshot des Top-Level und aller Sub-Blöcke (Volladdierer, MUX).
Kurze Beschreibung deines Designs: Wie hast du die Funktionen realisiert? Warum hast du bestimmte Komponenten gewählt?
Simulationswellenformen: Zeige die Testvektoren und die Ergebnisse. Beschrifte die Signale.
Feedback: Stundenaufwand (z.B. 5 Stunden) und Schwierigkeitsgrad (Medium).

Achte darauf, dass alle Screenshots gut lesbar sind und die Netznamen zu sehen sind. Speichere den Report als PDF und lade ihn auf Canvas hoch.

Häufige Fehler und Tipps

Viele Studierende vergessen, den Carry-In für die Subtraktion auf 1 zu setzen. Ohne das wird B nur invertiert, nicht aber +1 addiert – das Ergebnis ist falsch. Auch beim Double-Block muss der niedrigste Bit auf 0 gesetzt werden (GND), sonst entsteht ein falscher Wert.

Ein weiterer Fehler: Die Select-Leitungen werden vertauscht. Überprüfe die Wahrheitstabelle aus der Aufgabenstellung. Im Zweifelsfall simuliere jede Funktion einzeln.

Nutze die ISE-Hilfe (F1) oder Online-Tutorials für spezifische Komponenten. Die Xilinx-Community ist auch hilfreich.

Fazit: Deine ALU – Grundlage für komplexere Designs

Mit diesem Tutorial hast du gelernt, wie man eine ALU schematisch erfasst und simuliert. Dieses Wissen ist die Basis für spätere Labore, in denen du die ALU erweitern oder in einen Mikroprozessor einbetten wirst. Die Schaltplanerfassung ist eine wichtige Fertigkeit für jeden Computerarchitekten. Also hebe dein Projekt gut auf – es wird noch gebraucht!

Viel Erfolg im Labor und denk dran: Jede große KI-App oder jedes Gaming-System beginnt mit einer soliden ALU. Du baust gerade die Grundlage für die nächste Generation von Hochleistungsrechnern.