Verilog

Verilog , estandarizado como IEEE 1364 , es un lenguaje de descripción de hardware (HDL) utilizado para modelar sistemas electrónicos . Se usa con mayor frecuencia en el diseño y verificación de circuitos digitales, con el nivel de abstracción más alto en el nivel de transferencia de registros . También se utiliza en la verificación de circuitos analógicos y de señales mixtas , así como en el diseño de circuitos genéticos . ^{[ 1 ]}

En 2009, el estándar Verilog (IEEE 1364-2005) se fusionó con el estándar SystemVerilog , dando origen al estándar IEEE 1800-2009. Desde entonces, Verilog forma parte oficialmente del lenguaje SystemVerilog. La versión actual es el estándar IEEE 1800-2023. ^{[ 2 ]}

Los lenguajes de descripción de hardware como Verilog utilizan una sintaxis similar a la del software, pero a diferencia de los lenguajes de programación, modelan el hardware físico, incluyendo la operación concurrente, la temporización de señales y el comportamiento eléctrico. Existen dos tipos de operadores de asignación : una asignación bloqueante (=) y una asignación no bloqueante (<=). La asignación no bloqueante permite a los diseñadores describir una actualización de la máquina de estados sin necesidad de declarar ni utilizar variables de almacenamiento temporal . Dado que estos conceptos forman parte de la semántica del lenguaje Verilog, los diseñadores podían escribir rápidamente descripciones de circuitos grandes de forma relativamente compacta y concisa. En el momento de su introducción (1984), Verilog representó una enorme mejora en la productividad de los diseñadores de circuitos que ya utilizaban software de captura de esquemas gráficos y programas de software específicos para documentar y simular circuitos electrónicos .

Los diseñadores de Verilog buscaban un lenguaje con una sintaxis similar a la del lenguaje de programación C , que ya se utilizaba ampliamente en el desarrollo de software de ingeniería . Al igual que C, Verilog distingue entre mayúsculas y minúsculas y cuenta con un preprocesador básico (aunque menos sofisticado que el de ANSI C/C++). Sus palabras clave de control de flujo (if/else, for, while, case, etc.) son equivalentes, y su precedencia de operadores es compatible con C. Las diferencias sintácticas incluyen: anchos de bits requeridos para las declaraciones de variables, delimitación de bloques procedimentales (Verilog usa begin/end en lugar de llaves {}), y muchas otras diferencias menores. Verilog requiere que las variables tengan un tamaño definido. En C, estos tamaños se infieren del "tipo" de la variable (por ejemplo, un tipo entero puede ser de 32 bits).

Un diseño Verilog consta de una jerarquía de módulos . Los módulos encapsulan la jerarquía del diseño y se comunican con otros módulos mediante un conjunto de puertos de entrada, salida y bidireccionales declarados . Internamente, un módulo puede contener cualquier combinación de lo siguiente: declaraciones de red/variables (wire, reg, integer, etc.), bloques de instrucciones concurrentes y secuenciales , e instancias de otros módulos (subjerarquías). Las instrucciones secuenciales se colocan dentro de un bloque begin/end y se ejecutan en orden secuencial dentro del bloque. Sin embargo, los bloques en sí se ejecutan concurrentemente, lo que convierte a Verilog en un lenguaje de flujo de datos .

El concepto de "cable" en Verilog consta de valores de señal (de cuatro estados: "1, 0, flotante, indefinido") y de intensidades de señal (fuerte, débil, etc.). Este sistema permite modelar de forma abstracta líneas de señal compartidas, donde múltiples fuentes controlan una red común. Cuando un cable tiene varios controladores, su valor (legible) se determina mediante una función de los controladores y sus intensidades.

Un subconjunto de instrucciones en el lenguaje Verilog es sintetizable . Los módulos Verilog que cumplen con un estilo de codificación sintetizable, conocido como RTL ( nivel de transferencia de registros ), pueden implementarse físicamente mediante software de síntesis. Este software transforma algorítmicamente el código fuente Verilog (abstracto) en una lista de conexiones , una descripción lógicamente equivalente que consta únicamente de primitivas lógicas elementales (AND, OR, NOT, biestables, etc.) disponibles en una tecnología FPGA o VLSI específica . Las manipulaciones posteriores de la lista de conexiones dan como resultado un plano de fabricación de circuitos (como un conjunto de fotomáscaras para un ASIC o un archivo bitstream para una FPGA ).

A continuación se muestra un ejemplo sencillo con dos chanclas :

módulo de nivel superior ( reloj , reinicio ); entrada reloj ; entrada reinicio ;registro flop1 ; registro flop2 ;siempre @ ( posedge reset o posedge clock ) si ( reset ) begin flop1 <= 0 ; flop2 <= 1 ; end else begin flop1 <= flop2 ; flop2 <= flop1 ; end endmodule

El <=operador en Verilog es otro aspecto que lo distingue como lenguaje de descripción de hardware, a diferencia de un lenguaje procedimental convencional. Se conoce como asignación "no bloqueante". Su acción no se registra hasta que se ejecuta el bloque always. Esto significa que el orden de las asignaciones es irrelevante y producirá el mismo resultado: los flip-flops 1 y 2 intercambiarán valores en cada ciclo de reloj.

El otro operador de asignación =se denomina asignación bloqueante. Cuando =se utiliza la asignación, a efectos lógicos, la variable de destino se actualiza inmediatamente. En el ejemplo anterior, si las instrucciones hubieran utilizado el =operador bloqueante en lugar de <=, flop1 y flop2 no se habrían intercambiado. En cambio, como en la programación tradicional, el compilador habría entendido que simplemente debía asignar a flop1 el valor de flop2 (e ignorar la lógica redundante para asignar a flop2 el valor de flop1).

A continuación se muestra un ejemplo de circuito contador :

module Div20x ( rst , clk , cet , cep , count , tc ); // TÍTULO 'Contador divisor por 20 con habilitaciones' // enable CEP es solo una habilitación de reloj // enable CET es una habilitación de reloj y // habilita la salida TC // un contador usando el lenguaje Verilogtamaño del parámetro = 5 ; longitud del parámetro = 20 ;entrada rst ; // Estas entradas/salidas representan entrada clk ; // conexiones al módulo. entrada cet ; entrada cep ;salida [ tamaño - 1 : 0 ] recuento ; salida tc ;reg [ tamaño - 1 : 0 ] count ; // Las señales asignadas // dentro de un always // (o initial)block // deben ser de tipo regcable tc ; // Las demás señales son de tipo cable// La instrucción always que aparece a continuación es una instrucción de ejecución paralela que // se ejecuta cada vez que las señales // rst o clk pasan de nivel bajo a nivel alto.always @ ( posedge clk or posedge rst ) if ( rst ) // Esto provoca el reinicio del contador count <= { size { 1 'b0 }}; else if ( cet && cep ) // Habilita ambos true begin if ( count == length - 1 ) count <= { size { 1 'b0 }}; else count <= count + 1 'b1 ; end// el valor de tc se asigna continuamente // el valor de la expresión asignar tc = ( cet && ( count == length - 1 ));fin del módulo

Un ejemplo de retrasos:

... reg a , b , c , d ; cable e ; ... always @( b or e ) begin a = b & e ; b = a | b ; # 5 c = b ; d = # 6 c ^ e ; end

La cláusula `always` anterior ilustra el otro tipo de método de uso, es decir, se ejecuta cada vez que cambia alguna de las entidades de la lista ( b o e ). Cuando una de estas cambia, a se le asigna inmediatamente un nuevo valor y, debido a la asignación bloqueante, a b se le asigna un nuevo valor posteriormente (teniendo en cuenta el nuevo valor de a ). Tras un retraso de 5 unidades de tiempo, a c se le asigna el valor de b y el valor de c ^ e se almacena en un espacio invisible. Luego, tras 6 unidades de tiempo más, a d se le asigna el valor que se había almacenado.

Las señales que se generan dentro de un proceso (un bloque initial o always) deben ser de tipo reg . Las señales que se generan fuera de un proceso deben ser de tipo wire . La palabra clave reg no implica necesariamente un registro de hardware.

La definición de constantes en Verilog admite la adición de un parámetro de ancho. La sintaxis básica es:

< tamaño >'< base >< valor >

Dónde:

• tamaño: El ancho en bits de la constante (opcional, pero muy recomendable)
• base: El especificador de base: b(binario), o(octal), d(decimal), h(hexadecimal)
• valor: El valor numérico en la base especificada

Ejemplos:

• 16'h1A23 o 16'h1a23: se permiten mayúsculas y minúsculas en hexadecimal 1A23 (usando 16 bits).
• 20'd44 – Decimal 44 (usando 20 bits – la extensión 0 es automática)
• 4'b1010 – Binario 1010 (usando 4 bits)
• 6'o77 – Octal 77 (usando 6 bits)

En Verilog existen varias instrucciones que no tienen equivalente en hardware real, como el comando $display. Sin embargo, los ejemplos que se presentan aquí constituyen el subconjunto clásico (y limitado) del lenguaje que sí tiene una correspondencia directa con compuertas lógicas reales.

// Ejemplos de multiplexores: tres maneras de hacer lo mismo.// El primer ejemplo utiliza la asignación continua wire out ; assign out = sel ? a : b ;// El segundo ejemplo utiliza un procedimiento // para lograr lo mismo.reg out ; always @( a or b or sel ) begin case ( sel ) 1 'b0 : out = b ; 1 'b1 : out = a ; endcase end// Finalmente, puedes usar if/else en una // estructura procedimental. reg out ; always @( a or b or sel ) if ( sel ) out = a ; else out = b ;

La siguiente estructura interesante es un pestillo transparente ; este pasa la entrada a la salida cuando la señal de puerta está configurada en "paso directo" y captura la entrada y la almacena al pasar la señal de puerta a "retención". La salida permanece estable independientemente de la señal de entrada mientras la puerta está configurada en "retención". En el ejemplo siguiente, el nivel de "paso directo" de la puerta se alcanza cuando el valor de la cláusula if es verdadero, es decir, gate = 1. Esto se lee como "si gate es verdadero, la señal din se envía continuamente a latch_out". Una vez que la cláusula if es falsa, el último valor en latch_out permanece y es independiente del valor de din.

// Ejemplo de pestillo transparentereg latch_out ; always @( gate or din ) if ( gate ) latch_out = din ; // Pasar el estado // Tenga en cuenta que el else no es necesario aquí. La variable // latch_out seguirá el valor de din mientras gate esté // en alto. Cuando gate pase a bajo, latch_out permanecerá constante.

El flip-flop es la siguiente plantilla importante; en Verilog, el D-flop es el más simple y se puede modelar como:

reg q ; siempre @( posedge clk ) q <= d ;

Lo más importante a destacar en el ejemplo es el uso de la asignación no bloqueante. Una regla general básica es usar <= cuando hay una instrucción de borde o borde negativo dentro de la cláusula always.

Una variante del D-flop es aquella con reinicio asíncrono; existe la convención de que el estado de reinicio será la primera cláusula if dentro de la instrucción.

reg q ; always @( posedge clk or posedge reset ) if ( reset ) q <= 0 ; else q <= d ;

La siguiente variante incluye tanto una condición de reinicio asíncrono como una condición de activación asíncrona; de nuevo entra en juego la convención, es decir, al término de reinicio le sigue el término de activación.

reg q ; always @( posedge clk or posedge reset or posedge set ) if ( reset ) q <= 0 ; else if ( set ) q <= 1 ; else q <= d ;

Nota: Si este modelo se utiliza para simular un flip-flop Set/Reset, pueden producirse errores de simulación. Considere la siguiente secuencia de eventos de prueba: 1) Reset pasa a nivel alto; 2) CLK pasa a nivel alto; 3) Set pasa a nivel alto; 4) CLK vuelve a pasar a nivel alto; 5) Reset pasa a nivel bajo, seguido de 6) Set pasa a nivel bajo. Suponga que no hay violaciones de setup ni hold.

En este ejemplo, la instrucción always @ se ejecutaría primero cuando se produce el flanco ascendente de reset, lo que pondría q en un valor de 0. La siguiente vez que se ejecute el bloque always será con el flanco ascendente de clk, lo que nuevamente mantendrá q en un valor de 0. El bloque always se ejecuta entonces cuando set pasa a nivel alto, lo que, debido a que reset está en nivel alto, obliga a q a permanecer en 0. Esta condición puede ser correcta o no, dependiendo del flip-flop real. Sin embargo, este no es el problema principal de este modelo. Nótese que cuando reset pasa a nivel bajo, set sigue en nivel alto. En un flip-flop real, esto hará que la salida pase a 1. Sin embargo, en este modelo no ocurrirá porque el bloque always se activa con los flancos ascendentes de set y reset, no con los niveles. Puede ser necesario un enfoque diferente para los flip-flops set/reset.

La última variante básica implementa un flip-flop D con un multiplexor que alimenta su entrada. El multiplexor tiene una entrada D y retroalimentación del propio flip-flop. Esto permite una función de carga controlada.

// Estructura básica con una ruta de retroalimentación EXPLÍCITA siempre @( posedge clk ) if ( gate ) q <= d ; else q <= q ; // ruta de retroalimentación explícita// La estructura más común ASUME que la retroalimentación está presente // Esta es una suposición segura ya que así es como el // compilador de hardware la interpretará. Esta estructura // se parece mucho a un pestillo. Las diferencias son el // '''@(posedge clk)''' y el '''<=''' no bloqueante // always @( posedge clk ) if ( gate ) q <= d ; // el multiplexor "else" está "implícito"

Cabe destacar que en esta descripción no se mencionan bloques "iniciales". Existe una diferencia entre las herramientas de síntesis de FPGA y ASIC en esta estructura. Las herramientas de FPGA permiten bloques iniciales donde se establecen valores de registro en lugar de usar una señal de "reinicio". Las herramientas de síntesis de ASIC no admiten esta funcionalidad. Esto se debe a que el estado inicial de una FPGA se descarga en las tablas de memoria de la FPGA. Un ASIC es una implementación de hardware real.

Existen dos formas distintas de declarar un proceso Verilog: las palabras clave ` always` e ` initial` . ` always` indica un proceso de ejecución libre, mientras que ` initial` indica un proceso que se ejecuta exactamente una vez. Ambas construcciones comienzan su ejecución en el tiempo 0 del simulador y se ejecutan hasta el final del bloque. Una vez que un bloque `always` ha llegado a su fin, se reprograma (de nuevo). Es un error común creer que un bloque `initial` se ejecuta antes que un bloque `always`. De hecho, es mejor considerar el bloque `initial` como un caso especial del bloque ` always` , que finaliza después de completarse por primera vez.

//Ejemplos: initial begin a = 1 ; // Asigna un valor al registro a en el tiempo 0 # 1 ; // Espera 1 unidad de tiempo b = a ; // Asigna el valor del registro a al registro b endalways @( a or b ) // Cada vez que a o b CAMBIAN, ejecuta el proceso begin if ( a ) c = b ; else d = ~ b ; end // Terminado este bloque, ahora regresa al principio (es decir, al control de eventos @)always @( posedge a ) // Se ejecuta siempre que el registro a tenga un cambio de bajo a alto a <= b ;

Estos son los usos clásicos de estas dos palabras clave, pero existen dos usos adicionales importantes. El más común es usar la palabra clave `always` sin la lista de sensibilidad `@(...)` . Es posible usar `always` como se muestra a continuación:

always begin // Siempre comienza a ejecutarse en el tiempo 0 y NUNCA se detiene clk = 0 ; // Establece clk en 0 # 1 ; // Espera 1 unidad de tiempo clk = 1 ; // Establece clk en 1 # 1 ; // Espera 1 unidad de tiempo end // Continúa ejecutándose, por lo que continúa desde el principio del begin

La palabra clave always actúa de forma similar a la construcción while(1) {..} del lenguaje C en el sentido de que se ejecutará indefinidamente.

La otra excepción interesante es el uso de la palabra clave inicial con la adición de la palabra clave forever .

El ejemplo que aparece a continuación es funcionalmente idéntico al ejemplo anterior que dice "siempre" .

inicial para siempre // Comienza en el tiempo 0 y repite el inicio/fin para siempre begin clk = 0 ; // Establece clk en 0 # 1 ; // Espera 1 unidad de tiempo clk = 1 ; // Establece clk en 1 # 1 ; // Espera 1 unidad de tiempo end

Verilog utiliza el par fork/join para crear procesos paralelos. Todas las instrucciones (o bloques) entre un par fork/join comienzan a ejecutarse simultáneamente cuando el flujo de ejecución llega a fork . La ejecución continúa después de join una vez que se completa la instrucción o bloque de mayor duración entre fork y join .

bifurcación inicial $write ( "A" ); // Imprimir carácter A $write ( "B" ); // Imprimir carácter B begin # 1 ; // Esperar 1 unidad de tiempo $write ( "C" ); // Imprimir carácter C end join

Tal como está escrito, es posible que se impriman las secuencias "ABC" o "BAC". El orden de simulación entre la primera y la segunda instrucción $write depende de la implementación del simulador y puede ser aleatorio intencionadamente. Esto permite que la simulación contenga tanto condiciones de carrera accidentales como comportamientos no deterministas deliberados.

Nótese que VHDL no puede generar dinámicamente múltiples procesos como Verilog. ^{[ 8 ]}

En Verilog, el orden de ejecución no siempre está garantizado. Esto se puede ilustrar mejor con un ejemplo clásico. Considere el siguiente fragmento de código:

inicial a = 0 ;b inicial = a ;initial begin # 1 ; $display ( "Valor a=%d Valor de b=%d" , a , b ); end

Dependiendo del orden de ejecución de los bloques iniciales, podría ser cero y cero, o bien cero y algún otro valor arbitrario no inicializado. La $displayinstrucción siempre se ejecutará después de que ambos bloques de asignación hayan finalizado, debido al retardo #1.

Nota: Estos operadores no se muestran en orden de precedencia.

El estándar IEEE 1364 define una lógica de cuatro valores con cuatro estados: 0, 1, Z ( alta impedancia ) y X (valor lógico desconocido). Para el lenguaje VHDL, su competidor, existe un estándar específico para lógica multivaluada, el IEEE 1164 , con nueve niveles. ^{[ 9 ]}

Las tareas del sistema permiten gestionar operaciones de entrada/salida sencillas y diversas funciones de medición de diseño durante la simulación. Todas las tareas del sistema llevan el prefijo $ para distinguirlas de las tareas y funciones del usuario. Esta sección presenta una breve lista de las tareas más utilizadas. No se trata de una lista exhaustiva.

• $display – Imprime en pantalla una línea seguida de un salto de línea automático.
• $write – Imprime en pantalla una línea sin el salto de línea.
• $swrite – Imprime en una variable una línea sin el salto de línea.
• $sscanf – Lee de una variable una cadena con formato especificado. (*Verilog-2001)
• $fopen – Abre un identificador a un archivo (lectura o escritura)
• $fdisplay – Imprime una línea de un archivo seguida de un salto de línea automático.
• $fwrite – Imprime en un archivo una línea sin el salto de línea.
• $fscanf – Lee desde un archivo una cadena con un formato especificado. (*Verilog-2001)
• $fclose – Cierra y libera un identificador de archivo abierto.
• $readmemh – Lee el contenido de un archivo hexadecimal y lo almacena en una matriz de memoria.
• $readmemb – Lee el contenido de un archivo binario y lo almacena en una matriz de memoria.
• $monitor – Imprime todas las variables listadas cuando cambia su valor.
• $time – Valor del tiempo de simulación actual.
• $dumpfile – Declara el nombre del archivo de salida en formato VCD ( Value Change Dump ).
• $dumpvars – Activar y volcar las variables.
• $dumpports – Activa y vuelca las variables en formato Extended-VCD.
• $random – Devuelve un valor aleatorio.

La PLI proporciona al programador un mecanismo para transferir el control de Verilog a una función de programa escrita en lenguaje C. Está oficialmente descontinuada por la norma IEEE Std 1364-2005 en favor de la interfaz procedimental de Verilog , más reciente , que reemplaza por completo a la PLI.

El PLI (ahora VPI) permite que Verilog interactúe con otros programas escritos en lenguaje C, como entornos de prueba , simuladores de conjuntos de instrucciones de microcontroladores , depuradores , etc. Por ejemplo, proporciona las funciones C tf_putlongp()^{[ 10 ]} y tf_getlongp()^{[ 11 ]} , que se utilizan para escribir y leer, respectivamente, el argumento entero de 64 bits de la tarea o función Verilog actual. Para enteros de 32 bits, se utilizan tf_putp()^{[ 12 ]} y tf_getp()^{[ 13 ] .}

Para obtener información sobre simuladores de Verilog, consulte la lista de simuladores de Verilog .

Notas