Mots-clés : module, port, port bidirectionnel, PAD
La modélisation structurelle comporte 3 types d'instructions de description : les instructions d'instanciation de porte (au niveau porte), les instructions d'instanciation UDP (User Defined Primitive), et les instructions d'instanciation de module. Cette section traite principalement des instructions d'instanciation au niveau module, les plus largement utilisées.
Module
Un module est la forme de définition d'une unité de base en Verilog, et constitue l'interface d'interaction avec le monde extérieur.
Le format du module est défini comme suit :
module module_name
#(parameter_list)
(port_list) ;
Declarations_and_Statements ;
endmodule
Une définition de module doit commencer par le mot-clé `module` et se terminer par le mot-clé `endmodule`.
Le nom du module, les signaux de port, les déclarations de port et les déclarations de paramètres optionnelles, etc., apparaissent avant les instructions Verilog utilisées dans la conception (Declarations_and_Statements dans la figure).
À l'intérieur d'un module, il y a 5 parties facultatives : les déclarations de variables, les instructions de flux de données, les instructions de niveau comportemental, les instanciations de modules de bas niveau, ainsi que les tâches et fonctions, comme le montre la figure ci-dessous. L'ordre et la position de ces 5 parties sont arbitraires. Cependant, toutes les variables doivent être déclarées avant utilisation. L'emplacement spécifique des déclarations de variables n'est pas requis, mais elles doivent être placées avant utilisation.

La plupart du code de simulation précédent utilise des déclarations de module ; vous pouvez vous y référer vous-même. Nous ne donnerons pas d'exemples spécifiques ici. Lorsque les ports seront introduits ci-dessous, nous effectuerons des simulations détaillées.
Port
Un port est l'interface permettant à un module d'interagir avec le monde extérieur. Pour l'environnement extérieur, l'intérieur d'un module est invisible, et les appels au module ne peuvent se faire que par des connexions de port.
Liste des ports
La définition de module contient une liste de ports optionnelle, qui liste généralement des variables de signal sans type et sans largeur de bits dans la déclaration de module. Ci-dessous se trouve une liste de ports pour un modèle PAD :
module pad(
DIN, OEN, PULL,
DOUT, PAD);Si un module n'a aucune interaction avec l'environnement extérieur, il n'a pas besoin de déclarer une liste de ports. Par exemple, dans nos simulations précédentes, le module test dans le fichier test.sv ne déclarait pas de ports spécifiques.
module test ; //直接分号结束
...... //数据流或行为级描述
endmodule
Déclaration de port
(1) Une fois que les signaux de port sont listés dans la liste de ports, ils peuvent être déclarés dans le corps du module.
Selon la direction du port, il existe 3 types de ports : input, output et port bidirectionnel (inout).
Les types input et inout ne peuvent pas être déclarés comme type de données reg, car le type reg est utilisé pour stocker des valeurs, tandis que les ports input peuvent seulement refléter les changements des signaux externes qui leur sont connectés, et ne peuvent pas stocker les valeurs de ces signaux.
output peut être déclaré comme type de données wire ou reg.
La déclaration de port du module pad dans l'exemple ci-dessus peut être exprimée dans le corps du module comme suit :
Exemple
input DIN, OEN ;
input [1:0] PULL ; //(00,01-dispull, 11-pullup, 10-pulldown)
inout PAD ; //valeur du pad
output DOUT ; //chargement du pad lorsque le pad est configuré en entrée
// déclaration du type de données du port
wire DIN, OEN ;
wire [1:0] PULL ;
wire PAD ;
reg DOUT ;
(2) En Verilog, les ports sont implicitement déclarés comme des variables de type wire. C'est-à-dire que lorsqu'un port possède l'attribut wire, il n'est pas nécessaire de déclarer à nouveau le type du port comme wire. Cependant, lorsqu'un port possède l'attribut reg, la déclaration reg ne peut pas être omise.
La déclaration de port dans l'exemple ci-dessus peut être simplifiée comme suit :
Exemple
input DIN, OEN ;
input [1:0] PULL ;
inout PAD ;
output DOUT ;
reg DOUT ;
(3) Bien sûr, la déclaration du signal DOUT peut être combinée en une seule instruction :
output reg DOUT ;
(4) Il existe également une méthode plus concise et couramment utilisée pour déclarer des ports, qui consiste à lister les ports et leurs types au niveau de la déclaration de module. Les ports de type Reg doivent être déclarés soit dans la déclaration de module, soit dans le corps du module. Par exemple, les deux styles d'écriture suivants sont équivalents.
Exemple
input DIN, OEN ,
input [1:0] PULL ,
inout PAD ,
output reg DOUT
);
module pad(
input DIN, OEN ,
input [1:0] PULL ,
inout PAD ,
output DOUT
);
reg DOUT ;
simulation de port inout
Simulez un modèle de pad qui inclut le type de port inout. Le code complet du modèle de pad est le suivant :
Exemple
//DIN, pilote de pad lorsque le pad est configuré en sortie
//OEN, direction du pad (1-entrée, o-sortie)
input DIN, OEN ,
//fonction pull (00,01-dispull, 10-pullup, 11-pulldown)
input [1:0] PULL ,
inout PAD ,
//charge du pad lorsque le pad est configuré en entrée
output reg DOUT
);
//entrée : (n'a pas d'effet sur la logique d'entrée externe du pad), sortie : DIN->PAD
assign PAD = OEN? 'bz : DIN ;
//entrée : (PAD->DOUT)
always @(*) begin
if (OEN == 1) begin //entrée
DOUT = PAD ;
end
else begin
DOUT = 'bz ;
end
end
//utiliser une porte trois états en Verilog pour réaliser la fonction de tirage vers le haut/bas
bufif1 puller(PAD, PULL[0], PULL[1]);
endmodule
Le code du banc de test est le suivant :
Exemple
module test ;
reg DIN, OEN ;
reg [1:0] PULL ;
wire PAD ;
wire DOUT ;
reg PAD_REG ;
assign PAD = OEN ? PAD_REG : 1'bz ; //
initial begin
PAD_REG = 1'bz ; //pad sans pilotage au début
OEN = 1'b1 ; //simulation d'entrée
#0 ; PULL = 2'b10 ; //tirage vers le bas
#20 ; PULL = 2'b11 ; //tirage vers le haut
#20 ; PULL = 2'b00 ; //désactivation du tirage
#20 ; PAD_REG = 1'b0 ;
#20 ; PAD_REG = 1'b1 ;
#30 ; OEN = 1'b0 ; //simulation de sortie
DIN = 1'bz ;
#15 ; DIN = 1'b0 ;
#15 ; DIN = 1'b1 ;
end
pad u_pad(
.DIN (DIN) ,
.OEN (OEN) ,
.PULL (PULL) ,
.PAD (PAD) ,
.DOUT (DOUT)
);
initial begin
forever begin
#100;
if ($time >= 1000) $finish ;
end
end
endmodule // test
Les résultats de simulation sont les suivants :

L'analyse des résultats de simulation est la suivante :
Lorsque la direction du PAD est en entrée et qu'il n'y a pas de pilote, la fonction de tirage peut être reflétée par la valeur du PAD.
Au cours des 60ns initiales, le côté pilote PAD_REG du PAD est z, ce qui peut être considéré comme une absence de pilotage. Ainsi, au début PULL=2, tirage vers le bas, la valeur du PAD est 0 ; à 20ns, PULL=3, tirage vers le haut, la valeur du PAD est 1 ;
À 40ns, PULL=0, aucune fonction de tirage, et la valeur d'entrée du PAD est z.
Après 60ns~100ns, le côté pilote PAD_REG du PAD commence un pilotage normal. À ce moment, cela équivaut à ce que le PAD soit directement connecté à PAD_REG, donc la valeur du PAD reste cohérente avec sa valeur de pilotage.
Dans l'analyse ci-dessus, la direction du PAD est toujours en entrée, et toutes les bornes de sortie DOUT restent cohérentes avec la valeur du PAD.
Lorsque la direction du PAD est en sortie, c'est-à-dire à 120ns OEN=0, la valeur du PAD reste cohérente avec la valeur de la borne d'entrée DIN.
Téléchargement du code source
Téléchargement