Wenn Signale von einer schnellen Taktdomäne in eine langsame Taktdomäne übertragen werden, muss eine Synchronisationsverarbeitung entsprechend den Eigenschaften des Signals durchgeführt werden. Bei Einzelbit-Signalen kann im Allgemeinen zwischen Pegelsignalen und Pulssignalen unterschieden werden.

Synchronisation von Pegelsignalen

Im synchronen Logikentwurf bezeichnet ein Pegelsignal ein Signal, das über einen langen Zeitraum unverändert bleibt. Die Zeit, in der es unverändert bleibt, ist relativ zum langsamen Takt definiert. Solange das schnelle Taktsignal lange genug auf High oder Low bleibt, um vom langsamen Takt erfasst zu werden, während die Timing-Constraints eingehalten werden, kann das Signal als Pegelsignal betrachtet werden.

Da Pegelsignale sicher erfasst werden können, werden auch Pegelsignale von der schnellen Taktdomäne zur langsamen Taktdomäne mit der Methode der Verzögerung und Registerstufung synchronisiert.

Synchronisation von Pulssignalen

Im synchronen Logikentwurf bezeichnet ein Pulssignal ein Signal, dessen gültige Breite, die von der schnellen Taktdomäne ausgegeben wird, kleiner als die Periode des langsamen Takts ist. Wenn die langsame Taktdomäne ein solches schmales Pulssignal direkt erfasst, kann es verpasst werden.

Wenn die Pulsbreiten solcher Pulssignale alle gleich sind und das Frequenzverhältnis der beiden Takte bekannt ist, kann die Methode "Pulsbreitenerweiterung in der schnellen Taktdomäne + Verzögerung und Registerstufung in der langsamen Taktdomäne" zur Synchronisation verwendet werden.

Wenn schmale Pulssignale manchmal auch die Eigenschaften von Pegelsignalen aufweisen, das heißt, wenn die gültige Breite des Signals manchmal größer als die Periode des langsamen Takts ist und vom langsamen Takt erfasst werden kann, dann ist eine Pulserweiterung für solche Signale offensichtlich unwirtschaftlich. In diesem Fall kann die Synchronisation über die Methode der "Handshake-Übertragung" erfolgen.

Unter der Annahme, dass die High-Pegel-Periode des Pulssignals die gültige Signalperiode ist, lautet das Grundprinzip wie folgt.

  • (1) Die schnelle Taktdomäne erkennt das Pulssignal und gibt beim Erkennen eines High-Pegels ein High-Pegel-Signal pulse_fast_r aus. Alternativ: Wenn die schnelle Taktdomäne ein High-Pegel-Signal ausgibt, ziehen Sie das Signal nicht voreilig auf Low; halten Sie das Ausgangssignal zunächst im High-Pegel-Zustand.
  • (2) Die langsame Taktdomäne führt eine Verzögerungs- und Registerstufen-Abtastung des Signals pulse_fast_r aus der schnellen Taktdomäne durch. Da das Pulssignal zu diesem Zeitpunkt von der schnellen Taktdomäne auf High gehalten wird, werden die Verzögerung und die Registerstufen das Signal mit Sicherheit erfassen.
  • (3) Nachdem die langsame Taktdomäne bestätigt hat, dass sie das High-Pegel-Signal pulse_fast2s_r abgetastet hat, führt sie es zur schnellen Taktdomäne zurück.
  • (4) Die schnelle Taktdomäne führt eine Verzögerungs- und Registerstufen-Abtastung des Rückkopplungssignals pulse_fast2s_r durch. Wenn das Rückkopplungssignal als High-Pegel erkannt wird, beweist dies, dass die langsame Taktdomäne ein gültiges High-Pegel-Signal empfangen hat. Wenn die eigene Logik der schnellen Taktdomäne zu diesem Zeitpunkt das Pulssignal nicht mehr auf High-Pegel benötigt, ziehen Sie das Pulssignal in der schnellen Taktdomäne einfach auf Low.

Die Essenz dieses Verfahrens besteht darin, die Pulsbreite von schmalen Pulssignalen durch gegenseitigen Handshake zu verlängern.

Das Verilog-Modell für die Synchronisationsverarbeitung unter Verwendung von Handshake-Signalen wird wie folgt beschrieben.

Beispiel

//Synchronisationsmodul mit einem Arbeitstakt von ungefähr 25MHz
//Asynchrone Daten stammen von einem Modul mit einem Arbeitstakt von 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 ;
   /**************** schneller Takt ***************/
   //(1) Wenn die schnelle Taktdomäne ein Pulssignal erkennt, zieht sie das Pulssignal nicht sofort auf niedrig
   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 ;
   /************ langsamer Takt *************/
   //(2) Die langsame Takt-Domäne führt eine Verzögerung und Registerstufen-Abtastung am Signal durch
   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ückkopplung von langsamem Takt zu schnellem Takt *******/
   //(3) Führe eine Verzögerung und Registerstufen-Abtastung am Rückkopplungssignal durch
   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
   //Steuere, dass das Puls-Signal der schnellen Taktdomäne auf niedrig gezogen wird
   assign clear_n = ~(!pulse_fast && pulse_slow2f_r[1]) ;


endmodule

Die Testbench ist wie folgt beschrieben.

Beispiel

`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

   //Abschnitt zur Erzeugung schmaler Pulse
   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

Die Simulationsergebnisse sind wie folgt, woraus ersichtlich ist:

  • (1) Ein einzelnes schmales Pulssignal in der schnellen Taktdomäne wird von der langsamen Taktdomäne erfasst, aber das synchronisierte Signal hat eine längere Verzögerung und eine größere Pulsbreite. Die Signalverzögerung wird durch Verzögerung und Registerstufung sowie Rückkopplungslöschung verursacht und ist unvermeidbar. Das Problem der übermäßigen Pulsbreite kann durch Flankenerkennung mittels Verzögerung und Registerstufung behandelt werden.
  • (2) Die Pulsbreite des synchronisierten Signals zweier benachbarter schmaler Pulssignale unterscheidet sich nicht von der eines einzelnen synchronisierten schmalen Pulssignals. Das heißt, die Synchronisationsschaltung verpasst die Erkennung des zweiten schmalen Pulses. Dies ist auch ein Merkmal der Handshake-Übertragung bei der Behandlung von Synchronisationsproblemen. Wenn sich das Pulssignal in der schnellen Taktdomäne zu schnell ändert, kann diese Methode benachbarte Pulse nicht unterscheiden.
  • (3) Wenn mehrere breite und schmale Pulssignale dicht beieinander liegen, kann diese Synchronisationsmethode zwar mehrere Pulssignale nicht unterscheiden, aber die Pulsbreite des synchronisierten Signals kann relativ größer sein.

Mehrbit-Datensynchronisation

Bei der Synchronisation von Mehrbit-Daten können, wenn jedes Bit der Daten als Pegelsignal betrachtet werden kann, das heißt, jedes Bit der Daten über einen relativ langen Zeitraum unverändert bleiben kann, sodass es vom langsamen Takt erfasst werden kann, einige Flip-Flop-Ressourcen verbraucht werden, um eine einfache Verzögerungs- und Registerstufungs-Synchronisation an den Mehrbit-Daten durchzuführen.

Wenn sich die Daten jedoch zu schnell ändern, kann die Methode der Verzögerungs- und Registerstufungsabtastung nicht mehr verwendet werden. Denn zu diesem Zeitpunkt ist jedes Bit der Daten kein Pegelsignal mehr, und die Änderungszeitpunkte sind ebenfalls ungleichmäßig. Die Abtastung mit einem asynchronen Takt kann fehlerhafte Daten erfassen, die durch unterschiedliche Pfadverzögerungen verursacht werden.

Eine gängige Methode zur Lösung solcher asynchronen Probleme ist die Verwendung eines asynchronen FIFO (First In First Out). Weitere Details finden Sie im nächsten Abschnitt:"4.4 FIFO Design"。

Quellcode-Download für dieses Kapitel

Herunterladen