En raison de diverses contraintes de scénarios d'application, les puces doivent souvent basculer entre différentes sources d'horloge dans différentes applications pendant leur fonctionnement. Par exemple, les modes basse consommation et haute performance nécessitent respectivement des horloges basse fréquence et haute fréquence. Les deux sources d'horloge peuvent provenir de la même source et être synchrones, ou elles peuvent être indépendantes. L'utilisation directe d'une logique de sélection pour la commutation d'horloge est susceptible de provoquer des glitches dans le signal d'horloge divisé, de sorte que la logique de commutation d'horloge nécessite également un traitement spécial.
Problème de commutation d'horloge
Le schéma de circuit de l'utilisation directe d'une logique de sélection pour commuter les horloges est présenté ci-dessous.


Schéma de commutation d'horloge
La commutation d'horloges lorsque les deux niveaux sont opposés produira certainement des impulsions parasites ; lorsque les niveaux sont identiques, même si aucune impulsion parasite n'est produite, la période ou le rapport cyclique de la première horloge après commutation n'est pas idéal. Par conséquent, pour éviter les impulsions parasites, la commutation d'horloge doit être effectuée lorsque les deux horloges sont au niveau bas.
Un circuit typique de commutation d'horloge est présenté ci-dessous.
Ce circuit utilise le front descendant de l'horloge pour tamponner le signal de sélection d'horloge sel_clk1. Pendant ce temps, un signal de sélection d'horloge fournit une commande par rétroaction pour l'autre horloge, garantissant qu'une seule horloge est active à tout moment. Enfin, une opération OU combine les deux chemins d'horloge pour terminer le processus de commutation d'horloge.

Le chronogramme de l'utilisation du circuit ci-dessus pour réaliser la commutation d'horloge (clk1->clk2) est présenté ci-dessous.
Comme on peut le voir sur la figure, lors de la commutation de clk1 vers clk2, clk1 est d'abord désactivée, puis clk2 est activée. Étant donné que le signal de sélection d'horloge est synchronisé sur le front descendant de l'horloge, aucune impulsion parasite ne se produira pendant le processus de commutation.

Le chronogramme de la commutation de clk2 vers clk1 est présenté ci-dessous.

Considérant que le signal de sélection peut être un signal asynchrone, deux étages de bascules doivent être ajoutés avant la bascule tampon du signal de sélection d'horloge pour la synchronisation afin de réduire la propagation de la métastabilité. Le schéma de structure est le suivant. Ce circuit de commutation d'horloge est plus universel.

Conception de commutation d'horloge
Une description logique universelle et sûre de la commutation d'horloge est la suivante.
Exemple
input rstn ,
input clk1,
input clk2,
input sel_clk1 , // 1 clk1, 0 clk2
output clk_out
);
reg [2:0] sel_clk1_r ;
reg [1:0] sel_clk1_neg_r ;
reg [2:0] sel_clk2_r ;
reg [1:0] sel_clk2_neg_r ;
//Utiliser une mise en mémoire tampon de 3 cycles pour synchroniser l'opération ET entre l'autre signal de contrôle d'horloge et ce signal de contrôle d'horloge
always @(posedge clk1 or negedge rstn) begin
if (!rstn) begin
sel_clk1_r <= 3'b111 ; //Remarque : la valeur par défaut
end
else begin
//sélectionner clk1, et non clk2
sel_clk1_r <= {sel_clk1_r[1:0], sel_clk1 & (!sel_clk2_neg_r[1])} ;
end
end
//Sur le front descendant, utiliser une mise en mémoire tampon de 2 cycles pour le signal de sélection d'horloge
always @(negedge clk1 or negedge rstn) begin
if (!rstn) begin
sel_clk1_neg_r <= 2'b11 ; //Notez la valeur par défaut
end
else begin
sel_clk1_neg_r <= {sel_clk1_neg_r[0], sel_clk1_r[2]} ;
end
end
//Utiliser une mise en mémoire tampon de 3 cycles pour synchroniser l'opération ET entre l'autre signal de contrôle d'horloge et ce signal de contrôle d'horloge
always @(posedge clk2 or negedge rstn) begin
if (!rstn) begin
sel_clk2_r <= 3'b0 ; //Notez la valeur par défaut
end
else begin
//sélectionner clk2, et non sélectionner clk1
sel_clk2_r <= {sel_clk2_r[1:0], !sel_clk1 & (!sel_clk1_neg_r[1])} ;
end
end
//Sur le front descendant, utiliser une mise en mémoire tampon de 2 cycles pour le signal de sélection d'horloge
always @(negedge clk2 or negedge rstn) begin
if (!rstn) begin
sel_clk2_neg_r <= 2'b0 ; //Notez la valeur par défaut
end
else begin
sel_clk2_neg_r <= {sel_clk2_neg_r[0], sel_clk2_r[2]} ;
end
end
//Lors de la réalisation d'opérations logiques d'horloge, on utilise généralement une bibliothèque de cellules spécifique au procédé.
//Ici, les cellules de portes logiques intégrées de Verilog sont utilisées à la place.
wire clk1_gate, clk2_gate ;
and (clk1_gate, clk1, sel_clk1_neg_r[1]) ;
and (clk2_gate, clk2, sel_clk2_neg_r[1]) ;
or (clk_out, clk1_gate, clk2_gate) ;
endmodule
La description du banc de test est la suivante, générant principalement le signal de sélection pour les horloges asynchrones.
Exemple
module test ;
reg clk_100mhz, clk_200mhz ;
reg rstn ;
reg sel ;
wire clk_out ;
always #(2.5) clk_200mhz = ~clk_200mhz ;
always @(posedge clk_200mhz)
clk_100mhz = #1 ~clk_100mhz ;
initial begin
clk_100mhz = 0 ;
clk_200mhz = 0 ;
rstn = 0 ;
sel = 1 ;
#11 rstn = 1 ;
#36.2 sel = ~sel ;
#119.7 sel = ~sel ;
end
clk_switch u_clk_switch(
.rstn (rstn),
.clk1 (clk_100mhz),
.clk2 (clk_200mhz),
.sel_clk1 (sel),
.clk_out (clk_out));
initial begin
forever begin
#100;
if ($time >= 10000) $finish ;
end
end
endmodule
Les résultats de simulation sont les suivants. On peut voir qu'aucun glitch n'est généré lorsque les horloges commutent entre elles, mais qu'il y a un retard.

Téléchargement du code source pour ce chapitre
Téléchargement