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
//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
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