Lire après écriture latence dans FIFO asynchrone?

Question

J'essaie d'interfacer un module avec une FIFO asynchrone générée par le générateur Xilinx CORE. Cependant, j'ai observé que les données fournies au port d'entrée d'AFIFO (bien que correct) commencent à apparaître sur dout après une latence de 6-7 cycles d'horloge. Doit on s'y attendre? Ou est-ce que je fais quelque chose de mal? Ce que je suis en train de faire est d'affirmer la broche write_enable de AFIFO, fournir les données d'entrée, puis affirmer la broche read_enable au cycle suivant. Mais le problème de la latence existe toujours. Toute aide est appréciée.

EDIT: Je joins une partie de mon code.

always @ (posedge clk1, posedge rst)//faster clock domain 
begin 
    if (rst) 
     wr_en<= 1'b 0; 

    else 
     begin 
      if (data_wrt) 
       begin 
       wr_en<= 1'b 1;       
       end 
      else 
       wr_en<= 1'b 0; 
     end 
end 
always @ (negedge clk2, posedge rst)//slower clock domain 
    begin 
     if (rst) 
      rd_en<= 1'b 0; 

     else 
      begin 
       if (wr_en) 
        begin 
        rd_en<= 1'b 1;        
        end 
       else 
        rd_en<= 1'b 0;    
      end 

    end 
AFIFO AFIFO1(//AFIFO module instantiation 
    .din(data_in), 
    .rd_clk(clk2), 
    .rd_en(rd_en), 
    .rst(reset), 
    .wr_clk(clk1), 
    .wr_en(wr_en), 
    .dout(data_out), 
    .empty(empty), 
    .full(full) 
    ); 

Answer 1

Quelle est la relation d'horloge? En supposant que vous voyez la latence dans les cycles 6-7 clk1 (horloge rapide), cela semble être quelque chose que vous attendez selon la relation d'horloge clk1/clk2. Cela dit, le point d'une FIFO asynchrone est habituellement d'agir comme un synchroniseur d'un domaine d'horloge à un autre. Le domaine d'horloge d'écriture (clk1) écrira des données à l'AFIFO tant qu'il n'est pas plein. Le domaine d'horloge de lecture (clk2) lira les nouvelles données tant que l'AFIFO n'est pas vide. Ce que vous faites ici rompt cet usage. Vous utilisez wr_en qui est généré par clk1 pour contrôler rd_en qui est cadencé par clk2. Alors maintenant wr_en est utilisé dans les deux domaines d'horloge et provoquera metastability. Donc, en bref, vous n'utilisez pas correctement AFIFO. Essayez plutôt de laisser votre logique clk2 toujours définie rd_en lorsque AFIFO est !empty.

Answer 2

Je pense que vous voulez transformer certaines données synchrones en clk1 en synchrones avec clk2 par une FIFO asynchrone. Tout d'abord, vous n'avez pas besoin d'échantillonner le signal synchrone de clk1 directement par clk2. Comme utiliser wr_en qui est généré par clk1 pour contrôler rd_en qui est cadencé par clk2.Il provoquera la métastabilité. FIFO est toujours utilisé pour résoudre le problème de la métastabilité. Donc, pas besoin de faire comme le second bloc toujours.

Donc, le problème est de savoir comment utiliser FIFO asynchrone correctement. Vous devriez lire le guide du produit générateur Xilinx FIFO comme PG057.Vous devriez connaître la théorie et la méthode d'utilisation de FIFO. Sinon, vous aurez beaucoup de mal quand vous utilisez FIFO.

Mon conseil est ci-dessous. Pour l'opération d'écriture, vous devez utiliser à la fois le signal almost_full et full pour éviter les débordements. Vous pouvez le voir dans PG057 figure 3-2. Vous devez utiliser almost_full, car si wr_en est continu, alors le signal complet est 1 clock plus lent à aviod overflow . Pour une opération de lecture, vous devez utiliser à la fois le signal almost_empty et le signal vide, pour la même raison. Ensuite, vous pouvez transformer la zone d'horloge correctement.

Pardonnez mon anglais.