Dokumentacja Verilog z przykładami: If-else

Q: Jak działa instrukcja if w Verilogu?

if (cond) statement; wykonuje statement, gdy cond jest niezerowe. Kilka instrukcji możesz objąć begin ... end. Dodaj else statement; dla gałęzi alternatywnej albo utwórz łańcuch z else if (other_cond) .... if/else istnieje tylko wewnątrz bloków proceduralnych, initial lub always, a nie na najwyższym poziomie modułu.

Q: Czym jest niechciany zatrzask (inferred latch) w Verilogu?

To zatrzask, który narzędzie do syntezy utworzyło bez twojej prośby, bo kombinacyjny blok always nie przypisywał sygnału w każdej ścieżce. Narzędzie widzi 'jeśli a, to out = 1' bez else, uznaje, że w nieprzypisanym przypadku trzeba zapamiętać poprzednią wartość, i tworzy zatrzask. Zatrzaski prawie zawsze są błędem. Rozwiązanie to nadanie każdemu sygnałowi wartości domyślnej na początku bloku albo jawne else.

Q: Jak uniknąć niechcianych zatrzasków w Verilogu?

W kombinacyjnym bloku always @(*) upewnij się, że każdy wyjściowy reg jest przypisywany w każdej ścieżce kodu. Najczystszy wzorzec to ustawienie wartości domyślnych na początku bloku, a potem warunkowe ich nadpisywanie. Kompilator zwykle ostrzega, gdy tworzy zatrzask. Traktuj to ostrzeżenie jak błąd.

Q: Co powstaje z łańcucha if-else po syntezie w Verilogu?

Koder priorytetowy. Pierwszy if ma najwyższy priorytet, kolejny else if jest sprawdzany tylko wtedy, gdy pierwszy jest fałszywy, i tak dalej. W sprzęcie staje się to łańcuchem multiplekserów z wbudowaną kolejnością priorytetów. Jeśli warunki wzajemnie się wykluczają, instrukcja case z tą samą logiką często syntezuje się do bardziej płaskiego sprzętu i czyta się czytelniej.

Znajoma składnia, inny model myślenia

if/else wygląda dokładnie jak w C:

if (condition) begin
    // ... statements ...
end else begin
    // ... statements ...
end

Reguły są jednak inne, bo Verilog to nie oprogramowanie. Warto pamiętać o dwóch rzeczach:

if/else istnieje tylko wewnątrz bloku proceduralnego. Nie da się napisać samodzielnego if na poziomie modułu.
To, do czego syntezuje się if/else, zależy od typu bloku. W bloku kombinacyjnym staje się multiplekserem albo koderem priorytetowym. W bloku taktowanym staje się przerzutnikiem z logiką warunkowej aktualizacji.

W bloku kombinacyjnym

module max_of_three(
    input  wire [7:0] a,
    input  wire [7:0] b,
    input  wire [7:0] c,
    output reg  [7:0] max
);
    always @(*) begin
        if (a >= b && a >= c)
            max = a;
        else if (b >= c)
            max = b;
        else
            max = c;
    end
endmodule

module test;
    reg [7:0] a, b, c;
    wire [7:0] max;
    max_of_three dut(.a(a), .b(b), .c(c), .max(max));

    initial begin
        a = 8'd10; b = 8'd20; c = 8'd15; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd50; b = 8'd30; c = 8'd40; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd5;  b = 8'd5;  c = 8'd50; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        $finish;
    end
endmodule

Kombinacyjny blok always @(*) uruchamia się ponownie, gdy zmieni się a, b albo c. Łańcuch if/else wybiera jedną gałąź, przypisuje max i blok się kończy. Ponieważ max jest zawsze przypisywane (każda ścieżka ma przypisanie), syntezator tworzy czystą logikę kombinacyjną, bez zatrzasku.

Zwróć uwagę, że max jest zadeklarowane jako reg, choć w sprzęcie nie ma przerzutnika. Obowiązuje ta sama reguła co zawsze: wszystko, co jest przypisywane wewnątrz always, musi być reg.

Pułapka zatrzasku

To najczęstszy błąd w kodzie kombinacyjnym początkujących:

// WRONG - infers a latch
always @(*) begin
    if (enable)
        out = data;
    // no else! when `enable` is low, what does `out` do?
end

Syntezator odczytuje "gdy enable jest w stanie niskim, out nie jest przypisywane" i uznaje, że out musi pamiętać poprzednią wartość. Pamiętanie wartości wymaga komórki pamięci, więc narzędzie wstawia zatrzask. Zatrzaski w projektach synchronicznych powodują problemy czasowe, trudno je resetować i prawie nigdy nie są tym, co zamierzasz.

Są dwa sposoby, żeby to naprawić:

// Fix 1: explicit else branch
module no_latch_1(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        if (enable) out = data;
        else        out = 8'd0;
    end
endmodule

// Fix 2: default assignment at the top
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // default first
        if (enable) out = data; // override if condition holds
    end
endmodule

module test;
    reg en;
    reg [7:0] d;
    wire [7:0] out1, out2;

    no_latch_1 u1(.enable(en), .data(d), .out(out1));
    no_latch_2 u2(.enable(en), .data(d), .out(out2));

    initial begin
        en = 0; d = 8'h55; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        en = 1; d = 8'hAA; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        $finish;
    end
endmodule

Oba dają ten sam sprzęt kombinacyjny: multiplekser 2 na 1. Wzorzec "wartość domyślna na początku" lepiej się skaluje, gdy masz wiele warunkowych przypisań do tego samego sygnału.

W bloku taktowanym

module counter_with_reset(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [7:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 8'd0;
        else if (enable)  count <= count + 8'd1;
        // else: implicit hold (count keeps its value - that's what a flip-flop does)
    end
endmodule

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

    counter_with_reset dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #50 enable = 0;
        #20 enable = 1;
        #30 $finish;
    end

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

Zwróć uwagę, co się różni od przypadku kombinacyjnego:

Blok to always @(posedge clk), czyli terytorium przerzutników.
Przypisanie używa <= (nieblokującego).
Nie ma else dla przypadku "ani reset, ani enable". To w porządku. W bloku taktowanym, gdy żadna gałąź się nie wykona, przerzutnik po prostu trzyma poprzednią wartość, a dokładnie to fizycznie robi przerzutnik. Zatrzask nie powstaje, bo sygnał już jest rejestrem.

To jedyne miejsce, w którym pominięcie else jest bezpieczne. Poza blokami taktowanymi zawsze obsługuj każdą ścieżkę.

Łańcuch `else if`: koder priorytetowy

Łańcuch instrukcji else if ma wbudowany priorytet: wcześniejsze warunki mają pierwszeństwo przed późniejszymi:

module priority_encoder(
    input  wire [3:0] requests,
    output reg  [1:0] grant,
    output reg        any
);
    always @(*) begin
        any = |requests;
        if      (requests[0]) grant = 2'd0;
        else if (requests[1]) grant = 2'd1;
        else if (requests[2]) grant = 2'd2;
        else if (requests[3]) grant = 2'd3;
        else                  grant = 2'd0;
    end
endmodule

module test;
    reg [3:0] req;
    wire [1:0] grant;
    wire any;
    priority_encoder dut(.requests(req), .grant(grant), .any(any));

    initial begin
        req = 4'b0000; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b0010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1111; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        $finish;
    end
endmodule

requests[0] ma najwyższy priorytet: jeśli jest ustawiony, wynik to 0 niezależnie od bitów o wyższych numerach. Syntezator zamienia łańcuch w kaskadę multiplekserów: najpierw sprawdza bit 0, potem bit 1, potem bit 2, potem bit 3. Każdy poziom dodaje niewielkie opóźnienie.

Jeśli warunki wzajemnie się wykluczają (na przykład przy dekodowaniu wejścia one-hot), instrukcja case (następny artykuł) daje bardziej płaski i szybszy sprzęt niż łańcuch else if. Używaj case, gdy nie ma rzeczywistej potrzeby priorytetu.

`if` bez `else` w kodzie taktowanym

Blok taktowany nie potrzebuje else, bo "zachowaj poprzednią wartość" to zachowanie domyślne. Tak buduje się wejścia enable:

always @(posedge clk) begin
    if (load) target <= incoming;
    // no else: when load is low, target keeps its value
end

To rejestr z wejściem ładowania. Większość rejestrów potoków, liczników i rejestrów konfiguracyjnych używa tego wzorca.

`begin`/`end` i pojedyncze instrukcje

Tak jak w C, przy pojedynczej instrukcji możesz pominąć begin/end:

if (a) out = 1;
else   out = 0;

Przy więcej niż jednej instrukcji użyj bloku:

if (a) begin
    out = 1;
    flag = 1;
end else begin
    out = 0;
    flag = 0;
end

Oba wzorce można swobodnie mieszać. Przewodniki stylu zwykle zalecają, żeby zawsze używać begin/end, bo wtedy dodanie drugiej instrukcji jest bezbolesne.

Co dalej

Następny artykuł, Instrukcja case, omawia case, czyli właściwe narzędzie do dekodowania wielu wariantów (maszyny stanów, wybór na podstawie opcode, tablice ROM). Potem przyjdą pętle for, które subtelnie różnią się od swoich odpowiedników z programowania, bo są rozwijane na etapie elaboracji.

Najczęściej zadawane pytania

Jak działa instrukcja if w Verilogu?

if (cond) statement; wykonuje statement, gdy cond jest niezerowe. Kilka instrukcji możesz objąć begin ... end. Dodaj else statement; dla gałęzi alternatywnej albo utwórz łańcuch z else if (other_cond) .... if/else istnieje tylko wewnątrz bloków proceduralnych, initial lub always, a nie na najwyższym poziomie modułu.

Czym jest niechciany zatrzask (inferred latch) w Verilogu?

To zatrzask, który narzędzie do syntezy utworzyło bez twojej prośby, bo kombinacyjny blok always nie przypisywał sygnału w każdej ścieżce. Narzędzie widzi 'jeśli a, to out = 1' bez else, uznaje, że w nieprzypisanym przypadku trzeba zapamiętać poprzednią wartość, i tworzy zatrzask. Zatrzaski prawie zawsze są błędem. Rozwiązanie to nadanie każdemu sygnałowi wartości domyślnej na początku bloku albo jawne else.

Jak uniknąć niechcianych zatrzasków w Verilogu?

W kombinacyjnym bloku always @(*) upewnij się, że każdy wyjściowy reg jest przypisywany w każdej ścieżce kodu. Najczystszy wzorzec to ustawienie wartości domyślnych na początku bloku, a potem warunkowe ich nadpisywanie. Kompilator zwykle ostrzega, gdy tworzy zatrzask. Traktuj to ostrzeżenie jak błąd.

Co powstaje z łańcucha if-else po syntezie w Verilogu?

Koder priorytetowy. Pierwszy if ma najwyższy priorytet, kolejny else if jest sprawdzany tylko wtedy, gdy pierwszy jest fałszywy, i tak dalej. W sprzęcie staje się to łańcuchem multiplekserów z wbudowaną kolejnością priorytetów. Jeśli warunki wzajemnie się wykluczają, instrukcja case z tą samą logiką często syntezuje się do bardziej płaskiego sprzętu i czyta się czytelniej.

Powiązane zagadnienia