FIFO (Premier entré, premier sorti) est une mémoire fréquemment utilisée dans la transmission de données asynchrones. Sa caractéristique est que les données sont premier entré, premier sorti (dernier entré, dernier sorti). En fait, le problème de transmission asynchrone de données de plusieurs bits de large, que ce soit d'une horloge rapide vers un domaine d'horloge lente ou d'une horloge lente vers un domaine d'horloge rapide, peut être géré avec une FIFO.
Principe de la FIFO
Workflow
Après la réinitialisation, sous le contrôle de l'horloge d'écriture et des signaux d'état, les données sont écrites dans la FIFO. L'adresse d'écriture de la RAM commence à 0. Chaque fois que des données sont écrites, le pointeur d'adresse d'écriture s'incrémente de un pour pointer vers la cellule mémoire suivante. Lorsque la FIFO est pleine, les données ne peuvent plus être écrites ; sinon, des données seront perdues par écrasement.
Lorsque les données de la FIFO sont dans un état non vide ou plein, sous le contrôle de l'horloge de lecture et des signaux d'état, les données peuvent être lues depuis la FIFO. L'adresse de lecture de la RAM commence à 0. Chaque fois que des données sont lues, le pointeur d'adresse de lecture s'incrémente de un pour pointer vers la cellule mémoire suivante. Lorsque la FIFO est vide à la lecture, plus aucune donnée ne peut être lue ; sinon, les données lues seront erronées.
La structure de stockage de la FIFO est une RAM à double port, de sorte que la lecture et l'écriture peuvent être effectuées simultanément. Le schéma typique de la structure d'une FIFO asynchrone est présenté ci-dessous. Les ports et les signaux internes seront expliqués lors de l'écriture du code.

Temporisation de lecture/écriture
En ce qui concerne la temporisation d'écriture, tant que les données de la FIFO ne sont pas pleines, des opérations d'écriture peuvent être effectuées ; si la FIFO est pleine, l'écriture de données supplémentaires est interdite.
En ce qui concerne la temporisation de lecture, tant que les données de la FIFO ne sont pas vides, des opérations de lecture peuvent être effectuées ; si la FIFO est vide, la lecture de données supplémentaires est interdite.
Dans tous les cas, pendant une période normale de lecture/écriture FIFO, si la lecture et l'écriture sont effectuées simultanément, le débit d'écriture de la FIFO ne doit pas être supérieur au débit de lecture.
État vide de lecture
Au début de la réinitialisation, la FIFO ne contient aucune donnée et le signal d'état vide est valide. Après l'écriture de données dans la FIFO, le signal d'état vide est mis à l'état bas et devient invalide. Lorsque l'adresse de lecture des données rattrape l'adresse d'écriture, c'est-à-dire lorsque les adresses de lecture et d'écriture sont égales, la FIFO est à l'état vide.
Comme il s'agit d'une FIFO asynchrone, lors de la comparaison des adresses de lecture et d'écriture, une logique de synchronisation par échantillonnage de registres est nécessaire, ce qui prend un certain temps. Par conséquent, le signal indicateur d'état vide n'est pas en temps réel et présente un certain retard. Si de nouvelles données sont écrites dans la FIFO pendant cette période de retard, il peut se produire un phénomène où le signal indicateur d'état vide est valide alors qu'il y a en réalité des données dans la FIFO.
À proprement parler, cette indication d'état vide est erronée. Cependant, le but de la génération de l'état vide est d'empêcher les opérations de lecture de lire des données depuis une FIFO vide. Lorsque le signal d'état vide est généré, la FIFO contient en réalité des données, ce qui équivaut à évaluer le signal d'état vide à l'avance. À ce stade, il n'y a pas de risque à arrêter la lecture des données de la FIFO. Par conséquent, cette conception est correcte du point de vue de l'application.
État plein d'écriture
Au début de la réinitialisation, la FIFO ne contient aucune donnée et le signal plein est invalide. Après l'écriture de données dans la FIFO, si aucune opération de lecture n'est effectuée ou si le débit de lecture est relativement lent, un signal d'état plein sera généré dès que l'adresse d'écriture des données dépasse l'adresse de lecture des données d'une profondeur de FIFO. À ce moment-là, l'adresse d'écriture et l'adresse de lecture sont également égales, mais leurs significations sont différentes.

À ce moment, un bit supplémentaire est souvent utilisé comme bit d'extension respectivement pour les adresses de lecture et d'écriture, afin de distinguer si la FIFO est vide ou pleine lorsque les adresses de lecture et d'écriture sont identiques. Lorsque les adresses de lecture/écriture et les bits d'extension sont tous identiques, cela indique que la quantité de données écrites et de données lues est égale, et la FIFO est vide. Si les adresses de lecture/écriture sont identiques mais que les bits d'extension sont opposés, cela indique que la quantité de données écrites a dépassé la quantité de données lues d'une profondeur de FIFO, et la FIFO est pleine. Bien sûr, la condition préalable à cet état est que l'état vide interdit les opérations de lecture et que l'état plein interdit les opérations d'écriture.
De même, en raison de l'existence d'une logique de retard asynchrone, le signal d'état plein n'est pas en temps réel. Mais cela équivaut aussi à évaluer à l'avance le signal d'état plein. À ce moment, ne pas effectuer d'opérations d'écriture dans la FIFO n'affectera pas l'exactitude de l'application.
Conception de FIFO
Exigences de conception
Pour concevoir une FIFO applicable à divers scénarios, les exigences suivantes sont proposées :
- (1) La profondeur et la largeur de la FIFO sont paramétrables, les signaux d'état vide et plein sont émis, et un signal d'état plein configurable est émis. Lorsque les données internes de la FIFO atteignent la quantité de paramètre configurée, ce signal est mis à l'état haut.
- (2) Les largeurs de bits des données d'entrée et des données de sortie peuvent être différentes, mais les largeurs des données d'écriture et de l'adresse d'écriture doivent être cohérentes avec les largeurs des données de lecture et de l'adresse de lecture. Par exemple, la largeur des données d'écriture est de 8 bits, et la largeur de l'adresse d'écriture est de 6 bits (64 éléments de données). Si la largeur des données de sortie doit être de 32 bits, la largeur de l'adresse de sortie doit être de 4 bits (16 éléments de données).
- (3) Le FIFO est asynchrone, c'est-à-dire que les signaux de commande de lecture et d'écriture proviennent de domaines d'horloge différents. Avant d'émettre les signaux d'état vide et plein, les signaux d'adresse de lecture et d'écriture doivent être synchronisés à l'aide du code de Gray, et les erreurs de transmission de données lors de la synchronisation par échantillonnage de registre doivent être réduites en réduisant le basculement des signaux multi-bits. La conversion entre le code de Gray et le binaire est présentée ci-dessous.
Conception de RAM à double port
Les paramètres de port de la RAM sont configurables, et les largeurs de bits de lecture/écriture peuvent être différentes. Il est recommandé, lors de la définition du tableau mémoire, de prendre comme référence les paramètres de la largeur d'adresse la plus longue et de la largeur de données la plus courte, afin que les variables de tableau puissent être facilement sélectionnées et accessibles.
La description Verilog est la suivante.
Exemple
#( parameter AWI = 5 ,
parameter AWO = 7 ,
parameter DWI = 64 ,
parameter DWO = 16
)
(
input CLK_WR , //horloge d'écriture
input WR_EN , //validation d'écriture
input [AWI-1:0] ADDR_WR ,//adresse d'écriture
input [DWI-1:0] D , //données d'écriture
input CLK_RD , //horloge de lecture
input RD_EN , //validation de lecture
input [AWO-1:0] ADDR_RD ,//adresse de lecture
output reg [DWO-1:0] Q //données de lecture
);
//La largeur de sortie est supérieure à la largeur d'entrée, trouver le facteur d'expansion et le nombre de bits correspondant
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO > 0 ? AWI-AWO : 'b1 ;
//La largeur d'entrée est supérieure à la largeur de sortie, trouver le facteur de réduction et le nombre de bits correspondant
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI > 0 ? AWO-AWI : 'b1;
genvar i ;
generate
//Extension de la largeur des données (réduction de la largeur d'adresse)
if (DWO >= DWI) begin
//Logique d'écriture, écrire une fois par horloge
reg [DWI-1:0] mem [(1<<AWI)-1 : 0] ;
always @(posedge CLK_WR) begin
if (WR_EN) begin
mem[ADDR_WR] <= D ;
end
end
//Logique de lecture, lire 4 fois par horloge
for (i=0; i<EXTENT; i=i+1) begin
always @(posedge CLK_RD) begin
if (RD_EN) begin
Q[(i+1)*DWI-1: i*DWI] <= mem[(ADDR_RD*EXTENT) + i ] ;
end
end
end
end
//=================================================
//Réduction de la largeur des données (extension de la largeur d'adresse)
else begin
//Logique d'écriture, écrire 4 fois par horloge
reg [DWO-1:0] mem [(1<<AWO)-1 : 0] ;
for (i=0; i<SHRINK; i=i+1) begin
always @(posedge CLK_WR) begin
if (WR_EN) begin
mem[(ADDR_WR*SHRINK)+i] <= D[(i+1)*DWO -1: i*DWO] ;
end
end
end
//Logique de lecture, lire une fois par cycle d'horloge
always @(posedge CLK_RD) begin
if (RD_EN) begin
Q <= mem[ADDR_RD] ;
end
end
end
endgenerate
endmodule
Conception du compteur
Le compteur est utilisé pour générer les informations d'adresse de lecture/écriture. Sa largeur de bits est configurable. Il n'est pas nécessaire de définir une valeur finale ; il suffit de le laisser déborder et de compter automatiquement à nouveau. La description Verilog est la suivante.
Exemple
#(paramètre W )
(
input rstn ,
input clk ,
input en ,
output [W-1:0] count
);
reg [W-1:0] count_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
count_r <= 'b0 ;
end
else if (en) begin
count_r <= count_r + 1'b1 ;
end
end
assign count = count_r ;
endmodule
Conception de FIFO
Ce module est la partie principale du FIFO. Il génère la logique de contrôle de lecture/écriture et produit les signaux d'état vide, plein et plein programmable.
En raison de limitations d'espace, seul le code logique pour une largeur de données de lecture supérieure à la largeur de données d'écriture est donné ici. Pour la description du code où la largeur de données d'écriture est supérieure à la largeur de données de lecture, voir la pièce jointe.
Exemple
#( parameter AWI = 5 ,
parameter AWO = 3 ,
parameter DWI = 4 ,
parameter DWO = 16 ,
parameter PROG_DEPTH = 16) //Profondeur configurable
(
input rstn, //Lecture et écriture utilisent une seule réinitialisation
input wclk, //horloge d'écriture
input winc, //validation d'écriture
input [DWI-1: 0] wdata, //données d'écriture
input rclk, //horloge de lecture
input rinc, //validation de lecture
output [DWO-1 : 0] rdata, //données de lecture
output wfull, //drapeau plein en écriture
output rempty, //drapeau vide en lecture
output prog_full //drapeau plein programmable
);
//La largeur de sortie est supérieure à la largeur d'entrée, trouver le facteur d'expansion et le nombre de bits correspondant
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO ;
//La largeur de sortie est inférieure à la largeur d'entrée, trouver le multiple de réduction et le nombre de bits correspondant
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI ;
//==================== compteur push/wr ===============
wire [AWI-1:0] waddr ;
wire wover_flag ; //Utiliser un bit supplémentaire pour l'extension de l'adresse d'écriture
ccnt #(.W(AWI+1))
u_push_cnt(
.rstn (rstn),
.clk (wclk),
.en (winc && !wfull), //Interdire l'écriture lorsque plein
.count ({wover_flag, waddr})
);
//============== compteur pop/rd ===================
wire [AWO-1:0] raddr ;
wire rover_flag ; //Utiliser un bit supplémentaire pour l'extension de l'adresse de lecture
ccnt #(.W(AWO+1))
u_pop_cnt(
.rstn (rstn),
.clk (rclk),
.en (rinc & !rempty), //Interdire la lecture lorsque vide
.count ({rover_flag, raddr})
);
//==============================================
//Données étroites en entrée, données larges en sortie
generate
if (DWO >= DWI) begin : EXTENT_WIDTH
//Conversion en code Gray
wire [AWI:0] wptr = ({wover_flag, waddr}>>1) ^ ({wover_flag, waddr}) ;
//Synchroniser le pointeur de données d'écriture sur le domaine d'horloge de lecture
reg [AWI:0] rq2_wptr_r0 ;
reg [AWI:0] rq2_wptr_r1 ;
always @(posedge rclk or negedge rstn) begin
if (!rstn) begin
rq2_wptr_r0 <= 'b0 ;
rq2_wptr_r1 <= 'b0 ;
end
else begin
rq2_wptr_r0 <= wptr ;
rq2_wptr_r1 <= rq2_wptr_r0 ;
end
end
//Conversion en code Gray
wire [AWI-1:0] raddr_ex = raddr << EXTENT_BIT ;
wire [AWI:0] rptr = ({rover_flag, raddr_ex}>>1) ^ ({rover_flag, raddr_ex}) ;
//Synchroniser le pointeur de données de lecture avec le domaine d'horloge d'écriture
reg [AWI:0] wq2_rptr_r0 ;
reg [AWI:0] wq2_rptr_r1 ;
always @(posedge wclk or negedge rstn) begin
if (!rstn) begin
wq2_rptr_r0 <= 'b0 ;
wq2_rptr_r1 <= 'b0 ;
end
else begin
wq2_rptr_r0 <= rptr ;
wq2_rptr_r1 <= wq2_rptr_r0 ;
end
end
//Conversion inverse du code Gray
//Si seuls les signaux d'état vide et plein sont nécessaires, la conversion inverse n'est pas nécessaire
//En raison du signal d'état plein programmable, la conversion inverse d'adresse est pratique pour la comparaison
reg [AWI:0] wq2_rptr_decode ;
reg [AWI:0] rq2_wptr_decode ;
entier i ;
always @(*) begin
wq2_rptr_decode[AWI] = wq2_rptr_r1[AWI];
for (i=AWI-1; i>=0; i=i-1) begin
wq2_rptr_decode[i] = wq2_rptr_decode[i+1] ^ wq2_rptr_r1[i] ;
end
end
always @(*) begin
rq2_wptr_decode[AWI] = rq2_wptr_r1[AWI];
for (i=AWI-1; i>=0; i=i-1) begin
rq2_wptr_decode[i] = rq2_wptr_decode[i+1] ^ rq2_wptr_r1[i] ;
end
end
//Lorsque les adresses de lecture/écriture et les bits d'extension sont exactement identiques, il s'agit de l'état vide
assign rempty = (rover_flag == rq2_wptr_decode[AWI]) &&
(raddr_ex >= rq2_wptr_decode[AWI-1:0]);
//Lorsque les adresses de lecture/écriture sont identiques mais que les bits d'extension diffèrent, il s'agit de l'état plein
assign wfull = (wover_flag != wq2_rptr_decode[AWI]) &&
(waddr >= wq2_rptr_decode[AWI-1:0]) ;
//Lorsque les bits d'extension sont identiques, l'adresse d'écriture est nécessairement supérieure ou égale à l'adresse de lecture
//Lorsque les bits d'extension diffèrent, la partie adresse d'écriture est nécessairement inférieure à l'adresse de lecture ; il faut ajouter une profondeur de FIFO à l'adresse d'écriture réelle
assign prog_full = (wover_flag == wq2_rptr_decode[AWI]) ?
waddr - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1 :
waddr + (1<<AWI) - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1;
//Instanciation de RAM à double port
ramdp
#( .AWI (AWI),
.AWO (AWO),
.DWI (DWI),
.DWO (DWO))
u_ramdp
(
.CLK_WR (wclk),
.WR_EN (winc & !wfull), //Interdire l'écriture lorsque plein
.ADDR_WR (waddr),
.D (wdata[DWI-1:0]),
.CLK_RD (rclk),
.RD_EN (rinc & !rempty), //Interdire la lecture lorsque vide
.ADDR_RD (raddr),
.Q (rdata[DWO-1:0])
);
end
//==============================================
//grand en entrée et petit en sortie
/*
else begin: SHRINK_WIDTH
……
end
*/
endgenerate
endmodule
Instanciation de FIFO
Le FIFO conçu peut être instancié ci-dessous pour effectuer le traitement asynchrone d'une transmission de données à largeur multi-bit.
La largeur des données d'écriture est de 4 bits, et la profondeur d'écriture est de 32.
La largeur des données de lecture est de 16 bits, la profondeur de lecture est de 8, et la profondeur totale configurable est de 16.
Exemple
input rstn,
input [4-1: 0] din, //Données d'écriture asynchrones
input din_clk, //Horloge d'écriture asynchrone
input din_en, //validation d'écriture asynchrone
output [16-1 : 0] dout, //données après synchronisation
input dout_clk, // Utiliser l'horloge de manière synchrone
input dout_en ); // Validation synchrone des données
wire fifo_empty, fifo_full, prog_full ;
wire rd_en_wir ;
wire [15:0] dout_wir ;
// Interdire la lecture lorsque l'état est vide en lecture, sinon elle continuera à lire
assign rd_en_wir = fifo_empty ? 1'b0 : 1'b1 ;
fifo #(.AWI(5), .AWO(3), .DWI(4), .DWO(16), .PROG_DEPTH(16))
u_buf_s2b(
.rstn (rstn),
.wclk (din_clk),
.winc (din_en),
.wdata (din),
.rclk (dout_clk),
.rinc (rd_en_wir),
.rdata (dout_wir),
.wfull (fifo_full),
.rempty (fifo_empty),
.prog_full (prog_full));
// Données et validation après synchronisation du cache
reg dout_en_r ;
always @(posedge dout_clk or negedge rstn) begin
if (!rstn) begin
dout_en_r <= 1'b0 ;
end
else begin
dout_en_r <= rd_en_wir ;
end
end
assign dout = dout_wir ;
assign dout_en = dout_en_r ;
endmodule
testbench
Exemple
`define SMALL2BIG
module test ;
`ifdef SMALL2BIG
reg rstn ;
reg clk_slow, clk_fast ;
reg [3:0] din ;
reg din_en ;
wire [15:0] dout ;
wire dout_en ;
//réinitialisation
initial begin
clk_slow = 0 ;
clk_fast = 0 ;
rstn = 0 ;
#50 rstn = 1 ;
end
// L'horloge de lecture clock_slow est plus rapide que 1/4 de l'horloge d'écriture clk_fast
// S'assurer que les données de lecture sont légèrement plus rapides que les données d'écriture
parameter CYCLE_WR = 40 ;
always #(CYCLE_WR/2/4) clk_fast = ~clk_fast ;
always #(CYCLE_WR/2-1) clk_slow = ~clk_slow ;
// génération de données
initial begin
din = 16'h4321 ;
din_en = 0 ;
wait (rstn) ;
//(1) Tester les signaux full, prog_full, empty
force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
repeat(32) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
@(negedge clk_fast) din_en = 1'b0 ;
//(2) Tester la lecture/écriture de données
#500 ;
rstn = 0 ;
#10 rstn = 1 ;
release test.u_data_buf2.u_buf_s2b.rinc;
repeat(100) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
//(3) Arrêter la lecture et tester à nouveau les signaux empyt, full, prog_full
force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
repeat(18) begin
@(negedge clk_fast) ;
din_en = 1'b1 ;
din = {$random()} % 16;
end
end
fifo_s2b u_data_buf2(
.rstn (rstn),
.din (din),
.din_clk (clk_fast),
.din_en (din_en),
.dout (dout),
.dout_clk (clk_slow),
.dout_en (dout_en));
`else
`endif
//arrêter la simulation
initial begin
forever begin
#100;
if ($time >= 5000) $finish ;
end
end
endmodule
Analyse de simulation
D'après le stimulus de test en 3 étapes dans le testbench, l'analyse est la suivante :
Test (1) : Les résultats de timing du port FIFO et de certains signaux internes sont les suivants :
Comme on peut le voir sur la figure, il y a un délai avant que le FIFO ne commence en interne à écrire des données et que le signal d'état vide ne passe à l'état bas. Cela est dû à la synchronisation des informations d'adresse de lecture/écriture.
Comme aucune opération de lecture du FIFO n'est effectuée à ce moment-là, il n'y a presque aucun retard dans le passage à l'état haut de full et prog_full par rapport à l'opération d'écriture des données.

Test (2) : Lorsque le FIFO lit et écrit simultanément, les signaux de port du module de traitement asynchrone de niveau supérieur numérique sont présentés ci-dessous. Les deux figures montrent respectivement le processus de lecture au début et à la fin de la transmission des données.
Comme on peut le voir sur les figures, les données sont transmises correctement au début comme à la fin, ce qui réalise le traitement asynchrone de données de largeur multi-bits entre différents domaines d'horloge.


Test (3) : Le diagramme de simulation temporelle de l'ensemble du comportement de lecture/écriture et d'arrêt de lecture du FIFO est présenté ci-dessous.
Comme on peut le voir sur la figure, lorsque la lecture et l'écriture sont effectuées simultanément, le signal d'état de lecture vide rempty passe à l'état bas, ce qui indique que des données ont été écrites dans le FIFO. D'une part, le débit de lecture des données est légèrement supérieur au débit d'écriture, et il y a un délai entre les transmissions de données, donc rempty passera à l'état haut pendant le processus intermédiaire.
Pendant le processus de lecture/écriture, les signaux full et prog_full restent à l'état bas, ce qui indique que la quantité de données dans le FIFO n'a pas atteint un certain niveau. Après l'arrêt de l'opération de lecture, les deux signaux full passent à l'état haut peu de temps après, ce qui indique que le FIFO est plein. Après une comparaison attentive des informations d'adresse de lecture/écriture, le comportement du FIFO ne présente aucun problème.

La conception FIFO complète est fournie en pièce jointe, y compris la conception asynchrone et la simulation pour les cas où la largeur de bits des données d'entrée est inférieure à la largeur de bits des données de sortie.
Télécharger le code source de ce chapitre
Téléchargement