Verilog功能模块——异步FIFO_异步fifo verilog

FIFO系列文章目录：

Verilog功能模块——异步FIFO-CSDN博客

Verilog功能模块——同步FIFO-CSDN博客

Verilog功能模块——读写位宽不同的异步FIFO-CSDN博客

Verilog功能模块——读写位宽不同的同步FIFO-CSDN博客

Verilog功能模块——标准FIFO转FWFT FIFO-CSDN博客

---

---

前言

FIFO的功能

FIFO在FPGA中应用很多，它主要有以下功能：

1. 数据缓存，很多时候数据发送速度和数据接收速度并不实时匹配，而在其中插入一个FIFO，来临时存储数据，就能平衡发送和接收速度
2. 组合与分解数据，FIFO的写入数据位宽和读出数据位宽可以不一致，例如可以16bit写入，8bit读出或者反过来，这就为组合与分解数据提供了方便
3. 跨时钟域传输数据，这是异步FIFO才有的功能，异步FIFO的读写时钟可以完全独立，所以可以借助异步FIFO来实现跨时钟域传输数据
4. 标准化接口，因为FIFO的写入与读出接口的控制时序非常简单，所以在模块需要外部数据时可以定义一个FIFO接口，这样数据接口的时序就不言自明了

为什么需要自编FIFO

我很喜欢在自编模块中使用FIFO接口，这样在使用此模块时就不必担心数据输入的时序问题，直接从FIFO中读数据即可。但这也带来了一些问题，如：

1. 实例化模块时还需要额外实例化FIFO IP核，总是不那么方便，降低了自编模块的通用性，这是最大的问题
2. 通常我只是需要FIFO这种接口，对于存储深度基本没要求，16的深度已经足够，但一些国产FPGA开发软件中的FIFO IP核最小深度就是512，这无疑造成了存储空间的浪费
3. 我总是使用FWFT类型的FIFO，所以在实例化FIFO IP核时还必须选择FWFT类型，这容易出错，也造成了自编模块使用的不方便；而且一些国产开发软件还不提供FWFT类型的FIFO，这使得还得额外加一个标准FIFO转FWFT FIFO的模块，这就更不方便了

综上，我觉得有必要使用纯Verilog来实现FWFT FIFO，这样就不需要额外的FIFO IP核了，模块通用性大大提升。

---

一. 异步FIFO实现原理

异步FIFO的实现原理有很多文章已经讲过了，这里就不详细讲了，只是简单总结一下，感兴趣的同学可以参考以下文章。

FIFO设计-异步FIFO篇 - 知乎 (zhihu.com)

IC基础(一)：异步FIFO原理与代码实现 - 你好24h - 博客园 (cnblogs.com)

ICer必备-异步FIFO设计原理 & RTL模型 - 知乎 (zhihu.com)

1.1 实现原理框图

异步FIFO的实现框图就是上面这张，可以看到分为了五个部分：

1. FIFO Memory，也就是一个双口RAM，或者是寄存器组
2. FIFO wptr & full，FIFO写指针与满信号
3. FIFO rptr & empty，FIFO读指针与空信号
4. sync_r2w，读指针同步到写时钟域
5. sync_w2r，写指针同步到读时钟域

FIFO空的判断依据：读指针 == 写指针，这意味着写入的数据全部读出，则FIFO为空。

FIFO满的判断依据：写指针 - 读指针 == FIFO深度，

注意：

1. 读写指针都是循环计数的，即从0计数到FIFO深度-1，然后再回到0
2. 写指针永远领先于读指针，因为FIFO必须是先写后读，所以当读指针最高位为1，而写指针最高位为0时，只是说明写指针最高位从1再次计数到了0
3. 设计时会让读写指针的位宽 = FIFO深度对应的位宽 + 1，低位用于确定读写RAM的地址，最高位用于判断写指针是否已经领先读指针一圈了，此时只需要判断写指针最高位不等于读指针，而其余地位相等即可得出写指针 - 读指针 == FIFO深度即FIFO满的结论。

异步FIFO中，读写指针的时间域不同，但空满信号的判断需要比较读写指针的值，这样就需要时间域的切换：

1. 读指针同步到写时钟域，用于判断FIFO满
2. 写指针同步到读时钟域，用于判断FIFO空

设计中采用的时间域同步方法是，将读写指针由二进制编码转换为格雷码，再经过两级D触发器，即可同步到对应时间域。

1.2 为什么需要转换为格雷码？

我们考虑一种情况，写指针 = 5’b01111，同步到了读时钟域，这时又写入了一个数据，写指针 = 5‘b10000，我们看到指针的每一位都发生了变化，这时经过两级D触发器，在读时钟域能正确的得到5‘b10000吗? 答案是：很难。因为读写时钟是独立的，写指针在写时钟上升沿变化，对于读时钟来说，这个变化的时刻是随机的，而D触发器要能正确的输出数据，需要输入满足建立时间和保持时间的要求，否则在读时钟域得到的数据就可能是不定态X，这个就是亚稳态。

亚稳态因为D触发器的输入不满足建立时间和保持时间要求而发生，但读写时钟的独立使得我们无法从设计上满足时序要求，所以亚稳态是无法从理论上避免的。而上述的二进制编码的极端情况，需要所有bit位变化，每一位都有发生亚稳态的可能，而只要有一位发生亚稳态，组合得到的多bit数据就是错误的，所以，这种多bit信号的跨时钟域有很大的亚稳态风险。

何为格雷码？

格雷码，Gray code，又称循环码或反射码，在格雷码中，相邻的两个数仅有一位二进制位不同，使得在数字之间的转换只需要进行一次位运算，避免了普通二进制码转换时可能需要多次位运算的情况。

以下表格展示了3bit二进制数据的正常编码与格雷码：

亚稳态只在数据变化时发生，不变化也就不存在亚稳态，而相邻的格雷码只会有一位不同，所以使用格雷码就将多bit信号的跨时钟域转换成了单bit信号的跨时钟域，极大的降低了亚稳态发生的概率。理论上，两级D触发器，发生亚稳态的概率就非常低了，能满足实际使用需求。

上面说到，判断写满的逻辑为二进制码写指针最高位不等于二进制码读指针，其余位相等，如写指针000，读指针100 或者写指针001，读指针101；可以发现转换为格雷码后，此逻辑变为：格雷码写指针最高位和次高位不等于格雷码读指针，其余位相等。

1.3 格雷码与二进制码如何互转？

二进制码转格雷码很简单，格雷码 = （二进制码 >> 1）^ 二进制码，即右移一位再异或：

//bin to gray
assign gray = (bin >> 1) ^ bin;
1
2

格雷码转二进制码稍显复杂：

// Verilog写法 gray to bin
reg [WIDTH-1 : 0] bin;
always @(*) begin : gray2bin
  integer i;
  for (i = 0; i <= WIDTH-1; i = i+1) begin
    bin[i] = ^(gray >> i);
  end
end

// SystemVerilog写法 gray to bin
logic [WIDTH-1 : 0] bin;
always_comb begin
  for (int i = 0; i <= WIDTH-1; i = i+1) begin
    bin[i] = ^(gray >> i);
  end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二. 模块功能框图与信号说明

信号说明：

注意：

1. 信号的命名与Vivado中的FIFO IP核完全一致
2. 复位均为高电平复位，与Vivado中的FIFO IP核保持一致
3. 复位为异步复位，写复位和读复位可以共用一个信号，也可以分开
4. FIFO深度通过ADDR_WIDTH来设置，所以FIFO的深度必然是2的指数，如2、4、8、16等

三. 部分代码展示

//++ 生成读写指针 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
reg  [ADDR_WIDTH:0] rptr_bin;
always @(posedge rd_clk or posedge rd_rst) begin
  if (rd_rst)
    rptr_bin <= 0;
  else if (rd_en & ~empty)
    rptr_bin <= rptr_bin + 1'b1;
end


reg  [ADDR_WIDTH:0] wptr_bin;
always @(posedge wr_clk or posedge wr_rst) begin
  if (wr_rst)
    wptr_bin <= 0;
  else if (wr_en & ~full)
    wptr_bin <= wptr_bin + 1'b1;
end


wire [ADDR_WIDTH-1:0] raddr = rptr_bin[ADDR_WIDTH-1:0];
wire [ADDR_WIDTH-1:0] waddr = wptr_bin[ADDR_WIDTH-1:0];
//-- 生成读写指针 ------------------------------------------------------------


//++ 二进制编码转换为格雷码 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
wire [ADDR_WIDTH:0] rptr_gray = (rptr_bin >> 1) ^ rptr_bin;
wire [ADDR_WIDTH:0] rptr_gray_p1 = ((rptr_bin + 1'b1) >> 1) ^ (rptr_bin + 1'b1);


wire [ADDR_WIDTH:0] wptr_gray = (wptr_bin >> 1) ^ wptr_bin;
wire [ADDR_WIDTH:0] wptr_gray_p1 = ((wptr_bin + 1'b1) >> 1) ^ (wptr_bin + 1'b1);
//-- 二进制编码转换为格雷码 ------------------------------------------------------------


//++ 格雷码的读写指针同步 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
reg [ADDR_WIDTH:0] rptr_gray_wr_clk_r1;
reg [ADDR_WIDTH:0] rptr_gray_wr_clk_r2;
always @(posedge wr_clk or posedge wr_rst) begin
  if (wr_rst) begin
    rptr_gray_wr_clk_r1 <= 0;
    rptr_gray_wr_clk_r2 <= 0;
  end
  else begin
    rptr_gray_wr_clk_r1 <= rptr_gray;
    rptr_gray_wr_clk_r2 <= rptr_gray_wr_clk_r1;
  end
end


reg [ADDR_WIDTH:0] wptr_gray_rd_clk_r1;
reg [ADDR_WIDTH:0] wptr_gray_rd_clk_r2;
always @(posedge rd_clk or posedge rd_rst) begin
  if (rd_rst) begin
    wptr_gray_rd_clk_r1 <= 0;
    wptr_gray_rd_clk_r2 <= 0;
  end
  else begin
    wptr_gray_rd_clk_r1 <= wptr_gray;
    wptr_gray_rd_clk_r2 <= wptr_gray_rd_clk_r1;
  end
end
//-- 格雷码的读写指针同步 ------------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

3.1 参考与更改

代码参考了Github上的分享，源链接：dpretet/async_fifo: A dual clock asynchronous FIFO written in verilog, tested with Icarus Verilog (github.com)

基本结构是完全一样的，主要做了以下更改：

1. 更改了部分信号名，使其更符合FIFO的通常命名，并保持与Vivado FIFO IP核名称一致，例如将winc改为wr_en，wdata改为din

2. 删除了一些不必要的中间信号，使代码逻辑更加简洁

3. 将原本5个v文件写成了一个v文件，方便在工程中调用

4. 更改了FIFO为空时，dout的行为，使其行为与Vivado FIFO IP核一致。之前FIFO为空，dout指向下一存储空间的值（无意义的值），改为FIFO为空时，dout保持最后一个有效数据值

3.2 “假满”与“假空”

“假满”问题：因为满信号是将读指针同步到写时钟域再与写指针比较产生的，同步会有两个写时钟的延迟，这意味着满信号在产生时，读指针是两个写时钟以前的值，如果同步的过程中又进行了读操作，则在满信号置高时，又读出了若干个值，所以此时FIFO并非真正的满，称为“假满”。假满时不响应外部写入，经过两个写时钟后，新的读指针同步到了写时钟域，full信号会拉低，脱离假满状态，此时如果不读出而是继续写入数据，则full信号会置高，这时的满就是“真满”。

所以“假满”并没有降低FIFO的深度，因为两个写时钟后会拉低full，脱离假满状态，此时可以继续写入，它只是让满信号不那么实时，但以这个full信号作为满信号不会产生任何功能问题。

同理，“假空”是因为空信号是将写指针同步到读时钟域再与读指针比较产生的，同步会有两个读时钟的延迟，如果再这两个读时钟内有若干次写入，则此时产生的empty信号并非真正的空，称为“假空”。再两个读时钟后empty会自动拉低，脱离假空状态。同样假空只是让空信号不那么实时，不会产生任何功能问题。

综上，实际使用时，“假满”和"假空"对FIFO功能没有影响。

3.3 之后的功能改进

本FIFO模块未实现位宽变换的功能，即写入数据位宽始终等于读出数据位宽，后续可在此模块基础上改进。

---

三. 功能仿真

可在两种条件下测试，写时钟频率 > 读时钟频率；写时钟频率 < 读时钟频率

两种条件下分别比较以下情形中的自编FIFO行为是否与FIFO IP核一致，

情形一：单次写单次读

情形二：写满后再读空

情形三：在读的过程中写，在写的过程中读

判断模块功能正常的依据：

1. 写入数据是否按顺序正常读出
2. 空信号和满信号是否正常输出。

为方便比较，编写了顶层文件，实例化了FIFO IP核与自编模块，部分代码如下：

vivado_async_fifo vivado_async_fifo_u0 (
  .wr_clk       (wr_clk                 ), // input wire wr_clk
  .wr_rst       (wr_rst                 ), // input wire wr_rst
  .rd_clk       (rd_clk                 ), // input wire rd_clk
  .rd_rst       (rd_rst                 ), // input wire rd_rst
  .din          (din                    ), // input wire [7 : 0] din
  .wr_en        (wr_en                  ), // input wire wr_en
  .rd_en        (rd_en                  ), // input wire rd_en
  .dout         (vivado_fifo_dout       ), // output wire [7: 0] dout
  .full         (vivado_fifo_full       ), // output wire full
  .almost_full  (vivado_fifo_almost_full), // output wire almost_full
  .empty        (vivado_fifo_empty      ), // output wire empty
  .almost_empty (vivado_fifo_almost_empty)  // output wire almost_empty
);


asyncFIFO #(
  .DATA_WIDTH(DATA_WIDTH),
  .ADDR_WIDTH(ADDR_WIDTH),
  .FWFT_EN(FWFT_EN)
) asyncFIFO_inst (
  .din          (din         ),
  .wr_en        (wr_en       ),
  .full         (full        ),
  .almost_full  (almost_full ),
  .wr_clk       (wr_clk      ),
  .wr_rst       (wr_rst      ),
  .dout         (dout        ),
  .rd_en        (rd_en       ),
  .empty        (empty       ),
  .almost_empty (almost_empty),
  .rd_clk       (rd_clk      ),
  .rd_rst       (rd_rst      )
);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

testbench部分代码如下：

// 生成时钟
localparam WCLKT = 2;
initial begin
  wr_clk = 0;
  forever #(WCLKT / 2) wr_clk = ~wr_clk;
end

localparam RCLKT = 6;
initial begin
  rd_clk = 0;
  forever #(RCLKT / 2) rd_clk = ~rd_clk;
end


// 复位块
initial begin
  wr_rst = 1;
  #(WCLKT * 2)
  wr_rst = 0;
end


// 读写使能控制
initial begin
  wr_en = 0;
  rd_en = 0;
  #(WCLKT * 2)
  wait(~full && ~vivado_fifo_full); // 两个FIFO都从复位态恢复时开始写

  // 写入一个数据
  wr_en = 1;
  #(WCLKT * 1)
  wr_en = 0;

  // 读出一个数据
  wait(~empty && ~vivado_fifo_empty);// 两个FIFO都非空时开始读，比较读数据和empty信号是否有差异
  rd_en = 1;
  #(RCLKT * 2)
  rd_en = 0;

  // 写满
  wr_en = 1;
  wait(full && vivado_fifo_full); // 两个FIFO都满时停止写，如果两者不同时满，则先满的一方会有写满的情况发生，但对功能无影响
  // vivado FIFO IP在FWFT模式时, 设定深度16时实际深度为17, 但仿真显示full会在写入15个数据后置高, 过几个时钟后后拉低,
  // 再写入一个数据, full又置高; 然后过几个时钟又拉低, 再写入一个数据置高, 如此才能写入17个数据
  // 所以这里多等待12个wclk周期, 就是为了能真正写满vivado FWFT FIFO
  #(WCLKT * 12)
  wr_en = 0;

  // 读空
  wait(~empty && ~vivado_fifo_empty);
  rd_en = 1;
  wait(empty && vivado_fifo_empty); // 两个FIFO都空时停止读，如果两者不同时空，则先空的一方会有读空的情况发生，但对功能无影响
  rd_en = 0;

  #(RCLKT * 10)
  $stop;
end


// 使用以下代码时，先注释掉上面的读写使能控制initial
// 同时读写
// assign wr_en = ~full || ~vivado_fifo_full; // 未满就一直写
// assign rd_en = ~empty || ~vivado_fifo_empty; // 未空就一直读

always @(posedge wr_clk) begin
  if (wr_rst)
    din <= 0;
  else if (wr_en && ~full && ~vivado_fifo_full)
    din <= din + 1;
end

assign rd_rst = wr_rst;

endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

8bit，16深度，FWFT FIFO仿真，波形如下：

可以看到模块输出的自编fifo与vivado fwft fifo的写端口和读端口行为是一致的，只是可能会超前或滞后一定的clk周期。

可以看到empty拉低时，数据已经有效了，所以自编模块实现了FWFT功能，Vivado FIFO的实际深度为17，所以它多读出了一个数据，空信号更晚拉高。

empty为高时，dout保持了最后一个有效数据值，此行为与Vivado FIFO IP核一致。

因篇幅问题，其它条件下的仿真不再展示，感兴趣的同学可通过更改testbench自行验证。

1. 更改读写时钟的频率，上述仿真是写时钟频率大于读时钟频率
2. FWFT_EN改为0，注意同步修改Vivado FIFO的配置

---

四. 工程分享

Verilog功能模块——异步FIFO，Vivado 2021.2工程。

欢迎大家关注我的公众号：徐晓康的博客，回复以下四位数字获取。

8301

建议复制过去不会码错字！

或者在我的码云仓库获取，传送门：

徐晓康/Verilog功能模块 - 码云 - 开源中国 (gitee.com)

---

徐晓康的博客持续分享高质量硬件、FPGA与嵌入式知识，软件，工具等内容，欢迎大家关注。