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

module  ramdp
    #(  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

module  ccnt
  #(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

module  fifo
    #(  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

module  fifo_s2b(
        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

`timescale 1ns/1ns
`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