【verilog】 异步FIFO设计（格雷码转换，跨时钟域）

已于 2022-08-30 23:47:33 修改
阅读量685 收藏 10
点赞数 2
分类专栏： 数字IC设计 文章标签： fpga ram verilog
于 2021-11-19 09:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helloworld573/article/details/121415573
版权

功能图

在这里插入图片描述

空满判别

对FIFO的空满判断采用地址位扩展的方法
waddr=raddr，fifo为空
waddr[最高bit]≠raddr[最高bit],waddr[次高bit:0]=raddr[次高bit:0],fifo为满

若一个异步FIFO深度为8，则所需地址线宽3bit
将其地址位扩展为4bit，最高位用于辅助空满计算
在最初时，waddr和raddr都为b0000，此时waddr=raddr，fifo为空
下面对其进行读写操作：
进行8次写后：waddr = b1000 raddr = b0000
             此时waddr[4]≠raddr[4],waddr[3:0]=raddr[3:0],fifo为满
进行8次读后：waddr = b1000 raddr = b1000
             此时waddr = raddr fifo为空
进行8次写后：waddr = b0000 raddr = b1000
             此时waddr[4]≠raddr[4],waddr[3:0]=raddr[3:0],fifo为满
进行8次读后：waddr = b0000 raddr = b0000
             此时waddr = raddr fifo为空
进行3次写后：waddr = b0011 raddr = b0000
进行1次读后：waddr = b0011 raddr = b0001
进行1次写后：waddr = b0100 raddr = b0001
进行3次读后：waddr = b0100 raddr = b0100 waddr = raddr fifo空

可以知道，fifo的读写是转圈的，连续地址写，也连续地址读，不会因为你把前面的地址读完了，
我的写就回来重新写。

顶层


module asyn_fifo #(
   parameter DEPTH   = 256,       
   parameter WIDTH_A = 8,       
   parameter WIDTH_D = 16       
)(                                 
   input                     w_clk,
   input                     rst_n,
   input                     w_req,
   input [WIDTH_D-1:0]       w_data,
                     
   input                     r_clk, 
   input                     r_req, 
                     
   output [WIDTH_D-1:0]      r_data,
   
   output                    w_full ,  
   output                    r_empty 
   
);

wire [WIDTH_A:0]  w_addr;
wire [WIDTH_A:0]  r_gaddr_syn;
wire [WIDTH_A:0]  r_addr;
wire [WIDTH_A:0]  w_gaddr;
wire [WIDTH_A:0]  r_gaddr;
wire [WIDTH_A:0]  w_gaddr_syn;

write_part #(
   .WIDTH_A(WIDTH_A)     
)write_control(            
  .w_clk  ( w_clk   ),     
  .w_rst  ( rst_n   ),     
  .w_req  ( w_req   ),     
                   
  .r_gaddr( r_gaddr_syn ),   
                   
  .w_full ( w_full  ),   
  .w_addr ( w_addr  ),    
                   
  .w_gaddr( w_gaddr )    
);                     

RAM #(                                 
   .DEPTH  (DEPTH  ),                     
   .WIDTH_A(WIDTH_A),                     
   .WIDTH_D(WIDTH_D)                                                                  
)
RAM_inst
(                                            
    .r_clk ( r_clk  ) , 
    .w_clk ( w_clk  ) ,             
    .rst_n ( rst_n  ) ,             
                   
    .w_addr( w_addr[WIDTH_A-1:0] ) ,   //!!ram的读写地址需要丢弃掉扩展位         
    .w_data( w_data ) ,     
    .w_en  ( w_req & (!w_full)   ) ,              
                   
    .r_addr( r_addr[WIDTH_A-1:0] ) ,            
    .r_en  ( r_req & (!r_empty)   ) ,              
                   
    .r_data( r_data )      
);                                            
    

syn #(                          
  .WIDTH_D(WIDTH_A)                
)
syn_w_2_r                                      
(                                      
    .syn_clk ( r_clk ) ,  
    .syn_rst ( rst_n ) ,  
    .data_in ( w_gaddr ) ,  
             
    .syn_data( w_gaddr_syn )  
);        

syn #(                     
  .WIDTH_D(WIDTH_A)                                          
)                          
syn_r_2_w                  
(                          
   .syn_clk ( w_clk ) ,    
   .syn_rst ( rst_n ) ,    
   .data_in ( r_gaddr ),  
                           
   .syn_data( r_gaddr_syn )  
);     

                    
read_part  #(
  .WIDTH_A(WIDTH_A)   
)read_control(                               
  .r_clk   ( r_clk   ),              
  .r_rst   ( rst_n   ),              
  .r_req   ( r_req   ),              
                              
  .w_gaddr ( w_gaddr_syn ),            
                            
  .r_empty ( r_empty ),           
  .r_addr  ( r_addr  ),            
                             
  .r_gaddr ( r_gaddr )            
);                      


endmodule

子模块

/*
 * 模块1：二进制码转格雷码模块
 * 模块2：双端口RAM模块
 * 模块3：数据(格雷码)同步模块 
 * 模块4：读地址控制器
 * 模块5：写地址控制器
 */


/*模块：二进制码->转->格雷码*/
module bin_to_gray #(
  parameter  WIDTH_D = 5
)(
   input  [WIDTH_D-1:0] bin_c,
   output [WIDTH_D-1:0] gray_c
);                 


/*---------产生格雷码的最高位---------*/
wire gray_msb;
assign gray_msb = bin_c[WIDTH_D-1]; //保留二进制码的最高位作为格雷码的最高位  


/*---------产生格雷码的其他位---------*/
//除最高位，格雷码的其他位均服从：
//格雷码的第n位 = 二进制码的第n+1位 异或 二进制码的第n位
reg [WIDTH_D-2:0] gray_others_bit;
integer i;     
always @( * )begin
  for(i=0;i<WIDTH_D-1;i=i+1)//为了代码的通用性，这里确实是用for产生组合逻辑比较好·
    gray_others_bit[i] = bin_c[i]^bin_c[i+1]; 
    //等价于	  
    // assign gray_others_bit[0] = bin_c[0]^bin_c[1]; 
    // assign gray_others_bit[1] = bin_c[1]^bin_c[2]; 
    // assign gray_others_bit[2] = bin_c[2]^bin_c[3]; 
    // assign gray_others_bit[3] = bin_c[3]^bin_c[4]; 
    // assign gray_others_bit[4] = bin_c[4]^bin_c[5]; 
end
    
assign gray_c = {gray_msb,gray_others_bit};


endmodule



/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/



/*模块：双口RAM*/
module RAM #(
   parameter DEPTH = 256,
   parameter WIDTH_A = 8,
   parameter WIDTH_D = 16

)(
  input                    r_clk,
  input                    w_clk,
  input                    rst_n,
                           
  input [WIDTH_A-1:0]      w_addr,   
  input [WIDTH_D-1:0]      w_data,
  input                    w_en,
  
  input [WIDTH_A-1:0]      r_addr,
  input                    r_en,
  
  output reg[WIDTH_D-1:0]  r_data
);


reg [15:0]  mem[0:DEPTH-1];

integer i;
always @( posedge w_clk )
  if( !rst_n )
    for(i=0;i<DEPTH;i=i+1)  //同步复位时，将mem里全刷上0
      mem[i] <= 'h0000;     //
  else if( w_en )
    mem[w_addr] <= w_data;
    
always @( posedge r_clk )
  if( !rst_n )
    r_data <= 'h0000;
  else if( r_en )
    r_data <= mem[r_addr];
    
endmodule  



/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/



/*模块：同步模块，将输入的并行数据，打两拍到指定时钟域*/
module syn #(
  parameter WIDTH_D = 5
)
(
    input                    syn_clk,
    input                    syn_rst,
    input [WIDTH_D:0]      data_in,
    
    output [WIDTH_D:0]     syn_data
);

reg [WIDTH_D:0] syn_reg_1,syn_reg_2;

always @( posedge syn_clk )
  if( !syn_rst ) begin
  	syn_reg_1 <= 'h00;
  	syn_reg_2 <= 'h00;
  end
  else begin
    syn_reg_1 <= data_in;
    syn_reg_2 <= syn_reg_1; //普通的数据可不敢这样同步，得全是亚稳态，连续的格雷码这么做才能
  end			    //相对稳定一些
  
assign syn_data = syn_reg_2;

endmodule





/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/




//读地址控制器
//功能1：产生读地址的格雷码和二进制码
//       格雷码将在顶层中送给写控制器
//       二进制码将在顶层中送给RAM
//功能2：将产生的格雷码读地址，与输入进来的已经同步到读时钟域
//       的写时钟域发来的格雷码写地址相对比产生empty信号
//
//注意：在此module中，无论是input的地址，还是output的地址
//      都含有1bit的扩展位
module read_part #(
   parameter WIDTH_A = 8 //读地址[8:0]，最高位[8]为扩展位，其他位[7:0]为真实地址位 
)(
      input            r_clk,          
      input            r_rst,          
      input            r_req,         //读请求
                                              
      input      [WIDTH_A:0] w_gaddr, //输入的是同步到读时钟域之后的
				      //写时钟域发过来的写地址的格雷码      
                                       
      output           	      r_empty,//空指示信号  
      output reg [WIDTH_A:0]  r_addr, //此控制器产生的二进制读地址
      output reg [WIDTH_A:0]  r_gaddr //经由此控制器产生的格雷码读地址(调用了格雷码转换模块)
);

/*有读请求且不为空，地址向前走*/
always @( posedge r_clk )                                                          
  if( !r_rst )                                                                     
    r_addr <= 'h00;                                                                
  else if( r_req&&(!r_empty) )                                                      
    r_addr <= r_addr + 1'b1;                                                       
       
/*将生成的地址转码成格雷码*/
wire [WIDTH_A:0] r_gaddr_w;									    
bin_to_gray #(                                                                     
  .WIDTH_D(WIDTH_A+1)                                                                      
)                                                                                  
bin_to_gray_inst                                                                   
(                                                                                  
   .bin_c ( r_addr ),                                                              
   .gray_c( r_gaddr_w )                                                              
); 

/*复位格雷码*/
always @( posedge r_clk )
  if( !r_rst )
    r_gaddr <= 'h0;
  else
    r_gaddr <= r_gaddr_w;	  

/*生成empty指示信号*/                                                                           
assign r_empty = (w_gaddr==r_gaddr_w)?1'b1:1'b0;       

endmodule



/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------*/



//写地址控制模块，与读地址控制模块大同小异
module write_part #(
  parameter WIDTH_A = 8 
)(
  input            w_clk,
  input            w_rst,
  input            w_req,
             
  input      [WIDTH_A:0] r_gaddr,
             
  output           w_full ,
  output reg[WIDTH_A:0]  w_addr ,
  
  output reg [WIDTH_A:0]  w_gaddr       
);                                   

//reg [4:0] w_addr;
always @( posedge w_clk )
  if( !w_rst )
    w_addr <= 'h00;
  else if( w_req&&(!w_full) )
    w_addr <= w_addr + 1'b1;

wire [WIDTH_A:0] w_gaddr_w;
bin_to_gray #(             
  .WIDTH_D(WIDTH_A+1)              
)
bin_to_gray_inst
(                                
   .bin_c ( w_addr ),    
   .gray_c( w_gaddr_w )    
);        

always @( posedge w_clk )
  if( !w_rst )
    w_gaddr <= 'h0;
  else
    w_gaddr <= w_gaddr_w;	  



assign w_full = ({~w_gaddr_w[WIDTH_A],~w_gaddr_w[WIDTH_A-1],w_gaddr_w[WIDTH_A-2:0]}==r_gaddr)?1'b1:1'b0;

endmodule

测试

`timescale 1ns/1ps

module tb;

logic         w_clk ;
logic         w_req ;
logic [7:0]   w_data;
      
logic         r_clk; 
logic         rst_n; 
logic         r_req; 

logic [7:0]   r_data;
logic         w_full;
logic         r_empty;

always #10 w_clk = ~w_clk;
always #20 r_clk = ~r_clk; //读的慢写的快

initial begin
  w_req = 0;
  w_data = 0;
  r_req = 0;
  w_clk = 0;
  r_clk = 0;
  rst_n = 0;
  #30; 
  rst_n = 1;
  #20;
  r_req = 1;
  w_req = 1;
  forever begin
    @( posedge w_clk )
    if( !w_full )
    w_data = w_data + 'd5;
  end     
end

asyn_fifo #(
  .DEPTH   (256),
  .WIDTH_A (8  ),  
  .WIDTH_D (8 ) 
)
asyn_fifo_inst(             
     .w_clk  ( w_clk   ),   
     .rst_n  ( rst_n   ),   
     .w_req  ( w_req   ),   
     .w_data ( w_data  ),  
                      
     .r_clk  ( r_clk   ),   
     .r_req  ( r_req   ),  
                      
     .r_data ( r_data  ),  
                      
     .w_full ( w_full  ), 
     .r_empty( r_empty )                                       
);   

endmodule
搞IC的那些年
关注
专栏目录
跨时钟域问题（三）异步FIFO的Verilog实现（格雷码）
安静到无声
08-11 4615
异步FIFO是用来在两个异步时钟域间传输数据。图1 用异步FIFO进行数据传输System X利用xclk时钟将数据写入FIFO，并利用System X利用yclk时钟进行输出。其中fifo_full和fifo_empty分别是满标志和空标志，用于说明数据状态，当fifo_full时，不再进行数据的写入，当fifo_empty时不再进行数据的读取。.........
【Verilog基础】异步FIFO不用格雷码会影响FIFO功能吗？异步FIFO读写指针同步带来的延迟会导致设计出错吗？（面试常问）
悟已往之不谏 知来者之可追
08-12 951
【Verilog基础】异步FIFO不用格雷码会影响FIFO功能吗？（面试常问）
异步fifo_FPGA 设计之 跨时钟域（五 - 异步FIFO）
weixin_39733146的博客
11-17 1250
在之前的一篇文章中我们已经总结了格雷码的原理和使用，本篇将继续多比特跨时钟域设计系列，总结 异步FIFO 的设计。本篇介绍的 异步FIFO 设计原理是基于上一篇文章推荐的论文《Simulation and Synthesis Techniques for Asynchronous FIFO Design》，我将会从以下几点来总结：FIFO整体架构及模块划分读写指针是怎么工作的如何产生满空信号读写时...
异步FIFO中格雷码和二进制数据的转换
zl01121100的博客
05-05 591
1、二进制数据转换为格雷码 parameter ADDRSIZE = 4; wire [ADDRSIZE:0] wbnext,wgnext; //wbnext is binary code,wgnext is gray code; assign wgnext = (wbnext >> 1) ^ wbnext; //binary code ...
Xilinx系FPGA学习笔记（七）FIFO的IP核学习
最新发布
贾saisai的博客
09-11 1347
FIFO（First In First Out），即先进先出。FPGA 或者 ASIC 中使用到的 FIFO一般指的是对数据的存储具有先进先出特性的一个缓存器，常被用于数据的缓存或者高速异步数据的交互。它与普通存储器的区别是没有外部读写地址线，这样使用起来相对简单，但缺点就是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加 1 完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。
牛客网 Verilog刷题 跨时钟域传输专题3 异步FIFO
weixin_47563272的博客
09-27 483
牛客网 Verilog刷题 跨时钟域传输专题3 异步FIFO
异步FIFO设计之格雷码
jk_101的博客
12-20 540
相邻的格雷码只有1bit的差异，因此格雷码常常用于异步fifo设计中，保证afifo的读地址（或写地址）被写时钟（或读时钟）采样时最多只有1bit发生跳变。在不考虑路径延时的情况下，因为源数据（读写地址）只有1bit变化，即使发生了亚稳态，最终的结果相当于被目的时钟延迟一拍采样。需要注意的是：异步fifo中使用格雷码无法避免亚稳态，它起到的作用是，即使发生了亚稳态，依旧能够保证异步fifo的功能正确。
异步fifo跨时钟域处理
11-30
使用FPGA内部FIFO做跨时钟域的信息处理，避免亚稳态的传播。
yibufifo.rar_FIFO 格雷码_fifo_veriolg d触发器_异步FIFO_格雷码
09-21
5. **Gray code原理与Verilog实现**：理解格雷码的转换规则，并能用Verilog代码实现这一转换是设计异步FIFO的必备技能。通过格雷码的逻辑运算，可以方便地在硬件中实现地址的无跳变变化。 以上就是关于"yibufifo....
基于Verilog HDL的异步FIFO设计与实现
08-05
"基于Verilog HDL的异步FIFO设计与实现" ...本文提出了一种新颖的异步FIFO设计方案，该方案使用格雷码和象限检测法来产生正确的空/满标志，可以应用于多时钟域的情况，解决异步信号传输问题，并确保信号电平的稳定。
异步FIFO设计与FPGA跨时钟域难题解构
异步FIFO结构及FPGA设计---跨时钟域设计 异步FIFO是现代集成电路设计中的关键组件，特别是在多时钟域系统中，它们用于连接不同时钟速率的模块，确保数据在异步时钟之间高效且可靠地传输。这种设计的关键在于解决两...
Verilog之跨时钟域设计-FIFO
AMD81192的博客
04-27 2392
跨时钟域处理(二):格雷码
qq_40268672的博客
02-19 5511
在跨时钟域处理(一)中，我们介绍了针对单bit信号的跨时钟域处理方法—使用DFF打两拍，然而这个方法对多bit的数据并不管用。 首先，我们知道，使用DFF打两拍可以基本消除亚稳态的问题，但是无法保证采样得到的数据是正确的，因此，如果现在要采样的是一个多bit的跨时钟域信号，比如4bit信号，那么由于建立时间和保持时间的违例，虽然在打两拍之后可以得到一个稳定的数据，但该数据的每一个bit都不一定是正确的，所以其可能的值有24=162^4=1624=16种，这显然是无法接受的，因此，对于多比特信号的跨时钟域处理
跨时钟域、格雷码、独热码、竞争冒险
weixin_49155137的博客
07-23 633
每两个相邻编码之间只有一位是不同的，并且对于N位格雷码，当从最高位编码（对应二进制2^N -1）跳转到最低位编码（对应0）时也只会发生1bit跳转。单bit跳转意味着格雷码在通过二级同步器跨时钟时，输出不会出现不可控的中间状态，只能是正确的更新状态或者保持原来的状态。，第二级寄存器锁存住某个时钟上升沿到来时的输入电平，第一级寄存器锁存住下一个时钟沿到来时的输入电平，如果这两个寄存器锁存住的电平信号不同，就说明检测到了边沿，具体是上升沿还是下降沿可以通过组合逻辑来实现。要实现边沿检测，最直接的想法是用。
3位格雷码的顺序编码_一种优化格雷码编码方式实现跨时钟域的装置的制作方法...
weixin_39713335的博客
12-21 345
本发明属于信号处理技术领域，尤其是涉及一种优化格雷码编码方式实现跨时钟域的装置。背景技术：随着时间的推移，集成电路行业发展至今，已有类似如intel这样先进的foundry，提出迈入10nm制程的规划。高集成度的推行，也使芯片规模越来越大，功能越来越复杂，目前soc的内部时钟高度复杂，导致跨时钟域的接口越来越多。针对这些异步信号的处理方法多种多样，在最常用的异步fifo实现的跨时钟域处理中个，大量...
异步FIFO结构及FPGA设计
03-30 2675
http://www.pld.com.cn/application/a82.htm摘要：首先介绍异步FIFO的概念、应用及其结构，然后分析实现异步FIFO的难点问题及其解决办法；在传统设计的基础上提出一种新颖的电路结构并对其进行综合仿真和FPGA实现。 关键词：异步电路 FIFO 亚稳态 格雷码1 异步FIFO介绍在现代的集成电路芯片中，随着设计规模的不断扩大，一个系统中往往含有数
(一)异步FIFO的设计
一个粉尘的成长博客
11-17 447
异步FIFO的设计与验证
异步fifo深度 设计地址格雷码_多时钟域的设计和综合技巧（四）
weixin_33568172的博客
01-16 240
同步数据信号将数据从一个时钟域传递到另一个时钟域类似于传递多个没有顺序关系的控制信号。但是不能使用同步器来同步数据信号，因为会采样到错误数据。在时钟域之间同步数据的两种常用方法是：（1）使用握手信号在时钟域之间传递数据（2）使用FIFO（先进先出存储器）。使用握手信号在时钟域之间传递数据可以使用握手控制信号在时钟域之间传递数据。但是在使用握手信号时，控制信号越多，将数据从一个时钟域传递到另一个时钟...
异步fifo设计
hu491199877的博客
03-31 1654
verilog 异步fifo设计
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

搞IC的那些年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值