VHDLwhiz UART Test Interface Generator Gebruikershandleiding

Met dit product kunt u aangepaste interfaces genereren voor het lezen en schrijven van FPGA-registerwaarden met behulp van UART. De gegenereerde VHDL-module en het Python-script bieden de mogelijkheid om te communiceren met verschillende typen registers in uw FPGA-ontwerp.

Vereisten

Python 3-interpreter
pyseriaal pakket

Protocol

Het product maakt gebruik van een data framing protocol met vier besturingstekens:

Naam: LEES_VERZOEK, Waarde: 0x0A – Opdracht van de host naar de FPGA om een schrijfsequentie te starten om alle registers via UART terug te sturen
Naam: START_SCHRIJVEN, Waarde: 0x0B – Markeert het begin van een schrijfsequentie in beide richtingen

Naam: EINDE_SCHRIJVEN, Waarde: 0x0C – Markeert het einde van een schrijfsequentie in beide richtingen
Naam: ONTSNAPPEN, Waarde: 0x0D – Escape-teken dat wordt gebruikt om controlewoorden te ontsnappen

Instructies voor productgebruik

De scripts uitvoeren

Om het product te gebruiken, moet u ervoor zorgen dat Python 3 en het Pyserial-pakket zijn geïnstalleerd. Voer de scripts uit via een Python 3-interpreter.

Aangepaste interfaces genereren

Gebruik het gen_uart_regs.py-script om aangepaste interfaces te genereren voor het lezen en schrijven van FPGA-registerwaarden. U kunt de samenstelling van invoer- en uitvoerregisters en -typen opgeven bij het genereren van de uitvoer files.

Interactie met registers

U kunt lezen van of schrijven naar een willekeurig aantal registers in uw FPGA-ontwerp met behulp van de gegenereerde VHDL-module en het Python-script. De toegankelijke registers kunnen typen hebben zoals std_logic, std_logic_vector, signed of unsigned.

Licentie

De MIT-licentie dekt de auteursrechtvereisten en gebruiksvoorwaarden van de broncode. Raadpleeg LICENSE.txt file in de ritssluiting file voor meer informatie.

Wijzigingslogboek

Deze wijzigingen hebben betrekking op het project files, en dit document wordt dienovereenkomstig bijgewerkt

Versie	Opmerkingen
1.0.0	Eerste release
1.0.1	Herstelde ontbrekende «self» referentie bug bij het importeren als uart_regs.py als een Python module. Veranderde write failed printout naar exception naar Vermijd het afdrukken naar de console wanneer u deze uitvoert als een geïmporteerde module.
1.0.2	Oplossing voor Vivado [Synth 8-248]-fout wanneer er geen uitvoermodus-regels zijn.
1.0.3	Herstel Vivado Linter-waarschuwing: Register is ingeschakeld door synchrone reset
1.0.4	Herstel het cornercase bij het ontvangen van een misvormd woord met het escape-teken als laatste byte. Het volgende woord zou ook verloren gaan omdat we recv_data_prev_is_escape niet hebben gewist bij terugkeer naar IDLE. Het script gen_uart_regs.py staat nu alleen unieke reg-namen toe.

Beschrijving

In dit document wordt het volgende beschreven files en mappen:
gen_uart_regs.py

gegenereerd/uart_regs.vhd
gegenereerd/uart_regs.py
gegenereerd/instantiatie_sjabloon.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/
Het gen_uart_regs.py script en ondersteunende VHDL fileMet de programma's in dit project kunt u aangepaste interfaces genereren voor het lezen en schrijven van FPGA-registerwaarden van verschillende typen en breedtes met behulp van UART.
U kunt de gegenereerde VHDL-module en het Python-script gebruiken om te lezen van of te schrijven naar een willekeurig aantal registers in uw ontwerp. De voor UART toegankelijke registers kunnen de typen std_logic, std_logic_vector, Signed of Unsigned hebben.
U kunt bij het genereren van de uitvoer beslissen over de precieze samenstelling van invoer- en uitvoerregisters en typen files gebruikt het gen_uart_regs.py-script.
De Python-scripts zijn gedeeltelijk gemaakt met behulp van de ChatGPT-tool voor kunstmatige intelligentie, terwijl de VHDL-code met de hand is gemaakt.

Vereisten

De scripts in dit project moeten via een Python 3-interpreter worden uitgevoerd en het Pyserial-pakket moet worden geïnstalleerd.
U kunt pyserial installeren via Pip met behulp van deze opdracht: pip install pyserial

Protocol

De VHDL files en Python-script gebruiken een data-framingprotocol met vier besturingselementen

Naam	Waarde	Opmerking
LEES_VERZOEK	0x0A	Opdracht van de host naar de FPGA om een schrijfbewerking te starten volgorde om alle registers terug te sturen via UART
START_SCHRIJVEN	0x0B	Markeert het begin van een schrijfsequentie in beide richting
END_WRITE	0x0C	Markeert het einde van een schrijfreeks in beide richtingen
ONTSNAPPEN	0x0D	Escape-teken dat wordt gebruikt om te ontsnappen aan een van de controlewoorden, inclusief het ESCAPE-teken zelf, wanneer deze verschijnen als gegevens tussen de markeringen START_WRITE en END_WRITE.

Elke READ_REQ-byte zonder escapecode die naar de FPGA wordt verzonden, is een instructie om alle UART-toegankelijke registers (in- en uitgangen) via UART terug naar de host te sturen. Deze opdracht wordt meestal alleen gegeven door het uart_regs.py-script.
Na ontvangst van dit commando zal de FPGA reageren door de inhoud van alle registers terug te sturen naar de host. Eerst de ingangssignalen en vervolgens de uitgangssignalen. Als hun lengtes niet optellen tot een veelvoud van 8 bits, zullen de lagere bits van de laatste byte opgevulde nullen zijn.
Een schrijfsequentie begint altijd met de START_WRITE byte en eindigt met de END_WRITE byte. Alle bytes daartussen worden beschouwd als databytes. Als databytes dezelfde waarde hebben als een controlekarakter, moet de databyte worden geëscaped. Dit betekent dat er een extra ESCAPE-karakter wordt verzonden vóór de databyte om aan te geven dat het daadwerkelijk data is.
Als een START_WRITE zonder escapecode ergens in de stroom bytes arriveert, wordt dit beschouwd als het begin van een schrijfreeks. De uart_regs_backend-module gebruikt deze informatie om opnieuw te synchroniseren voor het geval de communicatie niet meer synchroon loopt.

gen_uart_regs.py

Dit is het script waarmee u moet beginnen om de interface te genereren. Hieronder ziet u een screenshot van het helpmenu dat u kunt krijgen door het volgende uit te voeren: python gen_uart_regs.py -h
Om een aangepaste interface te genereren, moet u het script uitvoeren met elk van uw gewenste door UART bestuurbare registers vermeld als argumenten. De beschikbare typen zijn std_logic, std_logic_vector, unsigned en Signed.
De standaardmodus (richting) is ingesteld en het standaardtype is std_logic_vector tenzij het register de volgende lengte heeft: 1. Dan wordt het standaard ingesteld op std_logic.

Als u dus een std_logic ingangssignaal wilt creëren, kunt u een van deze argumenten gebruiken:
mijn_sl=1
mijn_sl=1:in

mijn_sl=1:in:std_logic
Alle bovenstaande varianten zullen ertoe leiden dat het script dit UART-toegankelijke signaal genereert:
Laten we het script uitvoeren met argumenten om een interface te genereren met verschillende registers van verschillende richtingen, lengtes en typen

gegenereerd files

Een succesvolle uitvoering van het gen_uart_regs.py-script zal een uitvoermap produceren met de naam gegenereerd met de drie files hieronder vermeld. Als ze al bestaan, worden ze overschreven.
gegenereerd/uart_regs.vhd

gegenereerd/uart_regs.py
gegenereerd/instantiatie_sjabloon.vho
uart_regs.vhd

Dit is de aangepaste interfacemodule die door het script wordt gegenereerd. U moet het in uw ontwerp concretiseren, waar het toegang heeft tot de registers die u wilt besturen met behulp van UART.
Alles boven de sectie “– UART toegankelijke registers” zal identiek zijn voor elke uart_regs-module, terwijl de samenstelling van poortsignalen onder die regel afhangt van de argumenten die aan het generatorscript worden gegeven.
De onderstaande lijst toont de entiteit voor de module uart_regs die resulteert uit de opdracht genereren exampbestand getoond in de gen_uart_regs.py sectie

U hoeft het uart_rx-signaal niet te synchroniseren, omdat dat in de uart_rx wordt afgehandeld. module.
Wanneer de module een leesverzoek ontvangt, registreert deze de waarden van alle in- en uitgangssignalen binnen de huidige klokcyclus. De momentane momentopname wordt vervolgens via UART naar de host verzonden.
Wanneer er wordt geschreven, worden alle uitgangsregisters binnen dezelfde klokcyclus bijgewerkt met de nieuwe waarden. Het is niet mogelijk om de uitgangssignaalwaarden individueel te wijzigen.

Met het uart_regs.py-script kan de gebruiker echter alleen geselecteerde uitvoer bijwerken door eerst de huidige waarden van alle registers terug te lezen. Vervolgens schrijft het alle waarden terug, inclusief de bijgewerkte waarden.
uart_regs.py
Het gegenereerde/uart_regs.py file wordt samen met de uart_regs VHDL-module gegenereerd en bevat de aangepaste registerinformatie in de header van de file. Met dit script kunt u eenvoudig lezen van of schrijven naar uw aangepaste registers.

Helpmenu

Typ python uart_regs.py -h om het helpmenu af te drukken:

De UART-poort instellen

Het script heeft opties om de UART-poort in te stellen met de -c-switch. Dit werkt op Windows en Linux. Stel het in op een van de beschikbare poorten die in het helpmenu worden vermeld. Om een standaardpoort in te stellen, kunt u ook de variabele UART_PORT bewerken in het script uart_regs.py.

Lijsten registreren

Informatie over de registertoewijzing wordt in de header van het uart_regs.py-script geplaatst door het gen_uart_regs.py-script. U kunt de beschikbare registers weergeven met de -l-schakelaar, zoals hieronder te zien is. Dit is een lokale opdracht en zal niet communiceren met de doel-FPGA

Schrijven naar registers

U kunt naar elk van de out-modusregisters schrijven met behulp van de schakelaar -w. Geef de registernaam op, gevolgd door “=” en de opgegeven waarde als binaire, hexadecimale of decimale waarde, zoals hieronder weergegeven.
Houd er rekening mee dat de VHDL-implementatie vereist dat het script alle uitvoerregisters tegelijk schrijft. Als u daarom geen volledige set uitvoerregisters opgeeft, zal het script eerst een leesbewerking uitvoeren van de doel-FPGA en vervolgens die waarden gebruiken voor de ontbrekende. Het resultaat is dat alleen de opgegeven registers veranderen
Wanneer u een schrijfactie uitvoert, veranderen alle gespecificeerde registers tijdens dezelfde klokcyclus, en niet zodra ze via UART worden ontvangen.

Registers lezen

Gebruik de schakelaar -r om alle registerwaarden te lezen, zoals hieronder weergegeven. De geel gemarkeerde waarden zijn de waarden die we in de vorige schrijfvoorbeeld hebben gewijzigdample
Elke lezing toont een momentopname van alle invoer- en uitvoerregisters. Het zijn allemaal sampgeleid tijdens dezelfde klokcyclus

Fouten opsporen

Gebruik de schakelaar -d met een van de andere schakelaars als u fouten in het communicatieprotocol wilt opsporen. Vervolgens drukt het script alle verzonden en ontvangen bytes af tag als het controlekarakters zijn, zoals hieronder weergegeven.

De interface gebruiken in andere Python-scripts

Het uart_regs.py-script bevat een UartRegs-klasse die u eenvoudig kunt gebruiken als communicatie-interface in andere aangepaste Python-scripts. Importeer eenvoudigweg de klasse, maak er een object van en begin met het gebruiken van de methoden, zoals hieronder weergegeven.

Raadpleeg de docstrings in de Python-code voor methoden en beschrijvingen en retourwaardetypen.

instantiatie_sjabloon.vho

De instantiatiesjabloon wordt voor uw gemak samen met de uart_regs-module gegenereerd. Om codeertijd te besparen, kunt u de module-instantiatie en signaaldeclaraties naar uw ontwerp kopiëren.

Statische RTL files

U moet het volgende opnemen files in uw VHDL-project zodat ze worden gecompileerd in dezelfde bibliotheek als de uart_regs-module:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
De uart_regs_backend-module implementeert de eindige-statusmachines die de registergegevens in- en uitklokken. Het gebruikt de modules uart_rx en uart_tx om de UART-communicatie met de host af te handelen.

Demoprojecten

Er zijn drie demoprojecten opgenomen in de Zip file. Hiermee kunt u de randapparatuur op de verschillende kaarten bedienen, evenals een paar grotere, interne registers.
De demomappen bevatten vooraf gegenereerde uart_regs.vhd en uart_regs.py files speciaal gemaakt voor die ontwerpen.

Rooster iCEstick

De map demo/icecube2_icestick bevat een demo-implementatie voor registertoegang voor het Lattice iCEstick FPGA-bord.
Om het implementatieproces te doorlopen, opent u de demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file in de Lattice iCEcube2-ontwerpsoftware.
Nadat u het project in de iCEcube2 GUI hebt geladen, klikt u op Extra → Alles uitvoeren om de programmeerbitmap te genereren file.

U kunt de Lattice Diamond Programmer Standalone-tool gebruiken om de FPGA te configureren met de gegenereerde bitmap file. Wanneer Diamond Programmer wordt geopend, klikt u op Een bestaand programmeurproject openen in het welkomstdialoogvenster.
Kies een project file gevonden in de Zip: demo/lattice_icestick/diamond_programmer_project.xcf en klik op OK.
Nadat het project is geladen, klikt u op de drie stippen in het File Naamkolom, zoals hierboven weergegeven. Blader om de bitmap te selecteren file die je hebt gegenereerd in iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Ten slotte, terwijl het iCEstick-bord is aangesloten op een USB-poort op uw computer, selecteert u Ontwerp → Programma om de SPI-flitser te programmeren en de FPGA te configureren.
U kunt nu doorgaan met het lezen en schrijven van registers met behulp van het script demo/lattice_icestick/uart_regs.py zoals beschreven in de sectie uart_regs.py.

Xilinx Digilent Arty A7-35T

U kunt de demo-implementatie voor de Artix-7 35T Arty FPGA-evaluatiekit vinden in de map demo/arty_a7_35.
Open Vivado en navigeer naar het uitgepakte bestand files gebruiken de Tcl-console onderaan de GUI-interface. Typ deze opdracht om de demoprojectmap te openen:

CD /demo/arty_a7_35/vivado_proj/
Voer het Tcl-script create_vivado_proj.tcl uit om het Vivado-project opnieuw te genereren:
bron ./create_vivado_proj.tcl

Klik op Bitstream genereren in de zijbalk om alle implementatiestappen te doorlopen en de programmeerbitstream te genereren file.
Klik ten slotte op Open Hardware Manager en programmeer de FPGA via de GUI.
U kunt nu doorgaan met het lezen en schrijven van registers met behulp van het demo/arty_a7_35/uart_regs.py-script, zoals beschreven in de sectie uart_regs.py.

Xilinx Digilent Arty S7-50

Je kunt de demo-implementatie voor de Arty S7: Spartan-7 FPGA-ontwikkelbord vinden in de map demo/arty_s7_50.
Open Vivado en navigeer naar het uitgepakte bestand files gebruiken de Tcl-console onderaan de GUI-interface. Typ deze opdracht om de demoprojectmap te openen:

CD /demo/arty_s7_50/vivado_proj/
Voer het Tcl-script create_vivado_proj.tcl uit om het Vivado-project opnieuw te genereren:
bron ./create_vivado_proj.tcl

Klik op Bitstream genereren in de zijbalk om alle implementatiestappen te doorlopen en de programmeerbitstream te genereren file.
Klik ten slotte op Open Hardware Manager en programmeer de FPGA via de GUI.
U kunt nu doorgaan met het lezen en schrijven van registers met behulp van het demo/arty_s7_50/uart_regs.py-script, zoals beschreven in de sectie uart_regs.py.

Uitvoering

Er zijn geen specifieke uitvoeringseisen.

Beperkingen

Voor dit ontwerp zijn geen specifieke timingbeperkingen nodig omdat de UART-interface traag is en wordt behandeld als een asynchrone interface.

De uart_rx-invoer naar de uart_regs-module wordt gesynchroniseerd binnen de uart_rx-module. Het hoeft dus niet te worden gesynchroniseerd in de module op het hoogste niveau.

Bekende problemen

Mogelijk moet u de module resetten voordat deze kan worden gebruikt, afhankelijk van of uw FPGA-architectuur standaard registerwaarden ondersteunt.

Meer info

Veelgestelde vragen

V: Wat is het doel van de UART-testinterfacegenerator?

A: Met de UART-testinterfacegenerator kunt u aangepaste interfaces maken voor interactie met FPGA-registerwaarden via UART-communicatie.

V: Hoe installeer ik het Pyserial-pakket?

A: U kunt Pyserial installeren via Pip met behulp van de opdracht: pip install pyserial

Documenten / Bronnen

VHDLwhiz UART-testinterfacegenerator [pdf] Gebruikershandleiding
UART-testinterfacegenerator, testinterfacegenerator, interfacegenerator, generator

Referenties

Gebruiksaanwijzing

VHDLwhiz UART-testinterfacegenerator

Productinformatie