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

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

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

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

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

`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 ;

   //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