Portas de Entrada e Saída

Parte da seção Fundamentos do Journey de Verilog da Coddy — lição 31 de 90.

Portas de entrada e saída são as conexões que permitem que um módulo se comunique com o mundo exterior. Elas são como os pinos em um chip. As portas são a interface entre um módulo e o restante do projeto.

Todo módulo possui:

Portas de entrada — sinais que entram no módulo
Portas de saída — sinais que saem do módulo

Portas de Entrada

As portas de entrada recebem dados do exterior. Elas não podem ser alteradas dentro do módulo — apenas lidas.

input clk;        // Entrada de bit único
input [7:0] data; // Vetor de entrada de 8 bits
input a, b;       // Múltiplas entradas em uma linha

Regras para entradas (inputs):

Não podem receber a atribuição de um valor dentro do módulo
Não podem ser declaradas como reg
Sempre são wire (por padrão)

Portas de Saída

Portas de saída enviam dados para o exterior. Elas podem ser acionadas por blocos assign ou always.

output out;           // Saída de bit único
output [3:0] result;  // Saída de 4 bits
output reg busy;      // A saída pode ser reg
output wire ready;    // A saída pode ser wire

Regras para saídas:

Podem ser wire (com assign) ou reg (com always)
Devem ser acionadas por algo dentro do módulo

Sintaxe de Declaração de Portas

A sintaxe de declaração de portas é a maneira específica como você escreve as portas de entrada e saída em um módulo. Ela informa ao Verilog três coisas sobre cada porta:

Direção — é input, output ou inout?
Tamanho — qual é a sua largura em bits?
Nome — como ele é chamado?

module example (
  input [7:0] data_in,    // Vetor de entrada
  input clk,              // Entrada única
  input enable,           // Entrada única
  output reg [7:0] out,   // Saída reg
  output busy             // Saída wire
);

Por que a Direção da Porta é Importante

A direção informa ao Verilog:

Quais sinais o módulo pode ler (entradas)
Quais sinais o módulo pode escrever (saídas)
Quais tipos de conexões são permitidos

Usar a direção errada causa erros de compilação.

Exemplo de Código

module port_demo (
  input [3:0] a,        // Pode apenas ler
  input [3:0] b,        // Pode apenas ler
  output reg [3:0] sum, // Pode escrever (reg)
  output [3:0] diff     // Pode escrever (wire)
);
  always @(*) begin
    sum = a + b;        // Escrevendo no reg de saída
  end
  
  assign diff = a - b;   // Escrevendo no wire de saída
endmodule

Desafio

Complete as Declarações de Portas

O que fazer:

Adicione uma entrada de 8 bits chamada data_in
Adicione uma entrada de bit único chamada clk
Adicione uma saída de 4 bits chamada result (use reg — será atribuída em um bloco always)
Adicione uma saída de bit único chamada valid (use wire — será atribuída com assign)

Folha de consulta

Portas são a interface entre um módulo e o mundo exterior.

Portas de Entrada (Input)

Entradas são sempre wire, somente leitura dentro do módulo:

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

Portas de Saída (Output)

Saídas podem ser wire (acionadas por assign) ou reg (acionadas por always):

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

Declaração de Portas no Cabeçalho do Módulo

Cada declaração de porta especifica a direção, o tamanho e o nome:

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

Experimente você mesmo

module port_challenge (
  // Tarefa 1: Adicione uma entrada de 8 bits chamada data_in
  
  
  // Tarefa 2: Adicione uma entrada de um único bit chamada clk
  
  
  // Tarefa 3: Adicione uma saída de 4 bits chamada result (use reg)
  
  
  // Tarefa 4: Adicione uma saída de um único bit chamada valid (use wire)
  
  
);

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