פרמטרים ב-Verilog: parameter ו-localparam למודולים גמישים

קבועים עם טוויסט

parameter הוא קבוע: הקומפיילר בוחר את הערך שלו וצורב אותו בתכנון לפני שהסימולציה מתחילה. הטוויסט הוא שמי שיוצר מופע של המודול יכול לשנות את הערך. אותו קובץ מקור של מודול יכול לייצר מעגלים בגדלים שונים, לפי הפרמטרים שנותנים לו.

כך בונים IP רב פעמי. מודול FIFO עם הפרמטרים WIDTH ו-DEPTH יכול לשרת כל צוות בחברה. מונה עם פרמטר WIDTH הוא אותו קוד מקור, בין אם הוא סופר עד 16 ובין אם עד 4 מיליארד.

הצהרת פרמטר בסיסית

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

שלושה פריטי תחביר חדשים:

1. בלוק פרמטרים: #( parameter WIDTH = 8 ) בין שם המודול לרשימת הפורטים. ערך ברירת המחדל 8 הוא מה שהמודול משתמש בו כשאף אחד לא דורס.
2. מקום השימוש: output reg [WIDTH-1:0] count. הפרמטר הוא פשוט קבוע, ואנחנו מציבים אותו בטווח הביטים. אותו קוד מקור של מודול מייצר פלט של 8 או 16 ביטים, לפי WIDTH.
3. תחביר הדריסה: counter #(.WIDTH(16)) dut16(...) בזמן יצירת המופע. בלוק ה-#(...) בא לפני שם המופע, אחרי שם המודול. פרמטרים שלא מזכירים שומרים על ברירות המחדל שלהם.

localparam: קבועים פנימיים

יש קבועים שאתם לא רוצים שמי שמשתמש במודול ידרוס. קידודי מצבים הם המקרה הקלאסי:

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 הופך את IDLE, RUNNING, DONE לזמינים בתוך המודול, אבל לא ניתנים לדריסה ביצירת מופע. זו הבחירה הנכונה: לשנות מבחוץ איזה ערך מצב פירושו IDLE היה מפחיד.

השתמשו ב-parameter לדברים שמי שמשתמש במודול צריך להגדיר (רוחבים, עומקים, אפשרויות התנהגות), וב-localparam לכל השאר. תבנית נפוצה היא לגזור localparams מתוך parameters:

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

רוחבים עם פרמטרים בפועל

השימוש הנפוץ ביותר בפרמטרים הוא להפוך רוחבי אפיקים לגמישים. הנה מחבר שעובד בכל רוחב:

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

קובץ מקור אחד, שני מופעים, שני רוחבים שונים, בלי העתק הדבק. זה כל הרווח מפרמטרים.

כמה פרמטרים, דריסה לפי שם

במודולים גדולים יותר יהיו לעיתים קרובות כמה פרמטרים. דורסים אותם לפי שם, בכל סדר:

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), ...);

לא חייבים לדרוס כל פרמטר; מי שלא מוזכר שומר על ברירת המחדל שלו. ברירת המחדל של AFULL בדוגמה מחושבת מתוך DEPTH, כלומר אם דורסים את DEPTH, גם AFULL מתעדכן אוטומטית. זה בדיוק סוג התלות ש-localparam היה מטפל בה גם, אם לא הייתם רוצים לאפשר לדרוס את AFULL בנפרד.

טעויות נפוצות

שכחת ה-# בדריסה. counter (.WIDTH(16)) dut(...) נראה כמו דריסה, אבל Verilog קוראת את (.WIDTH(16)) כחיבור פורט. צריך counter #(.WIDTH(16)) dut(...).

שימוש בפרמטרים במקום שבו הם לא קבועים מספיק. פרמטרים נפתרים בזמן ה-elaboration, לפני שקיימים אותות כלשהם. אי אפשר לתת פרמטר לפי אות בזמן ריצה: אם הערך תלוי במה שכניסה עושה בזמן הסימולציה, זה לא פרמטר, זו לוגיקה.

בלבול בין parameter ל-localparam ברשימות פורטים. רק parameter נכנס לבלוק ה-#(...) שבראש המודול. localparam חי בתוך הגוף. הקומפיילר יגיד לכם אם תחליפו ביניהם.

מה הלאה

עכשיו אתם יכולים ליצור מודולים שהגודל שלהם נקבע בזמן הקומפילציה. שני המסמכים הבאים עוסקים בכללים לכתיבת קבועים מילוליים (8'h1F, 4'b1010, 32'd100) ובערכים x ו-z שמופיעים כשאותות לא מוזנים או מתנגשים. אחרי זה נעבור לאופרטורים: כל מה שאפשר לעשות עם הווקטורים והפרמטרים שראיתם.