Verilog-module

Een module is een blok Verilog-code dat een bepaalde functionaliteit implementeert. Modules kunnen worden ingebed in andere modules en een module op een hoger niveau kan communiceren met de modules op een lager niveau met behulp van hun invoer- en uitvoerpoorten.

Syntaxis

Een module moet worden ingesloten tussen module en endmodule trefwoorden. De naam van de module moet direct na de module . worden gegeven trefwoord en een optionele lijst met poorten kunnen ook worden gedeclareerd. Houd er rekening mee dat poorten die in de lijst met poortdeclaraties zijn gedeclareerd, niet opnieuw kunnen worden aangegeven in de hoofdtekst van de module.

  
  
	module <name> ([port_list]);
		// Contents of the module
	endmodule
	
	// A module can have an empty portlist
	module name;
		// Contents of the module
	endmodule

  

Alle variabele declaraties, dataflow-statements, functies of taken en eventuele lagere module-instanties moeten worden gedefinieerd binnen de module en endmodule trefwoorden. Er kunnen meerdere modules met verschillende namen in hetzelfde bestand zijn en ze kunnen in elke volgorde worden gedefinieerd.

Voorbeeld

De module dff vertegenwoordigt een D-flip-flop die drie ingangspoorten d, clk, rstn en één uitgangspoort q heeft. De inhoud van de module beschrijft hoe een D-flip-flop zich moet gedragen voor verschillende combinaties van ingangen. Hier wordt ingang d altijd toegewezen aan uitgang q op de positieve flank van de klok als rstn hoog is omdat het een actieve lage reset is.

  
  
// Module called "dff" has 3 inputs and 1 output port
module dff ( 	input 			d,
							input 			clk,
							input 			rstn,
							output reg	q);
			
	// Contents of the module	
	always @ (posedge clk) begin
		if (!rstn)
			q <= 0;
		else 
			q <= d;
	end
endmodule

  

Hardwareschema

Deze module wordt tijdens de synthese omgezet in het volgende digitale circuit.

Merk op dat u geen code buiten een module kunt laten schrijven!

Wat is het doel van een module?

Een module vertegenwoordigt een ontwerpeenheid die bepaalde gedragskenmerken implementeert en tijdens de synthese wordt omgezet in een digitaal circuit. Elke combinatie van ingangen kan aan de module worden gegeven en deze zal een overeenkomstige uitgang leveren. Hierdoor kan dezelfde module te hergebruiken om grotere modules te vormen die complexere hardware implementeren.

De hierboven getoonde DFF kan bijvoorbeeld worden geketend om een ​​schuifregister te vormen.

  
  
module shift_reg ( 	input 	d,
										input  	clk,
										input 	rstn,
										output 	q);
			
	wire [2:0] q_net;
	dff u0 (.d(d), 				.clk(clk), .rstn(rstn), .q(q_net[0]));
	dff u1 (.d(q_net[0]), .clk(clk), .rstn(rstn), .q(q_net[1]));
	dff u2 (.d(q_net[1]), .clk(clk), .rstn(rstn), .q(q_net[2]));
	dff u3 (.d(q_net[2]), .clk(clk), .rstn(rstn), .q(q));
	
endmodule

  

Hardwareschema

Merk op dat de dff-instanties met draden zijn verbonden zoals beschreven door de Verilog RTL-module.

In plaats van uit kleinere blokken op te bouwen tot grotere ontwerpblokken, kan ook het omgekeerde worden gedaan. Overweeg de opsplitsing van een eenvoudige GPU-engine in kleinere componenten, zodat elk kan worden weergegeven als een module die een specifieke functie implementeert. De hieronder getoonde GPU-engine kan worden onderverdeeld in vijf verschillende subblokken waarin elk een specifieke functionaliteit uitvoert. De businterface-eenheid krijgt gegevens van buiten in het ontwerp, die door een andere eenheid worden verwerkt om instructies te extraheren. Andere eenheden verwerken later gegevens die door de vorige eenheid zijn verstrekt.

Elk subblok kan worden weergegeven als een module met een bepaalde set ingangs- en uitgangssignalen voor communicatie met andere modules en elk subblok kan indien nodig verder worden onderverdeeld in fijnere blokken.

Wat zijn modules op het hoogste niveau?

Een topniveau module is er een die bevat alle andere modules. Een module op het hoogste niveau wordt niet geïnstantieerd binnen een andere module.

Ontwerpmodules worden bijvoorbeeld normaal gesproken geïnstantieerd in testbankmodules op het hoogste niveau, zodat simulatie kan worden uitgevoerd door een invoerstimulus te bieden. Maar de testbench wordt niet geïnstantieerd in een andere module, omdat het een blok is dat al het andere inkapselt en daarom de module op het hoogste niveau is. .

Ontwerp op topniveau

De onderstaande ontwerpcode heeft een module op het hoogste niveau genaamd design. Dit komt omdat het alle andere submodules bevat die nodig zijn om het ontwerp compleet te maken. De submodules kunnen meer geneste submodules hebben, zoals mod3 in mod1 en mod4 in mod2. Hoe dan ook, al deze zijn opgenomen in de module op het hoogste niveau wanneer mod1 en mod2 worden geïnstantieerd. Dus dit maakt het ontwerp compleet en is de module op het hoogste niveau voor het ontwerp.

  
  
	//---------------------------------
	//  Design code
	//---------------------------------
	module mod3 ( [port_list] );
		reg c;
		// Design code
	endmodule
	
	module mod4 ( [port_list] );
		wire a;
		// Design code
	endmodule
	
	module mod1 ( [port_list] );	 	// This module called "mod1" contains two instances
		wire 	y;
	
		mod3 	mod_inst1 ( ... ); 	 		// First instance is of module called "mod3" with name "mod_inst1"
		mod3 	mod_inst2 ( ... );	 		// Second instance is also of module "mod3" with name "mod_inst2"
	endmodule

	module mod2 ( [port_list] ); 		// This module called "mod2" contains two instances
		mod4 	mod_inst1 ( ... );			// First instance is of module called "mod4" with name "mod_inst1"
		mod4 	mod_inst2 ( ... );			// Second instance is also of module "mod4" with name "mod_inst2"
	endmodule
	
	// Top-level module
	module design ( [port_list]); 		// From design perspective, this is the top-level module
		wire 	_net;
		mod1 	mod_inst1 	( ... ); 			// since it contains all other modules and sub-modules
		mod2 	mod_inst2 	( ... );
	endmodule

  

Testbank topniveau

De testbench-module bevat een stimulans om de functionaliteit van het ontwerp te controleren en wordt voornamelijk gebruikt voor functionele verificatie met behulp van simulatietools. Daarom wordt het ontwerp geïnstantieerd en d0 genoemd in de testbench-module. Vanuit een simulatorperspectief is testbench de module op het hoogste niveau.

  
  
	//-----------------------------------------------------------
	// Testbench code
	// From simulation perspective, this is the top-level module
	// because 'design' is instantiated within this module
	//-----------------------------------------------------------
	module testbench; 												
		design d0 ( [port_list_connections] ); 	
		
		// Rest of the testbench code
	endmodule

  

Hiërarchische namen

Een hiërarchische structuur wordt gevormd wanneer modules in elkaar kunnen worden geïnstantieerd, en daarom wordt de module op het hoogste niveau de root genoemd. . Aangezien elke lagere module-instanties binnen een bepaalde module verschillende identificatienamen moeten hebben, zal er geen dubbelzinnigheid zijn bij het benaderen van signalen. Een hiërarchische naam wordt opgebouwd door een lijst van deze identifiers gescheiden door punten . voor elk niveau van de hiërarchie. Elk signaal is toegankelijk binnen elke module via het hiërarchische pad naar dat specifieke signaal.

  
  
	// Take the example shown above in top level modules
	design.mod_inst1 					// Access to module instance mod_inst1
	design.mod_inst1.y 					// Access signal "y" inside mod_inst1
	design.mod_inst2.mod_inst2.a		// Access signal "a" within mod4 module
	
	testbench.d0._net; 					// Top level signal _net within design module accessed from testbench