Eingangs- und Ausgangs-Ports

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

Eingangs- und Ausgangs-Ports sind die Verbindungen, die es einem Modul ermöglichen, mit der Außenwelt zu kommunizieren. Sie sind wie die Pins auf einem Chip. Ports sind die Schnittstelle zwischen einem Modul und dem Rest des Designs.

Jedes Modul hat:

Eingangsports — Signale, die in das Modul eingehen
Ausgangsports — Signale, die aus dem Modul ausgehen

Eingangsports

Eingangsports empfangen Daten von außen. Sie können innerhalb des Moduls nicht geändert werden – sie sind nur lesbar.

input clk;        // Ein-Bit-Eingang
input [7:0] data; // 8-Bit-Eingangsvektor
input a, b;       // Mehrere Eingänge in einer Zeile

Regeln für Eingänge:

Kann innerhalb des Moduls keinem Wert zugewiesen werden
Kann nicht als reg deklariert werden
Immer wire (standardmäßig)

Ausgangs-Ports

Ausgangs-Ports senden Daten nach außen. Sie können durch assign- oder always-Blöcke angesteuert werden.

output out;           // Ein-Bit-Ausgang
output [3:0] result;  // 4-Bit-Ausgang
output reg busy;      // Ausgang kann reg sein
output wire ready;    // Ausgang kann wire sein

Regeln für Ausgänge:

Können wire (mit assign) oder reg (mit always) sein
Müssen von etwas innerhalb des Moduls angesteuert werden

Syntax der Port-Deklaration

Die Syntax der Port-Deklaration ist die spezifische Art und Weise, wie Sie Eingangs- und Ausgangs-Ports in einem Modul schreiben. Sie teilt Verilog drei Dinge über jeden Port mit:

Richtung — ist es Input, Output oder Inout?
Größe — wie viele Bits breit ist es?
Name — wie wird es genannt?

module example (
  input [7:0] data_in,    // Eingangsvektor
  input clk,              // Einzelner Eingang
  input enable,           // Einzelner Eingang
  output reg [7:0] out,   // Ausgang reg
  output busy             // Ausgang wire
);

Warum die Port-Richtung wichtig ist

Die Richtung teilt Verilog mit:

Welche Signale das Modul lesen kann (Eingänge)
Welche Signale das Modul schreiben kann (Ausgänge)
Welche Arten von Verbindungen zulässig sind

Die Verwendung der falschen Richtung führt zu Kompilierungsfehlern.

Code-Beispiel

module port_demo (
  input [3:0] a,        // Kann nur lesen
  input [3:0] b,        // Kann nur lesen
  output reg [3:0] sum, // Kann schreiben (reg)
  output [3:0] diff     // Kann schreiben (wire)
);
  always @(*) begin
    sum = a + b;        // Schreiben in output reg
  end
  
  assign diff = a - b;   // Schreiben in output wire
endmodule

Aufgabe

Vervollständigen Sie die Port-Deklarationen

Was zu tun ist:

Fügen Sie einen 8-Bit-Eingang namens data_in hinzu
Fügen Sie einen Ein-Bit-Eingang namens clk hinzu
Fügen Sie einen 4-Bit-Ausgang namens result hinzu (verwenden Sie reg — wird in einem always-Block zugewiesen)
Fügen Sie einen Ein-Bit-Ausgang namens valid hinzu (verwenden Sie wire — wird mit assign zugewiesen)

Spickzettel

Ports sind die Schnittstelle zwischen einem Modul und der Außenwelt.

Eingangs-Ports (Input Ports)

Eingänge sind immer wire und innerhalb des Moduls schreibgeschützt:

input clk;        // Single-bit
input [7:0] data; // 8-bit vector
input a, b;       // Multiple inputs

Ausgangs-Ports (Output Ports)

Ausgänge können wire (angesteuert durch assign) oder reg (angesteuert durch always) sein:

output wire ready;    // Use with assign
output reg busy;      // Use with always

Port-Deklaration im Modul-Header

Jede Port-Deklaration spezifiziert Richtung, Größe und Name:

module example (
  input [7:0] data_in,   // 8-bit input
  input clk,             // single-bit input
  output reg [3:0] sum,  // 4-bit output reg
  output diff            // single-bit output wire
);
  always @(*) sum = data_in[3:0] + 1;
  assign diff = data_in[0];
endmodule

Probier es selbst

module port_challenge (
  // Aufgabe 1: Fügen Sie einen 8-Bit-Eingang namens data_in hinzu
  
  
  // Aufgabe 2: Fügen Sie einen Ein-Bit-Eingang namens clk hinzu
  
  
  // Aufgabe 3: Fügen Sie einen 4-Bit-Ausgang namens result hinzu (verwenden Sie reg)
  
  
  // Aufgabe 4: Fügen Sie einen Ein-Bit-Ausgang namens valid hinzu (verwenden Sie wire)
  
  
);

  reg [3:0] counter;
  
  always @(posedge clk) begin
    counter <= counter + 1;
    result <= counter;
  end
  
  assign valid = (counter > 8);
  
endmodule