Blok always w Verilogu: logika kombinacyjna i sekwencyjna

Główne narzędzie behawioralnego Veriloga

assign opisuje logikę kombinacyjną w postaci jednego równania. Gdy tylko potrzebujesz if/else, case albo pamięci, sięgasz po always. Blok always to fragment kodu proceduralnego, który uruchamia się ponownie za każdym razem, gdy zmienią się określone sygnały. Sygnały wyzwalające ponowne uruchomienie tworzą listę czułości.

Najczęściej spotkasz dwie postacie always:

1. always @(*): uruchamia się ponownie, gdy zmieni się dowolny sygnał odczytywany w bloku. Buduje logikę kombinacyjną.
2. always @(posedge clk): uruchamia się ponownie tylko na zboczu narastającym clk. Buduje taktowaną logikę sekwencyjną (przerzutniki, czyli flip-flopy).

Istnieją też inne formy (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), ale te dwie powyżej obejmują prawie każdy syntezowalny blok, jaki napiszesz.

Kombinacyjne always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

Trzy rzeczy, na które warto zwrócić uwagę:

• out jest typu reg. Wszystko, co jest przypisywane wewnątrz always, musi być reg. To słowo kluczowe nie oznacza "to jest przerzutnik". Tutaj znaczy tylko "zapisuję to z bloku proceduralnego".
• always @(*). Gwiazdka * mówi "obudź się, gdy zmieni się cokolwiek, co odczytuję". Symulator sam ustala listę czułości. Możesz wypisać listę ręcznie, na przykład always @(sel), ale @(*) jest bezpieczniejsze, bo pominięty sygnał to klasyczne źródło błędów.
• Brak zegara. Ten blok opisuje logikę kombinacyjną. Syntezator tworzy układ, który oblicza out bezpośrednio z sel, bez przerzutników i bez wejścia zegarowego.

Gałąź default jest opcjonalna w składni, ale w praktyce nie powinna być pomijana. Bez niej każda nieobsłużona wartość wejścia sprawia, że out zachowuje poprzednią wartość, a to syntezuje się do niezamierzonego zatrzasku (latch). Zawsze dodawaj default.

Sekwencyjne always @(posedge clk)

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

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

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

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

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

Najważniejsze różnice względem wersji kombinacyjnej:

• always @(posedge clk). Blok uruchamia się ponownie tylko na zboczu narastającym clk. Między zboczami nic się nie dzieje.
• Przypisanie nieblokujące <=. W bloku taktowanym to właściwy operator. Oznacza "zaplanuj, że count przyjmie nową wartość na końcu kroku czasowego", a dokładnie tak zachowuje się przerzutnik. Powody i alternatywę znajdziesz w artykule Przypisania blokujące i nieblokujące.
• default nie jest potrzebny. if obsługuje obie gałęzie (reset i brak resetu), więc nie ma ryzyka zatrzasku.

Syntezator rozpoznaje ten kształt (taktowana lista czułości i przypisanie nieblokujące) i tworzy 4-bitowy rejestr (cztery przerzutniki) oraz logikę kombinacyjną obliczającą count + 1 i multiplekser wybierający między resetem a inkrementacją.

Co widzi synteza

Ten sam kod modułu może opisywać dwa zupełnie różne układy, zależnie od kształtu bloku always:

Trzeci przypadek to pułapka zatrzasku. Zatrzask to przezroczysta komórka pamięci, która trzyma swoje wyjście, gdy wejście sterujące nie jest aktywne. Bywa przydatny w konkretnych projektach, ale gdy powstaje przypadkiem, prawie zawsze jest błędem. Większość narzędzi do syntezy głośno ostrzega, gdy wykryje zatrzask, o który nie prosisz. Traktuj to ostrzeżenie jak błąd.

Odmiany listy czułości

Spotkasz też kilka rzadszych list czułości:

• always @(a or b or c): jawna lista. Verilog-2001 dodał separator ,: always @(a, b, c). Działa każdy z zapisów.
• always @(posedge clk or negedge reset_n): reset asynchroniczny. Blok uruchamia się na zboczu narastającym zegara albo na zboczu opadającym resetu. Stosuje się go, gdy reset musi zadziałać natychmiast, bez czekania na następny takt zegara.
• always @(negedge clk): taktowanie zboczem opadającym. Rzadkie. Niektóre projekty używają go dla przerzutników wyzwalanych zboczem opadającym zamiast narastającym.

W nowych projektach wybieraj always @(*) dla logiki kombinacyjnej i always @(posedge clk) dla sekwencyjnej. Po reset asynchroniczny sięgaj tylko wtedy, gdy projekt naprawdę go potrzebuje.

Dwa bloki to dwa układy

Kilka bloków always w tym samym module działa niezależnie. Każdy staje się osobnym fragmentem sprzętu:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sekwencyjne
    output reg  [7:0] comb_out    // kombinacyjne
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // negacja bitowa
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

Blok taktowany tworzy rejestr z przerzutników. Blok kombinacyjny tworzy bramkę XOR. Działają obok siebie i nic o sobie nie wiedzą. Oba wyjścia zmieniają się według zupełnie różnych harmonogramów.

Czego bloki always nie potrafią

Kilka rzeczy wygląda kusząco, ale jest niedozwolonych:

• Przypisanie do wire: cel musi być typu reg. Kompilator to wymusza.
• Przypisanie do tego samego reg z dwóch różnych bloków always: w symulacji daje niezdefiniowane zachowanie i nie da się tego zsyntezować. Jeden sygnał, jedno źródło sterowania.
• Odczyt i zapis tego samego sygnału w tym samym bloku kombinacyjnym w sposób tworzący pętlę sprzężenia zwrotnego: always @(*) x = x + 1; to pętla o zerowym opóźnieniu, której symulator nie potrafi rozwiązać.

Dwa pierwsze problemy wyłapie kompilator. Trzeci czasem ujawnia się dopiero w symulacji jako zawieszenie.

Co dalej

Następny artykuł, Blok initial, omawia rodzeństwo always: blok, który wykonuje się dokładnie raz na początku symulacji. To podstawowe narzędzie testbenchy. Potem przyjdą reguły przypisań blokujących i nieblokujących, które decydują o tym, czy blok taktowany robi to, co zamierzasz.