조합 논리 회로
조합 논리 회로¶
개요¶
조합 논리 회로는 현재 입력만으로 출력이 결정되는 디지털 회로입니다. 이 레슨에서는 조합 논리 회로의 특성과 가산기, 멀티플렉서, 디멀티플렉서, 디코더, 인코더 등 주요 조합 회로를 학습합니다. 이 회로들은 CPU와 메모리 등 컴퓨터 하드웨어의 핵심 구성 요소입니다.
난이도: ⭐⭐ (중급)
목차¶
- 조합 논리 회로의 특성
- 반가산기 (Half Adder)
- 전가산기 (Full Adder)
- 리플 캐리 가산기
- 멀티플렉서 (MUX)
- 디멀티플렉서 (DEMUX)
- 디코더 (Decoder)
- 인코더 (Encoder)
- 비교기와 기타 회로
- 연습 문제
1. 조합 논리 회로의 특성¶
조합 회로 vs 순차 회로¶
┌─────────────────────────────────────────────────────────────┐
│ 디지털 회로의 분류 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ 조합 논리 회로 │ │ 순차 논리 회로 │ │
│ │ (Combinational) │ │ (Sequential) │ │
│ ├─────────────────────┤ ├─────────────────────┤ │
│ │ - 메모리 없음 │ │ - 메모리 있음 │ │
│ │ - 출력 = f(현재입력) │ │ - 출력 = f(입력,상태)│ │
│ │ - 피드백 없음 │ │ - 피드백 있음 │ │
│ │ │ │ │ │
│ │ 예: 가산기, MUX, │ │ 예: 플립플롭, │ │
│ │ 디코더, 인코더 │ │ 레지스터, 카운터 │ │
│ └─────────────────────┘ └─────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
조합 회로의 특성¶
조합 논리 회로의 특성:
1. 출력은 현재 입력에만 의존
┌────────────────┐
│ │
입력 →│ 조합 회로 │→ 출력
│ │
└────────────────┘
Y = f(X₁, X₂, ..., Xₙ)
2. 기억 요소(메모리)가 없음
- 이전 입력이나 상태를 저장하지 않음
3. 전파 지연만 존재
- 입력 변화 → 출력 변화까지의 시간
- 게이트 지연(gate delay)의 합
4. 피드백 경로 없음
- 출력이 다시 입력으로 연결되지 않음
조합 회로 설계 절차¶
┌─────────────────────────────────────────────────────────────┐
│ 조합 회로 설계 절차 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 문제 정의 │
│ - 입력과 출력 명확히 정의 │
│ - 동작 조건 파악 │
│ │
│ 2. 진리표 작성 │
│ - 모든 입력 조합에 대한 출력 결정 │
│ - Don't Care 조건 파악 │
│ │
│ 3. 논리식 유도 │
│ - SOP (곱의 합) 또는 POS (합의 곱) 형태 │
│ │
│ 4. 논리식 간소화 │
│ - 불 대수 또는 K-맵 사용 │
│ │
│ 5. 회로 구현 │
│ - 논리 게이트로 회로 설계 │
│ - 필요시 NAND/NOR 게이트로 변환 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 반가산기 (Half Adder)¶
반가산기 개념¶
반가산기 (Half Adder):
두 개의 1비트 입력을 더하여 합(Sum)과 자리올림(Carry)을 출력
┌─────────────────────────────────────────────────────────────┐
│ │
│ A ─────┐ ┌─────────────┐ │
│ ├─────┤ HA ├───── S (Sum) │
│ B ─────┘ │ ├───── C (Carry) │
│ └─────────────┘ │
│ │
│ 이진 덧셈: A + B = CS │
│ 0 + 0 = 00 (0) │
│ 0 + 1 = 01 (1) │
│ 1 + 0 = 01 (1) │
│ 1 + 1 = 10 (2) │
│ │
└─────────────────────────────────────────────────────────────┘
진리표와 논리식¶
반가산기 진리표:
┌───┬───┬───────┬─────────┐
│ A │ B │ S(Sum)│ C(Carry)│
├───┼───┼───────┼─────────┤
│ 0 │ 0 │ 0 │ 0 │
│ 0 │ 1 │ 1 │ 0 │
│ 1 │ 0 │ 1 │ 0 │
│ 1 │ 1 │ 0 │ 1 │
└───┴───┴───────┴─────────┘
논리식:
S = A ⊕ B (XOR)
C = A · B (AND)
회로 구현¶
반가산기 회로:
A ───┬─────┬───────────────────┐
│ │ │
│ │ ┌──────┐ │
│ └─────┤ XOR ├──────┼─── S
│ ┌─────┤ │ │
B ───┼─────┼─────┴──────┘ │
│ │ │
│ │ ┌──────┐ │
│ └─────┤ AND ├──────┼─── C
└───────────┤ │ │
└──────┘
블록 기호:
┌───────┐
A ───┤ ├─── S (Sum)
│ HA │
B ───┤ ├─── C (Carry)
└───────┘
게이트 수: XOR 1개 + AND 1개 = 2개
NAND 게이트로 구현¶
NAND 게이트만으로 반가산기 구현:
XOR을 NAND로: 4개 필요
AND를 NAND로: 2개 필요
하지만 회로를 최적화하면:
┌───────┐
A ───┤ NAND ├───┬───────────────────┐
B ───┤ 1 │ │ │
└───────┘ │ ┌───────┐ │ ┌───────┐
├───┤ NAND ├───────┼───┤ NAND ├─── S
A ───┬───────────┘ │ 3 │ │ │ 5 │
│ ┌───────┐ └───────┘ │ └───────┘
└───┤ NAND ├───────────────────┘
B ───────┤ 2 │
└───────┘ ┌───────┐
┌───┤ NAND ├─── C
│ │ 4 │
(NAND1 출력) ────┴───┤ │
└───────┘
총 5개의 NAND 게이트 사용
3. 전가산기 (Full Adder)¶
전가산기 개념¶
전가산기 (Full Adder):
세 개의 1비트 입력(A, B, Cᵢₙ)을 더하여 합과 자리올림을 출력
┌─────────────────────────────────────────────────────────────┐
│ │
│ A ─────┐ │
│ │ ┌─────────────┐ │
│ B ─────┼─────┤ FA ├───── S (Sum) │
│ │ │ ├───── Cₒᵤₜ (Carry Out) │
│ Cᵢₙ ────┘ └─────────────┘ │
│ │
│ 이진 덧셈: A + B + Cᵢₙ = CₒᵤₜS │
│ │
│ Cᵢₙ = 하위 비트에서 올라온 자리올림 │
│ Cₒᵤₜ = 상위 비트로 전달할 자리올림 │
│ │
└─────────────────────────────────────────────────────────────┘
진리표와 논리식¶
전가산기 진리표:
┌───┬───┬─────┬───────┬──────────┐
│ A │ B │ Cᵢₙ │ S │ Cₒᵤₜ │
├───┼───┼─────┼───────┼──────────┤
│ 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 │
└───┴───┴─────┴───────┴──────────┘
논리식:
S = A ⊕ B ⊕ Cᵢₙ
Cₒᵤₜ = AB + BCᵢₙ + ACᵢₙ = AB + Cᵢₙ(A ⊕ B)
설명:
- S: 1의 개수가 홀수면 1 (XOR의 연속)
- Cₒᵤₜ: 2개 이상이 1이면 1
두 개의 반가산기로 구현¶
전가산기 = 2개의 반가산기 + OR 게이트
┌───────┐ ┌───────┐
A ────────┤ ├──────┤ ├─────── S
│ HA1 │ │ HA2 │
B ────────┤ ├──┬───┤ ├─────┐
└───────┘ │ └───────┘ │
C1 │ C2 │
│ │ │ │
Cᵢₙ ──────────┼───────┘ │ │
│ │ ┌────┴────┐
└───────────────┴────┤ OR ├─── Cₒᵤₜ
└─────────┘
동작:
1. HA1: A ⊕ B = P (부분합), A·B = G (생성)
2. HA2: P ⊕ Cᵢₙ = S (최종합), P·Cᵢₙ = 전파 캐리
3. Cₒᵤₜ = G + P·Cᵢₙ = AB + (A⊕B)·Cᵢₙ
회로 구현¶
전가산기 상세 회로:
┌───────┐
A ────────┬────────────┤ XOR ├──────┬──────────────┐
│ │ │ │ │
B ────────┼───┬────────┤ │ │ ┌───────┐ │
│ │ └───────┘ └──┤ XOR ├───┼── S
│ │ (P) ┌──┤ │ │
Cᵢₙ ───────┼───┼───────────────────────┘ └───────┘ │
│ │ │
│ │ ┌───────┐ │
│ └────────┤ AND ├──┐ │
│ ┌────────┤ │ │ ┌───────┐ │
│ │ └───────┘ └───┤ │ │
│ │ (G) │ OR ├──────┴── Cₒᵤₜ
│ │ ┌───────┐ ┌───┤ │
│ └────────┤ AND ├──┘ └───────┘
│ │ │
(P) ───────┴────────────┤ │
└───────┘
블록 기호:
┌───────┐
A ────┤ ├──── S
B ────┤ FA │
Cᵢₙ ────┤ ├──── Cₒᵤₜ
└───────┘
4. 리플 캐리 가산기¶
리플 캐리 가산기 개념¶
리플 캐리 가산기 (Ripple Carry Adder):
전가산기를 직렬로 연결하여 다중 비트 덧셈 수행
4비트 리플 캐리 가산기:
A₃ B₃ A₂ B₂ A₁ B₁ A₀ B₀
│ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐
│ FA₃ │←─┤ FA₂ │←─┤ FA₁ │←─┤ FA₀ │←─ Cᵢₙ (0)
└──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘
│ │ │ │
▼ ▼ ▼ ▼
Cₒᵤₜ S₃ S₂ S₁ S₀
결과: Cₒᵤₜ S₃ S₂ S₁ S₀ = A₃A₂A₁A₀ + B₃B₂B₁B₀
8비트 가산기¶
8비트 리플 캐리 가산기:
A[7:0] ───┬──────────────────────────────────────────────┐
│ │
B[7:0] ───┼──────────────────────────────────────────────┼──┐
│ │ │
▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐┌───┐
0 ─────┤FA0├───┤FA1├───┤FA2├───┤FA3├───┤FA4├───┤FA5├─┤FA6├┤FA7├─── Cₒᵤₜ
└─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘└─┬─┘
│ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
S₀ S₁ S₂ S₃ S₄ S₅ S₆ S₇
캐리 전파 지연:
- 최악의 경우: 캐리가 LSB에서 MSB까지 전파
- 지연 시간 = n × (FA 전파 지연)
리플 캐리 가산기의 한계¶
┌─────────────────────────────────────────────────────────────┐
│ 리플 캐리 가산기의 장단점 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 장점: │
│ - 설계가 단순함 │
│ - 게이트 수가 적음 (n비트에 n개의 FA) │
│ - 규칙적인 구조 │
│ │
│ 단점: │
│ - 캐리 전파 지연이 선형으로 증가 │
│ - 32비트, 64비트에서 매우 느림 │
│ │
│ 지연 시간 분석: │
│ - 1개 FA의 캐리 지연: 약 2 게이트 지연 │
│ - n비트 가산기 총 지연: 약 2n 게이트 지연 │
│ │
│ 개선된 가산기: │
│ - 캐리 룩어헤드 가산기 (Carry Lookahead Adder) │
│ - 캐리 선택 가산기 (Carry Select Adder) │
│ - 캐리 저장 가산기 (Carry Save Adder) │
│ │
└─────────────────────────────────────────────────────────────┘
뺄셈기¶
가산기를 이용한 뺄셈:
A - B = A + (-B) = A + (B의 2의 보수) = A + B' + 1
4비트 가산기/감산기:
Sub(0=덧셈, 1=뺄셈)
│
B₃ ───────⊕───┐ B₂ ───────⊕───┐
│ │ │ │
A₃ ────┐ │ │ A₂ ────┐ │ │
│ │ │ │ │ │
▼ ▼ │ ▼ ▼ │
┌─────┐ │ ┌─────┐ │
←─────┤ FA₃ │←─┼──────────┤ FA₂ │←──┼─ ...
└──┬──┘ │ └──┬──┘ │
│ │
S₃ S₂
Sub = 0: B 그대로, Cᵢₙ = 0 → A + B
Sub = 1: B 반전, Cᵢₙ = 1 → A + B' + 1 = A - B
5. 멀티플렉서 (MUX)¶
멀티플렉서 개념¶
멀티플렉서 (Multiplexer, MUX):
여러 입력 중 하나를 선택하여 출력하는 데이터 선택기
┌─────────────────────────────────────────────────────────────┐
│ │
│ 2ⁿ개 입력 → 1개 출력 │
│ n개의 선택선 (Select lines) │
│ │
│ D₀ ───┐ │
│ D₁ ───┼───┐ ┌─────────┐ │
│ D₂ ───┼───┼─────┤ │ │
│ D₃ ───┼───┼─────┤ MUX ├───── Y │
│ ... │ │ │ n:1 │ │
│ D₂ⁿ⁻₁──┼───┼─────┤ │ │
│ │ │ └────┬────┘ │
│ │ │ │ │
│ │ │ S₀ S₁...Sₙ₋₁ │
│ │ │ │ │
│ │ │ (선택선) │
│ │
│ Y = D_S (S번째 입력이 출력) │
│ │
└─────────────────────────────────────────────────────────────┘
2:1 MUX¶
2:1 멀티플렉서:
┌─────────┐
D₀ ──┤ 0 │
│ MUX ├─── Y
D₁ ──┤ 1 │
└────┬────┘
│
S
진리표:
┌───┬──────┐
│ S │ Y │
├───┼──────┤
│ 0 │ D₀ │
│ 1 │ D₁ │
└───┴──────┘
논리식:
Y = S'·D₀ + S·D₁
회로:
┌───────┐
D₀ ──────────────┤ │
│ AND ├────┐
S ───┬───[NOT]───┤ │ │ ┌───────┐
│ └───────┘ ├────┤ OR ├─── Y
│ ┌───────┐ │ │ │
│ │ │ │ └───────┘
D₁ ──┼───────────┤ AND ├────┘
│ │ │
└───────────┤ │
└───────┘
4:1 MUX¶
4:1 멀티플렉서:
┌─────────┐
D₀ ────┤ 00 │
D₁ ────┤ 01 │
│ MUX ├─── Y
D₂ ────┤ 10 │
D₃ ────┤ 11 │
└────┬────┘
│
S₁ S₀
진리표:
┌────┬────┬──────┐
│ S₁ │ S₀ │ Y │
├────┼────┼──────┤
│ 0 │ 0 │ D₀ │
│ 0 │ 1 │ D₁ │
│ 1 │ 0 │ D₂ │
│ 1 │ 1 │ D₃ │
└────┴────┴──────┘
논리식:
Y = S₁'S₀'D₀ + S₁'S₀D₁ + S₁S₀'D₂ + S₁S₀D₃
4:1 MUX 회로¶
4:1 멀티플렉서 회로:
D₀ ────┐ ┌─────┐
└─────┤ AND ├────┐
S₁'────┬─────┤ │ │
S₀'────┼─────┤ │ │
│ └─────┘ │
D₁ ────│ ┌─────┐ │
└─────┤ AND ├────┼────┐
S₁'────┬─────┤ │ │ │
S₀ ────┼─────┤ │ │ │ ┌─────┐
│ └─────┘ │ ├────┤ │
D₂ ────│ ┌─────┐ │ │ │ OR ├─── Y
└─────┤ AND ├────┼────┼────┤ │
S₁ ────┬─────┤ │ │ │ │ │
S₀'────┼─────┤ │ │ │ └─────┘
│ └─────┘ │ │
D₃ ────│ ┌─────┐ │ │
└─────┤ AND ├────┘────┘
S₁ ────┬─────┤ │
S₀ ────┴─────┤ │
└─────┘
2개의 2:1 MUX로 구성:
┌───────┐
D₀ ──┤ 0 │
│ MUX ├──┐ ┌───────┐
D₁ ──┤ 1 │ └────┤ 0 │
└───┬───┘ │ MUX ├─── Y
│ ┌────┤ 1 │
┌───┴───┐ │ └───┬───┘
D₂ ──┤ 0 │ │ │
│ MUX ├──┘ S₁
D₃ ──┤ 1 │
└───┬───┘
S₀
MUX의 응용¶
┌─────────────────────────────────────────────────────────────┐
│ MUX의 응용 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 데이터 선택 │
│ - 여러 소스 중 하나 선택 │
│ - CPU의 데이터 경로 │
│ │
│ 2. 병렬-직렬 변환 │
│ - 병렬 데이터를 순차적으로 출력 │
│ │
│ 3. 논리 함수 구현 │
│ - 진리표의 출력을 데이터 입력으로 │
│ - 어떤 n변수 함수도 2ⁿ:1 MUX로 구현 가능 │
│ │
│ 4. 조건부 데이터 전송 │
│ - if-else 문의 하드웨어 구현 │
│ │
└─────────────────────────────────────────────────────────────┘
예: MUX로 논리 함수 구현
함수 Y = A'B + AB' (XOR)를 4:1 MUX로 구현:
진리표:
┌───┬───┬───┐
│ A │ B │ Y │
├───┼───┼───┤
│ 0 │ 0 │ 0 │ → D₀ = 0
│ 0 │ 1 │ 1 │ → D₁ = 1
│ 1 │ 0 │ 1 │ → D₂ = 1
│ 1 │ 1 │ 0 │ → D₃ = 0
└───┴───┴───┘
┌─────────┐
0 ──┤ 00 │
1 ──┤ 01 │
│ 4:1 ├─── Y = A ⊕ B
1 ──┤ 10 MUX │
0 ──┤ 11 │
└────┬────┘
A B
6. 디멀티플렉서 (DEMUX)¶
디멀티플렉서 개념¶
디멀티플렉서 (Demultiplexer, DEMUX):
하나의 입력을 여러 출력 중 하나로 전달 (MUX의 역)
┌─────────────────────────────────────────────────────────────┐
│ │
│ 1개 입력 → 2ⁿ개 출력 │
│ n개의 선택선 │
│ │
│ ┌─────────┐───── Y₀ │
│ │ │───── Y₁ │
│ D ───────┤ DEMUX │───── Y₂ │
│ │ 1:2ⁿ │───── Y₃ │
│ │ │ ... │ │
│ └────┬────┘───── Y₂ⁿ⁻₁ │
│ │ │
│ S₀ S₁...Sₙ₋₁ │
│ │
│ 선택된 출력만 입력 D를 받고, 나머지는 0 │
│ │
└─────────────────────────────────────────────────────────────┘
1:4 DEMUX¶
1:4 디멀티플렉서:
┌─────────┐───── Y₀
│ │───── Y₁
D ────┤ DEMUX │
│ 1:4 │───── Y₂
└────┬────┘───── Y₃
│
S₁ S₀
진리표 (D=1일 때):
┌────┬────┬────┬────┬────┬────┐
│ S₁ │ S₀ │ Y₀ │ Y₁ │ Y₂ │ Y₃ │
├────┼────┼────┼────┼────┼────┤
│ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │
│ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │
│ 1 │ 0 │ 0 │ 0 │ 1 │ 0 │
│ 1 │ 1 │ 0 │ 0 │ 0 │ 1 │
└────┴────┴────┴────┴────┴────┘
논리식:
Y₀ = D · S₁' · S₀'
Y₁ = D · S₁' · S₀
Y₂ = D · S₁ · S₀'
Y₃ = D · S₁ · S₀
DEMUX 회로¶
1:4 DEMUX 회로:
┌───────┐
D ───┬───────┤ │
│ │ AND ├─── Y₀
S₁'───────┼───────┤ │
S₀'───────┼───────┤ │
│ └───────┘
│ ┌───────┐
├───────┤ │
│ │ AND ├─── Y₁
S₁'───────┼───────┤ │
S₀ ───────┼───────┤ │
│ └───────┘
│ ┌───────┐
├───────┤ │
│ │ AND ├─── Y₂
S₁ ───────┼───────┤ │
S₀'───────┼───────┤ │
│ └───────┘
│ ┌───────┐
└───────┤ │
│ AND ├─── Y₃
S₁ ───────────────┤ │
S₀ ───────────────┤ │
└───────┘
7. 디코더 (Decoder)¶
디코더 개념¶
디코더 (Decoder):
n비트 입력을 2ⁿ개의 출력 중 하나로 활성화
┌─────────────────────────────────────────────────────────────┐
│ │
│ n개 입력 → 2ⁿ개 출력 │
│ 입력값에 해당하는 출력만 1, 나머지는 0 │
│ │
│ ┌─────────┐───── Y₀ │
│ A₀ ──────┤ │───── Y₁ │
│ A₁ ──────┤ DECODER │───── Y₂ │
│ ... │ n:2ⁿ │───── Y₃ │
│ Aₙ₋₁ ────┤ │ ... │ │
│ └─────────┘───── Y₂ⁿ⁻₁ │
│ │
│ Y_i = 1 if 입력 = i (이진수) │
│ │
└─────────────────────────────────────────────────────────────┘
2:4 디코더¶
2:4 디코더 (2-to-4 Decoder):
┌─────────┐───── Y₀
A₀ ────┤ │───── Y₁
A₁ ────┤ 2:4 DEC │───── Y₂
└─────────┘───── Y₃
진리표:
┌────┬────┬────┬────┬────┬────┐
│ A₁ │ A₀ │ Y₀ │ Y₁ │ Y₂ │ Y₃ │
├────┼────┼────┼────┼────┼────┤
│ 0 │ 0 │ 1 │ 0 │ 0 │ 0 │
│ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │
│ 1 │ 0 │ 0 │ 0 │ 1 │ 0 │
│ 1 │ 1 │ 0 │ 0 │ 0 │ 1 │
└────┴────┴────┴────┴────┴────┘
논리식:
Y₀ = A₁' · A₀'
Y₁ = A₁' · A₀
Y₂ = A₁ · A₀'
Y₃ = A₁ · A₀
디코더 회로¶
2:4 디코더 회로:
┌───────┐
A₁'──────────┤ │
│ AND ├─── Y₀ (=A₁'A₀')
A₀'──────────┤ │
└───────┘
┌───────┐
A₁'──────────┤ │
│ AND ├─── Y₁ (=A₁'A₀)
A₀ ──────────┤ │
└───────┘
┌───────┐
A₁ ──────────┤ │
│ AND ├─── Y₂ (=A₁A₀')
A₀'──────────┤ │
└───────┘
┌───────┐
A₁ ──────────┤ │
│ AND ├─── Y₃ (=A₁A₀)
A₀ ──────────┤ │
└───────┘
Enable 입력이 있는 디코더¶
3:8 디코더 with Enable:
┌──────────┐───── Y₀
A₀ ───────┤ │───── Y₁
A₁ ───────┤ 3:8 │───── Y₂
A₂ ───────┤ DEC │───── Y₃
│ │───── Y₄
E ────────┤ (Enable) │───── Y₅
└──────────┘───── Y₆
───── Y₇
E=0: 모든 출력이 0 (비활성화)
E=1: 정상 동작
Enable의 용도:
- 여러 디코더 연결 시 선택
- 칩 선택 (Chip Select)
- 타이밍 제어
디코더의 응용¶
┌─────────────────────────────────────────────────────────────┐
│ 디코더의 응용 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 메모리 주소 디코딩 │
│ - n비트 주소로 2ⁿ개 메모리 위치 선택 │
│ │
│ 2. 명령어 디코딩 │
│ - 연산 코드(opcode)를 제어 신호로 변환 │
│ │
│ 3. 7세그먼트 디스플레이 │
│ - BCD를 7세그먼트 패턴으로 변환 │
│ │
│ 4. 민텀 생성기 │
│ - 논리 함수 구현 (디코더 + OR 게이트) │
│ │
└─────────────────────────────────────────────────────────────┘
디코더로 논리 함수 구현:
예: Y = Σm(1, 2, 4, 7) 를 3:8 디코더로 구현
┌──────────┐
A ────┤ │───── m₀
B ────┤ 3:8 │───── m₁ ──┐
C ────┤ DEC │───── m₂ ──┼──┐
│ │───── m₃ │ │ ┌──────┐
│ │───── m₄ ──┼──┼────┤ │
│ │───── m₅ │ │ │ OR ├─── Y
│ │───── m₆ │ └────┤ │
└──────────┘───── m₇ ──┴───────┤ │
└──────┘
Y = m₁ + m₂ + m₄ + m₇
8. 인코더 (Encoder)¶
인코더 개념¶
인코더 (Encoder):
2ⁿ개의 입력 중 활성화된 하나를 n비트 이진 코드로 변환 (디코더의 역)
┌─────────────────────────────────────────────────────────────┐
│ │
│ 2ⁿ개 입력 → n개 출력 │
│ 활성화된 입력의 번호를 이진수로 출력 │
│ │
│ D₀ ──────┐ │
│ D₁ ──────┼────┐ ┌─────────┐ │
│ D₂ ──────┼────┼─────┤ ├───── A₀ │
│ D₃ ──────┼────┼─────┤ ENCODER ├───── A₁ │
│ ... │ │ │ 2ⁿ:n │ ... │ │
│ D₂ⁿ⁻₁───┼────┼─────┤ ├───── Aₙ₋₁ │
│ │ │ └─────────┘ │
│ │
│ 가정: 동시에 하나의 입력만 활성화 │
│ │
└─────────────────────────────────────────────────────────────┘
4:2 인코더¶
4:2 인코더:
┌─────────┐
D₀ ────┤ │───── A₀
D₁ ────┤ 4:2 │
D₂ ────┤ ENC │───── A₁
D₃ ────┤ │
└─────────┘
진리표:
┌────┬────┬────┬────┬────┬────┐
│ D₃ │ D₂ │ D₁ │ D₀ │ A₁ │ A₀ │
├────┼────┼────┼────┼────┼────┤
│ 0 │ 0 │ 0 │ 1 │ 0 │ 0 │
│ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │
│ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │
│ 1 │ 0 │ 0 │ 0 │ 1 │ 1 │
└────┴────┴────┴────┴────┴────┘
논리식:
A₀ = D₁ + D₃
A₁ = D₂ + D₃
우선순위 인코더¶
우선순위 인코더 (Priority Encoder):
여러 입력이 동시에 활성화되어도 최고 우선순위 입력만 인코딩
┌─────────────────────────────────────────────────────────────┐
│ │
│ 일반 인코더의 문제: │
│ - 두 개 이상의 입력이 동시에 1이면 잘못된 출력 │
│ │
│ 우선순위 인코더: │
│ - 높은 번호 입력이 높은 우선순위 │
│ - Valid 출력 추가 (입력이 있는지 표시) │
│ │
└─────────────────────────────────────────────────────────────┘
4:2 우선순위 인코더:
┌─────────┐───── A₀
D₀ ────┤ │───── A₁
D₁ ────┤ 4:2 │
D₂ ────┤ P.ENC │───── V (Valid)
D₃ ────┤ │
└─────────┘
진리표 (X = don't care):
┌────┬────┬────┬────┬────┬────┬───┐
│ D₃ │ D₂ │ D₁ │ D₀ │ A₁ │ A₀ │ V │
├────┼────┼────┼────┼────┼────┼───┤
│ 0 │ 0 │ 0 │ 0 │ X │ X │ 0 │ ← 입력 없음
│ 0 │ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │
│ 0 │ 0 │ 1 │ X │ 0 │ 1 │ 1 │ ← D₁이 우선
│ 0 │ 1 │ X │ X │ 1 │ 0 │ 1 │ ← D₂가 우선
│ 1 │ X │ X │ X │ 1 │ 1 │ 1 │ ← D₃가 최우선
└────┴────┴────┴────┴────┴────┴───┘
논리식:
A₁ = D₃ + D₂
A₀ = D₃ + D₂'D₁
V = D₃ + D₂ + D₁ + D₀
인코더의 응용¶
┌─────────────────────────────────────────────────────────────┐
│ 인코더의 응용 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 키보드 인코더 │
│ - 누른 키를 스캔 코드로 변환 │
│ - 우선순위 인코더로 동시 키 처리 │
│ │
│ 2. 인터럽트 컨트롤러 │
│ - 여러 인터럽트 요청 중 우선순위가 높은 것 선택 │
│ - 인터럽트 번호 생성 │
│ │
│ 3. 위치 인코더 │
│ - 센서 배열에서 위치 정보 추출 │
│ │
│ 4. 데이터 압축 │
│ - One-hot 코드를 이진 코드로 변환 │
│ │
└─────────────────────────────────────────────────────────────┘
9. 비교기와 기타 회로¶
비교기 (Comparator)¶
1비트 비교기:
두 비트 A와 B를 비교하여 크기 관계 출력
┌─────────┐───── G (A > B)
A ─────┤ │───── E (A = B)
B ─────┤ COMP │───── L (A < B)
└─────────┘
진리표:
┌───┬───┬───┬───┬───┐
│ A │ B │ G │ E │ L │
├───┼───┼───┼───┼───┤
│ 0 │ 0 │ 0 │ 1 │ 0 │
│ 0 │ 1 │ 0 │ 0 │ 1 │
│ 1 │ 0 │ 1 │ 0 │ 0 │
│ 1 │ 1 │ 0 │ 1 │ 0 │
└───┴───┴───┴───┴───┘
논리식:
G = A · B'
E = A ⊙ B = (A ⊕ B)'
L = A' · B
n비트 비교기¶
4비트 비교기:
A[3:0] ────────┐ ┌─────────┐───── A > B
├─────┤ │
B[3:0] ────────┘ │ 4-bit │───── A = B
│ COMP │
│ │───── A < B
└─────────┘
동작 원리:
MSB부터 비교하여 처음 다른 비트에서 결정
A = 1011, B = 1010
│ │
A₃=B₃ A₂=B₂ A₁>B₁ → A > B
논리식 (캐스케이드):
G = A₃B₃' + (A₃⊙B₃)(A₂B₂' + (A₂⊙B₂)(A₁B₁' + (A₁⊙B₁)A₀B₀'))
E = (A₃⊙B₃)(A₂⊙B₂)(A₁⊙B₁)(A₀⊙B₀)
L = E' · G'
BCD to 7-Segment 디코더¶
7-Segment 디스플레이:
─a─
│ │
f b
│ │
─g─
│ │
e c
│ │
─d─
BCD 입력 (4비트) → 7개 세그먼트 출력
┌─────────────┐───── a
D₀ ──┤ │───── b
D₁ ──┤ BCD to │───── c
D₂ ──┤ 7-Segment │───── d
D₃ ──┤ Decoder │───── e
│ │───── f
└─────────────┘───── g
부분 진리표:
┌────────┬────────────────────────────┐
│ BCD │ Segments (a-g) │
├────────┼────────────────────────────┤
│ 0000 │ 1 1 1 1 1 1 0 (0) │
│ 0001 │ 0 1 1 0 0 0 0 (1) │
│ 0010 │ 1 1 0 1 1 0 1 (2) │
│ 0011 │ 1 1 1 1 0 0 1 (3) │
│ 0100 │ 0 1 1 0 0 1 1 (4) │
│ 0101 │ 1 0 1 1 0 1 1 (5) │
│ 0110 │ 1 0 1 1 1 1 1 (6) │
│ 0111 │ 1 1 1 0 0 0 0 (7) │
│ 1000 │ 1 1 1 1 1 1 1 (8) │
│ 1001 │ 1 1 1 1 0 1 1 (9) │
└────────┴────────────────────────────┘
패리티 발생기/검사기¶
패리티 (Parity):
오류 검출을 위해 데이터에 추가하는 비트
짝수 패리티 (Even Parity):
- 전체 1의 개수가 짝수가 되도록 패리티 비트 추가
- 데이터 1의 개수가 홀수면 P=1, 짝수면 P=0
홀수 패리티 (Odd Parity):
- 전체 1의 개수가 홀수가 되도록 패리티 비트 추가
4비트 짝수 패리티 발생기:
D₀ ───┬───⊕───┬───⊕───┬───⊕─── P (패리티 비트)
│ │ │
D₁ ───┘ │ │
│ │
D₂ ───────────┘ │
│
D₃ ───────────────────┘
P = D₀ ⊕ D₁ ⊕ D₂ ⊕ D₃
예: D = 1011
P = 1 ⊕ 0 ⊕ 1 ⊕ 1 = 1
전송: 1011 + 1 = 10111 (1의 개수 = 4, 짝수)
10. 연습 문제¶
기초 문제¶
1. 반가산기와 전가산기의 차이점을 설명하시오.
2. 4비트 리플 캐리 가산기에서 0111 + 0011을 계산하시오. 각 FA의 S와 Cₒᵤₜ을 표시하시오.
3. 8:1 멀티플렉서에서 선택선이 S₂S₁S₀ = 101일 때 어떤 입력이 출력으로 나가는가?
설계 문제¶
4. 전가산기를 NAND 게이트만으로 구현하시오. 필요한 최소 게이트 수는?
5. 4:1 MUX만을 사용하여 다음 함수를 구현하시오.
Y = A'B + AB'C + ABC'
6. 3:8 디코더와 OR 게이트를 사용하여 다음 함수를 구현하시오.
Y = Σm(0, 2, 5, 7)
분석 문제¶
7. 다음 회로의 동작을 분석하고 진리표를 작성하시오.
┌─────────┐
A ───┤ 0 │
│ MUX ├─── Y
B ───┤ 1 │
└────┬────┘
│
A
8. 8비트 리플 캐리 가산기에서 각 FA의 지연이 10ns일 때, 최악의 경우 총 지연 시간은?
응용 문제¶
9. 4비트 가산기/감산기를 설계하시오. Sub 입력이 0이면 덧셈, 1이면 뺄셈을 수행.
10. 우선순위 인코더를 사용하여 8개의 인터럽트 요청 중 가장 우선순위가 높은 것을 선택하는 회로를 설계하시오.
정답
**1.** - 반가산기: 2개 입력(A, B)으로 합과 캐리 출력. 하위 비트의 캐리 입력 없음. - 전가산기: 3개 입력(A, B, Cᵢₙ)으로 합과 캐리 출력. 하위 비트의 캐리를 처리. **2.** 0111 + 0011: - FA₀: 1+1+0 = S₀=0, C₀=1 - FA₁: 1+1+1 = S₁=1, C₁=1 - FA₂: 1+0+1 = S₂=0, C₂=1 - FA₃: 0+0+1 = S₃=1, Cₒᵤₜ=0 - 결과: 01010 (7+3=10) **3.** S₂S₁S₀ = 101 = 5₁₀이므로 D₅가 출력으로 나감. **4.** 전가산기는 9개의 NAND 게이트로 구현 가능. **5.** A, B를 선택선으로 사용: - D₀(A=0,B=0) = 0 - D₁(A=0,B=1) = C' - D₂(A=1,B=0) = C - D₃(A=1,B=1) = C' **6.** 3:8 디코더의 출력 m₀, m₂, m₅, m₇을 OR 게이트로 연결. **7.** 회로 분석: - S=A=0: Y=D₀=A - S=A=1: Y=D₁=B - 따라서 Y = A'·A + A·B = A·B **8.** 리플 캐리 가산기에서 캐리가 최하위에서 최상위까지 전파되는 경우: 8 FA × 10ns = 80ns **9.** 4비트 가산기/감산기: - B 입력을 XOR 게이트를 통해 Sub와 연결 - Sub=0: B 그대로, Cᵢₙ=0 (덧셈) - Sub=1: B 반전, Cᵢₙ=1 (뺄셈) **10.** 8:3 우선순위 인코더 사용: - D₀~D₇: 인터럽트 요청 (D₇이 최고 우선순위) - A₂A₁A₀: 선택된 인터럽트 번호 - V: 유효한 인터럽트 요청 있음다음 단계¶
- 06_Sequential_Logic.md - 래치, 플립플롭, 레지스터, 카운터
참고 자료¶
- Digital Design (Morris Mano)
- Computer Organization and Design (Patterson & Hennessy)
- Logisim - Digital Circuit Simulator
- CircuitVerse - Online Digital Circuit Simulator
- Digital Circuits - All About Circuits