Projektowanie Scalonych Systemów Wbudowanych VERILOG

Transkrypt

1 Projektowanie Scalonych Systemów Wbudowanych VERILOG

2 OPIS BEHAWIORALNY proces Proces wątek sterowania lub przetwarzania danych, niezależny w sensie czasu wykonania, ale komunikujący się z innymi procesami. Procesy są wykonywane równolegle. Procesem może być jedna instrukcja lub może mieć bardziej złożony opis. Mogą wymieniać ze sobą dane. Procesy reprezentują układy cyfrowe działające jednocześnie w tym samym czasie EiT 2016/17 PSSW - Verilog 2

3 Bloki proceduralne Blok (instrukcja) initial jest wykonywana tylko raz, wykonywanie rozpoczyna się w czasie 0 i zależy od instrukcji wewnątrz bloku, NIE JEST syntezowalna, służy tylko dla symulatora do inicjowania wartości sygnałów. initial <instrukcja> Blok (instrukcja) always jest wykonywana wielokrotnie (instrukcja wewnątrz bloku jest wykonywana w nieskończoność), JEST SYNTEZOWALNA always <instrukcja> EiT 2016/17 PSSW - Verilog 3

4 Bloki proceduralne W projekcie może być kilka instrukcji initial i always. Wszystkie są wykonywane począwszy od zera chyba, że wprowadzimy opóźnienia. module trzy_instrukcje; initial $display ("instrukcja 1"); initial $display ("instrukcja 2"); initial $display ("instrukcja 3"); module `timescale 1ns/1ps module trzy_instrukcje_2; initial #1 $display ("instrukcja 1"); initial $display ("instrukcja 2"); initial #2 $display ("instrukcja 3"); module EiT 2016/17 PSSW - Verilog 4

5 Grupowanie instrukcji Do grupowania instrukcji używamy bloków sekwencyjnego współbieżnego W bloku initial lub always można wykonać kilka instrukcji, ale muszą być zgrupowane. EiT 2016/17 PSSW - Verilog 5

6 Blok sekwencyjny begin <instrukcja_1> <instrukcja_n> Instrukcje wewnątrz bloku sekwencyjnego wykonywane są sekwencyjnie, czyli w kolejności wystąpienia. `timescale 1ns/1ps module trzy_instrukcje_3; initial begin #1 $display ("instrukcja 1",$time); $display ("instrukcja 2",$time); #2 $display ("instrukcja 3",$time); module EiT 2016/17 PSSW - Verilog 6

7 Blok współbieżny fork join <instrukcja_1> <instrukcja_n> Instrukcje wewnątrz bloku współbieżnego wykonywane są jednocześnie niezależnie od kolejności wystąpienia. `timescale 1ns/1ps module trzy_instrukcje_4; initial fork #1 $display ("instrukcja 1",$time); $display ("instrukcja 2",$time); #2 $display ("instrukcja 3",$time); join module EiT 2016/17 PSSW - Verilog 7

8 Przypisania Ciągłe (assign) opis układu na poziomie strukturalnym lub funkcjonalnym; wykonywane są równolegle i natychmiast. Proceduralne (w bloku proceduralnym always lub initial) opis układu na poziomie funkcjonalnym; wykonywane są według kolejności zapisu; mogą być: blokujące nieblokujące EiT 2016/17 PSSW - Verilog 8

9 Przypisania ciągłe Przypisanie ciągłe (assign) opisuje stan logiczny węzła za pomocą równań, w sposób ciągły steruje siecią logiczną (modelowanie na poziomie przepływu danych) Cechy: lewa strona typu wire zmienna (1-bitowa) lub wektor lub sklejenie bitów (nie można stosować reg), wartość jest obliczana po zmianie wartości jednego z argumentów, argumenty mogą być typu wire, reg lub wywołania funkcji; mogą być bitami lub wektorami, poszczególne przypisania są wykonywane jednocześnie (równolegle), uwzględniona jest kolejność bitów: LSB prawej do LSB lewej strony, opóźnienia określają moment przypisania obliczonej wartości, może być niejawne. EiT 2016/17 PSSW - Verilog 9

10 Przypisania proceduralne Przypisania proceduralne (wewnątrz bloków proceduralnych: always, initial) uaktualnia wartość zmiennych jednorazowo, które następnie są przechowywane aż do następnego przypisania (modelowanie na poziomie behawioralnym). Cechy: lewa strona typu reg, integer, real, time lub element pamięci, prawa strona dowolne wyrażenie, wszystkie operatory, ogólnie, są wykonywane w kolejności zapisu (uwaga: blokujące i nieblok.), EiT 2016/17 PSSW - Verilog 10

11 blokujące: Przypisania proceduralne [zmienna] = [wyrażenie] Przypisania wykonywane są wg kolejności zapisu w kodzie (po kolei). Symulacja zatrzymuje się na danym przypisaniu, po jego wykonaniu jest kontynuowana dalej zmienne są aktualizowane po kolei. nieblokujące: [zmienna] <= [wyrażenie] Przypisania wykonywane są jednocześnie (równolegle) w całym bloku, nie blokując realizacji innych zmienne są aktualizowane jednocześnie. EiT 2016/17 PSSW - Verilog 11

12 Przypisania blokujące i nieblokujące (1) Przykład obliczanie wartości initial #10 Ab = 3; An = 3; begin Ab = 2; Bb = Ab+1; begin An <= 2; Bn <= An+1; blok proceduralny initial wcześniej zdeklarowane zmienne typu reg, tu przyjmują wartość 3 Przypisanie blokujące: 1. zmienna Ab przyjmuje nową wartość 2, 2. obliczenie wartości zm. Bb z nową wartością Ab. Przypisanie nieblokujące: 1. zmienna An przyjmuje nową wartość 2, 1. jednocześnie obliczana jest wartość zmiennej Bn z poprzednią wartością An=2. Plik: przyp_bnb_1.v Jakie będą wartości zmiennych po wykonaniu bloku initial? EiT 2016/17 PSSW - Verilog 12

13 Przypisania blokujące i nieblokujące (2) Przykład obl. wart. z opóźnieniem wewnętrznym initial #10 Ab = 3; An = 3; begin Ab = #1 2; Bb = #1 Ab+1; begin An <= #1 2; Bn <= #1 An+1; oczekiwanie (opóźnienie) wewnątrz przypisania Wykonanie przypisania: obliczanie prawej strony, odczekanie wewnętrznego opóźnienia, przypisanie obl. wartości do lewej strony. Działa dwuetapowo jak master-slave. Plik: przyp_bnb_2.v Jakie będą wartości zmiennych po wykonaniu bloku initial? EiT 2016/17 PSSW - Verilog 13

14 Przypisania blokujące i nieblokujące (3) Przykład obl. wart. z opóźnieniem (zwykłym) initial #10 Ab = 3; An = 3; begin #1 Ab = 2; #1 Bb = Ab+1; begin #1 An <= 2; #1 Bn <= An+1; opóźnienie zwykłe Wykonanie każdego przypisania nastąpi po późnieniu o 1 jedn. czasową. W przypadku przypisania nieblokującego, przypisania będą wykonywane po kolei z powodu opóźnień, co da efekt jakby były blokujące. Plik: przyp_bnb_3.v Jakie będą wartości zmiennych po wykonaniu bloku initial? EiT 2016/17 PSSW - Verilog 14

15 Przypisania blokujące Przykład 2 module block (input data, clk, output reg rega, regb); data clock D Q rega always@(posedge clk) begin rega = data; regb = rega; module D Q regb EiT 2016/17 PSSW - Verilog 15

16 Przykład 2 Przypisania nieblokujące module block (input data, clk, output reg rega, regb); rega always@(posedge clk) begin rega <= data; regb <= rega; module data clock D Q D Q regb EiT 2016/17 PSSW - Verilog 16

17 Proceduralne przypisanie ciągłe występuje w bloku proceduralnym, zmienne typu reg, działa przez pewien określony czas (gdy są spełnione warunki). module dff_set_reset (input clk, set, reset, d, output reg q); set) if(reset) assign q=o; else if(set) assign q=l; else deassign q; clk) q<=d; module przypisanie ciągłe gdy reset = 1 przypisanie ciągłe gdy set =1 i reset = 0 (tu niższy priorytet ma set) odwołanie przypisań ciągłych, gdy set i reset są zerami ta instrukcja proceduralna wykona się dopiero, gdy proced. przypisanie ciągłe zostanie odwołane (deassign) EiT 2016/17 PSSW - Verilog 17

18 Przerzutniki i liczniki Ćwiczenia praktyczne EiT 2016/17 PSSW - Verilog 18

19 Dany jest automat: X = {a b}, Y = {x, y, z}, S = {p, q, r, s} Automaty opis za pomocą tabeli Litery wejściowe Aktualne stany wewnętrzne Funkcja przejść (stany następne) Tabela przejść i wyjść dla automatu Mealy ego a b a b p p s x z q q r x y r s p y z s q p y x Tabela przejść i wyjść dla automatu Moor a a b p r s x q s r z r q r y s p p y UWAGA: w automacie Moor a litera wyjściowa zależy tylko od aktualnego stanu EiT 2016/17 PSSW - Verilog 19

20 Automaty Model automatu Mealy ego wejście UKŁAD KOMBINACYJNY 1 funkcja przejść (fun. wzbudzeń przerz.) PRZERZUTNIKI stan UKŁAD KOMBINACYJNY 2 funkcja wyjść wyjście zegar Model automatu Moor a wejście UKŁAD KOMBINACYJNY 1 funkcja przejść (fun. wzbudzeń przerz.) PRZERZUTNIKI stan UKŁAD KOMBINACYJNY 2 funkcja wyjść wyjście zegar EiT 2016/17 PSSW - Verilog 20

21 Automaty Przykładowy automat układ wykrywa sekwencję 101 na wej. i wystawia 1 na jeden takt zegara S0 S0 S1 0 S1 S2 S1 0 S2 S0 S3 0 S3 S2 S1 1 S0/0 0 1 S1/0 1 0 S2/ S3/1 EiT 2016/17 PSSW - Verilog 21

22 Automaty kod z trzema procesami // definicja automatu module automat_3mo (input x,reset,clk, output reg y); reg [1:0] state, next_state; parameter [1:0] S0=2'd0,S1=2'd1,S2=2'd2,S3=2'd3; // Proces pierwszy case (state) S0: if (x) next_state=s1; else next_state=s0; S1: if (x) next_state=s1; else next_state=s2; S2: if (x) next_state=s3; else next_state=s0; S3: if (x) next_state=s1; else next_state=s2; case clk) // Proces drugi if (!reset) state<=0; else state<=next_state; // Proces trzeci if (state==s3) y=1; else y=0; module EiT 2016/17 PSSW - Verilog 22

23 automaty - wynik symulacji 0 S0/ S1/0 0 S2/ S3/1 EiT 2016/17 PSSW - Verilog 23

24 Automaty kod z dwoma procesami // definicja automatu module automat_2mo (input x,reset,clk, reg [1:0] state; output reg y); parameter [1:0] S0=2'd0,S1=2'd1,S2=2'd2,S3=2'd3; clk) // Proces pierwszy if(!reset) else state<=0; begin case (state) case S0: if (x) state<=s1; else state<=s0; S1: if (x) state<=s1; else state<=s2; S2: if (x) state<=s3; else state<=s0; S3: if (x) state<=s1; else state<=s2; // Poces drugi - funkcja wyjść if (state==s3) y=1; else y=0; module EiT 2016/17 PSSW - Verilog 24

25 Automaty kod z jednym procesem // definicja automatu module automat_1mo (input x,reset,clk, reg [1:0] state; output reg y); parameter [1:0] S0=2'd0,S1=2'd1,S2=2'd2,S3=2'd3; clk) // Jeden proces if(!reset) state<=0; else begin case (state) S0: begin y<=0; if (x) state<=s1; else state<=s0; S1: begin y<=0; if (x) state<=s1; else state<=s2; S2: begin y<=0; if (x) state<=s3; else state<=s0; S3: begin y<=1; if (x) state<=s1; else state<=s2; case module EiT 2016/17 PSSW - Verilog 25