Verilog Vector'lar ve Array'ler: Çok Bitli Sinyaller Açıklaması

Bir Wire vs Birçok

Şimdiye kadar gördüğümüz her sinyal bir bit genişliğindeydi. Gerçek tasarımlar neredeyse hiç böyle görünmez - adresler 16 veya 32 bit, veri bus'ları 8 veya 64, RGB piksel'leri 24'tür. Verilog sana herhangi bir sinyali çok bitli yapmak için tek bir mekanizma verir: köşeli parantezlere bir aralık ekle.

wire [7:0] data;       // 8 bitlik wire, bit 7 MSB, bit 0 LSB
reg  [15:0] address;   // 16 bitlik reg
output reg [31:0] result; // 32 bitlik modül çıkışı

Parantezler arasındaki sayılar en anlamlı ve en az anlamlı bitlerin bit pozisyonları'dır. [7:0], "bu sinyal 7'den 0'a numaralandırılmış bitlere sahip" demektir, bu da toplam 8 bittir. İlk sayı yüksek indeks. İkincisi düşük.

Bazen [0:7] göreceksin - aynı sayıda bit, dilimleme amacıyla zıt endianness. [high:low] formu ezici endüstri geleneğidir; aksini yapmak için güçlü bir nedenin olmadıkça buna bağlı kal.

Çalışılmış Bir Örnek: 8-Bit Adder

module adder8(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    // 8 bit + 8 bit 9 bitlik bir sonuç üretebilir (bir carry out).
    assign sum = a + b;
endmodule

module test;
    reg  [7:0] a, b;
    wire [8:0] sum;

    adder8 dut(.a(a), .b(b), .sum(sum));

    initial begin
        a = 8'd10;  b = 8'd20;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100;  #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;   #1 $display("%h + %h = %h",   a, b, sum);
        $finish;
    end
endmodule

Her +, iki 8 bitlik vector'ı ekler ve 9 bitlik bir sonuç üretir. 8'd10 gibi sayı literal'leri "10'un 8 bit genişliğinde decimal değeri" der - bunları Number Literals bölümünde kapsayacağız.

Dilimleme: Bitleri Seçme

Bir vector'ın olduğunda, bireysel bitleri veya bitişik aralıkları çekebilirsin:

module slicing(input wire [15:0] data);
    initial begin
        $display("tam data   = %b", data);
        $display("alt byte   = %b", data[7:0]);
        $display("üst byte   = %b", data[15:8]);
        $display("nibble[3:1] = %b", data[3:1]);
        $display("bit 9       = %b", data[9]);
    end
endmodule

module test;
    initial begin
        force test.dut.data = 16'b1010_1100_0011_0101;
        #1 $finish;
    end

    slicing dut();
endmodule

Testbench'in force satırına takılma - dilimlemeyi göstermek için sadece bir değer enjekte etmenin bir yoluna ihtiyacımız vardı. İlginç kısım dilimlerin kendileridir.

Birkaç kural:

• Dilim yönü tanımlamayla eşleşmelidir. [7:0] tanımladıysan, [high:low] ile dilimle. Yönü tersine çevirmek bir sözdizimi hatasıdır.
• Aralık dışında dilimleme simülasyonda x (bilinmeyen) üretir. Sentez aracı uyarabilir veya hata verebilir.
• Bit seçimi yazdığın indeks üzerinde sıfır tabanlıdır - data[0], 0 adlı bittir, ki bu (bir [7:0] tanımlama için) LSB'dir.

Değişken-Baz Dilimleri: +: ve -:

Yaygın bir ihtiyaç: "bana bit N'den başlayarak 8 bit ver". data[N+7:N]'i doğrudan yazamazsın çünkü Verilog aralığın her iki ucunun da sabit olmasını gerektirir. Bunu çözen sözdizimi:

data[base +: width]   // `base`'ten başlayarak YUKARI giden width bit
data[base -: width]   // `base`'ten başlayarak AŞAĞI giden width bit

module variable_slice;
    reg [31:0] word = 32'hDEAD_BEEF;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            $display("byte %0d = %h", i, word[i*8 +: 8]);
        end
        $finish;
    end
endmodule

Genişlik sabittir (her seferinde 8 bit seçiyoruz) ama baz bir çalışma zamanı ifadesi olabilir. Bu, byte adreslenebilir memory'ler, shift register tap'leri vb. için ihtiyacın olan tam şeydir.

Array'ler: Vector'ların Bir Adım Ötesi

Bir vector tek bir çok bitli sinyaldir. Bir array, bağımsız olarak indekslenen bir vector koleksiyonudur:

reg [31:0] mem [0:1023];

Bu tanım iki aralıktır ve iki aralık farklı şeyler ifade eder:

• [31:0], packed boyut'tur - her bireysel kelimenin genişliği.
• [0:1023], unpacked boyut'tur - kaç kelime olduğu.

Yani mem, 1024 ayrı 32 bitlik register'dır. Birine tek bir indeksle erişirsin:

mem[5] = 32'hCAFE_BABE;       // kelime 5'i yaz
data   = mem[address];        // `address`'teki kelimeyi oku

module memory_demo;
    reg [7:0] mem [0:7];   // 8 byte
    integer i;

    initial begin
        for (i = 0; i < 8; i = i + 1) mem[i] = i * i;

        for (i = 0; i < 8; i = i + 1)
            $display("mem[%0d] = %0d", i, mem[i]);

        $finish;
    end
endmodule

Bu kareleri tutan küçük bir memory'dir. Gerçek tasarımlar register file'lar, lookup table'lar, FIFO'lar ve tek bir vector'dan büyük herhangi bir on-chip depolama için aynı kalıbı kullanır.

Packed vs Unpacked: Neden Önemli

Packed ve unpacked boyutlar arasındaki bölünme her yerde ortaya çıkar. Hangisinin hangisi olduğunu bilmek bir sürü debug'tan tasarruf sağlar:

• Packed bir vector tek bir sinyaldir. Tümünü bir sayı olarak ele alabilirsin: data + 1 çalışır, data == 32'h0 çalışır, data[7:0] çalışır.
• Unpacked bir array birçok sinyaldir. Tümünü bir sayı olarak ele alamazsın: mem + 1 bir sözdizimi hatasıdır. Önce belirli bir kelimeyi seçmelisin.

Birden çok packed boyut da yasaldır:

reg [3:0][7:0] regs;   // 32 bitlik bir sinyale paketlenmiş 4 byte

regs[0], bir byte'tır (alt byte). regs bütün olarak 32 bittir. SystemVerilog bunu yoğun olarak kullanır.

Birden çok unpacked boyut bir 2D memory oluşturur:

reg [31:0] frame [0:479][0:639];  // 32 bitlik piksel'lerin 480x640'ı

Tek bir piksel'e frame[y][x] ile erişirsin. HDL'de bir image buffer böyle görünür.

Sırada Ne Var

Artık ihtiyacın olan herhangi bir genişlikte sinyali tanımlayıp manipüle edebilirsin. Bir sonraki doc - Parameters - aynı modülün bir instance'da 8 bit, başka bir instance'da 32 bit çalışması için bu genişlikleri konfigüre edilebilir yapmayı gösterir. Sonra literal sayı yazma kurallarına (8'b1010_1100, 32'hDEAD_BEEF) ve bir şey sürülmediğinde ortaya çıkan x/z değerlerine geçeceğiz.