sintaxis de Verilog

Las convenciones léxicas en Verilog son similares a las de C en el sentido de que contiene un flujo de tokens. Un token léxico puede constar de uno o más caracteres y los tokens pueden ser comentarios, palabras clave, números, cadenas o espacios en blanco. Todas las líneas deben terminar con un punto y coma ; .

Verilog distingue entre mayúsculas y minúsculas , por lo que var_a y var_A son diferentes.

Comentarios

Hay dos formas de escribir comentarios en Verilog.

1. Una línea única comentario comienza con // y le dice al compilador de Verilog que trate todo lo que esté después de este punto hasta el final de la línea como un comentario.
2. Un múltiples líneas comentario comienza con /* y termina en */ y no se pueden anidar.

Sin embargo, los comentarios de una sola línea se pueden anidar en un comentario de varias líneas.

  
  
// 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

  

Espacio en blanco

El espacio en blanco es un término que se usa para representar los caracteres de espacios, tabuladores, líneas nuevas y saltos de formulario, y Verilog generalmente lo ignora, excepto cuando separa tokens. De hecho, esto ayuda en la sangría del código para que sea más fácil de leer.

module dut;              // 'module' is a keyword, 
                         // 'dut' is an identifier
  reg [8*6:1] name = "Hello!";   // The 2 spaces in the beginning are ignored

Sin embargo, los espacios en blanco (espacios) y las tabulaciones (de la tecla TAB) no se ignoran en las cadenas. En el siguiente ejemplo, la cadena variable llamada addr obtiene el valor "Earth" debido a la conservación de espacios en las cadenas.

   // 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 

Operadores

Hay tres tipos de operadores:unario , binario , y ternario o condicional .

• Los operadores unarios aparecerán a la izquierda de su operando
• Los operadores binarios deben aparecer entre sus operandos
• Los operadores condicionales tienen dos operadores separados que separan tres operandos

  
  
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 la expresión (y> 5) es verdadera, entonces la variable x obtendrá el valor en w , de lo contrario el valor en z .

Formato de número

Estamos más familiarizados con los números representados como decimales. Sin embargo, los números también se pueden representar en binario , octales y hexadecimal . De forma predeterminada, los simuladores de Verilog tratan los números como decimales. Para representarlos en un radix diferente , se deben seguir ciertas reglas.

16          // Number 16 in decimal
0x10        // Number 16 in hexadecimal
10000       // Number 16 in binary
20          // Number 16 in octal

Tamaño

Los números de tamaño se representan como se muestra a continuación, donde tamaño se escribe solo en decimal para especificar el número de bits en el número.

  
  
[size]'[base_format][number]

  

• formato_base puede ser decimal ('d o 'D), hexadecimal ('h o 'H) y octal ('o o 'O) y especifica en qué base se encuentra el número parte representa.
• número se especifica como dígitos consecutivos de 0, 1, 2 ... 9 para formato base decimal y 0, 1, 2 .. 9, A, B, C, D, E, F para formato hexadecimal.

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

Las letras mayúsculas son válidas para la especificación de números cuando el formato base es hexadecimal.

16'hcafe;         // lowercase letters Valid
16'hCAFE;         // uppercase letters Valid
32'h1D40_CAFE;    // underscore can be used as separator between 4 letters Valid

Sin tamaño

Números sin un base_format especificación son números decimales por predeterminado . Números sin tamaño especificación tienen un número predeterminado de bits según el tipo de simulador y máquina.

  
  
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

  

Negativo

Los números negativos se especifican colocando un signo menos - signo antes del tamaño de un número. Es ilegal tener un signo menos entre base_format y número .

-6'd3;            // 8-bit negative number stored as two's complement of 3
-6'sd9;           // For signed maths
8'd-4;            // Illegal

Cuerdas

Una secuencia de caracteres entre comillas dobles " " se llama cadena. No se puede dividir en varias líneas y cada carácter de la cadena requiere 1 byte para almacenarse.

"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

Identificadores

Identificadores son nombres de variables para que puedan ser referenciadas más adelante. Se componen de caracteres alfanuméricos [a-z][A-Z][0-9] , guiones bajos _ o signo de dólar $ y son sensibles a mayúsculas y minúsculas. No pueden comenzar con un dígito o un signo de dólar.

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

Palabras clave

Las palabras clave son identificadores especiales reservados para definir las construcciones del lenguaje y están en minúsculas. A continuación se proporciona una lista de palabras clave importantes.

Revisiones de Verilog

Verilog ha sido objeto de algunas revisiones a lo largo de los años y se han realizado más adiciones entre 1995 y 2001, como se muestra a continuación.

Capas de abstracción de diseño Tipos de datos de Verilog