Schlüsselwörter: Flip-Flop, Latch
Die Bedeutung von Latches
Ein Latch ist ein pegelgesteuertes Speicherelement. Die Datenspeicherung hängt vom Pegel des Eingangstakt- (oder Enable-)Signals ab. Nur wenn sich das Latch im freigegebenen Zustand befindet, ändert sich der Ausgang mit dem Dateneingang.
Wenn das Pegelsignal inaktiv ist, ändert sich das Ausgangssignal mit dem Eingangssignal, als würde es durch einen Puffer laufen; wenn der Pegel aktiv ist, wird das Ausgangssignal verriegelt. Jede Änderung des Ansteuersignals führt direkt zu einer Änderung des Ausgangszustands des Latches, was aufgrund instabiler transienter Eigenschaften sehr wahrscheinlich zu Schwingungen führt.
Das Schaltbild eines Latches ist wie folgt:

Ein Flip-Flop ist ein flankengesteuertes Speicherelement. Der Speichervorgang (Zustandsübergang) wird durch die steigende oder fallende Flanke eines Signals synchronisiert (wodurch der Zustandsübergang des Speicherelements auf einen sehr kurzen Zeitraum beschränkt wird).
Das Schaltbild eines Flip-Flops ist wie folgt:

Ein Register ist eine Variable in Verilog, die verwendet wird, um an Operationen beteiligte Daten und Operationsergebnisse vorübergehend zu speichern. Wenn eine Variable als Register deklariert wird, kann sie zu einem Flip-Flop, einem Latch oder sogar zu einer Variable vom Wire-Typ synthetisiert werden. In den meisten Fällen erwarten wir jedoch, dass sie zu einem Flip-Flop synthetisiert wird, aber manchmal kann sie aufgrund von Problemen beim Schreiben des Codes zu einer unerwünschten Latch-Struktur synthetisiert werden.
Die Hauptgefahren von Latches sind:
- 1) Der Eingangszustand kann sich mehrfach ändern, was leicht Glitches verursacht und die Unsicherheit der nachfolgenden Schaltungsstufe erhöht;
- 2) In den meisten FPGA-Ressourcen kann die Implementierung einer Latch-Struktur mehr Ressourcen erfordern als ein Flip-Flop;
- 3) Das Vorhandensein von Latches macht die statische Timing-Analyse komplexer.
Latches werden meist zur Clock-Gating-Steuerung verwendet. Im allgemeinen Design sollten wir die Erzeugung von Latches vermeiden.
Unvollständige if-Struktur
In der kombinatorischen Logik erzeugt eine unvollständige if-else-Struktur ein Latch.
Zum Beispiel fehlt in dem folgenden Modell der if-Anweisung eine else-Struktur. Standardmäßig bleibt der Wert des Registers q im else-Zweig unverändert, was bedeutet, dass es Daten speichern kann. Daher wird das Register q zu einer Latch-Struktur synthetisiert.
Beispiel
input data,
input en ,
output reg q) ;
always @(*) begin
if (en) q = data ;
end
endmodule
Es gibt hauptsächlich zwei Methoden, solche Latches zu vermeiden: Eine besteht darin, die if-else-Struktur zu vervollständigen, oder dem Signal Anfangswerte zuzuweisen.
Zum Beispiel kann die always-Anweisung im obigen Modell in die folgenden zwei Formen geändert werden:
Beispiel
always @(*) begin
if (en) q = data ;
else q = 1'b0 ;
end
// Anfangswert zuweisen
always @(*) begin
q = 1'b0 ;
if (en) q = data ; // Wenn en gültig ist, wird der Wert von q neu geschrieben; andernfalls bleibt q 0.
end
In der sequenziellen Logik erzeugt eine unvollständige if-else-Struktur jedoch kein Latch, wie im folgenden Modell gezeigt.
Dies liegt daran, dass das Register q Speicherfähigkeit besitzt und sein Wert sich nur bei der Taktflanke ändert, was genau die Eigenschaft eines Flipflops ist.
Beispiel
input clk ,
input data,
input en ,
output reg q) ;
always @(posedge clk) begin
if (en) q <= data ;
end
endmodule
In der kombinatorischen Logik erzeugen unvollständige Zuweisungsanweisungen unter jeder Verzweigungsbedingung ebenfalls ein Latch, wenn es viele Zuweisungsanweisungen in einer bedingten Anweisung gibt.
Tatsächlich entspricht dies aus Sicht der logischen Zerlegung jedes Signals einer unvollständigen if-else-Struktur, bei der das zugehörige Registersignal unter anderen Bedingungen kein Zuweisungsverhalten aufweist. Zum Beispiel:
Beispiel
input data1,
input data2,
input en ,
output reg q1 ,
output reg q2) ;
always @(*) begin
if (en) q1 = data1 ;
else q2 = data2 ;
end
endmodule
Diese Situation kann auch vermieden werden, indem die Zuweisungsanweisungen vervollständigt oder Anfangswerte zugewiesen werden. Zum Beispiel:
Beispiel
// q1 = 0; q2 = 0; // oder hier Anfangswerte für q1/q2 zuweisen
if (en) begin
q1 = data1 ;
q2 = 1'b0 ;
end
else begin
q1 = 1'b0 ;
q2 = data2 ;
end
end
Unvollständige case-Struktur
Das Prinzip der durch case-Anweisungen erzeugten Latches ist fast dasselbe wie bei if-Anweisungen. In der kombinatorischen Logik wird ebenfalls ein Latch erzeugt, wenn die case-Elementliste unvollständig ist und kein default-Schlüsselwort hinzugefügt wird oder mehrere Zuweisungsanweisungen unvollständig sind. Zum Beispiel:
Beispiel
input data1,
input data2,
input [1:0] sel ,
output reg q ) ;
always @(*) begin
case(sel)
2'b00: q = data1 ;
2'b01: q = data2 ;
endcase
end
endmodule
Natürlich gibt es auch zwei Methoden, solche Latches zu beseitigen: die case-Elementliste vervollständigen oder dem Signal Anfangswerte zuweisen.
Beim Vervollständigen der case-Elementliste können alle Elementfälle aufgelistet werden, oder das default-Schlüsselwort kann verwendet werden, um andere Elementfälle abzudecken.
Zum Beispiel kann die obige always-Anweisung auf die folgenden zwei Arten geändert werden.
Beispiel
case(sel)
2'b00: q = data1 ;
2'b01: q = data2 ;
default: q = 1'b0 ;
endcase
end
always @(*) begin
case(sel)
2'b00: q = data1 ;
2'b01: q = data2 ;
2'b10, 2'b11 :
q = 1'b0 ;
endcase
end
Ursprüngliche Signalzuweisung oder -beurteilung
In der kombinatorischen Logik wird ebenfalls ein Latch erzeugt, wenn die Quelle einer Signalzuweisung das Signal selbst enthält oder wenn die Beurteilungsbedingung Logik für das Signal selbst enthält. Das liegt daran, dass das Signal auch Speicherfähigkeit besitzen muss, es aber keinen Takt gibt, der es treibt. Solche Probleme können beispielsweise in if-Anweisungen, case-Anweisungen und ternären Ausdrücken auftreten:
Beispiel
reg a, b ;
always @(*) begin
if (a & b) a = 1'b1 ; //a -> Latch
else a = 1'b0 ;
end
//Signal selbst ist die Zuweisungsquelle
reg c;
wire [1:0] sel ;
always @(*) begin
case(sel)
2'b00: c = c ; //c -> Latch
2'b01: c = 1'b1 ;
default: c = 1'b0 ;
endcase
end
//Signal selbst als Teil einer Bedingung in "? expression"
wire d, sel2;
assign d = (sel2 && d) ? 1'b0 : 1'b1 ; //d -> Latch
Es gibt nur einen Weg, solche Latches zu vermeiden: Vermeiden Sie diesen Programmierstil in kombinatorischer Logik. Weisen Sie ein Signal nicht sich selbst zu, und verwenden Sie das zugewiesene Signal nicht selbst in der Bedingungslogik.
Wenn beispielsweise keine unmittelbare Ausgabe erforderlich ist, kann das Signal um einen Taktzyklus verzögert werden, bevor die zugehörige Logik kombiniert wird. Der erste Code, der oben ein Latch erzeugte, kann wie folgt beschrieben werden:
Beispiel
reg a_r ;
always (@posedge clk)
a_r <= a ;
always @(*) begin
if (a_r & b) a = 1'b1 ; //es gibt kein Latch
else a = 1'b0 ;
end
Unvollständige Liste sensitiver Signale
Wenn die Empfindlichkeitsliste im always@()-Block in der kombinatorischen Logik nicht vollständig ist und der Block nicht ausgelöst wird, wenn er es sollte, hält das zugehörige Register weiterhin das vorherige Ausgabeergebnis, wodurch ein Latch erzeugt wird.
In diesem Fall beseitigt das Vervollständigen der Liste der sensitiven Signale oder die direkte Verwendung von always@(*) das Latch.
Zusammenfassung
Kurz gesagt, um die Entstehung von Latches zu vermeiden, sind in der kombinatorischen Logik die folgenden Punkte zu beachten:
- 1) Die Struktur von if-else- oder case-Anweisungen muss vollständig sein.
- 2) Platzieren Sie das zugewiesene Signal nicht in der Zuweisungsquelle oder in Bedingungsabfragen.
- 3) Es wird empfohlen, always@(*) für die Liste der sensitiven Signale zu verwenden.
Quellcode-Download
Herunterladen