순차 논리 회로
순차 논리 회로¶
개요¶
순차 논리 회로는 현재 입력뿐만 아니라 이전 상태(메모리)에 따라 출력이 결정되는 디지털 회로입니다. 이 레슨에서는 기본 기억 소자인 래치와 플립플롭, 그리고 이를 활용한 레지스터와 카운터를 학습합니다. 이들은 CPU 레지스터, 메모리, 상태 기계 등 컴퓨터 핵심 구성 요소의 기반입니다.
난이도: ⭐⭐ (중급)
목차¶
1. 순차 논리 회로의 특성¶
조합 회로 vs 순차 회로¶
┌─────────────────────────────────────────────────────────────┐
│ 회로 유형 비교 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 조합 논리 회로: │
│ ┌────────┐ │
│ │ │ │
│ │ 입력 ──┤ 조합회로 ├── 출력 │
│ │ │ │
│ └────────┘ │
│ 출력 = f(현재 입력) │
│ │
│ 순차 논리 회로: │
│ ┌────────────────────────────────────────────┐ │
│ │ │ │
│ │ 입력 ──┤ 조합회로 ├── 출력 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌───────┐ │ │
│ │ │ 메모리 │ │ │
│ │ │ (상태) │◄───────────────────────── │ │
│ │ └───────┘ 피드백 │ │
│ │ │ │
│ └────────────────────────────────────────────┘ │
│ 출력 = f(현재 입력, 현재 상태) │
│ │
└─────────────────────────────────────────────────────────────┘
순차 회로의 특성¶
┌─────────────────────────────────────────────────────────────┐
│ 순차 논리 회로의 특성 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 기억 소자 (Memory Element) 포함 │
│ - 래치, 플립플롭 │
│ - 이전 상태를 저장 │
│ │
│ 2. 피드백 경로 존재 │
│ - 출력이 다시 입력에 영향 │
│ │
│ 3. 시간에 따른 동작 │
│ - 동기식: 클럭에 의해 상태 변화 │
│ - 비동기식: 입력 변화에 의해 즉시 상태 변화 │
│ │
│ 4. 상태 천이 (State Transition) │
│ - 현재 상태 + 입력 → 다음 상태 │
│ - 상태도(State Diagram)로 표현 │
│ │
└─────────────────────────────────────────────────────────────┘
동기식 vs 비동기식¶
동기식 순차 회로 (Synchronous):
입력 ────┐
│ ┌──────────┐
├────┤ ├──── 출력
│ │ 조합 │
상태 ────┼────┤ 회로 │
▲ │ └──────────┘
│ │
│ │ ┌──────────┐
└─────┴────┤ 플립플롭 │
│ │ (상태) │
CLK ─────┴────┤ │
└──────────┘
- 클럭 엣지에서만 상태 변화
- 예측 가능한 동작
- 설계와 분석이 용이
비동기식 순차 회로 (Asynchronous):
입력 ────┐
│ ┌──────────┐
├────┤ ├──── 출력
│ │ 조합 │
상태 ────┼────┤ 회로 │
▲ │ └──────────┘
│ │
│ │ ┌──────────┐
└─────┴────┤ 래치 │
│ (상태) │
└──────────┘
- 입력 변화에 즉시 반응
- 글리치(Glitch) 발생 가능
- 분석이 복잡
2. SR 래치¶
SR 래치 개념¶
SR 래치 (Set-Reset Latch):
가장 기본적인 기억 소자, 1비트 저장
┌─────────────────────────────────────────────────────────────┐
│ │
│ S (Set): Q를 1로 설정 │
│ R (Reset): Q를 0으로 설정 │
│ Q: 현재 상태 (출력) │
│ Q': Q의 보수 │
│ │
│ 동작: │
│ - S=1, R=0: Q=1 (Set) │
│ - S=0, R=1: Q=0 (Reset) │
│ - S=0, R=0: Q 유지 (저장) │
│ - S=1, R=1: 금지 (Forbidden) │
│ │
└─────────────────────────────────────────────────────────────┘
NOR 게이트 SR 래치¶
NOR 게이트로 구현한 SR 래치:
┌───────┐
R ──────────┤ │
│ NOR ├──────┬───── Q
┌─────┤ │ │
│ └───────┘ │
│ │
│ ┌───────┐ │
│ │ │ │
└─────┤ NOR ├──────┼───── Q'
│ │ │
S ──────────┤ │ │
└───────┘ │
│ │
└─────────┘
피드백
논리식:
Q = (R + Q')' = R' · Q
Q' = (S + Q)' = S' · Q'
NAND 게이트 SR 래치¶
NAND 게이트로 구현한 SR 래치 (Active-Low):
┌───────┐
S' ─────────┤ │
│ NAND ├──────┬───── Q
┌─────┤ │ │
│ └───────┘ │
│ │
│ ┌───────┐ │
│ │ │ │
└─────┤ NAND ├──────┼───── Q'
│ │ │
R' ─────────┤ │ │
└───────┘ │
│ │
└─────────┘
NAND SR 래치는 Active-Low:
- S'=0, R'=1: Q=1 (Set)
- S'=1, R'=0: Q=0 (Reset)
- S'=1, R'=1: Q 유지 (저장)
- S'=0, R'=0: 금지 (Forbidden)
SR 래치 진리표¶
NOR 게이트 SR 래치 진리표:
┌───┬───┬────────┬───────────────────────────────┐
│ S │ R │ Q(t+1)│ 동작 │
├───┼───┼────────┼───────────────────────────────┤
│ 0 │ 0 │ Q(t) │ 유지 (No change) │
│ 0 │ 1 │ 0 │ 리셋 (Reset) │
│ 1 │ 0 │ 1 │ 셋 (Set) │
│ 1 │ 1 │ ? │ 금지 (Forbidden/Invalid) │
└───┴───┴────────┴───────────────────────────────┘
금지 상태 (S=R=1)의 문제:
1. Q와 Q'가 모두 0이 됨 (Q ≠ Q')
2. S, R이 동시에 0으로 돌아가면 경쟁 상태 발생
3. 최종 상태가 불확정
SR 래치 타이밍 다이어그램¶
│
S ───┼──┐ ┌───┐ ┌───┐
│ └───┘ └───────┘ └───────────
│
R ───┼──────────┐ ┌───┐
│ └───┘ └───────────────
│
Q ───┼──────┐ ┌───────────┐
│ └───────┘ └───────
│
Q'───┼──┐ ┌───┐ ┌───────────
│ └───────┘ └───────┘
│
└─────────────────────────────────────→ 시간
Set Reset Set Reset
3. D 래치¶
D 래치 개념¶
D 래치 (Data Latch / Gated D Latch):
SR 래치의 금지 상태를 해결, 단일 데이터 입력
┌─────────────────────────────────────────────────────────────┐
│ │
│ D (Data): 저장할 데이터 │
│ EN (Enable): 게이트 제어 신호 │
│ │
│ 동작: │
│ - EN=1: Q = D (투명, Transparent) │
│ - EN=0: Q 유지 (래치, Latched) │
│ │
│ D 래치는 Enable이 1일 때 입력을 그대로 통과 │
│ "투명 래치(Transparent Latch)"라고도 불림 │
│ │
└─────────────────────────────────────────────────────────────┘
D 래치 회로¶
D 래치 회로 (SR 래치 기반):
┌───────┐
D ──────┬──────┤ │
│ │ AND ├──────── S ───┐
EN ─────┼──────┤ │ │
│ └───────┘ │
│ │
│ ┌───────┐ ┌────┴────┐
│ │ │ │ │
└─[NOT]┤ AND ├──────── R │ SR ├── Q
│ │ │ Latch │
EN ────────────┤ │ │ ├── Q'
└───────┘ └────────┘
논리식:
S = D · EN
R = D' · EN
EN=1일 때:
- D=1 → S=1, R=0 → Q=1
- D=0 → S=0, R=1 → Q=0
- 즉, Q = D
EN=0일 때:
- S=0, R=0 → Q 유지
D 래치 진리표¶
D 래치 진리표:
┌────┬───┬────────┬───────────────────────────────┐
│ EN │ D │ Q(t+1)│ 동작 │
├────┼───┼────────┼───────────────────────────────┤
│ 0 │ 0 │ Q(t) │ 유지 │
│ 0 │ 1 │ Q(t) │ 유지 │
│ 1 │ 0 │ 0 │ D 저장 (Q=0) │
│ 1 │ 1 │ 1 │ D 저장 (Q=1) │
└────┴───┴────────┴───────────────────────────────┘
간단히:
EN=0: Q(t+1) = Q(t) (유지)
EN=1: Q(t+1) = D (통과)
D 래치 기호¶
D 래치 기호:
┌───────────┐
D ───┤ D Q ├─── Q
│ │
EN ──┤ EN Q' ├─── Q'
└───────────┘
또는:
┌───────────┐
D ───┤ D Q ├─── Q
│ >o │
EN ──┤ ├─── Q'
└───────────┘
(레벨 트리거)
D 래치 타이밍¶
│
EN ──┼──┐ ┌───────┐ ┌───────────
│ └───────┘ └───────┘
│ ↑ Transparent ↑ Latched
│
D ───┼────┐ ┌───┐ ┌─────────┐
│ └───┘ └───┘ └───────────
│
Q ───┼────┐ ┌───────┐ ┌─────────────────
│ └───┘ └───┘
│
└─────────────────────────────────────────→ 시간
EN=1 (Transparent): Q가 D를 따라감
EN=0 (Latched): Q가 마지막 D 값을 유지
4. D 플립플롭¶
플립플롭 vs 래치¶
┌─────────────────────────────────────────────────────────────┐
│ 래치 vs 플립플롭 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 래치 (Latch): │
│ - 레벨 트리거 (Level-triggered) │
│ - Enable이 1인 동안 입력에 반응 │
│ - 투명 상태 존재 │
│ │
│ 플립플롭 (Flip-Flop): │
│ - 엣지 트리거 (Edge-triggered) │
│ - 클럭 엣지 순간에만 입력을 샘플링 │
│ - 더 예측 가능한 동작 │
│ │
│ 레벨 트리거 엣지 트리거 │
│ (래치) (플립플롭) │
│ │ │ │
│ EN ────┼──┐ ┌──── CLK ─┼──┐ ┌──── │
│ │ └────┘ │ └────┘ │
│ │ ↑~~~~↑ │ ↑ │
│ │ 반응 구간 │ 순간만 반응 │
│ │
└─────────────────────────────────────────────────────────────┘
D 플립플롭 개념¶
D 플립플롭 (D Flip-Flop):
클럭의 상승/하강 엣지에서만 D 값을 Q에 저장
┌─────────────────────────────────────────────────────────────┐
│ │
│ 동작: │
│ - 상승 엣지 트리거: CLK가 0→1 될 때 D를 Q에 저장 │
│ - 하강 엣지 트리거: CLK가 1→0 될 때 D를 Q에 저장 │
│ - 그 외 시간에는 Q 유지 │
│ │
│ 특성식: Q(t+1) = D │
│ (클럭 엣지에서) │
│ │
└─────────────────────────────────────────────────────────────┘
마스터-슬레이브 구조¶
D 플립플롭 (마스터-슬레이브 구조):
┌─────────────────────────────────────────┐
│ │
D ────┼────┬───────┐ │
│ │ │ │
│ │ ┌───┴───┐ ┌───────┐ │
│ │ │ │ │ │ │
│ └───┤ D Q ├─────┤ D Q ├────────┼─── Q
│ │Master │ │Slave │ │
CLK ──┼────────┤ EN │ ┌──┤ EN │ │
│ └───────┘ │ └───────┘ │
│ │ │
│ ┌──────────┘ │
│ │ [NOT] │
│ │ │
└────────┴──────────────────────────────┘
동작:
1. CLK=0: Master 래치 투명, Slave 래치 고정
- D가 Master의 Q로 전달
- Slave는 이전 값 유지
2. CLK=1: Master 래치 고정, Slave 래치 투명
- Master는 값 유지
- Master의 값이 Slave(최종 Q)로 전달
결과: 상승 엣지에서 D가 Q로 전달
D 플립플롭 기호¶
상승 엣지 트리거 D 플립플롭:
┌───────────┐
D ───┤ D Q ├─── Q
│ │
CLK ─┤ > Q' ├─── Q'
└───────────┘
↑
삼각형 = 엣지 트리거 (상승)
하강 엣지 트리거 D 플립플롭:
┌───────────┐
D ───┤ D Q ├─── Q
│ │
CLK ─┤ >o Q' ├─── Q'
└───────────┘
↑
원 = 반전 (하강 엣지)
D 플립플롭 진리표¶
상승 엣지 트리거 D 플립플롭 진리표:
┌───────┬───┬─────────┬───────────────────────────┐
│ CLK │ D │ Q(t+1) │ 동작 │
├───────┼───┼─────────┼───────────────────────────┤
│ 0 │ X │ Q(t) │ 유지 │
│ 1 │ X │ Q(t) │ 유지 │
│ ↓ │ X │ Q(t) │ 유지 (하강 엣지) │
│ ↑ │ 0 │ 0 │ D 저장 (상승 엣지) │
│ ↑ │ 1 │ 1 │ D 저장 (상승 엣지) │
└───────┴───┴─────────┴───────────────────────────┘
↑ = 상승 엣지 (0→1)
↓ = 하강 엣지 (1→0)
X = Don't care
D 플립플롭 타이밍¶
│
CLK ──┼──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐
│ └──┘ └──┘ └──┘ └──┘ └──┘ └──
│ ↑ ↑ ↑ ↑ ↑
│
D ───┼───────┐ ┌─────────────┐
│ └────────┘ └───
│
Q ───┼───────────┐ ┌─────────────
│ └────────┘
│ ↑ ↑ ↑
│ 상승 상승 상승
│ 엣지 엣지 엣지
└─────────────────────────────────────→ 시간
Q는 상승 엣지 순간의 D 값을 저장
다음 상승 엣지까지 유지
리셋/프리셋 기능¶
D 플립플롭 with Asynchronous Reset/Preset:
┌─────────────────┐
PRE ──┤ PR Q ├─── Q
│ │
D ───┤ D │
│ │
CLK ──┤ > Q' ├─── Q'
│ │
CLR ──┤ CLR │
└─────────────────┘
동작:
- CLR=1 (Active): Q=0 (비동기 리셋)
- PRE=1 (Active): Q=1 (비동기 프리셋)
- CLR=0, PRE=0: 정상 동작 (클럭 엣지에서 D 저장)
진리표:
┌─────┬─────┬───────┬───┬────────┐
│ CLR │ PRE │ CLK │ D │ Q │
├─────┼─────┼───────┼───┼────────┤
│ 1 │ 0 │ X │ X │ 0 │ ← 비동기 리셋
│ 0 │ 1 │ X │ X │ 1 │ ← 비동기 프리셋
│ 1 │ 1 │ X │ X │ ? │ ← 금지
│ 0 │ 0 │ ↑ │ D │ D │ ← 정상 동작
│ 0 │ 0 │ 0/1 │ X │ Q(t) │ ← 유지
└─────┴─────┴───────┴───┴────────┘
5. JK 플립플롭¶
JK 플립플롭 개념¶
JK 플립플롭:
SR 플립플롭의 금지 상태를 "토글"로 대체한 범용 플립플롭
┌─────────────────────────────────────────────────────────────┐
│ │
│ J (Jump): Set과 유사 │
│ K (Kill): Reset과 유사 │
│ │
│ 동작 (클럭 엣지에서): │
│ - J=0, K=0: Q 유지 (No change) │
│ - J=0, K=1: Q=0 (Reset) │
│ - J=1, K=0: Q=1 (Set) │
│ - J=1, K=1: Q 토글 (Q' = Q(t)') │
│ │
│ 특성식: Q(t+1) = J·Q' + K'·Q │
│ │
└─────────────────────────────────────────────────────────────┘
JK 플립플롭 진리표¶
JK 플립플롭 진리표:
┌───┬───┬─────────┬───────────────────────────────┐
│ J │ K │ Q(t+1) │ 동작 │
├───┼───┼─────────┼───────────────────────────────┤
│ 0 │ 0 │ Q(t) │ 유지 (Hold) │
│ 0 │ 1 │ 0 │ 리셋 (Reset) │
│ 1 │ 0 │ 1 │ 셋 (Set) │
│ 1 │ 1 │ Q(t)' │ 토글 (Toggle) │
└───┴───┴─────────┴───────────────────────────────┘
확장 진리표:
┌───┬───┬───────┬─────────┐
│ J │ K │ Q(t) │ Q(t+1) │
├───┼───┼───────┼─────────┤
│ 0 │ 0 │ 0 │ 0 │
│ 0 │ 0 │ 1 │ 1 │
│ 0 │ 1 │ 0 │ 0 │
│ 0 │ 1 │ 1 │ 0 │
│ 1 │ 0 │ 0 │ 1 │
│ 1 │ 0 │ 1 │ 1 │
│ 1 │ 1 │ 0 │ 1 │
│ 1 │ 1 │ 1 │ 0 │
└───┴───┴───────┴─────────┘
JK 플립플롭 기호¶
JK 플립플롭 기호:
┌───────────┐
J ───┤ J Q ├─── Q
│ │
CLK ──┤ > │
│ │
K ───┤ K Q' ├─── Q'
└───────────┘
JK 플립플롭 회로¶
JK 플립플롭 (SR 기반):
┌───────┐
J ─────────┬─┤ │
│ │ AND ├───────── S ───┐
Q' ────────┼─┤ │ │
│ └───────┘ │
│ ┌────┴────┐
│ │ │
│ │ SR ├── Q
CLK ───────┼────────────────────┤ F/F │
│ │ ├── Q'
│ └────┬────┘
│ ┌───────┐ │
K ─────────┼─┤ │ │
│ │ AND ├───────── R ───┘
Q ─────────┴─┤ │
└───────┘
S = J · Q'
R = K · Q
J=K=1일 때:
- Q=0이면: S=1, R=0 → Q=1
- Q=1이면: S=0, R=1 → Q=0
→ 토글!
6. T 플립플롭¶
T 플립플롭 개념¶
T 플립플롭 (Toggle Flip-Flop):
토글 기능에 특화된 플립플롭
┌─────────────────────────────────────────────────────────────┐
│ │
│ 동작 (클럭 엣지에서): │
│ - T=0: Q 유지 (Hold) │
│ - T=1: Q 토글 (Toggle) │
│ │
│ 특성식: Q(t+1) = T ⊕ Q(t) = T·Q' + T'·Q │
│ │
│ 용도: 카운터의 핵심 구성 요소 │
│ │
└─────────────────────────────────────────────────────────────┘
T 플립플롭 진리표¶
T 플립플롭 진리표:
┌───┬─────────┬───────────────────────────────┐
│ T │ Q(t+1) │ 동작 │
├───┼─────────┼───────────────────────────────┤
│ 0 │ Q(t) │ 유지 (Hold) │
│ 1 │ Q(t)' │ 토글 (Toggle) │
└───┴─────────┴───────────────────────────────┘
확장:
┌───┬───────┬─────────┐
│ T │ Q(t) │ Q(t+1) │
├───┼───────┼─────────┤
│ 0 │ 0 │ 0 │
│ 0 │ 1 │ 1 │
│ 1 │ 0 │ 1 │
│ 1 │ 1 │ 0 │
└───┴───────┴─────────┘
T 플립플롭 구현¶
JK 플립플롭으로 T 플립플롭 구현:
┌───────────┐
T ───┤ J Q ├─── Q
│ │
CLK ──┤ > │
│ │
T ───┤ K Q' ├─── Q'
└───────────┘
J = K = T로 연결
D 플립플롭으로 T 플립플롭 구현:
┌───────┐
T ───────────────┤ │
│ XOR ├───┐
Q ──────┬────────┤ │ │
│ └───────┘ │
│ │
│ ┌──────────┐ │
│ │ │ │
└─────┤ D Q ├───┴─── Q
│ │
CLK ──────────┤ > Q' ├─────── Q'
└──────────┘
D = T ⊕ Q
플립플롭 비교¶
┌───────────────────────────────────────────────────────────────┐
│ 플립플롭 비교 │
├───────────┬───────────────────────────────────────────────────┤
│ 종류 │ 특성 │
├───────────┼───────────────────────────────────────────────────┤
│ │ Q(t+1) = D │
│ D │ - 입력을 그대로 저장 │
│ │ - 레지스터에 주로 사용 │
├───────────┼───────────────────────────────────────────────────┤
│ │ Q(t+1) = J·Q' + K'·Q │
│ JK │ - 가장 범용적 │
│ │ - 모든 다른 플립플롭으로 변환 가능 │
├───────────┼───────────────────────────────────────────────────┤
│ │ Q(t+1) = T ⊕ Q │
│ T │ - 토글 기능 │
│ │ - 카운터에 주로 사용 │
├───────────┼───────────────────────────────────────────────────┤
│ │ Q(t+1) = S + R'·Q (S·R=0 조건) │
│ SR │ - 기본적인 래치 │
│ │ - 금지 상태 존재 (S=R=1) │
└───────────┴───────────────────────────────────────────────────┘
변환:
┌─────────────┬─────────────────────────────────────────────────┐
│ 변환 │ 방법 │
├─────────────┼─────────────────────────────────────────────────┤
│ D → JK │ J = D, K = D' │
│ D → T │ T = D ⊕ Q │
│ JK → D │ D = J │
│ JK → T │ J = K = T │
│ T → JK │ J = K = T │
│ T → D │ D = T ⊕ Q │
└─────────────┴─────────────────────────────────────────────────┘
7. 레지스터¶
레지스터 개념¶
레지스터 (Register):
여러 비트의 데이터를 동시에 저장하는 플립플롭 그룹
┌─────────────────────────────────────────────────────────────┐
│ │
│ 용도: │
│ - CPU 내부 데이터 임시 저장 │
│ - 데이터 전송 (병렬/직렬 변환) │
│ - 주소 저장 │
│ - 명령어 저장 │
│ │
│ 종류: │
│ - 병렬 입력/병렬 출력 (PIPO) │
│ - 직렬 입력/직렬 출력 (SISO) │
│ - 직렬 입력/병렬 출력 (SIPO) │
│ - 병렬 입력/직렬 출력 (PISO) │
│ │
└─────────────────────────────────────────────────────────────┘
4비트 병렬 레지스터¶
4비트 병렬 입력/병렬 출력 레지스터:
D₃ D₂ D₁ D₀
│ │ │ │
▼ ▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│ D Q │ │ D Q │ │ D Q │ │ D Q │
│ │ │ │ │ │ │ │
CLK─┤ > │─┤ > │─┤ > │─┤ > │
│ │ │ │ │ │ │ │
│ Q' │ │ Q' │ │ Q' │ │ Q' │
└────────┘ └────────┘ └────────┘ └────────┘
│ │ │ │
▼ ▼ ▼ ▼
Q₃ Q₂ Q₁ Q₀
동작:
- 클럭 엣지에서 D₃D₂D₁D₀가 동시에 Q₃Q₂Q₁Q₀에 저장
- 로드(Load) 기능만 있음
로드 기능이 있는 레지스터¶
4비트 레지스터 with Load Control:
D₃ D₀
│ │
▼ ▼
┌───────┐ ┌───────┐
│ 0 │ │ 0 │
Load ──────┤ MUX │ ... │ MUX │
│ 1 │ │ 1 │
┌─────┤ │ ┌─────┤ │
│ └───┬───┘ │ └───┬───┘
│ │ │ │
│ ▼ │ ▼
│ ┌────────┐ │ ┌────────┐
│ │ D Q │ │ │ D Q │
│ │ │ │ │ │
CLK ─┼────┤ > │───┼────┤ > │
│ │ │ │ │ │
│ │ Q' │ │ │ Q' │
│ └────────┘ │ └────────┘
│ │ │ │
└─────────┴───────┴─────────┘
│ │
▼ ▼
Q₃ Q₀
동작:
- Load=0: Q 유지 (MUX가 Q를 선택)
- Load=1: D 저장 (MUX가 D를 선택)
시프트 레지스터¶
4비트 직렬 입력/병렬 출력 시프트 레지스터 (SIPO):
Serial Out
↑
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │
│ D Q │───→│ D Q │───→│ D Q │───→│ D Q │─┘
│ │ │ │ │ │ │ │
│ > │ │ > │ │ > │ │ > │
│ │ │ │ │ │ │ │
└───┬────┘ └───┬────┘ └───┬────┘ └───┬────┘
│ │ │ │
▲ │ │ │
Serial In CLK CLK CLK
└─────────────┴─────────────┘
동작 (각 클럭 엣지에서):
- 데이터가 왼쪽에서 오른쪽으로 한 칸씩 시프트
- 새 비트가 Serial In으로 입력
예시 (초기값 0000, 입력 1101):
CLK Serial_In Q₃Q₂Q₁Q₀
0 - 0 0 0 0
1 1 1 0 0 0
2 1 1 1 0 0
3 0 0 1 1 0
4 1 1 0 1 1
양방향 시프트 레지스터¶
양방향 시프트 레지스터:
┌─────────────────────────────────────┐
│ │
Left_In ─────┼─┐ ┌───┼───── Right_Out
│ │ ┌─────────┐ ┌─────────┐ │ │
│ └───┤ 00 │ │ │ │ │
│ │ 01 MUX ├───┤ D Q ├───┼───┼─┐
Right_In ────┼─────┤ 10 │ │ │ │ │ │
│ ┌───┤ 11 │ │ > │ │ │ │
│ │ └────┬────┘ └─────────┘ │ │ │
│ │ │ ↑ │ │ │
│ │ S₁ S₀ CLK │ │ │
│ │ │ │ │
│ └───────────────────────────────┘ │ │
│ │ │
└─────────────────────────────────────┼─┘
│
Right_In
모드 선택 (S₁S₀):
- 00: 유지 (Hold)
- 01: 오른쪽 시프트
- 10: 왼쪽 시프트
- 11: 병렬 로드
8. 카운터¶
카운터 개념¶
카운터 (Counter):
클럭 펄스를 세는 순차 회로
┌─────────────────────────────────────────────────────────────┐
│ │
│ 종류: │
│ - 비동기 카운터 (Ripple Counter): 간단하지만 느림 │
│ - 동기 카운터 (Synchronous Counter): 빠름 │
│ │
│ 동작: │
│ - 업 카운터 (Up Counter): 0, 1, 2, 3, ... │
│ - 다운 카운터 (Down Counter): 7, 6, 5, 4, ... │
│ - 업/다운 카운터 │
│ │
│ 모듈러스: │
│ - MOD-n 카운터: 0부터 n-1까지 카운트 │
│ - n비트 카운터: 0부터 2ⁿ-1까지 (MOD-2ⁿ) │
│ │
└─────────────────────────────────────────────────────────────┘
비동기 카운터 (리플 카운터)¶
3비트 비동기 업 카운터:
┌────────┐ ┌────────┐ ┌────────┐
CLK ───────┤ T Q ├──────┤ T Q ├──────┤ T Q ├
│ │ │ │ │ │
1 ──────┤ │ 1──┤ │ 1──┤ │
│ Q' │ │ Q' │ │ Q' │
└───┬────┘ └───┬────┘ └───┬────┘
│ │ │
Q₀ Q₁ Q₂
(LSB) (MSB)
동작:
- 각 T 플립플롭의 T=1 (항상 토글)
- Q₀는 CLK로 직접 동작
- Q₁은 Q₀의 하강 엣지로 동작
- Q₂는 Q₁의 하강 엣지로 동작
타이밍:
│
CLK ──┼─┐ ┐ ┐ ┐ ┐ ┐ ┐ ┐ ┐
│ └─┘ └─┘ └─┘ └─┘ └─┘
│
Q₀ ──┼───┐ ┌───┐ ┌───┐ ┌───
│ └───┘ └───┘ └───┘
│
Q₁ ──┼───────┐ ┌───────┐
│ └───────┘ └───
│
Q₂ ──┼───────────────┐
│ └───────────
│
Count: 0 1 2 3 4 5 6 7 0...
비동기 카운터의 문제점¶
리플 딜레이 (Ripple Delay):
┌─────────────────────────────────────────────────────────────┐
│ │
│ 각 플립플롭의 지연이 누적됨 │
│ │
│ 4비트 카운터 예시 (0111 → 1000 천이): │
│ │
│ Q₃ Q₂ Q₁ Q₀ │
│ 0 1 1 1 (7) │
│ ↓ ↓ ↓ │
│ 0 1 1 0 (6) ← 글리치! │
│ ↓ ↓ │
│ 0 1 0 0 (4) ← 글리치! │
│ ↓ │
│ 0 0 0 0 (0) ← 글리치! │
│ │
│ 1 0 0 0 (8) ← 최종 상태 │
│ │
│ 총 지연 = n × (플립플롭 지연) │
│ │
└─────────────────────────────────────────────────────────────┘
동기 카운터¶
3비트 동기 업 카운터:
AND
│
┌──────────┬┴─────────┐
│ │ │
┌────────┐ ┌────────┐ ┌────────┐
│ T Q ├──┤ T Q ├──┤ T Q ├
│ │ │ │ │ │
1─┤ │ │ │ │ │
│ Q' │ │ Q' │ │ Q' │
└───┬────┘ └───┬────┘ └───┬────┘
│ ↑ │ ↑ │ ↑
Q₀ CLK Q₁ CLK Q₂ CLK
│
┌──────────┴──────────┐
│ │
CLK ────┴─────────────────────┘
논리:
T₀ = 1 (항상 토글)
T₁ = Q₀ (Q₀=1일 때 토글)
T₂ = Q₀ · Q₁ (Q₀=Q₁=1일 때 토글)
동작:
- 모든 플립플롭이 같은 CLK로 동시에 동작
- 글리치 없음
- 고속 동작 가능
MOD-N 카운터¶
MOD-6 카운터 (0~5까지 카운트):
3비트 카운터 + 리셋 로직
┌────────┐ ┌────────┐ ┌────────┐
│ D Q ├──┤ D Q ├──┤ D Q ├
│ │ │ │ │ │
│ │ │ │ │ │
│ Q' │ │ Q' │ │ Q' │
└───┬────┘ └───┬────┘ └───┬────┘
│ │ │
Q₀ Q₁ Q₂
│ │ │
└─────┬─────┴───────────┘
│
┌───┴───┐
│ │
│ AND ├───→ 리셋 (Q₂·Q₁ = 6 검출)
│ │
└───────┘
동작:
- 0, 1, 2, 3, 4, 5, 0, 1, 2, ...
- 6 (110)이 되면 즉시 0으로 리셋
또는 순차 로직으로 설계:
상태: 0→1→2→3→4→5→0...
업/다운 카운터¶
동기식 업/다운 카운터:
Up/Down 제어 신호에 따라 카운트 방향 결정
Up/Down
│
┌───────┼───────┐
│ │ │
┌────┴───┐ │ ┌───┴────┐
│ Q₀ │ │ │ Q₀' │
│ AND │ │ │ AND │
│ Up │ │ │ Down │
└────┬───┘ │ └───┬────┘
│ │ │
└───────┼───────┘
│
┌───┴───┐
│ OR ├────→ T₁
└───────┘
로직:
Up=1: T₁ = Q₀ (이전 비트가 1이면 토글)
Down=1: T₁ = Q₀' (이전 비트가 0이면 토글)
9. 클럭과 타이밍¶
클럭 신호¶
클럭 (Clock):
동기식 회로의 타이밍을 제어하는 주기적 신호
┌─────────────────────────────────────────────────────────────┐
│ │
│ 클럭 파형: │
│ │
│ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │
│ │ │ │ │ │ │ │ │ │
│ ────┘ └────┘ └────┘ └────┘ └──── │
│ │ │ │ │
│ ├────┼────┤ │
│ │ │ │ │
│ T_H T_L T (주기) │
│ │
│ - 주기 (T): 한 사이클의 시간 │
│ - 주파수 (f): f = 1/T │
│ - 듀티 사이클: T_H / T × 100% │
│ │
│ 예: 1GHz 클럭 │
│ - T = 1ns (나노초) │
│ - 1초에 10억 사이클 │
│ │
└─────────────────────────────────────────────────────────────┘
셋업 타임과 홀드 타임¶
플립플롭 타이밍 파라미터:
┌─────────────────────────────────────────────────────────────┐
│ │
│ 셋업 타임 (Setup Time, t_su): │
│ - 클럭 엣지 전에 입력이 안정되어야 하는 최소 시간 │
│ │
│ 홀드 타임 (Hold Time, t_h): │
│ - 클럭 엣지 후에 입력이 유지되어야 하는 최소 시간 │
│ │
│ 전파 지연 (Propagation Delay, t_pd): │
│ - 클럭 엣지에서 출력 변화까지의 시간 │
│ │
└─────────────────────────────────────────────────────────────┘
타이밍 다이어그램:
│←──t_su──→│←t_h→│
│ │ │
D ───┼───┐ │ │
│ └──────┼─────┼─────────
│ │ │
│ │ ↑ │
CLK ──┼──────────┼─┼───┼─────────
│ │ │ │
│ │ │ │
│ │←t_pd→│
Q ───┼──────────┼─────┼───┐
│ │ │ └─────
│
└──────────────────────────→ 시간
타이밍 위반¶
셋업 타임 위반:
│←t_su→│ (필요)
│ │
D ───┼──────┼──────┐
│ ↑ │ └─────
│ │ │
│ 실제 변화 (늦음!)
│ │
CLK ──┼──────┼──────────────
│ │ ↑
클럭 엣지
결과: 출력이 불확정 (메타스테이블 상태 가능)
홀드 타임 위반:
│ │←t_h→│ (필요)
│ │ │
D ───┼──────┼─────┼┐
│ │ │└─────
│ │ ↑
│ │ 실제 변화 (빠름!)
│ │
CLK ──┼──────┼──────────────
│ │ ↑
클럭 엣지
결과: 이전 입력 또는 새 입력이 샘플링될 수 있음
최대 클럭 주파수¶
최대 동작 주파수 계산:
┌─────────────────────────────────────────────────────────────┐
│ │
│ ┌────────┐ ┌──────────┐ ┌────────┐ │
│ │ FF₁ │ │ 조합 │ │ FF₂ │ │
│ │ ├─────────┤ 논리 ├─────────┤ │ │
│ │ Q │ │ │ │ D │ │
│ └────┬───┘ └──────────┘ └───┬────┘ │
│ │ │ │
│ └──────────────────────────────────────┘ │
│ │ │
│ CLK ────────────────┴───────────────────────── │
│ │
│ 최소 클럭 주기: │
│ T_min = t_pd(FF₁) + t_comb + t_su(FF₂) │
│ │
│ 최대 주파수: │
│ f_max = 1 / T_min │
│ │
│ 예시: │
│ t_pd = 2ns, t_comb = 5ns, t_su = 1ns │
│ T_min = 2 + 5 + 1 = 8ns │
│ f_max = 1 / 8ns = 125MHz │
│ │
└─────────────────────────────────────────────────────────────┘
메타스테이블리티¶
메타스테이블 상태 (Metastability):
┌─────────────────────────────────────────────────────────────┐
│ │
│ 셋업/홀드 타임 위반 시 발생하는 불안정 상태 │
│ │
│ 정상 상태: 메타스테이블 상태: │
│ │
│ 1 ──●── 1 ── ● │
│ │ ╲ ╱ │
│ │ ╲●●●●●╱ │
│ │ │ │
│ 0 ──┴── 0 ── │ │
│ 불확정 │
│ │
│ 위험: │
│ - 출력이 불확정 시간 동안 중간값 │
│ - 다음 단 회로가 0인지 1인지 판단 불가 │
│ - 시스템 오동작 가능 │
│ │
│ 해결: │
│ - 동기화 회로 (Synchronizer) 사용 │
│ - 충분한 마진을 둔 타이밍 설계 │
│ │
└─────────────────────────────────────────────────────────────┘
10. 연습 문제¶
기초 문제¶
1. 래치와 플립플롭의 차이점을 설명하시오.
2. D 플립플롭의 특성식을 쓰고 동작을 설명하시오.
3. JK 플립플롭에서 J=K=1일 때의 동작을 설명하시오.
분석 문제¶
4. 다음 회로의 동작을 분석하고 상태 천이표를 작성하시오.
┌───────────┐
D ───┤ D Q ├───┬─── Q
│ │ │
CLK ──┤ > Q' ├───┼─── Q'
└───────────┘ │
↑ │
└─────────┘
5. 4비트 리플 카운터의 타이밍 다이어그램을 그리시오. 초기 상태는 0000이다.
6. 다음 레지스터의 동작을 설명하시오. 초기값은 0000, 입력 시퀀스는 1, 0, 1, 1이다.
4비트 오른쪽 시프트 레지스터 (직렬 입력)
설계 문제¶
7. D 플립플롭만 사용하여 T 플립플롭을 구현하시오.
8. MOD-5 동기 카운터를 설계하시오. (0, 1, 2, 3, 4, 0, ...)
9. 4비트 양방향 시프트 레지스터를 설계하시오. (Left, Right, Hold 모드)
타이밍 문제¶
10. 다음 조건에서 최대 클럭 주파수를 계산하시오. - 플립플롭 전파 지연: 5ns - 조합 회로 지연: 15ns - 셋업 타임: 3ns - 홀드 타임: 2ns
정답
**1.** - 래치: 레벨 트리거, Enable이 활성화된 동안 입력에 반응 (투명) - 플립플롭: 엣지 트리거, 클럭 엣지 순간에만 입력을 샘플링 **2.** Q(t+1) = D (클럭 엣지에서). 클럭의 상승(또는 하강) 엣지에서 D 입력값을 Q에 저장하고, 다음 엣지까지 유지한다. **3.** J=K=1일 때 Q는 토글된다. 즉 Q(t+1) = Q(t)'. 현재 0이면 1이 되고, 1이면 0이 된다. **4.** 회로는 D 입력이 Q'에 연결된 D 플립플롭이다. 이는 T 플립플롭과 동일하게 동작하며, 매 클럭 엣지에서 토글된다. 상태 천이: 0→1→0→1→... **5.**CLK: _|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_|‾|_
Q₀: __|‾‾|__|‾‾|__|‾‾|__|‾‾|__|‾‾|__
Q₁: ____|‾‾‾‾|____|‾‾‾‾|____|‾‾‾‾|__
Q₂: ________|‾‾‾‾‾‾‾‾|________|‾‾‾‾
Q₃: ________________|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
다음 단계¶
- 07_CPU_구조_기초.md - CPU 구성 요소와 명령어 실행 사이클
참고 자료¶
- Digital Design (Morris Mano)
- Computer Organization and Design (Patterson & Hennessy)
- Logic Gate Simulator
- Digital Circuits Tutorial
- Nand2Tetris - Building a Computer from First Principles