In diesem Versuch werden Flipflops und darauf aufbauend sequentielle Schaltungen entworfen.

Zunächst müssen Sie Ihre git Datenbasis aktualisieren, damit die aktuellen Datein vom git server heruntergeladen werden.

cd
cd projects/digitaltechnikpraktikum
git pull

Analysieren Sie die Schaltung in der Datei de1_flipflop_rtl.vhd. Beispiele für die VHDL Beschreibung von Flipflops finden Sie hier dt-code-sequ.

1. Zeichnen Sie die Schaltung auf Papier anhand der VHDL Beschreibung
2. Beschreiben Sie in Worten welches Verhalten Sie am Ausgang LEDG(2) erwarten.
3. Beschreiben Sie in Worten welches Verhalten Sie an den Ausgängen LEDG(6) und LEDG(7) erwarten.
4. Beschreiben Sie die Schaltung, die das Verhalten an den Ausgängen LEDG(6) und LEDG(7) bestimmt als Automatengraph.
5. Geben Sie dazu die Zustandsfolgetabelle und die Ausgangstabelle an.

Zu dieser Schaltung gibt es eine passende Testbench t_de1_flipflop.vhd für die Simulation der Schaltung.

1. Starten Sie die Simulation im Verzeichnis “sim/de1_flipflop” und schauen Sie sich die Waveform an.
2. Vergleichen Sie das Verhalten in der Simulation mit Ihrer Schaltungsanalyse

Weiterhin gibt es auch ein Syntheseverzeichnis inklusive makefiles für die Synthese der Schaltung.

1. Starten Sie die Synthese der Schaltung im Verzeichnis “pnr/de1_flipflop”.
2. Laden Sie das Design auf das FPGA Board
3. Demonstrieren Sie die Funktion der Schaltung!

Analog zum Blinklicht aus der Vorlesung entwerfen Sie jetzt eine Schaltung, mit der die roten LEDS mit einer bestimmten Blinkfolge leuchten sollen. Die Blinkfolge ist abhängig von der Schalterstellung an SW(0).

SW(0) = 0, dann
Schritt1 - XXX0000XXX
Schritt2 - 0XXX00XXX0
Schritt3 - 000XXXX000

SW(0) = 1, dann
Schritt1 - XXX0000XXX
Schritt2 - 0X0X0X0X0X
Schritt3 - 000XXXX000

X = an, 0 = aus

1. Entwerfen Sie einen Mooreautomaten, der diese Blinkfolge erzeugt. Zeichnen Sie den Automatengraphen.
2. Legen Sie eine binäre Zustandskodierung fest. Wie viele Flipflops benötigen Sie für die Kodierung?
3. Welche Eingänge und welche Ausgänge hat der Automat?
4. Zeichnen Sie die Zustandsfolgetabelle und die Ausgangstabelle.
5. Geben Sie die Zustandsübergangslogik als boolesche Ausdrücke an.

Für den VHDL Entwurf des Blinklichtautomaten gibt es eine vorbereitete Datei de1_blinklicht_rtl.vhd und eine zugehörige Testbench t_de1_blinklicht.vhd. Dort können Sie die Ergänzungen direkt vornehmen. Das Verzeichnis “pnr/de1_blinklicht” für die Synthese und das Verzeichnis “sim/de1_blinklicht” für die Simulation sind mit den makefiles schon vorbereitet.

1. Entwerfen Sie den Automaten in VHDL
2. Simulieren Sie den Entwurf
3. Synthetisieren Sie die Schaltung und probieren Sie den Automaten auf dem FPGA Board aus.

In der Vorlesung haben Sie einen Zähler kennengelernt, der mit einem Ladesignal auf den Wert 5 gesetzt wird und dann runterzählt. Wenn der Zählerstand 0 ist, dann hört der Zähler auf zu zählen. Um genau diesen Zähler in VHDL zu beschreiben benötigt man einen Datentypen mit dem eine Gruppe von Signalen als Zahl interpretiert werden kann. Dann sind auch Operationen wie eine Addition oder ein Vergleich möglich. Ein solcher Datentyp ist “signed” oder “unsigned”. Eine Darstellung der verschiedenen Operationen finden Sie hier dt-code-vecnum.

Der folgende Code beschreibt ein Register mit 16 Bit Breite. Mit jedem Takt werden die 16 Bit Daten am Eingang in das Register übernommen. Der Datentyp des Registers ist “unsigned” damit man im folgenden mit den Werten rechnen kann.

library ieee;
use ieee.std_logic_1164.all; 
use ieee.numeric_std.all; 
 
entity example is
port(
  clk   : in std_ulogic;
  res_n : in std_ulogic;
  d_i   : std_ulogic_vector(15 downto 0)); 
end entity; 
 
architecture rtl of example is
 
  signal cnt : unsigned(15 downto 0); --Zahlen von 0 bis 65535
 
begin
 
  cnt <= "0000000000000000" when res_n = '0' else unsigned(x_i) when rising_edge(clk); 
 
end architecture rtl; 

Für den Zähler benötigen Sie dann noch einen Multiplexer, der wie hier dt-code beschrieben am einfachsten mit einem conditional signal assignment beschrieben wird.

y <= a_i when sel_i = '0' else b_i; 

Den Zahlenvergleich können Sie bei einem “unsigned” Typen direkt so machen:

architecture rtl of example is
  signal x                   : unsigned(7 downto 0); -- Zahlen von 0 bis 255
  signal x_is_greater_than_5 : std_ulogic; 
begin
x_is_greater_than_5 <= '1' when x > 5 else '0'; 
end architecture;  

Bei diesem Vergleich wird das Signal “x_is_greater_than_5” auf '1' gesetzt, wenn die Zahl x größer ist als 5. Ansonsten ist der Wert '0'.

Für den folgenden Entwurf ist eine Datei cnt15_rtl.vhd vorbereitet. Diese Datei soll den Zähler enthalten.

1. Entwerfen Sie einen ladbaren Rückwärtszähler, der beim Laden auf den Startwert 13 gesetzt wird.
2. Wenn der Zähler den Wert 0 erreicht hat, dann soll der Zähler auf 0 stehen bleiben.
3. Zeichnen Sie eine Architektur auf Papier bestehend aus Register, Addierer, Vergleicher und Multiplexer.
4. Beschreiben Sie den Zähler in der Datei cnt15_rtl.vhd.

Dieser Zähler wird in der Datei de1_cnt15_rtl.vhd mit den Ein- und Ausgängen auf dem FPGA verbunden. Zusätzliche wird der Zählerstand auf der HEX0 Anzeige ausgegeben. Für diese Schaltung ist eine Testbench vorbereitet in der Datei t_de1_cnt15.vhd.

1. Zeichnen Sie die Schaltung, die in de1_cnt15_rtl.vhd beschrieben ist auf Papier.
2. Simulieren Sie die Gesamtschaltung im Verzeichnis “sim/de1_cnt15”
3. Synthetisieren Sie die Schaltung im Verzeichnis “pnr/de1_cnt15” und probieren Sie die Schaltung auf dem FPGA aus.