Tutorial HDL @ Artix-7

Przykładowy projekt

Niniejszy tutorial pokazuje na wybranym przykładzie etapy postępowania, konieczne do wykonania projektu układu cyfrowego, opisanego za pomocą języka opisu sprzętu. Projekt zostanie praktycznie uruchomiony na platformie sprzętowej, wyposażonej w programowalny układ cyfrowy FPGA i konieczne zasoby wejścia / wyjścia. Tutorial prowadzi począwszy od edycji projektu, poprzez jego weryfikację, syntezę logiczną i implementację, a skończywszy na zaprogramowaniu układu FPGA.

Jako temat wyjściowy posłuży projekt dekodera kodu wyświetlacza siedmiosegmentowego. Konstrukcja pojedynczego znaku wyświetlacza oparta jest na siedmiu (a właściwie ośmiu, uwzględnaijąc kropkę dziesiętną  DP - Decimal Point) diodach elektroluminescencyjnych (LED), które emitują światło kiedy przepływa przez nie prąd:

Szeregowo włączony rezystor ogranicza prąd płynący przez diodę, aby zapewnić właściwe warunki jej pracy. Praktyczna realizacja powyższego obwodu może wyglądać np. tak:

Każdy segment wyświetlacza to odrębna dioda LED. Ułożone są one względem siebie tak, aby można było za ich pomocą wyświetlić przybliżone kształty znaków pisma (tu: cyfr arabskich). W praktyce zwykle elektrody jednego rodzaju (np. anody) są ze sobą połączone już w obudowie wyświetlacza, tworząc wtedy tzw. wyświetlacz ze wspólną anodą:

Wyświetlenie znaku polega tu więc na podaniu wysokiego poziomu napięcia na wspólną anodę, oraz niskiego poziomu napięcia na katody odpowiadające pożądanym do zaświecenia segmentom:

Z powodu zastosowania w obwodach anod kluczów tranzystorowych, które odwracają polaryzację, włączanie całego znaku odbywa się tutaj także niskim poziomem napięcia:

Aby świecąca kombinacja kilku segmentów ułożyła się w rozpoznawalny znak (tutaj: w cyfrę arabską), należy zakodowaną binarnie cyfrę dziesiętną (BCD - Binary Coded Decimal) przekodować na kod wyświetlacza:

Funkcję tę będzie pełnił zaprojektowany przez nas dekoder, który interpretuje informację na 4-bitowym wejściu (Digit) i zamienia ją na kombinację siedmiu bitów sterujących poszczególnymi segmentami (diodami LED) wyświetlacza (SegLED). Reguły transkodowania powinny być zgodne z poniższą tabelą, w której użyto tzw. "logiki prostej" (1 - segment świeci, 0 - segment nie świeci):

Ponieważ na docelowej dla niniejszego tutorialu platformie uruchomieniowej (płytka Digilent Nexys 4) zastosowano wyświetlacze ze wspólną anodą, skutkuje to odwróceniem poziomów napięciowych dla sterowania poszczególnych segmentów (tzw. "logika odwrotna"), a co za tym idzie - koniecznością zanegowania wartości logicznych na wyjściach dekodera (0 - segment świeci, 1 - segment nie świeci). Zostanie to zrealizowane w kodzie HDL za pomocą jednej operacji.

Ponadto na płytce umieszczono aż osiem wyświetlaczy siedmiosegmentowych, połączonych w jeden moduł sterowany multipleksowo. Jego szczególne właściwości będą jednak wykorzystywane dopiero w ostatnich zadaniach niniejszego tutorialu.

Rozpakowanie i otwarcie projektu

Używane tu oprogramowanie ActiveHDL jest rozbudowanym narzędziem, służącym do projektowania i weryfikacji układów cyfrowych. W ramach niniejszego tutoriala wykorzystywany będzie tylko edytor tekstowy HDL oraz symulator. Środowisko ActiveHDL posłuży także do wywoływania oprogramowania (do syntezy, implementacji, konfiguracji itp.) związanego z dalszą obróbką projektu dla wybranego typu układu programowalnego.

Aby poprawnie otworzyć wyjściową postać projektu należy wykonać kolejno następujące czynności:

• • zamknąć wszystkie otwarte kopie ActiveHDL

  • w folderze C:\My_Designs skasować dotychczasowy folder projektu seg7

• • pobrać aktualne archiwum seg7*.zip z niniejszej strony (na samym jej dole) i rozpakować je do folderu C:\My_Designs

  • UWAGA! Po prawidłowym rozpakowaniu ścieżka projektu powinna wyglądać tak: C:\My_Designs\seg7

  • wejść do folderu rozpakowanego projektu i otworzyć główny plik projektu:

• • UWAGA! Nie otwierać projektu bezpośrednio w archiwum !!

  • po otworzeniu projektu, w oknie Design Browser, na fiszce Files powinna być widoczna struktura plików projektu:

• • otworzyć plik projektu w języku opisu sprzętu VHDL - seg7.vhd

Projektowanie układów cyfrowych za pomocą języków opisu sprzętu

Projekt systemu cyfrowego można wprowadzać przy pomocy edytora graficznego, umieszczając na schemacie elementy i łącząc je, dokonawszy wcześniej syntezy funkcji logicznych. O ile takie podejście jest akceptowalne dla bardzo prostych projektów, to jednak stopień złożoności projektów współczesnych (kilkaset tysięcy...kilka milionów odpowiedników bramek logicznych) nie pozwala już na stosowanie tak niewydajnych narzędzi. Z pomocą przychodzą tu projektantowi narzędzia do automatycznej syntezy (czyli generowania struktury) układów cyfrowych. Edycja projektu (tj. opis jego działania) odbywa się tu na wyższym poziomie abstrakcji za pomocą języków opracowanych specjalnie do opisu działania układów cyfrowych (np.: VHDL, Verilog, języki HLS itp.)

W otworzonym pliku projektu dekodera wyświetlacza w języku VHDL odnaleźć można dwie podstawowe jednostki projektowe: entity i architecture. Pierwsza z nich opisuje tylko interfejs projektowanego modułu, a więc wszystkie wejścia i wyjścia, ich szerokość, typ i ew. inne parametry. Druga z jednostek projektowych opisuje natomiast tylko sposób działania projektowanego modułu, odnosząc się do pierwszej.

W jednostce entity przykładowego projektu zadeklarowane są więc następujące sygnały:

• • Digit : 4-bitowa magistrala wejściowa, wprowadzająca cyfrę BCD,

  • SegLED : 7-bitowa magistrala wyjściowa, sterująca katodami poszczególnych segmentów wyświetlacza,

  • Position : 8-bitowa magistrala wyjściowa, służąca do włączania poszczególnych wyświetlaczy (znaków) poprzez wysterowanie połączonych w obrębie jednego znaku (cyfry) anod diod LED,

  • DecPoint : 1-bitowe wyjście, sterujące katodami diod LED punktów dziesiętnych.

W jednostce architecture przykładowego projektu, po deklaracji pomocniczej, wewnętrznej, 7-bitowej magistrali Segment, opisano zachowanie się poszczególnych sygnałów wyjściowych:

• • konstrukcja with Digit select... przypisuje do magistrali Segment kombinacje bitów, powodujące włączenie lub wyłączenie odpowiednich segmentów wyświetlacza w zależności od cyfry podanej na wejście Digit. Należy zauważyć, że specyfikacja stanów odbywa się tu w logice prostej (1 - segment świeci, 0 - segment nie świeci).

  • klauzula SegLED <= not Segment; odwraca poziomy logiczne dla całej magistrali, aby dostosować je do wymagań fizycznych (wyświetlacz ze wspólną katodą: 0 na katodzie - segment świeci, 1 na katodzie - segment nie świeci)

  • i dodatkowo:

  • klauzula Position <= "11111110"; powoduje włączenie najmłodszej (skrajnej prawej) pozycji i wyłączenie pozostałych siedmiu pozycji modułu,

  • klauzula DecPoint <= '1'; powoduje wyłączenie wszystkich punktów dziesiętnych.

Należy tu zauważyć, że zasadnicza, najbardziej czasochłonna do zaprojektowania część architektury, czyli zbiór siedmiu funkcji logicznych, sterujących poszczególnymi segmentami w zależności od wartości cyfry podanej na wejście, w ogóle nie został przez projektanta zsyntezowany (jego struktura jest nieznana na etapie specyfikacji projektu) - tę część pracy wykona bowiem automatyczne narzędzie do syntezy, odciążając tym projektanta od żmudnej syntezy układu "na piechotę". Projektant ograniczył się tu jedynie do wyspecyfikowania zamierzonego efektu działania (podania de facto tablicy prawdy dla funkcji logicznych, nie wnikając w szczegóły ich implementacji).

Kompilacja i symulacja projektu

Przy aktywnym oknie pliku projektu seg7.vhd (kursor w jego obrębie) dokonujemy jego kompilacji poprzez naciśnięcie na klawiaturze przycisku funkcyjnego F11. Kompilacja nie powoduje jeszcze wygenerowania struktury układu, realizującej opisane działanie, ale jedynie buduje w pamięci komputera model symulacyjny, pozwalający zweryfikować poprawność kodu wprowadzonego przez projektanta. Po poprawnej kompilacji w oknie konsoli programu (zwykle w dolnej części ekranu) powinien się pojawić raport:

# Compile success 0 Errors 0 Warnings  Analysis time :  31.0 [ms]

Teraz można już przejść do weryfikacji projektu. W tym celu należy:

• • z menu Simulation wybrać opcję Initialize Simulation,

  • w oknie Design Browser, na fiszce Files otworzyć plik seg7.awc, pozwalający na wyświetlanie przebiegów czasowych symulacji,

  • w oknie Design Browser, na fiszce Files uruchomić (menu kontekstowe | Execute) makro zadanie1&2.do, dodające istotne sygnały i wcześniej przygotowane wymuszenia do okna wyświetlania przebiegów czasowych symulacji; pozostałe sygnały wyjściowe uznano za trywialne (stałe poziomy), więc nie będą tu poddawane symulacji,

    • ponieważ każdy z dodanych sygnałów jest w istocie magistralą, składającą się z wielu linii, należy go więc rozwinąć (mały znak + na lewo od nazwy każdego z sygnałów magistralnych), aby móc przeanalizować poszczególne bity wchodzące w jego skład,

    • do wejściowego sygnału danych Digit przypisano sekwencyjne wymuszenie typu Binary Counter; dzięki niemu podczas symulacji na wejście dekodera będą sekwencyjnie co 100 ns podawane kombinacje czterech bitów, odpowiadające wartościom kolejno od 0 do F w kodzie szesnastkowym,

  • kilkunastokrotnie nacisnąć na klawiaturze przycisk funkcyjny F5 (Run For)

  • podczas symulacji można przyciskami Ctrl+ i Ctrl- na klawiaturze numerycznej dostosowywać powiększenie w poziomie (tzw. podstawę czasu) tak, aby maksymalnie komfortowo móc zweryfikować wyniki symulacji.

Każdorazowe naciśnięcie przycisku F5 powoduje wykonanie symulacji dla kolejnego 100ns (umownie) odcinka czasu. Ponieważ czas ten jest równy okresowi wymuszanych zmian na wejściu dekodera, tak więc po każdym naciśnięciu F5 otrzymuje się kolejną liczbę dla dekodera i kolejną kombinację włączonych i wyłączonych segmentów wyświetlacza LED, wygenerowanych na tej podstawie przez dekoder. Należy zweryfikować poprawność pracy dekodera dla wszystkich 16 kombinacji.

Ostateczny wynik symulacji powinien wyglądać jak poniżej. Na koniec należy zatrzymać tryb symulacji, wybierając z menu Simulation opcję End Simulation.

Synteza i implementacja projektu

 Dalsza obróbka projektu będzie wykonywana przez zewnętrzne oprogramowanie (do syntezy, implementacji, programowania itp.), dostarczone przez producenta wybranego typu układu programowalnego (tu: Xilinx). Programy te są jednak zintegrowane ze środowiskiem ActiveHDL, a współpraca z nimi będzie się odbywać za pośrednictwem graficznej konsoli Design Flow (fiszka Design Flow w głównym oknie programu).

Pierwszym krokiem jest wykonanie syntezy opracowanego i zweryfikowanego projektu. Podczas tego procesu przygotowany w języku HDL opis działania układu jest za pomocą złożonych algorytmów zamieniany na model struktury układu, który będzie realizował zaprojektowaną funkcjonalność. Utworzony w wyniku syntezy model co prawda nadal istnieje tylko w zasobach komputera, na którym jest opracowywany, ale jest on już modelem strukturalnym, zawierającym elementy logiczne (bramki, przerzutniki i inne funktory) oraz opisującym połączenia między nimi.

Aby uruchomić syntezę należy na konsoli Design Flow nacisnąć przycisk synthesis. Otworzone zostanie okno logu, w którym pojawiały się będą bieżące raporty z przebiegu procesu syntezy logicznej. Po krótkim czasie synteza powinna zakończyć się sukcesem (poniżej). Okno logu należy wtedy zamknąć przyciskiem Close na dole.

UWAGA! Nie zamykać okna dopóki trwa proces syntezy - wtedy przycisk ma funkcję przerwania procesu (Abort).

Drugim krokiem obróbki projektu jest wykonanie implementacji zsyntezowanego już projektu. Podczas tego procesu otrzymany po syntezie model struktury układu zostaje dopasowany do zasobów konkretnego, wybranego do zaprogramowania układu FPGA. W procesie tym dokonywane jest rozmieszczenie zawartej w modelu logiki stosownie do zasobów docelowego układu oraz rozplanowywane są połączenia między tymi zasobami (dlatego w literaturze proces ten nazywany jest także Place & Route). Na tym etapie poszczególnym sygnałom projektu zostają też przyporządkowane - zgodnie z życzeniami projektanta - konkretne wyprowadzenia docelowego układu programowalnego. Należy tu podkreślić, że efektem działania procesu implementacji jest nadal istniejący tylko w zasobach komputera model struktury układu (tym razem z uwzględnieniem realiów fizycznych), ale oprócz tego uzyskiwany jest tu już plik z danymi, służącymi bezpośrednio do zaprogramowania wybranego układu FPGA.

Aby uruchomić implementację należy na konsoli Design Flow nacisnąć przycisk implementation. Otworzone zostanie okno logu, w którym pojawiały się będą bieżące raporty z przebiegu procesu implementacji. Po krótkim czasie implementacja powinna zakończyć się sukcesem (poniżej, ostrzeżenia są dopuszczalne). Okno logu należy wtedy zamknąć przyciskiem Close na dole.

UWAGA! Nie zamykać okna dopóki trwa proces implementacji - wtedy przycisk ma funkcję przerwania procesu (Abort).

Programowanie i testowanie układu

 Układ będzie uruchamiany na platformie uruchomieniowej Digilent Nexys 4 DDR (Nexys A7).

Podłączyć płytkę Nexys 4 do komputera przy pomocy kabla micro USB. W tym celu wykorzystać złącze micro USB ulokowane na płytce w pobliżu włącznika zasilania (lewy górny róg). Następnie włączyć zasilanie płytki.

Aby zaprogramować układ, należy z pulpitu Windows uruchomić program do konfiguracji układu programowalnego Vivado Lab 2019.1 (względnie całe narzędzie Vivado 2019.1). Po uruchomieniu środowiska Vivado:

• z menu Quick Start wybrać Open Hardware Manager 

• połączyć się z układem FPGA na platformie Nexys 4 (Open target | Auto Connect):

• wybrać programowanie układu (Program device):

• wskazać plik seg7.bit z danymi konfiguracyjnymi i uruchomić programowanie:

Po załadowaniu danych konfiguracyjnych do układu programowalnego powinien zostać wyświetlony komunikat o powodzeniu...

... a wyświetlacz na płytce powinien zaświecić.

Teraz należy przetestować działanie dekodera, wymuszając przy pomocy czterech połączonych z wejściami dekodera przełączników (zaznaczonych na rysunku) kolejno wszystkie możliwe kombinacje i obserwując zachowanie się wyświetlacza LED.

Zadania samodzielne

UWAGA!

Każde z poniższych zadań wymaga - oprócz modyfikacji kodu - jego kompilacji (dla zapisania pliku i ew. wykrycia błędów składniowych), a następnie syntezy i implementacji, na końcu zaś - ponownego zaprogramowania układu FPGA.

UWAGA!

Aby uniknąć konieczności ustawiania konfiguratora Hardware Manager dla każdego poniższego zadania, nie należy go zamykać po pierwszym jego wykorzystaniu, a jedynie ew. zminimalizować. Każdorazowo po stworzeniu w procesie implementacji nowego pliku konfiguracyjnego seg7.bit, konfigurator powinien tę zmianę wykryć, w wyniku czego kolejne programowanie układu FPGA będzie wykonane już nową zawartością.

Zadanie 1 (dla spróbowania własnych sił)

Zaprojektowany dotychczas dekoder cyfr BCD posiada pewną ułomność. Dla cyfr 6 i 9 kombinacje sterujące wyświetlaczem nie powodują włączenia niektórych segmentów (odpowiednio segmentu A i segmentu D). Należy dokonać odpowiednich zmian w kodzie VHDL, skompilować go, przeprowadzić symulację, syntezę, implementację, zaprogramować układ i przetestować, czy zmiany zostały skutecznie wprowadzone. W tym celu można posłużyć się zamieszczoną na początku tutorialu tabelką kodów.

Zadanie 2 (dla zaspokojenia rosnącego apetytu)

Po wprowadzeniu powyższych zmian możliwe jest już odróżnienie cyfry 6 od litery b. Tak poprawiony układ należy teraz rozbudować do dekodera cyfr HEX (szesnastkowych). Ponownie należy dokonać odpowiednich zmian w kodzie VHDL, przeprowadzić symulację, syntezę, implementację, zaprogramować układ i przetestować, czy zmiany zostały skutecznie wprowadzone. Po prawidłowym wykonaniu tego zadania na jednej pozycji wyświetlacza - w zależności od kombinacji na wejściu - powinny się pokazywać cyfry szesnastkowe 0..9 i A..F (dla uniknięcia niejednoznaczności cyfry szesnastkowe b oraz d należy zaprojektować jako małe litery alfabetu, dla odróżnienia ich od cyfr dziesiętnych 8 i 0).

UWAGA! Linia kodu zawierająca klauzulę when others powinna pozostać jako ostatnia linia selektywnego przypisania współbieżnego, które opisuje cały dekoder. Dodatkowe linie kodu w tym zadaniu należy wprowadzać POWYŻEJ tej linii.

Zadanie 3 (dla zaawansowanych)

Po wprowadzeniu powyższych zmian można uruchomić drugą pozycję wyświetlacza. W tym celu potrzebna będzie kolejna 4-bitowa magistrala wejściowa, wprowadzająca cyfrę BCD oraz skalarny sygnał wejściowy, wybierający do wyświetlania w danym momencie jedną z dwu cyfr (czyli do tzw. multipleksowania). W tym celu należy dokonać następujących zmian w kodzie VHDL:

• • w sekcji entity:

    • nazwę dotychczasowej magistrali wejściowej dla pierwszej cyfry zmienić z Digit na Digit0

    • pod deklarację portu magistrali dla cyfry pierwszej dodać deklarację dla drugiej cyfry:

    • Digit1 : in STD_LOGIC_VECTOR(3 downto 0);

    • pod powyższymi dodać deklarację skalarnego portu Sel sterującego wyświetlaniem jednej z dwóch cyfr:

    • Sel : in STD_LOGIC;

  • w sekcji architecture:

    • pod deklaracją wewnętrznej magistrali Segment wprowadzić deklarację wewnętrznej magistrali pomocniczej, która będzie stanowiła wejście dekodera 7-segmentowego:

    • signal Digit: STD_LOGIC_VECTOR(3 downto 0);

    • a po słowie kluczowym begin:

      • dodać współbieżne przypisanie warunkowe, które spowoduje skierowanie na wejście dekodera cyfry BCD z jednego lub drugiego wejścia, w zależności od stanu sygnału Sel:
        Digit <= Digit1 when Sel = '1' else Digit0;

      • analogicznie, dla sterowania włączeniem całej jednej albo drugiej cyfry, klauzulę:
        Position <= "11111110";  -- disable all positions but the rightmost
        zastąpić przez:
        Position <= "11111101" when Sel = '1' else "11111110";  -- control two rightmost positions

Następnie wprowadzone zmiany należy zweryfikować w sposób analogiczny jak w poprzednich punktach. z tym, że w odpowiednim momencie:

• • w oknie Design Browser, na fiszce Files uruchomić makro zadanie3.do (menu kontekstowe | Execute), w którym:

    • do wejściowych sygnałów danych Digit0 i Digit1 przypisano sekwencyjne wymuszenia typu Binary Counter (w kolumnie Stimulator widoczne jako Formula); dzięki którym podczas symulacji na wejścia ukłądu będą sekwencyjnie co 100 ns podawane kombinacje czterech bitów, odpowiadające wartościom kolejno od 0 do F dla Digit0 oraz od F do 0 dla Digit1 w w kodzie szesnastkowym,

    • do sygnału sterującego Sel przypisano wymuszenia typu Formula; dzięki któremu w chwili 600 ns zmieni się wybrane do wyświetlania wejście (z Digit0 na Digit1).

Przesymulować układ sprawdzając działanie selektora. Na koniec zatrzymać tryb symulacji, wybierając z menu Simulation opcję End Simulation.

Dla fizycznego wprowadzenia drugiej cyfry do układu wykorzystane zostaną kolejne cztery przełączniki, zaś do wyboru do wyświetlania w danym momencie jednej z dwu cyfr - przycisk BTNC (centralny). W tym celu należy zmodyfikować plik seg7.xdc, w którym znajduje się specyfikacja przypisania sygnałów występujących w projekcie do konkretnych wyprowadzeń układu FPGA, a co za tym idzie - do konkretnych zasobów sprzętowych płytki Nexys 4 (wyświetlacz, przełączniki, przyciski itp.) W tym celu w panelu Design Browser, na fiszce Files otworzyć plik seg7.xdc, a w nim:

• • w sekcji "Tutorial, Zadanie 1 i 2 | SWITCHes" zamienić wszystkie cztery nazwy "Digit[x]" na "Digit0[x]", aby odpowiadały zmienionej nazwie sygnału w projekcie,

  • w sekcji "Zadanie 3" usunąć znak komentarza # sprzed wszystkich pięciu dyrektyw set_property...

Na koniec zapisać plik!

Następnie należy przeprowadzić syntezę i implementację oraz zaprogramować i przetestować układ. Po wstępnym sprawdzeniu prawidłowości działania przyciskać przez chwilę przycisk BTNC możliwie szybko raz po razie (ale z zachowaniem odpowiedniej delikatności !), obserwując narastające proporcjonalne do szybkości przełączeń złudzenie jednoczesnego widzenia obu znaków. Efekt ten jest spowodowany bezwładnością ludzkiego oka i jest podstawą działania wyświetlacza multipleksowanego.

Zadanie 4 (dla ekspertów)

Chcąc pozbyć się uciążliwej konieczności szybkiego przyciskania przycisku i niedoskonałości efektu multipleksowania (widzialne migotanie cyfr) należy zlecić to zadanie odpowiednio szybko działającemu automatowi. W tym celu wykorzystany zostanie dostępny na płytce Nexys 4 układ oscylatora o częstotliwości 100MHz.

Generowany przez niego sygnał zegarowy o okresie 10 ns jest jednak zdecydowanie zbyt szybki, aby układ wyświetlacza multipleksowanego mógł prawidłowo zadziałać (zobacz na innych wykładach: relacja między częstotliwością a wzmocnieniem tranzystora). Dlatego, aby spowolnić szybkość przełączeń przy wyświetlaniu obu znaków do pożądanego zakresu od ok. 0,25 do 4,0 ms, zostanie zbudowany licznik, zliczający okresy zegara i odpowiednio wolniej sterujący sygnałem Sel.

Aby osiągnąć zamierzony cel, należy dokonać następujących modyfikacji projektu:

• • w kodzie VHDL:

    • w sekcji entity:

      • w deklaracji portu wejściowego nazwę sygnału Sel zamienić na Clk

      • (zamiast zewnętrznego sygnału selektora wprowadzony zostanie do układu sygnał zegarowy)

    • w sekcji architecture:

      • pod dotychczasowymi deklaracjami dwu magistral wewnętrznych dodać deklarację wewnętrznego sygnału selektora:
        signal Sel: STD_LOGIC;

      • pomiędzy dotychczasowy kod a klauzulę końca architektury (end seg7;) wkleić poniższy kod:
        process (Clk)
          variable Counter: STD_LOGIC_VECTOR(17 downto 0) := (others => '0');
        begin
          if Clk'event and Clk = '1' then    -- detect Clk rising edge
            Counter := Counter + 1;          -- increase Counter
          end if;
          Sel <= Counter(17);                -- toggle Sel with ~1.3 msec period
        end process;

      • Kod ten zawiera opis 18-bitowego licznika Counter, zliczającego kolejne okresy (narastające zbocza) sygnału zegarowego. Pojemność licznika pozwala na zliczenie 218 = 262.144 okresów zegara, co trwać będzie ok. 2,6 ms. Przez połowę tego czasu sygnał wyboru Sel będzie przyjmował wartość 0, a przez pozostałą połowę - wartość 1.

    • aby umożliwić syntezę zapisów arytmetycznych użytych w opisie licznika (operacja +), na początku pliku, po sekcji nagłówka (zielone komentarze), po obecnych już klauzulach library / use należy dodać:

    • use IEEE.STD_LOGIC_UNSIGNED.all;

  • w pliku seg7.xdc:

    • w sekcji "Zadanie 3 | PUSHBUTTONs", przez wstawienie na początku linii znaku komentarza # zdezaktywować klauzulę:

    • #set_property .... [get_ports { Sel }];

  • w sekcji "Zadanie 4 | CLOCKs" usunąć znak komentarza # sprzed obu dyrektyw

Po tym zapisać oba pliki!

Dla tej zmiany w kodzie nie przewidziano weryfikacji, ponieważ konieczność symulacji tak wielu zdarzeń (zboczy zegara) znacznie wydłużyłaby czas opracowania i utrudniłaby obserwację rezultatów. Należy jedynie przeprowadzić kompilację pliku VHD dla sprawdzenia poprawności składniowej, a następnie wykonać syntezę i implementację projektu oraz zaprogramować i przetestować układ.

Zadanie 5 (dla maniaków)

Zaproponować i wprowadzić odpowiednie zmiany zarówno w kodzie projektu VHD, jak i w pliku XDC, tak aby w analogiczny do powyższego sposób uruchomić cztery cyfry wyświetlacza.

Projekt seg7.zip:     seg7v1_ahdl11v1_vivado2019v1.zip