Puertos de módulo en Verilog: input, output e inout explicados

La interfaz de un módulo

La lista de puertos de un módulo es su interfaz - todo lo que el mundo exterior puede ver y tocar. Dentro del módulo, el cuerpo calcula salidas a partir de entradas. Los puertos son los wires que cruzan la frontera.

La declaración moderna de estilo ANSI pone dirección, tipo y ancho en línea:

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

Esa es toda la forma. Cada puerto tiene:

• Una dirección: input, output o inout.
• Un tipo: wire o reg (o logic en SystemVerilog).
• Un ancho: un rango como [7:0], o un solo bit si se omite.
• Un nombre: el identificador que usarás dentro del cuerpo.

Las tres direcciones

input - excitado desde fuera

Las entradas siempre son wire. El que excita está fuera del módulo - o bien una señal de un módulo de nivel superior o el reg del testbench. Dentro de este módulo, puedes leer las entradas en expresiones pero nunca asignarles:

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

Escribir data = ... dentro del módulo sería un error.

output - excitado desde dentro

Las salidas las excita algo dentro de este módulo. Pueden ser o bien wire (excitado por assign o por la salida de un submódulo) o reg (excitado desde always/initial).

module driver(
    input  wire       a,
    input  wire       b,
    input  wire       clk,
    output wire       y,    // wire - excitado por assign
    output reg        q     // reg  - excitado por always
);
    assign y = a & b;       // OK porque y es wire

    always @(posedge clk)
        q <= a;             // OK porque q es reg
endmodule

Intentar asignar a y dentro del bloque always, o excitar q con un assign, sería un error de compilación. La elección de la palabra clave tiene que coincidir con quien la excita.

inout - bidireccional

Los puertos inout son wires que pueden ser excitados alternativamente por el módulo o por lo que esté conectado fuera. Aparecen en los límites del chip - líneas SDA de I²C, pines GPIO bidireccionales, buses de datos compartidos. Dentro del módulo, controlas la dirección con un patrón 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 es el wire compartido. Cuando output_enable está en alto, el módulo excita pin a data_out. Cuando está en bajo, libera el pin a alta impedancia (z), permitiendo que un controlador externo lo use. data_in siempre observa lo que esté actualmente en el pin.

inout es raro en lógica puramente interna. Si estás construyendo un controlador de memoria, un núcleo de CPU o un pipeline de procesamiento de imagen, puede que nunca lo necesites. Es una característica para el anillo de I/O en los límites del chip.

Puertos de un solo bit vs multibit

El rango de ancho es opcional - omítelo para un puerto de un solo bit:

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

Puedes usar parámetros para los anchos, que es como funcionan los módulos parametrizados:

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

Estilos ANSI vs Verilog-1995

Ocasionalmente verás código antiguo que separa la lista de puertos y las declaraciones:

// Estilo Verilog-1995 antiguo - NO lo hagas en código nuevo
module foo(clk, data_in, data_out);
    input clk;
    input [7:0] data_in;
    output reg [7:0] data_out;
    // ...
endmodule

La lista de puertos contiene solo nombres; cada puerto luego se declara por separado dentro del cuerpo. Es verboso, propenso a errores "nombrado en la lista pero nunca declarado" y supone el doble de escribir. El estilo ANSI-2001 (el que se muestra a lo largo de estos docs) reemplaza ambos:

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

Usa el estilo ANSI. Las herramientas lo soportan desde 2001.

Un ejemplo completo

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
);
    // Salida combinacional - assign excita un wire
    assign msb_out = data_out[WIDTH-1];

    // Salida secuencial - always excita 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

Ese único módulo tiene:

• Un parámetro (WIDTH).
• Entradas para reloj, reset, habilitación de carga, data y habilitación de shift.
• Una salida reg (data_out) excitada dentro de un bloque always.
• Una salida wire (msb_out) excitada por una asignación continua.
• Una declaración completa de estilo ANSI que lista la dirección, el tipo y el ancho de cada puerto en línea.

Así es como está estructurado casi cada módulo sintetizable que vas a escribir.

Qué viene a continuación

El siguiente doc - Module Instantiation - muestra cómo coger este módulo y usarlo dentro de un diseño más grande. El shifter que acabas de escribir no es útil por sí solo; se gana su sitio cuando algo lo instancia y lo cablea en un sistema.