verilog 多种方法实现多位加法器

最新推荐文章于 2023-04-25 11:43:20 发布
最新推荐文章于 2023-04-25 11:43:20 发布
阅读量1.1w 收藏 78
点赞数 8
分类专栏： verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35608277/article/details/104405424
版权

一位全加器原理
在这里插入图片描述

法1 串行一位加法器法

一位全加器

module adder_1bit(
    input din_one, //第一个加数
    input din_two, //第二个加数
    input cin,     //进位输入
    
    output sum,    //和输出
    output cout    //进位输出
    );
    

//利用连续赋值语句实现全加操作    
   assign sum = din_one ^ din_two ^ cin;
   assign cout = (din_one & din_two) | (din_two & cin) | (din_one & cin);    
endmodule

2bit

module adder_2bit(
    input [1 : 0] din_one,  //第一个加数
    input [1 : 0] din_two,  //第二个加数
    input cin,              //进位输入
    
    output [1 : 0] sum,     //和输出
    output cout             //进位输出
    );
    
    wire cin_0bit;          //低位加法的进位输出

//实例化adder_1bit实现低位加法    
    adder_1bit U1_low_bit(
        .din_one(din_one[0]),
        .din_two(din_two[0]),
        .cin(cin),
        .sum(sum[0]),
        .cout(cin_0bit)
        );
    
//实例化adder_1bit实现高位加法       
    adder_1bit U2_high_bit(
        .din_one(din_one[1]),
        .din_two(din_two[1]),
        .cin(cin_0bit),
        .sum(sum[1]),
        .cout(cout)
        );
        

//利用模块实例化语句实现2位全加操作    
endmodule

4bit

module adder_4bit(
    input [3 : 0] din_one,  //第一个加数
    input [3 : 0] din_two,  //第二个加数
    input cin,              //进位输入
    
    output [3 : 0] sum,     //和输出
    output cout             //进位输出
    );
    
    wire cin_0bit;          //低位加法的进位输出

//实例化adder_1bit实现低位加法    
    adder_2bit U1_low_bit(
        .din_one(din_one[1 : 0]),
        .din_two(din_two[1 : 0]),
        .cin(cin),
        .sum(sum[1 : 0]),
        .cout(cin_0bit)
        );
    
//实例化adder_1bit实现高位加法       
    adder_2bit U2_high_bit(
        .din_one(din_one[3 : 2]),
        .din_two(din_two[3 : 2]),
        .cin(cin_0bit),
        .sum(sum[3 : 2]),
        .cout(cout)
        );
        

//利用模块实例化语句实现2位全加操作    
endmodule

法2 并行加法器

思路 ：直接用加法运算符“+”实现。直接表示

/*******************8位加法器 ***********************/
module adder_nonpipe(cout, sum, ina, inb, cin, enable);
 
output cout;
output [7:0] sum;
input [7:0] ina, inb;
input cin, enable;
 
reg cout;
reg [7:0] sum;
reg [7:0] tempa, tempb;
reg tempc;
 
always @(posedge enable)
begin
    tempa <= ina;
    tempb <= inb;
    tempc <= cin;
end
 
always @(posedge enable)
begin
    {cout,sum} <= tempa + tempb + tempc;
end
 
endmodule

法3 参数化

module N_bit_add(
    clk    ,
    rst_n  ,
    //其他信号,举例dout
    A ,
    B ,
    Cin ,
    dout ,
    sout
    );
    //参数定义
    parameter      DATA_W =         8;

    //输入信号定义
    input               clk    ;

    input               rst_n  ;
    input               Cin  ;
    input[DATA_W-1:0]        A ;
    input[DATA_W-1:0]        B ;
    //输出信号定义
    output[DATA_W-1:0]  dout   ;
    output              sout   ;

    //进位位，S[7]为输出最后进位
    reg   [DATA_W-1:0]  S   ;


    genvar i;
    generate for(i=0;i<DATA_W;i=i+1)
        begin:one_bit_add
            if(i==0)begin
                assign dout[i]=A[i]^B[i]^Cin;
                assign S[i]=(A[i]&B[i])|(A[i]&Cin)|(Cin&B[i]);
            end
            else begin
                assign dout[i]=A[i]^B[i]^S[i-1];
                assign S[i]=(A[i]&B[i])|(A[i]&Cin;)|(Cin&B[i]);
            end
            
        end
    endgenerate
    assign sout=S[7];

    endmodule

法4流水线

 1 /*******************8位2级流水加法器*************************/
 2 module adder_pipeline(cout, sum, ina, inb, cin, enable);
 3 
 4 output cout;
 5 output [7:0] sum;
 6 input [7:0] ina, inb;
 7 input cin, enable;
 8 
 9 reg cout;
10 reg [7:0] sum;
11 
12 reg [3:0] tempa, tempb, firsts;
13 reg firstc;
14 always @(posedge enable)
15 begin
16     {firstc,firsts} = ina[3:0] + inb[3:0] + cin;
17     tempa = ina[7:4];        //高4位输入寄存，使其与sum低4位在下级流水线同步输入。
tempb = inb[7:4];        //否则sum的高4位，与低四位分两个时钟周期输出
18 end
19 
20 always @(posedge enable)
21 begin
22     {cout,sum[7:4]} = tempa + tempb + firstc;
23     sum[3:0] = firsts;       //不能合并为{cout, sum} = {tempa + tempb + firstc, firsts}; 位宽不匹配
24 end
25 
26 endmodule

四级流水线

module adder_pipeline(rst_n,
                                clk,
                                a,
                                b,
                                cin,
                                sum
                                     );
     
parameter     DATA_SIZE = 8;
     
input rst_n;
input clk;
input [DATA_SIZE - 1 : 0] a;
input [DATA_SIZE - 1 : 0] b;    
input cin;

output [DATA_SIZE : 0] sum;

reg [DATA_SIZE - 1 : 0] a_r;
reg [DATA_SIZE - 1 : 0] b_r;
reg cin_r;

reg [DATA_SIZE : 0] sum;

reg [1:0] stage0_sum;
reg stage0_cout;
reg [DATA_SIZE - 1 : 0] stage0_a_r;
reg [DATA_SIZE - 1 : 0] stage0_b_r;

//reg [4:0] stage1_sum;
reg [3:0] stage1_sum;
reg stage1_cout;
reg [DATA_SIZE - 1 : 0] stage1_a_r;
reg [DATA_SIZE - 1 : 0] stage1_b_r;

//reg [6:0] stage2_sum;
reg [5:0] stage2_sum;
reg stage2_cout;
reg [DATA_SIZE - 1 : 0] stage2_a_r;
reg [DATA_SIZE - 1 : 0] stage2_b_r;

//reg [8:0] stage3_sum;
reg [7:0] stage3_sum;
reg stage3_cout;

always@(posedge clk)
    if(!rst_n)
        begin
            a_r <= 8'd0;
            b_r <= 8'd0;
            cin_r <= 1'b0;
        end
    else
        begin
            a_r <= a;
            b_r <= b;
            cin_r <= cin;
        end

always@(posedge clk)
    if(!rst_n)
        begin
            {stage0_cout,stage0_sum} <= 3'd0;
            stage0_a_r <= 8'd0;
            stage0_b_r <= 8'd0;        
        end
    else
        begin
            //{stage0_cout,stage0_sum} <= a_r[1:0] + b_r[1:0] + cin_r;    
            {stage0_cout,stage0_sum} <= {1'b0,a_r[1:0]} + {1'b0,b_r[1:0]} + cin_r;                
            stage0_a_r <= a_r;
            stage0_b_r <= b_r;        
        end
        
always@(posedge clk)
    if(!rst_n)
        begin
            {stage1_cout,stage1_sum} <= 5'd0;
            stage1_a_r <= 8'd0;
            stage1_b_r <= 8'd0;    
        end
    else
        begin
            //{stage1_cout,stage1_sum} <= { {a_r[3:2] + b_r[3:2] + stage0_cout},{stage0_sum} };
            //{stage1_cout,stage1_sum} <= { {{1'b0,a_r[3:2]} + {1'b0,b_r[3:2]} + stage0_cout},{stage0_sum} };    
            //{stage1_cout,stage1_sum} <= { {1'b0,a_r[3:2]} + {1'b0,b_r[3:2]} + stage0_cout,stage0_sum };
            //{stage1_cout,stage1_sum} = { {a_r[3],a_r[3:2]} + {b_r[3],b_r[3:2]} + stage0_cout,stage0_sum };
            {stage1_cout,stage1_sum} <= { {1'b0,stage0_a_r[3:2]} + {1'b0,stage0_b_r[3:2]} + stage0_cout,stage0_sum };
            stage1_a_r <= stage0_a_r;
            stage1_b_r <= stage0_b_r;
        end        

always@(posedge clk)
    if(!rst_n)
        begin
            {stage2_cout,stage2_sum} <= 7'd0;
            stage2_a_r <= 8'd0;
            stage2_b_r <= 8'd0;    
        end
    else
        begin
            {stage2_cout,stage2_sum} <= { {1'b0,stage1_a_r[5:4]} + {1'b0,stage1_b_r[5:4]} + stage1_cout,stage1_sum };            
            stage2_a_r <= stage1_a_r;
            stage2_b_r <= stage1_b_r;
        end        

always@(posedge clk)
    if(!rst_n)
        begin
            {stage3_cout,stage3_sum} <= 9'd0;
        end
    else
        begin
            {stage3_cout,stage3_sum} <= { {stage2_a_r[7],stage2_a_r[7:6]} + {stage2_b_r[7],stage2_b_r[7:6]} + stage2_cout,stage2_sum };    
        end

always@(posedge clk)
    if(!rst_n)
        begin
            sum <= 9'd0;
        end
    else
        begin
            sum <= {stage3_cout,stage3_sum};        
        end
        
endmodule

testbench

 `timescale 1 ns/1 ns

 module tb();

 //时钟周期，单位为ns，可在此修改时钟周期。
 parameter CYCLE    = 20;

 //复位时间，此时表示复位3个时钟周期的时间。
 parameter RST_TIME = 3 ;

 parameter DATA_W    = 4;


 //时钟和复位
 reg clk  ;
 reg rst_n;

 //uut的输入信号
 reg[DATA_W-1:0]  A  ;
 reg[DATA_W-1:0]  B  ;

 reg              Cin;
     //uut的输出信号
     wire      sout;
     wire[DATA_W-1:0] dout;

         //待测试的模块例化
         N_bit_add #(.DATA_W(4))uut(
             .clk          (clk     ), 
             .rst_n        (rst_n   ),
             .A               (A    ),
             .B               (B    ),
	         .Cin               (Cin),
             .dout          (dout   ),
             .sout          (sout   )
             );


             //生成本地时钟50M
             initial begin
                 clk = 0;
                 forever
                 #(CYCLE/2)
                 clk=~clk;
             end

             //产生复位信号
             initial begin
                 rst_n = 1;
                 #2;
                 rst_n = 0;
                 #(CYCLE*RST_TIME);
                 rst_n = 1;
             end
             integer i;
             //输入信号a赋值方式
             initial begin
	        	i=0;
                  #1;
                 //赋初值
	          	Cin=0;
	        	 A= 0;
                 #(10*CYCLE);
                 //开始赋值
                 for (i=0;i<16;i=i+1)begin
                     A=i;
                     #(CYCLE/2);
                 end
             end
	             integer j;	
             initial begin
	        	j=0;
                 #1;
                 //赋初值
		         B = 0;
                 #(10*CYCLE);
                 //开始赋值
                 for (j=0;j<16;j=j+1)begin
                     B=j;
                     #(CYCLE/2);
                 end
             end
     endmodule

ref
https://www.cnblogs.com/youngforever/archive/2013/06/08/3127204.html

rrr2
关注
  • 8
    点赞
  • 踩
  • 78
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
基于CSA原理，使用verilog实现7个数相加
01-04
基于CSA原理，使用verilog实现7个数相加
Verilog实现32位加法器（内含设计代码和测试代码）
01-17
本项目实现的是32位加法器，实现思路为连接4个8位加法器，已通过vivado Simulation。 使用语言：Verilog 使用软件：vivado 本项目包含： 1、vivado项目文件adder_32.xpr 2、readme.txt 3、vivado自动生成的文档(含设计代码和测试代码)
verilog 实现加法器
w40306030072的专栏
03-07 2万+
verilog 实现加法器 （1）半加器的实现 原理：半加器是由两个一位输入实现的，与全加器的区别是不带进位加，相对比较简单，其逻辑关系为：  进位输出：Ci+1=Ai*Bi  和输出：Si = Ai^Bi       其中*为与逻辑，^为异或逻辑。verilog 实现：module half_adder(a,b,sum,cout); input a; input b; ou
N个数求和
素宇的博客
02-21 2590
N个数求和本题的要求很简单，就是求N个数字的和。麻烦的是，这些数字是以有理数分子/分母的形式给出的，你输出的和也必须是有理数的形式。 输入格式：输入第一行给出一个正整数N（≤\le≤100）。随后一行按格式a1/b1 a2/b2 …给出N个有理数。题目保证所有分子和分母都在长整型范围内。另外，负数的符号一定出现在分子前面。 输出格式：输出上述数字和的最简形式 —— 即将结果写成整数部分 分数部分
verilog手撕代码2——各种加法器介绍——真值表、表达式、电路图
qq_42135020的博客
04-25 5112
各种加法器：半加器、全加器、RCA、LCA、CAS
Verilog自学笔记——多个有符号数的加法
ICer_CoolDong的博客
04-27 2690
Verilog自学笔记——多个有符号数的加法 因为神经网络（Neural Networks）需要大量的矩阵乘法，这其中就涉及到大量的有符号数的加法。参考：https://blog.csdn.net/DengFengLai123/article/details/104072423。以下为自己在实际仿真的时候总结。 1.输入的有符号数需要以补码形式存放（即正数用原码，负数用补码存放）。 当然，也可以存放在rom中读进去，但是因为需要使用DC测面积功耗等，而DC无法综合ip核，所以选择手写输入。 对于结果，定
Verilog基础知识（有符号数运算规则，加减运算，乘法运算中的符号位拓展问题）
热门推荐
maxwell2ic的博客
06-08 4万+
rule of thumb The format of the signed type is two’s complement. 有符号数均为补码表示 If any operand in an expression is unsigned the operation is considered to be unsigned. 只有计算表达式右边有无符号数，整个计算式都按照无符号数规则运算 只有...
相邻的数据累加——verilog
SummerXRT的博客
06-11 5353
例如，相邻16个点的数据累加： 数据采用补码形式相加； 在做累加之前要提前给数据位宽扩展 构造一个与源时钟的相反的反向时钟，将源时钟和反向时钟向与，创建一个采样时钟脉syn_pulse； 用计数器计算syn_pulse个数，每当出现syn_pulse，数据就累加一次； 计满16次就将数据输出； 代码如下： //相邻16点相加 module sigma_16(clk,rst_n,data_in,syn_in,data_out,syn_out); input clk,rst_n;
Verilog实现加法器
qq_43483403的博客
12-10 4602
1）实现半加器 半加器是不带进位输入的，只需要输入两个一位的加数a,b，输出和sum，进位输出cout。其逻辑关系式： sum = a^b; (a和b的异或，当输入a和b相同（即a,b同时取0或者同时取1）时，sum=0，当a,b取值不同（a=0,b=1或a=1,b=0）时,sum= 1) cout = a&b；（a，b同时取1时才会有进位输出） 2)全加器 全加器是带进位输入，剩下的端...
我的Verilog学习历程（三） 时序电路的一个例子：实现连加
wjpwjpwjp0831的博客
05-10 3412
学艺不精的我又来记录了（doge 有何错误以及需要改进的地方希望大家不吝指出！ 先看题目： 实验内容： 实验一个可以实现连续加法功能的计算器 具体要求如下： 1） 输入100MHz时钟，由EGO1板通过FPGA管脚直接输入； 2） 电路可实现连续加法功能，例如 A+B+C+……=S。其中A、B、C均为一位十进制数，采用8421码方式输入。加数的个数不超过10个，即S不超过100。但超过两位数时，显示后两位，舍弃百位。 3） 加数输入通过拨4开关SW3-SW0输入，SW3为MSB，通过按键开关确定输入。加号和
32位浮点数加法器_system verilog.zip
08-07
32位浮点数加法器基于system verilog，可以实现串行输入的两个标准化的32位浮点数的相加并得到标准化的结果。此外该加法器能处理“特殊”数字:零、正无穷、负无穷和“非数字(NaN)”。本文件带测试代码
verilog变量命名规则
09-20
论坛摘下来的。
verilog实现2级流水线结构的16位加法器
08-27
由于在网上和书上看到的流水线结构全是基于阻塞赋值的，结果输出是正确的（大部分时间），但是存在亚稳态的情况，
Verilog_一位加法器Verilog编程_
10-02
一位加法器，实现两个一位二进制的相加，有进位输入，输出，很好用，自己写的第一个
verilog写的8位加法器
01-06
verilog写的8位加法器，测试可用，完整程序，立马验证
Verilog &与&&的区别
qq_35608277的博客
02-20 3万+
逻辑操作符 逻辑与 && 逻辑或 || 逻辑非 ！ 位操作符 一元非 ~ 二元与 & 二元或 | 二元异或 ^ 归约操作符（单目运算符） 与归约 & 或归约 | 异或归约 ^ Verilog中&与&&的区别为：性质不同、计算结果不同、参数不同。 一、性质不同 1、&：&是位运算符，表示是按位与。 2、&&：&a...
移位寄存器及verilog实现 并行输入串行输出
qq_35608277的博客
02-20 1万+
1 概念 移位寄存器内的数据可以在移位脉冲（时钟信号）的作用下依次左移或右移。移位寄存器不仅可以存储数据，还可以用来实现数据的串并转换、分频，构成序列码发生器、序列码检测器，进行数值运算以及数据处理等，它也是数字系统中应用非常广泛的时序逻辑部件之一。 ...
Verilog 三种计数器写法
qq_35608277的博客
02-05 1万+
1 时序逻辑和组合逻辑彻底分开 //====================================================================== // --- 名称 : Count_1 // --- 作者 : xianyu_FPGA // --- 日期 : 2018-12-10 // --- 描述 : 模10计数器，0到10循环累加 //==============...
verilog 加法器
最新发布
05-18
Verilog加法器可以使用多种方法来实现，其中包括Ripple Carry Adder、Carry Lookahead Adder、Kogge-Stone Adder、Brent-Kung Adder等。下面以Ripple Carry Adder为例，介绍Verilog加法器的实现。 Ripple Carry Adder是一种基本的加法器，它将两个n位数相加，产生一个n+1位的结果，其中最高位是进位(Carry)。Ripple Carry Adder的实现非常简单，但是速度比较慢。 以下是一个4位Ripple Carry Adder的Verilog代码： ```verilog module rc_adder(a, b, cin, sum, cout); input [3:0] a, b; input cin; output [3:0] sum; output cout; wire [3:0] c; assign sum = a + b + cin; assign cout = c[4]; endmodule ``` 在这里，我们使用了assign语句来计算和(sum)和进位(cout)。其中，c[4]是一个5位的中间信号，表示进位。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值