VHDLwhiz UART Test Interface Generator User Manual

Mei dit produkt kinne jo oanpaste ynterfaces generearje foar it lêzen en skriuwen fan FPGA-registerwearden mei UART. De generearre VHDL-module en Python-skript jouwe de mooglikheid om te ynteraksje mei ferskate soarten registers yn jo FPGA-ûntwerp.

Requirements

Python 3 tolk
pyserial pakket

Protokol

It produkt brûkt in gegevensframingprotokol mei fjouwer kontrôlekarakters:

Namme: READ_REQ, Wearde: 0x0A - Kommando fan 'e host nei de FPGA om in skriuwsekwinsje te begjinnen om alle registers werom te stjoeren oer UART
Namme: START_WRITE, Wearde: 0x0B - Markearret it begjin fan in skriuwsekwinsje yn beide rjochtingen

Namme: END_WRITE, Wearde: 0x0C - Markearret it ein fan in skriuwsekwinsje yn beide rjochtingen
Namme: ÛNTSNAPPE, Wearde: 0x0D - Escape-karakter brûkt foar it ûntkommen fan kontrôlewurden

Produkt Usage Ynstruksjes

It útfieren fan de Skripten

Om it produkt te brûken, soargje derfoar dat jo Python 3 ynstalleare hawwe en it Pyserial-pakket. Laad de skripts fia in Python 3-tolk.

Oanpaste ynterfaces generearje

Brûk it gen_uart_regs.py-skript om oanpaste ynterfaces te generearjen foar it lêzen en skriuwen fan FPGA-registerwearden. Jo kinne de gearstalling fan ynfier- en útfierregisters en typen opjaan by it generearjen fan de útfier files.

Ynteraksje mei registers

Jo kinne lêze fan of skriuwe nei elk oantal registers yn jo FPGA-ûntwerp mei de oanmakke VHDL-module en Python-skript. De tagonklike registers kinne soarten hawwe lykas std_logic, std_logic_vector, ûndertekene, of net ûndertekene.

Fergunning

De MIT-lisinsje beslacht de auteursrjochteasken en gebrûksbetingsten fan 'e boarnekoade. Ferwize nei de LICENSE.txt file yn de Zip file foar details.

Feroaringslog

Dizze wizigingen ferwize nei it projekt files, en dit dokumint wurdt bywurke accordingly

Ferzje	Opmerkings
1.0.0	Inisjele release
1.0.1	Fixed ûntbrekkende "sels" referinsje bug by ymportearjen as uart_regs.py as Python module. Feroare skriuw mislearre ôfdruk nei útsûndering op mije printsjen nei de konsole as jo rinne as in ymportearre module.
1.0.2	Fix foar Vivado [Synth 8-248] flater as d'r gjin regs foar útmodus binne.
1.0.3	Fix Vivado Linter warskôging: Register hat ynskeakelje dreaun troch syngroane reset
1.0.4	Befestigje de hoekje by it ûntfangen fan in misfoarme wurd mei it ûntsnappingsteken as de lêste byte. It folgjende wurd soe ek ferlern gean, om't wy recv_data_prev_is_escape net wiske hawwe by it weromgean nei IDLE. It gen_uart_regs.py-skript lit no allinich unike reg-nammen ta.

Beskriuwing

Dit dokumint beskriuwt it folgjende files en mappen:
gen_uart_regs.py

generated/uart_regs.vhd
generated/uart_regs.py
generated/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/
It gen_uart_regs.py-skript en stypjende VHDL files yn dit projekt kinne jo generearje oanpaste Schnittstellen foar lêzen en skriuwen FPGA register wearden fan ferskate soarten en breedtes mei help fan UART.
Jo kinne de generearre VHDL-module en Python-skript brûke om te lêzen fan of te skriuwen nei elk oantal registers yn jo ûntwerp. De UART tagonklike registers kinne de typen std_logic, std_logic_vector, ûndertekene, of net ûndertekene hawwe.
Jo kinne beslute oer de krekte gearstalling fan ynfier- en útfierregisters en typen by it generearjen fan de útfier files mei it gen_uart_regs.py skript.
De Python-skripts waarden foar in part makke mei help fan it ChatGPT-ark foar keunstmjittige yntelliginsje, wylst de VHDL-koade mei de hân makke is.

Requirements

De skripts yn dit projekt moatte wurde útfierd troch in Python 3-tolk en it Pyserial-pakket moat ynstalleare wurde.
Jo kinne pyserial fia Pip ynstallearje mei dit kommando: pip install pyserial

Protokol

It hannelvolumint fan 'VHDL files en Python skript brûke in data-framing protokol mei fjouwer kontrôle

Namme	Wearde	Kommentaar
READ_REQ	0x0A	Kommando fan 'e host nei de FPGA om in skriuwe te begjinnen folchoarder om alle registers werom te stjoeren oer UART
START_WRITE	0x0B	Markearret it begjin fan in skriuwsekwinsje yn beide rjochting
END_WRITE	0x0 c	Markearret it ein fan in skriuwsekwinsje yn beide rjochtingen
ÛNTSNAPPE	0x0 d	Escape-karakter brûkt foar it ûntsnappen fan ien fan 'e kontrôlewurden, ynklusyf it ESCAPE-karakter sels, as se ferskine as gegevens tusken de START_WRITE- en END_WRITE-markers.

Elke unescaped READ_REQ-byte stjoerd nei de FPGA is in ynstruksje om al syn UART-tagonklike registers (yn- en útgongen) werom te stjoeren nei de host oer UART. Dit kommando wurdt normaal allinich útjûn troch it skript uart_regs.py.
By it ûntfangen fan dit kommando sil de FPGA reagearje troch de ynhâld fan alle registers werom te stjoeren nei de host. Earst de ynfiersinjalen, dan de útfiersinjalen. As har lingten net optelle ta in mearfâld fan 8 bits, sille de legere bits fan 'e lêste byte nullen wêze.
In skriuwsekwinsje begjint altyd mei de START_WRITE-byte en einiget mei de END_WRITE-byte. Elke bytes tusken dy wurde beskôge as gegevensbytes. As alle gegevensbytes deselde wearde hawwe as in kontrôlekarakter, moat de gegevensbyte ûntkommen wurde. Dit betsjut it ferstjoeren fan in ekstra ESCAPE-karakter foar de gegevensbyte om oan te jaan dat it feitlik gegevens binne.
As in net ûntkommen START_WRITE oeral yn 'e stream fan bytes komt, wurdt it beskôge as it begjin fan in skriuwsekwinsje. De module uart_regs_backend brûkt dizze ynformaasje om opnij te syngronisearjen yn gefal de kommunikaasje net syngronisearret.

gen_uart_regs.py

Dit is it skript wêrmei jo moatte begjinne om de ynterface te generearjen. Hjirûnder is in skermôfbylding fan it helpmenu dat jo kinne krije troch te rinnen: python gen_uart_regs.py -h
Om in oanpaste ynterface te generearjen, moatte jo it skript útfiere mei elk fan jo winske UART-kontrolearbere registers neamd as arguminten. De beskikbere typen binne std_logic, std_logic_vector, net ûndertekene, en ûndertekene.
De standert modus (rjochting) is yn en de standert type is std_logic_vector útsein as it register is fan lingte: 1. Dan, it sil standert oan std_logic.

As jo dus in std_logic ynfiersinjaal wolle oanmeitsje, kinne jo ien fan dizze arguminten brûke:
myn_sl=1
myn_sl=1:yn

my_sl=1:in:std_logic
Alle boppesteande farianten sille resultearje yn it skript dat dit UART-tagonklike sinjaal generearret:
Litte wy it skript útfiere mei arguminten om in ynterface te generearjen mei ferskate registers fan ferskate rjochtingen, lingten en typen

Generearre files

In suksesfolle run fan it gen_uart_regs.py-skript sil in útfiermap produsearje mei de namme generearre mei de trije files listed hjirûnder. As se al besteane, wurde se oerskreaun.
generated/uart_regs.vhd

generated/uart_regs.py
generated/instantiation_template.vho
uart_regs.vhd

Dit is de oanpaste ynterface module generearre troch it skript. Jo moatte it ynstantiearje yn jo ûntwerp, wêr't it tagong kin ta de registers dy't jo wolle kontrolearje mei UART.
Alles boppe de seksje "- UART tagonklike registers" sil identyk wêze foar elke uart_regs-module, wylst de gearstalling fan poartesinjalen ûnder dy line hinget ôf fan 'e arguminten jûn oan it generatorskript.
De list hjirûnder toant de entiteit foar de module uart_regs dy't ûntstiet út it generearje kommando example werjûn yn 'e gen_uart_regs.py secti

Jo hoege it uart_rx-sinjaal net te syngronisearjen, om't dat wurdt behannele yn 'e uart_rx. module.
As de module ûntfangt in lêsfersyk, sil it de wearden fan alle ynfier- en útfiersinjalen binnen de hjoeddeistige kloksyklus fange. De instantane momintopname wurdt dan stjoerd nei de host oer UART.
As in skriuwen bart, wurde alle útfierregisters bywurke mei de nije wearden binnen deselde kloksyklus. It is net mooglik om te feroarjen útfier sinjaal wearden yndividueel.

It skript uart_regs.py lit de brûker lykwols allinich selektearre útgongen bywurkje troch earst de aktuele wearden fan alle registers werom te lêzen. It skriuwt dan alle wearden werom, ynklusyf de bywurke.
uart_regs.py
De generearre/uart_regs.py file wurdt generearre tegearre mei de uart_regs VHDL module en befettet de oanpaste register ynformaasje yn de kop fan de file. Mei dit skript kinne jo maklik lêze fan of skriuwe nei jo oanpaste registers.

Help menu

Typ python uart_regs.py -h om it helpmenu te printsjen:

De UART-poarte ynstelle

It skript hat opsjes om de UART-poarte yn te stellen mei de -c-skeakel. Dit wurket op Windows en Linux. Stel it yn op ien fan 'e beskikbere havens neamd yn it helpmenu. Om in standert haven yn te stellen, kinne jo ek de UART_PORT fariabele bewurkje yn it uart_regs.py skript.

Listing registers

Ynformaasje oer de registermapping wurdt pleatst yn 'e koptekst fan it uart_regs.py-skript troch it gen_uart_regs.py-skript. Jo kinne de beskikbere registers listje mei de -l-skeakel, lykas hjirûnder te sjen. Dit is in lokaal kommando en sil net ynteraksje mei de doel-FPGA

Skriuwen nei registers

Jo kinne skriuwe nei ien fan 'e út-modusregisters mei de -w-skeakel. Jou de registernamme folge troch "=" en de wearde jûn as in binêre, heksadesimale of desimale wearde, lykas hjirûnder werjûn.
Tink derom dat de VHDL-ymplemintaasje it skript fereasket om alle útfierregisters tagelyk te skriuwen. Dêrom, as jo gjin folsleine set fan útfierregisters oantsjutte, sil it skript earst in lêzing útfiere fan 'e doel-FPGA en dan brûke dizze wearden foar de ûntbrekkende. It resultaat sil wêze dat allinich de oantsjutte registers feroarje
As jo útfiere in skriuwe, sille alle oantsjutte registers feroarje yn deselde klok syklus, net sa gau as se wurde ûntfongen oer UART.

Lêze registers

Brûk de -r-skeakel om alle registerwearden te lêzen, lykas hjirûnder werjûn. De wearden markearre yn giel binne dejingen dy't wy feroare yn 'e foarige skriuwen example
Elke lêzing toant in momintopname fan alle ynfier- en útfierregisters. Se binne allegear sampliede tidens deselde klok syklus

Debuggen

Brûk de -d-skeakel mei ien fan 'e oare skeakels as jo it kommunikaasjeprotokol moatte debuggen. Dan sil it skript alle ferstjoerde en ûntfongen bytes en tag se as se binne kontrôle karakters, lykas werjûn hjirûnder.

It brûken fan de ynterface yn oare Python-skripts

It skript uart_regs.py befettet in UartRegs-klasse dy't jo maklik kinne brûke as de kommunikaasje-ynterface yn oare oanpaste Python-skripts. Ymportearje de klasse gewoan, meitsje der in objekt fan en begjin de metoaden te brûken, lykas hjirûnder werjûn.

Ferwize nei de docstrings yn 'e Python-koade foar metoade en beskriuwingen en weromweardetypen.

instantiation_template.vho

It instantiaasje-sjabloan wurdt generearre tegearre mei de uart_regs-module foar jo gemak. Om kodearring tiid te besparjen, kinne jo de module-ynstantiaasje en sinjaaldeklaraasjes kopiearje yn jo ûntwerp.

Statyske RTL files

Jo moatte it folgjende opnimme files yn jo VHDL-projekt sadat se wurde kompilearre yn deselde bibleteek as de module uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
De module uart_regs_backend ymplementearret de finite-state masines dy't de registergegevens yn en út klokje. It brûkt de modules uart_rx en uart_tx om de UART-kommunikaasje mei de host te behanneljen.

Demo projekten

D'r binne trije demo-projekten opnommen yn 'e Zip file. Se litte jo de perifeare apparaten kontrolearje op 'e ferskate boerden en ek in pear gruttere, ynterne registers.
De demo mappen befetsje pre-generearre uart_regs.vhd en uart_regs.py files makke spesifyk foar dy ûntwerpen.

Rooster iCEstick

De demo/icecube2_icestick map befettet in register tagong demo ymplemintaasje foar de Lattice iCEstick FPGA board.
Om troch it ymplemintaasjeproses te rinnen, iepenje de demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file yn 'e Lattice iCEcube2-ûntwerpsoftware.
Nei it laden fan it projekt yn 'e iCEcube2 GUI, klikje op Tools → Alles útfiere om de programmearbitmap te generearjen file.

Jo kinne it Lattice Diamond Programmer Standalone-ark brûke om de FPGA te konfigurearjen mei de oanmakke bitmap file. As Diamond Programmer iepent, klikje op Iepenje in besteand programmeurprojekt yn it wolkom dialoochfinster.
Selektearje projekt file fûn yn de Zip: demo/lattice_icestick/diamond_programmer_project.xcf en klik OK.
Nei it projekt laden, klik op de trije stippen yn de File Namme kolom, lykas hjirboppe werjûn. Blêdzje om de bitmap te selektearjen file dat jo generearre yn iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
As lêste, mei it iCEstick-board yn in USB-poarte op jo kompjûter, selektearje Untwerp→ Programma om de SPI-flitser te programmearjen en de FPGA te konfigurearjen.
Jo kinne no trochgean mei it lêzen en skriuwen fan registers troch it demo/lattice_icestick/uart_regs.py-skript te brûken lykas beskreaun yn 'e seksje uart_regs.py.

Xilinx Digilent Arty A7-35T

Jo kinne de demo-ymplemintaasje fine foar de Artix-7 35T Arty FPGA-evaluaasjekit yn 'e map demo/arty_a7_35.
Iepenje Vivado en navigearje nei it ekstrahearre files mei de Tcl-konsole fûn oan 'e ûnderkant fan' e GUI-ynterface. Typ dit kommando om de demo-projektmap yn te gean:

cd /demo/arty_a7_35/vivado_proj/
Fier it create_vivado_proj.tcl Tcl-skript út om it Vivado-projekt te regenerearjen:
boarne ./create_vivado_proj.tcl

Klikje Bitstream generearje yn 'e sydbalke om alle ymplemintaasjestappen troch te rinnen en de programmearbitstream te generearjen file.
As lêste, klikje op Iepenje Hardware Manager en programmearje de FPGA fia de GUI.
Jo kinne no trochgean mei it lêzen en skriuwen fan registers troch it demo/arty_a7_35/uart_regs.py-skript te brûken lykas beskreaun yn 'e seksje uart_regs.py.

Xilinx Digilent Arty S7-50

Jo kinne de demo-ymplemintaasje fine foar it Arty S7: Spartan-7 FPGA-ûntwikkelingsboerd yn 'e map demo/arty_s7_50.
Iepenje Vivado en navigearje nei it ekstrahearre files mei de Tcl-konsole fûn oan 'e ûnderkant fan' e GUI-ynterface. Typ dit kommando om de demo-projektmap yn te gean:

cd /demo/arty_s7_50/vivado_proj/
Fier it create_vivado_proj.tcl Tcl-skript út om it Vivado-projekt te regenerearjen:
boarne ./create_vivado_proj.tcl

Klikje Bitstream generearje yn 'e sydbalke om alle ymplemintaasjestappen troch te rinnen en de programmearbitstream te generearjen file.
As lêste, klikje op Iepenje Hardware Manager en programmearje de FPGA fia de GUI.
Jo kinne no trochgean mei it lêzen en skriuwen fan registers troch it demo/arty_s7_50/uart_regs.py-skript te brûken lykas beskreaun yn 'e seksje uart_regs.py.

Útfiering

D'r binne gjin spesifike útfieringseasken.

Beheinings

Gjin spesifike timing beheinings binne nedich foar dit ûntwerp omdat de UART ynterface is stadich en behannele as in asynchronous ynterface.

De uart_rx-ynfier nei de uart_regs-module wurdt syngronisearre binnen de uart_rx-module. Sa hoecht it net te syngronisearje yn 'e top-level module.

Bekende problemen

Jo moatte miskien de module weromsette foardat it brûkt wurde kin, ôfhinklik fan oft jo FPGA-arsjitektuer standert registerwearden stipet.

Mear ynfo

FAQs

F: Wat is it doel fan 'e UART-testynterface-generator?

A: De UART-testynterface-generator makket it meitsjen fan oanpaste ynterfaces om te ynteraksje mei FPGA-registerwearden mei UART-kommunikaasje.

F: Hoe kin ik it Pyserial-pakket ynstallearje?

A: Jo kinne Pyserial fia Pip ynstallearje mei it kommando: pip install pyserial

Dokuminten / Resources

VHDLwhiz UART Test Interface Generator [pdf] Brûkershânlieding
UART Test Interface Generator, Test Interface Generator, Interface Generator, Generator

Referinsjes

User Manual

VHDLwhiz UART Test Interface Generator

Produkt ynformaasje