Bases des modules Verilog : Structure et syntaxe

Un module est un bloc de code Verilog implémentant une certaine fonctionnalité. Les modules peuvent être imbriqués ; un module de niveau supérieur communique avec ses sous-modules via leurs ports d'entrée/sortie.

Syntaxe

Un module doit être encadré par module et endmodule. Le nom suit module, liste de ports optionnelle. Les ports déclarés dans la liste ne peuvent être redéclarés dans le corps.

module  ([port_list]);
// Contenu du module
endmodule

// Module avec liste de ports vide
module name;
// Contenu
endmodule

Toutes déclarations de variables, instructions de flux de données, fonctions, tâches et instances de modules inférieurs doivent être dans module ... endmodule. Plusieurs modules différents peuvent être dans le même fichier, ordre quelconque.

Exemple

Le module dff représente une bascule D avec 3 entrées (d, clk, rstn) et 1 sortie (q). Le contenu décrit le comportement pour différentes combinaisons d'entrées. L'entrée d est assignée à la sortie q au front montant de clk si rstn est haut (reset actif bas).

// Module "dff" avec 3 entrées et 1 sortie
module dff (input d, input clk, input rstn, output reg q);
always @ (posedge clk) begin
    if (!rstn) q <= 0;
    else q <= d;
end
endmodule

Schéma matériel

Ce module sera converti en circuit numérique suivant pendant la synthèse.

Note : Vous ne pouvez pas avoir de code en dehors d'un module !

Quel est le but d'un module ?

Un module représente une unité de conception implémentant des caractéristiques comportementales, convertie en circuit numérique lors de la synthèse. Toute combinaison d'entrées produit une sortie correspondante, permettant la réutilisation pour former des modules plus grands et complexes.

Exemple : la bascule D ci-dessus peut être chainée 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 matériel

Les instances dff sont connectées par des fils comme décrit par le module RTL Verilog.

L'inverse est aussi possible : décomposer un moteur GPU simple en sous-blocs plus petits, chacun représenté comme module avec entrées/sorties pour communication. Le GPU peut être divisé en 5 sous-blocs avec fonctionnalités spécifiques. L'interface bus récupère données externes, une autre unité extrait instructions, etc.

Chaque sous-bloc = module avec ensemble de signaux d'entrée/sortie pour communiquer, et peut être divisé en blocs plus fins.

Qu'est-ce qu'un module de niveau supérieur (top-level) ?

Un module top-level contient tous les autres modules. Il n'est instancié dans aucun autre module.

Exemple : modules de conception instanciés dans un module testbench pour simulation. Le testbench n'est instancié nulle part, il encapsule tout -> top-level module.

Top-level de conception

Le code ci-dessous a un module top-level "design" car il contient tous les sous-modules requis. Les sous-modules peuvent avoir des sous-sous-modules imbriqués (mod3 dans mod1, mod4 dans mod2). Tous sont inclus dans le top-level quand mod1 et mod2 sont instanciés.

//---------------------------------
// Code de conception
//---------------------------------
module mod3 ( [port_list] ); reg c; // Code conception endmodule
module mod4 ( [port_list] ); wire a; // Code conception endmodule
module mod1 ( [port_list] );
wire y;
mod3 mod_inst1 ( ... ); // Instance de mod3 nommée mod_inst1
mod3 mod_inst2 ( ... ); // Deuxième instance de mod3 nommée mod_inst2
endmodule
module mod2 ( [port_list] );
mod4 mod_inst1 ( ... );
mod4 mod_inst2 ( ... );
endmodule
// Module top-level
module design ( [port_list]);
wire _net;
mod1 mod_inst1 ( ... ); // Contient tous modules/sous-modules
mod2 mod_inst2 ( ... );
endmodule

Top-level de testbench

Le module testbench contient stimulus pour vérifier la fonctionnalité de la conception, utilisé pour vérification fonctionnelle via outils de simulation. La conception est instanciée et appelée d0 dans le testbench. Du point de vue simulateur, testbench est le module top-level.

//-----------------------------------------------------------
// Code testbench
// Du point de vue simulation, c'est le top-level module
// car 'design' est instancié dans ce module
//-----------------------------------------------------------
module testbench;
design d0 ( [port_list_connections] );
// Reste du code testbench
endmodule

Noms hiérarchiques

Structure hiérarchique quand modules instanciés les uns dans les autres ; top-level = racine. Chaque instanciation de module inférieur dans un module donné doit avoir des noms d'identificateur différents, donc pas d'ambiguïté pour accéder aux signaux. Un nom hiérarchique est construit par liste d'identificateurs séparés par points . pour chaque niveau. Tout signal accessible dans n'importe quel module via le chemin hiérarchique.

// Exemple ci-dessus top-level modules
design.mod_inst1              // Accès instance mod_inst1
design.mod_inst1.y            // Accès signal "y" dans mod_inst1
design.mod_inst2.mod_inst2.a  // Accès signal "a" dans module mod4
testbench.d0._net;            // Signal top-level _net dans design accédé depuis testbench