Tham số trong Verilog: module có thể cấu hình

Hằng số nhưng có điểm đặc biệt

parameter là một hằng số: trình biên dịch chọn giá trị của nó và gắn cứng vào thiết kế trước khi mô phỏng bắt đầu. Điểm đặc biệt là ai khởi tạo module cũng có thể thay đổi giá trị đó. Cùng một tệp nguồn module có thể tạo ra các mạch kích thước khác nhau tùy theo cách nơi gọi tham số hóa nó.

Đó là cách xây dựng IP tái sử dụng được. Một module FIFO có tham số WIDTH và DEPTH có thể phục vụ mọi nhóm trong một công ty. Một bộ đếm có tham số WIDTH vẫn là cùng một mã nguồn dù nó đếm đến 16 hay 4 tỷ.

Khai báo tham số cơ bản

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;

    // Default WIDTH = 8
    counter dut8(.clk(clk), .reset(reset), .count(count8));

    // Override WIDTH to 16 for this instance
    counter #(.WIDTH(16)) dut16(.clk(clk), .reset(reset), .count(count16));

    always #5 clk = ~clk;

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

Ba phần cú pháp mới:

1. Khối tham số: #( parameter WIDTH = 8 ) đặt giữa tên module và danh sách port. Giá trị mặc định 8 là giá trị module dùng khi không ai ghi đè.
2. Nơi sử dụng: output reg [WIDTH-1:0] count. Tham số chỉ là một hằng số: chúng ta đặt nó vào khoảng bit. Cùng một mã nguồn module tạo ra output 8 bit hoặc 16 bit tùy theo WIDTH.
3. Cú pháp ghi đè: counter #(.WIDTH(16)) dut16(...) lúc khởi tạo. Khối #(...) đứng trước tên instance, sau tên module. Các tham số bạn không nhắc đến giữ giá trị mặc định.

localparam: hằng số nội bộ

Có những hằng số bạn không muốn nơi gọi ghi đè. Mã hóa trạng thái là ví dụ kinh điển:

module fsm(input wire clk, input wire reset, input wire go, output reg busy);
    // States are an implementation detail; nobody outside should care.
    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 giúp IDLE, RUNNING, DONE dùng được bên trong module nhưng không thể ghi đè khi khởi tạo. Đó là lựa chọn đúng: thay đổi giá trị trạng thái nào mang nghĩa IDLE từ bên ngoài module sẽ là thảm họa.

Dùng parameter cho những thứ nơi gọi nên cấu hình (độ rộng, độ sâu, tùy chọn hành vi) và localparam cho mọi thứ còn lại. Một mẫu phổ biến là suy ra localparam từ parameter:

parameter WIDTH = 32;
localparam WIDTH_M1 = WIDTH - 1;   // computed once; not overrideable

Độ rộng tham số hóa trong thực tế

Cách dùng tham số phổ biến nhất là làm cho độ rộng bus linh hoạt. Đây là một bộ cộng hoạt động ở mọi độ rộng:

module adder #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] a,
    input  wire [WIDTH-1:0] b,
    output wire [WIDTH:0]   sum    // +1 for carry-out
);
    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

Một tệp nguồn, hai instance, hai độ rộng khác nhau, không cần sao chép và dán. Đó là toàn bộ lợi ích của tham số.

Nhiều tham số, ghi đè theo tên

Với module lớn hơn, bạn thường có nhiều tham số. Ghi đè chúng theo tên, theo bất kỳ thứ tự nào:

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

// At the call site:
fifo #(.WIDTH(32), .DEPTH(1024)) cmd_queue (.clk(clk), .reset(reset), ...);

Bạn không cần ghi đè mọi tham số; những tham số không được nhắc đến giữ giá trị mặc định. Giá trị mặc định của AFULL trong ví dụ được tính từ DEPTH, nghĩa là nếu bạn ghi đè DEPTH thì AFULL tự động thay đổi theo. Đây chính là kiểu phụ thuộc mà localparam cũng xử lý được nếu bạn không muốn nơi gọi ghi đè AFULL một cách độc lập.

Các lỗi thường gặp

Quên dấu # khi ghi đè. counter (.WIDTH(16)) dut(...) trông giống ghi đè nhưng Verilog đọc (.WIDTH(16)) là một kết nối port. Bạn cần viết counter #(.WIDTH(16)) dut(...).

Dùng tham số ở chỗ giá trị không đủ cố định. Tham số được xác định ở giai đoạn elaboration, trước khi có bất kỳ tín hiệu nào. Bạn không thể tham số hóa theo một tín hiệu lúc chạy: nếu giá trị phụ thuộc vào trạng thái của một input khi mô phỏng, đó không phải tham số mà là logic.

Nhầm parameter và localparam trong danh sách port. Chỉ parameter được đặt trong khối #(...) ở đầu. localparam nằm trong phần thân. Trình biên dịch sẽ báo nếu bạn đặt nhầm.

Tiếp theo là gì

Giờ bạn đã có thể tạo module có kích thước được quyết định lúc biên dịch. Hai bài tiếp theo nói về quy tắc viết hằng số (8'h1F, 4'b1010, 32'd100) và các giá trị x và z xuất hiện khi tín hiệu không được điều khiển hoặc bị tranh chấp. Sau đó chúng ta chuyển sang toán tử: mọi thứ bạn có thể làm với các vector và tham số vừa học.