晒：《计算机组成实验报告》

第一部分运用TDM-CM++实验台的实验
- 实验三：微控制器实验
  - [实验目的]
  - [实验设备]
  - [实验原理]
  - [实验步骤以及结果]
  - [解释数据通路]
第二部分用Verilog-HDL进行计算机设计的实验
- [实验目的]
- [实验设备]
- [实验步骤]
- [实验内容]
  - 实验一：带进位的四位加法器
  - 实验二：时钟发生器
  - 实验六：数据控制器
  - 实验九：状态控制器
附录一：
- 实验十：CPU

计算机组成实验报告

指导教师姓名：戴老师

学生姓名：[email protected]

实验日期：星期六上午

第一部分运用TDM-CM++实验台的实验

实验三：微控制器实验

第二部分用Verilog-HDL进行计算机设计的实验

实验一：带进位的四位加法器

实验二：时钟发生器

实验三：指令寄存器

实验五：数据控制器

实验九：状态控制器

附一：CPU设计

附二：实验波形图

第一部分运用TDM-CM++实验台的实验

实验三：微控制器实验

（与《实验五：基本微型机设计与实现》一起分析）

[实验目的]

1 ．掌握时序产生器的组成原理。

2 ．掌握微程序控制器的组成原理。

3 ．掌握微程序的编制，写入，观察微程序的运行。

[实验设备]

TDN-CM++计算机组成原理教学实验系统一台。

[实验原理]

1. 时序控制电路

时序控制电路采用一片CPLD芯片，电路框图如图。产生4个等间隔的时序信号TS1－TS4。

φ：时钟脉冲输入端，接到方波发生器的输出（ H23 ）。 WI 调频率， W2 调脉宽。

START 键是实验板上一个微动开关 START 的按键信号。

STEP （单步开关）： STEP 开关为 0 时（ EXEC ），一旦按下启动键，时序信号 TS1 － TS4 将周而复始地发送出去。

STOP ：拨动开关。 STOP 停机； RUN 运行。

CLR ：拨动开关。时序清零。

TS1~TS4 等间隔的时序信号输出。

2 ．微指令格式

微指令字长共24位，其中UA5－UA0为6位的后续微地址，A、B、C为三个译码字段，分别由三个控制位译码出多位。

24	23	22	21	20	19	18	17	16	15 14 13	12 11 10	9 8 7	6	5	4	3	2	1
S3	S2	S1	S0	M	Cn	WE	A9	A8	A	B	C	μA5	μA4	μA3	μA2	μA1	μA0

3 ．微程序控制电路

微程序控制电路组成：控制存储器、微命令寄存器、微地址寄存器。

编程开关 : PROM（编程）：根据微地址和微指令格式将微指令二进制代码写入到控制存储器中；READ（校验）：可以对写入控制存储器中的二进制代码进行验证；RUN（运行）：只要给出微程序的入口微地址，则可根据微程序流程图自动执行微程序。

[实验步骤以及结果]

1 ．连接实验线路，接通电源。

2 ．运行实验台系统程序 NCMP53 ，按 F7 。

3 ．把时序电路中“ STOP ”开关置“ RUN ”、“ STEP ”开关置“ EXEC ”，按 START ，用 PC 模拟字波器观察φ， TS1~TS4 波形，画出波形图，测出周期和脉冲宽度。

4 ．联机装载微程序（把编程开关拨到 PROM 状态）（按 F4 ，输入文件名 EXI.TXT ）检查微程序是否正确（按 F3 ，输入起始地址，对照 37 页微程序代码。）运行实验台系统程序 NCMP53 ，按 F7 。

5 ．把 SWITCH 单元μ MA5~ μ AO 接线接到微控制器单元的 SE6~SE1 ， MA5~MA0 全置“ 1 ”。单步运行微程序。通过改变开关状态，把所有微程序全部执行。（注意：微地址“ 1 ”要变“ 0 ”）

[解释数据通路]

结合实验五，对照微程序流程图和基本微型机的硬件组成解释数据通路：

SWA	SWB	控制台命令
0	0	读内存
0	1	写内存
1	1	启动程序

默认SWA=1；SWB=1，处于启动程序状态。经过控制台指令地址从00－》01，启动控制台。

第二部分用Verilog-HDL进行计算机设计的实验

[实验目的]

1 ．了解工作原理。

2 ．学会编写模块程序

3 ．学会编写测试的模块程序。

[实验设备]

1 ．常用微机一台；

2 ． Model Sim SEPLUS5.6 软件一套。

[实验步骤]

1 ．编写模块程序；

2 ．编写测试程序；

3 ．编辑编译这两个模块程序；

4 ．运行模拟、观察波形、验证设计的正确性。

[实验内容]

实验一带进位四位加法器

实验二时钟发生器

实验五数据控制器

实验九状态控制器

附：实验十：CPU

实验一：带进位的四位加法器

[实验原理]

4位输入信号：add_a[4],add_b[4]

输入进位：carry

时钟信号：clk

4位输出信号：sum[4]

进位信号：flow

[实验步骤以及结果]

1．模块程序add4.v

module add4(add_a,add_b,sum,flow,clk,carry);

output [3:0] sum; //声明输出信号sum

output flow; //声明输出高位进位float

input [3:0] add_a,add_b; //声明两个4位二进制的输入信号add_a与add_b

input carry; //声明输入信号低位进位信号carry

input clk; //声明时钟信号CLK

reg [3:0] sum; //定义了一个4位的名为SUM的寄存器

reg flow; //定义了一个1位的名为FLOW的寄存器

always@(negedge clk) //CLK下降沿时，执行下列语句

begin

sum<=add_a+add_b+carry;//sum<=add_a+add_b+carry;

end

always@(posedge clk) //CLK上升沿时，执行下列语句

begin

flow<=(add_a[3]&add_b[3])|((add_a[3]|add_b[3])&sum[3]<1);

end //计算FLOW的数值

endmodule

2．测试程序add4_test.tst

module add4_test;

reg [3:0] add_a,add_b;

reg carry;

reg clk;

wire [3:0] sum;

wire flow;

add4 add4(add_a,add_b,sum,flow,clk,carry);

initial begin

carry=0;

clk=1;

add_a=4'b1011;

add_b=4'b0101;

end

always #1 clk=~clk; //产生时钟信号

always #5 carry=~carry; //间隔5，低位进位信号改变数值

always@(posedge clk)

begin

add_a<=add_b+1;

add_b<=add_a+1; //改变add_a与add_b

end

endmodule

3 ．仿真波形，见附件图；

实验二：时钟发生器

[实验原理]

时钟发生器clkgen利用外来时钟信号材料clk1，fetch，aluclk，送往CPU的其他部见。其中fetch是外部时钟，利用fetch的上升沿来触发CPU控制器开始执行一条指令，同时fetch信号还将控制地址多路器输出指令地址和数据地址；clk1信号用作指令寄存器、累加器、状态控制器的时钟信号；alu_clk则用于触发算术逻辑运算单元。

时钟信号：clk

中间信号：clk2=~clk2(clk1↑);clk4=~clk4(clk2↓)

输出信号：clk1=~clk;

fetch=~fetch(clk4↑);

alu_clk=clk2&clk4&!fetch

[实验步骤以及结果]

1．模块程序 clkgen.v

module clkgen(clk,clk1,fetch,alu_clk);

output clk1,fetch,alu_clk; //声明输出变量clk1,fetch,alu_clk

input clk; //声明时钟信号clk

reg clk2,clk4,fetch; //定义3个1位寄存器名为clk2,clk4,fetch

initial //初始化

begin

clk2=0;

clk4=1;

fetch=0;

end

assign clk1=~clk; //逻辑功能定义

assign alu_clk=clk2&clk4&!fetch;

always@(posedge clk1) //每当clk1的信号出现上升沿时，下列语句被不断重复执行

begin

clk2<=~clk2;

end

always@(negedge clk2)

begin

clk4<=~clk4;

end

always@(posedge clk4)

begin

fetch<=~fetch;

end

endmodule

2．测试程序clkgen_test.v

module clkgen_test;

reg clk;reg clk2;reg clk4;

clkgen clkgen(clk,clk1,fetch,alu_clk);

initial

begin

clk=1;

end

always #1 clk=~clk; //信号反相，#1表示延迟1个时间单位。

endmodule

3 ．仿真波形，见附录二。

实验六：数据控制器

[实验原理]

数据控制器的作用是控制累加器数据输出，由于数据总线是各种操作时传送数据的公共通道，不同的情况下传送不同的内容。累加器的数据只有在需要往RAM区或端口写时才允许输出，否则应呈现高阻态，以允许其他部件使用数据总线。数据控制其何时输出累加器的数据则由状态控制器输出的控制信号DAYA_ENA决定。

[实验步骤以及结果]

1 ．模块程序 datactl.v

module datactl(data,in,data_ena);

output[7:0] data;

input[7:0] in;

input data_ena; //声明输入输出

assign data=(data_ena)?in:8'bzzz_zzzz;//当data_ena为真，则允许输出，否则

//呈现高阻态

endmodule

2 ．测试程序datactl_test.v

module datactl_test;

wire [7:0] data;

reg [7:0] in;

reg data_ena;

datactl datactl(data,in,data_ena);

initial begin

data_ena=0;

in<=8'b0101_0101;

end

always #1 data_ena=~data_ena; //间隔2ns，data_ena改变

always #1 in=in+1; //间隔1ns，in的值在原来的基础上增1

endmodule

3 ．仿真波形，见附录二。

实验九：状态控制器

[实验原理]

状态控制器有两部分组成：（1）状态机；（2）状态控制器。

状态控制器接受复位信号RST，当RST有效时通过信号ENA使其为0，输入到状态机中停止状态机的工作。

状态机时CPU的控制核心，用于产生一系列的状态信号，启动或停止某些部件。CPU何时进行读指令读写I/O端口，RAM区等操作，都是由状态机来控制的。状态机的当前状态，由变量STATE记录，STATE的值就是当前这个指令周期中经过的时钟数。

指令周期由8个时钟周期组成，每个时钟周期都要完成固定的操作。

第0个时钟，因为CPU状态控制器的输出RD和LOAD_IR为高电平，其余均为低电平。指令寄存器寄存由ROM送来的高8位指令代码。

第1个时钟，与上一时钟相比只是INC_PC从0变为1，故PC增1，ROM送来低8位指令代码，指令寄存器寄存该8位代码。

第2个时钟，空操作。

第3个时钟，PC增1，指向下一条指令。若操作符为HLT，则输出信号HLT为高；如果操作符不为HLT，除了PC增1外，其他各控制线输出为零。

第4个时钟，若操作符号为ANDD,ADD,XORR或LDA，读相应地址的数据；若为JMP，将目的地址送给程序计数器；若为STO，输出累加器数据。

第5个时钟，若操作符为ANDD,ADD,XORR，算术运算器就进行相应的运算；若为LDA，就把数据通过算术运算器送给累加器；若为SKZ，线判断累加器的值是否为0，如果为，PC增1，否则保持原值；若为JMP，锁存目的地址；若为STO，将数据写入地址处。

第6个时钟，空操作。

第7个时钟，若操作符为SKZ且累加器值为0，则PC值再增加1，跳过一条指令，否则PC无变化。

[实验步骤以及结果]

1 ．模块程序 machinectl.v

module machinectl(ena,fetch,rst);

output ena;

input fetch,rst; //声明输入和输出

reg ena; //定义ena的寄存器

always @(posedge fetch or posedge rst)//当fetch或者rst信号出现上升沿时，

begin //根据rst的值确定ena的值

if(rst)

ena<=0;

else

ena<=1;

end

endmodule

machine.v

module machine(inc_pc,load_acc,load_pc,rd,wr,load_ir,datactl_ena,

halt,clk1,zero,ena,opcode);

output inc_pc,load_acc,load_pc,rd,wr,load_ir;

output datactl_ena,halt;

input clk1,zero,ena;

input [2:0] opcode;

reg inc_pc,load_acc,load_pc,rd,wr,load_ir;

reg datactl_ena,halt;

reg [2:0] state; //声明输入输出，以及定义寄存器

parameter //用parameter来定义标识符形式的常量

HLT=3'b000,

SKZ=3'b001,

ADD=3'b010,

ANDD=3'b011,

XORR=3'b100,

LDA=3'b101,

STO=3'b110,

JMP=3'b111;

always @(negedge clk1)

begin

if(!ena) //如果接收到复位信号RST，进行复位操作

begin

state<=3'b000;

{inc_pc,load_acc,load_pc,rd}<=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

ctl_cycle; //执行任务ctl_cycle

end

//------------task ctl_cycle------------任务开始---------

task ctl_cycle;

begin

casex(state) //case语句

0: //rd与load_ir均为高电平，其余为低电平。指令寄存器寄

Begin //存由ROM送来的高8位指令代码

{inc_pc,load_acc,load_pc,rd}<=4'b0001;

{wr,load_ir,datactl_ena,halt}<=4'b0100;

state<=1;

end

1: //INC_PC从0变为1，故PC增1，ROM送来低8位指令代码，

Begin //指令寄存器寄存该8位代码

{inc_pc,load_acc,load_pc,rd}<=4'b1001;

{wr,load_ir,datactl_ena,halt}<=4'b0100;

state<=2;

end

2: //空操作

Begin

{inc_pc,load_acc,load_pc,rd}<=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

state<=3;

end

3: //PC增1，指向下一条指令

begin

if(opcode==HLT) //若操作符为HLT，则输出信号HLT为高

begin

{inc_pc,load_acc,load_pc,rd}<=4'b1000;

{wr,load_ir,datactl_ena,halt}<=4'b0001;

end

else //否则其他各控制线输出为零。

begin

{inc_pc,load_acc,load_pc,rd}<=4'b1000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

state<=4;

end

begin

if(opcode==JMP) //若为JMP，将目的地址送给程序计数器

begin

{inc_pc,load_acc,load_pc,rd}<=4'b0010;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

if(opcode==ADD||opcode==ANDD||opcode==XORR||opcode==LDA)

begin //若操作符号为ANDD,ADD,XORR或LDA，读相应地址的数据

{inc_pc,load_acc,load_pc,rd}<=4'b0001;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

if(opcode==STO) //若为STO，输出累加器数据

begin {inc_pc,load_acc,load_pc,rd}<=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0010;

end

else

begin //其他则为空操作

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

state<=5;

end

begin

if(opcode==ADD||opcode==ANDD||opcode==XORR||opcode==LDA)

begin //若操作符为ANDD,ADD,XORR，算术运算器就进行相应的运算

{inc_pc,load_acc,load_pc,rd} <=4'b0101;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

if (opcode==SKZ&&zero==1) //若为SKZ，线判断累加器的值是否为0，如果为，

begin // PC增1，否则保持原值

{inc_pc,load_acc,load_pc,rd} <=4'b1000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

if(opcode==JMP) //若为JMP，锁存目的地址

begin

{inc_pc,load_acc,load_pc,rd} <=4'b1010;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

if(opcode==STO) //若为STO，将数据写入地址处

begin

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b1010;

end

else

begin //其他则为空操作

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

state<=6;

end

begin

if(opcode==STO) //若为STO，将数据写入地址处

begin

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0010;

end

else

if(opcode==ADD||opcode==ANDD||opcode==XORR||opcode==LDA)

begin //若操作符号为ANDD,ADD,XORR或LDA，读相应地址的数据

{inc_pc,load_acc,load_pc,rd} <=4'b0001;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else //其余为空操作

begin

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

state<=7;

end

begin

if(opcode==SKZ&&zero==1) //若操作符为SKZ且累加器值为0，

begin //则PC值再增加1，跳过一条指令，否则PC无变化

{inc_pc,load_acc,load_pc,rd} <=4'b1000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

else

begin

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

end

state<=0;

end

default: //缺省为空操作

begin

{inc_pc,load_acc,load_pc,rd} <=4'b0000;

{wr,load_ir,datactl_ena,halt}<=4'b0000;

state<=0;

end

endcase

end

endtask

//-------------end of task ctl_cycle-----任务结束-----------------

endmodule

control.v

module control(clk1, zero, fetch, rst, opcode, inc_pc, load_acc, load_pc, rd, wr, load_ir, halt, datactl_ena);

output inc_pc,load_acc,load_pc,rd,wr,load_ir;

output datactl_ena,halt;

input clk1,zero,fetch,rst;

input [2:0] opcode; //声明输入和输出

wire ena; //定义wire类型的ena

machinectl machinectl(.fetch(fetch),.rst(rst),.ena(ena));

machine machine(.clk1(clk1),.zero(zero),.opcode(opcode), .ena(ena),.inc_pc(inc_pc),.load_acc(load_acc),.load_pc(load_pc),

.rd(rd),.wr(wr),.load_ir(load_ir),.halt(halt),.datactl_ena(datactl_ena)); //将machinectl与machine连接起来

//machinectl.v与machine.v均为上层文件

endmodule

2 ．测试程序control_test.tst

module control_test;

wire inc_pc ,load_acc ,load_pc, rd, wr ,load_ir ,datactl_ena, halt;

wire clk1,fetch,alu_clock;

reg zero, rst;

reg [2:0] opcode;

reg clk;

clkgen clkgen(clk,clk1,fetch,alu_clk);

//用一个CLKGEN部件来产生clk1,fetch序列

control control(clk1, zero, fetch, rst, opcode, inc_pc, load_acc, load_pc, rd, wr, load_ir, halt, datactl_ena);

initial begin

rst=0;

clk=1;

zero=0;

opcode=3'b000;

end

always #1 clk=~clk; //产生时钟信号,1个时钟周期为2nm

always #160 zero=~zero;

always #16 opcode<=opcode+1;//经过8个时钟信号周期,opcode改变一次

endmodule

3 ．仿真波形，见附录二；

附录一：

实验十：CPU

源代码

包含：

accum.v累加器

adr.v地址多路器

alu.v算术运算器

clkgen.v 时钟发生器

control.v 状态控制器

machine.v

machinectl.v

counter.v程序计数器

datactl.v数据控制器

sig.v //生成信号CLK

addr_decode.v

ram.v

rom.v //外部器件

cpu.v //CPU集成

risc.v //CPU+外部器件

rscsys_ex1.v //测试仿真文件

test1.dat

test1.pro

test2.dat

test2.pro

test3.dat

test3.pro

cpu.v

module cpu(rst,clk,rd,wr,halt,addr,data);

input rst;

input clk;

output rd;

output wr;

output halt;

output [12:0] addr;

output [7:0] data;

wire clk1 ，fetch ，alu_clk;

wire [15:0] opc_iraddr;

wire [7:0] accum_data;

wire [7:0] alu_out;

wire zero，inc_pc， load_acc， load_pc，load_ir， datactl_ena;

wire [12:0] pc_addr;

wire [7:0] data_altera;

clkgen clkgen27p(.clk(clk), .clk1(clk1), .fetch(fetch), .alu_clk(alu_clk));

accum accum1p(.accum(accum_data), .data(alu_out), .ena(load_acc), .clk1(clk1), .rst(rst));

datactl datactl24p(.data(data_altera), .in(alu_out),.data_ena(datactl_ena));

adr adr22p(.addr(addr), .fetch(fetch), .ir_addr(opc_iraddr[12:0]), .pc_addr(pc_addr));

counter counter11p( .pc_addr(pc_addr), .ir_addr(opc_iraddr[12:0]), .load(load_pc), .clock(inc_pc), .rst(rst));

alu alu15p(.alu_out(alu_out), .zero(zero), .data(data_altera), .accum(accum_data), .alu_clk(alu_clk), .opcode(opc_iraddr[15:13]));

control control12p(.clk1(clk1), .zero(zero), .fetch(fetch), .rst(rst), .opcode(opc_iraddr[15:13]),.inc_pc(inc_pc), .load_acc(load_acc), .load_pc(load_pc), .rd(rd), .wr(wr), .load_ir(load_ir), .halt(halt), .datactl_ena(datactl_ena));

assign data = data_altera;

endmodule

sig.v

module sig(clk);

output clk;

reg clock;

initial

begin

clock=0;

end

assign clk=clock;

always #1 clock=~clock;

endmodule

Risc.v

module risc(rst);

reg rst;

wire clk, read, write, halt;

wire [7:0] data;

wire [12:0] addr;

wire ramsel, romsel;

sig sys_sig5p(.clk(clk));

cpu sys_rsc4p(.rst(rst),.clk(clk),.rd(read),.wr(write),.halt(halt),.addr(addr[12:0]),.data(data[7:0]));

ram sys_ram3p(.data(data[7:0]),.addr(addr[9:0]), .ena(ramsel), .read(read), .write(write));

rom sys_rom1p(.addr(addr[12:0]),.ena(romsel), .read(read), .data(data[7:0]));

addr_decode sys_addr_decode2p(.addr(addr[12:0]), .romsel(romsel), .ramsel(ramsel));

endmodule

recsya_ex1.v

//------------------------rscsys_ex1.v-------------------------------

`define VLP vlog1

`define PERIOD 100 //matches clkgen/vlog_behaviorial/verilog.v

module rscsys_ex1;

reg reset_req;

integer test;

reg [(3*8):0] mnemonic; //array that holds 3 8-bit ASCII characters

reg [12:0] PC_addr,IR_addr;

assign `VLP.rst =reset_req;

risc vlog1(rst);

initial //display time in nanoseconds

begin

$timeformat(-9,1,"ns",12);

display_debug_message;

end

always @(posedge `VLP.halt) // STOP when HALT instruction decoded

begin

#500

$display("\n************************************");

$display("*A HALT INSTRUCTION WAS PROCESSED!!! *");

$display("************************************\n");

display_debug_message;

end

task display_debug_message;

begin

$display("\n************************************");

$display("*THE FOLLOWING DEBUG TASK ARE AVAILABLE: *");

$display("* test1 to load the 1st diagnostic program. *");

$display("* test2 to load the 2nd diagnostic program. *");

$display("* test3 to load the Fibonacci program.*");

$display("************************************\n");

test1;

test2;

test3;

$stop;

end

endtask

task test1;

begin

test = 0;

disable MONITOR;

$readmemb("test1.pro",`VLP.sys_rom1p.memory);

$display("rom loaded successfully!");

$readmemb("test1.dat",`VLP.sys_ram3p.ram);

$display("ram loaded successfully!");

#1 test = 1;

sys_reset;

end

endtask

task test2;

begin

test = 0;

disable MONITOR;

$readmemb("test2.pro",`VLP.sys_rom1p.memory);

$display("rom loaded successfully!");

$readmemb("test2.dat",`VLP.sys_ram3p.ram);

$display("ram loaded successfully!");

#1 test = 2;

sys_reset;

end

endtask

task test3;

begin

test = 0;

disable MONITOR;

$readmemb("test3.pro",`VLP.sys_rom1p.memory);

$display("rom loaded successfully!");

$readmemb("test3.dat",`VLP.sys_ram3p.ram);

$display("ram loaded successfully!");

#1 test = 3;

sys_reset;

end

endtask

task sys_reset;

begin

reset_req = 0;

#(`PERIOD * 0.7) reset_req = 1;

#(1.5 * `PERIOD) reset_req = 0;

end

endtask

always @(test)

begin: MONITOR

case (test)

1: begin // display results when running test 1

$display("\n*** RUNNING CPUtest1 ----The Basic CPU Diagnostic Program ***");

$display("\n TIME PC INSTR ADDR DATA");$display("-------");

while(test==1)

@(`VLP.sys_rsc4p.adr22p.pc_addr)

if((`VLP.sys_rsc4p.adr22p.pc_addr%2==1)&&(`VLP.sys_rsc4p.adr22p.fetch==1))

begin

#60 PC_addr<=`VLP.sys_rsc4p.adr22p.pc_addr-1;

IR_addr<=`VLP.sys_rsc4p.adr22p.ir_addr;

#340 $strobe("%t %h %s %h %h",

$time,PC_addr,mnemonic,IR_addr,`VLP.data);

end

2:begin

$display("\n***RUNNING CPUtest2-The ad cpu program***");

$display("\n time pc instr addr data");

$display("-------------------------");

while(test==2)

@(`VLP.sys_rsc4p.adr22p.pc_addr)

if((`VLP.sys_rsc4p.adr22p.pc_addr%2==1)&&(`VLP.sys_rsc4p.adr22p.fetch==1))

begin

#60 PC_addr<=`VLP.sys_rsc4p.adr22p.pc_addr-1;

IR_addr<=`VLP.sys_rsc4p.adr22p.ir_addr;

#340 $strobe("%t %h %s %h %h",

$time,PC_addr,mnemonic,IR_addr,`VLP.data);

end

3:begin

$display("\n***RUNNING CPUtest3- an executable program***");

$display("***this pro should calculate the fibaci");

$display("***no sequence from 0 to 144***");

$display("\nTIME FIBOCI NO");

$display("-------------------------");

while(test==3)

begin

wait(`VLP.sys_rsc4p.alu15p.opcode==3'h1)

$strobe("%t %d",$time,`VLP.sys_ram3p.ram[10'h2]);

wait(`VLP.sys_rsc4p.alu15p.opcode!=3'h1);

end

endcase

end

always@(`VLP.sys_rsc4p.alu15p.opcode)

case(`VLP.sys_rsc4p.alu15p.opcode)

3'h0 :mnemonic="HLT";

3'h1 :mnemonic="SKZ";

3'h2 :mnemonic="ADD";

3'h3 :mnemonic="AND";

3'h4 :mnemonic="XOR";

3'h5 :mnemonic="LDA";

3'h6 :mnemonic="STO";

3'h7 :mnemonic="JMP";

default : mnemonic="???";

endcase

endmodule

晒：《计算机组成实验报告》

你可能感兴趣的:(晒：《计算机组成实验报告》)