西南交通大学 计算机组成原理实验课程设计

这篇具有很好参考价值的文章主要介绍了西南交通大学 计算机组成原理实验课程设计。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

 代码部分:

module CPU(  
input clk,              //时钟  
input reset,            //复位  
input [7:0]M_data_in,  
output reg Wirte_read,  
output [11:0]M_address,  
output [7:0]M_data_out,  
output reg overflow  
);  
//通用寄存器组  
reg[7:0]R0;  
reg[7:0]R1;  
reg[7:0]R2;  
reg[7:0]R3;  
reg[11:0]PC;    //程序计数器  
reg[15:0]IR;    //指令寄存器  
reg [7:0]Acc;   //累加寄存器/临时寄存器  
reg [8:0]temp;  //加减运算扩充符号位后的临时寄存器  
reg [11:0]MAR;  //内存地址寄存器  
reg [7:0]MDR;   //内存数据寄存器  
assign  M_address = MAR;  
assign  M_data_out = MDR;  
//状态  
localparam st_0  =  3'b000;  
localparam st_1  =  3'b001;  
localparam st_2  =  3'b010;  
localparam st_3  =  3'b011;  
localparam st_4  =  3'b100;  
reg [2:0]status /*synthesis preserve*/;  
//指令助记符  
parameter Idle = 4'b0000;  
parameter Load = 4'b0001;  
parameter Move = 4'b0010;  
parameter Add  = 4'b0011;  
parameter Sub  = 4'b0100;  
parameter AND  = 4'b0101;  
parameter OR   = 4'b0110;  
parameter XOR  = 4'b0111;  
parameter Shr  = 4'b1000;  
parameter Shl  = 4'b1001;  
parameter Swap = 4'b1010;  
parameter Jmp  = 4'b1011;  
parameter Jz   = 4'b1100;  
parameter Read = 4'b1101;  
parameter Write = 4'b1110;  
parameter Stop = 4'b1111;  
  
always @(*)   
begin  
    if(status == st_3 && reset == 1'b1 && IR[15:12] == Write)  
        Wirte_read = 1'b1;  
    else  
        Wirte_read = 1'b0;  
    if(status == st_1 && reset == 1'b1 && (IR[15:12]==Add || IR[15:12]==Sub)) 
        if(temp[8]^temp[7])   
            overflow = 1'b1;  
        else  
            overflow = 1'b0;  
    else    overflow = 1'b0;  
end  

 always @(posedge clk,negedge reset)  
begin  
    if(reset == 1'b0)  
        begin  
            R0 = 8'b0000_0000;  
            R1 = 8'b0000_0000;  
            R2 = 8'b0000_0000;  
            R3 = 8'b0000_0000;  
            PC = 8'b0000_0000;  
            IR = 16'h0000;  
            MDR = 8'b0000_0000;  
        end  
    else  
        case(status)  
            st_0:  
                begin  
                    IR[15:8] = M_data_in;  
                    IR[7:0]  = 8'b0000_0000;  
                    if(IR[15:12] != 4'b1111)  
                    PC = PC + 1'b1;  
                end  
            st_1:  
                begin  
                    case(IR[15:12])  
                        Idle:begin  end  
                        Load:begin  
                            R0 = IR[11:8];  
                            end  
                        Move:begin  
                            case(IR[11:10])  
                                2'b00:R0 = Acc;  
                                2'b01:R1 = Acc;  
                                2'b10:R2 = Acc;  
                                2'b11:R3 = Acc;  
                            endcase  
                            end  
                        Add:begin  
                            case(IR[11:10])  
                                2'b00:begin  
                                    temp = {R0[7],R0}+{Acc[7],Acc};  
                                    R0 = temp[7:0];  
                                    end  
                                2'b01:begin  
                                    temp = {R1[7],R1}+{Acc[7],Acc};  
                                    R1 = temp[7:0];  
                                    end  
                                2'b10:begin  
                                    temp = {R2[7],R2}+{Acc[7],Acc};  
                                    R2 = temp[7:0];  
                                    end  
                                2'b11:begin  
                                    temp = {R3[7],R3}+{Acc[7],Acc};  
                                    R3 = temp[7:0];  
                                    end   
                            endcase  
                            end  
                        Sub:begin  
//先求-Acc的补码,将补码减法变为补码加法 (x-y)补=x补+(-y)  
//对于这里没有直接将-Acc的补码存在Acc寄存器里的解释:  
//因为在时钟下降沿那个always块里有Acc的赋值,同一个寄存器的赋值不能出现在多个always语句里,会产生冲突  
//虽然一个时钟上升沿一个时钟下降沿不会产生冲突,但是编译时仍会报错  
//这也是为什么寄存器的清零一部分放在时钟上升沿时,一部分放在时钟下降沿时  
                            temp[7:0] = ~Acc;  
                            temp[7:0] = temp + 1'b1;  
                            temp[8] = temp[7];  
                            case(IR[11:10])  
                                2'b00:begin  
                                    temp = {R0[7],R0}+temp;  
                                    R0 = temp[7:0];  
                                    end  
                                2'b01:begin  
                                    temp = {R1[7],R1}+temp;  
                                    R1 = temp[7:0];  
                                    end  
                                2'b10:begin  
                                    temp = {R2[7],R2}+temp;  
                                    R2 = temp[7:0];  
                                    end  
                                2'b11:begin  
                                    temp = {R3[7],R3}+temp;  
                                    R3 = temp[7:0];  
                                    end   
                            endcase  
                            end  
                        AND:begin  
                            case(IR[11:10])  
                                2'b00:R0 = R0 & Acc;  
                                2'b01:R1 = R1 & Acc;  
                                2'b10:R2 = R2 & Acc;  
                                2'b11:R3 = R3 & Acc;  
                            endcase  
                            end  
                        OR:begin  
                            case(IR[11:10])  
                                2'b00:R0 = R0 | Acc;  
                                2'b01:R1 = R1 | Acc;  
                                2'b10:R2 = R2 | Acc;  
                                2'b11:R3 = R3 | Acc;  
                            endcase  
                            end  
                        XOR:begin  
                            case(IR[11:10])  
                                2'b00:R0 = R0 ^ Acc;  
                                2'b01:R1 = R1 ^ Acc;  
                                2'b10:R2 = R2 ^ Acc;  
                                2'b11:R3 = R3 ^ Acc;  
                            endcase  
                            end  
                        Shr:begin  
                            case(IR[11:10])  
                                2'b00:R0 = R0 >>1;  
                                2'b01:R1 = R1 >>1;  
                                2'b10:R2 = R2 >>1;  
                                2'b11:R3 = R3 >>1;  
                            endcase  
                            end  
                        Shl:begin  
                            case(IR[11:10])  
                                2'b00:R0 = R0 <<1;  
                                2'b01:R1 = R1 <<1;  
                                2'b10:R2 = R2 <<1;  
                                2'b11:R3 = R3 <<1;  
                            endcase  
                            end  
                        Swap:begin  
                            case(IR[9:8])  
                                2'b00:case(IR[11:10])  
                                            2'b00:R0 = R0;  
                                            2'b01:R0 = R1;  
                                            2'b10:R0 = R2;  
                                            2'b11:R0 = R3;  
                                        endcase  
                                2'b01:case(IR[11:10])  
                                            2'b00:R1 = R0;  
                                            2'b01:R1 = R1;  
                                            2'b10:R1 = R2;  
                                            2'b11:R1 = R3;  
                                        endcase  
                                2'b10:case(IR[11:10])  
                                            2'b00:R2 = R0;  
                                            2'b01:R2 = R1;  
                                            2'b10:R2 = R2;  
                                            2'b11:R2 = R3;  
                                        endcase  
                                2'b11:case(IR[11:10])  
                                            2'b00:R3 = R0;  
                                            2'b01:R3 = R1;  
                                            2'b10:R3 = R2;  
                                            2'b11:R3 = R3;  
                                        endcase  
                            endcase  
                            end  
                        Jmp:begin   end  
                        Jz:begin    end  
                        Read:begin  end  
                        Write:begin end  
                        Stop:begin  end  
                    endcase  
                end   
            st_2:  
                begin  
                    case(IR[15:12])  
                        Swap:  
                            case(IR[11:10])  
                                2'b00:R0 = Acc;  
                                2'b01:R1 = Acc;  
                                2'b10:R2 = Acc;  
                                2'b11:R3 = Acc;  
                            endcase  
                        Jmp:begin  
                            IR[7:0] = M_data_in;  
                            PC = PC +1'b1;  
                            end  
                        Jz:begin  
                            IR[7:0] = M_data_in;  
                            PC = PC +1'b1;  
                            end  
                        Read:begin  
                            IR[7:0] = M_data_in;  
                            PC = PC +1'b1;  
                            end  
                        Write:begin  
                            IR[7:0] = M_data_in;  
                            PC = PC +1'b1;  
                            MDR = R0;  
                            end  
                    endcase  
                end  
            st_3:  
                begin  
                    case(IR[15:12])  
                        Jmp:PC = IR[11:0];  
                        Jz:begin  
                            if(R0==4'b0000)  
                                PC = IR[11:0];  
                        end  
                        Read:begin  end  
                        Write:begin end  
                    endcase  
                end  
            st_4:  
                begin  
                    case(IR[15:12])  
                        Read:R0 = M_data_in;  
                        Write:begin end  
                    endcase  
                end  
        endcase  
end  
  
always @(negedge clk,negedge reset)  
begin  
    if(reset == 1'b0)  
        begin  
            status = st_0;  
            Acc = 8'b0000_0000;  
            MAR = 8'b0000_0000;  
        end  
    else  
        case(status)  
            st_0:  
                begin  
                MAR = PC;  
                case(IR[9:8])  
                    2'b00:Acc = R0;  
                    2'b01:Acc = R1;  
                    2'b10:Acc = R2;  
                    2'b11:Acc = R3;  
                endcase  
                    status = st_1;  
                end  
            st_1:  
                begin  
                    case(IR[15:12])  
                        Swap:status = st_2;  
                        Jmp:status = st_2;  
                        Jz:status = st_2;  
                        Read:status = st_2;  
                        Write:status = st_2;  
                        default:status = st_0;  
                    endcase  
                end  
            st_2:  
                begin  
                    case(IR[15:12])  
                        Jmp:begin  
                            MAR = IR[11:0];  
                            status = st_3;  
                            end  
                        Jz:begin  
                            if(R0 == 4'b0000)  
                                MAR = IR[11:0];  
                            else  
                                MAR = PC;  
                            status = st_3;  
                            end  
                        Read:begin  
                            MAR = IR[11:0];  
                            status = st_3;  
                            end  
                        Write:begin  
                            MAR = IR[11:0];  
                            status = st_3;  
                            end  
                        default:status = st_0;  
                    endcase  
                end  
            st_3:  
                begin  
                    case(IR[15:12])  
                        Read:begin    
                            MAR = PC;  
                            status = st_4;  
                        end  
                        Write:begin   
                            MAR = PC;  
                            status = st_4;  
                        end  
                        default:status = st_0;  
                    endcase  
                end  
            st_4:status = st_0;  
        endcase  
end  
endmodule  

波形图部分:

西南交通大学 计算机组成原理实验课程设计,verilog,fpga开发,经验分享

(上图Load为2节拍,我之前写错了。。。这里忘了改了)

西南交通大学 计算机组成原理实验课程设计,verilog,fpga开发,经验分享

西南交通大学 计算机组成原理实验课程设计,verilog,fpga开发,经验分享

西南交通大学 计算机组成原理实验课程设计,verilog,fpga开发,经验分享文章来源地址https://www.toymoban.com/news/detail-536427.html

到了这里,关于西南交通大学 计算机组成原理实验课程设计的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 南京大学数字电路与计算机组成实验的Verilator仿真(二)

    top.v sim_main.cpp 仿真结果 top.v sim_main.cpp 仿真结果 top.v sim_main.cpp top.v bcd7seg.v sim_main.cpp nvboard约束文件 top.nxdc Makefile文件 结果展示

    2024年02月15日
    浏览(34)
  • 山东大学计算机组成与设计实验七 节拍脉冲发生器时序电路

    山东大学计算机组成与设计实验七 节拍脉冲发生器时序电路实验, 山东大学计算机组成与设计实验, 山东大学计算机组成与设计实验报告, 计算机组成原理实验报告, 山东大学计算机组成原理实验报告 掌握节拍脉冲发生器的设计方法,理解节拍脉冲发生器的工作原理。 连续节

    2023年04月15日
    浏览(51)
  • 大连交通大学813软件工程考研习题

    1.什么是软件生存周期模型?有哪些主要模型? 生存周期模型:描述软件开发过程中各种活动如何执行的模型。对软件开发提供强有力的支持,为开发过程中的活动提供统一的政策保证,为参与开发的人员提供帮助和指导,是软件生存周期模型化技术的基础,也是建立软件开发

    2024年02月13日
    浏览(37)
  • 24大连交通大学软件工程813题库

    1.下面错误的说法是(  )。     A.  每个数据流必须用名词或名词短语命名     B.每个加工必须有名字,通常是动词短语     c.每个数据存储必须用名词或名词短语 D.每个数据源点或终点必须有名字 答案:C 2.下面错误的说法是(  )。     A.判定表能够把在什么

    2024年02月14日
    浏览(37)
  • 24大连交通大学813软件工程考研习题

    1.等价分类法相关概念。 (1)等价分类法的基本思想是什么? 根据程序的输入特性,将程序的定义域划分为有限个等价区段 —“等价类”,从等价类中选择出的用例具有“代表性”,即测试某个等价类的代表值就等价于对这一类其它值的测试。如果某个等价类的一个输入数

    2024年02月13日
    浏览(31)
  • 高校教务系统登录页面JS分析——重庆交通大学

    本文将介绍高校教务系统的密码加密逻辑以及使用JavaScript进行逆向分析的过程。通过本文,你将了解到密码加密的基本概念、常用加密算法以及如何通过逆向分析来破解密码。 本文仅供交流学习,勿用于非法用途。 密码加密是一种保护信息安全的技术手段,它通过将明文(

    2024年02月07日
    浏览(35)
  • 体验文心一言AI大模型生成伊利诺伊大学香槟分校、复旦大学、上海交通大学、东南大学和加州伯克利大学简介

    UIUC(University of Illinois at Urbana-Champaign)是美国伊利诺伊大学香槟分校的简称。该学校成立于1868年,位于美国伊利诺伊州香槟市,是一所公立研究型大学。UIUC是美国著名的常春藤盟校之一,在多个学科领域享有声誉,包括工程、商科、建筑、心理学、法学、医学、农学等。

    2024年02月11日
    浏览(49)
  • 最长公共子序列(上海交通大学考研机试题)

    题目描述 给出两个长度为 n 的整数序列,求它们的最长公共子序列(LCS)的长度,保证第一个序列中所有元素都不重复。 注意: 第一个序列中的所有元素均不重复。 第二个序列中可能有重复元素。 一个序列中的某些元素可能不在另一个序列中出现。 输入样例 5 2 1 3 8 7 2

    2024年02月09日
    浏览(25)
  • 【西安交通大学】:融合传统与创新的学府之旅

    🎉博客主页:小智_x0___0x_ 🎉欢迎关注:👍点赞🙌收藏✍️留言 🎉系列专栏:小智带你闲聊 🎉代码仓库:小智的代码仓库 西安交通大学是国家教育部直属重点大学,为我国最早兴办的高等学府之一。其前身是1896年创建于上海的南洋公学,1921年改称交通大学,1956年国务院

    2024年02月15日
    浏览(23)
  • 西安交通大学SQ轴承数据集(文末附数据)

    我们公开了一份基于振动信号的轴承数据集,数据来源于西安交通大学SQ(Spectra Quest)实验平台。 实验利用SQ(Spectra Quest)公司的机械故障综合模拟试验台进行电机轴承外圈和内圈故障模拟,采集了三种转频(19.05Hz、29.05Hz、39.05Hz)下三种不同程度故障(轻度故障、中度故障

    2024年02月02日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包