Asynchronous FIFO and synchronous FIFO-翻译自外网

这篇具有很好参考价值的文章主要介绍了Asynchronous FIFO and synchronous FIFO-翻译自外网。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Synchronous FIFO

先进先出 (FIFO) 是一种非常流行且有用的设计块,用于模块之间的同步和握手机制。

FIFO 的深度: FIFO 中的槽数或行数称为 FIFO 的深度。

FIFO 的宽度:每个槽或行中可以存储的位数称为 FIFO 的宽度。

在同步 FIFO 中,数据读取和写入操作使用相同的时钟频率。通常,它们与高时钟频率一起使用以支持高速系统。

Asynchronous FIFO and synchronous FIFO-翻译自外网,FPGA,fpga开发

Signals:

wr_en: 写使能

wr_data: 写数据write data

full: FIFO is full 满

empty: FIFO is empty 空

rd_en: 读使能 read enable

rd_data: 读数据read data

w_ptr: 写指针write pointer

r_ptr: 读指针 read pointer

FIFO 可以根据 wr_en 信号在时钟的每个 posege 存储/写入 wr_data,直到满为止。每次将数据写入 FIFO 存储器时,写入指针都会递增。

根据rd_en信号,可以在时钟的每个周期从FIFO中取出或读取数据,直到为空为止。每次从 FIFO 存储器读取数据时,读指针都会递增。

method
empty condition

w_ptr == r_ptr 即写指针和读指针具有相同的值。

full condition

满的情况意味着 FIFO 中的每个槽都被占用,但是 w_ptr 和 r_ptr 将再次具有相同的值。因此,无法确定是满状态还是空状态。因此,故意将 FIFO 的最后一个槽保持为空,满条件可以写为 (w_ptr+1’b1) == r_ptr)

code
module synchronous_fifo #(parameter DEPTH=8, DATA_WIDTH=8) (
  input clk, rst_n,
  input w_en, r_en,
  input [DATA_WIDTH-1:0] data_in,
  output reg [DATA_WIDTH-1:0] data_out,
  output full, empty
);
  
  reg [$clog2(DEPTH)-1:0] w_ptr, r_ptr;
  reg [DATA_WIDTH-1:0] fifo[DEPTH];
  
  // Set Default values on reset.
  always@(posedge clk) begin
    if(!rst_n) begin
      w_ptr <= 0; r_ptr <= 0;
      data_out <= 0;
    end
  end
  
  // To write data to FIFO
  always@(posedge clk) begin
    if(w_en & !full)begin
      fifo[w_ptr] <= data_in;
      w_ptr <= w_ptr + 1;
    end
  end
  
  // To read data from FIFO
  always@(posedge clk) begin
    if(r_en & !empty) begin
      data_out <= fifo[r_ptr];
      r_ptr <= r_ptr + 1;
    end
  end
  
  assign full = ((w_ptr+1'b1) == r_ptr);
  assign empty = (w_ptr == r_ptr);
endmodule
testbench
module sync_fifo_TB;
  parameter DATA_WIDTH = 8;
  
  reg clk, rst_n;
  reg w_en, r_en;
  reg [DATA_WIDTH-1:0] data_in;
  wire [DATA_WIDTH-1:0] data_out;
  wire full, empty;
  
  // Queue to push data_in
  reg [DATA_WIDTH-1:0] wdata_q[$], wdata;

  synchronous_fifo s_fifo(clk, rst_n, w_en, r_en, data_in, data_out, full, empty);

  always #5ns clk = ~clk;
  
  initial begin
    clk = 1'b0; rst_n = 1'b0;
    w_en = 1'b0;
    data_in = 0;
    
    repeat(10) @(posedge clk);
    rst_n = 1'b1;

    repeat(2) begin
      for (int i=0; i<30; i++) begin
        @(posedge clk);
        w_en = (i%2 == 0)? 1'b1 : 1'b0;
        if (w_en & !full) begin
          data_in = $urandom;
          wdata_q.push_back(data_in);
        end
      end
      #50;
    end
  end

  initial begin
    clk = 1'b0; rst_n = 1'b0;
    r_en = 1'b0;

    repeat(20) @(posedge clk);
    rst_n = 1'b1;

    repeat(2) begin
      for (int i=0; i<30; i++) begin
        @(posedge clk);
        r_en = (i%2 == 0)? 1'b1 : 1'b0;
        if (r_en & !empty) begin
          #1;
          wdata = wdata_q.pop_front();
          if(data_out !== wdata) $error("Time = %0t: Comparison Failed: expected wr_data = %h, rd_data = %h", $time, wdata, data_out);
          else $display("Time = %0t: Comparison Passed: wr_data = %h and rd_data = %h",$time, wdata, data_out);
        end
      end
      #50;
    end

    $finish;
  end
  
  initial begin 
    $dumpfile("dump.vcd"); $dumpvars;
  end
endmodule

method2
Empty condition

count == 0 i.e. FIFO contains nothing.

Full condition

count == FIFO_DEPTH i.e. counter value has reached till the depth of FIFO

method3
Empty condition

w_ptr == r_ptr i.e. write and read pointers has the same value. MSB of w_ptr and r_ptr also has the same value.

Full condition

w_ptr == r_ptr i.e. write and read pointers has the same value, but the MSB of w_ptr and r_ptr differs.

Asynchronous FIFO

在异步 FIFO 中,数据读取和写入操作使用不同的时钟频率。由于写入和读取时钟不同步,因此称为异步 FIFO。通常,这些用于数据需要从一个时钟域传递到另一个时钟域的系统,这通常被称为“时钟域交叉”。因此,异步 FIFO 有助于同步工作在不同时钟上的两个系统之间的数据流。

Asynchronous FIFO and synchronous FIFO-翻译自外网,FPGA,fpga开发

Gray code

Asynchronous FIFO and synchronous FIFO-翻译自外网,FPGA,fpga开发

Asynchronous FIFO Block Diagram

Asynchronous FIFO and synchronous FIFO-翻译自外网,FPGA,fpga开发

Signals:

wr_en: 写使能write enable

wr_data: 写数据write data

full: FIFO is full满

empty: FIFO is empty 空

rd_en: read enable 读使能

rd_data: read data 读数据

b_wptr: binary write pointer 二进制写指针

g_wptr: gray write pointer 格雷码写指针

b_wptr_next: binary write pointer next 指示用于二进制写入新数据的下一个可用地址。

g_wptr_next: gray write pointer next 指示用于格雷码写入新数据的下一个可用地址。

b_rptr: binary read pointer 二进制读指针

g_rptr: gray read pointer 格雷码读指针

b_rptr_next: binary read pointer next 指示用于二进制读新数据的下一个可用地址。

g_rptr_next: gray read pointer next 指示用于格雷码读入新数据的下一个可用地址。

b_rptr_sync: binary read pointer synchronized

b_wptr_sync: binary write pointer synchronized

同步必要性:

  • 异步 FIFO:它们具有独立的读写时钟,通常以不同的频率运行。
  • 时钟域交叉 (CDC):这些域之间的数据传输带来了同步挑战。
  • 亚稳态:跨时钟域的信号可能进入亚稳态(不确定值),可能导致数据损坏。
Asynchronous FIFO Operation

在同步 FIFO 的情况下,写入和读取指针在同一时钟上生成。然而,在异步 FIFO 的情况下,写指针与写时钟域对齐,而读指针与读时钟域对齐。因此,需要跨域来计算 FIFO 满和空的情况。这会导致实际设计中的亚稳态。为了解决这种亚稳态问题,可以使用2个触发器或3个触发器同步器来传递写入和读取指针。为了便于解释,我们将使用 2 个触发器同步器。请注意,单个“2 FF 同步器”只能解决一位的亚稳态问题。因此,根据写入和读取指针,需要多个 2FF 同步器。

Asynchronous FIFO and synchronous FIFO-翻译自外网,FPGA,fpga开发

module synchronizer #(parameter WIDTH=3) (input clk, rst_n, [WIDTH:0] d_in, output reg [WIDTH:0] d_out);
  reg [WIDTH:0] q1;
  always@(posedge clk) begin
    if(!rst_n) begin
      q1 <= 0;
      d_out <= 0;
    end
    else begin
      q1 <= d_in;
      d_out <= q1;
    end
  end
endmodule
Usage of Binary to Gray code converter and vice-versa in Asynchronous FIFO

到目前为止,我们讨论了如何在各个时钟域中获取异步写入和读取指针。但是,我们不应该传递二进制格式的写入和读取指针值。由于亚稳态,整体写入或读取指针值可能不同。

示例:当写时钟域的二进制值 wr_ptr = 4’b1101 通过 2FF 同步器传输时,读时钟域的 wr_ptr 值可能会接收为 4’b1111 或任何其他不可接受的值。而格雷码则保证与之前的值相比只有一位变化。因此,写指针和读指针都需要首先转换为其相应域中的等效格雷码,然后将它们传递到相反的域。要检查另一个域中 FIFO 满和空的情况,我们有两种方法。

Way 1

将接收到的格雷码格式的指针转换为二进制格式,然后检查满和空的情况。

FIFO full condition
g2b_converter g2b_wr(g_rptr_sync, b_rptr_sync);
wrap_around = b_rptr_sync[PTR_WIDTH] ^ b_wptr[PTR_WIDTH];
wfull = wrap_around & (b_wptr[PTR_WIDTH-1:0] == b_rptr_sync[PTR_WIDTH-1:0]);
FIFO empty condition
g2b_converter g2b_rd(g_wptr_sync, b_wptr_sync);
rempty = (b_wptr_sync == b_rptr_next);
Way 2

借助接收到的格雷码写入和读取指针直接检查满和空状况。这是高效的,因为它不需要额外的硬件来将格雷码写入和读取指针转换为等效的二进制形式。

FIFO full condition
wfull = (g_wptr_next == {~g_rptr_sync[PTR_WIDTH:PTR_WIDTH-1], g_rptr_sync[PTR_WIDTH-2:0]});
FIFO empty condition
rempty = (g_wptr_sync == g_rptr_next);
Asynchronous FIFO Verilog Code

同步器 g_rptr_sync 的输出作为“写指针处理程序”模块的输入,用于生成 FIFO 满状态。如果二进制写指针 (b_wptr) 满足 (w_en & !full) 条件,则它会递增。该 b_wptr 值被馈送到 fifo_mem 模块以将数据写入 FIFO。

Write Pointer Handler
module wptr_handler #(parameter PTR_WIDTH=3) (
  input wclk, wrst_n, w_en,
  input [PTR_WIDTH:0] g_rptr_sync,
  output reg [PTR_WIDTH:0] b_wptr, g_wptr,
  output reg full
);

  reg [PTR_WIDTH:0] b_wptr_next;
  reg [PTR_WIDTH:0] g_wptr_next;
   
  reg wrap_around;
  wire wfull;
  
  assign b_wptr_next = b_wptr+(w_en & !full);
  assign g_wptr_next = (b_wptr_next >>1)^b_wptr_next;
  
  always@(posedge wclk or negedge wrst_n) begin
    if(!wrst_n) begin
      b_wptr <= 0; // set default value
      g_wptr <= 0;
    end
    else begin
      b_wptr <= b_wptr_next; // incr binary write pointer
      g_wptr <= g_wptr_next; // incr gray write pointer
    end
  end
  
  always@(posedge wclk or negedge wrst_n) begin
    if(!wrst_n) full <= 0;
    else        full <= wfull;
  end

  assign wfull = (g_wptr_next == {~g_rptr_sync[PTR_WIDTH:PTR_WIDTH-1], g_rptr_sync[PTR_WIDTH-2:0]});

endmodule
Read Pointer Handler

同步器 g_wptr_sync 的输出作为“读指针处理程序”模块的输入,以生成 FIFO 空条件。如果二进制读指针 (b_rptr) 满足 (r_en & !empty) 条件,则它会递增。该 b_rptr 值被馈送到 fifo_mem 模块以从 FIFO 读取数据。

module rptr_handler #(parameter PTR_WIDTH=3) (
  input rclk, rrst_n, r_en,
  input [PTR_WIDTH:0] g_wptr_sync,
  output reg [PTR_WIDTH:0] b_rptr, g_rptr,
  output reg empty
);

  reg [PTR_WIDTH:0] b_rptr_next;
  reg [PTR_WIDTH:0] g_rptr_next;

  assign b_rptr_next = b_rptr+(r_en & !empty);
  assign g_rptr_next = (b_rptr_next >>1)^b_rptr_next;
  assign rempty = (g_wptr_sync == g_rptr_next);
  
  always@(posedge rclk or negedge rrst_n) begin
    if(!rrst_n) begin
      b_rptr <= 0;
      g_rptr <= 0;
    end
    else begin
      b_rptr <= b_rptr_next;
      g_rptr <= g_rptr_next;
    end
  end
  
  always@(posedge rclk or negedge rrst_n) begin
    if(!rrst_n) empty <= 1;
    else        empty <= rempty;
  end
endmodule
FIFO Memory

基于二进制编码的写和读指针,数据分别写入 FIFO 或从 FIFO 读取。文章来源地址https://www.toymoban.com/news/detail-804197.html

module fifo_mem #(parameter DEPTH=8, DATA_WIDTH=8, PTR_WIDTH=3) (
  input wclk, w_en, rclk, r_en,
  input [PTR_WIDTH:0] b_wptr, b_rptr,
  input [DATA_WIDTH-1:0] data_in,
  input full, empty,
  output reg [DATA_WIDTH-1:0] data_out
);
  reg [DATA_WIDTH-1:0] fifo[0:DEPTH-1];
  
  always@(posedge wclk) begin
    if(w_en & !full) begin
      fifo[b_wptr[PTR_WIDTH-1:0]] <= data_in;
    end
  end
  /*
  always@(posedge rclk) begin
    if(r_en & !empty) begin
      data_out <= fifo[b_rptr[PTR_WIDTH-1:0]];
    end
  end
  */
  assign data_out = fifo[b_rptr[PTR_WIDTH-1:0]];
endmodule
Top Module
`include "synchronizer.v"
`include "wptr_handler.v"
`include "rptr_handler.v"
`include "fifo_mem.v"

module asynchronous_fifo #(parameter DEPTH=8, DATA_WIDTH=8) (
  input wclk, wrst_n,
  input rclk, rrst_n,
  input w_en, r_en,
  input [DATA_WIDTH-1:0] data_in,
  output reg [DATA_WIDTH-1:0] data_out,
  output reg full, empty
);
  
  parameter PTR_WIDTH = $clog2(DEPTH);
 
  reg [PTR_WIDTH:0] g_wptr_sync, g_rptr_sync;
  reg [PTR_WIDTH:0] b_wptr, b_rptr;
  reg [PTR_WIDTH:0] g_wptr, g_rptr;

  wire [PTR_WIDTH-1:0] waddr, raddr;

  synchronizer #(PTR_WIDTH) sync_wptr (rclk, rrst_n, g_wptr, g_wptr_sync); //write pointer to read clock domain
  synchronizer #(PTR_WIDTH) sync_rptr (wclk, wrst_n, g_rptr, g_rptr_sync); //read pointer to write clock domain 
  
  wptr_handler #(PTR_WIDTH) wptr_h(wclk, wrst_n, w_en,g_rptr_sync,b_wptr,g_wptr,full);
  rptr_handler #(PTR_WIDTH) rptr_h(rclk, rrst_n, r_en,g_wptr_sync,b_rptr,g_rptr,empty);
  fifo_mem fifom(wclk, w_en, rclk, r_en,b_wptr, b_rptr, data_in,full,empty, data_out);

endmodule
Testbench Code
module async_fifo_TB;

  parameter DATA_WIDTH = 8;

  wire [DATA_WIDTH-1:0] data_out;
  wire full;
  wire empty;
  reg [DATA_WIDTH-1:0] data_in;
  reg w_en, wclk, wrst_n;
  reg r_en, rclk, rrst_n;

  // Queue to push data_in
  reg [DATA_WIDTH-1:0] wdata_q[$], wdata;

  asynchronous_fifo as_fifo (wclk, wrst_n,rclk, rrst_n,w_en,r_en,data_in,data_out,full,empty);

  always #10ns wclk = ~wclk;
  always #35ns rclk = ~rclk;
  
  initial begin
    wclk = 1'b0; wrst_n = 1'b0;
    w_en = 1'b0;
    data_in = 0;
    
    repeat(10) @(posedge wclk);
    wrst_n = 1'b1;

    repeat(2) begin
      for (int i=0; i<30; i++) begin
        @(posedge wclk iff !full);
        w_en = (i%2 == 0)? 1'b1 : 1'b0;
        if (w_en) begin
          data_in = $urandom;
          wdata_q.push_back(data_in);
        end
      end
      #50;
    end
  end

  initial begin
    rclk = 1'b0; rrst_n = 1'b0;
    r_en = 1'b0;

    repeat(20) @(posedge rclk);
    rrst_n = 1'b1;

    repeat(2) begin
      for (int i=0; i<30; i++) begin
        @(posedge rclk iff !empty);
        r_en = (i%2 == 0)? 1'b1 : 1'b0;
        if (r_en) begin
          wdata = wdata_q.pop_front();
          if(data_out !== wdata) $error("Time = %0t: Comparison Failed: expected wr_data = %h, rd_data = %h", $time, wdata, data_out);
          else $display("Time = %0t: Comparison Passed: wr_data = %h and rd_data = %h",$time, wdata, data_out);
        end
      end
      #50;
    end

    $finish;
  end
  
  initial begin 
    $dumpfile("dump.vcd"); $dumpvars;
  end
endmodule

到了这里,关于Asynchronous FIFO and synchronous FIFO-翻译自外网的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • FPGA FIFO基本介绍(FIFO Geneerator(13.2))

    软件:vivado 2020.2  参考文献: 文档xilinx官网pg057-fifo-generator文档下载链接官网https://docs.xilinx.com/v/u/en-US/pg057-fifo-generatorhttps://docs.xilinx.com/v/u/en-US/pg057-fifo-generator https://docs.xilinx.com/v/u/en-US/pg057-fifo-generator 原官网免费文档已被上传为付费文档,笔者上传的免费文档未过审核。

    2024年01月25日
    浏览(46)
  • FPGA — FIFO学习笔记

    使用软件: Vivado 参考文档 :FIFO Generator v13.2 FIFO(Fist In Fist Out),即为先进先出,常被用于数据的缓存或高速异步数据的交互,与普通存储器区别是没有外部读写地址线,使用简单,缺点是只能顺序写入数据,顺序的读出数据,其数据地址由内部读写指针自动加1完成,不能像

    2024年02月16日
    浏览(38)
  • FPGA——FIFO

    FIFO FIFO(First In First Out,即先入先出),是一种数据缓冲器,用来实现数据先入先出的读写方式。FIFO 根据读写时钟是否相同,分为 SCFIFO(single-clock FIFO)和 DCFIFO(duabl-clock FIFO),SCFIFO 的读写为同一时钟,应用在同步时钟系统中;DCFIFO 的读写时钟不同,应用在异步时钟系统

    2024年02月05日
    浏览(41)
  • 【LabVIEW FPGA入门】FIFO

            要在 FPGA VI 的不同部分之间或 FPGA 目标中的 VI 之间传输缓冲数据,可使用 FIFO。FIFO 是一种先进先出的缓冲器,第一个写入内存的数据项就是第一个从内存中读取和删除的数据项,类似于队列。         FPGA FIFO 的功能类似于一个固定长度的队列,可将多个数据

    2024年03月27日
    浏览(49)
  • FPGA学习笔记——FIFO读写

    【实验任务】向FIFO中以50MHz的频率按顺序写入0~254,再从FIFO中以5Hz的频率按顺序读出0~254,输出到LED中点亮。 FIFO全称为“First-In-First-Out”,是FPGA内部的存储数据的缓冲器,读写数据具有先入先出的特点,与数据结构中的“队列”有异曲同工之妙。 本博客例化紫光同创官方提

    2024年02月15日
    浏览(35)
  • FPGA学习笔记(3):FIFO

    FIFO是First Input First Output的英文简写 代表先进的数据先出 ,后进的数据后出。 FIFO存储器是系统的缓冲环节,如果没有FIFO存储器,整个系统就不可能正常工作。 FIFO的功能可以概括为 (1)对连续的数据流进行缓存,防止在进机和存储操作时丢失数据; (2)数据集中起来进行

    2024年01月19日
    浏览(40)
  • FPGA中FIFO的应用(三)——Vivado FIFO IP核的调用

    ⭐️作者简介: 小瑞同学 ,一个努力精进的 FPGA 和通信学习者。 🍎个人主页:小瑞同学的博客主页 🌻个人信条:越努力,越幸运! ⏰日期:2023.12.6 🔍来源:自学经历 📖文章内容概述:简单介绍了 FIFO IP核 常用参数的配置,通过仿真分析了异步IP的 读写数据 过程。 连载

    2024年01月18日
    浏览(42)
  • 【FPGA】UART串口通信---基于FIFO

    我们在上一章完成了UART串口通信的收发模块,这一章我们将FIFO引入进来,使用FIFO进行缓存数据,来连接串口通信的收发模块 FIFO即First In First Out,是一种先进先出数据存储、缓冲器,我们知道一般的存储器是用外部的读写地址来进行读写,而FIFO这种存储器的结构并不需要外

    2023年04月14日
    浏览(85)
  • 【FPGA IP系列】FIFO深度计算详解

    FIFO(First In First Out)是一种先进先出的存储结构,经常被用来在FPGA设计中进行数据缓存或者匹配传输速率。 FIFO的一个关键参数是其深度,也就是FIFO能够存储的数据条数,深度设计的合理,可以防止数据溢出,也可以节省FPGA资源的消耗。 影响FIFO深度计算的主要因素包括: FIF

    2024年02月06日
    浏览(56)
  • 【FPGA IP系列】FIFO的通俗理解

    FPGA厂商提供了丰富的IP核,基础性IP核都是可以直接免费调用的,比如FIFO、RAM等等。 本文主要介绍FIFO的一些基础知识,帮助大家能够理解FIFO的基础概念。 FIFO全称是First In First Out,即先进先出。 FIFO是一个数据缓存队列,主要特点就是数据顺序写入,再按照同样的顺序输出数

    2024年02月15日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包