Verilog实现任意位宽异步FIFO

最新推荐文章于 2024-04-15 19:50:34 发布
最新推荐文章于 2024-04-15 19:50:34 发布
阅读量924 收藏 14
点赞数 1
分类专栏： 数字芯片 文章标签： fpga verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37612339/article/details/115659741
版权

主模块：

`timescale 1ns / 1ps

module Async_FIFO#(
    parameter   ADDR_WIDTH = 4,
                DATA_WIDTH = 8,
                ALMOST_GAP = 3
)(
    input   wire                        wr_clk  ,   //写时钟
    input   wire                        wr_rst_n,   //写复位
    input   wire                        wr_en   ,   //写使能
    input   wire    [DATA_WIDTH-1:0]    wr_data ,   //用于写入的数据
    
    input   wire                        rd_clk  ,   //读时钟
    input   wire                        rd_rst_n,   //读复位
    input   wire                        rd_en   ,   //读使能
    
    
    output  reg                         full    ,   //FIFO写满信号，使用输出寄存器以保证与控制时钟同步
    output  reg                         empty   ,   //FIFO读空信号，使用输出寄存器以保证与控制时钟同步
    output  reg                         almost_full,//FIFO将满信号，使用输出寄存器以保证与控制时钟同步
    output  reg                         almost_empty,//FIFO将空信号，使用输出寄存器以保证与控制时钟同步
    output  wire    [DATA_WIDTH-1:0]    rd_data     //读出的数据
);

wire  full_next, empty_next, almost_empty_next, almost_full_next;//空满信号次态逻辑

reg   [ADDR_WIDTH:0]    wr_addr_ptr_next, rd_addr_ptr_next;//读写地址指针二进制码次态逻辑
reg   [ADDR_WIDTH:0]    wr_addr_ptr, rd_addr_ptr;  //读写地址指针
wire  [ADDR_WIDTH-1:0]  wr_addr, rd_addr; //读写地址

//读写地址赋值
assign  wr_addr = wr_addr_ptr[ADDR_WIDTH-1:0];
assign  rd_addr = rd_addr_ptr[ADDR_WIDTH-1:0];  


wire  [ADDR_WIDTH:0]    wr_addr_ptr_gray_next, rd_addr_ptr_gray_next; //读写地址指针格雷码次态逻辑
reg   [ADDR_WIDTH:0]    wr_addr_ptr_gray, wr_addr_ptr_gray1, wr_addr_ptr_gray2; //写地址指针格雷码转换及跨时钟打拍信号
reg   [ADDR_WIDTH:0]    rd_addr_ptr_gray, rd_addr_ptr_gray1, rd_addr_ptr_gray2; //读地址指针格雷码转换及跨时钟打拍信号



// *************************** 写时钟域时序逻辑 ***************************** //
//数据更新
always@(posedge wr_clk or negedge wr_rst_n)
    if(!wr_rst_n) begin
        wr_addr_ptr <= 0;
        wr_addr_ptr_gray <= 0;
        full <= 0;
        almost_full <= 0;
    end
    else begin    
        wr_addr_ptr <= wr_addr_ptr_next;
        wr_addr_ptr_gray <= wr_addr_ptr_gray_next;
        full <= full_next;
        almost_full <= almost_full_next;
    end


//格雷码读指针同步至写时钟域
always@(posedge wr_clk or negedge wr_rst_n)
    if(!wr_rst_n)   begin
        rd_addr_ptr_gray1 <= 0;
        rd_addr_ptr_gray2 <= 0;
    end
    else    begin
        rd_addr_ptr_gray1 <= rd_addr_ptr_gray ;
        rd_addr_ptr_gray2 <= rd_addr_ptr_gray1;
    end
// ************************************************************************** //




// *************************** 读时钟域时序逻辑 ***************************** //
//数据更新
always@(posedge rd_clk or negedge rd_rst_n)
    if(!rd_rst_n) begin
        rd_addr_ptr <= 0;
        rd_addr_ptr_gray <= 0;
        empty <= 0;
        almost_empty <= 0;
    end
    else begin    
        rd_addr_ptr <= rd_addr_ptr_next;
        rd_addr_ptr_gray <= rd_addr_ptr_gray_next;
        empty <= empty_next;
        almost_empty <= almost_empty_next;
    end


//格雷码写指针同步至读时钟域
always@(posedge rd_clk or negedge rd_rst_n)
    if(!rd_rst_n)   begin
        wr_addr_ptr_gray1 <= 0;
        wr_addr_ptr_gray2 <= 0;
    end
    else    begin
        wr_addr_ptr_gray1 <= wr_addr_ptr_gray ;
        wr_addr_ptr_gray2 <= wr_addr_ptr_gray1;
    end
// ************************************************************************** //




// ********************** 格雷码计数器的处理(次态逻辑) ********************** //
//写地址指针:二进制转格雷码
assign  wr_addr_ptr_gray_next = (wr_addr_ptr_next >> 1) ^ wr_addr_ptr_next;

//读地址指针:二进制转格雷码
assign  rd_addr_ptr_gray_next = (rd_addr_ptr_next >> 1) ^ rd_addr_ptr_next;


reg [ADDR_WIDTH:0] wr_addr_ptr_gray_to_bin;
reg [ADDR_WIDTH:0] rd_addr_ptr_gray_to_bin;

//同步后的写地址格雷码指针解码：格雷码转二进制
integer i;
always@(*)  begin
    wr_addr_ptr_gray_to_bin[ADDR_WIDTH] = wr_addr_ptr_gray2[ADDR_WIDTH];
    for(i=ADDR_WIDTH-1; i>=0; i=i-1)
        wr_addr_ptr_gray_to_bin[i] = wr_addr_ptr_gray2[i] ^ wr_addr_ptr_gray_to_bin[i+1];
end


//同步后的读地址格雷码指针解码：格雷码转二进制
integer j;
always@(*)  begin
    rd_addr_ptr_gray_to_bin[ADDR_WIDTH] = rd_addr_ptr_gray2[ADDR_WIDTH];
    for(j=ADDR_WIDTH-1; j>=0; j=j-1)
        rd_addr_ptr_gray_to_bin[j] = rd_addr_ptr_gray2[j] ^ rd_addr_ptr_gray_to_bin[j+1];
end
// ************************************************************************** //




// ******************************* 次态逻辑 ********************************* //
//二进制写地址指针次态逻辑
always@(*)
    if(!wr_rst_n)
        wr_addr_ptr_next = 0;
    else if(wr_en && !full_next)
        wr_addr_ptr_next = wr_addr_ptr + 1;
    else    
        wr_addr_ptr_next = wr_addr_ptr;


//二进制读地址指针次态逻辑
always@(*)
    if(!rd_rst_n)
        rd_addr_ptr_next = 0;
    else if(rd_en && !empty_next)
        rd_addr_ptr_next = rd_addr_ptr + 1;
    else    
        rd_addr_ptr_next = rd_addr_ptr;


//满信号次态逻辑，用格雷码高两位取反，用二进制码最高位取反
assign  full_next = ({!wr_addr_ptr[ADDR_WIDTH], wr_addr} == rd_addr_ptr_gray_to_bin)?1:0;

//空信号次态逻辑
assign  empty_next = (rd_addr_ptr == wr_addr_ptr_gray_to_bin)?1:0;


reg [ADDR_WIDTH:0] room_avail;
reg [ADDR_WIDTH:0] data_avail;

//room_avail信号生成，用于进行将满判断，对应写时钟域信号
always@(*)
    if(wr_addr_ptr[ADDR_WIDTH] != rd_addr_ptr_gray_to_bin[ADDR_WIDTH])
        room_avail = rd_addr_ptr_gray_to_bin[ADDR_WIDTH-1:0] - wr_addr_ptr[ADDR_WIDTH-1:0];
    else
        room_avail = 2**ADDR_WIDTH - (wr_addr_ptr[ADDR_WIDTH-1:0] - rd_addr_ptr_gray_to_bin[ADDR_WIDTH-1:0]);

assign  almost_full_next = (room_avail <= ALMOST_GAP)?1:0;


//data_avail信号生成，用于进行将空判断，对应读时钟域信号
always@(*)
    if(rd_addr_ptr[ADDR_WIDTH] != wr_addr_ptr_gray_to_bin[ADDR_WIDTH])
        data_avail = 2**ADDR_WIDTH - (rd_addr_ptr[ADDR_WIDTH-1:0] - wr_addr_ptr_gray_to_bin[ADDR_WIDTH-1:0]);
    else
        data_avail = wr_addr_ptr_gray_to_bin[ADDR_WIDTH-1:0] - rd_addr_ptr[ADDR_WIDTH-1:0];

assign  almost_empty_next = (data_avail <= ALMOST_GAP)?1:0;

wire   RAM_wr_en,  RAM_rd_en;
assign RAM_wr_en = wr_en && !full_next;
assign RAM_rd_en = rd_en && !empty_next;
// ************************************************************************** //




// ****************************** 存储模块例化 ****************************** //
RAM_MEM RAM_MEM_inst
(
	.wr_clk    ( wr_clk    ) ,
    .wr_rst_n  ( wr_rst_n  ) ,
	.wr_en     ( RAM_wr_en ) ,
	.wr_addr   ( wr_addr   ) ,
	.rd_clk    ( rd_clk    ) ,
    .rd_rst_n  ( rd_rst_n  ) ,
	.rd_en     ( RAM_rd_en ) ,
	.rd_addr   ( rd_addr   ) ,
	.data_in   ( wr_data   ) ,
                           
	.data_out  ( rd_data   )
);
// ************************************************************************** //

endmodule




// ************************************************************************** //
// ****************************** 存储模块定义 ****************************** //
// ************************************************************************** //
module 	RAM_MEM  #(
    parameter   DATA_WIDTH = 8,
                ADDR_WIDTH = 4      
)(
	input 	wire                        wr_clk  ,
    input   wire                        wr_rst_n,
	input 	wire                        wr_en   ,
	input   wire    [ADDR_WIDTH-1:0]    wr_addr ,
	input   wire                        rd_clk  ,
    input   wire                        rd_rst_n,
	input   wire                        rd_en   ,
	input   wire    [ADDR_WIDTH-1:0]    rd_addr ,
	input   wire    [DATA_WIDTH-1:0]    data_in ,
    
	output  reg     [DATA_WIDTH-1:0]    data_out
);
			
//存储阵列定义
reg [DATA_WIDTH-1:0] SRAM_MEM [2**ADDR_WIDTH - 1:0];

//数据写入
integer i;
always @ (posedge wr_clk or negedge wr_rst_n)
	if(!wr_rst_n)
        for(i=0; i<2**ADDR_WIDTH;i=i+1)
            SRAM_MEM[i] <= 0;
    else if (wr_en)
		SRAM_MEM [wr_addr] <= data_in;
	else
		SRAM_MEM [wr_addr] <= SRAM_MEM [wr_addr];

//数据读出
always @ (posedge rd_clk or negedge rd_rst_n)
    if(!rd_rst_n)
        data_out <= 'b0;
    else if (rd_en)
		data_out <= SRAM_MEM [rd_addr];
	else
		data_out <= 'b0;
        
endmodule	
// ************************************************************************** //

testbench：

`timescale 1ns / 1ps

module tb_Async_FIFO();
parameter   ADDR_WIDTH = 4,
            DATA_WIDTH = 8;

reg    wr_clk      ;
reg    wr_rst_n    ;
reg    wr_en       ;
reg    [DATA_WIDTH-1:0]  wr_data ;
reg    rd_clk      ;
reg    rd_rst_n    ;
reg    rd_en       ;
                                       
wire   full        ;
wire   empty       ;
wire   almost_full ;
wire   almost_empty;
wire   [DATA_WIDTH-1:0]  rd_data;

initial begin
    wr_clk    = 0;
    wr_rst_n  = 0;
    wr_en     = 0;
    wr_data   = 0;
    rd_clk    = 0;
    rd_rst_n  = 0;
    rd_en     = 0;
    #20 wr_rst_n  = 1;  rd_rst_n  = 1; 
        wr_data   = 8'd5;
    #20 wr_en = 1; 
    #20 wr_data   = 8'd6;
    #20 wr_data   = 8'd7;
    #20 wr_data   = 8'd8;
    #20 wr_data   = 8'd9;
    #20 wr_data   = 8'd10;
    #10 wr_en = 0;
    #20  rd_en = 1;
    #300 rd_en = 0;  wr_en = 1;
    #10 wr_data   = 8'd1;
    #20 wr_data   = 8'd2;
    #20 wr_data   = 8'd3;
    #20 wr_data   = 8'd4;
    #20 wr_data   = 8'd5;
    #20 wr_data   = 8'd6;
    #20 wr_data   = 8'd7;
    #20 wr_data   = 8'd8;
    #20 wr_data   = 8'd9;
    #20 wr_data   = 8'd10;
    #20 wr_data   = 8'd11;
    #20 wr_data   = 8'd12;
    #20 wr_data   = 8'd13;
    #20 wr_data   = 8'd14;
    #20 wr_data   = 8'd15;
    #20 wr_data   = 8'd16;
    #20 wr_data   = 8'd17;
    #100 wr_en = 0;  rd_en = 1;
end


always #10 wr_clk = ~wr_clk;

always #20 rd_clk = ~rd_clk;


Async_FIFO  Async_FIFO_inst
(
    .wr_clk        ( wr_clk       ) ,   //写时钟
    .wr_rst_n      ( wr_rst_n     ) ,   //写复位
    .wr_en         ( wr_en        ) ,   //写使能
    .wr_data       ( wr_data      ) ,   //用于写入的数据
    
    .rd_clk        ( rd_clk       ) ,   //读时钟
    .rd_rst_n      ( rd_rst_n     ) ,   //读复位
    .rd_en         ( rd_en        ) ,   //读使能
    
    .full          ( full         ) ,   
    .empty         ( empty        ) ,   
    .almost_full   ( almost_full  ) ,
    .almost_empty  ( almost_empty ) ,
    .rd_data       ( rd_data      )     //读出的数据
);

endmodule

 

逻辑仿真波形图：

 

独狼JQ
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于简单的FIFO提供数据宽度转换
10-25
本设计方案描述了为不同宽度读写数据端口的数据宽度转换，怎样基于FPGA的FIFO实现共有时钟（同步）。可以使用Xilinx的Spartan II系列FPGA实现这种FIFO。这个方法使用了片上DLL（延迟锁相环）宏、分布式存储器和简单的计数器逻辑。
FPGA之FIFO详解，读写位宽不同
热门推荐
wandou0511的博客
02-09 1万+
这篇博客里，通过两个练习来总结在FPGA设计中FIFO读写位宽不同的情况下，我们应该去如何设计时序逻辑，因为在现实工程中FIFO读写位宽不同也是经常出现的情况。 练习1 设计一个模块包含读写位宽是32bit、读写深度是64的异步时钟FIFO，其中输入数据信号din和输入 数据指示信号din_vld是属于clk_in时钟域的，上游模块会负责写数据到本模块的FIFO中，当本模块FIFO写端口已写入了60个数据，也就是FIFO快要写满溢出的时候，这时上游模块仍有数据要写入FIFO...
Verilog功能模块——读写位宽不同的异步FIFO_fifo读写位宽不一致(2)
最新发布
04-15 687
前面的博文已经讲了异步FIFO和同步FIFO，但并没有实现FIFO的读写位宽转换功能，此功能是FIFO的主要功能之一，应用十分广泛，因此，在前面两个模块的基础上，本文使用纯Verilog实现了读写位宽不同的FIFO，并仿真验证了设计的正确性。一种极限情况，DIN_WIDTH = 4，DOUT_WIDTH=16，WADDR_WIDTH=5，RADDR_WIDTH =5+log2(4/16)=3。二. 模块功能框图与信号说明。
异步FIFO设计（Verilog）
沧海一升的博客
06-28 8435
FIFO（First In First Out）是异步数据传输时经常使用的存储器。该存储器的特点是数据先进先出（后进后出）。其实，多位宽数据的异步传输问题，无论是从快时钟到慢时钟域，还是从慢时钟到快时钟域，都可以使用 FIFO 处理。
FIFO 位宽转换
timeless_2014的博客
11-20 1万+
使用Xilinx FIFO进行位宽转换需要注意的问题： 1、高位宽转换为低位宽： 高位先输出，例： 32bit转为8bit : wr_data = 0x01020304 输出顺序为： rd_data0 =0x01, rd_data1 =0x02, rd_data2 =0x03, rd_data3 =0x04; 2、低位宽转高位宽： 先进的在高位，例： 8bit转32
Verilog | FIFO简单实现
qq_45776815的博客
05-25 2195
FIFO( First Input First Output)简单说就是指先进先出，也是缓存机制的一种，下面是我总结的 FIFO 的三大用途：1)提高传输效率，增加 DDR 带宽的利用率。比如我们有 4 路视频数据缓存到 DDR 中去，比较笨的方法是，每个通道视频数据对应一颗 DDR。现在对于 DDR 来说非常浪费，因为现在的 DDR3 可以跑 1600Mbps DDR4 可以跑到2400Mbps，如果你还是把一路视频数据对应一颗 DDR 显然严重浪费了带宽。
FIFO实现位宽转换
qq_40268672的博客
03-01 5607
之前在博客中实现了位宽相同的同步FIFO，然而，实际的应用场景往往更加复杂，它不仅需要FIFO实现先入先出的功能，有时候还需要实现数据位宽的转换，本文就介绍了如何通过Verilog实现一个具有位宽转换功能的同步FIFO。 写数据低位宽，读数据高位宽 在这种情况下，需要写入RDATA_WIDTH/WDATA_WIDTH个数据，才能读出一个数据，相应的RTL代码如下(主要设置了一个wr_cnt计数器): `timescale 1ns / 1ps /////////////////////////////////
数字电路设计笔记 - 异步FIFO(读写侧数据位宽不同)
hak22的博客
06-30 7358
近期参与的项目涉及到异步时钟域下多bit位数据传输的问题，解决的最好的办法便是异步FIFO。在网上查了相关的异步FIFO的资料，对于读写侧数据位宽相同情况下的异步FIFO有所了解。若要是读写侧数据位宽不同就再合适不过了，经过自己的一些改变，完成了该实现。理论知识网上介绍的很是你详细明了，咱们索性单刀直入，直捣黄龙。 一、总体实现架构图 总体实现架构图并没有变化，依旧包括存储模块、读指针及满生成模块、写指针及空生成模块及其两级数据同步模块。 ...
异步FIFO，Verilog源码
10-31
异步FIFO，Verilog源码实现异步FIFO，异步FIFO的原理,
Verilog实现的异步FIFO
04-05
Verilog实现的异步FIFO，不调用IP核，两级寄存器实现读写指针的同步，地址采用格雷码形式防止亚稳态
基于Verilog HDL的异步FIFO设计与实现
08-05
本文提出一种新颖的异步FIFO设计方案，它通过先比较读写地址并结合象限检测法产生异步的空/满标志，再把异步的空/满标志同步到相应的时钟域。通过仿真验证，该方法是稳定有效的。
异步fifo的verilog实现
07-08
该资源是实现了的通过异步fifo进行跨时钟域传输的vivado工程，在不同的时钟域进行fifo数据读写，并用读写地址的格雷码判断fifo空满产生空满标志。工程代码基于vivado2017.4，并在modelsim10.6上仿真成功。工程中附有...
异步fifo verilog代码.rar_fifo verilog 实现_fifo的读写_异步FIFO
09-15
实现了一种异步时钟同步的fifo设计，可实现不同时钟域读写fifo的互联
Verilog实现FIFO设计（二）之异步可变位宽，可变深度
凳子花❀的博客
08-15 2154
请查看：异步FIFO—Verilog实现 写的非常好，此处不再赘述。 补充一下采用博主代码实现时候的一些问题（可能是我个人的问题）： 在fifo_async这个模块中的下列代码： //=========================================================write fifo genvar i; generate for(i = 0; i < data_depth; i = i + 1 ) begin:fifo_init always@(posedg
【FPGA】单端口RAM的设计（同步读、同步写）
Reborn Lee
05-28 9227
Single Port RAM Synchronous Read/Write 这篇博文介绍单端口同步读写RAM，在之前的博文中，也介绍过类似的设计：【Verilog HDL 训练】第 13 天（存储器、SRAM） 在这篇博文中，与知识星球里的伙伴们交流，真是让我受益匪浅呀。 单端口同步读写RAM的设计没什么可描述的，代码不麻烦，看起来最为清晰： 输入输出： //-----------...
多比特跨时钟域之异步FIFO
Christmaso的博客
08-08 430
异步fifo
FPGA 中的DDR 用户编程
gtkknd的专栏
08-25 907
https://blog.csdn.net/baidu_34971492/article/details/88025611
verilog实现异步fifo
07-27
在Verilog中实现异步FIFO可以采用以下步骤： 1. 定义FIFO的输入和输出接口：包括读写时钟、读写使能信号、读写数据和读写指针等。 2. 使用两个时钟域的寄存器同步输入信号：由于读写时钟不同，需要使用两级寄存器...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值