Istruzioni if-else in Verilog spiegate: sintassi, esempi e migliori pratiche

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

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

1. Introduzione

1-1. Che cos’è un’istruzione if-else in Verilog?

• Branching condizionale nei circuiti combinazionali
• Controllo dei circuiti sequenziali (ad es., flip‑flop)
• Controllo dinamico dei segnali (ad es., multiplexer o operazioni condizionali)

1-2. Problemi causati dall’uso improprio delle istruzioni if-else

1. Vengono generati latch indesiderati

• Se non tutte le condizioni sono definite esplicitamente nei rami, lo strumento di sintesi può generare latch (elementi di memoria). *ò può provocare un comportamento di memorizz non voluto e impedire al circuito di funzionare come previsto.

2. I risultati della simulazione differiscono da quelli della sintesi

• Anche se la simulazione funziona come previsto, il comportamento può cambiare quando il progetto è implementato su FPGA o ASIC.
• Questo accade perché alcuni stili di codifica if-else possono indurre gli strumenti di sintesi a eseguire ottimizzazioni errate.

3. Ridotta leggibilità del codice

• Istruzioni if-else profondamente annidate rendono il codice più difficile da leggere e mantenere.
• In molti casi, l’uso di un’istruzione case al loro posto può rendere il codice più chiaro.

1-3. Scopo di questo articolo

• Il modo corretto di usare le istruzioni if-else
• Come scrivere codice Verilog che eviti latch non intenzionali
• Quando usare if-else vs. case
• Le migliori pratiche per la progettazione Verilog

2. Sintassi di base delle istruzioni if-else in Verilog

2-1. Come scrivere le istruzioni 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. Codice di esempio di base per le istruzioni 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

• Quando a è 1, y restituisce lo stesso valore di b.
• Quando a è 0, y restituisce il valore invertito di b.

2-3. Come funzionano le istruzioni if-else

1. Circuiti combinazionali (usando always_comb)

• Le uscite cambiano immediatamente in base ai segnali di ingresso.
• Non vengono generati latch, il che aiuta a evitare comportamenti indesiderati.
• Si consiglia di usare always_comb invece di always @(*) .

1. Circuiti sequenziali (usando always_ff)

• I dati vengono aggiornati in sincronia con il segnale di clock.
• Utilizzato per comportamenti come D flip-flop .

2-4. If-else nei circuiti combinazionali

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

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

• L’uso di always_comb garantisce che non vengano generati latch.
• È necessario assegnare valori per tutte le condizioni (se si omette else, potrebbe essere inferito un latch).

2-5. If-else nei circuiti sequenziali

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

• Quando reset è 1, l’output q viene azzerato a 0.
• Quando reset è 0 e si verifica il fronte di salita di clk, d viene memorizzato in q.

• Per i circuiti sequenziali, usa always_ff (non always @(*)).
• Usa <= (assegnazione non bloccante) per evitare condizioni di gara indesiderate.

2-6. Casi d’uso pratici delle istruzioni if-else

1. Controllo LED * Accendere/spegnere i LED a seconda dello stato di un interruttore.
2. ALU (Unità Aritmetico-Logica) * Controllare operazioni come addizione, sottrazione e operazioni logiche.
3. Transizioni stato * Progettare macchine a stati finiti (spiegato in dettaglio nella sezione successiva).

Riepilogo

• Le istruzioni if-else sono usate in Verilog per implementare rami condizionali.
• Dovrebbero essere applicate correttamente ai circuiti combinazionali (always_comb) e ai circuiti sequenziali (always_ff).
• Se tutte le condizioni non sono assegnate esplicitamente, potrebbero essere generati latch indesiderati.
• Nella progettazione reale dei circuiti, if-else è spesso usato per controllare gli stati.

3. Applicazioni delle istruzioni if-else

3-1. Progettazione di circuiti combinazionali

Esempio 1: adder a 4 bit

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

Spiegazione

• Se cin è 0, esegue a + b.
• Se cin è 1, esegue a + b + 1 (riporto incluso).
• L’uso di always_comb garantisce che questo sia un circuito combinazionale senza infer di latch.

3-2. Uso di if-else nei circuiti sequenziali (registri

Esempio 2: D flip-flop

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

Spiegazione

• Se reset è 1, q viene resettato a 0.
• Sul fronte di salita di clk, d viene memorizzato inq`.
• L’uso di always_ff fa sì che questo si comporti come un registro flip-flop.

3-3. Utilizzare le istruzioni if-else nelle transizioni di stato (FSM)

Esempio 3: Circuito di transizione di stato semplice

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

Spiegazione

• La variabile state contiene lo stato del LED (ON o OFF).
• Quando reset è 1, il LED è OFF (stato iniziale).
• Quando btn è premuto, il LED commuta tra ON ⇔ OFF.
• L’uso di un’istruzione case per le transizioni di stato migliora la leggibilità.

3-4. Tecniche avanzate per le istruzioni if-else

① Evitare annidamenti profondi di istruzioni 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

• Espressando le condizioni come un vettore di bit e usando un’istruzione case, l’annidamento è ridotto e la leggibilità è migliorata.

Riepilogo

• Le istruzioni if-else possono essere usate sia nei circuiti combinatori che sequenziali.
• Usaalways_combper la logica combinatoria ealways_ff` per la logica sequenziale.
• Le FSM (Finite State Machines) spesso combinano istruzioni if-else e case per gestire gli stati.
• Evita annidamenti profondi di if-else sfruttando istruzioni case o condizioni a vettore di bit.

4. Differenza tra istruzioni if-else e case

4-1. Cos’è un’istruzione case?

Sintassi di base del case

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

Codice di esempio 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

Spiegazione

• A seconda del valore di sel, y viene assegnato a a, b, c o d.
• Quando si ramifica su più valori fissi, l’uso di case rende il codice più conciso.
• L’inclusione di default previene comportamenti indefiniti quando compaiono valori inaspettati.

4-2. Differenze chiave tra if-else e case

4-3. Quando usare if-else vs. case

① Quando usare if-else

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

• if-else è migliore quando si gestiscono intervalli (es., 10~20).
• case non può gestire direttamente condizioni di intervallo.

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 è migliore quando le condizioni più alte devono sovrascrivere quelle successive.
• Utile per logica di priorità.

② Quando usare 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 è lo standard per le transizioni di stato 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

• Per i decoder di istruzioni con molti valori, case offre una leggibilità molto maggiore.

Riepilogo

5. Buone pratiche per le istruzioni if-else in Verilog

5-1. Come prevenire l’inferenza di latch

① Esempio errato (causa inferenza di latch)

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

Perché questo crea un latch?

• Se a == 1'b1, allora y = b.
• Se a == 0, y non viene riassegnato, quindi mantiene il suo valore precedente (comportamento di latch).
• Questa memorizzazione non intenzionale può portare a bug di progetto.

② Esempio corretto (evita il latch)

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

③ Uso di un’assegnazione di default

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

5-. Uso di always_comb e always_ff

① Logica combinatoria (always_comb)

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

• always_comb determina automaticamente la lista di sensibilità ( (*) ), quindi non è necessario scriverla manualmente.
• Rende più chiara l’intenzione del progetto e aiuta gli strumenti a ottimizzare correttamente.

② Logica sequenziale (always_ff)

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

• always_ff dichiara esplicitamente che questo blocco descrive un flip‑flop guidato dal clock.
• Rispetto a always @ (posedge clk or posedge reset), migliora la leggibilità e riduce gli errori.

5-3. Migliorare la leggibilità delle istruzioni if‑else

① Ridurre l’annidamento con le istruzioni 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

• Usare case rende il branching più pulito e più facile da seguire.
• L’operatore ternario (?) può abbreviare le espressioni if‑else semplici.

Riepilogo

6. Domande Frequenti (FAQ)

Q1: Perché le istruzioni if‑else a volte generano latch in Verilog? Come posso evitarlo?

A1: Cause dell’inferenza di latch

Esempio cattivo (che genera latch)

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

Come evitare l’inferenza di latch

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

A2: Linee guida d’uso

Q3: Le istruzioni if‑else influenzano la velocità di elaborazione in Verilog?

A3: Le prestazioni dipendono dalla sintesi del circuito

• Verilog è un linguaggio di descrizione hardware; la velocità di esecuzione dipende dalla struttura hardware sintetizzata, non dal codice stesso.
• Le istruzioni if-else profondamente annidate possono generare percorsi logici più lunghi e aumentare il ritardo di propagazione.
• Tuttavia, gli strumenti di sintesi eseguono ottimizzazioni, quindi i circuiti logicamente equivalenti di solito hanno differenze di prestazioni minime.

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

Q4: Devo usare = o <= nelle assegnazioni if-else?

A4: Bloccante (=) vs. non bloccante (<=)

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: Come posso ridurre l’annidamento profondo nelle istruzioni if-else?

A5: Usa l’operatore case o ternario

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

Riepilogo

7. Conclusione

7-1. Punti chiave di Verilog if-else

✅ Sintassi di base

• if-else è il costrutto di base per la ramificazione condizionale.
• Nei circuiti combinazionali, usa always_comb e assicurati che tutte le condizioni assegnino valori.

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

• Nei circuiti sequenziali (guidati dal clock), usa always_ff con assegnazioni non bloccanti ( <= ).

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

7-2. Uso corretto di if-else

• Usa always_comb e assegna valori in tutte le condizioni per evitare l’inferenza di latch.
• Imposta valori di default per prevenire comportamenti indefiniti.

• Usa always_ff con if-else per aggiornare lo stato ai fronti di clock.
• Usa <= (assegnazione non bloccante) per mantenere coerenti simulazione e comportamento hardware.

7-3. Quando usare case invece

7-4. Migliori pratiche

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. Errori comuni e correzioni

7-6. Riepilogo finale

7-7. Prossimi passi