Syntaxe Verilog
Les conventions lexicales de Verilog sont similaires à C dans le sens où il contient un flux de jetons. Un jeton lexical peut consister en un ou plusieurs caractères et les jetons peuvent être des commentaires, des mots-clés, des nombres, des chaînes ou des espaces blancs. Toutes les lignes doivent être terminées par un point-virgule ; .
Verilog est sensible à la casse , donc var_a et var_A sont différents.
Commentaires
Il existe deux façons d'écrire des commentaires dans Verilog.
- Une ligne unique le commentaire commence par
//et indique au compilateur Verilog de traiter tout ce qui se trouve après ce point jusqu'à la fin de la ligne comme un commentaire. - Un multiligne le commentaire commence par
/*et se termine par*/et ne peut pas être imbriqué.
Cependant, les commentaires sur une seule ligne peuvent être imbriqués dans un commentaire sur plusieurs lignes.
// This is a single line comment
integer a; // Creates an int variable called a, and treats everything to the right of // as a comment
/*
This is a
multiple-line or
block comment
*/
/* This is /*
an invalid nested
block comment */
*/
/* However,
// this one is okay
*/
// This is also okay
///////////// Still okay
Espace blanc
L'espace blanc est un terme utilisé pour représenter les caractères des espaces, des tabulations, des retours à la ligne et des sauts de page, et est généralement ignoré par Verilog, sauf lorsqu'il sépare les jetons. En fait, cela aide à l'indentation du code pour le rendre plus facile à lire.
module dut; // 'module' is a keyword,
// 'dut' is an identifier
reg [8*6:1] name = "Hello!"; // The 2 spaces in the beginning are ignored
Cependant, les blancs (espaces) et les tabulations (à partir de la touche TAB) ne sont pas ignorés dans les chaînes. Dans l'exemple ci-dessous, la chaîne la variable appelée addr prend la valeur "Earth" en raison de la préservation des espaces dans les chaînes.
// There is no space in the beginning of this line, // but there's a space in the string reg [8*6:1] addr = "Earth "; endmodule
Opérateurs
Il existe trois types d'opérateurs :unaire , binaire , et ternaire ou conditionnel .
- Les opérateurs unaires doivent apparaître à gauche de leur opérande
- Les opérateurs binaires doivent apparaître entre leurs opérandes
- Les opérateurs conditionnels ont deux opérateurs distincts qui séparent trois opérandes
x = ~y; // ~ is a unary operator, and y is the operand
x = y | z; // | is a binary operator, where y and z are its operands
x = (y > 5) ? w : z; // ?: is a ternary operator, and the expression (y>5), w and z are its operands
Si l'expression (y> 5) est vraie, alors la variable x obtiendra la valeur en w , sinon la valeur en z .
Format des nombres
Nous sommes plus familiers avec les nombres représentés sous forme de décimales. Cependant, les nombres peuvent également être représentés en binaire , octal et hexadécimal . Par défaut, les simulateurs Verilog traitent les nombres comme des décimales. Afin de les représenter dans une base différente , certaines règles doivent être respectées.
16 // Number 16 in decimal 0x10 // Number 16 in hexadecimal 10000 // Number 16 in binary 20 // Number 16 in octal
Taille
Les nombres dimensionnés sont représentés comme indiqué ci-dessous, où taille est écrit uniquement en décimal pour spécifier le nombre de bits dans le nombre.
[size]'[base_format][number]
- base_format peut être décimal ('d ou 'D), hexadécimal ('h ou 'H) et octal ('o ou 'O) et spécifie sur quelle base le nombre partie représente.
- numéro est spécifié sous forme de chiffres consécutifs de 0, 1, 2 ... 9 pour le format de base décimal et 0, 1, 2 .. 9, A, B, C, D, E, F pour le format hexadécimal.
3'b010; // size is 3, base format is binary ('b), and the number is 010 (indicates value 2 in binary)
3'd2; // size is 3, base format is decimal ('d) and the number is 2 (specified in decimals)
8'h70; // size is 8, base format is hexadecimal ('h) and the number is 0x70 (in hex) to represent decimal 112
9'h1FA; // size is 9, base format is hexadecimal ('h) and the number is 0x1FA (in hex) to represent decimal 506
4'hA = 4'd10 = 4'b1010 = 4'o12 // Decimal 10 can be represented in any of the four formats
8'd234 = 8'D234 // Legal to use either lower case or upper case for base format
32'hFACE_47B2; // Underscore (_) can be used to separate 16 bit numbers for readability
Les lettres majuscules sont autorisées pour la spécification numérique lorsque le format de base est hexadécimal.
16'hcafe; // lowercase letters Valid 16'hCAFE; // uppercase letters Valid 32'h1D40_CAFE; // underscore can be used as separator between 4 letters Valid
Non dimensionné
Nombres sans base_format les spécifications sont des nombres décimaux par par défaut . Nombres sans taille spécification ont un nombre de bits par défaut en fonction du type de simulateur et de machine.
integer a = 5423; // base format is not specified, a gets a decimal value of 5423
integer a = 'h1AD7; // size is not specified, because a is int (32 bits) value stored in a = 32'h0000_1AD7
Négatif
Les nombres négatifs sont spécifiés en plaçant un moins - signe avant la taille d'un nombre. Il est illégal d'avoir un signe moins entre base_format et numéro .
-6'd3; // 8-bit negative number stored as two's complement of 3 -6'sd9; // For signed maths 8'd-4; // Illegal
Chaînes
Une séquence de caractères entre guillemets doubles " " s'appelle une chaîne. Il ne peut pas être divisé en plusieurs lignes et chaque caractère de la chaîne prend 1 octet pour être stocké.
"Hello World!" // String with 12 characters -> require 12 bytes "x + z" // String with 5 characters "How are you feeling today ?" // Illegal for a string to be split into multiple lines
Identifiants
Identifiants sont des noms de variables afin qu'ils puissent être référencés ultérieurement. Ils sont composés de caractères alphanumériques [a-z][A-Z][0-9] , souligne _ ou signe dollar $ et sont sensibles à la casse. Ils ne peuvent pas commencer par un chiffre ou un signe dollar.
integer var_a; // Identifier contains alphabets and underscore -> Valid integer $var_a; // Identifier starts with $ -> Invalid integer v$ar_a; // Identifier contains alphabets and $ -> Valid integer 2var; // Identifier starts with a digit -> Invalid integer var23_g; // Identifier contains alphanumeric characters and underscore -> Valid integer 23; // Identifier contains only numbers -> Invalid
Mots clés
Les mots-clés sont des identificateurs spéciaux réservés pour définir les constructions du langage et sont en minuscules. Une liste de mots-clés importants est donnée ci-dessous.
Révisions Verilog
Verilog a subi quelques révisions au fil des ans et d'autres ajouts ont été effectués de 1995 à 2001, comme indiqué ci-dessous.
Verilog