Maîtriser la syntaxe Verilog : Règles clés et bonnes pratiques

Les conventions lexicales en Verilog sont similaires au C : un flux de tokens. Un token lexical peut comprendre un ou plusieurs caractères et peut être commentaires, mots-clés, nombres, chaînes ou espaces blancs. Toutes les lignes doivent se terminer par un point-virgule ;.

Verilog est sensible à la casse, donc var_a et var_A sont différents.

Commentaires

Deux façons d'écrire des commentaires en Verilog :

1. Commentaire sur une ligne commençant par // : tout ce qui suit jusqu'à la fin de la ligne est un commentaire.
2. Commentaire multi-lignes commençant par /* et finissant par */, ne peut pas être imbriqué.

Cependant, les commentaires sur une ligne peuvent être imbriqués dans un commentaire multi-lignes.

// Ceci est un commentaire sur une ligne
integer a; // Crée une variable int a, et traite tout à droite de // comme commentaire
/* Ceci est un commentaire multi-lignes ou bloc */
/* Ceci est /* un commentaire bloc imbriqué invalide */ */
/* Cependant, // celui-ci est okay */
// Ceci est aussi okay
///////////// Toujours okay

Espaces blancs

Les espaces blancs représentent espaces, tabulations, retours à la ligne et sauts de page, généralement ignorés par Verilog sauf quand ils séparent des tokens. Cela aide l'indentation pour la lisibilité.

module dut; // 'module' est un mot-clé, 'dut' un identifiant
reg [8*6:1] name = "Hello!"; // Les 2 espaces au début sont ignorés

Cependant, les espaces et tabulations ne sont pas ignorés dans les chaînes. Dans l'exemple ci-dessous, la variable string addr reçoit la valeur "Earth " à cause de la préservation des espaces.

// Pas d'espace au début de cette ligne, mais il y en a un dans la chaîne
reg [8*6:1] addr = "Earth ";
endmodule

Opérateurs

Trois types d'opérateurs : unaire, binaire, et ternaire ou conditionnel.

• Opérateurs unaires apparaissent à gauche de leur opérande
• Opérateurs binaires apparaissent entre leurs opérandes
• Opérateurs conditionnels ont deux opérateurs séparant trois opérandes

x = ~y; // ~ est un opérateur unaire, y est l'opérande
x = y | z; // | est un opérateur binaire, y et z sont ses opérandes
x = (y > 5) ? w : z; // ?: est un opérateur ternaire, (y>5), w et z sont ses opérandes

Si l'expression (y > 5) est vraie, x prend la valeur de w, sinon celle de z.

Format des nombres

Nous connaissons la représentation décimale. Mais les nombres peuvent être en binaire, octal et hexadécimal. Par défaut, les simulateurs Verilog traitent les nombres comme décimaux. Pour une autre base, certaines règles s'appliquent.

16     // Nombre 16 en décimal
0x10   // Nombre 16 en hexadécimal
10000  // Nombre 16 en binaire
20     // Nombre 16 en octal

Nombres dimensionnés (Sized)

Les nombres dimensionnés sont représentés comme suit, où size est écrit en décimal pour spécifier le nombre de bits :

[size]'[base_format][number]

• base_format : décimal ('d ou 'D), hexadécimal ('h ou 'H), octal ('o ou 'O), binaire ('b ou 'B).
• number : chiffres consécutifs selon la base.

3'b010;      // taille 3, base binaire, nombre 010 (valeur 2)
3'd2;        // taille 3, base décimale, nombre 2
8'h70;       // taille 8, base hexa, nombre 0x70 (décimal 112)
9'h1FA;      // taille 9, base hexa, nombre 0x1FA (décimal 506)
4'hA = 4'd10 = 4'b1010 = 4'o12 // Décimal 10 en quatre formats
8'd234 = 8'D234 // Majuscules/minuscules acceptées pour base_format
32'hFACE_47B2; // Underscore (_) pour séparer groupes de 16 bits pour lisibilité

Les lettres majuscules sont légales pour la spécification des nombres en base hexadécimale.

16'hcafe; // minuscules valide
16'hCAFE; // majuscules valide
32'h1D40_CAFE; // underscore comme séparateur valide

Non dimensionnés (Unsized)

Les nombres sans base_format sont décimaux par défaut. Sans size, le nombre de bits par défaut dépend du simulateur et de la machine.

integer a = 5423;      // base_format non spécifié, a = 5423 décimal
integer a = 'h1AD7;    // size non spécifié, a est int (32 bits) = 32'h0000_1AD7

Négatifs

Les nombres négatifs sont spécifiés en plaçant un signe moins - avant la taille. Il est illégal d'avoir un signe moins entre base_format et number.

-6'd3;    // nombre négatif 8-bit stocké en complément à deux de 3
-6'sd9;   // pour maths signés
8'd-4;    // Illégal

Chaînes (Strings)

Une séquence de caractères entre guillemets doubles " " est une chaîne. Ne peut pas être divisée en plusieurs lignes. Chaque caractère prend 1 octet.

"Hello World!"           // 12 caractères -> 12 octets
"x + z"                  // 5 caractères
"How are you feeling today ?" // Illégal : chaîne sur plusieurs lignes

Identificateurs

Les identificateurs sont noms de variables pour référence ultérieure. Composés de caractères alphanumériques [a-z][A-Z][0-9], underscores _ ou signe dollar $, sensibles à la casse. Ne peuvent pas commencer par un chiffre ou $.

integer var_a;    // Valide
integer $var_a;   // Invalide : commence par $
integer v$ar_a;   // Valide : contient $
integer 2var;     // Invalide : commence par chiffre
integer var23_g;  // Valide
integer 23;       // Invalide : seulement chiffres

Mots-clés

Les mots-clés sont identificateurs spéciaux réservés pour définir les constructions du langage, en minuscules. Liste importante ci-dessous.

Révisions de Verilog

Verilog a subi plusieurs révisions de 1995 à 2001 avec des ajouts :