Verilog fournit de nombreuses tâches système pouvant manipuler des fichiers. Les tâches système couramment utilisées comprennent principalement :
- Ouverture/fermeture de fichier : $fopen, $fclose, $ferror
- Écriture dans un fichier : $fdisplay, $fwrite, $fstrobe, $fmonitor
- Écriture de chaîne : $sformat, $swrite
- Lecture de fichier : $fgetc, $fgets, $fscanf, $fread
- Positionnement dans un fichier : $fseek, $ftell, $feof, $frewind
- Chargement de mémoire : $readmemh, $readmemb
Lors de l'utilisation de tâches d'opération sur fichiers (en faisant particulièrement attention à $sforamt, $gets, $sscanf, etc.) pour manipuler des fichiers, vous devez déterminer quelle tâche système utiliser en fonction de la nature du fichier et du contenu des variables, et garantir la cohérence des paramètres et des types de variables de lecture/écriture avec le contenu du fichier. Ne confondez pas les types chaîne avec les types multi-radix.
Ouverture/Fermeture de fichier
| Tâche système | Format d'appel | Description de la tâche |
|---|---|---|
| Ouverture de fichier | fd = $fopen("fname", mode) ; | fname est le nom du fichier à ouvrir fd est le descripteur de fichier 32 bits renvoyé --- Lorsque l'ouverture est correcte, fd est non nul --- Lorsqu'une erreur se produit à l'ouverture, fd est égal à zéro mode est utilisé pour spécifier le mode d'ouverture du fichier |
| Fermeture de fichier | $fclose(fd) ; | Fermer le fichier correspondant décrit par fd |
| Erreur de fichier | err = $ferror(fd, str) ; | Lorsque le fichier est ouvert normalement : --- err et str valent tous les deux zéro, Lorsqu'une erreur se produit lors de l'ouverture du fichier : --- err renvoie une valeur non nulle pour indiquer une erreur --- str renvoie une valeur non nulle contenant le type d'erreur --- La recommandation officielle est que la longueur de str soit de 640 bits |
L'exemple de code est le suivant :
Exemple
integer fd1, fd2 ;
integer err1, err2 ;
reg [320:0] str1, str2 ; //La variable pour le type d'erreur peut aussi être un type de chaîne pris en charge
initial begin
//fichier existant
fd1 = $fopen("./DATA_RD.HEX", "r"); //Ouvrir un fichier existant
err1 = $ferror(fd1, str1);
$display("Le descripteur de File1 est : %h.", fd1 );//Valeur non nulle
$display("Le numéro d'Error1 est : %h.", err1 ); //0
$display("L'info d'Error2 est : %s.", str1 ); //0
$fclose(fd1);
//fichier inexistant
fd2 = $fopen("../../FILE_NOEXIST.HEX", "r");//Le fichier ouvert n'existe pas
err2 = $ferror(fd2, str2);
$display("Le descripteur de File2 est : %h.", fd2 ); //0
$display("Le numéro d'Error2 est : %h.", err2 ); //Valeur non nulle
$display("L'info d'Error2 est : %s.", str2 ); //Valeur non nulle
$fclose(fd2);
end
Les types de mode d'ouverture de fichier et leurs descriptions sont les suivants :
| r | Ouvrir un fichier texte en lecture seule, autoriser uniquement la lecture des données. |
|---|---|
| w | Ouvrir un fichier texte en écriture seule, autoriser uniquement l'écriture des données. Si le fichier existe, le contenu d'origine du fichier sera supprimé. Si le fichier n'existe pas, créer un nouveau fichier. |
| a | Ouvrir un fichier texte en mode ajout, et écrire des données à la fin du fichier. Si le fichier n'existe pas, créer un nouveau fichier. |
| rb | Ouvrir un fichier binaire en lecture seule, autoriser uniquement la lecture des données. |
| wb | Ouvrir ou créer un fichier binaire en écriture seule, autoriser uniquement l'écriture des données. |
| ab | Ouvrir un fichier binaire en mode ajout, et écrire des données à la fin du fichier. |
| r+ | Ouvrir un fichier texte en lecture et en écriture, en autorisant à la fois la lecture et l'écriture. |
| w+ | Ouvrir ou créer un fichier texte pour la lecture et l'écriture, permettant à la fois la lecture et l'écriture. Si le fichier existe, le contenu d'origine du fichier sera supprimé. Si le fichier n'existe pas, créer un nouveau fichier. |
| a+ | Ouvrir un fichier texte en lecture et écriture, permettant à la fois la lecture et l'écriture. Si le fichier n'existe pas, créer un nouveau fichier. La lecture commence au début du fichier, l'écriture se fait uniquement en mode ajout. |
| rb+ | Ouvrir un fichier binaire en lecture et écriture, similaire à "r+". |
| wb+ | Ouvrir ou créer un fichier binaire en lecture et écriture, similaire à "w+". |
| ab+ | Ouvrir un fichier binaire en lecture et écriture, similaire à "a+". |
Écriture de fichiers
Les tâches système pour l'écriture de fichiers comprennent principalement : $fdisplay, $fwrite, $fstrobe, $fmonitor, ainsi que leurs tâches système correspondantes avec des formats intégrés tels que $fdisplayb, $fdisplayh, $fdisplayo, etc.
| Format d'appel | Description de la tâche |
|---|---|
| $fdisplay(fd, arguments) ; | Écrire dans le fichier de manière séquentielle ou conditionnelle, avec saut de ligne automatique. |
| $fwrite(fd, arguments) ; | Écrire dans le fichier de manière séquentielle ou conditionnelle, sans saut de ligne automatique. |
| $fstrobe(fd, arguments) ; | Écrire dans le fichier en mode strobe après l'exécution de l'instruction. |
| $fmonitor(fd, arguments) ; | Écrire dans un fichier chaque fois que les données changent. |
Par rapport aux tâches d'affichage standard $display, $write, $strobe, $monitor, les tâches système d'écriture dans un fichier nécessitent un descripteur de fichier fd supplémentaire dans le format d'utilisation, mais toutes les autres conditions d'impression et caractéristiques temporelles sont cohérentes avec leurs tâches d'affichage correspondantes.
Un exemple d'écriture dans un fichier en mode ajout est le suivant :
Exemple
integer fd ;
integer err, str ;
initial begin
fd = $fopen("./DATA_RD.HEX", "a+"); //Ouvrir en mode ajout à la fin
err = $ferror(fd, str);
if (!err) begin
$fdisplay(fd, "Nouvelle donnée1 : %h", fd) ;
$fdisplay(fd, "Nouvelle donnée2 : %h", str) ;
$fdisplay(fd, "Nouvelle donnée3 : %h", err) ;
//$write(fd, "New data3: %h", err) ; //Affiche la dernière ligne sans saut de ligne
end
$fclose(fd);
end
Ouvrez le fichier DATA_RD.HEX, et vous pouvez constater que 3 lignes de données ont été ajoutées à la fin du fichier.
Écriture de chaînes
Verilog fournit également les tâches système $swrite et $sformat pour écrire des données dans des chaînes.
| Format d'appel | Description de la tâche |
|---|---|
| $swrite(reg, list_of_arguments) ; | Écrire des chaînes dans une variable reg de manière séquentielle ou conditionnelle. |
| len = $sformat(reg, format_str, arguments) ; | Écrire des chaînes dans une variable reg selon le format format_str. Le format est conforme à celui spécifié par $display. Il n'est pas recommandé d'omettre le deuxième paramètre format_str. Peut renvoyer la longueur de chaîne len. |
Le deuxième paramètre de format de $sformat est de type chaîne, et il est généralement recommandé de ne pas l'omettre. Ce paramètre spécifie le type de la variable d'entrée. Lors de la spécification du type, d'autres informations de chaîne peuvent également être incluses. Pour les types et l'utilisation, reportez-vous à la fonction d'affichage $display. Ce paramètre peut également être de type registre, mais les données stockées doivent être des données de chaîne normales.
Un exemple de code pour écrire des chaînes est le suivant :
Exemple
reg [299:0] str_swrite, str_sformat;
reg [63:0] str_buf ;
integer len, age ;
initial begin
#20 ;
str_buf = "example!" ;
age = 9 ;
//$swrite écrit une chaîne contenant des variables dans un format spécifié
$swrite(str_swrite, "%s age is %d", str_buf, age) ;
$display("%s", str_swrite);
//$swrite écrit directement une chaîne sans variables
$swrite(str_swrite, "years ", "old.") ;
$display("%s", str_swrite);
//$swrite écrit une chaîne contenant des variables sans format spécifié, non recommandé
$swrite(str_swrite, age) ;
$display("$swrite test d'erreur : %d", str_swrite);
$display();
//$sformat écrit une chaîne contenant des variables dans un format spécifié
$sformat(str_sformat, "J'ai appris en %s", str_buf) ;
$display("%s", str_sformat);
//$sformat écrit directement une chaîne sans variables et obtient la longueur de la chaîne
len = $sformat(str_sformat, "pendant 4 ans !") ;
$display("%s", str_sformat);
$display("$sformat longueur : %d", len);
//$sformat écrit directement plusieurs chaînes sans variables en une seule fois, non recommandé
$sformat(str_sformat, "pendant", "4", "ans !") ;
$display("$sformat test d'erreur : %s", str_sformat);
end
En ignorant les espaces dans les informations imprimées, la sortie de débogage est la suivante :
À partir de cela, nous pouvons voir que $sformat et $swrite peuvent être utilisés de la même manière. Par exemple, $sformat peut écrire une chaîne dans un format spécifié, ou écrire une chaîne sans variables une seule fois. Dans ce cas, $sformat équivaut à ne pas spécifier le type de variable dans le deuxième paramètre, donc le troisième paramètre doit être omis.
$swrite peut également écrire plusieurs chaînes sans variables en une seule fois, alors que $sformat ne permet pas un tel appel.
Il est également recommandé de spécifier le type de variable lors de l'utilisation de $swrite pour écrire des chaînes contenant des variables ; sinon, le résultat peut être imprévisible.
Lecture de fichier
| Tâche système | Format d'appel et description | |
|---|---|---|
| Lire le fichier caractère par caractère | c = $fgetc( fd ) ; | |
| Sortir les données de fd vers la variable c au format caractère ; c doit avoir une largeur d'au moins 8 bits. Lorsqu'une erreur de lecture se produit, c est égal à EOF(-1) ; vous pouvez utiliser $ferror pour vérifier le type d'erreur. | ||
| Écrire un caractère dans le tampon | code = $ungetc(c, fd ) ; | |
| Écrire le caractère c dans le tampon du fichier fd. La valeur de c est renvoyée lors du prochain appel à $fgetc ; le contenu du fichier fd lui-même ne change pas. Lors d'une écriture normale dans le tampon, le code de valeur de retour est 0 ; lorsqu'une erreur se produit, le code de valeur de retour est EOF. | ||
| Lire un fichier ligne par ligne | code = $fgets(str, fd) | |
| Lire des caractères en continu jusqu'à ce que la variable str soit remplie, ou qu'une ligne soit lue complètement, ou que la fin du fichier soit atteinte. Lors d'une lecture normale, le code de valeur de retour est le nombre de lignes (fois) lues ; lorsqu'une erreur se produit, le code est 0. | ||
| Lire un fichier selon un format | code = $fscanf(fd, format, args) ; | |
| Lire les données du fichier fd dans la variable args selon le format format. Pour le format, reportez-vous à la description du format de $display. La condition d'arrêt pour une lecture est un espace ou un saut de ligne. Lorsqu'une erreur de lecture se produit, le code de valeur de retour est 0. | ||
| Lire une chaîne selon un format | code = $sscanf(str, format, args) ; | |
| Lire la variable de type chaîne str dans la variable args selon le format format. dans la variable data_get, le contenu de data_get sera anormal. | ||
| Lire le fichier en binaire. | code = $fread(store, fd, start, count) ; | |
| Lire les données du fichier fd dans un tableau ou dans la variable de registre store au format de flux de données binaires. start est l'adresse de début du fichier, et count est la longueur de lecture. Si start/count ne sont pas spécifiés, toutes les données seront remplies dans la variable store. Si store est de type registre, les paramètres start/count sont invalides. La lecture s'arrête après que la variable store a été remplie une fois avec des données. |
c0dec0de 5555aaaa 12345678 aaaa5555 New data1: 80000003 New data2: 00000000 New data3: 00000000
Exemples d'appels de $fgetc et $ungetc
Exemple
entier 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) ; //Lire caractère par caractère
$write("%c", char_buf[7:0]) ; //Afficher les caractères un par un sans saut de ligne
end
$write(".\n") ;
end
$ungetc("1", fd) ; //Écrire dans le tampon du fichier 3 fois consécutivement
$ungetc("2", fd) ;
$ungetc("3", fd) ;
char_buf[7:0] = $fgetc(fd) ; //lire 3
char_buf[15:8] = $fgetc(fd) ; //lire 2
char_buf[23:16] = $fgetc(fd) ; //lire 1，fin du tampon de lecture
char_buf[31:24] = $fgetc(fd) ; //lire a
$display("Lire le caractère après $ungetc : %s", char_buf);
$fclose(fd);
end
Les résultats de la simulation sont les suivants.
Comme le montre la figure, les 13 caractères lus par $fgetc sont corrects, et les caractères lus comprennent des caractères de saut de ligne.
Une fois que $ungetc a écrit des données de caractères dans le tampon de fichier, $fgetc peut ensuite être utilisé pour lire les données de caractères dans le tampon de fichier. La lecture/écriture suit le principe premier entré, dernier sorti (FILO, First in Last out), ce qui équivaut à empiler sur une pile. Lorsque les données de caractères "123" sont écrites en premier, les données lues sont "321".
Une fois que le tampon de fichier a été entièrement lu, lorsque la lecture des données de caractères est effectuée à nouveau, les données lues suivent toujours la position de la dernière lecture de fichier, c'est-à-dire le caractère "a" dans "a123" dans le journal.
Pendant ce processus, le contenu du fichier DATA_RD.HEX n'a jamais changé.
Exemple d'appel de $fgets
Exemple
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 //Lire ligne par ligne au format chaîne
code = $fgets(line_buf[i], fd) ; //Contient "\n" à la fin, donc 2 lignes seront imprimées
$display("Obtenir les données de ligne%d: %s", i, line_buf[i]) ;
end
end
//L'affichage hexadécimal montrera les caractères de code ASCII correspondants
$display("Afficher les données de ligne en hexadécimal%d: %h", 2, line_buf[2]) ;
$display("Afficher les données de ligne en hexadécimal%d: %h", 4, line_buf[4]) ;
$fclose(fd) ;
end
Les résultats de la simulation sont les suivants.
Les 4 premières lignes de données sont lues et affichées en tant que type chaîne, et les résultats sont normaux.
Lors de la lecture de la 5ème ligne du fichier, en raison de la limite de largeur de 100 bits de la variable line_buf, le contenu du fichier "New data1: 80000003 " doit être lu en 2 opérations distinctes.
Parce que chaque ligne se termine par un caractère de nouvelle ligne "\n", une ligne vide supplémentaire sera imprimée lors de l'utilisation de la fonction $display.
Lors de la lecture en tant que type chaîne et de l'affichage des données en hexadécimal, le contenu de données correspondant du fichier ne peut pas être affiché de manière intuitive. Par exemple, la deuxième ligne n'affiche pas "12345678," mais plutôt son code ASCII correspondant. Par conséquent, la tâche $fgets lit selon le type chaîne ; cela nécessite une attention particulière.
Exemples d'appels à $fscanf et $sscanf
Exemple
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
//Lire et afficher les 4 premières lignes de données en hexadécimal
code = $fscanf(fd, "%h", data_buf[i]);
$display("$fscanf a lu les données%d: %h", i, data_buf[i]) ;
end
for (i=4; i<6; i++) begin
//Lire et afficher les 2 dernières lignes de données en tant que type chaîne
code = $fscanf(fd, "%s", string_buf[i]);
$display("$fscanf a lu les données%d: %s", i, string_buf[i]) ;
end
end
//(1) $sscanf la variable source data_test est de type chaîne
data_test = "fedcba98" ;
code = $sscanf(data_test, "%h", data_get);
$display("$sscanf a lu les données0: %h", data_get) ;
//(2) $sscanf: d'abord convertir la variable source data_test en une variable de type chaîne
code = $sformat(data_test, "%h", data_buf[2]);
code = $sscanf(data_test, "%h", data_get);
//Il n'est pas recommandé de saisir directement une variable hexadécimale
//code = $sscanf(data_buf[2], "%h", data_get);
$display("$sscanf a lu les données0: %h", data_get) ;
$fclose(fd) ;
end
Les résultats de la simulation sont les suivants.
L'utilisation de $fscanf pour lire et afficher les 4 premières lignes du fichier en hexadécimal et les 2 dernières lignes en tant que type chaîne, tous les résultats sont normaux.
Lors de l'utilisation de $sscanf pour lire le contenu d'un registre source puis le déplacer vers un registre de destination, le contenu du registre source doit être une donnée de type chaîne.
Par exemple, lors de l'utilisation de $sscanf pour déplacer les données hexadécimales data_buf
Si $sscanf est utilisé directement pour déplacer les données data_buf au format hexadécimal
Juste une astuce secrète : les registres peuvent être directement assignés entre eux !!!
Exemple d'appel de $fread
Exemple
reg [71:0] bin_buf [3:0] ; //Chaque ligne contient 8 éléments de données de type mot et 1 caractère de retour à la ligne
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); //Lecture de type tableau, lire 4 fois
$display("$fread read data %h", bin_buf[0]) ;//Affichage hexadécimal
$display("$fread read data %h", bin_buf[1]) ;
$display("$fread read data %s", bin_buf[2]) ;//Affichage de chaîne
$display("$fread read data %s", bin_buf[3]) ;
end
fd = $fopen("DATA_RD.HEX", "r");
code = $fread(bin_reg, fd); //Lecture d'un seul registre
$display("$fread read data %h", bin_reg) ;
$fclose(fd) ;
end
Les résultats de la simulation sont les suivants.
Lorsque $fread lit un fichier en binaire, l'adresse de début et la longueur de lecture sont tous deux des paramètres pour définir des variables de type tableau.
Si le type de variable qui stocke les données est un type reg non tableau, une seule lecture sera effectuée jusqu'à ce que la variable de type reg soit entièrement remplie.
Positionnement dans le fichier
| Tâches système | Format d’appel | Description de la tâche |
|---|---|---|
| Obtenir la position dans le fichier | pos = $ftell( fd ) ; | Renvoie le décalage de la position actuelle du fichier par rapport au début du fichier ; l'adresse initiale est 0. Le décalage est mesuré en octets comme une unité (8 bits). Utilisé avec $fseek. |
| Repositionnement | code = $fseek(fd, offset, type) ; | Définit la position de la prochaine entrée ou sortie du fichier. offset est la valeur de décalage définie. type est le type d'opération du décalage. --- 0 : Définit la position à l'adresse de décalage. --- 1 : Définit la position à la position actuelle plus le décalage. --- 2 : Définit la position à la fin du fichier plus le décalage. Des nombres négatifs sont souvent utilisés pour représenter un décalage vers l'arrière depuis la fin du fichier. |
| Repositionnement sans décalage | code = $rewind( fd ) ; | Équivalent à $fseek( fd, 0, 0); |
| Déterminer la fin du fichier | code = $feof(fd) ; | Déterminer si la fin du fichier a été atteinte. Renvoie 1 lorsque la fin du fichier est détectée ; sinon, renvoie 0. |
Le contenu du fichier DATA_RD.HEX peut être représenté comme suit.
Avec le caractère de nouvelle ligne "\n" comme terminateur, la taille du fichier est : 4x9 + 3x20 = 96 octets.
Le code de test de positionnement dans le fichier est le suivant :
Exemple
reg [31:0] data4 ; //La longueur de la variable de registre est de 4 octets
reg [199:0] str_long ;
integer pos ;
initial begin
#40 ;
fd = $fopen("DATA_RD.HEX", "r");
err = $ferror(fd, str);
if (!err) begin
//première lecture
code = $fscanf(fd, "%h", data4);//Commencer la lecture à partir de la position 0
pos = $ftell(fd); //Après lecture de 8 octets, la position est 8, les coordonnées sont (0,8)
$display("Position après lecture : %d", pos) ;
$display("Données de la 1re lecture : %h", data4) ;
//type = 0
code = $fseek(fd, 4, 0) ; //Commencer la lecture à partir de la position 4, coordonnées (0,4)
code = $fscanf(fd, "%h", data4); //Arrêter lorsqu'un caractère de nouvelle ligne est lu
pos = $ftell(fd); //Après lecture de 4 octets, la position est 8, les coordonnées sont (0,8)
$display("type 0 : position actuelle : %d", pos) ;
$display("type 0 : données lues : %h", data4) ;
//type = 1
code = $fseek(fd, 4, 1) ; //Commencer la lecture à partir de la position 4+9=12, aux coordonnées (1,3)
code = $fscanf(fd, "%h", data4); //Arrêter lorsqu'un caractère de nouvelle ligne est lu
pos = $ftell(fd); //Après lecture de 5 octets, la position est 17, les coordonnées sont (1,8)
$display("type 1 : position actuelle : %d", pos) ;
$display("type 1 : données lues : %h", data4) ;
//type = 2
code = $fseek(fd, -(96-31), 2) ; //Commencer la lecture à partir de la position 31, coordonnées (3,4)
code = $fscanf(fd, "%h", data4);
pos = $ftell(fd); //Après lecture de 4 octets, la position est 35, les coordonnées sont (3,8)
$display("type 2 : position actuelle : %d", pos) ;
$display("type 2 : données lues : %h", data4) ;
//lecture après rembobinage
code = $rewind(fd) ;//Réinitialiser la position du pointeur de fichier au début du fichier
pos = $ftell(fd); //La position est 0 à ce stade
$display("Position après $rewind : %d", pos) ;
//lire tout le contenu du fichier
while (!$feof(fd)) begin
code = $fgets(str_long, fd);
$write("Lu : %s", str_long) ;
end
$fclose(fd) ;
end
end
Les résultats de la simulation sont les suivants.
Comme on peut le voir sur la figure, une ligne de données supplémentaire est imprimée à la fin du journal. Cela est dû au fait qu'il reste une ligne vide à la fin du fichier DATA_RD.TXT (le résultat d'une opération de retour à la ligne). La tâche système $feof ne considère pas cette ligne vide comme la fin du fichier, donc la valeur de retour est toujours 0. Cependant, cette ligne ne contient en réalité aucune donnée, donc les données lues sont incontrôlables.
Pour éliminer l'influence du caractère de retour à la ligne dans la dernière ligne de données du fichier, la dernière tâche système d'écriture de fichier $fdisplay dans l'exemple « écriture de fichier » peut être remplacée par $write.
Le reste du journal, combiné aux commentaires du code, montre que la simulation est correcte, donc aucune explication unifiée n'est donnée ici.
Chargement de la mémoire
| Tâches système | Format d'appel et description | |
|---|---|---|
| Charger un fichier hexadécimal | $readmemh("fname", mem, start_addr, finish_addr) | |
| fname est le nom du fichier de données. mem est une variable de type tableau/mémoire. start_addr et finish_addr sont respectivement l'adresse de début et l'adresse de fin. start_addr et finish_addr peuvent être omis. Dans ce cas, la condition d'arrêt du chargement des données est que la variable mémoire mem soit entièrement remplie, ou que le fichier ait été entièrement lu. Le contenu du fichier ne doit contenir que des caractères d'espacement (ou des caractères de saut de ligne/espace), des données binaires ou hexadécimales. Les commentaires sont marqués par "//". Il est recommandé d'utiliser des caractères de saut de ligne pour séparer les données. | ||
| Charger un fichier binaire | $readmemb("fname", mem, start_addr, finish_addr) | |
| Le format d'utilisation est le même que celui de $readmemb. |
Le contenu du fichier DATA_WITHNOTE.HEX est le suivant. Chargez le contenu de ce fichier dans une variable mémoire.
Le code d'exemple est le suivant :
Exemple
reg [31:0] mem_load [3:0] ;
initial begin
#50 ;
$readmemh("./DATA_WITHNOTE.HEX", mem_load);
$display("Lecture mémoire1 : %h", mem_load[0]) ;
$display("Lecture mémoire2 : %h", mem_load[1]) ;
$display("Lecture mémoire3 : %h", mem_load[2]) ;
$display("Lecture mémoire4 : %h", mem_load[3]) ;
end
Les résultats de simulation sont les suivants :
Télécharger le code source de ce chapitre
Téléchargement