Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Verilog

Dominando a Sintaxe do Verilog: Regras Essenciais e Boas Práticas

As convenções léxicas no Verilog são semelhantes a C no sentido de que contém um fluxo de tokens. Um token léxico pode consistir de um ou mais caracteres e tokens podem ser comentários, keywords, números, strings ou espaço em branco. Todas as linhas devem ser terminadas por ponto e vírgula ;.

Verilog é case-sensitive, então var_a e var_A são diferentes.

Comentários

Existem duas maneiras de escrever comentários em Verilog.

  1. Um comentário de linha única começa com // e diz ao compilador Verilog para tratar tudo após este ponto até o final da linha como comentário.
  2. Um comentário de múltiplas linhas começa com /* e termina com */ e não pode ser aninhado.

No entanto, comentários de linha única podem ser aninhados em um comentário de múltiplas linhas.

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

Espaço em Branco

Espaço em branco é um termo usado para representar os caracteres para espaços, tabs, newlines e formfeeds, e é geralmente ignorado pelo Verilog exceto quando separa tokens. Na verdade, isso ajuda na indentação do código para torná-lo mais fácil de ler.

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

No entanto, espaços em branco (spaces) e tabs (da tecla TAB) não são ignorados em strings. No exemplo abaixo, a variável string chamada addr obtém o valor "Earth " por causa da preservação de espaços em strings.

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

Existem três tipos de operadores: unários, binários e ternários ou condicionais.

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

Se a expressão (y > 5) for verdadeira, então a variável x receberá o valor em w, senão o valor em z.

Formato de Números

Estamos mais familiarizados com números representados como decimais. No entanto, números também podem ser representados em binário, octal e hexadecimal. Por padrão, simuladores Verilog tratam números como decimais. Para representá-los em uma radix diferente, certas regras devem ser seguidas.

16      // Número 16 em decimal
0x10    // Número 16 em hexadecimal
10000   // Número 16 em binário
20      // Número 16 em octal

Com Tamanho (Sized)

Números com tamanho são representados como mostrado abaixo, onde size é escrito apenas em decimal para especificar o número de bits no número.

[size]'[base_format][number]
3'b010;   // size é 3, base format é binário ('b), e o número é 010 (indica valor 2 em binário)
3'd2;     // size é 3, base format é decimal ('d) e o número é 2 (especificado em decimais)
8'h70;    // size é 8, base format é hexadecimal ('h) e o número é 0x70 (em hex) para representar decimal 112
9'h1FA;   // size é 9, base format é hexadecimal ('h) e o número é 0x1FA (em hex) para representar decimal 506
4'hA = 4'd10 = 4'b1010 = 4'o12 // Decimal 10 pode ser representado em qualquer um dos quatro formatos
8'd234 = 8'D234 // Legal usar tanto lower case quanto upper case para base format
32'hFACE_47B2; // Underscore (_) pode ser usado para separar números de 16 bits para legibilidade
Letras maiúsculas são legais para especificação de números quando o base format é hexadecimal.
16'hcafe; // lowercase letters Valid
16'hCAFE; // uppercase letters Valid
32'h1D40_CAFE; // underscore can be used as separator between 4 letters Valid

Sem Tamanho (Unsized)

Números sem especificação de base_format são números decimais por padrão. Números sem especificação de size têm um número padrão de bits dependendo do tipo de simulador e máquina.

integer a = 5423; // base format não especificado, a obtém valor decimal 5423
integer a = 'h1AD7; // size não especificado, porque a é int (32 bits) valor armazenado em a = 32'h0000_1AD7

Negativos

Números negativos são especificados colocando um sinal de menos - antes do size de um número. É ilegal ter um sinal de menos entre base_format e number.

-6'd3;  // número negativo de 8 bits armazenado como complemento de dois de 3
-6'sd9; // Para matemática signed
8'd-4;  // Illegal

Strings

Uma sequência de caracteres delimitada por aspas duplas " " é chamada de string. Não pode ser dividida em múltiplas linhas e cada caractere na string ocupa 1-byte para ser armazenado.

"Hello World!" // String com 12 caracteres -> requer 12 bytes
"x + z" // String com 5 caracteres
"How are you feeling today ?" // Illegal para uma string ser dividida em múltiplas linhas

Identificadores

Identificadores são nomes de variáveis para que possam ser referenciados posteriormente. São compostos por caracteres alfanuméricos [a-z][A-Z][0-9], underscores _ ou sinal de dólar $ e são case sensitive. Não podem começar com dígito ou sinal 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

Keywords

Keywords são identificadores especiais reservados para definir os construtos da linguagem e estão em lower case. Uma lista de keywords importantes é dada abaixo.

Dominando a Sintaxe do Verilog: Regras Essenciais e Boas Práticas

Revisões do Verilog

Verilog passou por algumas revisões ao longo dos anos e mais adições foram feitas de 1995 a 2001 como mostrado abaixo.

Dominando a Sintaxe do Verilog: Regras Essenciais e Boas Práticas

Verilog

  1. Domine o Verilog: Tutorial Completo para Projeto de Circuitos Digitais
  2. Dominando Concatenação Verilog: Guia Prático
  3. Entendendo Atribuições em Verilog: Tipos, Sintaxe e Boas Práticas
  4. Verilog Blocking vs Non-Blocking: Diferenças Essenciais Explicadas
  5. Dominando Funções em Verilog para Design RTL Eficiente
  6. Entendendo Tasks em Verilog: Funções vs Tasks, Sintaxe e Uso
  7. Gerador de Clock Verilog: Guia de Design e Implementação
  8. Dominando Funções Matemáticas do Verilog para Design de Hardware Eficiente
  9. Dominando $timeformat do Verilog: Precisão e Controle de Exibição
  10. Entendendo e Imprimindo Timescales do Verilog em Qualquer Escopo