Verilog Concatenation ve Replication: {} Operatörleri

Hak Ettiklerini Kazanan İki Küçük Operatör

Verilog'un iki {} şekli vardır:

1. Concatenation - {a, b, c} - birden çok sinyali daha geniş bir tanesine yapıştırır.
2. Replication - {N{pattern}} - bir kalıbı N kez kopyalar.

İkisini de sürekli kullanacaksın. Bir bus bölünmesi, birleştirilmesi, doldurulması veya sign ile genişletilmesi gerektiğinde, cevap bu iki operatörden biridir.

Concatenation: {a, b, c}

En basit durum: iki sinyali bir tanede üst üste yığ:

module concat_demo;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'h5;
    wire [7:0] combined = {a, b};   // 8 bit: AAAA_0101

    initial begin
        $display("a        = %b (%h)", a, a);
        $display("b        = %b (%h)", b, b);
        $display("combined = %b (%h)", combined, combined);
        $finish;
    end
endmodule

Soldan sağa okuma: a yüksek yarım, b alçak yarımdır. {} içindeki ilk operand en anlamlıdır. Sonucun genişliği operand genişliklerinin toplamıdır.

Herhangi bir sayıda operand'ı concatenate edebilirsin:

wire [31:0] word = {byte3, byte2, byte1, byte0};

Ve operandlar farklı genişlikte olabilir:

wire [11:0] frame = {start_bit, data_byte, parity, stop_bit};
//                    1 bit      8 bit      1 bit   2 bit  = 12

Yaygın bir kural: bir concatenation'un tüm operandlarının açık bir genişliği olmalıdır. Boyutsuz literaller (1'b1 yerine 1) hatalara neden olur çünkü parser kaç bit ayıracağını bilmez. Her zaman 1'b0, 1'b1, 4'd0 yaz; {} içinde asla çıplak 0 veya 1 yazma.

Sol Tarafta Concatenation

Bir atamanın LHS'inde concatenation, geniş bir sinyali parçalarına böler:

module split;
    wire [7:0] a = 8'd200;
    wire [7:0] b = 8'd100;
    wire [8:0] full_sum = a + b;
    wire carry_out;
    wire [7:0] sum_bits;

    // 9 bitlik toplamı carry biti ve 8 bitlik sum'a böl
    assign {carry_out, sum_bits} = full_sum;

    initial begin
        #1 $display("a + b = %0d, carry_out=%b, sum_bits=%0d",
                    full_sum, carry_out, sum_bits);
        $finish;
    end
endmodule

Bu kanonik adder-with-carry kalıbıdır. {carry_out, sum_bits} atamanın solunda tek bir 9 bitlik hedeftir ve bitler dağıtılır: üst bit carry_out'a, alt 8 bit sum_bits'e.

LHS concatenation assign'de ve prosedürel bloklarda çalışır:

always @(posedge clk) begin
    {high_byte, low_byte} <= incoming_word;
end

Replication: {N{pattern}}

Replication operatörü, sabit bir sayıda bir kalıbı kopyalar. Şekli {N{pattern}} - bir sayı, sonra kendi parantez çiftinde kalıp:

module replicate;
    initial begin
        $display("{8{1'b1}}        = %b", {8{1'b1}});         // 11111111
        $display("{4{1'b1}}        = %b", {4{1'b1}});         // 1111
        $display("{4{2'b10}}       = %b", {4{2'b10}});        // 10101010
        $display("{2{4'hA}}        = %h", {2{4'hA}});         // AA
        $display("{3{3'b101}}      = %b", {3{3'b101}});       // 101101101
        $finish;
    end
endmodule

N bir sabit olmalıdır - derleyicinin elaboration sırasında sonuç genişliğini bilmesi gerekir. Kalıp bir literal, parametre veya genişliği bilinen herhangi bir ifade olabilir.

İç parantezleri unutma. {8 1'b1} bir sözdizimi hatasıdır; {8{1'b1}} doğrudur. Dış {} operatördür; iç {...} tekrarlanan kalıbı sarmalar.

İkisini Birleştirme: Sign ve Zero Extension

İki operatör daha geniş değerler kurmak için doğal olarak birleşir:

module extension;
    wire [7:0] a_unsigned = 8'h7F;
    wire [7:0] a_negative = 8'hFF;   // signed olsaydı -1 olurdu

    // 16 bite zero-extend
    wire [15:0] zext = {8'b0, a_unsigned};

    // 16 bite sign-extend: a_negative'in üst bitini tekrarla
    wire [15:0] sext = { {8{a_negative[7]}}, a_negative };

    initial begin
        $display("a_unsigned    = %b -> zext = %b", a_unsigned, zext);
        $display("a_negative    = %b -> sext = %b", a_negative, sext);
        $finish;
    end
endmodule

{ {8{a_negative[7]}}, a_negative } standart sign-extension kalıbıdır. Şöyle oku: sign bitini sekiz kez tekrarla, sonra orijinal 8 biti ekle. Net sonuç: aynı sayının 16 bitlik iki'nin tümleyeni gösterimi.

Unsigned genişletme için atamaya güvenebilirsin - hedef daha geniş olduğunda Verilog otomatik olarak zero-extend yapar:

wire [15:0] zext_auto = a_unsigned;   // çalışır, üst 8 bit 0

Ama operand ve hedefin ikisi de signed olarak tanımlanmadıkça signed genişletme örtük olarak hiç olmaz. Açık replication deyimi daha güvenlidir.

Faydalı Kalıplar

N Bir'lik Bir Mask Kurma

parameter N = 5;
wire [31:0] mask = { {32-N{1'b0}}, {N{1'b1}} };
// örneğin N=5 ile, mask = 32'h0000_001F

Bir Vektörü Ters Çevirme

Verilog'da yerleşik bir ters çevirme yoktur, ama concatenation ile inline bir tane yazabilirsin:

wire [3:0] forward  = 4'b1010;
wire [3:0] reversed = {forward[0], forward[1], forward[2], forward[3]};
// reversed = 4'b0101

Daha geniş vektörler için bir generate döngüsü veya bir function daha temizdir.

Flag'leri Bir Status Byte'ına Paketleme

wire [7:0] status = {
    error_flag,    // [7]
    overflow,      // [6]
    underflow,     // [5]
    ready,         // [4]
    busy,          // [3]
    1'b0,          // [2] reserved
    1'b0,          // [1] reserved
    valid          // [0]
};

1 bitlik reserved slot'ların açık genişliği var - asla {} içinde çıplak 0 yok.

Yaygın Hatalar

{} içinde boyutsuz literaller. {a, 0} bir sözdizimi hatası veya 32 bit genişliğinde bir sıfırdır. Her zaman boyutlandır: {a, 1'b0}.

Replication'da iç parantezleri unutmak. {8 1'b1} parse edilmez; {8{1'b1}} parse edilir.

Sırayı karıştırmak. {a, b}, a'yı yüksek tarafa, b'yi alçak tarafa koyar. Varsayımı tersine çevir ve bir yerde ters bir byte sırası alacaksın.

Sıfır kez replicate etmek. {0{...}}, standart Verilog'da yasadışıdır. SystemVerilog buna izin verir (ve sıfır genişlikte bir sonuç üretir). Düz Verilog reddeder.

Sırada Ne Var

Artık her Verilog operatörünü gördün. Bir sonraki bölüm vites değiştirir ve yapıya dalar - modüllerin birbirine nasıl bağlandığı, port kuralları ve daha büyük tasarımlar kurmak için alt modülleri instantiate etme sözdizimi.