VHDLwhiz UART Test Interface Generator Gebruikershandleiding

Hierdie produk laat jou toe om pasgemaakte koppelvlakke te genereer vir die lees en skryf van FPGA-registerwaardes met behulp van UART. Die gegenereerde VHDL-module en Python-skrip bied die vermoë om met verskillende soorte registers in jou FPGA-ontwerp te kommunikeer.

Vereistes

Python 3 tolk
pyseriële pakket

Protokol

Die produk gebruik 'n dataraamprotokol met vier beheerkarakters:

Naam: READ_REQ, Waarde: 0x0A - Opdrag van die gasheer na die FPGA om 'n skryfvolgorde te begin om alle registers terug te stuur oor UART
Naam: START_SKRYF, Waarde: 0x0B – Merk die begin van 'n skryfreeks in enige rigting

Naam: END_SKRYF, Waarde: 0x0C – Merk die einde van 'n skryfreeks in enige rigting
Naam: Vlug, Waarde: 0x0D – Ontsnapkarakter wat gebruik word om beheerwoorde te ontsnap

Produkgebruiksinstruksies

Begin die skrifte

Om die produk te gebruik, maak seker dat jy Python 3 geïnstalleer het en die Pyserial-pakket. Begin die skrifte deur 'n Python 3-tolk.

Genereer pasgemaakte koppelvlakke

Gebruik die gen_uart_regs.py-skrip om pasgemaakte koppelvlakke te genereer vir die lees en skryf van FPGA-registerwaardes. Jy kan die samestelling van invoer- en afvoerregisters en tipes spesifiseer wanneer die uitset gegenereer word files.

Interaksie met registers

Jy kan lees uit of skryf na enige aantal registers in jou FPGA-ontwerp deur die gegenereerde VHDL-module en Python-skrip te gebruik. Die toeganklike registers kan tipes hê soos std_logic, std_logic_vector, signed, of unsigned.

Lisensie

Die MIT-lisensie dek die bronkode se kopieregvereistes en gebruiksvoorwaardes. Verwys na die LICENSE.txt file in die zip file vir besonderhede.

Veranderlogboek

Hierdie veranderinge verwys na die projek files, en hierdie dokument word dienooreenkomstig bygewerk

Weergawe	Opmerkings
1.0.0	Aanvanklike vrystelling
1.0.1	Vaste ontbrekende «self» verwysingsfout by die invoer as uart_regs.py as 'n Python-module. Verander skryf mislukte uitdruk na uitsondering op vermy druk na die konsole wanneer dit as 'n ingevoerde module loop.
1.0.2	Herstel vir Vivado [Synth 8-248]-fout wanneer daar geen uitmodusregs is nie.
1.0.3	Herstel Vivado Linter-waarskuwing: Register het aktiveer aangedryf deur sinchrone herstel
1.0.4	Maak die hoekkas reg wanneer 'n misvormde woord met die ontsnap-karakter as die laaste greep ontvang word. Die volgende woord sal ook verlore gaan omdat ons nie recv_data_prev_is_escape uitgevee het toe ons teruggekeer het na IDLE nie. Die gen_uart_regs.py script laat nou slegs unieke reg name toe.

Beskrywing

Hierdie dokument beskryf die volgende files en dopgehou:
gen_uart_regs.py

gegenereer/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/
Die gen_uart_regs.py script en ondersteunende VHDL files in hierdie projek laat jou toe om persoonlike koppelvlakke te genereer vir die lees en skryf van FPGA-registerwaardes van verskillende tipes en breedtes met behulp van UART.
Jy kan die gegenereerde VHDL-module en Python-skrip gebruik om uit of skryf na enige aantal registers in jou ontwerp. Die UART-toeganklike registers kan die tipes std_logic, std_logic_vector, getekende of ongetekende hê.
Jy kan besluit oor die presiese samestelling van inset- en uitsetregisters en tipes wanneer die uitset gegenereer word files met behulp van die gen_uart_regs.py script.
Die Python-skrifte is gedeeltelik geskep met behulp van die ChatGPT kunsmatige intelligensie-instrument, terwyl die VHDL-kode handgemaak is.

Vereistes

Die skrifte in hierdie projek moet deur 'n Python 3-tolk uitgevoer word en die Pyserial-pakket moet geïnstalleer word.
Jy kan pyserial installeer deur Pip deur hierdie opdrag te gebruik: pip install pyserial

Protokol

Die VHDL files en Python script gebruik 'n data-raam protokol met vier beheer

Naam	Waarde	Lewer kommentaar
READ_REQ	0x0A	Opdrag van die gasheer na die FPGA om 'n skryf te begin volgorde om alle registers oor UART terug te stuur
START_SKRYF	0x0B	Merk die begin van 'n skryfvolgorde in beide rigting
END_SKRYF	0x0C	Merk die einde van 'n skryfreeks in enige rigting
VLUG	0x0d	Ontsnapkarakter wat gebruik word om enige van die beheerwoorde te ontsnap, insluitend die ESCAPE-karakter self, wanneer hulle as data tussen die START_WRITE- en END_WRITE-merkers verskyn.

Enige READ_REQ-greep wat nie na die FPGA gestuur is nie, is 'n instruksie om al sy UART-toeganklike registers (insette en uitsette) terug te stuur na die gasheer oor UART. Hierdie opdrag word gewoonlik slegs deur die uart_regs.py-skrip uitgereik.
By ontvangs van hierdie opdrag sal die FPGA reageer deur die inhoud van alle registers terug te stuur na die gasheer. Eerstens die insetseine, dan die uitsetseine. As hul lengtes nie 'n veelvoud van 8 bisse optel nie, sal die onderste bisse van die laaste greep nulle wees.
'n Skryfvolgorde begin altyd met die START_WRITE greep en eindig met die END_WRITE greep. Enige grepe tussen hulle word as datagrepe beskou. As enige datagrepe dieselfde waarde as 'n kontrolekarakter het, moet die datagrepe ontsnap word. Dit beteken om 'n ekstra ESCAPE-karakter voor die datagreep te stuur om aan te dui dat dit eintlik data is.
As 'n onontgonnen START_WRITE enige plek in die stroom grepe aankom, word dit as die begin van 'n skryfvolgorde beskou. Die uart_regs_backend-module gebruik hierdie inligting om te hersinkroniseer ingeval die kommunikasie nie gesinchroniseer word nie.

gen_uart_regs.py

Dit is die skrif waarmee jy moet begin om die koppelvlak te genereer. Hieronder is 'n skermkiekie van die hulpkieslys wat u kan kry deur te hardloop: python gen_uart_regs.py -h
Om 'n pasgemaakte koppelvlak te genereer, moet u die skrip laat loop met elk van u gewenste UART-beheerbare registers wat as argumente gelys word. Die beskikbare tipes is std_logic, std_logic_vector, unsigned en signed.
Die verstekmodus (rigting) is in en die verstektipe is std_logic_vector tensy die register lank is: 1. Dan sal dit verstek na std_logic.

Dus, as jy 'n std_logic insetsein wil skep, kan jy enige van hierdie argumente gebruik:
my_sl=1
my_sl=1:in

my_sl=1:in:std_logic
Al die bogenoemde variante sal daartoe lei dat die skrip hierdie UART-toeganklike sein genereer:
Kom ons hardloop die skrif met argumente om 'n koppelvlak met verskeie registers van verskillende rigtings, lengtes en tipes te genereer

Gegenereer files

'n Suksesvolle uitvoering van die gen_uart_regs.py-skrip sal 'n uitvoerlêer met die naam produseer, gegenereer met die drie files hieronder gelys. As hulle reeds bestaan, sal hulle oorgeskryf word.
gegenereer/uart_regs.vhd

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

Dit is die pasgemaakte koppelvlakmodule wat deur die skrif gegenereer word. U moet dit in u ontwerp instansieer, waar dit toegang kan verkry tot die registers wat u met UART wil beheer.
Alles bo die "– UART toeganklike registers" afdeling sal identies wees vir elke uart_regs module, terwyl die samestelling van poort seine onder daardie lyn afhang van die argumente wat aan die generator script gegee word.
Die lys hieronder toon die entiteit vir die uart_regs-module wat voortspruit uit die genereer-opdrag bvample gewys in die gen_uart_regs.py secti

Jy hoef nie die uart_rx-sein te sinchroniseer nie, aangesien dit in die uart_rx hanteer word. module.
Wanneer die module 'n leesversoek ontvang, sal dit die waardes van alle inset- en uitsetseine binne die huidige kloksiklus vasvang. Die oombliklike momentopname word dan oor UART na die gasheer gestuur.
Wanneer 'n skryf plaasvind, word alle uitsetregisters opgedateer met die nuwe waardes binne dieselfde kloksiklus. Dit is nie moontlik om uitsetseinwaardes individueel te verander nie.

Die uart_regs.py-skrip laat die gebruiker egter toe om slegs geselekteerde uitsette op te dateer deur eers die huidige waardes van alle registers terug te lees. Dit skryf dan alle waardes terug, insluitend die opgedateerdes.
uart_regs.py
Die gegenereerde/uart_regs.py file word saam met die uart_regs VHDL-module gegenereer en bevat die persoonlike registerinligting in die kop van die file. Met hierdie skrif kan jy met gemak van jou persoonlike registers lees of skryf.

Hulp-kieslys

Tik python uart_regs.py -h om die hulpkieslys te druk:

Stel die UART-poort in

Die skrip het opsies om die UART-poort te stel met die -c-skakelaar. Dit werk op Windows en Linux. Stel dit op een van die beskikbare poorte wat in die hulpkieslys gelys word. Om 'n verstekpoort te stel, kan jy ook die UART_PORT-veranderlike in die uart_regs.py-skrip wysig.

Noteringsregisters

Inligting oor die registerkartering word in die kopskrif van die uart_regs.py-skrip geplaas deur die gen_uart_regs.py-skrip. Jy kan die beskikbare registers lys met die -l skakelaar, soos hieronder gesien. Dit is 'n plaaslike opdrag en sal nie met die teiken FPGA interaksie hê nie

Skryf aan registers

Jy kan na enige van die uit-modus-registers skryf deur die -w-skakelaar te gebruik. Verskaf die registernaam gevolg deur “=” en die waarde gegee as 'n binêre, heksadesimale of desimale waarde, soos hieronder getoon.
Let daarop dat die VHDL-implementering vereis dat die skrip alle uitvoerregisters gelyktydig skryf. As jy dus nie 'n volledige stel uitsetregisters spesifiseer nie, sal die skrip eers 'n lees vanaf die teiken FPGA uitvoer en dan daardie waardes vir die ontbrekende gebruik. Die gevolg sal wees dat slegs die gespesifiseerde registers verander
Wanneer jy 'n skryf doen, sal alle gespesifiseerde registers gedurende dieselfde kloksiklus verander, nie sodra hulle oor UART ontvang word nie.

Lees registers

Gebruik die -r-skakelaar om alle registerwaardes te lees, soos hieronder getoon. Die waardes wat in geel gemerk is, is dié wat ons in die vorige skryfbv verander hetample
Elke lees toon 'n oombliklike momentopname van alle invoer- en uitsetregisters. Hulle is almal sampgelei tydens dieselfde kloksiklus

Ontfouting

Gebruik die -d-skakelaar met enige van die ander skakelaars as jy die kommunikasieprotokol moet ontfout. Dan sal die skrif alle gestuurde en ontvangde grepe en tag hulle as hulle beheerkarakters is, soos hieronder getoon.

Gebruik die koppelvlak in ander Python-skrifte

Die uart_regs.py script bevat 'n UartRegs klas wat jy maklik kan gebruik as die kommunikasie koppelvlak in ander pasgemaakte Python skrifte. Voer eenvoudig die klas in, skep 'n objek daarvan en begin die metodes gebruik, soos hieronder getoon.

Verwys na die docstrings in die Python-kode vir metode en beskrywings en tipes terugkeerwaardes.

instantiation_template.vho

Die instansieringssjabloon word saam met die uart_regs-module vir u gerief gegenereer. Om kodering tyd te bespaar, kan jy die module instansiasie en sein verklarings in jou ontwerp kopieer.

Statiese RTL files

Jy moet die volgende insluit files in jou VHDL-projek sodat hulle in dieselfde biblioteek as die uart_regs-module saamgestel word:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Die uart_regs_backend-module implementeer die eindige-toestand masjiene wat die registerdata in- en uitklok. Dit gebruik die uart_rx- en uart_tx-modules om die UART-kommunikasie met die gasheer te hanteer.

Demo projekte

Daar is drie demo-projekte ingesluit in die Zip file. Hulle laat jou toe om die randapparatuur op die verskillende borde te beheer, asook 'n paar groter, interne registers.
Die demo-vouers bevat vooraf-gegenereerde uart_regs.vhd en uart_regs.py files spesifiek vir daardie ontwerpe gemaak.

Rooster iCEstick

Die demo/icecube2_icestick-lêergids bevat 'n registertoegang-demo-implementering vir die Lattice iCEstick FPGA-bord.
Om deur die implementeringsproses te loop, maak die demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project oop file in die Lattice iCEcube2-ontwerpsagteware.
Nadat u die projek in die iCEcube2 GUI gelaai het, klik Tools→ Run All om die programmeringsbitmap te genereer file.

Jy kan die Lattice Diamond Programmer Standalone-nutsding gebruik om die FPGA op te stel met die gegenereerde bitmap file. Wanneer Diamantprogrammeerder oopmaak, klik Open 'n bestaande programmeerderprojek in die verwelkomingsdialoog.
Kies projek file gevind in die zip: demo/lattice_icestick/diamond_programmer_project.xcf en klik OK.
Nadat die projek gelaai is, klik die drie kolletjies in die File Naam kolom, soos hierbo getoon. Blaai om die bitmap te kies file wat jy in iCEcube2 gegenereer het

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Ten slotte, met die iCEstick-bord wat by 'n USB-poort op jou rekenaar ingeprop is, kies Ontwerp→Program om die SPI-flits te programmeer en die FPGA op te stel.
Jy kan nou voortgaan om registers te lees en te skryf deur die demo/lattice_icestick/uart_regs.py script te gebruik soos beskryf in die uart_regs.py afdeling.

Xilinx Digilent Arty A7-35T

Jy kan die demo-implementering vir die Artix-7 35T Arty FPGA-evaluasiestel in die demo/arty_a7_35-lêergids vind.
Maak Vivado oop en navigeer na die onttrek files met behulp van die Tcl-konsole wat onderaan die GUI-koppelvlak gevind word. Tik hierdie opdrag om die demo-projeklêer te betree:

cd /demo/arty_a7_35/vivado_proj/
Voer die create_vivado_proj.tcl Tcl-skrip uit om die Vivado-projek te herstel:
bron ./create_vivado_proj.tcl

Klik Genereer Bitstream in die sybalk om deur al die implementeringstappe te loop en die programmeringsbitstroom te genereer file.
Ten slotte, klik Open Hardware Manager en programmeer die FPGA deur die GUI.
Jy kan nou voortgaan om registers te lees en te skryf deur die demo/arty_a7_35/uart_regs.py-skrip te gebruik soos beskryf in die uart_regs.py-afdeling.

Xilinx Digilent Arty S7-50

U kan die demo-implementering vir die Arty S7: Spartan-7 FPGA-ontwikkelingsbord in die demo/arty_s7_50-lêergids vind.
Maak Vivado oop en navigeer na die onttrek files met behulp van die Tcl-konsole wat onderaan die GUI-koppelvlak gevind word. Tik hierdie opdrag om die demo-projeklêer te betree:

cd /demo/arty_s7_50/vivado_proj/
Voer die create_vivado_proj.tcl Tcl-skrip uit om die Vivado-projek te herstel:
bron ./create_vivado_proj.tcl

Klik Genereer Bitstream in die sybalk om deur al die implementeringstappe te loop en die programmeringsbitstroom te genereer file.
Ten slotte, klik Open Hardware Manager en programmeer die FPGA deur die GUI.
Jy kan nou voortgaan om registers te lees en te skryf deur die demo/arty_s7_50/uart_regs.py-skrip te gebruik soos beskryf in die uart_regs.py-afdeling.

Implementering

Daar is geen spesifieke implementeringsvereistes nie.

Beperkings

Geen spesifieke tydsbeperkings is nodig vir hierdie ontwerp nie omdat die UART-koppelvlak stadig is en as 'n asinchrone koppelvlak behandel word.

Die uart_rx-invoer na die uart_regs-module word binne die uart_rx-module gesinchroniseer. Dit hoef dus nie in die topvlakmodule gesinchroniseer te word nie.

Bekende probleme

Jy sal dalk die module moet terugstel voordat dit gebruik kan word, afhangende van of jou FPGA-argitektuur verstekregisterwaardes ondersteun.

Meer inligting

Kopiereg VHDLwhiz.com

Gereelde vrae

V: Wat is die doel van die UART-toetskoppelvlakgenerator?

A: Die UART-toetskoppelvlakgenerator maak voorsiening vir die skepping van pasgemaakte koppelvlakke om met FPGA-registerwaardes te kommunikeer deur UART-kommunikasie te gebruik.

V: Hoe installeer ek die Pyserial-pakket?

A: Jy kan Pyserial deur Pip installeer met die opdrag: pip install pyserial

Dokumente / Hulpbronne

VHDLwhiz UART Toets Interface Generator [pdfGebruikershandleiding
UART Toets Interface Generator, Toets Interface Generator, Interface Generator, Generator

Verwysings

Gebruikershandleiding

VHDLwhiz UART Toets Interface Generator

Produk inligting