Verilog-Modul

Ein module ist ein Block von Verilog-Code, der eine bestimmte Funktionalität implementiert. Module können in andere Module eingebettet werden und ein Modul höherer Ebene kann mit seinen Modulen niedrigerer Ebene über deren Eingangs- und Ausgangsports kommunizieren.

Syntax

Ein Modul sollte in module eingeschlossen werden und endmodule Schlüsselwörter. Der Name des Moduls sollte direkt nach module angegeben werden Schlüsselwort und eine optionale Liste von Ports können ebenfalls deklariert werden. Beachten Sie, dass Ports, die in der Liste der Port-Deklarationen deklariert sind, nicht innerhalb des Hauptteils des Moduls neu deklariert werden können.

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

  

Alle Variablendeklarationen, Datenflussanweisungen, Funktionen oder Tasks und ggf. niedrigere Modulinstanzen müssen innerhalb von module definiert werden und endmodule Schlüsselwörter. Es können mehrere Module mit unterschiedlichen Namen in derselben Datei vorhanden sein und können in beliebiger Reihenfolge definiert werden.

Beispiel

Das Modul dff stellt ein D-Flip-Flop dar, das drei Eingangsports d, clk, rstn und einen Ausgangsport q hat. Der Inhalt des Moduls beschreibt, wie sich ein D-Flip-Flop bei verschiedenen Kombinationen von Eingängen verhalten soll. Hier wird Eingang d bei positiver Taktflanke immer dem Ausgang q zugewiesen, wenn rstn hoch ist, da es sich um einen aktiven Low-Reset handelt.

  
  
// 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

  

Hardware-Schema

Dieses Modul wird während der Synthese in die folgende digitale Schaltung umgewandelt.

Beachten Sie, dass außerhalb eines Moduls kein Code geschrieben werden kann !

Was ist der Zweck eines Moduls?

Ein Modul stellt eine Designeinheit dar, die bestimmte Verhaltenseigenschaften implementiert und während der Synthese in eine digitale Schaltung umgewandelt wird. Dem Modul kann eine beliebige Kombination von Eingaben gegeben werden, und es wird eine entsprechende Ausgabe liefern. Dies ermöglicht dasselbe Modul wiederverwendet werden, um größere Module zu bilden, die komplexere Hardware implementieren.

Beispielsweise kann das oben gezeigte DFF zu einem Schieberegister verkettet werden.

  
  
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

  

Hardware-Schema

Beachten Sie, dass die dff-Instanzen wie vom Verilog-RTL-Modul beschrieben durch Drähte miteinander verbunden sind.

Anstatt aus kleineren Blöcken zu größeren Designblöcken aufzubauen, kann man auch umgekehrt vorgehen. Betrachten Sie die Aufteilung einer einfachen GPU-Engine in kleinere Komponenten, sodass jede als Modul dargestellt werden kann, das eine bestimmte Funktion implementiert. Die unten gezeigte GPU-Engine kann in fünf verschiedene Unterblöcke unterteilt werden, von denen jeder eine bestimmte Funktionalität ausführt. Die Busschnittstelleneinheit erhält Daten von außen in das Design, die von einer anderen Einheit verarbeitet werden, um Anweisungen zu extrahieren. Andere Einheiten in der Reihe verarbeiten Daten, die von der vorherigen Einheit bereitgestellt wurden.

Jeder Unterblock kann als module dargestellt werden mit einem bestimmten Satz von Eingangs- und Ausgangssignalen für die Kommunikation mit anderen Modulen und jeder Unterblock kann nach Bedarf weiter in feinere Blöcke unterteilt werden.

Was sind Top-Level-Module?

Ein Top-Level Modul ist eines, das enthält alle anderen Module. Ein Top-Level-Modul wird nicht innerhalb eines anderen Moduls instanziiert.

Zum Beispiel werden Designmodule normalerweise innerhalb von Testbench-Modulen der obersten Ebene instanziiert, so dass die Simulation ausgeführt werden kann, indem ein Eingabestimulus bereitgestellt wird. Die Testbench wird jedoch nicht in einem anderen Modul instanziiert, da es sich um einen Block handelt, der alles andere kapselt und daher das Modul der obersten Ebene ist .

Design auf höchstem Niveau

Der unten gezeigte Designcode hat ein Top-Level-Modul namens design. Dies liegt daran, dass es alle anderen Untermodule enthält, die erforderlich sind, um das Design zu vervollständigen. Die Submodule können mehr verschachtelte Submodule haben, wie mod3 in mod1 und mod4 in mod2. Wie auch immer, all diese werden in das Modul der obersten Ebene aufgenommen, wenn mod1 und mod2 instanziiert werden. Das macht also das Design vollständig und ist das Top-Level-Modul für das Design.

  
  
	//---------------------------------
	//  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

  

Testbench oberste Ebene

Das Testbench-Modul enthält Anregungen zur Überprüfung der Funktionalität des Designs und dient primär der funktionalen Verifikation mit Simulationswerkzeugen. Daher wird das Design innerhalb des Testbench-Moduls instanziiert und als d0 bezeichnet. Aus Sicht des Simulators ist die Testbench das oberste Modul.

  
  
	//-----------------------------------------------------------
	// 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

  

Hierarchische Namen

Eine hierarchische Struktur wird gebildet, wenn Module ineinander instanziiert werden können, und daher wird das Modul der obersten Ebene als Wurzel bezeichnet . Da jede Instanziierung eines niedrigeren Moduls innerhalb eines gegebenen Moduls unterschiedliche Kennungsnamen haben muss, gibt es keine Mehrdeutigkeit beim Zugreifen auf Signale. Ein hierarchischer Name wird durch eine Liste dieser Bezeichner gebildet, die durch Punkte . getrennt sind für jede Hierarchieebene. Auf jedes Signal kann in jedem Modul zugegriffen werden, indem der hierarchische Pfad zu diesem bestimmten Signal verwendet wird.

  
  
	// 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