Dominar la sintaxis de Verilog: Reglas clave y mejores prácticas

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

Comentarios

Hay dos formas de escribir comentarios en Verilog:

1. Un comentario de línea única empieza con // y le dice al compilador que trate todo lo que sigue hasta el final de la línea como comentario.
2. Un comentario de múltiples líneas empieza con /* y termina con */ y no puede anidarse.

Sin embargo, los comentarios de línea única pueden anidarse en un comentario de múltiples líneas.

// Esto es un comentario de línea única
integer a; // Crea variable int llamada a, y trata todo a la derecha de // como comentario
/* Esto es un comentario de múltiples líneas o bloque */
/* Esto es /* un comentario de bloque anidado inválido */ */
/* Sin embargo, // este sí está bien */
// Esto también está bien
///////////// También está bien

Espacios en blanco

Espacio en blanco representa caracteres para espacios, tabulaciones, nuevas líneas y form feeds, y suele ser ignorado por Verilog excepto cuando separa tokens. De hecho, ayuda a la indentación del código para hacerlo más legible.

module dut; // 'module' es palabra clave, 'dut' es identificador
reg [8*6:1] name = "Hello!"; // Los 2 espacios al inicio son ignorados

Sin embargo, espacios en blanco y tabulaciones no se ignoran en cadenas. En el ejemplo siguiente, la variable string llamada addr obtiene el valor "Earth " por la preservación de espacios en cadenas.

// No hay espacio al inicio de esta línea,
// pero hay un espacio en la cadena
reg [8*6:1] addr = "Earth ";
endmodule

Operadores

Hay tres tipos de operadores: unarios, binarios y ternarios o condicionales.

• Operadores unarios aparecen a la izquierda de su operando
• Operadores binarios aparecen entre sus operandos
• Operadores condicionales tienen dos operadores separados que separan tres operandos

x = ~y; // ~ es operador unario, y es el operando
x = y | z; // | es operador binario, y y z son sus operandos
x = (y > 5) ? w : z; // ?: es operador ternario, (y>5), w y z son sus operandos

Si la expresión (y > 5) es verdadera, la variable x obtiene el valor de w, sino el de z.

Formato de números

Estamos más familiarizados con números en decimal. Pero también pueden representarse en binario, octal e hexadecimal. Por defecto, los simuladores Verilog tratan números como decimales. Para representarlos en otra base, hay que seguir ciertas reglas.

16       // Número 16 en decimal
0x10     // Número 16 en hexadecimal
10000    // Número 16 en binario
20       // Número 16 en octal

Con tamaño (Sized)

Los números con tamaño se representan así, donde size se escribe solo en decimal para especificar el número de bits:

[size]'[base_format][number]

• base_format puede ser decimal ('d o 'D), hexadecimal ('h o 'H) u octal ('o o 'O) y especifica en qué base está el number.
• number se especifica como dígitos consecutivos 0-9 para decimal y 0-9, A-F para hexadecimal.

3'b010;    // tamaño 3, base binaria ('b), número 010 (valor 2 en binario)
3'd2;      // tamaño 3, base decimal ('d), número 2
8'h70;     // tamaño 8, base hex ('h), número 0x70 (decimal 112)
9'h1FA;    // tamaño 9, base hex ('h), número 0x1FA (decimal 506)
4'hA = 4'd10 = 4'b1010 = 4'o12 // Decimal 10 en cuatro formatos
8'd234 = 8'D234 // Mayúsculas/minúsculas válidas para base
32'hFACE_47B2; // Guion bajo (_) separa números de 16 bits para legibilidad

16'hcafe; // minúsculas válido
16'hCAFE; // mayúsculas válido
32'h1D40_CAFE; // guion bajo como separador válido

Sin tamaño (Unsized)

Números sin especificación de base_format son decimales por defecto. Números sin size tienen un número de bits por defecto según simulador y máquina.

integer a = 5423;      // base no especificada, a = 5423 decimal
integer a = 'h1AD7;    // tamaño no especificado, a es int (32 bits) = 32'h0000_1AD7

Negativos

Números negativos se especifican poniendo signo menos - antes del tamaño. Es ilegal tener signo menos entre base_format e number.

-6'd3;   // número negativo de 8 bits guardado como complemento a dos de 3
-6'sd9;  // Para matemáticas con signo
8'd-4;   // Ilegal

Cadenas (Strings)

Una secuencia de caracteres entre comillas dobles " " se llama cadena. No puede dividirse en múltiples líneas y cada carácter ocupa 1 byte.

"Hello World!"           // 12 caracteres -> 12 bytes
"x + z"                  // 5 caracteres
"How are you feeling today ?" // Ilegal: cadena en múltiples líneas

Identificadores

Los identificadores son nombres de variables para referenciarlas después. Están compuestos por caracteres alfanuméricos [a-z][A-Z][0-9], guiones bajos _ o signo dólar $ y son case-sensitive. No pueden empezar con dígito ni signo dólar.

integer var_a;    // Alfabéticos y guion bajo -> Válido
integer $var_a;   // Empieza con $ -> Inválido
integer v$ar_a;   // Contiene $ -> Válido
integer 2var;     // Empieza con dígito -> Inválido
integer var23_g;  // Alfanuméricos y guion bajo -> Válido
integer 23;       // Solo números -> Inválido

Palabras clave

Las palabras clave son identificadores reservados para definir construcciones del lenguaje y están en minúsculas. Lista de palabras clave importantes:

Revisiones de Verilog

Verilog ha pasado por varias revisiones a lo largo de los años, con adiciones de 1995 a 2001: