Flip-Flop und Latch-Schlussfolgerung Dilemma

Question

Könnte mir jemand erklären, warum ein Latch anstelle eines Flip-Flops abgeleitet werden würde?

Sollte die Tatsache, dass der Block immer auf eine Signalflanke reagiert, nicht ausreichen, um auf ein Flip-Flop zu schließen. Wenn in diesem Fall eine negative Flanke des Reset ausgelöst wird, erhält a 0, ansonsten behält es den vorherigen Wert bei.

Diese Frage aus der gewählten besten Antwort auf dieser Frage kommt Stackoverflow:
System Verilog always_latch vs. always_ff

========================== ===============================================

Ich werde hier teilen, was ich bisher herausgefunden habe. Der Grund, warum dies zu einem Latch anstelle eines Flip-Flops synthetisiert wird, liegt darin, dass auf der rechten Seite der Zuweisung ein CONSTANT ist. Wenn dies der Fall ist, sind das Verhalten eines Latch und eines Flipflops gleichwertig, da es keine Rolle spielt, ob es den Eingangswert an einer Signalflanke (Flip-Flop) abfängt oder während die Eingangsverriegelung aktiviert ist (Latch) Eingabe ändert sich nicht. Daher wählt das Synthesewerkzeug das Element, das weniger Ressourcen benötigt, d. H. Das Latch.

Auf der anderen Seite, wenn auf der rechten Seite der Zuordnung eine VARIABLE wäre, müsste die Synthese auf ein Flip-Flop, schließen, denn es wäre egal, ob der Eingang an einer Flanke abgetastet wird (Flip-Flop)) oder während der Eingabe wird die Verriegelung aktiviert (Latch), was bedeutet, dass die beiden Logikelemente NICHT gleich sind.

Hier ist ein Beispiel. Die ersten zwei immer Blöcke werden zu einem Latch (in Quartus 14) synthetisiert, was OK ist, da sie äquivalent sind, wegen einer Konstante. Aber der 3. und der 4. always Block werden auch zu einem Latch synthetisiert, was nicht das beabsichtigte Verhalten ist und diese Blöcke sind nicht äquivalent! Der 3. Block wird eine Warnung geben, während der 4. Block nicht angezeigt wird.

module ff_latch(
    input logic clk, 
    input logic nrst, 
    input logic a, 
    output logic t, x, y, z 
); 

    always_ff @(posedge clk, negedge nrst) 
     begin 
      if (!nrst) 
      t <= 0; 
     end 

    always_latch 
     begin 
      if (!nrst) 
      x <= 0; 
     end 

    always_ff @(posedge clk, negedge nrst) 
     begin 
      if (!nrst) 
      y <= a; 
     end 

    always_latch 
     begin 
      if (!nrst) 
      z <= a; 
     end 

endmodule: ff_latch 

Für mich ist dieses Verhalten nicht richtig, wie ich gesagt, sagte ich einen Flip-Flop will (mit flankengetriggert). Es ist nicht einmal, dass die Codierung nicht eindeutig ist, immer Blöcke 3 und 4 sind deutlich unterschiedlich, wie in dieser Wellenform aus der obigen Simulation zu sehen:

Block 3 (tb_y) wie ein benimmt asynchrones Flip-Flop und Block 4. (tb_z) verhält sich wie ein Latch. Aber das Synthesewerkzeug schließt in beiden Fällen eine Verriegelung.

Wenn jemand etwas Licht darauf werfen oder den Code oder die Wellenform kommentieren kann, würde es sehr geschätzt werden.

Answer 1

Ein Synthesizer wird auf einen Latch schließen, da dieser Code sich wie ein Latch verhält. Es verhält sich nicht wie ein Flip-Flop. So einfach ist das.

Denken Sie darüber nach, wie sich dieser Code verhält: Zunächst wird der Wert a'x sein. Wenn rst niedrig bestätigt wird, wird a zu '0. a wird dann für immer bei '0 bleiben. Der Zustand a hängt daher nicht nur vom aktuellen Zustand der Eingänge, sondern auch vom vergangenen Zustand ab.Daher haben wir sequentielle Logik, nicht kombinatorische Logik. Flip-Flops ändern den Zustand an einer Taktflanke; a nicht. Die Tatsache, dass der Always-Block empfindlich auf eine Signalflanke reagiert, ist irrelevant. Das bedeutet nur, dass der Code innerhalb dieser Signalflanke ausgeführt wird - die positive Flanke von clk. Aber wenn das passiert, passiert nichts, also verhält sich dieser Code wie ein Latch.

Answer 2

Weil Sie nicht angegeben haben, was an der Uhr passiert. Es ist, als ob a nicht von clk oder seinem posege überhaupt abhängt. All Ihre Beschreibung besagt, dass a auf 0 eingestellt ist, wenn rst=0. Außerdem heißt es (implizit), dass a in allen anderen Fällen seinen vorherigen Wert behält. Dies kann durch ein Latch implementiert werden.

Beachten Sie, dass, nur weil Sie @posedge von clk haben, nicht bedeutet, dass jede Variable in diesem Block als Flop synthetisiert wird. Sie benötigen außerdem eine nicht blockierende Zuweisung an a, wenn der Block in der Ansicht von clk aktiviert wird. Siehe here.

Wenn Sie darauf bestehen, einen Flop auf, die die gleiche Funktionalität zu implementieren, können Sie dies versuchen:

always_ff @ (posedge clk or negedge rst) 
begin 
    if (!rst) 
    a <= '0; 
    else 
    a <= a; //Here, we are specifying what happens @posedge of clk 
end