Kurs FPGA Lattice (3). Podstawy języka Verilog

Dominik Bieczyński

Kursy

FPGA-CPLD-SPLD

1 lutego 2023

1603

W tym odcinku kursu nauczymy się podstawowych instrukcji języka Verilog i opiszemy proste układy kombinacyjne oraz sekwencyjne. Poprzednie części kursu można znaleźć na ep.com.pl.

Poprzednia część

Spis treści

Następna część

1. Kurs FPGA Lattice (1). Wstęp 2. Kurs FPGA Lattice (2). Pierwszy projekt 3. Kurs FPGA Lattice (3). Podstawy języka Verilog 4. Kurs FPGA Lattice (4). Generator, dzielnik i licznik 5. Kurs FPGA Lattice (5). IPExpress i inne gotowce 6. Kurs FPGA Lattice (6). Parametry i ćwiczenia 7. Kurs FPGA Lattice (7). Analizator logiczny Reveal 8. Kurs FPGA Lattice (8). Symulacja w EDA Playground 9. Kurs FPGA Lattice (9). Wyświetlacz multipleksowany 10. Kurs FPGA Lattice (10). Klawiatura matrycowa i maszyna stanów 11. Kurs FPGA Lattice (11). Statyczna analiza czasowa i maksymalna częstotliwość zegara 12. Kurs FPGA Lattice (12). Symulacja w Icarus Verilog i GTKWave 13. Kurs FPGA Lattice (13). Wyświetlacz LCD multipleksowany 14. Kurs FPGA Lattice (14). Enkoder obrotowy 15. Kurs FPGA Lattice (15). Pamięć EBR 16. Kurs FPGA Lattice (16). Generowanie dźwięków 17. Kurs FPGA Lattice (18). Nadajnik UART 18. Kurs FPGA Lattice (19). Odbiornik UART 19. Kurs FPGA Lattice (20). 14-segmentowy wyświetlacz LCD 20. Kurs FPGA Lattice (21). Terminal UART z 14-segmentowym wyświetlaczem LCD 21. Kurs FPGA Lattice (22). Sekwencyjny algorytm Double Dabble 22. Kurs FPGA Lattice (23). Kombinacyjny algorytm Double Dabble 23. Kurs FPGA Lattice (24). Miernik częstotliwości 24. Kurs FPGA Lattice (25). Direct Digital Synthesis 25. Kurs FPGA Lattice (26). Slave SPI 26. Kurs FPGA Lattice (27). Obsługa monitora VGA 27. Kurs FPGA Lattice (28). Sterownik VGA kompatybilny z OLED 28. Kurs FPGA Lattice (29). Terminal tekstowy VGA 29. Kurs FPGA Lattice (30). Zakończenie

Rozwiń cały spis treści Zwiń spis treści

Moduły i instancje modułów

Kod języka Verilog dzielimy na moduły, podobnie jak kod w językach programowania dzieli się na funkcje czy klasy. Każdy moduł komunikuje się z pozostałymi modułami przy pomocy portów – mogą one być wejściem input, wyjściem output lub sygnałem dwukierunkowym inout. Moduł nadrzędny, od którego zaczyna się cała aplikacja zwyczajowo nazywany jest top. Jest odpowiednikiem funkcji main() w C++. Każdy inny moduł należy opisać, a następnie powołać do życia tworząc co najmniej jedną instancję tego modułu. Moduły wygodnie jest zapisywać w oddzielnych plikach, których nazwa jest taka sama jak nazwa modułu.

Prześledźmy przykład zaprezentowany na listingu 1. W liniach oznaczonych jako #4 i #5 definiujemy moduły BramkaAND i BramkaOR. Każda z nich ma dwa wejścia x i y oraz wyjście result. Samo zdefiniowanie tych modułów jeszcze nie spowoduje wygenerowania ich w układzie FPGA. W module top w liniach oznaczonych #1 i #2 zostały utworzone dwie instancje modułu BramkaAND. W nawiasach podane są nazwy portów, jakie ma moduł top. W ten sposób wejścia i wyjścia modułu top, które są fizycznymi pinami układu FPGA, zostają połączone z wirtualnymi pinami modułów.

Listing 1. Przykład podziału kodu na moduły

// Plik top.v
module top(
	input ButtonA,
	input ButtonB,
	input ButtonC,
	output LED,
	output Buzzer,
	output Relay
);
		
	// Instancje modułów typu BramkaAND o nazwie AND1 i AND2
	BramkaAND AND1(ButtonA, ButtonB, LED);			// #1
	BramkaAND AND2(ButtonA, ButtonC, Buzzer);		// #2
	
	// Instancja modułu typu BramkaOR o nazwie OR1
	BramkaOR OR1(									// #3
		.x(ButtonA),
		.y(ButtonB),
		.result(Relay)
	);
	
endmodule

// Plik bramka_and.v
module BramkaAND(									// #4
	input x, y,
	output result
);
	
	assign result = x & y;
	
endmodule

// Plik bramka_or.v
module BramkaOR(									// #5
	input x, y,
	output result
);
	
	assign result = x | y;
	
endmodule

Należy zwrócić uwagę, że utworzyliśmy dwie instancje AND1 i AND2, które działają dokładnie tak samo, jednak połączone są z innymi sygnałami. Istnieją dwa sposoby tworzenia instancji i łączenia ich z sygnałami z innych modułów. Sposób pokazany w liniach #1 i #2 jest podobny do kodu C++, w którym tworzony jest obiekt jakiejś klasy, a jego konstruktor przyjmuje kilka argumentów. W tym przypadku kolejność argumentów ma znaczenie. Taki sposób jest przydatny dla bardzo prostych modułów, które mają niewiele portów. Drugi sposób został pokazany w linii #3. Każdy z portów modułu wymieniony jest po znaku kropki. Następnie w nawiasach podana jest nazwa sygnału, z którym dany port ma być połączony. Taki opis jest bardziej rozwlekły i czasochłonny, jednak ma kilka istotnych zalet. Po pierwsze kod staje się bardziej czytelny, ponieważ widzimy nazwę portu wewnątrz modułu i jednocześnie sygnał, z którym jest połączony na zewnątrz. Dodatkowo każdy z nich możemy opatrzyć komentarzem. Dzięki temu, że każdy port jest zapisany w osobnej linii, w razie błędu syntezator powie nam, w której linii jest błąd – w przypadku pierwszego sposobu, gdzie wszystko opisujemy w jednej linijce, komunikatory syntezatora mogą być trudniejsze do zrozumienia. Ponadto, kolejność przypisań jest dowolna.