Palabras clave: división de frecuencia par, división de frecuencia impar, división de frecuencia semi-entera, división de frecuencia fraccionaria

Al aprender Verilog, muchos módulos están compuestos por contadores y divisores de frecuencia, como la modulación por ancho de pulso PWM, el medidor de frecuencia, etc. La lógica de división de frecuencia suele implementarse mediante lógica de conteo. Esta sección resume brevemente la división de frecuencia par, impar, semi-entera y fraccionaria.

División de frecuencia par

Conectando la salida inversa de un flip-flop a su entrada, se puede construir un simple circuito divisor por 2.

Basándose en esto y conectando en cascada, se pueden construir circuitos divisores por 4 y por 8.

La implementación del circuito se muestra en la siguiente figura; al describirlo en Verilog, basta con utilizar una lógica de inversión simple.

Si el coeficiente de división par es demasiado grande, es necesario realizar un conteo cíclico del coeficiente de división N. Cuando el ciclo de conteo alcanza el valor intermedio N/2 del coeficiente de división, se invierte el reloj, lo que garantiza un ciclo de trabajo del 50% en el reloj dividido. Al ser una división par, también se puede contar cíclicamente hasta N/2.

A continuación se muestra un ejemplo de descripción Verilog para la división de frecuencia par.

Ejemplo

module even_divisor
  # (parameter DIV_CLK = 10 )
    (
    input               rstn ,
    input               clk,
    output              clk_div2,
    output              clk_div4,
    output              clk_div10
    );

   // división por 2
   reg                  clk_div2_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         clk_div2_r     <= 'b0 ;
      end
      else begin
         clk_div2_r     <= ~clk_div2_r ;
      end
   end
   assign       clk_div2 = clk_div2_r ;

   // división por 4
   reg                  clk_div4_r ;
   always @(posedge clk_div2 or negedge rstn) begin
      if (!rstn) begin
         clk_div4_r     <= 'b0 ;
      end
      else begin
         clk_div4_r     <= ~clk_div4_r ;
      end
   end
   assign clk_div4      = clk_div4_r ;

   // conteo N/2
   reg [3:0]            cnt ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt    <= 'b0 ;
      end
      else if (cnt == (DIV_CLK/2)-1) begin
         cnt    <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   // reloj de salida
   reg                  clk_div10_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         clk_div10_r <= 1'b0 ;
      end
      else if (cnt == (DIV_CLK/2)-1 ) begin
         clk_div10_r <= ~clk_div10_r ;
      end
   end
   assign clk_div10 = clk_div10_r ;
endmodule

En el testbench solo es necesario proporcionar señales como el reloj de excitación; no se enumeran aquí.

Los resultados de la simulación son los siguientes.

División de frecuencia impar

Si la división de frecuencia impar no requiere un ciclo de trabajo del 50%, se puede realizar de manera similar a la división par. Es decir, el contador cuenta cíclicamente el coeficiente de división N y, según el valor de conteo, se elige un cierto ciclo de trabajo para generar el reloj dividido.

Si la diferencia entre los niveles alto y bajo del reloj de salida de una división impar es de solo un ciclo, se puede aprovechar la característica de doble flanco del reloj fuente y utilizar operaciones "AND" u "OR" para ajustar el ciclo de trabajo del reloj dividido al 50%.

Ajuste del ciclo de trabajo mediante operación OR

El siguiente diagrama de tiempos muestra una división por 3 con un ciclo de trabajo del 50% mediante una operación OR.

Utilizando el flanco ascendente del reloj fuente, se genera un reloj dividido por 3 con nivel alto de 1 ciclo y nivel bajo de 2 ciclos.

Utilizando el flanco descendente del reloj fuente, se genera un reloj dividido por 3 con nivel alto de 1 ciclo y nivel bajo de 2 ciclos.

Los dos relojes divididos por 3 deben generarse con el mismo valor del contador pero en flancos diferentes, con una diferencia de fase de medio ciclo de reloj. Luego, al aplicar la operación OR a los dos relojes, se obtiene un reloj dividido por 3 con un ciclo de trabajo del 50%.

De manera similar, para una división por 9, es necesario generar en el flanco ascendente y descendente relojes divididos por 9 con 4 ciclos en alto y 5 en bajo, y luego aplicar la operación OR a los dos relojes. La descripción Verilog es la siguiente.

Ejemplo

module odo_div_or
  #(parameter DIV_CLK = 9)
   (
    input               rstn ,
    input               clk,
    output              clk_div9
    );

   // contador
   reg [3:0]            cnt ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt    <= 'b0 ;
      end
      else if (cnt == DIV_CLK-1) begin
         cnt    <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   // generar división por 9 en el flanco ascendente
   reg                  clkp_div9_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         clkp_div9_r <= 1'b0 ;
      end
      else if (cnt == (DIV_CLK>>1)-1 ) begin // conteo 4-8 en nivel bajo
        clkp_div9_r <= 0 ;
      end
      else if (cnt == DIV_CLK-1) begin // contar 0-3 es nivel alto
        clkp_div9_r <= 1 ;
      end
   end
 
   // generar división por 9 en el flanco descendente
   reg                  clkn_div9_r ;
   always @(negedge clk or negedge rstn) begin
      if (!rstn) begin
         clkn_div9_r <= 1'b0 ;
      end
      else if (cnt == (DIV_CLK>>1)-1 ) begin
        clkn_div9_r <= 0 ;
      end
      else if (cnt == DIV_CLK-1) begin
        clkn_div9_r <= 1 ;
      end
   end

   // operación OR, normalmente se usa la biblioteca de celdas lógicas básicas
   // or (clk_div9, clkp_div9_r, clkn_div9_r) ;
   assign clk_div9 = clkp_div9_r | clkn_div9_r ;

endmodule

Los resultados de la simulación son los siguientes.

Ajuste del ciclo de trabajo mediante operación AND

El siguiente diagrama de tiempos muestra una división por 3 con un ciclo de trabajo del 50% mediante una operación AND.

Utilizando el flanco ascendente del reloj fuente, se genera un reloj dividido por 3 con nivel alto de 2 ciclos y nivel bajo de 1 ciclo.

Utilizando el flanco descendente del reloj fuente, se genera un reloj dividido por 3 con nivel alto de 2 ciclos y nivel bajo de 1 ciclo.

Los dos relojes divididos por 3 deben generarse con el mismo valor del contador pero en flancos diferentes, con una diferencia de fase de medio ciclo de reloj. Luego, al aplicar la operación AND a los dos relojes, se obtiene un reloj dividido por 3 con un ciclo de trabajo del 50%.

De manera similar, para una división por 9, es necesario generar en el flanco ascendente y descendente relojes divididos por 9 con 5 ciclos en alto y 4 en bajo, y luego aplicar la operación AND a los dos relojes. La descripción Verilog es la siguiente.

Ejemplo

module odo_div_and
   #( parameter DIV_CLK = 9 )
   (
    input               rstn ,
    input               clk,
    output              clk_div9
    );

   // contador
   reg [3:0]            cnt ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt    <= 'b0 ;
      end
      else if (cnt == DIV_CLK-1) begin
         cnt    <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   // generar división por 9 en el flanco ascendente
   reg                  clkp_div9_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         clkp_div9_r <= 1'b0 ;
      end
      else if (cnt == (DIV_CLK>>1) ) begin // conteo 5-8 en nivel bajo
        clkp_div9_r <= 0 ;
      end
      else if (cnt == DIV_CLK-1) begin // contar 0-4 es nivel alto
        clkp_div9_r <= 1 ;
      end
   end

   // generar división por 9 en el flanco descendente
   reg                  clkn_div9_r ;
   always @(negedge clk or negedge rstn) begin
      if (!rstn) begin
         clkn_div9_r <= 1'b0 ;
      end
      else if (cnt == (DIV_CLK>>1) ) begin
        clkn_div9_r <= 0 ;
      end
      else if (cnt == DIV_CLK-1) begin
        clkn_div9_r <= 1 ;
      end
   end

   // operación AND, normalmente se usa la biblioteca de celdas lógicas básicas
   //and (clk_div9, clkp_div9_r, clkn_div9_r) ;
   assign clk_div9 = clkp_div9_r & clkn_div9_r ;

endmodule

Los resultados de la simulación son los siguientes.

División de frecuencia semi-entera

Utilizando la lógica de doble flanco del reloj, se puede realizar una división de frecuencia semi-entera. Sin embargo, sin importar cómo se ajuste, el ciclo de trabajo de la división semi-entera no puede ser del 50%. Existen muchos métodos para la división semi-entera; aquí solo se presenta uno similar al ajuste del ciclo de trabajo en la división impar.

  • (1) Por ejemplo, al realizar una división por 3.5, el contador cuenta cíclicamente hasta 7, generando dos relojes divididos compuestos por 4 y 3 ciclos del reloj fuente respectivamente. Desde la perspectiva de que a partir de 7 ciclos del reloj fuente se generan 2 relojes divididos, el proceso logra una división por 3.5, pero cada reloj dividido no es estrictamente una división por 3.5.
  • (2) A continuación, se ajustan los relojes divididos de período no uniforme. En un ciclo de conteo, se generan en el flanco descendente del reloj fuente dos relojes divididos compuestos por 4 y 3 ciclos del reloj fuente respectivamente. En comparación con los dos relojes de período no uniforme generados la primera vez, uno de los dos relojes generados ahora tiene un retraso de medio ciclo del reloj fuente, y el otro se adelanta medio ciclo del reloj fuente.
  • (3) Al aplicar la operación OR a los relojes generados en las dos ocasiones, se obtiene un reloj dividido por 3.5 con período uniforme. El diagrama de formas de onda de la división se muestra a continuación.

La descripción Verilog para la división de reloj por 3.5 es la siguiente.

Ejemplo

module half_divisor(
    input               rstn ,
    input               clk,
    output              clk_div3p5
    );

   // contador
   parameter            MUL2_DIV_CLK = 7 ;
   reg [3:0]            cnt ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt    <= 'b0 ;
      end
      else if (cnt == MUL2_DIV_CLK-1) begin // conteo del doble de la relación de división
         cnt    <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   reg                  clk_ave_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         clk_ave_r <= 1'b0 ;
      end
      //first cycle: 4 source clk cycle
      else if (cnt == 0) begin
         clk_ave_r <= 1 ;
      end
      //2nd cycle: 3 source clk cycle
      else if (cnt == (MUL2_DIV_CLK/2)+1) begin
         clk_ave_r <= 1 ;
      end
      else begin
         clk_ave_r <= 0 ;
      end
   end

   //adjust
   reg                  clk_adjust_r ;
   always @(negedge clk or negedge rstn) begin
      if (!rstn) begin
         clk_adjust_r <= 1'b0 ;
      end
      // este reloj solo sirve para ajustar un ciclo de trabajo consistente
      else if (cnt == 1) begin
         clk_adjust_r <= 1 ;
      end
      // este reloj solo sirve para ajustar la relación de división precisa consistente
      else if (cnt == (MUL2_DIV_CLK/2)+1 ) begin
         clk_adjust_r <= 1 ;
      end
      else begin
         clk_adjust_r <= 0 ;
      end
   end

   assign clk_div3p5 = clk_adjust_r | clk_ave_r ;

endmodule

Los resultados de la simulación son los siguientes.

División de frecuencia fraccionaria

Principios básicos

Una división fraccionaria irregular no puede lograr que cada período del reloj dividido sea un múltiplo fraccionario del período del reloj fuente, y mucho menos que el ciclo de trabajo del reloj dividido sea del 50%, porque Verilog no puede contar fracciones de reloj. Similar al concepto de "frecuencia promedio" introducido en la primera división de la división semi-entera, la división fraccionaria también se implementa basándose en división variable y promediado múltiple.

Por ejemplo, para una división por 7.6, basta con asegurar que el tiempo de 76 ciclos del reloj fuente sea igual al tiempo de 10 ciclos del reloj dividido. En este caso, dentro de 76 ciclos del reloj fuente se deben realizar 6 divisiones por 8 y 4 divisiones por 7. Otro ejemplo: para una división por 5.76, se necesitan 76 divisiones por 6 y 24 divisiones por 5 dentro de 576 ciclos del reloj fuente.

A continuación se explica el proceso de cálculo de estos parámetros de división.

Cuando se realiza una división por 7, puede entenderse como 10 divisiones por 7 dentro de 70 ciclos del reloj fuente. Si dentro de 76 ciclos del reloj fuente todavía se realizan 10 divisiones, equivale a agregar y distribuir los 6 ciclos extra del reloj fuente en los 70 ciclos, completando así la división por 7.6. Durante el proceso, inevitablemente 6 de los relojes divididos se obtienen mediante división por 8, mientras que los 4 restantes mantienen la división original por 7.

En muchos lugares se proporcionan sistemas de ecuaciones lineales con dos incógnitas para calcular estos parámetros de división, como se muestra a continuación. Su principio es consistente con el análisis anterior; se recomienda dominar el proceso de cálculo mencionado.

7N + 8M = 76
N  + M   = 10 

Donde 7 es la división entera y N es el número de veces de la división entera; 8 y M son el coeficiente de división después de sumar uno a la división entera y su número de veces.

Principio de promediado

Tomando la división por 7.6 como ejemplo, generalmente existen los siguientes 4 órdenes de implementación para las divisiones por 7 y por 8:

  • (1) Primero realizar 4 divisiones por 7, y luego 6 divisiones por 8;
  • (2) Primero realizar 6 divisiones por 8, y luego 4 divisiones por 7;
  • (3) Insertar uniformemente las 4 divisiones por 7 entre las 6 divisiones por 8;
  • (4) Insertar uniformemente las 6 divisiones por 8 entre las 4 divisiones por 7.

En los dos primeros métodos, la frecuencia del reloj no es uniforme y la fluctuación de fase es mayor, por lo que generalmente se utilizan los dos últimos métodos de inserción uniforme para la división fraccionaria.

La inserción uniforme se puede implementar mediante el método de acumulación de diferencias en el número de divisiones. El proceso de implementación de la división por 7.6 es el siguiente:

  • (1) La primera diferencia en el número de divisiones es 76-10*7 = 6 < 10, por lo que la primera división es por 7.
  • (2) La segunda acumulación de la diferencia es 6+6=12 > 10, por lo que la segunda división usa 8, y la diferencia se modifica a 12-10=2.
  • (3) La tercera acumulación de la diferencia es 2+6=8 < 10, por lo que la tercera división usa 7.
  • (4) La cuarta acumulación de la diferencia es 8+6=14 > 10, la cuarta división usa 8, y la diferencia se modifica a 14-10=4.

De manera similar, se completa el proceso de insertar uniformemente 6 divisiones por 8 en 4 divisiones por 7.

La siguiente tabla muestra el proceso de división de frecuencia del método de inserción promedio.

Cantidad de divisionesAcumulación de diferenciaModificación de diferenciaPeríodo de división
1667
26+6=1228
32+6=887
48+6=1448
54+6=1008
6667
76+6=1228
82+6=887
98+6=1448
104+6=1008

Simulación de diseño

La descripción en Verilog basada en el método de implementación de división de frecuencia fraccionaria mencionado anteriormente es la siguiente.

Ejemplo

module frac_divisor
  #(
   parameter            SOURCE_NUM = 76 , //cycles in source clock
   parameter            DEST_NUM   = 10  //cycles in destination clock
   )
   (
    input               rstn ,
    input               clk,
    output              clk_frac
    );
 
   //Parámetro de división por 7, parámetro de división por 8, diferencia de conteo
   parameter    SOURCE_DIV = SOURCE_NUM/DEST_NUM ;
   parameter    DEST_DIV   = SOURCE_DIV + 1;
   parameter    DIFF_ACC   = SOURCE_NUM - SOURCE_DIV*DEST_NUM ;


   reg [3:0]            cnt_end_r ;  //Período de división variable
   reg [3:0]            main_cnt ;   //Contador principal
   reg                  clk_frac_r ; //Salida de reloj, el número de ciclos de nivel alto es 1
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         main_cnt    <= 'b0 ;
         clk_frac_r  <= 1'b0 ;
      end
      else if (main_cnt == cnt_end_r) begin
         main_cnt    <= 'b0 ;
         clk_frac_r  <= 1'b1 ;
      end
      else begin
         main_cnt    <= main_cnt + 1'b1 ;
         clk_frac_r  <= 1'b0 ;
      end
   end
   //Reloj de salida
   assign       clk_frac        = clk_frac_r ;
   //Control de habilitación del acumulador de diferencia
   wire         diff_cnt_en     = main_cnt == cnt_end_r ;

   //Lógica del acumulador de diferencia
   reg [4:0]            diff_cnt_r ;
   wire [4:0]           diff_cnt = diff_cnt_r >= DEST_NUM ?
                                   diff_cnt_r -10 + DIFF_ACC :
                                   diff_cnt_r + DIFF_ACC ;                                
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         diff_cnt_r <= 0 ;
      end
      else if (diff_cnt_en) begin
         diff_cnt_r <= diff_cnt ;
      end
   end

   //Lógica de control de la variable de período de división
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt_end_r      <= SOURCE_DIV-1 ;
      end
      //Cuando el acumulador de diferencia se desborda, modificar el período de división
      else if (diff_cnt >= 10) begin
         cnt_end_r      <= DEST_DIV-1 ;
      end
      else begin
         cnt_end_r      <= SOURCE_DIV-1 ;
      end
   end

endmodule

Los resultados de la simulación son los siguientes.

Resumen de la división de frecuencia

La división por números pares no utiliza lógica de doble flanco del reloj y puede completar una división de reloj con un ciclo de trabajo del 50%; es la situación de división más ideal.

Si la división por números impares necesita generar un reloj dividido con un ciclo de trabajo del 50%, se debe utilizar la lógica de doble flanco del reloj. Si no se requiere un ciclo de trabajo específico, el método de implementación es similar al de la división por números pares.

La división de frecuencia semientera es un tipo especial de división de frecuencia fraccionaria y puede diseñarse con lógica de doble flanco. Al integrar dos señales de reloj de doble flanco en una única señal de reloj de salida mediante cierta lógica, se recomienda no utilizar lógica de selección, ya que es propensa a producir glitches y añade cierta incertidumbre al circuito. Por ejemplo, la siguiente descripción no es recomendable.

assign clk_div3p5 = (cnt == 1 || cnt ==2) ? clk_ave_r
                                          : clk_adjust_r ;

La idea básica de la división de frecuencia fraccionaria es que la frecuencia promedio del reloj de salida durante un período de tiempo cumpla con el requisito de división. Pero considerando la fluctuación de fase, también es necesario realizar una operación de promedio sobre la lógica de división cuyo coeficiente de división cambia.

Descargar el código fuente de este capítulo

Download