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

// déclaration de type de port
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

// déclaration de type de port
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

module pad(
    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

module pad(
    //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

`timescale 1ns/1ns
 
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