Instrukcja obsługi generatora interfejsu testowego UART VHDLwhiz

Ten produkt umożliwia generowanie niestandardowych interfejsów do odczytu i zapisu wartości rejestrów FPGA przy użyciu UART. Wygenerowany moduł VHDL i skrypt Pythona zapewniają możliwość interakcji z różnymi typami rejestrów w projekcie FPGA.

Wymagania

Interpreter Pythona 3
pakiet pyserial

Protokół

Produkt wykorzystuje protokół ramkowania danych z czterema znakami kontrolnymi:

Nazwa: ODCZYT_REQ, Wartość: 0x0A – Polecenie od hosta do układu FPGA inicjujące sekwencję zapisu w celu wysłania wszystkich rejestrów z powrotem przez UART
Nazwa: START_PISZ, Wartość: 0x0B – Oznacza początek sekwencji zapisu w dowolnym kierunku

Nazwa: ZAKOŃCZ_PISAĆ, Wartość: 0x0C – Oznacza koniec sekwencji zapisu w dowolnym kierunku
Nazwa: UCIECZKA, Wartość: 0x0D – Znak ucieczki używany do ucieczki słów kontrolnych

Instrukcje użytkowania produktu

Uruchamianie skryptów

Aby użyć produktu, upewnij się, że masz zainstalowany Python 3 i pakiet Pyserial. Uruchom skrypty za pomocą interpretera Python 3.

Generowanie niestandardowych interfejsów

Użyj skryptu gen_uart_regs.py, aby wygenerować niestandardowe interfejsy do odczytu i zapisu wartości rejestrów FPGA. Możesz określić skład rejestrów wejściowych i wyjściowych oraz typy podczas generowania danych wyjściowych. files.

Interakcja z rejestrami

Możesz odczytywać lub zapisywać do dowolnej liczby rejestrów w projekcie FPGA, używając wygenerowanego modułu VHDL i skryptu Python. Dostępne rejestry mogą mieć typy takie jak std_logic, std_logic_vector, signed lub unsigned.

Licencja

Licencja MIT obejmuje wymagania dotyczące praw autorskich i warunki użytkowania kodu źródłowego. Zobacz plik LICENCJA.txt file w Zipie file Więcej szczegółów.

Dziennik zmian

Zmiany te dotyczą projektu files, a niniejszy dokument jest odpowiednio aktualizowany

Wersja	Uwagi
1.0.0	Pierwsze wydanie
1.0.1	Naprawiono błąd brakującego odniesienia «self» podczas importowania jako uart_regs.py jako modułu Pythona. Zmieniono wydruk nieudanego zapisu na wyjątek unikaj drukowania na konsoli podczas działania jako zaimportowany moduł.
1.0.2	Naprawiono błąd Vivado [Synth 8-248] występujący w przypadku braku regulacji trybu wyjściowego.
1.0.3	Napraw ostrzeżenie Vivado Linter: Rejestr został włączony przez synchroniczne resetowanie
1.0.4	Napraw przypadek skrajny podczas otrzymywania niepoprawnie sformatowanego słowa ze znakiem ucieczki jako ostatnim bajtem. Następne słowo również zostałoby utracone, ponieważ nie wyczyściliśmy recv_data_prev_is_escape podczas powrotu do IDLE. Skrypt gen_uart_regs.py teraz pozwala tylko na unikatowe nazwy rejestrów.

Opis

W tym dokumencie opisano następujące kwestie files i foldery:
gen_uart_regs.py

wygenerowany/uart_regs.vhd
wygenerowano/uart_regs.py
wygenerowany/instancja_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/
Skrypt gen_uart_regs.py i obsługujący go język VHDL files w tym projekcie umożliwiają generowanie niestandardowych interfejsów do odczytu i zapisu wartości rejestrów FPGA różnych typów i szerokości za pomocą UART.
Możesz użyć wygenerowanego modułu VHDL i skryptu Pythona do odczytu lub zapisu do dowolnej liczby rejestrów w swoim projekcie. Rejestry dostępne w UART mogą mieć typy std_logic, std_logic_vector, ze znakiem lub bez znaku.
Podczas generowania wyjścia możesz zdecydować o dokładnym składzie rejestrów wejściowych i wyjściowych oraz ich typach filekorzysta ze skryptu gen_uart_regs.py.
Skrypty w Pythonie zostały stworzone częściowo przy pomocy narzędzia sztucznej inteligencji ChatGPT, natomiast kod VHDL został wykonany ręcznie.

Wymagania

Skrypty w tym projekcie należy uruchomić za pomocą interpretera Pythona 3 i zainstalować pakiet Pyserial.
Możesz zainstalować pyserial przez Pip używając tego polecenia: pip install pyserial

Protokół

VHDL fileSkrypty s i Python wykorzystują protokół ramkowania danych z czterema elementami sterującymi

Nazwa	Wartość	Komentarz
CZYTAJ_REQ	0x0A	Polecenie z hosta do FPGA w celu zainicjowania zapisu sekwencja wysyłania wszystkich rejestrów z powrotem przez UART
START_NAPISZ	0x0B	Oznacza początek sekwencji zapisu w dowolnym z następujących języków: kierunek
END_WRITE	0x0C	Oznacza koniec sekwencji zapisu w dowolnym kierunku
UCIECZKA	0x0D	Znak ucieczki używany do ucieczki od dowolnych słów kontrolnych, w tym samego znaku ESCAPE, gdy pojawiają się one jako dane między znacznikami START_WRITE i END_WRITE.

Każdy niezmieniony bajt READ_REQ wysłany do FPGA jest instrukcją wysłania wszystkich rejestrów dostępnych dla UART (wejścia i wyjścia) z powrotem do hosta przez UART. To polecenie jest zwykle wydawane tylko przez skrypt uart_regs.py.
Po otrzymaniu tego polecenia układ FPGA odpowie, wysyłając zawartość wszystkich rejestrów z powrotem do hosta. Najpierw sygnały wejściowe, potem sygnały wyjściowe. Jeśli ich długości nie sumują się do wielokrotności 8 bitów, dolne bity ostatniego bajtu zostaną uzupełnione zerami.
Sekwencja zapisu zawsze zaczyna się bajtem START_WRITE i kończy bajtem END_WRITE. Wszystkie bajty pomiędzy nimi są uważane za bajty danych. Jeśli jakikolwiek bajt danych ma taką samą wartość jak znak sterujący, bajt danych musi zostać escapowany. Oznacza to wysłanie dodatkowego znaku ESCAPE przed bajtem danych, aby wskazać, że są to faktycznie dane.
Jeśli bez zmiany znaczenia START_WRITE dotrze gdziekolwiek w strumieniu bajtów, uważa się to za początek sekwencji zapisu. Moduł uart_regs_backend wykorzystuje te informacje do ponownej synchronizacji w przypadku braku synchronizacji komunikacji.

gen_uart_regs.py

To jest skrypt, od którego musisz zacząć, aby wygenerować interfejs. Poniżej znajduje się zrzut ekranu menu pomocy, które można uzyskać, uruchamiając: python gen_uart_regs.py -h
Aby wygenerować niestandardowy interfejs, należy uruchomić skrypt z każdym żądanym rejestrem sterowanym przez UART wymienionym jako argumenty. Dostępne typy to std_logic, std_logic_vector, unsigned i ze znakiem.
Domyślny tryb (kierunek) jest włączony, a domyślnym typem jest std_logic_vector, chyba że rejestr ma długość: 1. Wtedy domyślnym ustawieniem będzie std_logic.

Zatem jeśli chcesz utworzyć sygnał wejściowy std_logic, możesz użyć dowolnego z poniższych argumentów:
mój_sl=1
mój_sl=1:w

my_sl=1:in:std_logic
Wszystkie powyższe warianty spowodują, że skrypt wygeneruje ten sygnał dostępny dla UART:
Uruchommy skrypt z argumentami, aby wygenerować interfejs z kilkoma rejestrami o różnych kierunkach, długościach i typach

Wygenerowano files

Pomyślne uruchomienie skryptu gen_uart_regs.py spowoduje utworzenie folderu wyjściowego o nazwie wygenerowany z trzema filesą wymienione poniżej. Jeśli już istnieją, zostaną nadpisane.
wygenerowany/uart_regs.vhd

wygenerowano/uart_regs.py
wygenerowany/instancja_template.vho
uart_regs.vhd

Jest to niestandardowy moduł interfejsu wygenerowany przez skrypt. Musisz utworzyć instancję w swoim projekcie, gdzie będzie mógł uzyskać dostęp do rejestrów, którymi chcesz sterować za pomocą UART.
Wszystko powyżej sekcji „– Rejestry dostępne UART” będzie identyczne dla każdego modułu uart_regs, natomiast skład sygnałów portów poniżej tej linii zależy od argumentów podanych skryptowi generatora.
Poniższa lista przedstawia encję dla modułu uart_regs wynikającą z polecenia generate, npampplik pokazany w sekcji gen_uart_regs.py

Nie musisz synchronizować sygnału uart_rx, ponieważ jest to obsługiwane w uart_rx. moduł.
Kiedy moduł otrzyma żądanie odczytu, przechwyci wartości wszystkich sygnałów wejściowych i wyjściowych w bieżącym cyklu zegara. Natychmiastowa migawka jest następnie wysyłana do hosta przez UART.
Kiedy nastąpi zapis, wszystkie rejestry wyjściowe są aktualizowane o nowe wartości w tym samym cyklu zegara. Nie ma możliwości indywidualnej zmiany wartości sygnałów wyjściowych.

Jednakże skrypt uart_regs.py umożliwia użytkownikowi aktualizację tylko wybranych wyjść poprzez najpierw odczytanie bieżących wartości wszystkich rejestrów. Następnie zapisuje wszystkie wartości, łącznie z tymi zaktualizowanymi.
uart_regs.py
Wygenerowany plik/uart_regs.py file jest generowany razem z modułem uart_regs VHDL i zawiera niestandardowe informacje o rejestrze w nagłówku pliku file. Dzięki temu skryptowi możesz z łatwością czytać i zapisywać w swoich niestandardowych rejestrach.

Menu pomocy

Wpisz python uart_regs.py -h, aby wydrukować menu pomocy:

Ustawianie portu UART

Skrypt ma opcje ustawiania portu UART za pomocą przełącznika -c. Działa to w systemach Windows i Linux. Ustaw go na jeden z dostępnych portów wymienionych w menu pomocy. Aby ustawić domyślny port, możesz również edytować zmienną UART_PORT w skrypcie uart_regs.py.

Rejestry notowań

Informacje o mapowaniu rejestrów są umieszczane w nagłówku skryptu uart_regs.py przez skrypt gen_uart_regs.py. Możesz wyświetlić listę dostępnych rejestrów za pomocą przełącznika -l, jak pokazano poniżej. Jest to polecenie lokalne i nie będzie oddziaływać z docelowym układem FPGA

Zapis do rejestrów

Możesz pisać do dowolnego rejestru trybu out, używając przełącznika -w. Podaj nazwę rejestru, po której następuje „=” i wartość podaną w postaci binarnej, szesnastkowej lub dziesiętnej, jak pokazano poniżej.
Należy zauważyć, że implementacja VHDL wymaga, aby skrypt zapisał wszystkie rejestry wyjściowe jednocześnie. Dlatego jeśli nie określisz kompletnego zestawu rejestrów wyjściowych, skrypt najpierw wykona odczyt z docelowego FPGA, a następnie użyje tych wartości dla brakujących. Rezultatem będzie zmiana tylko określonych rejestrów.
Kiedy wykonasz zapis, wszystkie określone rejestry ulegną zmianie w tym samym cyklu zegara, a nie zaraz po ich otrzymaniu przez UART.

Odczyt rejestrów

Użyj przełącznika -r, aby odczytać wszystkie wartości rejestrów, jak pokazano poniżej. Wartości zaznaczone na żółto to te, które zmieniliśmy w poprzednim zapisieample
Każdy odczyt pokazuje natychmiastową migawkę wszystkich rejestrów wejściowych i wyjściowych. Oni wszyscy są sampprowadzone w tym samym cyklu zegara

Debugowanie

Jeśli chcesz debugować protokół komunikacyjny, użyj przełącznika -d z dowolnym innym przełącznikiem. Następnie skrypt wydrukuje wszystkie wysłane i odebrane bajty oraz tag je, jeśli są znakami kontrolnymi, jak pokazano poniżej.

Korzystanie z interfejsu w innych skryptach Pythona

Skrypt uart_regs.py zawiera klasę UartRegs, której można z łatwością używać jako interfejsu komunikacyjnego w innych niestandardowych skryptach Pythona. Po prostu zaimportuj klasę, utwórz jej obiekt i zacznij korzystać z metod przedstawionych poniżej.

Zapoznaj się z dokumentacją w kodzie Pythona, aby zapoznać się z metodami, opisami i typami wartości zwracanych.

szablon_instancji.vho

Dla Twojej wygody szablon instancji jest generowany wraz z modułem uart_regs. Aby zaoszczędzić czas kodowania, możesz skopiować instancję modułu i deklaracje sygnałów do swojego projektu.

Statyczny RTL files

Musisz uwzględnić następujące elementy files w projekcie VHDL, aby zostały skompilowane w tej samej bibliotece, co moduł uart_regs:
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Moduł uart_regs_backend implementuje maszyny o skończonych stanach, które rejestrują i rejestrują dane rejestru. Wykorzystuje moduły uart_rx i uart_tx do obsługi komunikacji UART z hostem.

Projekty demonstracyjne

W Zipie znajdują się trzy projekty demonstracyjne file. Pozwalają sterować urządzeniami peryferyjnymi na różnych płytkach, a także kilkoma większymi, wewnętrznymi rejestrami.
Foldery demonstracyjne obejmują wstępnie wygenerowane pliki uart_regs.vhd i uart_regs.py filestworzone specjalnie dla tych projektów.

Kratkowy iCEstick

Folder demo/icecube2_icestick zawiera implementację demonstracyjną dostępu do rejestru dla płytki FPGA Lattice iCEstick.
Aby przejść przez proces wdrażania, otwórz demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file w oprogramowaniu do projektowania Lattice iCEcube2.
Po załadowaniu projektu do interfejsu GUI iCEcube2 kliknij Narzędzia → Uruchom wszystko, aby wygenerować bitmapę programowania file.

Możesz użyć samodzielnego narzędzia Lattice Diamond Programmer, aby skonfigurować układ FPGA z wygenerowaną mapą bitową file. Kiedy otworzy się Diamond Programmer, kliknij Otwórz istniejący projekt programisty w powitalnym oknie dialogowym.
Wybierz projekt file znaleźć w Zipie: demo/lattice_icestick/diamond_programmer_project.xcf i kliknij OK.
Po załadowaniu projektu kliknij trzy kropki w pliku File Kolumna Nazwa, jak pokazano powyżej. Przeglądaj, aby wybrać mapę bitową file który wygenerowałeś w iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Na koniec, po podłączeniu płytki iCEstick do portu USB w komputerze, wybierz Projekt → Program, aby zaprogramować pamięć flash SPI i skonfigurować FPGA.
Teraz możesz przystąpić do odczytu i zapisu rejestrów, korzystając ze skryptu demo/lattice_icestick/uart_regs.py, zgodnie z opisem w sekcji uart_regs.py.

Xilinx Digilent Arty A7-35T

Implementację demonstracyjną zestawu ewaluacyjnego Artix-7 35T Arty FPGA można znaleźć w folderze demo/arty_a7_35.
Otwórz Vivado i przejdź do wyodrębnionego pliku files za pomocą konsoli Tcl znajdującej się na dole interfejsu GUI. Wpisz to polecenie, aby wejść do folderu projektu demonstracyjnego:

płyta CD /demo/arty_a7_35/vivado_proj/
Wykonaj skrypt Tcl create_vivado_proj.tcl, aby zregenerować projekt Vivado:
źródło ./create_vivado_proj.tcl

Kliknij opcję Generuj strumień bitów na pasku bocznym, aby przejść przez wszystkie etapy implementacji i wygenerować programowy strumień bitów file.
Na koniec kliknij Otwórz Menedżera sprzętu i zaprogramuj FPGA za pomocą GUI.
Możesz teraz przystąpić do odczytu i zapisu rejestrów, używając skryptu demo/arty_a7_35/uart_regs.py, jak opisano w sekcji uart_regs.py.

Xilinx Digilent Arty S7-50

Implementację demonstracyjną płytki rozwojowej Arty S7: Spartan-7 FPGA znajdziesz w folderze demo/arty_s7_50.
Otwórz Vivado i przejdź do wyodrębnionego pliku files za pomocą konsoli Tcl znajdującej się na dole interfejsu GUI. Wpisz to polecenie, aby wejść do folderu projektu demonstracyjnego:

płyta CD /demo/arty_s7_50/vivado_proj/
Wykonaj skrypt Tcl create_vivado_proj.tcl, aby zregenerować projekt Vivado:
źródło ./create_vivado_proj.tcl

Kliknij opcję Generuj strumień bitów na pasku bocznym, aby przejść przez wszystkie etapy implementacji i wygenerować programowy strumień bitów file.
Na koniec kliknij Otwórz Menedżera sprzętu i zaprogramuj FPGA za pomocą GUI.
Możesz teraz przystąpić do odczytu i zapisu rejestrów, używając skryptu demo/arty_s7_50/uart_regs.py, jak opisano w sekcji uart_regs.py.

Realizacja

Nie ma szczególnych wymagań wdrożeniowych.

Ograniczenia

W tym projekcie nie są potrzebne żadne szczególne ograniczenia czasowe, ponieważ interfejs UART jest powolny i traktowany jako interfejs asynchroniczny.

Wejście uart_rx do modułu uart_regs jest synchronizowane w module uart_rx. Dlatego nie trzeba go synchronizować w module najwyższego poziomu.

Znane problemy

Może zaistnieć potrzeba zresetowania modułu, zanim będzie można go użyć, w zależności od tego, czy architektura FPGA obsługuje domyślne wartości rejestrów.

Więcej informacji

Prawo autorskie VHDLwhiz.com

Często zadawane pytania

P: Jaki jest cel generatora interfejsu testowego UART?

A: Generator interfejsu testowego UART umożliwia tworzenie niestandardowych interfejsów do interakcji z wartościami rejestrów FPGA za pomocą komunikacji UART.

P: Jak zainstalować pakiet Pyserial?

A: Możesz zainstalować Pyserial za pomocą Pip, używając polecenia: pip install pyserial

Dokumenty / Zasoby

Generator interfejsu testowego UART VHDLwhiz [plik PDF] Instrukcja obsługi
Generator interfejsu testowego UART, Generator interfejsu testowego, Generator interfejsu, Generator

Odniesienia

Instrukcja obsługi

Generator interfejsu testowego UART VHDLwhiz

Informacje o produkcie