디지털 논리 설계 완전 가이드: 불 대수부터 CPU 설계까지

10진수 → 2진수: 반복 나눗셈
  45 ÷ 2 = 22 나머지 1
  22 ÷ 2 = 11 나머지 0
  11 ÷ 2 =  5 나머지 1
   5 ÷ 2 =  2 나머지 1
   2 ÷ 2 =  1 나머지 0
   1 ÷ 2 =  0 나머지 1
  결과: 101101(2)

+5  → 0000 0101
-5 계산:
  1의 보수: 1111 1010
  +1:       1111 1011  ← -5의 2의 보수 표현

교환 법칙:   A + B = B + A,      A · B = B · A
결합 법칙:   A + (B+C) = (A+B)+C
분배 법칙:   A · (B+C) = AB + AC
항등 원소:   A + 0 = A,   A · 1 = A
보원:        A + A' = 1,  A · A' = 0
멱등 법칙:   A + A = A,   A · A = A

(A · B)' = A' + B'
(A + B)' = A' · B'

AND 게이트:          OR 게이트:           NOT 게이트:
A  B  A·B            A  B  A+B            A  A'
0  0   0             0  0   0             0   1
0  1   0             0  1   1             1   0
1  0   0             1  0   1
1  1   1             1  1   1

NAND 게이트:         NOR 게이트:
A  B  (A·B)'         A  B  (A+B)'
0  0    1            0  0    1
0  1    1            0  1    0
1  0    1            1  0    0
1  1    0            1  1    0

XOR 게이트:          XNOR 게이트:
A  B  A⊕B            A  B  (A⊕B)'
0  0   0             0  0    1
0  1   1             0  1    0
1  0   1             1  0    0
1  1   0             1  1    1

NOT A  = A NAND A
A AND B = (A NAND B) NAND (A NAND B)
A OR B  = (A NAND A) NAND (B NAND B)

        CD
AB    00  01  11  10
00  [  1   0   1   1 ]
01  [  1   1   1   0 ]
11  [  0   1   1   0 ]
10  [  0   0   1   1 ]

반가산기 (Half Adder):
  합(Sum) S = A ⊕ B
  올림(Carry) C = A · B

전가산기 (Full Adder):
  S = A ⊕ B ⊕ Cin
  Cout = AB + Cin(A ⊕ B)

4:1 MUX (S1, S0 = 선택 신호):
  S1=0, S0=0 → Y = I0
  S1=0, S0=1 → Y = I1
  S1=1, S0=0 → Y = I2
  S1=1, S0=1 → Y = I3

SR 래치 진리표:
S  R  Q(다음)
0  0  Q(유지)
1  0  1 (Set)
0  1  0 (Reset)
1  1  불확정 (금지)

D 플립플롭:  Q(다음) = D
JK 플립플롭:
  J=0, K=0 → Q(유지)
  J=1, K=0 → Q=1 (Set)
  J=0, K=1 → Q=0 (Reset)
  J=1, K=1 → Q' (Toggle)
T 플립플롭:
  T=0 → Q(유지)
  T=1 → Q' (Toggle)

3비트 비동기 카운터 (Ripple Counter):
  3개의 T 플립플롭 직렬 연결
  0 → 1 → 2 → 3 → 4 → 5 → 6 → 7 → 0 ...
  단점: 올림 전파 지연(ripple delay) 발생

3비트 동기 카운터:
  모든 플립플롭이 공통 클록 사용
  장점: 출력이 동시에 변화, 고속 동작 가능

상태: S0(0원), S1(100원), S2(200원), S3(300원 → 음료 출력)
입력: 100원(A), 200원(B)

상태 전이:
  S0 --A--> S1
  S0 --B--> S2
  S1 --A--> S2
  S1 --B--> S3(출력)
  S2 --A--> S3(출력)
  S2 --B--> S3(출력, 100원 거스름돈)

module module_name (
    input  wire clk,
    input  wire reset,
    input  wire [3:0] data_in,
    output reg  [3:0] data_out
);
    // 내부 신호 선언
    wire [3:0] temp;

    // 조합 회로: assign
    assign temp = data_in & 4'b1111;

    // 순서 회로: always
    always @(posedge clk or posedge reset) begin
        if (reset)
            data_out <= 4'b0000;
        else
            data_out <= temp;
    end
endmodule

module d_ff (
    input  wire clk,
    input  wire reset,
    input  wire d,
    output reg  q
);
    always @(posedge clk or posedge reset) begin
        if (reset)
            q <= 1'b0;
        else
            q <= d;
    end
endmodule

module counter_4bit (
    input  wire clk,
    input  wire reset,
    output reg  [3:0] count
);
    always @(posedge clk or posedge reset) begin
        if (reset)
            count <= 4'b0000;
        else
            count <= count + 1'b1;
    end
endmodule

module tb_counter;
    reg  clk, reset;
    wire [3:0] count;

    // DUT(Device Under Test) 인스턴스화
    counter_4bit uut (
        .clk(clk),
        .reset(reset),
        .count(count)
    );

    // 클록 생성: 10ns 주기
    initial clk = 0;
    always #5 clk = ~clk;

    initial begin
        reset = 1;
        #20 reset = 0;
        #200 $finish;
    end

    initial begin
        $monitor("t=%0t reset=%b count=%b", $time, reset, count);
    end
endmodule

1. 설계 입력 (HDL 코드 작성 / 스케매틱)
        ↓
2. 합성 (Synthesis) → 게이트 레벨 넷리스트
        ↓
3. 구현 (Implementation)
   ├── 매핑 (Map) → FPGA 리소스에 배치
   ├── 배치 (Place) → 물리적 위치 결정
   └── 배선 (Route) → 연결선 결정
        ↓
4. 타이밍 분석 (Timing Analysis)
        ↓
5. 비트스트림 생성 (Bitstream Generation)
        ↓
6. FPGA 프로그래밍

ALU 입력:
  A, B: 피연산자 (n비트)
  OpCode: 연산 선택

ALU 출력:
  Result: 연산 결과 (n비트)
  Zero: 결과가 0이면 1
  Carry: 올림 발생 시 1
  Overflow: 오버플로우 발생 시 1
  Negative: 결과가 음수이면 1

지원 연산 예시:
  000 → A + B (가산)
  001 → A - B (감산)
  010 → A AND B
  011 → A OR B
  100 → A XOR B
  101 → NOT A
  110 → A << 1 (좌측 시프트)
  111 → A >> 1 (우측 시프트)

module register_file (
    input  wire clk,
    input  wire we,
    input  wire [4:0] rs1, rs2, rd,
    input  wire [31:0] write_data,
    output wire [31:0] read_data1,
    output wire [31:0] read_data2
);
    reg [31:0] regs [0:31];

    assign read_data1 = regs[rs1];
    assign read_data2 = regs[rs2];

    always @(posedge clk) begin
        if (we && rd != 0)
            regs[rd] <= write_data;
    end
endmodule

명령어 페치(IF) → PC → 명령어 메모리
명령어 디코드(ID) → 레지스터 읽기, 제어 신호 생성
실행(EX) → ALU 연산
메모리 접근(MEM) → 데이터 메모리 읽기/쓰기
쓰기(WB) → 결과를 레지스터 파일에 저장

클록:   1  2  3  4  5  6  7  8  9
명령1: IF ID EX ME WB
명령2:    IF ID EX ME WB
명령3:       IF ID EX ME WB
명령4:          IF ID EX ME WB
명령5:             IF ID EX ME WB

[기초]
  불 대수 → 논리 게이트 → 카르노 맵
        ↓
[조합 회로]
  가산기, MUX, 디코더, 인코더
        ↓
[순서 회로]
  래치 → 플립플롭 → 레지스터 → 카운터
        ↓
[시스템 설계]
  FSM → 데이터패스 → 제어 유닛
        ↓
[HDL/FPGA]
  Verilog → 시뮬레이션 → FPGA 구현
        ↓
[CPU/SoC]
  ALU → 파이프라인 → 메모리 계층
        ↓
[AI 하드웨어]
  GPU 아키텍처 → TPU/NPU → FPGA 가속