Verilog-poorten

Poorten zijn een reeks signalen die fungeren als in- en uitgangen voor een bepaalde module en zijn de primaire manier om ermee te communiceren. Beschouw een module als een gefabriceerde chip die op een PCB is geplaatst en het wordt vrij duidelijk dat de enige manier om met de chip te communiceren via de pinnen is. Poorten zijn als pinnen en worden door het ontwerp gebruikt om signalen van de buitenwereld te verzenden en te ontvangen.

Typen poorten

Poorten worden standaard beschouwd als netten van het type wire .

Syntaxis

Poorten gedeclareerd als inout kan zowel als invoer als uitvoer fungeren.

  
  
	input  [net_type] [range] list_of_names; 	// Input port
	inout  [net_type] [range] list_of_names; 	// Input & Output port
	output [net_type] [range] list_of_names; 	// Output port driven by a wire
	output [var_type] [range] list_of_names; 	// Output port driven by a variable

  

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 );
                    
	// Design behavior as Verilog code
	
endmodule

  

Het is illegaal om dezelfde naam te gebruiken voor meerdere poorten.

  
  
	input  aport;         // First declaration - valid
	input  aport;         // Error - already declared
	output aport;         // Error - already declared

  

Ondertekende poorten

De signed attribuut kan worden gekoppeld aan een poortdeclaratie of een net/reg-declaratie of beide. Impliciete netten zijn standaard ongetekend .

  
  
module ( input      a, 
                    b,
         output     c);
		 
	// ports a, b, and c are by default unsigned
endmodule

  

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

  
  
	module ( input signed a, b,
	         output c);
		wire a, b;          // a, b are signed from port declaration
		reg signed c;       // c is signed from reg declaration
	endmodule

  

Poortvariaties

Verilog 1995

Verilog heeft een paar revisies ondergaan en de originele IEEE-versie in 1995 had de volgende manier voor poortdeclaratie. Hier moest de moduleverklaring eerst de namen van poorten tussen haakjes vermelden en vervolgens de richting van die poorten die later in de hoofdtekst van de module werden gedefinieerd.

  
  	
module test (a, b, c);
	
	input 	[7:0] a;            // inputs "a" and "b" are wires
	input 	[7:0] b;  
	output 	[7:0] c; 			// output "c" by default is a wire
	
	// Still, you can declare them again as wires to avoid confusion
	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;           // By default c is of type wire
	
	// port "c" is changed to a reg type
	reg    [7:0] c;           
endmodule
  

Verilog vanaf 2001

Poortnaamgeving in ANSI-C-stijl werd in 2001 geïntroduceerd en maakte het mogelijk om het type in de poortlijst te specificeren.

  
  
module test ( input [7:0]	a,
                            b, 		// "b" is considered an 8-bit input
              output [7:0]  c);
			  
	// Design content			  
endmodule

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

  

Als een poortdeclaratie een net- of variabel type bevat, wordt die poort als volledig gedeclareerd beschouwd. Het is illegaal om dezelfde poort opnieuw te declareren in een declaratie van het net of variabele type.

  
  
module test ( input      [7:0] a,       // a, e are implicitly declared of type wire
	          output reg [7:0] e );

   wire signed [7:0] a;     // illegal - declaration of a is already complete -> simulator dependent
   wire        [7:0] e;     // illegal - declaration of e is already complete
   
   // Rest of the design code
endmodule

  

Als de poortdeclaratie geen net- of variabel type bevat, kan de poort opnieuw worden gedeclareerd in een net- of variabele typedeclaratie.

  
  
module test ( input      [7:0] a,
              output     [7:0] e);
	              
     reg [7:0] e;              // Okay - net_type was not declared before
     
     // Rest of the design code
endmodule