Filozofia istnienia
kontemplując ciszęhttps://www.youtube.com/watch?v=-Ovhmoc3xCE
Nowoczesność w domu i w zagrodzie, takie skojarzenie wywołuje w moim umyśle hasło związane z układami programowalnymi. Te niewielkie żuczki (w rzeczywistości są małe, duże i ogromne), jakoby pochodzące z innego świata, dają wielkie możliwości. W czasach, gdy byłem studentem politechniki w programie nie było zajęć z nimi związanych. Ot... takie czasy. Owszem, gdzieś na wykładach z automatyki cyfrowej było wspomniane o układach PLA, ale nie sądzę, by wykładowca był do końca świadomy o czym mówi. Można naczytać się wielu książek, przegadać z kimś mnóstwo godzin na temat układów programowalnych (i nie tylko). Prawdziwą wiedzę daje dopiero własna praca. Aby móc ruszyć do przodu należy przede wszystkim spełnić jeden podstawowy i niezmierne istotny warunek: trzeba chcieć. Bez tej woli nic się nie uzyska. Każdy zapewne doświadczył zjawiska prokastynacji. To tendencja utożsamiana z odwlekaniem, opóźnianiem lub przekładaniem czegoś na później, ujawniająca się w różnych dziedzinach życia. Jej mechanizm polega na tym, że dzięki odłożeniu wykonania czynności na później pojawia się wrażenie, że nie trzeba działać natychmiast, a ponadto można zaangażować się w bardziej przyjemne, aktualne zadania. Odwlekaniu na później sprzyja złudzenie, że jutro będzie lepiej. Jednak uświadomienie sobie konieczności wykonania jakiegoś zadania powoduje stres, strach oraz nerwowość spowodowaną poczuciem, że zbyt mało czasu pozostało na dokładne i prawidłowe wykonanie planowanej czynności.
Powyższe uwagi doskonale opisują moją własną historię. W jakiś przedziwny sposób wiedza o istnieniu tego rodzaju układów powoli docierała do mojej świadomości. Wiedziałem, że są warte zainteresowania ale nie potrafiłem zbytnio tego uzasadnić. To jest takie ulotne. Poruszając się prawie po omacku, bo nie było w języku polskim właściwej literatury, nie było z kim pogadać. Początkowo powoli i ociężale podnosiłem swoją świadomość istnienia tych układów i szczegółów pozwalających na ich wykorzystanie. Nie trzeba nikogo przekonywać, że efektywne wykorzystanie ich możliwości wymaga poznania jakiegoś narzędzia, zarówno narzędzia w sensie programu (narzędziowego) i narzędzia w sensie języka (do opisu). Postawiłem na konia, któremu na imię VHDL. Jego filozofia jest tak odmienna od znanych języków programowania związanych z mikroprocesorami, że miałem poważne trudności z przełamaniem się w rozumieniu całości. Zaczynałem od rysowania schematów w programach narzędziowych, ale to nie jest droga godna polecenia, gdyż człowiek zaczyna gubić się w szczegółach a jak wiadomo, diabeł tkwi właśnie w szczegółach. VHDL stał się koniecznością. Poznanie syntaktyki i składni języka, choć jest istotnym elementem, tak naprawdę jest najmniej ważnym czynnikiem. Brak rozumienia filozofii tych układów nie pozwala na jakiekolwiek efektywne działanie. Jest jak łańcuch, który przykuwa skazańca do skały. Głównym problemem do pokonania jest pojęcie współbieżności. Przyzwyczajony do wizji algorytmicznych, sekwencyjnych języków programowania (bo tam też można mówić o pojęciu współbieżności) długo nie mogłem pokonać subtelnej bariery w odmiennej interpretacji tego pojęcia. Jakże często używając tych samych słów można wyrazić diametralnie odmienną myśl. Jestem przekonany, że to zjawisko jest wręcz powszechne, jedynie nie każdy ma odwagę do tego się przyznać.
Lata pracy poświęcone temu kawałeczkowi nie bardzo posuwały do przodu rozumienie tej filozofii. Przyznam szczerze, że niewiele brakowało, bym zawrócił z tej drogi. Wszystko wisiało na jednym włosku aż nadszedł czas, gdzie w błysku jednej chwili, w jakimś niepojętym akcie intuicji wszystko stało się jasne i zrozumiałe. Zadziałała jakaś przedziwna magia, wszystko zaczęło być zrozumiałe. Efektem końcowym tej przedziwnej walki jest książka (nie będę podawał tytułu, nie uprawiam kryptoreklamy). Natomiast mogę podzielić się posiadaną wiedzą. Wystarczy wyrazić chęć, zapiąć pasy i ruszyć przed siebie. Każdy zainteresowany dostanie moje wsparcie. Jednak chcę trochę pohamować potencjalnych entuzjastów, ja nie rozwiązuję cudzych problemów, pomogę w zrozumieniu, pokażę ciekawe kierunki, możliwości, zadbam, by zainteresowany również przeżył błysk olśnienia. Dalej to już każdy sobie poradzi.
[WEBPACK] Narzędzia do obróbki układów programowalnych
Moderator: ZbeeGin
Regulamin forum
Temat należy poprzedzić nazwa programu ujętą w kwadratowe nawiasy np. [KiCAD]
Temat należy poprzedzić nazwa programu ujętą w kwadratowe nawiasy np. [KiCAD]
[WEBPACK] Narzędzia do obróbki układów programowalnych
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Ostatnio zmieniony sobota 19 maja 2018, 00:59 przez gaweł, łącznie zmieniany 1 raz.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Narzędzia do konfigurowania
układów CPLD firmy Xilinx
cykliczny motyw...https://www.youtube.com/watch?v=dZDiaRZy0Ak
Firma Xilinx jest jedną z kilku, która oferuje układy szeroko rozumianej logiki programowalnej (PLD – ang. Programmable Logic Device). Można podzielić je głównie na dwie kategorie układów:
Realizacja projektów w oparciu o układy programowalne PLD sprowadza się do:
Każdy projekt (w sensie źródłowym) składa się z następujących części:
Poprawna reakcja na uruchomienie programu iMPACT jest następująca: Program sterujący iMPACT sam zauważy (i rozpozna) przyłączony układ PLD. Możliwe jest użycie w konstrukcji kilku różnych układów odpowiednio połączonych ze sobą, co powinno być właściwie zobrazowane w okienku programu. W tym przypadku użyty jest jeden układ z rodziny CoolRunner o symbolu XCR3256. Ustawiając wskaźnik myszki na symbolu układu scalonego i klikając prawym klawiszem myszki, możliwe jest przyporządkowanie każdemu układowi zbioru, którego zawartość ma być umieszczona w pamięci układu. Powyższy rysunek prezentuje stan po wykonaniu tej czynności.
Klikając myszką na rysunek układu scalonego (sam układ zostaje oznaczony kolorem), należy wybrać opcję: “Erase” (do usunięcia z pamięci układu dotychczasowej zawartości) lub opcję “Program” (do umieszczenia nowej zawartości w pamięci układu, w opcji “Program” można dodatkowo zażądać wcześniejszego kasowania układu, co oznacza, że operacja “Erase” nie jest bezwzględnie konieczna oraz weryfikację zawartości pamięci po zaprogramowaniu). Stopień zaawansowania zleconej operacji jest sygnalizowany przez program odpowiednim pakiem postępu. Zakończenie sygnalizowane jest komunikatem: Pozostało podziwiać działanie wyprodukowanie własnego, nowego układu scalonego lub powrócić po modyfikacji tekstu programu, bo efekty działania nie są właściwe. Tak wygląda w dużym skrócie proces “produkcji własnych układów cyfrowych”. Skrót ten wynika przede wszystkim z ogromnych możliwości funkcjonalnych pakietu WebPACK. związanych z generowaniem docelowych plików konfigurujących układy PLD, wsparciem pozwalającym symulować działanie tworzonego rozwiązania czyli weryfikacji działania bez konieczności używania fizycznych układów, dokumentowaniem projektu.
Cały prezentowany projekt jest następujący:
układów CPLD firmy Xilinx
cykliczny motyw...https://www.youtube.com/watch?v=dZDiaRZy0Ak
Firma Xilinx jest jedną z kilku, która oferuje układy szeroko rozumianej logiki programowalnej (PLD – ang. Programmable Logic Device). Można podzielić je głównie na dwie kategorie układów:
- układy CPLD,
- układy FPGA.
Realizacja projektów w oparciu o układy programowalne PLD sprowadza się do:
- określenia funkcji realizowanej przez układ PLD,
- wytworzenia odpowiedniego pliku do konfiguracji układu PLD,
- wprogramowaniu (umieszczeniu go w odpowiedniej pamięci) uzyskanego pliku konfiguracyjnego.
Każdy projekt (w sensie źródłowym) składa się z następujących części:
- opisu układu (pliki o rozszerzeniu .VHD będące opisem w języku VHDL, pliki o rozszerzeniu .V będące opisem w języku VERILOG, pliki o rozszerzeniu .SCH będące schematycznym rysunkiem),
- opisu dodatkowych wymagań (plik o rozszerzeniu .UCF zawierający między innymi przyporządkowanie fizycznych wyprowadzeń układu dla poszczególnych sygnałów).
Poprawna reakcja na uruchomienie programu iMPACT jest następująca: Program sterujący iMPACT sam zauważy (i rozpozna) przyłączony układ PLD. Możliwe jest użycie w konstrukcji kilku różnych układów odpowiednio połączonych ze sobą, co powinno być właściwie zobrazowane w okienku programu. W tym przypadku użyty jest jeden układ z rodziny CoolRunner o symbolu XCR3256. Ustawiając wskaźnik myszki na symbolu układu scalonego i klikając prawym klawiszem myszki, możliwe jest przyporządkowanie każdemu układowi zbioru, którego zawartość ma być umieszczona w pamięci układu. Powyższy rysunek prezentuje stan po wykonaniu tej czynności.
Klikając myszką na rysunek układu scalonego (sam układ zostaje oznaczony kolorem), należy wybrać opcję: “Erase” (do usunięcia z pamięci układu dotychczasowej zawartości) lub opcję “Program” (do umieszczenia nowej zawartości w pamięci układu, w opcji “Program” można dodatkowo zażądać wcześniejszego kasowania układu, co oznacza, że operacja “Erase” nie jest bezwzględnie konieczna oraz weryfikację zawartości pamięci po zaprogramowaniu). Stopień zaawansowania zleconej operacji jest sygnalizowany przez program odpowiednim pakiem postępu. Zakończenie sygnalizowane jest komunikatem: Pozostało podziwiać działanie wyprodukowanie własnego, nowego układu scalonego lub powrócić po modyfikacji tekstu programu, bo efekty działania nie są właściwe. Tak wygląda w dużym skrócie proces “produkcji własnych układów cyfrowych”. Skrót ten wynika przede wszystkim z ogromnych możliwości funkcjonalnych pakietu WebPACK. związanych z generowaniem docelowych plików konfigurujących układy PLD, wsparciem pozwalającym symulować działanie tworzonego rozwiązania czyli weryfikacji działania bez konieczności używania fizycznych układów, dokumentowaniem projektu.
Cały prezentowany projekt jest następujący:
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Konfiguracja układów FPGA firmy Xilinx
(na przykładzie układu z rodziny SPARTAN II)
Morderca modemów LTE.https://www.youtube.com/watch?v=IMY5PCCjdlE
Firma Xilinx w swojej bogatej ofercie posiada układy FPGA. Są to układy o znacząco większej elastyczności niż układy CPLD. Wynika to przede wszystkim z większych zasobów logicznych zawartych w samym układzie. Drugą istotną cechą, która odróżnia układy FPGA od układów CPLD jest to, że układy FPGA są konfigurowane w oparciu o pamięć RAM. W pewnym sensie można uznać to za jakąś formę wady, gdyż (w stosunku do układów CPLD, które nie wymagają one żadnych dodatkowych elementów – są gotowe do użycia) wymagają dodatkowych komponentów przeznaczonych na przechowywanie swojej konfiguracji. Znaczącym plusem natomiast jest to, że pamięci RAM są szybsze w działaniu w stosunku do pamięci nieulotnych (takie coś za coś). Konsekwencją takiego rozwiązania jest to, że układ FPGA po włączeniu zasilania nie jest skonfigurowany (niezasilana pamięć RAM traci przechowywane informacje). Rozwiązaniem tego problemu jest przepisanie odpowiednich danych z pamięci typu FLASH do pamięci w układzie FPGA. Zastosowanie rozwiązania z transmisją szeregową lub równoległą rodzi kilka rozwiązań (w obrębie samej transmisji szeregowej istnieje wiele rozwiązań). Często spotykanym sposobem jest zastosowanie mikrokontrolera, który w swoich zasobach przechowuje dane konfiguracyjne dla układu FPGA. Z powodu tej różnorodności, oprogramowanie odpowiedzialne za wygenerowanie danych do skonfigurowania układów FPGA wchodzące w skład pakietu WEBPack ogranicza się do utworzenia danych przeznaczonych dla samego układu FPGA (jest to plik o rozszerzeniu .BIT). Uzyskanie pozostałych możliwości związanych z konfigurowaniem układów FPGA zostało przeniesione do programu, który jest odpowiedzialny za programowanie układów PLD (program iMAPCT). W przypadku układów CPLD, program iMPACT programuje te układu w oparciu o zawartość plików o rozszerzeniu .JED. W przypadku układów FPGA, program iMPACT również może zaprogramować bezpośrednio układ FPGA (dane znajdują się w pliku o rozszerzeniu .BIT) lub dokonać przetworzenia tego pliku do formatu, który wynika z zastosowanego technicznego rozwiązania. W omawianym przypadku jest to pamięć szeregowa. To rozwiązanie jest czasami jedynym możliwym (jak w przypadku starszych układów) lub jednym z wielu możliwych (jak w przypadku nowych układów).
W zestawie do eksperymentów z układami FPGA firmowanym przez Xilinx jako pamięć konfiguracyjna zastosowany jest układ o symbolu XC18V01 (jest to szeregowa pamięć FLASH).
Poniższe rozważania dotyczą wymienionego zestawu zawierającego układ FPGA z rodziny SPARTAN II (układ XC2S100), ale również obowiązują dla innych układów (np. układów SPARTAN 3).
Rozpatrzmy projekt, w którym stan 8-bitowego licznika jest wyświetlany na wyświetlaczu jako 2 cyfry w zapisie szesnastkowym. Po wygenerowaniu odpowiednich plików (uruchomienie odpowiedniego procesu), można przejść do czynności związanych z zaprogramowaniem pamięci FLASH, z której dane będą następnie przepisywane do układu FPGA. Samo zaprogramowanie wymaga wcześniejszego utworzenia odpowiedniego pliku. Wszystkie te operacje są wykonywane przez program iMPACT, który jest uruchamiany w wyniku wybrania odpowiedniej opcji w okienku „Processes”. Po uruchomieniu programu istnieje możliwość dokładnego określenia czynności do wykonania. Jeżeli celem jest zaprogramowanie poprzez interfejs JTAG samego układu FPGA, to należy wybrać “Configure devices using ...” i przycisk “Finish”. W przypadku zaprogramowania pamięci FLASH należy wybrać “Prepare a PROM file” oraz “Next”.
W dalszej kolejności są określane szczegóły związane z realizowaną czynnością: Należy zaznaczyć opcje:
(na przykładzie układu z rodziny SPARTAN II)
Morderca modemów LTE.https://www.youtube.com/watch?v=IMY5PCCjdlE
Firma Xilinx w swojej bogatej ofercie posiada układy FPGA. Są to układy o znacząco większej elastyczności niż układy CPLD. Wynika to przede wszystkim z większych zasobów logicznych zawartych w samym układzie. Drugą istotną cechą, która odróżnia układy FPGA od układów CPLD jest to, że układy FPGA są konfigurowane w oparciu o pamięć RAM. W pewnym sensie można uznać to za jakąś formę wady, gdyż (w stosunku do układów CPLD, które nie wymagają one żadnych dodatkowych elementów – są gotowe do użycia) wymagają dodatkowych komponentów przeznaczonych na przechowywanie swojej konfiguracji. Znaczącym plusem natomiast jest to, że pamięci RAM są szybsze w działaniu w stosunku do pamięci nieulotnych (takie coś za coś). Konsekwencją takiego rozwiązania jest to, że układ FPGA po włączeniu zasilania nie jest skonfigurowany (niezasilana pamięć RAM traci przechowywane informacje). Rozwiązaniem tego problemu jest przepisanie odpowiednich danych z pamięci typu FLASH do pamięci w układzie FPGA. Zastosowanie rozwiązania z transmisją szeregową lub równoległą rodzi kilka rozwiązań (w obrębie samej transmisji szeregowej istnieje wiele rozwiązań). Często spotykanym sposobem jest zastosowanie mikrokontrolera, który w swoich zasobach przechowuje dane konfiguracyjne dla układu FPGA. Z powodu tej różnorodności, oprogramowanie odpowiedzialne za wygenerowanie danych do skonfigurowania układów FPGA wchodzące w skład pakietu WEBPack ogranicza się do utworzenia danych przeznaczonych dla samego układu FPGA (jest to plik o rozszerzeniu .BIT). Uzyskanie pozostałych możliwości związanych z konfigurowaniem układów FPGA zostało przeniesione do programu, który jest odpowiedzialny za programowanie układów PLD (program iMAPCT). W przypadku układów CPLD, program iMPACT programuje te układu w oparciu o zawartość plików o rozszerzeniu .JED. W przypadku układów FPGA, program iMPACT również może zaprogramować bezpośrednio układ FPGA (dane znajdują się w pliku o rozszerzeniu .BIT) lub dokonać przetworzenia tego pliku do formatu, który wynika z zastosowanego technicznego rozwiązania. W omawianym przypadku jest to pamięć szeregowa. To rozwiązanie jest czasami jedynym możliwym (jak w przypadku starszych układów) lub jednym z wielu możliwych (jak w przypadku nowych układów).
W zestawie do eksperymentów z układami FPGA firmowanym przez Xilinx jako pamięć konfiguracyjna zastosowany jest układ o symbolu XC18V01 (jest to szeregowa pamięć FLASH).
Poniższe rozważania dotyczą wymienionego zestawu zawierającego układ FPGA z rodziny SPARTAN II (układ XC2S100), ale również obowiązują dla innych układów (np. układów SPARTAN 3).
Rozpatrzmy projekt, w którym stan 8-bitowego licznika jest wyświetlany na wyświetlaczu jako 2 cyfry w zapisie szesnastkowym. Po wygenerowaniu odpowiednich plików (uruchomienie odpowiedniego procesu), można przejść do czynności związanych z zaprogramowaniem pamięci FLASH, z której dane będą następnie przepisywane do układu FPGA. Samo zaprogramowanie wymaga wcześniejszego utworzenia odpowiedniego pliku. Wszystkie te operacje są wykonywane przez program iMPACT, który jest uruchamiany w wyniku wybrania odpowiedniej opcji w okienku „Processes”. Po uruchomieniu programu istnieje możliwość dokładnego określenia czynności do wykonania. Jeżeli celem jest zaprogramowanie poprzez interfejs JTAG samego układu FPGA, to należy wybrać “Configure devices using ...” i przycisk “Finish”. W przypadku zaprogramowania pamięci FLASH należy wybrać “Prepare a PROM file” oraz “Next”.
W dalszej kolejności są określane szczegóły związane z realizowaną czynnością: Należy zaznaczyć opcje:
- “Xilinx PROM”,
- format “MCS”,
- w okienku “PROM File Name” wpisać nazwę pliku (plik będzie zawierał dane, które mają być umieszczone w pamięci FLASH),
- po ewentualnych modyfikacjach informacji w okienku “Location” wybrać opcję “Next”.
- w “Select a PROM” wybrać rodzinę układów “XC18V”, bo taki układ jest zastosowany w zestawie Xilinx z układem SPARTAN II (w przypadku innych zestawów należy wybrać właściwy),
- dalej wybrać układ o symbolu “XC18V01”,
- tak określony układ wybrać poprzez przycisk “Add”,
- przejść do kolejnego etapu (przycisk “Next”),
- określić plik przeznaczony dla układu FPGA, który będzie przetworzony do formatu dla pamięci FLASH.
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Symulacja działania
syntezowanych układów w strukturach PLD
Marzę o ciszy w umysłach
https://www.youtube.com/watch?v=NL_NYmy6upU
Projektując układy cyfrowe zarówno w wersji rzeczywistej, zrealizowanych na bazie prawdziwych układów logicznych i cyfrowych, oraz w wersji niejako wirtualnej, realizowanej w postaci opisu w języku VHDL, doświadczamy tych samych problemów. Utworzone rozwiązania podlegają identycznym prawom. Urządzenie jako całość będzie działać lub nie (będzie realizować założoną funkcjonalność) i to bez względu na zastosowaną technologią: zarówno wyimaginowaną (określoną jako abstrakcyjny opis) jak i fizyczną (zbudowaną z realnych komponentów). W przypadku rozwiązań fizycznych, weryfikacja działania takiego urządzenia nastręcza pewne trudności. Nie dość, że wszystko należy zbudować z rzeczywistych elementów, to dodatkowo konieczne jest wygenerowanie sygnałów wymuszających (również niejako fizycznych) i obserwacja wyników działania. Alternatywą jest niejako przejście do przestrzeni wirtualnej. Za pomocą odpowiedniego narzędzia można utworzyć wyimaginowane, wirtualne urządzenie i zrealizować wirtualne testy. Stosując powyższe koncepcje w praktyce zauważyłem jeden ciekawy i bardzo istotny wniosek: działa tak samo. Zamiast trudzić się z fizycznym układem, można potrudzić się z wirtualnym układem. Używając poetyckiej przenośni można powiedzieć, że wyobraźnia to potęga. Ponieważ zawsze najlepszą inspiracją jest przykład, więc... zapinamy pasy i ruszamy w nieznane przed siebie.
Posługując się pakietem oprogramowania WebPACK do syntezy układów cyfrowych w strukturach logiki programowalnej (CPLD oraz FPGA), istnieje możliwość symulacji jego działania. Symulacji może podlegać dowolny fragment syntezowanego układu (jako pojedynczy komponent) z ewentualnym uwzględnieniem komponentów zagłębionych. W szczególności takim fragmentem może być cały projekt. Symulacja działania polega na określeniu stanu sygnałów wejściowych dla danego komponentu oraz obserwacji przebiegów sygnałów wypracowanych w komponencie. W tym celu należy utworzyć odpowiedni zbiór w języku VHDL zawierający wymuszenia dla sygnałów wejściowych, który po dołączeniu do projektu “stanowi źródło sygnałów” w trakcie symulacji. Wynik symulacji, jako wykres przebiegu sygnałów cyfrowych, jest zobrazowany na ekranie monitora.
Rozpatrzmy to na przykładzie. Jest to dwucyfrowy licznik dziesiętny wraz z enkoderem umożliwiającym zobrazowanie jego stanu na siedmiosegmentowym wyświetlaczu. Projekt składa się z trzech komponentów:
[cnt10.vhd]:Jak widać, jest to komponent mający dwa sygnały wejściowe:
[decadecnt.vhd]:Ten komponent stanowi implementację jednocyfrowego licznika dekadowego.
[encoder.vhd]:Ten komponent realizuje zamianę czterobitowego kodu BCD na kod wymagany przez wyświetlacze siedmiosegmentowe. Po poprawnej kompilacji tego niewielkiego projektu można przystąpić do symulacji działania układu. W tym celu należy przejść do sekcji odpowiedzialnej za symulację zsyntezowanego układu poprzez wybranie opcji “Behavioral Simulation” w “Sources for”: w wyniku którego dostępne stają się procesy związane z symulacją. Utworzenie i dołączenie nowego zbioru na potrzeby symulacji może następić w wyniku uruchomienia procesu “Create New Source” w okienku “Processes”. Zostaje otwarte okienko dialogowe do określenia szczegółów, w którym w “File name” należy wpisać nazwę tworzonego zbioru, oraz zaznaczyć “VHDL Test Bench”. Po kliknięciu na przycisk “Next”, w kolejnym kroku, należy określić komponent, dla którego przygotowywany jest zbiór wymuszeń (tu wybrany jest komponent liczników dekadowych).
Po akceptacji (przycisk “Next” i później “Finish”), oprogramowanie WebPACK utworzy szkielet pliku do symulacji danego komponentu oraz przyłączy nowy plik do projektu. Utworzony plik należy uzupełnić. Postać zbioru do symulacji komponentu decadecnt.vhd (jako zbiór o nazwie decadecnt_tb.vhd) jest następująca (znakomita większość pliku jest automatycznie wygenerowana i pozostaje jedynie zmodyfikować wybrane fragmenty oraz uzupełnić o specyfikację sygnałów wymuszenia, które w tekście wyróżniono kolorem) :
[decadecnt_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY decadecnt_tb_vhd IS
END decadecnt_tb_vhd;
ARCHITECTURE behavior OF decadecnt_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT DecadeCnt
PORT(
Clk : IN std_logic;
Reset : IN std_logic;
Enable : IN std_logic;
Q : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;
--Inputs
SIGNAL Clk : std_logic := '0';
SIGNAL Reset : std_logic := '1';
SIGNAL Enable : std_logic := '1';
W tym miejscu można ewentualnie zmienić stan początkowy sygnałów wejściowych dla symulowanego komponentu.
--Outputs
SIGNAL Q : std_logic_vector(3 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: DecadeCnt PORT MAP(
Clk => Clk,
Reset => Reset,
Enable => Enable,
Q => Q
);
tb : PROCESS
BEGIN
Komponent ma dwa sygnały wejściowe (Clk i Reset), toteż jedynie te sygnały będą miały określoną wartość. Sygnały wyjściowe będą obserwowane na ekranie.
wait for 100 ns ;
Reset <= '0' ;
wait for 100 ns ;
Reset <= '1' ;
Zostaje wygenerowany sygnał Reset o pewnym czasie trwania (w sumie nie jest to istotne, gdyż symulacja dotyczy funkcjonowania układu) jako impuls ze stanem aktywnym niskim.
for Inx in 0 to 50 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
W dalszej części zostaje “wyprodukowana” pewna liczba impulsów zegarowych Clk.
wait ;
END PROCESS ;
END;
Wskazując na odpowiedni plik w sekcji “Sources for: Behavioral Simulation” należy uruchomić proces “Check syntax” (w “Xilinx ISE Simulator”). Po poprawnym jego zakończeniu w dalszej kolejności należy uruchomić proces “Simulate Behavioral Model”. W odpowiedzi zostanie uruchomiony program symulujący działanie komponentu.
Ponieważ w parametrach symulacji jest określony górny limit czasowy, można go zmienić lub zażądać symulacji zgodnie ze zbiorem wymuszeń. Sprowadza się to do użycia opcji “Reset” i “Run All” w elemencie menu “Simulation”. Uzyskany jest wynik symulacji w postaci przebiegu sygnałów cyfrowych. Program wstępnie zaproponuje do oglądania sygnały wejścia i wyjścia komponentu. W przypadku szyn, wyświetlana jest liczba odpowiadająca występującej kombinacji bitów. W menu “Window” i “Float” można wydzielić do niezależnego okienka sam przebieg sygnałów. Powrót następuje po użyciu “Window” i “Dock”. Prezentowane przebiegi mogą być rozciągane w czasie. Zakończenie symulacji następuje po użyciu opcji “Simulation” i “End simulation”. Program powraca do możliwości modyfikacji zbioru testów lub po przełączeniu na część realizującą syntezę wrócić do modyfikacji symulowanego komponentu. Po ewentualnych zmianach należy ponownie przeprowadzić syntezę całości by po przełączeniu na część realizującą symulację ponownie przeanalizować przebiegi sygnałów w komponencie.
W podobny sposób można utworzyć zbiór do symulacji innego komponentu. Realizuje się to w identyczny sposób (jedynie należy w odpowiednim momencie wskazać właściwy komponent, dla którego tworzony jest zbiór wymuszeń). Przykładowy zbiór do symulacji działania komponentu zamiany kodu BCD na kod wymagany przez wyświetlacz siedmiosegmentowy jest następujący:
[encoder_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY encoder_tb_vhd IS
END encoder_tb_vhd;
ARCHITECTURE behavior OF encoder_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT Encoder
PORT(
BCD : IN std_logic_vector(3 downto 0);
LED_A : OUT std_logic;
LED_B : OUT std_logic;
LED_C : OUT std_logic;
LED_D : OUT std_logic;
LED_E : OUT std_logic;
LED_F : OUT std_logic;
LED_G : OUT std_logic
);
END COMPONENT;
--Inputs
SIGNAL BCD : std_logic_vector(3 downto 0) := (others=>'0');
--Outputs
SIGNAL LED_A : std_logic;
SIGNAL LED_B : std_logic;
SIGNAL LED_C : std_logic;
SIGNAL LED_D : std_logic;
SIGNAL LED_E : std_logic;
SIGNAL LED_F : std_logic;
SIGNAL LED_G : std_logic;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: Encoder PORT MAP(
BCD => BCD,
LED_A => LED_A,
LED_B => LED_B,
LED_C => LED_C,
LED_D => LED_D,
LED_E => LED_E,
LED_F => LED_F,
LED_G => LED_G
);
tb : PROCESS
BEGIN
BCD <= "0000" ;
wait for 100 ns;
BCD <= "0001" ;
wait for 100 ns;
BCD <= "0010" ;
wait for 100 ns;
BCD <= "0100" ;
wait for 100 ns;
BCD <= "1000" ;
W przypadku wymuszenia poprzez wektor sygnałów, można je wypisać,
wait for 100 ns;
BCD <= "0000" ;
wait for 100 ns;
for Inx in 1 to 10 loop
BCD <= BCD + 1 ;
wait for 100 ns;
end loop ;
lub zrealizować zliczanie.
wait; -- will wait forever
END PROCESS;
END;
Podobnie można uzyskać przebieg sygnałów wejściowych i wyjściowych komponentu. W przypadku symulacji komponentu, który zawiera w sobie inne komponenty, to w trakcie symulacji można je również oglądać (czyli wszystkie występujące sygnały łącznie z sygnałami o znaczeniu lokalnym dla komponentu).
Przykładowy zbiór zawierający wymuszenia symulacyjne dla całego projektu wygląda następująco:
[cnt10_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY cnt10_tb_vhd IS
END cnt10_tb_vhd;
ARCHITECTURE behavior OF cnt10_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT cnt10
PORT(
Clk : IN std_logic ;
Reset : IN std_logic ;
A_SegmA : out std_logic ;
A_SegmB : out std_logic ;
A_SegmC : out std_logic ;
A_SegmD : out std_logic ;
A_SegmE : out std_logic ;
A_SegmF : out std_logic ;
A_SegmG : out std_logic ;
B_SegmA : out std_logic ;
B_SegmB : out std_logic ;
B_SegmC : out std_logic ;
B_SegmD : out std_logic ;
B_SegmE : out std_logic ;
B_SegmF : out std_logic ;
B_SegmG : out std_logic ) ;
END COMPONENT;
--Inputs
SIGNAL Clk : std_logic := '0';
SIGNAL Reset : std_logic := '1';
--Outputs
SIGNAL A_SegmA : std_logic ;
SIGNAL A_SegmB : std_logic ;
SIGNAL A_SegmC : std_logic ;
SIGNAL A_SegmD : std_logic ;
SIGNAL A_SegmE : std_logic ;
SIGNAL A_SegmF : std_logic ;
SIGNAL A_SegmG : std_logic ;
SIGNAL B_SegmA : std_logic ;
SIGNAL B_SegmB : std_logic ;
SIGNAL B_SegmC : std_logic ;
SIGNAL B_SegmD : std_logic ;
SIGNAL B_SegmE : std_logic ;
SIGNAL B_SegmF : std_logic ;
SIGNAL B_SegmG : std_logic ;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: cnt10 PORT MAP(
Clk => Clk,
Reset => Reset,
A_SegmA => A_SegmA,
A_SegmB => A_SegmB,
A_SegmC => A_SegmC,
A_SegmD => A_SegmD,
A_SegmE => A_SegmE,
A_SegmF => A_SegmF,
A_SegmG => A_SegmG,
B_SegmA => B_SegmA,
B_SegmB => B_SegmB,
B_SegmC => B_SegmC,
B_SegmD => B_SegmD,
B_SegmE => B_SegmE,
B_SegmF => B_SegmF,
B_SegmG => B_SegmG
);
tb : PROCESS
BEGIN
Reset <= '0' ;
wait for 100 ns ;
Reset <= '1' ;
wait for 100 ns ;
Tu zostaje wygenerowany impuls zerujący i w dalszej kolejności
for Inx in 0 to 64 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
kilkadziesiąt impulsów zegarowych,
Reset <= '0' ;
Clk <= '1' ;
wait for 100 ns ;
for Inx in 0 to 5 loop
Clk <= '0' ;
wait for 100 ns ;
Clk <= '1' ;
wait for 100 ns ;
end loop ;
Reset <= '1' ;
Clk <= '0' ;
ponownie impuls zerowania trwający kilka taktów zegarowych,
wait for 100 ns ;
for Inx in 0 to 120 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
oraz pewna liczba impulsów podlegających ponownemu zliczeniu.
wait; -- will wait forever
END PROCESS;
END;
Po wykonaniu wszystkich wymaganych czynności i operacji, można uzyskać przebieg sygnałów cyfrowych w całym projekcie. Początkowo w oknie symulatora są zaprezentowane sygnały wejścia i wyjścia komponentu. Zgodnie z wymuszeniami zawartymi w zbiorze, widać reakcję układu na sygnał zerowania. Przy przeglądaniu przebiegów istnieje możliwość posługiwania się znacznikami, którymi są dostępne poprzez odpowiednie przyciski. Rozwijając listę dostępnych sygnałów, w okienku symulatora (przy “Window” i “Dock”) można zaznaczyć dowolne sygnały (nawet w komponentach zagnieżdżonych) i metodą “przenieś i upuść” w obszarze nazw sygnałów dołączyć je do istniejącej już listy prezentowanych sygnałów.
syntezowanych układów w strukturach PLD
Marzę o ciszy w umysłach
https://www.youtube.com/watch?v=NL_NYmy6upU
Projektując układy cyfrowe zarówno w wersji rzeczywistej, zrealizowanych na bazie prawdziwych układów logicznych i cyfrowych, oraz w wersji niejako wirtualnej, realizowanej w postaci opisu w języku VHDL, doświadczamy tych samych problemów. Utworzone rozwiązania podlegają identycznym prawom. Urządzenie jako całość będzie działać lub nie (będzie realizować założoną funkcjonalność) i to bez względu na zastosowaną technologią: zarówno wyimaginowaną (określoną jako abstrakcyjny opis) jak i fizyczną (zbudowaną z realnych komponentów). W przypadku rozwiązań fizycznych, weryfikacja działania takiego urządzenia nastręcza pewne trudności. Nie dość, że wszystko należy zbudować z rzeczywistych elementów, to dodatkowo konieczne jest wygenerowanie sygnałów wymuszających (również niejako fizycznych) i obserwacja wyników działania. Alternatywą jest niejako przejście do przestrzeni wirtualnej. Za pomocą odpowiedniego narzędzia można utworzyć wyimaginowane, wirtualne urządzenie i zrealizować wirtualne testy. Stosując powyższe koncepcje w praktyce zauważyłem jeden ciekawy i bardzo istotny wniosek: działa tak samo. Zamiast trudzić się z fizycznym układem, można potrudzić się z wirtualnym układem. Używając poetyckiej przenośni można powiedzieć, że wyobraźnia to potęga. Ponieważ zawsze najlepszą inspiracją jest przykład, więc... zapinamy pasy i ruszamy w nieznane przed siebie.
Posługując się pakietem oprogramowania WebPACK do syntezy układów cyfrowych w strukturach logiki programowalnej (CPLD oraz FPGA), istnieje możliwość symulacji jego działania. Symulacji może podlegać dowolny fragment syntezowanego układu (jako pojedynczy komponent) z ewentualnym uwzględnieniem komponentów zagłębionych. W szczególności takim fragmentem może być cały projekt. Symulacja działania polega na określeniu stanu sygnałów wejściowych dla danego komponentu oraz obserwacji przebiegów sygnałów wypracowanych w komponencie. W tym celu należy utworzyć odpowiedni zbiór w języku VHDL zawierający wymuszenia dla sygnałów wejściowych, który po dołączeniu do projektu “stanowi źródło sygnałów” w trakcie symulacji. Wynik symulacji, jako wykres przebiegu sygnałów cyfrowych, jest zobrazowany na ekranie monitora.
Rozpatrzmy to na przykładzie. Jest to dwucyfrowy licznik dziesiętny wraz z enkoderem umożliwiającym zobrazowanie jego stanu na siedmiosegmentowym wyświetlaczu. Projekt składa się z trzech komponentów:
- całość układu (plik: cnt10.vhd),
- licznika dekadowego (plik: decadecnt.vhd),
- enkodera kodu BCD na kod wyświetlacza siedmiosegmentowego (plik: encoder.vhd).
[cnt10.vhd]:
Kod: Zaznacz cały
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity cnt10 is port ( Clk : in std_logic ;
Reset : in std_logic ;
A_SegmA : out std_logic ;
A_SegmB : out std_logic ;
A_SegmC : out std_logic ;
A_SegmD : out std_logic ;
A_SegmE : out std_logic ;
A_SegmF : out std_logic ;
A_SegmG : out std_logic ;
B_SegmA : out std_logic ;
B_SegmB : out std_logic ;
B_SegmC : out std_logic ;
B_SegmD : out std_logic ;
B_SegmE : out std_logic ;
B_SegmF : out std_logic ;
B_SegmG : out std_logic ) ;
end cnt10 ;
architecture Behavioral of cnt10 is
component DecadeCnt port ( Clk : in std_logic ;
Reset : in std_logic ;
Enable : in std_logic ;
Q : out std_logic_vector ( 3 downto 0 ) ) ;
end component ;
component Encoder port ( BCD : in std_logic_vector ( 3 downto 0 ) ;
LED_A : out std_logic ;
LED_B : out std_logic ;
LED_C : out std_logic ;
LED_D : out std_logic ;
LED_E : out std_logic ;
LED_F : out std_logic ;
LED_G : out std_logic ) ;
end component ;
signal Enable10 : std_logic ;
signal Q1 : std_logic_vector ( 3 downto 0 ) ;
signal Q10 : std_logic_vector ( 3 downto 0 ) ;
begin
Enable10 <= '1' when Q1 = "1001" else '0' ;
Instance1 : DecadeCnt port map ( Clk => Clk ,
Reset => Reset ,
Enable => '1' ,
Q => Q1 ) ;
Instance10 : DecadeCnt port map ( Clk => Clk ,
Reset => Reset ,
Enable => Enable10 ,
Q => Q10 ) ;
Seg1Instance : Encoder port map ( BCD => Q1 ,
LED_A => A_SegmA ,
LED_B => A_SegmB ,
LED_C => A_SegmC ,
LED_D => A_SegmD ,
LED_E => A_SegmE ,
LED_F => A_SegmF ,
LED_G => A_SegmG ) ;
Seg10Instance : Encoder port map ( BCD => Q10 ,
LED_A => B_SegmA ,
LED_B => B_SegmB ,
LED_C => B_SegmC ,
LED_D => B_SegmD ,
LED_E => B_SegmE ,
LED_F => B_SegmF ,
LED_G => B_SegmG ) ;
end Behavioral ;
- Clk – jako doprowadzenie zliczanych impulsów,
- Reset – jak sygnał zerujący licznik jedności (Q1) oraz dziesiątek (Q10).
[decadecnt.vhd]:
Kod: Zaznacz cały
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity DecadeCnt is port ( Clk : in std_logic ;
Reset : in std_logic ;
Enable : in std_logic ;
Q : out std_logic_vector ( 3 downto 0 ) ) ;
end DecadeCnt ;
architecture Behavioral of DecadeCnt is
signal Cnt : std_logic_vector ( 3 downto 0 ) ;
begin
process ( Clk , Reset , Enable )
begin
if ( Reset = '0' ) then
Cnt <= "0000" ;
elsif ( Enable = '1' ) then
if ( Clk'event and Clk = '1' ) then
if ( Cnt = "1001" ) then
Cnt <= "0000" ;
else
Cnt <= Cnt + "0001" ;
end if ;
end if ;
end if ;
end process ;
Q <= Cnt ;
end Behavioral ;
[encoder.vhd]:
Kod: Zaznacz cały
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Encoder is port ( BCD : in std_logic_vector ( 3 downto 0 ) ;
LED_A : out std_logic ;
LED_B : out std_logic ;
LED_C : out std_logic ;
LED_D : out std_logic ;
LED_E : out std_logic ;
LED_F : out std_logic ;
LED_G : out std_logic ) ;
end Encoder ;
architecture Behavioral of Encoder is
signal OutBus : std_logic_vector ( 6 downto 0 ) ;
begin
LED_A <= OutBus ( 0 ) ;
LED_B <= OutBus ( 1 ) ;
LED_C <= OutBus ( 2 ) ;
LED_D <= OutBus ( 3 ) ;
LED_E <= OutBus ( 4 ) ;
LED_F <= OutBus ( 5 ) ;
LED_G <= OutBus ( 6 ) ;
-- segment encoding
-- 0
-- ---
-- 5 | | 1
-- --- <- 6
-- 4 | | 2
-- ---
-- 3
with BCD select
OutBus <= "1111001" when "0001" , --1
"0100100" when "0010" , --2
"0110000" when "0011" , --3
"0011001" when "0100" , --4
"0010010" when "0101" , --5
"0000010" when "0110" , --6
"1111000" when "0111" , --7
"0000000" when "1000" , --8
"0010000" when "1001" , --9
"1000000" when others ; --0
end Behavioral ;
Po akceptacji (przycisk “Next” i później “Finish”), oprogramowanie WebPACK utworzy szkielet pliku do symulacji danego komponentu oraz przyłączy nowy plik do projektu. Utworzony plik należy uzupełnić. Postać zbioru do symulacji komponentu decadecnt.vhd (jako zbiór o nazwie decadecnt_tb.vhd) jest następująca (znakomita większość pliku jest automatycznie wygenerowana i pozostaje jedynie zmodyfikować wybrane fragmenty oraz uzupełnić o specyfikację sygnałów wymuszenia, które w tekście wyróżniono kolorem) :
[decadecnt_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY decadecnt_tb_vhd IS
END decadecnt_tb_vhd;
ARCHITECTURE behavior OF decadecnt_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT DecadeCnt
PORT(
Clk : IN std_logic;
Reset : IN std_logic;
Enable : IN std_logic;
Q : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;
--Inputs
SIGNAL Clk : std_logic := '0';
SIGNAL Reset : std_logic := '1';
SIGNAL Enable : std_logic := '1';
W tym miejscu można ewentualnie zmienić stan początkowy sygnałów wejściowych dla symulowanego komponentu.
--Outputs
SIGNAL Q : std_logic_vector(3 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: DecadeCnt PORT MAP(
Clk => Clk,
Reset => Reset,
Enable => Enable,
Q => Q
);
tb : PROCESS
BEGIN
Komponent ma dwa sygnały wejściowe (Clk i Reset), toteż jedynie te sygnały będą miały określoną wartość. Sygnały wyjściowe będą obserwowane na ekranie.
wait for 100 ns ;
Reset <= '0' ;
wait for 100 ns ;
Reset <= '1' ;
Zostaje wygenerowany sygnał Reset o pewnym czasie trwania (w sumie nie jest to istotne, gdyż symulacja dotyczy funkcjonowania układu) jako impuls ze stanem aktywnym niskim.
for Inx in 0 to 50 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
W dalszej części zostaje “wyprodukowana” pewna liczba impulsów zegarowych Clk.
wait ;
END PROCESS ;
END;
Wskazując na odpowiedni plik w sekcji “Sources for: Behavioral Simulation” należy uruchomić proces “Check syntax” (w “Xilinx ISE Simulator”). Po poprawnym jego zakończeniu w dalszej kolejności należy uruchomić proces “Simulate Behavioral Model”. W odpowiedzi zostanie uruchomiony program symulujący działanie komponentu.
Ponieważ w parametrach symulacji jest określony górny limit czasowy, można go zmienić lub zażądać symulacji zgodnie ze zbiorem wymuszeń. Sprowadza się to do użycia opcji “Reset” i “Run All” w elemencie menu “Simulation”. Uzyskany jest wynik symulacji w postaci przebiegu sygnałów cyfrowych. Program wstępnie zaproponuje do oglądania sygnały wejścia i wyjścia komponentu. W przypadku szyn, wyświetlana jest liczba odpowiadająca występującej kombinacji bitów. W menu “Window” i “Float” można wydzielić do niezależnego okienka sam przebieg sygnałów. Powrót następuje po użyciu “Window” i “Dock”. Prezentowane przebiegi mogą być rozciągane w czasie. Zakończenie symulacji następuje po użyciu opcji “Simulation” i “End simulation”. Program powraca do możliwości modyfikacji zbioru testów lub po przełączeniu na część realizującą syntezę wrócić do modyfikacji symulowanego komponentu. Po ewentualnych zmianach należy ponownie przeprowadzić syntezę całości by po przełączeniu na część realizującą symulację ponownie przeanalizować przebiegi sygnałów w komponencie.
W podobny sposób można utworzyć zbiór do symulacji innego komponentu. Realizuje się to w identyczny sposób (jedynie należy w odpowiednim momencie wskazać właściwy komponent, dla którego tworzony jest zbiór wymuszeń). Przykładowy zbiór do symulacji działania komponentu zamiany kodu BCD na kod wymagany przez wyświetlacz siedmiosegmentowy jest następujący:
[encoder_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY encoder_tb_vhd IS
END encoder_tb_vhd;
ARCHITECTURE behavior OF encoder_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT Encoder
PORT(
BCD : IN std_logic_vector(3 downto 0);
LED_A : OUT std_logic;
LED_B : OUT std_logic;
LED_C : OUT std_logic;
LED_D : OUT std_logic;
LED_E : OUT std_logic;
LED_F : OUT std_logic;
LED_G : OUT std_logic
);
END COMPONENT;
--Inputs
SIGNAL BCD : std_logic_vector(3 downto 0) := (others=>'0');
--Outputs
SIGNAL LED_A : std_logic;
SIGNAL LED_B : std_logic;
SIGNAL LED_C : std_logic;
SIGNAL LED_D : std_logic;
SIGNAL LED_E : std_logic;
SIGNAL LED_F : std_logic;
SIGNAL LED_G : std_logic;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: Encoder PORT MAP(
BCD => BCD,
LED_A => LED_A,
LED_B => LED_B,
LED_C => LED_C,
LED_D => LED_D,
LED_E => LED_E,
LED_F => LED_F,
LED_G => LED_G
);
tb : PROCESS
BEGIN
BCD <= "0000" ;
wait for 100 ns;
BCD <= "0001" ;
wait for 100 ns;
BCD <= "0010" ;
wait for 100 ns;
BCD <= "0100" ;
wait for 100 ns;
BCD <= "1000" ;
W przypadku wymuszenia poprzez wektor sygnałów, można je wypisać,
wait for 100 ns;
BCD <= "0000" ;
wait for 100 ns;
for Inx in 1 to 10 loop
BCD <= BCD + 1 ;
wait for 100 ns;
end loop ;
lub zrealizować zliczanie.
wait; -- will wait forever
END PROCESS;
END;
Podobnie można uzyskać przebieg sygnałów wejściowych i wyjściowych komponentu. W przypadku symulacji komponentu, który zawiera w sobie inne komponenty, to w trakcie symulacji można je również oglądać (czyli wszystkie występujące sygnały łącznie z sygnałami o znaczeniu lokalnym dla komponentu).
Przykładowy zbiór zawierający wymuszenia symulacyjne dla całego projektu wygląda następująco:
[cnt10_tb.vhd]
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY cnt10_tb_vhd IS
END cnt10_tb_vhd;
ARCHITECTURE behavior OF cnt10_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT cnt10
PORT(
Clk : IN std_logic ;
Reset : IN std_logic ;
A_SegmA : out std_logic ;
A_SegmB : out std_logic ;
A_SegmC : out std_logic ;
A_SegmD : out std_logic ;
A_SegmE : out std_logic ;
A_SegmF : out std_logic ;
A_SegmG : out std_logic ;
B_SegmA : out std_logic ;
B_SegmB : out std_logic ;
B_SegmC : out std_logic ;
B_SegmD : out std_logic ;
B_SegmE : out std_logic ;
B_SegmF : out std_logic ;
B_SegmG : out std_logic ) ;
END COMPONENT;
--Inputs
SIGNAL Clk : std_logic := '0';
SIGNAL Reset : std_logic := '1';
--Outputs
SIGNAL A_SegmA : std_logic ;
SIGNAL A_SegmB : std_logic ;
SIGNAL A_SegmC : std_logic ;
SIGNAL A_SegmD : std_logic ;
SIGNAL A_SegmE : std_logic ;
SIGNAL A_SegmF : std_logic ;
SIGNAL A_SegmG : std_logic ;
SIGNAL B_SegmA : std_logic ;
SIGNAL B_SegmB : std_logic ;
SIGNAL B_SegmC : std_logic ;
SIGNAL B_SegmD : std_logic ;
SIGNAL B_SegmE : std_logic ;
SIGNAL B_SegmF : std_logic ;
SIGNAL B_SegmG : std_logic ;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: cnt10 PORT MAP(
Clk => Clk,
Reset => Reset,
A_SegmA => A_SegmA,
A_SegmB => A_SegmB,
A_SegmC => A_SegmC,
A_SegmD => A_SegmD,
A_SegmE => A_SegmE,
A_SegmF => A_SegmF,
A_SegmG => A_SegmG,
B_SegmA => B_SegmA,
B_SegmB => B_SegmB,
B_SegmC => B_SegmC,
B_SegmD => B_SegmD,
B_SegmE => B_SegmE,
B_SegmF => B_SegmF,
B_SegmG => B_SegmG
);
tb : PROCESS
BEGIN
Reset <= '0' ;
wait for 100 ns ;
Reset <= '1' ;
wait for 100 ns ;
Tu zostaje wygenerowany impuls zerujący i w dalszej kolejności
for Inx in 0 to 64 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
kilkadziesiąt impulsów zegarowych,
Reset <= '0' ;
Clk <= '1' ;
wait for 100 ns ;
for Inx in 0 to 5 loop
Clk <= '0' ;
wait for 100 ns ;
Clk <= '1' ;
wait for 100 ns ;
end loop ;
Reset <= '1' ;
Clk <= '0' ;
ponownie impuls zerowania trwający kilka taktów zegarowych,
wait for 100 ns ;
for Inx in 0 to 120 loop
Clk <= '1' ;
wait for 100 ns ;
Clk <= '0' ;
wait for 100 ns ;
end loop ;
oraz pewna liczba impulsów podlegających ponownemu zliczeniu.
wait; -- will wait forever
END PROCESS;
END;
Po wykonaniu wszystkich wymaganych czynności i operacji, można uzyskać przebieg sygnałów cyfrowych w całym projekcie. Początkowo w oknie symulatora są zaprezentowane sygnały wejścia i wyjścia komponentu. Zgodnie z wymuszeniami zawartymi w zbiorze, widać reakcję układu na sygnał zerowania. Przy przeglądaniu przebiegów istnieje możliwość posługiwania się znacznikami, którymi są dostępne poprzez odpowiednie przyciski. Rozwijając listę dostępnych sygnałów, w okienku symulatora (przy “Window” i “Dock”) można zaznaczyć dowolne sygnały (nawet w komponentach zagnieżdżonych) i metodą “przenieś i upuść” w obszarze nazw sygnałów dołączyć je do istniejącej już listy prezentowanych sygnałów.
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Łączenie kilku układów PLD do
wspólnego złącza programującego
https://www.youtube.com/watch?v=eDrgr43_vX4
Kilka układów PLD występujących w obrębie jednego urządzenia (jednej płytki PCB) może być podłączonych do jednego złącza programującego. Do programowania układów PLD używa się specjalnego interfejsu JTAG, który zawiera następujące sygnały:
Wybierając pierwszy układ: oraz drugi układ: Całość w akcji wygląda następująco (po ustawieniu stopnia podziału dla pierwszego układu PLD): drugi w oparciu o otrzymany sygnał taktujący “pogania” jeden segment na wyświetlaczu LED. Projekt składa się z dwóch części: PLD_A dla układu XCR3064 oraz PLD_B dla układu XC9536. Teksty poszczególnych plików źródłowych wchodzących w projekt są następujące:
PLD_A (dla XCR3064) :
Zbiór PLD_A.VHD:
Zbiór PLD_A.UCF:PLD_B (dla XC9536XL) :
Zbiór PLD_B.VHD:Zbiór PLD_B.UCF:
wspólnego złącza programującego
https://www.youtube.com/watch?v=eDrgr43_vX4
Kilka układów PLD występujących w obrębie jednego urządzenia (jednej płytki PCB) może być podłączonych do jednego złącza programującego. Do programowania układów PLD używa się specjalnego interfejsu JTAG, który zawiera następujące sygnały:
- TCK – sygnał taktujący,
- TMS – sygnał trybu,
- TDI – sygnał danych wejściowych,
- TDO – sygnał danych wyjściowych.
Wybierając pierwszy układ: oraz drugi układ: Całość w akcji wygląda następująco (po ustawieniu stopnia podziału dla pierwszego układu PLD): drugi w oparciu o otrzymany sygnał taktujący “pogania” jeden segment na wyświetlaczu LED. Projekt składa się z dwóch części: PLD_A dla układu XCR3064 oraz PLD_B dla układu XC9536. Teksty poszczególnych plików źródłowych wchodzących w projekt są następujące:
PLD_A (dla XCR3064) :
Zbiór PLD_A.VHD:
Kod: Zaznacz cały
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity pld_a is
Port ( ClkIn : in STD_LOGIC ;
Reset : in STD_LOGIC ;
Sel : in STD_LOGIC_VECTOR ( 3 downto 0 ) ;
ClkOut : out STD_LOGIC ) ;
end pld_a;
architecture Behavioral of pld_a is
signal Counter : std_logic_vector ( 19 downto 0 ) ;
begin
process ( ClkIn , Reset )
begin
if Reset = '0' then
Counter <= "00000000000000000000" ;
else
if ClkIn'event and ClkIn = '1' then
Counter <= Counter + "00000000000000000001" ;
end if ;
end if ;
end process ;
with Sel select
ClkOut <= Counter ( 19 ) when "1110" ,
Counter ( 18 ) when "1101" ,
Counter ( 17 ) when "1011" ,
Counter ( 14 ) when "0111" ,
'0' when others ;
end Behavioral ;
Kod: Zaznacz cały
NET "ClkIn" LOC = "P2" ;
NET "ClkOut" LOC = "P21" ;
NET "Reset" LOC = "P12" | PULLUP ;
NET "Sel<0>" LOC = "P16" | PULLUP ;
NET "Sel<1>" LOC = "P17" | PULLUP ;
NET "Sel<2>" LOC = "P18" | PULLUP ;
NET "Sel<3>" LOC = "P19" | PULLUP ;
Zbiór PLD_B.VHD:
Kod: Zaznacz cały
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity pld_b is
Port ( ClkIn : in STD_LOGIC ;
Reset : in STD_LOGIC ;
SegA : out STD_LOGIC ;
SegB : out STD_LOGIC ;
SegC : out STD_LOGIC ;
SegD : out STD_LOGIC ;
SegE : out STD_LOGIC ;
SegF : out STD_LOGIC ;
SegG : out STD_LOGIC ) ;
end pld_b ;
architecture Behavioral of pld_b is
signal Counter : std_logic_vector ( 2 downto 0 ) ;
signal Displ : std_logic_vector ( 6 downto 0 ) ;
begin
SegA <= Displ ( 0 ) ;
SegB <= Displ ( 1 ) ;
SegC <= Displ ( 2 ) ;
SegD <= Displ ( 3 ) ;
SegE <= Displ ( 4 ) ;
SegF <= Displ ( 5 ) ;
SegG <= Displ ( 6 ) ;
process ( ClkIn , Reset )
begin
if Reset = '0' then
Counter <= "000" ;
else
if ClkIn'event and ClkIn = '1' then
Counter <= Counter + "001" ;
end if ;
end if ;
end process ;
with Counter select
Displ <= "1111111" when "001" ,
"1111110" when "010" ,
"1111101" when "011" ,
"1111011" when "100" ,
"1110111" when "101" ,
"1101111" when "110" ,
"1011111" when "111" ,
"0000000" when others ;
end Behavioral ;
Kod: Zaznacz cały
NET "ClkIn" LOC = "P5" ;
NET "Reset" LOC = "P1" ;
NET "SegA" LOC = "P24" ;
NET "SegB" LOC = "P25" ;
NET "SegC" LOC = "P33" ;
NET "SegD" LOC = "P34" ;
NET "SegE" LOC = "P35" ;
NET "SegF" LOC = "P26" ;
NET "SegG" LOC = "P27" ;
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Prosty programator układów
PLD firmy Xilinx
Księżniczka z dalekiej północyhttps://www.youtube.com/watch?v=sMtG4fkpsY4
Każdy projekt z użyciem układów PLD w pewnym momencie musi zostać “zweryfikowany przez rzeczywistość”. W tym celu koniecznością jest przeniesienie wygenerowanego przez oprogramowanie “ISE WebPACK” kodu do fizycznego układu. Do programowania (umieszczenia kodu w pamięci konfiguracyjnej układy PLD) używany jest program iMPACT, który steruje poprzez złącze drukarkowe prostym interfejsem pośredniczącym w operacji programowania. Schemat interfejsu przedstawia następujący rysunek: Odpowiadająca schematowi płytka drukowana pokazane jest na poniższych rysunkach:
PLD firmy Xilinx
Księżniczka z dalekiej północyhttps://www.youtube.com/watch?v=sMtG4fkpsY4
Każdy projekt z użyciem układów PLD w pewnym momencie musi zostać “zweryfikowany przez rzeczywistość”. W tym celu koniecznością jest przeniesienie wygenerowanego przez oprogramowanie “ISE WebPACK” kodu do fizycznego układu. Do programowania (umieszczenia kodu w pamięci konfiguracyjnej układy PLD) używany jest program iMPACT, który steruje poprzez złącze drukarkowe prostym interfejsem pośredniczącym w operacji programowania. Schemat interfejsu przedstawia następujący rysunek: Odpowiadająca schematowi płytka drukowana pokazane jest na poniższych rysunkach:
- strona TOP:
- strona BOTTOM:
- strona TOP:
- strona BOTTOM:
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Re: [WEBPACK] Narzędzia do obróbki układów programowalnych
Ciąg dalszy w aspektach sprzętowych: TUTAJ
Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse
Kto jest online
Użytkownicy przeglądający to forum: Obecnie na forum nie ma żadnego zarejestrowanego użytkownika i 1 gość