精华内容
下载资源
问答
  • Verilog实现ALU的代码

    2020-12-19 12:45:01
    Verilog实现ALU的代码
  • Verilog实现ALU.zip

    2019-10-22 23:50:22
    使用Verilog语言实现一个四位的ALU运算单元(包括设计文件和约束文件)
  • 实验目的 一、 掌握算术逻辑单元 (ALU) 的功能。 二、 掌握数据通路和控制器的设计方法。 三、 掌握组合电路和时序电路,以及参数化和结构化...三、 完成6位ALU的下载测试,并查看RTL电路图,以及实现电路资源和时间性

    实验目的

    一、 掌握算术逻辑单元 (ALU) 的功能。
    二、 掌握数据通路和控制器的设计方法。
    三、 掌握组合电路和时序电路,以及参数化和结构化的Verilog描述方法。
    四、 了解查看电路性能和资源使用情况。
    五、 利用ALU设计应用器件。

    实验环境

    Vivado 2019.2 on ubantu20.04

    实验步骤

    一、 完成ALU模块的逻辑设计和仿真
    二、 查看32位ALU的RTL和综合电路图,以及综合电路资源和时间性能报告
    三、 完成6位ALU的下载测试,并查看RTL电路图,以及实现电路资源和时间性能报告
    四、 完成FLS的逻辑设计、仿真和下载测试

    工程文件源代码

    https://github.com/windwangustc/USTC

    实验过程

    一、 ALU模块的逻辑设计和仿真

    在这里插入图片描述
    根据上图的输入输出逻辑真值表,可以很容易的设计出ALU功能模块,代码如下:

    module alu #(parameter WIDTH=32)
        (
            input clk,
            input [WIDTH-1:0] a,b,
            input [2:0]f,
            output reg [WIDTH-1:0] y,
            output reg z
        );
        localparam ADD=0, SUB=1, AND=2, OR=3, XOR=4;
        always @(*)
        begin
            case(f)
                ADD: y = a+b; 
                SUB: y = a-b;
                AND: y = a&b;
                OR:  y = a|b;
                XOR: y = a^b;
                default: 
                    begin y = 0 ;
                           z = 1; 
                    end
           endcase
           if(y) z=0;
           else  z=1;
        end
    endmodule
    

    以4位ALU为例进行仿真的结果如下,可以看到加减与或的逻辑结果和时序都正确,Y=0时Z输出1:
    在这里插入图片描述
    32位ALU的RTL:
    在这里插入图片描述

    二、 完成6位ALU的下载测试,并查看RTL电路图

    在这里插入图片描述
    6位ALU的逻辑电路图已经给出了,在原有的ALU上加上寄存器和译码器即可完成电路设计,同时有了寄存器就可以分析时间性能了,代码如下图所示。其中寄存器FABZY都是由module register实例化后得来,之后将这些寄存器同实例化后的ALU和Decoder连线即可。

    module alu_6
    (   
            input en,clk,
            input [7:0] sw,
            output  z,
            output [5:0] y
    );
    wire ef,ea,eb;
    wire [5:0] x;
    assign x[5:0]= sw[5:0];
    wire [5:0] a,b;
    wire [2:0] f;
    wire [5:0] y_in;
    wire z_in;
    decoder_2to4 d1(.en(en),.sel(sw[7:6]),.ef(ef),.ea(ea),.eb(eb));
    register #(3,0) F(.clk(clk),.rst(0),.en(ef),.d(x[2:0]),.q(f[2:0]));
    register #(6,0) A(.clk(clk),.rst(0),.en(ea),.d(x[5:0]),.q(a[5:0]));
    register #(6,0) B(.clk(clk),.rst(0),.en(eb),.d(x[5:0]),.q(b[5:0]));
    alu #(6) alu6 (.a(a),.b(b),.f(f),.y(y_in),.z(z_in));
    register #(6,0) Y(.clk(clk),.rst(0),.en(1),.d(y_in[5:0]),.q(y[5:0]));
    register #(1,0) Z(.clk(clk),.rst(0),.en(1),.d(z_in),.q(z));
    endmodule
    
    

    RTL图如下图所示,和上面给的电路图是一致的:
    在这里插入图片描述

    三、 完成FLS的逻辑设计、仿真和下载测试

    在这里插入图片描述
    根据上面的功能描述和状态转移表,可以设计出大致的数据通路,这里还需要几个选择器来选择初始状态下输入输出f1=d,f2=d,下图未画出:
    在这里插入图片描述
    FLS模块的代码如下,其中edge_detect是取边沿模块,目的是无论button按下持续多少个周期,都只产生一个周期的使能信号,register_2_signal是针对fn-1和fn-2的输入输出寄存器。在最后一个always块中,实现了状态机。

    module FLS
    (
        input  clk, rst, en,
        input  [6:0]  d,
        output [6:0]  f
     );
        wire [6:0] fn_1,fn_2;
        reg [6:0] Fn_1,Fn_2;
        reg [6:0] fn_tmp;
        wire [6:0] fn;
        wire pos_edge;
    //generate en edge signal
    edge_detect Edge_input(.clk(clk),.en(en),.pos_edge(pos_edge));
    //register for fn-2 and fn-1
    register_2_signal #(7) RegforFeedback
    (
    .clk(clk),.en(pos_edge),.rst(rst),
    .Fn_1(Fn_1),.Fn_2(Fn_2),.fn_1(fn_1),.fn_2(fn_2)
    );
    //calculate with 7-bit ALU
    alu #(7) alu_7(.a(fn_1),.b(fn_2),.f(3'b000),.y(fn));
    always@(*)
    begin
        if(fn_2==0)
            begin
                Fn_2 = d;
                Fn_1 = 0;
                fn_tmp = d;
                //original fib start with 0 1 1....
                //Fn_2 = 7'b0000001;
            end
        else if(fn_1==0)
            begin
                Fn_2 = fn_2;
                Fn_1= d;
                fn_tmp= d;
                //original fib start with 0 1 1....
                //Fn_1 = 7'b0000001;
            end
        else
            begin   
                Fn_1 = fn;
                Fn_2 = fn_1;
                fn_tmp = fn;
            end
    end
    //output f
    register #(7,0) reg_f(.clk(clk),.rst(rst),.en(pos_edge),.d(fn_tmp),.q(f));
    endmodule
    
    

    RTL电路如下,可以看到和逻辑设计中的数据通路是基本一致的:

    在这里插入图片描述
    FLS仿真结果如下,pos_edge是en取边沿后的触发信号,可以看到f前两次f1=d,f2=d,之后的f时序符合斐波那契序列,正确:
    在这里插入图片描述

    展开全文
  • 算术逻辑单元(arithmetic and logic unit) 是能实现多组算术运算和逻辑运算的组合逻辑电路,简称ALU。 module ALU(A, B, Cin, Sum, Cout, Operate, Mode); input [3:0] A, B; // two operands of ALU input Cin...

    算术逻辑单元(arithmetic and logic unit) 是能实现多组算术运算和逻辑运算的组合逻辑电路,简称ALU。

    module ALU(A, B, Cin, Sum, Cout, Operate, Mode); 
    
    input [3:0] A, B; // two operands of ALU 
    input Cin; //carry in at the LSB 
    input [3:0] Operate; //determine f(.) of sum = f(a, b) 
    input Mode; //arithmetic(mode = 1'b1) or logic operation(mode = 1'b0) 
    output [3:0] Sum; //result of ALU 
    output Cout; //carry produced by ALU operation 
    // carry generation bits and propogation bits. 
    wire [3:0] G, P; 
    
    // carry bits; 
    reg [2:0] C; 
    reg Cout;
    
    // function for carry generation: 
    function gen; 
    input A, B; 
    input [1:0] Oper; 
    begin 
    case(Oper) 
    2'b00: gen = A; 
    2'b01: gen = A & B; 
    2'b10: gen = A & (~B); 
    2'b11: gen = 1'b0; 
    endcase
    end 
    endfunction
    // function for carry propergation: 
    function prop; 
    input A, B; 
    input [1:0] Oper; 
    
    begin 
    case(Oper) 
    2'b00: prop = 1; 
    2'b01: prop = A | (~B); 
    2'b10: prop = A | B; 
    2'b11: prop = A; 
    endcase
    end 
    endfunction 
    
    // producing carry generation bits; 
    assign G[0] = gen(A[0], B[0], Operate[1:0]); 
    assign G[1] = gen(A[1], B[1], Operate[1:0]); 
    assign G[2] = gen(A[2], B[2], Operate[1:0]); 
    assign G[3] = gen(A[3], B[3], Operate[1:0]); 
    
    // producing carry propogation bits; 
    assign P[0] = prop(A[0], B[0], Operate[3:2]); 
    assign P[1] = prop(A[1], B[1], Operate[3:2]); 
    assign P[2] = prop(A[2], B[2], Operate[3:2]); 
    assign P[3] = prop(A[3], B[3], Operate[3:2]); 
    
    // producing carry bits with carry-look-ahead; 
    always @(G or P or Cin, Mode) 
    begin 
    if (Mode) begin 
    C[0] = G[0] | P[0] & Cin; 
    C[1] = G[1] | P[1] & G[0] | P[1] & P[0] & Cin;
    C[2] = G[2] | P[2] & G[1] | P[2] & P[1] & G[0] | P[2] & P[1] & P[0] & Cin; 
    Cout = G[3] | P[3] & G[2] | P[3] & P[2] & G[1] | P[3] & P[2] & P[1] & G[0] | P[3] & 
    P[2] & P[1] & P[0] & Cin; 
    end 
    else begin 
    C[0] = 1'b0; 
    C[1] = 1'b0; 
    C[2] = 1'b0; 
    Cout = 1'b0; 
    end 
    end 
    
    // calculate the operation results; 
    assign Sum[0] = (~G[0] & P[0]) ^ Cin; 
    assign Sum[1] = (~G[1] & P[1]) ^ C[0]; 
    assign Sum[2] = (~G[2] & P[2]) ^ C[1]; 
    assign Sum[3] = (~G[3] & P[3]) ^ C[2]; 
    
    endmodule
    module ALU(A, B, Cin, Sum, Cout, Operate, Mode); 
    input [3:0] A, B; //输入信号:两个四位的操作对象A、B
    input Cin; //输入进位信号
    input [3:0] Operate; //输入信号,决定输出sum的操作
    input Mode; //算数操作(mode = 1'b1) 或者 逻辑操作(mode = 1'b0) 
    output [3:0] Sum; //输出ALU计算结果
    output Cout; //输出ALU操作产生的进位信号
    
    wire [3:0] G, P; //进位生成位和增长位
    
    reg [2:0] C; 
    reg Cout;
    
    function gen; //进位信号生成函数
    input A, B; //函数输入信号A、B
    input [1:0] Oper; //函数输入操作信号Oper
    begin 
    case(Oper) 
    2'b00: gen = A; //生成A信号
    2'b01: gen = A & B; //生成A和B相与信号
    2'b10: gen = A & (~B); //生成A和~B相与信号
    2'b11: gen = 1'b0; //生成低电平信号
    endcase
    end 
    endfunction
    
    function prop; //进位信号增长函数
    input A, B; //函数输入信号A、B
    input [1:0] Oper; //函数输入操作信号Oper
    
    begin 
    case(Oper) 
    2'b00: prop = 1; //返回高电平信号
    2'b01: prop = A | (~B); //返回A和~B相或信号
    2'b10: prop = A | B; //返回A和B相或信号
    2'b11: prop = A; //返回A信号
    endcase
    end 
    endfunction 
    
    //产生进位生成位信号
    assign G[0] = gen(A[0], B[0], Operate[1:0]); 
    assign G[1] = gen(A[1], B[1], Operate[1:0]); 
    assign G[2] = gen(A[2], B[2], Operate[1:0]); 
    assign G[3] = gen(A[3], B[3], Operate[1:0]); 
    
    //产生进位增长位信号
    assign P[0] = prop(A[0], B[0], Operate[3:2]); 
    assign P[1] = prop(A[1], B[1], Operate[3:2]); 
    assign P[2] = prop(A[2], B[2], Operate[3:2]); 
    assign P[3] = prop(A[3], B[3], Operate[3:2]); 
    
    //产生带进位提前的进位
    always @(G or P or Cin, Mode) 
    begin 
    if (Mode) begin 
    C[0] = G[0] | P[0] & Cin; 
    C[1] = G[1] | P[1] & G[0] | P[1] & P[0] & Cin;
    C[2] = G[2] | P[2] & G[1] | P[2] & P[1] & G[0] | P[2] & P[1] & P[0] & Cin; 
    Cout = G[3] | P[3] & G[2] | P[3] & P[2] & G[1] | P[3] & P[2] & P[1] & G[0] | P[3] & 
    P[2] & P[1] & P[0] & Cin; 
    end 
    else begin 
    C[0] = 1'b0; 
    C[1] = 1'b0; 
    C[2] = 1'b0; 
    Cout = 1'b0; 
    end 
    end 
    
    //计算操作结果
    assign Sum[0] = (~G[0] & P[0]) ^ Cin; 
    assign Sum[1] = (~G[1] & P[1]) ^ C[0]; 
    assign Sum[2] = (~G[2] & P[2]) ^ C[1]; 
    assign Sum[3] = (~G[3] & P[3]) ^ C[2]; 
    
    endmodule
    

     

    展开全文
  • Verilog 语言实现alu的设计 用Verilog 语言实现alu的设计
  • [verilog]ALU实现

    万次阅读 2018-04-12 09:19:34
    module alu( input signed [31:0] alu_a, input signed [31:0] alu_b, input [4:0] alu_op, output reg [31:0] alu_out ); parameter A_NOP = 5'h00; parameter A_ADD = 5'h01; parameter A_SUB = 5'h02; ...

     

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: 
    // 
    // Create Date:    16:44:32 03/29/2018 
    // Design Name: 
    // Module Name:    alu 
    // Project Name: 
    // Target Devices: 
    // Tool versions: 
    // Description: 
    //
    // Dependencies: 
    //
    // Revision: 
    // Revision 0.01 - File Created
    // Additional Comments: 
    //
    //
    module alu(
    input  signed	 [31:0]	alu_a,
    input  signed	 [31:0]	alu_b,
    input	          [4:0]   alu_op,
    output  reg		 [31:0]	alu_out
    );
    
    parameter	A_NOP	= 5'h00;	
    parameter	A_ADD	= 5'h01;
    parameter	A_SUB	= 5'h02;
    parameter	A_AND = 5'h03;
    parameter	A_OR  = 5'h04;
    parameter	A_XOR = 5'h05;
    parameter	A_NOR = 5'h06;
    
    
    always@(*)
    begin
    case (alu_op)
    	A_NOP:alu_out = 32'b0;
    	A_ADD:alu_out = alu_a + alu_b;
    	A_SUB:alu_out = alu_a - alu_b;
    	A_AND:alu_out = alu_a & alu_b;
    	A_OR :alu_out = alu_a | alu_b;
    	A_XOR:alu_out = alu_a ^ alu_b;
    	A_NOR:alu_out = alu_a ~^ alu_b;
    endcase
    end
    	
    
    endmodule
    

     

    下面写一个top模块进行实例化

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: 
    // 
    // Create Date:    16:45:31 03/29/2018 
    // Design Name: 
    // Module Name:    top 
    // Project Name: 
    // Target Devices: 
    // Tool versions: 
    // Description: 
    //
    // Dependencies: 
    //
    // Revision: 
    // Revision 0.01 - File Created
    // Additional Comments: 
    //
    //
    module top(
    input 	 [31:0] a,
    input  	 [31:0] b,
    output    [31:0] out
        );
    
    wire [31:0] c;
    wire [31:0] d;
    wire [31:0] e;
    
    alu al0(a,b,5'h01,c);
    alu al1(b,c,5'h01,d);
    alu al2(c,d,5'h01,e);
    alu al3(d,e,5'h01,out);
    
    endmodule
    

     

    展开全文
  • Verilog HDL是一种硬件描述语言(HDL:Hardware Description Language),以文本形式来描述数字系统硬件的结构和行为的语言,用它可以表示逻辑电路图、逻辑表达式,还可以表示数字逻辑系统所完成的逻辑功能。 Verilog...
  • VERILOG实现的4位 ALU 模块实现 5种运算 加减 与或非
  • 算术逻辑单元(Arithmetic&logical Unit)是中央处理器(CPU)的执行单元,是所有中央处理器的核心组成部分,由"And Gate"(与门) 和"Or Gate"(或门)构成的算术逻辑单元,主要功能是进行二位元的算术运算,如加减乘...
  • Verilog 实现一个简单的ALU

    万次阅读 多人点赞 2019-10-31 20:49:33
    Verilog实现一个简单的ALU,使其具有进行N位有符号数的加法、减法及大小比较运算的功能。本篇文章实现的ALU以N = 8为例,想要实现其他位宽的数据运算,可以通过修改N的值来实现。 代码实现: /*------------------...

    简介:
    用Verilog实现一个简单的ALU,使其具有进行N位有符号数的加法、减法及大小比较运算的功能。本篇文章实现的ALU以N = 8为例,想要实现其他位宽的数据运算,可以通过修改N的值来实现。
    代码实现:

    /*----------------------------------------------------------------
    Filename: alu.v
    Function: 设计一个N位的ALU(可实现两个N位有符号整数加 减 比较运算)
    Author: Zhang Kaizhou
    Date: 2019-10-31 20:40:42
    -----------------------------------------------------------------*/
    module alu(ena, clk, opcode, data1, data2, y);
    	//定义alu位宽
    	parameter N = 8; //输入范围[-128, 127]
    	
    	//定义输入输出端口
    	input ena, clk;
    	input [1 : 0] opcode;
    	input signed [N - 1 : 0] data1, data2; //输入有符号整数范围为[-128, 127] 
    	output signed [N : 0] y; //输出范围有符号整数范围为[-255, 255]
    	
    	//内部寄存器定义
    	reg signed [N : 0] y;
    	
    	//状态编码
    	parameter ADD = 2'b00, SUB = 2'b01, COMPARE = 2'b10;
    	
    	//逻辑实现
    	always@(posedge clk)
    	begin
    		if(ena)
    		begin
    			casex(opcode)
    				ADD: y <= data1 + data2; //实现有符号整数加运算
    				SUB: y <= data1 - data2; //实现有符号数减运算
    				COMPARE: y <= (data1 > data2) ? 1 : ((data1 == data2) ? 0 : 2); //data1 = data2 输出0; data1 > data2 输出1; data1 < data2 输出2;
    				default: y <= 0;
    			endcase
    		end
    	end
    endmodule
    
    /*------------------------------------
    Filename: alu_t.v
    Function: 测试alu模块的逻辑功能
    Author: Zhang Kaizhou
    Date: 2019-10-31 20:42:38
    ------------------------------------*/
    `timescale 1ns/1ns
    `define half_period 5
    module alu_t(y);
    	//alu位宽定义
    	parameter N = 8;
    	
    	//输出端口定义
    	output signed [N : 0] y;
    	
    	//寄存器及连线定义
    	reg ena, clk;
    	reg [1 : 0] opcode;
    	reg signed [N - 1 : 0] data1, data2;
    	
    	//产生测试信号
    	initial
    	begin
    		//设置电路初始状态
    		#10 clk = 0; ena = 0; opcode = 2'b00;
    			data1 = 8'd0; data2 = 8'd0;
    		#10 ena = 1;
    		
    		//第一组测试
    		#10 data1 = 8'd8; data2 = 8'd5; //y = 8 + 5 = 13
    		#20 opcode = 2'b01; // y = 8 - 5 = 3
    		#20 opcode = 2'b10; // 8 > 5 y = 1
    		
    		//第二组测试
    		#10 data1 = 8'd127; data2 = 8'd127; opcode = 2'b00; //y = 127 + 127 = 254
    		#20 opcode = 2'b01; //y = 127 - 127 = 0
    		#20 opcode = 2'b10; // 127 == 127 y = 0
    		
    		//第三组测试
    		#10 data1 = -8'd128; data2 = -8'd128; opcode = 2'b00; //y = -128 + -128 = -256
    		#20 opcode = 2'b01; //y = -128 - (-128) = 0
    		#20 opcode = 2'b10; // -128 == -128 y = 0
    		
    		//第四组测试
    		#10 data1 = -8'd52; data2 = 8'd51; opcode = 2'b00; //y = -52 + 51 = -1
    		#20 opcode = 2'b01; //y = -52 - 51 = -103
    		#20 opcode = 2'b10; //-52 < 51 y = 2
    		
    		#100 $stop;
    	end
    	
    	//产生时钟
    	always #`half_period clk = ~clk;
    	
    	//实例化
    	alu m0(.ena(ena), .clk(clk), .opcode(opcode), .data1(data1), .data2(data2), .y(y));
    endmodule
    

    ModelSim仿真结果:
    在这里插入图片描述
    总结:
    由上面的仿真结果可知,本次设计的ALU的逻辑功能达到的设计预期。
    本次设计的关键点在于通过 “singed"的关键字定义输入输出数据为有符号的整数。这样使得加减运算变得十分简单,可以直接采用”+" "-"符号来实现相关运算,从而免去了自己设计有符号加法器的繁琐过程。
    附注:
    关于原码 反码 补码转换相关问题的总结:
    在数字电路中,运算基本单元为0 1 代码构成的二进制数。在计算机存储器中,数字是以其二进制补码的形式存放的。
    带符号数的二进制表示是以 符号位 + 数值位表示的。正数符号位为0,负数符号位为1。
    例如:假定二进制数长度为8位,其中最高位为符号位。

    1. 原码表示法:
      5 = 0000 0101B -5 = 1000 0101B

    2. 反码表示法:
      5 = 0000 0101B -5 = 1111 1010B

    3. 补码表示法:
      5 = 0000 0101B -5 = 1111 1011B

    由以上可知:

    1. 正数的原码,反码,补码均相同。
    2. 负数的反码 = 原码各位取反(除符号位)。
    3. 负数的补码 = 反码 + 1。
    4. +0的补码 = -0的补码 = 0000 0000B

    【重要】

    1. 位宽为N的二进制数能够表示的有符号整数的范围为[-2^(n - 1), 2^(n - 1) - 1]。
      例如N = 8,即一个8位二进制数能够表示的有符号整数的范围为[-2^7, 2^7 - 1] = [-128, 127]。
    2. 位宽为N的二进制数能够表示的无符号整数的范围为[0, 2^n - 1]。
      例如N = 8,即一个8位二进制数能够表示的无符号整数的范围为[0, 2^8 - 1] = [0, 255]。
    展开全文
  • 32位ALU设计(verilog实现)

    千次阅读 多人点赞 2020-11-06 18:40:42
    ​ 算术逻辑单元(arithmetic and logic unit) 是能实现多组算术运算和逻辑运算的组合逻辑电路,简称ALU。算术逻辑单元是中央处理器(CPU)的执行单元,是所有中央处理器的核心组成部分,由"And Gate"(与门) 和"Or ...
  • alu verilog HDL 语言实现

    2009-12-10 22:26:47
    verilog HDL语言实现ALU 运行于quartus II
  • 1.题目 2.源码 // ********************************************************************************* // Project Name : 74381_ALU // Email : 2972880695@qq.com // Website : https://home.cnbl...
  • 简单ALU(算术逻辑单元)的verilog实现,可实现两数相加、相减,或一个数的加1、减1操作。 小结: 要学会看RTL图,能够根据RTL图大致判断功能的正确性 代码: 1 module alu_add_sub( 2 rst_n, 3 ...
  • DE1-SoC_ALU_程序 用DE1-SoC板的多周期输入实现。 DE1-SoC板,ModelSim ALTERA入门版和Quartus II Web Edition 14.1
  • Verilog HDL8位ALU

    2015-11-17 14:55:19
    Verilog HDL语言实现的一个8位ALU硬件电路
  • Verilog HDL语言实现一个4位的ALU

    千次阅读 多人点赞 2019-01-22 12:37:03
    编写一个4位的ALU实现8种逻辑运算功能 在设计ALU的代码之前,首先应学会任务task和函数function,利用任务和函数可以把一个很大的程序模块分解成许多较小的任务和函数便于理解和调试。 task和function的相同点和...
  • ALU设计 用Verilog HDL

    2013-04-16 10:09:24
    Verilog HDL设计一个模块,该模块实现了一个4bit的ALU,可以对两个4bit二进制操作数进行算术运算和逻辑运算  算术运算包括加法与减法  逻辑运算包括与运算、或运算  设计一个模块,利用Verilog HDL模块元件实例...
  • 使用Verilog语言实现一个四位的ALU运算单元实验内容需要实现的功能设计思路约束文件测试最后 设计思路主要来自这里,不过原文的乘法实现有一些小问题,我做了一些修改。 实验内容 设计一个算术逻辑单元 输入信号:...
  • 8位RISC CPU的Verilog实现 文章目录8位RISC CPU的Verilog实现一. 设计需求二. 硬件组成2.1 存储器2.1.1 ROM2.2.2 RAM2.2 CPU2.2.1 PC2.2.2 累加器2.2.3 地址选择器2.2.4 ALU2.2.5 通用寄存器2.2.6 IR2.3 内部结构...
  • 1、利用Verilog语言完成单周期MIPS指令处理器的设计, 2、锻炼复杂电路的设计能力。 二、实验要求 完成单周期MIPS指令处理器设计,并下载到FPGA开发板上,开发板的LED灯显示ALU的计算结果,处理器的时钟由开发板上的...

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

verilog实现alu