Verilog-Always-Blöcke meistern: Syntax, Blocking- vs Non-Blocking-Zuweisungen und SystemVerilog-Erweiterungen

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Einführung

Welche Rolle spielt der always-Block in Verilog?

Warum brauchen wir den always-Block?

• Kombinatorische Logik : Ausgabe ändert sich sofort, wenn Eingaben ändern
• Sequentielle Logik : Ausgabe ändert sich synchron mit einem Taktsignal oder Timing-Ereignissen

Häufige Muster des always-Blocks

• always @(*) → Verwendet für kombinierte Logik
• always @(posedge clk) → Sequentielle Logik, ausgelöst am steigenden Flanke des Takts
• always @(posedge clk or negedge rst) → Sequentielle Logik mit asynchronem Reset oder komplexerer Steuerung

Zweck dieses Artikels

• Lernen Sie, always-Blöcke korrekt zu schreiben
• Verstehen Sie, warum Synthesefehler auftreten
• Klären Sie den Unterschied zwischen = und <=
• Vermeiden Sie häufige Anfängerfehler

2. Grundsyntax und Typen von always-Blöcken

Grundsyntax des always-Blocks

always @(sensitivity list)
begin
  // statements
end

Verwendung von always @(*) für kombinierte Logik

always @(*) begin
  if (a == 1'b1)
    y = b;
  else
    y = c;
end

Vorteile der Verwendung von @(*)

• Schließt automatisch alle referenzierten Signale in die Sensitivitätsliste ein
• Verhindert Abweichungen zwischen Simulations- und Syntheseergebnissen

Verwendung von always @(posedge clk) für sequentielle Logik

always @(posedge clk) begin
  q <= d;
end

posedge vs negedge

• posedge : ausgelöst am steigenden Flanke
• negedge : ausgelöst am fallenden Flanke

always @(posedge clk or negedge rst) mit asynchronem Reset

always @(posedge clk or negedge rst) begin
  if (!rst)
    q <= 1'b0;
  else
    q <= d;
end

Mit dieser Beschreibung wird q sofort zurückgesetzt, wenn rst niedrig ist, andernfalls fängt es d am Taktrand ein.

Kombinatorische vs. Sequentielle Schaltungen

3. Arten von Zuweisungen in always-Blöcken

Zwei Zuweisungsoperatoren in Verilog

• = : Blockierende Zuweisung
• <= : Nicht-blockierende Zuweisung

Blockierende Zuweisung (=)

always @(*) begin
  a = b;
  c = a;
end

Typische Anwendungsfälle

• Steuerstrukturen ( if , case ) in kombinatorischer Logik
• Logik, die kein Halten des Zustands erfordert

Nicht-blockierende Zuweisung (<=)

always @(posedge clk) begin
  a <= b;
  c <= a;
end

Typische Anwendungsfälle

• Sequenzielle Logik (Register, Flip-Flops)
• Genaue Zustandspropagation über mehrere Signale

Blockierende vs. Nicht-blockierende Zuweisungen: Vergleich

Was passiert, wenn man sie mischt?

always @(posedge clk) begin
  a = b;
  a <= c;
end

Richtlinien für die Verwendung

• Verwenden Sie = in always @(*)-Blöcken (kombinatorisch)
• Verwenden Sie <= in always @(posedge clk)-Blöcken (sequentiell)

4. Häufige Fallstricke und Best Practices mit always-Blöcken

Fehler in Sensitivitätslisten

Falsche Sensitivitätslisten können versteckte Bugs verursachen

always @(a) begin
  if (b)
    y = 1'b1;
  else
    y = 1'b0;
end

Lösung: Verwenden Sie @(*)

always @(*) begin
  if (b)
    y = 1'b1;
  else
    y = 1'b0;
end

Unbeabsichtigte Latch-Generierung

Fehlende if/case-Zweige erzeugen Latches

always @(*) begin
  if (enable)
    y = d; // y is undefined when enable == 0
end

Lösung: Immer einen Wert zuweisen

always @(*) begin
  if (enable)
    y = d;
  else
    y = 1'b0; // y is always defined
end

Übermäßig komplexe Bedingungen

Typischer Fehler: Kein default in einer case-Anweisung

always @(*) begin
  case(sel)
    2'b00: y = a;
    2'b01: y = b;
    2'b10: y = c;
    // 2'b11 not handled → y may be undefined
  endcase
end

Lösung: Fügen Sie eine default-Klausel hinzu

always @(*) begin
  case(sel)
    2'b00: y = a;
    2'b01: y = b;
    2'b10: y = c;
    default: y = 1'b0; // safety net
  endcase
end

Steuerung mehrerer Signale in einem Block

Zusammenfassung gängiger Fallstricke

5. Erweiterungen von always in SystemVerilog

always_comb: für kombinierende Logik

Überblick

always_comb begin
  y = a & b;
end

Hauptvorteile

• Erzeugt automatisch die Sensitivitätsliste
• Tools warnen, wenn unbeabsichtigte Latches abgeleitet werden
• Verhindert Konflikte mit zuvor definierten Variablen

Beispiel (Verilog vs SystemVerilog)

// Verilog
always @(*) begin
  y = a | b;
end

// SystemVerilog
always_comb begin
  y = a | b;
end

always_ff: für sequentielle Logik (Flip-Flops)

Überblick

always_ff @(posedge clk or negedge rst_n) begin
  if (!rst_n)
    q <= 1'b0;
  else
    q <= d;
end

Hauptvorteile

• Erlaubt nur non-blocking Zuweisungen ( <= )
• Tools überprüfen die Korrektheit der Sensitivitätsliste
• Die Lesbarkeit des Codes verbessert sich, da es klar sequentiell ist

always_latch: für latch-basierte Logik

Überblick

always_latch begin
  if (enable)
    q = d;
end

Zu beachtende Punkte

• Wenn einige Zweige die Zuweisung überspringen, wird ein Latch explizit erstellt
• Nur verwenden, wenn Latches wirklich erforderlich sind

SystemVerilog-Nutzungszusammenfassung

SystemVerilog wird zum Standard

6. FAQ: Häufige Fragen zum always-Block

Q1. Sollte ich if oder case innerhalb eines always-Blocks verwenden?

• Für 2–3 einfache Bedingungen → if ist leichter lesbar
• Für mehrere unterschiedliche Zustände → case ist klarer und drückt die Absicht besser aus

Q2. Was passiert, wenn ich Signale in der Sensitivitätsliste weglasse?

Q3. Warum erscheinen unbeabsichtigte Latches in meinem Design?

Schlechtes Beispiel:

always @(*) begin
  if (en)
    y = d; // y is held when en == 0
end

Lösung:

always @(*) begin
  if (en)
    y = d;
  else
    y = 1'b0; // always assigned
end

Q4. Kann ich = und <= im selben Block mischen?

• Kombinatorische Logik → = verwenden (blocking)
• Sequentielle Logik → <= verwenden (non‑blocking)

Daumenregel:

Q5. Was ist der Unterschied zwischen always_ff und always @(posedge clk)?

Q6. Ist es in Ordnung, mehrere Signale in einem always‑Block zu steuern?

• Jeder Ausgang unabhängig arbeitet
• Sie synchrone und asynchrone Logik mischen

Q7. Was passiert, wenn ich <= in kombinatorischer Logik verwende?

7.it

always‑Blöcke sind das Fundament des Verilog‑Designs

Wichtigste Erkenntnisse

• Die Unterschiede und Verwendung von always @(*) vs always @(posedge clk)
• Der Unterschied zwischen = (blocking) und <= (non‑blocking) Zuweisungen
• Wie man häufige Fehler wie Latch‑Erzeugung und unvollständige Sensitivitätslisten vermeidet
• SystemVerilog‑Erweiterungen (always_comb, always_ff, always_latch) für sichereres Design
• Praktische Antworten auf häufige Fragen aus der Praxis (FAQ)

Präzision bestimmt die Qualität

Nächste Schritte: Weiter zu höherem Design

• Finite‑State‑Machine (FSM)‑Design
• Pipelining‑ und Streaming‑Architekturen
• Entwicklung von IPKernen und FPGA‑Implementierung

Abschließende Gedanken für Hardware‑Designer