UART Receiver mit FPGA und VHDL

Bauen Sie einen UART Empfänger, der seriell Daten empfängt und dann an den roten LEDs anzeigt.

Aktualisieren Sie das dtlab Projekt mit

cd ~/projects/dtlab
git pull

Die Datei top_uart.vhd beschreibt das Modul “top_uart”. “top_uart” stellt den toplevel auf dem FPGA dar. Das ist der gleiche toplevel wie bei der letzten Aufgabe. In das Modul wird zusätzlich zu dem vorhanden UART Transmitter jetzt der UART Receiver eingebaut. Die Gesamtschaltung kann dann senden und empfangen.

Auf dem FPGA soll zusätzlich zum dem UART Transmitter ein UART Receiver aufgebaut werden, mit dem man Zeichen von einem Rechner empfangen kann. Die Übertragung hat die folgenden Parameter

57600 Baud
Acht Datenbits, kein Paritybit
Ein Stopbit

Die Architektur des UART Receivers ist in Abbildung 1 dargestellt.

Abbildung 1: UART Receiver Architektur auf dem FPGA

Der Receiver soll wie in Abbildung 2 dargestellt auf dem toplevel eingebaut werden.

Abbildung 2: UART Receiver auf toplevel

Die Daten kommen auf UART_RXD seriell an. Nach dem Empfang werden die acht empfangenen Datenbits auf den roten LEDs dargestellt.

Abbildung 3: UART Receiver Timing

In Abbildung 3 ist das Timing der Schaltung für eine Bitdauer von vier Systemtakten dargestellt. Das wäre eine Baudrate von 15 MBit/s bei einer Systemtaktfrequenz von 50 MHz. Das wäre also viel zu schnell. So kann aber das Zusammenspiel der Komponenten einfacher dargestellt werden.

Die Komponenten "uart_rx_baudcnt", "uart_rx_bitcnt", "uart_rx_shift" und "uart_rx"sind als leere Architectures schon im Projekt vorhanden
Die "uart_rx_edge" Komponente enthält einen Flankendetektor und eine Verzögerungs- und Synchronisierstufe.
Instantiieren Sie die Komponenten “uart_rx_bitcnt”, “uart_rx_baudcnt”, “edge” und “uart_rx_shift” in “uart_rx” und verbinden Sie die Komponenten gemäß Abbildung 1
Instantiieren Sie “uart_rx” in “top_uart” gemäß Abbildung 2
Überprüfen Sie die Struktur mit dem RTL Viewer aus der Synthese

Die Testbench "t_top_uart" dient zur Simulation von “top_uart”. Dort ist ein simulierter UART Transmitter mit 57600 Baud enthalten.

Stellen Sie im Simulator sicher, dass die Daten korrekt empfangen werden

Die Komponente “uart_rx_edge” enthält einen Flankendetektor und eine Synchronisierstufe. Das Modul sorgt dafür, dass das Flankenerkennungssignal “edge” aktiv wird, bevor das Signal an “rxd_o” von 1 auf 0 geht.

Analysieren Sie den VHDL Code in “uart_rx_edge”.
Zeichnen Sie die Schaltung auf Papier
Erläutern Sie das Verhalten mit einem Timingdiagramm in dem die Signale UART_RXD, uart_rxd_sync, sr, edge und clk vorkommen

Im Timingdiagramm in Abbildung 3 sind die Signale uart_rxd_sync und edge dargestellt. Ihr Timingdiagramm soll erläutern wie es dazu kommt und wie sich UART_RXD dazu verhält.

Das Modul "uart_rx_baudcnt" sorgt für das Timing der Bits. Es wird ein Signal “en_f_o” am Ende eines Bits und das Signal “en_h_o” zur Hälfte der Bitzeit ausgegeben. Dieses Timing beruht auf dem eigenen Systemtakt. Im Timingdiagramm in Abbildung 3 ist der Signalverlauf uart_rxd_sync dargestellt, der in der Abbildung perfekt zu dem Zähler “baudcnt” passt. Das echte System erzeugt die UART Signale allerdings mit einer abweichenden Frequenz. Bei der Konstruktion des Baudzähler geht man einfach davon aus, dass die eigene Taktfrequenz perfekt ist.

Entwerfen Sie eine Architektur für “uart_rx_baudcnt”.
Die Architektur soll für eine Baudrate von 57600 Baud geeignet sein.
Fangen Sie zunächst mit einer Bitdauer von 4 Takten an, wie in Abbildung 3 dargestellt.
Der Eingang “sres_i” hat die Funktion eines high aktiven, synchronen Resets.
Zeichnen Sie die Architektur auf Papier auf
Instantiieren Sie das Modul in “uart_rx”.
Der Eingang “sres_i” wird später von dem jetzt noch nicht vorhandenen Modul “uart_rx_bitcnt” erzeugt. Schreiben Sie direkt in “uart_rx” einen kurzen Code für den Simulator, der das Signal für 30 Takt auf '0', dann für drei Takte auf '1' und dann wieder auf '0' setzt.
Zeigen Sie die Funktion im Simulator wie in Abbildung 3, d.h. zeigen Sie, dass en_h und en_f korrekt erzeugt werden.

Jetzt sollte das Modul “uart_rx_baudcnt” fertig sein. Es muss später im Gesamtmodell noch die korrekte Funktion unter Beweis stellen.

Das Modul "uart_rx_shift" dient zum Empfang der Daten, die an UART_RXD ankommen. Die Daten von UART_RXD gehen allerdings erst durch die Synchronisierstufe in “uart_rx_edge” und werden um zwei Takte verzögert.

Entwerfen Sie eine Architektur für das Modul “uart_rx_shift”, mit der die Daten am Eingang “ser_i” seriell in das Schieberegister übernommen werden.
Zeichnen Sie die Architektur auf Papier auf
Schreiben Sie den VHDL Code für das Schieberegister
Instantiieren Sie das Modul in “uart_rx”

Jetzt muss das Schiebesignal “shift_i” zum richtigen Zeitpunkt wie in Abbildung 3 dargestellt kommen. Das Schiebesignal wird vom Modul “uart_rx_bitcnt” erzeugt. Prüfen Sie im Simulator die Funktion des Schieberegister zunächst mit einem kurzen Code, der das Schiebesignal zweimal aktiviert.

Das Modul "uart_rx_bitcnt" zählt nicht nur die empfangenen Bits, sondern erzeugt gleichzeitig das “shift” Signal für das Schieberegister und setzt den Baudzähler “uart_rx_baudcnt” zurück.

Der Zähler wird von dem Signal der Flankenerkennung “edge_i” und dann von den Signalen vom Baudcounter “uart_rx_baudcnt” beeinflusst.
Der Zähler soll im Wartezustand auf 0 stehen.
Ein fallende Flanke an UART_RXD sorgt dafür, dass der Zähler auf 1 geht und der Baudzähler von 0 anfängt zu zählen.
Immer wenn der Baudzähler fertig ist, zählt der Bitzähler eins weiter
Bei der Hälfte der Bitzeit wird bei den richtigen Bits das Schieberegister geschoben

Im Labor gibt es ein FTDI-RS232 Kabel zum Anschluss eines Rechners an eine RS-232 Schnittstelle. Auf dem FPGA Board ist ein MAX232 Chip mit dem die 3,3V Logiksignal auf RS-232 (+7/-7V) Niveau gewandelt werden. Das Kabel enthält einen USB-UART Konverterchip von FTDI. Das Kabel kann also per USB an einen Rechner angeschlossen werden.

Abbildung 3: FTDI RS-232 Kabel

Nach dem Einstecken des Modems erscheint unter /dev/ttyXXXXXXX ein neues Device. Unter Linux ist dies /dev/ttyUSB0, unter MacOS ist dies /dev/tty.usbserial-DM000IKG

Auf dem Rechner wird ein Terminalprogramm benötigt, mit dem die Daten von der seriellen Schnittstelle angezeigt werden können.

Unter MacOS ist screen vorinstalliert und kann so verwendet werden:

sudo screen /dev/ttyUSB0 57600

Unter MS Windows kann putty installiert und genutzt werden.

Unter Linux ist bei unseren virtuellen Maschinen gtkterm installiert und kann direkt so gestartet werden:

gtkterm --port /dev/ttyUSB0 --speed 57600 --echo

Tippen Sie im Terminalprogramm Zeichen ein und beobachten Sie, ob die Zeichen korrekt auf den roten LEDs angezeigt werden. Die ASCII Tabelle zeigt die Codes für die verschiedenen Buchstaben.