Verilog-poorten begrijpen: Invoer, uitvoer en modulecommunicatie

Poorten zijn een set signalen die als in- en uitgangen fungeren voor een module en de primaire manier zijn om met het ontwerp te communiceren. Stel je een module voor als een gefabriceerde chip op een PCB; het wordt duidelijk dat de enigste manier om met de chip te communiceren via zijn pinnen is. Poorten zijn als pinnen en worden gebruikt om signalen van en naar de buitenwereld te sturen en ontvangen.

Poorttypen

Poorten worden standaard beschouwd als nets van type wire.

Syntaxis

Poorten gedeclareerd als inout kunnen zowel als input als output fungeren.

input [net_type] [bereik] lijst_van_namen; // Invoerpoort
inout [net_type] [bereik] lijst_van_namen; // In- & uitvoerpoort
output [net_type] [bereik] lijst_van_namen; // Uitvoerpoort gedreven door wire
output [var_type] [bereik] lijst_van_namen; // Uitvoerpoort gedreven door variabele

Voorbeeld

In de onderstaande code zijn er drie input poorten, één output poort en één inout poort.

module my_design (
    input wire clk,
    input en,
    input rw,
    inout [15:0] data,
    output int );
// Ontwerpgedrag als Verilog-code
endmodule

Het is illegaal dezelfde naam voor meerdere poorten te gebruiken.

input aport; // Eerste declaratie - geldig
input aport; // Fout - al gedeclareerd
output aport; // Fout - al gedeclareerd

Gesigneerde poorten

Het signed attribuut kan aan een poortdeclaratie of net/reg-declaratie of beide gekoppeld worden. Impliciete nets zijn standaard unsigned.

module ( input a, b, output c); // poorten a, b, c zijn standaard unsigned
endmodule

Als ofwel de net/reg-declaratie een signed attribuut heeft, dan wordt de andere ook als signed beschouwd.

module ( input signed a, b, output c);
wire a, b; // a, b zijn signed via poortdeclaratie
reg signed c; // c is signed via reg-declaratie
endmodule

Poortvariaties

Verilog 1995

De originele IEEE-versie van 1995 had de volgende manier voor poortdeclaratie. De module-declaratie moest eerst de namen van poorten binnen haakjes lijsten en daarna de richting binnen de module-body definiëren.

module test (a, b, c);
input [7:0] a; // inputs "a" en "b" zijn wires
input [7:0] b;
output [7:0] c; // output "c" is standaard wire
// Nog steeds kun je ze opnieuw als wires declareren om verwarring te voorkomen
wire [7:0] a; wire [7:0] b; wire [7:0] c;
endmodule
module test (a, b, c);
input [7:0] a, b;
output [7:0] c;
reg [7:0] c; // poort "c" gewijzigd naar reg-type
endmodule

Verilog 2001 en later

ANSI-C stijl poortnaamgeving werd in 2001 geïntroduceerd en liet het type toe in de poortlijst.

module test ( input [7:0] a, b, output [7:0] c);
// Ontwerpinnhoud
endmodule
module test ( input wire [7:0] a, input wire [7:0] b, output reg [7:0] c);
// Ontwerpinnhoud
endmodule

Als een poortdeclaratie een net- of variabeltype bevat, dan wordt die poort als volledig gedeclareerd beschouwd. Het is illegaal de poort opnieuw te declareren in een net- of variabeltypedeclaratie.

module test ( input [7:0] a, output reg [7:0] e );
wire signed [7:0] a; // illegaal - declaratie van a al compleet -> simulator-afhankelijk
wire [7:0] e; // illegaal - declaratie van e al compleet
// Rest van ontwerpcode
endmodule

Als de poortdeclaratie geen net- of variabeltype bevat, kan de poort in een net- of variabeltypedeclaratie opnieuw gedeclareerd worden.

module test ( input [7:0] a, output [7:0] e);
reg [7:0] e; // OK - net_type was niet eerder gedeclareerd
// Rest van ontwerpcode
endmodule