Manuale utente del generatore di interfaccia di test UART VHDLwhiz

Questo prodotto consente di generare interfacce personalizzate per la lettura e la scrittura di valori di registro FPGA tramite UART. Il modulo VHDL generato e lo script Python forniscono la possibilità di interagire con vari tipi di registri nel tuo progetto FPGA.

Requisiti

Interprete Python 3
pacchetto pyserial

Protocollo

Il prodotto utilizza un protocollo di framing dei dati con quattro caratteri di controllo:

Nome: LEGGI_REQ, Valore: 0x0A – Comando dall’host all’FPGA per avviare una sequenza di scrittura per inviare tutti i registri tramite UART
Nome: INIZIA_SCRIVI, Valore: 0x0B – Contrassegna l'inizio di una sequenza di scrittura in entrambe le direzioni

Nome: FINE_SCRITTURA, Valore: 0x0C – Segna la fine di una sequenza di scrittura in entrambe le direzioni
Nome: FUGA, Valore: 0x0D – Carattere di escape utilizzato per l'escape delle parole di controllo

Istruzioni per l'uso del prodotto

Esecuzione degli script

Per utilizzare il prodotto, assicurati di avere installato Python 3 e il pacchetto Pyserial. Esegui gli script tramite un interprete Python 3.

Generazione di interfacce personalizzate

Utilizzare lo script gen_uart_regs.py per generare interfacce personalizzate per la lettura e la scrittura di valori di registro FPGA. È possibile specificare la composizione dei registri di input e output e i tipi quando si genera l'output files.

Interazione con i registri

Puoi leggere o scrivere su qualsiasi numero di registri nel tuo progetto FPGA usando il modulo VHDL generato e lo script Python. I registri accessibili possono avere tipi come std_logic, std_logic_vector, signed o unsigned.

Licenza

La licenza MIT copre i requisiti di copyright e i termini di utilizzo del codice sorgente. Fare riferimento al file LICENSE.txt file nella Zip file per maggiori dettagli.

Registro delle modifiche

Queste modifiche si riferiscono al progetto files, e il presente documento viene aggiornato di conseguenza

Versione	Osservazioni
1.0.0	Versione iniziale
1.0.1	Corretto bug di riferimento «self» mancante durante l'importazione come uart_regs.py come modulo Python. Modificato printout di scrittura non riuscita in eccezione a evitare di stampare sulla console quando si esegue come modulo importato.
1.0.2	Correzione dell'errore Vivado [Synth 8-248] quando non sono presenti registri in modalità out.
1.0.3	Correggi l'avviso Vivado Linter: il registro è abilitato da reset sincrono
1.0.4	Corregge il caso limite quando si riceve una parola malformata con il carattere di escape come ultimo byte. Anche la parola successiva andrebbe persa perché non abbiamo cancellato recv_data_prev_is_escape quando torniamo a IDLE. Lo script gen_uart_regs.py ora consente solo nomi di registro univoci.

Descrizione

Questo documento descrive quanto segue filese cartelle:
gen_uart_regs.py

generato/uart_regs.vhd
generato/uart_regs.py
generato/istanziazione_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/
Lo script gen_uart_regs.py e il supporto VHDL fileI moduli in questo progetto consentono di generare interfacce personalizzate per la lettura e la scrittura di valori di registro FPGA di vari tipi e larghezze utilizzando UART.
Puoi utilizzare il modulo VHDL generato e lo script Python per leggere o scrivere su un numero qualsiasi di registri nel tuo progetto. I registri accessibili UART possono avere i tipi std_logic, std_logic_vettoriale, con segno o senza segno.
Puoi decidere la composizione precisa dei registri e dei tipi di input e output durante la generazione dell'output files utilizzando lo script gen_uart_regs.py.
Gli script Python sono stati creati in parte con l'aiuto dello strumento di intelligenza artificiale ChatGPT, mentre il codice VHDL è realizzato artigianalmente.

Requisiti

Gli script di questo progetto devono essere eseguiti tramite un interprete Python 3 e il pacchetto Pyserial deve essere installato.
Puoi installare pyserial tramite Pip usando questo comando: pip install pyserial

Protocollo

Il VHDL fileGli script Python e s utilizzano un protocollo di data-framing con quattro controlli

Nome	Valore	Commento
LEGGI_REQ	0x0Un	Comando dall'host all'FPGA per avviare una scrittura sequenza per inviare tutti i registri tramite UART
START_SCRIVI	0x0B	Segna l'inizio di una sequenza di scrittura in entrambi direzione
FINE_SCRIVI	0x0C	Contrassegna la fine di una sequenza di scrittura in entrambe le direzioni
FUGA	0x0D	Carattere di escape utilizzato per eseguire l'escape di qualsiasi parola di controllo, incluso il carattere ESCAPE stesso, quando appaiono come dati tra i marcatori START_WRITE e END_WRITE.

Qualsiasi byte READ_REQ senza escape inviato all'FPGA è un'istruzione per inviare tutti i suoi registri accessibili da UART (ingressi e uscite) all'host tramite UART. Questo comando viene solitamente emesso solo dallo script uart_regs.py.
Dopo aver ricevuto questo comando, l'FPGA risponderà inviando il contenuto di tutti i registri all'host. Prima i segnali di ingresso, poi i segnali di uscita. Se la loro lunghezza non ammonta a un multiplo di 8 bit, i bit inferiori dell'ultimo byte verranno riempiti con zeri.
Una sequenza di scrittura inizia sempre con il byte START_WRITE e termina con il byte END_WRITE. Tutti i byte compresi tra questi sono considerati byte di dati. Se alcuni byte di dati hanno lo stesso valore di un carattere di controllo, il byte di dati deve essere sottoposto a escape. Ciò significa inviare un carattere ESCAPE extra prima del byte di dati per indicare che si tratta effettivamente di dati.
Se un START_WRITE senza caratteri di escape arriva in un punto qualsiasi del flusso di byte, viene considerato l'inizio di una sequenza di scrittura. Il modulo uart_regs_backend utilizza queste informazioni per risincronizzarsi nel caso in cui la comunicazione non sia sincronizzata.

gen_uart_regs.py

Questo è lo script con cui devi iniziare per generare l'interfaccia. Di seguito è riportato uno screenshot del menu di aiuto che puoi ottenere eseguendo: python gen_uart_regs.py -h
Per generare un'interfaccia personalizzata, è necessario eseguire lo script con ciascuno dei registri controllabili UART desiderati elencati come argomenti. I tipi disponibili sono std_logic, std_logic_vettoriale, senza segno e con segno.
La modalità (direzione) predefinita è in e il tipo predefinito è std_logic_vector a meno che il registro non abbia lunghezza: 1. Quindi, verrà impostato automaticamente su std_logic.

Pertanto, se desideri creare un segnale di ingresso std_logic, puoi utilizzare uno qualsiasi di questi argomenti:
mio_sl=1
mio_sl=1:in

my_sl=1:in:std_logic
Tutte le varianti di cui sopra comporteranno che lo script generi questo segnale accessibile da UART:
Eseguiamo lo script con argomenti per generare un'interfaccia con diversi registri di direzioni, lunghezze e tipi diversi

Generato files

Un'esecuzione riuscita dello script gen_uart_regs.py produrrà una cartella di output denominata generate con i tre fileè elencato di seguito. Se esistono già, verranno sovrascritti.
generato/uart_regs.vhd

generato/uart_regs.py
generato/istanziazione_template.vho
uart_regs.vhd

Questo è il modulo di interfaccia personalizzato generato dallo script. Devi crearne un'istanza nel tuo progetto, dove può accedere ai registri che desideri controllare utilizzando UART.
Tutto al di sopra della sezione “- Registri accessibili UART” sarà identico per ogni modulo uart_regs, mentre la composizione dei segnali di porta al di sotto di quella riga dipende dagli argomenti forniti allo script del generatore.
L'elenco seguente mostra l'entità per il modulo uart_regs risultante dal comando generate example mostrato nella sezione gen_uart_regs.py

Non è necessario sincronizzare il segnale uart_rx, poiché viene gestito nel file uart_rx. modulo.
Quando il modulo riceve una richiesta di lettura, acquisirà i valori di tutti i segnali di ingresso e uscita all'interno del ciclo di clock corrente. Lo snapshot istantaneo viene quindi inviato all'host tramite UART.
Quando avviene una scrittura, tutti i registri di uscita vengono aggiornati con i nuovi valori all'interno dello stesso ciclo di clock. Non è possibile modificare individualmente i valori del segnale di uscita.

Tuttavia, lo script uart_regs.py consente all'utente di aggiornare solo gli output selezionati rileggendo prima i valori correnti di tutti i registri. Quindi riscrive tutti i valori, compresi quelli aggiornati.
uart_regs.py
Il file generato/uart_regs.py file viene generato insieme al modulo VHDL uart_regs e contiene le informazioni sul registro personalizzato nell'intestazione del file file. Con questo script puoi leggere o scrivere facilmente nei tuoi registri personalizzati.

Menu di aiuto

Digita python uart_regs.py -h per stampare il menu di aiuto:

Impostazione della porta UART

Lo script ha opzioni per impostare la porta UART usando l'opzione -c. Funziona su Windows e Linux. Impostalo su una delle porte disponibili elencate nel menu di aiuto. Per impostare una porta predefinita, puoi anche modificare la variabile UART_PORT nello script uart_regs.py.

Registri di elencazione

Le informazioni sulla mappatura dei registri vengono inserite nell'intestazione dello script uart_regs.py dallo script gen_uart_regs.py. È possibile elencare i registri disponibili con l'opzione -l, come mostrato di seguito. Questo è un comando locale e non interagirà con l'FPGA di destinazione

Scrivere ai registri

È possibile scrivere in qualsiasi registro della modalità out utilizzando l'opzione -w. Fornire il nome del registro seguito da "=" e il valore fornito come valore binario, esadecimale o decimale, come mostrato di seguito.
Si noti che l'implementazione VHDL richiede che lo script scriva tutti i registri di output simultaneamente. Pertanto, se non si specifica un set completo di registri di output, lo script eseguirà prima una lettura dall'FPGA di destinazione e poi utilizzerà quei valori per quelli mancanti. Il risultato sarà che solo i registri specificati cambieranno
Quando si esegue una scrittura, tutti i registri specificati cambieranno durante lo stesso ciclo di clock, non appena vengono ricevuti tramite UART.

Lettura dei registri

Utilizzare l'opzione -r per leggere tutti i valori del registro, come mostrato di seguito. I valori contrassegnati in giallo sono quelli che abbiamo modificato nella scrittura precedente example
Ogni lettura mostra un'istantanea istantanea di tutti i registri di input e output. Sono tutti sampled durante lo stesso ciclo di clock

Debug

Utilizzare l'opzione -d con una qualsiasi delle altre opzioni se è necessario eseguire il debug del protocollo di comunicazione. Quindi, lo script stamperà tutti i byte inviati e ricevuti e tag se sono personaggi di controllo, come mostrato di seguito.

Utilizzo dell'interfaccia in altri script Python

Lo script uart_regs.py contiene una classe UartRegs che puoi facilmente utilizzare come interfaccia di comunicazione in altri script Python personalizzati. Importa semplicemente la classe, creane un oggetto e inizia a utilizzare i metodi, come mostrato di seguito.

Fare riferimento alle docstring nel codice Python per metodo, descrizioni e tipi di valore restituito.

istanziazione_template.vho

Il modello di istanziazione viene generato insieme al modulo uart_regs per tua comodità. Per risparmiare tempo nella codifica, puoi copiare la creazione di istanze del modulo e le dichiarazioni di segnale nel tuo progetto.

RTL statico files

È necessario includere quanto segue files nel tuo progetto VHDL in modo che siano compilati nella stessa libreria del modulo uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Il modulo uart_regs_backend implementa le macchine a stati finiti che registrano l'entrata e l'uscita dei dati del registro. Utilizza i moduli uart_rx e uart_tx per gestire la comunicazione UART con l'host.

Progetti dimostrativi

Ci sono tre progetti demo inclusi nello Zip file. Ti consentono di controllare le periferiche sulle diverse schede nonché alcuni registri interni più grandi.
Le cartelle demo includono uart_regs.vhd e uart_regs.py pregenerati fileÈ realizzato appositamente per quei modelli.

Reticolo iCEstick

La cartella demo/icecube2_icestick contiene un'implementazione demo di accesso al registro per la scheda FPGA Lattice iCEstick.
Per eseguire il processo di implementazione, aprire demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file nel software di progettazione Lattice iCEcube2.
Dopo aver caricato il progetto nella GUI di iCEcube2, fare clic su Strumenti→Esegui tutto per generare la bitmap di programmazione file.

È possibile utilizzare lo strumento Lattice Diamond Programmer Standalone per configurare l'FPGA con la bitmap generata file. Quando si apre Diamond Programmer, fare clic su Apri un progetto programmatore esistente nella finestra di dialogo di benvenuto.
Seleziona il progetto file trovato nello Zip: demo/lattice_icestick/diamond_programmer_project.xcf e fare clic su OK.
Una volta caricato il progetto, fai clic sui tre punti nel file File Colonna del nome, come mostrato sopra. Sfoglia per selezionare la bitmap file che hai generato in iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Infine, con la scheda iCEstick collegata a una porta USB del computer, seleziona Design→Programma per programmare il flash SPI e configurare l'FPGA.
Ora puoi procedere alla lettura e alla scrittura dei registri utilizzando lo script demo/lattice_icestick/uart_regs.py come descritto nella sezione uart_regs.py.

Xilinx Digilent Arty A7-35T

È possibile trovare l'implementazione demo per il kit di valutazione FPGA Artix-7 35T Arty nella cartella demo/arty_a7_35.
Apri Vivado e vai all'estratto files utilizzando la console Tcl che si trova nella parte inferiore dell'interfaccia GUI. Digita questo comando per accedere alla cartella del progetto demo:

CD /demo/arty_a7_35/vivado_proj/
Esegui lo script Tcl create_vivado_proj.tcl per rigenerare il progetto Vivado:
fonte ./create_vivado_proj.tcl

Fai clic su Genera bitstream nella barra laterale per eseguire tutti i passaggi di implementazione e generare il bitstream di programmazione file.
Infine, fai clic su Apri Gestione hardware e programma l'FPGA tramite la GUI.
Ora puoi procedere alla lettura e scrittura dei registri utilizzando lo script demo/arty_a7_35/uart_regs.py come descritto nella sezione uart_regs.py.

Xilinx Digilent Arty S7-50

È possibile trovare l'implementazione demo per la scheda di sviluppo FPGA Arty S7: Spartan-7 nella cartella demo/arty_s7_50.
Apri Vivado e vai all'estratto files utilizzando la console Tcl che si trova nella parte inferiore dell'interfaccia GUI. Digita questo comando per accedere alla cartella del progetto demo:

CD /demo/arty_s7_50/vivado_proj/
Esegui lo script Tcl create_vivado_proj.tcl per rigenerare il progetto Vivado:
fonte ./create_vivado_proj.tcl

Fai clic su Genera bitstream nella barra laterale per eseguire tutti i passaggi di implementazione e generare il bitstream di programmazione file.
Infine, fai clic su Apri Gestione hardware e programma l'FPGA tramite la GUI.
Ora puoi procedere alla lettura e scrittura dei registri utilizzando lo script demo/arty_s7_50/uart_regs.py come descritto nella sezione uart_regs.py.

Implementazione

Non sono previsti requisiti di implementazione specifici.

Vincoli

Per questo progetto non sono necessari vincoli temporali specifici perché l'interfaccia UART è lenta e trattata come un'interfaccia asincrona.

L'input uart_rx al modulo uart_regs è sincronizzato all'interno del modulo uart_rx. Pertanto, non è necessario sincronizzarlo nel modulo di livello superiore.

Problemi noti

Potrebbe essere necessario reimpostare il modulo prima di poterlo utilizzare, a seconda che l'architettura FPGA supporti i valori di registro predefiniti.

Maggiori informazioni

Domande frequenti

D: Qual è lo scopo del generatore di interfaccia di test UART?

A: Il generatore di interfacce di test UART consente la creazione di interfacce personalizzate per interagire con i valori del registro FPGA utilizzando la comunicazione UART.

D: Come faccio a installare il pacchetto Pyserial?

A: Puoi installare Pyserial tramite Pip usando il comando: pip install pyserial

Documenti / Risorse

Generatore di interfaccia di test UART VHDLwhiz [pdf] Manuale d'uso
Generatore di interfaccia di test UART, generatore di interfaccia di test, generatore di interfaccia, generatore

Riferimenti

Manuale d'uso

Generatore di interfaccia di test UART VHDLwhiz

Informazioni sul prodotto