Synthesis of Sequential Logic序向邏輯合成順序回路の合成

1. Synthesizing Sequential Logic1. 序向邏輯的合成1. 順序回路の合成

1.1 Commonly synthesized sequential logic1.1 常見被合成的序向邏輯1.1 よく合成される順序回路

1.2 When a register variable becomes a flip-flop1.2 暫存變數何時會變成正反器1.2 レジスタ変数がフリップフロップになるとき

A register variable in a behavior is synthesized as an edge-triggered flip-flop when行為描述中的暫存變數（reg）在下列情況下會被合成成邊緣觸發正反器：ビヘイビア記述中のレジスタ変数は、次の条件を満たすときエッジトリガ・フリップフロップとして合成される。

• it is aligned with the clock behavior (assigned inside always @(posedge clk) or negedge), and它與時脈行為對齊（在 always @(posedge clk) 或 negedge 中被指定），且クロック動作に同期していること（always @(posedge clk) または negedge の中で代入されること）、かつ
• it is assigned a value by some assignment there (and its value must survive to the next clock).它在該處被某個指定敘述賦值（而且它的值必須保留到下一個時脈）。そこで何らかの代入によって値が与えられること（その値は次のクロックまで保持される必要がある）。

module swap_synch (set1, set2, clk, data_a, data_b);
  output data_a, data_b;
  input  clk, set1, set2;
  reg    data_a, data_b;

  always @ (posedge clk)
    begin
      if (set1)      begin data_a <= 1; data_b <= 0; end
      else if (set2) begin data_a <= 0; data_b <= 1; end
      else
        begin
          data_b <= data_a;      // non-blocking: true swap
          data_a <= data_b;
        end
    end
endmodule

Each of data_a and data_b becomes one DFF fed by a 4:1 mux selected by {set1, set2}:data_a 與 data_b 各變成一個 DFF，前面接一個由 {set1, set2} 選擇的 4:1 多工器：data_a と data_b はそれぞれ 1 個の DFF になり、その前段に {set1, set2} で選択される 4:1 マルチプレクサが入る。

The synthesized netlist folds each mux into a few gates (inverter, AND, NOR) in front of the DFF.合成後的 netlist 會把每個多工器摺成 DFF 前面的幾個閘（反相器、AND、NOR）。合成後のネットリストでは、各マルチプレクサは DFF の前段にある数個のゲート（インバータ、AND、NOR）にまとめられる。

// (a)
always @ (posedge clk) begin t = a & b; y <= t | c; end
// (b)
always @ (posedge clk) begin y <= t | c; t = a & b; end
// (c)
always @ (posedge clk) begin q1 <= d; q2 <= q1; q3 <= q2; end
// (d)
always @ (posedge clk) begin q1 = d; q2 = q1; q3 = q2; end

2. Reset: Event Control, Synchronous and Asynchronous2. 重置：事件控制、同步與非同步2. リセット：イベント制御、同期と非同期

2.1 Event control with reset2.1 含 reset 的事件控制2.1 リセットを含むイベント制御

If the event control expression is sensitive to the edge of more than one signal:若事件控制運算式對一個以上訊號的邊緣敏感：イベント制御式が複数の信号のエッジに感応する場合：

• an if statement must be the first statement in the behavior;行為中的第一個敘述必須是 if 敘述；ビヘイビアの最初の文は if 文でなければならない。
• the synchronizing signal (clock) is not tested explicitly in the body — by default the last branch describes the synchronous activity.同步訊號（時脈）不在內文中明確測試 — 預設最後一個分支就是描述同步動作。同期信号（クロック）は本体で明示的に判定しない。既定では最後の分岐が同期動作を表す。

2.2 Asynchronous vs synchronous reset2.2 非同步 reset 與同步 reset2.2 非同期リセットと同期リセット

module reg_4_a (Data_in, clock, reset, Data_out);
  input  [3:0] Data_in;
  input        clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge clock or posedge reset)
    begin
      if (reset == 1'b1) Data_out <= 4'b0;
      else               Data_out <= Data_in;
    end
endmodule

module reg_4_b (Data_in, clock, reset, Data_out);
  input  [3:0] Data_in;
  input        clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge clock)
    begin
      if (reset == 1'b1) Data_out <= 4'b0;
      else               Data_out <= Data_in;
    end
endmodule

2.3 Waveform comparison (active-high reset)2.3 波形比較（高準位有效的 reset）2.3 波形の比較（アクティブハイのリセット）

3. Registered Combinational Logic3. 暫存化的組合邏輯3. レジスタ付き組合せ論理

3.1 Example 1 — registered AND3.1 範例 1 — 暫存化的 AND3.1 例 1 — レジスタ付き AND

module reg_and (a, b, c, clk, y);
  input  a, b, c, clk;
  output y;
  reg    y;

  always @ (posedge clk)
    begin
      y <= a & b & c;
    end
endmodule

The expression becomes a 3-input AND driving the D pin of one DFF.這個運算式變成一個 3 輸入 AND 閘，驅動一個 DFF 的 D 腳。この式は 3 入力 AND となり、1 個の DFF の D 端子を駆動する。

3.2 Example 2 — registered mux3.2 範例 2 — 暫存化的多工器3.2 例 2 — レジスタ付きマルチプレクサ

module mux_reg (a, b, c, d, y, select, clock);
  input  [7:0] a, b, c, d;
  output [7:0] y;
  input  [1:0] select;
  reg    [7:0] y;

  always @ (posedge clock)
    case (select)
      0: y <= a;          // non-blocking
      1: y <= b;          // same result with =
      2: y <= c;
      3: y <= d;
      default y <= 8'bx;
    endcase
endmodule

4. Shift Registers, Barrel Shifter and Load Registers4. 移位暫存器、桶形移位器與載入暫存器4. シフトレジスタ、バレルシフタ、ロードレジスタ

4.1 Shift register4.1 移位暫存器4.1 シフトレジスタ

On every triggering clock edge the register catches the input data.每個觸發的時脈邊緣，暫存器都會擷取輸入資料。トリガとなるクロックエッジごとに、レジスタは入力データを取り込む。

module Shift_reg4 (Data_in, Data_out, clock, reset);
  input       Data_in, clock, reset;
  output      Data_out;
  reg   [3:0] Data_reg;

  assign Data_out = Data_reg[0];

  always @ (negedge reset or posedge clock)
    begin
      if (reset == 1'b0) Data_reg <= 4'b0;            // async, active low
      else               Data_reg <= {Data_in, Data_reg[3:1]};
    end
endmodule

Data enters at bit 3 and shifts right; Data_out is the input delayed by 4 clocks. Four DFFs in a chain, all with asynchronous clear.資料從位元 3 進入並向右移；Data_out 就是延遲 4 個時脈的輸入。四個 DFF 串成一條鏈，全部帶非同步清除。データはビット 3 から入って右へシフトする。Data_out は入力を 4 クロック遅らせたものである。非同期クリア付きの DFF 4 個が直列に並ぶ。

4.2 Shift register with judgement4.2 帶判斷的移位暫存器4.2 判定付きシフトレジスタ

module shifter_1 (Data_in, clock, reset, sig_d, new_signal);
  input  Data_in, clock, reset;
  output sig_d, new_signal;
  reg    sig_a, sig_b, sig_c, sig_d, new_signal;

  always @ (posedge reset or posedge clock)
    begin
      if (reset == 1'b1)
        begin
          sig_a <= 0; sig_b <= 0; sig_c <= 0; sig_d <= 0;
          new_signal <= 0;
        end
      else
        begin
          sig_a <= Data_in;
          sig_b <= sig_a;
          sig_c <= sig_b;
          sig_d <= sig_c;
          new_signal <= (~sig_a) & sig_b;
        end
    end
endmodule

sig_b is the previous value of sig_a, so (~sig_a) & sig_b is 1 when the stream just went 1 → 0: a registered falling-edge detector (inverter + AND + one extra DFF).sig_b 是 sig_a 的前一個值，所以當位元流剛從 1 變 0 時 (~sig_a) & sig_b 為 1：這是一個暫存化的下降緣偵測器（反相器 + AND + 一顆額外的 DFF）。sig_b は sig_a の 1 つ前の値なので、ビット列が 1 → 0 と変化した直後に (~sig_a) & sig_b が 1 になる。すなわちレジスタ付きの立ち下がりエッジ検出器（インバータ + AND + DFF 1 個）である。

4.3 Barrel shifter with loading data4.3 可載入資料的桶形移位器4.3 データロード付きバレルシフタ

module barrel_shifter (Data_out, Data_in, load, clock, reset);
  output [7:0] Data_out;
  input  [7:0] Data_in;
  input        load, clock, reset;
  reg    [7:0] Data_out;

  always @ (posedge reset or posedge clock)
    begin
      if      (reset == 1'b1) Data_out <= 8'b0;
      else if (load  == 1'b1) Data_out <= Data_in;
      else                    Data_out <= {Data_out[6:0], Data_out[7]};  // rotate left
    end
endmodule

Each bit has a 2:1 mux (load ? Data_in[i] : Data_out[i-1]) in front of a DFF with asynchronous reset.每個位元在帶非同步重置的 DFF 前面都有一個 2:1 多工器（load ? Data_in[i] : Data_out[i-1]）。各ビットは、非同期リセット付き DFF の前段に 2:1 マルチプレクサ（load ? Data_in[i] : Data_out[i-1]）を持つ。

4.4 Stored register with loading data4.4 可載入資料的儲存暫存器4.4 データロード付き保持レジスタ

module Par_load_reg4 (Data_out, Data_in, load, clock, reset);
  input  [3:0] Data_in;
  input        load, clock, reset;
  output [3:0] Data_out;
  reg    [3:0] Data_out;

  always @ (posedge reset or posedge clock)
    begin
      if      (reset == 1'b1) Data_out <= 4'b0;
      else if (load  == 1'b1) Data_out <= Data_in;
    end
endmodule

No final else — but in a clocked block that is fine: holding the value is what a flip-flop does. The tool adds a feedback mux (or uses an enable flip-flop), not a latch.沒有最後的 else — 但在時序區塊中這沒問題：保持原值本來就是正反器的行為。工具會加上一個回授多工器（或改用帶 enable 的正反器），不會產生閂鎖。最後の else が無いが、クロック同期ブロックではこれで問題ない。値を保持することはフリップフロップ本来の動作だからである。ツールはフィードバック・マルチプレクサを追加する（またはイネーブル付きフリップフロップを使う）のであって、ラッチを作らない。

5. Ripple and Ring Counters5. 漣波計數器與環形計數器5. リプルカウンタとリングカウンタ

5.1 Ripple counter5.1 漣波計數器5.1 リプルカウンタ

module ripple_counter (clock, toggle, reset, count);
  input        clock, toggle, reset;
  output [3:0] count;
  reg    [3:0] count;
  wire         c0, c1, c2;

  assign c0 = count[0];
  assign c1 = count[1];
  assign c2 = count[2];

  always @ (posedge reset or posedge clock)
    if (reset == 1'b1) count[0] <= 1'b0; else
    if (toggle == 1'b1) count[0] <= ~count[0];

  always @ (posedge reset or negedge c0)
    if (reset == 1'b1) count[1] <= 1'b0; else
    if (toggle == 1'b1) count[1] <= ~count[1];

  always @ (posedge reset or negedge c1)
    if (reset == 1'b1) count[2] <= 1'b0; else
    if (toggle == 1'b1) count[2] <= ~count[2];

  always @ (posedge reset or negedge c2)
    if (reset == 1'b1) count[3] <= 1'b0; else
    if (toggle == 1'b1) count[3] <= ~count[3];
endmodule

Each stage is a toggle flip-flop clocked by the falling edge of the previous bit, so the count goes up 0, 1, 2, ... 15. The synthesized netlist realizes each T-FF as a DFF with an XOR (toggle ^ Q) at D, and the clock pin of stage i is driven by an inverted count[i-1].每一級都是一個由前一位元下降緣觸發的 toggle 正反器，所以計數值依 0, 1, 2, … 15 遞增。合成後的 netlist 把每個 T-FF 實作成 D 端接 XOR（toggle ^ Q）的 DFF，而第 i 級的時脈腳由反相後的 count[i-1] 驅動。各段は前のビットの立ち下がりエッジでクロックされるトグル・フリップフロップであり、計数値は 0, 1, 2, … 15 と増える。合成後のネットリストでは、各 T-FF は D に XOR（toggle ^ Q）を付けた DFF として実現され、第 i 段のクロック端子は反転した count[i-1] で駆動される。

5.2 Ring counter5.2 環形計數器5.2 リングカウンタ

module ring_counter (count, enable, clock, reset);
  output [7:0] count;
  input        enable, reset, clock;
  reg    [7:0] count;

  always @ (posedge reset or posedge clock)
    if (reset == 1'b1) count <= 8'b0000_0001; else
    if (enable == 1'b1) count <= {count[6:0], count[7]};   // concatenation operator
endmodule

A single 1 circulates: 0000_0001 → 0000_0010 → ... → 1000_0000 → 0000_0001. Eight states from eight DFFs, each output already one-hot decoded (no decoding glitches). Bit 0 resets to 1, so it needs a flip-flop that is preset rather than cleared.只有一個 1 在循環：0000_0001 → 0000_0010 → … → 1000_0000 → 0000_0001。八個 DFF 給出八個狀態，每個輸出本身就是 one-hot 解碼的結果（沒有解碼突波）。位元 0 重置後為 1，所以它需要的是預設（preset）而不是清除的正反器。1 個の 1 が巡回する：0000_0001 → 0000_0010 → … → 1000_0000 → 0000_0001。8 個の DFF で 8 状態を表し、各出力はそのままワンホットのデコード結果になる（デコードによるグリッチが無い）。ビット 0 はリセット後に 1 なので、クリアではなくプリセットされるフリップフロップが必要になる。

6. Pipelined 16-bit Adder6. 管線化的 16 位元加法器6. パイプライン化 16 ビット加算器

6.1 Serial connection of two 8-bit adders6.1 兩個 8 位元加法器的串接6.1 8 ビット加算器 2 個の直列接続

Two 8-bit adders chained through the carry form a 16-bit adder. The carry ripples through both, so the critical path is too long → use a pipelined design.兩個 8 位元加法器透過進位串接就構成一個 16 位元加法器。進位要漣波通過兩級，關鍵路徑太長 → 改用管線化設計。8 ビット加算器 2 個をキャリーで連結すると 16 ビット加算器になる。キャリーが両方を伝播するためクリティカルパスが長すぎる → パイプライン構成にする。

6.2 Pipelined design6.2 管線化設計6.2 パイプライン構成

module add_16_pipe (c_out, sum, a, b, c_in, clock);
  parameter size   = 16;
  parameter half   = size / 2;      // 8
  parameter double = 2 * size;      // 32
  parameter triple = 3 * half;      // 24
  parameter size1  = half - 1;      // 7
  parameter size2  = size - 1;      // 15
  parameter size3  = half + 1;      // 9
  parameter R1 = 1;                 // 1
  parameter L1 = half;              // 8
  parameter R2 = size3;             // 9
  parameter L2 = size;              // 16
  parameter R3 = size + 1;          // 17
  parameter L3 = size + half;       // 24
  parameter R4 = double - half + 1; // 25
  parameter L4 = double;            // 32

  input  [size2:0]  a, b;
  input             c_in, clock;
  output [size2:0]  sum;
  output            c_out;
  reg    [double:0] IR;
  reg    [triple:0] PR;
  reg    [size:0]   OR;

  assign {c_out, sum} = OR;

  always @ (posedge clock) begin
    // Load input register
    IR[0]     <= c_in;
    IR[L1:R1] <= a[size1:0];
    IR[L2:R2] <= b[size1:0];
    IR[L3:R3] <= a[size2:half];
    IR[L4:R4] <= b[size2:half];

    // Load pipeline register
    PR[L3:R3]  <= IR[L4:R4];
    PR[L2:R2]  <= IR[L3:R3];
    PR[half:0] <= IR[L2:R2] + IR[L1:R1] + IR[0];

    // Load output register
    OR <= {{1'b0, PR[L3:R3]} + {1'b0, PR[L2:R2]} + PR[half], PR[size1:0]};
  end
endmodule

7. Finite State Machines7. 有限狀態機7. 有限状態機械

7.1 Developing the logic of an FSM7.1 發展 FSM 的邏輯7.1 FSM の論理を組み立てる

• Make sure the description is complete (every state, every input, a default).確保描述是完整的（每個狀態、每個輸入，再加上 default）。記述が完全であることを確かめる（すべての状態、すべての入力、そして default）。
• Modeling options for the next-state / output logic: continuous assignments; a behavior whose event control is an event-or of the state and inputs; functions; an external module.次態／輸出邏輯的建模方式：連續指定；事件控制為狀態與輸入之 event-or 的行為區塊；函式；外部模組。次状態・出力論理のモデル化の選択肢：連続代入、状態と入力の event-or をイベント制御に持つビヘイビア、関数、外部モジュール。

7.2 Example: sequence detector7.2 範例：序列偵測器7.2 例：系列検出器

• Synchronously read a serial bit stream on the rising clock edge.在時脈上升緣同步讀取一串串列位元流。クロックの立ち上がりエッジでシリアルなビット列を同期的に読む。
• Assert the output after two successive 0s or two successive 1s.出現連續兩個 0 或連續兩個 1 之後，把輸出拉高。0 が 2 回連続、または 1 が 2 回連続したら出力をアサートする。
• Test bench: the input stream changes on the falling clock edge, so it is stable at every rising edge.測試平台（testbench）：輸入位元流在時脈下降緣改變，因此在每個上升緣都是穩定的。テストベンチ：入力列はクロックの立ち下がりエッジで変化するため、立ち上がりエッジでは常に安定している。

7.3 FSM type 1: Mealy machine7.3 FSM 型式一：Mealy 機7.3 FSM その 1：Mealy 機械

module seq_det_mealy_1exp (clock, reset, in_bit, out_bit);
  input       clock, reset, in_bit;
  output      out_bit;
  reg   [2:0] state_reg, next_state;
  parameter start_state = 3'b000;
  parameter read_1_zero = 3'b001;
  parameter read_1_one  = 3'b010;
  parameter read_2_zero = 3'b011;
  parameter read_2_one  = 3'b100;

  always @ (posedge clock or posedge reset)
    if (reset == 1) state_reg <= start_state; else state_reg <= next_state;

  always @ (state_reg or in_bit)
    case (state_reg)
      start_state: if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_1_zero: if (in_bit == 0) next_state = read_2_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_2_zero: if (in_bit == 0) next_state = read_2_zero; else
                   if (in_bit == 1) next_state = read_1_one;  else
                                    next_state = start_state;
      read_1_one:  if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_2_one;  else
                                    next_state = start_state;
      read_2_one:  if (in_bit == 0) next_state = read_1_zero; else
                   if (in_bit == 1) next_state = read_2_one;  else
                                    next_state = start_state;
      default:                      next_state = start_state;
    endcase

  assign out_bit = (((state_reg == read_1_zero) || (state_reg == read_2_zero)) && (in_bit == 0)) ||
                   (((state_reg == read_1_one)  || (state_reg == read_2_one))  && (in_bit == 1))
                   ? 1 : 0;
endmodule

Separate clocked state register and combinational next-state block, a complete case with default, and the output computed from state and in_bit. The final else branches only matter when in_bit is x/z in simulation.時序的狀態暫存器與組合的次態區塊分開寫、case 完整並附 default，而輸出由狀態與 in_bit 共同決定。最後那些 else 分支只有在模擬中 in_bit 為 x/z 時才會用到。クロック同期の状態レジスタと組合せの次状態ブロックを分け、case は default 付きで完全にし、出力は状態と in_bit から計算する。最後の else 分岐が意味を持つのは、シミュレーションで in_bit が x/z のときだけである。

Simulation: in_bit = 0011_1000_1 (left first)模擬：in_bit = 0011_1000_1（最左邊先進入）シミュレーション：in_bit = 0011_1000_1（左から順に入力）

out_bit is high while the state is 1 or 3 and the input is 0, or while the state is 2 or 4 and the input is 1 — i.e. during the bit periods where the second, third, ... equal bit is present at the input, before the clock edge that reads it.當狀態為 1 或 3 且輸入為 0，或狀態為 2 或 4 且輸入為 1 時，out_bit 為高 — 也就是在第二個、第三個……相同位元出現在輸入端的那段位元期間，早於讀取它的那個時脈邊緣。状態が 1 または 3 で入力が 0 のとき、あるいは状態が 2 または 4 で入力が 1 のとき、out_bit はハイになる。つまり 2 番目、3 番目…と続く等しいビットが入力に現れているビット期間であり、それを読み込むクロックエッジより前である。

7.4 FSM type 2: Moore machine7.4 FSM 型式二：Moore 機7.4 FSM その 2：Moore 機械

• next_state depends on {input, current_state} (transition logic T).next_state 取決於 {input, current_state}（轉移邏輯 T）。next_state は {input, current_state} に依存する（遷移論理 T）。
• The output depends only on {current_state} (output logic G).輸出只取決於 {current_state}（輸出邏輯 G）。出力は {current_state} のみに依存する（出力論理 G）。

State diagram: the same five states and transitions, with node outputs start_state/0, read_1_zero/0, read_1_one/0, read_2_zero/1, read_2_one/1.狀態圖：五個狀態與轉移都相同，節點輸出為 start_state/0、read_1_zero/0、read_1_one/0、read_2_zero/1、read_2_one/1。状態図：5 つの状態と遷移は同じで、ノードの出力は start_state/0、read_1_zero/0、read_1_one/0、read_2_zero/1、read_2_one/1 となる。

Approach I — explicit FSM方法一 — 明確式 FSM方法 I — 明示的 FSM

module seq_det_moore_1exp (clock, reset, in_bit, out_bit);
  ... // declarations identical to seq_det_mealy_1exp

  always @ (posedge clock or posedge reset)
    if (reset == 1) state_reg <= start_state; else state_reg <= next_state;

  always @ (state_reg or in_bit)
    case (state_reg)
      ... // next-state logic identical to the Mealy machine
    endcase

  assign out_bit = ((state_reg == read_2_zero) || (state_reg == read_2_one)) ? 1 : 0;
endmodule

The state sequence is identical to the Mealy machine; only the output differs. out_bit_moore rises after the clock edge that enters read_2_zero/read_2_one and lasts whole clock periods, whereas out_bit_mealy rises as soon as the matching input appears (half a cycle earlier with this test bench).狀態序列與 Mealy 機完全相同，只有輸出不同。out_bit_moore 在進入 read_2_zero／read_2_one 的那個時脈邊緣之後才拉高，並維持整個時脈週期；而 out_bit_mealy 在相符的輸入一出現就拉高（在這個測試平台中早了半個週期）。状態の並びは Mealy 機械と同一で、異なるのは出力だけである。out_bit_moore は read_2_zero／read_2_one に入るクロックエッジの後に立ち上がり、クロック周期ぶんだけ持続する。一方 out_bit_mealy は一致する入力が現れた時点で立ち上がる（このテストベンチでは半周期早い）。

7.5 Approach II — implicit state machine7.5 方法二 — 隱含式狀態機7.5 方法 II — 暗黙的状態機械 Un-synthesized無法合成合成不可

module seq_det_mealy_1imp (clock, reset, in_bit, out_bit);
  input  clock, reset, in_bit;
  output out_bit;
  reg    last_bit, this_bit, flag;
  wire   out_bit;

  always begin: wrapper_for_synthesis
    @ (posedge clock /* or posedge reset */) begin: machine
      if (reset == 1) begin
        last_bit = 0;
        this_bit = 0;
        flag     = 0;
        disable machine; end
      else begin                                            // 1
        last_bit = this_bit;
        this_bit = in_bit;
        forever
          @ (posedge clock /* or posedge reset */) begin   // 2
            if (reset == 1) begin
              last_bit = 0;
              this_bit = 0;
              flag     = 0;
              disable machine; end
            else begin
              last_bit = this_bit;
              this_bit = in_bit;
              flag     = 1; end
          end                                               // 2
      end                                                   // 1
    end    // machine
  end      // wrapper_for_synthesis

  assign out_bit = (flag && (this_bit == last_bit) && (this_bit == in_bit));
endmodule

• The state is implicit in where the code is waiting (first @ vs the @ inside forever), plus the stored bits and flag (set after the second sampled bit).狀態隱含在程式停在哪裡等待（第一個 @ 還是 forever 裡的 @），再加上存起來的位元與 flag（在取樣到第二個位元之後被設起來）。状態は、コードがどこで待っているか（最初の @ か、forever の中の @ か）と、保持されたビットおよび flag（2 ビット目をサンプルした後に立つ）に暗黙的に含まれる。
• It uses multiple event controls in one behavior and forever — constructs listed as "to be avoided" in Lecture 4 (Part 2). Only tools that support implicit state machines accept it (the slide's netlist uses scan-mux flip-flops dffrmqb for last_bit, this_bit, flag).它在同一個行為中使用多個事件控制，還用了 forever — 這些都是第 4 講（下）列為「應避免」的語法結構。只有支援隱含式狀態機的工具才接受（投影片的 netlist 以掃描多工正反器 dffrmqb 實作 last_bit、this_bit、flag）。1 つのビヘイビアの中で複数のイベント制御を使い、さらに forever も用いている。いずれも第 4 講（後半）で「避けるべき」と挙げられた構文である。暗黙的状態機械に対応したツールだけがこれを受け付ける（スライドのネットリストでは last_bit、this_bit、flag にスキャンマルチプレクサ付きフリップフロップ dffrmqb が使われている）。
• The reset is synchronous: posedge reset is commented out.這裡的 reset 是同步的：posedge reset 被註解掉了。ここでのリセットは同期式である。posedge reset はコメントアウトされている。

7.6 Various-way state encoding7.6 各種狀態編碼方式7.6 さまざまな状態符号化

parameter start_state = 5'b00001;
parameter read_1_zero = 5'b00010;
parameter read_1_one  = 5'b00100;
parameter read_2_zero = 5'b01000;
parameter read_2_one  = 5'b10000;

8. Summary and Exam Checklist8. 總結與考前檢查表8. まとめと試験前チェックリスト

always @ (posedge clock or posedge reset)      // state register
  if (reset) state_reg <= S0;
  else       state_reg <= next_state;

always @*                                     // next-state logic
  begin
    next_state = state_reg;                   // default: stay
    case (state_reg)
      ...
      default: next_state = S0;
    endcase
  end

assign out = (state_reg == S_DETECT);         // Moore output