Lorsque des signaux sont transmis d'un domaine d'horloge rapide vers un domaine d'horloge lent, un traitement de synchronisation doit être effectué en fonction des caractéristiques du signal. Pour les signaux d'un seul bit, ils peuvent généralement être distingués en signaux de niveau et signaux d'impulsion.

Synchronisation des signaux de niveau

Dans la conception de logique synchrone, un signal de niveau désigne un signal qui reste inchangé pendant longtemps. Le temps pendant lequel il reste inchangé est défini par rapport à l'horloge lente. Tant que le signal d'horloge rapide reste haut ou bas suffisamment longtemps pour être capturé par l'horloge lente tout en respectant les contraintes temporelles, le signal peut être considéré comme un signal de niveau.

Comme les signaux de niveau peuvent être capturés en toute sécurité, les signaux de niveau du domaine d'horloge rapide vers le domaine d'horloge lent sont également synchronisés à l'aide de la méthode du retard et de la mise en cascade de registres.

Synchronisation des signaux d'impulsion

Dans la conception de logique synchrone, un signal d'impulsion désigne un signal dont la largeur valide en sortie du domaine d'horloge rapide est inférieure à la période de l'horloge lente. Si le domaine d'horloge lent capture directement un tel signal d'impulsion étroit, celui-ci risque d'être manqué.

Si les largeurs d'impulsion de ces signaux d'impulsion sont toutes cohérentes, et que le rapport de fréquence des deux horloges est connu, la méthode de "l'élargissement de la largeur d'impulsion dans le domaine d'horloge rapide + retard et mise en cascade de registres dans le domaine d'horloge lent" peut être utilisée pour la synchronisation.

Si les signaux d'impulsion étroits présentent parfois aussi les caractéristiques de signaux de niveau, c'est-à-dire que parfois la largeur valide du signal est supérieure à la période de l'horloge lente et peut être capturée par l'horloge lente, alors effectuer un élargissement d'impulsion sur de tels signaux est manifestement peu économique. Dans ce cas, la synchronisation peut être réalisée par la méthode du "transfert par poignée de main".

En supposant que la période de niveau haut du signal d'impulsion soit la période de signal valide, le principe de base est le suivant.

  • (1) Le domaine d'horloge rapide détecte le signal d'impulsion et émet un signal de niveau haut pulse_fast_r lorsqu'un niveau haut est détecté. Alternativement, lorsque le domaine d'horloge rapide émet un signal de niveau haut, ne vous précipitez pas pour mettre le signal à l'état bas ; maintenez d'abord le signal de sortie à l'état haut.
  • (2) Le domaine d'horloge lent effectue un retard et un échantillonnage par étages de registres sur le signal pulse_fast_r provenant du domaine d'horloge rapide. Comme le signal d'impulsion est maintenu à l'état haut par le domaine d'horloge rapide à ce moment-là, le retard et l'échantillonnage par étages de registres captureront certainement le signal.
  • (3) Après que le domaine d'horloge lent a confirmé avoir échantillonné le signal de niveau haut pulse_fast2s_r, il le renvoie au domaine d'horloge rapide.
  • (4) Le domaine d'horloge rapide effectue un retard et un échantillonnage par étages de registres sur le signal de rétroaction pulse_fast2s_r. Si le signal de rétroaction est détecté comme étant à l'état haut, cela prouve que le domaine d'horloge lent a reçu un signal de niveau haut valide. Si la logique propre du domaine d'horloge rapide n'a plus besoin que le signal d'impulsion soit à l'état haut à ce moment-là, il suffit de mettre le signal d'impulsion du domaine d'horloge rapide à l'état bas.

L'essence de cette méthode est d'étendre la largeur d'impulsion des signaux d'impulsion étroits au moyen d'une poignée de main mutuelle.

Le modèle Verilog pour le traitement de synchronisation à l'aide de signaux de poignée de main est décrit comme suit.

Exemple

//Module de synchronisation avec une horloge de fonctionnement d'environ 25MHz
//Les données asynchrones proviennent d'un module avec une horloge de fonctionnement de 100MHz
module pulse_syn_fast2s
  #( parameter          PULSE_INIT = 1'b0
   )
  (
   input                rstn,
   input                clk_fast,
   input                pulse_fast,
   input                clk_slow,
   output               pulse_slow);

   wire                 clear_n ;
   reg                  pulse_fast_r ;
   /**************** horloge rapide ***************/
   //(1) Lorsque le domaine d'horloge rapide détecte un signal d'impulsion, il ne se précipite pas pour mettre le signal d'impulsion à l'état bas
   always@(posedge clk_fast or negedge rstn) begin
        if (!rstn)
           pulse_fast_r  <= PULSE_INIT ;
        else if (!clear_n)
           pulse_fast_r  <= 1'b0 ;
        else if (pulse_fast)
           pulse_fast_r  <= 1'b1 ;
   end

   reg  [1:0]           pulse_fast2s_r ;
   /************ horloge lente *************/
   //(2) Le domaine d'horloge lente effectue un retard et un échantillonnage par étages de registres sur le signal
   always@(posedge clk_slow or negedge rstn) begin
      if (!rstn)
        pulse_fast2s_r     <= 3'b0 ;
      else
        pulse_fast2s_r     <= {pulse_fast2s_r[0], pulse_fast_r} ;
   end
   assign pulse_slow = pulse_fast2s_r[1] ;

   reg [1:0]            pulse_slow2f_r ;
   /********* rétroaction de l'horloge lente vers l'horloge rapide *******/
   //(3) Effectuer un retard et un échantillonnage par étages de registres sur le signal de rétroaction
   always@(posedge clk_fast or negedge rstn) begin
      if (!rstn)
        pulse_slow2f_r  <= 1'b0 ;
      else
        pulse_slow2f_r  <= {pulse_slow2f_r[0], pulse_slow} ;
   end
   //Commander le signal d'impulsion du domaine d'horloge rapide pour qu'il soit mis à l'état bas
   assign clear_n = ~(!pulse_fast && pulse_slow2f_r[1]) ;


endmodule

Le banc de test est décrit comme suit.

Exemple

`timescale 1ns/1ps

module test ;
   reg          clk_100mhz, clk_25mhz ;
   reg          rstn ;

   initial begin
      clk_100mhz = 0 ;
      clk_25mhz  = 0 ;
      rstn = 0 ;
      #11 rstn = 1 ;
   end
   always #(10/2)   clk_100mhz  = ~clk_100mhz ;
   always #(45/2)   clk_25mhz   = ~clk_25mhz ;

   reg [7:0]            cnt ;
   reg                  pulse_sig ;
   always @(posedge clk_100mhz or negedge rstn) begin
      if (!rstn) begin
         cnt     <= 'b0 ;
      end
      else begin
         cnt    <= cnt + 1'b1 ;
      end
   end

   //Section de génération d'impulsions étroites
   always @(posedge clk_100mhz or negedge rstn) begin
      if (!rstn) begin
         pulse_sig      <= 1'b0 ;
      end
      else if (cnt == 5 ||
               cnt == 40 || cnt == 42 ||
               cnt >= 75 && cnt <= 81 || cnt == 85 || cnt == 87 )
      begin
         pulse_sig      <= 1'b1 ;
      end
      else begin
         pulse_sig      <= 1'b0 ;
      end
   end

   pulse_syn_fast2s u_fast2s_pulse(
      .rstn             (rstn),
      .clk_fast         (clk_100mhz),
      .pulse_fast       (pulse_sig),
      .clk_slow         (clk_25mhz),
      .pulse_slow       ());

   initial begin
      forever begin
         #100;
         if ($time >= 10000)  $finish ;
      end
   end

endmodule // test

Les résultats de simulation sont les suivants, à partir desquels on peut voir :

  • (1) Un seul signal d'impulsion étroite dans le domaine d'horloge rapide est capturé par le domaine d'horloge lente, mais le signal synchronisé présente un retard plus long et une largeur d'impulsion plus grande. Le retard du signal est causé par le retard et la mise en cascade de registres ainsi que par l'effacement par rétroaction, et il est inévitable. Le problème d'une largeur d'impulsion excessive peut être traité en effectuant une détection de front au moyen d'un retard et d'une mise en cascade de registres.
  • (2) La largeur d'impulsion du signal synchronisé de deux signaux d'impulsions étroites adjacents ne diffère pas de celle d'un signal unique d'impulsion étroite synchronisé. Autrement dit, le circuit de synchronisation rate la détection de la deuxième impulsion étroite. C'est aussi une caractéristique du transfert par poignée de main dans la gestion des problèmes de synchronisation. Lorsque le signal d'impulsion dans le domaine d'horloge rapide change trop rapidement, cette méthode ne peut pas distinguer des impulsions adjacentes.
  • (3) Lorsque plusieurs signaux d'impulsions larges et étroites sont proches les uns des autres, bien que cette méthode de synchronisation ne puisse pas distinguer plusieurs signaux d'impulsion, la largeur d'impulsion du signal synchronisé peut être relativement plus grande.

Synchronisation de données multi-bits

Lors de la synchronisation de données multi-bits, si chaque bit des données peut être considéré comme un signal de niveau, c'est-à-dire que chaque bit de données peut rester inchangé pendant une période relativement longue afin de pouvoir être capturé par l'horloge lente, certaines ressources de bascules peuvent être consommées pour effectuer une synchronisation simple par retard et mise en cascade de registres sur les données multi-bits.

Cependant, si les données changent trop rapidement, la méthode d'échantillonnage par retard et mise en cascade de registres ne peut plus être utilisée. Car à ce moment-là, chaque bit des données n'est plus un signal de niveau, et les instants de changement sont également irréguliers. Un échantillonnage avec une horloge asynchrone peut capturer des données incorrectes causées par des retards de chemin différents.

Une méthode courante pour résoudre de tels problèmes asynchrones consiste à utiliser une FIFO asynchrone (Premier entré, premier sorti). Veuillez vous référer à la section suivante pour plus de détails :"4.4 Conception FIFO"。

Téléchargement du code source pour ce chapitre

Téléchargement