Istruzione case in Verilog: decodifica a più vie fatta bene

La diramazione a più vie

case è il costrutto di smistamento piatto di Verilog. Gli dai un'espressione e lui sceglie il ramo corrispondente:

case (expression)
    pattern_1: statement_1;
    pattern_2: statement_2;
    pattern_3: begin
        statement_3a;
        statement_3b;
    end
    default: default_statement;
endcase

Strutturalmente somiglia allo switch del C, ma:

• Non esiste break: ogni ramo termina implicitamente dove inizia il successivo.
• I pattern possono essere vettori, non solo interi.
• Il sintetizzatore trasforma l'intero costrutto in un mux piatto (o in un decodificatore one-hot, quando i pattern lo permettono).

Un esempio completo: mux 4 a 1

module mux4(
    input  wire [1:0] sel,
    input  wire [7:0] in0, in1, in2, in3,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 8'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [7:0] out;
    wire [7:0] a = 8'hA0, b = 8'hB0, c = 8'hC0, d = 8'hD0;

    mux4 dut(.sel(sel), .in0(a), .in1(b), .in2(c), .in3(d), .out(out));

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

Il corpo del case ha quattro pattern espliciti più un default. Il sintetizzatore vede un ingresso a 2 bit che corrisponde a uno di quattro valori e genera un multiplexer 4 a 1. Pulito, piatto, veloce.

Perché ti serve default

In un case combinatorio, omettere default è la stessa trappola di un if senza else: qualsiasi valore di ingresso non previsto lascia out senza assegnazione e il sintetizzatore deduce un latch.

Con un sel a 2 bit, i pattern qui sopra coprono tutti e quattro i valori possibili, quindi in teoria default è superfluo. In pratica:

1. Il sintetizzatore non riesce sempre a dimostrare che i casi sono esaustivi.
2. In simulazione il selettore può valere x o z, che non corrisponde a nessun caso esplicito.
3. Aggiungere un nuovo caso in seguito potrebbe lasciare il comportamento di default non specificato.

Scrivi sempre default. Per macchine a stati e logica di mux in cui sai che il default è irraggiungibile, l'assegnazione a 'x:

default: out = 8'bx;

…dice al sintetizzatore "questo è un don't care, ottimizza liberamente" e fa comparire in simulazione un x ben visibile se in qualche modo il caso irraggiungibile viene raggiunto. Il meglio dei due mondi.

Una macchina a stati con case

L'uso classico di case è la logica di transizione tra stati di una macchina a stati finiti:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=red, 01=yellow, 10=green
);
    localparam RED    = 2'd0;
    localparam GREEN  = 2'd1;
    localparam YELLOW = 2'd2;

    reg [1:0] state;
    reg [3:0] timer;

    always @(posedge clk) begin
        if (reset) begin
            state <= RED;
            timer <= 4'd0;
        end else if (timer == 4'd0) begin
            case (state)
                RED:    begin state <= GREEN;  timer <= 4'd6; end
                GREEN:  begin state <= YELLOW; timer <= 4'd2; end
                YELLOW: begin state <= RED;    timer <= 4'd5; end
                default: begin state <= RED;   timer <= 4'd0; end
            endcase
        end else begin
            timer <= timer - 4'd1;
        end
    end

    always @(*) light = state;
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [1:0] light;
    traffic_light dut(.clk(clk), .reset(reset), .light(light));

    always #5 clk = ~clk;

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

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

Il blocco case (state) è la logica di transizione. Ogni ramo decide qual è lo stato successivo e per quanto tempo restarci. Qui default è irraggiungibile (copriamo in modo esaustivo RED/GREEN/YELLOW nello spazio a 2 bit), ma c'è come rete di sicurezza: se state diventasse in qualche modo 2'd3, la FSM tornerebbe pulitamente a RED invece di generare un latch.

Finite State Machines approfondisce questo pattern.

Più pattern per ramo

Puoi elencare più pattern che condividono una singola istruzione, separandoli con virgole:

case (opcode)
    4'h0, 4'h1, 4'h2: result = a + b;
    4'h3, 4'h4:       result = a - b;
    4'h8:             result = a & b;
    default:          result = 8'd0;
endcase

Qui due opcode significano entrambi "sottrai" e tre significano "somma". Il sintetizzatore mette in OR i pattern per costruire il comparatore.

casez e casex: confronto con don't care

A volte vuoi confrontare un pattern lasciando alcuni bit non specificati, per esempio "qualsiasi opcode che inizia con 010":

casez (opcode)
    8'b010?_????: instruction = ALU_OP;
    8'b110?_????: instruction = LOAD_OP;
    8'b1110_????: instruction = JUMP_OP;
    default:      instruction = UNKNOWN;
endcasez

casez tratta ? (e z) nel pattern come don't care. Ogni ? corrisponde sia a 0 sia a 1. È utile per decodificare formati di istruzione in cui alcune posizioni di bit non sono usate da certe classi di opcode.

casex estende il meccanismo trattando come don't care anche x. casex è pericoloso perché i segnali non inizializzati (che in simulazione valgono x) corrispondono a ogni caso, con comportamenti sorprendenti. La maggior parte delle guide di stile moderne consiglia casez e vieta casex.

In SystemVerilog hai anche case inside, la versione più pulita di tutte (accetta intervalli ed elenchi), ma il Verilog semplice si ferma a casez.

case contro una catena di if/else if

Entrambi i costrutti possono esprimere decisioni a più vie, ma si sintetizzano in hardware diverso:

• case è uno smistamento piatto. Il sintetizzatore può produrre un decodificatore one-hot, un albero di mux bilanciato o altre strutture piatte. Il tempo di valutazione è costante.
• if/else if è una catena di priorità. Il sintetizzatore produce una cascata in cui ogni livello aggiunge ritardo. È più lento in modo logaritmico.

Dal punto di vista funzionale si sovrappongono. Come stile: usa case quando le condizioni riguardano il valore di una singola espressione. Usa if/else if quando esiste una vera priorità o quando le condizioni coinvolgono segnali diversi.

// Better as case:
if      (sel == 2'd0) out = a;
else if (sel == 2'd1) out = b;
else if (sel == 2'd2) out = c;
else                  out = d;

// Better as if/else if:
if      (urgent_event)  next_state = HANDLE_URGENT;
else if (timer_expired) next_state = TIMEOUT;
else if (data_ready)    next_state = PROCESS;
else                    next_state = state;

Le prime tre condizioni si chiedono tutte "quanto vale sel?": un case si legge in modo più naturale e si sintetizza più piatto. Le altre tre sono eventi indipendenti con una priorità evidente: qui if/else if è la scelta migliore.

Cosa viene dopo

L'ultima pagina di questo capitolo, For Loops, tratta il for di Verilog e la cosa sorprendente che succede quando lo usi in codice sintetizzabile. Poi entriamo sul serio nella logica sequenziale e nelle FSM.