FPGA clock divider

Se cree que el crossover FPGA es una técnica relativamente frecuente y relativamente básica en los FPGA. La siguiente es una explicación específica de la división de reloj del FPGA.

Concepto:

El reloj FPGA se divide en la frecuencia del reloj del sistema del FPGA según sus propias necesidades, de modo que alcance la frecuencia de 1 /N original. De acuerdo con el valor de N, por lo general se puede dividir en pares e impares.

División de frecuencia par:

División de frecuencia par, es decir, N es un número par para dividir el reloj del sistema. Este diseño es implementado principalmente por un contador. El principio de diseño es el siguiente: el reloj de referencia del sistema se utiliza como condición de activación para hacer un contador ascendente. Cuando el valor del contador es (n /2 - 1), el reloj de salida salta. Para implementar un programa de división por 4, haga lo siguiente:

module div_4 (clk, clr_n, clk_o);

input clk;

input clr_n;

Salida clk_o;

reg [1: 0] cnt_div;

reg clk_o_1;

siempre @ (posedge clk o negedge clr_n)

begin

if (! clr_n)

cnt_div < = 0;

else if (cnt_div == 2'b01)

cnt_div < = 0; < Br>

else

cnt_div < = cnt_div + 1;

end

always @ (posedge clk o negedge clr_n)

begin < Br>

if (! Clr_n)

clk_o_1 < = 0;

else if (cnt_div == 2'b01)

clk_o_1 < = ~ clk_o_1;

fin

asignar clk_o = clk_o_1;

endmodule

división de frecuencia impar:

el método de división de frecuencia múltiple impar es cuando N es El reloj del sistema se divide en momentos impares. El principio es: establezca dos contadores idénticos con el valor máximo de (n-1), uno de los cuales se activa por el flanco ascendente del reloj del sistema y el otro es la condición de disparo del flanco descendente del reloj del sistema; el reloj de salida está en el valor del contador (n) -1) /2 y (n-1) respectivamente, volteando para obtener dos relojes con una relación de trabajo diferente al 50%, y finalmente realizar la operación de fase-O en los dos relojes de salida para obtener una relación de trabajo del 50%. Reloj dividido impar. El código de referencia para implementar un reloj de división por 5 es el siguiente:

módulo div_5 (clk, clr_n, clk_o);

clk de entrada;

Ingrese clr_n;

salida clk_o;

reg [2: 0] cnt_div1;

reg [2: 0] cnt_div2;

reg clk_o_1; < Br>

reg clk_o_2;

always @ (posedge clk o negedge clr_n)

begin

if (! Clr_n)

cnt_div1 < = 0;

else if (cnt_div1 == 3'b100)

cnt_div1 < = 0;

else

cnt_div1 < = cnt_div1 + 1;

finaliza

siempre @ (cliqueo de posición o negriore)

comienza a

si (! Clr_n)

clk_o_1 < = 0;

else if (cnt_div 1 == 3'b010)

clk_o_1 < = ~ clk_o_1;

else if (cnt_div1 == 3'b100) < Br>

clk_o_1 < = ~ clk_o_1;

end

always @ (negedge clk o negedge clr_n)

begin

if (! Clr_n)

cnt_div2 < = 0;

else if (cnt_div2 == 3'b100)

cnt_div2 < = 0;

else < Br>

cnt_div2 < = cnt_div2 + 1;

end

always @ (posedge clk o negedge clr_n)

begin

if ( ! clr_n)

clk_o_2 < = 0;

else if (cnt_div2 == 3'b010)

clk_o_2 < = ~ clk_o_2;

else if (cnt_div2 == 3'b100)

clk_o_2 < = ~ clk_o_2;

end

asigna clk_o = clk_o_1 |  Clk_o_2;

endmodule

OK, ¡listo! También hay algunos cruces con decimales para continuar agregando más tarde