CPU部件实现之ALU、寄存器堆、PC、RAM

已于 2022-02-04 09:48:55 修改
阅读量5.3k 收藏 52
点赞数 18
分类专栏： 大学课程 文章标签： 合肥工业大学 CPU 计算机组成原理 Verilog 实验
于 2021-06-30 22:54:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44977889/article/details/118370773
版权

系统硬件综合设计-多周期CPU的设计与实现

计算机组成原理 实验五 单周期CPU设计与实现——十条指令CPU

文章目录

ALU和寄存器堆

一、实验目的：

理解和掌握CPU中的算术逻辑运算部件（ALU）和寄存器堆（Register File）的工作原理，并使用Verilog和ModelSim进行设计和仿真。

二、实验内容：

  1. 使用Verilog完成ALU的设计,并编写测试仿真文件验证其正确性。要求：
     ALU支持16位的加、减、与、或以及移位运算。
  2. 使用Verilog完成通用寄存器堆的设计，并编写测试仿真文件验证其正确性。要求：
    寄存器堆包含8个16位的寄存器；
    寄存器堆有两个读端口和一个写端口。

三、 源代码

MyALU.v

module ALU(
    input wire [15:0] A_1, //操作数1
    input wire [15:0] A_2,  //操作数2
    input wire [3:0] OP,  //操作码
    output [15:0] result,//  结果
    //status[0:3] //0: zero, 1: carry, 2: negative, 3: overflow
    //output reg [3:0] status
    output zero,
    output carry,
    output negative,
    output overflow
);

    wire signed [15:0] tmpX = A_1, tmpY = A_2;
    reg [16:0] res_T = 17'b0;//??????????16??17???????
    always@* begin
        case(OP)
            3'b000: 
                res_T = A_1 + A_2;
            3'b001:
                res_T = A_1 -A_2;
            3'b010:
                res_T = A_1 & A_2;
            3'b011:
                res_T = A_1 | A_2;
            3'b100:
                res_T = A_1 >> A_2;
            3'b101:
                res_T = A_1 << A_2;
            default:
                res_T = 16'b1111111111111111; 
        endcase
    end
    assign ans = res_T[15:0];
    assign zero = res_T == 16'b0 ? 0 : 1; //判断是否等于0
    assign negative = res_T[15];            //判断是否为负数
    assign overflow = res_T[16];             //判断是否溢出
    
endmodule

MyALU_tb.v

module MyALU_tb();
    reg [15:0] inData_1, inData_2;
    reg [3:0]  OP [0:7];
    wire [15:0] result;
    wire zero, carry, negative, overflow;
    
    initial begin
        inData_1 = 16'b0101010101010101;//21845
        inData_2 = 16'b1010101010101010;//43690
		    
        #10  OP[0] = 3'b000;
        #10  OP[1] = 3'b001;
        #10  OP[2] = 3'b010;
        #10  OP[3] = 3'b011;
        #10  OP[4] = 3'b100;
        #10  OP[5] = 3'b101;
        
		    #100 $stop;
    end
	
    
    ALU test1(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[0]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
	ALU test2(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[1]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
	ALU test3(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[2]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
	ALU test4(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[3]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
	ALU test5(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[4]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
	ALU test6(
        .A_1(inData_1), .A_2(inData_2),
        .OP( OP[5]),
        .result(result),
        .zero(zero),
        .carry(carry),
        .negative(negative),
        .overflow(overflow)
    );
	
endmodule

在这里插入图片描述
registerBank.v

module registerBank(
    input [2:0] addrA,addrB,inAddr,
    output wire[15:0] outA,outB,
    input wire[15:0] inData,
    input clk,WE
);

    reg[15:0] regs[0:7];
  
    assign outA = regs[addrA];
    assign outB = regs[addrB];
  
    always@(negedge clk)begin
        if( WE == 1 )
            regs[inAddr] = inData;
    end
endmodule

registerBank_tb.v

module registerBank_tb();
  parameter CYCLE = 2;
  
	reg [2:0] addrA, addrB, inAddr;
	wire [15:0] outA, outB;
	reg [15:0] inData;
	reg clk, WE;
 
	initial begin
    clk = 1'b0;
    //WE = 1'b0;
  end
  
  always #(CYCLE/2) clk = ~ clk;
  always #(CYCLE/2) WE = ~ WE;
  
	initial begin
    
    //assign WE = 1'b0;
    assign WE = 1'b1;
    assign inData = 16'h35A1;
    assign inAddr = 3'b010;
    assign addrA = 3'b010;
    assign addrB = 3'b100;
    
    #(CYCLE*1) 
    assign WE = 1'b1;
    assign inData = 16'h1234;
    assign inAddr = 3'b001;
    assign addrA = 3'b000;
    assign addrB = 3'b001;
    
    #(CYCLE*2)
    assign WE = 1'b0;
    assign inData = 16'h65df;
    assign inAddr = 3'b101;
    assign addrA = 3'b101;
    assign addrB = 3'b010;
    
    #(CYCLE*3)
    assign WE = 1'b1;
    assign inData = 16'h12ce;
    assign inAddr = 3'b100;
    assign addrA = 3'b100;
    assign addrB = 3'b011;
    
    #(CYCLE*2)
    assign WE = 1'b1;
    assign inData = 16'hefd3;
    assign inAddr = 3'b110;
    assign addrA = 3'b011;
    assign addrB = 3'b110;
    
    #(CYCLE*5)
    $stop;
	end
  
  registerBank reg_file(
	.clk(clk), .WE(WE),
    .addrA(addrA), .addrB(addrB), .inData(inData),
    .inAddr(inAddr),
    .outA(outA), .outB(outB)
  );
endmodule

在这里插入图片描述

PC和半导体存储器RAM

一、实验目的：

理解和掌握CPU中程序计数器PC和半导体存储器RAM的工作原理，并使用Verilog和ModelSim进行设计和仿真。

二、实验内容：

  1. 使用Verilog完成程序计数器PC的设计，要求：
     PC为8位计数器
  2. 使用Verilog完成数据存储器的设计，并编写测试仿真文件验证其正确性。要求：
     存储字长16位，存储容量1K字节；
     一根读写控制信号线控制读写，低电平有效。

三、源代码

PC.v

module MyPC(
    input clk, 
    input rst,
    output [7:0] PC
);
    reg [7:0] pc_T = 8'b0;
    
    always @(posedge clk or posedge rst) begin
        if(rst)
            pc_T = 8'b0;//8'b01011010;
        else
            pc_T = pc_T + 1'b1;
    end
    assign PC = pc_T;
endmodule

PC_tb.v

module MyPC_tb();
    reg clk;
    reg rst = 1'b0;
    wire [7:0] initAddr = 8'b10000000;
    wire [7:0] pcAddr;
     
    //wire [9:0] cnt = 10'd0;
    
    always #60 assign rst = ~rst;//if(cnt%0==100) clk = ~clk;
    //assign cnt = cnt + 1'd1; 
        initial begin
		    #0
		        assign clk = 1'b1;
				//assign rst = 1'b0;
			  #10
			      assign clk = 1'b0;
			  #20
			      assign clk = ~clk;
			   #30
			       assign clk = 1'b1;
			   #40
			       assign clk = 1'b0;
			   #50
			       assign clk = ~clk;
				/*
			#50
				assign clk = 1'b0;
			#100 clk = ~clk;
			*/
			#100 $stop;
        end
    MyPC pc1(
        .clk(clk),
        .rst(rst),
        //.initAddr(initAddr),
        .PC(PC)
    );

endmodule

在这里插入图片描述
RAM.v

module  MyRAM #( parameter DATA_WIDTH = 16,DEPTH = 1024)(
    //input;
    input    wire    clk,
    input    wire    WE, //write low enable;
    input    wire    [clogb2(DEPTH)-1:0] address,
    input    wire    [DATA_WIDTH-1:0] dataIn,
    //output;
    output   wire     [DATA_WIDTH-1:0] dataOut     
);

function integer clogb2 (input integer depth);
begin
    for (clogb2=0; depth>1; clogb2=clogb2+1) 
        depth = depth >>1;                          
end
endfunction 

(* ramstyle = "M9K" *) reg [DATA_WIDTH-1:0] memory[0:DEPTH-1];
reg [clogb2(DEPTH)-1:0] address_reg;
//read;

always @(posedge clk ) begin
    address_reg <= address;
end //always

assign dataOut = memory[address_reg];
//write;

always @(posedge clk ) begin
    if(~WE) begin
        memory[address] <= dataIn;
    end
end //always

endmodule

RAM_tb.v

`timescale 1ns/1ns
module MyRAM_tb ();
parameter CYCLE = 8;
parameter ADDR_WIDTH = 10;
parameter DATA_WIDTH = 16;

reg clk;
reg WE;
reg [ADDR_WIDTH-1:0] address;
reg [DATA_WIDTH-1:0] dataIn;

wire [DATA_WIDTH-1:0] dataOut;


MyRAM  tb_u1(
    .clk                (clk),
    .WE              (WE),
    .address          (address),
    .dataIn             (dataIn),
    .dataOut                (dataOut)
);

initial begin
    clk = 1'b0;
end
always #(CYCLE/2) clk = ~ clk;
always #(CYCLE/2) WE = ~ WE;

initial begin
    WE = 1'b1;
    address = 10'd0;
    dataIn = 0;
    
    #(CYCLE*2)      
    WE = 1'b0;
    address = 10'd1;
    dataIn = 16'habcc;
    
    #(CYCLE*3)      
    WE = 1'b0;
    address = 10'd2;
    dataIn = 16'hbbdd;
    
    #(CYCLE*4)      
    WE = 1'b0;
    address = 10'd3;
    dataIn = 16'hccee;//
    
    #(CYCLE*5)      
    WE = 1'b0;
    address = 10'd4;
    dataIn = 16'h1234;
    
    #(CYCLE*6)      
    WE = 1'b0;
    address = 10'd1;
    dataIn = 16'h568f;
    
    //#(CYCLE*100) 
    //$stop;
    
    #(CYCLE*7)      
    WE = 1'b0;
    address = 10'd2;
    dataIn = 16'h568e;
    
    #(CYCLE*8) 
    WE = 1'b0;
    address = 8'd3;
    dataIn = 16'h568c;
    
    #(CYCLE*9) 
    WE = 1'b0;
    address = 10'd4;
    dataIn = 16'h568a;
    
    #(CYCLE*10)
    $stop;
   
end

endmodule

后记

既来之 则赞之
若有疑问，欢迎评论
本文仅供参考，务必独立思考

秃秃然然
关注
专栏目录
cpu之ALU
coolsunxu的博客
12-19 3376
cpu之ALU
【此后无良辰】实验三 CPU部件实现之PC和半导体存储
qq_40493829的博客
08-03 1967
一、 实验目的 理解和掌握CPU中程序计数器PC和半导体存储器RAM的工作原理，并使用Verilog和ModelSim进行设计和仿真。 二、 实验内容 使用Verilog完成程序计数器PC的设计，要求： PC为8位计数器 使用Verilog完成数据存储器的设计，并编写测试仿真文件验证其正确性。要求 存储字长16位，存储容量1K字节； 一根读写控制信号线控制读写，低电平有效。 三、 实验原理 PC： 是用于存放下一条指令所在单元的地址的地方。当执行一条指令时，首先需要根据PC中存放的指令地址，将指
【计算机组成原理】实验三 CPU 部件实现之 PC 和半导体存储器 RAM
清风微醺的博客
06-02 2593
1. 使用 Verilog 完成程序计数器 PC 的设计，要求： PC 为 8 位计数器 module PC(clk,rst,y); input clk,rst; output y; reg[7:0] y; initial y = 0; always@(posedge clk or negedge rst)begin if(!rst) y = 0; else y = y + 1; end endmodule module test( ); re
实验三、CPU 部件实现之 PC 和半导体存储器 RAM
lalala_HFUT的博客
06-21 4403
实验三、CPU部件实现之PC和半导体存储器RAM 一、实验目的: 理解和掌握CPU中程序计数器PC和半导体存储器RAM的工作原理，并使用Verilog 和ModelSim进行设计和仿真。 二、实验内容: 使用Verilog完成程序计数器PC的设计，要求:PC为8位计数器 使用Verilog完成数据存储器的设计，并编写测试仿真文件验证...
【此后无良辰】实验二 CPU部件实现之ALU和寄存器堆
qq_40493829的博客
08-03 6464
一、 实验目的 理解和掌握CPU中的算术逻辑运算部件（ALU）和寄存器堆（Register File）的工作原理，并使用Verilog和ModelSim进行设计和仿真。 二、 实验内容 使用Verilog完成ALU的设计,并编写测试仿真文件验证其正确性。要求： ALU支持16位的加、减、与、或以及移位运算。 使用Verilog完成通用寄存器堆的设计，并编写测试仿真文件验证其正确性。要求 寄存器堆包含8个16位的寄存器； 寄存器堆有两个读端口和一个写端口。 三、 实验原理 ALU和寄存器堆的原
alu（cpu部件）
06-04
用vhdl语言编写cpu部件alu
合工大计组实验cpu设计报告.zip
06-30
计算机组成原理课设-cpu的设计，仅作学习参考 实验一、Verilog与ModelSim基础 实验二、CPU部件实现之ALU和寄存器堆 实验三、CPU部件实现之PC和半导体存储器RAM 实验四、单周期CPU设计与实现——单指令CPU
CPU设计——数据通路的设计与实现-四川大学计算机组成原理高分实验报告.doc
08-18
数据通路通常包括算术逻辑单元（ALU）、寄存器堆、指令计数器PC、多选器、加法器等部件。ALU是数据通路的核心，它可以执行如加法、减法、逻辑与、逻辑或、异或、非等基本运算。寄存器堆用于暂时存储数据和指令，而...
掌握单片机核心技术：CPU、ALU与寄存器详解
- 单片机中有一部分固定的特殊功能寄存器（SFR），它们专门用于实现特定功能，如定时器、中断控制器等，这些区域通常被总线控制，不能像普通RAM那样直接访问。 通过学习和理解这些知识点，可以更好地掌握单片机的...
Computer-1:这是计算机的新设计，其所有内部部件如CPU，RAM，CU等
04-15
标题中的“Computer-1”指的是一个新型计算机的设计概念，它涵盖了计算机系统的主要组成部分，包括CPU（中央处理器）、RAM（随机存取存储器）以及CU（可能是控制单元）。这个设计是在Logisim平台上实现的，Logisim是...
计算机组成原理寄存器堆实验报告.pdf
07-10
计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf计算机组成原理寄存器堆实验报告.pdf
计算机组成原理寄存器堆设计实验
12-16
1. 学习使用Verilog HDL语言进行时序电路的设计方法 2. 掌握灵活运用Verilog HDL语言进行行为级语言描述的技巧和方法; 3. 学习寄存器堆的数据传送和读写工作原理,掌握寄存器堆的设计方法.
MIPS 32位CPU中ALU的实现
03-27
组成原理实验设计，MIPS 32位CPU中ALU的实现。
计算机组成原理——半导体存储器原理实验
09-21
这是一个关于计算机组成原理中的半导体存储器原理实验
寄存器堆实验
12-31
本次实验要求掌握触发器的基本原理，掌握寄存器和寄存器堆的组成原理。
计算机组成原理实验报告 单周期控制部件及MIPS CPU实现
m0_51456787的博客
04-08 5138
目录一.实验目的二．实验设备及环境三．实验任务四. 实验步骤 一.实验目的 1．理解MIPS指令结构，理解MIPS指令集中常用指令的功能和编码。 2．熟悉单周期MIPS CPU控制部件及单周期CPU的工作原理及设计。 3．认识和掌握指令与CPU的关系、指令的执行过程。 4．掌握用Verilog HDL和EDA工具进行软件设计与仿真。 二．实验设备及环境 装有 Xilinx Vivado的 Windows 7计算机，FPGA。 三．实验任务 （1）学习MIPS指令集，深入理解常用指令的功能和编码，并进行归纳确
半导体存储器
redredredlu的专栏
04-21 752
半导体存储器(semi-conductor memory)是一种以半导体电路作为存储媒体的存储器,内存储器就是由称为存储器芯片的半导体集成电路组成。 按功能分类 按其功能可分为：随机存取存储器（简称RAM）和只读存储器（只读ROM） RAM包括DRAM（动态随机存取存储器）和SRAM（静态随机存取存储器），当关机或断电时，其中的信息都会随之丢失。 DRAM主要用于主存（内存的主体部分），
计算机组成原理学习笔记：ALU，寄存器和CPU
m0_66203806的博客
05-18 7568
ALU是计算机处理器中执行所有算术和逻辑操作的部件。它是执行实际计算的中心，可以执行加法、减法、乘法、除法等算术操作，以及AND、OR、NOT、XOR等逻辑操作。寄存器是CPU内部的高速存储资源，用于暂存指令、数据和地址等信息。它们是CPU中最快的存储部件。CPU是计算机的大脑，负责解释和执行程序中的指令。它控制数据流在计算机系统中的移动。
计算机组成原理——ALU
最新发布
TENET123的博客
07-02 5114
计算机组成原理——ALU
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值