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
| Systemaufgabe | Aufrufformat | Aufgabenbeschreibung |
|---|---|---|
| Datei öffnen | fd = $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 |
| Dateifehler | err = $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
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:
| r | Eine Textdatei nur zum Lesen öffnen; nur das Lesen von Daten erlauben. |
|---|---|
| w | Eine 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. |
| a | Eine Textdatei im Anhängemodus öffnen und Daten am Ende der Datei schreiben. Wenn die Datei nicht existiert, wird eine neue Datei erstellt. |
| rb | Eine Binärdatei nur zum Lesen öffnen; nur das Lesen von Daten erlauben. |
| wb | Eine Binärdatei nur zum Schreiben öffnen oder erstellen; nur das Schreiben von Daten erlauben. |
| ab | Eine 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.
| Aufrufformat | Aufgabenbeschreibung |
|---|---|
| $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
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.
| Aufrufformat | Aufgabenbeschreibung |
|---|---|
| $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
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
| Systemaufgabe | Aufrufformat und Beschreibung | |
|---|---|---|
| Datei zeichenweise lesen | c = $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 schreiben | code = $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 lesen | code = $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 lesen | code = $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 lesen | code = $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. |
c0dec0de 5555aaaa 12345678 aaaa5555 New data1: 80000003 New data2: 00000000 New data3: 00000000
Beispiele für $fgetc- und $ungetc-Aufrufe
Beispiel
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
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
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
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
| Systemaufgaben | Aufrufformat | Aufgabenbeschreibung |
|---|---|---|
| Dateiposition ermitteln | pos = $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. |
| Verschiebung | code = $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 Offset | code = $rewind( fd ) ; | Entspricht $fseek( fd, 0, 0); |
| Dateiende ermitteln | code = $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
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
| Systemaufgaben | Aufrufformat 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
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