Ports d'entrée et de sortie

Fait partie de la section Fondamentaux du Journey Verilog de Coddy — leçon 31 sur 90.

Les ports d'entrée et de sortie sont les connexions qui permettent à un module de communiquer avec le monde extérieur. Ils sont comme les broches d'une puce. Les ports sont l'interface entre un module et le reste de la conception.

Chaque module possède :

Ports d'entrée — signaux qui entrent dans le module
Ports de sortie — signaux qui sortent du module

Ports d'entrée

Les ports d'entrée reçoivent des données de l'extérieur. Ils ne peuvent pas être modifiés à l'intérieur du module — seulement lus.

input clk;        // Entrée sur un seul bit
input [7:0] data; // Vecteur d'entrée de 8 bits
input a, b;       // Plusieurs entrées sur une seule ligne

Règles pour les entrées :

Ne peuvent pas se voir assigner une valeur à l'intérieur du module
Ne peuvent pas être déclarées comme reg
Toujours wire (par défaut)

Ports de sortie

Les ports de sortie envoient des données vers l'extérieur. Ils peuvent être pilotés par des blocs assign ou always.

output out;           // Sortie à un seul bit
output [3:0] result;  // Sortie 4 bits
output reg busy;      // La sortie peut être de type reg
output wire ready;    // La sortie peut être de type wire

Règles pour les sorties :

Peuvent être wire (avec assign) ou reg (avec always)
Doivent être pilotées par quelque chose à l'intérieur du module

Syntaxe de déclaration des ports

La syntaxe de déclaration des ports est la manière spécifique dont vous écrivez les ports d'entrée et de sortie dans un module. Elle indique à Verilog trois choses sur chaque port :

Direction — est-ce une entrée (input), une sortie (output) ou bidirectionnel (inout) ?
Taille — quelle est sa largeur en bits ?
Nom — comment s'appelle-t-il ?

module example (
  input [7:0] data_in,    // Vecteur d'entrée
  input clk,              // Entrée simple
  input enable,           // Entrée simple
  output reg [7:0] out,   // Registre de sortie
  output busy             // Fil de sortie
);

Pourquoi la direction des ports est importante

La direction indique à Verilog :

Quels signaux le module peut lire (entrées)
Quels signaux le module peut écrire (sorties)
Quels types de connexions sont autorisés

L'utilisation de la mauvaise direction provoque des erreurs de compilation.

Exemple de code

module port_demo (
  input [3:0] a,        // Lecture seule uniquement
  input [3:0] b,        // Lecture seule uniquement
  output reg [3:0] sum, // Peut écrire (reg)
  output [3:0] diff     // Peut écrire (wire)
);
  always @(*) begin
    sum = a + b;        // Écriture vers output reg
  end
  
  assign diff = a - b;   // Écriture vers output wire
endmodule

Défi

Complétez les déclarations de ports

Ce qu'il faut faire :

Ajoutez une entrée de 8 bits appelée data_in
Ajoutez une entrée d'un seul bit appelée clk
Ajoutez une sortie de 4 bits appelée result (utilisez reg — sera assignée dans un bloc always)
Ajoutez une sortie d'un seul bit appelée valid (utilisez wire — sera assignée avec assign)

Aide-mémoire

Les ports sont l'interface entre un module et le monde extérieur.

Ports d'entrée (Input)

Les entrées sont toujours de type wire, en lecture seule à l'intérieur du module :

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

Ports de sortie (Output)

Les sorties peuvent être de type wire (pilotées par assign) ou reg (pilotées par always) :

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

Déclaration des ports dans l'en-tête du module

Chaque déclaration de port spécifie la direction, la taille et le nom :

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

Essayez vous-même

module port_challenge (
  // Tâche 1 : Ajouter une entrée de 8 bits appelée data_in
  
  
  // Tâche 2 : Ajouter une entrée d'un seul bit appelée clk
  
  
  // Tâche 3 : Ajouter une sortie de 4 bits appelée result (utiliser reg)
  
  
  // Tâche 4 : Ajouter une sortie d'un seul bit appelée valid (utiliser wire)
  
  
);

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