[WEBPACK] Narzędzia do obróbki układów programowalnych

Tu jest miejsca na dyskusje nad innymi programami wspomagającymi prace elektronika przy projektowaniu pcb itp. ale również można tu wstawiać tematy związane z innymi programami typu CAD

Moderator: ZbeeGin

Regulamin forum
Temat należy poprzedzić nazwa programu ujętą w kwadratowe nawiasy np. [KiCAD]
Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

[WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » piątek 18 maja 2018, 21:44

Filozofia istnienia
webp-1_ilu00.jpg

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.
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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » piątek 18 maja 2018, 22:42

Narzędzia do konfigurowania
układów CPLD firmy Xilinx
webp-2_ilu00.jpg

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.
W oparciu o wymienione układy można budować urządzenia przetwarzające sygnały logiczne (cyfrowe). Do ich konfiguracji (czyli określenia realizowanej funkcji) używane jest oprogramowanie, które można bezpłatnie pobrać ze strony producenta (http://www.xilinx.com). Do pobrania z wymienionej strony jest program instalacyjny o nazwie “ISE WebPACK”. Pobranie tego pliku wymaga wcześniejszego zarejestrowania się na stronie Xilinx'a (to nie boli). Większym problemem jest samo pobranie wersji instalacyjnej (plik jest sporych rozmiarów). Ze względu na ciągłe rozwijanie się produktu (ISE WebPACK) co jakiś czas pojawiają się uaktualnienia. Poniższe przykłady zostały “wyprodukowane” przez wersję o symbolu “8i” chociaż są oferowane nowsze.
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.
Do określenia funkcji układu do dyspozycji jest kilka możliwości, jak narysowanie schematu układu logicznego, opisanie funkcji w odpowiednim języku lub można użyć specjalizowanego oprogramowania do realizacji określonych czynności (jak przykładowo program do opisu automatu synchronicznego w oparciu o grafy przejść). Program ISE WebPACK akceptuje opis w języku VHDL oraz w języku VERILOG. Oba języki udostępniają porównywalne możliwości. Istnieje możliwość realizacji projektów w sposób mieszany, czyli poszczególne fragmenty/zespoły cyfrowe mogą być opisane w różny sposób (schemat/opis w języku). Efektem finalnym całego procesu przetwarzania jest powstanie pliku do zaprogramowania docelowego układu. W przypadku układów CPLD jest to plik o rozszerzeniu .JED lub .BIT w przypadku układów FPGA. Samo zaprogramowanie (jako umieszczenie powstałego kodu w odpowiedniej pamięci) nie wymaga użycia specjalizowanych programatorów. Współczesne układy PLD są programowalne w układzie i wymagają nieskomplikowanych interfejsów do ich zaprogramowania. Najczęściej używane są programatory (zawierające bufory trójstanowe) dołączane do wyjścia drukarkowego w komputerze. Stopień ich komplikacji jest podobny przykładowo do programatorów szeregowych stosowanych do programowania mikrokontrolerów AVR.
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).
Poniżej zawarty jest przykładowy projekt 8-bitowego licznika wraz z obsługą dwucyfrowego 7-segmentowego wyświetlacza LCD, który zostanie uruchomiony w zestawie startowym dla układów CoolRunner. Do dyspozycji jest generator sygnału zegarowego o częstotliwości 32kHz (typowy generator stosowany w układach zegarowych), dwucyfrowy 7-segmentowy wyświetlacz LCD. W zestawie startowym do dyspozycji znajduje się układ CPLD z rodziny CoolRuner (XPLA3) o symbolu XCR3256XL.
webp-2_ilu01.jpg
Po uruchomieniu programu:
webp-2_ilu02.jpg
należy otworzyć istniejący lub utworzyć nowy projekt. Posługując się poniższym przykładem (po rozpakowaniu pliku archiwalnego) dostępny jest do otwarcia projekt licznika.
webp-2_ilu03.jpg
Po otwarciu projektu, pokazuje się lista plików źródłowych związanych z projektem. Prezentowany projekt składa się z kilku komponentów (wszystkie są napisane w języku VHDL). Dwuklikając na odpowiednią pozycję na liście możliwe jest otwarcie wskazanego pliku w oknie do edycji.
webp-2_ilu04.jpg
W okienku “Processes” wyszczególnione są wszystkie możliwe do wykonania procesy związane z wybranym (w okienku “Sources for”) plikiem źródłowym. Klikając na “+” w “Processes” można uszczegóławiać wybór procesu do wykonania.
webp-2_ilu05.jpg
Wybierając dwuklikiem proces “Generate Programming File” żądane jest wykonanie wszystkich niezbędnych czynności związanych z uzyskaniem finalnego efektu jakim jest wygenerowanie pliku konfigurującego dla układ PLD. W przypadku jakichkolwiek błędów
webp-2_ilu06.jpg
(tu wprowadzonych celowo do zaprezentowania zachowania się pakietu ISE), całość jest zatrzymana z odpowiednim komunikatem oraz procesy, które nie zostały zrealizowane są oznaczone odpowiednią ikonką. Po poprawieniu błędów (tu: usunięciu wiersza), powtórne wykonanie poleceń zostaje zakończone pomyślnie. Świadczą o tym odpowiednie ikonki przy procesach oraz prezentowany jest sumaryczny raport. Rozwijając w okienku “Processes” opcję “Generate Programming File
webp-2_ilu07.jpg
możliwe jest przejście do ostatniej fazy, jaką jest zaprogramowanie układu PLD. W tym celu należy rozwinąć „Generate Programming File” klikając na odpowiedni „+” i w dalszej kolejności wybrać „Configure Device iMPACT”. Zostanie uruchomiony program do programowania (konfiguracji) układu CPLD.
Poprawna reakcja na uruchomienie programu iMPACT jest następująca:
webp-2_ilu08.jpg
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),
webp-2_ilu09.jpg
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.
webp-2_ilu10.jpg
Zakończenie sygnalizowane jest komunikatem:
webp-2_ilu11.jpg
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.
webp-2_ilu12.jpg
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:
Counter.zip
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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » sobota 19 maja 2018, 22:52

Konfiguracja układów FPGA firmy Xilinx
(na przykładzie układu z rodziny SPARTAN II)

webp-3_ilu00.jpg

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
webp-3_ilu01.jpg
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.
webp-3_ilu02.jpg
Po wygenerowaniu odpowiednich plików (uruchomienie odpowiedniego procesu),
webp-3_ilu03.jpg
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”.
webp-3_ilu04.jpg
Po uruchomieniu programu istnieje możliwość dokładnego określenia czynności do wykonania.
webp-3_ilu05.jpg
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”
webp-3_ilu06.jpg
oraz “Next”.
W dalszej kolejności są określane szczegóły związane z realizowaną czynnością:
webp-3_ilu07.jpg
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 dalszej kolejności:
  • 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),
    webp-3_ilu08.jpg
  • dalej wybrać układ o symbolu “XC18V01”,
    webp-3_ilu09.jpg
  • tak określony układ wybrać poprzez przycisk “Add”,
    webp-3_ilu10.jpg
  • przejść do kolejnego etapu (przycisk “Next”),
    webp-3_ilu11.jpg
  • określić plik przeznaczony dla układu FPGA, który będzie przetworzony do formatu dla pamięci FLASH.
Wynikiem jest określenie środowiska, w którym zastosowany jest układ FPGA i pamięć FLASH.
webp-3_ilu12.jpg
Wybierając opcję “Generate File” utworzony zostaje właściwy plik.
webp-3_ilu13.jpg
Wybierając “Boundary Scan”, program iMPACT rozpozna łańcuch układów przyłączonych do interfejsu JTAG.
webp-3_ilu14.jpg
Klikając na symbol pamięci FLASH,
webp-3_ilu15.jpg
można przejść do operacji jej programowania.
webp-3_ilu16.jpg
Kończąc działanie programu iMPACT istnieje możliwość zapisania szczegółów w odpowiednim pliku konfiguracyjnym, tak, że ponowne uruchomienie tego programu nie będzie wymagało ich określania. W przypadku zmian, poprawek i ponownego wygenerowania plików konfiguracyjnych należy pamiętać, że produktem pakietu WEBPack jest plik strumienia bitowego (.BIT), który za każdym razem musi być przeformatowany w programie iMPACT.
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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » niedziela 20 maja 2018, 21:47

Symulacja działania
syntezowanych układów w strukturach PLD
webp-4_ilu00.jpg

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).
Treść poszczególnych plików jest następująca:
[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 ;
Jak widać, jest to komponent mający dwa sygnały wejściowe:
  • Clk – jako doprowadzenie zliczanych impulsów,
  • Reset – jak sygnał zerujący licznik jedności (Q1) oraz dziesiątek (Q10).
Pozostałe sygnały komponentu stanowią wyjście sygnałów do sterowania poszczególnymi segmentami wyświetlacza jedności (A_SegmA .. A_SegmG) oraz dziesątek (B_SegmA .. B_SegmG).
[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 ;
Ten komponent stanowi implementację jednocyfrowego licznika dekadowego.
[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 ;
Ten komponent realizuje zamianę czterobitowego kodu BCD na kod wymagany przez wyświetlacze siedmiosegmentowe.
webp-4_ilu01.jpg
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”:
webp-4_ilu02.jpg
w wyniku którego dostępne stają się procesy związane z symulacją.
webp-4_ilu03.jpg
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,
webp-4_ilu04.jpg
w którym w “File name” należy wpisać nazwę tworzonego zbioru, oraz zaznaczyć “VHDL Test Bench”.
webp-4_ilu05.jpg
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”).
webp-4_ilu06.jpg
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,
webp-4_ilu07.jpg
można go zmienić lub zażądać symulacji zgodnie ze zbiorem wymuszeń.
webp-4_ilu08.jpg
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.
webp-4_ilu09.jpg
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.
webp-4_ilu10.jpg
Powrót następuje po użyciu “Window” i “Dock”. Prezentowane przebiegi mogą być rozciągane w czasie.
webp-4_ilu11.jpg
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ę
webp-4_ilu12.jpg
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.
webp-4_ilu13.jpg
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.
webp-4_ilu14.jpg
Zgodnie z wymuszeniami zawartymi w zbiorze, widać reakcję układu na sygnał zerowania.
webp-4_ilu15.jpg
Przy przeglądaniu przebiegów istnieje możliwość posługiwania się znacznikami, którymi są dostępne poprzez odpowiednie przyciski.
webp-4_ilu16.jpg
Rozwijając listę dostępnych sygnałów, w okienku symulatora (przy “Window” i “Dock”)
webp-4_ilu17.jpg
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.
webp-4_ilu18.jpg
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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » środa 23 maja 2018, 00:37

Łączenie kilku układów PLD do
wspólnego złącza programującego

webp-5_ilu00.jpg

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.
Odpowiedni program sterujący procesem programowania poprzez prosty interfejs steruje wymienionymi sygnałami. Dane (do układu) są przesyłane w sposób szeregowy poprzez sygnał TDI oraz (z układu) mogą być odczytane poprzez sygnał TDO. Najprostszym rozwiązaniem pozwalającym przyłączyć kilka układów do jednego złącza programującego JTAG jest połączenie ich w sposób szeregowy. Wyjście sygnału TDO jednego układu jest doprowadzane do wejścia TDI kolejnego układu. Pozostałe sygnały TCK i TMS doprowadza się wszystkich układów w sposób równoległy. Prezentuje to ilustracja
webp-5_ilu01.png
Połączone układy należą do różnych rodzin (jeden jest z grupy CoolRunner, drugi z grupy XC9500XL). Do sprawdzenia tej koncepcji w naturze, zostało zbudowane następujące urządzenie. Składa się ono z dwóch układów połączonych w łańcuch jak na rysunku wyżej. Pierwszy układ (XCR3064) spełnia rolę podzielnika wejściowej częstotliwości (generuje sygnał taktujący pracą drugiego układu). Stopień podziału może być modyfikowany w niewielkim zakresie (poprzez ustawienie odpowiedniej kombinacji na DIP-switch przyłączonym do układu). Drugi układ (XC9536XL) jest 3-bitowym licznikiem zliczającym doprowadzone z pierwszego układu impulsy oraz w zależności od stanu licznika steruje świeceniem poszczególnych segmentów wyświetlacza (sześć stanów z włączaniem pojedynczych segmentów, jeden stan z wygaszonymi segmentami oraz jeden stan z włączonymi wszystkimi segmentami). Pomijając złącze programujące, schemat jest następujący:
webp-5_ilu02.png
Zbudowane urządzenie wygląda następująco:
webp-5_ilu03.jpg
Po wygenerowaniu docelowych zbiorów dla obu układów można przystąpić do ich zaprogramowania. Użyty program (iMPACT) sam zauważa szeregowe połączenie układów, co obrazuje w swoim okienku.
webp-5_ilu04.jpg
Po przyporządkowaniu każdemu układowi jego zbioru konfiguracyjnego, można przystąpić do programowania poszczególnych układów.
Wybierając pierwszy układ:
webp-5_ilu05.jpg
oraz drugi układ:
webp-5_ilu06.jpg
Całość w akcji wygląda następująco (po ustawieniu stopnia podziału dla pierwszego układu PLD):
webp-5_ilu07.jpg
drugi w oparciu o otrzymany sygnał taktujący “pogania” jeden segment na wyświetlaczu LED.
webp-5_ilu08.jpg
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 ;
Zbiór PLD_A.UCF:

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 ;
PLD_B (dla XC9536XL) :
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 ;
Zbiór PLD_B.UCF:

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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » czwartek 24 maja 2018, 20:23

Prosty programator układów
PLD firmy Xilinx

webp-6_ilu00.jpg

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:
webp-6_ilu01.png
Odpowiadająca schematowi płytka drukowana pokazane jest na poniższych rysunkach:
  • strona TOP:
    webp-6_ilu02.png
  • strona BOTTOM:
    webp-6_ilu03.png
Rozmieszczenie elementów prezentują poniższe rysunki:
  • strona TOP:
    webp-6_ilu04.png
  • strona BOTTOM:
    webp-6_ilu05.png
Przekładając powyższe rysunki na rzeczywiste urządzenie mamy:
webp-6_ilu06.jpg
webp-6_ilu07.jpg
Gotowy programator w akcji:
webp-6_ilu08.jpg
webp-6_ilu09.jpg
Programowanie układów PLD zostało sprawdzone na “firmowym zestawie badawczym”. Zadziałało bez żadnych problemó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

Awatar użytkownika
gaweł
Expert
Expert
Posty: 612
Rejestracja: wtorek 24 sty 2017, 22:05
Lokalizacja: Białystok

Re: [WEBPACK] Narzędzia do obróbki układów programowalnych

Postautor: gaweł » czwartek 07 cze 2018, 12:15

Ciąg dalszy w aspektach sprzętowych: TUTAJ

Prawdziwe słowa nie są przyjemne. Przyjemne słowa nie są prawdziwe.
Lao Tse


Wróć do „Inne”

Kto jest online

Użytkownicy przeglądający to forum: Obecnie na forum nie ma żadnego zarejestrowanego użytkownika i 2 gości