Verilog Always-Block: Kombinatorische und sequentielle Logik

Das Arbeitspferd des Verhaltens-Verilog

assign beschreibt kombinatorische Logik aus einer einzelnen Gleichung. Sobald du if/else, case oder Speicher brauchst, greifst du zu always. Ein always-Block ist ein Stück prozeduraler Code, der jedes Mal neu läuft, wenn sich bestimmte Signale ändern. Die Signale, die das Neu-Laufen auslösen, sind die Sensitivitätsliste.

Zwei Formen von always siehst du am häufigsten:

1. always @(*) - läuft neu, wenn sich irgendein im Block gelesenes Signal ändert. Baut kombinatorische Logik.
2. always @(posedge clk) - läuft nur bei steigender Flanke von clk neu. Baut getaktete sequentielle Logik (Flip-Flops).

Andere Formen existieren (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), aber die beiden oben decken fast jeden synthetisierbaren Block ab, den du schreibst.

Kombinatorisches always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

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

Drei Dinge fallen auf:

• out ist reg. Alles, was in einem always zugewiesen wird, muss reg sein. Das Schlüsselwort heißt hier nicht "das ist ein Flip-Flop"; es heißt nur "ich werde aus einem prozeduralen Block geschrieben".
• always @(*). Der * sagt: "Wach auf, wann immer sich etwas ändert, das ich lese." Der Simulator ermittelt die Sensitivitätsliste automatisch. Du kannst die Liste auch von Hand schreiben - always @(sel) -, aber @(*) ist sicherer, weil ein vergessenes Signal eine klassische Bug-Quelle ist.
• Kein Takt. Dieser Block beschreibt kombinatorische Logik. Der Synthesizer erzeugt ein Stück Logik, das out direkt aus sel berechnet - keine Flip-Flops, kein Takt-Pin nötig.

Der default-Fall ist im Geist nicht optional, auch wenn er es in der Syntax ist. Lass ihn weg, und jeder nicht spezifizierte Eingangswert lässt out seinen alten Wert behalten - was zu einem unbeabsichtigten Latch synthetisiert. Schreib immer den default.

Sequentielles always @(posedge clk)

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

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

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

Die wichtigsten Unterschiede zur kombinatorischen Version:

• always @(posedge clk). Der Block läuft nur bei steigender Flanke von clk neu. Zwischen den Flanken passiert nichts.
• Non-blocking-Zuweisung <=. Innerhalb eines getakteten Blocks ist das der richtige Operator. Er sagt: "Plane count so, dass es am Ende des Zeitschritts seinen neuen Wert annimmt" - genau so verhält sich ein Flip-Flop. Das Warum und die Alternative liegen in Blocking vs Non-blocking.
• Kein default nötig. Das if deckt beide Zweige ab (Reset und Nicht-Reset). Kein Latch-Risiko.

Der Synthesizer sieht diese Form - getaktete Sensitivität, non-blocking-Zuweisung - und erzeugt ein 4-Bit-Register (vier Flip-Flops) plus die kombinatorische Logik, die count + 1 berechnet, und den Mux, der zwischen Reset und Inkrement auswählt.

Der Synthese-Unterschied

Derselbe Modul-Quelltext kann je nach Form des always-Blocks zwei völlig verschiedene Stücke Hardware beschreiben:

Block	Hardware
always @(*) y = expr;	Pure kombinatorische Logik. Kein Gedächtnis.
always @(posedge clk) y <= expr;	Flip-Flop. Erfasst expr einmal pro Taktzyklus.
always @(*) if (en) y = expr;	Latch - üblicherweise ein Bug. Der "else"-Fall behält den alten Wert.
always @(posedge clk) if (en) y <= expr;	Flip-Flop mit Enable. Erfasst nur, wenn en high ist.

Der dritte Fall ist die Latch-Falle. Ein Latch ist eine transparente Speicherzelle, die ihren Ausgang hält, solange der Eingang nicht aktiv ist - in bestimmten Designs nützlich, fast immer ein Bug, wenn versehentlich. Die meisten Synthese-Tools warnen laut, wenn sie ein Latch ableiten, das du nicht wolltest. Behandle die Warnung als Fehler.

Varianten der Sensitivitätsliste

Du wirst ein paar weniger häufige Sensitivitätslisten sehen:

• always @(a or b or c) - explizite Liste. Verilog-2001 hat den ,-Separator hinzugefügt: always @(a, b, c). Beides funktioniert.
• always @(posedge clk or negedge reset_n) - asynchroner Reset. Der Block läuft bei einer steigenden Taktflanke oder einer fallenden Resetflanke. Wird verwendet, wenn Reset sofort wirken muss und nicht auf den nächsten Takt warten kann.
• always @(negedge clk) - Taktung an der fallenden Flanke. Selten; manche Designs nutzen es für "fallend-flankengesteuerte" Flip-Flops, die statt an der steigenden an der fallenden Flanke erfassen.

Bevorzuge in neuen Designs always @(*) für kombinatorisch und always @(posedge clk) für sequentiell. Greife nur dann zum asynchronen Reset, wenn das Design ihn wirklich braucht.

Zwei Blöcke sind zwei Stücke Hardware

Mehrere always-Blöcke im selben Modul sind unabhängig - jeder wird zu seinem eigenen Stück Hardware:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sequentiell
    output reg  [7:0] comb_out    // kombinatorisch
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // bitweise invertiert
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

Der getaktete Block erzeugt ein Flip-Flop-Register. Der kombinatorische Block erzeugt ein XOR-Gatter. Sie leben nebeneinander; keiner weiß vom anderen. Die beiden Ausgänge ändern sich nach völlig unterschiedlichen Zeitplänen.

Was always-Blöcke nicht können

Ein paar Dinge, die verlockend aussehen, aber nicht erlaubt sind:

• Einem wire zuweisen: Das Ziel muss reg sein. Compiler-erzwungen.
• Denselben reg aus zwei verschiedenen always-Blöcken zuweisen: erzeugt undefiniertes Verhalten in der Simulation und synthetisiert nicht. Ein Treiber pro Signal.
• Im selben kombinatorischen Block dasselbe Signal lesen und schreiben in einer Weise, die eine Rückkopplungsschleife erzeugt: always @(*) x = x + 1; ist eine Zero-Delay-Schleife, die der Simulator nicht auflösen kann.

Die ersten beiden fängt der Compiler ab. Das dritte zeigt sich manchmal erst in der Simulation als Hänger.

Wie es weitergeht

Das nächste Doc - Initial-Block - behandelt das Geschwister von always: einen Block, der genau einmal beim Simulationsstart läuft. Das ist das Arbeitspferd von Testbenches. Danach folgen die Regeln für blocking vs non-blocking-Zuweisung, die entscheiden, ob dein getakteter Block das tut, was du gemeint hast.