Module Verilog
Un module est un bloc de code Verilog qui implémente une certaine fonctionnalité. Les modules peuvent être intégrés dans d'autres modules et un module de niveau supérieur peut communiquer avec ses modules de niveau inférieur en utilisant leurs ports d'entrée et de sortie.
Syntaxe
Un module doit être entouré de module et endmodule mots clés. Le nom du module doit être donné juste après le module mot-clé et une liste facultative de ports peuvent également être déclarés. Notez que les ports déclarés dans la liste des déclarations de port ne peuvent pas être redéclarés dans le corps du module.
module <name> ([port_list]);
// Contents of the module
endmodule
// A module can have an empty portlist
module name;
// Contents of the module
endmodule
Toutes les déclarations de variables, les instructions de flux de données, les fonctions ou les tâches et les instances de module inférieures, le cas échéant, doivent être définies dans le module et endmodule mots clés. Il peut y avoir plusieurs modules avec des noms différents dans le même fichier et peuvent être définis dans n'importe quel ordre.
Exemple
Le module dff représente une bascule D qui a trois ports d'entrée d, clk, rstn et un port de sortie q. Le contenu du module décrit comment une bascule D doit se comporter pour différentes combinaisons d'entrées. Ici, l'entrée d est toujours affectée à la sortie q sur le front positif de l'horloge si rstn est à l'état haut car il s'agit d'une réinitialisation active à l'état bas.
// 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
Schéma du matériel
Ce module sera converti dans le circuit numérique suivant lors de la synthèse.
Notez que vous ne pouvez pas avoir de code écrit en dehors d'un module !
A quoi sert un module ?
Un module représente une unité de conception qui implémente certaines caractéristiques comportementales et sera convertie en un circuit numérique lors de la synthèse. N'importe quelle combinaison d'entrées peut être donnée au module et il fournira une sortie correspondante. Cela permet au même module à réutiliser pour former des modules plus grands qui implémentent un matériel plus complexe.
Par exemple, le DFF illustré ci-dessus peut être chaîné pour former un registre à décalage.
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
Schéma du matériel
Notez que les instances dff sont connectées ensemble avec des fils comme décrit par le module Verilog RTL.
Au lieu de construire à partir de blocs plus petits pour former des blocs de conception plus grands, l'inverse peut également être fait. Considérez la décomposition d'un moteur GPU simple en composants plus petits de sorte que chacun puisse être représenté comme un module qui implémente une fonctionnalité spécifique. Le moteur GPU présenté ci-dessous peut être divisé en cinq sous-blocs différents où chacun exécute une fonctionnalité spécifique. L'unité d'interface de bus reçoit des données de l'extérieur dans la conception, qui sont traitées par une autre unité pour extraire des instructions. D'autres unités en aval traitent les données fournies par l'unité précédente.
Chaque sous-bloc peut être représenté par un module avec un certain ensemble de signaux d'entrée et de sortie pour la communication avec d'autres modules et chaque sous-bloc peut être divisé en blocs plus fins selon les besoins.
Que sont les modules de niveau supérieur ?
Un niveau supérieur module est celui qui contient tous les autres modules. Un module de niveau supérieur n'est instancié dans aucun autre module.
Par exemple, les modules de conception sont normalement instanciés dans des modules de banc d'essai de niveau supérieur afin que la simulation puisse être exécutée en fournissant un stimulus d'entrée. Mais, le testbench n'est instancié dans aucun autre module car c'est un bloc qui encapsule tout le reste et est donc le module de niveau supérieur .
Conception de niveau supérieur
Le code de conception présenté ci-dessous comporte un module de niveau supérieur appelé design. En effet, il contient tous les autres sous-modules nécessaires pour rendre la conception complète. Les sous-modules peuvent avoir plus de sous-modules imbriqués comme mod3 à l'intérieur de mod1 et mod4 à l'intérieur de mod2. Quoi qu'il en soit, tous ces éléments sont inclus dans le module de niveau supérieur lorsque mod1 et mod2 sont instanciés. Cela rend donc le design complète et est le module de niveau supérieur pour la conception.
//---------------------------------
// 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
Niveau supérieur du banc d'essai
Le module testbench contient des stimuli pour vérifier la fonctionnalité de la conception et est principalement utilisé pour la vérification fonctionnelle à l'aide d'outils de simulation. Par conséquent, la conception est instanciée et appelée d0 à l'intérieur du module testbench. Du point de vue du simulateur, testbench est le module de niveau supérieur.
//-----------------------------------------------------------
// 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
Noms hiérarchiques
Une structure hiérarchique est formée lorsque les modules peuvent être instanciés les uns dans les autres, et donc le module de niveau supérieur est appelé la racine . Étant donné que chaque instanciation de module inférieur dans un module donné doit avoir des noms d'identifiant différents, il n'y aura aucune ambiguïté dans l'accès aux signaux. Un nom hiérarchique est construit par une liste de ces identifiants séparés par des points . pour chaque niveau de la hiérarchie. N'importe quel signal est accessible dans n'importe quel module en utilisant le chemin hiérarchique vers ce signal particulier.
// 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
Verilog