PCBと回路 — 論理ゲートから半導体プロセスまで

「NANDゲートひとつから汎用コンピュータを組み上げられる」という事実は、 計算機科学における最も美しい帰結のひとつである。 — Noam Nisan & Shimon Schocken, The Elements of Computing Systems

この章で学ぶこと

• MOSFET の動作原理と CMOS 論理の構成方法を説明できる
• 基本論理ゲート（NOT, AND, OR, NAND, NOR, XOR）の真理値表を書ける
• NANDゲートの万能性（functional completeness）を証明できる
• 組み合わせ回路（加算器、マルチプレクサ、デコーダ）を設計できる
• 順序回路（ラッチ、フリップフロップ、カウンタ）の動作を説明できる
• Verilog HDL で基本的な回路記述ができる
• PCB（プリント基板）の設計原理と多層構造を理解する
• FPGA の構成要素とリコンフィギュラブル・コンピューティングの概念を説明できる
• 半導体製造プロセスの全工程を概説できる
• プロセスノード微細化の物理的限界と最新技術動向を把握する

前提知識

• ブール代数の基本（AND, OR, NOT）の概念
• 電圧・電流の初歩的な概念（中学理科レベル）

対象読者

目次

1. トランジスタ — コンピュータの最小構成要素
2. 論理ゲート — ブール代数の物理実装
3. 組み合わせ回路 — 論理ゲートの組み合わせ
4. 順序回路 — 記憶と状態遷移
5. Verilog HDL による回路記述
6. PCB（プリント基板）の設計と構造
7. FPGA — リコンフィギュラブル・ハードウェア
8. 半導体製造プロセス
9. 最新技術動向と将来展望
10. アンチパターンと設計の落とし穴
11. 実践演習
12. FAQ
13. まとめ
14. 参考文献

1. トランジスタ — コンピュータの最小構成要素

1.1 半導体の物理

コンピュータの計算能力の根源は、半導体の物理特性にある。導体（金属）は電気をよく通し、絶縁体（ガラス）は通さない。半導体はその中間に位置し、外部条件（電圧、温度、不純物の添加）によって導電性を制御できる。

シリコン（Si）は4価の元素であり、結晶構造では隣接する原子と4つの共有結合を形成する。純粋なシリコンの導電性は非常に低いが、不純物を意図的に添加するドーピングによって電気特性を大きく変化させられる。

ドーピングの原理:

  N型半導体（リン P を添加）:

P型半導体（ホウ素 B を添加）:

PN接合:

空乏層（電界形成）

  → 順方向バイアスで電流ON、逆方向で電流OFF
  → これがダイオードの原理であり、トランジスタの基盤技術

なぜシリコンか？ シリコンが半導体産業の主役である理由は複数ある:

1.2 MOSFET の動作原理

MOSFET（Metal-Oxide-Semiconductor Field-Effect Transistor）は現代のデジタル回路における基本素子である。電界効果によってチャネルの導通を制御する。

NMOS トランジスタの構造と動作:

  断面図:
           ゲート (G)
             │

Source              Drain

  動作モード:
  ─────────────────────────────────────────────
  ゲート電圧 Vgs    チャネル状態    論理値
  ─────────────────────────────────────────────
  0V (Low)          閉（非導通）    OFF → 論理 0
  Vdd (High)        開（導通）      ON  → 論理 1
  ─────────────────────────────────────────────

  閾値電圧 Vth:
  - Vgs < Vth → OFF（カットオフ領域）
  - Vgs > Vth → ON（飽和/線形領域）
  - 先端プロセスでは Vth ≈ 0.2〜0.4V 程度

PMOS トランジスタは NMOS と相補的に動作する。基板が N 型で、ソース・ドレインが P 型であり、ゲートに Low を印加すると導通する。

NMOS vs PMOS 比較:

  NMOS:                          PMOS:
  Vgs = High → ON                Vgs = Low → ON
  Vgs = Low  → OFF               Vgs = High → OFF

1.3 CMOS 論理の利点

CMOS（Complementary MOS）技術が現代の集積回路の標準となった理由を整理する。

CMOS の最大の利点は静的消費電力がほぼゼロであることである。PMOS と NMOS が相補的に動作するため、論理状態が安定しているとき、Vdd から GND への直通経路が存在しない。電力を消費するのはスイッチング遷移時のみであり、これにより数十億個のトランジスタを 1 チップに集積しても、熱設計電力（TDP）を実用的な範囲に収められる。

1.4 トランジスタ数の進化

ムーアの法則とトランジスタ数の推移:

  年代    チップ             トランジスタ数    プロセス
  ──────────────────────────────────────────────────────
  1971    Intel 4004             2,300         10 μm
  1978    Intel 8086            29,000          3 μm
  1989    Intel 486          1,200,000          1 μm
  1999    Pentium III         9,500,000        250 nm
  2006    Core 2 Duo        291,000,000         65 nm
  2012    Ivy Bridge      1,400,000,000         22 nm
  2020    Apple M1       16,000,000,000          5 nm
  2023    Apple M3 Max   92,000,000,000          3 nm
  2024    Apple M4       28,000,000,000          3 nm

  → 約50年間で10桁以上の増加
  → 2年で約2倍のペースは鈍化傾向にあるが、
    3D積層やチップレット技術で実効的な集積度は向上し続けている

2. 論理ゲート — ブール代数の物理実装

2.1 ブール代数の復習

ジョージ・ブール（1854年）が体系化したブール代数は、TRUE/FALSE（1/0）の2値を扱う数学体系である。クロード・シャノン（1937年）がリレー回路とブール代数の等価性を示したことで、論理回路設計の数学的基盤が確立された。

ブール代数の基本法則:

恒等法則:     A + 0 = A          A · 1 = A
零元法則:     A + 1 = 1          A · 0 = 0
べき等法則:   A + A = A          A · A = A
補元法則:     A + A' = 1         A · A' = 0
交換法則:     A + B = B + A      A · B = B · A
結合法則:     (A+B)+C = A+(B+C)  (A·B)·C = A·(B·C)
分配法則:     A·(B+C) = A·B+A·C  A+(B·C) = (A+B)·(A+C)
吸収法則:     A + A·B = A        A · (A+B) = A
ド・モルガン: (A+B)' = A'·B'     (A·B)' = A'+B'

ド・モルガンの法則は特に重要である。この法則により、AND と OR は NOT を介して相互変換できることが示される。これが NAND（および NOR）の万能性の数学的根拠となる。

2.2 基本論理ゲートの CMOS 実装

各論理ゲートは CMOS トランジスタの組み合わせとして実装される。

基本論理ゲート — 真理値表と CMOS トランジスタ数:

注: NAND と NOR は AND/OR よりトランジスタ数が少ない
   → 実際の回路設計では NAND/NOR ベースで構成するのが効率的

CMOS NANDゲートの回路構成:

  Vdd ─── ┬ ─────── ┬ ───
           │         │

        ┌──┴──┐   ┌──┴──┐
  A ────┤PMOS │   │PMOS ├──── B
        └──┬──┘   └──┬──┘

│         │
           └────┬────┘
                │
                ├──────── 出力 Y = (A·B)'
                │

             ┌──┴──┐
  A ─────────┤NMOS │
             └──┬──┘

             ┌──┴──┐
  B ─────────┤NMOS │
             └──┬──┘

│
  GND ──────────┘

  動作:
  - A=0 or B=0 → PMOS側が導通 → Y=Vdd(1)
  - A=1 and B=1 → NMOS側が導通 → Y=GND(0)
  - PMOS は並列接続（どちらかONで導通）
  - NMOS は直列接続（両方ONで導通）

2.3 NAND の万能性（Functional Completeness）

NANDゲートは「万能ゲート」（universal gate）と呼ばれ、NANDの組み合わせだけで他の全ての論理ゲートを構成できる。これを functional completeness（機能完全性）という。

NANDゲートによる他ゲートの構成:

1. NOT(A) = NAND(A, A)

   A ──┬──[NAND]── A'
       │
   A ──┘

2. AND(A, B) = NOT(NAND(A, B)) = NAND(NAND(A,B), NAND(A,B))

   A ──┐                    ┌──[NAND]── A·B
   B ──┴──[NAND]──┬─────────┤
                  └─────────┘

3. OR(A, B) = NAND(NOT(A), NOT(B)) = NAND(NAND(A,A), NAND(B,B))

   A ──┬──[NAND]──┐
       │          ├──[NAND]── A+B
   A ──┘          │
   B ──┬──[NAND]──┘
       │
   B ──┘

4. XOR(A, B) = NANDゲート4個で構成可能

   A ──┬───────────[NAND]──┐
       │                   │
       ├──[NAND]──W──┬─────┤
       │              │    ├──[NAND]── A⊕B
   B ──┤              │    │
       │              ├────┘
       └──────────────┤
                      │
   B ──┬──────────────┘
       │
       └──────[NAND]──┘

   簡略化: W = NAND(A,B)
   XOR = NAND(NAND(A,W), NAND(B,W))

証明の概略: 任意のブール関数は、カルノー図または真理値表から主加法標準形（SOP: Sum of Products）として表現できる。SOP は AND, OR, NOT の組み合わせであり、上記の通り全て NAND で構成できる。したがって NAND は機能完全である。NOR も同様に機能完全であることが証明できる。

2.4 伝搬遅延とファンアウト

実際の論理ゲートには理想的でない特性がある。

伝搬遅延（Propagation Delay）: 入力変化から出力が安定するまでの時間。先端プロセス（3nm〜5nm）では数ピコ秒（ps）オーダーだが、ゲートを多段接続するとこの遅延が累積する。クリティカルパス（最長遅延経路）がクロック周波数の上限を決定する。

ファンアウト（Fan-out）: 1つのゲート出力が駆動できる後段ゲートの入力数。ファンアウトが大きすぎると信号品質が劣化する。一般に、標準セルライブラリでは FO4（ファンアウト4のインバータ遅延）を遅延の基本単位として用いる。

グリッチ（Glitch）: 組み合わせ回路において、異なる経路の伝搬遅延差により、出力が一時的に誤った値を示す現象。同期式設計ではクロックエッジでのみ値をサンプリングすることでグリッチの影響を排除する。

3. 組み合わせ回路 — 論理ゲートの組み合わせ

組み合わせ回路（Combinational Circuit）は、出力が現在の入力のみに依存する回路である。内部に記憶素子を持たず、同じ入力に対して常に同じ出力を返す。

3.1 半加算器と全加算器

算術演算の最も基本的な回路が加算器である。

半加算器（Half Adder）:

  入力: A, B（各1ビット）
  出力: Sum（和）, Cout（繰り上がり）

  回路:
  A ──┬──[XOR]── Sum = A ⊕ B
      │
  B ──┤
      │
      └──[AND]── Cout = A · B

  真理値表:

全加算器（Full Adder）:

  入力: A, B, Cin（前段からの繰り上がり）
  出力: Sum, Cout

  回路（半加算器2つ + ORゲート1つ）:

  A ──┬──[HA1]──S1──┬──[HA2]── Sum = A ⊕ B ⊕ Cin
      │             │
  B ──┘    C1──┐    │
               │  Cin ──┘    C2──┐
               │                  │
               └──[OR]────────────┘── Cout

  論理式:
  Sum  = A ⊕ B ⊕ Cin
  Cout = (A · B) + (Cin · (A ⊕ B))

  真理値表:

3.2 リップルキャリー加算器と高速化手法

N ビット加算器を構成する最も単純な方法は、N 個の全加算器を直列に接続するリップルキャリー加算器（Ripple Carry Adder）である。

4ビット リップルキャリー加算器:

  A0 B0   A1 B1   A2 B2   A3 B3
   │  │    │  │    │  │    │  │
   ▼  ▼    ▼  ▼    ▼  ▼    ▼  ▼

  ┌────┐  ┌────┐  ┌────┐  ┌────┐
  │FA0 │─→│FA1 │─→│FA2 │─→│FA3 │─→ Cout
  └────┘  └────┘  └────┘  └────┘

│        │       │       │
    ▼        ▼       ▼       ▼
   S0       S1      S2      S3

  Cin=0 → FA0 → C1 → FA1 → C2 → FA2 → C3 → FA3 → Cout

  遅延: O(N) — キャリーが最下位から最上位まで伝搬するため
  → 32ビット/64ビット加算器では遅延が大きすぎる

この遅延問題を解決するために、キャリー先読み加算器（Carry Lookahead Adder: CLA）が開発された。

キャリー先読み加算器（CLA）の原理:

  各ビット位置 i に対して:
    Generate: Gi = Ai · Bi      （そのビットでキャリーが生成される）
    Propagate: Pi = Ai ⊕ Bi     （前段のキャリーが伝搬される）

  キャリーの計算:
    C1 = G0 + P0·C0
    C2 = G1 + P1·G0 + P1·P0·C0
    C3 = G2 + P2·G1 + P2·P1·G0 + P2·P1·P0·C0
    C4 = G3 + P3·G2 + P3·P2·G1 + P3·P2·P1·G0 + P3·P2·P1·P0·C0

  → 全キャリーを並列計算可能
  → 遅延: O(log N) — 大幅な高速化

  加算器の速度比較:

3.3 マルチプレクサ（MUX）

マルチプレクサは複数の入力から1つを選択して出力する回路である。CPUのデータパスにおいて、レジスタの選択やALUの入力切り替えなどに広く使用される。

2:1 マルチプレクサ:

  D0 ──┐
       ├──[MUX]── Y
  D1 ──┘
        │
  S ────┘（選択信号）

  Y = S'·D0 + S·D1

  S=0 → Y=D0
  S=1 → Y=D1

4:1 マルチプレクサ:

  D0 ──┐
  D1 ──┤
       ├──[MUX]── Y
  D2 ──┤
  D3 ──┘
      │ │
  S1 ─┘ └─ S0

  Y = S1'·S0'·D0 + S1'·S0·D1 + S1·S0'·D2 + S1·S0·D3

  → N:1 MUX は log₂(N) 本の選択信号を必要とする
  → 任意のブール関数を MUX で実装可能（LUT として機能）

MUXの万能性: N 入力のブール関数は、2^N : 1 MUX を使って実装できる。入力を選択信号に接続し、データ入力に真理値表の出力値を設定すればよい。この原理が FPGA の LUT（Look-Up Table）の基盤となっている。

3.4 デコーダとエンコーダ

2:4 デコーダ:

  入力 A1 A0 → 出力 Y3 Y2 Y1 Y0

用途:
  - メモリアドレスデコーダ（アドレス → メモリセル選択）
  - 命令デコーダ（オペコード → 制御信号）
  - 7セグメントディスプレイのドライバ

3.5 ALU（算術論理演算ユニット）

ALU は CPU の中核であり、加算、減算、AND、OR、XOR、シフトなどの演算を実行する。ALU はこれまでに述べた組み合わせ回路の集大成である。

シンプルな ALU の構成:

  A[N-1:0] ──┐
              ├──[ALU]── Result[N-1:0]
  B[N-1:0] ──┘           Flags (Zero, Carry, Overflow, Negative)
              │
  Op[2:0] ───┘（演算選択）

  演算コード例:

→ MUX で演算結果を選択し、Opコードに応じた結果を出力
  → フラグ出力は条件分岐命令で使用

4. 順序回路 — 記憶と状態遷移

順序回路（Sequential Circuit）は、出力が現在の入力だけでなく過去の状態にも依存する回路である。内部にフィードバックループまたは記憶素子を持ち、これがコンピュータの「記憶」の物理的基盤となる。

4.1 SRラッチ

最も基本的な記憶素子は SR ラッチ（Set-Reset Latch）である。

NOR型 SRラッチ:

  S ──[NOR]──┬── Q
       ↑     │
       │     │
       └─────┤（クロスカップルドフィードバック）
             │
  R ──[NOR]──┴── Q'
       ↑     │
       │     │
       └─────┘

  動作表:

→ S=R=1 の禁止状態は Q と Q' が両方 0 になり不定
  → この制約を解消したのが D ラッチ、D フリップフロップ

4.2 Dフリップフロップ

D フリップフロップはクロック信号のエッジ（立ち上がりまたは立ち下がり）でのみ入力を取り込む。現代のデジタルシステムの基本記憶素子である。

D フリップフロップ（ポジティブエッジトリガ）:

  D ──[Master]──[Slave]── Q
       ↑                   │
  CLK ─┘                   └── Q'

  動作:

タイミング制約:

4.3 レジスタとカウンタ

D フリップフロップを並列に並べるとレジスタ（N ビットの記憶素子）になり、フィードバックを加えるとカウンタになる。

4ビットレジスタ:

  D3 → [DFF] → Q3
  D2 → [DFF] → Q2    共通CLKで全ビット同時に更新
  D1 → [DFF] → Q1
  D0 → [DFF] → Q0
       ↑
  CLK ─┘

4ビット同期式バイナリカウンタ:

  CLK → [DFF0] → Q0 ──┬── 出力
              ↑        │
              └─[NOT]──┘（T型フリップフロップ動作）

  各段のトグル条件: 下位ビットが全て1のときにトグル
  Q0: 毎クロックトグル
  Q1: Q0=1 のときトグル
  Q2: Q0=Q1=1 のときトグル
  Q3: Q0=Q1=Q2=1 のときトグル

  カウント: 0000 → 0001 → 0010 → ... → 1111 → 0000

4.4 有限状態マシン（FSM）

有限状態マシンは順序回路の一般的な抽象モデルであり、CPUの制御ユニットやプロトコル処理に広く使用される。

FSM の構成:

FSM の2つの型:

例: 自動販売機の制御FSM（ムーア型）:

状態遷移図（100円の商品、10円と50円硬貨対応）:

  [S0: 0円] ──10円──→ [S1: 10円] ──10円──→ [S2: 20円]
     │                    │                    │
    50円                  50円                 50円
     │                    │                    │
     ▼                    ▼                    ▼
  [S5: 50円] ──10円──→ [S6: 60円] ──10円──→ [S7: 70円]
     │                    │                    │
    50円                  50円                 ...
     │                    │
     ▼                    ▼                    最終的に
  [S10: 100円]         [S11: 110円]         → [販売実行]
  → 商品排出           → 商品排出+お釣り10円    → S0に戻る

5. Verilog HDL による回路記述

5.1 HDL（ハードウェア記述言語）の概要

HDL は回路の構造や動作をテキストで記述するための言語である。主要な HDL として Verilog と VHDL がある。

5.2 コード例1: Verilog による全加算器

// full_adder.v — 1ビット全加算器
// 入力: a, b, cin（キャリー入力）
// 出力: sum（和）, cout（キャリー出力）
 
module full_adder (
    input  wire a,
    input  wire b,
    input  wire cin,
    output wire sum,
    output wire cout
);
 
    // 構造的記述（ゲートレベル）
    wire w1, w2, w3;
 
    // 半加算器1: a + b
    xor g1 (w1, a, b);       // w1 = a XOR b
    and g2 (w2, a, b);       // w2 = a AND b
 
    // 半加算器2: w1 + cin
    xor g3 (sum, w1, cin);   // sum = w1 XOR cin = a XOR b XOR cin
    and g4 (w3, w1, cin);    // w3 = w1 AND cin
 
    // キャリー出力
    or  g5 (cout, w2, w3);   // cout = w2 OR w3
 
endmodule
 
 
// ----- テストベンチ -----
module full_adder_tb;
    reg a, b, cin;
    wire sum, cout;
 
    full_adder uut (.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));
 
    initial begin
        $display("a b cin | sum cout");
        $display("--------|----------");
 
        // 全入力パターンを網羅
        {a, b, cin} = 3'b000; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b001; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b010; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b011; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b100; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b101; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b110; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        {a, b, cin} = 3'b111; #10;
        $display("%b %b  %b  |  %b    %b", a, b, cin, sum, cout);
 
        $finish;
    end
endmodule
 
// シミュレーション実行（Icarus Verilog）:
//   iverilog -o full_adder_tb full_adder.v
//   vvp full_adder_tb
//
// 期待出力:
//   a b cin | sum cout
//   --------|----------
//   0 0  0  |  0    0
//   0 0  1  |  1    0
//   0 1  0  |  1    0
//   0 1  1  |  0    1
//   1 0  0  |  1    0
//   1 0  1  |  0    1
//   1 1  0  |  0    1
//   1 1  1  |  1    1

5.3 コード例2: Verilog による4ビットカウンタ

// counter_4bit.v — 同期式4ビットアップカウンタ（リセット付き）
module counter_4bit (
    input  wire       clk,
    input  wire       rst_n,  // アクティブLowリセット
    input  wire       en,     // カウント有効
    output reg [3:0]  count
);
 
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            count <= 4'b0000;       // 非同期リセット
        end else if (en) begin
            count <= count + 4'b0001; // カウントアップ
        end
        // en=0 のときは count を保持（暗黙的）
    end
 
endmodule
 
 
// ----- テストベンチ -----
module counter_4bit_tb;
    reg        clk, rst_n, en;
    wire [3:0] count;
 
    counter_4bit uut (
        .clk(clk), .rst_n(rst_n), .en(en), .count(count)
    );
 
    // クロック生成（周期 10ns = 100MHz）
    initial clk = 0;
    always #5 clk = ~clk;
 
    initial begin
        $dumpfile("counter.vcd");
        $dumpvars(0, counter_4bit_tb);
 
        // 初期化とリセット
        rst_n = 0; en = 0;
        #20;
        rst_n = 1;          // リセット解除
        #10;
        en = 1;             // カウント開始
 
        // 20クロック分カウント（0〜15を1周+α）
        #200;
 
        en = 0;             // カウント停止
        #30;
        en = 1;             // カウント再開
        #50;
 
        $finish;
    end
 
    // モニタ
    always @(posedge clk) begin
        $display("Time=%0t rst_n=%b en=%b count=%d (%b)",
                 $time, rst_n, en, count, count);
    end
endmodule

5.4 コード例3: Python によるビット演算のみの加算器

"""
bit_adder.py — ビット演算のみで実装する加算器
+ 演算子を一切使用せず、AND, XOR, シフトのみで加算を実現する。
これは全加算器のリップルキャリー動作をソフトウェアで再現したものである。
"""
 
 
def add_bitwise(a: int, b: int) -> int:
    """
    2つの整数をビット演算のみで加算する。
    キャリー伝搬が 0 になるまでループする。
 
    原理:
      sum = a XOR b        （キャリーなしの各ビットの和）
      carry = (a AND b) << 1  （キャリーを1ビット左シフト）
      → sum と carry を再度加算（キャリーが0になるまで繰り返し）
 
    >>> add_bitwise(0, 0)
    0
    >>> add_bitwise(5, 3)
    8
    >>> add_bitwise(255, 1)
    256
    """
    # Python は任意精度整数のため、負数処理にはマスクが必要
    MASK = 0xFFFFFFFF  # 32ビットマスク
    MAX_INT = 0x7FFFFFFF
 
    while b != 0:
        # キャリーなしの加算
        sum_without_carry = (a ^ b) & MASK
        # キャリーの計算
        carry = ((a & b) << 1) & MASK
        # 次のイテレーション
        a = sum_without_carry
        b = carry
 
    # 32ビット符号付き整数として解釈
    return a if a <= MAX_INT else ~(a ^ MASK)
 
 
def add_8bit(a: int, b: int) -> tuple[int, int]:
    """
    8ビット加算器のシミュレーション。
    全加算器をビットごとにシミュレートする。
 
    戻り値: (result, carry_out) のタプル
 
    >>> add_8bit(100, 50)
    (150, 0)
    >>> add_8bit(200, 100)
    (44, 1)
    """
    result = 0
    carry = 0
 
    for i in range(8):
        # i番目のビットを抽出
        bit_a = (a >> i) & 1
        bit_b = (b >> i) & 1
 
        # 全加算器の論理
        sum_bit = bit_a ^ bit_b ^ carry
        carry = (bit_a & bit_b) | (carry & (bit_a ^ bit_b))
 
        # 結果に設定
        result = result | (sum_bit << i)
 
    return (result, carry)
 
 
def subtract_twos_complement(a: int, b: int, bits: int = 8) -> int:
    """
    2の補数を用いた減算: a - b = a + (~b + 1)
 
    >>> subtract_twos_complement(10, 3)
    7
    >>> subtract_twos_complement(5, 8)
    -3
    """
    mask = (1 << bits) - 1  # 8ビットマスク: 0xFF
 
    # b の2の補数 = ビット反転 + 1
    b_complement = (~b & mask)
    result, _ = add_8bit(a & mask, b_complement)
    result, _ = add_8bit(result, 1)
    result = result & mask
 
    # 符号付き整数として解釈
    if result >= (1 << (bits - 1)):
        return result - (1 << bits)
    return result
 
 
# ---- テスト ----
if __name__ == "__main__":
    import doctest
    doctest.testmod(verbose=True)
 
    print("\n=== ビット演算加算器テスト ===")
    test_cases = [
        (0, 0), (1, 1), (5, 3), (127, 128),
        (255, 1), (100, 200), (42, 58)
    ]
 
    for a, b in test_cases:
        result = add_bitwise(a, b)
        result_8bit, carry = add_8bit(a & 0xFF, b & 0xFF)
        print(f"  {a:3d} + {b:3d} = {result:4d}"
              f"  (8bit: {result_8bit:3d}, carry={carry})")
 
    print("\n=== 2の補数減算テスト ===")
    sub_cases = [(10, 3), (5, 8), (100, 100), (0, 1)]
    for a, b in sub_cases:
        result = subtract_twos_complement(a, b)
        print(f"  {a:3d} - {b:3d} = {result:4d}")

6. PCB（プリント基板）の設計と構造

6.1 PCB とは何か

PCB（Printed Circuit Board: プリント基板）は、集積回路（IC）、抵抗、コンデンサ、コネクタなどの電子部品を機械的に支持し、電気的に接続する基板である。全ての電子機器（スマートフォン、PC、家電、自動車 ECU）の基盤をなす。

PCBの基本構造（4層基板の断面図）:

  ┌─────────────────────────────────────────────────────┐
  │  ████ 部品 ████  ██ 部品 ██    █ IC █              │  ← 実装部品
  ├─────────────────────────────────────────────────────┤
  │ ▓▓▓ 銅箔パターン（信号層 L1: Top） ▓▓▓▓▓▓▓▓▓▓▓▓▓ │  ← 信号配線
  ├─────────────────────────────────────────────────────┤
  │ ░░░░░░░░ プリプレグ（絶縁層）░░░░░░░░░░░░░░░░░░░░ │  ← FR-4 基材
  ├─────────────────────────────────────────────────────┤
  │ ████████████ 銅箔ベタ（GND層 L2）██████████████████ │  ← グラウンドプレーン
  ├─────────────────────────────────────────────────────┤
  │ ░░░░░░░░░░ コア材（絶縁層）░░░░░░░░░░░░░░░░░░░░░░ │  ← FR-4 基材
  ├─────────────────────────────────────────────────────┤
  │ ████████████ 銅箔ベタ（電源層 L3）█████████████████ │  ← 電源プレーン
  ├─────────────────────────────────────────────────────┤
  │ ░░░░░░░░ プリプレグ（絶縁層）░░░░░░░░░░░░░░░░░░░░ │  ← FR-4 基材
  ├─────────────────────────────────────────────────────┤
  │ ▓▓▓ 銅箔パターン（信号層 L4: Bottom）▓▓▓▓▓▓▓▓▓▓▓ │  ← 信号配線
  ├─────────────────────────────────────────────────────┤
  │  ██ はんだ ██  ████ はんだ ████                     │  ← 裏面実装
  └─────────────────────────────────────────────────────┘

ビア（層間接続）:
  ────── ▓ ──────── ← L1
  ────── │ ──────── ← プリプレグ
  ────── │ ──────── ← L2（GND）
  ────── │ ──────── ← コア
  ────── │ ──────── ← L3（電源）
  ────── │ ──────── ← プリプレグ
  ────── ▓ ──────── ← L4

  スルーホールビア: 全層貫通
  ブラインドビア:   外層から内層まで（L1↔L2）
  ベリードビア:     内層間のみ（L2↔L3）

6.2 PCB の層構成と設計考慮事項

設計上の重要概念:

インピーダンス整合: 高速信号（数百MHz〜GHz帯域）では、配線のインピーダンスが信号品質に大きく影響する。伝送線路のインピーダンスは、配線幅、基板の誘電率、GNDプレーンとの距離で決まる。一般に50Ω（シングルエンド）または100Ω（差動ペア）に整合させる。

クロストーク: 並走する配線間で電磁結合により信号が漏れる現象。配線間隔を広げる（3W ルール: 配線幅 W の3倍以上の間隔）ことで低減できる。

電源インテグリティ（PI）: 電源プレーンの安定性。デカップリングコンデンサを IC の近傍に配置し、高周波ノイズをバイパスする。電源プレーンを分割する場合は、リターン電流パスの断絶に注意が必要である。

熱設計: 高発熱部品の放熱設計。サーマルビア（GND プレーンに熱を逃がすビア群）やヒートシンクの配置が重要となる。

6.3 PCB の製造工程

PCB製造の主要工程:

  1. 設計データ入力（ガーバーファイル）
     ↓
  2. 内層パターン形成
     基材にドライフィルム → 露光 → 現像 → エッチング → 剥膜
     ↓
  3. 積層プレス
     内層 + プリプレグ + 銅箔 → 高温高圧でプレス
     ↓
  4. ドリル加工
     スルーホールビア穴あけ（機械ドリルまたはレーザー）
     ↓
  5. めっき
     デスミア → 無電解銅めっき → 電解銅めっき
     ↓
  6. 外層パターン形成
     ドライフィルム → 露光 → 現像 → エッチング → 剥膜
     ↓
  7. ソルダーレジスト
     基板表面を絶縁被覆（緑色が一般的）
     ↓
  8. シルクスクリーン印刷
     部品番号、端子名称等のマーキング
     ↓
  9. 表面処理
     HASL / ENIG / OSP 等のはんだ付け性向上処理
     ↓
  10. 外形加工・検査
      ルーター加工 → 電気検査（導通/絶縁）→ 出荷

7. FPGA — リコンフィギュラブル・ハードウェア

7.1 FPGA とは何か

FPGA（Field-Programmable Gate Array）は、製造後にユーザーが回路構成を自由に変更できるプログラマブルデバイスである。ASIC（特定用途向けIC）と汎用プロセッサ（CPU）の中間に位置する。

FPGA の位置づけ:

  柔軟性 高 ←──────────────────────────────→ 性能 高

開発コスト:  CPU < GPU < FPGA <<< ASIC
  単位性能:    CPU < GPU ≈ FPGA < ASIC
  消費電力効率: CPU < GPU < FPGA < ASIC
  市場投入速度: CPU ≈ GPU > FPGA >> ASIC

7.2 FPGA の内部構造

FPGA の基本構成要素:

CLB の内部構造:

7.3 FPGA の応用分野

7.4 コード例4: Verilog によるFPGA向け簡易UARTトランスミッタ

// uart_tx.v — 簡易UARTトランスミッタ
// ボーレート: パラメータ化可能
// フレーム: 8データビット、1ストップビット、パリティなし (8N1)
 
module uart_tx #(
    parameter CLK_FREQ  = 50_000_000,  // システムクロック 50MHz
    parameter BAUD_RATE = 115_200       // ボーレート
)(
    input  wire       clk,
    input  wire       rst_n,
    input  wire       tx_start,   // 送信開始信号
    input  wire [7:0] tx_data,    // 送信データ
    output reg        tx_out,     // UART TX 出力
    output reg        tx_busy     // 送信中フラグ
);
 
    // ボーレート分周カウンタの上限値
    localparam BAUD_DIV = CLK_FREQ / BAUD_RATE - 1;
 
    // 状態定義
    localparam IDLE  = 2'b00;
    localparam START = 2'b01;
    localparam DATA  = 2'b10;
    localparam STOP  = 2'b11;
 
    reg [1:0]  state;
    reg [15:0] baud_cnt;    // ボーレートカウンタ
    reg [2:0]  bit_idx;     // 送信ビットインデックス (0-7)
    reg [7:0]  tx_shift;    // シフトレジスタ
 
    // ボーレートタイミング信号
    wire baud_tick = (baud_cnt == BAUD_DIV);
 
    // ボーレートカウンタ
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            baud_cnt <= 16'd0;
        else if (state == IDLE)
            baud_cnt <= 16'd0;
        else if (baud_tick)
            baud_cnt <= 16'd0;
        else
            baud_cnt <= baud_cnt + 16'd1;
    end
 
    // メイン状態マシン
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state    <= IDLE;
            tx_out   <= 1'b1;     // アイドル時はHigh
            tx_busy  <= 1'b0;
            bit_idx  <= 3'd0;
            tx_shift <= 8'd0;
        end else begin
            case (state)
                IDLE: begin
                    tx_out <= 1'b1;
                    if (tx_start) begin
                        state    <= START;
                        tx_shift <= tx_data;
                        tx_busy  <= 1'b1;
                    end
                end
 
                START: begin
                    tx_out <= 1'b0;           // スタートビット (Low)
                    if (baud_tick) begin
                        state   <= DATA;
                        bit_idx <= 3'd0;
                    end
                end
 
                DATA: begin
                    tx_out <= tx_shift[0];    // LSBファースト
                    if (baud_tick) begin
                        tx_shift <= {1'b0, tx_shift[7:1]}; // 右シフト
                        if (bit_idx == 3'd7)
                            state <= STOP;
                        else
                            bit_idx <= bit_idx + 3'd1;
                    end
                end
 
                STOP: begin
                    tx_out <= 1'b1;           // ストップビット (High)
                    if (baud_tick) begin
                        state   <= IDLE;
                        tx_busy <= 1'b0;
                    end
                end
            endcase
        end
    end
 
endmodule

8. 半導体製造プロセス

8.1 シリコンウェハーの製造

半導体製造は、砂（SiO₂）から始まり、世界最高の精度が要求される工業プロセスである。

シリコンウェハー製造工程:

  1. 原料精製

└──────┬───────┘
                                                     │

     ┌──────────────────────────────────────────────┘
     ▼
  2. 多結晶シリコン製造
     ┌──────────────┐
     │ シーメンス法  │  → 純度 99.999999999%（イレブンナイン）
     │ CVD 堆積     │     世界で最も純度の高い人工物質の一つ
     └──────┬───────┘

│
  3. 単結晶成長（チョクラルスキー法）

→ 原子レベルで完全に規則的な結晶構造

  4. ウェハー加工
     インゴット → ワイヤーソーでスライス → ラッピング
     → ポリッシング → 洗浄 → 検査
     → 表面粗さ: 原子数個分のレベル（< 0.5nm RMS）

8.2 フォトリソグラフィ

フォトリソグラフィは半導体製造の中核工程であり、回路パターンをウェハー上に転写する技術である。

フォトリソグラフィの基本工程:

│
           ▼

│
           ▼

│
           ▼

│
           ▼

│
           ▼

8.3 EUV リソグラフィ

7nm 以降のプロセスノードでは、従来の ArF 液浸リソグラフィ（波長 193nm）の解像度限界を超えるため、EUV（Extreme Ultraviolet: 極端紫外線、波長 13.5nm）リソグラフィが導入された。

EUV 光源は、真空チャンバー内で溶融スズの液滴にCO₂レーザーを照射し、プラズマ化させることで 13.5nm の光を発生させる。この光は全ての物質に吸収されるため、レンズは使えず、多層膜ミラー（Mo/Si 反射ミラー）で集光・結像する。

8.4 先端プロセスノードの変遷

トランジスタ構造の進化:

  ── プレーナ型（〜22nm）──

── FinFET（22nm〜3nm）──

── GAA FET / ナノシート（2nm〜）──

── CFET（将来）──

8.5 製造コストとイールド

→ 先端プロセスは設計コストだけで数百億〜千億円規模に達し、大量生産で回収する必要がある。このため、先端ノードを使えるのは Apple、Qualcomm、NVIDIA、AMD など限られたファブレス企業に絞られつつある。

9. 最新技術動向と将来展望

9.1 チップレット技術

単一のモノリシックダイを巨大化する代わりに、機能ブロックを個別のダイ（チップレット）に分割し、高速インターコネクトで接続する技術が主流になりつつある。

チップレットアーキテクチャの例（AMD EPYC）:

利点:
  - 各チップレットを最適なプロセスで製造
    （演算コア = 最先端5nm、I/O = コスト効率の良い6nm）
  - 歩留まり向上（小さなダイは不良率が低い）
  - 設計の再利用性（同じCCDを数を変えて構成）
  - 柔軟な製品ラインナップ（CCD数で差別化）

9.2 3D積層技術

3D積層の主要技術:

  TSV（Through-Silicon Via）:

HBM（High Bandwidth Memory）:

│
    インターポーザ（2.5D実装の場合）

9.3 ポストムーアの法則時代

物理的な微細化の限界が近づく中、性能向上を実現するための複数のアプローチが並行して進んでいる。

10. アンチパターンと設計の落とし穴

アンチパターン1: 非同期リセットの誤用

【誤り】非同期リセットを組み合わせ論理の出力で生成する

  // 危険な例
  wire async_rst = some_combinational_logic;  // グリッチが発生しうる

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

  問題点:
  - 組み合わせ論理の出力にはグリッチ（瞬間的な誤パルス）が生じうる
  - 非同期リセットはグリッチに反応して意図しないリセットが発生
  - デバッグが極めて困難（タイミング依存の間欠的障害）

  【対策】リセット信号にはリセットシンクロナイザを使用する

  // 正しい例: リセットシンクロナイザ
  reg rst_meta, rst_sync;

  always @(posedge clk or negedge rst_n_ext) begin
      if (!rst_n_ext) begin
          rst_meta <= 1'b0;
          rst_sync <= 1'b0;
      end else begin
          rst_meta <= 1'b1;      // メタステーブル解消段
          rst_sync <= rst_meta;  // 安定化
      end
  end

  // rst_sync をシステムリセットとして使用
  // → リセット解除はクロックに同期、リセット印加は非同期（安全）

アンチパターン2: クロックドメイン間の不適切な信号渡し

【誤り】異なるクロックドメイン間で信号を直接接続する

  // clk_a ドメイン
  always @(posedge clk_a) begin
      signal_a <= some_logic;
  end

  // clk_b ドメイン — 危険! signal_a を直接使用
  always @(posedge clk_b) begin
      result <= signal_a;        // メタステーブル発生の可能性
  end

  問題点:
  - clk_a と clk_b が非同期の場合、セットアップ/ホールド時間違反
  - フリップフロップがメタステーブル状態に陥り、出力が不定値になる
  - 後段の回路に不定値が伝搬し、システム全体が不安定化

  メタステーブル状態:

【対策】2段フリップフロップ同期化器（ダブルFF同期器）

  // 正しい例: CDC (Clock Domain Crossing) 同期器
  reg signal_meta, signal_sync;

  always @(posedge clk_b or negedge rst_n) begin
      if (!rst_n) begin
          signal_meta <= 1'b0;
          signal_sync <= 1'b0;
      end else begin
          signal_meta <= signal_a;     // 第1段（メタステーブル吸収）
          signal_sync <= signal_meta;  // 第2段（安定化）
      end
  end

  // signal_sync を clk_b ドメインで安全に使用
  // → MTBF (Mean Time Between Failures) が大幅に向上
  // → 多ビットバスの場合は FIFO やグレイコードカウンタを使用

アンチパターン3: ラッチの意図しない推論

【誤り】if-else や case 文で全条件を網羅しない

  // 危険な例: default 節がない case 文
  always @(*) begin
      case (sel)
          2'b00: out = a;
          2'b01: out = b;
          2'b10: out = c;
          // 2'b11 が欠落 → ラッチが推論される
      endcase
  end

  問題点:
  - 合成ツールは未定義の条件で値を保持する必要があると判断
  - フリップフロップではなくラッチ（レベルセンシティブ記憶素子）を生成
  - 意図しないラッチはタイミング解析を複雑にし、バグの温床

  【対策】全条件を網羅するか、default 節を必ず記述

  // 正しい例
  always @(*) begin
      case (sel)
          2'b00:   out = a;
          2'b01:   out = b;
          2'b10:   out = c;
          default: out = 1'b0;  // 全条件を網羅
      endcase
  end

11. 実践演習

演習1: 論理回路の設計（基礎 — 初学者向け）

課題 A: NANDゲートだけを使って、以下のゲートを構成する回路図を描け:

1. NOTゲート（1入力）
2. ANDゲート（2入力）
3. ORゲート（2入力）
4. XORゲート（2入力）

課題 B: 以下のブール式をカルノー図で簡単化し、最小項の数を求めよ:

F(A, B, C, D) = Σm(0, 1, 2, 5, 8, 9, 10)

課題 C: 以下の真理値表を実現する回路を、NANDゲートのみで設計せよ:

A B C | Y
------+---
0 0 0 | 1
0 0 1 | 0
0 1 0 | 1
0 1 1 | 1
1 0 0 | 0
1 0 1 | 0
1 1 0 | 1
1 1 1 | 0

ヒント: まずSOP（積和標準形）に変換し、ド・モルガンの法則でNAND表現に変形する。

演習2: HDL実装（応用 — 中級者向け）

課題 A: Verilog で 8 ビットの ALU を実装せよ。以下の演算をサポートすること:

• ADD（加算）
• SUB（減算: 2の補数加算）
• AND, OR, XOR（ビット演算）
• SLL, SRL（論理シフト）
• SLT（Set Less Than: 比較）

フラグ出力として Zero（結果がゼロ）、Carry（キャリー）、Overflow（オーバーフロー）、Negative（負数）を含めること。

課題 B: 課題 A の ALU に対して、全演算・全フラグの網羅的テストベンチを作成せよ。境界値（0x00, 0x7F, 0x80, 0xFF）を特に重点的にテストすること。

課題 C: 上記 ALU をもとに、簡単な 4 命令 CPU（LOAD, STORE, ADD, JUMP）をVerilog で設計し、シミュレーションで動作を確認せよ。

演習3: 半導体・PCB（発展 — 上級者向け）

課題 A: KiCad（オープンソース EDA ツール）を使って、以下の仕様の PCB を設計せよ:

• ATmega328P（Arduino 互換）マイコン搭載
• USB-C コネクタ（電源供給）
• LED × 4（GPIO 出力確認用）
• 2層基板、基板サイズ 50mm × 30mm 以内

課題 B: Nand2Tetris（「The Elements of Computing Systems」）の Project 1〜5 を完了し、NANDゲートから ALU、CPU までを段階的に構築せよ。

課題 C: FPGA 評価ボード（Digilent Basys 3、Terasic DE10-Lite 等）を使用して、UART通信モジュールを実装し、PC との双方向通信を実現せよ。ボーレート 115200bps、8N1 フレーム形式とする。

12. FAQ

Q1: ソフトウェアエンジニアが回路や半導体を学ぶ必要はあるのか？

A: 必須ではないが、以下の理解に直結する重要な背景知識である:

• なぜコンピュータが2進数を使うのか — トランジスタの ON/OFF（高電圧/低電圧）の2状態が最も信頼性高く区別できるため。3値以上では雑音耐性が低下する。
• なぜ浮動小数点に誤差があるのか — IEEE 754 の仮数部は有限ビット幅であり、無限小数を正確に表現できない。これはハードウェアのビット幅制約に起因する。
• なぜ CPU クロックに上限があるのか — 配線遅延、ゲート遅延、消費電力（動的電力 ∝ f × V² × C）の物理的制約。クロック周波数の引き上げは2005年頃に壁に達し（Power Wall）、マルチコア化へ移行した。
• なぜメモリアクセスが遅いのか — DRAM はキャパシタのチャージ/リードが必要で、SRAM（キャッシュ）より本質的に遅い。キャッシュ階層設計の理解に回路知識が役立つ。
• なぜ特定の並列パターンが高速なのか — GPU や FPGA の並列アーキテクチャは、組み合わせ回路の並列性をそのまま活用している。

Q2: FPGA と ASIC はどのように使い分けるのか？

A: 判断基準は主に「量産数量」「開発期間」「性能要求」の3軸で決まる:

典型的なパスとして、FPGA でプロトタイプ開発 → 量産決定後に ASIC 化（FPGA-to-ASIC migration）というフローが広く採用されている。

Q3: ムーアの法則は終わりつつあるのか？

A: 「ダイ上のトランジスタ数が2年で倍増する」という原義のムーアの法則は、物理的限界により鈍化している。しかし、「コンピューティング能力の指数的向上」という広義では、以下の手段により依然として進行中である:

1. トランジスタ構造の革新 — FinFET → GAA → CFET と垂直方向への制御面拡大
2. チップレットと3D積層 — 面積あたりのトランジスタ数ではなく、パッケージあたりの総トランジスタ数で進化
3. アーキテクチャの改善 — 特定用途向けアクセラレータ（GPU, TPU, NPU）によるワットあたり性能の向上
4. 新しい計算パラダイム — 量子コンピューティング、光コンピューティング、ニューロモーフィック・コンピューティング

2nm ノードが 2025〜2026年に量産開始予定であり、1.4nm（TSMC A14）も2028年頃のロードマップに載っている。物理的な微細化の終焉はまだ数世代先と見込まれるが、1nm以下ではトランジスタのチャネル長が原子数十個分に達するため、量子力学的効果（トンネリング）との戦いが本格化する。

Q4: PCB設計をソフトウェアエンジニアが学ぶメリットは何か？

A: IoT、ロボティクス、組み込みシステムの分野では、ハードウェアとソフトウェアの境界が曖昧になりつつある。PCB設計の基礎知識があると:

• ハードウェアチームとの技術的コミュニケーションが円滑になる
• 信号インテグリティ、ノイズ、EMC の問題をソフトウェア側から軽減する設計ができる
• IoT プロトタイプの自作が可能になる（KiCad + JLCPCB 等で低コスト小ロット製造）
• デバッグ時にオシロスコープやロジックアナライザの測定結果を正しく解釈できる

Q5: Verilog と VHDL のどちらを学ぶべきか？

A: 所属する業界や地域の標準に従うのが現実的である。ただし、以下を参考に選択できる:

• Verilog / SystemVerilog — 北米・アジアの半導体企業で主流。C言語に近い構文で学習曲線が緩やか。検証（UVM）でも SystemVerilog が標準。迷ったらこちら。
• VHDL — 欧州の航空・防衛・宇宙産業で強い。強い型付けにより、コンパイル時に多くのエラーを検出できる。安全性が求められるシステムで好まれる。

いずれにせよ、一方を習得すれば他方への移行は容易である。本質的な回路設計の概念は言語に依存しない。

FAQ

Q1: このトピックを学ぶ上で最も重要なポイントは何ですか？

実践的な経験を積むことが最も重要です。理論だけでなく、実際にコードを書いて動作を確認することで理解が深まります。

Q2: 初心者がよく陥る間違いは何ですか？

基礎を飛ばして応用に進むことです。このガイドで説明している基本概念をしっかり理解してから、次のステップに進むことをお勧めします。

Q3: 実務ではどのように活用されていますか？

このトピックの知識は、日常的な開発業務で頻繁に活用されます。特にコードレビューやアーキテクチャ設計の際に重要になります。

13. まとめ

知識の階層構造（ボトムアップ）:

補足A. コード例5: Python による論理ゲートシミュレータ

ソフトウェアで論理回路のシミュレーションを構築することで、ハードウェアの動作原理をより深く理解できる。以下は、基本ゲートの定義から組み合わせ回路の構築・評価までを行う Python シミュレータである。

"""
logic_simulator.py — 論理回路シミュレータ
基本ゲートを定義し、組み合わせてより複雑な回路を構築・評価する。
NANDの万能性を実際に検証する教育用ツール。
"""
 
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Callable
from itertools import product
 
 
# ============================================================
# 基本ゲート定義
# ============================================================
 
def gate_not(a: int) -> int:
    """NOTゲート: 入力を反転"""
    return 1 - a
 
def gate_and(a: int, b: int) -> int:
    """ANDゲート: 両入力が1のとき1"""
    return a & b
 
def gate_or(a: int, b: int) -> int:
    """ORゲート: いずれかの入力が1のとき1"""
    return a | b
 
def gate_nand(a: int, b: int) -> int:
    """NANDゲート: AND の否定。万能ゲート。"""
    return 1 - (a & b)
 
def gate_nor(a: int, b: int) -> int:
    """NORゲート: OR の否定。万能ゲート。"""
    return 1 - (a | b)
 
def gate_xor(a: int, b: int) -> int:
    """XORゲート: 排他的論理和"""
    return a ^ b
 
def gate_xnor(a: int, b: int) -> int:
    """XNORゲート: 排他的論理和の否定"""
    return 1 - (a ^ b)
 
 
# ============================================================
# NANDゲートのみで他ゲートを構成（万能性の証明）
# ============================================================
 
def nand_not(a: int) -> int:
    """NAND で NOT を構成: NOT(A) = NAND(A, A)"""
    return gate_nand(a, a)
 
def nand_and(a: int, b: int) -> int:
    """NAND で AND を構成: AND(A,B) = NOT(NAND(A,B))"""
    return nand_not(gate_nand(a, b))
 
def nand_or(a: int, b: int) -> int:
    """NAND で OR を構成: OR(A,B) = NAND(NOT(A), NOT(B))"""
    return gate_nand(nand_not(a), nand_not(b))
 
def nand_xor(a: int, b: int) -> int:
    """NAND で XOR を構成（4個の NAND ゲート）"""
    w = gate_nand(a, b)
    return gate_nand(gate_nand(a, w), gate_nand(b, w))
 
 
# ============================================================
# 組み合わせ回路: 半加算器・全加算器・Nビット加算器
# ============================================================
 
@dataclass
class AdderResult:
    """加算器の出力"""
    sum_bits: list[int]
    carry_out: int
 
    def to_int(self) -> int:
        """ビットリストを整数に変換（LSBファースト）"""
        result = 0
        for i, bit in enumerate(self.sum_bits):
            result |= (bit << i)
        return result
 
    def __repr__(self) -> str:
        bits_str = ''.join(str(b) for b in reversed(self.sum_bits))
        return f"AdderResult(bits={bits_str}, carry={self.carry_out}, value={self.to_int()})"
 
 
def half_adder(a: int, b: int) -> tuple[int, int]:
    """
    半加算器: XOR で和、AND で繰り上がりを計算
 
    >>> half_adder(0, 0)
    (0, 0)
    >>> half_adder(1, 1)
    (0, 1)
    """
    return (gate_xor(a, b), gate_and(a, b))
 
 
def full_adder(a: int, b: int, cin: int) -> tuple[int, int]:
    """
    全加算器: 半加算器2つ + OR で構成
 
    >>> full_adder(1, 1, 1)
    (1, 1)
    """
    s1, c1 = half_adder(a, b)
    s2, c2 = half_adder(s1, cin)
    return (s2, gate_or(c1, c2))
 
 
def ripple_carry_adder(a_bits: list[int], b_bits: list[int],
                        cin: int = 0) -> AdderResult:
    """
    Nビットリップルキャリー加算器
 
    >>> r = ripple_carry_adder([1,0,1], [1,1,0])  # 5 + 6
    >>> r.to_int()
    11
    >>> r.carry_out
    0
    """
    n = len(a_bits)
    assert len(b_bits) == n, "入力ビット数が一致しない"
 
    sum_bits = []
    carry = cin
 
    for i in range(n):
        s, carry = full_adder(a_bits[i], b_bits[i], carry)
        sum_bits.append(s)
 
    return AdderResult(sum_bits=sum_bits, carry_out=carry)
 
 
# ============================================================
# 回路グラフ表現（ネットリスト）
# ============================================================
 
@dataclass
class Wire:
    """配線（信号線）"""
    name: str
    value: int = 0
 
 
@dataclass
class Gate:
    """論理ゲートのノード"""
    name: str
    gate_type: str
    inputs: list[str]
    output: str
    func: Callable
 
 
@dataclass
class Circuit:
    """論理回路のネットリスト表現"""
    name: str
    input_names: list[str]
    output_names: list[str]
    gates: list[Gate] = field(default_factory=list)
 
    def add_gate(self, name: str, gate_type: str,
                 inputs: list[str], output: str,
                 func: Callable) -> None:
        """ゲートを回路に追加"""
        self.gates.append(Gate(name, gate_type, inputs, output, func))
 
    def evaluate(self, input_values: dict[str, int]) -> dict[str, int]:
        """
        入力値を与えて回路を評価し、全信号値を返す。
        トポロジカル順序で評価する簡易実装。
        """
        signals = dict(input_values)
        evaluated = set(input_values.keys())
        remaining = list(self.gates)
 
        max_iterations = len(self.gates) * 2
        iteration = 0
 
        while remaining and iteration < max_iterations:
            iteration += 1
            progress = False
            next_remaining = []
 
            for gate in remaining:
                if all(inp in evaluated for inp in gate.inputs):
                    args = [signals[inp] for inp in gate.inputs]
                    signals[gate.output] = gate.func(*args)
                    evaluated.add(gate.output)
                    progress = True
                else:
                    next_remaining.append(gate)
 
            remaining = next_remaining
            if not progress and remaining:
                raise ValueError(
                    f"回路にフィードバックループまたは未定義信号が存在: "
                    f"{[g.name for g in remaining]}"
                )
 
        return {name: signals.get(name, 0) for name in self.output_names}
 
    def truth_table(self) -> list[dict[str, int]]:
        """全入力パターンの真理値表を生成"""
        rows = []
        for values in product([0, 1], repeat=len(self.input_names)):
            inputs = dict(zip(self.input_names, values))
            outputs = self.evaluate(inputs)
            rows.append({**inputs, **outputs})
        return rows
 
    def print_truth_table(self) -> None:
        """真理値表を整形して出力"""
        table = self.truth_table()
        headers = self.input_names + self.output_names
        print(" | ".join(f"{h:>5}" for h in headers))
        print("-" * (7 * len(headers)))
        for row in table:
            print(" | ".join(f"{row[h]:>5}" for h in headers))
 
 
# ============================================================
# 使用例: 2ビット加算器を回路グラフとして構築
# ============================================================
 
def build_2bit_adder() -> Circuit:
    """2ビット加算器をゲートレベルで構築"""
    circuit = Circuit(
        name="2bit_adder",
        input_names=["a0", "a1", "b0", "b1"],
        output_names=["s0", "s1", "cout"]
    )
 
    # ビット0: 半加算器（Cin=0なので半加算器で十分）
    circuit.add_gate("xor0", "XOR", ["a0", "b0"], "s0", gate_xor)
    circuit.add_gate("and0", "AND", ["a0", "b0"], "c0", gate_and)
 
    # ビット1: 全加算器
    circuit.add_gate("xor1", "XOR", ["a1", "b1"], "p1", gate_xor)
    circuit.add_gate("and1", "AND", ["a1", "b1"], "g1", gate_and)
    circuit.add_gate("xor2", "XOR", ["p1", "c0"], "s1", gate_xor)
    circuit.add_gate("and2", "AND", ["p1", "c0"], "pc1", gate_and)
    circuit.add_gate("or1",  "OR",  ["g1", "pc1"], "cout", gate_or)
 
    return circuit
 
 
# ============================================================
# 万能性検証
# ============================================================
 
def verify_nand_universality() -> None:
    """NANDゲートの万能性を全入力パターンで検証"""
    print("=== NANDゲートの万能性検証 ===\n")
 
    # NOT の検証
    print("NOT: nand_not(a) == gate_not(a)")
    for a in [0, 1]:
        assert nand_not(a) == gate_not(a), f"NOT不一致: a={a}"
    print("  -> 全パターン一致\n")
 
    # AND, OR, XOR の検証
    for name, nand_fn, ref_fn in [
        ("AND", nand_and, gate_and),
        ("OR",  nand_or,  gate_or),
        ("XOR", nand_xor, gate_xor),
    ]:
        print(f"{name}: nand_{name.lower()}(a,b) == gate_{name.lower()}(a,b)")
        for a, b in product([0, 1], repeat=2):
            result = nand_fn(a, b)
            expected = ref_fn(a, b)
            assert result == expected, \
                f"{name}不一致: a={a}, b={b}, got={result}, expected={expected}"
        print("  -> 全パターン一致\n")
 
    print("全ゲートの万能性が検証された。\n")
 
 
# ============================================================
# メイン
# ============================================================
 
if __name__ == "__main__":
    import doctest
    doctest.testmod()
 
    # 万能性検証
    verify_nand_universality()
 
    # 2ビット加算器の真理値表
    print("=== 2ビット加算器 真理値表 ===\n")
    adder = build_2bit_adder()
    adder.print_truth_table()
 
    # リップルキャリー加算器のテスト
    print("\n=== 8ビットリップルキャリー加算器 ===\n")
    test_pairs = [(100, 55), (200, 100), (255, 1), (0, 0), (127, 128)]
    for a, b in test_pairs:
        a_bits = [(a >> i) & 1 for i in range(8)]
        b_bits = [(b >> i) & 1 for i in range(8)]
        result = ripple_carry_adder(a_bits, b_bits)
        print(f"  {a:3d} + {b:3d} = {result.to_int():3d} (carry={result.carry_out})")

補足B. 消費電力の物理 — なぜ電力が問題になるのか

デジタル回路の消費電力は、ソフトウェアのパフォーマンスに直結する問題である。CPU のクロック周波数が 2005年頃に約3〜4GHz で頭打ちになった「Power Wall」問題は、消費電力の物理的制約に起因する。

B.1 CMOS 消費電力の三要素

CMOS 回路の総消費電力:

  P_total = P_dynamic + P_short + P_static

  1. 動的消費電力 (P_dynamic):
     P_dynamic = alpha * C_L * V_dd^2 * f

     alpha: アクティビティファクタ（スイッチング率、0〜1）
     C_L:   負荷容量（配線容量 + ゲート容量）
     V_dd:  電源電圧
     f:     動作周波数

     → 電圧の2乗に比例 → 電圧を下げれば劇的に削減
     → 周波数に比例 → クロックを上げると線形に増加
     → 先端プロセスでは V_dd = 0.65〜0.8V 程度

  2. 短絡電力 (P_short):
     スイッチング遷移時にPMOS/NMOSが同時にONになる瞬間の貫通電流
     → 動的消費電力の 10〜15% 程度
     → 入力信号の遷移時間を短くすることで低減可能

  3. 静的消費電力 (P_static):
     P_static = I_leak * V_dd

     I_leak: リーク電流（サブスレッショルドリーク + ゲートリーク）
     → トランジスタが OFF でも量子力学的トンネリングにより微小電流が流れる
     → 微細化するほどリーク電流が増大（ゲート酸化膜が薄くなるため）
     → 先端プロセス（3nm以下）では全消費電力の 30〜50% を占める

B.2 電力の壁（Power Wall）とその対策

Dennardスケーリング（1974年）の崩壊:

  理想（Dennardスケーリング）:

現実（2005年頃〜）:

対策の進化:
  年代        アプローチ              具体例
  ─────────────────────────────────────────────────
  2005〜      マルチコア化            Core 2 Duo
  2007〜      動的電圧/周波数制御     Intel SpeedStep
  2010〜      ヘテロジニアス設計      ARM big.LITTLE
  2015〜      ドメイン特化加速器      GPU, TPU, NPU
  2020〜      チップレット + DVFS     AMD Zen 3/4
  2023〜      極低電圧動作 + 3D積層   Apple M3 (Efficiency Core)

B.3 ソフトウェアエンジニアへの示唆

消費電力の物理を理解することで、ソフトウェア最適化の方向性が見える:

補足C. デジタル設計のワークフロー — RTL から GDS II まで

C.1 ASIC 設計フロー

デジタル回路の設計フロー（ASIC向け）:

▼

▼

▼

▼

▼

所要期間の目安:

C.2 FPGA 設計フロー

FPGA では ASIC の「製造」工程が「コンフィギュレーション（書き込み）」に置き換わるため、イテレーションが格段に速い。

FPGA 設計フロー:

  RTL設計 → シミュレーション → 論理合成 → 配置配線
  → タイミング解析 → ビットストリーム生成 → FPGA に書き込み

  主要ツールチェーン:

オープンソース FPGA ツールチェーン（iCE40 FPGA 向け）:
  Verilog → [Yosys] → ネットリスト → [nextpnr] → ビットストリーム
  → [iceprog] → FPGA に書き込み

  → 商用ツールなしで FPGA 開発が可能
  → 学習・教育・ホビー用途に最適

補足D. PCB設計実践 — KiCad によるワークフロー

D.1 EDA ツールの比較

D.2 KiCad 設計フロー

KiCad による PCB 設計ワークフロー:

  1. 回路図エディタ（Eeschema）
     ├── シンボル（部品記号）の配置
     ├── 配線（ネット接続）
     ├── 電源/GND の接続
     ├── ERC（電気規則チェック）
     └── BOM（部品表）生成

  2. フットプリント割り当て
     ├── 各シンボルに対応する PCB フットプリントを指定
     └── 0402, 0603, SOT-23, QFP, BGA 等

  3. PCBエディタ（Pcbnew）
     ├── 基板外形の定義
     ├── 部品の配置（手動 + 自動配置）
     ├── 配線ルールの設定
     │   ├── 最小線幅/間隔
     │   ├── インピーダンス制御（差動ペア等）
     │   └── 電源/GND の太線化
     ├── 配線（手動ルーティング / インタラクティブルータ）
     ├── ベタ GND の注入（銅箔ベタ）
     ├── DRC（デザインルールチェック）
     └── 3Dビューアでの確認

  4. 製造データ出力
     ├── ガーバーファイル（各層のパターンデータ）
     ├── ドリルファイル（穴位置データ）
     ├── BOM + CPL（実装座標データ）
     └── → PCB 製造業者に発注（JLCPCB, PCBWay, Elecrow 等）

  コスト目安（2層基板、100mm x 100mm、5枚）:
  JLCPCB: 約 $2〜$5 + 送料
  → 個人開発者でも非常に低コストでプロトタイプ可能

補足E. 歴史的視点 — 電子計算機の物理的進化

計算機の物理的実装の進化:

  年代        技術              速度       消費電力    集積度
  ────────────────────────────────────────────────────────
  1940年代    真空管            kHz級      巨大       ENIAC: 17,468本
              (電子スイッチ)               (174kW)

  1950年代    トランジスタ      MHz級      中         個別部品
              (点接触→接合型)              (数kW)

  1960年代    SSI/MSI IC        数MHz      小         数十〜数百素子/チップ
              (小/中規模集積)              (数W)

  1970年代    LSI               MHz級      小         数千〜1万素子
              (大規模集積)                            Intel 4004: 2,300

  1980年代    VLSI              10MHz級    中         数万〜数十万素子
              (超大規模集積)                          Intel 386: 275,000

  1990年代    ULSI              100MHz級   中         数百万〜1千万素子
                                                     Pentium: 3.1M

  2000年代    SoC               GHz級      数十W      数億素子
              (System on Chip)                        Core 2: 291M

  2010年代    FinFET SoC        数GHz      数W〜      数十億〜百億素子
                                          数百W      Apple A14: 11.8B

  2020年代    GAA / チップレット  数GHz     数W〜       数百億〜千億素子
                                          数百W      Apple M3 Max: 92B

  → 80年間でスイッチング素子の数は10桁以上増加
  → 消費電力は真空管時代の174kWから数Wまで激減
     （1素子あたりの電力は約15桁改善）

補足F. デバッグと検証の基礎

F.1 デジタル回路のデバッグ手法

F.2 テストベンチの設計原則

良いテストベンチの要件:

  1. 自己検証（Self-checking）
     → 期待値と実際の出力を自動比較
     → 手動での波形目視確認に頼らない

  2. 再現性（Reproducibility）
     → 乱数シードを固定して再現可能にする
     → 環境依存を排除

  3. 網羅性（Coverage）
     → 全入力パターンの網羅（小規模回路の場合）
     → ランダムテスト + コーナーケース（大規模回路の場合）
     → コードカバレッジ + 機能カバレッジの計測

  4. 段階的テスト
     → ユニットテスト（個別モジュール）
     → 結合テスト（モジュール間インタフェース）
     → システムテスト（全体動作）

  5. 文書化
     → テスト項目リスト
     → カバレッジレポート
     → 既知の制限事項の記録

補足G. 用語集

次に読むべきガイド

14. 参考文献

1. Nisan, N. & Schocken, S. The Elements of Computing Systems (Nand2Tetris). MIT Press, 2nd Edition, 2021. — NANDゲートからOSまでをボトムアップで構築する名著。本章の内容の実践に最適。
2. Weste, N. & Harris, D. CMOS VLSI Design: A Circuits and Systems Perspective. 4th Edition, Pearson, 2010. — CMOS回路設計の標準的教科書。トランジスタレベルの設計から物理設計まで網羅。
3. Patterson, D. & Hennessy, J. Computer Organization and Design: The Hardware/Software Interface. 6th Edition (RISC-V Edition), Morgan Kaufmann, 2020. — コンピュータアーキテクチャの教科書。ALU、データパス、制御ユニットの設計を詳述。
4. Harris, D. & Harris, S. Digital Design and Computer Architecture. 2nd Edition, Morgan Kaufmann, 2012. — デジタル回路からプロセッサ設計までを一冊で学べる教科書。Verilog と VHDL の両方を扱う。
5. Mead, C. & Conway, L. Introduction to VLSI Systems. Addison-Wesley, 1980. — VLSI設計の古典。チップ設計の方法論を確立した歴史的著作。
6. IEEE Standard 1364-2005 (Verilog) / IEEE Standard 1800-2017 (SystemVerilog). — Verilog/SystemVerilog の公式規格。
7. Wolf, W. Modern VLSI Design: IP-Based Design. 4th Edition, Pearson, 2008. — 現代のIP再利用ベースのVLSI設計手法を解説。
8. Rabaey, J., Chandrakasan, A. & Nikolic, B. Digital Integrated Circuits: A Design Perspective. 2nd Edition, Pearson, 2003. — デジタルICの設計原理。消費電力、遅延、面積のトレードオフを理論的に扱う。
9. Kilts, S. Advanced FPGA Design: Architecture, Implementation, and Optimization. Wiley-IEEE Press, 2007. — FPGA設計の上級テキスト。タイミングクロージャ、リソース最適化を詳述。
10. TSMC Technology Roadmap (公開資料). — 最新の半導体プロセスノード情報。3nm/2nm の技術詳細。

参考文献

• MDN Web Docs - Web技術のリファレンス
• Wikipedia - 技術概念の概要