Valores X y Z en Verilog: señales desconocidas y de alta impedancia explicadas

Lógica de dos estados vs cuatro estados

En software, un bit es 0 o 1. En Verilog, un bit puede ser uno de cuatro valores:

• 0 - el wire está excitado a bajo.
• 1 - el wire está excitado a alto.
• x - el valor del wire es desconocido. El simulador no puede decirlo.
• z - el wire está en alta impedancia. Nada lo está excitando.

Ese modelo de cuatro estados existe porque el hardware tiene el mismo problema. Un wire real puede estar conectado a bajo, conectado a alto, indefinido (excitado por dos fuentes peleando entre sí) o flotando (sin driver). El simulador tiene que modelar los cuatro para ser útil.

Cómo aparece x

Ejecuta esto y mira la salida:

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

    // `a` is never assigned.
    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á declarado pero nunca escrito, así que se queda en x. Sumar x + 5 produce x - cualquier aritmética con un desconocido produce un desconocido. La salida lee aaaa cantidades de x's.

Fuentes comunes de x en tus diseños:

• Un reg declarado pero nunca reseteado (la mayoría del Verilog sintetizable usa un reset explícito para limpiarlos).
• Una sentencia case sin default, alcanzada por un valor de entrada que ninguno de los casos emparejó.
• Un wire que perdió su único driver tras una refactorización.
• Una cadena if/else donde una rama no asigna una señal que la otra sí (latches x si no se cubre).
• Leer pasado el final de un vector o array.

Propagación de X: un pequeño bit de x arruina todo

Lo cruel de x es que se propaga. Un bit x en un operando convierte todo el resultado en x:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - the AND identity wins
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - the OR identity wins
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - arithmetic always taints
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

Fíjate en que 0 & x es 0 (AND con 0 siempre es 0) y 1 | x es 1 (OR con 1 siempre es 1). El simulador es bit a bit pesimista pero sigue respetando las identidades. La aritmética y la comparación no son tan generosas.

Por esto un único registro no inicializado puede hacer que un bus de salida entero vaya xxxx. Sigue hacia atrás desde cualquier x y encontrarás la fuente.

Cómo aparece z

z es el valor de un wire que nadie está excitando:

module z_demo;
    wire [3:0] floating;   // declared, no driver
    reg  enable;
    wire data_out;
    reg  data;

    // A tri-state output: drives `data` when `enable` is high, releases when low.
    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

Dos patrones en ese fragmento:

• floating solo se declara y nunca se excita. Por defecto va a z.
• data_out es un tri-state deliberado. Cuando enable está en bajo, la salida libera explícitamente a z. Así es como un driver de bus "suelta" para que otro driver pueda tomar el control.

En lógica interna, z casi siempre es incorrecto. En un pin bidireccional o un bus compartido, z es exactamente correcto.

Comparar con == vs ===

El operador de igualdad regular == devuelve x cuando cualquier operando tiene un bit x o 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  - not useful
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - also not useful

        $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

=== (y su compañero !==) hace una comparación estricta bit a bit incluyendo x y z. Úsalos siempre que necesites testear a favor o en contra de x/z en un testbench. === no es sintetizable, pero dentro de un bloque initial en un testbench eso no importa.

La función de sistema $isunknown(expr) es la forma más limpia de preguntar "¿esta expresión tiene algún bit x o z?" - devuelve 1 si sí, 0 si no.

Usar x como un don't-care intencional

Un patrón controvertido pero legítimo: 'x en un caso default de una máquina de estados le dice al sintetizador "este estado es inalcanzable, optimiza libremente":

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

El sintetizador puede usar el x para fusionar estados y reducir el conteo de puertas. En simulación, si tu razonamiento estaba equivocado y el default se alcanza, verás x propagar desde next_state y el bug se hace visible inmediatamente.

Usa esto solo cuando hayas pensado a fondo si el default realmente es inalcanzable. Si no lo has hecho, pon el default a un estado seguro en su lugar.

Receta común de depuración

Estás mirando una forma de onda llena de x. La receta:

1. Encuentra el x más temprano. Recorre la forma de onda hacia atrás en el tiempo. La señal más temprana en ir a x es la más cercana a la fuente.
2. Encuentra su driver. Abre el código fuente. ¿Qué asigna esta señal? ¿Un assign? ¿Un bloque always?
3. Comprueba las entradas al driver. Si el RHS del driver tiene algún x, la propagación está haciendo lo que se supone - el bug está aguas arriba.
4. Si el driver tiene entradas limpias pero produce x, el driver está incompleto. Un case al que le falta un default, un if al que le falta un else, un registro al que le falta un reset.

La mayoría de los bugs tipo tormenta de x se reducen a uno de estos: falta reset, falta default o un submódulo que no está conectado.

Qué viene a continuación

Ya tienes la historia completa de tipos de datos: wire/reg, vectores, parámetros, literales numéricos y el modelo lógico de cuatro estados. El siguiente capítulo empieza a usar todo eso para construir expresiones - operadores de todos los sabores, incluidos los operadores a nivel de bit que no tendrían sentido en software.