VHDLwhiz.com
Registri VHDL Generatore di interfaccia di test UART – Manuale utente
Versione: 1.0.0
Data: 1 settembre 2023
Autore: Jonas Julian Jensen
Prodotto URL: https://vhdlwhiz.com/product/vhdl-registers-uart-test-interfacegenerator
E-mail di contatto: jonas@vhdlwhiz.com
Questo documento descrive l'utilizzo del generatore di interfaccia di test UART di VHDLwhiz per produrre un modulo VHDL personalizzato e uno script Python per leggere e scrivere valori di registro FPGA.
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 questo documento viene aggiornato di conseguenza.
| Versione | Osservazioni |
| 1.0.0 | Versione iniziale |
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/
IL gen_uart_regs.py script e 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 files e lo script Python utilizzano un protocollo di framing dei dati con quattro caratteri di controllo:
| Nome | Valore | Commento |
| LEGGI RICHIESTA | bueOA | Comando dall'host all'FPGA per avviare una sequenza di scrittura per rinviare tutti i registri su UART |
| START_SCRIVI | Bue0B | Contrassegna l'inizio di una sequenza di scrittura in entrambe le direzioni |
| FINE_SCRIVI | OxOC | Contrassegna la fine di una sequenza di scrittura in entrambe le direzioni |
| FUGA | OxOD | 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 qualche byte di dati ha lo stesso valore di un carattere di controllo, è necessario eseguire l'escape del byte di dati. Ciò significa inviare un carattere ESCAPE aggiuntivo 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.
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 diverse direzioni, lunghezze e tipi:
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 nel gen_uart_regs.py sezione.
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 dispone di opzioni per impostare la porta UART utilizzando l'opzione -c. Funziona su Windows e Linux. Impostalo su una delle porte disponibili elencate nel menu 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. Puoi 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.
Nota 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 quindi utilizzerà tali valori per quelli mancanti. Il risultato sarà che cambieranno solo i registri specificati.
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 examplui.
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_ice stick_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 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: source ./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: source ./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.
Copyright VHDLwhiz.com
Documenti / Risorse
 |
VHDLwhiz VHDL registra il generatore dell'interfaccia di test UART [pdf] Manuale d'uso VHDL, Generatore di interfaccia di test UART dei registri VHDL, Generatore di interfaccia di test UART dei registri, Generatore di interfaccia di test UART, Generatore di interfaccia di test, Generatore di interfaccia, Generatore |