Verilog X ve Z Değerleri: Bilinmeyen ve Yüksek Empedans Sinyalleri Açıklaması

İki Durum vs Dört Durum Mantığı

Yazılımda, bir bit 0 veya 1'dir. Verilog'da bir bit dört değerden biri olabilir:

• 0 - wire düşük sürülür.
• 1 - wire yüksek sürülür.
• x - wire'ın değeri bilinmeyen'dir. Simülatör bilemez.
• z - wire yüksek empedans'tır. Hiçbir şey onu sürmüyor.

O dört durumlu model var çünkü donanımın aynı sorunu var. Gerçek bir wire düşüğe bağlanabilir, yükseğe bağlanabilir, tanımsız olabilir (birbirleriyle savaşan iki kaynak tarafından sürülür) veya yüzer olabilir (hiç sürücü yok). Simülatörün yararlı olması için dördünü de modellemesi gerekir.

x Nasıl Ortaya Çıkar

Bunu çalıştır ve çıktıya bak:

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

    // `a` asla atanmamış.
    assign c = a + b;

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

a tanımlı ama hiç yazılmamış, bu yüzden x'te oturur. x + 5 eklemek x üretir - bir bilinmeyenle herhangi bir aritmetik bir bilinmeyen üretir. Çıktı aaaa değerinde x'ler okur.

Tasarımlarında yaygın x kaynakları:

• Tanımlı ama asla reset edilmemiş bir reg (sentezlenebilir Verilog'un çoğu onları temizlemek için açık bir reset kullanır).
• default'u olmayan, hiçbir case'in eşleşmediği bir giriş değeri tarafından vurulan bir case ifadesi.
• Bir refactor'dan sonra tek sürücüsünü kaybeden bir wire.
• Bir dalın diğerinin atadığı bir sinyali atamadığı bir if/else zinciri (kapsanmazsa x latch'ler).
• Bir vector'ın veya array'in sonu ötesinde okuma.

X Yayılması: Küçük Bir Miktar x Her Şeyi Bozar

x hakkında acımasız olan şey, yayılmasıdır. Bir operand'da bir x bit sonucun tamamını x'e döndürür:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - AND identity'si kazanır
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - OR identity'si kazanır
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - aritmetik her zaman bulaşır
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

0 & x'in 0 (0 ile AND her zaman 0) ve 1 | x'in 1 (1 ile OR her zaman 1) olduğuna dikkat et. Simülatör bit-by-bit pesimisttir ama yine de identity'lere saygı duyar. Aritmetik ve karşılaştırma bu kadar cömert değildir.

İşte bu yüzden tek bir initialize edilmemiş register tüm bir çıkış bus'ını xxxx yapabilir. Herhangi bir x'ten geriye doğru izle ve kaynağı bulacaksın.

z Nasıl Ortaya Çıkar

z, kimsenin sürmediği bir wire'ın değeridir:

module z_demo;
    wire [3:0] floating;   // tanımlı, sürücü yok
    reg  enable;
    wire data_out;
    reg  data;

    // Bir tri-state çıkış: `enable` yüksek olduğunda `data`'yı sürer, düşük olduğunda serbest bırakır.
    assign data_out = enable ? data : 1'bz;

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

        enable = 1; data = 1; #1 $display("sürülen:  data_out = %b", data_out);
        enable = 0;            #1 $display("serbest: data_out = %b", data_out);
        $finish;
    end
endmodule

O snippet'te iki kalıp:

• floating sadece tanımlı ve asla sürülmemiş. Varsayılan olarak z'ye gider.
• data_out kasıtlı bir tri-state'tir. enable düşük olduğunda, çıkış açıkça z'ye serbest bırakılır. Bir bus sürücüsünün başka bir sürücünün devralabilmesi için "bırakma" şekli budur.

Dahili mantıkta z neredeyse her zaman yanlıştır. Çift yönlü bir pin'de veya paylaşılan bir bus'ta z tam olarak doğrudur.

== ile ==='i Karşılaştırma

Düzenli equality operatörü ==, herhangi bir operand'da bir x veya z bit olduğunda x döndürür:

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  - yararlı değil
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - ayrıca yararlı değil

        $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

=== (ve ortağı !==), x ve z dahil sıkı bir bit-by-bit karşılaştırma yapar. Bir testbench'te x/z'ye karşı veya için test etmen gerektiğinde her zaman bunu kullan. === sentezlenebilir değildir, ama bir testbench'in initial bloğunun içinde bu önemli değildir.

$isunknown(expr) system fonksiyonu, "bu ifade herhangi bir x veya z bit içeriyor mu?" demenin en temiz yoludur - evet ise 1, hayır ise 0 döndürür.

Kasıtlı Bir Don't-Care Olarak x Kullanma

Tartışmalı ama meşru bir kalıp: bir state machine'in default case'inde 'x, sentezleyiciye "bu state ulaşılamaz, serbest optimize et" der:

case (state)
    IDLE:    next_state = go ? RUNNING : IDLE;
    RUNNING: next_state = done ? IDLE : RUNNING;
    default: next_state = 'x;   // ulaşılmaz
endcase

Sentezleyici, x'i state'leri birleştirmek ve gate sayısını azaltmak için kullanabilir. Simülasyonda, mantığın yanlışsa ve default'a gerçekten ulaşılırsa, x'in next_state'ten yayıldığını görürsün ve hata hemen görünür hale gelir.

Bunu yalnızca default'un gerçekten ulaşılamaz olup olmadığını düşündüğünde kullan. Düşünmediysen, default'u bunun yerine güvenli bir state'e ayarla.

Yaygın Debug Reçetesi

x'lerle dolu bir waveform'a bakıyorsun. Reçete:

1. En erken x'i bul. Waveform'u zaman içinde geri yürü. x'e giden en erken sinyal kaynağa en yakındır.
2. Sürücüsünü bul. Kaynağı aç. Bu sinyali ne atıyor? Bir assign? Bir always bloğu?
3. Sürücünün girişlerini kontrol et. Sürücünün RHS'inde herhangi bir x varsa, yayılma yapması gerekeni yapıyor - hata yukarı akıştadır.
4. Sürücünün temiz girişleri var ama x üretiyorsa, sürücü eksiktir. Default eksik bir case, else eksik bir if, reset eksik bir register.

Çoğu x-fırtınası hatası şunlardan birine çöker: eksik reset, eksik default veya bağlı olmayan bir alt modül.

Sırada Ne Var

Artık tam veri tipi hikayesine sahipsin: wire/reg, vector'lar, parametreler, sayı literal'leri ve dört durumlu mantık modeli. Bir sonraki bölüm hepsini ifadeler kurmak için kullanmaya başlar - her çeşit operatör, yazılımda anlamlı olmayacak bit düzeyi operatörleri dahil.