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.

Si le signal de sélection d'horloge sel_clk1 est asynchrone par rapport aux deux horloges, alors le moment de commutation d'horloge est arbitraire. Si l'horloge commute de clk1 à clk2, et que le moment de commutation est celui où le niveau de sortie de clk1 est haut, commuter l'horloge immédiatement à cet instant provoquera des glitches sur l'horloge de sortie. Le diagramme de forme d'onde est le suivant :

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

module clk_switch(
    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

`timescale 1ns/1ps
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