Verilog case-Anweisung: Mehrweg-Decoding richtig gemacht

Die Mehrweg-Verzweigung

case ist Verilogs flaches Dispatch-Konstrukt. Du gibst ihm einen Ausdruck; er wählt den passenden Zweig:

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

Es ist strukturell ähnlich zum switch aus C, aber:

• Es gibt kein break - jeder Zweig wird implizit vom nächsten beendet.
• Muster können Vektoren sein, nicht nur Ganzzahlen.
• Der Synthesizer verwandelt das Ganze in einen flachen Mux (oder einen One-Hot-Decoder, wenn die Muster es ermöglichen).

Ein durchgearbeitetes Beispiel: 4-zu-1-Mux

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

Der case-Body hat vier explizite Muster plus ein default. Der Synthesizer sieht einen 2-Bit-Eingang, der auf einen von vier Werten gemappt wird, und erzeugt einen 4-zu-1-Multiplexer. Sauber, flach, schnell.

Warum du default brauchst

Bei kombinatorischem case ist das Weglassen von default dieselbe Falle wie ein if ohne else: Jeder ungematchte Eingangswert lässt out unzugewiesen, und der Synthesizer leitet ein Latch ab.

Bei einem 2-Bit-sel decken die obigen Muster alle vier möglichen Werte ab - theoretisch ist default also redundant. In der Praxis:

1. Der Synthesizer beweist nicht immer, dass die Cases vollständig sind.
2. Der Selektor kann in der Simulation x oder z sein, was zu keinem expliziten Case passt.
3. Ein später hinzugefügter Case kann das Default-Verhalten unspezifiziert lassen.

Schreibe immer default. Für Automaten und Mux-Logik, bei der du weißt, dass der Default unerreichbar ist, weise 'x zu:

default: out = 8'bx;

… das sagt dem Synthesizer "das ist ein Don't-Care, optimiere frei" und lässt in der Simulation ein leuchtend rotes x auftauchen, falls der unerreichbare Case doch erreicht wird. Das ist das Beste aus beiden Welten.

Ein Automat in case

Die klassische Anwendung von case ist die Zustandsübergangs-Logik eines endlichen Automaten:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=rot, 01=gelb, 10=grün
);
    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

Der case (state)-Block ist die Zustandsübergangs-Logik. Jeder Zweig entscheidet, was der nächste Zustand ist und wie lange darin verweilt wird. default ist hier unerreichbar (wir decken RED/GREEN/YELLOW im 2-Bit-Raum vollständig ab), aber er ist als Sicherheitsnetz da - falls state irgendwie 2'd3 wird, resettet der Automat sauber auf RED, statt zu latchen.

Endliche Automaten geht in diesem Muster in die Tiefe.

Mehrere Muster pro Zweig

Du kannst mehrere Muster auflisten, die sich eine einzige Anweisung teilen, getrennt durch Kommas:

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

Das sind zwei Opcodes, die beide "subtrahieren" bedeuten, und drei, die "addieren" bedeuten. Der Synthesizer ODER't die Muster für den Komparator zusammen.

casez und casex: Don't-Care-Matching

Manchmal willst du ein Muster matchen, bei dem manche Bits unspezifiziert sind - "jeder Opcode, der mit 010 anfängt":

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

casez behandelt ? (und z) im Muster als Don't-Cares. Jedes ? matcht 0 oder 1. Nützlich zum Decodieren von Instruktionsformaten, bei denen einige Bit-Positionen für bestimmte Opcode-Klassen ungenutzt sind.

casex erweitert das und behandelt auch x als Don't-Care. casex ist gefährlich, weil uninitialisierte Signale (die in der Simulation x sind) zu jedem Case passen und überraschendes Verhalten erzeugen. Die meisten modernen Style-Guides empfehlen casez und verbieten casex.

In SystemVerilog gibt es zudem case inside, das die sauberste Variante ist - es akzeptiert Bereiche und Listen -, aber klassisches Verilog hört bei casez auf.

case vs if/else if-Kette

Beide Konstrukte können Mehrweg-Entscheidungen ausdrücken, aber sie synthetisieren zu unterschiedlicher Hardware:

• case ist ein flaches Dispatch. Der Synthesizer kann einen One-Hot-Decoder, einen balancierten Mux-Baum oder andere flache Strukturen erzeugen. Konstante Auswertungszeit.
• if/else if ist eine Prioritätskette. Der Synthesizer erzeugt eine Kaskade, bei der jede Ebene Verzögerung hinzufügt. Logarithmisch langsamer.

Funktional überlappen sie. Stilistisch: Nutze case, wann immer die Bedingungen den Wert eines einzelnen Ausdrucks betreffen. Nutze if/else if, wenn es eine echte Priorität gibt oder Bedingungen verschiedene Signale betreffen.

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

// Besser als 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;

Die ersten drei Bedingungen sind alle "was ist sel?" - ein case liest sich natürlicher und synthetisiert flacher. Die zweiten drei sind unabhängige Ereignisse mit einer offensichtlichen Priorität - if/else if passt besser.

Wie es weitergeht

Das letzte Doc dieses Kapitels - For-Schleifen - behandelt Verilogs for und das Überraschende, das passiert, wenn du es in synthetisierbarem Code benutzt. Danach geht es ernsthaft in sequentielle Logik und Automaten.