Verilog实现FIFO设计（二）之异步可变位宽，可变深度

请查看：异步FIFO—Verilog实现
写的非常好，此处不再赘述。

---

补充一下采用博主代码实现时候的一些问题（可能是我个人的问题）：

1. 在fifo_async这个模块中的下列代码：

//=========================================================write fifo 
genvar i;
generate 
for(i = 0; i < data_depth; i = i + 1 )
begin:fifo_init
always@(posedge wr_clk or posedge rst)
    begin
       if(rst)
          fifo_ram[i] <= 'h0;//fifo复位后输出总线上是0，并非ram中真的复位。可无
       else if(wr_en && (~full))
          fifo_ram[wr_addr] <= din;
       else
          fifo_ram[wr_addr] <= fifo_ram[wr_addr];
    end   
end    
endgenerate    

此处代码编译是没问题的，但是我后期通过Vivado进行综合的时候会报错，具体错误我忘了，大概意思就是：fifo_ram这个东西多次赋值是不允许的。应该是generate的问题，解决方法就是不使用generate for，老老实实的把所有的赋值为0都写上，或者在always块里面使用for循环进行初始化，具体参考以下代码（和参考文章中的代码基本相同，就是改了一下我说到的那个问题，这个代码仿真，综合都通过了）：

module fifo_async#(
                 parameter   data_width = 32,
                 parameter   data_depth = 8,
                 parameter   addr_width = 4
)
(
                  input                           rst_n,
                  input                           wr_clk,
                  input                           wr_en,
                  input      [data_width-1:0]     din,         
                  input                           rd_clk,
                  input                           rd_en,
                  output reg                     valid,
                  output reg [data_width-1:0]     dout,
                  output                          empty,
                  output                          full
    );


reg    [addr_width:0]    wr_addr_ptr;//地址指针，比地址多一位，MSB用于检测在同一圈
reg    [addr_width:0]    rd_addr_ptr;
wire   [addr_width-1:0]  wr_addr;//RAM 地址
wire   [addr_width-1:0]  rd_addr;

wire   [addr_width:0]    wr_addr_gray;//地址指针对应的格雷码
reg    [addr_width:0]    wr_addr_gray_d1;
reg    [addr_width:0]    wr_addr_gray_d2;
wire   [addr_width:0]    rd_addr_gray;
reg    [addr_width:0]    rd_addr_gray_d1;
reg    [addr_width:0]    rd_addr_gray_d2;


reg [data_width-1:0] fifo_ram [data_depth-1:0];

//=========================================================write fifo 


always@(posedge wr_clk or negedge rst_n)
    begin:write_ram
			 integer i; 
       if(!rst_n)
				 for( i = 0; i < data_depth; i = i + 1 ) begin:write_ram_init
          	 fifo_ram[i] <= 'h0;//fifo复位后输出总线上是0，并非ram中真的复位。可无
				 end//write_ram_init
       else if(wr_en && (~full))
          fifo_ram[wr_addr] <= din;
       else
          fifo_ram[wr_addr] <= fifo_ram[wr_addr];  
    end//write_ram    

//========================================================read_fifo
always@(posedge rd_clk or negedge rst_n)
   begin
      if(!rst_n)
         begin
            dout <= 'h0;
            valid <= 1'b0;
         end
      else if(rd_en && (~empty))
         begin
            dout <= fifo_ram[rd_addr];
            valid <= 1'b1;
         end
      else
         begin
            dout <=   'h0;//fifo复位后输出总线上是0，并非ram中真的复位，只是让总线为0；
            valid <= 1'b0;
         end
   end
assign wr_addr = wr_addr_ptr[addr_width-1-:addr_width];
assign rd_addr = rd_addr_ptr[addr_width-1-:addr_width];
//=============================================================格雷码同步化
always@(posedge wr_clk )
   begin
      rd_addr_gray_d1 <= rd_addr_gray;
      rd_addr_gray_d2 <= rd_addr_gray_d1;
   end
always@(posedge wr_clk or negedge rst_n)
   begin
      if(!rst_n)
         wr_addr_ptr <= 'h0;
      else if(wr_en && (~full))
         wr_addr_ptr <= wr_addr_ptr + 1;
      else 
         wr_addr_ptr <= wr_addr_ptr;
   end
//=========================================================rd_clk
always@(posedge rd_clk )
      begin
         wr_addr_gray_d1 <= wr_addr_gray;
         wr_addr_gray_d2 <= wr_addr_gray_d1;
      end
always@(posedge rd_clk or negedge rst_n)
   begin
      if(!rst_n)
         rd_addr_ptr <= 'h0;
      else if(rd_en && (~empty))
         rd_addr_ptr <= rd_addr_ptr + 1;
      else 
         rd_addr_ptr <= rd_addr_ptr;
   end

//========================================================== translation gary code
assign wr_addr_gray = (wr_addr_ptr >> 1) ^ wr_addr_ptr;
assign rd_addr_gray = (rd_addr_ptr >> 1) ^ rd_addr_ptr;

assign full = (wr_addr_gray == {~(rd_addr_gray_d2[addr_width-:2]),rd_addr_gray_d2[addr_width-2:0]}) ;//高两位不同
assign empty = ( rd_addr_gray == wr_addr_gray_d2 );

endmodule

2.一个简单的testbench，先写入一个数据再读出来，然后依次写入四个数据，使full信号有效，再依次读出来。

module fifo_async_tb();
                        
  reg                 tb_rst_n  ;  
  reg                 tb_wr_clk ;                 
  reg                 tb_wr_en  ;              
  reg   [31:0]        tb_din    ;               
  reg                 tb_rd_clk ;                     
  reg                 tb_rd_en  ;                    
  wire                tb_valid  ;                      
  wire  [31:0]        tb_dout   ;                     
  wire                tb_empty  ;                        
  wire                tb_full   ;                      

  task delay;
    input [31:0] num;
    begin
      repeat(num) @(posedge tb_wr_clk);
      #1;
    end
  endtask

  task delay1;
    input [31:0] num;
    begin
      repeat(num) @(posedge tb_rd_clk);
      #1;
    end
  endtask

  initial begin
    tb_wr_clk = 0;
  end
  always #40 tb_wr_clk = ~tb_wr_clk;

  initial begin
    tb_rd_clk = 0;
  end
  always #10 tb_rd_clk = ~tb_rd_clk;

  initial begin
    tb_rst_n = 1;
    delay(1);
    tb_rst_n = 0;
    delay(1);
    tb_rst_n = 1;
  end

  initial begin
    $dumpfile(" async_fifo_tb.vcd ");
    $dumpvars();
  end

  initial begin
    tb_wr_en = 0;
    tb_din = 0;
    tb_rd_en = 0;
    delay(3);
    // write data
    tb_wr_en = 1;
    tb_din = 32'haaaa;
    delay(1);
    tb_wr_en = 0;
    delay(5);
    // read data, empty
    tb_rd_en = 1;
    delay1(1);
    tb_rd_en = 0;
    delay1(5);
    // write data1
    tb_wr_en = 1;
    tb_din = 32'hbbbb;
    delay(1);
    tb_wr_en = 0;
    delay(5);
    // write data2
    tb_wr_en = 1;
    tb_din = 32'hcccc;
    delay(1);
    tb_wr_en = 0;
    delay(5);
    // write data3
    tb_wr_en = 1;
    tb_din = 32'hdddd;
    delay(1);
    tb_wr_en = 0;
    delay(5);
    // write data4, full
    tb_wr_en = 1;
    tb_din = 32'heeee;
    delay(1);
    tb_wr_en = 0;
    delay(5);
    // read data1
    tb_rd_en = 1;
    delay1(1);
    tb_rd_en = 0;
    delay1(5);
    // read data2
    tb_rd_en = 1;
    delay1(1);
    tb_rd_en = 0;
    delay1(5);
    // read data3
    tb_rd_en = 1;
    delay1(1);
    tb_rd_en = 0;
    delay1(5);
    // read data4, empty
    tb_rd_en = 1;
    delay1(1);
    tb_rd_en = 0;
    delay1(5);
    delay(5);
    $finish;
  end
fifo_async#(
                 .data_width(32) ,
                 .data_depth(4 ) ,
                 .addr_width(2 )  
) dut1_fifo_async
(
  .rst_n ( tb_rst_n  )  ,
  .wr_clk( tb_wr_clk )  ,
  .wr_en ( tb_wr_en  )  ,
  .din   ( tb_din    )  ,         
  .rd_clk( tb_rd_clk )  ,
  .rd_en ( tb_rd_en  )  ,
  .valid ( tb_valid  )  ,
  .dout  ( tb_dout   )  ,
  .empty ( tb_empty  )  ,
  .full  ( tb_full   )            
    );


endmodule

仿真波形图：

读出来的结果：

3.如果你想使用一个深度的异步fifo（data_depth=1），即用来缓冲数据的话，通过这个代码是无法实现的，会报错，这个代码只能是深度为4，如果资源不那么紧张的话，就将就用一下吧。如果想要写一个数据立马读出来，你可以在例化的时候使用.re_en(~empty)，即只要fifo非空，就开始读数据。