精华内容
下载资源
问答
  • always模块构成简易ALU运算器 此模块属于组合逻辑电路,其输入、输出信号如下: input opcode, //操作码 input a, //操作数 input b, output out //数值输出 并且利用case语句,结合parameter定义,构建简易ALU...

    always模块构成简易ALU运算器

    此模块属于组合逻辑电路,其输入、输出信号如下:

    input opcode, //操作码
    input a, //操作数
    input b,
    output out //数值输出

    并且利用case语句,结合parameter定义,构建简易ALU运算器如下:

    module C_Alu(
    	input [1:0] opcode,	//操作码
    	input [3:0] a,			//操作数
    	input [3:0] b,
    	
    	output reg [7:0]out	//数值输出
    	);
    
    parameter add = 2'b00;
    parameter sub = 2'b01;
    parameter mul = 2'b10;
    parameter div = 2'b11;
    
    always@(opcode or a or b )		//电平触发
    begin
    	case(opcode)
    		add: out <= a+b;
    		sub: out <= a-b;
    		mul: out <= a*b;
    		div: out <= a/b;
    		default: out <= 8'bz;
    	endcase
    end
    
    endmodule
    

    利用modelsim软件进行仿真,其测试代码如下:

    module C_Alu_tb;
    	reg [1:0] opcode;	//操作码
    	reg [3:0] a;			//操作数
    	reg [3:0] b;
    	
    	wire  [7:0]out;			//数值输出
    
    C_Alu i1 (
    	.a(a),
    	.b(b),
    	.opcode(opcode),
    	.out(out)
    );
    
    initial                                                
    begin                                                  
    	#50 
    	#50 opcode = 2'b01;
    	#50 a=3;b=1;	
    end 
                                                      
    endmodule
    

    在仿真的时间设置上,设置1s停止,时间间隔为1ps,得到的时序图如下:

    仿真图

    由此可验证always搭键建议ALU运算器成功。

    展开全文
  • ALU运算器VHDL

    2012-11-12 13:36:59
    计算机组成原理实验课,用VHDL描述语言写的ALU元算,可以参考
  • 用xilinx设计,仿真已经通过,4位ALU运算器
  • 多功能ALU运算器设计实验实验内容模块说明ALU模块代码(带CF,SF,PF版本)ALU模块代码(不带CF,SF,PF版本)测试用例代码逻辑引脚图仿真截图思考与探索 实验内容   本实验要求设计一个具有16种运算功能的32位ALU,并...

    实验内容

      本实验要求设计一个具有16种运算功能的32位ALU,并能够产生运算结果的标志:结果为零标志ZF(Zero Hag)和溢出标志OF(Overflow Flag)。ALU通过4根控制线ALU_OP[3:0]来选择其16种运算功能。仿真测试,要求测试用例能完整测试各种功能及标志位的不同结果。

    ALU_OP[3:0] ALU功能 操作说明
    0000 and 逻辑与运算
    0001 or 逻辑或运算
    0010 xor 逻辑异或运算
    0011 nor 逻辑或非运算
    0100 add 算术加运算
    0101 sub 算术减运算
    0110 slt 若A<B,则输出1;否则输出0
    0111 sll B逻辑左移A所指定的位数
    1000 F=A+1 自加1
    1000~1001 保留

    模块说明

    module ALU(ALU_OP,A,B,F,ZF,OF); // 模块名为ALU
    	  input  [3:0] ALU_OP;	    // ALU_OP为控制16种运算功能的控制线
    	  input  [32:1] A;		    //A,B为32位的运算数
    	  input  [32:1] B;		    
    	  output [32:1] F;			// F为输出结果
    	  output  ZF;				// ZF为零标志
    	  output  OF;				// OF为溢出标志
    

    ALU模块代码(带CF,SF,PF版本)

    module ALU(ALU_OP,A,B,F,ZF,OF,CF,SF,PF);//加了CF,SF,PF版
    	  input  [3:0] ALU_OP;
    	  input  [32:1] A;
    	  input  [32:1] B;
    	  output [32:1] F;
    	  output  ZF,OF,CF,CF,SF,PF;
    	  reg [32:1] F;
    	  reg  C,ZF,OF,CF,SF,PF;
    	  always@(*)
    	   begin
    		C=0;
    		OF=0;
    		case(ALU_OP)
    			4'b0000:begin F=A&B; end
    			4'b0001:begin F=A|B; end
    			4'b0010:begin F=A^B; end
    			4'b0011:begin F=~(A|B); end 
    			4'b0100:begin {C,F}=A+B;OF = A[32]^B[32]^F[32]^C;CF = C;end 
    			4'b0101:begin {C,F}=A-B;OF = A[32]^B[32]^F[32]^C;CF = ~C; end 
    			4'b0110:begin F=A<B; end
    			4'b0111:begin F=B<<A; end
    			4'b1000:begin {C,F}=A+1;OF = C;;CF = C; end
    		endcase
    		ZF = F==0;
    		SF = F[32];
    		PF = ~^F;
    		end
    endmodule
    

    ALU模块代码(不带CF,SF,PF版本)

    module ALU(ALU_OP,A,B,F,ZF,OF); //未加CF,SF,PF版
    	  input  [3:0] ALU_OP;
    	  input  [32:1] A;
    	  input  [32:1] B;
    	  output [32:1] F;
    	  output  ZF;
    	  output  OF;
    	  reg [32:1] F;
    	  reg    C,ZF,OF;
    	  always@(*)
    	   begin
    		C=0;
    		OF=0;
    		case(ALU_OP)
    			4'b0000:begin F=A&B; end
    			4'b0001:begin F=A|B; end
    			4'b0010:begin F=A^B; end
    			4'b0011:begin F=~(A|B); end 
    			4'b0100:begin {C,F}=A+B;OF = A[32]^B[32]^F[32]^C; end 
    			4'b0101:begin {C,F}=A-B;OF = A[32]^B[32]^F[32]^C; end 
    			4'b0110:begin F=A<B; end
    			4'b0111:begin F=B<<A; end
    			4'b1000:begin {C,F}=A+1;OF = C!=0; end
    		endcase
    		ZF = F==0;
    		end
    endmodule
    

    测试用例代码

    initial begin
    		A=32'h55555555; B=32'h99999999;
    		ALU_OP = 4'b0000; #100;//按位与
    		ALU_OP = 4'b0001; #100;//按位或
    		ALU_OP = 4'b0010; #100;//按位异或
    		ALU_OP = 4'b0011; #100;//按位或非
    		ALU_OP = 4'b0100; #100;//相加
    		ALU_OP = 4'b0101; #100;//相减				
    		ALU_OP = 4'b0110; #100;//判断A<B
    		ALU_OP = 4'b0111; #100;//B逻辑左移A
    		ALU_OP = 4'b1000; #100;//自加1
    		
    		A=32'h00FF00FF; B=32'h5F5F5F5F;
    		ALU_OP = 4'b0000; #100;//按位与
    		ALU_OP = 4'b0001; #100;//按位或
    		ALU_OP = 4'b0010; #100;//按位异或
    		ALU_OP = 4'b0011; #100;//按位或非
    		ALU_OP = 4'b0100; #100;//相加
    		ALU_OP = 4'b0101; #100;//相减				
    		ALU_OP = 4'b0110; #100;//判断A<B
    		ALU_OP = 4'b0111; #100;//B逻辑左移A
    		ALU_OP = 4'b1000; #100;//自加1
    		
    		A=32'hF0F0F0F0; B=32'h00000004;
    		ALU_OP = 4'b0000; #100;//按位与
    		ALU_OP = 4'b0001; #100;//按位或
    		ALU_OP = 4'b0010; #100;//按位异或
    		ALU_OP = 4'b0011; #100;//按位或非
    		ALU_OP = 4'b0100; #100;//相加
    		ALU_OP = 4'b0101; #100;//相减				
    		ALU_OP = 4'b0110; #100;//判断A<B
    		ALU_OP = 4'b0111; #100;//B逻辑左移A
    		ALU_OP = 4'b1000; #100;//自加1
    		
    		A=32'h00000004; B=32'hEFEFEFEF;
    		ALU_OP = 4'b0000; #100;//按位与
    		ALU_OP = 4'b0001; #100;//按位或
    		ALU_OP = 4'b0010; #100;//按位异或
    		ALU_OP = 4'b0011; #100;//按位或非
    		ALU_OP = 4'b0100; #100;//相加
    		ALU_OP = 4'b0101; #100;//相减				
    		ALU_OP = 4'b0110; #100;//判断A<B
    		ALU_OP = 4'b0111; #100;//B逻辑左移A
    		ALU_OP = 4'b1000; #100;//自加1
    		
    	end
    endmodule
    

    逻辑引脚图

    在这里插入图片描述

    仿真截图

    ①操作数:A=32’h55555555; B=32’h99999999;
    在这里插入图片描述
    在这里插入图片描述

    ②操作数:A=32’h00FF00FF; B=32’h5F5F5F5F;
    在这里插入图片描述
    在这里插入图片描述

    思考与探索

    1. 对于加法运算,当输入测试数据A=OFFFFH, B=1H时,该组数据相加产生什么结果?请同学考虑,当A、B被看作无符号数,A. B被看成有符号数,这两种情况下运算器硬件操作上有区别吗?无符号数和有符号数是怎样识别的呢?

      答:该组数据相加产生10000H。当A、B被看作无符号数,A. B被看成有符号数,这两种情况下运算器硬件操作上没有区别,系统对有符号数和无符号数的加减法都采用一样的策略。CPU只会根据输入信号进行逻辑运算,在硬件级别没有有符号无符号的概念。识别无符号数和有符号数,可以根据指令进行判断,如MIPS加法指令,add是带符号数加,addu是无符号数加。

    2. 仔细研究MIPS的核心指令集,结合本实验所实现的ALU,分析该ALU能否实现MIPS核心指令集的所有指令?如果不能,请分析它还需要哪些运算功能?

      答:经过分析,该ALU不能实现MIPS核心指令集的所有指令。它还需要:带进位的加法运算、带进位的减法运算、位清除指令、负数比较、位测试指令、比较指令、相等测试指令等。

    3. 从你的实验结果中能否对以下问题得出结论:slt操作中“A<B”,是对有符号数的比较还是无符号数的比较?如果不能,请考虑对A=32’b0、B= 32’bFFFF_ FFFF 做slt操作实验,得出该问题的结论。

      答:带入数据进行实验研究
      A=32’b0; B=32’hFFFFFFFF; F=1
      A=32’hFFFFFFFFF; B=32’b0; F=0
      A=32’h8FFFFFFF; B=32’hFFFFFFFF; F=1
      A=32’hFFFFFFFF; B=32’h8FFFFFFF; F=0
      A=32’h0FFFFFFF; B=32’h7FFFFFFF; F=1
      A=32’h8FFFFFFF; B=32’h7FFFFFFF; F=0
      表明slt操作中的“A<B”是对无符号数的比较。

    4. 实验中的ALU实现了逻辑左移操作sll,考虑逻辑右移和算术右移操作如何实现?
      考虑为何MIPS指令系统中没有算术左移指令?

      答:逻辑右移可以通过B>>A实现。算术右移还需判断原操作数的符号位(最高位),若原操作数符号位为0,则操作与逻辑右移相同。若原操作数符号为1,需要在逻辑右移的基础上,将B操作数的最高A位置1。MIPS指令系统中没有算术左移指令是因为算数左移和逻辑左移的方法是一样的。

    5. 80X86CPU除了ZF和OF,还有其他标志位,试理解80X86的3个标志位SF、CF和PF的作用和逻辑,将这3个标志位实现到MIPS的多功能ALU中,并完成板级调试。
      答:详见实验源代码。

    展开全文
  • 简单的ALU运算器 HDL实现

    千次阅读 2020-08-27 20:55:23
    一个运算器 包含这许许多多的运算方式,但输出只有一个 result 。 接下来我们就根据图来分析代码 *module* simple_alu( *input* [11:0] alu_control, *//控制信号* *input* [31:0] alu_src1, *//源操作数* *...

    一个运算器 包含这许许多多的运算方式,但输出只有一个 result 。

    接下来我们就根据图来分析代码

    在这里插入图片描述

    *module* simple_alu(
    
      *input* [11:0] alu_control,  *//控制信号*
    
      *input* [31:0] alu_src1,   *//源操作数*
    
      *input* [31:0] alu_src2,   *//源操作数*
    
      *output*[31:0] alu_result   
    
    );
    
      *//定义操作变量*
    
      *wire* op_add;  *//加法操作*
    
      *wire* op_sub;  *//减法*
    
      *wire* op_slt;  *//有符号比较,小于置位 小于置位可以理解为小于取1*
    
      *wire* op_sltu ; *//无符号比较 ,小于置位* 
    
      *wire* op_and;
    
      *wire* op_nor;  *//按位或非* 
    
      *wire* op_or;   
    
      *wire* op_xor;  *//按位异或* 
    
      *wire* op_sll;  *//逻辑左移* 
    
      *wire* op_srl;  *//逻辑右移* 
    
      *wire* op_sra;  *//算术右移* 
    
      *wire* op_lui;  *//高位加载* 
    
    
    
      *//将控制信号赋值给操作变量*
    
      *assign* op_add *=* alu_control[0];
    
      *assign* op_sub *=* alu_control[1];
    
      *assign* op_slt *=* alu_control[2];
    
      *assign* op_sltu *=* alu_control[3];
    
      *assign* op_and *=* alu_control[4];
    
      *assign* op_nor *=* alu_control[5];
    
      *assign* op_or *=* alu_control[6];
    
      *assign* op_xor *=* alu_control[7];
    
      *assign* op_sll *=* alu_control[8];
    
      *assign* op_srl *=* alu_control[9];
    
      *assign* op_sra *=* alu_control[10];
    
      *assign* op_lui *=* alu_control[11];
    
    
    
      *wire* [31:0] add_sub_result; *//加减用一个结果*
    
      *wire* [31:0] slt_result;
    
      *wire* [31:0] sltu_result;
    
      *wire* [31:0] and_result;
    
      *wire* [31:0] nor_result;
    
      *wire* [31:0] or_result;
    
      *wire* [31:0] xor_result;
    
      *wire* [31:0] sll_result;
    
      *wire* [31:0] srl_result;
    
      *wire* [31:0] sra_result;
    
      *wire* [31:0] lui_result;
    
    
    
      *//位运算*
    
      *assign* and_result *=* alu_src1 *&* alu_src2 ;
    
      *assign* or_result *=* alu_src1 *|* alu_src2;
    
      *assign* nor_result *=* *~*or_result;
    
      *assign* xor_result *=* alu_src1 ^ alu_src2;
    
      *assign* lui_result *=* {alu_src2[15:0 , 16'b0]}; *//理解高位加载的含义 将小尾端 0———15位左移,后16位补零 提取指令中需要用到的数*
    
    
    
    
    
      *//加法减法*
    
      *wire* [31:0] adder_a;
    
      *wire* [31:0] adder_b;
    
      *wire*    adder_cin;  *//cin*
    
      *wire* [31:0] adder_result; *//结果*
    
      *wire*    adder_count; *//进位*
    
    
    
      *//加减法运算 以及 比较运算的减法*
    
      *assign* adder_a *=* alu_src1;
    
      *assign* adder_b *=* (op_sub *|* op_slt *|*op_sltu) ? *~*alu_src2 : alu_src2;  *//如果涉及到减法的操作,按位取反*
    
      *assign* adder_cin *=* (op_sub *|* op_slt *|*op_sltu) ? 1'b1 : 1b'0;     *//再加一*
    
      *assign* {adder_count, adder_result} *=* adder_a *+* adder_b *+* adder_cin;
    
      *assign* add_sub_result *=* adder_result;
    
    
    
      *//有符号比较*
    
      *assign* slt_result[31:1] *=* 31'b0;  *//结果非符号位置零*
    
      *assign* slt_result[0] *=* ({alu_src1[31] *&* alu_src2[31]})*|* (*~*(alu_src1[31] ^ alu_src2[31]) *&* adder_result[31] );  *//减法分为两段,第一段比较两操作数异号的情况,第二段比较两操作数同号的情况,并且需要结合两数做减法的结果。*
    
    
    
      *//无符号比较*
    
      *assign* sltu_result [31:1] *=* 31'b0;
    
      *assign* sltu_result [0]  *=* *~*adder_count;  *//无符号数没有符号 因此直接看进位 取反*
    
    
    
      *//逻辑左移*
    
      *assign* sll_result *=* alu_src2 *<<* alu_src1[4:0];
    
      *//逻辑右移*
    
      *assign* srl_result *=* alu_src2 *>>* alu_src1[4:0];
    
    
    
      *//算术右移*
    
      *assign* sra_result *=* ($*signed*(alu_src2)) *>>>* alu_src1[4:0];
    
    
    
    
    
      *assign* alu_result *=* ({32 { op_add *|* op_sub}} *&* add_sub_result)*|*  ({32{op_slt}} *&* slt_result)*|*  ({32{op_sltu}} *&* sltu_result)*|*  ({32{op_and}} *&* and_result)*|*  ({32{op_nor}} *&* nor_result)*|*  ({32{op_or}} *&* or_result)*|*  ({32{op_xor}} *&* xor_result)*|*  ({32{op_sll}} *&* sll_result)*|*  ({32{op_srl}} *&* srl_result)*|*  ({32{op_sra}} *&* sra_result)*|*  ({32{op_lui}} *&* lui_result);
    
    
    
    *endmodule*
    

    需要注意的几点

    1. 三输入 :两个源操作数 一个控制信号 一输出:结果
    2. 定义有符号无符号比较大小时,小于置位的含义位,src1 < src2 则结果为1 反之为0
    3. 理解高位加载的含义 将小尾端 0———15位左移,后16位补零 目的是提取指令中需要用到的数
    4. 减法 按位取反加1 分布实现
    5. 有符号比较大小要用到减法的结果
    6. 无符号比较要用到加法的进位
    展开全文
  • 8位ALU运算器(VHDL语言)

    热门讨论 2011-05-18 19:10:08
    (1)按照实验要求设计简单ALU,能执行8种操作,分别为: 1)加、减、增1、减1等4种8位...也可以先构造4位加法,再进一步实现8位加减运算。 注意:算术运算的两个操作数要求都是带符号数,即1位符号位和7位数据位。
  • 四位二进制ALU运算器

    2010-07-18 20:50:46
    数字系统综合设计,实现四位二进制数逻辑运算和算术运算
  • module alu5(ena, clk, opcode, a, b, c,d); parameter N = 32; //状态编码 parameter sla=3'b000, sra=3'b001, add=3'b010, sub=3'b011, mul=3'b100, andd=3'b101, ord=3'b110, notd=3'b111; //定义...

    源文件:

    
    module alu5(ena, clk, opcode, a, b, c,d);
    
    	parameter N = 32; 
    	//状态编码
    	parameter sla=3'b000,
    	sra=3'b001,
    	add=3'b010,
    	sub=3'b011,
    	mul=3'b100,
    	andd=3'b101,
    	ord=3'b110,
    	notd=3'b111;
    	
    	//定义输入输出端口
    	input ena, clk;
    	input [2 : 0] opcode;
    	input signed [N - 1 : 0] a, b; //输入有符号整数范围为[-128, 127] 
    	output signed[N-1:0] c;
    	output signed[2:0] d;
    	
    	//内部寄存器定义
    	reg signed [N : 0] temp;
    	reg cf;
    	reg [5:0] ii;
    	reg signed [N-1:0] c;
    	reg signed [2:0] d;
    	
    	//逻辑实现
    	always@(posedge clk)
    	begin
    		if(ena)
    		begin
    			casex(opcode)
    				sla:
    					begin
    					  c={a[31],a[29],a[28],a[27],a[26],a[25],a[24],a[23],a[22],a[21],a[20],a[19],a[18],a[17],a[16],a[15],a[14],a[13],a[12],a[11],a[10],a[9],a[8],a[7],a[6],a[5],a[4],a[3],a[2],a[1],a[0],1'b0};
    					  if({a[29],a[28],a[27],a[26],a[25],a[24],a[23],a[22],a[21],a[20],a[19],a[18],a[17],a[16],a[15],a[14],a[13],a[12],a[11],a[10],a[9],a[8],a[7],a[6],a[5],a[4],a[3],a[2],a[1],a[0]}==30'b000000000000000000000000000000)
    					  	d[0]=1'b1;
    					  else
    					  	d[0]=1'b0;
    					  if(a[N-1]==1'b1)
    					  	d[2]=1'b1;
    					  else
    					  	d[2]=1'b0;
    					  d[1]=1'bz;
    					end
    				sra:
    					begin
    					  c={a[31],a[31],a[30],a[29],a[28],a[27],a[26],a[25],a[24],a[23],a[22],a[21],a[20],a[19],a[18],a[17],a[16],a[15],a[14],a[13],a[12],a[11],a[10],a[9],a[8],a[7],a[6],a[5],a[4],a[3],a[2],a[1]};
    					  if({a[31],a[30],a[29],a[28],a[27],a[26],a[25],a[24],a[23],a[22],a[21],a[20],a[19],a[18],a[17],a[16],a[15],a[14],a[13],a[12],a[11],a[10],a[9],a[8],a[7],a[6],a[5],a[4],a[3],a[2],a[1]}==31'b0000000000000000000000000000000)
    					  	d[0]=1'b1;
    					  else
    					  	d[0]=1'b0;
    					  if(a[N-1]==1'b1)
    					  	d[2]=1'b1;
    					  else
    					  	d[2]=1'b0;
    					  d[1]=1'bz;
    					end
    				add:
    					begin
    					  temp=0;
    					  temp={1'b0,a[N-1:0]}+{1'b0,b[N-1:0]};
    					  c=temp[N-1:0];
    					  cf=temp[N];
    					  d[1]=c[N-1]^a[N-1]^b[N-1]^cf;
    					  if(c==32'h00000000)
    					  	d[0]=1'b1;
    					  else
    					  	d[0]=1'b0;
    					  if(c[N-1]==1'b1)
    					  	d[2]=1'b1;
    					  else
    					  	d[2]=1'b0;
    					 end
    				sub:
    					begin
    					  temp=0;
    					  temp={1'b0,a[N-1:0]}-{1'b0,b[N-1:0]};
    					  c=temp[N-1:0];
    					  cf=temp[N];
    					  d[1]=c[N-1]^a[N-1]^b[N-1]^cf;
    					  if(c==32'h00000000)
    					  	d[0]=1'b1;
    					  else
    					  	d[0]=1'b0;
    					  if(c[N-1]==1'b1)
    					  	d[2]=1'b1;
    					  else
    					  	d[2]=1'b0;
    					 end
    				mul:
    					begin
    					  c=0;
    					  for(ii=0;ii<32;ii=ii+1)
    						if(b[ii])
    						  c=c+(a<<(ii));
    					  if(c==32'h00000000)
    						d[0]=1'b1;
    					  else
    						d[0]=1'b0;
    					  d[2]=a[31]^b[31];
    					  d[1]=1'bz;
    					end
    				andd:
    					begin
    					  c=a&b;
    					  if(c==32'h00000000)
    						d[0]=1'b1;
    					  else
    						d[0]=1'b1;
    					  d[2]=1'b0;
    					  d[1]=1'b0;
    					end
    				ord:
    					begin
    					  c=a|b;
    					  if(c==32'h00000000)
    						d[0]=1'b1;
    					  else
    						d[0]=1'b0;
    					  d[2]=1'b0;
    					  d[1]=1'b0;
    					end
    				notd:
    					begin
    					  c=~a;
    					  if(c==32'h00000000)
    						d[0]=1'b1;
    					  else
    						d[0]=1'b0;
    					  d[2]=1'b0;
    					  d[1]=1'b0;
    					end
    				default: c<=0;
    
    			endcase
    		end
    	end
    endmodule
    
    

    测试文件:

    `timescale 1ns/1ns
    `define half_period 5
    module alu_t5(c,d);
    	//alu位宽定义
    	parameter N = 32;
    	parameter sla=3'b000,
    	  sra=3'b001,
    	  add=3'b010,
    	  sub=3'b011,
    	  mul=3'b100,
    	  andd=3'b101,
    	  ord=3'b110,
    	  notd=3'b111;
    	
    	//输出端口定义
    	output signed [N-1 : 0] c;
    	output signed [2 : 0] d;
    	
    	//寄存器及连线定义
    	reg ena, clk;
    	reg [2 : 0] opcode;
    	reg signed [N - 1 : 0] a,b;
    	
    	//产生测试信号
    	initial
    	begin
    		//设置电路初始状态
    		#20 clk = 0; ena = 0; opcode = 3'b000;
    			a = 32'd0; b = 32'd0;
    		#20 ena = 1;
    		
    		//test sla
    		#20 a=32'hdffffffd;
    	    opcode=sla;
    		#20 a=32'h4ffffff0;
    	    opcode=sla;
    		
    		//test sra
    		#20 a=32'hfffffffd;
    	    opcode=sra;
    		#20 a=32'h3ffffff9;
    	    opcode=sra;
    		
    		//test add
    		#20 a=32'd1000;
    	    b=32'd2000;
    	    opcode=add;
    		#20 a=32'd2000;
    	    b=-32'd5000;
    	    opcode=add;
    		#20 a=-32'd120000;
    	    b=-32'd10000;
    	    opcode=add;
    		#20 a=32'd6000;
    	    b=-32'd6000;
    	    opcode=add;
    		
    		//test sub
    		#20 a=32'd6000;
    	    b=32'd5000;
    	    opcode=sub;
    		#20 a=32'd2000;
    	    b=32'd4000;
    	    opcode=sub;
    		#20 a=32'd8000;
    	    b=32'd8000;
    	    opcode=sub;
    		
    		//test mul
    		#20 a=32'd100;
    	    b=32'd100;
    	    opcode=mul;
    		#20 a=-32'd200;
    	    b=32'd300;
    	    opcode=mul;
    		#20 a=-32'd400;
    	    b=-32'd200;
    	    opcode=mul;
    		
    		//test and
    		#20 a=32'h0101_1101;
    	    b=32'h1100_0110;
    	    opcode=andd;
    		#20 a=32'h1101_1001;
    	    b=32'h0010_0110;
    	    opcode=andd;
    		
    		//test or
    		#20 a=32'h0111_0011;
    	    b=32'h0001_1011;
    	    opcode=ord;
    		#20 a=32'h1111_0000;
    	    b=32'h1111_1111;
    	    opcode=ord;
    		
    		//test not
    		#20 a=32'h1111_0000;
    	    opcode=notd;
    		#20 a=32'h1111_1111;
    	    opcode=notd;
    		
    		
    		#100 $stop;
    	end
    	
    	//产生时钟
    	always #`half_period clk = ~clk;
    	
    	//实例化
    	alu5 m0(.ena(ena), .clk(clk), .opcode(opcode), .a(a), .b(b), .c(c), .d(d));
    endmodule
    
    
    展开全文
  • 实验三 运算器组成实验 目录实验三 运算器组成实验一、实验说明1.多位串行加法器和多位可控加减电路的设计(必做)2. 快速加法器的设计(必做)3. 阵列乘法器设计(必做)4. 阵列除法器设计(选做)5. 多位算术逻辑...
  • Verilog编写的32位ALU运算器

    热门讨论 2009-03-06 16:13:43
    用Verilog编写的32位ALU运算器),具有与、或逻辑运算;加、减算术运算;小于置一,零检测,以及溢出检测等功能。其中加法运算是采用了快速进位链
  • 算逻运算器ALU实验

    2021-04-09 19:21:12
    算逻运算器ALU实验一、实验目的二、实验要求三、实验原理四、实验内容五、实验环境与设备六、实验代码设计(含符号说明)七、实验检验与测试 一、实验目的 理解算术逻辑单元 ALU 的工作原理。 掌握算术逻辑单元ALU ...
  • 加法: CHIP Add16 { IN a [ 16 ] , b [ 16 ] ; OUT out [ 16 ] ; PARTS : // Put you code here: HalfAdder ( a = a [ 0 ] , b = b [ 0 ] , carry = c0 , sum = out [ 0 ] ) ; ...
  • 2)运算器的核心是算术逻辑单元(ALU)。 3)运算器的操作种类来源于控制器,操作的数值来源于存储器。处理结果往往返回存储器(也可以暂时保存)。 4)运算器也包含许多通用的逻辑单元,暂存操作数,累加器(ACC)...
  • educoder logism 计算机组成原理 8位可控加减法电路设计CLA182四位先行进位电路设计等九关完整答案,已通过。
  • 华中科技大学实验设计,包含8位可控加法电路设计到MIPS运算器设计等11项已通关实验。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,090
精华内容 436
关键字:

alu运算器