verilog实现除法器运算

这篇具有很好参考价值的文章主要介绍了verilog实现除法器运算。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

verilog实现除法器运算

本文通过verilog实现了一个位宽参数可配置的除法运算模块

1, 设计思路

我们要计算 a_data/b_data = div_data ----remain_data;

  • 🌿 确定位宽:若a_data的位宽为A_WIDTH, b_data的位宽为B_WIDTH;则div_data的最大位宽为A_WIDTH, remain_data的位宽为B_WIDTH;

  • 🍃 计算div_data的最高位:若a_data >= (b_data<<(A_WIDTH-1)), 则div_data的最高位div_data[A_WIDTH-1]为1,否则div_data[A_WIDTH-1]为0; 即div_data[A_WIDTH-1] = a_data > (b_data<<(A_WIDTH-1)) ? 1‘b1 : 1’b0;

  • 🌾 计算div_data的次高位:若div_data的最高位div_data[A_WIDTH-1]为1,则a_data_tmp = a_data – (b_data<<(A_WIDTH-1)); 否则a_data_tmp = a_data; 次高位div_data[A_WIDTH-2] = a_data_tmp >= (b_data<<(A_WIDTH-2)) ? 1‘b1 : 1’b0;

  • 🌴 依次类推,可 计算出完整的div_data;

  • 🌲. 计算完div_data后,可用 remain_data = a_data – b_data*div_data获取余数

举个例子,计算8/3 也就是 4’b1000/3’b011 = 3’b010;

  • 🥝 div_data[3] = 4’b1000 > (3’b011 << 3) ? 1’b1 : 1’b0 ; 由于div_data[3]为0,所以a_data_tmp为4‘b1000;

  • 🥑 div_data[2] = 4’b1000 > (3’b011 << 2) ? 1’b1 : 1’b0; 由于div_data[2]为0,所以a_data_tmp为4‘b1000;

  • 🍇 div_data[1] = 4’b1000 > (3’b011 << 1) ? 1’b1 : 1’b0; 由于div_data[1]为1,所以a_data_tmp为4‘b1000-(3’b011 << 1) = 4’b0010;

  • 🍒 div_data[0] = 4’b0010 > (3’b011 << 0) ? 1’b1 : 1’b0;

  • 🍐所以 div_data = 4‘b0010 = 2;

  • 🌼 remain_data = a_data – b_data*div_data = 8 – 3 * 2 = 2 = 3’b010;

2, Verilog代码

// Filename      : div.v
// Author        : ppkuan
module div(/*autoarg*/
    //Inputs
    clk, rst_n, in_vld, a_data, b_data, 

    //Outputs
    out_vld, remain_data, div_data
);

parameter   A_WIDTH = 10;
parameter   B_WIDTH = 5;
// a_data/b_data = div_data------remain_data

input                             clk         ;
input                             rst_n       ;
input                             in_vld      ;
input       [A_WIDTH - 1 : 0]     a_data      ;
input       [B_WIDTH - 1 : 0]     b_data      ;

output reg                        out_vld     ;
output reg  [B_WIDTH - 1 : 0]     remain_data ;
output reg  [A_WIDTH - 1 : 0]     div_data    ;


wire   [A_WIDTH - 1 : 0]                             div_data_tmp    ;
wire   [A_WIDTH - 1 : 0] [A_WIDTH + B_WIDTH - 1 : 0] ab_data_tmp     ;
wire   [A_WIDTH - 1 : 0] [A_WIDTH - 1 : 0]           a_data_tmp      ; 
wire   [B_WIDTH - 1 : 0]                             remain_data_tmp ;

assign  ab_data_tmp[A_WIDTH - 1]   = b_data << (A_WIDTH - 1);
assign  div_data_tmp[A_WIDTH - 1]  = {{B_WIDTH{1'b0}}, a_data} >= ab_data_tmp[A_WIDTH - 1] ? 1'b1 : 1'b0;
assign  a_data_tmp[A_WIDTH - 1]    = div_data_tmp[A_WIDTH - 1] ? {{B_WIDTH{1'b0}},a_data} - ab_data_tmp[A_WIDTH - 1] : a_data;

genvar i;
generate 
    for(i = A_WIDTH - 2; i >= 0; i--)
        begin:div
            assign ab_data_tmp[i]  = (b_data << i);
            assign div_data_tmp[i] = {{B_WIDTH{1'b0}}, a_data_tmp[i+1]} >= ab_data_tmp[i] ? 1'b1 : 1'b0;
            assign a_data_tmp[i]   = div_data_tmp[i] ? {{B_WIDTH{1'b0}},a_data_tmp[i+1]} - ab_data_tmp[i] : a_data_tmp[i + 1];
        end
endgenerate

assign remain_data_tmp = {{B_WIDTH{1'b0}}, a_data} - div_data_tmp * b_data;

always@(posedge clk or negedge rst_n)
    if(!rst_n)
    begin
        out_vld     <= 'b0            ;
        remain_data <= 'd0            ;
        div_data    <= 'd0            ;
    end
    else if(in_vld)
    begin
        out_vld     <= 'b1            ;
        remain_data <= remain_data_tmp;
        div_data    <= div_data_tmp   ;
    end
    else 
    begin
        out_vld     <= 'b0            ;
    end
endmodule

3, 测试用例:

module test;

wire         clk         ;
wire         rst_n       ;
wire         in_vld      ;
wire [9 : 0] a_data      ;
wire [4 : 0] b_data      ;
wire         out_vld     ;
wire [9 : 0] div_data    ;
wire [4 : 0] remain_data ;

reg         clk_r       ;
reg         rst_n_r     ;
reg         in_vld_r    ;
reg [9 : 0] a_data_r    ;
reg [4 : 0] b_data_r    ;
 
assign clk    = clk_r    ;
assign rst_n  = rst_n_r  ;
assign in_vld = in_vld_r ;
assign a_data = a_data_r ;
assign b_data = b_data_r ;

div#(
    .A_WIDTH(10),
    .B_WIDTH(5)) 
    u_div(/*autoinst*/
    // a_data/b_data = div_data------remain_data

    .clk                            (clk                                        ), // input 
    .rst_n                          (rst_n                                      ), // input 
    .in_vld                         (in_vld                                     ), // input 
    .a_data                         (a_data[9 : 0]                              ), // input 
    .b_data                         (b_data[4 : 0]                              ), // input 

    .out_vld                        (out_vld                                    ), // output
    .remain_data                    (remain_data[4 : 0]                         ), // output
    .div_data                       (div_data[9 : 0]                            )  // output
);

initial
begin
clk_r =    0;
in_vld_r = 0;
rst_n_r =  1;
#10
rst_n_r =  0;
#10
rst_n_r =  1;
#10
in_vld_r = 1;
a_data_r = 10'd57;
b_data_r = 5'd8;
#10
in_vld_r = 0;
$finish;
end

always #5 clk_r = !clk_r;

endmodule

测试结果如图所示

verilog实现除法器运算

57/8 = 7—1;计算正确;文章来源地址https://www.toymoban.com/news/detail-463586.html

到了这里,关于verilog实现除法器运算的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 基于verilog的除法器的实现

    本文应该是目前全网最通俗易懂,而且比较全面的用verilog实现除法器的文章。首先说明一下本文的探讨的重点。我们首先从整数的除法开始讲起,然后慢慢延伸到小数的除法,和负数的除法。 对于一个除法器来说,他的实现框架应该是下面这个图: 在这个框架图中,A是被除

    2024年02月05日
    浏览(28)
  • 数字IC经典电路(2)——经典乘法器的实现(乘法器简介及Verilog实现)

    数字电路中乘法器是一种常见的电子元件,其基本含义是将两个数字相乘,并输出其乘积。与加法器不同,乘法器可以实现更复杂的运算,因此在数字电路系统中有着广泛的应用。 乘法器的主要用途是在数字信号处理、计算机科学以及其他数字电路应用中进行精确的数字乘法

    2024年02月06日
    浏览(64)
  • 数字IC经典电路(1)——经典加法器的实现(加法器简介及Verilog实现)

    加法器是数字系统最基础的计算单元,用来产生两个数的和,加法器是以二进制作运算。负数可用二的补数来表示,减法器也是加法器,乘法器可以由加法器和移位器实现。加法器和乘法器由于会频繁使用,因此加法器的速度也影响着整个系统的计算速度。对加法器的设计也

    2024年02月14日
    浏览(52)
  • verilog编程之乘法器的实现

    知识储备 首先来回顾一下乘法是如何在计算机中实现的。 假设现在有两个32位带符号定点整数x和y,我们现在要让x和y相乘,然后把乘积存放在z中,大家知道,两个32位数相乘,结果不会超过64位,因此z的长度应该为64位。 z = x * y中,x是被乘数,在Verilog代码中 multiplicand表示

    2024年04月12日
    浏览(36)
  • 用加法器实现补码的加/减运算

    目录 1.原码的加减运算 (1)原码的加/减法运算 (2)溢出判断 (3)符号扩展 2.加法器原理 3.加法器实现补码的加减运算 1.原码的加减运算 (1)原码的加/减法运算 正+正---绝对值做加法,结果为正 负+负---绝对值做加法,结果为负 正+负---绝对值大的减绝对值小的,符号同绝

    2024年01月18日
    浏览(48)
  • Verilog实现四位加/减法器(逻辑表达式)

      起因是老师要我们以逻辑表达式的形式交作业,强调是逻辑表达式,在网上找了许久,没有找到,便从一些文章中找到了灵感,特分享 说明: 此代码为四位加/减法器的Verilog代码实现(用的是逻辑表达式) 第一种表达: 第二种表达: 这是上面的波形图 参考链接: 原码

    2024年02月11日
    浏览(34)
  • FPGA流水线除法器(Verilog)原理及实现

      除法器的计算过程如下图所示。 假设数值的位宽为N。 Step1:分别将被除数和除数扩展至原来2倍位宽(2N),被除数在其左边补N位0,除数在其右边补N位0; Step2:将被除数依次左移(每次左移1位),末位补数值(该数值为被除数高N位与除数高N位的商),高N位为被除数高

    2024年02月11日
    浏览(38)
  • 各种加法器的比对分析与Verilog实现(1)

            接下来几篇博客,我将介绍常见的几种加法器设计,包括超前进位、Kogge-Stone、brent-kung、carry-skip、Conditional-Sum等加法器的原理及Verilog实现。        本文将介绍行波进位加法器、超前进位加法器的原理及Verilog实现。 1.1 原理        从下方原理图即可看出,

    2024年02月08日
    浏览(46)
  • 各种加法器的比对分析与Verilog实现(2)

          本文将介绍Kogge-Stone加法器和brent-kung加法器的原理,在下一篇博客中我将用Verilog进行实现。 目录 1. 并行前缀加法器(Parallel-Prefix Adder, PPA)  2. Kogge-Stone加法器原理 3. brent-kung加法器原理        为了减少AND门的深度,PPA对CLA进行了进一步优化。不过PPA和CLA进行的计算

    2024年02月07日
    浏览(53)
  • verilog数组的定义、转换和加法器的实现

    看了别人的博客有的人也称reg [31:0] add0[0:12]这样的数组为二维数组,其实中二维数组不是真正意义上的数组,而是由多个寄存器组成的ROM或者RAM。我觉得这样理解好记一点:这个是一维数组,一共有0到12共13组数据,每组数据的宽度是0到31一共32个位宽。 优势:简单易于编程

    2024年02月11日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包