FIFO (First In First Out) ist ein Speicher, der häufig bei der asynchronen Datenübertragung verwendet wird. Seine Eigenschaft ist, dass Daten zuerst hinein- und zuerst hinausgehen (zuletzt hinein, zuletzt hinaus). Tatsächlich kann das Problem der asynchronen Übertragung von mehrbitbreiten Daten, ob von einem schnellen Takt in eine langsame Taktdomäne oder von einem langsamen Takt in eine schnelle Taktdomäne, mit FIFO behandelt werden.
FIFO-Prinzip
Workflow
Nach dem Reset werden Daten unter der Steuerung des Schreibtakts und der Statussignale in den FIFO geschrieben. Die Schreibadresse des RAM beginnt bei 0. Bei jedem Schreiben von Daten wird der Schreibadresszeiger um eins erhöht, um auf die nächste Speicherzelle zu zeigen. Wenn der FIFO voll ist, können keine Daten mehr geschrieben werden; andernfalls gehen Daten durch Überschreiben verloren.
Wenn sich die FIFO-Daten in einem nicht leeren oder vollen Zustand befinden, können unter der Steuerung des Lesetakts und der Statussignale Daten aus dem FIFO gelesen werden. Die Leseadresse des RAM beginnt bei 0. Bei jedem Lesen von Daten wird der Leseadresszeiger um eins erhöht, um auf die nächste Speicherzelle zu zeigen. Wenn der FIFO leer gelesen wird, können keine weiteren Daten gelesen werden; andernfalls sind die gelesenen Daten falsch.
Die Speicherstruktur des FIFO ist ein Dual-Port-RAM, sodass Lesen und Schreiben gleichzeitig ausgeführt werden können. Das typische Strukturdiagramm eines asynchronen FIFO ist unten dargestellt. Die Ports und internen Signale werden beim Schreiben des Codes erläutert.

Lese-/Schreib-Timing
Was das Schreib-Timing betrifft, können Schreibvorgänge durchgeführt werden, solange der FIFO nicht voll ist; wenn der FIFO voll ist, ist das Schreiben weiterer Daten untersagt.
Was das Lese-Timing betrifft, können Lesevorgänge durchgeführt werden, solange der FIFO nicht leer ist; wenn der FIFO leer ist, ist das Lesen weiterer Daten untersagt.
In jedem Fall darf während eines normalen FIFO-Lese-/Schreibbetriebs, wenn gleichzeitig gelesen und geschrieben wird, die FIFO-Schreibrate nicht größer als die Leserate sein.
Leerer Zustand beim Lesen
Zu Beginn des Resets enthält das FIFO keine Daten, und das Leerstatus-Signal ist gültig. Nachdem Daten in das FIFO geschrieben wurden, wird das Leerstatus-Signal auf Low gezogen und wird ungültig. Wenn die Lesedatenadresse die Schreibadresse einholt, das heißt, wenn Lese- und Schreibadresse gleich sind, befindet sich das FIFO im leeren Zustand.
Da es sich um ein asynchrones FIFO handelt, ist beim Vergleich von Lese- und Schreibadressen eine Synchronisationslogik mit Registerabgriff erforderlich, die eine gewisse Zeit in Anspruch nimmt. Daher ist das Leerstatus-Anzeigesignal nicht echtzeitfähig und weist eine gewisse Verzögerung auf. Wenn während dieser Verzögerungszeit neue Daten in das FIFO geschrieben werden, kann das Phänomen auftreten, dass das Leerstatus-Anzeigesignal gültig ist, sich aber tatsächlich Daten im FIFO befinden.
Streng genommen ist diese Leerstatus-Anzeige falsch. Der Zweck der Erzeugung des leeren Zustands besteht jedoch darin, zu verhindern, dass Leseoperationen Daten aus einem leeren FIFO lesen. Wenn das Leerstatus-Signal erzeugt wird, enthält das FIFO tatsächlich Daten, was einer vorzeitigen Beurteilung des Leerstatus-Signals gleichkommt. Zu diesem Zeitpunkt ist es sicher, das Lesen von FIFO-Daten zu stoppen. Daher ist dieses Design aus Anwendungssicht in Ordnung.
Voller Zustand beim Schreiben
Zu Beginn des Resets enthält das FIFO keine Daten, und das Vollsignal ist ungültig. Nachdem Daten in das FIFO geschrieben wurden, wird, wenn keine Leseoperation ausgeführt wird oder die Leserate relativ langsam ist, ein Vollstatus-Signal erzeugt, sobald die Schreibdatenadresse die Lesedatenadresse um eine FIFO-Tiefe überschreitet. Zu diesem Zeitpunkt sind die Schreibadresse und die Leseadresse ebenfalls gleich, ihre Bedeutungen sind jedoch unterschiedlich.

Zu diesem Zeitpunkt wird häufig ein zusätzliches 1 Bit als Erweiterungsbit für die Lese- und Schreibadressen verwendet, um zu unterscheiden, ob der FIFO leer oder voll ist, wenn die Lese- und Schreibadressen identisch sind. Wenn die Lese-/Schreibadressen und die Erweiterungsbits alle identisch sind, zeigt dies an, dass die Menge der geschriebenen Daten und der gelesenen Daten gleich ist und der FIFO leer ist. Wenn die Lese-/Schreibadressen identisch sind, aber die Erweiterungsbits entgegengesetzt sind, zeigt dies an, dass die Menge der geschriebenen Daten die Menge der gelesenen Daten um eine FIFO-Tiefe überschritten hat und der FIFO voll ist. Natürlich ist die Voraussetzung für diese Bedingung, dass der Leerzustand Leseoperationen verbietet und der Vollzustand Schreiboperationen verbietet.
Ähnlich ist das Vollstatussignal aufgrund der Existenz asynchroner Verzögerungslogik nicht in Echtzeit. Es ist aber auch gleichbedeutend damit, das Vollstatussignal im Voraus zu beurteilen. Zu diesem Zeitpunkt wirkt sich die Nichtausführung von FIFO-Schreiboperationen nicht auf die Korrektheit der Anwendung aus.
FIFO-Design
Entwurfsanforderungen
Um einen FIFO zu entwerfen, der auf verschiedene Szenarien anwendbar ist, werden die folgenden Anforderungen vorgeschlagen:
- (1) Die FIFO-Tiefe und -Breite sind parametrisierbar, es werden Leer- und Vollstatussignale ausgegeben und ein konfigurierbares Vollstatussignal ausgegeben. Wenn die internen Daten im FIFO die konfigurierte Parametermenge erreichen, wird dieses Signal auf high gezogen.
- (2) Die Bitbreiten der Eingangsdaten und Ausgangsdaten können unterschiedlich sein, aber die Breiten von Schreibdaten und Schreibadresse müssen mit den Breiten von Lesedaten und Leseadresse übereinstimmen. Zum Beispiel beträgt die Schreibdatenbreite 8 Bit und die Schreibadressbreite 6 Bit (64 Datenelemente). Wenn die Ausgangsdatenbreite 32 Bit betragen soll, sollte die Ausgangsadressbreite 4 Bit betragen (16 Datenelemente).
- (3) Das FIFO ist asynchron, das heißt, die Lese- und Schreibsteuersignale stammen aus unterschiedlichen Taktdomänen. Vor der Ausgabe der Leer- und Voll-Statussignale sollten die Lese- und Schreibadresssignale mithilfe von Gray-Code synchronisiert werden, und die Datenübertragungsfehler bei der Synchronisation durch Register-Tapping sollten durch Reduzierung des Umschaltens von Multi-Bit-Signalen verringert werden. Die Umwandlung zwischen Gray-Code und Binärcode ist unten dargestellt.
Dual-Port-RAM-Design
Die RAM-Port-Parameter sind konfigurierbar, und die Lese-/Schreib-Bitbreiten können unterschiedlich sein. Es wird empfohlen, beim Definieren des Speicherarrays die Parameter der längeren Adressbreite und der kürzeren Datenbreite als Referenz zu verwenden, damit Array-Variablen einfach ausgewählt und angesprochen werden können.
Die Verilog-Beschreibung ist wie folgt.
Beispiel
#( parameter AWI = 5 ,
parameter AWO = 7 ,
parameter DWI = 64 ,
parameter DWO = 16
)
(
input CLK_WR , //Schreibtakt
input WR_EN , //Schreibfreigabe
input [AWI-1:0] ADDR_WR ,//Schreibadresse
input [DWI-1:0] D , //Schreibdaten
input CLK_RD , //Lesetakt
input RD_EN , //Lesefreigabe
input [AWO-1:0] ADDR_RD ,//Leseadresse
output reg [DWO-1:0] Q //Lesedaten
);
//Die Ausgangsbreite ist größer als die Eingangsbreite, ermittle den Erweiterungsfaktor und die entsprechende Bitanzahl
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO > 0 ? AWI-AWO : 'b1 ;
//Die Eingangsbreite ist größer als die Ausgangsbreite, ermittle den Reduktionsfaktor und die entsprechende Bitanzahl
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI > 0 ? AWO-AWI : 'b1;
genvar i ;
generate
//Datenbreitenerweiterung (Adressbreitenreduzierung)
if (DWO >= DWI) begin
//Schreiblogik, einmal pro Takt schreiben
reg [DWI-1:0] mem [(1<<AWI)-1 : 0] ;
always @(posedge CLK_WR) begin
if (WR_EN) begin
mem[ADDR_WR] <= D ;
end
end
//Leselogik, 4-mal pro Takt lesen
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
//=================================================
//Datenbreitenreduzierung (Adressbreitenerweiterung)
else begin
//Schreiblogik, 4-mal pro Takt schreiben
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
//Leselogik, einmal pro Takt lesen
always @(posedge CLK_RD) begin
if (RD_EN) begin
Q <= mem[ADDR_RD] ;
end
end
end
endgenerate
endmodule
Zählerentwurf
Der Zähler wird verwendet, um Lese-/Schreibadressinformationen zu erzeugen. Seine Bitbreite ist konfigurierbar. Es ist nicht nötig, einen Endwert festzulegen; lassen Sie ihn einfach überlaufen und automatisch erneut zählen. Die Verilog-Beschreibung lautet wie folgt.
Beispiel
#(Parameter 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
FIFO-Design
Dieses Modul ist der Hauptteil des FIFO. Es erzeugt die Lese-/Schreibsteuerlogik und liefert Leer-, Voll- und programmierbare Voll-Statussignale.
Aufgrund von Platzbeschränkungen wird hier nur der Logikcode für eine Lesedatenbreite angegeben, die größer als die Schreibdatenbreite ist. Für die Codebeschreibung, bei der die Schreibdatenbreite größer als die Lesedatenbreite ist, siehe Anhang.
Beispiel
#( parameter AWI = 5 ,
parameter AWO = 3 ,
parameter DWI = 4 ,
parameter DWO = 16 ,
parameter PROG_DEPTH = 16) //Konfigurierbare Tiefe
(
input rstn, //Lesen und Schreiben verwenden einen Reset
input wclk, //Schreibtakt
input winc, //Schreibfreigabe
input [DWI-1: 0] wdata, //Schreibdaten
input rclk, //Lesetakt
input rinc, //Lesefreigabe
output [DWO-1 : 0] rdata, //Lesedaten
output wfull, //Voll-Flagge für Schreiben
output rempty, //Leer-Flagge für Lesen
output prog_full //programmierbare Voll-Flagge
);
//Die Ausgangsbreite ist größer als die Eingangsbreite, ermittle den Erweiterungsfaktor und die entsprechende Bitanzahl
parameter EXTENT = DWO/DWI ;
parameter EXTENT_BIT = AWI-AWO ;
//Ausgangsbreite ist kleiner als Eingangsbreite, ermittle den Reduktionsfaktor und die entsprechende Anzahl an Bits
parameter SHRINK = DWI/DWO ;
parameter SHRINK_BIT = AWO-AWI ;
//==================== Push-/Schreibzähler ===============
wire [AWI-1:0] waddr ;
wire wover_flag ; //Ein zusätzliches Bit für die Schreibadresserweiterung verwenden
ccnt #(.W(AWI+1))
u_push_cnt(
.rstn (rstn),
.clk (wclk),
.en (winc && !wfull), //Schreiben verhindern, wenn voll
.count ({wover_flag, waddr})
);
//============== pop/rd-Zähler ===================
wire [AWO-1:0] raddr ;
wire rover_flag ; //Ein zusätzliches Bit für die Leseadresserweiterung verwenden
ccnt #(.W(AWO+1))
u_pop_cnt(
.rstn (rstn),
.clk (rclk),
.en (rinc & !rempty), //Lesen verhindern, wenn leer
.count ({rover_flag, raddr})
);
//==============================================
//Schmale Daten hinein, breite Daten hinaus
generate
if (DWO >= DWI) begin : EXTENT_WIDTH
//Gray-Code-Umwandlung
wire [AWI:0] wptr = ({wover_flag, waddr}>>1) ^ ({wover_flag, waddr}) ;
//Schreibdatenzeiger mit der Lese-Takt-Domäne synchronisieren
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
//Gray-Code-Umwandlung
wire [AWI-1:0] raddr_ex = raddr << EXTENT_BIT ;
wire [AWI:0] rptr = ({rover_flag, raddr_ex}>>1) ^ ({rover_flag, raddr_ex}) ;
//Synchronisiere den Lese-Datenzeiger mit der Schreibtaktdomäne
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
//Gray-Code-Rückumwandlung
//Wenn nur Leer- und Voll-Statussignale benötigt werden, ist keine Rückumwandlung erforderlich
//Aufgrund des programmierbaren Voll-Statussignals ist die Adress-Rückumwandlung für den Vergleich praktisch
reg [AWI:0] wq2_rptr_decode ;
reg [AWI:0] rq2_wptr_decode ;
integer 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
//Wenn Lese-/Schreibadressen und Erweiterungsbits exakt gleich sind, handelt es sich um den Leerzustand
assign rempty = (rover_flag == rq2_wptr_decode[AWI]) &&
(raddr_ex >= rq2_wptr_decode[AWI-1:0]);
//Wenn Lese-/Schreibadressen gleich sind, aber die Erweiterungsbits abweichen, handelt es sich um den Vollzustand
assign wfull = (wover_flag != wq2_rptr_decode[AWI]) &&
(waddr >= wq2_rptr_decode[AWI-1:0]) ;
//Wenn die Erweiterungsbits gleich sind, ist die Schreibadresse zwangsläufig nicht kleiner als die Leseadresse
//Wenn die Erweiterungsbits abweichen, ist der Schreibadressteil zwangsläufig kleiner als die Leseadresse; zur tatsächlichen Schreibadresse muss eine FIFO-Tiefe addiert werden
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;
//Dual-Port-RAM-Instanziierung
ramdp
#( .AWI (AWI),
.AWO (AWO),
.DWI (DWI),
.DWO (DWO))
u_ramdp
(
.CLK_WR (wclk),
.WR_EN (winc & !wfull), //Schreiben bei Voll verhindern
.ADDR_WR (waddr),
.D (wdata[DWI-1:0]),
.CLK_RD (rclk),
.RD_EN (rinc & !rempty), //Lesen bei leerem Zustand verbieten
.ADDR_RD (raddr),
.Q (rdata[DWO-1:0])
);
end
//==============================================
//groß rein und klein raus
/*
else begin: SHRINK_WIDTH
……
end
*/
endgenerate
endmodule
FIFO-Instanziierung
Die entworfene FIFO kann unten instanziiert werden, um die asynchrone Verarbeitung der Übertragung mehrbitbreiter Daten abzuschließen.
Die Schreibdatenbreite beträgt 4 Bit, und die Schreibtiefe beträgt 32.
Die Lesedatenbreite beträgt 16 Bit, die Lesetiefe beträgt 8, und die konfigurierbare Volltiefe beträgt 16.
Beispiel
input rstn,
input [4-1: 0] din, //Asynchrone Schreibdaten
input din_clk, //Asynchroner Schreib-Takt
input din_en, //Asynchrone Schreibfreigabe
output [16-1 : 0] dout, //Daten nach Synchronisation
input dout_clk, // Den Takt synchron verwenden
input dout_en ); // Synchrone Datenfreigabe
wire fifo_empty, fifo_full, prog_full ;
wire rd_en_wir ;
wire [15:0] dout_wir ;
// Lesen im Read-Empty-Zustand verbieten, andernfalls wird weiter gelesen
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));
// Daten und Enable nach Cache-Synchronisation
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
Beispiel
`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 ;
// Zurücksetzen
initial begin
clk_slow = 0 ;
clk_fast = 0 ;
rstn = 0 ;
#50 rstn = 1 ;
end
// Lesetakt clock_slow ist schneller als 1/4 des Schreibtakts clk_fast
// Sicherstellen, dass Lesedaten etwas schneller als Schreibdaten sind
parameter CYCLE_WR = 40 ;
always #(CYCLE_WR/2/4) clk_fast = ~clk_fast ;
always #(CYCLE_WR/2-1) clk_slow = ~clk_slow ;
//Datengenerierung
initial begin
din = 16'h4321 ;
din_en = 0 ;
wait (rstn) ;
//(1) Test der full-, prog_full- und empty-Signale
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) Test des Datenlesens/-schreibens
#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) Lesen stoppen und empty-, full-, prog_full-Signale erneut testen
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
//Simulation stoppen
initial begin
forever begin
#100;
if ($time >= 5000) $finish ;
end
end
endmodule
Simulationsanalyse
Basierend auf dem 3-Schritt-Teststimulus in der Testbench lautet die Analyse wie folgt:
Test (1): Die Timing-Ergebnisse des FIFO-Ports und einiger interner Signale sind wie folgt.
Wie aus der Abbildung ersichtlich ist, gibt es eine Verzögerungsphase, bevor der FIFO intern mit dem Schreiben von Daten beginnt und das Empty-Status-Signal auf Low geht. Dies wird durch die Synchronisation der Lese-/Schreibadressinformationen verursacht.
Da zu diesem Zeitpunkt kein FIFO-Lesevorgang ausgeführt wird, erfolgt das High-Werden von full und prog_full relativ zum Schreibdatenvorgang nahezu ohne Verzögerung.

Test (2): Wenn der FIFO gleichzeitig liest und schreibt, werden die Portsignale des digitalen Top-Level-Moduls für asynchrone Verarbeitung unten dargestellt. Die beiden Abbildungen zeigen jeweils den Lesevorgang am Anfang und am Ende der Datenübertragung.
Wie aus den Abbildungen ersichtlich ist, werden die Daten sowohl am Anfang als auch am Ende korrekt übertragen, wodurch die asynchrone Verarbeitung von Daten mit mehreren Bitbreiten zwischen verschiedenen Taktdomänen abgeschlossen wird.


Test (3): Das Timing-Simulationsdiagramm des gesamten FIFO-Lese-/Schreibverhaltens und des Lesestopps ist unten dargestellt.
Wie aus der Abbildung ersichtlich ist, geht beim gleichzeitigen Lesen und Schreiben das Read-Empty-Status-Signal rempty auf Low, was darauf hinweist, dass Daten in den FIFO geschrieben wurden. Einerseits ist die Lesedatenrate etwas höher als die Schreibrate, und es gibt Verzögerungen zwischen Datenübertragungen, sodass rempty während des Zwischenprozesses auf High geht.
Während des Lese-/Schreibvorgangs bleiben die Signale full und prog_full auf Low, was darauf hinweist, dass die Datenmenge im FIFO ein bestimmtes Niveau nicht erreicht hat. Nachdem der Lesevorgang stoppt, gehen die beiden full-Signale kurz danach auf High, was anzeigt, dass der FIFO voll ist. Bei sorgfältigem Vergleich der Lese-/Schreibadressinformationen weist das FIFO-Verhalten keine Probleme auf.

Das vollständige FIFO-Design ist im Anhang enthalten, einschließlich des asynchronen Designs und der Simulation für Fälle, in denen die Bitbreite der Eingabedaten kleiner als die Bitbreite der Ausgabedaten ist.
Quellcode für dieses Kapitel herunterladen
Herunterladen