Verilog always block: לוגיקה צירופית וסדרתית

סוס העבודה של Verilog התנהגותי

assign מתאר לוגיקה צירופית של משוואה אחת. ברגע שצריך if/else, case או זיכרון, עוברים ל-always. בלוק always הוא קטע קוד פרוצדורלי שרץ מחדש בכל פעם שאותות מסוימים משתנים. האותות שמפעילים את הריצה מחדש הם רשימת הרגישות.

יש שתי צורות של always שתפגשו הכי הרבה:

1. always @(*): רץ מחדש כש_כל_ אות שנקרא בבלוק משתנה. בונה לוגיקה צירופית.
2. always @(posedge clk): רץ מחדש רק בקצה העולה של clk. בונה לוגיקה סדרתית מסונכרנת לשעון (flip-flops).

קיימות צורות נוספות (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), אבל שתי הצורות שלמעלה מכסות כמעט כל בלוק בר סינתזה שתכתבו.

always @(*) צירופי

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

שלושה דברים שכדאי לשים לב אליהם:

• out הוא reg. כל מה שמקבל השמה בתוך always חייב להיות reg. מילת המפתח לא אומרת "זה flip-flop"; כאן היא אומרת רק "אני נכתב מתוך בלוק פרוצדורלי".
• always @(*). ה-* אומר "תתעורר בכל פעם שמשהו שאני קורא משתנה". הסימולטור מחשב את רשימת הרגישות בעצמו. אפשר לכתוב את הרשימה ידנית, always @(sel), אבל @(*) בטוח יותר, כי אות שנשכח ברשימה הוא מקור קלאסי לבאגים.
• אין שעון. הבלוק הזה מתאר לוגיקה צירופית. הסינתיסייזר מייצר לוגיקה שמחשבת את out ישירות מתוך sel, בלי flip-flops ובלי צורך בפין שעון.

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

always @(posedge clk) סדרתי

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

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

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

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

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

ההבדלים העיקריים לעומת הגרסה הצירופית:

• always @(posedge clk). הבלוק רץ מחדש רק בקצה העולה של clk. בין הקצוות לא קורה כלום.
• השמה לא חוסמת <=. בתוך בלוק מסונכרן לשעון זה האופרטור הנכון. הוא אומר "תזמן ל-count לקבל את הערך החדש בסוף צעד הזמן", וזו בדיוק ההתנהגות של flip-flop. הסיבה והחלופה מוסברות ב-השמה חוסמת מול לא חוסמת.
• אין צורך ב-default. ה-if מכסה את שני הענפים (reset ובלי reset), כך שאין סיכון ל-latch.

הסינתיסייזר מזהה את הצורה הזו, רגישות לשעון והשמה לא חוסמת, ומייצר אוגר של 4 ביטים (ארבעה flip-flops), יחד עם הלוגיקה הצירופית שמחשבת את count + 1 וה-mux שבוחר בין reset להגדלה.

ההבחנה בסינתזה

אותו קוד מקור של מודול יכול לתאר שני רכיבי חומרה שונים לגמרי, לפי הצורה של בלוק ה-always:

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

גרסאות של רשימת הרגישות

תפגשו גם כמה רשימות רגישות פחות נפוצות:

• always @(a or b or c): רשימה מפורשת. Verilog-2001 הוסיפה את המפריד ,: always @(a, b, c). שתי הצורות עובדות.
• always @(posedge clk or negedge reset_n): reset אסינכרוני. הבלוק רץ בקצה עולה של השעון או בקצה יורד של ה-reset. משתמשים בזה כשה-reset חייב להשפיע מיד, בלי לחכות לשעון הבא.
• always @(negedge clk): סנכרון לקצה היורד. נדיר; יש תכנונים שמשתמשים בזה ל-flip-flops "מופעלי קצה יורד" שלוכדים בקצה היורד במקום בעולה.

בתכנונים חדשים העדיפו always @(*) ללוגיקה צירופית ו-always @(posedge clk) ללוגיקה סדרתית. השתמשו ב-reset אסינכרוני רק כשהתכנון באמת צריך אותו.

שני בלוקים הם שני רכיבי חומרה

כמה בלוקים של always באותו מודול הם בלתי תלויים, וכל אחד מהם הופך לרכיב חומרה משלו:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // סדרתי
    output reg  [7:0] comb_out    // צירופי
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // היפוך ביט אחר ביט
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

הבלוק המסונכרן לשעון מייצר אוגר של flip-flops. הבלוק הצירופי מייצר שער XOR. הם חיים זה לצד זה, ואף אחד מהם לא יודע על השני. שני הפלטים משתנים בלוחות זמנים שונים לגמרי.

מה בלוקים של always לא יכולים לעשות

כמה דברים שנראים מפתים אבל אסורים:

• השמה ל-wire: היעד חייב להיות reg. הקומפיילר אוכף את זה.
• השמה לאותו reg משני בלוקים שונים של always: יוצרת התנהגות לא מוגדרת בסימולציה ולא עוברת סינתזה. מקור הזנה אחד לכל אות.
• קריאה וכתיבה של אותו אות באותו בלוק צירופי באופן שיוצר לולאת משוב: always @(*) x = x + 1; היא לולאה באפס השהיה שהסימולטור לא יכול לפתור.

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

מה הלאה

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