实验十二寄存器及寄存器堆设计
姓名：洪至远学号：3100104624 专业：工信1015
课程名称：逻辑与计算机设计基础实验同组学生姓名：谢志聪
实验时间：2011年12月13日实验地点：紫金港东4-509 指导老师：蒋方炎，陆汉权一、实验目的和要求
●掌握寄存器、锁存器的工作原理及设计方法
●掌握寄存器堆的工作原理及设计方法
●了解计算机中寄存器及寄存器堆的概念
二、实验内容和原理
实验内容:
实现含由16个16位寄存器构成的寄存器堆，要求：
?支持寄存器地址选择
?支持写入任意16位值
?支持读取寄存器的值
增加到xCal中。
12.1 寄存器
寄存器是计算机常用的基本器件，结构如下图：
D0D1D2D3D4D5D6D7
1、 由同一信号控制的一组相互并联的触发器构成
2、 包含存储、处理和传输，可构成寄存器组使用
3、上图所示，为边沿D 触发器构成的8位基本寄存器的结构
12.2 锁存器
锁存器由多个一位锁存器/触发器并联构成，它：
1、 一般采用电平控制锁存：
2、 高电平时置入数据
3、 低电平时锁存数据，并指示数据稳定
4、 带使能端的RS 触发器实现的锁存器
12.3 寄存器组
寄存器组是多个寄存器组成的集合 1、寄存器写：寄存器地址→变量译码器
2、寄存器读：寄存器地址→数据选择器
三、主要仪器设备
1. 装有ISE 的计算机系统 1台
2. Spartan III 实验板 1套
锁存
2锁存器波形图
数据选择器
变量译码器
m 01
n -2n -1
3寄存器组结构
四、操作方法与实验步骤
实验步骤：
(1)、设计16个16位寄存器构成的寄存器堆。
(2)、修改相关代码。
(3)、修改ucf文件。
(4)、下载并验证。
实验代码如下：
module top(
input wire clk,
input wire [3:0]btn_in,
input wire[7:0]switch,
output wire [3:0]anode,
output wire [7:0]segment,
output wire Rc
);
//variable definition: op1, op2,disp_num…
reg [15:0]display_num;
wire [15:0]op1,op2;
wire [3:0]btn_out;
wire [15:0] result, reg_out;
wire [15:0] disp_counter,disp_clock;
wire clk_1s;
initial begin
display_num=16'b0000_0000_0000_0000;
end
display m0(clk,display_num, anode, segment);//display module
calculate_result m1(btn_out[3:0], op1, op2, result); //calculate result
create_oprands m2(switch[3:0], btn_out[3:0], switch[7:4], result, op1, op2, reg_out);
pbdebounce b0(clk, btn_in[0], btn_out[0]);
pbdebounce b1(clk, btn_in[1], btn_out[1]);
pbdebounce b2(clk, btn_in[2], btn_out[2]);
pbdebounce b3(clk, btn_in[3], btn_out[3]);
clock_1s m4(clk, clk_1s);
counter_16_rev m5((clk_1s & btn_out[0]), switch[2], disp_counter, Rc); clock_24h m6(clk_1s, disp_clock);
always @* begin
case (switch[1:0])
2'b01:begin //operand 1
display_num = op1;
end
2'b10:begin //operand 2
display_num = op2;
end
2'b00:begin //result
if(btn_out[1]==1 && switch[3] == 1)
display_num = reg_out;
else
display_num = result;
end
2'b11:begin //counter & clock
if(btn_out[1:0] == 2'b01)
display_num = disp_counter;
else if(btn_out[1:0] == 2'b10)
display_num = disp_clock;
end
endcase
end
endmodule
module create_oprands
(input wire [3:0]switch,input wire [3:0]btn_out,input wire [3:0]address,input wire[15:0]reg_in3,output reg [15:0]op_out1,
output reg [15:0]op_out2,output wire [15:0]reg_out3);
reg [15:0]op1;
reg [15:0]op2;
wire [15:0] out_shift1,out_shift2,reg_out1,reg_out2;
reg[15:0] reg_in1,reg_in2;
initial op1 <= 16'b0000_0000_0000_0000;
initial op2 <= 16'b0000_0000_0000_0000;
always @(posedge btn_out[0])begin
if(switch == 2'b01) op1[3:0]<= op1[3:0] + 4'd1;
else if(switch == 2'b10) op2[3:0]<= op2[3:0] + 4'd1;
end
always @(posedge btn_out[1])begin
if(switch == 2'b01) op1[7:4]<= op1[7:4] + 4'd1;
else if(switch == 2'b10) op2[7:4]<= op2[7:4] + 4'd1;
end
always @(posedge btn_out[2])begin
if(switch == 2'b01) op1[11:8]<= op1[11:8] + 4'd1;
else if(switch == 2'b10) op2[11:8]<= op2[11:8] + 4'd1;
end
always @(posedge btn_out[3])begin
if(switch == 2'b01) op1[15:12]<= op1[15:12] + 4'd1;
else if(switch == 2'b10) op2[15:12]<= op2[15:12] + 4'd1;
end
shift_reg_16 m1(btn_out[2:0], switch[3:0], address, out_shift1, out_shift2);
regfile_16 m2(btn_out[0], btn_out[1], switch[1:0], address, reg_in1, reg_in2, reg_in3, reg_out1, reg_out2, reg_out3);
always @* begin
if(switch[1:0] == 2'b01)begin
case(switch[3:2])
2'b00:op_out1 = op1;
2'b01:op_out1 = out_shift1;
default: if(btn_out[1] == 1'b1) op_out1 = reg_out1;
endcase
reg_in1 = op_out1;
end
else if(switch[1:0] == 2'b10) begin
case(switch[3:2])
2'b00:op_out2 = op2;
2'b01:op_out2 = out_shift2;
default:
if(btn_out[1] == 1'b1) op_out2 = reg_out2;
endcase
reg_in2 = op_out2;
end
end
endmodule
module mux_16_1(input wire rclk, input wire [3:0]address,input wire [15:0]regQ0, regQ1, regQ2, regQ3,regQ4, regQ5,regQ6,regQ7, regQ8, regQ9, regQ10, regQ11, regQ12, regQ13, regQ14,regQ15,output reg [15:0]data_out);
always @*begin
if(rclk==1'b1)
case(address[3:0])
4'b0000:data_out=regQ0;
4'b0001:data_out=regQ1;
4'b0010:data_out=regQ2;
4'b0011:data_out=regQ3;
4'b0100:data_out=regQ4;
4'b0101:data_out=regQ5;
4'b0110:data_out=regQ6;
4'b0111:data_out=regQ7;
4'b1000:data_out=regQ8;
4'b1001:data_out=regQ9;
4'b1010:data_out=regQ10;
4'b1011:data_out=regQ11;
4'b1100:data_out=regQ12;
4'b1101:data_out=regQ13;
4'b1110:data_out=regQ14;
4'b1111:data_out=regQ15;
endcase
else
data_out=16'h0000;
end
endmodule
module decode_4_16(input wire[3:0] address,input wire wclk,output
reg[15:0] Yi);
always @*begin
if(wclk==1'b1)
case(address[3:0])
4'b0000:Yi=16'b0000000000000001;
4'b0001:Yi=16'b0000000000000010;
4'b0010:Yi=16'b0000000000000100;
4'b0011:Yi=16'b0000000000001000;
4'b0100:Yi=16'b0000000000010000;
4'b0101:Yi=16'b0000000000100000;
4'b0110:Yi=16'b0000000001000000;
4'b0111:Yi=16'b0000000010000000;
4'b1000:Yi=16'b0000000100000000;
4'b1001:Yi=16'b0000001000000000;
4'b1010:Yi=16'b0000010000000000;
4'b1011:Yi=16'b0000100000000000;
4'b1100:Yi=16'b0001000000000000;
4'b1101:Yi=16'b0010000000000000;
4'b1110:Yi=16'b0100000000000000;
4'b1111:Yi=16'b1000000000000000;
endcase
else
Yi=16'h0000;
end
endmodule
module btn_increment(btn, switch, op1, op2);
input wire [1:0] switch;
input wire [3:0] btn;
output reg [15:0] op1;
output reg [15:0] op2;
initial begin
op1<=16'h1234; //op1,op2初始化
op2<=16'h7890;
end
always @(posedge btn[0])begin
if(switch == 4'b01) op1[3:0] <= op1[3:0] + 4'd1;
else if(switch == 4'b10) op2[3:0] <= op2[3:0] + 4'd1;
end
always @(posedge btn[1])begin
if(switch == 4'b01) op1[7:4] <= op1[7:4] + 4'd1;
else if(switch == 4'b10) op2[7:4] <= op2[7:4] + 4'd1;
end
always @(posedge btn[2])begin
if(switch == 4'b01) op1[11:8] <= op1[11:8] + 4'd1;
else if(switch == 4'b10) op2[11:8] <= op2[11:8] + 4'd1;
end
always @(posedge btn[3])begin
if(switch == 4'b01) op1[15:12] <= op1[15:12] + 4'd1;
else if(switch == 4'b10) op2[15:12] <= op2[15:12] + 4'd1;
end
endmodule
module regfile(input wire wclk, rclk, input wire [3:0]address, input wire [15:0] data_in, output wire[15:0] data_out);
wire [15:0] clk;
wire [15:0] Yi;
wire [15:0] regQ0;
wire [15:0] regQ1;
wire [15:0] regQ2;
wire [15:0] regQ3;
wire [15:0] regQ4;
wire [15:0] regQ5;
wire [15:0] regQ6;
wire [15:0] regQ7;
wire [15:0] regQ8;
wire [15:0] regQ9;
wire [15:0] regQ10;
wire [15:0] regQ11;
wire [15:0] regQ12;
wire [15:0] regQ13;
wire [15:0] regQ14;
wire [15:0] regQ15;
assign clk[15:0] = {16{wclk}} & Yi;
decode_4_16 M0(address[3:0],wclk,Yi);
mux_16_1 M1(rclk, address[3:0],
regQ0, regQ1, regQ2, regQ3,
regQ4, regQ5, regQ6, regQ7,
regQ8, regQ9, regQ10,regQ11,
regQ12,regQ13,regQ14,regQ15,
data_out);
register16 R0(clk[0], data_in, regQ0),
R1(clk[1], data_in, regQ1),
R2(clk[2], data_in, regQ2),
R3(clk[3], data_in, regQ3),
R4(clk[4], data_in, regQ4),
R5(clk[5], data_in, regQ5),
R6(clk[6], data_in, regQ6),
R7(clk[7], data_in, regQ7),
R8(clk[8], data_in, regQ8),
R9(clk[9], data_in, regQ9),
R10(clk[10], data_in, regQ10),
R11(clk[11], data_in, regQ11),
R12(clk[12], data_in, regQ12),
R13(clk[13], data_in, regQ13),
R14(clk[14], data_in, regQ14),
R15(clk[15], data_in, regQ15);
endmodule
module regfile_16 (input wire wclk, rclk, input wire [1:0]switch,
input wire [3:0]address, input wire [15:0]op1_in, input wire [15:0]op2_in,
input wire [15:0]result_in,output reg [15:0]op1_out, output reg [15:0]op2_out,
output reg [15:0]result_out);
wire [15:0] op_o;
wire [1:0] btn_op1;
wire [1:0] btn_op2;
reg [15:0] op_in;
regfile rf(wclk, rclk, address, op_in, op_o);
always @* begin
if(switch[1:0] == 2'b01) begin
op1_out = op_o;
op_in = op1_in;
end
else if(switch[1:0] == 2'b10) begin
op2_out = op_o;
op_in = op2_in;
end
else if(switch[1:0] == 2'b00) begin
result_out = op_o;
op_in = result_in;
end
end
endmodule
module register16(clk, D, Q);
input clk;
input [15:0]D;
output [15:0] Q;
wire clk1;
BUFG cc(clk1,clk);
FD FDQ0(.C(clk),.D(D[0]),.Q(Q[0])),
FDQ1(.C(clk),.D(D[1]),.Q(Q[1])),
FDQ2(.C(clk),.D(D[2]),.Q(Q[2])),
FDQ3(.C(clk),.D(D[3]),.Q(Q[3])),
FDQ4(.C(clk),.D(D[4]),.Q(Q[4])),
FDQ5(.C(clk),.D(D[5]),.Q(Q[5])),
FDQ6(.C(clk),.D(D[6]),.Q(Q[6])),
FDQ7(.C(clk),.D(D[7]),.Q(Q[7])),
FDQ8(.C(clk),.D(D[8]),.Q(Q[8])),
FDQ9(.C(clk),.D(D[9]),.Q(Q[9])),
FDQ10(.C(clk),.D(D[10]),.Q(Q[10])),
FDQ11(.C(clk),.D(D[11]),.Q(Q[11])),
FDQ12(.C(clk),.D(D[12]),.Q(Q[12])),
FDQ13(.C(clk),.D(D[13]),.Q(Q[13])),
FDQ14(.C(clk),.D(D[14]),.Q(Q[14])),
FDQ15(.C(clk),.D(D[15]),.Q(Q[15]));
endmodule
module calculate_result(btn,op1,op2,result);
input [3:0] btn;
input [15:0] op1;
input [15:0] op2;
output reg [15:0] result;
wire [15:0] add_sub_result;//calculate_result m1(btn_out[3:0], op1, op2, result); //calculate result
adder_16bits m0(op1, op2, btn[1], add_sub_result, co);
always @(btn) begin
if(btn[0] ==1 || btn[1] == 1)
result = add_sub_result;
if(btn[2] == 1)
result = op1 & op2;
if(btn[3] == 1)
result = op1 | op2;
end
endmodule
module adder_16bits(A, B, Ctr, S, Co);
input wire [16:1] A, B;
input wire Ctr;
output wire [16:1] S;
output wire Co;
wire [16:1] Bo;
wire [15:1] Ctemp;
assign Bo = {16{Ctr}} ^ B;
adder_1bit A1_1(A[1], Bo[1], Ci,S[1],Ctemp[1]),
A1_2(A[2], Bo[2], Ctemp[1],S[2],Ctemp[2]),
A1_3(A[3], Bo[3], Ctemp[2],S[3],Ctemp[3]),
A1_4(A[4], Bo[4], Ctemp[3],S[4],Ctemp[4]),
A1_5(A[5], Bo[5], Ctemp[4],S[5],Ctemp[5]),
A1_6(A[6], Bo[6], Ctemp[5],S[6],Ctemp[6]),
A1_7(A[7], Bo[7], Ctemp[6],S[7],Ctemp[7]),
A1_8(A[8], Bo[8], Ctemp[7],S[8],Ctemp[8]),
A1_9(A[9], Bo[9], Ctemp[8],S[9],Ctemp[9]),
A1_10(A[10], Bo[10], Ctemp[9],S[10],Ctemp[10]),
A1_11(A[11], Bo[11], Ctemp[10],S[11],Ctemp[11]),
A1_12(A[12], Bo[12], Ctemp[11],S[12],Ctemp[12]),
A1_13(A[13], Bo[13], Ctemp[12],S[13],Ctemp[13]),
A1_14(A[14], Bo[14], Ctemp[13],S[14],Ctemp[14]),
A1_15(A[15], Bo[15], Ctemp[14],S[15],Ctemp[15]),
A1_16(A[16], Bo[16], Ctemp[15],S[16],Co);
endmodule
module adder_1bit( input a , input b, input ci, output s, output co);
and (c1,a,b), (c2,b,ci), (c3,a,ci);
xor (s1,a,b), (s,s1,ci);
or (co,c1,c2,c3);
endmodule
module display(input wire clk,input wire [15:0] digit,output reg [ 3:0] node, output reg [ 7:0] segment);
reg [3:0] code = 4'b0;
reg [15:0] count = 15'b0;
always @(posedge clk) begin
case (count[15:14])
2'b00 : begin
node <= 4'b1110;
code <= digit[3:0];
end
2'b01 : begin
node <= 4'b1101;
code <= digit[7:4];
end
2'b10 : begin
node <= 4'b1011;
code <= digit[11:8];
end
2'b11 : begin
node <= 4'b0111;
code <= digit[15:12];
end
endcase
case (code)
4'b0000: segment <= 8'b11000000;
4'b0001: segment <= 8'b11111001;
4'b0010: segment <= 8'b10100100;
4'b0011: segment <= 8'b10110000;
4'b0100: segment <= 8'b10011001;
4'b0101: segment <= 8'b10010010;
4'b0110: segment <= 8'b10000010;
4'b0111: segment <= 8'b11111000;
4'b1000: segment <= 8'b10000000;
4'b1001: segment <= 8'b10010000;
4'b1010: segment <= 8'b10001000;
4'b1011: segment <= 8'b10000011;
4'b1100: segment <= 8'b11000110;
4'b1101: segment <= 8'b10100001;
4'b1110: segment <= 8'b10000110;
4'b1111: segment <= 8'b10001110;
default: segment <= 8'b00000000;
endcase
count <= count + 1;
end
endmodule
module pbdebounce
(input wire clk,
input wire button,
output reg pbreg);
reg [7:0] pbshift;
wire clk_1ms;
timer_1ms m0(clk, clk_1ms);
always@(posedge clk_1ms) begin
pbshift=pbshift<<1;//左移1位
pbshift[0]=button;
if (pbshift==0)
pbreg=0;
if (pbshift==8'hFF)// pbshift八位全为1 pbreg=1;
end
endmodule
module timer_1ms(input wire clk,output reg clk_1ms);
reg [15:0] cnt;
initial begin
cnt [15:0] <=0;
clk_1ms <= 0;
end
always@(posedge clk)
if(cnt>=25000) begin
cnt<=0;
clk_1ms <= ~clk_1ms;
end
else begin
cnt<=cnt+1;
end
endmodule
module shift_reg_16( btn, switch, p_in, out_shift1, out_shift2);
input wire [2:0] btn;
input wire [3:0] switch;
input wire [3:0] p_in;
output reg [15:0] out_shift1;
output reg [15:0] out_shift2;
wire [0:15] Q1,Q2;
wire clk1 = btn[1]&switch[2]&~switch[3]&switch[0]&~switch[1];
wire clk2 = btn[1]&switch[2]&~switch[3]&switch[1]&~switch[0];
shift_reg sr1(clk1, btn[2], btn[0], {4{p_in[0],p_in[1],p_in[2],p_in[3]}}, Q1);
shift_reg sr2(clk2, btn[2], btn[0], {4{p_in[0],p_in[1],p_in[2],p_in[3]}}, Q2);
always @* begin
if(switch == 4'b0101) out_shift1[15:0] = Q1[0:15];
else if(switch == 4'b0110) out_shift2[15:0] = Q2[0:15];
end
endmodule
module shift_reg(clk, S, s_in, p_in, Q);
input wire clk, S, s_in;
input wire [15:0] p_in;
output wire [15:0] Q;
wire [15:0] D;
wire nS;
FD FDQ0(.C(clk), .D(D[0]), .Q(Q[0])),
FDQ1(.C(clk), .D(D[1]), .Q(Q[1])),
FDQ2(.C(clk), .D(D[2]), .Q(Q[2])),
FDQ3(.C(clk), .D(D[3]), .Q(Q[3])),
FDQ4(.C(clk), .D(D[4]), .Q(Q[4])),
FDQ5(.C(clk), .D(D[5]), .Q(Q[5])),
FDQ6(.C(clk), .D(D[6]), .Q(Q[6])),
FDQ7(.C(clk), .D(D[7]), .Q(Q[7])),
FDQ8(.C(clk), .D(D[8]), .Q(Q[8])),
FDQ9(.C(clk), .D(D[9]), .Q(Q[9])),
FDQ10(.C(clk), .D(D[10]), .Q(Q[10])),
FDQ11(.C(clk), .D(D[11]), .Q(Q[11])),
FDQ12(.C(clk), .D(D[12]), .Q(Q[12])),
FDQ13(.C(clk), .D(D[13]), .Q(Q[13])),
FDQ14(.C(clk), .D(D[14]), .Q(Q[14])),
FDQ15(.C(clk), .D(D[15]), .Q(Q[15]));
OR2 D0_L(.I0(L_0), .I1(R_0), .O(D[0])),
D1_L(.I0(L_1), .I1(R_1), .O(D[1])),
D2_L(.I0(L_2), .I1(R_2), .O(D[2])),
D3_L(.I0(L_3), .I1(R_3), .O(D[3])),
D4_L(.I0(L_4), .I1(R_4), .O(D[4])),
D5_L(.I0(L_5), .I1(R_5), .O(D[5])),
D6_L(.I0(L_6), .I1(R_6), .O(D[6])),
D7_L(.I0(L_7), .I1(R_7), .O(D[7])),
D8_L(.I0(L_8), .I1(R_8), .O(D[8])),
D9_L(.I0(L_9), .I1(R_9), .O(D[9])),
D10_L(.I0(L_10), .I1(R_10), .O(D[10])),
D11_L(.I0(L_11), .I1(R_11), .O(D[11])),
D12_L(.I0(L_12), .I1(R_12), .O(D[12])),
D13_L(.I0(L_13), .I1(R_13), .O(D[13])),
D14_L(.I0(L_14), .I1(R_14), .O(D[14])),
D15_L(.I0(L_15), .I1(R_15), .O(D[15]));
AND2 L0_L(.I0(Q[1]), .I1(nS), .O(L_0)),
L1_L(.I0(Q[2]), .I1(nS), .O(L_1)),
L2_L(.I0(Q[3]), .I1(nS), .O(L_2)),
L3_L(.I0(Q[4]), .I1(nS), .O(L_3)),
L4_L(.I0(Q[5]), .I1(nS), .O(L_4)),
L5_L(.I0(Q[6]), .I1(nS), .O(L_5)),
L6_L(.I0(Q[7]), .I1(nS), .O(L_6)),
L7_L(.I0(Q[8]), .I1(nS), .O(L_7)),
L8_L(.I0(Q[9]), .I1(nS), .O(L_8)),
L9_L(.I0(Q[10]), .I1(nS), .O(L_9)),
L10_L(.I0(Q[11]), .I1(nS), .O(L_10)),
L11_L(.I0(Q[12]), .I1(nS), .O(L_11)),
L12_L(.I0(Q[13]), .I1(nS), .O(L_12)),
L13_L(.I0(Q[14]), .I1(nS), .O(L_13)),
L14_L(.I0(Q[15]), .I1(nS), .O(L_14)),
L15_L(.I0(s_in), .I1(nS), .O(L_15));
AND2 R0_L(.I0(p_in[0]), .I1(S), .O(R_0)),
R1_L(.I0(p_in[1]), .I1(S), .O(R_1)),
R2_L(.I0(p_in[2]), .I1(S), .O(R_2)),
R3_L(.I0(p_in[3]), .I1(S), .O(R_3)),
R4_L(.I0(p_in[4]), .I1(S), .O(R_4)),
R5_L(.I0(p_in[5]), .I1(S), .O(R_5)),
R6_L(.I0(p_in[6]), .I1(S), .O(R_6)),
R7_L(.I0(p_in[7]), .I1(S), .O(R_7)),
R8_L(.I0(p_in[8]), .I1(S), .O(R_8)),
R9_L(.I0(p_in[9]), .I1(S), .O(R_9)),
R10_L(.I0(p_in[10]), .I1(S), .O(R_10)),
R11_L(.I0(p_in[11]), .I1(S), .O(R_11)),
R12_L(.I0(p_in[12]), .I1(S), .O(R_12)),
R13_L(.I0(p_in[13]), .I1(S), .O(R_13)),
R14_L(.I0(p_in[14]), .I1(S), .O(R_14)),
R15_L(.I0(p_in[15]), .I1(S), .O(R_15));
INV nS_L(.I(S), .O(nS));
endmodule
module clock_24h(clk_sec, digit);
output wire[15:0] digit;
input wire clk_sec;
wire [3:0] min_low, min_high, hour_low, hour_high;
wire clk_hour, clk_day;
m_gen_min MIN (clk_sec, clk_hour, min_low, min_high);
m_gen_hour HOUR (clk_hour, clk_day, hour_low, hour_high);
assign digit[15:12] = hour_high[3:0];
assign digit[11:8] = hour_low[3:0];
assign digit[7:4] = min_high[3:0];
assign digit[3:0] = min_low[3:0];
endmodule
module counter_16_rev(clk, s, cnt, Rc);
input wire clk, s;
output reg [15:0] cnt;
output wire Rc;
assign Rc = (~s & (~|cnt)) | (s & (&cnt));
always@(posedge clk) begin
if (s)//s==1时，正向计数
cnt <= cnt+1;
else //s==0时，反向计数
cnt <= cnt-1;
end
endmodule
module m_gen_min(clk_sec, clk_hour, min_low, min_high); input wire clk_sec;//秒时钟
output reg clk_hour;//小时时钟
output reg[3:0] min_low, min_high;//分钟低位，分钟高位
reg [15:0] cnt;
always @(posedge clk_sec) begin
if (clk_hour == 1)
clk_hour = 0;
// if (cnt == 59) begin
// cnt = 0;
if (min_low == 9) begin//分钟低位十进制，高位六进制
min_low = 0; /* base 10 */
if (min_high == 5) begin
min_high = 0; /* base 6 */
clk_hour = 1;
end else
min_high = min_high + 1;
end else
min_low = min_low + 1;
// end else
// cnt = cnt + 1;
end
endmodule
module m_gen_hour(clk_hour, clk_day, hour_low, hour_high); input wire clk_hour;//小时时钟
output reg clk_day;//天时钟
output reg[3:0] hour_low, hour_high;//小时低位，小时高位
always @(posedge clk_hour)
if (hour_low == 3 && hour_high == 2) begin
//23小时，再来一个小时时钟就进位为1天。
hour_low = 0;
hour_high = 0;
clk_day = ~clk_day;
end else if (hour_low == 9) begin
hour_low = 0;//小时低位为十进制
hour_high = hour_high + 1;
end else
hour_low = hour_low + 1;
endmodule
module clock_1s(clk, clk_1s);
input wire clk;
output reg clk_1s;
reg [31:0] cnt;
always@(posedge clk)
begin
if (cnt < 25_000_000)
begin//25M*(1/50M)S=0.5S
cnt<=cnt+1;
end else begin
cnt <= 0;
clk_1s<= ~clk_1s;// clk_1s==1的时间=0.5s end // clk_1s==0的时间=0.5s end //周期T=1S
endmodule
实验引脚分配代码如下：
NET "clk" LOC = "T9";
NET "btn_in[0]" LOC = "M13";
NET "btn_in[1]" LOC = "M14";
NET "btn_in[2]" LOC = "L13";
NET "btn_in[3]" LOC = "L14";
NET "anode[3]" LOC = "E13";
NET "anode[2]" LOC = "F14";
NET "anode[1]" LOC = "G14";
NET "anode[0]" LOC = "D14";
NET "segment[0]" loc = "E14";
NET "segment[1]" loc = "G13";
NET "segment[2]" loc = "N15";
NET "segment[3]" loc = "P15";
NET "segment[4]" loc = "R16";
NET "segment[5]" loc = "F13";
NET "segment[6]" loc = "N16";
NET "segment[7]" loc = "P16";
NET "switch[0]" loc = "F12";
NET "switch[1]" loc = "G12";
NET "switch[2]" loc = "H14";
NET "switch[3]" loc = "H13";
NET "switch[4]" loc = "J14";
NET "switch[5]" loc = "J13";
NET "switch[6]" loc = "K14";
NET "switch[7]" loc = "K13";
net "btn_in[0]" clock_dedicated_route = false; net "btn_in[1]" clock_dedicated_route = false; net "btn_in[2]" clock_dedicated_route = false; net "btn_in[3]" clock_dedicated_route = false;
五、实验结果与分析
操作过程：
?当sw[3]=1时，sw[7:4]为读写地址
?– sw[1:0]=01时，btn[0]为A操作数写入对应地址，btn[1]为把对应内容读到操作数A。
?– sw[1:0]=10时，btn[0]为B操作数写入对应地址，btn[1]为把对应内容读到操作数B。
?– sw[1:0]=00时，btn[0]为结果写入对应地址，btn[1]为把对应内容读到结果。
实验结果演示：
? 1.将A设为1234，存到1号寄存器
? 2.将B设为5678，存到4号寄存器
? 3.计算结果（加法），写入第15号寄存器。
? 4.读出1号寄存器的值读到结果
? 5.读出4号寄存器的值读到A
? 6.读出15号寄存器的值读到B
分析：
寄存器的功能十分重要，CPU对存储器中的数据进行处理时，往往先把数据取到内部寄存器中，而后再作处理。外部寄存器是计算机中其它一些部件上用于暂存数据的寄存器，它与CPU之间通过“端口”交换数据，外部寄存器具有寄存器和内存储器双重特点。实验通过对寄存器的一系列操作，实现了寄存器的读入、读出及运算，也让我更直观的理解了寄存器在计算机中的作用。
六、讨论、心得
通过这次试验，我掌握了寄存器、锁存器的工作原理及设计方法，同时，还掌握了寄存器堆的工作原理及设计方法，通过实验的预习工作，我还了解了计算机中寄存器及寄存器堆的概念。在这次实验的代码完成过程中，进一步巩固和提高了我对V erilog的使用熟悉程度，获益匪浅。
寄存器实验报告
一、实验目的 1. 了解寄存器的分类方法，掌握各种寄存器的工作原理； 2. 学习使用V erilog HDL 语言设计两种类型的寄存器。 二、实验设备 PC 微机一台，TD-EDA 实验箱一台，SOPC 开发板一块。 三、实验内容 寄存器中二进制数的位可以用两种方式移入或移出寄存器。第一种方法是以串行的方式将数据每次移动一位，这种方法称之为串行移位(Serial Shifting)，线路较少，但耗费时间较多。第二种方法是以并行的方式将数据同时移动，这种方法称之为并行移位(Parallel Shifting)，线路较为复杂，但是数据传送的速度较快。因此，按照数据进出移位寄存器的方式，可以将移位寄存器分为四种类型：串行输入串行输出移位寄存器(Serial In- Serial Out)、串行输入并行输出移位寄存器(Serial In- Parallel Out)、并行输入串行输出移位寄存器(Parallel In- Serial Out)、并行输入并行输出移位寄存器(Parallel In-Parallel Out)。 本实验使用V erilog HDL 语言设计一个八位并行输入串行输出右移移位寄存器(Parallel In- Serial Out)和一个八位串行输入并行输出寄存器(Serial In- Parallel Out)，分别进行仿真、引脚分配并下载到电路板进行功能验证。 四、实验步骤 1．并行输入串行输出移位寄存器实验步骤 1）. 运行Quartus II 软件，选择File New Project Wizard 菜单，工程名称及顶层文件名称为SHIFT8R，器件设置对话框中选择Cyclone 系列EP1C6Q240C8 芯片，建立新工程。 2.) 选择File New 菜单，创建V erilog HDL 描述语言设计文件，打开文本编辑器界面。 3.) 在文本编辑器界面中编写V erilog HDL 程序，源程序如下： module SHFIT8R(din,r_st,clk,load,dout); input [7:0]din; input clk,r_st,load; output dout; reg dout; reg [7:0]tmp; always @(posedge clk) if(!r_st) begin dout<=0; end else begin if(load) begin tmp=din; end else
电子通信与软件工程 系2013-2014学年第2学期 《数字电路与逻辑设计实验》实验报告 --------------------------------------------------------------------------------------------------------------------- 班级: 姓名: 学号: 成绩: 同组成员: 姓名: 学号: --------------------------------------------------------------------------------------------------------------------- 一、 实验名称:集成计数器及寄存器的运用 二、实验目的: 1、熟悉集成计数器逻辑功能与各控制端作用。 2、掌握计数器使用方法。 三、 实验内容及步骤: 1、集成计数器74LS90功能测试。74LS90就是二一五一十进制异步计数器。逻辑简图为图8、1所示。 四、 五、 图8、1 六、 74LS90具有下述功能: ·直接置0(1)0(2)0(.1)R R ,直接置9(S9(1,·S,.:,＝1) ·二进制计数(CP 、输入QA 输出) ·五进制计数(CP 2输入Q D Q C Q B 箱出) ·十进制计数(两种接法如图8.2A 、B 所示) ·按芯片引脚图分别测试上述功能,并填入表 8、1、表8、2、表8、3中。
图8、2 十进制计数器 2、计数器级连 分别用2片74LS90计数器级连成二一五混合进制、十进制计数器。 3、任意进制计数器设计方法 采用脉冲反馈法(称复位法或置位法)。可用74LS90组成任意模(M)计数器。图8、3就是用74LS90实现模7计数器的两种方案,图(A)采用复位法。即计数计到M异步清0。图(B)采用置位法,即计数计到M一1异步置0。 图8、3 74LS90 实现七进进制计数方法 （1）按图8、3接线,进行验证。 （2）设计一个九进制计数器并接线验证。 （3）记录上述实验的同步波形图。 四、实验结果:
寄存器组的设计与实现 第______ _________组 成员___ ____ ____ 实验日期___ _____ _____ 实验报告完成日期___________ 1、实验目的 １、学习掌握Ｑｕａｒｔｕｓ软件的基本操作； ２、理解寄存器组的工作原理和过程； ３、设计出寄存机组并对设计的正确性进行验证； 二、实验内容
１、设计出功能完善的寄存器组，并对设计的正确性进行验证。要求如下： （１）用图形方式设计出寄存器组的电路原理图 （２）测试波形时用时序仿真实现，先将不同的数据连续写入 ４个寄存器后，再分别读出 （３）将设计文档封装成器件符号。 （４）数据的宽度最好是１６位 ２、能移位的暂存器实验，具体要求如下： （１）用图形方式设计出能移位的暂存器电路原理图，分别实 现左移、逻辑右移和算术右移。 （２）测试波形时要用时序仿真实现，测试数据不要全为０也 不要全为１，算术右移的测试数据要求为负数（即符号位为 １） （３）将设计文档封装成器件符号。 （4）数据的宽度最好是１６位 三、能完善的寄存器组设计思想 1、对于寄存器组设计思路 利用具有三态功能的寄存器堆７４６７０芯片进行设计，根据实验要求，需要设计１６位的存储器组，则需要７４６７０芯片４片，在寄存器组工作时，同时对４片７４６７０芯片进行读写操作控制，封装后即可作为包含有４个寄存器的１６位寄存器组在主机系统中调用。 2、对７４６７０器件的学习 ７４６７０（三态输出４×４寄存器堆）提供４个４位的寄存器，在功能上可对４个寄存器去分别进行写操作和读操作。在寄存器进行写操作时，通过ＷＢ、ＷＡ两个寄存器选择端的组合和００、０１、１０、１１、来选择寄存器，公国ＧＷＮ写操作端控制进行三态控制，在ＧＷＮ为低电平时将数据写入端数据Ｄ４Ｄ３Ｄ２Ｄ１写入该寄存器；在寄存
实验四典型时序电路的功能测试与综合仿真报告 15291204张智博一．74LS290构成的24位计数器 方法：第一片74290的Q3与第二片的INB相连，R01，R02相连，INA，R91,R92悬空构成24位计数器。50Hz，5v方波电压源提供时钟信号，用白炽灯显示输出信号。 实验电路： 实验现象：
输出由000000变为000001，000010，000011，000100，001000，001001，001010，001011，001100，010001，010000，010010，010011，010100，011000，011001，011010，011011，011100，100000，100001，100010，100011，100100，最终又回到000000，实现一次进位。 二．74LS161构成的24位计数器 方法：运用多次置零法 用两片74LS161构成了24位计数器，两片计数器的时钟信号都由方波电压源提供，第一片芯片的Q3和第二片芯片的Q0通过与非门，构成两个74LS161的LOAD信号，第一片的CO接第二片的ENT，其他ENT和ENP接Vcc（5v）。输出接白炽灯。 电路图： 实验现象：以下为1—24的计数过程
三．74LS194构成的8位双向移位寄存器 方法：通过两片194级联，控制MA,MB的值，来控制左右移动 实验电路由两片74LS194芯片构成。两个Ma接在一起，两个Mb接在一起，第一片的Dr，第二片的Dl，分别通过开关接到Vcc（5v）上。第一片的Q3接到第二片的Dr，第二片的Q0接到第一片的Dl。8个输出端分别接白炽灯。 实验电路：
计算机原理与设计 实验报告 实验三多周期MIPS CPU的控制部件用有限状态机实现多周期CPU的控制部 件
一．实验目的 1、了解MIPS—CPU控制器的功能和工作原理； 2、掌握用有限状态机技术实现多周期控制器的方法； 3、熟练掌握用Verilog HDL语言设计多周期控制器的方法； 4、熟练掌握对多周期控制器的仿真实验验证和硬件测试两种调试方法； 5、掌握向MIPS-CPU顶层数据通路中增加控制单元的方法，并通过仿真验证和硬件测试两种方法对电路进行故障定位的调试技术。 二．实验内容 （1）MIPS—CPU控制器的有限状态机设计，根据MIPS—CPU 各种类型指令执行要求和有限状态机的设计原理，将多周期控制器的指令执行划分为多个状态，确定每一种指令的有限状态机，最后归纳为完整的多周期控制器有限状态机。通过Verilog HDL语言实现多周期控制器有限状态机。 （2）根据MIPS—CPU控制器的接口要求，在有限状态机的
基础上，用Verilog HDL实现完整的MIPS—CPU控制器的设计，并根据仿真波形，验证设计的正确性，并对出现的故障进行定位，修改程序，重新编译； （3）设计控制器的硬件下载测试方案。将编译通过的电路下载到实验台中。根据硬件调试结果验证设计的正确性，并对出现的故障进行定位，修改程序重新编译；最终完成控制器的硬件电路设计； （4）在MIPS—CPU指令系统的数据通路基础上，增加控制单元电路，并进行编译，仿真波形和调试。根据仿真波形，验证设计的正确性，并对出现的故障进行定位，修改程序，重新编译； （5）对增加了控制单元的顶层数据通路设计硬件下载测试方案。将编译通过的电路下载到实验台中。根据硬件调试结果验证设计的正确性，并对出现的故障进行定位，修改程序，重新编译；最终完成增加了控制单元的顶层数据通路设计。三．实验原理与步骤 1.把指令执行分成多个阶段，每个阶段在一个时钟周期内完成 （1）.时钟周期以最复杂阶段所花时间为准 （2）.尽量分成大致相等的若干阶段 （3）.每个阶段内最多只能完成：1次访存或1次寄存器堆读/写或1次ALU
成绩：实验报告 课程名称：计算机组成原理 实验项目：寄存器的原理及操作 姓名： 专业：计算机科学与技术 班级： 学号：
计算机科学与技术学院 实验教学中心 20 16年6月20日
实验项目名称：寄存器的原理及操作 一、实验目的 1.了解模型机中 A, W 寄存器结构、工作原理及其控制方法。 2.了解模型机中寄存器组 R0..R3 结构、工作原理及其控制方法。 3.了解模型机中地址寄存器 MAR，堆栈寄存器 ST，输出寄存器 OUT寄存器结构、工作原理及其控 制方法。 二、实验内容 1、A、W寄存器：利用 COP2000实验仪上的K16..K23 开关做为DBUS的数据，其它开关做为控制信号， 将数据写入寄存器A， W。 2、R0、R1、R2、R3 寄存器实验：利用COP2000实验仪上的K16..K23 开关做为DBUS的数据，其它开 关做为控制信号，对数据寄存器组R0..R3 进行读写。 3、MAR、ST、OUT寄存器：利用COP2000实验仪上的K16..K23 开关做为DBUS的数据，其它开关做为 控制信号，将数据写入地址寄存器MAR，堆栈寄存器ST，输出寄存器OUT。 三、实验用设备仪器及材料 伟福 COP2000 系列计算机组成原理实验系统 四、实验原理及接线 实验 1：A，W 寄存器实验
实验 2 ：R0，R1， R2，R3寄存器实验
MAR为存储器地址寄存器，其功能是存储操作数在内存中的地址,信号MAREN的功能是将数据总线DBUS上数据 MAR，信号 MAROE的功能是将MAR的值送到地址总线ABUS上 ST 堆栈寄存器的作用，是出现中断或子程序调用时，保存断点处PC 的值，以便中断或子程序结束时， 能继续执行原程序。图中，信号STEN的作用是将数据总线DBUS上数据存入堆栈寄存器ST 中
杭州电子科技大学计算机学院 实验报告 实验项目： 课程名称：计算机组成原理与系统结构设计 姓名： 学号： 同组姓名： 学号 : 实 验 位 置 （ 机 号 ） ： 实验日期： 指 导 教 师： 实验 内容 （算 法、 程 序、 步骤 和 方 法） 一、 实验目的 （1 ）学会使用Verilog HDL 进行时序电路的设计方法。 （2）掌握灵活应用Verilog HDL 进行各种描述与建模的技巧和方法。 （3 ）学习寄存器堆的数据传送与读 /写工作原理，掌握寄存器堆得设计方法。 二、 实验仪器 ISE 工具软件 三、 步骤、方法 （1） 启动Xilinx ISE 软件，选择File->New Project,输入工程名shiyan2,默认选择后，点 击Next 按钮，确认工程信息后点击 Finish 按钮，创建一个完整的工程。 （2） 在工程管理区的任意位置右击，选择 New Source 命令。弹出 New Source Wizard 对 话框， 选择Verilog Module,并输入Verilog 文件名，点击Next 按钮进入下一步， 点击Finish 完成创建。 （3） 编辑程序源代码，然后编译，综合；选择 Synthesize--XST 项中的Check Syntax 右击 选择 Run 命令，并查看RTL 视图；如果编译出错，则需要修改程序代码，直至正确。 （4） 在工程管理区将 View 类型设置成 Simulation ，在任意位置右击，选择 New Source 命 令，选择Verilog Test Fixture 选项。点击Next ，点击Finish ，完成。编写激励代码，观察仿 真波形，如果验证逻辑有误，则修改代码，重新编译，仿真，直至正确。 （5） 由于实验四并未链接实验板，所以后面的链接实验板的步骤此处没有。
实验六移位寄存器的设计 一、实验目的 1、掌握中规模4位双向移位寄存器逻辑功能及使用方法。 2、熟悉移位寄存器的应用—实现数据的串行、并行转换和构成环形计数器。 二、实验预习要求 1、复习有关寄存器及串行、并行转换器有关内容。 2、查阅CC40194、CC4011及CC4068 逻辑线路。熟悉其逻辑功能及引脚排列。 3、在对CC40194进行送数后，若要使输出端改成另外的数码，是否一定要使寄存器清零？ 4、使寄存器清零，除采用R C输入低电平外，可否采用右移或左移的方法？可否使用并行送数法？若可行，如何进行操作？ 5、若进行循环左移，图6－4接线应如何改接？ 6、画出用两片CC40194构成的七位左移串 /并行转换器线路。 7、画出用两片CC40194构成的七位左移并 /串行转换器线路。 三、实验设备及器件 1、＋5V直流电源 2、单次脉冲源 3、逻辑电平开关 4、逻辑电平显示器 5、CC40194×2（74LS194）CC4011(74LS00) CC4068(74LS30) 四、设计方法与参考资料 1、移位寄存器是一个具有移位功能的寄存器，是指寄存器中所存的代码能够在移位脉冲的作用下依次左移或右移。既能左移又能右移的称为双向移位寄存器，只需要改变左、右移的控制信号便可实现双向移位要求。根据移位寄存器存取信息的方式不同分为：串入串出、串入并出、并入串出、并入并出四种形式。 本实验选用的4位双向通用移位寄存器，型号为CC40194或74LS194，两者功能相同，可互换使用，其逻辑符号及引脚排列如图6－1所示。 其中D0、D1、D2、D3为并行输入端；Q0、Q1、Q2、Q3为并行输出端；S R为右移串行输 C为直接无条件清零端； 入端，S L为左移串行输入端；S1、S0为操作模式控制端；R
实验四 译码器的设计及延迟估算 1、 设计译码器并估算延迟 设计一个用于16bit 寄存器堆的译码器，每一个寄存器有32bit 的宽度，每个bit 的寄存器单元形成的负载可以等效为3个单位化的晶体管(后面提到负载都为单位化后的负载)。 译码器的结构可参考典型的4-16译码器 译码器和寄存器堆的连接情况(Output 输出为1的一行寄存器被选中) ① 假定4个寄存器地址位的正反8个输入信号，每个信号的输入负载可以等效为10。确定 译码器的级数，并计算相关逻辑努力，以此来确定每一级中晶体管的尺寸（相当于多少个单位化的晶体管）及整个译码电路的延迟(以单位反相器的延迟的本征延迟Tp0为单位)。 解： 96332,10int =?==ext g C C C ,9.696/10F ==? 假定每一级的逻辑努力：G=1，又因为分支努力(每个信号连接8个与非门)： 81*8*1B ==， 路径努力8.7686.91=??==GFB H 所以，使用最优锥形系数就可得到最佳的电路级数39.36.3ln 8.76ln 6.3ln ln ===H N ,故N 取3级。 因为逻辑努力：2121G =??=，路径努力：6.15386.92=??==GFB H 则使得路径延时最小的门努力 36.5)6.153(3/1===N H h 。 所以： . 36.5136.5,68.2236.5, 36.5136.5132211=========g h f g h f g h f
故第一级晶体管尺寸为7.68 1036.5=?； 第二级尺寸为956.1768.27.6=?； 第三级尺寸为96244.9636.5956.17≈=?。 故延迟为：0008.22)36.5136.5436.51(p p p t t t =+++++= ② 如果在四个寄存器地址输入的时候，只有正信号，反信号必须从正信号来获得。每个正信号的输入的等效负载为20,使用与①中同样的译码结构，在这种条件下确定晶体管的大小并评估延迟(以单位反相器的延迟的本征延迟Tp0为单位)。 解：因为输入时通过两级反相器，使这两个反相器分摊原来单个反相器的等效扇出，将两级反相器等效为一级，故其逻辑努力32.236.5h ==, 故36.5,68.2,32.2,32.24321====f f f f 所以： 第一级尺寸为：()9.2832.210=?； 第二级尺寸为：728.632.29.2=?； 第三级尺寸为：03.1868.2728.6=?； 第四级尺寸为：65.9636.503.18=? 正信号通路的延迟为：()0036.2236.5136.5436.5132.2132.2p p p t t t =++++++++= 反信号通路情况与上问相同，延迟为0008.22)36.5136.5436.51(p p p t t t =+++++= 2、 根据单位反相器(NMOS:W=0.5u L=0.5u PMOS:W=1.8u L=0.5u)，设计出实 际电路，并仿真1题中第一问的路径延迟。 设计出实际电路如下：
序号: 学号: C H A N G Z H O U U N I V E R S I T Y 计算机组成原理 课程设计报告 题 目： 8位机微程序控制器模型计算机的设计与实现 学 生 姓 名： 学 号: 学 院（系）： 专 业 班 级： 校内指导教师： 专业技术职务： 实 习 时 间： 年 月 日 年 月 日
计算机组成原理课程设计任务书
计算机科学与技术系指导教师
目录 1、课程设计的目的 (1) 2、课程设计的环境 (1) 3、课程设计的内容 (1) 3.1课程设计的原理 (1) 3.2课程设计机器指令 (3) 3.3微指令格式 (4) 3.4数据通路图 (6) 4、设计方案 (7) 4.1设计指令 (9) 4.2微程序流程图 (10) 4.3微指令二进制微代码表 (10) 5、验证与结果分析 (13) 5.1课设过程中所遇问题 (23) 5.2对应问题的解决 (23) 6、课程设计总结 (24) 6.1任务分工 (24) 6.2心得体会 (24) 参考文献 (26)
1、课程设计的目的 深入了解计算机各种指令的执行过程，以及控制器的组成，指令系统微程序设计的具体知识，进一步理解和掌握动态微程序设计的概念；完成微程序控制的特定功能计算机的指令系统设计和调试。 总体概括而言，分为两点：1、在掌握部件单元电路实验的基础上，进一步将其组成系统，构造一台基本模型计算机。2、为其定义两条以上的机器指令，并编写相应的微程序，上机调试，掌握整机概念。 2、课程设计的环境 硬件环境：TEC-9实验系统一台，排线若干，连接有关联的开关，使信号同步。 软件环境：HQFC-B1计算机组成原理软件，进行微程序的写入。 3、课程设计的内容 1、通过知识的综合运用，设计一台新的微程序控制器模型计算机。 2、选择合适的寻址方式，进行数据的提取。 3、确定你需要做的两条指令，并画出对应指令的流程图。 4、根据流程图，设计控制器代码。 5、根据控制器代码，在TEC-9实验系统上进行连线、调试，修改控制器代码。 6、最后，得出正确的控制器代码并完成实验报告、答辩，课程设计完成3.1课程设计的原理 TEC-9实验系统的组成：控制台、数据通路、控制器、时序电路、数字逻辑实验区、电源模块 时序发生器 时序发生器产生计算机模型所需的时序和数字逻辑实验所需的时钟。时序电路由一个500KHz晶振、2片GAL22V10组成。根据本机的设计，执行一条微程序指令需要4个节拍脉冲T1、T2、T3、T4，执行一条机器指令需要三个节拍电位W1、W2、W3，因此本机的基本时序如下：
成绩： 计算机原理实验室实验报告 本说明打印前删除！！proteus 实验报告格式必须保持原样，蓝色部分按照实验内容自行填写；全班统一使用A4大小纸张，部分困难学生可以使用等大小纸张，自绘实验报告格式；全部实验完成后，学委按照实验顺序把每个学生的实验报告（含首页）装订成册，按照学号顺序排列，提交给实验指导老师（询问代课老师，学校将实验工作指派给了哪位老师）。 学委提交报告时，需要同时提交（附录）实验成绩登记表一份。其中表头部分课程，班级，班级总人数照实填写，项目填写本学期本课程的实验数量；学号姓名栏按照顺序填写，报告一栏填写该同学交报告的份数（每项目每人一份报告）；出勤和成绩栏留空，由实验室填写；特殊情况填写在备注处，若空间不够请写于背面并在备注处标明；若有学号超过58号的情况，请在背后按照格式登记所有项目；空学号可以不留空位置，顺序递进。 课程：计算机组成原理 姓名：刘翔翔 专业：软件工程 学号：1420561 21 日期：2016年6月 太原工业学院 计算机工程系
实验二：输寄存器实验 实验环境PC机＋Win 7＋proteus仿真器实验日期2016.06.01 一．实验内容 基本要求 1.理解CPU运算器中寄存器的作用 2.设计并验证寄存器组（至少四个寄存器） 扩展要求 3.实现更多的寄存器（至少8个） 思考题： 思考随着寄存器的增多，电路设计的复杂度是什么比例增大？ 二．理论分析或算法分析 1.基本要求 使用74LS373充当寄存器，74LS139做地址译码，74LS245用作输入，数码管显示寄存器内的数据。74LS139为二-四译码器，用两根线作为地址线接到74LS139的输入端，输出端分别接到每个74LS373的OE上，再用一个74LS139配合反相器产生控制每个74LS373的LE的信号。74LS245的输出端分别对应接到373输入端的每个管脚上的。74LS373的输出端对应接到数码管的对应管教上，以实现数据的显示。先在各个寄存器中输入不同的数据，然后关闭74ls248(输入)，选择不同的373(寄存器)，在数码管上显示不同的数据。 2.扩展要求 与基本要求相比大体不变，地址译码部分选择74LS138来做地址译码器。原理图连接方式原理不变，验证方式不变。
设计示例2：寄存器堆设计 1、 功能概述： MIPS 指令格式中的寄存器号是5bits ，指令可以访问25=32个32位的寄存器。这样的一堆寄存器“堆在一起”构成一个寄存器堆（Register File ）。模块框图如图1所示： Regfile 图1 模块框图 2、 结构框图： 3、 接口说明： 表1： 寄存器堆模块接口信号说明表 clk we wdata Valid Valid waddr rst_n 图2 寄存器堆写时序框图
4、设计电路源代码 //功能描述风格寄存器堆的设计 module regfile( input clk, input rst_n, //写端口 input we, //写使能 input[4:0] waddr, //写寄存器下标 input[31:0] wdata, //待写入寄存器堆的数据 //读端口1 input[4:0]raddr1, //读端口1寄存器下标 output[31:0] rdata1,//从端口1读出的寄存器堆的数据 //读端口2 input[4:0]raddr2, //读端口2寄存器下标 output[31:0] rdata2 //从端口2读出的寄存器堆的数据); reg[31:0] regs[0:31]; //32个32位寄存器堆 //Write operation always @ (posedge clk or negedge rst_n) begin if(!rst_n) begin:reset_all_registers //将32个寄存器复位为0. integer i; for(i=0;i<32;i=i+1) regs[i] = 32'd0; end else begin //写寄存器堆有效时，更新寄存器堆中某个寄存器的数据 if((we == 1'b1) && (waddr != 5'h0)) begin regs[waddr] <= wdata; end end end //Read port1 operation assign rdata1 = (raddr1 == 5'd0) ? 32'd0 : regs[raddr1]; //Read port2 operation assign rdata2 = (raddr2 == 5'd0) ? 32'd0 : regs[raddr2];
实验六 移位寄存器功能测试及应用 --实验报告要求 一. 实验目的(0.5分） 1. 熟悉寄存器、移位寄存器的电路结构和工作原理。 2. 掌握中规模4位双向移位寄存器逻辑功能及使用方法。 3. 熟悉移位寄存器的应用。 二. 实验电路 D0、D1 、D2 、D3为并行输入端；Q0、Q1、Q2、Q3为并行输出端；SR 为右移串行输入端，SL 为左移串行输入端；S1、S0 为操作模式控制端；R C 为直接无条件清零端；CP 为时钟脉冲输入端。 三 图2 CC40194/74LS194 逻辑功能测试 图1 CC40194/74LS194的逻辑符号及引脚功能 图3 环形计数器
四. 实验原理（0.5分） 1.移位寄存器是一个具有移位功能的寄存器，是指寄存器中所存的代码能够在移位脉冲的作用下依次左移或右移。既能左移又能右移的称为双向移位寄存器，只需要改变左、右移的控制信号便可实现双向移位要求。根据移位寄存器存取信息的方式不同分为：串入串出、串入并出、并入串出、并入并出四种形式。 本实验选用的4位双向通用移位寄存器，型号为CC40194或74LS194，两者功能相同，可互换使用。 74LS194有5种不同操作模式：即并行送数寄存，右移（方向由Q0-->Q3）,左移（方向由Q3→Q0），保持及清零。 2．移位寄存器应用很广，可构成移位寄存器型计数器：顺序脉冲发生器；串行累加器；可用数据转换，即把串行数据转换为并行数据，或把并行数据转换为串行数据等。本实验研究移位寄存器用作环形计数器和数据的串、并行转换。 （1）环行计数器 把移位寄存器的输出反馈到它的串行输入端，就可以进行循环移位。 （2）实现数据、并行转换器 a）串行∕并行转换器 串行∕并行转换器是指串行输入的数码，经转换电路之后变换成并行输出。 b）并行∕串行转换器 并行∕串行转换器是指并行输入的数码经转换电路之后，换成串行输出。 五. 实验内容与步骤（共1分） 1. 2.测试74LS194的逻辑功能（0.5分） (1)在实验箱上选取一个16P插座，按定位标记插好74LS194集成块。 (2)将实验挂箱上＋5V直流电源接40194的16脚，地接8脚。S1、S0、SL、SR、D0、D1、D2、D3分别接至逻辑电平开关的输出插口；Q0、Q1、Q2、Q3接至发光二极管。CP端接单次脉冲源。 (3)改变不同的输入状态，逐个送入单次脉冲，观察寄存器输出状态，记录之。 a)清除：令=0，其它输入均为任意态，这时寄存器输出Q0、 Q1、 Q2 、Q3应均为0。清除后，至=1。 b）送数：令=S1=S0=1 ，送入任意4位二进制数，如D0、D1、D2、D3=1010，加CP脉冲，观察CP=0、CP由1→0、CP=1三种情况下寄存器输出状态的变化，观察寄存输出状态变化是否发生在CP脉冲的上升沿。 （c）右移：清零后，令=1， S1=0 S0=1，由右移输入端S R送入二进制数码如0100，由CP端连续加4个脉冲，观察输出情况，记录之。 （d）左移：先清零或予至，再令=1 S1=1，S0=0，由左移输入端S L送入二进制数码
移位寄存器实验报告 姓名：陈素学号：3120100621 专业：软件工程课程名称：逻辑与计算机设计基础实验同组学生姓名：张闻 实验时间：y yyy-mm-dd 实验地点：紫金港东4-509 指导老师：一、实验目的和要求 掌握移位寄存器的工作原理及设计方法 掌握串、并数据转换的概念与方法 了解序列信号在CPU控制器设计中的应用 二、实验内容和原理 2.1 实验原理 带并行置入的移位寄存器 移位寄存器：每来一个时钟脉冲，寄存器中的数据按顺序向左或向右移动一位必须采用主从触发器或边沿触发器 不能采用电平触发器 数据移动方式：左移、右移 数据输入输出方式 串行输入，串行输出 串行输入，并行输出 并行输入，串行输出 串行输入的移位寄存器 使用D触发器，可构成串行输入的移位寄存器 2.2 标题 <正文>
带并行输入的右移移位寄存器 数据输入移位寄存器的方式：串行输入、并行输入 带并行输入的8位右移移位寄存器 module shift_reg(clk, S, s_in, p_in, Q); input wire clk, S, s_in; input wire [7:0] p_in; output wire [7:0] Q; wire [7:0] D; wire nS; FD FDQ0(.C(clk), .D(D[0]), .Q(Q[0])), FDQ1(.C(clk), .D(D[1]), .Q(Q[1])), FDQ2(.C(clk), .D(D[2]), .Q(Q[2])), FDQ3(.C(clk), .D(D[3]), .Q(Q[3])), FDQ4(.C(clk), .D(D[4]), .Q(Q[4])), FDQ5(.C(clk), .D(D[5]), .Q(Q[5])), FDQ6(.C(clk), .D(D[6]), .Q(Q[6])), FDQ7(.C(clk), .D(D[7]), .Q(Q[7])); OR2 D0_L(.I0(L_0), .I1(R_0), .O(D[0])), D1_L(.I0(L_1), .I1(R_1), .O(D[1])), D2_L(.I0(L_2), .I1(R_2), .O(D[2])), D3_L(.I0(L_3), .I1(R_3), .O(D[3])), D4_L(.I0(L_4), .I1(R_4), .O(D[4])), 串行输入 S
6.9 通用寄存器实验报告 一、实验目的: 1、了解通用寄存器组的用途及对CPU的重要性。 2、掌握通用寄存器组的设计方法。 二、实验内容: 1、通用寄存器组的作用 通用寄存器组是CPU的重要组成部分。 （1）从存储器和外部设备（除DMA方式外）取来的数据要放在通用寄存器中； （2）向存储器和外部设备（除DMA方式外）输出的数据从通用寄存器中取出； （3）参加算术运算和逻辑运算的数据从通用寄存器组中取出，同时通用寄存器也是运算结果的暂存地。 （4）通用寄存器组有两个读端口，负责提供进行算术逻辑单元需要的源操作数和目的操作数；有一个写端口，负责将运算结果保存到指定的寄存器内。 2、通用寄存器组功能实现 根据通用寄存器组的功能要求，一个只有四个16位寄存器的通用寄存器组的框图如下图所示： ⑴寄存器部分： 当reset为低电平时，将四个16位寄存器R0-R3复位为0；当寄存器的write和sel
为高电平时，在时钟信号clk的上升沿将D端的输入D[15-0]写入寄存器，然后送到寄存器的输出Q[15-0]。4个寄存器的允许写信号write和外部产生的目的寄存器写信号DRWr 直接相连。每个寄存器还有另一个选择信号sel，它决定哪一个寄存器进行写操作。4个寄存器的选择信号分别和2-4译码器产生的sel00、sel01、sel10、sel11相连。只有当一个寄存器被选中（sel为高电平时），才允许对该寄存器进行写操作。 ⑵ 2-4译码器： 2-4译码器的输入sel[1-0]接DR[1-0],2-4译码器对2位的输入信号sel[1-0]进行2-4译码，产生4个输出sel00、sel01、sel10、sel11，分别送往4个寄存器R0、R1、R2和R3的选择端sel。 ⑶ 4选1多路器 4选1多路选择器1从4个寄存器R0、R1、R2和R3的输出Q[15-0]选择1路送到DR_data[15-0]，给算术逻辑单元提供目的操作数；选择信号sel[1-0]接DR[1-0]。4选1多路选择器2从4个寄存器R0、R1、R2和R3的输出Q[15-0]选择1路送到SR_data[15-0]，给算术逻辑单元提供源操作数；选择信号sel[1-0]接SR[1-0]。 三、实验要求: 1、实验设计目标 设计一个通用寄存器组满足以下要求： （1）通用寄存器组中有4个16位的寄存器。 （2）当复位信号reset=0时，将通用寄存器组中的4个寄存器清零。 （3）通用寄存器组中有1个写入信号，当DRWr=1时，在时钟clk的上升沿将数据总线上的数写入DR[1-0]指定的寄存器。 （4）通用寄存器组中有两个读出端口，一个对应算术逻辑单元的目的操作数DR,另一个对应算术逻辑单元的源操作数SR。DR[1-0]选择目的操作数;SR[1-0]选择源操作数。 （5）设计要求层次设计。底层的设计实体有三个：16位寄存器，具有复位功能和允许写功能；一个2-4译码器，对应寄存器写选择；一个4选1多路开关，负责选择寄存器的读出。顶层设计构成一个完整的通用寄存器组。 2、顶层设计实体的引脚要求 引脚要求对应关系如下： （1）clk对应试验台上的时钟（单脉冲）。 （2）reset对应实验台上的CPU复位信号CPU_RST。 （3）SR[1-0]对应实验台开关SA1，SA0。
单周期CPU及其Verilog HDL设计 一、指令的设计 MIPS32的指令的三种格式的参考： R类型： I类型： J类型: R类型指令的op为0，具体操作由func指定。rs和rt是源寄存器号，rd是目的寄存器号。只有移位指令使用sa来指定移位位数。I类型指令的低16位是立即数，计算时要把它扩展到32位。依指令的不同，有零扩展和符号扩展两种。J类型指令右边26位是字地址，用于产生跳转的目标地址。具体的指令格式和内容请参考MIPS32。 设计报告中需自行设计所有指令的二进制格式和对应的汇编指令格式。 二、单周期CPU的设计 我们把时钟的电平从低到高变化的瞬间称为时钟上升沿，两个相邻时钟上升沿之间的时间间隔称为一个时钟周期。单周期CPU指的是一条指令的执行在一个这样的时钟周期内完成，然后开始下一条指令的执行，即一条指令用一个周期。 2.1执行一条指令所需的硬件电路 我们的目的地是要设计CPU的硬件电路，使其能够从存储器中读出一条条指令并执行指令所描述的操作。从存储器中读取指令的动作一般与指令本身的意义无关，可以以同样的方法把指令从存储器中取出。而执行指令则与指令本身的意义密切相关，因此最重要是首先搞清楚CPU要执行的每条指令的意义。下面以两种类型的电路来举例。 2.1.1与取指令有关的电路
指令存储在存储器中。CPU取指令时把程序计数器（PC）中的内容作为存储器的地址，根据它来访问存储器，从PC值指定的存储单元中取来一条32位指令。如果取来的指令执行时没有引起转移，PC的值要加4；如果转移，要把转移的目标地址写入PC，以便在下一个时钟周期取出下一条指令。 图2.1 取指令时用到的硬件电路和指令寄存器 如图2.1所示，PC是一个简单的32位寄存器，由32个D触发器构成。指令存储器（Inst Mem）的输入端a是地址、输出端do是数据输出，即指令。图中的加法器专供PC+4使用，它的输出接到多路器的一个输入端。如果取来的指令没有引起转移或跳转，则选择PC+4，在时钟上升沿处将其打入PC；若引起转移或跳转，则用多路器选择下一条指令该打入的PC值。 2.1.2寄存器计算类型指令执行时所需电路 寄存器类型的指令有add等。如图2.2所示是执行它们所需的部分硬件电路。大多数MIPS指令属于三操作数指令。指令格式中的rs和rt是两个5位的寄存器号，由它们从寄存器堆（Regfile）中读出两个32位的数据。由于寄存器号有5位，所以能从32个寄存器中选出一个。32个寄存器合在一起称为寄存器堆（Register File）。从寄存器堆读出的两个32位数据分别被送到ALU的a和b的输入端。 图2.2 执行寄存器计算类型指令所需电路 具体的计算由ALU完成。ALU的计算控制码aluc由控制部件（Control Unit）产生。这里的控制部件是简单的组合电路，输入信号是指令的操作码op和功能码func，输出信号3个，它们分别是ALU的操作码aluc、计算结果是否写入寄存器堆的控制信号wreg和下一条指令的地址选择信号pcsource。ALU的计算结
寄 存 器 实 验 报 系别：信息技术系 专业：计算机科学与技术 班级：计科142 姓名：康道顺 学号：201401014233
实验一寄存器实验 一、实验目的 (1)了解模型机中A, W寄存器结构、工作原理及其控制方法。 (2)了解模型机中寄存器组R0..R3结构、工作原理及其控制方法。 二、实验要求 (1)A、W寄存器：利用COP2000实验仪上的K16..K23开关做为DBUS的数据， 其它开关做为控制信号，将数据写入寄存器A，W。 (2)R0、R1、R2、R3寄存器实验：利用COP2000实验仪上的K16..K23开关 做为DBUS的数据，其它开关做为控制信号，对数据寄存器组R0..R3进 行读写。 三、实验说明 寄存器的作用是用于保存数据的，因为我们的模型机是8位的，因此在本模型机中大部寄存器是8位的，标志位寄存器(Cy, Z)是二位的。 COP2000用74HC574来构成寄存器。74HC574的功能如下： 注意： 1. 在CLK的上升沿将输入端的数据打入到8个触发器中
74HC574工作波形图 四、实验原理 实验1：A，W寄存器实验 （1）原理图 寄存器A原理图 寄存器W原理图（2）工作波形图
寄存器A，W写工作波形图 （4）实验数据 例：将55H写入A寄存器 二进制开关K23-K16用于DBUS[7:0]的数据输入，置数据55H。 置控制信号为： 按住CLOCK脉冲键，CLOCK由高变低，这时寄存器A的黄色选择指示灯亮，表明选择A寄存器。放开CLOCK键，CLOCK由低变高，产生一个上升沿，数据55H 被写入A寄存器。 a)将66H写入W寄存器 。。。。。。 实验2：R0，R1，R2，R3寄存器实验 （1）原理图
实验三寄存器组的设计与实现 一、实验目的 1. 学习掌握Quartus II 的图形编辑、编译、仿真的设计流程； 2. 学习74670三态输出寄存器堆的使用； 3. 理解寄存器组的工作原理和过程，设计出4个16位寄存器组并对设计的正确性进行验证 二、实验任务及要求 1. 设计出功能完善的寄存器组，并对设计的正确性进行验证。具体要求如下： (1) 用图形方式设计出寄存器组的电路原理图。 (2) 测试波形要用时序仿真实现，先将不同的数据连续写入4个寄存器后，再分别读出。 (3) 将设计文件封装成器件符号。 (4) 数据的宽度最好为16位。 三、实验装置 安装有Quartus II软件的PC机1台 四、设计思想 运用具有三态功能的芯片74670进行设计，74670为4*4（4个4位寄存器）的寄存器堆，使用四片74670并联，同时对4 片74670 芯片进行读写操作控制，从而实现4个16位数据的存储与输出。 五、逻辑电路图
74670芯片图：三态输出的4*4寄存器堆 六、实验结果： 见原理图，波形图以及元件封装图。 1.原理图分析：见设计思想
2.波形图分析： 当RE为1,WE不为1时，实现输入功能，WB，WA控制数据输入到哪个寄存器组当RE为1，WE为1时，出现高阻状态，此时既不输入也不输出 当WE为1，RE不为1时，实现输出功能，RB,RA控制哪个寄存器组的数据输出 3.封装元件的功能说明： d[15..0]16位输入数据 q[15..0]16位输出数据 gwn:写入数据使能控制端，低有效 wa,wb：选择控制端，四种组合控制16位数输入到相应四种寄存器组 grn：读出数据使能控制端，低有效 ra,rb:选择控制端，四种组合控制从四种寄存器组读出相应16位数
2.1 寄存器实验 姓名：孙坚学号：134173733 班级：13计算机日期：2015.4.3 一．实验要求：利用CPTH 实验仪上的K16..K23 开关做为DBUS 的数据，其它开关做为控制信号，将数据写入寄存器，这些寄存器包括累加器A，工作寄存器W，数据寄存器组R0..R3，地址寄存器MAR，堆栈寄存器ST，输出寄存器OUT。 二．实验目的：了解模型机中各种寄存器结构、工作原理及其控制方法。 三．实验电路：寄存器的作用是用于保存数据的，因为我们的模型机是8位的，因此在本模型机中大部寄存器是8 位的，标志位寄存器(Cy, Z)是二位的。 CPTH 用74HC574 来构成寄存器。74HC574 的功能如下： 1. 在CLK的上升沿将输入端的数据打入到8 个触发器中 2. 当OC = 1 时触发器的输出被关闭，当OC=0 时触发器的输出数据
四．实验数据及步骤： 实验1：A，W 寄存器实验 寄存器A，W 写工作波形图
连接线表： 系统清零和手动状态设定：K23-K16开关置零，按[RST]钮，按[TV/ME]键三次，进入"Hand......"手动状态。 在后面实验中实验模式为手动的操作方法不再详述． 将66H写入A寄存器 二进制开关K23-K16用于DBUS[7:0]的数据输入，置数据66H 置控制信号为： 按住STEP脉冲键，CK由高变低，这时寄存器A 的黄色选择指示灯亮，表明选择A 寄存器。放开STEP 键，CK 由低变高，产生一个上升沿，数据66H 被写入A 寄存器。 将88H写入W寄存器 二进制开关K23-K16用于DBUS[7:0]的数据输入，置数据88H 置控制信号为： 按住STEP脉冲键，CK由高变低，这时寄存器W 的黄色选择指示灯亮，表明选择W 寄存器。放开STEP 键，CK 由低变高，产生一个上升沿，数据88H 被写入W 寄存器。 注意观察： １．数据是在放开STEP键后改变的，也就是CK的上升沿数据被打入。 ２．WEN，AEN为高时，即使CK有上升沿，寄存器的数据也不会改变。