VHDLwhiz UART Test Interface Generator Manual de usuario

Este produto permítelle xerar interfaces personalizadas para ler e escribir valores de rexistro FPGA usando UART. O módulo VHDL xerado e o script Python ofrecen a posibilidade de interactuar con varios tipos de rexistros no seu deseño FPGA.

Requisitos

Intérprete de Python 3
paquete pyserial

Protocolo

O produto usa un protocolo de marco de datos con catro caracteres de control:

Nome: READ_REQ, Valor: 0x0A: comando do host ao FPGA para iniciar unha secuencia de escritura para enviar todos os rexistros de volta a través de UART
Nome: START_WRITE, Valor: 0x0B: marca o inicio dunha secuencia de escritura en calquera dirección

Nome: END_WRITE, Valor: 0x0C: marca o final dunha secuencia de escritura en calquera dirección
Nome: ESCAPAR, Valor: 0x0D: carácter de escape usado para escapar de palabras de control

Instrucións de uso do produto

Execución dos scripts

Para usar o produto, asegúrate de ter instalado Python 3 e o paquete Pyserial. Execute os scripts a través dun intérprete de Python 3.

Xeración de interfaces personalizadas

Use o script gen_uart_regs.py para xerar interfaces personalizadas para ler e escribir valores de rexistro FPGA. Pode especificar a composición dos rexistros e tipos de entrada e saída ao xerar a saída files.

Interacción cos rexistros

Podes ler ou escribir en calquera número de rexistros do teu deseño FPGA usando o módulo VHDL xerado e o script Python. Os rexistros accesibles poden ter tipos como std_logic, std_logic_vector, signed ou unsigned.

Licenza

A licenza MIT cobre os requisitos de copyright e as condicións de uso do código fonte. Consulte o LICENSE.txt file no Zip file para os detalles.

Rexistro de cambios

Estes cambios refírense ao proxecto files, e este documento actualízase en consecuencia

Versión	Observacións
1.0.0	Lanzamento inicial
1.0.1	Corrixiuse un erro de referencia «auto» ao importar como uart_regs.py como módulo de Python. Cambiouse a impresión de erros de escritura a excepción a evite imprimir na consola cando se execute como módulo importado.
1.0.2	Corrixiuse o erro de Vivado [Synth 8-248] cando non hai rexistros de modo de saída.
1.0.3	Corrixir o aviso de Vivado Linter: o rexistro ten habilitado dirixido por reinicio sincrónico
1.0.4	Corrixe o caso da esquina ao recibir unha palabra mal formada co carácter de escape como último byte. A seguinte palabra tamén se perdería porque non borramos recv_data_prev_is_escape ao volver a IDLE. O script gen_uart_regs.py agora só permite nomes de rexistro únicos.

Descrición

Este documento describe o seguinte files e cartafoles:
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/
O script gen_uart_regs.py e VHDL compatible files deste proxecto permítenche xerar interfaces personalizadas para ler e escribir valores de rexistro FPGA de varios tipos e anchos usando UART.
Podes usar o módulo VHDL xerado e o script Python para ler ou escribir en calquera número de rexistros do teu deseño. Os rexistros accesibles UART poden ter os tipos std_logic, std_logic_vector, signed ou unsigned.
Pode decidir sobre a composición precisa dos rexistros e tipos de entrada e saída ao xerar a saída files usando o script gen_uart_regs.py.
Os scripts de Python creáronse parcialmente coa axuda da ferramenta de intelixencia artificial ChatGPT, mentres que o código VHDL está feito a man.

Requisitos

Os scripts deste proxecto deben executarse a través dun intérprete Python 3 e debe estar instalado o paquete Pyserial.
Podes instalar pyserial a través de Pip usando este comando: pip install pyserial

Protocolo

O VHDL files e o script Python usan un protocolo de marco de datos con catro controles

Nome	Valor	Comenta
READ_REQ	0x0A	Comando do host ao FPGA para iniciar unha escritura secuencia para enviar todos os rexistros de volta a través de UART
START_ESCRIBIR	0x0B	Marca o inicio dunha secuencia de escritura en calquera dirección
END_WRITE	0x0C	Marca o final dunha secuencia de escritura en calquera dirección
ESCAPAR	0x0D	Carácter de escape usado para escapar de calquera das palabras de control, incluído o propio carácter de escape, cando aparecen como datos entre os marcadores START_WRITE e END_WRITE.

Calquera byte READ_REQ sen escape enviado á FPGA é unha instrución para enviar todos os seus rexistros accesibles por UART (entradas e saídas) de volta ao host a través de UART. Este comando adoita ser emitido só polo script uart_regs.py.
Ao recibir este comando, a FPGA responderá enviando o contido de todos os rexistros de volta ao host. Primeiro, os sinais de entrada, despois os sinais de saída. Se as súas lonxitudes non suman un múltiplo de 8 bits, os bits inferiores do último byte serán ceros acolchados.
Unha secuencia de escritura sempre comeza co START_WRITE byte e remata co END_WRITE byte. Calquera byte entre eles considérase como bytes de datos. Se algún byte de datos ten o mesmo valor que un carácter de control, o byte de datos debe escaparse. Isto significa enviar un carácter ESCAPE extra antes do byte de datos para indicar que en realidade se trata de datos.
Se un START_WRITE sen escape chega a calquera parte do fluxo de bytes, considérase o inicio dunha secuencia de escritura. O módulo uart_regs_backend usa esta información para resincronizarse no caso de que a comunicación non se sincronice.

gen_uart_regs.py

Este é o script co que debes comezar para xerar a interface. A continuación móstrase unha captura de pantalla do menú de axuda que pode obter executando: python gen_uart_regs.py -h
Para xerar unha interface personalizada, debes executar o script con cada un dos rexistros controlables UART que desexes listados como argumentos. Os tipos dispoñibles son std_logic, std_logic_vector, unsigned e signed.
O modo predeterminado (dirección) está en e o tipo predeterminado é std_logic_vector a non ser que o rexistro sexa de lonxitude: 1. Entón, por defecto será std_logic.

Así, se queres crear un sinal de entrada std_logic, podes usar calquera destes argumentos:
meu_sl=1
my_sl=1:in

my_sl=1:in:std_logic
Todas as variantes anteriores farán que o script xere este sinal accesible por UART:
Imos executar o script con argumentos para xerar unha interface con varios rexistros de diferentes direccións, lonxitudes e tipos

Xerado files

Unha execución exitosa do script gen_uart_regs.py producirá un cartafol de saída chamado xerado cos tres files listados a continuación. Se xa existen, sobrescribiranse.
generated/uart_regs.vhd

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

Este é o módulo de interface personalizado xerado polo script. Debes crealo no teu deseño, onde pode acceder aos rexistros que queres controlar mediante UART.
Todo o que está enriba da sección "– Rexistros accesibles UART" será idéntico para todos os módulos uart_regs, mentres que a composición dos sinais de porto debaixo desa liña depende dos argumentos dados ao script xerador.
A lista a continuación mostra a entidade para o módulo uart_regs resultante do comando generar, por exemploample mostrado na sección gen_uart_regs.py

Non precisa sincronizar o sinal uart_rx, xa que se xestiona no uart_rx. módulo.
Cando o módulo recibe unha solicitude de lectura, capturará os valores de todos os sinais de entrada e saída dentro do ciclo de reloxo actual. A instantánea envíase entón ao host a través de UART.
Cando se produce unha escritura, todos os rexistros de saída actualízanse cos novos valores dentro do mesmo ciclo de reloxo. Non é posible cambiar individualmente os valores do sinal de saída.

Non obstante, o script uart_regs.py permite ao usuario actualizar só as saídas seleccionadas lendo primeiro os valores actuais de todos os rexistros. Despois escribe de novo todos os valores, incluídos os actualizados.
uart_regs.py
O ficheiro generated/uart_regs.py file xérase xunto co módulo VHDL uart_regs e contén a información do rexistro personalizado na cabeceira do file. Con este script, podes ler ou escribir nos teus rexistros personalizados con facilidade.

Menú de axuda

Escriba python uart_regs.py -h para imprimir o menú de axuda:

Configurando o porto UART

O script ten opcións para configurar o porto UART usando o interruptor -c. Isto funciona en Windows e Linux. Estableceo nun dos portos dispoñibles que aparecen no menú de axuda. Para establecer un porto predeterminado, tamén pode editar a variable UART_PORT no script uart_regs.py.

Listaxe de rexistros

A información sobre a asignación do rexistro colócase na cabeceira do script uart_regs.py mediante o script gen_uart_regs.py. Podes listar os rexistros dispoñibles co interruptor -l, como se ve a continuación. Este é un comando local e non interactuará co FPGA de destino

Escritura aos rexistros

Podes escribir en calquera dos rexistros do modo de saída usando o interruptor -w. Introduza o nome do rexistro seguido de "=" e o valor indicado como un valor binario, hexadecimal ou decimal, como se mostra a continuación.
Teña en conta que a implementación de VHDL require que o script escriba todos os rexistros de saída simultaneamente. Polo tanto, se non especifica un conxunto completo de rexistros de saída, o script realizará primeiro unha lectura desde o FPGA de destino e despois utilizará eses valores para os que faltan. O resultado será que só cambien os rexistros especificados
Cando realizas unha escritura, todos os rexistros especificados cambiarán durante o mesmo ciclo de reloxo, non tan pronto como se reciban a través de UART.

Lectura de rexistros

Use o interruptor -r para ler todos os valores do rexistro, como se mostra a continuación. Os valores marcados en amarelo son os que cambiamos na escritura anterior example
Cada lectura mostra unha instantánea instantánea de todos os rexistros de entrada e saída. Todos son sampconducido durante o mesmo ciclo de reloxo

Depuración

Use o interruptor -d con calquera dos outros interruptores se precisa depurar o protocolo de comunicación. A continuación, o script imprimirá todos os bytes enviados e recibidos e tag se son personaxes de control, como se mostra a continuación.

Usando a interface noutros scripts de Python

O script uart_regs.py contén unha clase UartRegs que pode usar facilmente como interface de comunicación noutros scripts de Python personalizados. Simplemente importe a clase, cree un obxecto dela e comece a usar os métodos, como se mostra a continuación.

Consulte as docstrings do código de Python para ver métodos e descricións e tipos de valores de retorno.

instanciación_template.vho

O modelo de instanciación xérase xunto co módulo uart_regs para a súa comodidade. Para aforrar tempo de codificación, pode copiar a instanciación do módulo e as declaracións de sinal no seu deseño.

RTL estático files

Debe incluír o seguinte files no seu proxecto VHDL para que se compilen na mesma biblioteca que o módulo uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
O módulo uart_regs_backend implementa as máquinas de estado finito que rexistran e saen os datos do rexistro. Usa os módulos uart_rx e uart_tx para xestionar a comunicación UART co host.

Proxectos de demostración

Hai tres proxectos de demostración incluídos no Zip file. Permítenche controlar os periféricos das diferentes placas, así como algúns rexistros internos máis grandes.
Os cartafoles de demostración inclúen uart_regs.vhd e uart_regs.py xerados previamente fileestá feito específicamente para eses deseños.

Lattice ICEstick

O cartafol demo/icecube2_icestick contén unha implementación de demostración de acceso ao rexistro para a placa FPGA Lattice iCEstick.
Para executar o proceso de implementación, abra o demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file no software de deseño Lattice iCEcube2.
Despois de cargar o proxecto na GUI de iCEcube2, prema en Ferramentas → Executar todo para xerar o mapa de bits de programación. file.

Podes usar a ferramenta Lattice Diamond Programmer Standalone para configurar o FPGA co mapa de bits xerado file. Cando se abra Diamond Programmer, faga clic en Abrir un proxecto de programador existente na caixa de diálogo de benvida.
Seleccione proxecto file atopado no Zip: demo/lattice_icestick/diamond_programmer_project.xcf e fai clic en Aceptar.
Despois de que se cargue o proxecto, fai clic nos tres puntos File Columna de nome, como se mostra arriba. Navega para seleccionar o mapa de bits file que xeraches en iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Finalmente, coa placa iCEstick conectada a un porto USB do teu ordenador, selecciona Deseño→Programa para programar o flash SPI e configurar a FPGA.
Agora podes proceder a ler e escribir rexistros utilizando o script demo/lattice_icestick/uart_regs.py tal e como se describe na sección uart_regs.py.

Xilinx Digilent Arty A7-35T

Podes atopar a implementación de demostración para o kit de avaliación Artix-7 35T Arty FPGA no cartafol demo/arty_a7_35.
Abra Vivado e navegue ata o extraído files usando a consola Tcl que se atopa na parte inferior da interface GUI. Escriba este comando para entrar no cartafol do proxecto de demostración:

cd /demo/arty_a7_35/vivado_proj/
Execute o script create_vivado_proj.tcl Tcl para rexenerar o proxecto Vivado:
fonte ./create_vivado_proj.tcl

Fai clic en Xerar bitstream na barra lateral para realizar todos os pasos de implementación e xerar o bitstream de programación file.
Finalmente, fai clic en Abrir Xestor de hardware e programa o FPGA a través da GUI.
Agora podes proceder a ler e escribir rexistros usando o script demo/arty_a7_35/uart_regs.py tal e como se describe na sección uart_regs.py.

Xilinx Digilent Arty S7-50

Podes atopar a implementación de demostración para a tarxeta de desenvolvemento Arty S7: Spartan-7 FPGA no cartafol demo/arty_s7_50.
Abra Vivado e navegue ata o extraído files usando a consola Tcl que se atopa na parte inferior da interface GUI. Escriba este comando para entrar no cartafol do proxecto de demostración:

cd /demo/arty_s7_50/vivado_proj/
Execute o script create_vivado_proj.tcl Tcl para rexenerar o proxecto Vivado:
fonte ./create_vivado_proj.tcl

Fai clic en Xerar bitstream na barra lateral para realizar todos os pasos de implementación e xerar o bitstream de programación file.
Finalmente, fai clic en Abrir Xestor de hardware e programa o FPGA a través da GUI.
Agora podes proceder a ler e escribir rexistros usando o script demo/arty_s7_50/uart_regs.py tal e como se describe na sección uart_regs.py.

Implementación

Non hai requisitos específicos de implementación.

Restricións

Non se necesitan restricións de tempo específicas para este deseño porque a interface UART é lenta e trátase como unha interface asíncrona.

A entrada uart_rx para o módulo uart_regs está sincronizada dentro do módulo uart_rx. Polo tanto, non é necesario sincronizalo no módulo de nivel superior.

Problemas coñecidos

É posible que necesites restablecer o módulo antes de poder utilizalo, dependendo de se a túa arquitectura FPGA admite valores de rexistro predeterminados.

Máis información

Dereitos de autor VHDLwhiz.com

Preguntas frecuentes

P: Cal é o propósito do xerador de interfaces de proba UART?

R: O xerador de interfaces de proba UART permite a creación de interfaces personalizadas para interactuar cos valores de rexistro FPGA mediante a comunicación UART.

P: Como instalo o paquete Pyserial?

R: Podes instalar Pyserial a través de Pip usando o comando: pip install pyserial

Documentos/Recursos

Xerador de interfaces de proba VHDLwhiz UART [pdfManual do usuario
Xerador de interfaces de proba UART, xerador de interfaces de proba, xerador de interfaces, xerador

Referencias

Manual de usuario

Xerador de interfaces de proba VHDLwhiz UART

Información do produto