• ALU——调用加法乘法模块

    只调用加法模块的仿真图：

    （注：alu_control 为十六进制

    001高位加载 src2的低16位加载到高16位上

    002算数右移 src1算数右移  （高位补1）

    004逻辑右移 src1逻辑右移 （逻辑右移直接补0）

    008逻辑左移 src1逻辑左移

    010异或 020或 040或非 080与

    100 无符号比较 小于置位

    200 有符号比较 小于置位

    400 减法

    800 加法

    没有调用乘法器的ALU （下面那个调用了）

     alu.v

    1. `timescale 1ns / 1ps
    2.  
    3. module alu(
    4.     input  [11:0] alu_control, 
    5.     input  [31:0] alu_src1, 
    6.     input  [31:0] alu_src2,
    7.     output   [31:0] alu_result 
    8.     );
    9.     reg [31:0] alu_result;
    10.     wire alu_add;   //加法
    11.     wire alu_sub;   //减法
    12.     wire alu_slt;   //有符号比较，小于置位
    13.     wire alu_sltu;  //无符号比较，小于置位
    14.     wire alu_and;   //按位与
    15.     wire alu_nor;   //按位或非
    16.     wire alu_or;    //按位或 
    17.     wire alu_xor;   //按位异或
    18.     wire alu_sll;   //逻辑左移
    19.     wire alu_srl;   //逻辑右移
    20.     wire alu_sra;   //算数右移
    21.     wire alu_lui;   //高位加载
    22.  
    23.     assign alu_mult = alu_control[11];
    24.     assign alu_add  = alu_control[11];
    25.     assign alu_sub  = alu_control[10];
    26.     assign alu_slt  = alu_control[ 9];
    27.     assign alu_sltu = alu_control[ 8];
    28.     assign alu_and  = alu_control[ 7];
    29.     assign alu_nor  = alu_control[ 6];
    30.     assign alu_or   = alu_control[ 5];
    31.     assign alu_xor  = alu_control[ 4];
    32.     assign alu_sll  = alu_control[ 3];
    33.     assign alu_srl  = alu_control[ 2];
    34.     assign alu_sra  = alu_control[ 1];
    35.     assign alu_lui  = alu_control[ 0];
    36.  
    37.     wire [31:0] add_sub_result; //加减结果，减法用加法来实现
    38.     wire [31:0] slt_result;     //
    39.     wire [31:0] sltu_result;    //
    40.     wire [31:0] and_result;
    41.     wire [31:0] nor_result;
    42.     wire [31:0] or_result;
    43.     wire [31:0] xor_result;
    44.     wire [31:0] sll_result;
    45.     wire [31:0] srl_result;
    46.     wire [31:0] sra_result;     
    47.     wire [31:0] lui_result;
    48.  
    49.     wire signed [31:0] temp_src1;   //带符号数的临时变量
    50.     assign temp_src1 = alu_src1;    //方便后面对alu_src1进行算数右移
    51.     assign and_result = alu_src1 & alu_src2;        //按位与
    52.     assign or_result  = alu_src1 | alu_src2;        //按位或
    53.     assign nor_result = ~or_result;                 //或非
    54.     assign xor_result = alu_src1 ^ alu_src2;        //异或
    55.     assign lui_result = {alu_src2[15:0], 16'd0};    //高位加载，第二个操作数的低十六位加载到高十六位上
    56.     assign sll_result = alu_src1 << alu_src2;       //逻辑左移
    57.     assign srl_result = alu_src1 >> alu_src2;       //逻辑右移
    58.     assign slt_result = adder_result[31] ? 1'b1 : 1'b0;   // 带符号数小于置位
    59.     assign sltu_result = adder_cout ? 1'b0 : 1'b1;     //无符号数小于置位
    60.     assign sra_result = temp_src1 >>> alu_src2;     //算数右移
    62.     wire [31:0] adder_operand1;
    63.     wire [31:0] adder_operand2;
    64.     wire        adder_cin     ;
    65.     wire [31:0] adder_result  ;
    66.     wire        adder_cout    ;
    67.     assign adder_operand1 = alu_src1; 
    68.     assign adder_operand2 = alu_add ? alu_src2 : ~alu_src2;     //默认进行减法，为slt和sltu服务
    69.     assign adder_cin      = ~alu_add;  //巧妙到我都以为代码有bug
    70.     adder adder_module(     //调用加法模块
    71.     .A(adder_operand1),
    72.     .B(adder_operand2),
    73.     .Cin     (adder_cin     ),
    74.     .S  (adder_result  ),
    75.     .Cout    (adder_cout    )
    76.     );
    77. assign add_sub_result = adder_result;
    79. 	always@(*)
    80. 	begin
    82.         if(alu_add | alu_sub)
    83.             alu_result <= add_sub_result;
    84.             else if(alu_slt)
    85.             alu_result <= slt_result;
    86.             else if(alu_sltu)
    87.             alu_result <= sltu_result;
    88.             else if(alu_and)
    89.             alu_result <= and_result;
    90.             else if(alu_nor)
    91.             alu_result <= nor_result;
    92.             else if(alu_or)
    93.             alu_result <= or_result;
    94.             else if(alu_xor)
    95.             alu_result <= xor_result;
    96.             else if(alu_sll)
    97.             alu_result <= sll_result;
    98.             else if(alu_srl)
    99.             alu_result <= srl_result;
    100.             else if(alu_sra)
    101.             alu_result <= sra_result;
    102.             else if(alu_lui)
    103.             alu_result <= lui_result;
    104.          
    105. 	end
    106. endmodule

    testbench.v 

    1. `timescale 1ns / 1ps
    2.  
    3. module tb;
    4.  
    5.     // Inputs
    6.     reg clk;
    7.     reg [11:0] alu_control;
    8.     reg [31:0] alu_src1;
    9.     reg [31:0] alu_src2;
    10.  
    11.     // Outputs
    12.     wire [31:0] alu_result;
    13.  
    14.     // Instantiate the Unit Under Test (UUT)
    15. //alu al(
    16. //    input  [11:0] alu_control, 
    17. //    input  [31:0] alu_src1, 
    18. //    input  [31:0] alu_src2,
    19. //    output [31:0] alu_result 
    20. //    );
    21. alu alu_module(
    22.             .alu_control(alu_control),
    23.             .alu_src1   (alu_src1   ),
    24.             .alu_src2   (alu_src2   ),
    25.             .alu_result (alu_result )
    26.         );
    27.     initial begin
    28.         // Initialize Inputs
    29.         clk = 0;
    30.         alu_control = 0;
    31.         alu_src1 = 32'H10001111;
    32. 		alu_src2 = 32'H00000004;
    33.  
    34.         // Wait 100 ns for global reset to finish
    35.         #100;
    36.         alu_control = 12'b0000_0000_0001;
    37.         #400;
    38.         alu_control = 12'b0000_0000_0010;
    39.         #500;
    40.         alu_control = 12'b0000_0000_0100;
    41.         #400;
    42.         alu_control = 12'b0000_0000_1000;
    43.         #500;
    44.         alu_control = 12'b0000_0001_0000;
    45.         #400;
    46.         alu_control = 12'b0000_0010_0000;
    47.         #500;
    48.         alu_control = 12'b0000_0100_0000;
    49.         #400;
    50.         alu_control = 12'b0000_1000_0000;
    51. 		#400;
    52.         alu_control = 12'b0001_0000_0000;
    53. 		#400;
    54.         alu_control = 12'b0010_0000_0000;
    55. 		#400;
    56.         alu_control = 12'b0100_0000_0000;
    57. 		#400;
    58.         alu_control = 12'b1000_0000_0000;
    59.         // Add stimulus here
    60.     end
    61.    always #5 clk = ~clk;
    62. endmodule
    63.

     alu_display.v

    1. module alu_display(
    2.     //时钟与复位信号
    3.      input clk,
    4.     input resetn,    //后缀"n"代表低电平有效
    5.  
    6.     //拨码开关，用于选择输入数
    7.     input [1:0] input_sel, //00:输入为控制信号(alu_control)
    8.                            //10:输入为源操作数1(alu_src1)
    9.                            //11:输入为源操作数2(alu_src2)
    10.  
    11.     //触摸屏相关接口，不需要更改
    12.     output lcd_rst,
    13.     output lcd_cs,
    14.     output lcd_rs,
    15.     output lcd_wr,
    16.     output lcd_rd,
    17.     inout[15:0] lcd_data_io,
    18.     output lcd_bl_ctr,
    19.     inout ct_int,
    20.     inout ct_sda,
    21.     output ct_scl,
    22.     output ct_rstn
    23.     );
    24. //-----{调用ALU模块}begin
    25.     reg   [11:0] alu_control;  // ALU控制信号
    26.     reg   [31:0] alu_src1;     // ALU操作数1
    27.     reg   [31:0] alu_src2;     // ALU操作数2
    28.     wire  [31:0] alu_result;   // ALU结果
    29.     alu alu_module(
    30.         .alu_control(alu_control),
    31.         .alu_src1   (alu_src1   ),
    32.         .alu_src2   (alu_src2   ),
    33.         .alu_result (alu_result )
    34.     );
    35. //-----{调用ALU模块}end
    36.  
    37. //---------------------{调用触摸屏模块}begin--------------------//
    38. //-----{实例化触摸屏}begin
    39. //此小节不需要更改
    40.     reg         display_valid;
    41.     reg  [39:0] display_name;
    42.     reg  [31:0] display_value;
    43.     wire [5 :0] display_number;
    44.     wire        input_valid;
    45.     wire [31:0] input_value;
    46.  
    47.     lcd_module lcd_module(
    48.         .clk            (clk           ),   //10Mhz
    49.         .resetn         (resetn        ),
    50.  
    51.         //调用触摸屏的接口
    52.         .display_valid  (display_valid ),
    53.         .display_name   (display_name  ),
    54.         .display_value  (display_value ),
    55.         .display_number (display_number),
    56.         .input_valid    (input_valid   ),
    57.         .input_value    (input_value   ),
    58.  
    59.         //lcd触摸屏相关接口，不需要更改
    60.         .lcd_rst        (lcd_rst       ),
    61.         .lcd_cs         (lcd_cs        ),
    62.         .lcd_rs         (lcd_rs        ),
    63.         .lcd_wr         (lcd_wr        ),
    64.         .lcd_rd         (lcd_rd        ),
    65.         .lcd_data_io    (lcd_data_io   ),
    66.         .lcd_bl_ctr     (lcd_bl_ctr    ),
    67.         .ct_int         (ct_int        ),
    68.         .ct_sda         (ct_sda        ),
    69.         .ct_scl         (ct_scl        ),
    70.         .ct_rstn        (ct_rstn       )
    71.     ); 
    72. //-----{实例化触摸屏}end
    73.  
    74. //-----{从触摸屏获取输入}begin
    75. //根据实际需要输入的数修改此小节，
    76. //建议对每一个数的输入，编写单独一个always块
    77.     //当input_sel为00时，表示输入数控制信号，即alu_control
    78.     always @(posedge clk)
    79.     begin
    80.         if (!resetn)
    81.         begin
    82.             alu_control <= 12'd0;
    83.         end
    84.         else if (input_valid && input_sel==2'b00)
    85.         begin
    86.             alu_control <= input_value[11:0];
    87.         end
    88.     end
    89.     
    90.     //当input_sel为10时，表示输入数为源操作数1，即alu_src1
    91.     always @(posedge clk)
    92.     begin
    93.         if (!resetn)
    94.         begin
    95.             alu_src1 <= 32'd0;
    96.         end
    97.         else if (input_valid && input_sel==2'b10)
    98.         begin
    99.             alu_src1 <= input_value;
    100.         end
    101.     end
    102.  
    103.     //当input_sel为11时，表示输入数为源操作数2，即alu_src2
    104.     always @(posedge clk)
    105.     begin
    106.         if (!resetn)
    107.         begin
    108.             alu_src2 <= 32'd0;
    109.         end
    110.         else if (input_valid && input_sel==2'b11)
    111.         begin
    112.             alu_src2 <= input_value;
    113.         end
    114.     end
    115. //-----{从触摸屏获取输入}end
    116.  
    117. //-----{输出到触摸屏显示}begin
    118. //根据需要显示的数修改此小节，
    119. //触摸屏上共有44块显示区域，可显示44组32位数据
    120. //44块显示区域从1开始编号，编号为1~44，
    121.     always @(posedge clk)
    122.     begin
    123.         case(display_number)
    124.             6'd1 :
    125.             begin
    126.                 display_valid <= 1'b1;
    127.                 display_name  <= "SRC_1";
    128.                 display_value <= alu_src1;
    129.             end
    130.             6'd2 :
    131.             begin
    132.                 display_valid <= 1'b1;
    133.                 display_name  <= "SRC_2";
    134.                 display_value <= alu_src2;
    135.             end
    136.             6'd3 :
    137.             begin
    138.                 display_valid <= 1'b1;
    139.                 display_name  <= "CONTR";
    140.                 display_value <={20'd0, alu_control};
    141.             end
    142.             6'd4 :
    143.             begin
    144.                 display_valid <= 1'b1;
    145.                 display_name  <= "RESUL";
    146.                 display_value <= alu_result;
    147.             end
    148.             default :
    149.             begin
    150.                 display_valid <= 1'b0;
    151.                 display_name  <= 40'd0;
    152.                 display_value <= 32'd0;
    153.             end
    154.         endcase
    155.     end
    156. //-----{输出到触摸屏显示}end
    157. //----------------------{调用触摸屏模块}end---------------------//
    158. endmodule

    调用乘法器的ALU（代码扔到末尾）

     这里结果我不知道怎么只显示希望的结果（出现了0，这个是个过程值，当时做乘法器的时候，看仿真的时候是配合着mult_end信号看的，我也不会把这个end信号调出来）

    slt sltu没看明白：（手册里有以后看 挖坑）

     小于置位指令（SLT,SLTI,SLTU，SLTIU）比较两个操作数然后设置目的寄存器，

                                                    如果小于就设置为1，否则就将目的寄存器设置为0。

    alu.v

    1. `timescale 1ns / 1ps
    2.  
    3. module alu(
    4.     input clk,
    5.     input  [12:0] alu_control, 
    6.     input  [31:0] alu_src1, 
    7.     input  [31:0] alu_src2,
    8.     output   [31:0] alu_result 
    9.     );
    10.     reg [31:0] alu_result;
    11.     wire alu_mul;//乘法
    12.     wire alu_add;   //加法
    13.     wire alu_sub;   //减法
    14.     wire alu_slt;   //有符号比较，小于置位
    15.     wire alu_sltu;  //无符号比较，小于置位
    16.     wire alu_and;   //按位与
    17.     wire alu_nor;   //按位或非
    18.     wire alu_or;    //按位或 
    19.     wire alu_xor;   //按位异或
    20.     wire alu_sll;   //逻辑左移
    21.     wire alu_srl;   //逻辑右移
    22.     wire alu_sra;   //算数右移
    23.     wire alu_lui;   //高位加载
    24.  
    25.  
    26.     assign alu_mul = alu_control[12];
    27.     assign alu_add  = alu_control[11];
    28.     assign alu_sub  = alu_control[10];
    29.     assign alu_slt  = alu_control[ 9];
    30.     assign alu_sltu = alu_control[ 8];
    31.     assign alu_and  = alu_control[ 7];
    32.     assign alu_nor  = alu_control[ 6];
    33.     assign alu_or   = alu_control[ 5];
    34.     assign alu_xor  = alu_control[ 4];
    35.     assign alu_sll  = alu_control[ 3];
    36.     assign alu_srl  = alu_control[ 2];
    37.     assign alu_sra  = alu_control[ 1];
    38.     assign alu_lui  = alu_control[ 0];
    39.  
    40.     wire [31:0] mul_result;
    41.     wire [31:0] add_sub_result; //加减结果，减法用加法来实现
    42.     wire [31:0] slt_result;     
    43.     wire [31:0] sltu_result;    
    44.     wire [31:0] and_result;
    45.     wire [31:0] nor_result;
    46.     wire [31:0] or_result;
    47.     wire [31:0] xor_result;
    48.     wire [31:0] sll_result;
    49.     wire [31:0] srl_result;
    50.     wire [31:0] sra_result;     
    51.     wire [31:0] lui_result;
    52.  
    53.     wire signed [31:0] temp_src1;   //带符号数的临时变量
    54.     assign temp_src1 = alu_src1;    //方便后面对alu_src1进行算数右移
    55.     assign and_result = alu_src1 & alu_src2;        //按位与
    56.     assign or_result  = alu_src1 | alu_src2;        //按位或
    57.     assign nor_result = ~or_result;                 //或非
    58.     assign xor_result = alu_src1 ^ alu_src2;        //异或
    59.     assign lui_result = {alu_src2[15:0], 16'd0};    //高位加载，第二个操作数的低十六位加载到高十六位上
    60.     assign sll_result = alu_src1 << alu_src2;       //逻辑左移
    61.     assign srl_result = alu_src1 >> alu_src2;       //逻辑右移
    62.     assign slt_result = adder_result[31] ? 1'b1 : 1'b0;   // 带符号数小于置位
    63.     assign sltu_result = adder_cout ? 1'b0 : 1'b1;     //无符号数小于置位
    64.     assign sra_result = temp_src1 >>> alu_src2;     //算数右移
    66.     wire [31:0] adder_operand1;
    67.     wire [31:0] adder_operand2;
    68.     wire        adder_cin     ;
    69.     wire [31:0] adder_result  ;
    70.     wire        adder_cout    ;
    71.     assign adder_operand1 = alu_src1; 
    72.     assign adder_operand2 = alu_add ? alu_src2 : ~alu_src2;     //默认进行减法，为slt和sltu服务
    73.     assign adder_cin      = ~alu_add;  //巧妙到我都以为代码有bug
    74.     adder adder_module(     //调用加法模块
    75.     .A(adder_operand1),
    76.     .B(adder_operand2),
    77.     .Cin     (adder_cin     ),
    78.     .S  (adder_result  ),
    79.     .Cout    (adder_cout    )
    80.     );
    81. assign add_sub_result = adder_result;
    85.     wire         clk;      // 时钟
    86.  //   wire        mult_begin; // 乘法开始信号
    87.     wire  [31:0] mult_op1;  // 乘法源操作数1
    88.     wire [31:0] mult_op2;  // 乘法源操作数2
    89.      wire [63:0] product;   // 乘积
    90.      wire        mult_end ;  // 乘法结束信号
    91.      
    92.         assign mult_op1 = alu_src1; 
    93.          assign mult_op2 =alu_src2;
    94.        assign mult_begin=1;
    95.          
    96.          multiply multiply_module//调用乘法模块  
    97.          (     
    98.          .clk(clk),
    99.          .mult_begin(mult_begin),
    100.          .mult_op1     (alu_src1 ),
    101.          .mult_op2  (alu_src2 ),
    102.          .product    ( product ),
    103.          .mult_end ()
    104.          );
    105.       assign mul_result =product ;
    106.       
    107. 	always@(*)
    108. 	begin
    110.         if(alu_add | alu_sub)
    111.             alu_result <= add_sub_result;
    112.             else if(alu_mul)
    113.             alu_result =mul_result;
    114.             else if(alu_slt)
    115.             alu_result <= slt_result;
    116.             else if(alu_sltu)
    117.             alu_result <= sltu_result;
    118.             else if(alu_and)
    119.             alu_result <= and_result;
    120.             else if(alu_nor)
    121.             alu_result <= nor_result;
    122.             else if(alu_or)
    123.             alu_result <= or_result;
    124.             else if(alu_xor)
    125.             alu_result <= xor_result;
    126.             else if(alu_sll)
    127.             alu_result <= sll_result;
    128.             else if(alu_srl)
    129.             alu_result <= srl_result;
    130.             else if(alu_sra)
    131.             alu_result <= sra_result;
    132.             else if(alu_lui)
    133.             alu_result <= lui_result;
    134.             
    135. 	end
    136. endmodule

    alu.display (就改了个信号数组的范围)

    1. module alu_display(
    2.     //时钟与复位信号
    3.      input clk,
    4.     input resetn,    //后缀"n"代表低电平有效
    5.  
    6.     //拨码开关，用于选择输入数
    7.     input [1:0] input_sel, //00:输入为控制信号(alu_control)
    8.                            //10:输入为源操作数1(alu_src1)
    9.                            //11:输入为源操作数2(alu_src2)
    10.  
    11.     //触摸屏相关接口，不需要更改
    12.     output lcd_rst,
    13.     output lcd_cs,
    14.     output lcd_rs,
    15.     output lcd_wr,
    16.     output lcd_rd,
    17.     inout[15:0] lcd_data_io,
    18.     output lcd_bl_ctr,
    19.     inout ct_int,
    20.     inout ct_sda,
    21.     output ct_scl,
    22.     output ct_rstn
    23.     );
    24. //-----{调用ALU模块}begin
    25.     reg   [12:0] alu_control;  // ALU控制信号
    26.     reg   [31:0] alu_src1;     // ALU操作数1
    27.     reg   [31:0] alu_src2;     // ALU操作数2
    28.     wire  [31:0] alu_result;   // ALU结果
    29.     alu alu_module(
    30.         .alu_control(alu_control),
    31.         .alu_src1   (alu_src1   ),
    32.         .alu_src2   (alu_src2   ),
    33.         .alu_result (alu_result )
    34.     );
    35. //-----{调用ALU模块}end
    36.  
    37. //---------------------{调用触摸屏模块}begin--------------------//
    38. //-----{实例化触摸屏}begin
    39. //此小节不需要更改
    40.     reg         display_valid;
    41.     reg  [39:0] display_name;
    42.     reg  [31:0] display_value;
    43.     wire [5 :0] display_number;
    44.     wire        input_valid;
    45.     wire [31:0] input_value;
    46.  
    47.     lcd_module lcd_module(
    48.         .clk            (clk           ),   //10Mhz
    49.         .resetn         (resetn        ),
    50.  
    51.         //调用触摸屏的接口
    52.         .display_valid  (display_valid ),
    53.         .display_name   (display_name  ),
    54.         .display_value  (display_value ),
    55.         .display_number (display_number),
    56.         .input_valid    (input_valid   ),
    57.         .input_value    (input_value   ),
    58.  
    59.         //lcd触摸屏相关接口，不需要更改
    60.         .lcd_rst        (lcd_rst       ),
    61.         .lcd_cs         (lcd_cs        ),
    62.         .lcd_rs         (lcd_rs        ),
    63.         .lcd_wr         (lcd_wr        ),
    64.         .lcd_rd         (lcd_rd        ),
    65.         .lcd_data_io    (lcd_data_io   ),
    66.         .lcd_bl_ctr     (lcd_bl_ctr    ),
    67.         .ct_int         (ct_int        ),
    68.         .ct_sda         (ct_sda        ),
    69.         .ct_scl         (ct_scl        ),
    70.         .ct_rstn        (ct_rstn       )
    71.     ); 
    72. //-----{实例化触摸屏}end
    73.  
    74. //-----{从触摸屏获取输入}begin
    75. //根据实际需要输入的数修改此小节，
    76. //建议对每一个数的输入，编写单独一个always块
    77.     //当input_sel为00时，表示输入数控制信号，即alu_control
    78.     always @(posedge clk)
    79.     begin
    80.         if (!resetn)
    81.         begin
    82.             alu_control <= 12'd0;
    83.         end
    84.         else if (input_valid && input_sel==2'b00)
    85.         begin
    86.             alu_control <= input_value[11:0];
    87.         end
    88.     end
    89.     
    90.     //当input_sel为10时，表示输入数为源操作数1，即alu_src1
    91.     always @(posedge clk)
    92.     begin
    93.         if (!resetn)
    94.         begin
    95.             alu_src1 <= 32'd0;
    96.         end
    97.         else if (input_valid && input_sel==2'b10)
    98.         begin
    99.             alu_src1 <= input_value;
    100.         end
    101.     end
    102.  
    103.     //当input_sel为11时，表示输入数为源操作数2，即alu_src2
    104.     always @(posedge clk)
    105.     begin
    106.         if (!resetn)
    107.         begin
    108.             alu_src2 <= 32'd0;
    109.         end
    110.         else if (input_valid && input_sel==2'b11)
    111.         begin
    112.             alu_src2 <= input_value;
    113.         end
    114.     end
    115. //-----{从触摸屏获取输入}end
    116.  
    117. //-----{输出到触摸屏显示}begin
    118. //根据需要显示的数修改此小节，
    119. //触摸屏上共有44块显示区域，可显示44组32位数据
    120. //44块显示区域从1开始编号，编号为1~44，
    121.     always @(posedge clk)
    122.     begin
    123.         case(display_number)
    124.             6'd1 :
    125.             begin
    126.                 display_valid <= 1'b1;
    127.                 display_name  <= "SRC_1";
    128.                 display_value <= alu_src1;
    129.             end
    130.             6'd2 :
    131.             begin
    132.                 display_valid <= 1'b1;
    133.                 display_name  <= "SRC_2";
    134.                 display_value <= alu_src2;
    135.             end
    136.             6'd3 :
    137.             begin
    138.                 display_valid <= 1'b1;
    139.                 display_name  <= "CONTR";
    140.                 display_value <={20'd0, alu_control};
    141.             end
    142.             6'd4 :
    143.             begin
    144.                 display_valid <= 1'b1;
    145.                 display_name  <= "RESUL";
    146.                 display_value <= alu_result;
    147.             end
    148.             default :
    149.             begin
    150.                 display_valid <= 1'b0;
    151.                 display_name  <= 40'd0;
    152.                 display_value <= 32'd0;
    153.             end
    154.         endcase
    155.     end
    156. //-----{输出到触摸屏显示}end
    157. //----------------------{调用触摸屏模块}end---------------------//
    158. endmodule

    testbench.v

    1. `timescale 1ns / 1ps
    2.  
    3. module tb;
    4.  
    5.     // Inputs
    6.     reg clk;
    7.     reg [12:0] alu_control;
    8.     reg [31:0] alu_src1;
    9.     reg [31:0] alu_src2;
    10.     // Outputs
    11.     wire [31:0] alu_result;
    12.  
    13.     // Instantiate the Unit Under Test (UUT)
    14. //alu al(
    15. //    input  [11:0] alu_control, 
    16. //    input  [31:0] alu_src1, 
    17. //    input  [31:0] alu_src2,
    18. //    output [31:0] alu_result 
    19. //    );
    20. alu alu_module(
    21.             .clk(clk),
    22.             .alu_control(alu_control),
    23.             .alu_src1   (alu_src1   ),
    24.             .alu_src2   (alu_src2   ),
    25.             .alu_result (alu_result )
    26.         );
    27.     initial begin
    28.         // Initialize Inputs
    29.         clk = 0;
    30.         alu_control = 0;
    31.         alu_src1 = 32'H10001111;
    32. 		alu_src2 = 32'H00000004;
    33.  
    34.         // Wait 100 ns for global reset to finish
    35.         #100;
    36.         alu_control = 13'b00000_0000_0001;
    37.         #400;
    38.         alu_control = 13'b00000_0000_0010;
    39.         #500;
    40.         alu_control = 13'b00000_0000_0100;
    41.         #400;
    42.         alu_control = 13'b00000_0000_1000;
    43.         #500;
    44.         alu_control = 13'b00000_0001_0000;
    45.         #400;
    46.         alu_control = 13'b00000_0010_0000;
    47.         #500;
    48.         alu_control = 13'b00000_0100_0000;
    49.         #400;
    50.         alu_control = 13'b00000_1000_0000;
    51. 		#400;
    52.         alu_control = 13'b00001_0000_0000;
    53. 		#400;
    54.         alu_control = 13'b00010_0000_0000;
    55. 		#400;
    56.         alu_control = 13'b00100_0000_0000;
    57. 		#400;
    58.         alu_control = 13'b01000_0000_0000;
    59.         #400;
    60.          alu_control = 13'b10000_0000_0000;
    61.         // Add stimulus here
    62.     end
    63.    always #5 clk = ~clk;
    64. endmodule

    multiply.v 和 add.v 之前的记录里有。

     

             一般认为“>>>”在Verilog里是算术右移指令，但实操中发现它有时会在右移时仍然补零，即使符号位为1。这是因为“>>>”会先判断这个操作数是否有符号数。如果是无符号数，则补零，是有符号数，才会补符号位。而一般使用的reg operand; 这种变量定义法默认所定义的变量为无符号数，因此只补零。

    Result = operandB >>> operandA;  //错误示范

        解决办法是利用Verilog的内置函数$signed()，将被移位的操作数转为有符号数类型。

    Result = ($signed(operandB)) >>> operandA;  //更正后

  • 相关阅读:
    XV6源码阅读——进程地址空间
    自己整理博哥爱运维0817-----k8s集成GitLab流水线---md文档
    Windows10电脑音频出现故障【开机小喇叭突然变红叉，我成功解决的方法】
    金仓数据库 KingbaseES V8.3至V8.6迁移最佳实践（2. KingbaseES V8.3和 V8.6 兼容性）
    猫头虎博主第5️⃣期赠书活动:《Java官方编程手册（第12版·Java 17）套装上下册》
    git提交设置忽略指定文件，文件夹
    Stream流使用——(未完)
    用DIV+CSS技术设计的网页与实现制作【体育文化】dreamweaver学生网页设计
    【MySQL】【牛客-SQL进阶挑战】06 其他常用操作
    两APP通信之AIDL使用。
  • 原文地址：https://blog.csdn.net/nahnah_/article/details/128003344