Benutzerhandbuch für den VHDLwhiz UART Test Interface Generator

Mit diesem Produkt können Sie benutzerdefinierte Schnittstellen zum Lesen und Schreiben von FPGA-Registerwerten mithilfe von UART erstellen. Das generierte VHDL-Modul und das Python-Skript ermöglichen die Interaktion mit verschiedenen Registertypen in Ihrem FPGA-Design.

Anforderungen

Python 3-Interpreter
pyserial-Paket

Protokoll

Das Produkt verwendet ein Datenrahmenprotokoll mit vier Steuerzeichen:

Name: LESE_ANFORDERUNG, Wert: 0x0A – Befehl vom Host an das FPGA, eine Schreibsequenz zu initiieren, um alle Register über UART zurückzusenden
Name: START_WRITE, Wert: 0x0B – Markiert den Beginn einer Schreibsequenz in beide Richtungen

Name: END_WRITE, Wert: 0x0C – Markiert das Ende einer Schreibsequenz in beide Richtungen
Name: FLUCHT, Wert: 0x0D – Escape-Zeichen zum Escapen von Steuerwörtern

Anweisungen zur Produktverwendung

Ausführen der Skripte

Um das Produkt zu verwenden, stellen Sie sicher, dass Sie Python 3 und das Pyserial-Paket installiert haben. Führen Sie die Skripte über einen Python 3-Interpreter aus.

Generieren benutzerdefinierter Schnittstellen

Verwenden Sie das Skript gen_uart_regs.py, um benutzerdefinierte Schnittstellen zum Lesen und Schreiben von FPGA-Registerwerten zu generieren. Sie können die Zusammensetzung der Eingabe- und Ausgaberegister und -typen beim Generieren der Ausgabe angeben files.

Interaktion mit Registern

Sie können mit dem generierten VHDL-Modul und dem Python-Skript aus einer beliebigen Anzahl von Registern in Ihrem FPGA-Design lesen oder in diese schreiben. Die zugänglichen Register können Typen wie std_logic, std_logic_vector, mit Vorzeichen oder ohne Vorzeichen haben.

Lizenz

Die MIT-Lizenz umfasst die Urheberrechtsanforderungen und Nutzungsbedingungen des Quellcodes. Siehe LICENSE.txt file im Zip file für weitere Einzelheiten.

Änderungsprotokoll

Diese Änderungen beziehen sich auf das Projekt files, und dieses Dokument wird entsprechend aktualisiert

Version	Hinweise
1.0.0	Erstveröffentlichung
1.0.1	Fehler behoben, der beim Importieren als uart_regs.py als Python-Modul zu einem fehlenden «self»-Verweis führte. Ausdruck mit fehlgeschlagenem Schreiben in Ausnahme geändert. Vermeiden Sie das Drucken auf der Konsole, wenn es als importiertes Modul ausgeführt wird.
1.0.2	Fix für Vivado [Synth 8-248]-Fehler, wenn keine Out-Mode-Regulatoren vorhanden sind.
1.0.3	Vivado Linter-Warnung beheben: Register hat aktiviert, gesteuert durch synchroner Reset
1.0.4	Beheben Sie den Sonderfall beim Empfang eines fehlerhaften Wortes mit dem Escape-Zeichen als letztem Byte. Das nächste Wort würde ebenfalls verloren gehen, da wir recv_data_prev_is_escape bei der Rückkehr zu IDLE nicht gelöscht haben. Das Skript gen_uart_regs.py erlaubt jetzt nur eindeutige Registrierungsnamen.

Beschreibung

In diesem Dokument wird Folgendes beschrieben files und Ordner:
gen_uart_regs.py

generiert/uart_regs.vhd
generiert/uart_regs.py
generiert/instantiation_template.vho
rtl/uart_regs_backend.vhd
rtl/uart_rx.vhd
rtl/uart_tx.vhd
demo/lattice_icestick/
demo/xilinx_arty_a7_35/
demo/xilinx_arty_s7_50/
Das Skript gen_uart_regs.py und die Unterstützung von VHDL fileMit den s in diesem Projekt können Sie benutzerdefinierte Schnittstellen zum Lesen und Schreiben von FPGA-Registerwerten verschiedener Typen und Breiten mithilfe von UART generieren.
Sie können das generierte VHDL-Modul und das Python-Skript verwenden, um aus einer beliebigen Anzahl von Registern in Ihrem Design zu lesen oder in diese zu schreiben. Die über UART zugänglichen Register können die Typen std_logic, std_logic_vector, signiert oder unsigniert haben.
Sie können bei der Generierung der Ausgabe über die genaue Zusammensetzung der Ein- und Ausgaberegister und -typen entscheiden files mit dem Skript gen_uart_regs.py.
Die Python-Skripte wurden teilweise mit Hilfe des künstlichen Intelligenztools ChatGPT erstellt, während der VHDL-Code handgefertigt ist.

Anforderungen

Die Skripte in diesem Projekt müssen über einen Python 3-Interpreter ausgeführt werden und das Pyserial-Paket muss installiert sein.
Sie können pyserial über Pip mit diesem Befehl installieren: pip install pyserial

Protokoll

Das VHDL files und Python-Skript verwenden ein Data-Framing-Protokoll mit vier Steuerelementen

Name	Wert	Kommentar
LESE_ANFORDERUNG	Version:	Befehl vom Host an das FPGA, einen Schreibvorgang zu initiieren Sequenz zum Zurücksenden aller Register über UART
START_WRITE	0x0B	Markiert den Beginn einer Schreibsequenz in Richtung
END_WRITE	0x0C	Markiert das Ende einer Schreibsequenz in beide Richtungen
FLUCHT	Version:	Escape-Zeichen, das zum Escapezeichen aller Steuerwörter verwendet wird, einschließlich des ESCAPE-Zeichens selbst, wenn diese als Daten zwischen den Markierungen START_WRITE und END_WRITE erscheinen.

Jedes nicht maskierte READ_REQ-Byte, das an den FPGA gesendet wird, ist eine Anweisung, alle über UART zugänglichen Register (Ein- und Ausgänge) über UART an den Host zurückzusenden. Dieser Befehl wird normalerweise nur vom Skript uart_regs.py ausgegeben.
Beim Empfang dieses Befehls antwortet das FPGA, indem es den Inhalt aller Register an den Host zurücksendet. Zuerst die Eingangssignale, dann die Ausgangssignale. Wenn sich ihre Länge nicht auf ein Vielfaches von 8 Bits summiert, werden die unteren Bits des letzten Bytes mit aufgefüllten Nullen versehen.
Eine Schreibsequenz beginnt immer mit dem START_WRITE-Byte und endet mit dem END_WRITE-Byte. Alle Bytes dazwischen werden als Datenbytes betrachtet. Wenn Datenbytes denselben Wert wie ein Steuerzeichen haben, muss das Datenbyte maskiert werden. Dies bedeutet, dass vor dem Datenbyte ein zusätzliches ESCAPE-Zeichen gesendet wird, um anzuzeigen, dass es sich tatsächlich um Daten handelt.
Wenn ein START_WRITE ohne Escapezeichen irgendwo im Bytestrom ankommt, wird es als Beginn einer Schreibsequenz betrachtet. Das Modul uart_regs_backend verwendet diese Informationen zur Neusynchronisierung, falls die Kommunikation nicht mehr synchron ist.

gen_uart_regs.py

Dies ist das Skript, mit dem Sie beginnen müssen, um die Schnittstelle zu generieren. Unten sehen Sie einen Screenshot des Hilfemenüs, das Sie erhalten können, indem Sie Folgendes ausführen: python gen_uart_regs.py -h
Um eine benutzerdefinierte Schnittstelle zu generieren, müssen Sie das Skript ausführen, wobei jedes Ihrer gewünschten UART-steuerbaren Register als Argumente aufgeführt ist. Die verfügbaren Typen sind „std_logic“, „std_logic_vector“, „unsigned“ und „signed“.
Der Standardmodus (Richtung) ist in und der Standardtyp ist std_logic_vector, es sei denn, das Register hat die Länge: 1. Dann wird standardmäßig std_logic verwendet.

Wenn Sie also ein std_logic-Eingangssignal erstellen möchten, können Sie eines dieser Argumente verwenden:
my_sl=1
my_sl=1:in

my_sl=1:in:std_logic
Alle oben genannten Varianten führen dazu, dass das Skript dieses über UART zugängliche Signal generiert:
Lassen Sie uns das Skript mit Argumenten ausführen, um eine Schnittstelle mit mehreren Registern unterschiedlicher Richtungen, Längen und Typen zu generieren

Generiert files

Eine erfolgreiche Ausführung des Skripts gen_uart_regs.py erzeugt einen Ausgabeordner mit dem Namen „generated“ mit den drei files sind unten aufgeführt. Wenn sie bereits vorhanden sind, werden sie überschrieben.
generiert/uart_regs.vhd

generiert/uart_regs.py
generiert/instantiation_template.vho
uart_regs.vhd

Dies ist das vom Skript generierte benutzerdefinierte Schnittstellenmodul. Sie müssen es in Ihrem Design instanziieren, wo es über UART auf die Register zugreifen kann, die Sie steuern möchten.
Alles oberhalb des Abschnitts „– UART-zugängliche Register“ ist für jedes uart_regs-Modul identisch, während die Zusammensetzung der Portsignale unterhalb dieser Zeile von den Argumenten abhängt, die dem Generatorskript übergeben werden.
Die folgende Auflistung zeigt die Entität für das uart_regs-Modul, die sich aus dem Generierungsbefehl ex ergibtampDie Datei wird im Abschnitt gen_uart_regs.py angezeigt

Sie müssen das uart_rx-Signal nicht synchronisieren, da dies im uart_rx gehandhabt wird. Modul.
Wenn das Modul eine Leseanforderung erhält, erfasst es die Werte aller Ein- und Ausgangssignale innerhalb des aktuellen Taktzyklus. Der sofortige Snapshot wird dann über UART an den Host gesendet.
Bei einem Schreibvorgang werden alle Ausgangsregister innerhalb desselben Taktzyklus mit den neuen Werten aktualisiert. Es ist nicht möglich, die Ausgangssignalwerte einzeln zu ändern.

Das Skript uart_regs.py ermöglicht es dem Benutzer jedoch, nur ausgewählte Ausgänge zu aktualisieren, indem er zunächst die aktuellen Werte aller Register zurückliest. Anschließend werden alle Werte zurückgeschrieben, auch die aktualisierten.
uart_regs.py
Die generierte/uart_regs.py file wird zusammen mit dem VHDL-Modul uart_regs generiert und enthält die benutzerdefinierten Registerinformationen im Header des file. Mit diesem Skript können Sie problemlos aus Ihren benutzerdefinierten Registern lesen oder in diese schreiben.

Hilfemenü

Geben Sie python uart_regs.py -h ein, um das Hilfemenü zu drucken:

Einstellen des UART-Ports

Das Skript bietet Optionen zum Einstellen des UART-Ports mit dem Schalter -c. Dies funktioniert unter Windows und Linux. Stellen Sie ihn auf einen der verfügbaren Ports ein, die im Hilfemenü aufgeführt sind. Um einen Standardport einzustellen, können Sie auch die Variable UART_PORT im Skript uart_regs.py bearbeiten.

Verzeichnisse auflisten

Informationen zur Registerzuordnung werden vom Skript gen_uart_regs.py in den Header des Skripts uart_regs.py eingefügt. Sie können die verfügbaren Register mit dem Schalter -l auflisten, wie unten gezeigt. Dies ist ein lokaler Befehl und interagiert nicht mit dem Ziel-FPGA

Schreiben in Register

Mit dem Schalter -w können Sie in jedes der Out-Modus-Register schreiben. Geben Sie den Registernamen gefolgt von „=“ und den Wert als Binär-, Hexadezimal- oder Dezimalwert an, wie unten gezeigt.
Beachten Sie, dass die VHDL-Implementierung erfordert, dass das Skript alle Ausgaberegister gleichzeitig schreibt. Wenn Sie also keinen vollständigen Satz von Ausgaberegistern angeben, führt das Skript zuerst einen Lesevorgang vom Ziel-FPGA durch und verwendet dann diese Werte für die fehlenden. Das Ergebnis ist, dass sich nur die angegebenen Register ändern.
Wenn Sie einen Schreibvorgang ausführen, ändern sich alle angegebenen Register im selben Taktzyklus und nicht, sobald sie über UART empfangen werden.

Register lesen

Verwenden Sie den Schalter -r, um alle Registerwerte zu lesen, wie unten gezeigt. Die gelb markierten Werte sind diejenigen, die wir im vorherigen Schreibbeispiel geändert habenample
Bei jedem Lesevorgang wird ein sofortiger Schnappschuss aller Ein- und Ausgangsregister angezeigt. Sie sind alle sampgeführt während des gleichen Taktzyklus

Debuggen

Verwenden Sie den Schalter -d zusammen mit einem der anderen Schalter, wenn Sie das Kommunikationsprotokoll debuggen müssen. Anschließend druckt das Skript alle gesendeten und empfangenen Bytes aus und tag sie, wenn es sich um Steuerzeichen handelt, wie unten gezeigt.

Verwendung der Schnittstelle in anderen Python-Skripten

Das Skript uart_regs.py enthält eine UartRegs-Klasse, die Sie problemlos als Kommunikationsschnittstelle in anderen benutzerdefinierten Python-Skripten verwenden können. Importieren Sie einfach die Klasse, erstellen Sie ein Objekt daraus und beginnen Sie mit der Verwendung der Methoden, wie unten gezeigt.

Methoden und Beschreibungen sowie Rückgabewerttypen finden Sie in den Dokumentzeichenfolgen im Python-Code.

instanziation_template.vho

Die Instanziierungsvorlage wird zu Ihrer Bequemlichkeit zusammen mit dem uart_regs-Modul generiert. Um Programmierzeit zu sparen, können Sie die Modulinstanziierung und Signaldeklarationen in Ihr Design kopieren.

Statisches RTL files

Sie müssen Folgendes einschließen files in Ihrem VHDL-Projekt, sodass sie in derselben Bibliothek wie das uart_regs-Modul kompiliert werden:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Das Modul uart_regs_backend implementiert die Finite-State-Maschinen, die die Registerdaten ein- und austakten. Es verwendet die Module uart_rx und uart_tx, um die UART-Kommunikation mit dem Host abzuwickeln.

Demo-Projekte

Im Zip sind drei Demoprojekte enthalten file. Sie ermöglichen die Steuerung der Peripheriegeräte auf den verschiedenen Platinen sowie einiger größerer interner Register.
Die Demo-Ordner enthalten vorgenerierte uart_regs.vhd und uart_regs.py fileEs wurde speziell für diese Designs hergestellt.

Gitter-iCEstick

Der Ordner demo/icecube2_icestick enthält eine Demo-Implementierung für den Registerzugriff für das Lattice iCEstick FPGA-Board.
Um den Implementierungsprozess durchzuführen, öffnen Sie demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file in der Entwurfssoftware Lattice iCEcube2.
Nachdem Sie das Projekt in die iCEcube2-GUI geladen haben, klicken Sie auf Tools→Run All, um die Programmier-Bitmap zu generieren. file.

Sie können das Lattice Diamond Programmer Standalone-Tool verwenden, um das FPGA mit der generierten Bitmap zu konfigurieren file. Wenn Diamond Programmer geöffnet wird, klicken Sie im Begrüßungsdialogfeld auf „Vorhandenes Programmiererprojekt öffnen“.
Projekt auswählen file finden Sie in der Zip-Datei: demo/lattice_icestick/diamond_programmer_project.xcf und klicken Sie auf OK.
Klicken Sie nach dem Laden des Projekts auf die drei Punkte im File Namensspalte, wie oben gezeigt. Durchsuchen Sie die Bitmap, um sie auszuwählen file die Sie in iCEcube2 generiert haben

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Wenn das iCEstick-Board schließlich an einen USB-Anschluss Ihres Computers angeschlossen ist, wählen Sie Design→Programm, um den SPI-Flash zu programmieren und das FPGA zu konfigurieren.
Sie können jetzt mit dem Lesen und Schreiben von Registern fortfahren, indem Sie das Skript demo/lattice_icestick/uart_regs.py verwenden, wie im Abschnitt uart_regs.py beschrieben.

Xilinx Digilent Arty A7-35T

Die Demo-Implementierung für das Artix-7 35T Arty FPGA-Evaluierungskit finden Sie im Ordner demo/arty_a7_35.
Öffnen Sie Vivado und navigieren Sie zum extrahierten files mithilfe der Tcl-Konsole, die sich unten in der GUI-Oberfläche befindet. Geben Sie diesen Befehl ein, um den Demoprojektordner aufzurufen:

CD /demo/arty_a7_35/vivado_proj/
Führen Sie das Tcl-Skript create_vivado_proj.tcl aus, um das Vivado-Projekt neu zu generieren:
Quelle ./create_vivado_proj.tcl

Klicken Sie in der Seitenleiste auf „Bitstream generieren“, um alle Implementierungsschritte auszuführen und den Programmierbitstream zu generieren file.
Klicken Sie abschließend auf „Hardware-Manager öffnen“ und programmieren Sie den FPGA über die GUI.
Sie können jetzt mit dem Lesen und Schreiben von Registern fortfahren, indem Sie das Skript demo/arty_a7_35/uart_regs.py verwenden, wie im Abschnitt uart_regs.py beschrieben.

Xilinx Digilent Arty S7-50

Die Demo-Implementierung für das Arty S7: Spartan-7 FPGA-Entwicklungsboard finden Sie im Ordner demo/arty_s7_50.
Öffnen Sie Vivado und navigieren Sie zum extrahierten files mithilfe der Tcl-Konsole, die sich unten in der GUI-Oberfläche befindet. Geben Sie diesen Befehl ein, um den Demoprojektordner aufzurufen:

CD /demo/arty_s7_50/vivado_proj/
Führen Sie das Tcl-Skript create_vivado_proj.tcl aus, um das Vivado-Projekt neu zu generieren:
Quelle ./create_vivado_proj.tcl

Klicken Sie in der Seitenleiste auf „Bitstream generieren“, um alle Implementierungsschritte auszuführen und den Programmierbitstream zu generieren file.
Klicken Sie abschließend auf „Hardware-Manager öffnen“ und programmieren Sie den FPGA über die GUI.
Sie können nun mit dem Lesen und Schreiben von Registern fortfahren, indem Sie das Skript demo/arty_s7_50/uart_regs.py verwenden, wie im Abschnitt uart_regs.py beschrieben.

Durchführung

Es gibt keine spezifischen Implementierungsanforderungen.

Einschränkungen

Für dieses Design sind keine besonderen Zeitbeschränkungen erforderlich, da die UART-Schnittstelle langsam ist und als asynchrone Schnittstelle behandelt wird.

Der uart_rx-Eingang zum uart_regs-Modul wird innerhalb des uart_rx-Moduls synchronisiert. Daher muss es nicht im Modul der obersten Ebene synchronisiert werden.

Bekannte Probleme

Möglicherweise müssen Sie das Modul zurücksetzen, bevor es verwendet werden kann, abhängig davon, ob Ihre FPGA-Architektur Standardregisterwerte unterstützt.

Mehr Infos

FAQs

F: Was ist der Zweck des UART-Testschnittstellengenerators?

A: Der UART-Testschnittstellengenerator ermöglicht die Erstellung benutzerdefinierter Schnittstellen zur Interaktion mit FPGA-Registerwerten mittels UART-Kommunikation.

F: Wie installiere ich das Pyserial-Paket?

A: Sie können Pyserial über Pip mit dem Befehl installieren: pip install pyserial

Dokumente / Ressourcen

VHDLwhiz UART-Testschnittstellengenerator [pdf] Benutzerhandbuch
UART-Testschnittstellengenerator, Testschnittstellengenerator, Schnittstellengenerator, Generator

Verweise

Bedienungsanleitung

VHDLwhiz UART-Testschnittstellengenerator

Produktinformationen