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
# (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
#(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
#( 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
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 divisiones | Acumulación de diferencia | Modificación de diferencia | Período de división |
|---|---|---|---|
| 1 | 6 | 6 | 7 |
| 2 | 6+6=12 | 2 | 8 |
| 3 | 2+6=8 | 8 | 7 |
| 4 | 8+6=14 | 4 | 8 |
| 5 | 4+6=10 | 0 | 8 |
| 6 | 6 | 6 | 7 |
| 7 | 6+6=12 | 2 | 8 |
| 8 | 2+6=8 | 8 | 7 |
| 9 | 8+6=14 | 4 | 8 |
| 10 | 4+6=10 | 0 | 8 |
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
#(
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.
: 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