Puertos de entrada y salida

Parte de la sección Fundamentos del Journey de Verilog de Coddy — lección 31 de 90.

Los puertos de entrada y salida son las conexiones que permiten que un módulo se comunique con el mundo exterior. Son como los pines de un chip. Los puertos son la interfaz entre un módulo y el resto del diseño.

Cada módulo tiene:

Puertos de entrada — señales que entran al módulo
Puertos de salida — señales que salen del módulo

Puertos de entrada

Los puertos de entrada reciben datos desde el exterior. No se pueden cambiar dentro del módulo, solo leer.

input clk;        // Entrada de un solo bit
input [7:0] data; // Vector de entrada de 8 bits
input a, b;       // Múltiples entradas en una sola línea

Reglas para las entradas:

No se les puede asignar un valor dentro del módulo
No se pueden declarar como reg
Siempre son wire (por defecto)

Puertos de salida

Los puertos de salida envían datos al exterior. Pueden ser controlados por bloques assign o always.

output out;           // Salida de un solo bit
output [3:0] result;  // Salida de 4 bits
output reg busy;      // La salida puede ser reg
output wire ready;    // La salida puede ser wire

Reglas para las salidas:

Pueden ser wire (con assign) o reg (con always)
Deben ser controladas por algo dentro del módulo

Sintaxis de declaración de puertos

La sintaxis de declaración de puertos es la forma específica en que se escriben los puertos de entrada y salida en un módulo. Le indica a Verilog tres cosas sobre cada puerto:

Dirección — ¿es de entrada, salida o inout?
Tamaño — ¿cuántos bits de ancho tiene?
Nombre — ¿cómo se llama?

module example (
  input [7:0] data_in,    // Vector de entrada
  input clk,              // Entrada única
  input enable,           // Entrada única
  output reg [7:0] out,   // Registro de salida
  output busy             // Cable de salida
);

Por qué importa la dirección del puerto

La dirección le indica a Verilog:

Qué señales puede leer el módulo (entradas)
Qué señales puede escribir el módulo (salidas)
Qué tipos de conexiones están permitidas

El uso de la dirección incorrecta provoca errores de compilación.

Ejemplo de código

module port_demo (
  input [3:0] a,        // Solo lectura
  input [3:0] b,        // Solo lectura
  output reg [3:0] sum, // Puede escribir (reg)
  output [3:0] diff     // Puede escribir (wire)
);
  always @(*) begin
    sum = a + b;        // Escribiendo en output reg
  end
  
  assign diff = a - b;   // Escribiendo en output wire
endmodule

Desafío

Completa las declaraciones de puertos

Qué hacer:

Añade una entrada de 8 bits llamada data_in
Añade una entrada de un solo bit llamada clk
Añade una salida de 4 bits llamada result (usa reg — se asignará en un bloque always)
Añade una salida de un solo bit llamada valid (usa wire — se asignará con assign)

Hoja de referencia

Los puertos son la interfaz entre un módulo y el mundo exterior.

Puertos de Entrada

Las entradas son siempre wire, de solo lectura dentro del módulo:

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

Puertos de Salida

Las salidas pueden ser wire (controladas por assign) o reg (controladas por always):

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

Declaración de Puertos en la Cabecera del Módulo

Cada declaración de puerto especifica la dirección, el tamaño y el nombre:

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

Pruébalo tú mismo

module port_challenge (
  // Tarea 1: Añadir una entrada de 8 bits llamada data_in
  
  
  // Tarea 2: Añadir una entrada de un solo bit llamada clk
  
  
  // Tarea 3: Añadir una salida de 4 bits llamada result (usar reg)
  
  
  // Tarea 4: Añadir una salida de un solo bit llamada valid (usar wire)
  
  
);

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