לוגיקה מסונכרנת לשעון ב-Verilog: flip-flops, אוגרים ו-pipelines

אבן הבניין: D flip-flop

כל תכנון סינכרוני חוזר לרכיב חומרה זעיר אחד: ה-D flip-flop. יש לו כניסת שעון, כניסת נתונים ויציאת נתונים. בכל קצה עולה של השעון הוא לוכד את הערך של D ומחזיק אותו עד הקצה הבא. זה הכול.

ב-Verilog:

always @(posedge clk) begin
    q <= d;
end

שלוש שורות, flip-flop אחד. ה-<= הוא השמה לא חוסמת, וזו בדיוק ההתנהגות של flip-flops אמיתיים (מוסבר ב-השמה חוסמת מול לא חוסמת). הרגישות ל-posedge clk היא מה שהופך את הבלוק לסדרתי.

הערימו הרבה כאלה עם לוגיקה צירופית ביניהם, ותוכלו לבנות כל מעגל סינכרוני שתרצו.

אוגר עם reset

תכנונים אמיתיים תמיד צריכים reset, דרך להביא את המערכת למצב ידוע בהדלקה או לפי דרישה:

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

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

זה reset סינכרוני: תנאי ה-reset נבדק בקצה שעון כמו כל כניסה אחרת. הסינתיסייזר מייצר flip-flop עם mux של 2 ל-1 בכניסת הנתונים שלו: כש-reset גבוה, ה-mux מזין אפס; אחרת הוא מזין את d.

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

אוגר עם enable

לעיתים קרובות רוצים אוגר שמתעדכן רק כשמשהו אומר לו. משתמשים ב-if בתוך הבלוק המסונכרן לשעון, וסומכים על ההתנהגות המובלעת של "שמירת הערך הקודם" כשה-else חסר:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

זה ה-"load-enabled register" הקנוני. הוא מופיע בכל מקום: אוגרי תצורה, שלבי pipeline שמתקדמים רק כשהשלב הבא מוכן, מונים שנעצרים וממשיכים. השמטת ה-else האחרון מכוונת ובטוחה בתוך בלוק מסונכרן לשעון: flip-flop כבר זוכר את הערך הקודם שלו, ולכן "לא לעשות כלום" פירושו "להחזיק".

בבלוק צירופי אותו קוד היה מסיק latch. כללים שונים, אותו תחביר.

מונה

מונה הוא אוגר שהערך הבא שלו הוא הערך הנוכחי ועוד אחד:

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

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [3:0] count;

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

המונה גדל בכל מחזור שעון כש-enable גבוה. אחרי 16 מחזורים הוא חוזר ל-0 (כי הצהרנו על 4 ביטים ו-15 + 1 גולש ל-0). הגלישה הזו טבועה באריתמטיקה של N ביטים, וכך בדיוק מתנהג מונה חומרה אמיתי.

Shift register

הערמת flip-flops נותנת shift register. הטריק הוא לבצע את כל ההזזות בהוראה לא חוסמת אחת:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg in = 0;
    wire [3:0] out;

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

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

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

הגוף הוא out <= {out[WIDTH-2:0], in}: משרשרים את הביטים התחתונים של out הנוכחי עם ה-in החדש, ומבצעים השמה של הכול. מכיוון שזו השמה לא חוסמת, צד ימין קורא את out ה_ישן_ לפני שצד שמאל מתעדכן. התוצאה היא הזזה נקייה של N ביטים במחזור שעון אחד.

זו תבנית ה-shift register בצורתה הקטנה ביותר. היא מתרחבת ל-LFSRs, משדרים טוריים, deserializers, כל תכנון שבו נתונים נעים בשרשרת של flip-flops בכל שעון.

Pipelines

Pipeline הוא שרשרת של אוגרים שמופרדים בלוגיקה צירופית. כל שלב מעבד נתונים מהשלב הקודם ומזין את הבא:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Stage 1: two parallel adds.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: combine the two partial sums.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: forward to output.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

שלושה שלבים, שלושה מחזורי latency, אבל תוצאה חדשה בכל מחזור ברגע שה-pipeline מלא. ה-latency הוא 3 שעונים כי הנתונים עוברים דרך שלושה flip-flops; התפוקה היא פעולה 1 לכל שעון כי שלושת השלבים עובדים בו זמנית על כניסות שונות.

כך תכנונים עתירי ביצועים מגיעים ליעדי התפוקה שלהם: שומרים על שלבים קצרים, מעמיקים את ה-pipeline, ונותנים למקביליות לעשות את העבודה.

reset אסינכרוני (כשצריך אותו)

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

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

ברשימת הרגישות יש עכשיו גם קצה שעון וגם קצה reset. ה-flip-flop מגיב מיד לכל אחד מהם. reset_n הוא לפי המוסכמה active-low (פעיל כשהוא נמוך), ולכן הבדיקה היא ~reset_n.

ל-reset אסינכרוני יש מחירים: קשה יותר לנתח את התזמון שלו, הוא עלול לגרום ל-metastability אם לא מטפלים בזהירות בשחרור שלו, והוא לא נייד בין כל ארכיטקטורות ה-FPGA. השתמשו ב-reset סינכרוני כברירת מחדל, ובאסינכרוני רק כשהתכנון דורש אותו.

מה הלאה

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