Blockierende Zuweisung

Teil des Abschnitts Grundlagen der Verilog-Journey von Coddy — Lektion 49 von 90.

Verilog hat zwei Arten von prozeduralen Zuweisungen: blockierend (=) und nicht-blockierend (<=). In dieser Lektion konzentrieren wir uns auf die blockierende Zuweisung.

Die blockierende Zuweisung verwendet den =-Operator. Sie wird als „blockierend“ bezeichnet, da sie die Ausführung der nächsten Anweisung blockiert, bis die aktuelle Zuweisung abgeschlossen ist. Der Code wird Schritt für Schritt in der richtigen Reihenfolge ausgeführt.

Syntax:

variable = expression;

Wann blockierende Zuweisungen zu verwenden sind

Die blockierende Zuweisung (=) wird für kombinatorische Logik verwendet — Schaltungen, bei denen sich die Ausgänge sofort ändern, wenn sich die Eingänge ändern, ohne Takt und ohne Speicher.

Beispiele für Kombinationslogik:

AND / OR / XOR Gatter
Addierer und Subtrahierer

Multiplexer
Decoder

Verilog-Beispiel:

always @(*) begin
  sum = a + b;      // Blockierende Zuweisung
  carry = a & b;    // Blockierende Zuweisung
end

Blockierende Zuweisungen in Always-Blöcken (Kombinatorische Logik)

always @(*) begin
  temp = a & b;    // Schritt 1
  out = temp | c;  // Schritt 2 (verwendet temp aus Schritt 1)
end

Die Reihenfolge ist wichtig. Dies ist für kombinatorische Logik in Ordnung.

Blockierend vs. Nicht-blockierend

	Blockierend (`=`)	Nicht-blockierend (`<=`)
Ausführung	Nacheinander	Gleichzeitig
Wartet die nächste Zeile?	Ja	Nein
Verwendung	Kombinatorische Logik	Sequenzielle Logik (Flipflops)

Wichtig: Verwenden Sie keine blockierenden Zuweisungen für Flip-Flops

Aufgabe

Füge die fehlenden blockierenden Zuweisungen hinzu, um die Werte von x und y unter Verwendung einer temporären Variable zu vertauschen.

Was zu tun ist:

Weise den Wert von x temp zu (speichere x in temp)
Weise den Wert von y x zu (verschiebe y nach x)
Weise den Wert von temp y zu (verschiebe das gespeicherte x nach y)

Spickzettel

Blockierende Zuweisung (=) wird sequenziell ausgeführt — jede Anweisung wird abgeschlossen, bevor die nächste beginnt. Verwendet für kombinatorische Logik innerhalb von always @(*) Blöcken.

always @(*) begin
  temp = a & b;    // Schritt 1
  out = temp | c;  // Schritt 2 (verwendet aktualisiertes temp)
end

	Blockierend (`=`)	Nicht-blockierend (`<=`)
Ausführung	Nacheinander	Gleichzeitig
Verwendung für	Kombinatorische Logik	Sequenzielle Logik (Flip-Flops)

Probier es selbst

module swap;
  reg x, y;
  reg temp;
  
  initial begin
    x = 1;
    y = 0;
    
    $display("Before swap: x=%d, y=%d", x, y);
    
    // TODO: Schritt 1 - x an temp zuweisen
    
    // TODO: Schritt 2 - y an x zuweisen
    
    // TODO: Schritt 3 - temp an y zuweisen
    
    $display("After swap: x=%d, y=%d", x, y);
    $finish;
  end
endmodule