Tutorial HDL @ Spartan-6

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 przykład posłuży projekt dekodera kodu wyświetlacza siedmiosegmentowego. Konstrukcja pojedynczej cyfry wyświetlacza oparta jest na siedmiu 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. W praktyce zwykle elektrody jednego rodzaju (np. katody) są ze sobą połączone już w obudowie wyświetlacza, tworząc tzw. wyświetlacz ze wspólną katodą:

Włączenie całego wyświetlacza polega tu więc na podaniu niskiego poziomu napięcia na wspólną katodę, oraz wysokiego poziomu napięcia na anody odpowiadające pożądanym do zaświecenia segmentom. 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ą:

Na docelowej dla niniejszego tutorialu platformie uruchomieniowej (płytka Digilent Nexys3) zastosowano wyświetlacze ze wspólną anodą, co skutkuje odwróceniem poziomów sterowania (wysoki poziom napięcia na wspólną anodę, a niski poziom napięcia na katody poszczególnych segmentów). Jednak - z powodu zastosowania w obwodach anod odwracających polaryzację kluczów tranzystorowych - włączanie całego wyświetlacza (pozycji) odbywa się tutaj także niskim poziomem napięcia. Ponadto na płytce umieszczono aż cztery wyświetlacze siedmiosegmentowe, połączone w jeden moduł sterowany multipleksowo. Jego właściwości będą tu jednak w pełni wykorzystywane dopiero w ostatnich zadaniach.

Rozpakowanie i otwarcie projektu

UWAGA! Należy sprawdzić, czy zalogowano się w systemie Windows jako użytkownik student2 (hasło: studentdwa).

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, programowania 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 katalogu C:\My_Designs skasować dotychczasowy folder projektu seg7 oraz archiwum z projektem

• • pobrać aktualne archiwum seg7.zip z niniejszej strony (na samym dole, strzałka w dół po samej prawej stronie) i rozpakować je do katalogu C:\My_Designs

• • wejść do folderu rozpakowanego projektu i otworzyć plik projektu seg7.adf UWAGA! Nie otwierać projektu bezpośrednio w archiwum!! Kontakt z serwerem licencji może potrwać nawet kilkadziesiąt sekund.

  • zgodzić się (Next) na propozycję konfiguracji licencji (License Configuration)

• • 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 dla opisu zachowania 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.

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 : 4-bitowa magistrala wyjściowa, służąca do włączania poszczególnych wyświetlaczy (cyfr) poprzez wysterowanie połączonych anod diod LED w obrębie jednego wyświetlacza (cyfry),

  • DecPoint : 1-bitowe wyjście, sterujące katodą diody LED punktu dziesiętnego.

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 <= "1110"; powoduje włączenie najmłodszej pozycji i wyłączenie pozostałych 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 otwartym oknie pliku projektu seg7.vhd 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 : 0.6 [s]

Teraz można już przejść do weryfikacji projektu. W tym celu należy najpierw w oknie Design Browser, na fiszce Files otworzyć plik przebiegów czasowych symulacji waveform.awf. W pliku tym znajdują się tylko dwa najistotniejsze sygnały projektu: wejściowy Digit oraz wyjściowy SegLED. Pozostałe sygnały wyjściowe uznano za trywialne (stałe poziomy), więc nie będą tu poddawane symulacji. Ponieważ każdy z w/w sygnałów jest w istocie magistralą, składającą się z wielu linii, należy je więc rozwinąć (mały znak + na lewo od nazwy każdego z sygnałów magistralnych), aby móc analizować poszczególne bity wchodzące w jej skład.

Dla sygnału wejściowego przypisano już sekwencyjne wymuszenie Binary Counter (widoczne w kolumnie Stimulator). Dzięki niemu podczas symulacji na wejście dekodera będą sekwencyjnie podawane kombinacje czterech bitów, odpowiadające wartościom kolejno od 0 do 15 w NKB (Naturalnym Kodzie Binarnym).

Aby przesymulować układ należy:

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

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

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

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

Przed uruchomieniem implementacji należy upewnić się, że wykonane będą wszystkie etapy obróbki poza budową modelu czasowego (Timing). Poszczególne etapy można włączać / wyłączać na konsoli Design Flow przez kliknięcie myszką w odpowiednie ikonki tuż pod przyciskiem implementation. Prawidłowa konfiguracja narzędzi powinna wyglądać jak poniżej:

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

Podłączyć płytkę Nexys-3 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, nie prawy dolny!). Następnie włączyć zasilanie płytki.

Aby zaprogramować układ, należy z konsoli Design Browser uruchomić program do konfiguracji układu programowalnego: Analysis | iMPACT.

Następnie dokonać odpowiednich ustawień dla konfiguratora iMPACT wg reguł zawartych w niniejszym linku.

Z menu kontekstowego dla układu (prawy przycisk myszy) wybrać opcję Program. Po załadowaniu do układu programowalnego danych konfiguracyjnych 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 iMPACT 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 *.bit, konfigurator powinien tę zmianę wykryć i po rozpoczęciu programowania układu poprosić projektanta o zgodę na zmianę. W żadnym jednak wypadku nie doprowadzać do sytuacji, że jednocześnie otwarta jest więcej niż jedna instancja konfiguratora.

W razie podejrzeń, że automatyczne wykrycie zmiany zawartości pliku *.bit nie zaszło, można taką zmianę wymusić ręcznie. W tym celu w oknie Boundary Scan, dla zidentyfikowanego układu xc6slx16 / seg7.bit ...

...uruchomić menu kontekstowe i wybrać opcję Assign New Configuration File... po czym wskazać na plik konfiguracyjny, utworzony jako wynik implementacji (C:\My_Designs\seg7\implement\ver1\rev1\seg7.bit)

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 razie posługiwania się zamieszczoną na początku tutoriala tabelką kodów należy zwrócić uwagę, że kolejność kolumn dla segmentów wyświetlacza jest tam odwrotna (A...G) niż przyjęto w projekcie (G...A).

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. 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. 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 <= "1110"; -- disable all positions but the rightmost

      • zastąpić przez:

      • Position <= "1101" when Sel='1' else "1110"; -- control two positions

Nie wykonywać poleceń w znajdujacym się poniżej, zaczernionym tekście.

Następnie wprowadzone zmiany należy zweryfikować. W oknie Design Browser, na fiszce Files otworzyć plik przebiegów czasowych symulacji zadanie3.awf. W pliku tym znajduje się już wstępnie przygotowane środowisko do symulacji. Wejściowe sygnały Digit0 oraz Digit1 sterowane będą przez sekwencyjne wymuszenia Binary Counter. Dzięki nim podczas symulacji będą sekwencyjnie generowane kombinacje czterech bitów odpowiednio: od 0 do 15 (Digit0 - licznik w górę) oraz od 15 do 0 (Digit1 - licznik w dół). Wartość zaś sygnału Sel można będzie zmieniać na przeciwną (0/1) pomiędzy kolejnymi krokami symulacji każdorazowo przez przyciśnięcie na klawiaturze przycisku S.

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ą pozostałe cztery przełączniki, zaś do wyboru do wyświetlania w danym momencie jednej z dwu cyfr - przycisk BTNS (centralny). W tym celu należy zmodyfikować plik seg7.ucf, 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 Nexys3 (wyświetlacz, przełączniki, przyciski itp.) W tym celu w panelu Design Browser, na fiszce Files otworzyć plik seg7.ucf, a w nim:

• • w sekcji "Tutorial, Zadanie 1 i 2" 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 NET...

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 BTNS 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 maniakó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 Nexys3 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 sig7;) 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 automatu zliczającego w 18-bitowym liczniku Counter kolejne okresy (narastające zbocza) sygnału zegarowego. Pojemność licznika pozwala na zliczenie 2¹⁸ = 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 (+), 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 UCF:

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

    • NET "Sel" LOC = "B8" ; #BTNS

    • w sekcji "Zadanie 4" usunąć znak komentarza # sprzed dyrektywy NET "Clk"..

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.