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

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

    // Vervollständige die bedingte Verzweigungsstruktur
    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

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

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

    always @(*) begin
        // 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

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

    always @(*) begin
        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

    //Signal selbst als Teil der Bedingung
    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, b ;
    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