Verilog if-else: Bedingte Logik in prozeduralen Blöcken

Vertraute Syntax, anderes mentales Modell

if/else sieht genauso aus wie in C:

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

Aber die Regeln sind anders, weil Verilog keine Software ist. Zwei Dinge zu beachten:

1. if/else lebt nur innerhalb eines prozeduralen Blocks. Du kannst kein freistehendes if auf Modul-Ebene schreiben.
2. Wozu das if/else synthetisiert, hängt vom Blocktyp ab. In einem kombinatorischen Block wird es zu einem Multiplexer oder Priority Encoder. In einem getakteten Block wird es zu einem Flip-Flop mit bedingter Update-Logik.

In einem kombinatorischen Block

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

Der kombinatorische always @(*)-Block läuft jedes Mal neu, wenn sich a, b oder c ändert. Die if/else-Kette wählt einen Zweig, weist max zu, und der Block ist fertig. Da max immer zugewiesen wird (jeder Pfad hat eine Zuweisung), erzeugt der Synthesizer reine kombinatorische Logik - kein Latch.

Beachte, dass max als reg deklariert ist, obwohl in der Hardware kein Flip-Flop existiert. Gleiche Regel wie immer: Alles, was in einem always zugewiesen wird, muss reg sein.

Die Latch-Falle

Das ist der häufigste Bug in kombinatorischem Anfänger-Code:

// FALSCH - leitet ein Latch ab
always @(*) begin
    if (enable)
        out = data;
    // kein else! Was tut `out`, wenn `enable` low ist?
end

Der Synthesizer liest "wenn enable low ist, wird out nicht zugewiesen" und entscheidet, dass out seinen vorherigen Wert behalten muss. Einen Wert zu erinnern braucht eine Speicherzelle, also fügt das Tool ein Latch ein. Latches in synchronen Designs verursachen Timing-Probleme, sind schwer zu resetten und sind fast nie das, was du gemeint hast.

Zwei Wege zur Lösung:

// Fix 1: explizites else
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-Zuweisung oben
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // erst Default
        if (enable) out = data; // konditional überschreiben
    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

Beide erzeugen dieselbe kombinatorische Hardware - einen 2-zu-1-Mux. Das Muster "Default oben" skaliert besser, wenn du viele konditionale Zuweisungen auf dasselbe Signal hast.

In einem getakteten Block

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: implizites Halten (count behält Wert - das tut ein Flip-Flop)
    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

Sieh, was anders ist als im kombinatorischen Fall:

• Der Block ist always @(posedge clk) - Flip-Flop-Territorium.
• Zuweisung nutzt <= (non-blocking).
• Es gibt kein else für den "weder reset noch enable"-Fall. Das ist okay. In einem getakteten Block, wenn kein Zweig feuert, behält das Flip-Flop einfach seinen vorigen Wert - genau das, was ein Flip-Flop physisch tut. Kein Latch wird abgeleitet, weil das Signal bereits ein Register ist.

Das ist die eine Stelle, an der das Weglassen eines else sicher ist. Außerhalb getakteter Blöcke immer jeden Pfad behandeln.

Verkettete else if: Ein Priority Encoder

Eine Kette von else if-Anweisungen hat implizite Priorität - frühere Bedingungen schlagen spätere:

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] hat höchste Priorität - ist es gesetzt, ist grant 0, egal was die höherwertigen Bits tun. Der Synthesizer verwandelt die Kette in einen kaskadierten Mux: erst Bit 0 prüfen, dann Bit 1, dann Bit 2, dann Bit 3. Jede Ebene fügt etwas Delay hinzu.

Sind die Bedingungen sich gegenseitig ausschließend - etwa beim Decodieren eines One-Hot-Eingangs -, produziert eine case-Anweisung (nächstes Doc) flachere, schnellere Hardware als eine else if-Kette. Nimm die case-Form, wenn keine echte Prioritäts-Anforderung besteht.

if ohne else in getaktetem Code

Ein getakteter Block braucht kein else, weil "vorigen Wert halten" der Default ist. Damit baut man Enables:

always @(posedge clk) begin
    if (load) target <= incoming;
    // kein else: wenn load low ist, behält target seinen Wert
end

Das ist ein Load-Enable-Register. Die meisten Pipeline-Register, Zähler und Konfigurationsregister nutzen dieses Muster.

begin/end und einzelne Anweisungen

Wie in C kannst du begin/end für eine einzelne Anweisung weglassen:

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

Für mehr als eine Anweisung nimm den Block:

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

Die beiden Muster lassen sich frei mischen. Style-Guides empfehlen allgemein, immer begin/end zu verwenden, damit das Hinzufügen einer zweiten Anweisung schmerzlos ist.

Wie es weitergeht

Das nächste Doc - Case-Anweisung - behandelt case, das richtige Werkzeug für Mehrweg-Decoding (Automaten, Opcode-Dispatch, ROM-Tabellen). Danach folgen for-Schleifen, die sich subtil von ihren Software-Verwandten unterscheiden, weil sie zur Elaborationszeit aufgerollt werden.