devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MIPS指令集单周期CPU兼Verilog学习_cpu单周期指令

作者：你好赵伟 | 2024-03-20 09:00:03

赞

踩

cpu单周期指令

1.单周期CPU原理（单个时钟周期内的操作）：

        （1）取指，PC+4

        （2）译码

        （3）取操作数，ALU运算

        （4）访存（MEM）

        （5）写回（RegWr）

        将每一级操作抽象为CPU中的若干个模块：

                （1）指令读取模块（指令存储器）

                （2）指令寄存器（IR）

                （3）数据寄存器（rs,rt,rd）

                （4）逻辑运算器件（ALU）

                （5）数据存储器

                （6）控制单元

2.实验要求

        MIPS指令集三种指令：

        R型指令：

                汇编代码格式：op rd,rs,rt

                机器中存储：

                

                含义：[rs]+[rt]  \rightarrow [rd]

         I型指令：

                汇编代码格式：op rt,rs,imm16

                机器中存储：

                

                含义：[rs]+imm16 \rightarrow [rt] 

        J型指令：  

                汇编代码格式：op imm26

                机器中存储：

                

                需要注意的是，这里的跳转地址为： PC高四位+imm26+00   ，构成了32的地址

                来看下MIPS指令集：

        来看一下整体的数据通路：

3.代码实现        

         看上去非常复杂，我们把每个元件单拎出来看输入和输出：

            1）符号扩展单元Extender

                   符号扩展单元看起来比较简单，它的作用：

                            （1）将imm16符号扩展至32位后送至ALU

                               

                   ExtOp=\left\{\begin{matrix} 0 &,ZeroExt& \\ 1&,SignExt \end{matrix}\right.

              input1：[15:0] imm16,           input2：ExtOp

              output：[31:0] imm32

        扩展器模块代码如下（extender.v）：         

  1. module extender(
  2.     input [15:0] imm16,
  3.     input ExtOp,
  4.     output [31:0] imm32
  5.     );
  6.  
  7.     //ExtOp 为 0 做零扩展，为 1 做符号扩展
  8.     //imm16是以补码储存在机器中的
  9.  
  10.     assign imm32 = {imm16[15],{16{1'b0}},imm16[14:0]}; 
  11.  
  12.     
  13. endmodule

     进行一下简单的仿真（extender_tb.v）：

  1. module extender_tb();
  2.     reg [15:0] imm16;
  3.     reg ExtOp;
  4.     wire [31:0] imm32;
  5.     
  6.     initial begin
  7.         imm16 = 16'b1111111111111111;
  8.         ExtOp = 1;
  9.     end
  10.     
  11.     extender test(imm16,ExtOp,imm32);
  12.     
  13. endmodule

          11...11经过符号扩展后变成了10...0011...111，观察仿真波形：

 扩展器完成！

           2）pc模块

                  pc的输入输出：input1：pc_new(经过+4的pc 或者 跳转地址)

                                            input2：clk(在板子上是手动的按键/上升沿触发)

                                            input3：reset(pc复位信号，由板子上的SW0给出)

                                            output1：pc_out(输出到InsMem中)

                                            output2：pc_plus(经过+4的pc，这样可以节省一个专门pc+4器件)  

                   pc模块参考代码（pc.v）： 注：这里的pc_out设置一个初始值0

  1. `timescale 1ns / 1ps
  2.  
  3. module pc(
  4.     input [31:0] pc_in,
  5.     input clk,
  6.     input reset,
  7.     output reg[31:0] pc_out,   //输出到mem进行取指
  8.     output [31:0] pc_plus   //经过+4的pc
  9.     );
  10.     
  11.     initial begin
  12.         pc_out = 0;
  13.     end
  14.     
  15.     always @(posedge clk) begin
  16.         if(reset == 0) begin
  17.             pc_out=pc_in;
  18.        end 
  19.        else begin
  20.             pc_out=0;
  21.        end
  22.     end
  23.     
  24.     assign pc_plus = pc_out + 4;
  25.     
  26. endmodule

         pc模块测试用的仿真文件（pc_tb.v）:

  1. module pc_tb();
  2.     reg clk;
  3.     reg[31:0] pc_in;
  4.     reg reset;
  5.     wire[31:0] pc_out;
  6.     wire[31:0] pc_plus;
  7.     
  8.     initial begin
  9.         clk=0;
  10.         pc_in=0;
  11.         reset=0;
  12.     end
  13.     
  14.     always @(*) begin
  15.             #5 clk <= ~clk;
  16.         end
  17.     
  18.     pc pc_test(pc_in,clk,reset,pc_out,pc_plus);
  19.  
  20. endmodule

               pc和自增模块完成！

       3）指令存储器模块（InsMem）

                功能：根据输入的pc，在存储器中找到pc所指向的那条指令后，将其发送给各个部件。

                输入：input1：pc

                           output：经过拆解过的指令

                注：(1)存储器的指令写入要在模块中实现而不是在仿真中实现

                       (2)将存储器设计为32位的寄存器组而不是8位的寄存器组有一个好处：当读入16进制的文件时，8位的寄存器会两个两个数据读，因此在读入单条（正常顺序）                            的指令时，顺序会错乱。比如：

                           

                         这时8位寄存器组的存储内容会为：0111_1000_0101_0110_0011_0100_ 0001_0010

                         这样做指令分割的时候会非常麻烦。

                下面来看下InsMem模块的代码（InsMem.v）：

  1.  
  2. module InsMem(
  3.     input [31:0]addr,   //即pc值
  4.     output [5:0]op,     //31:26
  5.     output [4:0]rs,     //25:21
  6.     output [4:0]rt,     //20:16
  7.     output [4:0]rd,     //15:11
  8.     output [4:0]shamt,  //10:6
  9.     output [5:0]func    //5:0
  10.     
  11.     );
  12.     
  13.     reg [31:0] mem [63:0];  //最多可存64条指令
  14.     initial begin
  15.         $readmemh("D:/meiyong/testdata.txt",mem);
  16.     end
  17.     
  18.     assign op = mem[addr >> 2][31:26];      //这里用的是32位的指令寄存器组，因此pc要除以4
  19.     assign rs = mem[addr >> 2][25:21];
  20.     assign rt = mem[addr >> 2][20:16];
  21.     assign rd = mem[addr >> 2][15:11];
  22.     assign shamt = mem[addr >> 2][10:6];
  23.     assign func = mem[addr >> 2][5:0];
  24.     
  25.     
  26. endmodule

                写个仿真测试一下（test_insmem_tb.v）：

  1. module test_insmem_tb( );
  2.     reg [31:0] addr;
  3.     wire [5:0]op;     //31:26
  4.     wire [4:0]rs;     //25:21
  5.     wire [4:0]rt;     //20:16
  6.     wire [4:0]rd;     //15:11
  7.     wire [4:0]shamt;  //10:6
  8.     wire [5:0]func;
  9.     
  10.     InsMem tset_insmem(addr,op,rs,rt,rd,shamt,func);
  11.     
  12.     initial begin
  13.         addr = 0;
  14.     end
  15.     
  16. endmodule

                  检验一下输出波形：

                                                                                      

               注：第一条指令是12345678

        4）数据存储器模块（dataMem）

                数据存储器也跟指令存储器一样采用32位的寄存器组来实现。

                输入：访问/写入地址，写入的数据，写使能信号Wr。

                输出：读出的数据

                数据存储器模块代码（dataMem.v）：

  1. `timescale 1ns / 1ps
  2.  
  3. module dataMem(
  4.     input clk,
  5.     input [31:0] dataAdd,
  6.     input [31:0] dataIn,
  7.     input dataWr,
  8.     output reg[31:0] dataOut
  9.     );
  10.     
  11.     integer i;
  12.     reg [31:0] mem [511:0];
  13.     
  14.     initial begin 
  15.         for(i=0;i<512;i=i+1) begin
  16.             mem[i] <= 0;
  17.         end
  18.     end
  19.     
  20.     always @(posedge clk) begin 
  21.         if(dataWr == 1) begin
  22.             mem[dataAdd>>2] <= dataIn; 
  23.         end
  24.     end
  25.     
  26.     always @(*) begin
  27.         dataOut <= mem[dataAdd>>2]; 
  28.     end
  29. endmodule

        

          5）数据寄存器组模块（Register）

                寄存器组内有32个32位的通用寄存器，通过rs、rt、rd来指定访问的是哪个寄存器。

                输入：input1：clk        input2：rs，rt，rd        input3：distSel（写哪个寄存器，rt还是rd）        input4：RegWr        input5：将写入rd的dataIn

                输出：两条线out1和out2

                数据寄存器模块源代码（Register.v）：

  1. module Register(
  2.     input clk,
  3.     input [4:0]rs,
  4.     input [4:0]rt,
  5.     input [4:0]rd,
  6.     input distSel,  //写入rt还是rd,0写rt，1写rd
  7.     input RegWr,
  8.     input [31:0]dataIn,
  9.     output reg[31:0]out1,
  10.     output reg[31:0]out2
  11.     );
  12.     
  13.     reg [31:0] Reg[31:0];   //32个通用寄存器
  14.     
  15.     integer i;
  16.     //对寄存器初始化
  17.     initial begin
  18.         for (i = 0; i < 32; i = i+ 1) Reg[i] <= 0;  
  19.     end
  20.     
  21.     always @(posedge clk) begin
  22.         if(RegWr == 1) begin 
  23.               case(distSel) 
  24.                 0: Reg[rt] = dataIn;  //写rt
  25.                 1: Reg[rd] = dataIn; //写rd
  26.               endcase       
  27.         end
  28.     end
  29.     
  30.     always @(*) begin
  31.         out1 <= Reg[rs];
  32.         out2 <= Reg[rt];
  33.     end
  34.     
  35. endmodule

                测试用的仿真代码（Reg_test_tb.v）： //这里把Register中Reg的初始化改成了 Reg[i] = i ;

  1. module Reg_test_tb( );
  2.     reg clk;
  3.     reg [4:0]rs;
  4.     reg [4:0]rt;
  5.     reg [4:0]rd;
  6.     reg distSel;
  7.     reg RegWr;
  8.     reg [31:0]dataIn;
  9.     wire [31:0]out1;
  10.     wire [31:0]out2;
  11.     
  12.     Register myReg(clk,rs,rt,rd,distSel,RegWr,dataIn,out1,out2);
  13.     
  14.     initial begin
  15.         clk=0;
  16.         rs=5'b00101;
  17.         rt=5'b00110;
  18.         rd=5'b00111;
  19.         distSel=1;   
  20.         RegWr=0;
  21.         dataIn=0;
  22.     end
  23.     
  24.     always @(*)  begin
  25.         #5 clk <= ~clk;
  26.     end
  27.     
  28. endmodule

                out1和out2的波形如下：

         6）运算单元模块（ALU）

                这是和控制单元一样最为复杂的模块,先来看看需要实现多少个函数：

         虽然有20（21）个函数，但是总结起来，ALU部件要用的也就9种操作，因此ALUop码只需要四位（0000~1000）。

ALUop功能涉及到的指令

0000

两数相加add，addi
0001两数相减sub，subi
0010按位与and，andi
0011按位或or，ori
0100按位异或xor，xori
0101逻辑右移(直接移)srl
0110逻辑左移(直接移)sll
0111算术右移(补符号位)sra
1000比较是否相等beq，bne
1001设置高位lui

               注意区分算术移位和逻辑移位。

                逻辑移位：直接移位，空的地方补0。

                算术右移：空出的位全部补符号位。

                运算器模块代码（ALU.v）:

  1. `timescale 1ns / 1ps
  2.  
  3.  
  4.  
  5. module ALU(
  6.         input [3:0]ALUop,
  7.         input [31:0]in1,    //可能是rs或者shamt
  8.         input [31:0]in2,    //可能是rt或者imm16
  9.         output reg zero,    //用来指示beq是否相等，1相等，0不相等
  10.         output reg[31:0] res
  11.     );
  12.     
  13.      integer i;
  14.      
  15.     
  16.     always @(*) begin 
  17.         case (ALUop)
  18.             //求和
  19.             4'b0000: begin 
  20.                 res = in1 + in2;  
  21.                 zero = 0; 
  22.             end
  23.             //求差
  24.             4'b0001: begin
  25.                 res = in1 - in2;
  26.             end
  27.             //按位与
  28.             4'b0010: begin
  29.                 res = in1 & in2;
  30.             end
  31.             //按位或
  32.             4'b0011: begin 
  33.                 res = in1 | in2;
  34.             end
  35.             //按位异或
  36.             4'b0100: begin
  37.                 res = in1 ^ in2;
  38.             end
  39.             //直接右移,in1是shamt，in2是rt
  40.             4'b0101: begin
  41.                 res = in2 >> in1[4:0]; 
  42.             end
  43.             //直接左移
  44.             4'b0110:begin
  45.                 res = in2 << in1[4:0];
  46.             end
  47.             //补符号位右移
  48.             4'b0111: begin
  49.                 res = in2 >> in1[4:0];
  50.                 if(in2[31]==1'b1) begin
  51.                     for(i=0;i<in1;i=i+1)  res[31-i] = 1;
  52.                 end
  53.                 else begin
  54.                     for(i=0;i<in1;i=i+1)  res[31-i] = 0;
  55.                 end
  56.             end
  57.             //判断相等
  58.             4'b1000: begin
  59.                 zero = in1==in2 ? 1'b1 : 1'b0;
  60.             end
  61.             //lui指令：设置rt的高16位
  62.             4'b1001: begin
  63.                 res = {in2[31],in2[14:0],{16{0}}};
  64.             end
  65.         endcase
  66.     end
  67.     
  68. endmodule

                测试一下算术右移功能（ALU_test_tb.v）:

  1. module ALU_test_tb();
  2.     reg[3:0] ALUop;
  3.     reg[31:0] in1;
  4.     reg[31:0] in2;
  5.     wire zero;
  6.     wire[31:0] res;
  7.     
  8.     initial begin
  9.         ALUop = 4'b0111;
  10.         in1 = 5'b00100;
  11.         in2 = 32'hf1234567;
  12.     end
  13.     
  14.     ALU testALU(ALUop,in1,in2,zero,res);
  15.     
  16. endmodule

      7）pc选择（PCselect）

               该模块用一个四选一的数据选择器来实现，输出的是pc的下一个值，即下一步要运行指的令的地址。

               输入的四个信号分别为：

序号功能所服务的指令
0正常进行下一条指令正常指令

1

beq或bne指令生效所跳转到的指令地址beq，bne
2无条件跳转j
3跳转到rs内的值jr

                jr指令：jr rs        含义：rs寄存器中存有下条指令的地址，pc改为rs内存的值。

                PC选择器模块代码（PCselect.v）:

  1. `timescale 1ns / 1ps
  2.  
  3. //本模块用来选择最后的pc
  4. module PCselect(
  5.     input [31:0]addedPC,    //加过4的PC
  6.     input [31:0]ex_imm32,
  7.     input [25:0]jAddr,
  8.     input [31:0]jr_rs,
  9.     input [1:0]sel,
  10.     output reg[31:0]finalPC
  11. );
  12.  
  13.     always@(*) begin
  14.         case (sel) 
  15.             0: finalPC <= addedPC;  //正常执行下一条指令
  16.             1: finalPC <= addedPC+(ex_imm32<<2); //beq或者bne跳转指令生效
  17.             2: finalPC <= {addedPC[31:28],jAddr[25:0],0,0}; //无条件跳转指令
  18.             3: finalPC <= jr_rs;
  19.         endcase
  20.     end
  21.     
  22. endmodule

      8）控制单元（control）

                输入：指令的op和funct码，ALU的zero（判断rs、rt，0不相等，1相等）

                输出：(1)PC的reset         (2)PCsel的选择信号，选择下条指令地址                                                                                                                                                                                     (3)ALU要进行的操作ALUop         (4)reg的写信号RegWr；选择哪个寄存器reg_distSel；进入寄存器的是ALUresult还是从数据存储器来的信号：regIn_sel                                 (5)ALU的两个输入ALUin1_sel, ALUin2_sel：第一个选rs还是shamt ， 第二个选rt还是imm32.                                                                                                                               (6)dataMem的写信号memWr.

                控制模块源代码（control.v）:

  1. `timescale 1ns / 1ps
  2.  
  3. module control(
  4.     input [5:0] op,
  5.     input [5:0] funct,
  6.     input zero,
  7.  //   input PC_reset,
  8.     output reg[3:0]ALUop,
  9.     output reg[1:0]PCsel,
  10.     output reg reg_distSel,
  11.     output reg regWr,
  12.     output reg dataWr,
  13.     output reg ALUin1_sel,  //选rs还是shamt，0是rs，1是shamt
  14.     output reg ALUin2_sel,   //选rt还是imm,0是rt，1是imm
  15.     output reg regIn_sel    //选ALUout还是dataMem_out,0是ALUout，1是dataMem_out
  16.     );
  17.     
  18.     
  19.     always @(*) begin
  20.         case(op)
  21.              //r型指令
  22.             6'b000000:begin     
  23.                 case(funct)
  24.                     //add
  25.                     6'b100000:begin
  26.      //                   PC_reset <= 0;
  27.                         ALUop <= 4'b0000;
  28.                         PCsel <= 2'b00;
  29.                         reg_distSel <= 1;
  30.                         regWr <= 1;
  31.                         dataWr <= 0;
  32.                         ALUin1_sel <= 0;
  33.                         ALUin2_sel <= 0;
  34.                         regIn_sel <= 0;
  35.                     end 
  36.                     //sub
  37.                     6'b100010:begin
  38.              //           PC_reset <= 0;
  39.                         ALUop <= 4'b0001;
  40.                         PCsel <= 2'b00;
  41.                         reg_distSel <= 1;
  42.                         regWr <= 1;
  43.                         dataWr <= 0;
  44.                         ALUin1_sel <= 0;
  45.                         ALUin2_sel <= 0;
  46.                         regIn_sel <= 0;
  47.                     end
  48.                     //and
  49.                     6'b100100:begin
  50.               //          PC_reset <= 0;
  51.                         ALUop <= 4'b0010;
  52.                         PCsel <= 2'b00;
  53.                         reg_distSel <= 1;
  54.                         regWr <= 1;
  55.                         dataWr <= 0;
  56.                         ALUin1_sel <= 0;
  57.                         ALUin2_sel <= 0;
  58.                         regIn_sel <= 0;
  59.                     end
  60.                     //or
  61.                     6'b100101:begin
  62.          //               PC_reset <= 0;
  63.                         ALUop <= 4'b0011;
  64.                         PCsel <= 2'b00;
  65.                         reg_distSel <= 1;
  66.                         regWr <= 1;
  67.                         dataWr <= 0;
  68.                         ALUin1_sel <= 0;
  69.                         ALUin2_sel <= 0;
  70.                         regIn_sel <= 0;
  71.                     end
  72.                     //xor
  73.                     6'b100110:begin
  74.             //            PC_reset <= 0;
  75.                         ALUop <= 4'b0100;
  76.                         PCsel <= 2'b00;
  77.                         reg_distSel <= 1;
  78.                         regWr <= 1;
  79.                         dataWr <= 0;
  80.                         ALUin1_sel <= 0;
  81.                         ALUin2_sel <= 0;
  82.                         regIn_sel <= 0;
  83.                     end
  84.                     //sll
  85.                     6'b000000:begin
  86.              //           PC_reset <= 0;
  87.                         ALUop <= 4'b0110;
  88.                         PCsel <= 2'b00;
  89.                         reg_distSel <= 1;
  90.                         regWr <= 1;
  91.                         dataWr <= 0;
  92.                         ALUin1_sel <= 1;
  93.                         ALUin2_sel <= 0;
  94.                         regIn_sel <= 0;
  95.                     end
  96.                     //srl
  97.                     6'b000010:begin
  98.           //              PC_reset <= 0;
  99.                         ALUop <= 4'b0101;
  100.                         PCsel <= 2'b00;
  101.                         reg_distSel <= 1;
  102.                         regWr <= 1;
  103.                         dataWr <= 0;
  104.                         ALUin1_sel <= 1;
  105.                         ALUin2_sel <= 0;
  106.                         regIn_sel <= 0;
  107.                     end
  108.                     //sra
  109.                     6'b000011:begin
  110.                //         PC_reset <= 0;
  111.                         ALUop <= 4'b0111;
  112.                         PCsel <= 2'b00;
  113.                         reg_distSel <= 1;
  114.                         regWr <= 1;
  115.                         dataWr <= 0;
  116.                         ALUin1_sel <= 1;
  117.                         ALUin2_sel <= 0;
  118.                         regIn_sel <= 0;
  119.                     end
  120.                     //jr
  121.                     6'b001000:begin
  122.                 //        PC_reset <= 0;
  123.                         ALUop <= 4'b0111;   //无所谓
  124.                         PCsel <= 2'b11; //PC选择rs的内容
  125.                         reg_distSel <= 0;
  126.                         regWr <= 0;
  127.                         dataWr <= 0;
  128.                         ALUin1_sel <= 0;
  129.                         ALUin2_sel <= 0;
  130.                         regIn_sel <= 0;
  131.                     end
  132.                 endcase
  133.             end
  134.             //下面是I型指令  
  135.             //addi
  136.             6'b001000:begin
  137.      //           PC_reset <= 0;
  138.                 ALUop <= 4'b0000;
  139.                 PCsel <= 2'b00;
  140.                 reg_distSel <= 0;
  141.                 regWr <= 1;
  142.                 dataWr <= 0;
  143.                 ALUin1_sel <= 0;
  144.                 ALUin2_sel <= 1;
  145.                 regIn_sel <= 0;
  146.             end
  147.             //andi
  148.             6'b001100:begin
  149.      //           PC_reset <= 0;
  150.                 ALUop <= 4'b0001;
  151.                 PCsel <= 2'b00;
  152.                 reg_distSel <= 0;
  153.                 regWr <= 1;
  154.                 dataWr <= 0;
  155.                 ALUin1_sel <= 0;
  156.                 ALUin2_sel <= 1;
  157.                 regIn_sel <= 0;
  158.             end
  159.             //ori
  160.             6'b001101:begin
  161.           //      PC_reset <= 0;
  162.                 ALUop <= 4'b0011;
  163.                 PCsel <= 2'b00;
  164.                 reg_distSel <= 0;
  165.                 regWr <= 1;
  166.                 dataWr <= 0;
  167.                 ALUin1_sel <= 0;
  168.                 ALUin2_sel <= 1;
  169.                 regIn_sel <= 0;
  170.             end
  171.             //xori
  172.             6'b001110:begin
  173.        //         PC_reset <= 0;
  174.                 ALUop <= 4'b0100;
  175.                 PCsel <= 2'b00;
  176.                 reg_distSel <= 0;
  177.                 regWr <= 1;
  178.                 dataWr <= 0;
  179.                 ALUin1_sel <= 0;
  180.                 ALUin2_sel <= 1;
  181.                 regIn_sel <= 0;
  182.             end
  183.             //lw
  184.             6'b100011:begin
  185.        //         PC_reset <= 0;
  186.                 ALUop <= 4'b0000;
  187.                 PCsel <= 2'b00;
  188.                 reg_distSel <= 0;
  189.                 regWr <= 1;
  190.                 dataWr <= 0;
  191.                 ALUin1_sel <= 0;
  192.                 ALUin2_sel <= 1;
  193.                 regIn_sel <= 1;
  194.             end
  195.             //sw
  196.             6'b101011:begin
  197.        //         PC_reset <= 0;
  198.                 ALUop <= 4'b0000;
  199.                 PCsel <= 2'b00;
  200.                 reg_distSel <= 0;
  201.                 regWr <= 0;
  202.                 dataWr <= 1;
  203.                 ALUin1_sel <= 0;
  204.                 ALUin2_sel <= 1;
  205.                 regIn_sel <= 0;
  206.             end
  207.             //beq
  208.             6'b000100:begin
  209.          //       PC_reset <= 0;
  210.                 ALUop <= 4'b1000;
  211.                 reg_distSel <= 0;
  212.                 regWr <= 0;
  213.                 dataWr <= 0;
  214.                 ALUin1_sel <= 0;
  215.                 ALUin2_sel <= 1;
  216.                 regIn_sel <= 0;
  217.                 if(zero == 1) //1表示相等,要跳转
  218.                     PCsel <= 2'b01;
  219.                 else 
  220.                     PCsel <= 2'b00;
  221.             end
  222.             //bne
  223.             6'b000101:begin
  224.         //        PC_reset <= 0;
  225.                 ALUop <= 4'b1000;
  226.                 reg_distSel <= 0;
  227.                 regWr <= 0;
  228.                 dataWr <= 0;
  229.                 ALUin1_sel <= 0;
  230.                 ALUin2_sel <= 1;
  231.                 regIn_sel <= 0;
  232.                 if(zero == 0)
  233.                     PCsel <= 2'b01;
  234.                 else 
  235.                     PCsel <= 2'b00;
  236.             end
  237.             //lui，设置rt寄存器的高十六位，后面是16个0
  238.             6'b001111: begin
  239.      //           PC_reset <= 0;
  240.                 ALUop <= 4'b1001; 
  241.                 PCsel <= 2'b00;  
  242.                 reg_distSel <= 0;
  243.                 regWr <= 1;
  244.                 dataWr <= 0;
  245.                 ALUin1_sel <= 0;
  246.                 ALUin2_sel <= 1;
  247.                 regIn_sel <= 0;
  248.             end
  249.             //j
  250.             6'b000010: begin
  251.       //          PC_reset <= 0;
  252.                 ALUop <= 4'b1001;   //无所谓
  253.                 reg_distSel <= 0;   //无所谓
  254.                 PCsel <= 2'b10;
  255.                 regWr <= 0;
  256.                 dataWr <= 0;
  257.                 ALUin1_sel <= 0;    //无所谓
  258.                 ALUin2_sel <= 1;    //无所谓
  259.                 regIn_sel <= 0;     //无所谓
  260.             end
  261.         endcase
  262.     end
  263.     
  264. endmodule

            这个模块不设置仿真，因为要需要调用很多其他模块。

        9）顶层仿真

                这个仿真文件是用来统筹所有其他的模块并且进行运行MIPS指令。这里还未写顶层模块

                下面直接贴上仿真代码（main_tb.v）：

  1. `timescale 1ns / 1ps
  2.  
  3. module main_tb( );
  4.     reg clk;  
  5.     wire pc_reset;  wire push;  wire [31:0]pc_out;  wire [31:0]pc_in;  wire[31:0] plused_pc;
  6.     pc my_pc(pc_in,clk,pc_reset,pc_out,plused_pc);
  7.     
  8.     wire [5:0]op;  wire [4:0]rs; wire [4:0]rt;  wire [4:0]rd;  wire [4:0]shamt;  wire [5:0]funct;  wire [31:0]imm32;
  9.     InsMem my_Insmem(pc_out,op,rs,rt,rd,shamt,funct);   extender my_extender({rd,shamt,funct},imm32);
  10.     
  11.     wire ctrl_distReg; wire [31:0]reg_dataIn;  wire RegWr;  wire [31:0]reg_out1;  wire [31:0]reg_out2;
  12.     Register my_Register(clk, rs, rt, rd, ctrl_distReg, RegWr, reg_dataIn, reg_out1, reg_out2);
  13.     
  14.     wire [31:0]ALU_in1;  wire[31:0]ALU_in2;  wire ALUsel_in1;  wire ALUsel_in2;
  15.     dataSel_2 ALU1(reg_out1,shamt,ALUsel_in1,ALU_in1);  dataSel_2 ALU2(reg_out2,imm32,ALUsel_in2,ALU_in2);
  16.     
  17.     wire [3:0]ALUctrl;  wire ALU_zero;  wire [31:0]ALU_out;
  18.     ALU my_ALU(ALUctrl,ALU_in1,ALU_in2,ALU_zero,ALU_out);
  19.     
  20.     wire dataWr;  wire [31:0]dataOut;
  21.     dataMem mt_dataMem(clk,ALU_out,reg_out2,dataWr,dataOut);
  22.     wire regIn_sel_wire;
  23.     dataSel_2 regIn_sel(ALU_out,dataOut,regIn_sel_wire,reg_dataIn);
  24.     
  25.     wire [1:0]pcSel;
  26.     PCselect my_PCselect(plused_pc,imm32,{rs,rt,rd,shamt,funct},reg_out1,pcSel,pc_in);
  27.     
  28.     control my_control(op,funct,ALU_zero,pc_reset,ALUctrl,pcSel,ctrl_distReg,RegWr,dataWr,ALUsel_in1,ALUsel_in2,regIn_sel_wire);
  29.     
  30.    initial begin
  31.         clk=0;
  32.  
  33.    end
  34.  
  35.  
  36.     always @(*) begin
  37.         #5 clk <= ~clk;
  38.     end
  39.        
  40. endmodule

        在testdata.txt中写入几行指令来测试CPU是否能正常工作。

                经过测试后观察波形，这些指令都能够正常运行。

        测试过后，将顶层写成一个模块，然后将程序烧入CPU中。

        顶层模块代码（top.v）:

  1. `timescale 1ns / 1ps
  2. //结合所有CPU器件的模块，但还没有通过数码管进行输出
  3. module top(
  4.     input push,
  5.     input clk_7seg,
  6.     input [1:0]SW,
  7.     output [11:0]display,
  8.  //   input clk,
  9.     input pc_reset
  10. //    output  effective_clk
  11.     
  12.     );
  13.     wire [31:0]pc_out;
  14.     wire [31:0]pc_in;
  15.     wire [31:0]plused_pc;
  16.     wire [5:0]op;
  17.     wire  [4:0]rs;
  18.     wire [4:0]rt;
  19.     wire [4:0]rd;
  20.     wire [4:0]shamt;
  21.     wire [5:0]funct;
  22.     wire [31:0]imm32;
  23.     wire  ctrl_distReg;
  24.     wire [31:0]reg_dataIn;
  25.     wire RegWr;
  26.     wire [31:0]reg_out1;
  27.     wire [31:0]reg_out2;
  28.     wire   [31:0]ALU_in1;
  29.     wire  [31:0]ALU_in2;
  30.     wire   ALUsel_in1;
  31.     wire  ALUsel_in2;
  32.     wire [3:0]ALUctrl;
  33.     wire  ALU_zero;
  34.     wire  [31:0]ALU_out;
  35.     wire  dataWr;
  36.     wire [31:0]dataOut;
  37.     wire regIn_sel_wire;
  38.     wire  [1:0]pcSel;
  39.    
  40.     wire effective_clk;
  41.     wire [31:0]extended_shamt;
  42.     
  43.     clk_dura my_clkdura(clk_7seg,push,effective_clk);
  44.     
  45.     extend5 shamt_ex(shamt,extended_shamt);
  46.     
  47.     pc my_pc(pc_in,effective_clk,pc_reset,pc_out,plused_pc);
  48.     
  49.     InsMem my_Insmem(pc_out,op,rs,rt,rd,shamt,funct);   extender my_extender({rd,shamt,funct},imm32);
  50.     Register my_Register(effective_clk, rs, rt, rd, ctrl_distReg, RegWr, reg_dataIn, reg_out1, reg_out2);
  51.     
  52.     dataSel_2 ALU1(reg_out1,extended_shamt,ALUsel_in1,ALU_in1);  dataSel_2 ALU2(reg_out2,imm32,ALUsel_in2,ALU_in2);
  53.     ALU my_ALU(ALUctrl,ALU_in1,ALU_in2,ALU_zero,ALU_out);
  54.     dataMem mt_dataMem(effective_clk,ALU_out,reg_out2,dataWr,dataOut);
  55.     dataSel_2 regIn_sel(ALU_out,dataOut,regIn_sel_wire,reg_dataIn);
  56.     PCselect my_PCselect(plused_pc,imm32,{rs,rt,rd,shamt,funct},reg_out1,pcSel,pc_in);
  57.         
  58.     control my_control(op,funct,ALU_zero,ALUctrl,pcSel,ctrl_distReg,RegWr,dataWr,ALUsel_in1,ALUsel_in2,regIn_sel_wire);
  59.  
  60.     _7seg my_7seg(clk_7seg,SW,pc_out,pc_in,rs,reg_out1,rt,reg_out2,ALU_out,reg_dataIn,display);
  61. endmodule

                之前顶层模块把所有参数都写进了模块的参数列表（即input，output）中，但在约束文件中并未将他们接至引脚上，因此会造成输出悬空的现象，在进行硬件implementation会报错如下：

        顶层模块仿真（top_test_tb.v）：

  1. `timescale 1ns / 1ps
  2.  
  3. module top_test_tb();
  4.     reg push;
  5.     reg clk_7seg;
  6.     reg [1:0]SW;
  7.     reg pc_reset;
  8.     
  9.     wire [11:0]display;
  10. //    wire effective_clk;
  11.  
  12.     
  13.     top test_top(push,clk_7seg,SW,display,pc_reset);
  14.                  
  15.     initial begin
  16.         push = 0;
  17.         clk_7seg = 0;
  18.         SW = 0;
  19.         pc_reset = 0;
  20.     end
  21.     
  22.     always @(clk_7seg) begin
  23.         #5 clk_7seg <=  ~clk_7seg;
  24.     end
  25.     
  26.     always @(push) begin
  27.         #80 push <= ~push;
  28.     end
  29.     
  30.     
  31. endmodule

        指令文件（test.txt）：

  1. 20010008    //add $1,$0,8
  2. 34020002    //ori $2,$0,2
  3. 00411820    //add $3,$2,$1
  4. 00622822    //sub $5,$3,$2
  5. 00a22024    //and $4,$5,$2
  6. 00824025    //or $8,$4,$2
  7. 00084040    //sll $8,$8,1
  8. ac080004    //sw $8,4($0)
  9. 8c090004    //lw $9,4($0)

        0~2条指令波形（pc：00~08）：

         3~5条指令波形（pc：0C~14）：

         6~8条指令（pc：18~20）：

 3.CPU烧板

        本实验还有在basys3板子上展示的要求，要求如下：

         七段数码管

                为了在数码管上显示，要写一个七段数码管显示的模块，通过当前的pc,rs,rt,ALU_out值来进行显示。

                该模块代码（_7seg.v）:

  1. `timescale 1ns / 1ps
  2.  
  3. module _7seg(
  4.     input clk_7seg,
  5.     input [1:0]SW,  //(sw15,sw14)
  6.     input [31:0]pc_now, //当前pc值
  7.     input [31:0]pc_next,    //下条pc值
  8.     
  9.     input [4:0]rs,  //rs寄存器的编号
  10.     input [31:0]reg_out1,   //rs寄存器的内容
  11.     
  12.     input [4:0]rt,  //rt寄存器的编号
  13.     input [31:0]reg_out2,   //rt寄存器的内容
  14.     
  15.     input [31:0]ALU_out,    //ALU结果
  16.     input [31:0]dataOut,    //DB总线
  17.     
  18.     output reg[11:0] display
  19.     
  20.     );
  21.     
  22.     //count == T1MS 用来分频
  23.     reg [19:0] count = 0;
  24.     reg [2:0] sel = 0;
  25.     parameter T1MS = 50000;
  26.     always @(posedge clk_7seg) begin
  27.         count <= count+1;
  28.         if(count == T1MS) begin
  29.             count <= 0;
  30.             if(sel==3) sel<=0;
  31.             else sel <= sel+1;
  32.         end
  33.     end
  34.     
  35.     always @(posedge clk_7seg) begin
  36.         case(SW) 
  37.             //pc
  38.             0: begin
  39.                 case(sel)
  40.                     0: begin
  41.                         display[11:8] <= 4'b0111;
  42.                         //第一位输出
  43.                         case(pc_now[7:4])
  44.                             4'b0000: display[7:0] <= 8'b1100_0000; 
  45.                             4'b0001: display[7:0] <= 8'b1111_1001;
  46.                             4'b0010: display[7:0] <= 8'b1010_0100;
  47.                             4'b0011: display[7:0] <= 8'b1011_0000;
  48.                             4'b0100: display[7:0] <= 8'b1001_1001;
  49.                             4'b0101: display[7:0] <= 8'b1001_0010;
  50.                             4'b0110: display[7:0] <= 8'b1000_0010;
  51.                             4'b0111: display[7:0] <= 8'b1101_1000;
  52.                             4'b1000: display[7:0] <= 8'b1000_0000;
  53.                             4'b1001: display[7:0] <= 8'b1001_0000;
  54.                             4'b1010: display[7:0] <= 8'b1000_1000;
  55.                             4'b1011: display[7:0] <= 8'b1000_0011;
  56.                             4'b1100: display[7:0] <= 8'b1100_0110;
  57.                             4'b1101: display[7:0] <= 8'b1010_0001;
  58.                             4'b1110: display[7:0] <= 8'b1000_0110;
  59.                             4'b1111: display[7:0] <= 8'b1000_1110;
  60.                             default : display[7:0] = 8'b1111_1111; //全灭
  61.                          endcase
  62.                     end
  63.                     1: begin
  64.                         display[11:8] <= 4'b1011;
  65.                         //第二位输出
  66.                         case(pc_now[3:0])
  67.                             4'b0000: display[7:0] <= 8'b1100_0000; 
  68.                             4'b0001: display[7:0] <= 8'b1111_1001;
  69.                             4'b0010: display[7:0] <= 8'b1010_0100;
  70.                             4'b0011: display[7:0] <= 8'b1011_0000;
  71.                             4'b0100: display[7:0] <= 8'b1001_1001;
  72.                             4'b0101: display[7:0] <= 8'b1001_0010;
  73.                             4'b0110: display[7:0] <= 8'b1000_0010;
  74.                             4'b0111: display[7:0] <= 8'b1101_1000;
  75.                             4'b1000: display[7:0] <= 8'b1000_0000;
  76.                             4'b1001: display[7:0] <= 8'b1001_0000;
  77.                             4'b1010: display[7:0] <= 8'b1000_1000;
  78.                             4'b1011: display[7:0] <= 8'b1000_0011;
  79.                             4'b1100: display[7:0] <= 8'b1100_0110;
  80.                             4'b1101: display[7:0] <= 8'b1010_0001;
  81.                             4'b1110: display[7:0] <= 8'b1000_0110;
  82.                             4'b1111: display[7:0] <= 8'b1000_1110;
  83.                             default : display[7:0] = 8'b1111_1111; //全灭
  84.                          endcase
  85.                     end
  86.                     2: begin
  87.                         display[11:8] <= 4'b1101;
  88.                         //第三位输出
  89.                         case(pc_next[7:4])
  90.                             4'b0000: display[7:0] <= 8'b1100_0000; 
  91.                             4'b0001: display[7:0] <= 8'b1111_1001;
  92.                             4'b0010: display[7:0] <= 8'b1010_0100;
  93.                             4'b0011: display[7:0] <= 8'b1011_0000;
  94.                             4'b0100: display[7:0] <= 8'b1001_1001;
  95.                             4'b0101: display[7:0] <= 8'b1001_0010;
  96.                             4'b0110: display[7:0] <= 8'b1000_0010;
  97.                             4'b0111: display[7:0] <= 8'b1101_1000;
  98.                             4'b1000: display[7:0] <= 8'b1000_0000;
  99.                             4'b1001: display[7:0] <= 8'b1001_0000;
  100.                             4'b1010: display[7:0] <= 8'b1000_1000;
  101.                             4'b1011: display[7:0] <= 8'b1000_0011;
  102.                             4'b1100: display[7:0] <= 8'b1100_0110;
  103.                             4'b1101: display[7:0] <= 8'b1010_0001;
  104.                             4'b1110: display[7:0] <= 8'b1000_0110;
  105.                             4'b1111: display[7:0] <= 8'b1000_1110;
  106.                             default : display[7:0] = 8'b1111_1111; //全灭
  107.                          endcase
  108.                     end
  109.                     3: begin
  110.                         display[11:8] <= 4'b1110;
  111.                         //第四位输出
  112.                         case(pc_next[3:0])
  113.                             4'b0000: display[7:0] <= 8'b1100_0000; 
  114.                             4'b0001: display[7:0] <= 8'b1111_1001;
  115.                             4'b0010: display[7:0] <= 8'b1010_0100;
  116.                             4'b0011: display[7:0] <= 8'b1011_0000;
  117.                             4'b0100: display[7:0] <= 8'b1001_1001;
  118.                             4'b0101: display[7:0] <= 8'b1001_0010;
  119.                             4'b0110: display[7:0] <= 8'b1000_0010;
  120.                             4'b0111: display[7:0] <= 8'b1101_1000;
  121.                             4'b1000: display[7:0] <= 8'b1000_0000;
  122.                             4'b1001: display[7:0] <= 8'b1001_0000;
  123.                             4'b1010: display[7:0] <= 8'b1000_1000;
  124.                             4'b1011: display[7:0] <= 8'b1000_0011;
  125.                             4'b1100: display[7:0] <= 8'b1100_0110;
  126.                             4'b1101: display[7:0] <= 8'b1010_0001;
  127.                             4'b1110: display[7:0] <= 8'b1000_0110;
  128.                             4'b1111: display[7:0] <= 8'b1000_1110;
  129.                             default : display[7:0] = 8'b1111_1111; //全灭
  130.                          endcase
  131.                     end
  132.                 endcase
  133.             end
  134.             //rs
  135.             1: begin
  136.                   case(sel)
  137.                       0: begin
  138.                           display[11:8] <= 4'b0111;
  139.                           //第一位输出
  140.                           case(rs[4])
  141.                               0: display[7:0] <= 8'b1100_0000; 
  142.                               1: display[7:0] <= 8'b1111_1001;
  143.                           
  144.                               default : display[7:0] = 8'b1111_1111; //全灭
  145.                            endcase
  146.                       end
  147.                       1: begin
  148.                           display[11:8] <= 4'b1011;
  149.                           //第二位输出
  150.                           case(rs[3:0])
  151.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  152.                               4'b0001: display[7:0] <= 8'b1111_1001;
  153.                               4'b0010: display[7:0] <= 8'b1010_0100;
  154.                               4'b0011: display[7:0] <= 8'b1011_0000;
  155.                               4'b0100: display[7:0] <= 8'b1001_1001;
  156.                               4'b0101: display[7:0] <= 8'b1001_0010;
  157.                               4'b0110: display[7:0] <= 8'b1000_0010;
  158.                               4'b0111: display[7:0] <= 8'b1101_1000;
  159.                               4'b1000: display[7:0] <= 8'b1000_0000;
  160.                               4'b1001: display[7:0] <= 8'b1001_0000;
  161.                               4'b1010: display[7:0] <= 8'b1000_1000;
  162.                               4'b1011: display[7:0] <= 8'b1000_0011;
  163.                               4'b1100: display[7:0] <= 8'b1100_0110;
  164.                               4'b1101: display[7:0] <= 8'b1010_0001;
  165.                               4'b1110: display[7:0] <= 8'b1000_0110;
  166.                               4'b1111: display[7:0] <= 8'b1000_1110;
  167.                               default : display[7:0] = 8'b1111_1111; //全灭
  168.                            endcase
  169.                       end
  170.                       2: begin
  171.                           display[11:8] <= 4'b1101;
  172.                           //第三位输出
  173.                           case(reg_out1[7:4])
  174.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  175.                               4'b0001: display[7:0] <= 8'b1111_1001;
  176.                               4'b0010: display[7:0] <= 8'b1010_0100;
  177.                               4'b0011: display[7:0] <= 8'b1011_0000;
  178.                               4'b0100: display[7:0] <= 8'b1001_1001;
  179.                               4'b0101: display[7:0] <= 8'b1001_0010;
  180.                               4'b0110: display[7:0] <= 8'b1000_0010;
  181.                               4'b0111: display[7:0] <= 8'b1101_1000;
  182.                               4'b1000: display[7:0] <= 8'b1000_0000;
  183.                               4'b1001: display[7:0] <= 8'b1001_0000;
  184.                               4'b1010: display[7:0] <= 8'b1000_1000;
  185.                               4'b1011: display[7:0] <= 8'b1000_0011;
  186.                               4'b1100: display[7:0] <= 8'b1100_0110;
  187.                               4'b1101: display[7:0] <= 8'b1010_0001;
  188.                               4'b1110: display[7:0] <= 8'b1000_0110;
  189.                               4'b1111: display[7:0] <= 8'b1000_1110;
  190.                               default : display[7:0] = 8'b1111_1111; //全灭
  191.                            endcase
  192.                       end
  193.                       3: begin
  194.                           display[11:8] <= 4'b1110;
  195.                           //第四位输出
  196.                           case(reg_out1[3:0])
  197.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  198.                               4'b0001: display[7:0] <= 8'b1111_1001;
  199.                               4'b0010: display[7:0] <= 8'b1010_0100;
  200.                               4'b0011: display[7:0] <= 8'b1011_0000;
  201.                               4'b0100: display[7:0] <= 8'b1001_1001;
  202.                               4'b0101: display[7:0] <= 8'b1001_0010;
  203.                               4'b0110: display[7:0] <= 8'b1000_0010;
  204.                               4'b0111: display[7:0] <= 8'b1101_1000;
  205.                               4'b1000: display[7:0] <= 8'b1000_0000;
  206.                               4'b1001: display[7:0] <= 8'b1001_0000;
  207.                               4'b1010: display[7:0] <= 8'b1000_1000;
  208.                               4'b1011: display[7:0] <= 8'b1000_0011;
  209.                               4'b1100: display[7:0] <= 8'b1100_0110;
  210.                               4'b1101: display[7:0] <= 8'b1010_0001;
  211.                               4'b1110: display[7:0] <= 8'b1000_0110;
  212.                               4'b1111: display[7:0] <= 8'b1000_1110;
  213.                               default : display[7:0] = 8'b1111_1111; //全灭
  214.                            endcase
  215.                       end
  216.                   endcase
  217.             end
  218.             //rt
  219.             2: begin
  220.                   case(sel)
  221.                       0: begin
  222.                           display[11:8] <= 4'b0111;
  223.                           //第一位输出
  224.                           case(rt[4])
  225.                                 0: display[7:0] <= 8'b1100_0000; 
  226.                                 1: display[7:0] <= 8'b1111_1001;
  227.                             
  228.                               default : display[7:0] = 8'b1111_1111; //全灭
  229.                            endcase
  230.                       end
  231.                       1: begin
  232.                           display[11:8] <= 4'b1011;
  233.                           //第二位输出
  234.                           case(rt[3:0])
  235.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  236.                               4'b0001: display[7:0] <= 8'b1111_1001;
  237.                               4'b0010: display[7:0] <= 8'b1010_0100;
  238.                               4'b0011: display[7:0] <= 8'b1011_0000;
  239.                               4'b0100: display[7:0] <= 8'b1001_1001;
  240.                               4'b0101: display[7:0] <= 8'b1001_0010;
  241.                               4'b0110: display[7:0] <= 8'b1000_0010;
  242.                               4'b0111: display[7:0] <= 8'b1101_1000;
  243.                               4'b1000: display[7:0] <= 8'b1000_0000;
  244.                               4'b1001: display[7:0] <= 8'b1001_0000;
  245.                               4'b1010: display[7:0] <= 8'b1000_1000;
  246.                               4'b1011: display[7:0] <= 8'b1000_0011;
  247.                               4'b1100: display[7:0] <= 8'b1100_0110;
  248.                               4'b1101: display[7:0] <= 8'b1010_0001;
  249.                               4'b1110: display[7:0] <= 8'b1000_0110;
  250.                               4'b1111: display[7:0] <= 8'b1000_1110;
  251.                               default : display[7:0] = 8'b1111_1111; //全灭
  252.                            endcase
  253.                       end
  254.                       2: begin
  255.                           display[11:8] <= 4'b1101;
  256.                           //第三位输出
  257.                           case(reg_out2[7:4])
  258.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  259.                               4'b0001: display[7:0] <= 8'b1111_1001;
  260.                               4'b0010: display[7:0] <= 8'b1010_0100;
  261.                               4'b0011: display[7:0] <= 8'b1011_0000;
  262.                               4'b0100: display[7:0] <= 8'b1001_1001;
  263.                               4'b0101: display[7:0] <= 8'b1001_0010;
  264.                               4'b0110: display[7:0] <= 8'b1000_0010;
  265.                               4'b0111: display[7:0] <= 8'b1101_1000;
  266.                               4'b1000: display[7:0] <= 8'b1000_0000;
  267.                               4'b1001: display[7:0] <= 8'b1001_0000;
  268.                               4'b1010: display[7:0] <= 8'b1000_1000;
  269.                               4'b1011: display[7:0] <= 8'b1000_0011;
  270.                               4'b1100: display[7:0] <= 8'b1100_0110;
  271.                               4'b1101: display[7:0] <= 8'b1010_0001;
  272.                               4'b1110: display[7:0] <= 8'b1000_0110;
  273.                               4'b1111: display[7:0] <= 8'b1000_1110;
  274.                               default : display[7:0] = 8'b1111_1111; //全灭
  275.                            endcase
  276.                       end
  277.                       3: begin
  278.                           display[11:8] <= 4'b1110;
  279.                           //第四位输出
  280.                           case(reg_out2[3:0])
  281.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  282.                               4'b0001: display[7:0] <= 8'b1111_1001;
  283.                               4'b0010: display[7:0] <= 8'b1010_0100;
  284.                               4'b0011: display[7:0] <= 8'b1011_0000;
  285.                               4'b0100: display[7:0] <= 8'b1001_1001;
  286.                               4'b0101: display[7:0] <= 8'b1001_0010;
  287.                               4'b0110: display[7:0] <= 8'b1000_0010;
  288.                               4'b0111: display[7:0] <= 8'b1101_1000;
  289.                               4'b1000: display[7:0] <= 8'b1000_0000;
  290.                               4'b1001: display[7:0] <= 8'b1001_0000;
  291.                               4'b1010: display[7:0] <= 8'b1000_1000;
  292.                               4'b1011: display[7:0] <= 8'b1000_0011;
  293.                               4'b1100: display[7:0] <= 8'b1100_0110;
  294.                               4'b1101: display[7:0] <= 8'b1010_0001;
  295.                               4'b1110: display[7:0] <= 8'b1000_0110;
  296.                               4'b1111: display[7:0] <= 8'b1000_1110;
  297.                               default : display[7:0] = 8'b1111_1111; //全灭
  298.                            endcase
  299.                       end
  300.                   endcase
  301.             end
  302.             //ALUout:DB数据
  303.             3: begin
  304.                   case(sel)
  305.                       0: begin
  306.                           display[11:8] <= 4'b0111;
  307.                           //第一位输出
  308.                           case(ALU_out[7:4])
  309.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  310.                               4'b0001: display[7:0] <= 8'b1111_1001;
  311.                               4'b0010: display[7:0] <= 8'b1010_0100;
  312.                               4'b0011: display[7:0] <= 8'b1011_0000;
  313.                               4'b0100: display[7:0] <= 8'b1001_1001;
  314.                               4'b0101: display[7:0] <= 8'b1001_0010;
  315.                               4'b0110: display[7:0] <= 8'b1000_0010;
  316.                               4'b0111: display[7:0] <= 8'b1101_1000;
  317.                               4'b1000: display[7:0] <= 8'b1000_0000;
  318.                               4'b1001: display[7:0] <= 8'b1001_0000;
  319.                               4'b1010: display[7:0] <= 8'b1000_1000;
  320.                               4'b1011: display[7:0] <= 8'b1000_0011;
  321.                               4'b1100: display[7:0] <= 8'b1100_0110;
  322.                               4'b1101: display[7:0] <= 8'b1010_0001;
  323.                               4'b1110: display[7:0] <= 8'b1000_0110;
  324.                               4'b1111: display[7:0] <= 8'b1000_1110;
  325.                               default : display[7:0] = 8'b1111_1111; //全灭
  326.                            endcase
  327.                       end
  328.                       1: begin
  329.                           display[11:8] <= 4'b1011;
  330.                           //第二位输出
  331.                           case(ALU_out[3:0])
  332.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  333.                               4'b0001: display[7:0] <= 8'b1111_1001;
  334.                               4'b0010: display[7:0] <= 8'b1010_0100;
  335.                               4'b0011: display[7:0] <= 8'b1011_0000;
  336.                               4'b0100: display[7:0] <= 8'b1001_1001;
  337.                               4'b0101: display[7:0] <= 8'b1001_0010;
  338.                               4'b0110: display[7:0] <= 8'b1000_0010;
  339.                               4'b0111: display[7:0] <= 8'b1101_1000;
  340.                               4'b1000: display[7:0] <= 8'b1000_0000;
  341.                               4'b1001: display[7:0] <= 8'b1001_0000;
  342.                               4'b1010: display[7:0] <= 8'b1000_1000;
  343.                               4'b1011: display[7:0] <= 8'b1000_0011;
  344.                               4'b1100: display[7:0] <= 8'b1100_0110;
  345.                               4'b1101: display[7:0] <= 8'b1010_0001;
  346.                               4'b1110: display[7:0] <= 8'b1000_0110;
  347.                               4'b1111: display[7:0] <= 8'b1000_1110;
  348.                               default : display[7:0] = 8'b1111_1111; //全灭
  349.                            endcase
  350.                       end
  351.                       2: begin
  352.                           display[11:8] <= 4'b1101;
  353.                           //第三位输出
  354.                           case(dataOut[7:4])
  355.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  356.                               4'b0001: display[7:0] <= 8'b1111_1001;
  357.                               4'b0010: display[7:0] <= 8'b1010_0100;
  358.                               4'b0011: display[7:0] <= 8'b1011_0000;
  359.                               4'b0100: display[7:0] <= 8'b1001_1001;
  360.                               4'b0101: display[7:0] <= 8'b1001_0010;
  361.                               4'b0110: display[7:0] <= 8'b1000_0010;
  362.                               4'b0111: display[7:0] <= 8'b1101_1000;
  363.                               4'b1000: display[7:0] <= 8'b1000_0000;
  364.                               4'b1001: display[7:0] <= 8'b1001_0000;
  365.                               4'b1010: display[7:0] <= 8'b1000_1000;
  366.                               4'b1011: display[7:0] <= 8'b1000_0011;
  367.                               4'b1100: display[7:0] <= 8'b1100_0110;
  368.                               4'b1101: display[7:0] <= 8'b1010_0001;
  369.                               4'b1110: display[7:0] <= 8'b1000_0110;
  370.                               4'b1111: display[7:0] <= 8'b1000_1110;
  371.                               default : display[7:0] = 8'b1111_1111; //全灭
  372.                            endcase
  373.                       end
  374.                       3: begin
  375.                           display[11:8] <= 4'b1110;
  376.                           //第四位输出
  377.                           case(dataOut[3:0])
  378.                               4'b0000: display[7:0] <= 8'b1100_0000; 
  379.                               4'b0001: display[7:0] <= 8'b1111_1001;
  380.                               4'b0010: display[7:0] <= 8'b1010_0100;
  381.                               4'b0011: display[7:0] <= 8'b1011_0000;
  382.                               4'b0100: display[7:0] <= 8'b1001_1001;
  383.                               4'b0101: display[7:0] <= 8'b1001_0010;
  384.                               4'b0110: display[7:0] <= 8'b1000_0010;
  385.                               4'b0111: display[7:0] <= 8'b1101_1000;
  386.                               4'b1000: display[7:0] <= 8'b1000_0000;
  387.                               4'b1001: display[7:0] <= 8'b1001_0000;
  388.                               4'b1010: display[7:0] <= 8'b1000_1000;
  389.                               4'b1011: display[7:0] <= 8'b1000_0011;
  390.                               4'b1100: display[7:0] <= 8'b1100_0110;
  391.                               4'b1101: display[7:0] <= 8'b1010_0001;
  392.                               4'b1110: display[7:0] <= 8'b1000_0110;
  393.                               4'b1111: display[7:0] <= 8'b1000_1110;
  394.                               default : display[7:0] = 8'b1111_1111; //全灭
  395.                            endcase
  396.                       end
  397.                   endcase
  398.             end
  399.         endcase
  400.     end
  401.     
  402. endmodule

            这里的display[0]~diplay[6]分别是数码管的A~G。

        按键消抖

                消抖原理：FPGA板子上的按键在按下时，由于弹性形变，因此会导致信号不稳定，在极短的时间内会产生多次高电平，因此要在信号保持稳定后再进行读取，这样              能避免按下一次按键后执行多条指令。

                脉冲信号为push，写一个模块消抖（clk_dura.v）:

  1. `timescale 1ns / 1ps
  2.  
  3. module clk_dura(
  4.     input clk,
  5.     input push,
  6.     output reg effective_clk
  7.     );
  8.     
  9.     reg [31:0] count;
  10.     integer i;
  11.     initial begin
  12.      for(i=0;i<32;i=i+1) count[i] = 0; 
  13.     end
  14.     
  15.     always @(posedge clk) begin
  16.         if(push && count<=32'd30000000) count = count + 1;
  17.         else if(!push) count = 0; 
  18.     end
  19.     
  20.     always @(count) begin
  21.         if(count == 32'd10000000) effective_clk = 1'b1;
  22.         else effective_clk = 0;
  23.     end
  24. endmodule

        虽然加了延迟消除抖动，但是在上板子的时候会发现仍会出现按一下跳两条指令的情况，（猜测是板子问题）因此加入了简易的松手检测，如下图：

   

        强行抹除了长按可能造成跳多条指令的影响（计数器到了30ms后不会再增加）。

        修改过后按键运行正常。

  需要全项目源代码的，链接已经贴在下面，需要自取。

  项目源代码：https://download.csdn.net/download/wuyzh39/87244971

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/272177
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号