Slide lab 1+2

1

VERILOG FINAL PROJECT

Digital Electronics

Bộ môn Kỹ thuật máy tínhKhoa Điện tử - Viễn thôngTrường ĐH Bách Khoa Đà Nẵng

Cấu trúc MIPS:

2

Shiftleft 2

PC

Instructionmemory

Readaddress

Instruction[31– 0]

Datamemory

Readdata

Writedata

RegistersWriteregister

Writedata

Readdata 1

Readdata 2

Readregister 1

Readregister 2

Instruction [15– 11]



Add

ALUresult

Zero


MemtoRegALUOpMemWrite

RegWrite

MemReadBranchJumpRegDst

ALUSrc


4

Mux

Instruction [25– 0] Jump address [31– 0]

PC+4 [31– 28]

Signextend

16 32Instruction [15– 0]

1

Mux

1

0

Mux

0

1

Mux

0

1

ALUcontrol

Control

Add ALUresult

Mux

0

1 0

ALU

Shiftleft 226 28

Address

duyninh

Typewriter

PCin

duyninh

Typewriter

PC

duyninh

Line

duyninh

Typewriter

PC4

duyninh

Line

duyninh

Typewriter

Shift_left28

duyninh

Typewriter

Shift_left32

duyninh

Line

duyninh

Line

duyninh

Typewriter

Sign_extend_Out

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

2

duyninh

Typewriter

1

duyninh

Typewriter

ALUBranchOut

duyninh

Typewriter

ALU2Out

duyninh

Line

duyninh

Typewriter

ALUcontrolOUt

duyninh

Typewriter

BranchSel

duyninh

Line

duyninh

Typewriter

MuxBranchOut

duyninh

Typewriter

duyninh

Typewriter

ZeroFlag

duyninh

Typewriter

duyninh

Typewriter

duyninh

Line

duyninh

Typewriter

DataMemOut

duyninh

Line

duyninh

Typewriter

JumpAddress

duyninh

Pencil

duyninh

Pencil

duyninh

Oval

duyninh

Oval

duyninh

Oval

duyninh

Oval

duyninh

Oval

duyninh

Oval

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Typewriter

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Pencil

duyninh

Typewriter

duyninh

Oval

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Typewriter

jreg

duyninh

Typewriter

MuxJr

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Line

duyninh

Typewriter

1

duyninh

Typewriter

0

duyninh

Typewriter

MuxJumpOut

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

duyninh

Typewriter

Phân công nhóm

3

Project 3:Nguyễn Văn Hiếu (leader) - testbenchĐặng Thanh Quang -Nguyễn Hữu Hòa -

Project 1

Nguyễn Lê Hoàng Tuấn(nt)-testbench+MultiplexorVõ Ngọc Trí Minh - DecoderĐặng Thị Nguyên Thảo - Register

Project 2

Trần Phước Thịnh (nt) –Nguyễn Thị Bảo Trâm - MuxNguyễn Duy Hoàng -Trương Thị Kim Ngà -

Decoder (5:32)

1. Khối giải mã Decoder:1.1 Giới thiệu:- Khối decoder làm nhiệm vụ giải mã, lựa chọn thanh ghi cần xử lý- Sơ đồ khối của một mạch giải mã 5:32 (5 đầu vào, 32 đầu ra)

4

Decoder532

RegWrite

WriteEnable[31:0]WriteRegister[4:0]

Decoder (5:32)

Khối Decoder gồm:+ 1 ngõ vào 5 bit để lựa chọn thanh ghi: WriteRegister+ 1 ngõ vào điều khiển 1 bit: RegWrite+ 32 ngõ ra enable 1 bit: WriteEnable

5

Decoder (5:32)

1.2 Phân tích:- Ta lập bảng trạng thái mô tả hoạt động của bộ decoder 5:32

6

aa bb cc dd ee Y0 Y1 Y2 Y3 Y4 … Y27 Y28 Y29 Y30 Y3100 00 00 00 00 1 0 0 0 0 0 0 0 0 0 000 00 00 00 11 0 1 0 0 0 0 0 0 0 0 000 00 00 11 00 0 0 1 0 0 0 0 0 0 0 000 00 00 11 11 0 0 0 1 0 0 0 0 0 0 000 00 11 00 00 0 0 0 0 1 0 0 0 0 0 0

.......... .......... …..….. …..….. …..….. ….. ….. ….. ….. …. … ….. ….. ….. ….. …..11 11 00 11 11 0 0 0 0 0 0 1 0 0 0 011 11 11 00 00 0 0 0 0 0 0 0 1 0 0 011 11 11 00 11 0 0 0 0 0 0 0 0 1 0 011 11 11 11 00 0 0 0 0 0 0 0 0 0 1 011 11 11 11 11 0 0 0 0 0 0 0 0 0 0 1

Decoder (5:32)

Với a, b, c, d, e lần lượt là 5 bit ngõ vào WriteRegister- a: WriteRegister[4]; b: WriteRegister[3]; c: WriteRegister[2]- d: WriteRegister[1]; e: WriteRegister[0] Y0, Y1, Y2, Y3, … Y31 lần lượt là 32 bit đầu ra WriteEnable để lựa chọn

thanh ghi cần xử lý Đặt Nota= a; Notb= b; Notc= c ; Notd= d; Note= e

7

Decoder (5:32)

Ta có phương trình logic:- Y0=Nota.Notb.Notc.Notd.Note. Đặt And4_0=Nota.Notb.Notc.Notd WriteEnable[0]=And4_0.RegWrite.Note

- Y1=Nota.Notb.Notc.Notd.e. Đặt And4_0=Nota.Notb.Notc.Notd WriteEnable[1]=And4_0.RegWrite.e

- Y2=Nota.Notb.Notc.d.Note. Đặt And4_1=Nota.Notb.Notc.d WriteEnable[2]=And4_1.RegWrite.Note

- Y3=Nota.Notb.Notc.d.e. Đặt And4_1=Nota.Notb.Notc.d WriteEnable[3]=And4_1.RegWrite.e

- …................................- Y30=a.b.c.d.Note. Đặt And4_15=a.b.c.d WriteEnable[30]=And4_15.RegWrite.Note

- Y31=a.b.c.d.e. Đặt And4_15=a.b.c.d WriteEnable[31]=And4_15.RegWrite.e

8

Decoder (5:32) Code chương trình:`timescale 1 ps / 100 fs

module Decoder(RegWrite, WriteRegister, WriteEnable);

input RegWrite;

input [4:0] WriteRegister;

output [31:0] WriteEnable;

wire Nota, Notb, Notc, Notd, Note;

wire And4_0,And4_1,And4_2,And4_3,And4_4,And4_5,And4_6,And4_7,And4_8,And4_9,And4_10,

And4_11,And4_12,And4_13,And4_14,And4_15;

not #(50) Inv4(Nota, WriteRegister[4]);

not #(50) Inv3(Notb, WriteRegister[3]);

not #(50) Inv2(Notc, WriteRegister[2]);

not #(50) Inv1(Notd, WriteRegister[1]);

not #(50) Inv0(Note, WriteRegister[0]);

and #(50) And4to1_0 (And4_0 , Nota, Notb, Notc, Notd);

……………………………………………

and #(50) And4to1_15(And4_15,WriteRegister[4],WriteRegister[3],WriteRegister[2],WriteRegister[1]);

and #(50) And3to1_0 (WriteEnable[0] , RegWrite, And4_0 , Note);

and #(50) And3to1_1 (WriteEnable[1] , RegWrite, And4_0 , WriteRegister[0]);

…………………………………………………

and #(50) And3to1_31(WriteEnable[31], RegWrite, And4_15, WriteRegister[0]);

endmodule 9

Decoder (5:32)

- Sơ đồ mạch:

10

Register

2. Register:

WriteEnable là tín hiệu điều khiển, cho phép ghi dữ liệu lên thanh ghi Clk là tín hiệu xung đồng bộ WriteData[31..0] là dữ liệu được ghi vào thanh ghi ( gồm 32 bit ) WrittenRegister[31..0] là giá trị của thanh ghi (gồm 32 bit )

11

Construction of Register

12

Bit of Register

Write Enable Q Bit Data Output

0 0 x 0

0 1 x 1

1 x 0 0

1 x 1 1

Output = Q . Write Enable + Write Enable . Bit Data

Bit of Register

14

Bit of Register

module D_FF(q, d, reset, clk);

output q;

input d, reset, clk;

reg q; // Indicate that q is stateholding

always @(posedge clk or posedge reset)

if (reset)

q=0; // On reset, set to 0

else

q=d; // Otherwise, out = d

endmodule

15

Bit of Register

Output = Q . Write Enable + Write Enable . Bit Data

BitOfReg (Q of D Flip-Flop)= a BitData = b

WriteEnable = c

and #(50) U1(a_and_notc,BitOfReg,(~WriteEnable));

and #(50) U2(b_and_c,BitData,WriteEnable);

or #(50) U3(d,a_and_notc,b_and_c);

16

Bit of Register

`timescale 1 ps / 100 fs

module BitOfRegister(WriteEnable, BitData, BitOfReg, clk);

output BitOfReg; // BitOfReg (Q of D Flip-Flop) = a

input BitData, WriteEnable; // BitData = b, WriteEnable = c

input clk;

wire d,a_and_notc, b_and_c; // input of D Flip-Flop

wire reset;

assign reset=0;

and #(50) U1(a_and_notc, BitOfReg, (~WriteEnable));

and #(50) U2(b_and_c, BitData, WriteEnable);

or #(50) U3(d, a_and_notc, b_and_c);

D_FF DFF0(BitOfReg, d, reset, clk);

endmodule

17

Register

18

Register

module Register(WriteEnable, WriteData, WrittenRegister, clk);input WriteEnable, clk;input [31:0] WriteData;output [31:0] WrittenRegister;

BitOfRegister Bit0 (WriteEnable, WriteData[0 ], WrittenRegister[0 ], clk);BitOfRegister Bit1 (WriteEnable, WriteData[1 ], WrittenRegister[1 ], clk);

……………..BitOfRegister Bit30(WriteEnable, WriteData[30], WrittenRegister[30], clk);BitOfRegister Bit31(WriteEnable, WriteData[31], WrittenRegister[31], clk);

endmodule

19

Bộ chọn kênh

3.1-Phân tích:3.1.1-Khối chọn kênh mux32_32to32_32- Ngõ ra của khối thanh ghi Register32 là 32 thanh ghi 32 bit , tùy theo

giá trị của ReadRegister mà ta sẽ lựa chọn một thanh ghi trong tổng số32 thanh ghi ở trên để đưa dữ liệu của nó đến ngõ ra của ReadData.

- Sơ đồ khối chọn kênh này có dạng như sau:

20

Bộ chọn kênh

3.1.2-Khối chọn kênh mux32_1to1_1- Vì 32 bit của thanh ghi ngõ ra ReadData là độc lập nên ta có thể xây

dựng khối mux32_32to1_32 từ 32 khối mux32_1to1_1.- Sơ đồ khối chọn kênh này có dạng như sau:

21

3.2-Tiến trình thiết kế khối chọn kênh mux32_1to1_13.2.1-Thành lập bảng trạng thái ngõ ra BitReadData

22

RR[4] RR[3] RR[2] RR[1] RR[0] BitReadData0 0 0 0 0 BitDataOut0

0 0 0 0 1 BitDataOut1





















23











24

3.2.2- Thiết lập phương trình logic-Từ bảng trạng thái trên , nếu ta gọi:● RR[4]=e;RR[3]=d;RR[2]=c;RR[1]=b;RR[0]=a● Phủ định của a,b,c,d,e lần lượt là na,nb,nc,nd,ne● tg[31..0] là một mảng 32 bit để lưu trữ giá trị tạm thời;thì ta có:tg[0]=ne.nd.nc.nb.na.BitDataOut0 tg[10]=ne. d.nc. b.na.BitDataOut10tg[1]=ne.nd.nc.nb. a.BitDataOut1 tg[11]=ne. d.nc. b. a.BitDataOut11tg[2]=ne.nd.nc. b.na.BitDataOut2 tg[12]=ne. d. c.nb.na.BitDataOut12tg[3]=ne.nd.nc. b. a.BitDataOut3 tg[13]=ne. d. c.nb. a.BitDataOut13tg[4]=ne.nd. c.nb.na.BitDataOut4 tg[14]=ne. d. c. b.na.BitDataOut14tg[5]=ne.nd. c.nb. a.BitDataOut5 tg[15]=ne. d. c. b. a.BitDataOut15tg[6]=ne.nd. c. b.na.BitDataOut6 tg[16]= e.nd.nc.nb.na.BitDataOut16tg[7]=ne.nd. c. b. a.BitDataOut7 tg[17]= e.nd.nc.nb. a.BitDataOut17tg[8]=ne. d.nc.nb.na.BitDataOut8 tg[18]= e.nd.nc. b.na.BitDataOut18tg[9]=ne. d.nc.nb. a.BitDataOut9 tg[19]= e.nd.nc. b. a.BitDataOut19 25

tg[20]= e.nd. c.nb.na.BitDataOut20 tg[26]= e. d.nc. b.na.BitDataOut26tg[21]= e.nd. c.nb. a.BitDataOut21 tg[27]= e. d.nc. b. a.BitDataOut27tg[22]= e.nd. c. b.na.BitDataOut22 tg[28]= e. d. c.nb.na.BitDataOut28tg[23]= e.nd. c. b. a.BitDataOut23 tg[29]= e. d. c.nb. a.BitDataOut29tg[24]= e. d.nc.nb.na.BitDataOut24 tg[30]= e. d. c. b.na.BitDataOut30tg[25]= e. d.nc.nb. a.BitDataOut25 tg[31]= e. d. c. b. a.BitDataOut31

Vậy:BitReadData=tg[0] + tg[1] + tg[2] + tg[3] + tg[4] + tg[5] + tg[6] + tg[7] + tg[8] +

tg[9] + tg[10]+ tg[11] + tg[12] + tg[13] + tg[14] + tg[15] + tg[16] + tg[17] + tg[18] + tg[19] + tg[20] + tg[21]+ tg[22] + tg[23] + tg[24] + tg[25] + tg[26] + tg[27] + tg[28] + tg[29] + tg[30]+ tg[31]

26

3.3-Tiến trình thiết kế khối cộng 32 bit or323.3.1-Phân tích- Theo yêu cầu của project 1, chúng ta chỉ có thể sử dụng các cổng logic

có tối đa 4 đầu vào.- Để thực hiện cộng 32 bit ngõ vào chúng ta cần phân tích thành các khối

nhỏ hơn đó là các cổng logic chỉ có tối đa 4 đầu vào.3.3.2-Thành lập phương trình logic-Gọi m[9..0] là thanh ghi 10 bit lưu trữ tạm thời.-Gọi tg[31..0] lần lượt là 32 bit cần thực hiện việc cộng gộp.-Nếu ta có:m[0]=tg[0]+tg[1]+tg[2]+tg[3] m[4]=tg[16]+tg[17]+tg[18]+tg[19]m[1]=tg[4]+tg[5]+tg[6]+tg[7] m[5]=tg[20]+tg[21]+tg[22]+tg[23]m[2]=tg[8]+tg[9]+tg[10]+tg[11] m[6]=tg[24]+tg[25]+tg[26]+tg[27]m[3]=tg[12]+tg[13]+tg[14]+tg[15] m[7]=tg[28]+tg[29]+tg[30]+tg[31]

27

BitReadData =m[0]+m[1]+m[2]+m[3]+m[4]+m[5]+m[6]+m[7]Nếu: m[8] =m[0]+m[1]+m[2]+m[3]

=

m[9] =m[4]+m[5]+m[6]+m[7]=

Vậy: BitReadData =m[8]+m[9]

28

3.4-Tiến trình thiết kế khối chọn kênh mux32_32to1_32- Đưa từng bit từ [31..0] trong 32 bit của mỗi thanh ghi DataOut0,

DataOut1,.., DataOut31 vào các ngõ vào BitDataOut0, BitDataOut1, .., BitDataOut31 của các Mux32_1to1_1 thứ [31..0].

- 5 bit điều khiển ReadRegister[1..0] được đưa vào 5 bit điều khiểnReadRegister[1..0] đồng thời ở tất cả các Mux32_1to1_1 thứ [31..0].

- 32 bit BitReadData ở Mux32_1to1_1 thứ [31..0] được đưa vào 32 bit từ[31..0] của thanh ghi ngõ ra ReadData theo đúng thứ tự bit.

29

MIPS ALU

Yêu cầu: Thiết kế khối ALU (Arithmetic Logic Unit: Khối số học – logic) 32 bit đơn giản của MIPS. ALU thực hiện các nhiệm vụ sau: ADD, SUB, XOR và SLT.

Sơ đồ khối tổng quát củaALU thiết kế được sẽ có dạngnhư hình vẽ sau:

30

MIPS ALU

Bảng thông số cho ALU control để lựa chọn nhiệm vụ cần thực hiện của ALU:

Cờ Carryout và Overflow chỉ xét ở các lệnh ADD và SUB Cờ Zero và Negative được xét ở các lệnh ADD, SUB và XOR.

31

MIPS ALU

Dự vào yêu cầu thiết kế ,ta chia ALU thành các khối chính như sau: Khối Add_Xor_Sub. Khối chọn kênh MultiplexorOut. Khối MuxFag. Khối CheckFag. Khối Zero_Negative_Finder

32

Khối Add_Xor_Subb

THỰC HIỆN :1. Khối thực hiện Add, Sub, Xor:1.1 Phân tích:

Khối này sẽ thực hiện các phép toán ADD, SUB và XOR tín hiệu vào 32 bit ở Bus A và Bus B. Để thực hiện việc này trước tiên ta phải xây dựngkhối mạch thực hiện các phép toán ADD, SUB và XOR tín hiệu 1 bit .Sauđó sẽ xây dựng khối mạch thực hiện ADD, SUB và XOR 32bit dựa trêncác khối mạch ADD , SUB và XOR 1 bit này.

Sơ đồ khối của khối ADD, SUB và XOR có dạng như sau:

33

ADD, SUB, XOR

CFAdd

CFSubOFAddOFSub

ADDresult[31..0]XORresult[31..0]SUBresult[31..0]

BusA[31..0]

BusB[31..0]

Khối Add_Xor_Subb

1.2 Thiết kế khối ADD, SUB và XOR 1 bit :1.2.1 Khối thực hiện phép toán XOR :

Xét 2 bit vào a và b,khối này sẽ thực hiện phép toán XOR a và b.Tachỉ cần dùng lệnh: xor #(50) U1(a_xor_b, a, b); là có thể tạo được khối này.

1.2.2 Khối thực hiện phép toán ADD:

cinAdd: số nhớ của lần cộng trước đóCAdd : số nhớ của lần cộng hiện tạioutAdd: tổng hiện tại 34

cinAdd

Addab

OutAdd

CAdd

Khối Add_Xor_Subb

Bảng giá trị bộ Add Bảng Karnaugh và tối thiểu hóa:

35

input output

a b cinAdd outAdd CAdd

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

0 1 0 1

1 0 1 0

00 01 11 100

1

abcinAdd

outAdd

0 0 1 0

0 1 1 1

00 01 11 100

1

abcinAdd

CAdd

Khối Add_Xor_Subb

Phương trình logic: outAdd

CAdd

Sử dụng 2 phương trình logic này để viết code cho phép toán cộng.

36

Khối Add_Xor_Subb

1.2.3 Khối thực hiện phép toán SUB :

cinSub: số mượn của lần trừ trước đó CSub: số mượn của lần trừ hiện tại outSub: hiệu số hiện tại

Tương tự như khối Add,chúng ta cũng phải lập bảng giátrị,bảng cacno và tối thiểu hóa để tìm được phương trìnhlogic cho phép toán SUB

37

cinSub

Subab

OutSub

CSub

Khối Add_Xor_Subb

Bảng giá trị bộ SUB Bảng cacno và tối thiểu hóa

38

input output

a b cinSub outSub CSub

0 0 0 0 0

0 0 1 1 1

0 1 0 1 1

0 1 1 0 1

1 0 0 1 0

1 0 1 0 0

1 1 0 0 0

1 1 1 1 1

0 1 0 1

1 0 1 0

0 1 0 0

1 1 1 0

00 01 11 10

00 01 11 10

0

1

0

1

ab

ab

cinSub

cinSub

outSub

CSub

Khối Add_Xor_Subb

Từ đó ta tìm được phương trình logic của phép toán SUB:

outSub

CSub

Sử dụng 2 phương trình logic này để viết code cho phép toántrừ

Khối Add_Xor_Subb

Sau khi viết code và chạy trong quartus ta được sơ đồ mạch như sau:

comb~2

U2

U5

U6ab

cinAdd (GND)

cinSub (GND)

a_xor_b

outAdd

outSub

CAdd

CSub

U1

U3

comb~0

comb~1

comb~3

Khối Add_Xor_Subb

1.3 Thiết kế khối ADD, SUB và XOR 32 bit:1.3.1 Phân tích:- Vì tín hiệu vào có 32 bit . Do đó ta chỉ cần gọi 32 lần modul Calc_bit(đã xây dựng ở phần trên) để thực hiện ADD, SUB , XOR 32 bit theothứ tự từ bit 0 đến bit 31.

- Trong khối này ta cũng có thể tìm được cờ carry và cờ overflow.Dựa vào lý thuyết như sau:

+ Carryout: (tràn không dấu) xảy ra khi có nhớ (mượn) từ MSB.Như vậy cờ Carry( CFAdd và CFSub ) chính là

CAdd[31] và CSub[31]

+ Overflow: (tràn có dấu) xảy ra khi kết quả phép toán vượt quá dảigiới hạn tính toán

Cách xác định cờ Overflow như sau:

Khối Add_Xor_Subb

+ Đối với phép cộng: 2 số hạng của phép cộng cùng dấu nhưng kết quảkhác dấu với 2 số hạng đó. Từ bảng, suy ra cách nhận biết thông qua bit nhớ: overflow xảy ra khi bit nhớ cinAdd và CAdd của MSB khácnhau.

+ Đối với phép trừ: số bị trừ là số dương và số trừ là số âm, kết quả là sốâm hoặc số bị trừ là số âm và số trừ là số dương, kết quả là số dương. Từbảng, suy ra cách nhận biết thông qua bit mượn: overflow xảy ra khibit mượn cinSub và CSub của MSB khác nhau.

cinAddcinSub

a b CAdd outAdd CSub outSub

0 0 0 0 0 0 0

0 0 1 0 1 1 1

0 1 0 0 1 0 1

0 1 1 1 0 0 0

1 0 0 0 1 1 1

1 0 1 1 0 1 0

1 1 0 1 0 0 0

1 1 1 1 1 1 1

Khối Add_Xor_Subb

Do đó ta so sánh 2 bit CAdd[31] và CFAdd[30] nếu 2 bit này khác nhauthì cờ OFAdd sẽ được set. Tương tự nếu 2 bit CSub[31] và CFSub[30]khác nhau thì cờ OFSub sẽ được set. Để làm được điều này ta dùngphép toán XOR .

Khối chọn kênh MultiplexorOut

Phân tích:- Sau khi thực hiện tính toán, ta có được kết quả của 4 phép toán ADD,SUB, XOR và SLT. Căn cứ vào 2 bit điều khiển ở port ALU control để xácđịnh kết quả nào sẽ được đưa ra output port theo như bảng sau:

- Do đó, cần có khối chọn kênh MultiplexorOut.

44

ALU CONTROL LINES FUNCTION

00 ADD01 XOR10 SUB11 SLT

Khối chọn kênh MultiplexorOut

Sơ đồ khối:

Nhận xét: 4 ngõ vào 32 bit là ADDresult, SUBresult, XORresult và SLTresult 1 ngõ vào điều khiển 2 bit là ALUcontrol 1 ngõ ra 32 bit là Output

45

MultiplexorOut4→1

Output [31..0]

ALUcontrol [1..0]

SLTresult [31..0]

XORresult [31..0]

SUBresult [31..0]

ADDresult [31..0]

Khối chọn kênh MultiplexorBit

Xây dựng Khối chọn kênh MultiplexorOut từ 32 Khối chọn kênhMultiplexorBit.

Sơ đồ khối:

Nhận xét: 4 ngõ vào là các bit BitOfADD, BitOfSUB, BitOfXORvà BitOfSLT 1 ngõ vào điều khiển 2 bit là ALUcontrol 1 ngõ ra là bit BitOfOutput

46

MultiplexorBit4→1

BitOfOutput

ALUcontrol [1..0]

BitOfSLT

BitOfXOR

BitofSUB

BitofADD

Thiết kế khối MultiplexorBit

Bảng trạng thái:

Phương trình logic:

47

ALUcontrolBitOfOutput

ALUcontrol [1] ALUcontrol [0]0 0 BitOfADD0 1 BitOfXOR1 0 BitOfSUB1 1 BitOfSLT

Thiết kế khối MultiplexorBit

Code: Sơ đồ mạch:

Thực hiện trên Quartus II

48


module MultiplexorBit(BitOfADD, BitOfXOR, BitOfSUB, BitOfSLT, BitOfOutput, ALUcontrol);

input BitOfADD, BitOfXOR, BitOfSUB, BitOfSLT;

input [1:0] ALUcontrol;

output BitOfOutput;

wire BitSel[0:3];

and #(50) U0(BitSel[0], BitOfADD, (~ALUcontrol[1]), (~ALUcontrol[0]));

and #(50) U1(BitSel[1], BitOfXOR, (~ALUcontrol[1]), ALUcontrol[0] );

and #(50) U2(BitSel[2], BitOfSUB, ALUcontrol[1] , (~ALUcontrol[0]));

and #(50) U3(BitSel[3], BitOfSLT, ALUcontrol[1] , ALUcontrol[0] );

or #(50) Uout(BitOfOutput, BitSel[0], BitSel[1], BitSel[2], BitSel[3]);

endmodule

U1

U3

BitOfADD

BitOfXOR

BitOfSUB

BitOfSLT

ALUcontrol[1..0] U0

BitOfOutput

UoutU2

Thiết kế khối MultiplexorOut

Tiến trình:- Đưa từng bit từ [31..0] trong 32 bit của mỗi port ADDresult,

SUBresult, XORresult và SLTresult vào các ngõ vào BitOfADD,BitOfSUB, BitOfXOR và BitOfSLT của các MultiplexorBit thứ[31..0].

- 2 bit điều khiển ALUcontrol[1..0] được đưa vào 2 bit điều khiểnALUcontrol[1..0] đồng thời ở tất cả các MultiplexorBit thứ [31..0].

- 32 BitOfOutput ở MultiplexorBit thứ [31..0] được đưa vào 32 bit từ[31..0] của port Output theo đúng thứ tự bit.

Thực hiện trên Quartus II

49

Khối MuxFlag

Nhận xét:- Vì cờ CarryOut và cờ Overflow chỉ xét ở các lệnh ADD và SUB do đó

ta cần có mạch chọn kênh 2 1 để chọn cờ cần xét là của lệnh ADDhay SUB tùy thuộc vào 2 bit điều khiển của ALUcontrol.

- Tuy nhiên, căn cứ vào bảng thông số cho ALUcontrol để lựa chọn nhiệmvụ cần thực hiện của ALU: Ta thấy rằng chỉ cần xét MSB của ALUcontrollà có thể xác định được nhiệm vụ cần thực hiện là lệnh ADD hay lệnhSUB để xét cờ → sử dụng 1 bit điều khiển là ALUcontrol[1]

50

ALUcontrolBitOfOutput

ALUcontrol [1] ALUcontrol [0]0 0 BitOfADD0 1 BitOfXOR1 0 BitOfSUB1 1 BitOfSLT

Khối MuxFlag

Sơ đồ khối:

Bảng trạng thái:


51

MuxFlag2 → 1

FlagOfAdd

FlagOfSubFlagOut

control

Control FlagOut0 FlagOfAdd1 FlagOfSub

Thiết kế khối MuxFlag

Code: Sơ đồ mạch:

52


module MuxFlag(FlagOfAdd, FlagOfSub, Control, FlagOut);

input FlagOfAdd, FlagOfSub;

input Control;

output FlagOut;

wire And2[0:1];

and #(50) And2_0(And2[0], FlagOfAdd, (~Control));

and #(50) And2_1(And2[1], FlagOfSub, Control );

or #(50) FlOut(FlagOut, And2[0], And2[1]);

endmodule Thực hiện trên Quartus II

Module CheckFlag

Nhiệm vụ: Quyết định có cập nhật cờ mới hay giữ nguyên trạng thái của cờ đang hiện hành.

Sơ đồ khối :

Tất cả các đầu vào, ra đều là 1 bit

53

CheckFlagNewFlag

Currentflag

Control

OutFlag

Module CheckFlag

- OutFlag: cờ ra- NewFlag: cờ mới cập nhật- CurrentFlag: cờ hiện hành- Control: bit điều khiển, Control= 0 :cờ ra OutFlag sẽ lấy theo cờ mới NewFlag, nếu Control = 1:giữ nguyên cờ hiện hành CurrentFlag.

54

Module CheckFlag

NewFlag CurrenrFlag Control OutFlag

0 0 0 00 1 0 01 0 0 11 1 0 10 0 1 00 1 1 11 0 1 01 1 1 1

55

Module CheckFlag


56

Module CheckFlag

Code Verilog:module CheckFlag(NewFlag, CurrentFlag, Control, OutFlag);

input NewFlag, CurrentFlag, Control;

output OutFlag;

wire NewFlag_and_NotControl, CurrentFlag_and_Control;

and U1(NewFlag_and_NotControl, NewFlag , (~Control));

and U2(CurrentFlag_and_Control,CurrentFlag, Control );

or U3(OutFlag, NewFlag_and_NotControl, CurrentFlag_and_Control);

Endmodule

Sơ đồ mạch:

57

Khối tính cờ Zero và Negative(Zero_Negative_finder)

58

Sơ đồ khối :

1 ngõ vào 32 bit : OutputofALU 2 ngõ ra 1 bit : ZeroFlag và NegativeFlag

Khối tính cờ Zero và Negative(Zero_Negative_finder)

Thuật toán thiết kế tính cờ Zero và Negative.1. Phân tích: − Cờ Zero và Negative chỉ thay đổi giá trị đối với các phép tính Adds,

Xors , Subtracts.− Phép tính SLT không làm thay đổi giá trị của cờ Zero và Negative.− Cờ Zero: − Cờ Zero chỉ lập khi cả 32 bit đầu vào đều là bit 0− Cờ Negative: − Cờ Negative chỉ lập khi bit MSB=1 và 31 còn lại là bit 0.− Vậy điểm chung của 2 cờ nếu được lập thì 31 bit thấp của sẽ có giá trị

là 0. Dựa vào đặc điểm này để viết thuật toán kiểm tra tra cờ.

59

Khối tính cờ Zero và Negative(Zero_Negative_Finder)

2. Thuật toán thiết kế: Tính Or 31 bit thấp của dữ liệu 32 bit “OutputofALU” để tạo ra bit “

Or31bitoutput”. Tìm giá trị của cờ Zero bằng thuật toán như sau:

ZeroFlag = Or31bitoutput + OutputofALU[31]

Tìm giá trị của cờ Negative bằng thuật toán như sau:

NegativeFlag = Or31bitoutput . OutputofALU[31]

60


Code chương trình:`timescale 1 ps / 100 fs

module Zero_Negative_Finder(OutputOfALU, ZeroFlag, NegativeFlag);

input [31:0] OutputOfALU;

output ZeroFlag, NegativeFlag;

wire Or4[0:6];

wire Or3;

wire Nand4[0:1];

wire Or31bitOfOutput; // excepting MSB of Output _ Output[31]

or #(50) Or4_0(Or4[0], OutputOfALU[0 ], OutputOfALU[1 ], OutputOfALU[2 ], OutputOfALU[3]);

or #(50) Or4_1(Or4[1], OutputOfALU[4 ], OutputOfALU[5 ], OutputOfALU[6 ], OutputOfALU[7]);

………………………………………………………………………

or #(50) Or4_6(Or4[6], OutputOfALU[24], OutputOfALU[25], OutputOfALU[26], OutputOfALU[27]);

or #(50) Or3_0(Or3, OutputOfALU[28], OutputOfALU[29], OutputOfALU[30]);

nand #(50) Nand4_0(Nand4[0], (~Or4[0]), (~Or4[1]), (~Or4[2]), (~Or4[3]));

nand #(50) Nand4_1(Nand4[1], (~Or4[4]), (~Or4[5]), (~Or4[6]), (~Or3));

or #(50) Or31bit(Or31bitOfOutput, Nand4[0], Nand4[1]);

nor #(50) ZeroF(ZeroFlag, Or31bitOfOutput, OutputOfALU[31]);

and #(50) NegativeF(NegativeFlag, (~Or31bitOfOutput), OutputOfALU[31]);

endmodule61


62

Sơ đồ mạch :

Tổng hợp Project 2

Sơ đồ khối:

ALU có 8 ports: Port vào gồm: Bus A và Bus B Port điều khiển: ALU control Port ra gồm: Output Zero Overflow Negative Carryout

63


Bảng thông số cho ALU control để lựa chọn nhiệm vụ cần thực hiện của ALU:

Cờ Carryout và Overflow chỉ xét ở các lệnh ADD và SUB Cờ Zero và Negative được xét ở các lệnh ADD, SUB và XOR.

64


Nguyên lý hoạt động cuả ALU:1. Khối Add_xor_sub: - Khối này sử dụng dữ liệu 32bit đầu vào từ Bus A và Bus B để thực hiện các phép toán Add,Xor, Sub- Giá trị đầu ra gồm:CFadd _cờ carry của phép toán AddCFsub _cờ carry của phép toán SubOFadd _cờ Overflow của phép toán AddOFsub _cờ của phép toán SubADDresult_ giá trị của phép toán AddXORresult_giá trị của phép XORSUBresult_giá trị của phép toán Sub

65


2. Khối chọn kênh Multiplexorout: Sau khi thực hiện tính toán ởkhối tính toán, ta có được 4 kếtquả của ADD, SUB, XOR và SLT.Căn cứ vào 2 bit điều khiển ở port ALUcontrol để xác định dữliệu nào sẽ được đưa ra output portCụ thể: ALUcontrol =00_ dữ liệu ADDresult được đưa đến OutputALUcontrol =01_ dữ liệu XORresult được đưa đến OutputALUcontrol =10_dữ liệu SUBresult được đưa đến OutputALUcontrol =11_dữ liệu SLTresult được đưa đến Output

66


3. Khối tính và kiểm tra cờ Zero,Negative:

Dữ liệu ở đầu ra từ khối MultiplexorOut được đưa đến khốiZero_Negative_Finder để xác định giá trị của cờ Zero và Negative.

Dữ liệu đầu ra của khối này là giá trị của cờ Zero và Negative. Giá trị của ZeroFlag và NegativeFlag được đưa đến khối CheckFag để

xác định việc giữ hay thay đổi giá trị của cờ ở đầu ra theo giá trị của bítđiều khiển control. Phương trình logic để thực hiện chọn cờ :OutFlag = control.NewFlag + control.CurrenFlagcontrol = 0 _ cập nhật cờ mới .control = 1 _giữ nguyên giá trị của cờ trước đó.

Giá trị của OutFlag chính là giá trị của cờ Zero và Negative ở đầu ra củaALU 67


4. Khối tính, kiểm tra cờ Carry và OverFlow:

Đầu vào của khối MuxOverflowFlag là giá trị của cờ OFadd và OFsub. Khối này sẽ chọn giá trị cờ của phép toán add hoặc sub theo sự điềukhiển của ALUcontrol[1] và xuất ra port FlagOut.ALUcontrol[1]=1 _chọn giá trị của OFsub.ALUcontrol[1]=0 _chọn giá trị của OFadd.

Giá trị FlagOut được đưa vào khối CheckFlag để xác định việc giữ hay thay đổi giá trị của cờ ở đầu ra của khối CheckFlag theo giá trị của bit điều khiển ALUcontrol[0]. Phương trình logic thực hiện chọn cờ: OutFlag = ALUcontrol[0].NewFlag + ALUcontrol[0].CurrenFlagALUcontrol[0] =1 : giữ nguyên giá trị của cờ trước đó.ALUcontrol[0] =0 : cập nhật cờ mới . 68

Đoạn mã khối Add

Code chương trình:

`timescale 1 ps / 100 fsmodule Add(A,B,Y);

input [31:0] A,B;output [31:0] Y;wire [32:0] C;assign C[0]=0;

Addbit Addbit0 (A[0 ], B[0 ], C[0 ], Y[0 ], C[1 ]);Addbit Addbit1 (A[1 ], B[1 ], C[1 ], Y[1 ], C[2 ]);Addbit Addbit2 (A[2 ], B[2 ], C[2 ], Y[2 ], C[3 ]);Addbit Addbit3 (A[3 ], B[3 ], C[3 ], Y[3 ], C[4 ]);Addbit Addbit4 (A[4 ], B[4 ], C[4 ], Y[4 ], C[5 ]);………………………………………………………………………………………Addbit Addbit26(A[26], B[26], C[26], Y[26], C[27]);Addbit Addbit27(A[27], B[27], C[27], Y[27], C[28]);Addbit Addbit28(A[28], B[28], C[28], Y[28], C[29]);Addbit Addbit29(A[29], B[29], C[29], Y[29], C[30]);Addbit Addbit30(A[30], B[30], C[30], Y[30], C[31]);Addbit Addbit31(A[31], B[31], C[31], Y[31], C[32]);

endmodule

Code chương trình:

module Addbit(a,b,cin,y,cou);

input a,b,cin;

output y,cou;

wire a_xor_b;

xor #(50) (a_xor_b,a,b);

xor #(50) (y,a_xor_b,cin);

or #(50) (cou,a_xor_b & cin,a & b);

endmodule

Đoạn mã khối Addbit

Bảng sự thật:

a b cin y cout0 0 0 0 00 0 1 1 00 1 0 1 00 1 1 0 11 0 0 1 01 0 1 0 11 1 0 0 11 1 1 1 1

Khối addbit

Khối Addbit

Công thức tổng quát:

bacinbacincinbacinba

cinbacinbacinbacinbacoutcinba

cinbacinba

cinbacinbacinbacinbay

.)()(.)(

........

)()(

........

Khối shift_left_2

Khối shift_left_2: Khối có tác dụng dịch 32 bit sang trái 2 bit Ví dụ:1001 1000 1110 0011 0010 0101 1010 1001Lấy 30 phần tử đầu tiên sau đó thêm 2 số 0 ở cuối cùng. Ta được như sau:0110 0011 1000 1100 1001 0110 1010 0100 Khối sign_extend:- Khối này có tác dụng chuyển từ 16 bit có dấu sang 32 bit có dấu.- Đối với MSB của 16 bit là “0” thì ta thêm 16 số “0” trước nó- Đối với MSB của 16 bit là “1” thì ta thêm 16 số “1” trước nó Ví dụ:1/ 0110 0011 0010 1000 0100 1100 1100 1101 chuyển thành0000…0000 0110 0011 0010 1000 0100 1100 1100 11012/ 1110 0011 0010 1000 0100 1100 1100 1101 chuyển thành1111…1111 1110 0011 0010 1000 0100 1100 1100 1101

Đoạn mã shift_left_2

Đoạn mã shift_left_2:

module shift_left_2(In32, Out32);

input [31:0] In32;

output [31:0] Out32;

assign Out32 = {In32[29:0],2'b00};

Endmodule

Đoạn mã sign_extend:

module sign_extend(In16,Out32);

input [15:0] In16;

output [31:0] Out32;

assign Out32 = {{16{In16[15]}},In16};

endmodule

Chức năng bộ MUX

Chức năng của bộ MUX 2x32 to 32 . Bộ MUX để chọn dữ liệu một trong hai đầu vào 32 bit . Datain0 và Datain1 là hai dữ liệu đầu vào . Sel là bit chọn dữ liệu đầu ra . dataOut dữ liệu ra 32 bit .

75

MUX 2x32 to 32

Sơ đồ khối bộ MUX 2x32 to 32.

76

MUX 2x32 to 32

Ý tưởng bộ MUX 2x32to32. Trong bộ MUX 2x32to32 gồm 32 khối MUX 2to1. Mỗi khối MUX 2to1 có 2 đầu vào là bit tương ứng của Data0 và Data1. Đầu ra mỗi khối MUX 2to1 là bit có thứ tự tương ứng với bit Data0 và

Data1.

77

MUX 2 to 1

78

bitin1 bitin0 Sel bitout0 0 0 00 0 1 00 1 0 10 1 1 01 0 0 01 0 1 11 1 0 1

selinselin

ininselinininselin

selininselininselininselininbitout

.1.0

)00(.1)11(.0

.0.1.0.1.0.1 .0.1

MUX 2x5 to 5

79

Khối Control và ALUcontrol

Bảng quan hệ :

80

Value Type

opcode function ALUOp ALUControl

add 100000 00xor 100110 01sub 100010 10slt 101010 11lw 100011sw 101011bne 000101 01 10

J j 000010 xx xx

R 000000 10

I00 00

Kết quả phân tích

Phương trình logic của ALUcontrol :

81

ALUcontrol[0] = (f[5] & (not f[4]) & f[1] & (not f[0])) & A[1] & (not A[0]) & (f[3] xor f[2])

ALUcontrol[1] = ( (f[5] & (not f[4]) & f[1] & (not f[0])) & (not f[2]) & A[1] & (not A[0]) ) or ((not A[1]) & A[0])

Khối Control :o Được viết theo mức behaviouralo Dùng casex

Khối DataMem

82

input [31:0] address, writedata;reg [7:0] datamem[1023:0];

always @(address or datamem[address] or datamem[address+1] ordatamem[address+2] or datamem[address+3])

begintemp={datamem[address],datamem[address+1],datamem[address+2],datamem[address+3]};

end

Hiệu chỉnh DataMem

83

always @(address or datamem[address] ordatamem[address+1] ordatamem[address+2] ordatamem[address+3])

if (readenable)begintemp={datamem[address],datamem[address+1],datamem[address+2],datamem[address+3]};end

sw (store word) Mem[Adrr]Mem[Adrr] lw (load word)

always @(address or datamem[address] or datamem[address+1] or datamem[address+2] ordatamem[address+3])if (readenable or writeenable)begintemp={datamem[address],datamem[address+1],datamem[address+2],datamem[address+3]};end

Testbench

84

Mã Assembly :0 lw $1, 0($0) ; mem 0 ($0) = 54 lw $2, 4($0) ; mem 4 ($0) = 08 lw $3, 8($0) ; mem 8 ($0) = 012 lw $4, 12($0) ; mem 12($0) = 116 lw $5, 16($0) ; mem 16($0) = 220 lw $6, 20($0) ; mem 20($0) = 4024 lw $7, 24($0) ; mem 24($0) = 428 LOOP:slt $2, $0, $132 bne $2, $0, ELSE36 j DONE40 ELSE: add $3, $3, $544 add $6, $6, $748 sw $3, 0($6)52 sub $1, $1, $456 j LOOP60 lw $8, 0($6)64 DONE: j DONE

Mã C++:$1 = 5; // the number of repeat$3 = 0;$6 = 40;while (0<$1)

{$3 = $3 + 2;$6 = $6 + 4;mem[$6] = $3;$1 = $1 – 1;

}

Kết quả cuối cùng:$1 = 0;$3 = 10; $6 = 60; // địa chỉ word

Documents

Slide lab 1+2