FPGA实现除法运算

我们用软件编程的时候,用到除法的时候,一个/这样的除号就搞定了。但是如果用硬件来实现除法,又是怎么样实现的了。

计算机存储的数都是以二进制数来存储的,二进制的除法和我们平常用到十进制除法是一样的。辗转相除法。

  clip_image001

计算如上图,从最高位开始计算,如果大于除数,商为1。然后算下一位。直到算到最后一位,最后剩的结果为余数。

原理是很简单的,但是实现起来,还是有点麻烦的。下面就编写代码来实现硬件的除法。

这里输入的除数和被除数都是8位的数。简单考虑,都是无符号数。即不考虑数据正负。输出的商和余数也都是8位表示。

从以上的图片计算,我们可看出,计算是首先将除数和被除数的最高的三位,比较,如果小于,则对应计算出来的商为1,然后被除数要减去除数,否则为0。然后再将除数和被除数的后面三位在比较,依次与被除数的最后3位比较完,输出最后的结果。

而这里,我们采用的方法是,将被除数,扩展成16位的数据,低8位为被除数的值,高八位的值全为0。开始信号有效时,将被除数扩展成16位数据赋值给data,然后开始运算。比较data的高八位和除数的值,如果大于0,说明被除数大,将此时商置1,赋值给data的最低位,然后将data8位数据减去除数。最后将data向左移位一位,准备下一次比较。最终计算8次后。Data的高8位数据就为所求的余数,低八位就为所求的商。

下面举个例子说明:

初始:输入被除数的值为78,输入除数的值为34

 

Data_next

除数

每次结果()

Data_reg

开始

00000000_01001110

00100010

 

0000000_01001110

左移一位

00000000_10011100

 

00000000(0)

00000000_10011100

左移两位

00000001_00111000

 

00000001(0)

00000001_00111000

左移三位

00000010_01110000

 

00000010(0)

00000010_01110000

左移四位

00000100_11100000

 

00000100(0)

00000100_11100000

左移五位

00001001_11000000

 

00001001(0)

00001001_11000000

左移六位

00010011_10000000

 

00010011(0)

00010011_10000000

左移七位

00100111_00000000

 

00000101(1)

00100111_00000000

左移八位

00000101_00000001

 

00001010(0)

00001010_00000010

计算完后,输出的商就为2(00000010),余数为10。计算正确。

 

代码如下,所示:

`timescale 1ns / 1ps

module divison

#(

    parameter W = 16,  //扩展的位数

    parameter N = 8    //输入的除数和被除数的位数

)

(

    input                    clk,

    input                   rst_n,

    input         [N1:0]     dividend,

    input         [N1:0] divisor,

    input                   start,

    output   wire [N1:0]     quotient,

    output   wire [N1:0]     remainder,

    output   reg          ready,

    output   reg         busy,

    output   reg             finish

        

);

parameter idle       = 3’b000;

parameter start_div   = 3’b001;

parameter shift       = 3’b010;

parameter done      = 3’b110;

 

reg[2:0] state;    

reg[2:0] state_next;

 

reg[W1:0] data;

reg[W1:0] data_next;

 

reg[N1:0] n_reg;   //存储计算的次数

reg[N1:0] n_next;

 

always@(posedge clk) begin

   if(!rst_n) begin

        state <= idle;

        data_next <= 0;

        n_reg <= 0;

    end

    else  begin

        state <= state_next;

        data <= data_next;

        n_reg <= n_next;

    end

end

always@*  begin

    state_next = state ;

    data_next=data;

    n_next = n_reg;

    ready = 1;

    busy = 0;

    finish = 0;

    case(state)

    idle: begin

        data = 0;

        //只有在空闲状态,开始信号才有效。

        if( start == 1 && busy !=0 ) begin 

            state_next = shift;

            data_next = {{WN{1’b0}},dividend};

            n_next = N;

        end

    end

    shift: begin

        data_next = {data[W2:0],1’b0};

        busy = 1;

        ready = 0;

        n_next = n_reg 1’b1;

        if(data_next[W1:N] >= divisor) begin

            data_next[0] = 1;

            data_next[W1:N] = data_next[W1:N] divisor;

        end

        if(n_reg==1)

            state_next = done;                         

    end

    done:  begin

        finish = 1;

        state_next = idle;

    end

    endcase

end

assign quotient  = finish ? data[N1:0] : quotient;

assign remainder = finish ? data[W1:N] : remainder;

endmodule

代码,比较简单,只要知道了原理,代码是很好编写的。主要是要理解将被除数扩展为16位。然后再计算。

编写测试代码,测试:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

reg[5:0] i;

 

always #1 clk = ~clk;

initial begin

    // Initialize Inputs

    clk = 0;

    rst_n = 0;

    dividend = 12;

    divisor = 123;

    start = 0;

 

    // Wait 100 ns for global reset to finish

    #100  rst_n = 1;

    start = 1;

   

    for(i=0;i<=32;i=i+1) begin

         dividend = {$random}%256 ;

         divisor = {$random}%256;

         start = 1;

       @(finish);

    end

end

    仿真图如下所示。

 

image

从仿真图中,可看出,在输入数据8个时钟周期后,输出最终的计算结果。

 

此条目发表在FPGA分类目录,贴了, 标签。将固定链接加入收藏夹。

发表评论

电子邮件地址不会被公开。