Manual d'usuari del generador d'interfícies de prova VHDLwhiz UART

Aquest producte us permet generar interfícies personalitzades per llegir i escriure valors de registre FPGA mitjançant UART. El mòdul VHDL generat i l'script Python ofereixen la possibilitat d'interaccionar amb diversos tipus de registres en el vostre disseny FPGA.

Requisits

Intèrpret Python 3
paquet pyserial

Protocol

El producte utilitza un protocol de marc de dades amb quatre caràcters de control:

Nom: READ_REQ, Valor: 0x0A: ordre de l'amfitrió a l'FPGA per iniciar una seqüència d'escriptura per enviar tots els registres de nou a través d'UART
Nom: START_ESCRIURE, Valor: 0x0B: marca el començament d'una seqüència d'escriptura en qualsevol direcció

Nom: END_WRITE, Valor: 0x0C: marca el final d'una seqüència d'escriptura en qualsevol direcció
Nom: ESCAPAR, Valor: 0x0D: caràcter d'escapament utilitzat per escapar de paraules de control

Instruccions d'ús del producte

Execució dels scripts

Per utilitzar el producte, assegureu-vos que teniu instal·lat Python 3 i el paquet Pyserial. Executeu els scripts mitjançant un intèrpret de Python 3.

Generació d'interfícies personalitzades

Utilitzeu l'script gen_uart_regs.py per generar interfícies personalitzades per llegir i escriure valors de registre FPGA. Podeu especificar la composició dels registres i tipus d'entrada i sortida en generar la sortida files.

Interacció amb els registres

Podeu llegir o escriure en qualsevol nombre de registres del vostre disseny FPGA mitjançant el mòdul VHDL generat i l'script Python. Els registres accessibles poden tenir tipus com ara std_logic, std_logic_vector, signed o unsigned.

llicència

La llicència del MIT cobreix els requisits de copyright i les condicions d'ús del codi font. Consulteu el LICENSE.txt file al Zip file per als detalls.

Registre de canvis

Aquests canvis fan referència al projecte files, i aquest document s'actualitza en conseqüència

Versió	Observacions
1.0.0	Alliberament inicial
1.0.1	S'ha corregit l'error de referència "auto" que faltava quan s'importava com a uart_regs.py com a mòdul de Python. S'ha canviat la impressió d'error d'escriptura a excepció a evita imprimir a la consola quan s'executa com a mòdul importat.
1.0.2	S'ha solucionat l'error Vivado [Synth 8-248] quan no hi ha registres de mode de sortida.
1.0.3	Solucioneu l'avís de Vivado Linter: el registre ha activat impulsat per restabliment sincrònic
1.0.4	Corregiu el cas de la cantonada quan rebeu una paraula amb un format incorrecte amb el caràcter d'escapada com a darrer byte. La paraula següent també es perdria perquè no hem esborrat recv_data_prev_is_escape quan tornem a IDLE. L'script gen_uart_regs.py ara només permet noms de registre únics.

Descripció

Aquest document descriu el següent files i carpetes:
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
demostració/lattice_icestick/
demo/xilinx_arty_a7_35/
demostració/xilinx_arty_s7_50/
L'script gen_uart_regs.py i compatible amb VHDL fileEls d'aquest projecte us permeten generar interfícies personalitzades per llegir i escriure valors de registre FPGA de diversos tipus i amplades mitjançant UART.
Podeu utilitzar el mòdul VHDL generat i l'script Python per llegir o escriure en qualsevol nombre de registres del vostre disseny. Els registres accessibles UART poden tenir els tipus std_logic, std_logic_vector, signed o unsigned.
Podeu decidir la composició precisa dels registres i tipus d'entrada i sortida en generar la sortida files utilitza l'script gen_uart_regs.py.
Els scripts de Python es van crear parcialment amb l'ajuda de l'eina d'intel·ligència artificial ChatGPT, mentre que el codi VHDL està fet a mà.

Requisits

Els scripts d'aquest projecte s'han d'executar mitjançant un intèrpret Python 3 i el paquet Pyserial s'ha d'instal·lar.
Podeu instal·lar pyserial mitjançant Pip utilitzant aquesta ordre: pip install pyserial

Protocol

El VHDL files i l'script Python utilitzen un protocol de marc de dades amb quatre controls

Nom	Valor	Comenta
READ_REQ	0x0A	Comanda des de l'amfitrió a l'FPGA per iniciar una escriptura seqüència per enviar tots els registres de nou per UART
START_ESCRIU	0x0B	Marca l'inici d'una seqüència d'escriptura en qualsevol direcció
END_SCRIU	0x0C	Marca el final d'una seqüència d'escriptura en qualsevol direcció
ESCAPAR	0x0D	Caràcter d'escapada que s'utilitza per escapar de qualsevol de les paraules de control, inclòs el propi caràcter d'escapada, quan apareixen com a dades entre els marcadors START_WRITE i END_WRITE.

Qualsevol byte READ_REQ sense escapar enviat a l'FPGA és una instrucció per enviar tots els seus registres accessibles per UART (entrades i sortides) a l'amfitrió a través d'UART. Aquesta ordre normalment només l'emet l'script uart_regs.py.
En rebre aquesta ordre, l'FPGA respondrà enviant el contingut de tots els registres de nou a l'amfitrió. Primer, els senyals d'entrada, després els senyals de sortida. Si les seves longituds no sumen un múltiple de 8 bits, els bits inferiors de l'últim byte seran zeros encoixinats.
Una seqüència d'escriptura sempre comença amb el byte START_WRITE i acaba amb el byte END_WRITE. Qualsevol byte entre aquests es considera bytes de dades. Si algun byte de dades té el mateix valor que un caràcter de control, el byte de dades s'ha d'escapar. Això significa enviar un caràcter ESCAPE addicional abans del byte de dades per indicar que en realitat es tracta de dades.
Si un START_WRITE sense escapar arriba a qualsevol part del flux de bytes, es considera l'inici d'una seqüència d'escriptura. El mòdul uart_regs_backend utilitza aquesta informació per tornar a sincronitzar-se en cas que la comunicació no es sincronitzi.

gen_uart_regs.py

Aquest és l'script amb el qual heu de començar per generar la interfície. A continuació es mostra una captura de pantalla del menú d'ajuda que podeu obtenir executant: python gen_uart_regs.py -h
Per generar una interfície personalitzada, heu d'executar l'script amb cadascun dels registres controlables UART que vulgueu enumerats com a arguments. Els tipus disponibles són std_logic, std_logic_vector, unsigned i signed.
El mode predeterminat (direcció) és en i el tipus predeterminat és std_logic_vector tret que el registre sigui de longitud: 1. Aleshores, per defecte serà std_logic.

Per tant, si voleu crear un senyal d'entrada std_logic, podeu utilitzar qualsevol d'aquests arguments:
my_sl=1
my_sl=1:in

my_sl=1:in:std_logic
Totes les variants anteriors faran que l'script generi aquest senyal accessible per UART:
Executem l'script amb arguments per generar una interfície amb diversos registres de diferents direccions, longituds i tipus

Generat files

Una execució correcta de l'script gen_uart_regs.py produirà una carpeta de sortida anomenada generada amb els tres files enumerades a continuació. Si ja existeixen, se sobreescriuran.
generated/uart_regs.vhd

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

Aquest és el mòdul d'interfície personalitzat generat per l'script. Heu d'instanciar-lo al vostre disseny, on pot accedir als registres que voleu controlar mitjançant UART.
Tot el que hi ha a sobre de la secció "– Registres accessibles UART" serà idèntic per a cada mòdul uart_regs, mentre que la composició dels senyals de port per sota d'aquesta línia depèn dels arguments donats a l'script del generador.
La llista següent mostra l'entitat per al mòdul uart_regs resultant de l'ordre generate exampfitxer que es mostra a la secció gen_uart_regs.py

No cal que sincronitzeu el senyal uart_rx, ja que això es gestiona a uart_rx. mòdul.
Quan el mòdul rep una sol·licitud de lectura, capturarà els valors de tots els senyals d'entrada i sortida dins del cicle de rellotge actual. La instantània instantània s'envia a l'amfitrió mitjançant UART.
Quan es produeix una escriptura, tots els registres de sortida s'actualitzen amb els nous valors dins del mateix cicle de rellotge. No és possible canviar els valors del senyal de sortida individualment.

Tanmateix, l'script uart_regs.py permet a l'usuari actualitzar només les sortides seleccionades llegint primer els valors actuals de tots els registres. A continuació, escriu tots els valors, inclosos els actualitzats.
uart_regs.py
El fitxer generated/uart_regs.py file es genera juntament amb el mòdul uart_regs VHDL i conté la informació del registre personalitzat a la capçalera del file. Amb aquest script, podeu llegir o escriure als vostres registres personalitzats amb facilitat.

Menú d'ajuda

Escriviu python uart_regs.py -h per imprimir el menú d'ajuda:

Configuració del port UART

L'script té opcions per configurar el port UART mitjançant l'interruptor -c. Això funciona a Windows i Linux. Configureu-lo en un dels ports disponibles que apareixen al menú d'ajuda. Per establir un port predeterminat, també podeu editar la variable UART_PORT a l'script uart_regs.py.

Llistat de registres

La informació sobre l'assignació del registre es col·loca a la capçalera de l'script uart_regs.py mitjançant l'script gen_uart_regs.py. Podeu llistar els registres disponibles amb el commutador -l, com es veu a continuació. Aquesta és una ordre local i no interactuarà amb l'FPGA de destinació

Escriure als registres

Podeu escriure a qualsevol dels registres del mode de sortida utilitzant el commutador -w. Proporcioneu el nom del registre seguit de "=" i el valor donat com a valor binari, hexadecimal o decimal, tal com es mostra a continuació.
Tingueu en compte que la implementació de VHDL requereix que l'script escrigui tots els registres de sortida simultàniament. Per tant, si no especifiqueu un conjunt complet de registres de sortida, l'script primer realitzarà una lectura des de l'FPGA de destinació i després utilitzarà aquests valors per als que falten. El resultat serà que només canvien els registres especificats
Quan feu una escriptura, tots els registres especificats canviaran durant el mateix cicle de rellotge, no tan bon punt es rebin per UART.

Lectura de registres

Utilitzeu l'interruptor -r per llegir tots els valors del registre, tal com es mostra a continuació. Els valors marcats en groc són els que hem canviat a l'escriptura anterior example
Cada lectura mostra una instantània instantània de tots els registres d'entrada i sortida. Tots són sampconduït durant el mateix cicle de rellotge

Depuració

Utilitzeu el commutador -d amb qualsevol dels altres interruptors si necessiteu depurar el protocol de comunicació. Aleshores, l'script imprimirà tots els bytes enviats i rebuts i tag si són caràcters de control, com es mostra a continuació.

Ús de la interfície en altres scripts de Python

L'script uart_regs.py conté una classe UartRegs que podeu utilitzar fàcilment com a interfície de comunicació en altres scripts de Python personalitzats. Simplement importeu la classe, creeu-ne un objecte i comenceu a utilitzar els mètodes, tal com es mostra a continuació.

Consulteu les cadenes de documents del codi de Python per obtenir el mètode i les descripcions i els tipus de valors de retorn.

instantiation_template.vho

La plantilla d'instanciació es genera juntament amb el mòdul uart_regs per a la vostra comoditat. Per estalviar temps de codificació, podeu copiar la instanciació del mòdul i les declaracions de senyal al vostre disseny.

RTL estàtic files

Heu d'incloure el següent files al vostre projecte VHDL perquè es compilin a la mateixa biblioteca que el mòdul uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
El mòdul uart_regs_backend implementa les màquines d'estats finits que registren i surt les dades del registre. Utilitza els mòduls uart_rx i uart_tx per gestionar la comunicació UART amb l'amfitrió.

Projectes de demostració

Hi ha tres projectes de demostració inclosos al Zip file. Us permeten controlar els perifèrics de les diferents plaques, així com uns quants registres interns més grans.
Les carpetes de demostració inclouen uart_regs.vhd i uart_regs.py pregenerats fileestà fet específicament per a aquests dissenys.

ICEstick de gelosia

La carpeta demo/icecube2_icestick conté una implementació de demostració d'accés al registre per a la placa FPGA Lattice iCEstick.
Per executar el procés d'implementació, obriu el demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file al programari de disseny Lattice iCEcube2.
Després de carregar el projecte a la GUI d'iCEcube2, feu clic a Eines → Executar tot per generar el mapa de bits de programació file.

Podeu utilitzar l'eina autònoma del programador Lattice Diamond per configurar l'FPGA amb el mapa de bits generat file. Quan s'obre Diamond Programmer, feu clic a Obre un projecte de programador existent al quadre de diàleg de benvinguda.
Seleccioneu el projecte file es troba al Zip: demo/lattice_icestick/diamond_programmer_project.xcf i feu clic a D'acord.
Després de carregar el projecte, feu clic als tres punts del fitxer File Columna de nom, tal com es mostra a dalt. Navega per seleccionar el mapa de bits file que heu generat a iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Finalment, amb la placa iCEstick connectada a un port USB de l'ordinador, seleccioneu Disseny→Programa per programar el flaix SPI i configurar l'FPGA.
Ara podeu procedir a llegir i escriure registres utilitzant l'script demo/lattice_icestick/uart_regs.py tal com es descriu a la secció uart_regs.py.

Xilinx Digilent Arty A7-35T

Podeu trobar la implementació de demostració del kit d'avaluació d'Arty FPGA Artix-7 35T a la carpeta demo/arty_a7_35.
Obriu Vivado i navegueu fins a l'extret files utilitza la consola Tcl que es troba a la part inferior de la interfície GUI. Escriviu aquesta ordre per entrar a la carpeta del projecte de demostració:

cd /demo/arty_a7_35/vivado_proj/
Executeu l'script create_vivado_proj.tcl Tcl per regenerar el projecte Vivado:
font ./create_vivado_proj.tcl

Feu clic a Genera bitstream a la barra lateral per executar tots els passos d'implementació i generar el bitstream de programació file.
Finalment, feu clic a Obre el gestor de maquinari i programeu l'FPGA a través de la GUI.
Ara podeu procedir a llegir i escriure registres utilitzant l'script demo/arty_a7_35/uart_regs.py tal com es descriu a la secció uart_regs.py.

Xilinx Digilent Arty S7-50

Podeu trobar la implementació de demostració per a la placa de desenvolupament Arty S7: Spartan-7 FPGA a la carpeta demo/arty_s7_50.
Obriu Vivado i navegueu fins a l'extret files utilitza la consola Tcl que es troba a la part inferior de la interfície GUI. Escriviu aquesta ordre per entrar a la carpeta del projecte de demostració:

cd /demo/arty_s7_50/vivado_proj/
Executeu l'script create_vivado_proj.tcl Tcl per regenerar el projecte Vivado:
font ./create_vivado_proj.tcl

Feu clic a Genera bitstream a la barra lateral per executar tots els passos d'implementació i generar el bitstream de programació file.
Finalment, feu clic a Obre el gestor de maquinari i programeu l'FPGA a través de la GUI.
Ara podeu procedir a llegir i escriure registres utilitzant l'script demo/arty_s7_50/uart_regs.py tal com es descriu a la secció uart_regs.py.

Implementació

No hi ha requisits específics d'implementació.

Restriccions

No calen limitacions de temps específiques per a aquest disseny perquè la interfície UART és lenta i es tracta com una interfície asíncrona.

L'entrada uart_rx al mòdul uart_regs es sincronitza dins del mòdul uart_rx. Per tant, no cal que estigui sincronitzat al mòdul de nivell superior.

Problemes coneguts

És possible que hàgiu de restablir el mòdul abans de poder-lo utilitzar, depenent de si la vostra arquitectura FPGA admet els valors de registre predeterminats.

Més informació

Preguntes freqüents

P: Quin és l'objectiu del generador d'interfície de prova UART?

R: El generador d'interfícies de prova UART permet la creació d'interfícies personalitzades per interactuar amb els valors del registre FPGA mitjançant la comunicació UART.

P: Com instal·lo el paquet Pyserial?

R: Podeu instal·lar Pyserial mitjançant Pip mitjançant l'ordre: pip install pyserial

Documents/Recursos

Generador d'interfície de prova VHDLwhiz UART [pdfManual d'usuari
Generador d'interfícies de prova UART, generador d'interfícies de prova, generador d'interfícies, generador

Referències

Manual d'usuari

Generador d'interfície de prova VHDLwhiz UART

Informació del producte