Verilog getaktete Logik: Flip-Flops, Register und Pipelines

Der Baustein: Ein D-Flip-Flop

Alles im synchronen Design läuft auf ein winziges Stück Hardware zurück: das D-Flip-Flop. Es hat einen Takteingang, einen Daten-Eingang und einen Daten-Ausgang. An jeder steigenden Taktflanke erfasst es den Wert von D und hält ihn bis zur nächsten Flanke. Das war's.

In Verilog:

always @(posedge clk) begin
    q <= d;
end

Drei Zeilen, ein Flip-Flop. Das <= ist non-blocking, was genau dem Verhalten echter Flip-Flops entspricht (siehe Blocking vs Non-blocking). Die posedge clk-Sensitivität macht es sequentiell.

Stapele viele davon mit kombinatorischer Logik dazwischen und du hast jede synchrone Schaltung, die du bauen willst.

Ein Register mit Reset

Echte Designs brauchen immer einen Reset - einen Weg, das System beim Einschalten oder auf Anforderung in einen bekannten Zustand zu setzen:

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

Das ist ein synchroner Reset - die Reset-Bedingung wird wie jeder andere Eingang an einer Taktflanke ausgewertet. Der Synthesizer erzeugt ein Flip-Flop mit einem 2-zu-1-Mux am Daten-Eingang: ist reset high, speist der Mux Null; sonst d.

Für die meisten Designs ist synchroner Reset die richtige Wahl. Einfacheres Timing, gutes Zusammenspiel mit FPGAs, und das Reset-Signal kann von überall kommen - es braucht keine eigene takt-ausgerichtete Quelle.

Ein Register mit Enable

Oft willst du ein Register, das nur aktualisiert, wenn ihm etwas dazu sagt. Verwende ein if innerhalb des getakteten Blocks und vertraue auf das implizite "vorigen Wert halten"-Verhalten des fehlenden else:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // Kein else - q behält seinen alten Wert, genau das tut ein FF
    end
endmodule

Das ist das kanonische "Load-Enable-Register". Es taucht überall auf - Konfigurationsregister, Pipeline-Stufen, die nur vorrücken, wenn die nachgelagerte Stufe bereit ist, Counter, die pausieren und weiterlaufen. Das Weglassen des finalen else ist absichtlich und in einem getakteten Block sicher: Ein Flip-Flop erinnert sich bereits an seinen vorigen Wert, also heißt "nichts tun" "halten".

In einem kombinatorischen Block würde derselbe Code ein Latch ableiten. Andere Regeln, gleiche Syntax.

Ein Counter

Ein Counter ist ein Register, dessen nächster Wert sein aktueller Wert plus eins ist:

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

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

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

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

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

Der Counter inkrementiert in jedem Taktzyklus, wenn enable high ist. Nach 16 Zyklen springt er auf 0 zurück (weil wir 4 Bit deklariert haben und 15 + 1 zu 0 überläuft). Dieses Wrapping ist N-Bit-Arithmetik immanent und genau das, was ein echter Hardware-Counter tut.

Ein Schieberegister

Flip-Flops stapeln ergibt ein Schieberegister. Der Trick: alle Verschiebungen in einer non-blocking-Anweisung erledigen:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

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

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

Der Body ist out <= {out[WIDTH-2:0], in} - die unteren Bits des aktuellen out mit dem neuen in konkatenieren und das Ganze zuweisen. Weil non-blocking, liest die RHS das alte out, bevor die LHS aktualisiert. Der Effekt: ein sauberer N-Bit-Shift in einem einzigen Taktzyklus.

Das ist das Schieberegister-Muster in seiner kleinsten Form. Es verallgemeinert sich auf LFSRs, serielle Sender, Deserializer - jedes Design, in dem Daten pro Takt durch eine Flip-Flop-Kette wandern.

Pipelines

Eine Pipeline ist eine Kette von Registern, die durch kombinatorische Logik getrennt sind. Jede Stufe verarbeitet Daten der vorigen Stufe und speist die nächste:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Stufe 1: zwei parallele Additionen.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stufe 2: die beiden Teilsummen kombinieren.
            stage2    <= stage1_ab + stage1_cd;
            // Stufe 3: an Ausgang weiterreichen.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

Drei Stufen, drei Zyklen Latenz, aber ein neues Ergebnis pro Zyklus, sobald die Pipeline gefüllt ist. Die Latenz ist 3 Takte, weil die Daten durch drei Flip-Flops gehen; der Durchsatz ist 1 Operation pro Takt, weil alle drei Stufen gleichzeitig an unterschiedlichen Eingängen arbeiten.

So erreichen Hochleistungs-Designs ihre Durchsatzziele: Stufen kurz halten, tiefer pipelinen und Parallelität die Arbeit machen lassen.

Asynchroner Reset (wenn nötig)

Manchmal kannst du nicht auf eine Taktflanke warten, um Reset zu aktivieren - der Chip wird heruntergefahren, der Takt ist gated, ein externer Watchdog reißt die Leitung. In diesen Fällen:

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

Die Sensitivitätsliste hat jetzt sowohl eine Taktflanke als auch eine Resetflanke. Das Flip-Flop reagiert sofort auf eine von beiden. reset_n ist per Konvention active-low (aktiviert, wenn low), deshalb der Test ~reset_n.

Asynchroner Reset hat Trade-offs: Schwieriger zeitlich zu analysieren, kann beim De-Assert Metastabilität verursachen, wenn man nicht aufpasst, nicht in allen FPGA-Architekturen portabel. Nimm standardmäßig synchronen Reset, async nur, wenn das Design es verlangt.

Wie es weitergeht

Du kannst jetzt jeden synchronen Datenpfad bauen. Das nächste Doc - Endliche Automaten - kombiniert ein getaktetes Register mit einer case-Anweisung zu dem Standard-FSM-Idiom: dem Arbeitspferd jedes Controllers, jeder Protokoll-Engine und jedes Entscheidungs-Blocks im Digital-Design.