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

已于 2022-08-30 23:47:33 修改
阅读量610 收藏 8
点赞数 1
分类专栏： 数字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的那些年
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
跨异步时钟域的6种方法
helrori
05-25 1万+
方法1 双触发器（打2拍） 该方法只用于慢到快时钟域的1bit信号传递。 module ff2( input clk0,//10M input din, input clk1,//100M output dout ); reg din_r=1'd0; reg r0=1'd0; reg r1=1'd0; assign dout = r1; always@(posedge clk0) din_r <= din;/
跨时钟域、格雷码、独热码、竞争冒险
weixin_49155137的博客
07-23 432
每两个相邻编码之间只有一位是不同的，并且对于N位格雷码，当从最高位编码（对应二进制2^N -1）跳转到最低位编码（对应0）时也只会发生1bit跳转。单bit跳转意味着格雷码在通过二级同步器跨时钟时，输出不会出现不可控的中间状态，只能是正确的更新状态或者保持原来的状态。，第二级寄存器锁存住某个时钟上升沿到来时的输入电平，第一级寄存器锁存住下一个时钟沿到来时的输入电平，如果这两个寄存器锁存住的电平信号不同，就说明检测到了边沿，具体是上升沿还是下降沿可以通过组合逻辑来实现。要实现边沿检测，最直接的想法是用。
verilog电路设计：同/异步fifo、按键消抖、无毛刺时钟切换电路、二进制/格雷码转换
d_b_的博客
06-18 407
【代码】verilog电路设计：同/异步fifo、按键消抖、无毛刺时钟切换电路、二进制/格雷码转换。
同步（单时钟）、异步（双时钟）FIFO的Verilog HDL实现（含Testbench仿真代码）
qq_36045093的博客
07-21 5227
参考资料： 《FPGA自学笔记——设计与验证》；《硬件架构的艺术》；《Verilog HDL数字集成电路高级程序设计》等 链接： 一、FIFO的定义和应用场景 FIFO（First in First Out）是一种先进先出的数据缓冲器，通常用于接口电路的数据缓存。与普通存储器的区别是没有外部读写地址线，可以使用两个时钟分别进行读和写操作。 FIFO只能顺序写入数据和顺序读出数据，其数据地址由内部读、写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。 二、FIFO的
46-FPGA跨时钟域异步FIFO设计.7z
03-17
FPGA跨时钟域异步FIFO设计,Vivado仿真工程
基于异步FIFO实现不同时钟域间数据传递的设计
12-09
本文通过采用异步FIFO的方式给出了这个问题的一种解决方法，并采用Verilog 硬件描述语言通过前仿真和逻辑综合完成设计。 关键词：异步FIFO；时钟域；Verilog引言当今集成电路设计的主导思想之一就是设计同步化，即对...
55-FPGA跨时钟域格雷码设计.7z
03-31
FPGA跨时钟域格雷码设计,Vivado仿真工程
基于Verilog HDL的异步FIFO设计与实现
08-05
本文提出一种新颖的异步FIFO设计方案，它通过先比较读写地址并结合象限检测法产生异步的空/满标志，再把异步的空/满标志同步到相应的时钟域。通过仿真验证，该方法是稳定有效的。
异步fifo的verilog实现
07-08
该资源是实现了的通过异步fifo进行跨时钟域传输的vivado工程，在不同的时钟域进行fifo数据读写，并用读写地址的格雷码判断fifo空满产生空满标志。工程代码基于vivado2017.4，并在modelsim10.6上仿真成功。工程中附有...
跨时钟域处理3大方法揭晓
03-15
跨时钟域处理的3大方法，讲的很细，很清楚，很适合初学者的学习
异步fifo跨时钟域处理
11-30
使用FPGA内部FIFO做跨时钟域的信息处理，避免亚稳态的传播。
【FIFO】异步 FIFO 设计
记录学习历程
06-05 5274
异步 FIFO 指一种 FIFO 设计，其中数据值从一个时钟域写入 FIFO 缓冲区，而数据值从另一个时钟域的同一 FIFO 缓冲区读取，其中两个时钟域彼此异步。异步 FIFO 用于将数据从一个时钟域安全地传递到另一个时钟域。本文讨论了一种 FIFO 设计风格以及在进行异步 FIFO 设计时必须考虑的重要细节。
Verilog之跨时钟域设计-FIFO
AMD81192的博客
04-27 2216
异步FIFO的设计
ZZ2588的博客
01-06 2983
本文首先对异步 FIFO 设计的重点难点进行分析 最后给出详细代码 一、FIFO简单讲解 FIFO的本质是RAM， 先进先出 重要参数：fifo深度（简单来说就是需要存多少个数据） fifo位宽（每个数据的位宽） FIFO有同步和异步两种，同步即读写时钟相同，异步即读写时钟不相同 同步FIFO用的少，可以作为数据缓存 异步FIFO可以解决跨时钟域的问题，在应用时需根据实际情况考虑好fifo深度即可 本次要设计一个异步FIFO，深度为8，位宽也是8. 代码是学习...
异步fifo设计
hu491199877的博客
03-31 1591
verilog 异步fifo设计
(一)异步FIFO的设计
一个粉尘的成长博客
11-17 356
异步FIFO的设计与验证
异步FIFO_Verilog实现
Crazzy_M的博客
05-18 4118
异步FIFO_Verilog实现 概述： FIFO本质上还是RAM，是一种先进先出的数据缓存器(先存入的数据先取出)。它与普通存储器的区别：没有外部读写地址线，只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加1，不像其他存储器可以由地址线决定读取或写入某个指定的地址，异步FIFO读写时钟不同，读写是相互独立的。 用途： (1)跨时钟域多bit传输：读写可以由不同的时钟控制，使用异步FIFO可以在两个不同时钟系统之间快速方便的传输数据。 (2)数据匹配：对于不同宽度的数据接口可以使用FIFO，
IC设计基础系列之CDC篇3：揭秘《跨时钟域处理》三大方法
热门推荐
时间的诗
06-11 1万+
  来自：http://dengkanwen.com/238.html   跨时钟域处理是FPGA设计中经常遇到的问题，而如何处理好跨时钟域间的数据，可以说是每个FPGA初学者的必修课。如果是还在校的本科生，跨时钟域处理也是面试中经常常被问到的一个问题。 在本篇文章中，主要介绍3种跨时钟域处理的方法，这3种方法可以说是FPGA界最常用也最实用的方法，这三种方法包含了单bit和多bit数据的...
跨时钟域信号同步问题
求知欲
11-05 3421
在从一个时钟域跨越至另一个时钟域时，在目的时钟对接近过渡状态的总线进行采样时，数据zongxian
跨时钟域处理格雷码verilog
最新发布
10-15
跨时钟域处理格雷码是指在不同时钟域之间进行格雷码的转换和处理。Verilog语言提供了一些机制来实现这样的跨时钟域处理。 首先，Verilog中可以使用时钟使能（clock enable）来控制时钟域切换时的格雷码转换。通过将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

搞IC的那些年

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

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

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

打赏作者

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

抵扣说明：

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

余额充值