CPU Entwurf mit VHDL (Schwerpunkt VHDL) - Exam

Aufgabe 1)

Gegeben sind die folgenden logischen Grundfunktionen, die in der Booleschen Algebra verwendet werden:

• UND (Konjunktion): \(A \cdot B\)
• ODER (Disjunktion): \(A + B\)
• NICHT (Negation): \(\overline{A}\)
• NAND: \(\overline{A \cdot B}\)
• NOR: \(\overline{A + B}\)
• XOR (Exklusives ODER): \(A \oplus B\)
• Grundlagen für Schaltkreisentwurf, z.B., Addierer, Multiplexer.
• Wichtig für Zustandsmaschinen und digitale Logik in CPUs.

a)

Teilaufgabe 1: Entwerfe eine logische Schaltung, die die Funktion einer 1-Bit Volladdierer-Schaltung realisiert. Ein 1-Bit-Volladdierer hat drei Eingänge \(A\), \(B\) und den Übertrags-Bit \(C_{in}\) sowie zwei Ausgänge: die Summe (\(S\)) und den Übertrag (\(C_{out}\)). Formuliere die logischen Gleichungen für \(S\) und \(C_{out}\) unter Verwendung der Grundfunktionen der Booleschen Algebra.

• Tipp: Der Ausgang \(S\) kann als \((A \oplus B \oplus C_{in})\) und der Ausgang \(C_{out}\) als \((A \cdot B) + (C_{in} \cdot (A \oplus B))\) ausgedrückt werden.

Lösung:

Teilaufgabe 1: Entwurf einer logischen Schaltung für einen 1-Bit VolladdiererEin 1-Bit Volladdierer hat die Aufgabe, drei Eingänge zu verarbeiten:

• A: Erster Operand
• B: Zweiter Operand
• C_{in}: Übertrags-Bit

• S: Die Summe des Addierers
• C_{out}: Der Übertrag (Carry-Out)

• UND (Konjunktion): A \bullet B
• ODER (Disjunktion): A + B
• NICHT (Negation): \bar{A}
• NAND: \bar{A \bullet B}
• NOR: \bar{A + B}
• XOR (Exklusives ODER): A \text{ XOR } B

• Summe (S):Die Summe bei einem 1-Bit Volladdierer kann ausgedrückt werden als:
  S = A \text{ XOR } B \text{ XOR } C_{in}
• Übertrag (C_{out}):Der Übertrag bei einem 1-Bit Volladdierer kann ausgedrückt werden als:
  C_{out} = (A \bullet B) + (C_{in} \bullet (A \text{ XOR } B))

b)

Teilaufgabe 2: Implementiere die oben formulierte 1-Bit Volladdierer-Schaltung in VHDL. Erstelle den entsprechenden VHDL-Code und simuliere die Schaltung, um sicherzustellen, dass sie korrekt funktioniert. Die Simulationsumgebung sollte die Wahrheitstabelle für alle möglichen Eingabekombinationen von \(A\), \(B\) und \(C_{in}\) generieren.

 library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity Volladdierer is    Port ( A : in  STD_LOGIC;           B : in  STD_LOGIC;           C_in : in  STD_LOGIC;           S : out  STD_LOGIC;           C_out : out  STD_LOGIC); end Volladdierer; architecture Behavioral of Volladdierer is begin    S <= A XOR B XOR C_in;    C_out <= (A AND B) OR (C_in AND (A XOR B)); end Behavioral; -- Testbench Code library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity tb_Volladdierer is end tb_Volladdierer; architecture Behavioral of tb_Volladdierer is    component Volladdierer       Port ( A : in  STD_LOGIC;              B : in  STD_LOGIC;              C_in : in  STD_LOGIC;              S : out  STD_LOGIC;              C_out : out  STD_LOGIC);    end component;    signal A : STD_LOGIC := '0';    signal B : STD_LOGIC := '0';    signal C_in : STD_LOGIC := '0';    signal S : STD_LOGIC;    signal C_out : STD_LOGIC; begin    uut: Volladdierer       Port map ( A => A,                  B => B,                  C_in => C_in,                  S => S,                  C_out => C_out);    process    begin       -- Test case 0       A <= '0'; B <= '0'; C_in <= '0';       wait for 10 ns;       -- Test case 1       A <= '0'; B <= '1'; C_in <= '0';       wait for 10 ns;       -- Test case 2       A <= '1'; B <= '1'; C_in <= '1';       wait for 10 ns;       -- Add additional test cases as necessary       wait;    end process; end Behavioral;

Lösung:

Hier ist der VHDL-Code, der eine 1-Bit Volladdierer-Schaltung implementiert und die grundlegende Testbench beinhaltet, um die Funktionsweise zu überprüfen:1-Bit Volladdierer - VHDL Code:

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity Volladdierer is    Port (         A : in  STD_LOGIC;        B : in  STD_LOGIC;        C_in : in  STD_LOGIC;        S : out  STD_LOGIC;        C_out : out  STD_LOGIC    );end Volladdierer;architecture Behavioral of Volladdierer isbegin    S <= A XOR B XOR C_in;    C_out <= (A AND B) OR (C_in AND (A XOR B));end Behavioral;

library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity tb_Volladdierer isend tb_Volladdierer;architecture Behavioral of tb_Volladdierer is    component Volladdierer        Port (             A : in  STD_LOGIC;            B : in  STD_LOGIC;            C_in : in  STD_LOGIC;            S : out  STD_LOGIC;            C_out : out  STD_LOGIC        );    end component;    signal A : STD_LOGIC := '0';    signal B : STD_LOGIC := '0';    signal C_in : STD_LOGIC := '0';    signal S : STD_LOGIC;    signal C_out : STD_LOGIC;begin    uut: Volladdierer        Port map (            A => A,            B => B,            C_in => C_in,            S => S,            C_out => C_out        );    process    begin        -- Test case 0        A <= '0'; B <= '0'; C_in <= '0';        wait for 10 ns;        -- Test case 1        A <= '0'; B <= '1'; C_in <= '0';        wait for 10 ns;        -- Test case 2        A <= '1'; B <= '0'; C_in <= '0';        wait for 10 ns;        -- Test case 3        A <= '1'; B <= '1'; C_in <= '0';        wait for 10 ns;        -- Test case 4        A <= '0'; B <= '0'; C_in <= '1';        wait for 10 ns;        -- Test case 5        A <= '0'; B <= '1'; C_in <= '1';        wait for 10 ns;        -- Test case 6        A <= '1'; B <= '0'; C_in <= '1';        wait for 10 ns;        -- Test case 7        A <= '1'; B <= '1'; C_in <= '1';        wait for 10 ns;        wait;    end process;end Behavioral;

• Der Volladdierer-Code beschreibt die logischen Operationen zur Berechnung der Summe S und des Übertrags C_out.
• Die Testbench initialisiert die Signale A, B und C_in und testet alle möglichen Kombinationen der Eingaben, indem sie die entsprechenden Ausgaben feststellt. Jeder Zustand wird durch eine Wartezeit von 10 ns überprüft.

Aufgabe 2)

Flip-Flops und RegisterFlip-Flops und Register sind grundlegende Speicherelemente in digitalen Schaltungen, die Zustände speichern können.

• Flip-Flops speichern 1 Bit Information.
• Register bestehen aus mehreren Flip-Flops und speichern mehrere Bits.
• Flip-Flops typischerweise synchron (gesteuert durch eine Taktflanke).
• Wichtige Typen: D-Flip-Flop, JK-Flip-Flop, T-Flip-Flop.
• Registerarten: Schieberegister, Parallelregister, zirkulare Register.
• VHDL-Syntax:
• Flip-Flop:

   process (clk)  begin  if rising_edge(clk) then  q <= d;  end if;  end process; 

• Register:

   signal register : std_logic_vector(N-1 downto 0); 

a)

Implementiere ein D-Flip-Flop in VHDL, das einen Eingangsbit 'd' speichert und bei einer steigenden Taktflanke auf den Ausgang 'q' überträgt. Achte dabei auf die korrekte Verwendung der VHDL-Syntax.

Lösung:

Implementiere ein D-Flip-Flop in VHDL

In dieser Aufgabe implementierst Du ein D-Flip-Flop in VHDL, das einen Eingangsbit 'd' speichert und bei einer steigenden Taktflanke auf den Ausgang 'q' überträgt. Achte dabei auf die korrekte Verwendung der VHDL-Syntax.

 library ieee;  use ieee.std_logic_1164.all;  entity DFlipFlop is  port (  clk : in std_logic;  -- Takteingang  d : in std_logic;    -- Dateneingang  q : out std_logic    -- Datenaugang  );  end DFlipFlop;  architecture Behavioral of DFlipFlop is  begin  process (clk)  begin  if rising_edge(clk) then  q <= d;  end if;  end process;  end Behavioral;  

• Erklärung:
• Die Bibliotheksanweisungen library ieee; und use ieee.std_logic_1164.all; sind notwendig, um die Standard-Logik-Typen und -Operatoren von VHDL zu nutzen.
• Die Entity beschreibt das Interface des Flip-Flops, also die Eingangs- und Ausgangsports.
• Im Architekturteil wird die eigentliche Schaltung implementiert. Das Process-Statement beschreibt die Logik, die bei einer steigenden Taktflanke den Wert von 'd' auf 'q' überträgt.

b)

Erweitere Dein D-Flip-Flop aus Teilaufgabe 1 zu einem 4-Bit-Register. Stelle sicher, dass das Register bei jeder steigenden Taktflanke die 4-Bit-Eingabewerte speichert und an den 4-Bit-Ausgang weiterleitet.

Lösung:

Erweiterung zu einem 4-Bit-Register in VHDL

In dieser Aufgabe erweiterst Du das D-Flip-Flop aus der vorherigen Teilaufgabe zu einem 4-Bit-Register. Dieses Register speichert bei jeder steigenden Taktflanke die 4-Bit-Eingabewerte und leitet sie an den 4-Bit-Ausgang weiter.

 library ieee;  use ieee.std_logic_1164.all;  entity Register4Bit is  port (  clk : in std_logic;                       -- Takteingang  d   : in std_logic_vector(3 downto 0);  -- 4-Bit Dateneingang  q   : out std_logic_vector(3 downto 0)  -- 4-Bit Datenaugang  );  end Register4Bit;  architecture Behavioral of Register4Bit is  begin  process (clk)  begin  if rising_edge(clk) then  q <= d;  end if;  end process;  end Behavioral;  

• Erklärung:
• Die Bibliotheksanweisungen library ieee; und use ieee.std_logic_1164.all; sind notwendig, um die Standard-Logik-Typen und -Operatoren von VHDL zu nutzen.
• Die Entity beschreibt das Interface des 4-Bit-Registers, also die Eingangs- und Ausgangsports
• Die Eingänge sind clk (Takteingang) und d (4-Bit Dateneingang).
• Der Ausgang ist q (4-Bit Datenaugang).
• Im Architekturteil wird die eigentliche Schaltung implementiert. Das Prozess-Statement beschreibt die Logik, die bei einer steigenden Taktflanke den Wert von 'd' auf 'q' überträgt.

c)

Erläutere den Unterschied zwischen einem Parallelregister und einem Schieberegister. Implementiere ein 4-Bit-Schieberegister in VHDL, das seine Werte bei jeder Taktflanke eine Position nach rechts verschiebt. Beschreibe die Funktion und Anwendung eines solchen Schieberegisters.

Lösung:

Unterschied zwischen Parallelregister und Schieberegister

• Parallelregister: Ein Parallelregister speichert mehrere Bits gleichzeitig und kann alle diese Bits parallel zur gleichen Zeit lesen oder schreiben. Es besteht aus mehreren Flip-Flops, die synchron arbeiten.
• Schieberegister: Ein Schieberegister speichert auch mehrere Bits, jedoch werden die Bits bei jeder Taktflanke um eine Position verschoben. Es gibt serielle Eingabe und/oder Ausgabe, was bedeutet, dass die Bits nacheinander (nicht parallel) verschoben werden.

VHDL-Implementierung eines 4-Bit-Schieberegisters

 library ieee;  use ieee.std_logic_1164.all;  entity ShiftRegister is  port (  clk : in std_logic;                      -- Takteingang  serial_in : in std_logic;               -- Serieller Eingabewert  q : out std_logic_vector(3 downto 0)    -- 4-Bit Datenaugang  );  end ShiftRegister;  architecture Behavioral of ShiftRegister is  signal register : std_logic_vector(3 downto 0);  begin  process (clk)  begin  if rising_edge(clk) then  register <= serial_in & register(3 downto 1);  end if;  end process;  q <= register;  end Behavioral;  

• Erklärung:
• Die Bibliotheksanweisungen library ieee; und use ieee.std_logic_1164.all; sind notwendig, um die Standard-Logik-Typen und -Operatoren von VHDL zu nutzen.
• Die Entity beschreibt das Interface des Schieberegisters.
• Die Eingänge sind clk (Takteingang) und serial_in (Serieller Eingabewert).
• Der Ausgang ist q, ein 4-Bit Datenaugang.
• Im Architekturteil wird die eigentliche Schaltung implementiert. Das Prozess-Statement beschreibt die Logik, die bei einer steigenden Taktflanke die Bits um eine Position nach rechts verschiebt und den neuen serial_in-Wert links einfügt.
• Das Schieberegister kann verwendet werden in Anwendungen wie Datenpaktübertragung, Digital-zu-Analog-Wandler und Sequenzgenerierung.

Aufgabe 3)

Entwirf eine VHDL-Datei für einen einfachen 4-Bit-Zähler. Ein 4-Bit-Zähler zählt von 0 bis 15 und setzt sich beim Erreichen von 15 wieder auf 0 zurück. Du sollst die Grundstruktur einer VHDL-Datei gemäß dem folgenden Aufbau verwenden:

• Library und Use-Anweisungen: Importieren von Bibliotheken und Paketen
• Entity-Deklaration: Definition der externen Schnittstellen (Eingänge/Ausgänge)
• Architecture-Deklaration: Beschreibung des internen Verhaltens und der internen Struktur
• Signal- und Komponentendeklarationen: Definition von Signalen und untergeordneten Einheiten
• Prozessblöcke und Concurrent Statements: Beschreibung des zeitlichen Verhaltens und der parallelen Abläufe

a)

Schreibe die Entity-Deklaration für den 4-Bit-Zähler, inkludiere die notwendigen Eingänge und Ausgänge. Berücksichtige dabei einen Eingang zum Zurücksetzen des Zählers, einen Eingang für den Takt und einen Ausgang, der den aktuellen Zählwert anzeigt. Die Eingänge und Ausgänge sollten die korrekten Datentypen und Größen haben.

Lösung:

Lösung für die Entity-Deklaration eines 4-Bit-Zählers:

Hier ist die Entity-Deklaration für einen einfachen 4-Bit-Zähler in VHDL. Diese Deklaration umfasst die notwendigen Eingänge und Ausgänge, darunter einen Eingang zum Zurücksetzen des Zählers, einen Eingang für den Takt und einen Ausgang, der den aktuellen Zählwert anzeigt:

library IEEE;use IEEE.STD_LOGIC_1164.ALL;use IEEE.STD_LOGIC_ARITH.ALL;use IEEE.STD_LOGIC_UNSIGNED.ALL;entity Zaehler is    Port (        clk : in STD_LOGIC;             -- Takteingang        reset : in STD_LOGIC;           -- Eingang zum Zurücksetzen des Zählers        count : out STD_LOGIC_VECTOR (3 downto 0) -- Ausgang für den aktuellen Zählwert    );end Zaehler;

• clk: Der Takteingang (in STD_LOGIC), welcher die Taktrate des Zählers bestimmt.
• reset: Der Eingang, um den Zähler zurückzusetzen (in STD_LOGIC).
• count: Der Ausgang, welcher den aktuellen Zählwert darstellt (out STD_LOGIC_VECTOR (3 downto 0)).

Diese Entity-Deklaration legt die äußeren Schnittstellen des 4-Bit-Zählers fest und bereit die Grundlage für die anschließende Architektur-Deklaration und die interne Verhaltensbeschreibung.

b)

Entwickle die Architecture-Deklaration dieses 4-Bit-Zählers. Verwende Signale zur Speicherung des aktuellen Zählwertes. Beschreibe das Verhalten des Zählers in einem Prozessblock, der auf den Takteingang reagiert. Der Zähler soll mit jedem Taktzyklus den Zählwert um 1 erhöhen und beim Erreichen des Wertes 15 wieder auf 0 gesetzt werden.

Lösung:

Architecture-Deklaration für den 4-Bit-Zähler:

Hier ist die vollständige Architecture-Deklaration für einen einfachen 4-Bit-Zähler in VHDL. Diese Deklaration verwendet ein Signal zur Speicherung des aktuellen Zählwertes und beschreibt das Verhalten des Zählers in einem Prozessblock, der auf den Takteingang reagiert:

architecture Verhalten of Zaehler is    signal count_internal : STD_LOGIC_VECTOR (3 downto 0);    -- Internes Signal zur Speicherung des Zählwertesbegin    process(clk, reset)    begin        if reset = '1' then            count_internal <= (others => '0'); -- Zähler auf 0 setzen bei Reset        elsif rising_edge(clk) then            if count_internal = "1111" then                count_internal <= (others => '0'); -- Zurücksetzen auf 0 bei Erreichen von 15            else                count_internal <= count_internal + 1; -- Zähler um 1 erhöhen            end if;        end if;    end process;    count <= count_internal; -- Zuweisung des internen Zählwertes an den Ausgangend Verhalten;

• count_internal: Ein internes Signal vom Typ STD_LOGIC_VECTOR, das den aktuellen Zählwert speichert.
• process(clk, reset): Ein Prozessblock, der auf Änderungen an den Signalen clk und reset reagiert.
• if reset = '1' then: Dieser Block setzt den Zähler auf 0 zurück, wenn das Reset-Signal aktiv (logisch 1) ist.
• elsif rising_edge(clk) then: Dieser Teil des Prozessblocks reagiert auf eine steigende Flanke des Taktsignals clk.
• if count_internal = "1111" then: Wenn der Zählwert 15 erreicht, wird der Zähler auf 0 zurückgesetzt.
• else: Andernfalls wird der Zählwert um 1 erhöht.
• count <= count_internal: Schließlich wird der aktuelle Zählwert an den Ausgang count weitergegeben.

Diese Architecture-Deklaration beschreibt das Verhalten des 4-Bit-Zählers im Detail und stellt sicher, dass der Zähler korrekt von 0 bis 15 zählt und sich anschließend zurücksetzt.

Aufgabe 4)

Kontext: Du hast eine einfache AND-Gatter-Komponente in VHDL mit den Signalen 'A' und 'B' als Eingänge und 'Y' als Ausgang zu entwerfen. Verwende die entsprechenden VHDL-Entwurfsstrukturen: Entity und Architecture.Entity:

• Definiert die Schnittstelle einer Komponente, enthält Ports (Eingänge/Ausgänge).
• Syntax:

  entity Name is   port (    Signal1: in std_logic;     Signal2: out std_logic   );end Name;

• Beschreibt das Verhalten und die interne Struktur der Komponente.
• Syntax:

  architecture ArchName of Name isbegin  -- Verhaltensbeschreibungend ArchName;

a)

Definiere die Entity für das AND-Gatter, das zwei Eingänge ('A' und 'B') und einen Ausgang ('Y') hat. Achte darauf, dass die Signale den Typ std_logic verwenden.

Lösung:

Subexercise:Definiere die Entity für das AND-Gatter, das zwei Eingänge ('A' und 'B') und einen Ausgang ('Y') hat. Achte darauf, dass die Signale den Typ std_logic verwenden.Entity Definition:

entity AND_Gate is  port (    A: in std_logic;    B: in std_logic;    Y: out std_logic  );end AND_Gate;

b)

Implementiere die entsprechende Architecture für das oben definierte AND-Gatter. Beschreibe das Verhalten des Gatters in der beschriebenen Architektur.

Lösung:

Subexercise:Implementiere die entsprechende Architecture für das oben definierte AND-Gatter. Beschreibe das Verhalten des Gatters in der beschriebenen Architektur.Architecture Implementation:

architecture Behavioral of AND_Gate isbegin  -- Beschreibe das Verhalten des AND-Gatters  Y <= A and B;end Behavioral;

c)

Erkläre die Bedeutung der begin- und end-Schlüsselwörter in der Architecture Definition. Wie unterscheiden sich diese von denen in der Entity Definition?

Lösung:

Subexercise:Erkläre die Bedeutung der begin- und end-Schlüsselwörter in der Architecture Definition. Wie unterscheiden sich diese von denen in der Entity Definition?

• Bedeutung in der Architecture Definition:

Das begin-Schlüsselwort in einer Architecture Definition markiert den Beginn des Bereichs, in dem das Verhalten der Komponente beschrieben wird. Hier werden die logischen Ausdrücke und Zuweisungen definiert, die das Verhalten des Schaltkreises bestimmen. Das end-Schlüsselwort schließt die Architektur-Beschreibung ab.

• Beispiel:

  architecture Behavioral of AND_Gate isbegin  -- Verhalten des Gatters  Y <= A and B;end Behavioral;

• Bedeutung in der Entity Definition:

In der Entity Definition wird das begin-Schlüsselwort nicht verwendet. Hier geht es vielmehr darum, die Schnittstelle der Komponente zu definieren, d.h. die Art und Richtung der Signale (Ports), die die Komponente erwartet und ausgibt. Das end-Schlüsselwort dient dazu, die Entity-Definition abzuschließen.

• Beispiel:

  entity AND_Gate is  port (    A: in std_logic;    B: in std_logic;    Y: out std_logic  );end AND_Gate;

Hauptunterschiede:

• Entity: Definiert die Schnittstelle und verwendet kein begin.
• Architecture: Beschreibt das Verhalten der Komponente und verwendet begin und end zur Abgrenzung dieses Verhaltens.

d)

Schreibe eine Testbench in VHDL für das oben definierte AND-Gatter. Die Testbench sollte alle möglichen Kombinationen der Eingänge 'A' und 'B' ausprobieren (also 00, 01, 10, 11) und die Ausgabe 'Y' entsprechend überprüfen.

Lösung:

Subexercise:Schreibe eine Testbench in VHDL für das oben definierte AND-Gatter. Die Testbench sollte alle möglichen Kombinationen der Eingänge 'A' und 'B' ausprobieren (also 00, 01, 10, 11) und die Ausgabe 'Y' entsprechend überprüfen.Testbench Implementation:

LIBRARY ieee;USE ieee.std_logic_1164.ALL;ENTITY AND_Gate_tb ISEND AND_Gate_tb;ARCHITECTURE behavior OF AND_Gate_tb IS     -- Component Declaration for the Unit Under Test (UUT)    COMPONENT AND_Gate    PORT(         A : IN  std_logic;         B : IN  std_logic;         Y : OUT  std_logic        );    END COMPONENT;      -- Inputs   signal A : std_logic := '0';   signal B : std_logic := '0';       -- Outputs   signal Y : std_logic;      -- Clock period definitions   constant clk_period : time := 10 ns;BEGIN   -- Instantiate the Unit Under Test (UUT)   uut: AND_Gate PORT MAP (          A => A,          B => B,          Y => Y        );   -- Stimulus process   stim_proc: process   begin            -- hold reset state for 100 ns.      wait for 100 ns;                -- Test all combinations of A and B      A <= '0'; B <= '0'; wait for clk_period;      A <= '0'; B <= '1'; wait for clk_period;      A <= '1'; B <= '0'; wait for clk_period;      A <= '1'; B <= '1'; wait for clk_period;            -- Insert stimuli here       wait;   end process;END;