Verilog Parameters: Modülleri Konfigüre Edilebilir Yapma

Bir Twist'li Sabitler

Bir parameter bir sabittir - derleyici değerini seçer ve simülasyon başlamadan önce tasarıma pişirir. Twist, onu instantiate edenin değeri değiştirebilmesidir. Aynı modül kaynağı dosyası, çağıranların onu nasıl parametrelendirdiğine bağlı olarak farklı boyutlarda devreler üretebilir.

Yeniden kullanılabilir IP'yi böyle kurarsın. WIDTH ve DEPTH parametrelerine sahip bir FIFO modülü bir şirketteki her takımı destekleyebilir. WIDTH parametresine sahip bir counter, 16'ya veya 4 milyara saysın aynı kaynaktır.

Temel Parameter Tanımı

module counter #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 0;
        else       count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [7:0] count8;
    wire [15:0] count16;

    // Varsayılan WIDTH = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Bu instance için WIDTH'i 16'ya override et
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #40 $display("4 saat sonra: count8=%0d count16=%0d", count8, count16);
        $finish;
    end
endmodule

Üç yeni sözdizimi parçası:

1. Parameter bloğu: modül adı ile port listesi arasında #( parameter WIDTH = 8 ). Varsayılan değer 8, kimse override etmediğinde modülün kullandığıdır.
2. Kullanım yeri: output reg [WIDTH-1:0] count. Parametre sadece bir sabittir - onu bit aralığına takarız. Aynı modül kaynağı WIDTH'e bağlı olarak 8 bitlik veya 16 bitlik bir çıkış üretir.
3. Override sözdizimi: instantiation zamanında counter #(.WIDTH(16)) dut16(...). #(...) bloğu instance adından önce, modül adından sonra gelir. Bahsetmediğin parametreler varsayılanlarını korur.

localparam: Dahili Sabitler

Çağıranların override etmesini istemediğin sabitler vardır. State encoding'leri klasik örnektir:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // State'ler bir uygulama detayıdır; dışarıdaki kimse umursamamalı.
    localparam IDLE    = 2'd0;
    localparam RUNNING = 2'd1;
    localparam DONE    = 2'd2;

    reg [1:0] state;

    always @(posedge clk) begin
        if (reset) state <= IDLE;
        else begin
            case (state)
                IDLE:    if (go) state <= RUNNING;
                RUNNING: state <= DONE;
                DONE:    state <= IDLE;
            endcase
        end
    end

    always @(*) busy = (state != IDLE);
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg go = 0;
    wire busy;

    fsm dut(.clk(clk), .reset(reset), .go(go), .busy(busy));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  go = 1;
        #10 go = 0;
        #40 $finish;
    end

    always @(posedge clk) $display("t=%0t state=%0d busy=%b", $time, dut.state, busy);
endmodule

localparam, IDLE, RUNNING, DONE'u modülün içinde kullanılabilir yapar ama instantiation'dan override edilemez. Bu doğru seçimdir - modül dışından hangi state değerinin IDLE anlamına geldiğini değiştirmek korkutucu olurdu.

Çağıranların konfigüre etmesi gereken şeyler için (genişlikler, derinlikler, davranış seçenekleri) parameter ve diğer her şey için localparam kullan. Yaygın bir kalıp, parameter'lardan localparam'lar türetmektir:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // bir kez hesaplandı; override edilemez

Pratikte Parametrelenmiş Genişlikler

Parametrelerin en yaygın kullanımı bus genişliklerini esnek hale getirmektir. İşte herhangi bir genişlikte çalışan bir adder:

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // carry-out için +1
);
    assign sum = a + b;
endmodule

module test;
    reg  [3:0]  a4, b4;
    wire [4:0]  sum4;
    reg  [15:0] a16, b16;
    wire [16:0] sum16;

    adder #(.WIDTH(4))  small(.a(a4),  .b(b4),  .sum(sum4));
    adder #(.WIDTH(16)) big  (.a(a16), .b(b16), .sum(sum16));

    initial begin
        a4  = 4'd9;       b4  = 4'd8;
        a16 = 16'd60000;  b16 = 16'd10000;
        #1;
        $display("small: %0d + %0d = %0d", a4,  b4,  sum4);
        $display("big  : %0d + %0d = %0d", a16, b16, sum16);
        $finish;
    end
endmodule

Bir kaynak dosya, iki instance, iki farklı genişlik, kopyala-yapıştır yok. Parametrelerin tüm getirisi budur.

Birden Çok Parametre, Adlandırılmış Override

Daha büyük modüller için genellikle birkaç parametren olur. Onları herhangi bir sırada adlandırarak override et:

module fifo #(
    parameter WIDTH = 8,
    parameter DEPTH = 16,
    parameter AFULL = DEPTH - 2
)(
    input  wire             clk,
    input  wire             reset,
    // ... portlar ...
);
    // ...
endmodule

// Çağrı sitesinde:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Her parametreyi override etmek zorunda değilsin; belirtilmeyenler varsayılanlarını korur. Örnekteki AFULL varsayılanı DEPTH'ten hesaplanır, bu da eğer DEPTH'i override edersen, AFULL'un otomatik olarak takip ettiği anlamına gelir - eğer çağıranların AFULL'u bağımsız olarak override edebilmesini istemiyorsan localparam'ın da ele alacağı türden bir bağımlılık.

Yaygın Hatalar

Override'da #'i unutmak. counter (.WIDTH(16)) dut(...) bir override gibi görünür ama Verilog (.WIDTH(16))'ı bir port bağlantısı olarak okur. counter #(.WIDTH(16)) dut(...) gerekir.

Parametreleri yeterince sabit olmadıkları yerde kullanmak. Parametreler elaboration zamanında, herhangi bir sinyal var olmadan önce çözülür. Çalışma zamanı bir sinyali üzerinde parametre yapamazsın - değer simülasyon zamanında bir input'un yaptığına bağlıysa, o parametre değil, mantıktır.

Port listelerinde parameter ve localparam'ı karıştırmak. Yalnızca parameter üstteki #(...) bloğuna girer. localparam gövdenin içinde yaşar. Bunları takas ederken derleyici sana söyleyecektir.

Sırada Ne Var

Artık boyutu derleme zamanında ayarlanan modüller yapabilirsin. Sonraki iki doc, literal sabitlerin (8'h1F, 4'b1010, 32'd100) yazma kurallarını ve sinyaller sürülmediğinde veya çekiştiğinde ortaya çıkan x ve z değerlerini kapsar. Ondan sonra operatörlere geçiyoruz - şimdiye kadar gördüğün vektörler ve parametrelerle yapabileceğin her şey.