Verilog bietet viele Systemaufgaben, mit denen Dateien bearbeitet werden können. Die häufig verwendeten Systemaufgaben umfassen hauptsächlich:

  • Datei öffnen/schließen: $fopen, $fclose, $ferror
  • Datei schreiben: $fdisplay, $fwrite, $fstrobe, $fmonitor
  • String schreiben: $sformat, $swrite
  • Datei lesen: $fgetc, $fgets, $fscanf, $fread
  • Dateipositionierung: $fseek, $ftell, $feof, $frewind
  • Speicher laden: $readmemh, $readmemb

Wenn Sie Dateioperationsaufgaben (insbesondere unter Beachtung von $sforamt, $gets, $sscanf usw.) zum Arbeiten mit Dateien verwenden, müssen Sie anhand der Dateiart und des Variableninhalts entscheiden, welche Systemaufgabe verwendet werden soll, und die Konsistenz der Parameter und der Typen der Lese-/Schreibvariablen mit dem Dateiinhalt sicherstellen. Verwechseln Sie String-Typen nicht mit Multi-Radix-Typen.

Datei öffnen/schließen

SystemaufgabeAufrufformatAufgabenbeschreibung
Datei öffnenfd = $fopen("fname", mode) ;fname ist der Name der zu öffnenden Datei
fd ist der zurückgegebene 32-Bit-Dateideskriptor
--- Bei korrektem Öffnen ist fd ungleich null
--- Wenn beim Öffnen ein Fehler auftritt, ist fd null
mode wird verwendet, um den Dateiöffnungsmodus anzugeben
Datei schließen$fclose(fd) ;Schließe die entsprechende durch fd beschriebene Datei
Dateifehlererr = $ferror(fd, str) ;Wenn die Datei normal geöffnet wird:
--- sowohl err als auch str sind null,
Wenn beim Öffnen der Datei ein Fehler auftritt:
--- err gibt einen Wert ungleich null zurück, um einen Fehler anzuzeigen
--- str gibt einen Wert ungleich null zurück, der den Fehlertyp speichert
--- Die offizielle Empfehlung ist, dass die Länge von str 640 Bit breit ist

Beispielcode sieht wie folgt aus:

Beispiel

  //Datei öffnen/schließen
   integer fd1, fd2 ;
   integer err1, err2 ;
   reg [320:0] str1, str2 ; //Die Variable für den Fehlertyp kann auch ein unterstützter String-Typ sein
   initial begin
      //vorhandene Datei
      fd1 = $fopen("./DATA_RD.HEX", "r");    //Eine vorhandene Datei öffnen
      err1 = $ferror(fd1, str1);
      $display("Datei1-Deskriptor ist: %h.", fd1 );//Wert ungleich null
      $display("Fehler1-Nummer ist: %h.", err1 );  //0
      $display("Fehler2-Info ist: %s.", str2 );    //0
      $fclose(fd1);
      //nicht vorhandene Datei
      fd2 = $fopen("../../FILE_NOEXIST.HEX", "r");//Die geöffnete Datei existiert nicht
      err2 = $ferror(fd2, str2);
      $display("Deskriptor von Datei 2 ist: %h.", fd2 ); //0
      $display("Nummer von Fehler 2 ist: %h.", err2 );   //Wert ungleich null
      $display("Info zu Fehler 2 ist: %s.", str2 );     //Wert ungleich null
      $fclose(fd2);
   end

Die Typen der Dateiöffnungsmodi und ihre Beschreibungen sind wie folgt:

rEine Textdatei nur zum Lesen öffnen; nur das Lesen von Daten erlauben.
wEine Textdatei nur zum Schreiben öffnen; nur das Schreiben von Daten erlauben. Wenn die Datei existiert, wird der ursprüngliche Dateiinhalt gelöscht. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
aEine Textdatei im Anhängemodus öffnen und Daten am Ende der Datei schreiben. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
rbEine Binärdatei nur zum Lesen öffnen; nur das Lesen von Daten erlauben.
wbEine Binärdatei nur zum Schreiben öffnen oder erstellen; nur das Schreiben von Daten erlauben.
abEine Binärdatei im Anhängemodus öffnen und Daten am Ende der Datei schreiben.
r+Öffnet eine Textdatei zum Lesen und Schreiben, wobei sowohl Lesen als auch Schreiben erlaubt sind.
w+Eine Textdatei zum Lesen und Schreiben öffnen oder erstellen, wobei sowohl Lesen als auch Schreiben erlaubt ist. Wenn die Datei existiert, wird der ursprüngliche Dateiinhalt gelöscht. Wenn die Datei nicht existiert, wird eine neue Datei erstellt.
a+Öffnet eine Textdatei zum Lesen und Schreiben, wobei sowohl Lesen als auch Schreiben möglich ist. Wenn die Datei nicht existiert, wird eine neue Datei erstellt. Das Lesen beginnt am Anfang der Datei, das Schreiben erfolgt nur im Anhängemodus.
rb+Öffnet eine Binärdatei zum Lesen und Schreiben, ähnlich wie "r+".
wb+Öffnet oder erstellt eine Binärdatei zum Lesen und Schreiben, ähnlich wie "w+".
ab+Öffnet eine Binärdatei zum Lesen und Schreiben, ähnlich wie "a+".

Schreiben in Dateien

Die Systemaufgaben zum Schreiben von Dateien umfassen hauptsächlich: $fdisplay, $fwrite, $fstrobe, $fmonitor sowie ihre entsprechenden Systemaufgaben mit integrierten Formaten wie $fdisplayb, $fdisplayh, $fdisplayo usw.

AufrufformatAufgabenbeschreibung
$fdisplay(fd, arguments) ;Schreibt sequenziell oder bedingt in die Datei, mit automatischem Zeilenumbruch.
$fwrite(fd, arguments) ;Schreibt sequenziell oder bedingt in die Datei, ohne automatischen Zeilenumbruch.
$fstrobe(fd, arguments) ;Strobe-Schreiben in die Datei, nachdem die Anweisung ausgeführt wurde.
$fmonitor(fd, arguments) ;In Datei schreiben, wann immer sich Daten ändern.

Im Vergleich zu den Standard-Anzeigeaufgaben $display, $write, $strobe, $monitor benötigen die Systemaufgaben zum Schreiben in Dateien im Verwendungsformat einen zusätzlichen Dateideskriptor fd, aber alle anderen Ausgabebedingungen und Timing-Eigenschaften stimmen mit ihren entsprechenden Anzeigeaufgaben überein.

Ein Beispiel für das Schreiben in eine Datei im Anhängemodus ist wie folgt:

Beispiel

  //(2) Datei schreiben
   integer fd ;
   integer err, str ;
   initial begin
      fd = $fopen("./DATA_RD.HEX", "a+");  //Am Ende im Anhängemodus öffnen
      err = $ferror(fd, str);
      if (!err) begin
         $fdisplay(fd, "Neue Daten1: %h", fd) ;
         $fdisplay(fd, "Neue Daten2: %h", str) ;
         $fdisplay(fd, "Neue Daten3: %h", err) ;
         //$write(fd, "New data3: %h", err) ; //Letzte Zeile ohne Zeilenumbruch ausgeben
      end
      $fclose(fd);
   end

Öffnen Sie die Datei DATA_RD.HEX, und Sie können sehen, dass 3 Datenzeilen am Ende der Datei hinzugefügt wurden.

Schreiben von Strings

Verilog stellt außerdem die Systemaufgaben $swrite und $sformat bereit, um Daten in Strings zu schreiben.

AufrufformatAufgabenbeschreibung
$swrite(reg, list_of_arguments) ;Schreibt Strings sequenziell oder bedingt in eine Variable reg.
len = $sformat(reg, format_str, arguments) ;Schreibt Strings gemäß dem Format format_str in eine Variable reg.
Das Format stimmt mit dem überein, das von $display angegeben wird.
Es wird nicht empfohlen, den zweiten Parameter format_str wegzulassen.
Kann die Stringlänge len zurückgeben.

Das zweite Parameterformat von $sformat ist vom Typ String, und es wird im Allgemeinen empfohlen, es nicht wegzulassen. Dieser Parameter gibt den Typ der Eingabevariable an. Bei der Angabe des Typs können auch andere Stringinformationen enthalten sein. Für die Typen und die Verwendung siehe die Anzeigefunktion $display. Dieser Parameter kann auch vom Registertyp sein, aber die gespeicherten Daten müssen normale Stringdaten sein.

Beispielcode zum Schreiben von Strings ist wie folgt:

Beispiel

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

      //$swrite schreibt einen String, der Variablen in einem angegebenen Format enthält
      $swrite(str_swrite, "%s age is %d", str_buf, age) ;
      $display("%s", str_swrite);
      //$swrite schreibt direkt einen String ohne Variablen
      $swrite(str_swrite, "years ", "old.") ;
      $display("%s", str_swrite);
      //$swrite schreibt eine Zeichenkette, die Variablen ohne ein angegebenes Format enthält, nicht empfohlen
      $swrite(str_swrite, age) ;
      $display("$swrite Fehlertest: %d", str_swrite);

      $display();
     //$sformat schreibt eine Zeichenkette, die Variablen in einem angegebenen Format enthält
      $sformat(str_sformat, "Ich habe in %s gelernt", str_buf) ;
      $display("%s", str_sformat);
      //$sformat schreibt direkt eine Zeichenkette ohne Variablen und ermittelt die Zeichenkettenlänge
      len = $sformat(str_sformat, "seit 4 Jahren!") ;
      $display("%s", str_sformat);
      $display("$sformat Länge: %d", len);
      //$sformat schreibt direkt mehrere Zeichenketten ohne Variablen auf einmal, nicht empfohlen
      $sformat(str_sformat, "für", "4", "Jahre!") ;
      $display("$sformat Fehlertest: %s", str_sformat);
   end

Wenn man die Leerzeichen in den ausgegebenen Informationen ignoriert, sieht die Debug-Ausgabe wie folgt aus:

Daraus ist ersichtlich, dass $sformat und $swrite auf dieselbe Weise verwendet werden können. Zum Beispiel kann $sformat eine Zeichenkette in einem angegebenen Format schreiben oder eine Zeichenkette ohne Variablen nur einmal schreiben. In diesem Fall entspricht $sformat dem Weglassen der Angabe des Variablentyps im zweiten Parameter, daher sollte der dritte Parameter weggelassen werden.

$swrite kann auch mehrere Zeichenketten ohne Variablen auf einmal schreiben, während $sformat einen solchen Aufruf nicht erlaubt.

Es wird außerdem empfohlen, den Variablentyp anzugeben, wenn $swrite zum Schreiben von Zeichenketten mit Variablen verwendet wird; andernfalls kann das Ergebnis unvorhersehbar sein.

Dateilesen

SystemaufgabeAufrufformat und Beschreibung 
Datei zeichenweise lesenc = $fgetc( fd ) ; 
 Gibt fd-Daten im Zeichenformat an die Variable c aus; c muss mindestens 8 Bit breit sein.
Wenn ein Lesefehler auftritt, ist c gleich EOF(-1); mit $ferror kann der Fehlertyp überprüft werden.
 
Zeichen in Puffer schreibencode = $ungetc(c, fd ) ; 
 Schreibt das Zeichen c in den Puffer der Datei fd.
Der Wert von c wird beim nächsten Aufruf von $fgetc zurückgegeben; der Inhalt der Datei fd selbst ändert sich nicht.
Bei einem normalen Puffer-Schreibvorgang ist der Rückgabecode 0; wenn ein Fehler auftritt, ist der Rückgabecode EOF.
 
Datei zeilenweise lesencode = $fgets(str, fd) 
 Liest kontinuierlich Zeichen, bis die Variable str gefüllt ist, eine Zeile vollständig gelesen wurde oder das Dateiende erreicht ist.
Bei einem normalen Lesevorgang ist der Rückgabecode die Anzahl der gelesenen Zeilen (Male); wenn ein Fehler auftritt, ist code 0.
 
Datei nach Format lesencode = $fscanf(fd, format, args) ; 
 Liest Daten gemäß dem Format format aus der Datei fd in die Variable args.
Zum Format siehe die Formatbeschreibung von $display.
Die Abbruchbedingung für einen Lesevorgang ist ein Leerzeichen oder ein Zeilenumbruch.
Wenn ein Lesefehler auftritt, ist der Rückgabecode 0.
 
Zeichenkette nach Format lesencode = $sscanf(str, format, args) ; 
 Liest die String-Variable str gemäß dem Format format in die Variable args ein.
In die Variable data_get wird der Inhalt in data_get abnormal sein.
 
Datei binär lesen.code = $fread(store, fd, start, count) ; 
 Liest Daten aus der Datei fd im binären Datenstromformat in das Array oder die Registervariable store ein.
start ist die Startadresse der Datei, und count ist die Leselänge.
Wenn start/count nicht angegeben sind, werden alle Daten in die Variable store gefüllt.
Wenn store ein Registertyp ist, sind die Parameter start/count ungültig. Das Lesen wird beendet, nachdem die Variable store einmal mit Daten gefüllt wurde.
 
Als Beispiel wird die Datei DATA_RD.HEX aus der Simulation "file write" als Referenzdatei zum Lesen verwendet. Der Dateiinhalt ist wie folgt.
c0dec0de
5555aaaa
12345678
aaaa5555
New data1: 80000003
New data2: 00000000
New data3: 00000000

Beispiele für $fgetc- und $ungetc-Aufrufe

Beispiel

   //(4.1) Zeichen lesen
   integer      i ;
   reg [31:0]   char_buf ;
   initial begin
      #30 ;
      fd = $fopen("DATA_RD.HEX", "r");
      $write("Zeichen lesen: ");
      err = $ferror(fd, str);
      if (!err) begin
         for (i=0; i<13; i++) begin
            char_buf[7:0] = $fgetc(fd) ;  //Zeichenweise lesen
            $write("%c", char_buf[7:0]) ; //Einzelne Zeichen nacheinander ohne Zeilenumbruch ausgeben
         end
         $write(".\n") ;
      end

      $ungetc("1", fd) ;            //3-mal hintereinander in den Dateipuffer schreiben
      $ungetc("2", fd) ;
      $ungetc("3", fd) ;
      char_buf[7:0]   = $fgetc(fd) ;  //3 lesen
      char_buf[15:8]  = $fgetc(fd) ;  //2 lesen
      char_buf[23:16] = $fgetc(fd) ;  //1 lesen, Lesepufferende
      char_buf[31:24] = $fgetc(fd) ;  //a lesen
      $display("Zeichen nach $ungetc lesen: %s", char_buf);
      $fclose(fd);
   end

Die Simulationsergebnisse sind wie folgt.

Wie aus der Abbildung ersichtlich ist, sind die 13 von $fgetc gelesenen Zeichen korrekt, und die gelesenen Zeichen enthalten Zeilenumbruchzeichen.

Nachdem $ungetc Zeichendaten in den Dateipuffer geschrieben hat, kann anschließend $fgetc verwendet werden, um die Zeichendaten im Dateipuffer zu lesen. Das Lesen/Schreiben folgt dem First-in-Last-out-Prinzip (FILO, First in Last out), was dem Ablegen auf einem Stack entspricht. Wenn die Zeichendaten "123" zuerst geschrieben werden, werden die ausgelesenen Daten "321".

Nachdem der Dateipuffer vollständig gelesen wurde, richten sich die beim erneuten Lesen von Zeichendaten ausgelesenen Daten weiterhin nach der Position des letzten Dateilesevorgangs, d. h. dem Zeichen "a" in "a123" im Protokoll.

Während dieses Vorgangs hat sich der Inhalt der Datei DATA_RD.HEX nie geändert.

Beispiel für einen $fgets-Aufruf

Beispiel

   //(4.2) Zeile lesen
   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  //Zeile für Zeile im Stringformat lesen
            code = $fgets(line_buf[i], fd) ;  //Enthält "\n" am Ende, daher werden 2 Zeilen ausgegeben
            $display("Zeilendaten abrufen%d: %s", i, line_buf[i]) ;
         end
      end
      //Die hexadezimale Anzeige zeigt die entsprechenden ASCII-Code-Zeichen
      $display("Hex-Zeilendaten anzeigen%d: %h", 2, line_buf[2]) ;
      $display("Hex-Zeilendaten anzeigen%d: %h", 4, line_buf[4]) ;
      $fclose(fd) ;
   end

Die Simulationsergebnisse sind wie folgt.

Die ersten 4 Datenzeilen werden als String-Typ gelesen und angezeigt, und die Ergebnisse sind normal.

Beim Lesen der 5. Zeile der Datei muss aufgrund der 100-Bit-Breitenbegrenzung der Variablen line_buf der Dateiinhalt "New data1: 80000003 " in 2 separaten Vorgängen gelesen werden.

Weil jede Zeile mit einem Zeilenumbruchzeichen "\n" endet, wird bei Verwendung der Funktion $display eine zusätzliche Leerzeile ausgegeben.

Beim Lesen als String-Typ und Anzeigen der Daten im Hexadezimalformat kann der entsprechende Dateninhalt der Datei nicht intuitiv angezeigt werden. Zum Beispiel wird in der zweiten Zeile nicht "12345678," angezeigt, sondern der entsprechende ASCII-Code. Daher liest die $fgets-Task gemäß String-Typ; dies muss beachtet werden.

Beispiele für $fscanf- und $sscanf-Aufrufe

Beispiel

   //(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
            //Die ersten 4 Datenzeilen in hexadezimaler Form lesen und anzeigen
            code = $fscanf(fd, "%h", data_buf[i]);
            $display("$fscanf gelesene Daten%d: %h", i, data_buf[i]) ;
         end
         for (i=4; i<6; i++) begin
            //Die letzten 2 Datenzeilen als String-Typ lesen und anzeigen
            code = $fscanf(fd, "%s", string_buf[i]);
            $display("$fscanf gelesene Daten%d: %s", i, string_buf[i]) ;
         end
      end

      //(1) $sscanf Quellvariable data_test ist ein String-Typ
      data_test = "fedcba98" ;
      code = $sscanf(data_test, "%h", data_get);
      $display("$sscanf gelesene Daten0: %h", data_get) ;
      //(2) $sscanf: Zuerst die Quellvariable data_test in eine String-Variable umwandeln
      Code = $sformat(data_test, "%h", data_buf[2]);
      code = $sscanf(data_test, "%h", data_get);
      //Die direkte Eingabe einer hexadezimalen Variablen wird nicht empfohlen
      //code = $sscanf(data_buf[2], "%h", data_get);
      $display("$sscanf gelesene Daten0: %h", data_get) ;
      $fclose(fd) ;
   end

Die Simulationsergebnisse sind wie folgt.

Bei Verwendung von $fscanf zum Lesen und Anzeigen der ersten 4 Zeilen der Datei im Hexadezimalformat und der letzten 2 Zeilen als String-Typ sind alle Ergebnisse normal.

Wenn $sscanf verwendet wird, um den Inhalt eines Quellregisters zu lesen und ihn dann in ein Zielregister zu verschieben, sollte der Inhalt im Quellregister String-Typ-Daten sein.

Zum Beispiel, wenn $sscanf verwendet wird, um die hexadezimalen Daten data_buf zu verschieben

Wenn $sscanf direkt verwendet wird, um die Daten data_buf im Hexadezimalformat zu verschieben

Nur ein geheimer Tipp: Register können direkt einander zugewiesen werden!!!

Beispiel für einen $fread-Aufruf

Beispiel

   //(4.4) $fread
   reg [71:0]   bin_buf [3:0] ; //Jede Zeile enthält 8 Datenelemente vom Typ Wort und 1 Zeilenumbruchzeichen
   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); //Array-Typ-Lesen, 4-mal lesen
         $display("$fread read data %h", bin_buf[0]) ;//Hexadezimale Anzeige
         $display("$fread read data %h", bin_buf[1]) ;
         $display("$fread read data %s", bin_buf[2]) ;//String-Anzeige
         $display("$fread read data %s", bin_buf[3]) ;
      end

      fd = $fopen("DATA_RD.HEX", "r");
      code = $fread(bin_reg, fd); //Einzelregister-Lesen
      $display("$fread read data %h", bin_reg) ;
      $fclose(fd) ;
   end

Die Simulationsergebnisse sind wie folgt.

Wenn $fread eine Datei binär liest, sind sowohl die Startadresse als auch die Leselänge Parameter zum Festlegen von Variablen des Array-Typs.

Wenn der die Daten speichernde Variablentyp ein Nicht-Array-Reg-Typ ist, wird nur ein Lesevorgang ausgeführt, bis die Reg-Typ-Variable vollständig gefüllt ist.

Dateipositionierung

SystemaufgabenAufrufformatAufgabenbeschreibung
Dateiposition ermittelnpos = $ftell( fd ) ;Gibt den Offset der aktuellen Dateiposition vom Dateianfang zurück; die Anfangsadresse ist 0.
Der Offset wird in Bytes als eine Einheit (8 Bit) gemessen.
Wird zusammen mit $fseek verwendet.
Verschiebungcode = $fseek(fd, offset, type) ;Legt die Position für die nächste Eingabe oder Ausgabe der Datei fest.
offset ist der festgelegte Offset-Wert.
type ist der Operationstyp des Offsets.
--- 0: Setzt die Position auf die Offset-Adresse.
--- 1: Setzt die Position auf die aktuelle Position plus den Offset.
--- 2: Setzt die Position auf das Dateiende plus den Offset. Negative Zahlen werden oft verwendet, um einen Offset rückwärts vom Dateiende darzustellen.
Relokation ohne Offsetcode = $rewind( fd ) ;Entspricht $fseek( fd, 0, 0);
Dateiende ermittelncode = $feof(fd) ;Ermitteln, ob das Ende der Datei erreicht wurde.
Gibt 1 zurück, wenn das Dateiende erkannt wird; andernfalls gibt es 0 zurück.

Der Inhalt der Datei DATA_RD.HEX kann wie folgt dargestellt werden.

Mit dem Zeilenumbruchzeichen "\n" als Terminator beträgt die Dateigröße: 4x9 + 3x20 = 96 Bytes.

Der Testcode für die Dateipositionierung lautet wie folgt:

Beispiel

   // Dateiposition
   reg [31:0]   data4 ;      //Die Länge der Registervariable beträgt 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
         //erstes Lesen
         Code = $fscanf(fd, "%h", data4);//Lesen ab Position 0 starten
         pos  = $ftell(fd);      //Nach dem Lesen von 8 Bytes ist die Position 8, die Koordinaten sind (0,8)
         $display("Position nach dem Lesen: %d", pos) ;
         $display("Erste gelesene Daten: %h", data4) ;

         //Typ = 0
         Code = $fseek(fd, 4, 0) ; //Lesen ab Position 4 starten, Koordinaten (0,4)
         Code = $fscanf(fd, "%h", data4); //Stoppen, wenn ein Zeilenumbruchzeichen gelesen wird
         pos  = $ftell(fd);      //Nach dem Lesen von 4 Bytes ist die Position 8, die Koordinaten sind (0,8)
         $display("Typ 0: aktuelle Position: %d", pos) ;
         $display("Typ 0: gelesene Daten: %h", data4) ;
         //Typ = 1
         code = $fseek(fd, 4, 1) ; //Lesen ab Position 4+9=12 starten, bei Koordinaten (1,3)
         Code = $fscanf(fd, "%h", data4); //Stoppen, wenn ein Zeilenumbruchzeichen gelesen wird
         pos  = $ftell(fd);      //Nach dem Lesen von 5 Bytes ist die Position 17, die Koordinaten sind (1,8)
         $display("Typ 1: aktuelle Position: %d", pos) ;
         $display("Typ 1: gelesene Daten: %h", data4) ;
         //Typ = 2
         code = $fseek(fd, -(96-31), 2) ; //Lesen ab Position 31 starten, Koordinaten (3,4)
         Code = $fscanf(fd, "%h", data4);
         pos  = $ftell(fd);      //Nach dem Lesen von 4 Bytes ist die Position 35, die Koordinaten sind (3,8)
         $display("Typ 2: aktuelle Position: %d", pos) ;
         $display("Typ 2: gelesene Daten: %h", data4) ;

         //rewind lesen
         code   = $rewind(fd) ;//Dateizeigerposition auf den Anfang der Datei zurücksetzen
         pos    = $ftell(fd);  //Die Position ist an dieser Stelle 0
         $display("Position nach $rewind: %d", pos) ;
         //gesamten Inhalt der Datei lesen
         while (!$feof(fd)) begin
            code   = $fgets(str_long, fd);
            $write("Gelesen: %s", str_long) ;
         end
         $fclose(fd) ;
      end
   end

Die Simulationsergebnisse sind wie folgt.

Wie aus der Abbildung ersichtlich ist, wird am Ende des Protokolls eine zusätzliche Datenzeile ausgegeben. Das liegt daran, dass sich am Ende der Datei DATA_RD.TXT noch eine leere Zeile befindet (das Ergebnis einer Zeilenumbruchoperation). Die Systemtask $feof betrachtet diese leere Zeile nicht als Dateiende, daher ist der Rückgabewert weiterhin 0. Diese Zeile enthält jedoch tatsächlich keine Daten, sodass die gelesenen Daten unkontrollierbar sind.

Um den Einfluss des Zeilenumbruchzeichens in der letzten Datenzeile der Datei zu beseitigen, kann die letzte dateischreibende Systemtask $fdisplay im Beispiel "Datei schreiben" durch $write ersetzt werden.

Der Rest des Protokolls zeigt zusammen mit den Codekommentaren, dass die Simulation korrekt ist, daher wird hier keine einheitliche Erklärung gegeben.

Speicher wird geladen

SystemaufgabenAufrufformat und Beschreibung 
Hexadezimale Datei laden$readmemh("fname", mem, start_addr, finish_addr) 
 fname ist der Name der Datendatei.
mem ist eine Variable vom Array- oder Speichertyp.
start_addr und finish_addr sind die Start- bzw. Endadresse.
start_addr und finish_addr können weggelassen werden. In diesem Fall ist die Bedingung für das Beenden des Datenladens, dass die Speichervariable mem vollständig gefüllt ist oder die Datei vollständig gelesen wurde.
Der Dateiinhalt sollte nur Whitespace-Zeichen (oder Zeilenumbruch-/Leerzeichen), Binär- oder Hexadezimaldaten enthalten.
Kommentare werden mit "//" gekennzeichnet. Es wird empfohlen, Zeilenumbruchzeichen zu verwenden, um Daten zu trennen.
 
Binärdatei laden$readmemb("fname", mem, start_addr, finish_addr) 
 Das Anwendungsformat ist dasselbe wie bei $readmemb. 

Der Inhalt der Datei DATA_WITHNOTE.HEX lautet wie folgt. Lade den Inhalt dieser Datei in eine Speichervariable.

Der Beispielcode lautet wie folgt:

Beispiel

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

Die Simulationsergebnisse sind wie folgt:

Quellcode für dieses Kapitel herunterladen

Herunterladen