디지털 시스템 실험

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

디지털 시스템 실험 KECE210                                                                        전기전자전파 공학부

실험조 : ○○조                    실험일 :

실험제목

Simple Computer - Data Path

실험목표

1. 컴퓨터 시스템의 기본적인 구조를 이해한다.

2. DATAPATH를 설계 및 구현하고 검증한다.

실험준비물

Altera Quartus II 4.0 software, HBE-COMBO 보드

배경지식

1. 컴퓨터 시스템

- 폰 노이만 구조 (Von Neumann Architecture)

폰노이만 구조는 (1)Control Unit (2)Arithmetic/Logic Unit (ALU) (3)Memory Unit (4)Input Device (5)Output Device 로 구성된다.

폰노이만 구조의 특징은 컴퓨터 프로그램이 순서에 따라 한번에 하나씩 실행되는 명령어로 구성되며, 프로그램의 실행 코드 및 데이터가 임의 접근이 가능한 메모리에 저장된다는 것이다. 실행되는 코드와 데이터가 Central Processing Unit으로 로드되어 수행되는 구조이다.

그림. 폰 노이만 구조

2. 컴퓨터 프로그램

- 폰 노이만 구조 하에서 컴퓨터 프로그램이 실행되면 Memory Unit에 코드 및 데이터가 Load되고, 순차적인 Microoperation이 Control Unit 및 ALU에 의해 실행된다.

- 하나의 프로그램 코드는 고급 언어(High Level Language)로 작성되어 Compiler, Linker에 의해 어셈블리 언어로 바뀐다. 어셈블리 언어는 Microoperation의 나열로 구성된다.

예) 피보나치 수열을 계산하는 프로그램

- C언어로 작성된 피보나치 수열 게산 프로그램

- Assembly 언어로 작성된 피보나치 수열 계산 프로그램

- Microoperation은 프로그램 수행의 가장 기본적인 단위를 의미한다.

예)

addi $t2, $t1, $to

t1, t0 레지스터에 저장된 값을 더하여 t2 레지스터에 저장한다.

3. Simple Computer Architecture

- Simple Computer는 각각의 Microoperation을 수행하기 위한 Data Path와 Microoperation의 수행 흐름을 제어하기 위한 Control Unit으로 구성된다.

4. Data Path

- Data Path는 데이터를 저장하기 위한 레지스터, Microoperation을 수행하기 위한 ALU, Shifter 등의 회로로 구성된다. Register File과 Function Unit의 두 부분으로 나눌 수 있다.

A. Arithmetic Logic Unit (ALU)

- Arithmetic Logic Unit은 덧셈, 뺄셈 등의 산술 연산과 AND, OR 등의 논리 연산을 수행하는 회로를 의미한다.

- Adder, Logic Unit, 그리고 2-to-1 MUX로 구성된다.

- 연산 수행 제어를 위해서 {Cin, S2, S1, S0}의 제어 정보가 입력된다.

A-1 Arithmetic Circuit

- Arithmetic Circuit은 다음과 같은 진리표를 따르는 회로이다. {Cin, S1, S0, A, B}의 입력을 통해 8가지의 산술 연산을 수행한다.

- Arithmetic Circuit은 다음과 같은 회로 구성을 통해 구현할 수 있다.

A-2 Logic Circuit

- Logic Circuit은 입력 A,B에 대해 {S1,S0}의 Selection Bit에 따라 AND, OR, XOR, NOT의 논리 연산을 수행하는 회로이다. 다음은 Logic Circuit의 진리표와 구성도를 나타낸다.

5. Control Word

- Data Path를 통해 Microoperation의 수행을 정의하고 제어하기 위한 입력을 Control Word라 한다. Control Word는 다음과 같이 구성된다.

▶ DA : Destination Address, Microoperation의 연산 수행 결과를 저장할 Register의 Address를 의미한다.

▶ AA : Destination Address, Microoperation의 첫번 째 입력 A가 저장된 Register의 Address를 의미한다.

▶ BA : Destination Address, Microoperation의 두번 째 입력 B가 저장된 Register의 Address를 의미한다.

▶ MB : MUX B, Microoperation의 두번째 입력 값을 결정하기 위한 MUX B의 Selection Bit를 의미한다.

▶ FS : Function Selection, ALU에서 어떠한 연산을 수행할 지를 정의한다. {Cin, S2, S1, S0}의 ALU Selection Bit를 정의한다.

▶ MD : Mux D, Destination Register에 Microoperation 수행 결과를 저장할 지 외부로부터의 새로운 데이터를 저장할지를 결정하는 MUX D의 Selection Bit이다.

▶ RW : Destination Register에 새로운 값을 저장할지 저장하지 않을지를 정의하는 값이다.

예1) Control Word 11/10/01/0/0001/0/1

R3 = R2 + R1의 Microoperation을 정의하기 위한 Control Word이다.

예2) Control Word 11/10/01/0/1010/0/1

R3 = R2 - R1의 Microoperation을 정의하기 위한 Control Word이다.

실험설계

DATAPATH의 전체 구성도 및 각각의 세부 회로 구성도를 바탕으로 각각의 모듈을 구현한다.

1. Register File 모듈 구현

- 4개의 Register로 구성된 Register File 모듈을 구현한다. 4개의 Register로 구성되어 있기 때문에 Destination Address, A Address, B Address 등은 2bit 의 값을 가지게 된다. 각각의 Register는 4bit의 값을 저장하도록 구현한다.

- Clock, Destination Address, Destination Data, Write, A Address, B Address 를 입력으로 하고, A Data, B Data를 출력으로 하는 모듈을 작성한다.

- Write는 Clock의 Positive Edge에서 발생하도록 구현한다.

2. Function Unit 모듈 구현

- Function Unit은 Arithmetic Circuit, Logic Circuit으로 구성된다.

- A Data, B Data, {Cin, S2, S1, S0}의 4bit 입력에 따라 4bit의 연산 결과를 출력하는 회로를 구현한다.

3. Data Path 모듈 구현 및 시뮬레이션

- Register File, Function Unit 그리고 MUX B, MUX D를 연결하여 전체 Data Path 회로를 구현하고 결과를 시뮬레이션 한다.

- Control Word 는 13bit 로 정의된다.

Verilog Code & PIN number

1. DATAPATH.v

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

/*	Register File	*/

/* INPUT : CLK, Ddata, Write, Daddr, Aaddr, Baddr                        */

/* OUTPUT : Adata, Bdata, Reg0, Reg1, Reg2, Reg3 // For Debugging    */

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

module RegisterFile(CLK, Ddata, Write, Daddr, Aaddr, Baddr, Adata, Bdata, Reg0,Reg1,Reg2,Reg3);

input CLK;

input [3:0] Ddata;

input [1:0] Daddr, Aaddr, Baddr;

input Write;

output [3:0] Adata;

output [3:0] Bdata;

output [3:0] Reg0, Reg1, Reg2, Reg3;

endmodule

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

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

/*	InputLogic                         */

/* INPUT  : Bdata, S1,S0 (Selection Bit)               */

/* OUTPUT : Bout	*/

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

module InputLogic(Bdata, S1, S0, Bout);

input [3:0] Bdata;

input S1, S0;

output [3:0] Bout;

endmodule

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

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

/*	Arithmetic Circuit                         */

/* INPUT  : Adata, Bdata, S1, S0, Cin                  */

/* OUTPUT : Gout (Value), Cout (Carry)	*/

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

module ArithmeticCircuit(Adata, Bdata, S1, S0, Cin, Gout, Cout);

input [3:0] Adata, Bdata;

input S1,S0,Cin;

output [3:0] Gout;

output Cout;

endmodule

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

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

/*	Logic Circuit	*/

/* INPUT  : Adata, Bdata, S1, S0	*/

/* OUTPUT : Gout	*/

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

module LogicCircuit(Adata, Bdata, S1, S0, Gout);

input [3:0] Adata, Bdata;

input S1, S0;

output [3:0] Gout;

endmodule

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

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

/*	Function Unit	*/

/* INPUT  : Adata, Bdata, FS	*/

/* OUTPUT : Fout	*/

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

module FunctionUnit(Adata, Bdata, FS, Fout);

input [3:0] Adata, Bdata;

input [3:0] FS;

output [3:0] Fout;

endmodule

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

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

/*	DATAPATH Circuit	*/

/* INPUT  : CLK, ControlWord, ConstantIn, DataIn       */

/* OUTPUT : Reg0, Reg1, Reg2, Reg3                  */

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

module DATAPATH(CLK, ControlWord, ConstantIn, DataIn, Reg0, Reg1, Reg2, Reg3);

input [12:0] ControlWord;

input [3:0] ConstantIn;

input [3:0] DataIn;

input CLK;

output [3:0] Reg0, Reg1, Reg2, Reg3;

endmodule

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

2. UTILITY.V

/*************** 2-4 Decoder ********************/

module DECODER2to4(A1,A0,D3,D2,D1,D0);

input A1,A0;

output D3,D2,D1,D0;

wire b0,b1,b2,b3,b4,b5,b6,b7;

assign b0 = ~ A0;

assign b1 = ~ A1;

assign b2 = A0;

assign b3 = ~ A1;

assign b4 = A1;

assign b5 = ~ A0;

assign b6 =  A1;

assign b7 = A0;

assign D0 = b0 & b1;

assign D1 = b2 & b3;

assign D2 = b4 & b5;

assign D3 = b6 & b7;

endmodule

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

/*************** Multiplexer ****************/

module MUX2to1(D1,D0,OUT,S);

input [3:0] D1,D0;

input S;

output [3:0] OUT;

reg [3:0] OUT;

always @(D1 or D0 or S) begin

if( S == 1'b0 )

OUT = D0;

else if( S == 1'b1 )

OUT = D1;

end

endmodule

module MUX4to1(D3,D2,D1,D0,OUT, S1, S0);

input [3:0] D3, D2, D1, D0;

input S1, S0;

output [3:0] OUT;

reg [3:0] OUT;

always @(D3 or D2 or D1 or D0 or S1 or S0) begin

if( {S1,S0} == 2'b00)

OUT = D0;

else if( {S1,S0} == 2'b01)

OUT = D1;

else if( {S1,S0} == 2'b10)

OUT = D2;

else if( {S1,S0} == 2'b11)

OUT = D3;

end

endmodule

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

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

/*************** 4bit Adder ****************/

module half_adder(C,S,X,Y);

output C, S;

input X, Y;

xor x0(S, X, Y);

and a0(C, X, Y);

endmodule

module full_adder(C,S,X,Y,Z);

output C, S;

input X, Y, Z;

wire C0, C1;

wire S0;

// First half adder instance

half_adder h0(C0, S0, X, Y);

// Second half adder instance

half_adder h1(C1, S, S0, Z);

// Carry

or o0(C, C1, C0);

endmodule

module adder_4bit(Cout,Sum,A,B,Cin);

output Cout;

output [3:0] Sum;

input [3:0] A, B;

input Cin;

wire [2:0] cw;

full_adder f0 (cw[0], Sum[0], A[0], B[0], Cin);

full_adder f1 (cw[1], Sum[1], A[1], B[1], cw[0]);

full_adder f2 (cw[2], Sum[2], A[2], B[2], cw[1]);

full_adder f3 (Cout, Sum[3], A[3], B[3], cw[2]);

endmodule

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

* Test Bench 코드

`timescale 10ns/1ps

module DATAPATH_TB;

reg CLK;

reg [12:0] CW;

reg [3:0] CONSTANT;

reg [3:0] DATA;

wire [3:0] reg0, reg1, reg2, reg3;

DATAPATH U1(CLK, CW, CONSTANT, DATA, reg0, reg1, reg2, reg3);

initial begin

CLK<=0;CW<=13'b0000000000000;CONSTANT<=4'b0000;DATA<=4'b0000;

#10 DATA<=4'b0100;CW<=13'b0000000000011;  // Register 0에 초기 값 셋팅

#10 DATA<=4'b0101;CW<=13'b0100000000011;  // Register 1에 초기 값 셋팅

#10 DATA<=4'b0110;CW<=13'b1000000000011;  // Register 2에 초기 값 셋팅

#10 DATA<=4'b0111;CW<=13'b1100000000011;  // Register 3에 초기 값 셋팅

#20 CW<=13'b1100010000101;CONSTANT<=4'b0000;DATA<=4'b0000; // R3 = R0+R1;

#10 CW<=13'b1011010101001;CONSTANT<=4'b0000;DATA<=4'b0011; // R2 = R3-R1;

end

always #5

CLK = ~CLK;

endmodule

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