91����

Dieser Versuch führt sequentielle Schaltungen, d.h. Schaltungen mit Flipflops ein.

Die erste sequentielle Schaltung ist ein Modulo 256 ��ä������, d.h. ein ��ä������, der von 0 bis 255 zählt und dann wieder von vorn mit 0 beginnt. Der ��ä������stand soll als hexadezimale Ausgabe auf der 7-Segment Anzeige ausgegeben werden. Gleichzeitig soll der ��ä������stand binär auf die roten LEDs ausgegeben werden.

Im ersten Schritt wird der ��ä������ mit der Taste KEY0 getaktet und kann mit KEY1 zurückgesetzt werden. Der Code für den ��ä������ ist hier:

Code für den ��ä������

1. Erstellen Sie ein Verzeichnis p1
2. Laden Sie den Code in dieses Verzeichnis.
3. Übernehmen Sie bin2seg.vhd aus dem letzten Versuch. Ergänzen Sie die Ziffern a-f.
4. Simulieren Sie den Code mit Modelsim und erläutern Sie die Funktion.
5. Ändern Sie den Code in counter.vhd um die Funktion des ��ä������s zu erhalten.
6. Simulieren Sie die neue Schaltung und überprüfen Sie die Funktion.
7. Synthetisieren Sie die Schaltung mit Quartus und laden Sie die Schaltung auf das FPGA.
8. Demonstrieren Sie die Funktion
9. Modifizieren Sie die Schaltung und takten Sie die Schaltung mit SW0.
10. Überprüfen Sie die Funktion auf dem Board

Bislang wird der ��ä������ direkt mit dem Taster KEY0 getaktet. Die Schaltung soll jetzt so umgebaut werden, dass als Systemtakt für alle Flipflops ein 50 MHz Takt von einem Taktgenerator vom Board verwendet werden soll. Weiterhin soll die Schaltungaber jeweils um eins hochzählen, wenn der Taster KEY0 gedrückt wird.

Das Problem ist, dass auch ein sehr kurzes Drücken des Tasters KEY0 um Größenordnungen langsamer als die Taktperiode des 50 MHz Taktes ist. Zur Lösung des Problems müssen Sie eine Schaltung entwerfen, die nur für die Dauer eines Taktsignals ein Signal erzeugt, wenn sich der Zustand des Signals KEY0 von 0 nach 1 ändert.

Die Schaltungsidee ist die folgende:

1. Speichern Sie den Zustand des Signals KEY0 in einem Flipflop, das mit dem Systemtakt von 50 MHz getaktet ist.
2. Am Ausgang dieses Flipflops ist das Signal KEY0 um eine Taktperiode gegenüber dem Eingang des Flipflops verzögert.
3. Wenn zwischen dem Ausgang des Flipflops und dem Signal KEY0 ein Unterschied besteht, dann hat sich das Signal KEY0 offensichtlich verändert.
4. Werten Sie diesen Unterschied aus und erzeugen Sie ein Signal von der Dauer eines Taktes.

Jetzt haben Sie ein Signal, dass einen Takt lang aktiv ist, wenn sich das Signal KEY0 von 0 auf 1 ändert. Nun muss der ��ä������ noch so verändert werden, dass er nur dann zählt, wenn ein “enable” signal aktiv ist.

Der noch nicht ganz fertige Code für die Schaltung ist hier:

Code für den ��ä������ mit Enable und die Flankenerkennung

1. Erstellen Sie ein neues Verzeichnis p2 und laden Sie die Dateien in dieses Verzeichnis
2. Übernehmen Sie counter.vhd und bin2seg.vhd aus dem Verzeichnis p1.
3. Fügen Sie ein neues Signal “enable_i” in die Entity von counter ein.
4. Ergänzen Sie die Funktionalität von counter so, dass er nur noch zählt, wenn dieses “enable_i” Signal “1” ist.
5. Ergänzen Sie das neue Modul edge so, dass die steigende Flanke von key_i erkannt werden.
6. Verbinden Sie auf dem Toplevel das Module edge und den counter.
7. Simulieren Sie die Schaltung
8. Laden Sie die Schaltung auf das FPGA

Bislang wird der ��ä������ von dem Schalter KEY0 kontrolliert. Jetzt soll der ��ä������ autonom im Sekundentakt hochzählen. Dazu soll allerdings weiter der 50MHz Systemtakt vom Board verwendet werden. Deshalb soll jetzt das Enablesignal aus einem neuen ��ä������ “counter_long” generiert werden, der im Systemtakt mit 50 MHz hochzählt und nach 50 Mio. Takten jeweils ein Enablesignal für einen Takt lang auf “1” setzt. Mit diesem Enablesignal wird dann der bekannte ��ä������ gesteuert.

Code für den Vorteiler

1. Legen Sie ein neues Verzeichnis p3 an und kopieren Sie die bisherigen VHDL Dateien in dieses Verzeichnis
2. Laden Sie die neue Datei “counter_long.vhd” zusätzlich in dieses Verzeichnis.
3. Modifizieren Sie counter_long.vhd so, dass der ������� in jeder Sekunde ein enable Signal erzeugt.
4. Integrieren Sie counter_long in den Toplevel.
5. Simulieren Sie die Schaltung
6. Laden Sie die Schaltung auf das FPGA

Der ��ä������ soll jetzt so erweitert werden, dass mit KEY0 ein Wert in den ��ä������ geladen wird, der an den Schalter SW(7..0) eingestellt wird. Der ��ä������ soll also wie bisher im Sekundentakt zählen, aber wenn KEY0 gedrückt wird, dann lädt der ��ä������ den Wert von SW(7..0) und zählt dann ab diesem Wert weiter.

1. Legen Sie ein neues Verzeichnis p4 an und kopieren Sie die bisherigen VHDL Dateien dorthin.
2. Verändern Sie counter.vhd so, dass die zusätzlichen Signale “load_i” und “load_data_i” in der Entity erscheinen. An load_data_i sollen die zu ladenden Daten für den ��ä������ anliegen.
3. Integrieren Sie den neuen counter im Toplevel.
4. Testen Sie die Schaltung auf dem FPGA.