Digital Communication IC Design
Verilog HDL Self-Study Guide數位通訊積體電路設計
Verilog HDL 自學指南デジタル通信 IC 設計
Verilog HDL 自学ガイド

1. Digital IC Design Flow and Abstraction1. 數位 IC 設計流程與抽象層次1. デジタル IC 設計フローと抽象化

1.1 The cell-based design flow1.1 Cell-based 設計流程1.1 セルベース設計フロー

The course places Verilog inside a larger industrial flow. Knowing where each tool sits is worth easy exam marks.本課程把 Verilog 放在一條更大的產業流程裡。知道每個工具落在哪個位置，是很好拿的考試分數。この講義は Verilog をより大きな産業フローの中に位置づけます。どのツールがどこに入るかを知っておくと、試験で確実に点が取れます。

The research-level loop the lecture draws is: choose a direction → pick a topic → simulate the algorithm (MATLAB/C) → write Verilog → verify the IC design → layout → fabrication → board assembly → chip measurement → compare against reference ICs. Verilog sits in the middle, and the algorithm simulation before it produces the golden pattern the testbench will later compare against.投影片畫出的研究層級循環是：選定方向 → 決定題目 → 模擬演算法（MATLAB/C）→ 撰寫 Verilog → 驗證 IC 設計 → 佈局 → 下線製造 → 電路板組裝 → 晶片量測 → 與參考 IC 比較。Verilog 位在中間，而在它之前的演算法模擬會產生測試平台日後要拿來比對的 golden pattern。講義が描く研究レベルのループは、方向を選ぶ → テーマを決める → アルゴリズムを（MATLAB/C で）シミュレーションする → Verilog を書く → IC 設計を検証する → レイアウト → 製造 → ボード実装 → チップ測定 → 参照 IC と比較、という流れです。Verilog はその中間にあり、その手前のアルゴリズムシミュレーションが、後でテストベンチが比較に使う golden pattern を生み出します。

1.2 Levels of abstraction1.2 抽象層次1.2 抽象化のレベル

1.3 Design model domains1.3 設計模型的三個領域1.3 設計モデルの 3 つの領域

The same design can be viewed in three domains at each level: abstract (behavior), structural (connectivity), and physical (geometry). Moving down the abstract column is design; moving rightwards from abstract to structural is synthesis; comparing the two is verification.同一份設計在每一層都可以從三個領域來看：抽象（行為）、結構（連接關係）與實體（幾何形狀）。沿著抽象那一欄往下走是設計；從抽象往右走到結構是合成；把兩者互相比對則是驗證。同じ設計は、どのレベルでも 3 つの領域から眺められます：抽象（動作）、構造（接続関係）、物理（幾何形状）。抽象の列を下に降りるのが設計、抽象から構造へ右に移るのが合成、両者を突き合わせるのが検証です。

2. Verilog Language Foundations2. Verilog 語言基礎2. Verilog 言語の基礎

2.1 Modules and ports2.1 模組與埠2.1 モジュールとポート

The module is the basic building block — Verilog's design entity. Three facts about modules carry most of the exam weight:module 是最基本的組成單位 — Verilog 的設計實體。關於模組有三件事佔了大部分的考試分數：module は最も基本的な構成単位、すなわち Verilog の設計エンティティです。モジュールについて試験の配点の大半を占めるのは次の 3 点です。

• Modules are created by declaration and can never be nested. Hierarchy is built by instantiation, not by textual nesting.模組是用宣告建立的，而且絕對不能巢狀。階層是靠實體化建立，不是靠文字上的巢狀。モジュールは宣言によって作られ、入れ子にはできません。階層はインスタンス化で作るものであり、テキスト上の入れ子で作るものではありません。
• All modules run concurrently. Textual order in the file means nothing.所有模組都同時執行。檔案中的文字先後順序毫無意義。すべてのモジュールは並行して動作します。ファイル内の記述順序には何の意味もありません。
• Port directions are input, output, inout; every port defaults to wire unless you declare otherwise.埠的方向有 input、output、inout；除非另行宣告，每個埠預設都是 wire。ポートの方向は input、output、inout の 3 つで、明示しない限りすべてのポートは既定で wire です。

module test (a, b, c, d);
  input  a, b;          // default net type: wire
  output c, d;
  wire   c, d;          // explicit, but redundant here

  assign c = a | b;     // continuous assignment, drives a net
  assign d = a & b;
endmodule

2.2 Nets versus registers — the central distinction2.2 net 與 register — 最核心的區別2.2 net と register — 中心となる区別

Verilog splits every signal into one of two families. Almost every "why does this not compile?" question in the course reduces to putting a signal in the wrong family.Verilog 把每個訊號分成兩大家族。這門課裡幾乎所有「為什麼這段編不過？」的問題，追根究柢都是把訊號放錯了家族。Verilog はすべての信号をこの 2 つの系統のいずれかに分類します。この講義で出てくる「なぜコンパイルが通らないのか」という疑問は、ほぼすべて信号を誤った系統に置いたことに帰着します。

module test (a, b, c, d);
  input  a, b;
  output c, d;
  reg    c, d;          // required because they are assigned procedurally

  always @ (a or b) begin   // sensitivity list
    c = a | b;
    d = a & b;
  end
endmodule

This synthesizes to exactly the same two gates as the assign version above — no latches, no flip-flops — because the sensitivity list is complete and both targets are assigned unconditionally.這段合成出來的結果，和上面用 assign 的版本完全相同 — 就是那兩個閘，沒有鎖存器、也沒有正反器 — 因為敏感度列表是完整的，而且兩個目標都被無條件賦值。これは上の assign 版とまったく同じ 2 つのゲートに合成されます — ラッチもフリップフロップも生じません — センシティビティリストが完全で、両方の対象が無条件に代入されているからです。

Scope作用範圍スコープ

The scope of a variable is the module, task, function, or named begin…end block in which it is declared. To reach inside an instantiated module from a testbench, use a hierarchical path name: X.w, or X.Y.Z.w. This is legal in testbenches and is how force reaches internal nodes; it is not synthesizable.一個變數的作用範圍是宣告它的那個 module、task、function，或具名的 begin…end 區塊。若要從測試平台伸進被實體化的模組內部，要用階層路徑名稱：X.w 或 X.Y.Z.w。這在測試平台中是合法的，也是 force 能碰到內部節點的方式；但它不可合成。変数のスコープは、それを宣言した module・task・function、または名前付きの begin…end ブロックです。テストベンチからインスタンス化したモジュールの内部に手を伸ばすには、階層パス名（X.w や X.Y.Z.w）を使います。テストベンチでは合法で、force が内部ノードに届くのもこの仕組みですが、合成はできません。

2.3 The four-value logic system2.3 四值邏輯系統2.3 4 値論理システム

Logic values are not case-sensitive (x and X are the same); identifiers and keywords are.邏輯值不分大小寫（x 和 X 相同）；識別字與關鍵字則會分。論理値は大文字・小文字を区別しません（x と X は同じ）。一方、識別子とキーワードは区別します。

The AND truth table over four values is the one to memorise, because it shows the asymmetry that makes x propagation tolerable:四值下的 AND 真值表最該背起來，因為它呈現出讓 x 的傳播不至於失控的那種不對稱性：4 値の AND 真理値表は覚えておくべきものです。x の伝播が許容できるものになる非対称性が、そこに現れているからです。

2.4 Number literals2.4 數值常量2.4 数値リテラル

• size — a decimal count of bits (optional)size — 以十進位寫的位元數（可省略）size — ビット数を十進で書いたもの（省略可）
• base_format — d/D decimal, h/H hex, o/O octal, b/B binarybase_format — d/D 十進、h/H 十六進、o/O 八進、b/B 二進base_format — d/D 十進、h/H 十六進、o/O 八進、b/B 二進
• number — the value expressed in that basenumber — 用該底數表示的數值number — その基数で表した値

Two rules govern what happens when size and value disagree:位元數與數值不吻合時，由兩條規則決定結果：サイズと値が食い違うときは、次の 2 つの規則が結果を決めます。

• Value too long → truncate from the left (keep the LSBs).數值太長 → 從左邊截掉（保留 LSB）。値が長すぎる → 左から切り捨てる（LSB 側を残す）。
• Value too short → pad on the left with 0, except that a leading x or z extends itself.數值太短 → 左邊補 0，但是開頭若為 x 或 z 則會自我延伸。値が短すぎる → 左を 0 で埋める。ただし先頭が x または z の場合はそれ自身が拡張されます。

2.5 The three descriptive styles2.5 三種描述風格2.5 3 つの記述スタイル

Verilog lets you mix all three freely inside one module. The exam habitually asks you to write the same circuit in all three.Verilog 允許在同一個模組裡自由混用這三種風格。考試很習慣要你把同一個電路用三種風格各寫一次。Verilog では 1 つのモジュール内で 3 つのスタイルを自由に混ぜられます。試験では同じ回路を 3 つのスタイルすべてで書かせるのが定番です。

module fa_bhv (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;
  reg    S, CO;         // required to hold values between events

  always @ (A or B or CI) begin
    S  = A ^ B ^ CI;                    // procedural assignment
    CO = A & B | A & CI | B & CI;
  end
endmodule

module fa_rtl (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;

  assign S  = A ^ B ^ CI;               // continuous assignment
  assign CO = A & B | A & CI | B & CI;
endmodule

module half_add (S, C, X, Y);
  output S, C;
  input  X, Y;
  xor (S, X, Y);        // primitive: output first, then inputs
  and (C, X, Y);
endmodule

module full_add (S, CO, A, B, CI);
  output S, CO;
  input  A, B, CI;
  wire   N1, N2, N3;

  or       P1  (CO, N3, N2);            // primitive with instance name P1
  half_add HA1 (N1, N2, A,  B),         // module instances
           HA2 (S,  N3, N1, CI);
endmodule

2.6 Instantiation and hierarchy2.6 實體化與階層2.6 インスタンス化と階層

Hierarchy is created by module instantiation. Rules:階層是由模組實體化建立的。規則如下：階層はモジュールのインスタンス化によって作られます。規則は次のとおりです。

• A module is never declared inside another module.模組絕不會宣告在另一個模組裡面。モジュールを別のモジュールの中で宣言することはできません。
• A module instance must be named. (A primitive instance need not be.)模組實體必須命名。（原件實體則不必。）モジュールのインスタンスには必ず名前が要ります。（プリミティブのインスタンスには不要です。）
• Ports may be connected by position, by name, or left empty.埠可以依位置連接、依名稱連接，或是留空不接。ポートは位置による接続、名前による接続のいずれでもよく、空のままにもできます。

// by position — order must match the declaration exactly
full_add FA0 (sum[0], c1, a[0], b[0], cin);

// by name — order is irrelevant, far safer for wide port lists
full_add FA0 (.S(sum[0]), .CO(c1), .A(a[0]), .B(b[0]), .CI(cin));

// empty port — leave an output unconnected
full_add FA0 (.S(sum[0]), .CO(), .A(a[0]), .B(b[0]), .CI(cin));

Array of instances實體陣列インスタンス配列

When the same bit-wise operation repeats across a vector, an array of instances is more compact than writing each one out:當同一個位元運算要在整個向量上重複時，用實體陣列會比一個一個寫出來簡潔得多：同じビット単位の演算がベクタ全体で繰り返されるときは、1 つずつ書き下すよりインスタンス配列のほうがはるかに簡潔です。

wire [3:0] a, b, y;
and A[3:0] (y, a, b);      // four AND gates: y[i] = a[i] & b[i]

A 16-bit ripple-carry adder built this way chains the carry through a wire vector:用這種寫法做出的 16 位元漣波進位加法器，會透過一條線向量把進位串起來：この書き方で作る 16 ビットのリップルキャリー加算器は、配線ベクタを通してキャリーを連結します。

module rca16 (sum, cout, a, b, cin);
  output [15:0] sum;  output cout;
  input  [15:0] a, b; input  cin;
  wire   [16:0] c;

  assign c[0] = cin;
  assign cout = c[16];

  full_add FA [15:0] (sum, c[16:1], a, b, c[15:0]);
endmodule

2.7 Language conventions2.7 語言慣例2.7 言語の約束事

• Verilog is case sensitive. Keywords are all lower-case.Verilog 區分大小寫。關鍵字全部是小寫。Verilog は大文字・小文字を区別します。キーワードはすべて小文字です。
• Identifiers may use letters, digits, underscore, and $; up to 1024 characters; the first character must not be a digit or $.識別字可以使用字母、數字、底線與 $，最長 1024 個字元；第一個字元不可以是數字或 $。識別子には英字・数字・アンダースコア・$ が使え、長さは 1024 文字までです。先頭の文字を数字や $ にすることはできません。
• Comments: // to end of line, /* ... */ for blocks.註解：// 到行尾，/* ... */ 為區塊註解。コメント：// は行末まで、/* ... */ はブロックコメントです。
• Compiler directives begin with a grave accent — e.g. `define state0 3'b001. That is a backtick, not an apostrophe.編譯器指令以重音符開頭 — 例如 `define state0 3'b001。那是反引號，不是單引號。コンパイラディレクティブはグレイヴアクセントで始まります — たとえば `define state0 3'b001。アポストロフィではなくバッククォートです。
• Names beginning with $ are built-in system tasks and functions — $monitor, $time, $finish. They never synthesize.以 $ 開頭的名稱是內建的系統任務與系統函式 — $monitor、$time、$finish。它們一律不可合成。$ で始まる名前は組み込みのシステムタスク・システム関数です — $monitor、$time、$finish。いずれも合成されません。

3. Simulation and Testbenches3. 模擬與測試平台3. シミュレーションとテストベンチ

3.1 Event-driven simulation3.1 事件驅動模擬3.1 イベント駆動シミュレーション

The simulator maintains a time-ordered event list. Initial events are the input changes in the testbench; executing them schedules further events at later times. Simulation stops when the event list becomes empty — or when $finish is executed, whichever comes first.模擬器維護一份依時間排序的事件清單。最初的事件是測試平台中的輸入變化；執行它們會排程更晚時刻的後續事件。當事件清單變空時模擬就停止 — 或是執行到 $finish，以先發生者為準。シミュレータは時刻順のイベントリストを保持します。最初のイベントはテストベンチでの入力変化であり、それを実行するとより後の時刻に新たなイベントが登録されます。イベントリストが空になるとシミュレーションは停止します — あるいは $finish が実行されたときで、どちらか早いほうです。

3.2 Delay in simulation, and the inertial rule3.2 模擬中的延遲與慣性規則3.2 シミュレーションにおける遅延と慣性の規則

With no delay specified, a gate produces its result immediately (zero response time). With a gate delay, the output is scheduled delay time units later. But Verilog gate delay is inertial, not transport, and that has a consequence that is a perennial exam question.沒有指定延遲時，閘會立即產生結果（反應時間為零）。有閘延遲時，輸出會被排程在延遲個時間單位之後。但 Verilog 的閘延遲是慣性延遲而非傳輸延遲，這件事帶來的後果是歷年必考題。遅延を指定しなければ、ゲートは即座に結果を出します（応答時間ゼロ）。ゲート遅延がある場合、出力は遅延時間単位だけ後に登録されます。ただし Verilog のゲート遅延は伝送遅延ではなく慣性遅延であり、その帰結は毎年のように試験に出ます。

3.3 Testbench anatomy3.3 測試平台的結構3.3 テストベンチの構成

The system tasks every testbench uses每個測試平台都會用到的系統任務どのテストベンチでも使うシステムタスク

`timescale 1ns/10ps

module tb_fa;
  reg  A, B, CI;
  wire S, CO;

  fa_rtl DUT (.S(S), .CO(CO), .A(A), .B(B), .CI(CI));   // connect by name

  initial
    $monitor("t=%0d A=%b B=%b CI=%b -> CO=%b S=%b", $time, A, B, CI, CO, S);

  initial begin
    {A,B,CI} = 3'b000;
    repeat (7) #10 {A,B,CI} = {A,B,CI} + 1'b1;          // sweep all 8 cases
    #10 $finish;
  end
endmodule

File I/O and memory loading檔案 I/O 與記憶體載入ファイル I/O とメモリのロード

• $fopen, $fclose, $fdisplay — behave like their C counterparts.$fopen、$fclose、$fdisplay — 行為與 C 的同名函式相同。$fopen、$fclose、$fdisplay — C の対応する関数と同じ振る舞いをします。
• $readmemh / $readmemb — read a text file into a 2-D array (hex or binary). Verilog supports only 2-D arrays, so a 1024×16 RAM is reg [15:0] RAM_1 [0:1023]; and the file has 1024 lines of 16 bits.$readmemh／$readmemb — 把文字檔讀進二維陣列（十六進位或二進位）。Verilog 只支援二維陣列，所以 1024×16 的 RAM 要寫成 reg [15:0] RAM_1 [0:1023];，而檔案有 1024 行、每行 16 個位元。$readmemh／$readmemb — テキストファイルを 2 次元配列に読み込みます（16 進または 2 進）。Verilog は2 次元配列しかサポートしないので、1024×16 の RAM は reg [15:0] RAM_1 [0:1023]; と書き、ファイルは 16 ビット 1024 行になります。

Compiler directives編譯器指令コンパイラディレクティブ

4. Data Types and Operators4. 資料型別與運算子4. データ型と演算子

4.1 Net types in detail4.1 net 型別詳解4.1 net 型の詳細

A classic tri use: O = A when E = 1, otherwise O = z. That is exactly what the built-in primitive bufif1 does.tri 的經典用法：E = 1 時 O = A，否則 O = z。這正是內建原件 bufif1 在做的事。tri の典型的な使い方：E = 1 のとき O = A、そうでなければ O = z。これは組み込みプリミティブ bufif1 がまさに行うことです。

Declaration forms宣告的寫法宣言の書き方

wire       x;                    // scalar
wand       y;                    // wired-AND resolution
wire [15:0] data;                // vector; data[5] bit-select, data[5:3] part-select
wire [0:7]  array_a;             // little-endian declaration; array_a[0:3] is the left half
wire [7:0]  array_2d_p [0:31];   // 32 entries of 8 bits; array_2d_p[2] is an 8-bit vector
wire        a = b + c;           // declaration with an implicit continuous assignment

4.2 Register types and memory4.2 register 型別與記憶體4.2 register 型とメモリ

reg        a, b;
reg [15:0] counter;
reg [7:0]  shift_reg [0:15];     // 16-deep memory of 8-bit words
integer    c;

Memory記憶體メモリ

A memory is a collection of registers — a 2-D array. Individual bits cannot be addressed directly: you must read a whole word out first.記憶體就是一群暫存器 — 一個二維陣列。不能直接定址到單一位元：必須先把整個字讀出來。メモリはレジスタの集まり、すなわち 2 次元配列です。個々のビットを直接アドレス指定することはできません。まずワード全体を読み出す必要があります。

reg [31:0] cache [0:1023];       // 1K x 32-bit memory
reg [31:0] one_word;
reg        one_bit;

one_word = cache[1022];          // legal: word select
one_bit  = one_word[31];         // legal: bit select on a plain reg
// one_bit = cache[1022][31];    // NOT legal in Verilog-1995/2001 memories

4.3 Addressing rules4.3 定址規則4.3 アドレッシングの規則

• MSB of a part-select = leftmost array index.部分選取的 MSB = 最左邊的陣列索引。部分選択の MSB = いちばん左の配列添字。
• LSB of a part-select = rightmost array index.部分選取的 LSB = 最右邊的陣列索引。部分選択の LSB = いちばん右の配列添字。
• An out-of-bounds part-select returns x — silently. Avoid it.超出範圍的部分選取會無聲地回傳 x。不要這樣寫。範囲外の部分選択は何も言わずに x を返します。書かないこと。

4.4 Parameters (constants)4.4 參數（常數）4.4 パラメータ（定数）

parameter size      = 16;
reg [size-1:0] a;                          // parameterised width
parameter num_b     = 2'b01;
parameter av_delay  = (min_delay + max_delay) / 2;   // expression of other parameters

A parameter's value cannot change during simulation, but it can be changed at compile time by substitution:參數的值在模擬期間不能改變，但可以在編譯期以替換的方式改掉：パラメータの値はシミュレーション中に変えられませんが、コンパイル時に置き換えることはできます。

module top;
  adder #(.WIDTH(8)) A1 (...);
  // or, the older form:
  defparam A2.WIDTH = 12;
  adder A2 (...);
endmodule

module adder (sum, a, b);
  parameter WIDTH = 4;
  output [WIDTH-1:0] sum;
  input  [WIDTH-1:0] a, b;
  assign sum = a + b;
endmodule

adder #(16) A3 (s, x, y);   // WIDTH = 16

4.5 Operator catalogue4.5 運算子總表4.5 演算子一覧

Arithmetic算術算術

Binary + - * / %; unary + -.二元 + - * / %；一元 + -。2 項 + - * / %、単項 + -。

Bitwise位元ビット単位

~ & | ^ ~^ ^~. The shorter operand is zero-extended to the width of the longer.~ & | ^ ~^ ^~。較短的運算元會被補零延伸到較長者的寬度。~ & | ^ ~^ ^~。短いほうのオペランドは長いほうの幅までゼロ拡張されます。

Reduction縮減リダクション

Unary operators & ~& | ~| ^ ~^ ^~ that collapse a vector to a single bit.一元運算子 & ~& | ~| ^ ~^ ^~，把一個向量收縮成單一位元。単項演算子 & ~& | ~| ^ ~^ ^~ は、ベクタを1 ビットに畳み込みます。

Logical邏輯論理

! && || == != === !==. These return a single-bit truth value.! && || == != === !==。這些回傳單一位元的真假值。! && || == != === !==。いずれも 1 ビットの真偽値を返します。

Only === and !== can ask "is this signal exactly x?" — and neither is synthesizable, because real hardware has no x.只有 === 與 !== 能問「這個訊號是不是剛好等於 x？」— 而且兩者都不可合成，因為真實硬體沒有 x。「この信号はちょうど x か」と問えるのは === と !== だけです — そしてどちらも合成できません。実際のハードウェアに x は存在しないからです。

Other operators其他運算子その他の演算子

{3{a}, 2{b}, 4{c}}   // -> {a,a,a, b,b, c,c,c,c}

4.6 Operator precedence4.6 運算子優先順序4.6 演算子の優先順位

5. User-Defined Primitives (UDPs)5. 使用者自定原件（UDP）5. ユーザー定義プリミティブ（UDP）

5.1 Primitives and the rules that govern them5.1 原件與規範它們的規則5.1 プリミティブとそれを律する規則

A primitive is a built-in logic model: and, or, nand, nor, buf, not, xor, xnor, and the tri-state buffers bufif0/1, notif0/1. Because the predefined set is limited, Verilog lets you define your own with primitive … endprimitive.原件是內建的邏輯模型：and、or、nand、nor、buf、not、xor、xnor，以及三態緩衝器 bufif0/1、notif0/1。由於預先定義的種類有限，Verilog 讓你用 primitive … endprimitive 自己定義。プリミティブは組み込みの論理モデルで、and、or、nand、nor、buf、not、xor、xnor、およびトライステートバッファ bufif0/1、notif0/1 があります。定義済みの種類は限られているため、Verilog では primitive … endprimitive で自分のプリミティブを定義できます。

and (d, a, b, c);          // no instance name — legal
and M1 (z2, x2, y2);       // with instance name — also legal
my_udp   (c2, a2, b2);
my_udp N1 (c1, a1, b1);

5.2 Table symbols5.2 表格符號5.2 テーブル記号

5.3 Combinational UDPs5.3 組合邏輯 UDP5.3 組合せ論理 UDP

Structure: $n$ inputs, 1 output, and therefore $n+1$ columns in the table — the first $n$ are inputs, the last is the output.結構：$n$ 個輸入、1 個輸出，因此表格有 $n+1$ 欄 — 前 $n$ 欄是輸入，最後一欄是輸出。構成：入力 $n$ 個と出力 1 個なので、テーブルは $n+1$ 列になります — 先頭の $n$ 列が入力、最後の 1 列が出力です。

Boolean function out = ab + ac + bc (majority of three)布林函數 out = ab + ac + bc（三者多數決）ブール関数 out = ab + ac + bc（3 入力の多数決）

primitive boolean_func (out, a, b, c);
  output out;
  input  a, b, c;

  table
    // a  b  c  :  out
       0  0  ?  :  0;
       0  ?  0  :  0;
       ?  0  0  :  0;
       1  1  ?  :  1;
       1  ?  1  :  1;
       ?  1  1  :  1;
  endtable
endprimitive

5.4 Sequential UDPs5.4 序向 UDP5.4 順序回路 UDP

Structure: $n$ inputs, plus a state and an output — so $n+2$ columns: <n inputs> : <state> : <output = next state>. The output port must be declared reg, and an initial statement inside the primitive may set its power-up value.結構：$n$ 個輸入，再加上一個狀態與一個輸出 — 所以有 $n+2$ 欄：<n 個輸入> : <狀態> : <輸出＝次態>。輸出埠必須宣告為 reg，而原件內部的 initial 敘述可以設定它的上電初值。構成：入力 $n$ 個に状態と出力が加わるので $n+2$ 列になります：<n 個の入力> : <状態> : <出力＝次状態>。出力ポートは reg と宣言する必要があり、プリミティブ内の initial 文で電源投入時の値を設定できます。

Two flavours:有兩種：2 つの種類があります。

• Level-sensitive — evaluate whenever the observation signal is at the active level. Models a latch.準位敏感 — 只要觀測訊號處於作用準位就求值。用來模擬鎖存器。レベルセンシティブ — 観測信号がアクティブレベルにある間はいつでも評価します。ラッチのモデルです。
• Edge-sensitive — evaluate only at the rising or falling edge. Models a flip-flop.邊緣敏感 — 只在上升或下降邊緣求值。用來模擬正反器。エッジセンシティブ — 立ち上がりまたは立ち下がりエッジでのみ評価します。フリップフロップのモデルです。

primitive latch (q, clk, d);
  output q;  reg q;
  input  clk, d;

  table
   // clk  d  : state : q(next)
        0   1  :   ?   :   1;
        0   0  :   ?   :   0;
        1   ?  :   ?   :   -;  // hold
  endtable
endprimitive

primitive dff (q, clk, d);
  output q;  reg q;
  input  clk, d;

  table
   // clk    d  : state : q(next)
      (01)   0  :   ?   :   0;
      (01)   1  :   ?   :   1;
      (0x)   1  :   1   :   1;
      (0x)   0  :   0   :   0;
      (?0)   ?  :   ?   :   -;  // ignore falling
       ?    (??):   ?   :   -;  // ignore data change
  endtable
endprimitive

primitive mux2 (out, sel, a, b);
  output out;
  input  sel, a, b;

  table
   // sel  a  b  :  out
       0   1  ?  :   1;
       0   0  ?  :   0;
       1   ?  1  :   1;
       1   ?  0  :   0;
       x   0  0  :   0;    // both agree — selector does not matter
       x   1  1  :   1;
  endtable
endprimitive

6. Models of Propagation Delay6. 傳播延遲的模型6. 伝搬遅延のモデル

6.1 Gate propagation delay6.1 閘的傳播延遲6.1 ゲートの伝搬遅延

Signal transition definitions訊號轉態的定義信号遷移の定義

Delay specification forms延遲的指定方式遅延の指定形式

and (y, x1, x2);                 // no delay — zero
and #2 (y, x1, x2);              // all transitions: 2
and #1.45 (y, x1, x2);           // fractional, scaled by `timescale
and #(2,3) (y, x1, x2);          // rise = 2, fall = 3

bufif1 #(3,4,1) (out, in, ctrl); // rise = 3, fall = 4, turn-off = 1
bufif1 #(3:4:5, 6:7:8, 5:8:9) (out, in, ctrl);  // min:typ:max for each

The bufif1 truth table — worth knowing because it is the basis of every tri-state bus:bufif1 的真值表 — 值得記住，因為每一條三態匯流排都建立在它之上：bufif1 の真理値表 — あらゆるトライステートバスの土台なので覚えておく価値があります。

L means "0 or z", H means "1 or z" — the simulator's way of saying the output is either driven or floating but definitely not the opposite polarity.L 代表「0 或 z」，H 代表「1 或 z」— 這是模擬器在說：輸出不是被驅動就是浮接，但絕不會是相反的極性。L は「0 または z」、H は「1 または z」を表します — 出力は駆動されているかフローティングかのどちらかであって、逆の極性には決してならない、というシミュレータの言い方です。

6.2 Net delay6.2 net 延遲6.2 ネット遅延

Delay may be attached to a net, and it adds to the gate delay of whatever drives it.延遲可以掛在 net 上，而且它會疊加到驅動它的那個閘的延遲之上。遅延はネットにも付けられ、それを駆動するもののゲート遅延に加算されます。

module my_xor1 (y_out, a, b);
  output y_out;
  input  a, b;
  xor #5 (y_out, a, b);
endmodule

module my_xor2 (y_out, a, b);
  output y_out;
  input  a, b;
  wire #3 y_int;          // net delay = 3
  xor #5 (y_int, a, b);   // gate delay = 5
  assign y_out = y_int;
endmodule

6.3 Module path delay and specify blocks6.3 模組路徑延遲與 specify 區塊6.3 モジュールパス遅延と specify ブロック

In a structural description, the module delay can be traced through gate and net delays. In a behavioral description there are no gates to trace, so paths are described separately inside specify … endspecify.在結構描述中，模組延遲可以沿著閘延遲與 net 延遲一路追蹤。但行為描述裡沒有閘可以追，所以路徑要另外寫在 specify … endspecify 之中。構造記述では、モジュールの遅延をゲート遅延とネット遅延をたどって求められます。しかし動作記述にはたどるべきゲートがないため、経路は specify … endspecify の中に別途記述します。

specify
  // simple path, parallel connection (bit i to bit i)
  (a => y) = (3, 4);                  // rise = 3, fall = 4

  // full connection: every bit of a to every bit of y
  (a *> y) = (3, 4);

  // named delay values
  specparam t_rise = 3, t_fall = 4;
  (b => y) = (t_rise, t_fall);

  // state-dependent: only while enable is high (a latch)
  if (enable) (data *> q) = (3, 4);

  // edge-sensitive: clock edge to register output
  (posedge clock => (q +: data)) = (5, 6);
endspecify

Pulse rejection脈衝排除パルスの除去

Module paths obey inertial-delay rules too. A pulse narrower than the path delay is rejected. The PATHPULSE$ specparam lets you separate two thresholds:模組路徑同樣遵守慣性延遲規則。比路徑延遲窄的脈衝會被排除。PATHPULSE$ 這個 specparam 讓你把兩個門檻分開：モジュールパスも慣性遅延の規則に従います。パス遅延より狭いパルスは除去されます。specparam の PATHPULSE$ を使うと、2 つのしきい値を分けて指定できます。

• Reject limit — pulses narrower than this are suppressed entirely.排除門檻（reject limit） — 比它還窄的脈衝會被完全抑制。リジェクト限界 — これより狭いパルスは完全に抑制されます。
• Error limit — pulses between the reject and error limits propagate as x, flagging "this might be a real glitch, I cannot tell".錯誤門檻（error limit） — 介於排除門檻與錯誤門檻之間的脈衝會以 x 傳播，等於標示「這也許是真的突波，我判斷不了」。エラー限界 — リジェクト限界とエラー限界の間にあるパルスは x として伝搬し、「本物のグリッチかもしれないが判断できない」と示します。

6.4 Time units and `timescale6.4 時間單位與 `timescale6.4 時間単位と `timescale

With `timescale 10ps/1ps: one time unit is 10 ps, and all times are rounded to 1 ps precision. So nor #3.57 (z, x1, x2) gives a delay of $3.57 \times 10\,\text{ps} = 35.7\,\text{ps}$, rounded to 36 ps.用 `timescale 10ps/1ps 時：一個時間單位是 10 ps，所有時間都四捨五入到 1 ps 的精度。因此 nor #3.57 (z, x1, x2) 的延遲是 $3.57 \times 10\,\text{ps} = 35.7\,\text{ps}$，取整為 36 ps。`timescale 10ps/1ps の場合、1 時間単位は 10 ps で、すべての時刻は 1 ps の精度に丸められます。したがって nor #3.57 (z, x1, x2) の遅延は $3.57 \times 10\,\text{ps} = 35.7\,\text{ps}$ となり、丸めて 36 ps です。

wire #2.5 w;
and #(1.24, 3.66) G1 (w, a, b);
assign y = w;

BNF notation, brieflyBNF 記法簡介BNF 記法について簡単に

The IEEE Verilog standard describes syntax in Backus-Naur Form. You need to read it, not write it:IEEE Verilog 標準用 Backus-Naur Form 描述語法。你需要會讀它，不需要會寫它：IEEE Verilog 規格は構文を Backus-Naur Form で記述しています。読めれば十分で、書けるようになる必要はありません。

For example conditional_expression ::= expression1 ? expression2 : expression3.例如 conditional_expression ::= expression1 ? expression2 : expression3。たとえば conditional_expression ::= expression1 ? expression2 : expression3 です。

7. Behavioral Descriptions7. 行為描述7. 動作記述

Everything from the preceding sections can coexist in one module:前面各節提到的一切，都可以共存在同一個模組裡：ここまでの節で扱ったものは、すべて 1 つのモジュールの中に共存できます。

module my_module (...);
  assign ...;                  // continuous assignment
  and (...);                   // instantiation of a primitive
  my_udp (...);                // instantiation of a UDP
  adder_16bits M1 (...);       // instantiation of a module
  always @ (...) begin         // behavior
    ...
  end
endmodule

7.1 initial and always7.1 initial 與 always7.1 initial と always

The body may be a single statement or a block statement delimited by begin … end. Procedural statements assign values to register variables — the one exception being force…release, which can also target nets.本體可以是單一敘述，也可以是以 begin … end 括起來的區塊敘述。程序式敘述賦值給的是register 變數 — 唯一的例外是 force…release，它也可以作用在 net 上。本体は単一の文でも、begin … end で囲んだブロック文でもかまいません。手続き文が値を代入する相手はレジスタ変数です — 唯一の例外が force…release で、これはネットも対象にできます。

initial begin
  sig_a = 0;     // procedural assignments
  sig_b = 1;     // execute sequentially
  sig_c = 0;
end

always @ (b or c or d) begin
  if (b == 1'b1)
    a = c;
  else
    a = d;
end

7.2 Blocking versus non-blocking assignment7.2 阻擋式與非阻擋式賦值7.2 ブロッキング代入とノンブロッキング代入

a = 0;
a = 1;
c = a;     // c = 1

a = 0;
a <= 1;
c = a;     // c = 0

In the non-blocking case, a <= 1 schedules the update for the end of the time step, so c = a still reads the old value 0.在非阻擋式的情況下，a <= 1 把更新排到時間步的最後，所以 c = a 讀到的仍是舊值 0。ノンブロッキングの場合、a <= 1 は更新を時間ステップの最後に登録するため、c = a が読むのは古い値 0 のままです。

The rule you actually code by實際寫程式時依循的規則実際にコードを書くときの規則

7.3 Intra-assignment delay7.3 賦值內延遲7.3 代入内遅延

a = #5 b;     // b captured now, written at t+5;
              //   flow resumes at t+5
c = d;        // executes at t+5

e = @(bus) f;  // f captured now, written when
               //   bus next changes
g = h;         // executes after that event

With non-blocking assignment the difference becomes dramatic, because the activity flow is not suspended at all:改用非阻擋式賦值後差別更明顯，因為活動流程完全不會被暫停：ノンブロッキング代入にすると違いは劇的になります。実行フローがまったく止まらないからです。

initial begin
  d <= #10 0;     // evaluated at t=0, scheduled for t=10
  d <= #11 1;     // evaluated at t=0, scheduled for t=11
  d <= #12 0;     // evaluated at t=0, scheduled for t=12
  d <= #13 1;     // evaluated at t=0, scheduled for t=13
end                // all four lines execute at t=0

Repeated intra-assignment delay重複型的賦值內延遲繰り返しを伴う代入内遅延

repeat may appear in the intra-assignment position to wait for $n$ occurrences of an event — the idiomatic way to say "capture this now, deliver it three clocks later":repeat 可以出現在賦值內的位置，用來等待某事件發生 $n$ 次 — 這是「現在就把值抓起來，三個時脈之後再送出去」的慣用寫法：repeat は代入内の位置に書いて、あるイベントが $n$ 回起こるのを待てます — 「今の値を取り込んで、3 クロック後に出す」という定型表現です。

a = repeat (3) @(posedge clk) b;   // b captured now, written on the 3rd rising edge

Not synthesizable; useful in testbenches.不可合成；在測試平台裡很好用。合成はできませんが、テストベンチでは便利です。

7.4 Procedural continuous assignment (PCA)7.4 程序式連續賦值（PCA）7.4 手続き型連続代入（PCA）

Two mechanisms that override normal assignment. Both are dynamic bindings, both are testbench and debugging tools, and synthesis tools might not support either.有兩種機制可以覆蓋一般的賦值。兩者都是動態繫結，都是測試平台與除錯用的工具，而且合成工具可能兩者都不支援。通常の代入を上書きする仕組みが 2 つあります。どちらも動的な束縛であり、テストベンチとデバッグのための道具で、合成ツールはどちらもサポートしない可能性があります。

// force/release reaching into the DUT from a testbench
initial begin
  #100 force DUT.sig_a = 1'b1;     // hierarchical de-reference to an internal node
  #50  force DUT.sig_b = 1'b0;
  #50  release DUT.sig_a;
       release DUT.sig_b;
end                                 // non-synthesizable

Net and register assignment modes — the summary tablenet 與 register 的賦值方式 — 總表ネットとレジスタへの代入方式 — まとめの表

7.5 Procedural timing controls7.5 程序式時序控制7.5 手続き型のタイミング制御

posedge and negedge — exact definitionsposedge 與 negedge — 精確定義posedge と negedge — 正確な定義

The transitions through x are the reason a simulation can appear to clock itself during the unknown-value startup phase before reset is applied.會經過 x 的那些轉態，正是為什麼在重置生效之前那段值都未知的啟動階段，模擬看起來像是會自己打時脈。x を経由する遷移があるからこそ、リセットがかかる前の値が不定な起動段階では、シミュレーションが勝手にクロックを刻んでいるように見えるのです。

Event or — a D flip-flop with asynchronous active-low set and reset事件 or — 帶非同步低態有效 set 與 reset 的 D 正反器イベントの or — 非同期・負論理のセットとリセットを持つ D フリップフロップ

always @ (posedge clk or negedge set or negedge rst) begin
  if (rst == 0)
    q = 1'b0;                // asynchronous reset — highest priority
  else if (set == 0)
    q = 1'b1;                // asynchronous set
  else if (clk == 1)
    q = data_in;             // synchronous branch — must be last
  else
    q = q;
end

waitwaitwait

data_out = 0;
wait (enable) data_out = data_in;   // suspend until enable is true

wait is level-sensitive (unlike @, which is edge/change sensitive) and is not synthesizable.wait 是準位敏感的（不像 @ 是邊緣／變化敏感），而且不可合成。wait はレベルセンシティブで（エッジ・変化に反応する @ とは異なります）、合成できません。

Named events具名事件名前付きイベント

event  trigger;           // declared only within a module
always @ (posedge clk) -> trigger;          // event-trigger operator
always @ (trigger) $display("fired at %0d", $time);

Named events synchronize activity within and between modules; they can be referenced from other modules by hierarchical de-referencing. Not synthesizable.具名事件用來在模組內部與模組之間同步活動；可以由其他模組透過階層路徑引用。不可合成。名前付きイベントは、モジュール内およびモジュール間で動作を同期させるために使い、他のモジュールから階層パスで参照できます。合成はできません。

7.6 Activity flow control7.6 活動流程控制7.6 実行フローの制御

Available constructs: the conditional operator ?:; case, casex, casez; if…else; loops repeat, for, while, forever; disable; and fork…join.可用的語法結構：條件運算子 ?:；case、casex、casez；if…else；迴圈 repeat、for、while、forever；disable；以及 fork…join。使える構文：条件演算子 ?:、case・casex・casez、if…else、ループの repeat・for・while・forever、disable、そして fork…join。

case and its variantscase 及其變體case とその派生

if…elseif…elseif…else

• True is the numerical value 1. False is any of {0, x, z}.真就是數值 1。假則是 {0, x, z} 中的任何一個。真は数値の 1 です。偽は {0, x, z} のいずれかです。
• A dangling else pairs with the nearest if. Use begin…end when nesting to make the intent explicit.懸空的 else 會配給最近的 if。巢狀時請用 begin…end 把意圖寫清楚。宙に浮いた else はいちばん近い if と結び付きます。入れ子にするときは begin…end で意図を明示してください。

Loops迴圈ループ

parameter memory_size = 1024;
integer i;

initial begin
  i = 0;
  repeat (memory_size) begin
    mem[i] = 0;
    i = i + 1;
  end
end

integer k;
always @ (a or b) begin
  for (k = 0; k < 8; k = k + 1)
    y[k] = a[k] & b[k];
end
// unrolls into 8 AND gates

while (count < limit) begin
  ...
  count = count + 1;
end

initial begin
  clk = 0;
  forever #5 clk = ~clk;   // 10-unit period
end

begin : search_block          // named block
  for (i = 0; i < 16; i = i + 1)
    if (mem[i] == target) begin
      found = 1;
      disable search_block;   // break out early
    end
end

7.7 fork…join and race conditions7.7 fork…join 與競爭條件7.7 fork…join と競合状態

There is no ordering among the threads, so interaction between them can create ambiguity.執行緒之間沒有先後順序，所以它們一旦互動就可能產生無法確定的結果。スレッド間に順序関係がないため、互いに影響し合うとあいまいさが生じ得ます。

fork
  a = 1;
  b = a;      // is b 1 or the old a?
join

fork
  a = 1;
  #1 b = a;   // ordering is now explicit
join

7.8 Simulation of procedural assignments — the time-step algorithm7.8 程序式賦值的模擬 — 時間步演算法7.8 手続き型代入のシミュレーション — 時間ステップのアルゴリズム

Within one simulation time step, the simulator performs these steps in this order:在一個模擬時間步之內，模擬器依照這個順序執行下列步驟：1 つのシミュレーション時間ステップの中で、シミュレータはこの順序で次の処理を行います。

1. Evaluate all expressions on the right-hand sides.計算所有右式的運算式。すべての右辺の式を評価する。
2. Execute blocking assignments.執行阻擋式賦值。ブロッキング代入を実行する。
3. Execute non-blocking assignments that have no intra-assignment timing control.執行沒有賦值內時序控制的非阻擋式賦值。代入内タイミング制御を持たないノンブロッキング代入を実行する。
4. Execute past assignments that had been scheduled to land in the current time step.執行先前排程、要落在目前這個時間步的賦值。以前に登録され、現在の時間ステップに着地する予定の代入を実行する。
5. Execute $monitor. ($display executes when it is encountered — that is, before the non-blocking assignments.)執行 $monitor。（$display 是在被執行到的當下就跑 — 也就是在非阻擋式賦值之前。）$monitor を実行する。（$display は出会った時点で実行される — つまりノンブロッキング代入より前です。）
6. Advance simulation time.推進模擬時間。シミュレーション時刻を進める。

module blocking_nonblocking ();
  reg a, b, c, d;

  initial begin            initial begin
    #10  a = 0;              c = #10 0;
    #11  a = 1;              c = #11 1;
    #12  a = 0;              c = #12 0;
    #13  a = 1;              c = #13 1;
  end                      end

  initial begin            initial begin
    #10  b <= 0;             d <= #10 0;
    #11  b <= 1;             d <= #11 1;
    #12  b <= 0;             d <= #12 0;
    #13  b <= 1;             d <= #13 1;
  end                      end

  initial begin
    $monitor("TIME = %d A = %b B = %b C = %b D = %b", $time, a, b, c, d);
    #50 $finish;
  end
endmodule

// Attempt 1                  // Attempt 2                 // Attempt 3
always @(posedge clk) begin   always @(posedge clk) begin  always @(posedge clk)
  a = b;                        a <= b;                      a <= b;
  b = a;                        b <= a;                    always @(posedge clk)
end                           end                            b <= a;

8. Tasks, Functions, and Timing Analysis8. 任務、函式與時序分析8. タスク・関数とタイミング解析

8.1 Task versus function8.1 task 與 function8.1 task と function

Both let you call a common procedure from several places and both improve readability. The differences are mechanical and heavily examined:兩者都讓你從多個地方呼叫同一段共用流程，也都能改善可讀性。差別是機械式的，而且是考試重點：どちらも共通の処理を複数の場所から呼び出せるようにし、可読性も高めます。違いは形式的なものですが、試験で頻出です。

task full_adder;
  input  a, b, cin;
  output sum, cout;
  begin
    sum  = a ^ b ^ cin;
    cout = (a & b) | (a & cin) | (b & cin);
  end
endtask

always @ (a or b or cin)
  full_adder (a, b, cin, s, co);

function [3:0] add4;
  input [3:0] x, y;
  begin
    add4 = x + y;      // assign to the function name
  end
endfunction

assign sum = add4(a, b);   // called in an expression

Worked example — LFSR as a function實例演練 — 用 function 寫 LFSR実例 — LFSR を function で書く

A Linear Feedback Shift Register is the standard binary pattern generator for self-testing circuits, and in a communication IC it is also the scrambler and the PRBS source. The lecture's structure:線性回授移位暫存器是自我測試電路的標準二元圖樣產生器，在通訊 IC 裡它同時也是擾碼器與 PRBS 源。投影片給的結構是：線形帰還シフトレジスタは自己テスト回路の標準的な 2 値パターン発生器であり、通信 IC ではスクランブラや PRBS 源でもあります。講義が示す構成は次のとおりです。

• $C_N = 1$ always, meaning $Y[0]$ feeds the input of the leftmost register (stage $N-1$).$C_N = 1$ 恆成立，代表 $Y[0]$ 餵進最左邊那個暫存器（第 $N-1$ 級）的輸入。$C_N = 1$ は常に成り立ち、$Y[0]$ が最も左のレジスタ（第 $N-1$ 段）の入力に入ることを意味します。
• For $j = 1, 2, \ldots, N-1$: if $C_j = 1$, then the XOR of $Y[j]$ and $Y[0]$ forms the input of the register at stage $j-1$; otherwise $Y[j]$ itself feeds stage $j-1$.對 $j = 1, 2, \ldots, N-1$：若 $C_j = 1$，則 $Y[j]$ 與 $Y[0]$ 的 XOR 構成第 $j-1$ 級暫存器的輸入；否則就由 $Y[j]$ 自己餵進第 $j-1$ 級。$j = 1, 2, \ldots, N-1$ について、$C_j = 1$ なら $Y[j]$ と $Y[0]$ の XOR が第 $j-1$ 段のレジスタの入力になり、そうでなければ $Y[j]$ 自身が第 $j-1$ 段に入ります。

module lfsr (Y, clk, rst);
  parameter N    = 8;
  parameter TAPS = 8'b1000_1110;    // C[N-1:0], the characteristic polynomial
  output [N-1:0] Y;
  input          clk, rst;
  reg    [N-1:0] Y;

  function [N-1:0] next_state;
    input [N-1:0] y;
    integer j;
    begin
      next_state[N-1] = y[0];                        // C_N = 1 always
      for (j = 1; j <= N-1; j = j + 1)
        next_state[j-1] = TAPS[j] ? (y[j] ^ y[0]) : y[j];
    end
  endfunction

  always @ (posedge clk or posedge rst)
    if (rst) Y <= {N{1'b1}};        // must never be all-zero
    else     Y <= next_state(Y);
endmodule

8.2 Static versus dynamic timing analysis8.2 靜態時序分析與動態時序分析8.2 静的タイミング解析と動的タイミング解析

8.3 Timing-check system tasks8.3 時序檢查系統任務8.3 タイミングチェック・システムタスク

These may be invoked inside a testbench behavior or inside a module's specify block.這些可以在測試平台的 behavior 內呼叫，也可以寫在模組的 specify 區塊裡。これらはテストベンチの behavior の中でも、モジュールの specify ブロックの中でも呼び出せます。

The edge specifieredge 指定子edge 指定子

The transitions {01, 10, 0x, x1, 1x, x0} can be named explicitly:轉態 {01, 10, 0x, x1, 1x, x0} 可以被明確指名：遷移 {01, 10, 0x, x1, 1x, x0} は明示的に名指しできます。

$setuphold (data, edge 01 clk, 5, 2);

NotifiersNotifierノーティファイア

When a timing check is violated, Verilog reports the violation but the output still takes its new value — which hides the fact that real silicon might have gone metastable. A notifier fixes this: an extra port on a sequential UDP that forces the output to x whenever the notifier register toggles.時序檢查被違反時，Verilog 會回報違規，但輸出仍然會取得新值 — 這就掩蓋了真實矽晶片可能已經進入介穩態的事實。notifier 解決了這件事：在序向 UDP 上多加一個埠，只要 notifier 暫存器翻轉就把輸出強制成 x。タイミングチェックに違反すると、Verilog は違反を報告しますが出力は新しい値を取ってしまいます — 実際のシリコンならメタステーブルになっていたかもしれない事実が隠れてしまうのです。ノーティファイアがこれを解決します。順序回路 UDP に追加のポートを設け、ノーティファイア・レジスタがトグルするたびに出力を x に強制します。

reg notifier;
specify
  $setuphold (posedge clk, data, 5, 2, notifier);
endspecify
// the UDP has an extra input port bound to `notifier`;
//   toggling it drives q to x, propagating the uncertainty

9. Finite State Machines9. 有限狀態機9. 有限状態機械

9.1 Mealy versus Moore9.1 Mealy 與 Moore9.1 Mealy と Moore

9.2 Explicit versus implicit style9.2 顯式風格與隱式風格9.2 明示的スタイルと暗黙的スタイル

always begin
  @(posedge clk) y = 0;
  @(posedge clk) y = 1;
  @(posedge clk) y = 1;
end
// no state register; reset is awkward;
//   only works for a simple ring

always @(posedge clk or posedge rst)
  if (rst) state <= S0;
  else     state <= next_state;

always @(*)
  case (state)
    S0: next_state = S1;
    S1: next_state = S2;
    S2: next_state = S0;
    default: next_state = S0;
  endcase

9.3 The recommended coding template9.3 建議的撰寫樣板9.3 推奨される記述テンプレート

The resulting three-block template is the one to reproduce under exam conditions:由此得到的三區塊樣板，就是考試時要能默寫出來的那一個：こうして得られる 3 ブロックのテンプレートが、試験で再現できるようにしておくべきものです。

module seq_detect (out, in_bit, clk, rst);
  output out;
  input  in_bit, clk, rst;

  parameter S0 = 2'b00,   // no history
            S1 = 2'b01,   // last bit was 0
            S2 = 2'b10,   // last bit was 1
            S3 = 2'b11;   // two successive equal bits seen

  reg [1:0] state, next_state;

  // ---- Block 1: state register (sequential) ----
  always @ (posedge clk or posedge rst)
    if (rst) state <= S0;
    else     state <= next_state;

  // ---- Block 2: next-state logic (combinational) ----
  always @ (state or in_bit)
    case (state)
      S0:      next_state = in_bit ? S2 : S1;
      S1:      next_state = in_bit ? S2 : S3;
      S2:      next_state = in_bit ? S3 : S1;
      S3:      next_state = in_bit ? S3 : S1;
      default: next_state = S0;          // completes the case — no latch
    endcase

  // ---- Block 3: output logic (Moore: state only) ----
  assign out = (state == S3);
endmodule

9.4 State encoding9.4 狀態編碼9.4 状態エンコーディング