VHDLwhiz UART Test Interface Generator Manual User

Binibigyang-daan ka ng produktong ito na bumuo ng mga custom na interface para sa pagbabasa at pagsulat ng mga halaga ng rehistro ng FPGA gamit ang UART. Ang nabuong VHDL module at Python script ay nagbibigay ng kakayahang makipag-ugnayan sa iba't ibang uri ng mga rehistro sa iyong disenyo ng FPGA.

Mga kinakailangan

Python 3 interpreter
pyserial package

Protocol

Gumagamit ang produkto ng data framing protocol na may apat na control character:

Pangalan: READ_REQ, Halaga: 0x0A – Utos mula sa host hanggang sa FPGA upang simulan ang isang pagkakasunud-sunod ng pagsulat upang maipadala ang lahat ng mga rehistro pabalik sa UART
Pangalan: START_WRITE, Halaga: 0x0B - Minamarkahan ang simula ng isang pagkakasunud-sunod ng pagsulat sa alinmang direksyon

Pangalan: END_WRITE, Halaga: 0x0C - Minamarkahan ang pagtatapos ng isang pagkakasunud-sunod ng pagsulat sa alinmang direksyon
Pangalan: TUMAKAS, Halaga: 0x0D – Escape character na ginagamit para sa pagtakas ng mga control na salita

Mga Tagubilin sa Paggamit ng Produkto

Pagpapatakbo ng mga Script

Para magamit ang produkto, tiyaking mayroon kang Python 3 na naka-install at ang Pyserial package. Patakbuhin ang mga script sa pamamagitan ng isang Python 3 interpreter.

Pagbuo ng Mga Custom na Interface

Gamitin ang gen_uart_regs.py script upang bumuo ng mga custom na interface para sa pagbabasa at pagsulat ng mga halaga ng rehistro ng FPGA. Maaari mong tukuyin ang komposisyon ng mga rehistro at uri ng input at output kapag bumubuo ng output files.

Pakikipag-ugnayan sa mga Register

Maaari kang magbasa mula o sumulat sa anumang bilang ng mga rehistro sa iyong disenyo ng FPGA gamit ang nabuong VHDL module at Python script. Ang mga naa-access na rehistro ay maaaring may mga uri tulad ng std_logic, std_logic_vector, nilagdaan, o hindi nalagdaan.

Lisensya

Sinasaklaw ng lisensya ng MIT ang mga kinakailangan sa copyright ng source code at mga tuntunin ng paggamit. Sumangguni sa LICENSE.txt file sa Zip file para sa mga detalye.

Changelog

Ang mga pagbabagong ito ay tumutukoy sa proyekto files, at ang dokumentong ito ay ina-update nang naaayon

Bersyon	Remarks
1.0.0	Paunang paglabas
1.0.1	Inayos ang nawawalang "self" reference bug kapag nag-import bilang uart_regs.py bilang isang Python module. Binago ang write failed printout sa exception to iwasan ang pag-print sa console kapag tumatakbo bilang isang na-import na module.
1.0.2	Ayusin ang error sa Vivado [Synth 8-248] kapag walang out mode reg.
1.0.3	Ayusin ang babala ng Vivado Linter: Ang Register ay may enable na driven by sabaysabay na pag-reset
1.0.4	Ayusin ang case ng sulok kapag tumatanggap ng mali ang pagkakabuo ng salita na may escape character bilang huling byte. Ang susunod na salita ay mawawala rin dahil hindi namin na-clear ang recv_data_prev_is_escape noong bumalik sa IDLE. Ang gen_uart_regs.py script ay nagbibigay-daan na ngayon sa mga natatanging pangalan ng reg.

Paglalarawan

Inilalarawan ng dokumentong ito ang mga sumusunod files at mga folder:
gen_uart_regs.py

nabuo/uart_regs.vhd
nabuo/uart_regs.py
nabuo/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/
Ang gen_uart_regs.py script at sumusuporta sa VHDL files sa proyektong ito ay nagbibigay-daan sa iyo na bumuo ng mga custom na interface para sa pagbabasa at pagsulat ng mga halaga ng rehistro ng FPGA ng iba't ibang uri at lapad gamit ang UART.
Maaari mong gamitin ang nabuong VHDL module at Python script upang magbasa mula o magsulat sa anumang bilang ng mga rehistro sa iyong disenyo. Ang mga naa-access na rehistro ng UART ay maaaring may mga uri na std_logic, std_logic_vector, nilagdaan, o hindi nalagdaan.
Maaari kang magpasya sa tumpak na komposisyon ng mga rehistro at uri ng input at output kapag bumubuo ng output files gamit ang gen_uart_regs.py script.
Ang mga script ng Python ay bahagyang ginawa sa tulong ng ChatGPT artificial intelligence tool, habang ang VHDL code ay gawa sa kamay.

Mga kinakailangan

Ang mga script sa proyektong ito ay dapat na tumakbo sa pamamagitan ng isang Python 3 interpreter at ang Pyserial package ay dapat na naka-install.
Maaari kang mag-install ng pyserial sa pamamagitan ng Pip gamit ang command na ito: pip install pyserial

Protocol

Ang VHDL files at Python script ay gumagamit ng data-framing protocol na may apat na kontrol

Pangalan	Halaga	Magkomento
READ_REQ	0x0A	Command mula sa host sa FPGA upang simulan ang isang write sequence upang ipadala ang lahat ng mga rehistro pabalik sa UART
START_WRITE	0x0B	Minarkahan ang simula ng isang pagkakasunud-sunod ng pagsulat sa alinman direksyon
END_WRITE	0x0C	Minamarkahan ang pagtatapos ng isang pagkakasunud-sunod ng pagsulat sa alinmang direksyon
TUMAKAS	0x0D	Escape character na ginagamit para sa pagtakas sa alinman sa mga control word, kabilang ang ESCAPE character mismo, kapag lumitaw ang mga ito bilang data sa pagitan ng START_WRITE at END_WRITE marker.

Ang anumang hindi nakatakas na READ_REQ byte na ipinadala sa FPGA ay isang tagubilin upang ipadala ang lahat ng mga UART-accessible na rehistro nito (mga input at output) pabalik sa host sa pamamagitan ng UART. Ang utos na ito ay karaniwang ibinibigay lamang ng uart_regs.py script.
Sa pagtanggap ng utos na ito, tutugon ang FPGA sa pamamagitan ng pagpapadala ng nilalaman ng lahat ng mga rehistro pabalik sa host. Una, ang input signal, pagkatapos ay ang output signal. Kung ang kanilang mga haba ay hindi nagdaragdag ng hanggang sa isang maramihang ng 8 bits, ang mas mababang mga bit ng huling byte ay magiging mga padded na zero.
Ang pagkakasunud-sunod ng pagsulat ay palaging nagsisimula sa START_WRITE byte at nagtatapos sa END_WRITE byte. Anumang mga byte sa pagitan ng mga iyon ay itinuturing na mga byte ng data. Kung ang anumang mga byte ng data ay may parehong halaga bilang isang control character, ang data byte ay dapat na i-escape. Nangangahulugan ito na magpadala ng karagdagang ESCAPE character bago ang byte ng data upang isaad na ito ay talagang data.
Kung ang isang hindi nakatakas na START_WRITE ay dumating saanman sa stream ng mga byte, ito ay itinuturing na simula ng isang write sequence. Ginagamit ng uart_regs_backend na module ang impormasyong ito upang muling i-synchronize kung sakaling mawalan ng sync ang komunikasyon.

gen_uart_regs.py

Ito ang script na dapat mong simulan upang makabuo ng interface. Nasa ibaba ang isang screenshot ng menu ng tulong na maaari mong makuha sa pamamagitan ng pagpapatakbo: python gen_uart_regs.py -h
Upang makabuo ng isang pasadyang interface, dapat mong patakbuhin ang script sa bawat isa sa iyong nais na nakokontrol na mga rehistro ng UART na nakalista bilang mga argumento. Ang mga available na uri ay std_logic, std_logic_vector, unsigned, at signed.
Ang default na mode (direksyon) ay nasa at ang default na uri ay std_logic_vector maliban kung ang rehistro ay may haba: 1. Pagkatapos, ito ay magiging default sa std_logic.

Kaya, kung gusto mong lumikha ng std_logic input signal, maaari mong gamitin ang alinman sa mga argumentong ito:
my_sl=1
my_sl=1:sa

my_sl=1:in:std_logic
Ang lahat ng mga variant sa itaas ay magreresulta sa script na bumubuo ng signal na naa-access ng UART na ito:
Patakbuhin natin ang script na may mga argumento upang makabuo ng isang interface na may ilang mga rehistro ng iba't ibang direksyon, haba, at uri

Nabuo files

Ang matagumpay na pagpapatakbo ng gen_uart_regs.py script ay gagawa ng isang output folder na pinangalanang nabuo kasama ng tatlo files nakalista sa ibaba. Kung mayroon na sila, mapapatungan ang mga ito.
nabuo/uart_regs.vhd

nabuo/uart_regs.py
nabuo/instantiation_template.vho
uart_regs.vhd

Ito ang custom na interface module na nabuo ng script. Kailangan mong i-instantiate ito sa iyong disenyo, kung saan maa-access nito ang mga rehistro na gusto mong kontrolin gamit ang UART.
Lahat ng nasa itaas ng seksyong “– UART accessible registers” ay magiging magkapareho para sa bawat uart_regs module, habang ang komposisyon ng mga port signal sa ibaba ng linyang iyon ay nakadepende sa mga argumentong ibinigay sa generator script.
Ipinapakita ng listahan sa ibaba ang entity para sa uart_regs module na nagreresulta mula sa generate command halampipinapakita sa gen_uart_regs.py secti

Hindi mo kailangang i-synchronize ang signal ng uart_rx, dahil pinangangasiwaan iyon sa uart_rx. modyul.
Kapag nakatanggap ang module ng read request, kukunin nito ang mga value ng lahat ng input at output signal sa loob ng kasalukuyang clock cycle. Ang instant snapshot ay ipapadala sa host sa UART.
Kapag nangyari ang isang pagsusulat, ang lahat ng mga rehistro ng output ay ina-update gamit ang mga bagong halaga sa loob ng parehong ikot ng orasan. Hindi posibleng baguhin ang mga halaga ng signal ng output nang paisa-isa.

Gayunpaman, ang uart_regs.py script ay nagbibigay-daan sa gumagamit na i-update lamang ang mga napiling output sa pamamagitan ng unang pagbabasa pabalik sa kasalukuyang mga halaga ng lahat ng mga rehistro. Pagkatapos ay isinusulat nito ang lahat ng mga halaga, kabilang ang mga na-update.
uart_regs.py
Ang nabuong/uart_regs.py file ay nabuo kasama ng uart_regs VHDL module at naglalaman ng custom na impormasyon sa pagpaparehistro sa header ng file. Gamit ang script na ito, maaari kang magbasa mula o sumulat sa iyong mga custom na rehistro nang madali.

Menu ng tulong

I-type ang python uart_regs.py -h upang i-print ang menu ng tulong:

Pagtatakda ng UART port

Ang script ay may mga opsyon upang itakda ang UART port gamit ang -c switch. Gumagana ito sa Windows at Linux. Itakda ito sa isa sa mga available na port na nakalista sa menu ng tulong. Upang magtakda ng default na port, maaari mo ring i-edit ang UART_PORT variable sa uart_regs.py script.

Mga rehistro ng listahan

Ang impormasyon tungkol sa register mapping ay inilalagay sa header ng uart_regs.py script ng gen_uart_regs.py script. Maaari mong ilista ang magagamit na mga rehistro gamit ang -l switch, tulad ng nakikita sa ibaba. Ito ay isang lokal na utos at hindi makikipag-ugnayan sa target na FPGA

Pagsusulat sa mga rehistro

Maaari kang sumulat sa alinman sa mga rehistro ng out mode sa pamamagitan ng paggamit ng -w switch. Ibigay ang pangalan ng rehistro na sinusundan ng "=" at ang halaga na ibinigay bilang isang binary, hexadecimal, o decimal na halaga, tulad ng ipinapakita sa ibaba.
Tandaan na ang pagpapatupad ng VHDL ay nangangailangan ng script na isulat ang lahat ng mga rehistro ng output nang sabay-sabay. Samakatuwid, kung hindi ka tumukoy ng kumpletong hanay ng mga rehistro ng output, magsasagawa muna ang script ng pagbabasa mula sa target na FPGA at pagkatapos ay gagamitin ang mga halagang iyon para sa mga nawawala. Ang magiging resulta ay ang mga tinukoy na rehistro lamang ang magbabago
Kapag nagsagawa ka ng pagsulat, magbabago ang lahat ng tinukoy na rehistro sa parehong cycle ng orasan, hindi sa sandaling matanggap ang mga ito sa UART.

Pagbabasa ng mga rehistro

Gamitin ang -r switch upang basahin ang lahat ng mga halaga ng rehistro, tulad ng ipinapakita sa ibaba. Ang mga value na minarkahan ng dilaw ay ang mga binago namin sa nakaraang write example
Ang bawat pagbabasa ay nagpapakita ng agarang snapshot ng lahat ng input at output registers. Lahat sila ay samphumantong sa parehong ikot ng orasan

Pag-debug

Gamitin ang -d switch sa alinman sa iba pang switch kung kailangan mong i-debug ang protocol ng komunikasyon. Pagkatapos, ipi-print ng script ang lahat ng ipinadala at natanggap na mga byte at tag kung sila ay mga control character, tulad ng ipinapakita sa ibaba.

Gamit ang interface sa iba pang mga script ng Python

Ang uart_regs.py script ay naglalaman ng klase ng UartRegs na madali mong magagamit bilang interface ng komunikasyon sa iba pang custom na script ng Python. I-import lamang ang klase, lumikha ng isang bagay nito, at simulan ang paggamit ng mga pamamaraan, tulad ng ipinapakita sa ibaba.

Sumangguni sa mga docstring sa Python code para sa pamamaraan at mga paglalarawan at mga uri ng halaga ng pagbabalik.

instantiation_template.vho

Ang template ng instantiation ay nabuo kasama ng uart_regs module para sa iyong kaginhawahan. Upang makatipid ng oras sa pag-coding, maaari mong kopyahin ang instantiation ng module at mga deklarasyon ng signal sa iyong disenyo.

Static na RTL files

Kailangan mong isama ang mga sumusunod files sa iyong proyekto sa VHDL upang maisama ang mga ito sa parehong library bilang module ng uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Ang uart_regs_backend na module ay nagpapatupad ng mga makinang may hangganan na estado na nag-orasan sa loob at labas ng data ng rehistro. Ginagamit nito ang uart_rx at uart_tx na mga module upang pangasiwaan ang komunikasyon ng UART sa host.

Mga proyekto sa demo

Mayroong tatlong mga proyekto ng demo na kasama sa Zip file. Hinahayaan ka nilang kontrolin ang mga peripheral sa iba't ibang mga board pati na rin ang ilang mas malalaking, panloob na mga rehistro.
Kasama sa mga demo folder ang paunang nabuong uart_regs.vhd at uart_regs.py files ginawa partikular para sa mga disenyo.

Lattice iCEstick

Ang folder ng demo/icecube2_icestick ay naglalaman ng isang register access demo na pagpapatupad para sa Lattice iCEstick FPGA board.
Upang tumakbo sa proseso ng pagpapatupad, buksan ang demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file sa Lattice iCEcube2 design software.
Pagkatapos i-load ang proyekto sa iCEcube2 GUI, i-click ang Tools→Run All para bumuo ng programming bitmap file.

Maaari mong gamitin ang tool ng Lattice Diamond Programmer Standalone upang i-configure ang FPGA gamit ang nabuong bitmap file. Kapag nagbukas ang Diamond Programmer, i-click ang Buksan ang isang umiiral na proyekto ng programmer sa welcome dialog box.
Pumili ng proyekto file matatagpuan sa Zip: demo/lattice_icestick/diamond_programmer_project.xcf at i-click ang OK.
Pagkatapos mag-load ng proyekto, i-click ang tatlong tuldok sa File Pangalan ng column, tulad ng ipinapakita sa itaas. Mag-browse upang piliin ang bitmap file na nabuo mo sa iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Panghuli, kapag ang iCEstick board ay nakasaksak sa isang USB port sa iyong computer, piliin ang Design→Program para i-program ang SPI flash at i-configure ang FPGA.
Maaari ka na ngayong magpatuloy sa pagbabasa at pagsulat ng mga rehistro sa pamamagitan ng paggamit ng demo/lattice_icestick/uart_regs.py script gaya ng inilarawan sa seksyong uart_regs.py.

Xilinx Digilent Arty A7-35T

Mahahanap mo ang demo na pagpapatupad para sa Artix-7 35T Arty FPGA evaluation kit sa demo/arty_a7_35 na folder.
Buksan ang Vivado at mag-navigate sa na-extract files gamit ang Tcl console na makikita sa ibaba ng interface ng GUI. I-type ang command na ito para ipasok ang demo project folder:

cd /demo/arty_a7_35/vivado_proj/
Isagawa ang create_vivado_proj.tcl Tcl script upang muling buuin ang proyekto ng Vivado:
pinagmulan ./create_vivado_proj.tcl

I-click ang Bumuo ng Bitstream sa sidebar upang patakbuhin ang lahat ng mga hakbang sa pagpapatupad at buuin ang programming bitstream file.
Panghuli, i-click ang Open Hardware Manager at i-program ang FPGA sa pamamagitan ng GUI.
Maaari ka na ngayong magpatuloy sa pagbabasa at pagsulat ng mga rehistro sa pamamagitan ng paggamit ng demo/arty_a7_35/uart_regs.py script gaya ng inilalarawan sa seksyong uart_regs.py.

Xilinx Digilent Arty S7-50

Mahahanap mo ang pagpapatupad ng demo para sa Arty S7: Spartan-7 FPGA development board sa folder ng demo/arty_s7_50.
Buksan ang Vivado at mag-navigate sa na-extract files gamit ang Tcl console na makikita sa ibaba ng interface ng GUI. I-type ang command na ito para ipasok ang demo project folder:

cd /demo/arty_s7_50/vivado_proj/
Isagawa ang create_vivado_proj.tcl Tcl script upang muling buuin ang proyekto ng Vivado:
pinagmulan ./create_vivado_proj.tcl

I-click ang Bumuo ng Bitstream sa sidebar upang patakbuhin ang lahat ng mga hakbang sa pagpapatupad at buuin ang programming bitstream file.
Panghuli, i-click ang Open Hardware Manager at i-program ang FPGA sa pamamagitan ng GUI.
Maaari ka na ngayong magpatuloy sa pagbabasa at pagsulat ng mga rehistro sa pamamagitan ng paggamit ng demo/arty_s7_50/uart_regs.py script gaya ng inilalarawan sa seksyong uart_regs.py.

Pagpapatupad

Walang tiyak na mga kinakailangan sa pagpapatupad.

Mga hadlang

Walang tiyak na timing constraints ang kailangan para sa disenyong ito dahil ang UART interface ay mabagal at itinuturing bilang isang asynchronous na interface.

Ang uart_rx input sa uart_regs module ay naka-synchronize sa loob ng uart_rx module. Kaya, hindi ito kailangang i-synchronize sa top-level na module.

Mga kilalang isyu

Maaaring kailanganin mong i-reset ang module bago ito magamit, depende sa kung sinusuportahan ng iyong arkitektura ng FPGA ang mga default na halaga ng rehistro.

Higit pang impormasyon

Mga FAQ

Q: Ano ang layunin ng UART test interface generator?

A: Ang UART test interface generator ay nagbibigay-daan para sa paglikha ng mga custom na interface upang makipag-ugnayan sa FPGA register values gamit ang UART communication.

T: Paano ko mai-install ang Pyserial package?

A: Maaari mong i-install ang Pyserial sa pamamagitan ng Pip gamit ang command: pip install pyserial

Mga Dokumento / Mga Mapagkukunan

VHDLwhiz UART Test Interface Generator [pdf] User Manual
UART Test Interface Generator, Test Interface Generator, Interface Generator, Generator

Mga sanggunian

User Manual

VHDLwhiz UART Test Interface Generator

Impormasyon ng Produkto