数字IC经典电路（3）——经典除法器的实现（除法器简介及Verilog实现）

写在前面的话

除法器是一种用于执行除法运算的电路或器件。在数字电路中，除法器经常被用作重要的计算单元，其主要功能是将一个数除以另一个数并给出商和余数。

与加法器和减法器类似，除法器也属于算术逻辑单元(ALU)的一种。不同的是，加法器和减法器能够执行加法和减法运算，但不能执行除法运算。因此，在数字电路中，需要引入除法器来执行除法运算。

除法器通常由两个输入，也就是被除数和除数，以及两个输出，也就是商和余数。当除法器接收到被除数和除数时，它会执行除法运算并给出商和余数。除法器可以使用不同的算法和技术来实现，在设计数字电路时，需要考虑精度、速度和功耗等因素。

在数字电路中，除法器的应用非常广泛。除法器可以用于实现浮点数运算、计算器、编码器、解码器、系统控制等多种应用。在图像处理、音频处理和信号处理等领域，除法器也经常被用于执行复杂的算法和数据处理任务。

总之，除法器是数字电路中不可或缺的一个部分，它可以用于执行除法运算并支持多种应用。值得注意的是，除法器的设计需要考虑多方面的因素，尤其是在高性能应用中需要考虑速度和精度等方面的要求。

除法器分类

数字IC设计中常用的除法器种类有以下几种：

1. 二进制除法器：输入为两个二进制数，输出为商和余数。常用于计算机系统中的除法操作。

2. 非恢复余数除法器：输入为两个二进制数，输出为商和余数。与二进制除法器相比，非恢复余数除法器可实现更高的除法精度。

3. 恢复余数除法器：输入为两个二进制数，输出为商和余数。与非恢复余数除法器相比，恢复余数除法器可实现更高的精度和速度。

4. SRT除法器：输入为两个二进制数，输出为商和余数。SRT除法器采用了一种特殊的算法，能够实现高速除法运算。

5. 模数N除法器：输入为两个二进制数和一个模数N，输出为商和余数。该种除法器常用于数字信号处理和通信系统中。

6. 浮点除法器：输入为两个浮点数，输出为商。常用于科学计算、图像处理等领域中。

经典除法器

8bit并行除法器

并行除法器是一种用于处理数字除法的电路，可以同时处理多个数字的除法运算。它可以高效地进行除法计算，并且可以加速复杂数学运算。

Verilog代码：

// -----------------------------------------------------------------------------
// Editor : 0078
// Verdion: v1.0
// Description:  8 bit parallel divider
// -----------------------------------------------------------------------------
module parallel_div(
  input 				       clk 			    , 		//时钟信号
  input [7:0] 			       dividend 		, 		// 被除数
  input [7:0] 			       divisor 		    , 		// 除数
  output reg [7:0] 		       quotient 		, 		// 商
  output wire [7:0] 		   remainder 			    // 余数
);

reg [7:0] temp_dividend; // 寄存器，存储被除数



// 除法操作，使用反复修正法
always @(posedge clk) begin
  temp_dividend <= {temp_dividend[6:0], dividend[7]}; // 左移后添加被除数最高位
  if(temp_dividend >= divisor) begin
    temp_dividend <= temp_dividend - divisor;
    quotient <= quotient + 1;
  end else begin
    quotient <= quotient;
  end
end

assign remainder = temp_dividend;

endmodule

Quartus RTL图

Quartus Post mapping图

8bit无符号二进制除法器

无符号二进制除法器是一种用于计算二进制数除法运算的电路或程序。它可以将一个无符号二进制被除数除以一个无符号二进制除数，得到商和余数。

原理是基于二进制数的整除的短除法运算。将被除数和除数都转换为二进制数，然后从高位向低位逐位进行除法运算，每次计算都要将被除数左移一位，在最后一位上填充一个新的二进制位。如果被除数减去除数结果为负数，则余数为被除数，否则余数为被除数减去除数。除数和被除数的二进制位数越多，需要进行的除法运算次数和计算复杂度就越大。

Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// File   : 8bit_div.v
// Verdion: v1.0
// Description: 
// -----------------------------------------------------------------------------
module div_8bit (
  input  				[7:0] 	dividend 		, 	// 被除数
  input  				[7:0] 	divisor 		, 	// 除数
  input  						clk 			,   // 时钟
  input  						reset 			,   // 复位信号
  output reg 			[7:0]  	quotient 		, 	// 商
  output reg 			[7:0] 	remainder  			// 余数
);

  reg [7:0]  	quo 	; 	// 定义一个寄存器quo，用于保存商
  reg [15:0]  	buf1 	; 	// 定义一个寄存器buf1，用于暂存除数和被除数
  reg [3:0]  	count 	;  	// 定义一个计数器count，用于计数和判断是否完成计算

  always @(posedge clk or posedge reset) begin
    if (reset) begin // 如果收到复位信号，则重新开始计算
      quo <= 8'b0;
      buf1 <= {dividend, divisor};
      count <= 4'b0000;
    end else begin
      if (count == 4'b0000) begin // 如果是第一步，则将被除数移至buf的高8位
        buf1[15:8] <= buf1[7:0];
        buf1[7:0] <= divisor; // 将除数移至buf的低8位
        count <= 4'b0001; // 更新计数器
      end else begin
        buf1 <= buf1 << 1; // 左移1位，相当于乘以2
        if (buf1[15:8] >= buf1[7:0]) begin // 如果buf的高8位大于或等于buf的低8位，则进行减法运算
          buf1[15:8] <= buf1[15:8] - buf1[7:0];
          quo[count - 1] <= 1'b1; // 将当前位的商设置为1
        end else begin
          quo[count - 1] <= 1'b0; // 将当前位的商设置为0
        end
        count <= count + 1; // 更新计数器
        if (count == 4'b1000) begin // 如果计算完成，则将quo和buf的高8位从buf中取出，分别输出作为商和余数
          quotient <= quo;
          remainder <= buf1[15:8];
        end
      end
    end
  end

endmodule

Quartus RTL图

Quartus Post mapping图

非恢复余数除法器

非恢复除法器（non-restoring division）是一种计算除法的电路，其原理是在每一次迭代中，被除数与当前的余数进行比较，根据比较结果决定余数的调整，并根据调整后的余数和商位的值计算下一位的商。非恢复除法器的主要思想是通过减少余数的调整次数以提高计算速度和效率。

在数字电路中，非恢复除法器常常用于高性能计算机的算术单元中，用于执行除法运算。与恢复除法器相比，非恢复除法器的计算速度更快，且设计更简单，适合在需要高性能计算的场合中使用。

以32位二进制数除以16位二进制数为例，非恢复除法器的计算流程如下：

1. 对于N位的被除数和M位的除数，将被除数放在N位的寄存器中，商放在另一N位的寄存器中，并将余数置为零。

2. 从高位到低位，将每一位的被除数和余数相减，将结果存入寄存器中，并根据比较结果选择下一步操作。如果结果大于或等于零，说明当前商位应为1，将商位设置为1；否则，说明当前商位应为0，将商位设置为0。

3. 根据商位的值，将当前余数调整为被除数-除数或者为余数本身。如果当前余数已经小于或等于除数，则无需调整余数。

4. 重复步骤2和3，直到计算出所有的商位。

非恢复除法器是一种高效的计算除法的电路，常用于高性能计算环境中。

Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : non_restoring_div.v
// Create : 2023-03-22 13:36:45
// Revise : 2023-03-22 13:36:45
// Editor : 0078
// Verdion: v1.0
// Description: non-restoring divider
// --------------------------------- --------------------------------------------
module non_restoring_div (
  input                   clk       ,   // 时钟信号
  input         [7:0]     dividend  ,   // 被除数，8位
  input         [7:0]     divisor   ,   // 除数，8位
  output wire   [7:0]     quotient  ,   // 商，8位
  output wire   [7:0]     remainder     // 余数，8位
);

  reg [7:0] count; // 计数器，8位
  reg [7:0] temp_dividend; // 被除数临时变量，8位
  reg [7:0] temp_quotient; // 商临时变量，8位

  always @(posedge clk) begin
    if (count == 8'd0) begin // 初始条件，8次循环结束后跳出循环
      temp_dividend <= dividend; // 初始化，被除数先保存到临时变量中
      count <= 8'd1; // 计数器初始化为1
    end else begin
      count <= count + 8'd1; // 每次循环计数器加1
      if (temp_dividend >= divisor) begin // 如果被除数大于等于除数，则减去除数，商加1
        temp_dividend <= temp_dividend - divisor;
        temp_quotient <= temp_quotient + 8'd1;
      end else begin // 如果被除数小于除数，则商不变
        temp_quotient <= temp_quotient + 8'd0;
      end
    end
  end

  assign quotient = temp_quotient; // 将最终的商输出
  assign remainder = temp_dividend; // 将最终的余数输出

endmodule

Quartus RTL图

Quartus Post mapping图

恢复余数除法器

恢复除法器是一种广泛应用于数字电路中的除法器，可用于进行高速计算。其原理是将被除数与除数的具有符号的二进制数先进行扩展，然后再进行除法操作，最终得到商和余数。

该除法器在数字电路中的应用非常广泛，可用于高速计算、信号处理、图像处理等领域。其特点是计算速度快、精度高、可靠性强等，可以大大提高数字电路的工作效率。

除此之外，恢复除法器还有一些其他的优点，如可以进行高精度的带符号除法计算，还可以支持浮点除法、多项式除法等操作，因此在数字电路设计中得到了广泛的运用。

恢复除法器是一种功能强大、应用广泛的除法器，其原理简单而实用，对于数字电路的高速计算和处理具有重要作用。
Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : restore_div.v
// Create : 2023-03-22 14:04:49
// Revise : 2023-03-22 14:04:49
// Editor : 0078
// Verdion: v1.0
// Description: 
// -----------------------------------------------------------------------------

module restore_div (
  input   				clk 		,   // 时钟信号
  input 		[7:0] 	a 			,  	// 被除数
  input 		[7:0] 	b 			,  	// 除数
  output reg 	[7:0] 	quotient 	,  	// 商
  output reg 	[7:0] 	remainder   	// 余数
);

  reg [7:0] count;       // 用于计算商的寄存器
  reg [7:0] partial_dividend;  // 部分商
  wire [15:0] dividend;  // 真正的被除数
  reg  [7:0] remainder_partial;  // 部分余数

  // 将被除数 a 左移 8 位，成为真正的被除数 dividend
  assign dividend = {a, 8'b0};

  // 开始执行除法运算
  always @(posedge clk) begin
    if (count <= 7) begin
      // 正常情况下，部分余数应该为 0，否则应该加上除数 b
      if (remainder_partial >= b) begin
        partial_dividend[count] <= 1;
        remainder_partial <= remainder_partial - b;
      end else begin
        partial_dividend[count] <= 0;
      end
      remainder_partial <= {remainder_partial, dividend[count]} - (b * partial_dividend[count]);
    end

    // 每执行 8 次，就得到了一个完整的部分商，放入商的寄存器中
    if ((count == 7) && (remainder_partial >= b)) begin
      partial_dividend[count] <= 1;
      remainder_partial <= remainder_partial - b;
    end
    if (count == 7) begin
      quotient <= partial_dividend;
      remainder <= remainder_partial;
    end

    // 计数器每次加 1
    count <= count + 1;
  end

endmodule

Quartus RTL图

Quartus Post mapping图

SRT除法器

SRT除法器是一种高速除法电路，被广泛应用于数字信号处理（DSP）和计算机系统中。SRT除法器采用SRT（Sweeney — Robertson — Tocher）算法，它建立在恒定除数除法的基础上，可以实现高速的除法运算。

SRT除法器在数字电路中的应用非常广泛，主要是用于科学计算和信号处理器设计。SRT除法器的优点是能够在最短的时间内完成除法运算，减少了计算时间和计算硬件的使用。这使得它在大规模数字信号处理、图像处理和音频处理等领域中拥有广泛的应用。

许多数字信号处理器（DSP），FPGA和ASIC芯片都使用SRT除法器来实现除法运算。在数字系统中，SRT除法器可以用于实现IIR数字滤波器等高级算法。
Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : srt_div.v
// Editor : 0078
// Verdion: v1.0
// Description: srt divider
// -----------------------------------------------------------------------------
module srt_div(
    input     				clk 			,       //时钟信号
    input  					rstn 			,       //异步复位信号，复位时为低电平
    input  		[7:0]  		dividend 		,   	//被除数
    input 		[7:0] 		divisor 		,    	//除数
    output reg 	[7:0] 		quotient     			//商
);

reg [7:0] remainder;   //声明寄存器，记录余数
reg [7:0] A;           //声明寄存器，记录被除数
reg [7:0] S;           //声明寄存器，记录除数
reg shift;             //声明寄存器，记录是否左移
integer i ;
always @(posedge clk or negedge rstn) begin
    if (~rstn) begin    //异步复位
        quotient <= 8'b0;
        remainder <= 8'b0;
        A <= dividend;
        S <= divisor;
        shift <= 1'b0;
    end else begin

        // 初始化操作
        if (remainder == 0) begin
            quotient <= 8'b0;
            A <= dividend;
            S <= divisor;
            shift <= 1'b0;
        end else begin
            // 余数不为0,继续之前的操作
            if (A[7] == 1) begin    // 判断被除数的符号位是否为1
                A <= {1'b0, A} - S;
                shift <= 1'b1;      // 若为1，则左移操作
            end else begin
                A <= {1'b0,A} + S;
                shift <= 1'b1;      // 若不为1，则右移操作
            end
        end
        
        // 循环除操作
        for (i=0; i<8; i=i+1) begin
            if (A[7] == 1) begin
                quotient[i] <= 1'b0; // 商的位为0
            end else begin
                quotient[i] <= 1'b1; // 商的位为1
                A <= {1'b0,A} + S;
            end
            // 循环左移或右移操作
            if (shift == 1'b1) begin
                A <= {1'b0,A} << 1;
            end else begin
                A <= {A[6:0],1'b0};
            end
        end

        // 获取余数
        remainder <= A;
    end
end

endmodule

Quartus RTL图
结构规整

Quartus Post mapping图

查找表除法器

查找表除法器是一种数字电路，其可以计算两个二进制数的商并输出结果。其工作原理在于将除数不断左移，并比较被除数与除数大小关系，以此来得出商的每一位。查找表除法器的优势在于可以通过预先生成查找表来加快计算速度，减少逻辑门电路的数量。

在数字电路中，查找表除法器广泛应用于硬件实现的数字信号处理器、图像处理器等领域。由于其快速计算商的能力，查找表除法器被广泛用于高速数据处理和嵌入式系统中。除此之外，查找表除法器在图形处理器、计算机视觉、经济学和金融领域中也有着广泛应用。

Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : lut_div.v
// Create : 2023-03-22 16:01:02
// Revise : 2023-03-22 16:01:02
// Editor : 0078
// Verdion: v1.0
// Description: 
// -----------------------------------------------------------------------------
module lut_div (
  input [7:0] dividend,  // 被除数
  input [7:0] divisor,   // 除数
  output reg [7:0] quotient // 商
);

  reg [7:0] remainder   ;   // 余数
  reg [7:0] lut [7:0]   ; // 储存查找表的数组

  initial begin
    // 生成查找表
    lut[0] = 0;
    lut[1] = 128;
    lut[2] = 64;
    lut[3] = 42;
    lut[4] = 32;
    lut[5] = 25;
    lut[6] = 21;
    lut[7] = 18;
  end
integer i ;
  always @(*) begin
    remainder = dividend; // 初始化余数
    quotient = 0;         // 初始化商

    for ( i = 7; i >= 0; i = i - 1) begin
      // 左移一位，将余数溢出到商中
      remainder = remainder << 1;
      quotient = quotient << 1;
      remainder[0] = 0;   //清除最低位

      // 使用查找表查找余数和除数的差，如果大于等于零则更新余数和商
      if (remainder >= divisor) begin
        remainder = remainder - divisor;
        quotient[i] = 1;
      end
    end
  end

endmodule

Quartus RTL图

Quartus Post mapping图

Radix-2除法器

Radix-2除法器是一种广泛应用于数字电路中的除法器，它的主要特点是利用二进制的性质来实现高效的除法运算。其工作原理基于二进制的长除法算法，通过将被除数和除数都表示成二进制数，并借助于诸如加法器、移位器等基本电路来实现逐位相除，从而得到商和余数。

在数字电路中，Radix-2除法器被广泛应用于各种需要进行高速除法运算的场合。例如，在计算机处理器、数字信号处理器、通信系统等领域都有广泛的应用。在这些应用中，Radix-2除法器通常作为关键的模块出现，以实现高效、快速的除法运算，从而提高整个系统的性能和效率。
Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : radix2_div.v
// Create : 2023-03-22 16:18:45
// Revise : 2023-03-22 16:18:45
// Editor : 0078
// Verdion: v1.0
// Description:  radix-2 divider
// -----------------------------------------------------------------------------
module radix2_div(
    input 			[7:0]  		dividend 	,  		// 被除数，8位无符号
    input 			[7:0]  		divisor 	,   	// 除数，8位无符号
    input						clk 	 	,	 	//时钟信号
    input                       rst_n       ,       //复位信号
    output wire 		[7:0] 	quotient 	,  		// 商，8位无符号
    output wire 		[7:0] 	remainder  			// 余数，8位无符号
);

reg [7:0] remainder_reg; // 当前余数
reg [7:0] divisor_reg;   // 当前除数
reg [7:0] quotient_reg;  // 当前商
reg [3:0] i;             // 循环计数器




// Radix-2除法算法
// 使用了4次迭代来计算出8位商和余数
always@(posedge  clk or negedge rst_n) begin
    if (!rst_n ) begin// 初始化
            remainder_reg <= dividend;
            divisor_reg <= divisor;
            quotient_reg <= 0;
    end
    else begin
    // 第1次迭代
        if(remainder_reg >= {divisor_reg,4'b0}) begin
            remainder_reg <= remainder_reg - {divisor_reg,4'b0};
            quotient_reg[7] <= 1;
        end
        else begin
            quotient_reg[7] <= 0;
        end
        
        // 第2次迭代
        if(remainder_reg >= {divisor_reg,3'b0,1'b0}) begin
            remainder_reg <= remainder_reg - {divisor_reg,3'b0,1'b0};
            quotient_reg[6] <= 1;
        end
        else begin
            quotient_reg[6] <= 0;
        end
        
        // 第3次迭代
        if(remainder_reg >= {divisor_reg,2'b0,2'b0}) begin
            remainder_reg <= remainder_reg - {divisor_reg,2'b0,2'b0};
            quotient_reg[5] <= 1;
        end
        else begin
            quotient_reg[5] <= 0;
        end
        
        // 第4次迭代
        if(remainder_reg >= {divisor_reg,1'b0,3'b0}) begin
            remainder_reg <= remainder_reg - {divisor_reg,1'b0,3'b0};
            quotient_reg[4] <= 1;
        end
        else begin
            quotient_reg[4] <= 0;
        end
        
        // 将当前商和余数传递到下一个时钟周期
        for(i=0;i<4;i=i+1) begin
            quotient_reg[i] <= quotient_reg[i+4];
        end
    end
end

// 将计算出的商和余数通过输出端口输出
assign quotient = quotient_reg;
assign remainder = remainder_reg;
    
endmodule

Quartus RTL图

Quartus Post mapping图

阵列除法器

阵列除法器是一种常见的数字电路，用于在数字系统中执行除法运算。工作原理基于二进制位操作和移位运算，该电路将被除数和除数作为输入，并且通过一个连乘和减法的序列，不断地将结果左移或右移以进行精度控制，最终输出商和余数。

在数字电路中，阵列除法器广泛应用于处理器中的乘除指令，实现高速的运算。除此之外，阵列除法器还可被用于编码器，电子秤，数字滤波等电路中，以实现精准的控制和计算。其高效、稳定和可靠。

Verilog代码：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : array_div.v
// Create : 2023-03-22 16:52:24
// Revise : 2023-03-22 16:54:34
// Editor : 0078
// Verdion: v1.0
// Description: 
// -----------------------------------------------------------------------------

//x= 0.x1x2x3x4x5x6
//y=0.y1y2y3
//q=0.q1q2q3
//r=0.00r3r4r5r6
module array_div (
    input         x1    ,
    input         x2    ,
    input         x3    ,
    input         x4    ,
    input         x5    ,
    input         x6    ,
    //-------------------

    input         y1    ,
    input         y2    ,
    input         y3    ,
    //-------------------

    output wire   q1    ,
    output wire   q2    ,
    output wire   q3    ,

    //------------------
    output wire   r3    ,
    output wire   r4    ,
    output wire   r5    ,
    output wire   r6    

);

 //
 wire p11   ;
 wire c11   ;

 wire p12   ;
 wire c12   ;

 wire p13   ;
 wire c13   ;

 wire p14   ;


//
 wire p21   ;
 wire c21   ;

 wire p22   ;
 wire c22   ;

 wire p23   ;
 wire c23   ;

 wire p24   ;
//
 wire p31   ;
 wire c31   ;

 wire p32   ;
 wire c32   ;

 wire p33   ;
 wire c33   ;

 wire p34   ;
//
 wire p41   ;
 wire c41   ;

 wire p42   ;
 wire c42   ;

 wire p43   ;
 wire c43   ;

 wire p44   ;

 //
 wire s11 ;
 wire s12 ;
 wire s13 ;
 wire s14 ;
 //
 wire s21 ;
 wire s22 ;
 wire s23 ;
 wire s24 ;
  //
 wire s31 ;
 wire s32 ;
 wire s33 ;
 wire s34 ;
 //
 wire s41 ;
 wire s42 ;
 wire s43 ;
 wire s44 ;
//
 wire b11 ;
 wire b12 ;
 wire b13 ;
 wire b14 ;
 //
 wire b21 ;
 wire b22 ;
 wire b23 ;
 wire b24 ;
  //
 wire b31 ;
 wire b32 ;
 wire b33 ;
 wire b34 ;
 //
 wire b41 ;
 wire b42 ;
 wire b43 ;
 wire b44 ;
 //
 wire c1;
 wire c2;
 wire c3;

 //inst
  cas inst_cas_11 (
    .Ai           (1'b0     ), 
    .Bi           (1'b0     ), 
    .Ci           (c11      ), 
    .pin          (1'b0     ), 
    .pout         (p11      ), 
    .Bo           (b11      ), 
    .So           (         ), 
    .Cii          (c1       )
    );

  cas inst_cas_12 (
    .Ai           (x1     ), 
    .Bi           (y1     ), 
    .Ci           (c12    ), 
    .pin          (p11    ), 
    .pout         (p12    ), 
    .Bo           (b12    ), 
    .So           (s12    ), 
    .Cii          (c11    )
    );

  cas inst_cas_13 (
    .Ai           (x2       ), 
    .Bi           (y2       ), 
    .Ci           (c13      ), 
    .pin          (p12      ), 
    .pout         (p13      ), 
    .Bo           (b13      ), 
    .So           (s13      ), 
    .Cii          (c12      )
    );



    cas inst_cas_14 (
    .Ai           (x3       ), 
    .Bi           (y3       ), 
    .Ci           (p14      ), 
    .pin          (p13      ), 
    .pout         (p14      ), 
    .Bo           (b14      ), 
    .So           (s14      ), 
    .Cii          (c13      )
    );


//
    cas inst_cas_21 (
    .Ai           (s12    ), 
    .Bi           (b11    ), 
    .Ci           (c21    ), 
    .pin          (c1     ), 
    .pout         (p21    ), 
    .Bo           (b21    ), 
    .So           (s21    ), 
    .Cii          (c2     )
    );

  cas inst_cas_22 (
    .Ai           (s13     ), 
    .Bi           (b12     ), 
    .Ci           (c22     ), 
    .pin          (p21     ), 
    .pout         (p22     ), 
    .Bo           (b22     ), 
    .So           (s22     ), 
    .Cii          (c21     )
    );

  cas inst_cas_23 (
    .Ai           (s14     ), 
    .Bi           (b13     ), 
    .Ci           (c23     ), 
    .pin          (p22     ), 
    .pout         (p23     ), 
    .Bo           (b23     ), 
    .So           (s23     ), 
    .Cii          (c22     )
    );

  cas inst_cas_24 (
    .Ai           (x4     ), 
    .Bi           (b14    ), 
    .Ci           (p24    ), 
    .pin          (p23    ), 
    .pout         (p24    ), 
    .Bo           (b24    ), 
    .So           (s24    ), 
    .Cii          (c23    )
    );

//
  cas inst_cas_31 (
    .Ai           (s22    ), 
    .Bi           (b21    ), 
    .Ci           (c31    ), 
    .pin          (c2     ), 
    .pout         (p31    ), 
    .Bo           (b31    ), 
    .So           (s31    ), 
    .Cii          (c3     )
    );

  cas inst_cas_32 (
    .Ai           (s23    ), 
    .Bi           (b22    ), 
    .Ci           (c32    ), 
    .pin          (p31    ), 
    .pout         (p32    ), 
    .Bo           (b32    ), 
    .So           (s32    ), 
    .Cii          (c31    )
    );


  cas inst_cas_33 (
    .Ai           (s24      ), 
    .Bi           (b23      ), 
    .Ci           (c33      ), 
    .pin          (p32      ), 
    .pout         (p33      ), 
    .Bo           (b33      ), 
    .So           (s33      ), 
    .Cii          (c32      )
    );

  cas inst_cas_34 (
    .Ai           (x5       ), 
    .Bi           (b24      ), 
    .Ci           (p34      ), 
    .pin          (p33      ), 
    .pout         (p34      ), 
    .Bo           (b34      ), 
    .So           (s34      ), 
    .Cii          (c33      )
    );


  //

  cas inst_cas_41 (
    .Ai           (s32    ), 
    .Bi           (b31    ), 
    .Ci           (c41    ), 
    .pin          (c3     ), 
    .pout         (p41    ), 
    .Bo           (       ), 
    .So           (r3     ), 
    .Cii          (q3     )
    );

  cas inst_cas_42 (
    .Ai           (s33    ), 
    .Bi           (b32    ), 
    .Ci           (c42    ), 
    .pin          (p41    ), 
    .pout         (p42    ), 
    .Bo           (       ), 
    .So           (r4     ), 
    .Cii          (c41    )
    );


  cas inst_cas_43 (
    .Ai           (s34    ), 
    .Bi           (b33    ), 
    .Ci           (c43    ), 
    .pin          (p42    ), 
    .pout         (p43    ), 
    .Bo           (       ), 
    .So           (r5     ), 
    .Cii          (c42    )
    );

  cas inst_cas_44 (
    .Ai           (x6     ), 
    .Bi           (b34    ), 
    .Ci           (p44    ), 
    .pin          (p43    ), 
    .pout         (p44    ), 
    .Bo           (       ), 
    .So           (r6     ), 
    .Cii          (c43    )
    );

assign  q1 = c2 ;
assign  q2 = c3 ;
endmodule

其中CAS为可控加法/减法单元，代码如下：

// -----------------------------------------------------------------------------
// Copyright (c) 2014-2023 All rights reserved
// -----------------------------------------------------------------------------
// Author : HFUT90S  1320343336@qq.com
// File   : cas.v
// Create : 2023-03-22 19:32:35
// Revise : 2023-03-22 19:32:35
// Editor : 0078
// Verdion: v1.0
// Description: 
// -----------------------------------------------------------------------------
module cas (
	input 			Ai 			,   // 
	input 			Bi 			,   // 
	input 			Ci 			,   // 
	input 			pin 		, 	// 
	output 	wire	pout 		,	// 
	output 	wire	Bo 			,	// 
	output 	wire	So 			,	// 
	output 	wire	Cii  			// 
);

//Pin = 0 add
//Pin = 1 sub

assign Cii = ((Ai|Ci) & (Bi^pin))|Ai&Ci ;	
assign So  =  Ai ^ (Bi ^ pin) ^ Ci    	;




assign pout = pin  	;
assign Bo 	= Bi 	;

endmodule 

Quartus RTL图

Quartus Post mapping图

总结

数字电路中的除法器主要用于对两个数进行除法运算，是数字电路中的一种重要的算术部件。硬件除法器通常是使用门电路和触发器等基本元件组合设计而成，可以实现基于二进制数值系统的除法运算。通常分为两类：整除法器和带余数除法器。其中整除法器输出商的整数部分，而带余数除法器可以输出商的整数部分和余数部分。

在数字电路中，硬件除法器可以广泛应用于各种数字信号处理系统，例如数字滤波器、图像处理、通讯系统、计算机等。此外，对于某些需要高精度计算的应用场合，硬件除法器也是不可或缺的。在现代数字电路设计中，硬件除法器的性能和精度已经得到了很大的提高，同时也已经广泛应用于各种数字信号处理系统中，为数字信号处理技术的发展做出了重要的贡献。

文章来源地址https://www.toymoban.com/news/detail-431466.html

到了这里，关于数字IC经典电路（3）——经典除法器的实现（除法器简介及Verilog实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！