Ports de module Verilog : input, output et inout expliqués

L'interface d'un module

La liste de ports d'un module est son interface - tout ce que le monde extérieur peut voir et toucher. À l'intérieur du module, le corps calcule les sorties à partir des entrées. Les ports sont les wires qui franchissent la frontière.

La déclaration moderne style ANSI met direction, type et largeur inline :

module my_module(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  data_in,
    output reg  [7:0]  data_out,
    output wire        valid
);
    // corps
endmodule

C'est toute la forme. Chaque port a :

• Une direction : input, output ou inout.
• Un type : wire ou reg (ou logic en SystemVerilog).
• Une largeur : une plage comme [7:0], ou 1 bit si omise.
• Un nom : l'identifiant que tu utiliseras dans le corps.

Les trois directions

input - piloté depuis l'extérieur

Les entrées sont toujours des wire. Le pilote est à l'extérieur du module - soit un signal d'un module de plus haut niveau, soit un reg du testbench. À l'intérieur de ce module, tu peux lire les entrées dans les expressions mais jamais les assigner :

module reader(input wire [7:0] data);
    initial $display("data = %h", data);
endmodule

Écrire data = ... à l'intérieur du module serait une erreur.

output - piloté depuis l'intérieur

Les sorties sont pilotées par quelque chose à l'intérieur de ce module. Elles peuvent être soit wire (pilotées par assign ou par la sortie d'un sous-module) soit reg (pilotées depuis always/initial).

module driver(
    input  wire       a,
    input  wire       b,
    input  wire       clk,
    output wire       y,    // wire - piloté par assign
    output reg        q     // reg  - piloté par always
);
    assign y = a & b;       // OK parce que y est wire

    always @(posedge clk)
        q <= a;             // OK parce que q est reg
endmodule

Essayer d'assigner y à l'intérieur du bloc always, ou de piloter q avec un assign, serait une erreur de compilation. Le choix du mot-clé doit correspondre au pilote.

inout - bidirectionnel

Les ports inout sont des wires qui peuvent être pilotés alternativement par le module ou par ce qui est connecté à l'extérieur. Ils apparaissent aux frontières des puces - lignes SDA I²C, broches GPIO bidirectionnelles, bus de données partagés. À l'intérieur du module, tu contrôles la direction avec un motif tri-state :

module bidir_pin(
    input  wire data_out,
    input  wire output_enable,
    output wire data_in,
    inout  wire pin
);
    assign pin     = output_enable ? data_out : 1'bz;
    assign data_in = pin;
endmodule

pin est le wire partagé. Quand output_enable est haut, le module pilote pin vers data_out. Quand bas, il relâche la broche en haute impédance (z), laissant un pilote externe l'utiliser. data_in observe toujours ce qui est actuellement sur la broche.

inout est rare dans la logique purement interne. Si tu construis un contrôleur mémoire, un cœur CPU, un pipeline de traitement d'image, tu n'en auras peut-être jamais besoin. C'est une fonctionnalité pour l'anneau I/O aux frontières d'une puce.

Ports 1 bit vs multi-bits

La plage de largeur est optionnelle - omets-la pour un port 1 bit :

input wire valid,         // 1 bit
input wire [7:0] data,    // 8 bits
input wire [31:0] addr,   // 32 bits

Tu peux utiliser des paramètres pour les largeurs, c'est comme ça que fonctionnent les modules paramétrés :

module bus #(
    parameter WIDTH = 32
)(
    input  wire [WIDTH-1:0] in,
    output wire [WIDTH-1:0] out
);
    assign out = in;
endmodule

Styles ANSI vs Verilog-1995

Tu verras occasionnellement du code plus ancien qui sépare la liste de ports et les déclarations :

// Ancien style Verilog-1995 - NE FAIS PAS ça dans le code récent
module foo(clk, data_in, data_out);
    input clk;
    input [7:0] data_in;
    output reg [7:0] data_out;
    // ...
endmodule

La liste de ports ne contient que des noms ; chaque port est ensuite déclaré séparément dans le corps. C'est verbeux, sujet aux erreurs « nommé dans la liste de ports mais jamais déclaré » et deux fois plus à taper. Le style ANSI-2001 (celui montré tout au long de cette doc) remplace les deux :

module foo(
    input  wire       clk,
    input  wire [7:0] data_in,
    output reg  [7:0] data_out
);
    // ...
endmodule

Utilise le style ANSI. Les outils le supportent depuis 2001.

Un exemple complet

module shifter #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             load,
    input  wire [WIDTH-1:0] data_in,
    input  wire             shift_en,
    output reg  [WIDTH-1:0] data_out,
    output wire             msb_out
);
    // Sortie combinatoire - assign pilote un wire
    assign msb_out = data_out[WIDTH-1];

    // Sortie séquentielle - always pilote un reg
    always @(posedge clk) begin
        if (reset)         data_out <= 0;
        else if (load)     data_out <= data_in;
        else if (shift_en) data_out <= data_out << 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg load = 0;
    reg shift_en = 0;
    reg [7:0] data_in;
    wire [7:0] data_out;
    wire msb_out;

    shifter #(.WIDTH(8)) dut(
        .clk(clk),
        .reset(reset),
        .load(load),
        .data_in(data_in),
        .shift_en(shift_en),
        .data_out(data_out),
        .msb_out(msb_out)
    );

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;

        data_in = 8'h81;
        #10 load = 1;
        #10 load = 0;

        shift_en = 1;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t data_out=%b msb_out=%b", $time, data_out, msb_out);
endmodule

Ce module unique a :

• Un paramètre (WIDTH).
• Des entrées pour horloge, reset, load enable, data et shift enable.
• Une sortie reg (data_out) pilotée à l'intérieur d'un bloc always.
• Une sortie wire (msb_out) pilotée par une assignation continue.
• Une déclaration ANSI complète qui liste la direction, le type et la largeur de chaque port inline.

C'est la forme de presque chaque module synthétisable que tu écriras.

La suite

Le prochain document - Instantiation de module - montre comment prendre ce module et l'utiliser à l'intérieur d'un design plus large. Le shifter que tu viens d'écrire n'est pas utile seul ; il gagne sa place quand quelque chose l'instancie et le câble dans un système.