Verilog X e Z Values: Sinais desconhecidos e em alta impedância explicados

Lógica de dois estados vs quatro estados

Em software, um bit é 0 ou 1. Em Verilog, um bit pode ser um de quatro valores:

• 0 - o wire é conduzido para baixo.
• 1 - o wire é conduzido para cima.
• x - o valor do wire é desconhecido. O simulador não sabe.
• z - o wire está em alta impedância. Nada está acionando ele.

Esse modelo de quatro estados existe porque hardware tem o mesmo problema. Um wire real pode estar amarrado em baixo, amarrado em alto, indefinido (acionado por duas fontes brigando) ou flutuando (sem driver nenhum). O simulador precisa modelar os quatro para ser útil.

Como x aparece

Execute isto e olhe a saída:

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

    // `a` nunca é atribuído.
    assign c = a + b;

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

a é declarado mas nunca escrito, então fica em x. Somar x + 5 produz x - qualquer aritmética com um desconhecido produz um desconhecido. A saída diz xxxx na coluna de a.

Fontes comuns de x em seus designs:

• Um reg declarado mas nunca resetado (a maioria do Verilog sintetizável usa um reset explícito para limpá-los).
• Uma declaração case sem default, atingida por um valor de entrada que nenhum caso cobriu.
• Um wire que perdeu seu único driver depois de um refactor.
• Uma cadeia if/else onde um ramo não atribui um sinal que o outro atribui (latches x se descoberto).
• Leitura além do fim de um vetor ou array.

Propagação de X: Um pouquinho de x arruína tudo

A coisa cruel sobre x é que ele se propaga. Um bit x em um operando vira o resultado inteiro x:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - identidade do AND vence
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - identidade do OR vence
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - aritmética sempre contamina
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

Note que 0 & x é 0 (AND com 0 é sempre 0) e 1 | x é 1 (OR com 1 é sempre 1). O simulador é bit-a-bit pessimista mas ainda respeita identidades. Aritmética e comparação não são tão generosas.

É por isso que um único register não inicializado pode fazer um barramento de saída inteiro virar xxxx. Trace para trás a partir de qualquer x e você encontrará a fonte.

Como z aparece

z é o valor de um wire que ninguém está conduzindo:

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

    // Uma saída tri-state: conduz `data` quando `enable` é alto, libera quando baixo.
    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

Dois padrões nesse trecho:

• floating é só declarado e nunca conduzido. Por padrão é z.
• data_out é um tri-state deliberado. Quando enable é baixo, a saída explicitamente libera para z. É assim que um driver de barramento "solta" para outro driver poder assumir.

Em lógica interna, z quase sempre está errado. Em um pino bidirecional ou um barramento compartilhado, z está exatamente certo.

Comparando com == vs ===

O operador de igualdade regular == retorna x quando algum operando tem um 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  - inutil
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - tambem inutil

        $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

=== (e seu parceiro !==) faz uma comparação estrita bit-a-bit incluindo x e z. Use-o sempre que precisar testar para ou contra x/z em um testbench. === não é sintetizável, mas dentro de um bloco initial em um testbench isso não importa.

A função de sistema $isunknown(expr) é a forma mais limpa de perguntar "essa expressão tem algum bit x ou z?" - retorna 1 se sim, 0 se não.

Usando x como um don't-care intencional

Um padrão controverso mas legítimo: 'x em um caso default de uma máquina de estado diz ao sintetizador "esse estado é inalcançável, otimize livremente":

case (state)
    IDLE:    next_state = go ? RUNNING : IDLE;
    RUNNING: next_state = done ? IDLE : RUNNING;
    default: next_state = 'x;   // inalcançável
endcase

O sintetizador pode usar o x para fundir estados e reduzir contagem de gates. Em simulação, se seu raciocínio estava errado e o default é alcançado, você verá x se propagar de next_state e o bug se torna visível imediatamente.

Use isso só quando você pensou cuidadosamente se o default realmente é inalcançável. Se não pensou, defina o default para um estado seguro.

Receita comum de debug

Você está olhando para uma forma de onda cheia de x. A receita:

1. Encontre o x mais cedo. Caminhe a forma de onda para trás no tempo. O sinal mais cedo a virar x é o mais próximo da fonte.
2. Encontre seu driver. Abra o fonte. O que atribui esse sinal? Um assign? Um bloco always?
3. Verifique as entradas do driver. Se o lado direito do driver tem algum x, propagação está fazendo o que devia - o bug é upstream.
4. Se o driver tem entradas limpas mas produz x, o driver está incompleto. Um case sem default, um if sem else, um register sem reset.

A maioria dos bugs de tempestade de x colapsa em um de: reset ausente, default ausente ou um submódulo que não está conectado.

O que vem a seguir

Você agora tem a história completa de tipos de dados: wire/reg, vetores, parameters, literais numéricos e o modelo lógico de quatro estados. O próximo capítulo começa a usar tudo isso para construir expressões - operadores de cada tipo, incluindo os operadores bit a bit que não fariam sentido em software.