Design Examples設計範例設計例

1. First-In First-Out (FIFO)1. 先進先出緩衝器（FIFO）1. 先入れ先出し（FIFO）

1.1 Interface and internal organization1.1 介面與內部組織1.1 インタフェースと内部構成

1.2 Verilog model1.2 Verilog 模型1.2 Verilog モデル

module FIFO (Data_out, Data_in, stack_empty, stack_full,
             clk, rst, write_to_stack, read_from_stack);
  parameter stack_width     = 12;   // width of stack and data paths
  parameter stack_height    = 8;    // height of stack (in # of words)
  parameter stack_ptr_width = 3;    // width of pointer to address stack

  output [stack_width-1:0]   Data_out;
  output                     stack_empty, stack_full;
  input  [stack_width-1:0]   Data_in;
  input                      clk, rst;
  input                      write_to_stack, read_from_stack;

  reg    [stack_ptr_width-1:0] read_ptr, write_ptr;   // pointers for reading and writing
  reg    [stack_ptr_width:0]   ptr_diff;              // gap between ptrs (0..8 needs 4 bits)
  reg    [stack_width-1:0]     Data_out;
  reg    [stack_width-1:0]     stack [stack_height-1:0];   // memory array

  assign stack_empty = (ptr_diff == 0)            ? 1'b1 : 1'b0;
  assign stack_full  = (ptr_diff == stack_height) ? 1'b1 : 1'b0;

  always @ (posedge clk or posedge rst) begin: data_transfer
    if (rst) Data_out = 0;
    else if ((read_from_stack) && (!write_to_stack) && (!stack_empty))
      Data_out <= stack[read_ptr];
    else if ((write_to_stack) && (!read_from_stack) && (!stack_full))
      stack[write_ptr] <= Data_in;
  end  // data_transfer

  always @ (posedge clk or posedge rst) begin: update_stack_ptrs
    if (rst) begin
      read_ptr  <= 0;
      write_ptr <= 0;
      ptr_diff  <= 0;
    end
    else if ((write_to_stack) && (!stack_full) && (!read_from_stack)) begin
      write_ptr <= write_ptr + 1;     // address for next clock edge
      ptr_diff  <= ptr_diff + 1;
    end
    else if ((!write_to_stack) && (!stack_empty) && (read_from_stack)) begin
      read_ptr  <= read_ptr + 1;
      ptr_diff  <= ptr_diff - 1;
    end
  end  // update_stack_ptrs
endmodule

2. Design Example I: Temperature Monitor System2. 設計範例一：溫度監測系統2. 設計例 I：温度モニタシステム

2.1 System overview2.1 系統概觀2.1 システム概要

2.2 Ckt 1 — data register2.2 電路 1 — 資料暫存器2.2 回路 1 — データレジスタ

module temp_register (temp_out, temp_in, clk, rst);
  output [11:0] temp_out;
  input  [11:0] temp_in;
  input         clk, rst;
  reg    [11:0] temp_out;

  always @ (posedge clk or posedge rst)
    begin
      if (rst == 1) temp_out = 0;
      else          temp_out = temp_in;
    end
endmodule

Stores (latches) the input data: twelve DFFs with asynchronous reset (the netlist shows an inverter on rst because the library flip-flops have active-low reset).把輸入資料存起來：十二個帶非同步重置的 D 型正反器（netlist 上 rst 前多了一個反相器，因為元件庫裡的正反器是低電位有效重置）。入力データを保持する。非同期リセット付きの D フリップフロップ 12 個である（ライブラリのフリップフロップがアクティブ Low リセットのため、netlist では rst にインバータが付く）。

2.3 Ckt 2 — data converter2.3 電路 2 — 資料轉換器2.3 回路 2 — データ変換器

module temp_converter (temp_out, temp_in);
  input  [11:0] temp_in;
  output [11:0] temp_out;
  parameter k32 = 6'b100000;    // decimal 32

  // F = 9/5 C + 32, 9/5 = 1.8 ~ 1 + .5 + .25
  assign temp_out = temp_in + (temp_in >> 1)
                  + (temp_in >> 2) + k32;
endmodule

assign temp_out = ((temp_in << 1)
                 - (temp_in >> 2)) + k32;

2.4 Ckt 3 — data filter2.4 電路 3 — 資料濾波器2.4 回路 3 — データフィルタ

module temp_filter (av_temp, clk, rst, temp_data);
  output [11:0] av_temp;
  input         clk;
  input  [11:0] temp_data;
  reg    [11:0] temp [3:0];

  always @ (negedge clk or posedge rst)
    if (rst) begin
      temp[0] <= 0; temp[1] <= 0; temp[2] <= 0; temp[3] <= 0;
    end
    else begin: data_pipeline
      temp[3] <= temp_data;
      temp[2] <= temp[3];
      temp[1] <= temp[2];
      temp[0] <= temp[1];
    end

  assign av_temp = (temp[3] + temp[2] + temp[1] + temp[0]) >> 2;
endmodule

A 4-deep, 12-bit shift register (48 flip-flops, clocked on the falling edge) and an adder tree followed by >> 2 = divide by 4: a moving average of the last four samples. (rst is missing from the slide's port declarations; add input rst;.)一個 4 級、12 位元的移位暫存器（48 個正反器，以時脈下降緣觸發），後面接加法樹再做 >> 2，也就是除以 4：最近四筆樣本的移動平均。（投影片的埠宣告漏了 rst，要補上 input rst;。）4 段・12 ビットのシフトレジスタ（フリップフロップ 48 個、クロックの立ち下がりエッジ動作）に加算器ツリーを続け、最後に >> 2（4 で割る）を行う。すなわち直近 4 サンプルの移動平均である。（スライドのポート宣言には rst が抜けているので input rst; を追加する。）

2.5 Ckt 4 — FIFO controller2.5 電路 4 — FIFO 控制器2.5 回路 4 — FIFO コントローラ

module fifo_controller (data_out, data_1, data_2, select, read, write,
                        empty_1, full_1, read_1, empty_2, full_2, read_2);
  input  [11:0] data_1, data_2;
  input  [1:0]  select;
  input         read, full_1, empty_1, full_2, empty_2;
  output [11:0] data_out;
  output        read_1, read_2, write;
  reg    [11:0] data_out;
  reg           read_1, read_2, write;

  always @ (select or data_1 or data_2 or read or full_1
            or empty_1 or full_2 or empty_2) begin
    read_1 = 0;
    read_2 = 0;
    if (read == 1)
      begin
        write = 0;
        case (select)
          2'b01: begin data_out = data_1; read_1 <= 1; end
          2'b10: begin data_out = data_2; read_2 <= 1; end
          2'b00: begin data_out = {empty_1, empty_2, full_1, full_2}; end
          default: data_out = 12'bz;
        endcase
      end
    else if (read == 0)
      begin
        data_out = 12'bz;
        write = 1;
      end
    else data_out = 12'bz;
  end
endmodule

A combinational block: every output is assigned on every 0/1 path, so no latches. The final else only covers read = x in simulation. The 12'bz assignments become tri-state output buffers.這是一個組合邏輯區塊：每條 0/1 路徑都指定了所有輸出，所以不會推論出閂鎖（latch）。最後那個 else 只是為了模擬時的 read = x。12'bz 的指定會合成為三態輸出緩衝器。これは組合せ論理ブロックである。0/1 のどの経路でもすべての出力に代入しているため、ラッチは推論されない。最後の else はシミュレーション時の read = x に備えるだけである。12'bz の代入はトライステート出力バッファになる。

2.6 Top level2.6 頂層模組2.6 トップレベル

module temp_monitor_unit (channel_1, channel_2, select, clk, rst, read, data_out);
  output [11:0] data_out;
  input  [11:0] channel_1, channel_2;
  input  [1:0]  select;
  input         clk, rst, read;
  wire   [11:0] temp1_out, temp2_out, temp_conv1, temp_conv2, av_temp1, av_temp2;
  wire   [11:0] Data_out1, Data_out2;

  temp_register   M1 (temp1_out, channel_1, clk, rst);      // (1)
  temp_register   M2 (temp2_out, channel_2, clk, rst);
  temp_converter  M3 (temp_conv1, temp1_out);              // (2)
  temp_converter  M4 (temp_conv2, temp2_out);
  temp_filter     M5 (av_temp1, clk, rst, temp_conv1);      // (3)
  temp_filter     M6 (av_temp2, clk, rst, temp_conv2);

  FIFO M7 (Data_out1, av_temp1, stack_empty1, stack_full1, clk, rst,
           write_to_stack, read_from_stack1);               // (5)
  FIFO M8 (Data_out2, av_temp2, stack_empty2, stack_full2, clk, rst,
           write_to_stack, read_from_stack2);

  fifo_controller M9 (data_out, Data_out1, Data_out2,       // (4)
           select, read, write_to_stack, stack_empty1, stack_full1,
           read_from_stack1, stack_empty2, stack_full2, read_from_stack2);
endmodule

3. Design Example II: AMD2901 4-Bit Microcontroller3. 設計範例二：AMD2901 四位元微控制器3. 設計例 II：AMD2901 4 ビット・マイクロコントローラ

3.1 Architecture3.1 架構3.1 アーキテクチャ

• Register file: dual-address, 16 words; outputs ad and bd hold the words addressed by a and b.暫存器檔：雙位址、16 個字；輸出 ad 與 bd 分別是位址 a、b 指到的資料字。レジスタファイル：デュアルアドレス、16 ワード。出力 ad と bd は、それぞれアドレス a、b のワードを保持する。
• Q register: receives the ALU output; its output goes to the operand selector.Q 暫存器：接收 ALU 的輸出；它的輸出再送回運算元選擇器。Q レジスタ：ALU の出力を受け取り、その出力はオペランドセレクタへ戻される。
• Operand selector: picks the two ALU operands r, s.運算元選擇器：挑出 ALU 的兩個運算元 r 與 s。オペランドセレクタ：ALU の 2 つのオペランド r、s を選ぶ。
• ALU flags: c_out, ovr, carry look-ahead g_bar, p_bar; plus f_0 (zero) and f_3 (sign).ALU 旗標：c_out、ovr，以及進位預看用的 g_bar、p_bar；另有 f_0（零）與 f_3（正負號）。ALU のフラグ：c_out、ovr、桁上げ先見用の g_bar、p_bar。さらに f_0（ゼロ）と f_3（符号）がある。

3.2 The 9-bit instruction word3.2 九位元的指令字3.2 9 ビットの命令語

In the table a, b, q, d mean the register-file word at address a (ad), at address b (bd), the Q register and the direct data input; o/z means zero. (The slide's ALU column writes ||, &&; the bitwise operators are meant.)表中的 a、b、q、d 分別指位址 a 的暫存器檔資料字（ad）、位址 b 的資料字（bd）、Q 暫存器，以及直接資料輸入；o/z 代表零。（投影片的 ALU 欄寫成 ||、&&，其實要的是逐位元運算子。）表中の a、b、q、d は、それぞれアドレス a のレジスタファイルのワード（ad）、アドレス b のワード（bd）、Q レジスタ、直接データ入力を表し、o/z はゼロを意味する。（スライドの ALU 欄は ||、&& と書かれているが、意図はビット単位の演算子である。）

Destination i[8:6]目的地 i[8:6]デスティネーション i[8:6]

The shift occurs before the load. "—" is don't care; reg_f[a] is the register-file word at address a. In the bit columns, d[i] is bit i of the data being shifted; ram3/ram0 and q3/q0 are the serial in/out pins that chain neighbouring slices.移位發生在載入之前。「—」表示不在意（don't care）；reg_f[a] 是位址 a 的暫存器檔資料字。位元欄中的 d[i] 是被移位資料的第 i 位元；ram3/ram0 與 q3/q0 是把相鄰 bit slice 串接起來的序列輸入／輸出腳位。シフトはロードより先に行われる。「—」はドントケアを表し、reg_f[a] はアドレス a のレジスタファイルのワードである。ビット欄の d[i] はシフトされるデータの第 i ビットであり、ram3/ram0 と q3/q0 は隣接するスライスを連結するシリアル入出力ピンである。

3.3 Mnemonic definitions with `define3.3 用 `define 定義助記符3.3 `define によるニーモニックの定義

// amd2901 bit slice microprocessor
// operands: instruction[2:0]
`define aq    3'b000
`define ab    3'b001
`define zq    3'b010
`define zb    3'b011
`define za    3'b100
`define da    3'b101
`define dq    3'b110
`define dz    3'b111
// opcodes: instruction[5:3]
`define add   3'b000
`define subr  3'b001
`define subs  3'b010
`define orrs  3'b011
`define andrs 3'b100
`define notrs 3'b101
`define exor  3'b110
`define exnor 3'b111
// destination mnemonics: instruction[8:6]
`define qreg  3'b000
`define nop   3'b001
`define rama  3'b010
`define ramf  3'b011
`define ramqd 3'b100
`define ramd  3'b101
`define ramqu 3'b110
`define ramu  3'b111

Compiler directives are honored by synthesis (Lecture 7), so the code reads `ramqd instead of a magic number. Note or / and are Verilog keywords, hence `orrs / `andrs.合成工具會處理編譯器指令（第 7 講），所以程式碼裡寫的是 `ramqd 而不是一個沒頭沒腦的數字。注意 or 與 and 是 Verilog 的保留字，因此才改用 `orrs 與 `andrs。コンパイラ指令は合成でも解釈される（第 7 講）ため、コードではマジックナンバーではなく `ramqd と書ける。or と and は Verilog の予約語なので、`orrs / `andrs という名前になっている点に注意する。

3.4 Ckt 1 — register file3.4 電路 1 — 暫存器檔3.4 回路 1 — レジスタファイル

module Register_file (clk, rst, a, b, f, dest_ctl, ram0, ram3, ad, bd);
  input        clk, rst;
  input  [3:0] a, b, f;
  input  [2:0] dest_ctl;
  inout        ram0, ram3;
  output [3:0] ad, bd;
  reg    [3:0] ab_data [15:0];   // memory: 16 elements
  wire   [3:0] data;
  wire         ram_en;
  reg    [4:0] row_index;        // note: size of row_index is critical

  assign ram_en = ((dest_ctl == `qreg) || (dest_ctl == `nop)) ? 0 : 1;

  always @ (posedge clk or posedge rst)
    if (rst == 1) for (row_index = 0; row_index < 16; row_index = row_index + 1)
                    ab_data[row_index] = 0;
    else if (ram_en) ab_data[b] = data;

  assign data = (dest_ctl == `ramqu || dest_ctl == `ramu) ? {f[2], f[1], f[0], ram0} :
                (dest_ctl == `ramqd || dest_ctl == `ramd) ? {ram3, f[3], f[2], f[1]} :
                (dest_ctl == `rama  || dest_ctl == `ramf) ? f : 4'bxxxx;

  assign ad   = ab_data[a];
  assign bd   = ab_data[b];
  assign ram3 = (dest_ctl == `ramu || dest_ctl == `ramqu) ? f[3] : 1'bz;
  assign ram0 = (dest_ctl == `ramd || dest_ctl == `ramqd) ? f[0] : 1'bz;
endmodule

• row_index must count to 16 to exit the reset loop, so it needs 5 bits — a 4-bit index wraps 15 → 0 and the loop never ends (Lecture 7, Type I loop).row_index 必須數到 16 才能離開重置迴圈，所以要 5 個位元 —— 4 位元的索引會從 15 繞回 0，迴圈永遠不會結束（第 7 講的 Type I 迴圈）。row_index はリセットループを抜けるために 16 まで数える必要があるので 5 ビット必要である。4 ビットでは 15 → 0 と折り返し、ループが終わらない（第 7 講の Type I ループ）。
• Shifting up: ram0 is an input (bit from the lower slice) and f[3] leaves on ram3. Shifting down: the reverse. Otherwise both pins float (z), so the bidirectional inout pins chain slices together.上移時：ram0 是輸入（來自較低位 slice 的位元），而 f[3] 由 ram3 送出；下移時剛好相反。其他情況兩支腳都浮接（z），所以這組雙向 inout 腳位可以把多片 slice 串接起來。上方向シフトでは ram0 が入力（下位スライスからのビット）となり、f[3] が ram3 から出ていく。下方向シフトではその逆である。それ以外では両ピンとも浮いた状態（z）になるため、双方向の inout ピンでスライス同士を連結できる。
• The 4'bxxxx default only occurs when ram_en = 0, so it is a true don't care.4'bxxxx 這個預設值只在 ram_en = 0 時出現，所以它確實是不在意值。4'bxxxx というデフォルト値は ram_en = 0 のときしか現れないので、本当のドントケアである。

3.5 Ckt 2 — operand selector3.5 電路 2 — 運算元選擇器3.5 回路 2 — オペランドセレクタ

module operand_selector (d, ad, bd, q, op_sel, r, s);
  input  [3:0] d, ad, bd, q;
  input  [2:0] op_sel;
  output [3:0] r, s;
  reg    [3:0] r, s;

  // operand codes
  always @ (op_sel) begin
    case (op_sel)
      `aq, `ab:      assign r = ad;
      `zq, `zb, `za: assign r = 4'b0;
      default:       assign r = d;
    endcase
    case (op_sel)
      `aq, `zq, `dq: assign s = q;
      `ab, `zb:      assign s = bd;
      `za, `da:      assign s = ad;
      default:       assign s = 4'b0;
    endcase
  end
endmodule

Uses the "simulation efficient" procedural continuous assignment style from Lecture 5 §5.2: the block wakes only on op_sel, yet r/s keep following d, ad, bd, q. It synthesizes to two 4-bit muxes, but PCA support is tool dependent; always @* with plain = is the portable form.這裡用的是第 5 講 §5.2 那種「模擬效率高」的程序式連續指定（procedural continuous assignment, PCA）寫法：區塊只在 op_sel 變動時被喚醒，但 r/s 仍會持續跟著 d、ad、bd、q 改變。它會合成成兩個 4 位元多工器，不過各家工具對 PCA 的支援程度不一；用 always @* 搭配單純的 = 才是可攜的寫法。第 5 講 §5.2 の「シミュレーション効率のよい」手続き的連続代入（PCA）のスタイルを使っている。ブロックは op_sel の変化でしか起動しないが、r/s は d、ad、bd、q を追従し続ける。合成すると 4 ビットのマルチプレクサ 2 個になるが、PCA の対応はツール依存である。always @* と通常の = を使う書き方のほうが移植性が高い。

3.6 Ckt 3 — ALU3.6 電路 3 — ALU3.6 回路 3 — ALU

module ALU_amd2901 (r, s, c_in, ctl, alu_out, g_bar, p_bar, ovr, c_out);
  input  [3:0] r, s;
  input        c_in;
  input  [2:0] ctl;
  output [3:0] alu_out;
  output       g_bar, p_bar, ovr, c_out;
  reg    [3:0] alu_out;
  reg          c_out;

  always @ (r or s or c_in or ctl)
    case (ctl)
      `add:    {c_out, alu_out} = r + s + c_in;
      `subr:   {c_out, alu_out} = r + ~s + c_in;
      `subs:   {c_out, alu_out} = s + ~r + ~c_in;
      `orrs:   {c_out, alu_out} = {1'b0, r | s};
      `andrs:  {c_out, alu_out} = {1'b0, r & s};
      `notrs:  {c_out, alu_out} = {1'b0, (~r) & s};
      `exor:   {c_out, alu_out} = {1'b0, r ^ s};
      `exnor:  {c_out, alu_out} = {1'b0, r ~^ s};
      default: {c_out, alu_out} = 5'bx;
    endcase

  assign ovr   = c_out ^ alu_out[3];
  assign g_bar = ~( (r[3] & s[3]) |
                    ((r[3] | s[3]) & (r[2] & s[2])) |
                    ((r[3] | s[3]) & (r[2] | s[2]) & (r[1] & s[1])) |
                    ((r[3] | s[3]) & (r[2] | s[2]) & (r[1] | s[1]) & (r[0] & s[0])) );
  assign p_bar = ~((r[3] ^ s[3]) & (r[2] ^ s[2]) & (r[1] ^ s[1]) & (r[0] ^ s[0]));
endmodule

3.7 Ckt 4 — Q register3.7 電路 4 — Q 暫存器3.7 回路 4 — Q レジスタ

module Q_register (clk, rst, data_in, dest_ctl, qs0, qs3, q);
  // parameterized register with shift left (up), shift right (down)
  // and transfer of interface bits to/from companion slices
  input        clk, rst;
  input  [3:0] data_in;
  input  [2:0] dest_ctl;
  inout        qs0, qs3;
  output [3:0] q;
  reg    [3:0] data;
  reg          q_en;

  reg_load_R #(4) M1 (data, clk, rst, q_en, q);
  bufif1 (qs3, data_in[3], (dest_ctl == `ramu || dest_ctl == `ramqu));
  bufif1 (qs0, data_in[0], (dest_ctl == `ramd || dest_ctl == `ramqd));

  always @ (dest_ctl)
    case (dest_ctl)
      `qreg, `ramqd, `ramqu: assign q_en = 1;
      default:               assign q_en = 0;
    endcase

  always @ (dest_ctl or qs0 or qs3)
    case (dest_ctl)
      // shift left (up)
      `ramqu:  assign data = {data_in[2], data_in[1], data_in[0], qs0};
      // shift right (dn)
      `ramqd:  assign data = {qs3, data_in[3], data_in[2], data_in[1]};
      // pass through
      `qreg:   assign data = data_in;
      default: assign data = 4'bx;
    endcase
endmodule

module reg_load_R (data, clk, reset, load, q);
  parameter size = 8;
  input  [size-1:0] data;
  input             clk, reset, load;
  output [size-1:0] q;
  reg    [size-1:0] q;

  always @ (posedge clk or posedge reset)
    if (reset == 1) q = 0; else if (load == 1) q = data;
endmodule

reg_load_R loads the target data when load is high and otherwise holds (an enable register, not a latch — Lecture 6 §4.4). The Q register instantiates it with #(4) to override size. bufif1 primitives drive the serial pins only while shifting in the matching direction.reg_load_R 在 load 為高時載入資料，否則保持原值（這是帶致能的暫存器，不是閂鎖 —— 第 6 講 §4.4）。Q 暫存器用 #(4) 實體化它以覆寫 size。bufif1 原語只有在對應方向的移位期間才會驅動序列腳位。reg_load_R は load が High のときデータを取り込み、それ以外では値を保持する（ラッチではなくイネーブル付きレジスタである。第 6 講 §4.4）。Q レジスタは #(4) を付けてインスタンス化し、size を上書きしている。bufif1 プリミティブは、対応する方向へシフトしている間だけシリアルピンを駆動する。

3.8 Ckt 5 — output selector3.8 電路 5 — 輸出選擇器3.8 回路 5 — 出力セレクタ

module output_selector (mux_out, channel_1, channel_2, sel, enable);
  input  [3:0] channel_1, channel_2;
  input  [2:0] sel;
  input        enable;           // active low
  output [3:0] mux_out;

  assign mux_out = (enable == 0 && sel == `rama) ? channel_1 :
                   (enable == 0)                  ? channel_2 : 4'bz;
endmodule

Connected as (y, ad, alu_out, instruction[8:6], enable): y = ad for destination rama, otherwise alu_out, and high-Z when enable = 1.接線為 (y, ad, alu_out, instruction[8:6], enable)：目的地是 rama 時 y = ad，否則為 alu_out；而 enable = 1 時輸出高阻抗。接続は (y, ad, alu_out, instruction[8:6], enable) である。デスティネーションが rama なら y = ad、それ以外は alu_out となり、enable = 1 のときはハイインピーダンスになる。

3.9 Top-level module3.9 頂層模組3.9 トップレベル・モジュール

module amd2901 (clk, rst, enable, c_in, a, b, d, instruction, ram0, ram3,
                qs0, qs3, y, g_bar, p_bar, ovr, c_out, f_0, f_3);
  input        clk, rst, c_in, enable;
  input  [3:0] a, b, d;
  input  [8:0] instruction;
  inout        ram0, ram3;
  inout        qs0, qs3;
  output [3:0] y;
  output       g_bar, p_bar, ovr, c_out, f_0, f_3;
  wire   [3:0] ad, bd, q, r, s, alu_out;

  Register_file M1 (
    clk,                // system clock
    rst,                // global reset
    a, b,               // addresses to memory
    alu_out,            // data path from ALU
    instruction[8:6],   // micro instruction bits for destination
    ram0, ram3,         // LSB and MSB from memory word
    ad, bd              // memory output words (4 bits each)
  );
  ALU_amd2901      M2 (r, s, c_in, instruction[5:3], alu_out, g_bar, p_bar, ovr, c_out);
  output_selector  M3 (y, ad, alu_out, instruction[8:6], enable);
  operand_selector M4 (d, ad, bd, q, instruction[2:0], r, s);
  Q_register       M5 (clk, rst, alu_out, instruction[8:6], qs0, qs3, q);

  assign f_0 = (alu_out == 4'b0) ? 0 : 1'bz;
  assign f_3 = alu_out[3];
endmodule

f_0 is an open-drain-style zero flag (drives 0 or floats, so several slices can share one wired line with a pull-up); f_3 is the sign bit. The overall netlist is five sub-blocks plus a 4-input OR and an inverting tri-state (invtn_c) for f_0.f_0 是開汲極式的零旗標（只會拉低或浮接，所以多片 slice 可以共用一條接上提升電阻的線）；f_3 則是正負號位元。整體 netlist 就是五個子區塊，再加上一個 4 輸入 OR 與一個反相三態閘（invtn_c）來產生 f_0。f_0 はオープンドレイン形式のゼロフラグである（0 を駆動するか浮かせるかなので、複数のスライスがプルアップ付きの 1 本の線を共有できる）。f_3 は符号ビットである。全体の netlist は 5 つのサブブロックに、f_0 用の 4 入力 OR と反転トライステート（invtn_c）を加えたものになる。

4. Summary and Exam Checklist4. 總結與考前檢查清單4. まとめと試験前チェックリスト