Verilog Initial-Block: Setup-Code beim Simulationsstart ausführen

Ein einmalig laufender prozeduraler Block

initial begin ... end ist das Geschwister von always. Der Unterschied: initial läuft genau einmal, beginnend bei Zeit 0, und endet dann. Es gibt keine Sensitivitätsliste und keine Schleife.

Er existiert aus einem Grund: Testbench-Setup. Initialwerte setzen, Stimulus anstoßen, Log-Dateien öffnen, $finish nach einer festen Simulationszeit aufrufen - alles, was einmalig zu Beginn eines Laufs in einer bekannten Reihenfolge passieren soll.

module simple_init;
    reg [7:0] data;

    initial begin
        $display("hello at time %0t", $time);
        data = 8'hA5;
        #10;
        $display("after 10 time units, data = %h", data);
        $finish;
    end
endmodule

Geh durch, was der Simulator macht:

1. Die Zeit rückt auf 0 vor.
2. Der initial-Block startet. Der erste $display druckt.
3. data wird auf 8'hA5 gesetzt.
4. #10 rückt die simulierte Zeit um 10 Einheiten vor.
5. Der zweite $display druckt.
6. $finish beendet die Simulation.

Der Block lief einmal. Es gibt keinen zweiten Durchlauf.

Das klassische Testbench-Skelett

Fast jede Testbench, die du je schreibst, benutzt einen initial-Block wie diesen:

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

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

    dut u_dut(.clk(clk), .reset(reset), .in(in), .out(out));

    // Taktgenerator - separater initial/always, der Sauberkeit halber.
    always #5 clk = ~clk;

    // Stimulus und Lifecycle.
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // Reset für 2 Zyklen halten.
        in = 4'd0;
        #20 reset = 0;

        // Stimulus treiben.
        in = 4'd1; #10;
        in = 4'd5; #10;
        in = 4'd9; #10;
        in = 4'hF; #10;

        $display("done at %0t", $time);
        $finish;
    end
endmodule

Schau dir die Form an - das ist die Testbench-Vorlage, zu der du jedes Mal greifst:

1. VCD-Dump-Datei öffnen ($dumpfile, $dumpvars) - behandelt in Dumpfile und VCD.
2. Initialwerte setzen und Reset halten für einige Zyklen.
3. Stimulus treiben durch eine Folge von Änderungen, jeweils mit #-Verzögerungen.
4. $finish, um die Simulation sauber zu beenden.

Das war's. Jeder Verilog-Test, den du siehst, einschließlich der in Hersteller-Beispielen, folgt diesem Muster.

Mehrere initial-Blöcke laufen parallel

Mehrere initial-Blöcke im selben Modul starten alle gleichzeitig zur Zeit 0. Jeder läuft seine eigenen Anweisungen in seiner eigenen Zeitscheibe:

module parallel_init;
    initial begin
        #5  $display("[A] at time %0t", $time);
        #10 $display("[A] at time %0t", $time);
    end

    initial begin
        $display("[B] at time %0t", $time);   // druckt zuerst
        #2  $display("[B] at time %0t", $time);
        #20 $finish;
    end
endmodule

Der Simulator startet beide Blöcke zur Zeit 0. Block Bs erstes $display läuft sofort. Block A wartet 5 Einheiten, bevor er druckt. Block B druckt erneut bei Zeit 2. Block As zweiter Druck feuert bei Zeit 15. Block Bs $finish killt die Simulation bei Zeit 22.

Setup, Taktgenerierung und Stimulus in separate initial-Blöcke aufzuteilen, ist üblicher Stil - jeder Block ist kurz und macht eine Sache.

Inline-Initialisierung in Deklarationen

Eine übliche kompakte Form: ein reg direkt bei der Deklaration initialisieren. Die meisten Simulatoren behandeln das wie ein initial:

reg clk = 0;
reg reset = 1;
reg [7:0] count = 0;

Das ist äquivalent zu:

reg clk;
reg reset;
reg [7:0] count;

initial begin
    clk = 0;
    reset = 1;
    count = 0;
end

Die kompakte Form ist das, was du in Testbenches sehen wirst - sie setzt den Initialwert direkt neben die Deklaration, wo er leicht zu erkennen ist.

initial ist simulation-only

Synthese-Tools ignorieren initial-Blöcke. Echte Hardware hat keinen "Moment Null", an dem Setup-Code läuft - sie hat Power-On, Reset-Signale und die Konfiguration, die daraus folgt. Wenn ein Register in echter Hardware in einem bekannten Zustand starten soll, treibst du es mit einem Reset-Signal in einem always @(posedge clk):

always @(posedge clk) begin
    if (reset) state <= IDLE;
    else       state <= next_state;
end

Dieser if (reset)-Zweig ist das synthetisierbare Äquivalent zu initial state = IDLE. Reset ist die Antwort auf "wie initialisiere ich ein Register auf echter Hardware?".

Einige FPGA-Flows akzeptieren ein eingeschränktes initial für Register-Reset-Werte (Xilinx-Tools zum Beispiel), aber das ist eine herstellerspezifische Erweiterung. Verlass dich darauf nicht in portablem Code.

Dinge, die du innerhalb von initial siehst

Ein paar gängige Muster jenseits des Standard-Testbench-Skeletts:

Zeitverzögerte Beendigung

initial begin
    #1000 $finish;   // Sicherheitsnetz: Sim nach 1000 Zeiteinheiten killen
end

Ein separates initial, dessen einzige Aufgabe es ist, eine harte Obergrenze für die Simulation zu setzen. Selbst wenn dein Haupt-Stimulus-Block hängt, weil er auf ein Signal wartet, das nie kommt, feuert dieser Block und beendet den Lauf.

Waveform-Setup

initial begin
    $dumpfile("dump.vcd");
    $dumpvars(0, test);   // alles unterhalb des `test`-Scopes dumpen
end

Diese beiden Zeilen weisen den Simulator an, eine VCD-Datei mit jedem Signal im test-Scope zu schreiben. Ohne sie bekommst du keine Waveform.

Anfängliches Speicher-Image

reg [7:0] memory [0:255];

initial begin
    $readmemh("image.hex", memory);
end

$readmemh lädt eine hex-formatierte Datei in das Array. Wird in CPU-Testbenches verwendet, um den Instruktionsspeicher vorzuladen. Simulation-only.

Häufige Fehler

initial für synthetisierbare Logik verwenden. Wird nicht synthetisiert. Nutze stattdessen Reset-Signale.

$finish vergessen. Ohne läuft der Simulator weiter, bis etwas anderes ihn stoppt (eine Default-Zeitgrenze, manueller Abbruch usw.). Für einen schnellen Test ist das okay; für ein Regressions-Skript immer $finish.

#delay zwischen Stimulus-Zuweisungen vergessen. Schreibst du a = 0; b = 1; ohne Verzögerung, passieren beide zur selben Simulationszeit, und das DUT sieht sie vielleicht gleichzeitig statt als separate Ereignisse. Setze #1 oder mehr zwischen verschiedene Stimulus-Ereignisse.

Versuchen, einen wire aus initial zu treiben. Gleiche Regel wie bei always: nur reg ist ein zulässiges Ziel.

Wie es weitergeht

Du hast die beiden Sorten prozeduraler Blöcke gesehen. Das nächste Doc behandelt das am häufigsten missverstandene Thema in Anfänger-Verilog: Blocking vs Non-blocking-Zuweisung. Zu wissen, wann du = und wann <= nimmst, ist der Unterschied zwischen einem funktionierenden Flip-Flop und einem Race-Condition-Chaos.