实现同步FIFO的两种方式（Verilog）

最新推荐文章于 2025-07-15 19:47:31 发布
原创 最新推荐文章于 2025-07-15 19:47:31 发布 · 2.2k 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga开发

文章详细介绍了同步FIFO的概念及其在FPGA设计中的应用，重点讲述了两种实现方法：计数器法和高位扩展法。通过Verilog代码展示了如何设计和测试这两个方法，并讨论了FIFO的满标志和空标志的判断。

0. 目录

1. FIFO简介

  • FIFO 是一种先进先出的数据缓存器，一般用在隔离两边读写带宽不一致，或者位宽不一样的地方。
  • 在 FPGA 设计，使用 FIFO 一般有两个方法，第一个方法是直接调用官方的 FIFO IP，另外一个方法是自己设计 FIFO 控制逻辑。
  • FIFO 包括同步 FIFO 和异步 FIFO 两种。
  • 同步 FIFO 有一个时钟信号，读和写逻辑全部使用这一个时钟信号。
  • 异步 FIFO 有两个时钟信号，读和写逻辑用的各自的读写时钟。
  • FIFO 与 RAM 的区别是没有外部读写地址线；缺点是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加 1 完成，不能像RAM那样可以由地址线决定读取或写入某个指定的地址。
  • FIFO 本质上是由 RAM 加读写控制逻辑构成的一种先进先出的数据缓冲器。
  • FIFO 的宽度：即 FIFO 一次读写操作的数据位。
  • FIFO 的深度：指的是 FIFO 可以存储多少个 N 位的数据（如果宽度为 N）。
  • 满标志：FIFO 已满或将要满时由 FIFO 的状态送出的一个信号，以阻止 FIFO 的写操作继续向 FIFO 中写数据而造成溢出（overflow）。
  • 空标志：FIFO 已空或将要空时由 FIFO 的状态送出的一个信号，以阻止 FIFO 的读操作继续从 FIFO 中读出数据而造成无效数据的读出（underflow）。
  • 读时钟：读操作所遵循的时钟，在每个时钟沿来临时读数据（同步FIFO中与写时钟一致）。
  • 写时钟：写操作所遵循的时钟，在每个时钟沿来临时写数据（同步FIFO中与读时钟一致）。

2. 同步FIFO的实现

  • 两种实现方式：计数器法和高位扩展法。
  • FIFO设计关键：产生可靠的 FIFO 读写指针和生成 FIFO“空”/“满”状态标志。
  • FIFO读空的情况：（读指针追上写指针）–读写指针实质为读写地址
    ① 在复位操作时，当读写指针相等时，表明 FIFO 为空；
    ② 当读指针读出 FIFO 中最后一 个字后，追赶上了写指针时，表明 FIFO 为空。如下左图。
  • FIFO写满的情况：（写指针追上读指针）
    ① 当读写指针再次相等时，表明 FIFO 为满，这种情况发生在，当写指针转了一圈，折回来(wrapped around) 又追上了读指针。如下右图。
    左图为读空，右图为写满

2.1 计数器法

构建一个计数器，该计数器(fifo_cnt)用于指示当前 FIFO 中数据的个数：

  • 复位时，该计数器为0，FIFO中的数据个数为0，当wr_en = rd_en=1时，说明又读又写，计数器不变，FIFO中的数据个数无变化。
  • 当wr_en =1,rd_en = 0时且 full=0，则 fifo_cnt +1；表示写操作且 FIFO 未满时候，FIFO 中的数据个数增加了 1 。
  • 当wr_en =0,rd_en = 1时且 empty=0，则 fifo_cnt -1; 表示读操作且 FIFO 未满时候，FIFO 中的数据个数减少了 1 。
  • fifo_cnt =0 的时候，表示 FIFO 空，需要设置 empty=1；fifo_cnt = fifo的深度 的时候，表示 FIFO现在已经满，需要设置 full=1。

2.1.1 计数器实现同步FIFO–Verilog代码

//计算器法：
//wr_en = rd_en = 1 -> cnt不变;  (cnt指的是当前FIFO内部的数据个数)
//wr_en =0, rd_en = 1 -> cnt=cnt-1;
//wr_en =1, rd_en = 0 -> cnt=cnt+1.
//cnt = fifo_len， -> full=1;
//cnt = 0，  -> empty = 1;

module Sync_FIFO_cnt(
    input wr_en,rd_en,clk,reset,
    input [7:0] dataIn,
    output [7:0] dataOut,
    output full,empty
    );
parameter fifo_len = 8;
reg [3:0] fifo_cnt; // 当前fifo内部数据的个数
reg [7:0] dataOut_reg; 
reg [2:0] addr_wr;
reg [2:0] addr_rd; 
reg full_reg,empty_reg;
reg [7:0] RAM [fifo_len-1:0];

// generate addr_write
always @(posedge clk or posedge reset)
if (reset) begin
    addr_wr <= 3'd0;
    RAM[addr_wr] <= 8'd0;
end
else if (full_reg == 1'd0 && wr_en) begin
    addr_wr <= addr_wr + 1'b1;
    RAM[addr_wr] <= dataIn;
end
else begin
    addr_wr <= addr_wr;
    RAM[addr_wr] <= RAM[addr_wr];
end

// generate addr_read
always @(posedge clk or posedge reset)
if (reset) begin
    addr_rd <= 3'd0;
    dataOut_reg <= 8'd0;
end
else if (empty_reg == 1'd0 && rd_en) begin
    addr_rd <= addr_rd + 1'b1;
    dataOut_reg <= RAM[addr_rd];
end
else begin
    addr_rd <= addr_rd;
    dataOut_reg <= dataOut_reg;
end

// count the number of fifo data
always @(posedge clk or posedge reset)
 if (reset)
    fifo_cnt <= 3'd0;
 else if (wr_en == 1'd1 && rd_en == 1'd0) begin
    fifo_cnt <= fifo_cnt + 1'd1;
    end
 else if (wr_en == 1'd0 && rd_en == 1'd1) begin
    fifo_cnt <= fifo_cnt - 1'd1;
    end
 else begin
    fifo_cnt <= fifo_cnt;
 end

// generate full and empty signal
 always @(*)
 if  (fifo_cnt == (fifo_len)) begin
    full_reg <= 1'd1;
    empty_reg <= 1'd0;
    end
 else if  (fifo_cnt == 3'd0) begin
    full_reg <= 1'd0;
    empty_reg <= 1'd1;
 end
 else begin
    full_reg <= 1'd0;
    empty_reg <= 1'd0;
 end
 
 assign dataOut = dataOut_reg;
 assign full    = full_reg;
 assign empty   = empty_reg;
   
endmodule

2.1.2 Sync_FIFO_cnt_tb

`timescale 1ns/1ns	//时间单位/精度
 
//------------<模块及端口声明>----------------------------------------
module Sync_FIFO_cnt_tb();
 
//parameter   DATA_WIDTH = 8  ;			//FIFO位宽
//parameter   DATA_DEPTH = 8 ;			//FIFO深度
//parameter fifo_depth = 8;
//parameter fifo_depth_bit = 3;
//parameter data_width = 8;
 
reg									clk		;
reg									rst_n	;
reg                                 rst;
reg		[DATA_WIDTH-1:0]			data_in	;
reg									rd_en	;
reg									wr_en	;
						
wire	[DATA_WIDTH-1:0]			data_out;	
wire								empty	;	
wire								full	;
wire	[$clog2(DATA_DEPTH) : 0]	fifo_cnt;
 
 
//------------<例化被测试模块>----------------------------------------
Sync_FIFO_cnt
//#(
//     .fifo_depth(fifo_depth),
//     .fifo_depth_bit(fifo_depth_bit),
//     .data_width(data_width)
//)
Sync_FIFO_cnt_u(
	.clk		(clk		),
	.reset		(~rst_n		),
	.dataIn	(data_in	),
	.rd_en		(rd_en		),
	.wr_en		(wr_en		),
                 
	.dataOut	(data_out	),	
	.empty		(empty		),	
	.full		(full		)		
);
 
//------------<设置初始测试条件>----------------------------------------
initial begin
	clk = 1'b0;							//初始时钟为0
	rst_n <= 1'b0;						//初始复位
	data_in <= 'd0;		
	wr_en <= 1'b0;		
	rd_en <= 1'b0;
//重复8次写操作，让FIFO写满 	
	repeat(8) begin		
		@(negedge clk)begin		
			rst_n <= 1'b1;				
			wr_en <= 1'b1;		
			data_in <= $random;			//生成8位随机数
		end
	end
//重复8次读操作，让FIFO读空	
	repeat(8) begin
		@(negedge clk)begin		
			wr_en <= 1'b0;
			rd_en <= 1'd1;
		end
	end
//重复4次写操作，写入4个随机数据	
	repeat(4) begin
		@(negedge clk)begin		
			wr_en <= 1'b1;
			data_in <= $random;	//生成8位随机数
			rd_en <= 1'b0;
		end
	end
//持续同时对FIFO读写，写入数据为随机数据	
	forever begin
		@(negedge clk)begin		
			wr_en <= 1'b1;
			data_in <= $random;	//生成8位随机数
			rd_en <= 1'b1;
		end
	end
end
//------------<设置时钟>----------------------------------------------
always #10 clk = ~clk;			//系统时钟周期20ns
//rst = ~ rst_n;
endmodule

测试结果：
在这里插入图片描述

2.2 高位扩展法

  • 当最高位不同，且其他位相同，则表示读指针或者写指针多跑了一圈，而显然不会让读指针多跑一圈，所以可能出现的情况只能是写指针多跑了一圈，就意味着FIFO被写满了。
  • 当最高位相同，且其他位相同，则表示读指针追到了写指针或者写指针追到了读指针，而显然不会让写指针追读指针（这种情况只能是写指针超过读指针一圈），所以可能出现的情况只能是读指针追到了写指针，也就意味着FIFO被读空了。
  • 此处要考虑FIFO深度不是2^N的情况，因此需要把高低位的判断分开。

2.2.1 位扩展实现同步FIFO–Verilog代码

module Sync_FIFO_addBit
#(
parameter fifo_depth = 8,
parameter fifo_depth_bit = 3,
parameter data_width = 8
)
(
    input wr_en,rd_en,clk,reset,
    input [data_width-1:0] dataIn,
    output [data_width-1:0] dataOut,
    output full,empty
    );

reg [data_width-1:0] RAM [fifo_depth-1:0];
reg  [fifo_depth_bit:0] addr_wr;
reg  [fifo_depth_bit:0] addr_rd;
reg [data_width-1:0] dataOut_reg; 
reg full_reg,empty_reg;

// generate addr_wr 
always @(posedge clk or posedge reset) 
if (reset) begin
    addr_wr <= 'd0;
    RAM[addr_wr] <= 'd0;
end
else if (addr_wr[fifo_depth_bit-1:0] < (fifo_depth - 1) && wr_en==1'd1 && full_reg == 1'd0) begin
    addr_wr <= addr_wr + 1'd1;
    RAM[addr_wr] <= dataIn;
end
else if (addr_wr[fifo_depth_bit-1:0] == (fifo_depth - 1) && wr_en==1'd1 && full_reg == 1'd0) begin
    addr_wr[fifo_depth_bit] <= ~addr_wr[fifo_depth_bit];
    addr_wr[fifo_depth_bit-1:0] <= 'd0;
    RAM[addr_wr[fifo_depth_bit-1:0]] <= dataIn;   
end
else begin    
    addr_wr <= addr_wr;
    RAM[addr_wr] <= RAM[addr_wr];
end    

// generate addr_rd 
always @(posedge clk or posedge reset) 
if (reset) begin
    addr_rd <= 'd0;
    dataOut_reg <= 'd0; 
end
else if (addr_rd[fifo_depth_bit-1:0] < (fifo_depth - 1) && rd_en==1'd1 && empty_reg == 1'd0) begin
    addr_rd <= addr_rd + 1'd1;
    dataOut_reg <= RAM[addr_rd[fifo_depth_bit-1:0]];
end
else if (addr_rd[fifo_depth_bit-1:0] == (fifo_depth - 1) && rd_en==1'd1 && empty_reg == 1'd0) begin
    addr_rd[fifo_depth_bit] <= ~addr_rd[fifo_depth_bit];
    addr_rd[fifo_depth_bit-1:0] <= 'd0;
    dataOut_reg <= RAM[addr_rd[fifo_depth_bit-1:0]];
end
else begin
    addr_rd <= addr_rd;
    dataOut_reg <= dataOut_reg;
end    
// judge full and empty
always @(*)
if (reset) begin
    empty_reg <= 1'd0;
    full_reg <= 1'd0;
end
else if (addr_wr[fifo_depth_bit-1:0] == addr_rd[fifo_depth_bit-1:0] && addr_wr[fifo_depth_bit] != addr_rd[fifo_depth_bit]) begin
    empty_reg <= 1'd0;
    full_reg <= 1'd1;
end
else if (addr_wr == addr_rd) begin
    empty_reg <= 1'd1;
    full_reg <= 1'd0;
end    
else begin
    empty_reg <= 1'd0;
    full_reg <= 1'd0;
end

assign dataOut = dataOut_reg;
assign full = full_reg;
assign empty = empty_reg;

endmodule

2.2.2 Sync_FIFO_addBit_tb

`timescale 1ns/1ns	//时间单位/精度
 
//------------<模块及端口声明>----------------------------------------
module Sync_FIFO_cnt_tb();
 
parameter   DATA_WIDTH = 8  ;			//FIFO位宽
parameter   DATA_DEPTH = 8 ;			//FIFO深度
parameter fifo_depth = 8;
parameter fifo_depth_bit = 3;
parameter data_width = 8;
 
reg									clk		;
reg									rst_n	;
reg                                 rst;
reg		[DATA_WIDTH-1:0]			data_in	;
reg									rd_en	;
reg									wr_en	;
						
wire	[DATA_WIDTH-1:0]			data_out;	
wire								empty	;	
wire								full	;
wire	[$clog2(DATA_DEPTH) : 0]	fifo_cnt;
 
 
//------------<例化被测试模块>----------------------------------------
Sync_FIFO_addBit
#(
     .fifo_depth(fifo_depth),
     .fifo_depth_bit(fifo_depth_bit),
     .data_width(data_width)
)
Sync_FIFO_addBit_u(
	.clk		(clk		),
	.reset		(~rst_n		),
	.dataIn	(data_in	),
	.rd_en		(rd_en		),
	.wr_en		(wr_en		),
                 
	.dataOut	(data_out	),	
	.empty		(empty		),	
	.full		(full		)		
);
 
//------------<设置初始测试条件>----------------------------------------
initial begin
	clk = 1'b0;							//初始时钟为0
	rst_n <= 1'b0;						//初始复位
	data_in <= 'd0;		
	wr_en <= 1'b0;		
	rd_en <= 1'b0;
//重复8次写操作，让FIFO写满 	
	repeat(8) begin		
		@(negedge clk)begin		
			rst_n <= 1'b1;				
			wr_en <= 1'b1;		
			data_in <= $random;			//生成8位随机数
		end
	end
//重复8次读操作，让FIFO读空	
	repeat(8) begin
		@(negedge clk)begin		
			wr_en <= 1'b0;
			rd_en <= 1'd1;
		end
	end
//重复4次写操作，写入4个随机数据	
	repeat(4) begin
		@(negedge clk)begin		
			wr_en <= 1'b1;
			data_in <= $random;	//生成8位随机数
			rd_en <= 1'b0;
		end
	end
//持续同时对FIFO读写，写入数据为随机数据	
	forever begin
		@(negedge clk)begin		
			wr_en <= 1'b1;
			data_in <= $random;	//生成8位随机数
			rd_en <= 1'b1;
		end
	end
end
//------------<设置时钟>----------------------------------------------
always #10 clk = ~clk;			//系统时钟周期20ns
//rst = ~ rst_n;
endmodule

仿真结果：
在这里插入图片描述

  • 实现了同步FIFO，下一篇学习异步FIFO。

参考文章：
同步FIFO的两种Verilog设计方法（计数器法、高位扩展法）

Verilog实现同步FIFO
uote_e的博客
06-25 980
该同步FIFO实现中包含一个输入时钟信号，一个复位信号，以及两个使能信号（写和读）。在读取数据时，我们需要将FIFO中的数据暂存在寄存器q中，以便输出到FIFO的数据总线中。需要注意的是，在读取数据之后，读指针read_ptr也需要自增，以便下一次读取数据。同步FIFO具有时钟控制信号，通过时钟控制信号使FIFO中的读写操作发生在同一时钟周期中。相对于异步FIFO，同步FIFO无需考虑读写指针的异步问题，因此实现起来更加简单。同步FIFO电路相对简单，易于实现，且具有良好的同步性能，适用于不同的应用场景。
同步FIFO的Verilog实现
qq_40230112的博客
03-23 4680
引言 在前面的文章中，我们已经对FIFO的基本设计思路做了简单的介绍，并且对异步FIFO进行了简单的Verilog实现，具体介绍见链接：同步FIFO与异步FIFO的基本原理，异步FIFO的Verilog实现，下面我们基于如前所述的FIFO基本原理，利用Verilog代码对同步FIFO进行了一个简单的代码实现，并进行了简单的仿真测试。1、实现过程 同步FIFO的设计过程中主要有如下几个注意事项： FIFO深度的计算 FIFO满空标志的产生 解决好如上所述的几个问题后...
vivado手撕Verilog同步FIFO代码（调用ip核版本）
最新发布
weixin_49391089的博客
07-15 1424
本文介绍了同步FIFO的设计与实现方法。首先阐述了FIFO的基本概念，包括其空满判断机制、深度和宽度定义，以及与RAM的区别。然后详细讲解了在Vivado中配置FIFO IP核的步骤，包括接口模式选择、读写参数设置等关键选项。接着给出了FIFO读写子模块的Verilog实现代码，其中重点说明了状态机设计以及空满信号检测机制。最后提供了顶层模块的例化方法和测试平台搭建过程。整个设计采用状态机实现FIFO读写控制，通过检测空满信号的边沿来确保数据可靠传输，并在读写操作间加入适当延迟以避免冲突。仿真结果验证了设计
FIFO的Verilog设计（一）——同步FIFO
weixin_51116586的博客
12-06 2938
FIFO在系统设计中被广泛应用，但是大多时候使用X家和A家封装的IP核，为了更好的理解FIFO工作原理并且为了方便在不同厂商工作环境之间移植，自己编写一个FIFO IP也是不错的选择。下面将介绍同步FIFO的工作原理和Verilog实现。
同步FIFO（Verilog）
qq_53433410的博客
10-24 1304
同步FIFO（Verilog）
同步FIFO的两种Verilog设计方法（计数器法、高位扩展法）
热门推荐
孤独的单刀
11-04 5万+
如何设计同步FIFO？
Verilog实现同步FIFO(附Verilog代码)
qq_40919669的博客
05-05 1万+
概述 本文为verilog实现同步FIFO的一种方法。fifo作为一种先入先出队列，其本质就是一块存储区域，而先入先出的特性让其读写十分方便，不需要控制地址。而我们在设计的过程中，就是要把读写信号与内存中的地址联系起来。 实现难点 本文利用预先定义二维数组寄存器作为fifo的存储空间。 直白一点讲，一块存储空间存满了就写不进去了，读空了就读不出来了。 verilog实现同步fifo的难点就在于空满标志状态的设计。 读写指针的工作原理 　　读指针：总是指向下一个将要被写入的单元，复位时，...
Verilog下同步FIFO快速实现
04-29
同步FIFO（First In First Out）是数字系统设计中常用的一种数据存储结构，尤其是在嵌入式系统和并行处理系统中。同步FIFO的设计和实现是Verilog硬件描述语言中的重要课题，它涉及到数据流控制、内存访问以及时序...
FIFO_RAM.rar_fifo 同步fifo_fifo同步_ram_verilog testbench_同步fifo设计
09-19
同步FIFO是FIFO的一种实现方式，它在时钟域之间传递数据，确保数据的正确传输。本篇将深入探讨同步FIFO的设计、RAM的使用以及Verilog中的testbench验证。 同步FIFO的核心在于解决时钟域之间的数据传输问题。当数据...
同步FIFO和异步FIFO的Verilog实现
10-18
同步FIFO和异步FIFO是两种常见的FIFO（First In First Out，先进先出）设计类型，它们在数字系统中广泛应用于数据缓存和不同速率、时钟域之间的数据传输。FIFO的设计核心在于如何判断其空/满状态，以确保数据的正确...
同步FIFO与异步FIFO的Verilog实现(附源代码和测试代码).doc
09-04
同步FIFO和异步FIFO是两种常见的FIFO（First In First Out）数据缓冲区的实现方式，它们在Verilog编程中广泛应用于数字系统设计。FIFO作为一种特殊的存储结构，其核心特性是遵循先进先出的原则，即最早存入的数据...
直接可用的同步FIFO的verilog代码，自己总结的非常详细的相应文档
04-02
直接可用的同步FIFO的verilog代码，自己总结的非常详细的相应文档
【Verilog】手撕同步FIFO
S_Wiper的博客
10-09 2175
FIFO是一种先进先出的数据缓存器，一般用在隔离两边读写带宽不一致，或者位宽不一样的地方。在FPGA设计中，使用FIFO一般有两个方法，第一个方法是直接调用官方的FIFO IP，第二个方法是自己设计FIFO控制逻辑。FIFO包括同步FIFO和异步FIFO两种，同步FIFO有一个时钟信号，读和写逻辑全部使用这一个时钟信号；异步FIFO有两个时钟信号，读和写逻辑使用各自的时钟。
Verilog功能模块——同步FIFO
徐大康的博客
10-12 1312
实现了纯Verilog的同步FIFO，包含FWFT功能与almost信号功能
同步FIFO的verilog设计
u014070258的专栏
05-10 2502
FIFO (First-In-First-Out) 是一种先进先出的数据交互方式，在数字ASIC设计中常常被使用。FIFO按工作时钟域的不同又可以分为：同步FIFO和异步FIFO。 同步FIFO的写时钟和读时钟为同一个时钟，FIFO内部所有逻辑都是同步逻辑，常常用于交互数据缓冲。异步FIFO的写时钟和读时钟为异步时钟，FIFO内部的写逻辑和读逻辑的交互需要异步处理，异步FIFO常用于跨时钟...
Verilog：同步FIFO、异步FIFO
2303_76814451的博客
10-20 5983
简单介绍FIFO的原理，并用Verilog实现同步/异步FIFO设计和仿真
Verilog实现同步FIFO的快速方法
在Verilog下实现同步FIFO的快速实现，需要掌握Verilog硬件描述语言的语法、结构以及时序控制等基础知识。 同步FIFO相比于异步FIFO，设计更为简单，因为它没有复杂的时钟域问题。在同步FIFO中，数据在同一个时钟沿被...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值