디지털 시스템 설계 및 실험 (학생용)

작성자 : 전기전자전파 공학부 □□□ 학번 : ○○○○○○○○○○

디지털 시스템 설계 및 실험 KEEE209                                                                 전기전자전파 공학부

실험조 : ○○조                    실험일 : 2014. 10.

실험제목

Latch & Flip-Flop, 4bit register & 4bit shift register

실험목표

1. SR Latch 를 설계한다.

2. SR Latch 를 이용하여 D-Type Positive-Edge-Triggered Flip-Flop 을 설계한다.

3. D Flip-Flop 을 이용하여 Negative-Edge-Triggered JK Flip-Flop 을 설계한다.

4. Negative-Edge-Triggered JK Flip-Flop 을 이용하여 BCD Ripple Counter 를 설계한다.

5. 4bit register, 4bit shift register를 설계한다.

6. Register를 이용하여 계산기를 설계한다.

실험준비물

Altera Quartus II 13 software, HBE-COMBO II-DLD 보드

배경지식

1. 이론

• Latch 회로

SR Latch 진리표

S	R	Q	Q'
0	0	1	1	사용 금지
0	1	1	0	Reset
1	0	0	1	set
1	1	Q	Q'	무변화

입력 신호에 의해서 출력이 변화를 갖는 회로로 일종의 기억 회로이다.

- SR Latch 회로

+ S(set), R(reset)을 의미한다.

+ 입력이 변화되기만 하면 게이트의 지연시간 이후에는 입력의 논리에 따라 출력이 결정되는 비동기식 회로이다.

• Flip-flop 회로

플립플롭이란 clock 신호에 의해 입력 신호에 의한 출력을 얻을 수 있는 회로로 clock이 인가되기 전에는 이전 상태를 그대로 유지하는 기억 회로 이다.

- RS Flip-flop 회로

+ RS Latch 회로는 입력이 변화에 의해 출력이 결정되는 비동기식 회로 이지만 RS 플립플롭 회로는 입력이 변화를 갖더라도 clock신호가 인가되지 않으면 출력의 변화가 없고 clock 신호가 인가되어야만 출력이 변화하는 동기 회로이다.

- D Flip-flop 회로

+ 플립플롭은 저장 장치로서 1비트 논리의 처리 및 저장이 가능하므로 입력 신호는 2단자를 갖지 않아도 된다.

+ RS 플립플롭이나 JK플립플롭은 2개의 입력 단자이므로 이를 하나의 입력 단자로 처리하여 1개의 데이터를 저장하므로 D(Data)라 부르고 D 입력을 갖는 플립플롭을 D 플립플롭이라 한다.

- JK Flip-flop 회로

+ SR Flip-flop은 정상적으로 동작하지 않는 부분이 존재하는 사용 금지 부분(R=S=0)이 존재한다. 이를 개선하여 사용 금지부분이 토글로 동작하도록 개선한 것이 JK(Jack-King) 플립플롭이다.

• 카운터

카운터는 시프트 레지스터와 마찬가지로 일련의 플립플롭을 연결하는 회로이지만, 그 연결하는 방법에 있어서 시프트 레지스터와 다르다. 카운터 회로에서는 주어진 플립플롭에 대하여 서로 다른 출력 상태의 수가 최대가 되도록 회로를 연결하며, 입력 펄스에 대하여 출력 상태가 규칙적으로 변하도록 한다.

- 4bit ripple up counter

A의 출력은 Clock 주파수의 1/2배 된다. 이것을 2분주되었다고 한다. B는 4분주, C는 8분주, D는 16분주되어 출력되고 있다.

Table 1. SR Latch with NAND Gates

Function table

S	R	Q	Q'
1	0	0	1
1	1	0	1	(after S=1, R=0)
0	1	1	0
1	1	1	0	(after S=0, R=1)
0	0	1	1

2. SR Latch 를 설계한다.

Figure 1. SR Latch with NAND Gates

Logic diagram

3. SR Latch 를 이용하여 D-Type Positive-Edge-Triggered Flip-Flop 을 설계한다.

Figure 2. D Flip-Flop Graphic symbol

Table 2. D Flip-Flop

Function table

D	Q(t+1)
0	0	Reset
1	1	Set

4. D Flip-Flop 을 이용하여 Negative-Edge-Triggered JK Flip-Flop 을 설계한다.

Figure 3. Negative-Edge-Triggered

JK Flip-Flop Graphic Symbol

Table 3. JK Flip-Flop Characteristic table

J	K	Q(t+1)
0	0	Q(t)	No change
0	1	0	Reset
1	0	1	Set
1	1	Q'(t)	Complement

5. Negative-Edge-Triggered JK Flip-Flop 을 이용하여 BCD Ripple Counter 를 설계한다.

Figure 4.1. State Diagram of a Decimal BCD Counter

<핀 설정>

AB11: FPGA_CLK1, P7: LED8, N7: LED7, M7: LED6, L8: LED5

6. 4Bit Register와 4Bit Shift Register를 설계한다.

4Bit Register

4Bit Shift Register

7. 위의 Register를 이용하여 한자리 정수(0~9)의 덧셈과 뺄셈을 수행하는 계산기를 설계한다.

한자리의 정수(0~9)를 입력하면 Register1에 저장되고 다시 정수를 입력하면 Shift되어 처음 수     는 Register2에 두 번째 수는 Register1에 저장된다. 여기서 IS_SUB키를 누르지 않으면 덧셈을     수행하고 IS_SUB키를 누르면 뺄셈을 수행한다.

/*****************************************************************************

SR Latch

******************************************************************************/

module SR_LATCH(S, R, Q, NQ);

input S, R;

output Q, NQ;

reg Q, NQ;

wire S, R;

always @(S or R)

begin

// Q, NQ 값 구성

end

endmodule

/*****************************************************************************

D-Type Positive-Edge-Triggered Flip-Flop

******************************************************************************/

module D_FF(CLK, D, Q, NQ);

input CLK, D;

output Q, NQ;

wire w1, w2, w3, w4;

// SR_LATCH 모듈 이용하여 구성

endmodule

/*****************************************************************************

Negative-Edge-Triggered JK Flip-Flop

******************************************************************************/

module JK_FF(J, K, CLK, Q, NQ);

input CLK, J, K;

output Q, NQ;

wire JK;

// JK 설정 및 D_FF 모듈 이용하여 Q,NQ 결정

endmodule

/*****************************************************************************

BCD Ripple Counter

******************************************************************************/

module BCD_RIPPLE_COUNTER(CLK, Q1, Q2, Q4, Q8);

input CLK;

output Q1, Q2, Q4, Q8;

wire NQ8;

supply1 p;

// JK_FF 모듈 이용하여 Q1,Q2,Q4,Q8 결정

endmodule

/*****************************************************************************

4Bit Register

******************************************************************************/

module Register(CLK, D, Q);

input [3:0] D;

input CLK;

output [3:0] Q;

// D_FF 모듈 이용하여 Q 결정

endmodule

/******************************************************************************

4Bit Shift Register

******************************************************************************/

module Shift_Register(CLK, SI, SO);

input SI, CLK;

output SO;

reg SO;

reg [2:0] Q;

// D_FF 모듈 이용하여 SO 결정

endmodule

/*****************************************************************************

Add/Subtract Calculation

******************************************************************************/

module Calculator(iCLK, D, IS_SUB, SUM, COUT);

input [9:0] D;

input iCLK, IS_SUB;

output [3:0] SUM;

output COUT;

wire [3:0] BCD;

wire key, CLK;

wire [3:0] A,B;

assign key = D[0]|D[1]|D[2]|D[3]|D[4]|D[5]|D[6]|D[7]|D[8]|D[9];

assign CLK = key & iCLK;

Decimal_to_BCD B1(.D(D),.BCD(BCD));

Register         B2(.CLK(CLK), .D(B),   .Q(A));

Register         B3(.CLK(CLK), .D(BCD), .Q(B));

addsub4        B4(.AIN(A), .BIN(B), .IS_SUB(IS_SUB), .SUM(SUM), .COUT(COUT));

endmodule

/*****************************************************************************

Decimal_to_BCD Converter

******************************************************************************/

module Decimal_to_BCD(D,BCD);

input [9:0] D;

output [3:0] BCD;

assign BCD[0] = D[1]|D[3]|D[5]|D[7]|D[9];

assign BCD[1] = D[2]|D[3]|D[6]|D[7];

assign BCD[2] = D[4]|D[5]|D[6]|D[7];

assign BCD[3] = D[8]|D[9];

endmodule

/******************************************************************************

Half Adder

******************************************************************************/

module HalfAdder(X, Y, S, COUT);

input X, Y;

output S, COUT;

assign S = X ^ Y;

assign COUT = X & Y;

endmodule

/******************************************************************************

Full Adder

******************************************************************************/

module FullAdder(X, Y, CIN, S, COUT);

input X, Y, CIN;

output S, COUT;

wire s1, c1, c2;

HalfAdder U1_HA(.X(X), .Y(Y), .S(s1), .COUT	(c1));

HalfAdder U2_HA(.X(s1), .Y(CIN), .S(S), .COUT(c2));

assign COUT = c2 | c1;

endmodule

/******************************************************************************

4Bit Adder with carry-in

******************************************************************************/

module add4c(AIN, BIN, CIN, SUM, COUT);

input [3:0] AIN, BIN;

input CIN;

output [3:0] SUM;

output COUT;

wire [2:0] carry;

FullAdder U1_FA(.X(AIN[0]), .Y(BIN[0]), .CIN(CIN), .S(SUM[0]), .COUT(carry[0]));

FullAdder U2_FA(.X(AIN[1]), .Y(BIN[1]), .CIN(carry[0]), .S(SUM[1]), .COUT(carry[1]));

FullAdder U3_FA(.X(AIN[2]), .Y(BIN[2]), .CIN(carry[1]), .S(SUM[2]), .COUT(carry[2]));

FullAdder U4_FA(.X(AIN[3]), .Y(BIN[3]), .CIN(carry[2]), .S(SUM[3]), .COUT(COUT));

endmodule

/******************************************************************************

4Bit Adder/Subtractor

******************************************************************************/

module addsub4(AIN, BIN, IS_SUB, SUM, COUT);

input [3:0] AIN, BIN;

input IS_SUB;

output [3:0] SUM;

output COUT;

wire C;

wire [3:0] cmpl = BIN^{4{IS_SUB}};

add4c U_ADD(.AIN(AIN), .BIN(cmpl), .CIN(IS_SUB), .SUM(SUM), .COUT(C));

assign COUT = C^IS_SUB;

endmodule