Instrukcje if-else w Verilogu wyjaśnione: składnia, przykłady i najlepsze praktyki

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Wprowadzenie

1-1. Czym jest instrukcja if-else w Verilogu?

• Warowe rozgałęzianie w układach kombinacyjnych
• Sterowanie układami sekwencyjnymi (np. przerzutnikami)
• Dynamiczne sterowanie sygnałami (np. multipleksery lub operacje warunkowe)

1-2. Problemy spowodowane nieprawidłowym użyciem instrukcji if-else

1. Generowane są niechciane latchy

• Jeśli nie wszystkie warunki są wyraźnie zdefiniowane w gałęziach, narzędzie syntezy może wygenerować latchy (elementy pamięci).
• Może to powodować niezamierzone zachowanie pamięci i uniemożliwiać prawidłowe działanie układu.

2. Wyniki symulacji różnią się od wyników syntezy

• Nawet jeśli symulacja działa zgodnie z oczekiwaniami, zachowanie może się zmienić po implementacji na FPGA lub ASIC.
• Dzieje się tak, ponieważ niektóre style kodowania if-else mogą prowadzić narzędzia syntezy do niepoprawnych optymalizacji.

3. Obniżona czytelność kodu

• Głęboko zagnieżdżone instrukcje if-else utrudniają czytanie i utrzymanie kodu.
• W wielu przypadkach użycie instrukcji case może uczć kod czytelniejszym.

1-3. Cel tego artykułu

• Poprawnego użycia instrukcji if-else
• Jak pisać kod Verilog, który unika niezamierzonych latchy
• Kiedy używać if-else vs. case
• Najlepszych praktyk projektowania w Verilogu

2. Podstawowa składnia instrukcji if-else w Verilogu

2-1. Jak pisać instrukcje if-else

always_comb begin
    if (condition) 
        statement1;
    else 
        statement2;
end

always_comb begin
    if (condition1) 
        statement1;
    else if (condition2) 
        statement2;
    else 
        statement3;
end

2-2. Podstawowy przykładowy kod dla instrukcji if-else

module if_else_example(input logic a, b, output logic y);
    always_comb begin
        if (a == 1'b1) 
            y = b;
        else 
            y = ~b;
    end
endmodule

• Gdy a jest 1, y wyjściowo przyjmuje tę samą wartość co b.
• Gdy a jest 0, y wyjściowo przyjmuje odwróconą wartość b.

2-3. Jak działają instrukcje if-else

1. Układy kombinacyjne (używając always_comb)

• Wyjścia zmieniają się natychmiast w zależności od sygnałów wejściowych.
• Nie są generowane przerzutniki, co pomaga uniknąć niezamierzonego zachowania.
• Zaleca się używać always_comb zamiast always @(*) .

1. Układy sekwencyjne (używające always_ff)

• Dane aktualizują się w synchronizacji z sygnałem zegara.
• Używane do zachowań takich jak przerzutniki D .

2-4. If-else w układach kombinacyjnych

module combination_logic(input logic a, b, output logic y);
    always_comb begin
        if (a == 1'b1) 
            y = b;
        else 
            y = ~b;
    end
endmodule

• Gdy a == 1 : y = b
• Gdy a == 0 : y = ~b

• Użycie always_comb zapewnia, że nie są generowane przerzutniki.
• Należy przypisać wartości dla wszystkich warunków (jeśli pominiesz else, może zostać wywnioskowany przerzutnik).

2-5. If-else w układach sekwencyjnych

module d_flipflop(input logic clk, reset, d, output logic q);
    always_ff @(posedge clk or posedge reset) begin
        if (reset) 
            q <= 1'b0;
        else 
            q <= d;
    end
endmodule

• Gdy reset jest 1, wyjścieqjest resetowane do0`.
• Gdy reset jest 0 i następuje narastające zbocze clk, d jest przechowywane w q.

• Dla układów sekwencyjnych używaj always_ff (nie always @(*)).
• Używaj <= (przypisanie nieblokujące), aby uniknąć niezamierzonych warunków wyścigu.

2-6. Praktyczne przypadki użycia instrukcji if-else

1. Sterowanie diodami LED

• Włączaj/wyłączaj diody LED w zależności od stanu przełącznika.

1. ALU (Jednostka Arytmetyczno‑Logiczna)

• Kontroluj operacje takie jak dodawanie, odejmowanie i operacje logiczne.

1. Przejścia stanów

• Projektowanie skończonych automatów stanów (szczegółowo wyjaśnione w następnym rozdziale).

Podsumowanie

• Instrukcje if-else są używane w Verilogu do implementacji rozgałęzień warunkowych.
• Powinny być prawidłowo stosowane w układach kombinacyjnych (always_comb) i sekwencyjnych (always_ff
• Jeśli nie wszystkie warunki są wyraźnie przypisane, mogą zostać wygenerowane niezamierzone przerzutniki.
• W rzeczywistym projektowaniu układów, if-else jest często używane do sterowania stanami.

3. Zastosowania instrukcji if-else

3-1. Projektowanie układów kombinacyjnych

Przykład 1: sumator 4‑bitowy

module adder(
    input logic [3:0] a, b,
    input logic cin,
    output logic [3:0] sum,
    output logic cout
);
    always_comb begin
        if (cin == 1'b0)
            {cout, sum} = a + b; // no carry
        else
            {cout, sum} = a + b + 1; // with carry
    end
endmodule

Wyjaśnienie

• Jeśli cin jest 0, wykonuje a + b.
• Jeśli cin jest 1, wykonuje a + b + 1 (z uwzględnieniem przeniesienia).
• Użycie always_comb zapewnia, że jest to układ kombinacyjny bez inferencji przerzutników.

3-2. Użycie if-else w układach sekwencyjnych (rejestry)

Przykład 2: przerzutnik D

module d_flipflop(
    input logic clk, reset, d,
    output logic q
);
    always_ff @(posedge clk or posedge reset) begin
        if (reset)
            q <= 1'b0; // reset output to 0
        else
            q <= d;    // store d on clock edge
    end
endmodule

Wyjaśnienie

• Jeśli reset jest 1, q jest resetowane do 0.
• Przy narastającym zboczu clk d jest zapisywane w q.
• Użycie always_ff sprawia, że zachowuje się to jak rejestr przerzutnikowy.

3-3. Użycie instrukcji if-else w przejściach stanów (FSM)

Przykład 3: Prosty układ przejścia stanów

module fsm_toggle(
    input logic clk, reset, btn,
    output logic led_state
);
    typedef enum logic {OFF, ON} state_t;
    state_t state, next_state;

    always_ff @(posedge clk or posedge reset) begin
        if (reset)
            state <= OFF; // initial state
        else
            state <= next_state;
    end

    always_comb begin
        case (state)
            OFF: if (btn) next_state = ON;
                 else next_state = OFF;
            ON:  if (btn) next_state = OFF;
                 else next_state = ON;
            default: next_state = OFF;
        endcase
    end

    assign led_state = (state == ON);
endmodule

Wyjaśnienie

• Zmienna state przechowuje status diody LED (WŁĄCZONA lub WYŁĄCZONA).
• Gdy reset jest 1, dioda LED jest WYŁĄCZONA (stan początkowy).
• Gdy przycisk btn jest naciśnięty, dioda LED przełącza się pomiędzy WŁĄCZONA ⇔ WYŁĄCZONA.
• Użycie instrukcji case do przejść stanów poprawia czytelność.

3-4. Zaawansowane techniki dla instrukcji if-else

① Unikaj głębokiego zagnieżdżania instrukcji if-else

always_comb begin
    if (a == 1) begin
        if (b == 1) begin
            if (c == 1) begin
                y = 1;
            end else begin
                y = 0;
            end
        end else begin
            y = 0;
        end
    end else begin
        y = 0;
    end
end

always_comb begin
    case ({a, b, c})
        3'b111: y = 1;
        default: y = 0;
    endcase
end

• Poprzez wyrażenie warunków jako wektora bitowego i użycie instrukcji case, zagnieżdżenie jest zmniejszone, a czytelność poprawiona.

Podsum

• Instrukcje if-else mogą być używane zarówno w układach kombinacyjnych, jak i sekwencyjnych.
• Używaj always_comb dla logiki kombinacyjnej i always_ff dla logiki sekwencyjnej.
• FSM (Maszyny Stanów Skończonych) często łączą instrukcje if-else i case do zarządzania stanami.
• Unikaj głębokiego zagnieżdżania if-else, wykorzystując instrukcje case lub warunki wektorów bitowych.

4. Różnica między instrukcjami if-else i case

4-1. Co to jest instrukcja case?

Podstawowa składnia case

always_comb begin
    case (condition_variable)
        value1: statement1;
        value2: statement2;
        value3: statement3;
        default: statement4; // if none match
    endcase
end

Przykładowy kod case

module case_example(input logic [1:0] sel, input logic a, b, c, d, output logic y);
    always_comb begin
        case (sel)
            2'b00: y = a;
            2'b01: y = b;
            2'b10: y = c;
            2'b11: y = d;
            default: y = 0; // fallback
        endcase
    end
endmodule

Wyjaśnienie

• W zależności od wartości sel, y jest przypisywane a, b, c lub d.
• Gdy rozgałęzianie opiera się na wielu stałych wartościach, użycie case sprawia, że kod jest bardziej zwięzły.
• Dodanie default zapobiega nieokreślonemu zachowaniu, gdy pojawią się nieoczekiwane wartości.

4-2. Kluczowe różnice między if-else a case

4-3. Kiedy używać if-else vs. case

① Kiedy używać if-else

always_comb begin
    if (value >= 10 && value <= 20)
        output_signal = 1;
    else
        output_signal = 0;
end

• if-else jest lepsze, gdy chodzi o zakresy (np. 10~20).
• case nie może bezpośrednio obsłużyć warunków zakresowych.

always_comb begin
    if (x == 1)
        y = 10;
    else if (x == 2)
        y = 20;
    else if (x == 3)
        y = 30;
    else
        y = 40;
end

• if-else jest najlepsze, gdy wyższe warunki powinny nadpisywać późniejsze.
• Przydatne w logice priorytetowej.

② Kiedy używać case

always_comb begin
    case (state)
        2'b00: next_state = 2'b01;
        2'b01: next_state = 2'b10;
        2'b10: next_state = 2'b00;
        default: next_state = 2'b00;
    endcase
end

• case jest standardem dla przejść stanów FSM.

always_comb begin
    case (opcode)
        4'b0000: instruction = ADD;
        4'b0001: instruction = SUB;
        4'b0010: instruction = AND;
        4'b0011: instruction = OR;
        default: instruction = NOP;
    endcase
end

• Dla dekoderów instrukcji z wieloma wartościami, case zapewnia znacznie lepszą czytelność.

Podsumowanie

5. Najlepsze praktyki dla instrukcji if-else w Verilogu

5-1. Jak zapobiegać inferencji latchy

① Zły przykład (powodujący inferencję latchy)

always_comb begin
    if (a == 1'b1)
        y = b; // when a == 0, y holds its previous value
end

Dlaczego to tworzy latch?

• Jeśli a == 1'b1, wtedy y = b.
• Jeśli a == 0, y nie jest ponownie przypisane, więc zachowuje swoją starą wartość (zachowanie latch).
• To niezamierzone przechowywanie może prowadzić do błędów w projekcie.

② Poprawny przykład (unikający latchy)

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // explicitly assign y
end

③ Użycie domyślnego przypisania

always_comb begin
    y = 1'b0; // default assignment
    if (a == 1'b1)
        y = b;
end

5-2. Użycie always_comb i always

① Logika kombinacyjna (always_comb)

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0;
end

• always_comb automatycznie określa listę wrażliwości ( (*) ), więc nie musisz jej pisać ręcznie.
• Ułatwia zrozumienie zamiaru projektu i pomaga narzędziom w prawidłowej optymalizacji.

② Logika sekwencyjna (always_ff)

always_ff @(posedge clk or posedge reset) begin
    if (reset)
        q <= 1'b0;
    else
        q <= d;
end

• always_ff wyraźnie deklaruje, że ten blok opisuje przerzutnik sterowany zegarem.
• W porównaniu do always @ (posedge clk or posedge reset) poprawia czytelność i zmniejsza liczbę błędów.

5-3. Poprawa czytelności instrukcji if-else

① Redukcja zagnieżdżenia przy użyciu instrukcji case

always_comb begin
    if (mode == 2'b00) begin
        if (enable) begin
            y = a;
        end else begin
            y = b;
        end
    end else begin
        y = c;
    end
end

always_comb begin
    case (mode)
        2'b00: y = enable ? a : b;
        default: y = c;
    endcase
end

• Użycie case sprawia, że rozgałęzienia są czystsze i łatwiejsze do śledzenia.
• Operator trójargumentowy (?) może skrócić proste wyrażenia if-else.

Podsumowanie

6. Najczęściej Zadawane Pytania (FAQ)

Pytanie 1: Dlaczego instrukcje if-else czasami generują latchy w Verilogu? Jak ich uniknąć?

Odpowiedź 1: Przyczyna wnioskowania latchy

Zły przykład (generujący latch)

always_comb begin
    if (a == 1'b1)
        y = b;  // when a == 0, y retains its value
end

Jak uniknąć wnioskowania latchy

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // explicitly assign a value
end

always_comb begin
    y = 1'b0; // default assignment
    if (a == 1'b1)
        y = b;
end

Pytanie 2: Jaka jest różnica między instrukcjami if-else a case? Której powinienem używać?

Odpowiedź 2: Wytyczne dotyczące użycia

Pytanie 3: Czy instrukcje if-else wpływają na szybkość przetwarzania w Verilogu?

Odpowiedź 3: Wydajność zależy od syntezy obwodu

• Verilog jest językiem opisu sprzętu; prędkość wykonania zależy od struktury sprzętu po syntezie, a nie od samego kodu.
• Głęboko zagnieżdżone instrukcje if-else mogą prowadzić do dłuższych ścieżek logicznych i zwiększać opóźnienie propagacji.
• Jednak narzędzia syntezy wykonują optymalizacje, więc logicznie równoważne układy zazwyczaj mają minimalne różnice w wydajności.

always_comb begin
    case (a)
        1: y = 10;
        2: y = 20;
        default: y = 30;
    endcase
end

Q4: Czy powinienem używać = czy <= w przypisaniach if-else?

A4: Blokujące (=) vs. nieblokujące (<=)

always_comb begin
    if (a == 1)
        y = b; // blocking assignment
end

always_ff @(posedge clk) begin
    if (reset)
        y <= 0; // non-blocking assignment
    else
        y <= d;
end

Q5: Jak mogę zredukować głębokie zagnieżdżenie w instrukcjach if-else?

A5: Użyj instrukcji case lub operatora trójargumentowego

always_comb begin
    if (mode == 2'b00) begin
        if (enable) begin
            y = a;
        end else begin
            y = b;
        end
    end else begin
        y = c;
    end
end

always_comb begin
    case (mode)
        2'b00: y = enable ? a : b;
        default: y = c;
    endcase
end

Podsumowanie

7. Zakończenie

7-1. Kluczowe punkty if-else w Verilogu

✅ Podstawowa składnia

• if-else jest podstawowym konstruktem do warunkowego rozgałęziania.
• W obwodach kombinacyjnych używaj always_comb i upewnij się, że wszystkie warunki przypisują wartości.

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // prevent latches with default assignment
end

• W obwodach sekwencyjnych (z zegarem) używaj always_ff z nieblokującymi przypisaniami (<=).

always_ff @(posedge clk or posedge reset) begin
    if (reset)
        q <= 1'b0;
    else
        q <= d;
end

7-2. Poprawne użycie if-else

• Używaj always_comb i przypisuj wartości we wszystkich warunkach, aby unikać inferencji latchy.
• Ustawiaj wartości domyślne, aby zapobiec nieokreślonemu zachowaniu.

• Używaj always_ff z if-else, aby aktualizować stan przy zboczu zegara.
• Używaj <= (przypisanie nieblokujące), aby zachować spójność symulacji i zachowania sprzętu.

7-3. Kiedy zamiast tego używać case

7-4. Dobre praktyki

always_comb begin
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0; // always assign explicitly
end

always_comb begin // combinational
    if (a == 1'b1)
        y = b;
    else
        y = 1'b0;
end

always_ff @(posedge clk) begin // sequential
    if (reset)
        y <= 0;
    else
        y <= d;
end

always_comb begin
    case (sel)
        2'b00: y = a;
        2'b01: y = b;
        2'b10: y = c;
        default: y = d;
    endcase
end

7-5. Częste błędy i ich poprawki

7-6. Podsumowanie końcowe

7-7. Kolejne kroki