Verilog proporciona muchas tareas de sistema que pueden operar sobre archivos. Las tareas de sistema más utilizadas incluyen principalmente:

  • Apertura y cierre de archivos: $fopen, $fclose, $ferror
  • Escritura de archivos: $fdisplay, $fwrite, $fstrobe, $fmonitor
  • Escritura de cadenas: $sformat, $swrite
  • Lectura de archivos: $fgetc, $fgets, $fscanf, $fread
  • Posicionamiento de archivos: $fseek, $ftell, $feof, $frewind
  • Carga de memoria: $readmemh, $readmemb

Al usar tareas de operación de archivos (preste especial atención a $sforamt, $gets, $sscanf, etc.) para operar sobre archivos, es necesario determinar qué tarea de sistema utilizar según la naturaleza del archivo y el contenido de las variables, y garantizar la coherencia entre los parámetros y los tipos de variables de lectura/escritura con el contenido del archivo. No confunda los tipos de cadena con los tipos de base múltiple.

Apertura/cierre de archivos

Tarea de sistemaFormato de llamadaDescripción de la tarea
Apertura de archivofd = $fopen("fname", mode) ;fname es el nombre del archivo que se abre
fd es el descriptor de archivo de 32 bits devuelto
--- Cuando se abre correctamente, fd es un valor distinto de cero
--- Cuando hay un error al abrir, fd es cero
mode se utiliza para especificar el modo de apertura del archivo
Cierre de archivo$fclose(fd) ;Cierra el archivo correspondiente descrito por fd
Error de archivoerr = $ferror(fd, str) ;Al abrir un archivo correctamente:
--- err y str son ambos cero,
Cuando hay un error al abrir el archivo:
--- err devuelve un valor distinto de cero para indicar el error
--- str devuelve un valor distinto de cero que almacena el tipo de error
--- Se recomienda oficialmente que la longitud de str sea de 640 bits de ancho

El código de ejemplo es el siguiente:

Ejemplo

  //open/close file
   integer fd1, fd2 ;
   integer err1, err2 ;
   reg [320:0] str1, str2 ; //La variable de tipo de error también puede ser del tipo string soportado
   initial begin
      //existing file
      fd1 = $fopen("./DATA_RD.HEX", "r");    //Abrir un archivo existente
      err1 = $ferror(fd1, str1);
      $display("File1 descriptor is: %h.", fd1 );//Valor distinto de cero
      $display("Error1 number is: %h.", err1 );  //0
      $display("Error2 info is: %s.", str1 );    //0
      $fclose(fd1);
      //not existing file
      fd2 = $fopen("../../FILE_NOEXIST.HEX", "r");//El archivo que se abre no existe
      err2 = $ferror(fd2, str2);
      $display("File2 descriptor is: %h.", fd2 ); //0
      $display("Error2 number is: %h.", err2 );   //Valor distinto de cero
      $display("Error2 info is: %s.", str2 );     //Valor distinto de cero
      $fclose(fd2);
   end

Los tipos de modo de apertura de archivo y sus descripciones son los siguientes:

rAbrir un archivo de texto en modo solo lectura, solo se permiten leer datos.
wAbrir un archivo de texto en modo solo escritura, solo se permiten escribir datos. Si el archivo existe, el contenido original se elimina. Si el archivo no existe, se crea un archivo nuevo.
aAbrir un archivo de texto en modo agregar y escribir datos al final del archivo. Si el archivo no existe, se crea un archivo nuevo.
rbAbrir un archivo binario en modo solo lectura, solo se permiten leer datos.
wbAbrir o crear un archivo binario en modo solo escritura, solo se permiten escribir datos.
abAbrir un archivo binario en modo agregar y escribir datos al final del archivo.
r+Abrir un archivo de texto en modo lectura-escritura, permite leer y escribir
w+Abrir o crear un archivo de texto en modo lectura-escritura, permite leer y escribir. Si el archivo existe, el contenido original se elimina. Si el archivo no existe, se crea un archivo nuevo.
a+Abrir un archivo de texto en modo lectura-escritura, permite leer y escribir. Si el archivo no existe, se crea un archivo nuevo. La lectura del archivo comienza desde la dirección inicial del archivo; la escritura solo puede ser en modo agregar.
rb+Abrir un archivo de texto binario en modo lectura-escritura, con funcionalidad similar a "r+".
wb+Abrir o crear un archivo de texto binario en modo lectura-escritura, con funcionalidad similar a "w+".
ab+Abrir un archivo de texto binario en modo lectura-escritura, con funcionalidad similar a "a+".

Escritura de archivos

Las tareas de sistema para escribir archivos incluyen principalmente: $fdisplay, $fwrite, $fstrobe, $fmonitor, así como sus correspondientes tareas de sistema con formato incorporado $fdisplayb, $fdisplayh, $fdisplayo, etc.

Formato de llamadaDescripción de la tarea
$fdisplay(fd, arguments) ;Escribir en el archivo en orden o bajo condición, con salto de línea automático
$fwrite(fd, arguments) ;Escribir en el archivo en orden o bajo condición, sin salto de línea automático
$fstrobe(fd, arguments) ;Escribir en el archivo de forma strobe después de que la sentencia se ejecute
$fmonitor(fd, arguments) ;Escribir en el archivo siempre que los datos cambien

En comparación con las tareas de visualización estándar $display, $write, $strobe, $monitor, las tareas de sistema de escritura de archivos requieren especificar adicionalmente el descriptor de archivo fd en el formato de uso; el resto de condiciones de impresión, características de temporización, etc., se mantienen consistentes con sus tareas de visualización correspondientes.

A continuación se muestra un ejemplo de escritura en un archivo utilizando el modo de escritura por adición:

Ejemplo

  //(2) write file
   integer fd ;
   integer err, str ;
   initial begin
      fd = $fopen("./DATA_RD.HEX", "a+");  //Abrir en modo agregar al final
      err = $ferror(fd, str);
      if (!err) begin
         $fdisplay(fd, "New data1: %h", fd) ;
         $fdisplay(fd, "New data2: %h", str) ;
         $fdisplay(fd, "New data3: %h", err) ;
         //$write(fd, "New data3: %h", err) ; //La última línea se imprime sin salto de línea
      end
      $fclose(fd);
   end

Al abrir el archivo DATA_RD.HEX, se puede ver que se han añadido 3 líneas de datos al final del archivo.

Escritura de cadenas

Verilog también proporciona las tareas de sistema $swrite y $sformat para escribir datos en cadenas.

Formato de llamadaDescripción de la tarea
$swrite(reg, list_of_arguments) ;Escribir cadenas en la variable reg en orden o bajo condición
len = $sformat(reg, format_str, arguments) ;Escribir cadenas en la variable reg según el formato format_str
El formato es el mismo que el formato especificado por $display
No se recomienda omitir el segundo parámetro format_str
Puede devolver la longitud de la cadena len

El segundo parámetro format de $sformat es de tipo cadena; generalmente se recomienda no omitirlo. Este parámetro especifica el tipo de las variables de entrada; al especificar el tipo también puede incluir otra información de cadena. Para los tipos y su uso, consulte la función de visualización $display. Este parámetro también puede ser de tipo registro, pero se requiere que los datos almacenados sean datos de cadena normales.

Un ejemplo de código para escribir cadenas es el siguiente:

Ejemplo

   //(3) write string
   reg [299:0] str_swrite, str_sformat;
   reg [63:0] str_buf ;
   integer    len, age ;
   initial begin
      #20 ;
      str_buf   = "ejemplo!" ;
      age       = 9 ;

      //$swrite escribe una cadena que contiene variables con formato especificado
      $swrite(str_swrite, "%s age is %d", str_buf, age) ;
      $display("%s", str_swrite);
      //$swrite escribe directamente una cadena que no contiene variables
      $swrite(str_swrite, "years ", "old.") ;
      $display("%s", str_swrite);
      //$swrite escribe una cadena que contiene variables sin especificar formato; no recomendado
      $swrite(str_swrite, age) ;
      $display("$swrite err test: %d", str_swrite);

      $display();
     //$sformat escribe una cadena que contiene variables con formato especificado
      $sformat(str_sformat, "I have learnt in %s", str_buf) ;
      $display("%s", str_sformat);
      //$sformat escribe directamente una cadena que no contiene variables y obtiene la longitud de la cadena
      len = $sformat(str_sformat, "for 4 years!") ;
      $display("%s", str_sformat);
      $display("$sformat len: %d", len);
      //$sformat escribe directamente varias cadenas sin variables a la vez; no recomendado
      $sformat(str_sformat, "for", "4", "years!") ;
      $display("$sformat err test: %s", str_sformat);
   end

Ignorando los espacios de la información impresa, la salida de depuración es la siguiente:

De esto se deduce que $sformat y $swrite pueden usarse de la misma manera, por ejemplo, $sformat puede escribir una cadena con formato especificado o escribir una sola vez una cadena que no contiene variables. En este caso, $sformat equivale a no especificar el tipo de variable en el segundo parámetro, por lo que el tercer parámetro debe omitirse.

$swrite también puede escribir varias cadenas que no contienen variables a la vez, mientras que $sformat no permite dicha llamada.

También se recomienda especificar el tipo de variable al usar $swrite para escribir cadenas que contienen variables; de lo contrario, el resultado puede ser impredecible.

Lectura de archivos

Tarea de sistemaFormato de llamada y descripción 
Leer archivo por caracteresc = $fgetc( fd ) ; 
 Muestra los datos de fd a la variable c en formato de carácter; el ancho de bits de c debe ser al menos 8
Cuando hay un error de lectura, el valor de c es EOF(-1); se puede usar $ferror para verificar el tipo de error
 
Escribir búfer por caráctercode = $ungetc(c, fd ) ; 
 Escribe el carácter c en el búfer del archivo fd
El valor de c se devuelve en la próxima llamada a $fgetc; el contenido del archivo fd en sí no cambia
Cuando la escritura del búfer es normal, el valor de retorno code es 0; cuando ocurre un error, el valor de retorno code es EOF
 
Leer archivo por líneascode = $fgets(str, fd) 
 Lee caracteres de forma continua hasta que la variable str se llene, o se complete la lectura de una línea, o se llegue al final del archivo
En una lectura normal, el valor de retorno code es el número de líneas (veces) leídas; cuando ocurre un error, code es 0
 
Leer archivo según formatocode = $fscanf(fd, format, args) ; 
 Lee los datos del archivo fd en las variables args según el formato format
Para format, consulte la descripción del formato especificado por $display
La condición de detención para una lectura es un espacio o un salto de línea
Cuando ocurre un error de lectura, el valor de retorno code es 0
 
Leer cadena según formatocode = $sscanf(str, format, args) ; 
 Según el formato format, lea la variable de tipo cadena str en la variable args
directamente a la variable data_get, el contenido en data_get será anómalo.
 
Leer archivo en binariocode = $fread(store, fd, start, count) ; 
 Leer datos del archivo fd en la variable de array o registro store en formato de flujo de datos binarios
start es la dirección de inicio del archivo, count es la longitud de lectura
Si start/count no se especifican, todos los datos se rellenarán en la variable store
Si store es de tipo registro, los parámetros start/count no son válidos, y la lectura se detendrá después de que la variable store se llene una vez con datos
 
Tomando el archivo DATA_RD.HEX de la simulación de "escritura de archivos" como archivo de referencia para la lectura, se da un ejemplo; el contenido de dicho archivo es el siguiente.
c0dec0de
5555aaaa
12345678
aaaa5555
New data1: 80000003
New data2: 00000000
New data3: 00000000

Ejemplos de llamada a $fgetc, $ungetc

Ejemplo

   //(4.1) read char
   integer      i ;
   reg [31:0]   char_buf ;
   initial begin
      #30 ;
      fd = $fopen("DATA_RD.HEX", "r");
      $write("Read char: ");
      err = $ferror(fd, str);
      if (!err) begin
         for (i=0; i<13; i++) begin
            char_buf[7:0] = $fgetc(fd) ;  //Leer por carácter individual
            $write("%c", char_buf[7:0]) ; //Imprimir caracteres individuales uno a uno sin salto de línea
         end
         $write(".\n") ;
      end

      $ungetc("1", fd) ;            //Escribir en el búfer del archivo 3 veces consecutivas
      $ungetc("2", fd) ;
      $ungetc("3", fd) ;
      char_buf[7:0]   = $fgetc(fd) ;  //read 3
      char_buf[15:8]  = $fgetc(fd) ;  //read 2
      char_buf[23:16] = $fgetc(fd) ;  //read 1,read buffer end
      char_buf[31:24] = $fgetc(fd) ;  //read a
      $display("Read char after $ungetc: %s", char_buf);
      $fclose(fd);
   end

Los resultados de la simulación son los siguientes.

Como se puede ver en la figura, los 13 caracteres leídos por $fgetc son correctos, y los caracteres leídos incluyen el salto de línea.

Después de que $ungetc escribe datos de caracteres en el búfer del archivo, se pueden leer los datos de caracteres del búfer del archivo usando $fgetc. La lectura y escritura siguen el principio de primero en entrar, último en salir (FILO, First in Last out), equivalente a un apilamiento. Cuando los datos de caracteres se escriben primero como "123", los datos leídos son "321".

Una vez que el búfer del archivo se ha leído por completo, al volver a leer datos de caracteres, los datos leídos continúan siguiendo la posición de la última lectura del archivo, es decir, el carácter "a" en "a123" del log.

Durante este proceso, el contenido del archivo DATA_RD.HEX no ha cambiado en absoluto.

Ejemplo de llamada a $fgets

Ejemplo

   //(4.2) read line
   integer      code ;
   reg [99:0]   line_buf [9:0] ;
   initial begin
      #31 ;
      fd = $fopen("DATA_RD.HEX", "r");
      err = $ferror(fd, str);
      if (!err) begin
         for (i=0; i<6; i++) begin  //Leer línea por línea en formato de cadena
            code = $fgets(line_buf[i], fd) ;  //Contiene "\n" al final, se imprimirán 2 líneas
            $display("Get line data%d: %s", i, line_buf[i]) ;
         end
      end
      //En visualización hexadecimal, se mostrarán los códigos ASCII correspondientes
      $display("Show hex line data%d: %h", 2, line_buf[2]) ;
      $display("Show hex line data%d: %h", 4, line_buf[4]) ;
      $fclose(fd) ;
   end

Los resultados de la simulación son los siguientes.

Los primeros 4 datos de línea se leen y muestran como tipo cadena, y los resultados son normales.

Al leer los datos de la quinta línea del archivo, debido a la limitación de ancho de bits de 100 de la variable line_buf, el contenido del archivo "New data1: 80000003 " necesita dividirse en 2 lecturas para completarse.

Debido a que cada línea termina con un salto de línea "\n", al imprimir con la función $display, aparecerá una línea en blanco adicional.

Al leer como tipo cadena y mostrar los datos en hexadecimal, el contenido de datos correspondiente del archivo no se puede mostrar de forma intuitiva. Por ejemplo, el contenido de la segunda línea no muestra "12345678," sino su código ASCII correspondiente. Por lo tanto, la tarea $fgets lee según el tipo cadena; esto requiere atención.

Ejemplos de llamada a $fscanf, $sscanf

Ejemplo

   //(4.3) $fscanf/$sscanf
   reg [31:0]   data_buf [9:0] ;
   reg [63:0]   string_buf [9:0] ;
   reg [31:0]   data_get ;
   reg [63:0]   data_test ;
   initial begin
      #32 ;
      fd = $fopen("DATA_RD.HEX", "r");
      err = $ferror(fd, str);
      if (!err) begin
         for (i=0; i<4; i++) begin
            //Los primeros 4 datos de línea se leen y muestran en hexadecimal
            code = $fscanf(fd, "%h", data_buf[i]);
            $display("$fscanf read data%d: %h", i, data_buf[i]) ;
         end
         for (i=4; i<6; i++) begin
            //Los últimos 2 datos de línea se leen y muestran como tipo cadena
            code = $fscanf(fd, "%s", string_buf[i]);
            $display("$fscanf read data%d: %s", i, string_buf[i]) ;
         end
      end

      //(1) La variable fuente data_test de $sscanf es de tipo cadena
      data_test = "fedcba98" ;
      code = $sscanf(data_test, "%h", data_get);
      $display("$sscanf read data0: %h", data_get) ;
      //(2) $sscanf: convertir primero la variable fuente data_test en una variable de cadena
      code = $sformat(data_test, "%h", data_buf[2]);
      code = $sscanf(data_test, "%h", data_get);
      //No se recomienda ingresar directamente variables hexadecimales
      //code = $sscanf(data_buf[2], "%h", data_get);
      $display("$sscanf read data0: %h", data_get) ;
      $fclose(fd) ;
   end

Los resultados de la simulación son los siguientes.

Usando $fscanf para leer y mostrar el contenido de las primeras 4 líneas del archivo en hexadecimal, y las últimas 2 líneas como tipo cadena, todo es normal.

Al usar $sscanf para leer el contenido del registro fuente y luego transferirlo al registro de destino, el contenido del registro fuente debe ser datos de tipo cadena.

Por ejemplo, al usar $sscanf para transferir el dato hexadecimal data_buf

Si se usa directamente $sscanf para transferir el dato en formato hexadecimal data_buf

Te lo digo en secreto, ¡¡¡entre registros se puede asignar directamente!!!

Ejemplo de llamada a $fread

Ejemplo

   //(4.4) $fread
   reg [71:0]   bin_buf [3:0] ; //Cada línea tiene 8 datos de tipo palabra y 1 salto de línea
   reg [143:0]  bin_reg ;
   initial begin
      #40 ;
      fd = $fopen("DATA_RD.HEX", "r");
      err = $ferror(fd, str);
      if (!err) begin
         code = $fread(bin_buf, fd, 0, 4); //Lectura de tipo array, leer 4 veces
         $display("$fread read data %h", bin_buf[0]) ;//Visualización hexadecimal
         $display("$fread read data %h", bin_buf[1]) ;
         $display("$fread read data %s", bin_buf[2]) ;//Visualización de cadena
         $display("$fread read data %s", bin_buf[3]) ;
      end

      fd = $fopen("DATA_RD.HEX", "r");
      code = $fread(bin_reg, fd); //Lectura de registro individual
      $display("$fread read data %h", bin_reg) ;
      $fclose(fd) ;
   end

Los resultados de la simulación son los siguientes.

Cuando $fread lee un archivo en modo binario, la dirección de inicio y la longitud de lectura son parámetros que se establecen para variables de tipo array.

Si el tipo de variable que almacena los datos es de tipo reg no array, solo se realizará una lectura, hasta que la variable de tipo reg se llene por completo.

Posicionamiento de archivos

Tarea del sistemaFormato de llamadaDescripción de la tarea
Obtener la posición del archivopos = $ftell( fd ) ;Devuelve el desplazamiento de la posición actual del archivo respecto al inicio del archivo; la dirección inicial es 0
El desplazamiento se mide en unidades de un byte (8 bits)
Se usa junto con $fseek
Reposicionamientocode = $fseek(fd, offset, type) ;Establece la posición de la siguiente entrada o salida del archivo
offset es el desplazamiento establecido
type es el tipo de operación del desplazamiento
--- 0: Establecer la posición en la dirección de desplazamiento
--- 1: Establecer la posición en la posición actual más el desplazamiento
--- 2: Establecer la posición al final del archivo más el desplazamiento; frecuentemente se usan números negativos para indicar un desplazamiento hacia atrás desde el final del archivo
Reposicionamiento sin desplazamientocode = $rewind( fd ) ;Equivalente a $fseek( fd, 0, 0);
Determinar el final del archivocode = $feof(fd) ;Comprobar si se ha llegado al final del archivo
Cuando se detecta el final del archivo, el valor de retorno es 1; de lo contrario, es 0

El contenido del archivo DATA_RD.HEX se puede representar de la siguiente manera.

Con el salto de línea "\n" como terminador, el tamaño del archivo es: 4x9 + 3x20 = 96 bytes.

El código de prueba de posicionamiento del archivo es el siguiente:

Ejemplo

   // file position
   reg [31:0]   data4 ;      //La longitud de la variable de registro es de 4 bytes
   reg [199:0]  str_long ;
   integer      pos ;
   initial begin
      #40 ;
      fd = $fopen("DATA_RD.HEX", "r");
      err = $ferror(fd, str);
      if (!err) begin
         //first read
         code = $fscanf(fd, "%h", data4);//Leer desde la posición 0
         pos  = $ftell(fd);      //Después de leer 8 bytes, la posición es 8, coordenada (0,8)
         $display("Position after read: %d", pos) ;
         $display("1st read data: %h", data4) ;

         //type = 0
         code = $fseek(fd, 4, 0) ; //Leer desde la posición 4, coordenada (0,4)
         code = $fscanf(fd, "%h", data4); //Detenerse al leer el salto de línea
         pos  = $ftell(fd);      //Después de leer 4 bytes, la posición es 8, coordenada (0,8)
         $display("type 0: current position: %d", pos) ;
         $display("type 0: read data: %h", data4) ;
         //type = 1
         code = $fseek(fd, 4, 1) ; //Leer desde la posición 4+9=12, coordenada (1,3)
         code = $fscanf(fd, "%h", data4); //Detenerse al leer el salto de línea
         pos  = $ftell(fd);      //Después de leer 5 bytes, la posición es 17, coordenada (1,8)
         $display("type 1: current position: %d", pos) ;
         $display("type 1: read data: %h", data4) ;
         //type = 2
         code = $fseek(fd, -(96-31), 2) ; //Leer desde la posición 31, coordenada (3,4)
         code = $fscanf(fd, "%h", data4);
         pos  = $ftell(fd);      //Después de leer 4 bytes, la posición es 35, coordenada (3,8)
         $display("type 2: current position: %d", pos) ;
         $display("type 2: read data: %h", data4) ;

         //rewind read
         code   = $rewind(fd) ;//Volver a apuntar el puntero del archivo al inicio del archivo
         pos    = $ftell(fd);  //En este momento la posición es 0
         $display("Position after $rewind: %d", pos) ;
         //read all content of file
         while (!$feof(fd)) begin
            code   = $fgets(str_long, fd);
            $write("Read : %s", str_long) ;
         end
         $fclose(fd) ;
      end
   end

Los resultados de la simulación son los siguientes.

Como se puede ver en la figura, se imprime una línea de datos adicional al final del log. Esto se debe a que el archivo DATA_RD.TXT tiene una línea en blanco al final (el resultado después de una operación de salto de línea). La tarea del sistema $feof no considera esta línea en blanco como final del archivo, por lo que el valor de retorno sigue siendo 0. Pero en realidad esta línea no tiene datos, por lo que los datos leídos son incontrolables.

Para eliminar la influencia del salto de línea en los datos de la última línea del archivo, se puede reemplazar la última tarea del sistema de escritura de archivos $fdisplay del ejemplo de "escritura de archivos" por $write.

En cuanto al resto del log, combinado con los comentarios del código, se puede ver que la simulación es correcta; aquí no se dará una explicación unificada.

Cargar memoria

Tarea del sistemaFormato de llamada y descripción 
Cargar archivo hexadecimal$readmemh("fname", mem, start_addr, finish_addr) 
 fname es el nombre del archivo de datos
mem es una variable de tipo array/memoria
start_addr y finish_addr son la dirección de inicio y la dirección de fin, respectivamente
start_addr y finish_addr se pueden omitir; en ese caso, la condición de detención de la carga de datos es que la variable de memoria mem se llene por completo, o que el archivo se lea por completo
El contenido del archivo solo debe contener caracteres de espacio en blanco (o saltos de línea y espacios), datos binarios o hexadecimales
Los comentarios se marcan con "//"; se recomienda usar saltos de línea para separar los datos
 
Cargar archivo binario$readmemb("fname", mem, start_addr, finish_addr) 
 El formato de uso es el mismo que $readmemb 

El contenido del archivo DATA_WITHNOTE.HEX es el siguiente; cargue el contenido de este archivo en la variable de memoria.

El código de ejemplo es el siguiente:

Ejemplo

   //6 load mem
   reg [31:0]   mem_load [3:0] ;
   initial begin
      #50 ;
      $readmemh("./DATA_WITHNOTE.HEX", mem_load);
      $display("Read memory1: %h", mem_load[0]) ;
      $display("Read memory2: %h", mem_load[1]) ;
      $display("Read memory3: %h", mem_load[2]) ;
      $display("Read memory4: %h", mem_load[3]) ;
   end

Los resultados de la simulación son los siguientes:

Descargar el código fuente de este capítulo

Download