Verilog X- und Z-Werte: Unknown und High-Impedance erklärt

Zwei-Zustände vs. Vier-Zustände-Logik

In Software ist ein Bit 0 oder 1. In Verilog kann ein Bit einen von vier Werten haben:

• 0 - die Leitung ist auf Low getrieben.
• 1 - die Leitung ist auf High getrieben.
• x - der Wert der Leitung ist unknown. Der Simulator kann es nicht sagen.
• z - die Leitung ist in High-Impedance. Nichts treibt sie.

Dieses Vier-Zustands-Modell existiert, weil Hardware dasselbe Problem hat. Eine echte Leitung kann low gebunden, high gebunden, undefiniert (von zwei sich bekämpfenden Quellen getrieben) oder floatend (kein Treiber) sein. Der Simulator muss alle vier modellieren, um nützlich zu sein.

Wie x auftaucht

Lass das laufen und schau dir die Ausgabe an:

module unknown_demo;
    reg [3:0] a;
    reg [3:0] b;
    wire [3:0] c;

    // `a` wird nie zugewiesen.
    assign c = a + b;

    initial begin
        b = 4'd5;
        #1 $display("a=%b b=%b c=%b", a, b, c);
        $finish;
    end
endmodule

a ist deklariert, aber nie geschrieben, also sitzt es auf x. x + 5 zu addieren ergibt x - jede Arithmetik mit einem Unknown produziert ein Unknown. Die Ausgabe liest aaaa mit lauter x'en.

Häufige Quellen von x in deinen Designs:

• Ein reg, der deklariert, aber nie resettet wird (das meiste synthetisierbare Verilog nutzt einen expliziten Reset zum Löschen).
• Eine case-Anweisung ohne default, getroffen von einem Eingangswert, zu dem kein Case passt.
• Ein wire, der nach einem Refactor seinen einzigen Treiber verloren hat.
• Eine if/else-Kette, in der ein Zweig ein Signal nicht zuweist, das der andere zuweist (latcht x, wenn nicht abgedeckt).
• Außerhalb eines Vektors oder Arrays lesen.

X-Propagation: Ein bisschen x ruiniert alles

Das Gemeine an x: es propagiert. Ein x-Bit in einem Operanden macht das ganze Ergebnis x:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - die AND-Identität gewinnt
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - die OR-Identität gewinnt
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - Arithmetik vergiftet immer
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

Beachte, dass 0 & x 0 ist (AND mit 0 ist immer 0) und 1 | x 1 ist (OR mit 1 ist immer 1). Der Simulator ist bitweise pessimistisch, respektiert aber Identitäten. Arithmetik und Vergleich sind weniger gnädig.

Genau deshalb kann ein einziges uninitialisiertes Register einen ganzen Output-Bus auf xxxx setzen. Verfolge rückwärts von jedem x und du findest die Quelle.

Wie z auftaucht

z ist der Wert einer Leitung, die niemand treibt:

module z_demo;
    wire [3:0] floating;   // deklariert, kein Treiber
    reg  enable;
    wire data_out;
    reg  data;

    // Tri-State-Output: treibt `data`, wenn `enable` high; gibt frei, wenn low.
    assign data_out = enable ? data : 1'bz;

    initial begin
        $display("floating = %b", floating);   // zzzz

        enable = 1; data = 1; #1 $display("getrieben:    data_out = %b", data_out);
        enable = 0;            #1 $display("freigegeben:  data_out = %b", data_out);
        $finish;
    end
endmodule

Zwei Muster in diesem Schnipsel:

• floating ist nur deklariert und nie getrieben. Es defaultet auf z.
• data_out ist ein bewusster Tri-State. Wenn enable low ist, gibt der Ausgang explizit in z frei. So lässt ein Bustreiber "los", damit ein anderer Treiber übernehmen kann.

Auf interner Logik ist z fast immer falsch. An einem bidirektionalen Pin oder einem geteilten Bus ist z genau richtig.

Vergleich mit == vs ===

Der gewöhnliche Gleichheitsoperator == liefert x, wenn einer der Operanden ein x- oder z-Bit hat:

module compare_demo;
    initial begin
        $display("1'b1 == 1'b1 = %b", 1'b1 == 1'b1);     // 1
        $display("1'b1 == 1'bx = %b", 1'b1 == 1'bx);     // x  - nicht nützlich
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - auch nicht nützlich

        $display("1'b1 === 1'b1 = %b", 1'b1 === 1'b1);   // 1
        $display("1'b1 === 1'bx = %b", 1'b1 === 1'bx);   // 0
        $display("1'bx === 1'bx = %b", 1'bx === 1'bx);   // 1

        $display("$isunknown(1'bx) = %b", $isunknown(1'bx));   // 1
        $finish;
    end
endmodule

=== (und sein Partner !==) macht einen strengen bitweisen Vergleich, der x und z einbezieht. Nutze ihn, wann immer du in einer Testbench auf oder gegen x/z testen musst. === ist nicht synthetisierbar, aber innerhalb eines initial-Blocks in einer Testbench ist das egal.

Die $isunknown(expr)-Systemfunktion ist der sauberste Weg, um zu fragen "hat dieser Ausdruck x- oder z-Bits?" - liefert 1 bei ja, 0 bei nein.

x als absichtliches Don't-Care

Ein kontroverses, aber legitimes Muster: 'x in einem default-Fall eines Automaten sagt dem Synthesizer "dieser Zustand ist unerreichbar, optimiere frei":

case (state)
    IDLE:    next_state = go ? RUNNING : IDLE;
    RUNNING: next_state = done ? IDLE : RUNNING;
    default: next_state = 'x;   // unerreichbar
endcase

Der Synthesizer kann das x nutzen, um Zustände zu mergen und Gatterzahl zu reduzieren. In der Simulation: War deine Überlegung falsch und der Default wird erreicht, siehst du x von next_state propagieren und der Bug wird sofort sichtbar.

Nutze das nur, wenn du wirklich durchgedacht hast, ob der Default wirklich unerreichbar ist. Wenn nicht, setze den Default stattdessen auf einen sicheren Zustand.

Übliche Debug-Anleitung

Du starrst auf eine Waveform voller x. Die Anleitung:

1. Finde das früheste x. Geh die Waveform zeitlich rückwärts. Das früheste Signal, das x wird, ist am nächsten an der Quelle.
2. Finde seinen Treiber. Öffne den Quelltext. Was weist diesem Signal zu? Ein assign? Ein always-Block?
3. Prüfe die Eingaben des Treibers. Hat die RHS des Treibers irgendein x, tut Propagation das, was sie soll - der Bug ist weiter oben.
4. Wenn der Treiber saubere Eingänge hat, aber x produziert, ist der Treiber unvollständig. Ein case ohne Default, ein if ohne else, ein Register ohne Reset.

Die meisten x-Sturm-Bugs reduzieren sich auf eines von: fehlender Reset, fehlender default oder ein Submodul, das nicht angeschlossen ist.

Wie es weitergeht

Du hast jetzt die vollständige Datentyp-Story: wire/reg, Vektoren, Parameter, Zahlen-Literale und das Vier-Zustands-Logik-Modell. Das nächste Kapitel beginnt, all das zum Bauen von Ausdrücken zu nutzen - Operatoren jeder Sorte, einschließlich der Bit-Level-Operatoren, die in Software keinen Sinn ergeben würden.