CPU Entwurf mit VHDL - Exam

Aufgabe 1)

Du sollst ein VHDL-Modell für eine einfache ALU (Arithmetic Logic Unit) entwerfen. Diese ALU soll in der Lage sein, Addition, Subtraktion, UND und ODER Operationen durchzuführen. Die ALU besitzt zwei 4-Bit-Eingänge (A und B), ein 2-Bit-Steuersignal (ALU_Sel, das die auszuführende Operation bestimmt) sowie einen 4-Bit-Ausgang (Result) und ein 1-Bit-Ausgangssignal (Zero), das angibt, ob der Ergebniswert null ist. Verwende in deinem Modell die Entity- und Architecture-Komponenten, Signale und Prozesse sowie Kontrollstrukturen wie IF- oder CASE-Anweisungen.

a)

Definiere die Entity für die ALU. Achte darauf, dass alle Eingaben und Ausgaben korrekt deklariert sind.

Lösung:

• Entity Definition für die ALU

In VHDL wird eine Entity verwendet, um die Schnittstelle zu einem Modul zu definieren. Die Entity spezifiziert alle Eingangs- und Ausgangssignale des Moduls. In diesem Fall definieren wir eine Entity für eine einfache ALU, die mit zwei 4-Bit-Eingängen (A und B), einem 2-Bit-Steuersignal (ALU_Sel), einem 4-Bit-Ausgang (Result) und einem 1-Bit-Ausgang (Zero) arbeitet.

Hier ist der VHDL-Code, der die Entity für diese ALU beschreibt:

ENTITY ALU IS     PORT (         A        : IN  STD_LOGIC_VECTOR(3 DOWNTO 0);         B        : IN  STD_LOGIC_VECTOR(3 DOWNTO 0);         ALU_Sel  : IN  STD_LOGIC_VECTOR(1 DOWNTO 0);         Result   : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);         Zero     : OUT STD_LOGIC     ); END ALU; 

Erklärung der Ports:

• A: 4-Bit-Eingang. Dies ist der erste Operand für die ALU-Operationen.
• B: 4-Bit-Eingang. Dies ist der zweite Operand für die ALU-Operationen.
• ALU_Sel: 2-Bit-Steuersignal. Dieses Signal bestimmt, welche Operation die ALU ausführen soll (Addition, Subtraktion, UND, ODER).
• Result: 4-Bit-Ausgang. Dies ist das Ergebnis der ALU-Operation.
• Zero: 1-Bit-Ausgang. Dieses Signal gibt an, ob das Ergebnis null ist (1, wenn das Ergebnis null ist; sonst 0).

Aufgabe 2)

Du wirst aufgefordert, eine digitale Schaltung zu modellieren und zu analysieren. Die Schaltung ist ein einfacher 4-Bit Zähler, der auf einem D-Flip-Flop basiert. Der Zähler erhöht sich um eins mit jedem positiven Taktimpuls und besitzt eine Reset-Funktion, die den Zählerstand auf Null setzt.

a)

a) Skizziere die Schaltung des 4-Bit Zählers. Benenne alle relevanten Teile der Schaltung wie Flip-Flops, Taktleitung und Reset-Leitung. Beschreibe die Funktionsweise der Schaltung in Worten.

Lösung:

• Schaltplan eines 4-Bit Zählers
• Relevante Teile:
  • D-Flip-Flops: Diese sind die grundlegenden Speicherbausteine der Schaltung. Es gibt vier D-Flip-Flops, die die 4 Bits des Zählers darstellen (Q0, Q1, Q2, Q3).
  • Taktleitung: Diese ist mit allen D-Flip-Flops verbunden und sorgt dafür, dass alle Flip-Flops gleichzeitig auf den neuen Zustand umschalten.
  • Reset-Leitung: Diese Leitung setzt alle Flip-Flops auf Null, unabhängig vom Taktimpuls.
• Funktionsweise der Schaltung:
  • Jeder D-Flip-Flop speichert einen Bit-Wert (0 oder 1). Der 4-Bit Zähler hat vier dieser Flip-Flops, was bedeutet, dass er Werte von 0000 (0) bis 1111 (15) zählen kann.
  • Die Flip-Flops sind in einem bestimmten Muster miteinander verknüpft, damit der Zähler sich mit jedem positiven Taktimpuls um eins erhöht.
  • Wenn der Taktimpuls auf die D-Flip-Flops einwirkt, wird der nächste Zustand der Flip-Flops errechnet und in der nächsten Taktflanke übernommen.
  • Die Reset-Leitung setzt alle Flip-Flops auf 0. Dies kann durch einen externen Schalter oder ein Signal gesteuert werden.
  • Beispielhafte Zählabfolge: Anfänglich 0000, bei erstem Taktimpuls 0001, nach dem zweiten Taktimpuls 0010, nach dem dritten Taktimpuls 0011, und so weiter, bis der Zähler den Wert 1111 (15) erreicht.

b)

b) Schreibe die VHDL-Beschreibung für den 4-Bit Zähler. Definiere die Entity und die Architecture der Schaltung und implementiere die Zustandsübergänge des Zählers mit Hilfe von Prozessen. Achte darauf, den Reset korrekt zu implementieren.

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity four_bit_counter is    Port ( clk : in  STD_LOGIC;           reset : in  STD_LOGIC;           q : out  STD_LOGIC_VECTOR (3 downto 0));end four_bit_counter;architecture Behavioral of four_bit_counter is    signal count: STD_LOGIC_VECTOR (3 downto 0) := (others => '0');begin    process(clk, reset)    begin        if reset = '1' then            count <= (others => '0');        elsif rising_edge(clk) then            count <= count + 1;        end if;    end process;    q <= count;end Behavioral;

Lösung:

• VHDL-Beschreibung für den 4-Bit Zähler

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity four_bit_counter is    Port ( clk : in  STD_LOGIC;           reset : in  STD_LOGIC;           q : out  STD_LOGIC_VECTOR (3 downto 0));end four_bit_counter;architecture Behavioral of four_bit_counter is    signal count: STD_LOGIC_VECTOR (3 downto 0) := (others => '0');begin    process(clk, reset)    begin        if reset = '1' then            count <= (others => '0');        elsif rising_edge(clk) then            count <= count + 1;        end if;    end process;    q <= count;end Behavioral;

Erklärung der VHDL-Beschreibung:
• Bibliotheken: Die Bibliothek IEEE.STD_LOGIC_1164 wird eingebunden, um die Standard-LOGIC-Typen zu verwenden.
• Entity: Die Entity 'four_bit_counter' beschreibt die Schnittstelle der Schaltung mit den Eingängen clk (Taktimpuls) und reset und dem Ausgang q (4-Bit-Zählerwert).
• Architecture: Der Architekturteil 'Behavioral' definiert das Verhalten des 4-Bit-Zählers.
• Signal count: Ein internes Signal 'count' speichert den aktuellen Zählerstand und wird initial auf 0 gesetzt.
• Prozess: Der Prozess wird bei jeder positiven Taktflanke (rising_edge(clk)) oder bei einem Reset ausgelöst. Falls das Reset-Signal aktiv ist (reset = '1'), wird der Zählerstand auf 0 gesetzt. Andernfalls wird der Zählerstand bei jeder positiven Taktflanke um 1 erhöht.
• Zuweisung: Der Ausgang q wird dem aktuellen Wert des Signals 'count' zugewiesen.

c)

c) Simuliere die beschriebene VHDL-Schaltung mit einer geeigneten Simulationssoftware (z.B. ModelSim). Zeige, dass die Schaltung wie gewünscht funktioniert, indem Du eine Simulationswellenform einfügst. Beschreibe die Beobachtungen und vergleiche sie mit den erwarteten Resultaten. Füge eine Fehleranalyse hinzu, falls die Simulation nicht die erwarteten Resultate liefert.

Lösung:

• Simulation der VHDL-Schaltung mit ModelSim
• Vorbereitung:
  • Erstelle ein neues Projekt in ModelSim und füge die VHDL-Datei mit der Beschreibung des 4-Bit Zählers hinzu.
  • Erstelle ein Testbench-Modul, um die Schaltung zu testen. Ein einfaches Testbench-Modul kann wie folgt aussehen:

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity tb_four_bit_counter isend tb_four_bit_counter;architecture Behavioral of tb_four_bit_counter is    signal clk : std_logic := '0';    signal reset : std_logic := '0';    signal q : std_logic_vector(3 downto 0);    component four_bit_counter is        Port ( clk : in  STD_LOGIC;               reset : in  STD_LOGIC;               q : out  STD_LOGIC_VECTOR (3 downto 0));    end component;    -- Instantiate the counter    uut: four_bit_counter port map (clk => clk, reset => reset, q => q);    -- Clock process    clk_process :process    begin        clk <= '0'; wait for 10 ns;        clk <= '1'; wait for 10 ns;    end process;    -- Stimulus process    stim_proc: process    begin        -- Initialize Inputs        reset <= '1';        wait for 20 ns;        reset <= '0';        wait for 200 ns;        -- End simulation        wait;    end process;begin    -- Architecture contentend Behavioral;

• Simulation starten: Lade das Testbench-Modul in ModelSim und starte die Simulation. Stellt sicher, dass die Simulation ausreichend lange läuft, um mehrere Taktzyklen abzudecken.
• Ergebnisse beachten: Die folgenden Wellenformen sollten in den Simulationsergebnissen beobachtet werden:

• Taktimpuls (clk): Ein Rechtecksignal mit einer Periodendauer von 20 ns.
• Reset-Signal (reset): Das Reset-Signal ist während der ersten 20 ns auf '1' und danach auf '0'.
• Ausgangssignal (q): Das Signal sollte sich wie folgt verhalten:
  • Zu Beginn: 0000 (Reset aktiv)
  • Nach 30 ns: 0001 (Erster Takt nach Reset)
  • Nach 50 ns: 0010 (Zweiter Takt nach Reset)
  • Nach 70 ns: 0011 (Dritter Takt nach Reset)
  • Und so weiter...

Aufgabe 3)

Design von ALUs (Arithmetic Logic Units)Design von ALUs umfasst die Planung und Implementierung von Berechnungseinheiten, die arithmetische und logische Operationen innerhalb der CPU ausführen.

• Wesentliche Operationen: Addition, Subtraktion, AND, OR, XOR, NOT
• Typischer Aufbau: Eingangsauswahl, Logikgatter, Volladdierer
• Eingänge: Operand A, Operand B, Steuerleitungen
• Ausgänge: Ergebnis, Flags (Carry, Overflow, Zero, Negativ)
• Latenz und Schaltungsoptimierung beachten
• Im VHDL erfolgt die Definition durch entity und architecture
• Beispiel VHDL Addition: Y <= A + B;

b)

b) Implementiere eine Schaltung zur Bestimmung des Überlaufs (Overflow) bei der Addition in VHDL. Erkläre, wie der Überlauf durch die Vorzeichen der Operanden und des Ergebnisses bestimmt werden kann. Zeige den relevanten VHDL-Code.

Lösung:

Implementierung einer Überlauf-Schaltung in VHDL

Bei der Implementierung einer ALU ist es wichtig, den Überlauf (Overflow) zu erkennen. Der Überlauf tritt auf, wenn das Ergebnis einer Addition nicht im definierten Zahlenbereich dargestellt werden kann. Insbesondere bei der Verarbeitung von Vorzeichen-binären Zahlen (zwei Ergänzungen) muss der Überlauf sorgfältig überwacht werden.

Überlaufbedingungen

Der Überlauf kann durch die Vorzeichen der Operanden und des Ergebnisses bestimmt werden:

• Ein Überlauf tritt auf, wenn zwei positive Werte (Operand A und Operand B) addiert werden und das Ergebnis negativ wird.
• Ein Überlauf tritt auch auf, wenn zwei negative Werte (Operand A und Operand B) addiert werden und das Ergebnis positiv wird.

VHDL Implementierung

Hier ist ein Beispiel für die Implementierung einer Überlauf-Schaltung in VHDL:

entity ALU is  Port (    A, B : in  STD_LOGIC_VECTOR(7 downto 0);    SUM    : out STD_LOGIC_VECTOR(7 downto 0);    Overflow : out STD_LOGIC  );end ALU;architecture Behavioral of ALU isbegin  process(A, B)  variable temp_sum : STD_LOGIC_VECTOR(8 downto 0); -- Erweiterung um ein Bit  begin    temp_sum := ('0' & A) + ('0' & B);    SUM <= temp_sum(7 downto 0);    Overflow <= (A(7) and B(7) and not temp_sum(7)) or ((not A(7)) and (not B(7)) and temp_sum(7));  end process;end Behavioral;

• Die Entität ALU hat zwei Eingangsoperanden (A und B), ein Ausgangsergebnis (SUM) und ein Überlaufsignal (Overflow).
• Innerhalb der Architektur Behavioral wird ein Prozess definiert, der immer dann aktiviert wird, wenn sich die Eingangsoperanden (A und B) ändern.
• Der temporäre Summenwert temp_sum wird um ein Bit erweitert, um das Carry-Bit zu speichern.
• Das Überlaufsignal Overflow wird durch die Prüfung der Vorzeichenbits der Operanden und des Ergebnisses bestimmt.

Durch diese Implementierung kannst Du sicherstellen, dass der Überlauf korrekt erkannt wird.

c)

c) Analysiere die Latenz deines ALU-Designs. Angenommen, die Verzögerung durch ein Logikgatter beträgt 10 ns und durch einen Volladdierer 20 ns. Berechne die Gesamtverzögerung für eine Addition und eine AND-Operation. Stelle sicher, dass Du die Schaltung für Multiplexer in deiner Analyse berücksichtigst.

Lösung:

Analyse der Latenz eines ALU-Designs

Die Latenz einer ALU misst die Verzögerungszeit zwischen dem Zeitpunkt, zu dem die Eingänge zugeführt werden, und dem Zeitpunkt, an dem das Ergebnis zur Verfügung steht. Um die Latenz für eine Addition und eine AND-Operation zu berechnen, müssen wir die Verzögerungen durch Logikgatter, Volladdierer und Multiplexer berücksichtigen.

Annahmen für die Verzögerungen:

• Verzögerung durch ein Logikgatter: 10 ns
• Verzögerung durch einen Volladdierer: 20 ns
• Verzögerung durch einen Multiplexer: 10 ns

Berechnung der Latenz für die Addition:

• Angenommen, die Addition wird durch eine Reihe von Volladdierern implementiert.
• Für eine n-Bit-ALU benötigt man n Volladdierer.
• Da die Verzögerung durch jeden Volladdierer 20 ns beträgt, ergibt die Gesamtverzögerung für die Addition 20 ns pro Volladdierer.
• Wenn wir von einer 8-Bit-ALU ausgehen, ergibt sich die Gesamtverzögerung für die Addition wie folgt:

\[ \text{Gesamtverzögerung bei Addition ohne Multiplexer} = 8 \times 20 \text{ ns} = 160 \text{ ns} \]

• Zusätzlich müssen wir die Verzögerung durch die Wahl eines Multiplexers berücksichtigen.
• Da wir davon ausgehen, dass die Verzögerung durch einen Multiplexer 10 ns beträgt:

\[ \text{Gesamtverzögerung bei Addition mit Multiplexer} = 160 \text{ ns} + 10 \text{ ns} = 170 \text{ ns} \]

Berechnung der Latenz für die AND-Operation:

• Die AND-Operation wird einfach durch Logikgatter umgesetzt.
• Angenommen, die AND-Operation erfolgt durch ein Logikgatter.

\[ \text{Gesamtverzögerung bei AND-Operation ohne Multiplexer} = 10 \text{ ns} \]

• Auch bei der AND-Operation müssen wir die Verzögerung durch den Multiplexer berücksichtigen:

\[ \text{Gesamtverzögerung bei AND-Operation mit Multiplexer} = 10 \text{ ns} + 10 \text{ ns} = 20 \text{ ns} \]

Zusammenfassung:

• Die Gesamtverzögerung für eine Addition beträgt 170 ns, wenn man die Verzögerung durch Multiplexer berücksichtigt.
• Die Gesamtverzögerung für eine AND-Operation beträgt 20 ns, wenn man die Verzögerung durch Multiplexer berücksichtigt.

Durch diese Analyse kannst Du sicherstellen, dass die Latenzzeiten in Deinem ALU-Design eingehalten werden.

d)

d) Beschreiben Sie, wie Flags wie Zero, Negativ und Carry innerhalb Ihrer ALU implementiert werden können. Geben Sie den VHDL-Code für die Berechnung des Zero-Flags an. Zeigen Sie Beispiele, wann dieser Flag gesetzt wird.

Lösung:

Implementierung von Flags in einer ALU

Flags in einer ALU sind spezielle Ausgabesignale, die zusätzliche Informationen über das Ergebnis einer arithmetischen oder logischen Operation geben. Typische Flags sind:

• Zero (Z): Wird gesetzt, wenn das Ergebnis einer Operation null ist.
• Negativ (N): Wird gesetzt, wenn das Ergebnis einer Operation negativ ist (d.h. das höchste Bit gesetzt ist).
• Carry (C): Wird gesetzt, wenn bei einer Addition ein Übertrag (Carry) auftritt oder bei einer Subtraktion ein Borrow.

Berechnung des Zero-Flags

Das Zero-Flag wird gesetzt, wenn das Ergebnis einer Operation null ist. Dies kann durch einen Vergleich des Ergebnisses mit null erreicht werden.

Beispielcode in VHDL für das Zero-Flag:

library IEEE;  use IEEE.STD_LOGIC_1164.ALL;  use IEEE.STD_LOGIC_ARITH.ALL;  use IEEE.STD_LOGIC_UNSIGNED.ALL;entity ALU is  Port (    A, B : in  STD_LOGIC_VECTOR(7 downto 0);    SUM    : out STD_LOGIC_VECTOR(7 downto 0);    Zero : out STD_LOGIC;    -- Weitere Signale für Negativ, Carry usw.  );end ALU;architecture Behavioral of ALU isbegin  process(A, B)  variable temp_sum : STD_LOGIC_VECTOR(8 downto 0);  begin    -- Berechnung der Addition    temp_sum := ('0' & A) + ('0' & B);    SUM <= temp_sum(7 downto 0);    -- Berechnung des Zero-Flags    if temp_sum(7 downto 0) = 
Aufgabe 4)
 Du wirst beauftragt, eine Kontrolleinheit für eine einfache CPU in VHDL zu entwerfen. Diese CPU kann die folgenden Grundoperationen ausführen: Addition, Subtraktion, Laden in ein Register und Speichern aus einem Register. Die Kontrolleinheit nutzt Zustandsautomaten zur Steuerung der Operationen. Deine Aufgabe ist es, die wesentlichen Komponenten der Kontrolleinheit zu entwickeln und zu beschreiben, wie sie in VHDL implementiert werden können. 
a)
 Beschreibe den allgemeinen Ablauf, wie eine Kontrolleinheit eine Instruktion interpretiert und die entsprechenden Operationen steuert. Gehe auf die Rolle von Zustandsautomaten (FSM) bei der Steuerung der Befehle ein und erläutere die Bedeutung von Signalen und Steuerleitungen. 
 Lösung: 
Ablauf einer Kontrolleinheit im Detail
Die Kontrolleinheit einer CPU ist verantwortlich dafür, Instruktionen zu interpretieren und die entsprechenden Operationen zu steuern. Dies geschieht in mehreren Schritten und unter der Verwendung eines Zustandsautomaten (Finite State Machine, FSM). Nachfolgend wird beschrieben, wie dieser Prozess aussieht und welche Rolle FSMs, Signale und Steuerleitungen dabei spielen.
Instruktionsfetch: Der erste Schritt besteht darin, die Instruktion aus dem Speicher zu holen. Die Adresse wird aus dem Programmzähler (PC) abgelesen und der Instruktionsspeicher wird an dieser Stelle gelesen. Das Ergebnis ist die aktuelle Instruktion, die dekodiert werden muss.
Dekodierung: Die Kontrolleinheit dekodiert die gelesene Instruktion, um festzustellen, welchen Befehl sie repräsentiert und welche Operanden gegebenenfalls verwendet werden.
Operationsteuerung mittels Zustandsautomaten (FSM): Ein FSM wird verwendet, um durch die verschiedenen Phasen einer Instruktion zu navigieren. Jeder Zustand des FSM repräsentiert eine Phase der Ausführung des Befehls. Abhängig vom aktuellen Zustand und der dekodierten Instruktion werden die entsprechenden Signale gesetzt.    
        
Zum Beispiel könnte ein Zustand des FSM sein, die ALU zu aktivieren und die Operation (z. B. Addition oder Subtraktion) durchzuführen.
        
Ein anderer Zustand könnte sein, das Ergebnis der ALU in ein Register zu speichern.
    
Signale und Steuerleitungen: Signale und Steuerleitungen sind die Mittel, über die die Kontrolleinheit die anderen Teile der CPU steuert. Diese Signale schalten Komponenten ein oder aus, wählen bestimmte Dateneingänge und steuern die Richtung des Datenflusses.    
        
Zum Beispiel könnte ein Signal verwendet werden, um die ALU anzuweisen, eine Addition durchzuführen.
        
Ein anderes Signal könnte ein bestimmtes Register auswählen, um Daten zu schreiben oder zu lesen.
    
Bedeutung und Implementierung von FSM in VHDL
Die Implementierung eines FSM in VHDL erfolgt typischerweise durch eine Mischung aus Zustandsvariablen und Case-Anweisungen. Jeder Zustand entspricht einer bestimmten Aktivität oder Kombination von Signalen.
entity ControlUnit is    Port (        clk : in std_logic;        reset : in std_logic;        instr : in std_logic_vector(31 downto 0);        -- Weitere Ports    );end ControlUnit;architecture Behavioral of ControlUnit is    type state_type is (FETCH, DECODE, EXECUTE, WRITEBACK);    signal state, next_state: state_type;    -- Weitere Signalebegin    process (clk, reset)    begin        if reset = '1' then            state <= FETCH;        elsif rising_edge(clk) then            state <= next_state;        end if;    end process;    process (state, instr)    begin        case state is            when FETCH =>                -- Anweisungen für FETCH                next_state <= DECODE;            when DECODE =>                -- Anweisungen für DECODE                next_state <= EXECUTE;            when EXECUTE =>                -- Anweisungen für EXECUTE                next_state <= WRITEBACK;            when WRITEBACK =>                -- Anweisungen für WRITEBACK                next_state <= FETCH;            when others =>                next_state <= FETCH;        end case;    end process;end Behavioral;
In diesem VHDL-Code-Beispiel zeigt die 'ControlUnit'-Architektur eine einfache FSM mit den Zuständen FETCH, DECODE, EXECUTE und WRITEBACK. Die Prozesse sorgen dafür, dass die Kontrolleinheit bei jedem Taktzyklus in den nächsten Zustand übergeht, basierend auf der aktuellen Anweisung.
b)
 Skizziere einen einfachen Zustandsautomaten (FSM) für die Steuerung der folgenden Instruktionen: Addition, Subtraktion, Laden und Speichern. Dokumentiere mindestens drei Zustände und beschreibe die Übergänge zwischen diesen Zuständen. Verwende Pseudocode oder ein Zustandsdiagramm. 
 Lösung: 
Zustandsautomat (FSM) für die Steuerung der Instruktionen
Ein spezieller Zustandsautomat (FSM) für die Steuerung der Instruktionen Addition, Subtraktion, Laden und Speichern könnte die folgenden Zustände beinhalten:
FETCH: Instruktion wird aus dem Speicher geholt.
DECODE: Die Instruktion wird dekodiert, um den Befehl und die Operanden zu ermitteln.
EXECUTE: Die Operation (Addition, Subtraktion, Laden oder Speichern) wird ausgeführt.
WRITEBACK: Ergebnis der Operation wird (falls nötig) in ein Register geschrieben.
Zusätzlich gibt es Übergangszustände zwischen diesen grundlegenden Zuständen. Die folgenden Diagramme und Pseudocode illustrieren die Schritte und Übergänge zwischen diesen Zuständen.
Zustandsdiagramm
Nachstehend ein einfaches Zustandsdiagramm:
FETCH -> DECODE -> EXECUTE -> WRITEBACK -> FETCH
Das Diagramm zeigt den typischen Ablauf für jede Instruktion. Zusätzliche Zustandsübergänge sind abhängig von der spezifischen Operation, die im DECODE-Zustand erkannt wird.
FSM Pseudocode
Im Folgenden wird ein Pseudocode für diesen FSM dargestellt.
type state_type is (FETCH, DECODE, EXECUTE, WRITEBACK);signal state, next_state: state_type;process (state, clk, reset)begin    if reset = '1' then        state <= FETCH;    elsif rising_edge(clk) then        state <= next_state;    end if;end process;process (state, instruction)begin    case state is        when FETCH =>            -- Instruktion aus dem Speicher lesen.            next_state <= DECODE;        when DECODE =>            -- Bestimme die Instruktionstyp (Addieren, Subtrahieren, Laden, Speichern).            if instruction = ADD then                next_state <= EXECUTE;            elsif instruction = SUB then                next_state <= EXECUTE;            elsif instruction = LOAD then                next_state <= EXECUTE;            elsif instruction = STORE then                next_state <= EXECUTE;            end if;        when EXECUTE =>            -- Operation entsprechend der Instruktion ausführen.            if instruction = ADD or instruction = SUB then                -- ALU Operation durchführen.                next_state <= WRITEBACK;            elsif instruction = LOAD then                -- Von Speicher in Register laden.                next_state <= WRITEBACK;            elsif instruction = STORE then                -- Von Register in Speicher speichern.                next_state <= FETCH;            end if;        when WRITEBACK =>            -- Ergebnis in Register schreiben.            next_state <= FETCH;        when others =>            next_state <= FETCH;    end case;end process;
In diesem Pseudocode repräsentiert der Zustand FETCH das Lesen der Instruktion aus dem Speicher. Der DECODE-Zustand dekodiert die Instruktion und ermittelt die auszuführende Operation. Der Zustand EXECUTE führt die tatsächliche Operation durch, und WRITEBACK speichert das Ergebnis, falls notwendig, zurück in das Register. Dies gewährleistet eine zyklische Bewegung durch die Zustände fetch-decode-execute-writeback.
c)
 Implementiere in VHDL einen Prozessblock, der die Zustandsübergänge für die oben genannten Instruktionen verwaltet. Schreibe dazu den VHDL-Code für den FSM-Prozess und füge Kommentare hinzu, die die Funktion jedes Zustands und Übergangs erklären. 
 Lösung: 
VHDL-Implementierung des FSM-Prozesses
Nachfolgend findest Du den VHDL-Code für den FSM-Prozess, der die Zustandsübergänge für die Instruktionen Addition, Subtraktion, Laden und Speichern verwaltet. Jedes Zustands- und Übergang Ereignis wird mit Kommentaren erklärt.
library IEEE;use IEEE.STD_LOGIC_1164.ALL;use IEEE.STD_LOGIC_ARITH.ALL;use IEEE.STD_LOGIC_UNSIGNED.ALL;entity ControlUnit is    Port (             clk : in STD_LOGIC;             reset : in STD_LOGIC;             instr : in STD_LOGIC_VECTOR(31 downto 0);             -- Weitere Signale wie benötigt    );end ControlUnit;architecture Behavioral of ControlUnit is    -- Definition der Zustände    type state_type is (FETCH, DECODE, EXECUTE, WRITEBACK);    signal state, next_state: state_type;begin    -- State transition process    process(clk, reset)    begin        if reset = '1' then            state <= FETCH;  -- Bei Reset Zustand auf FETCH setzen        elsif rising_edge(clk) then            state <= next_state;  -- Zustand bei steigender Flanke des Takts aktualisieren        end if;    end process;    -- FSM Prozess, der die Zustandsübergänge verwaltet    process(state, instr)    begin        case state is            when FETCH =>                -- In FETCH werden die Instruktionen aus dem Speicher geladen                -- Hier sollte die Logik zum Lesen einer Instruktion hinzugefügt werden                next_state <= DECODE;  -- Nach dem Lesen zur DECODE Phase übergehen            when DECODE =>                -- Dekodierung der Instruktion                -- Hier sollte die Logik zur Ermittlung des Befehls hinzugefügt werden                if instr(31 downto 26) =