Verilog Sayı Literal'leri: Binary, Hex, Decimal ve Boyutlu Sabitler

Boyutlu Bir Literal'in Anatomisi

Bir Verilog literal'i üç parçaya kadar sahiptir:

8'b1010_1100
│  │ │
│  │ └─ seçilen tabandaki rakamlar
│  └─── taban specifier: b (binary), h (hex), d (decimal), o (octal)
└────── bit cinsinden genişlik (decimal)

Soldan sağa okuma: "8 bitlik bir değer, binary olarak yazılı, 10101100 rakamlarıyla". Bu decimal'de 172, hex'te 0xAC, hangi şekilde yazsan da aynı bitler. Genişlik derleyiciye tam olarak kaç bit ayıracağını söyler; taban rakamları nasıl yorumlayacağını söyler.

Underscore'lar görsel ayırıcılardır. 32'b1010_1100_0011_0101, 32'b1010110000110101 ile aynıdır. Kullan.

Dört Taban

module bases;
    initial begin
        $display("binary  4'b1010 = %0d", 4'b1010);   // 10
        $display("hex     8'hFF   = %0d", 8'hFF);     // 255
        $display("decimal 16'd100 = %0d", 16'd100);   // 100
        $display("octal   6'o77   = %0d", 6'o77);     // 63
        $finish;
    end
endmodule

Hex (h), 4 bitten geniş her şey için standarttır. Binary (b), bit kalıplarını doğrudan okumak istediğinde standarttır. Decimal (d), insan-anlamlı sayımlar içindir. Octal (o) vardır ama neredeyse hiç görmeyeceksin.

Hex rakamları büyük/küçük harf duyarsızdır: 8'hAB ve 8'hab aynıdır.

Değer Sığmadığında Ne Olur

Rakamların tanımlı genişliği doldurmazsa, Verilog solda sıfır ile doldurur:

8'b101       // 8'b00000101'e eşdeğer  (= 5)
8'hF         // 8'h0F'e eşdeğer        (= 15)

Rakamların tanımlı genişliği aşarsa, Verilog yüksek bitleri uyarıyla truncate eder:

4'hFF        // 4'hF'e truncate olur, simülatör uyarır
4'b10000     // 4'b0000'e truncate olur

Uyarı arkadaşındır. Onu bastırma.

Boyutlu vs Boyutsuz

Genişliği olmayan bir literal:

'd10    // boyutsuz, varsayılan boyutu alır (≥32 bit)
10      // ayrıca boyutsuz - taban yok demek decimal demek

Boyutsuz literal'ler çoğu araçta varsayılan olarak 32 bittir. Bu bütün bir hata sınıfının kaynağıdır:

reg [7:0] count;
if (count == -1) ...      // -1 boyutsuz 32 bittir; karşılaştırma garipleşir

Düzeltme -1 yerine 8'hFF yazmaktır veya 8'd255 veya {8{1'b1}}. Genişliğe özgü ifadelerde kullanıldığında literal'leri her zaman boyutlandır.

Boyutsuz literal'lerin iyi olduğu tek yer, integer'ın sürpriz olmadan yeterince geniş olduğu testbench for döngülerindeki integer sayaçlarıdır.

Signed Literal'ler

Varsayılan olarak, boyutlu literal'ler unsigned'dır:

8'd255   // unsigned 255
8'b1111_1111   // unsigned 255 - aynı bit kalıbı, sadece farklı yazılmış

Literal'i signed olarak yorumlamak istiyorsan, apostroftan sonra s ekle:

8'sd10           // signed 10
8'sb1111_1111    // signed -1 (iki'nin tümleyeni)

s flag'i şunlar için önemlidir:

• <<< ve >>> operatörleri (aritmetik shift'ler) - signed operandları sign-extend eder.
• Signed karışık ifadelerde karşılaştırma operatörleri.
• $signed/$unsigned cast'leri.

Bus sinyallerinde çoğu sıradan aritmetik için, s'yi bırakacaksın.

X ve Z'li Sayı Literal'leri

Bir literal rakamı x (bilinmeyen) veya z (yüksek empedans) olabilir:

module xz_literals;
    initial begin
        $display("kısmi bilinmeyen: %b", 8'b1010_xxxx);
        $display("kısmi yüksek-Z:  %b", 8'b0000_zzzz);
        $display("hepsi bilinmeyen: %b", 8'bx);
        $finish;
    end
endmodule

8'bx, "8 bitin hepsi bilinmeyen" için bir kısaltmadır - değer tanımlanan genişliği doldurmak için yayılır. x rakamları state machine'lerin default case'lerinde ve initialization'da yaygındır. Semantiği X and Z Values bölümünde kapsıyoruz.

Pratikte Boyutlu Literal'ler Nerede Görünür

Gerçek modüller yazmaya başladığında, boyutlu literal'ler her yerde görünür:

// Bus genişlikleri
input  wire [31:0] addr;
wire [31:0] zero = 32'h0;
wire [31:0] all_ones = 32'hFFFF_FFFF;

// State encoding'leri
localparam IDLE = 3'd0;
localparam BUSY = 3'd1;
localparam DONE = 3'd2;

// Mask'ler
wire is_msb_set = data & 32'h8000_0000;

// Karşılaştırmalar
if (counter == 8'd255) ...

// Reset değerleri
always @(posedge clk) begin
    if (reset) data_out <= 8'd0;
    else       data_out <= data_in;
end

Kalıp tutarlı: genişliği yaz, taban'ı yaz, rakamları yaz. Uzanacağın her literal aynı şekle sahiptir.

Bir Test Sürüşü

module literal_tour;
    reg [7:0]  byte_val;
    reg [15:0] word_val;
    reg [31:0] big_val;

    initial begin
        byte_val = 8'hAC;
        word_val = 16'b1010_1100_0011_0101;
        big_val  = 32'd1_000_000;

        $display("byte_val = %h (decimal %0d)", byte_val, byte_val);
        $display("word_val = %h (decimal %0d)", word_val, word_val);
        $display("big_val  = %h (decimal %0d)", big_val,  big_val);

        // Underscore'lar sadece görseldir.
        if (32'd1_000_000 == 32'd1000000) $display("evet, underscore'lar yok sayılır");

        $finish;
    end
endmodule

Artık bir Verilog modülünün isteyebileceği herhangi bir sabiti yazmak için ihtiyacın olan her şeye sahipsin. Veri tipleri hikayesinin son parçası, bir sinyal temiz 0 veya 1 olmadığında ne olduğudur - x ve z değerleri.