Valeurs X et Z en Verilog : signaux inconnus et haute impédance expliqués

Logique 2 états vs 4 états

En logiciel, un bit est 0 ou 1. En Verilog, un bit peut prendre quatre valeurs :

• 0 - le wire est piloté à bas.
• 1 - le wire est piloté à haut.
• x - la valeur du wire est inconnue. Le simulateur ne peut pas dire laquelle.
• z - le wire est en haute impédance. Rien ne le pilote.

Ce modèle à 4 états existe parce que le matériel a le même problème. Un vrai wire peut être tiré bas, tiré haut, indéfini (piloté par deux sources qui se battent) ou flottant (aucun pilote). Le simulateur doit modéliser les quatre pour être utile.

Comment x apparaît

Lance ça et regarde la sortie :

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

    // `a` n'est jamais assigné.
    assign c = a + b;

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

a est déclaré mais jamais écrit, donc il reste à x. Ajouter x + 5 produit x - toute arithmétique avec un inconnu produit un inconnu. La sortie affiche autant de x que de bits.

Sources courantes de x dans tes designs :

• Un reg déclaré mais jamais reset (la plupart du Verilog synthétisable utilise un reset explicite pour les nettoyer).
• Un case sans default, atteint par une valeur d'entrée qu'aucun cas n'a matché.
• Un wire qui a perdu son unique pilote après un refactor.
• Une chaîne if/else où une branche n'assigne pas un signal que l'autre assigne (latche x si non couvert).
• Lire au-delà de la fin d'un vecteur ou d'un tableau.

La propagation de X : un petit bout de x gâche tout

La cruauté de x, c'est qu'il se propage. Un bit x dans une opérande rend tout le résultat x :

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - l'identité AND gagne
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - l'identité OR gagne
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - l'arithmétique pollue toujours
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

Remarque que 0 & x est 0 (AND avec 0 est toujours 0) et 1 | x est 1 (OR avec 1 est toujours 1). Le simulateur est pessimiste bit-par-bit mais respecte quand même les identités. L'arithmétique et la comparaison ne sont pas aussi généreuses.

C'est pourquoi un seul registre non initialisé peut faire qu'un bus de sortie entier devienne xxxx. Trace en arrière depuis n'importe quel x et tu trouveras la source.

Comment z apparaît

z est la valeur d'un wire que personne ne pilote :

module z_demo;
    wire [3:0] floating;   // déclaré, pas de pilote
    reg  enable;
    wire data_out;
    reg  data;

    // Une sortie tri-state : pilote `data` quand `enable` est haut, relâche quand bas.
    assign data_out = enable ? data : 1'bz;

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

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

Deux motifs dans ce snippet :

• floating est juste déclaré et jamais piloté. Il vaut z par défaut.
• data_out est un tri-state délibéré. Quand enable est bas, la sortie relâche explicitement à z. C'est ainsi qu'un pilote de bus « lâche » pour qu'un autre pilote prenne le relais.

Sur la logique interne, z est presque toujours faux. Sur une broche bidirectionnelle ou un bus partagé, z est exactement juste.

Comparer avec == vs ===

L'opérateur d'égalité standard == retourne x quand l'une des opérandes a un bit x ou z :

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  - pas utile
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - aussi pas utile

        $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

=== (et son partenaire !==) fait une comparaison stricte bit-à-bit y compris x et z. Utilise-le quand tu dois tester pour ou contre x/z dans un testbench. === n'est pas synthétisable, mais à l'intérieur d'un bloc initial dans un testbench ça n'a pas d'importance.

La fonction système $isunknown(expr) est la façon la plus propre de demander « cette expression a-t-elle des bits x ou z ? » - retourne 1 si oui, 0 si non.

Utiliser x comme don't-care intentionnel

Un motif controversé mais légitime : 'x dans un cas default d'une machine à états dit au synthétiseur « cet état est inatteignable, optimise librement » :

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

Le synthétiseur peut utiliser le x pour fusionner des états et réduire le nombre de portes. En simulation, si ton raisonnement était faux et que le default est atteint, tu verras x se propager depuis next_state et le bug devient visible immédiatement.

Utilise ça seulement quand tu as bien réfléchi à si le default est vraiment inatteignable. Si tu n'as pas réfléchi, mets le default à un état sûr à la place.

Recette de debug courante

Tu fixes une forme d'onde pleine de x. La recette :

1. Trouve le x le plus précoce. Remonte la forme d'onde dans le temps. Le signal le plus précoce à devenir x est le plus proche de la source.
2. Trouve son pilote. Ouvre le source. Qu'est-ce qui assigne ce signal ? Un assign ? Un bloc always ?
3. Vérifie les entrées du pilote. Si la RHS du pilote a un x, la propagation fait son boulot - le bug est en amont.
4. Si le pilote a des entrées propres mais produit x, le pilote est incomplet. Un case sans default, un if sans else, un registre sans reset.

La plupart des bugs en x-storm se résument à : reset manquant, default manquant, ou un sous-module non connecté.

La suite

Tu as maintenant l'histoire complète des types de données : wire/reg, vecteurs, paramètres, littéraux numériques et le modèle de logique 4 états. Le prochain chapitre commence à utiliser tout ça pour construire des expressions - opérateurs de tous types, y compris les opérateurs au niveau bit qui n'auraient pas de sens en logiciel.