Dokumentacja Verilog z przykładami: Logika taktowana

Q: Czym jest logika taktowana w Verilogu?

To logika, której aktualizacje są wyznaczane przez sygnał zegarowy. Standardowy idiom to always @(posedge clk) target <= nextvalue;: przy każdym zboczu narastającym clk sygnał target zapamiętuje nextvalue. Ta jedna linia opisuje w sprzęcie przerzutnik. Połączenie wielu takich przerzutników z logiką kombinacyjną między nimi daje liczniki, rejestry przesuwne, potoki, czyli wszystko, co synchroniczne.

Q: Jaka jest różnica między resetem synchronicznym a asynchronicznym w Verilogu?

Reset synchroniczny to always @(posedge clk) if (reset) ...: reset jest próbkowany na zboczu zegara jak każde inne wejście. Reset asynchroniczny to always @(posedge clk or negedge resetn) if (~resetn) ...: blok uruchamia się na zboczu zegara albo przy aktywacji resetu, więc reset działa natychmiast. Synchroniczny to domyślny wybór. Asynchronicznego używa się, gdy reset musi zadziałać nawet przy zatrzymanym zegarze.

Q: Jak zbudować potok (pipeline) w Verilogu?

Ułóż kilka stopni w postaci always @(posedge clk) stageNreg <= stageNcombinational;: logika kombinacyjna każdego stopnia zasila rejestr następnego stopnia, a wszystkie rejestry zapamiętują wartości na tym samym zboczu zegara. Powstaje potok, do którego co cykl wchodzą nowe dane i wychodzą N cykli później, z przepustowością jednego wyniku na takt.

Q: Czym jest rejestr przesuwny w Verilogu?

To łańcuch przerzutników, w którym wyjście każdego zasila wejście następnego. Każde zbocze zegara przesuwa wszystkie bity o jedną pozycję. Kanoniczna wersja w Verilogu używa przypisań nieblokujących: out <= {out[N-2:0], in};. Ta jedna linia tworzy N-bitowy rejestr przesuwny, który co cykl pobiera jeden bit z in.

Cegiełka: przerzutnik D

Całe projektowanie synchroniczne sprowadza się do jednego małego elementu sprzętu: przerzutnika D. Ma wejście zegarowe, wejście danych i wyjście danych. Przy każdym zboczu narastającym zegara zapamiętuje wartość D i trzyma ją do następnego zbocza. To wszystko.

W Verilogu:

always @(posedge clk) begin
    q <= d;
end

Trzy linie, jeden przerzutnik. <= to przypisanie nieblokujące, które zachowuje się dokładnie jak prawdziwe przerzutniki (więcej w artykule Przypisania blokujące i nieblokujące). To czułość na posedge clk sprawia, że logika jest sekwencyjna.

Połącz wiele takich elementów z logiką kombinacyjną między nimi, a zbudujesz dowolny układ synchroniczny.

Rejestr z resetem

Prawdziwe projekty zawsze potrzebują resetu, czyli sposobu na wprowadzenie systemu w znany stan przy włączeniu zasilania albo na żądanie:

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

To reset synchroniczny: warunek resetu jest sprawdzany na zboczu zegara jak każde inne wejście. Syntezator tworzy przerzutnik z multiplekserem 2 na 1 na wejściu danych. Gdy reset jest w stanie wysokim, multiplekser podaje zero, w przeciwnym razie podaje d.

W większości projektów reset synchroniczny to właściwy wybór. Upraszcza analizę czasową, dobrze współpracuje z FPGA, a sygnał resetu może pochodzić skądkolwiek i nie potrzebuje własnego źródła wyrównanego z zegarem.

Rejestr z enable

Często potrzebujesz rejestru, który aktualizuje się tylko na polecenie. Użyj if wewnątrz bloku taktowanego i skorzystaj z domyślnego zachowania "zachowaj poprzednią wartość" przy brakującym else:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

To kanoniczny rejestr z wejściem ładowania (load enable). Pojawia się wszędzie: w rejestrach konfiguracyjnych, w stopniach potoku, które przesuwają dane tylko wtedy, gdy kolejny stopień jest gotowy, w licznikach, które można wstrzymać i wznowić. Pominięcie końcowego else jest celowe i bezpieczne w bloku taktowanym: przerzutnik i tak pamięta poprzednią wartość, więc "nic nie rób" oznacza "trzymaj".

W bloku kombinacyjnym ten sam kod utworzyłby zatrzask. Inne reguły, ta sama składnia.

Licznik

Licznik to rejestr, którego następna wartość to bieżąca wartość plus jeden:

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [3:0] count;

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

Licznik zwiększa się w każdym cyklu zegara, gdy enable jest w stanie wysokim. Po 16 cyklach wraca do 0 (bo licznik ma 4 bity, a 15 + 1 przepełnia się do 0). To zawijanie wynika z natury arytmetyki N-bitowej i dokładnie tak zachowuje się prawdziwy licznik sprzętowy.

Rejestr przesuwny

Połączenie przerzutników w łańcuch daje rejestr przesuwny. Cała sztuka polega na wykonaniu wszystkich przesunięć w jednej instrukcji nieblokującej:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg in = 0;
    wire [3:0] out;

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

Ciało to out <= {out[WIDTH-2:0], in}: sklej młodsze bity bieżącego out z nowym in i przypisz całość. Ponieważ przypisanie jest nieblokujące, prawa strona odczytuje stare out, zanim lewa strona się zaktualizuje. Efektem jest czyste przesunięcie N bitów w jednym cyklu zegara.

To wzorzec rejestru przesuwnego w najmniejszej postaci. Uogólnia się na rejestry LFSR, nadajniki szeregowe, deserializery, czyli każdy projekt, w którym dane przechodzą przez łańcuch przerzutników z każdym taktem zegara.

Potoki

Potok (pipeline) to łańcuch rejestrów rozdzielonych logiką kombinacyjną. Każdy stopień przetwarza dane z poprzedniego stopnia i zasila następny:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Stage 1: two parallel adds.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: combine the two partial sums.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: forward to output.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

Trzy stopnie, trzy cykle opóźnienia, ale gdy potok się zapełni, co cykl pojawia się nowy wynik. Opóźnienie wynosi 3 takty, bo dane przechodzą przez trzy przerzutniki. Przepustowość to 1 operacja na takt, bo wszystkie trzy stopnie pracują jednocześnie na różnych danych.

Tak wydajne projekty osiągają docelową przepustowość: krótkie stopnie, głębszy potok i równoległość, która wykonuje pracę.

Reset asynchroniczny (gdy go potrzebujesz)

Czasem nie można czekać na zbocze zegara, żeby aktywować reset: układ jest wyłączany, zegar jest bramkowany albo zewnętrzny watchdog szarpie linię. W takich przypadkach:

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

Lista czułości zawiera teraz zarówno zbocze zegara, jak i zbocze resetu. Przerzutnik reaguje natychmiast na każde z nich. reset_n jest zgodnie z konwencją aktywny stanem niskim, dlatego warunek to ~reset_n.

Reset asynchroniczny ma swoje wady: trudniej go analizować czasowo, może wywołać metastabilność, jeśli jego zwolnienie nie jest starannie obsłużone, i nie jest przenośny między wszystkimi architekturami FPGA. Domyślnie używaj resetu synchronicznego, a asynchronicznego tylko wtedy, gdy projekt tego wymaga.

Co dalej

Potrafisz już zbudować dowolną synchroniczną ścieżkę danych. Następny artykuł, Maszyny stanów, łączy taktowany rejestr z instrukcją case w standardowy idiom automatu skończonego (FSM): podstawę każdego kontrolera, silnika protokołu i bloku podejmującego decyzje w projektowaniu cyfrowym.

Najczęściej zadawane pytania

Czym jest logika taktowana w Verilogu?

To logika, której aktualizacje są wyznaczane przez sygnał zegarowy. Standardowy idiom to always @(posedge clk) target <= next_value;: przy każdym zboczu narastającym clk sygnał target zapamiętuje next_value. Ta jedna linia opisuje w sprzęcie przerzutnik. Połączenie wielu takich przerzutników z logiką kombinacyjną między nimi daje liczniki, rejestry przesuwne, potoki, czyli wszystko, co synchroniczne.

Jaka jest różnica między resetem synchronicznym a asynchronicznym w Verilogu?

Reset synchroniczny to always @(posedge clk) if (reset) ...: reset jest próbkowany na zboczu zegara jak każde inne wejście. Reset asynchroniczny to always @(posedge clk or negedge reset_n) if (~reset_n) ...: blok uruchamia się na zboczu zegara albo przy aktywacji resetu, więc reset działa natychmiast. Synchroniczny to domyślny wybór. Asynchronicznego używa się, gdy reset musi zadziałać nawet przy zatrzymanym zegarze.

Jak zbudować potok (pipeline) w Verilogu?

Ułóż kilka stopni w postaci always @(posedge clk) stageN_reg <= stageN_combinational;: logika kombinacyjna każdego stopnia zasila rejestr następnego stopnia, a wszystkie rejestry zapamiętują wartości na tym samym zboczu zegara. Powstaje potok, do którego co cykl wchodzą nowe dane i wychodzą N cykli później, z przepustowością jednego wyniku na takt.

Czym jest rejestr przesuwny w Verilogu?

To łańcuch przerzutników, w którym wyjście każdego zasila wejście następnego. Każde zbocze zegara przesuwa wszystkie bity o jedną pozycję. Kanoniczna wersja w Verilogu używa przypisań nieblokujących: out <= {out[N-2:0], in};. Ta jedna linia tworzy N-bitowy rejestr przesuwny, który co cykl pobiera jeden bit z in.

Powiązane zagadnienia