前言

最近在做基于fpga的声阵列数据采集，需要fpga对4通道声阵列信号进行采集，利用AD7608八通道模数转换芯片将麦克风模拟信号转换成数字信号然后通过fpga异步fifo乒乓操作，将数据打包通过以太网传输至PC端进行声学信号处理。本章讲如何在vivado上实现异步fifo乒乓操作，文章最后会贴出仿真图以及总体工程文件（包括原码以及testbench）免费下载。

一、FIFO配置

首先第一面选择异步双端口RAM

第二步读写数据位宽选择16位（因为AD7608为18位，后面准备减少数据位宽至16），数据深度选择1024（实际只有1023，后面由于UDP最多一次只能传输1500左右字节，对于2字节数据，最多只能传输700左右），

第三步选择512个数据读满信号

第四步将读写计数全勾上

最后配置界面

二、状态转换图

写FIFO：（由于实时采集数据，也就是一直采集，所以每当来个采集完成信号存储一次fifo，当fifo1存满开始存fifo2）

读FIFO：（因为udp传输时钟远远大于数据采集时钟，所以当fifo1存满时，将当前fifo1数据通过udp传输出去，然后等待下一个fifo2满信号再继续传输数据，循环往复）

三、异步fifo乒乓操作控制代码

module data_stream_control_top(
    input              sys_clk        ,
    input              rst_n          ,
    //data_i
//    input        clk_in      
    input [15:0]       data_in        ,
    input              data_in_en     ,
    //data_ou
    input              clk_out        ,
    input              data_out_en    ,
    output             prog1_full     ,
    output     [15:0]  data_out       ,
    output reg         tx_start_en    ,
    output     [9:0]   rd_data1_count ,
    output     [9:0]   wr_data1_count ,
    output reg         data1_in_en    ,
    output reg         data1_out_en    ,
    output     [9:0]   rd_data2_count ,
    output     [9:0]   wr_data2_count ,
    output reg         data2_in_en    ,
    output reg [2:0]   nex_fifo_state ,
    output reg [2:0]   nex_data_state ,
    output reg         data_en_out    
    );
    
    
wire [15:0] data1_out;
wire [15:0] data2_out;    
//assign data_out =(cur_data_state== st_data2_en)? data2_out:data1_out;

    
wire    fifo1_full ;
wire    fifo1_empty;
//wire    prog1_full ;
wire    fifo2_full ;
wire    fifo2_empty;
wire    prog2_full ;
//wire  [9:0] rd_data1_count;
//wire  [9:0] wr_data1_count;
//wire  [9:0] rd_data2_count;
//wire  [9:0] wr_data2_count;
//reg data1_in_en;
//reg data2_in_en;  

assign clk_in = sys_clk;
//data_store
parameter st_fifo_idle = 3'b001;
parameter st_fifo1_en  = 3'b010;
parameter st_fifo2_en  = 3'b100;
reg [2:0] cur_fifo_state;
//reg [2:0] nex_fifo_state;



//data_get
parameter st_data_idle = 3'b001;
parameter st_data1_en  = 3'b010;
parameter st_data2_en  = 3'b100;
reg [2:0] cur_data_state;
//reg [2:0] nex_data_state;
//reg data1_out_en;
reg data2_out_en;

assign data_out = (((cur_data_state == st_data1_en)||(cur_data_state == st_data2_en))&&(data_en_out))? ((cur_data_state== st_data1_en)? data1_out:data2_out):16'd0;
//data_store 
always@(*)begin
    if(!rst_n)begin
        cur_fifo_state<=st_fifo_idle;    
    end
    else begin
       cur_fifo_state<=nex_fifo_state;  
    end
end

always@(posedge clk_in or negedge rst_n)begin
    if(!rst_n)begin
      nex_fifo_state <= st_fifo_idle;
      data1_in_en    <=  1'b0; 
      data2_in_en    <=  1'b0;   
    end
    else case(cur_fifo_state)
        st_fifo_idle:begin
                nex_fifo_state <= st_fifo1_en;
        end
        st_fifo1_en:begin
            if(wr_data1_count!=10'd512)begin
                if(data_in_en)
                    data1_in_en    <=  1'b1;
                else
                    data1_in_en    <=  1'b0;
            end    
            else begin
                nex_fifo_state <= st_fifo2_en;
                data1_in_en    <=  1'b0;
            end
        end    
        st_fifo2_en:begin
            if(wr_data2_count!=10'd512)begin
                if(data_in_en)
                    data2_in_en    <=  1'b1;
                else
                    data2_in_en    <=  1'b0;
            end    
            else begin
                nex_fifo_state <= st_fifo1_en;
                data2_in_en    <=  1'b0;
            end
        end 
    endcase
end

//data_get
always@(*)begin
    if(!rst_n)begin
        cur_data_state<=st_data_idle;    
    end
    else begin
       cur_data_state<=nex_data_state;  
    end
end


always@(posedge clk_out or negedge rst_n)begin
    if(!rst_n)begin
      nex_data_state <= st_data_idle;
      data1_out_en    <=  1'b0;
      data2_out_en    <=  1'b0;    
    end
    else case(cur_data_state)
        st_data_idle:begin
            if(wr_data1_count==10'd512)          
                nex_data_state <= st_data1_en;
            else if(wr_data2_count==10'd512)        
                nex_data_state <= st_data2_en;
            else
                nex_data_state <= st_data_idle;     
        end
        st_data1_en:begin
            if(rd_data1_count!=10'd0)begin
                    if(data_out_en)
                        data1_out_en    <=  1'b1;
                    else
                        data1_out_en    <=  1'b0;
                end    
            else begin
                    nex_data_state <= st_data_idle;
                    data1_out_en    <=  1'b0;
            end
        end  
        st_data2_en:begin
            if(rd_data2_count!=10'd0)begin
                if(data_out_en)
                    data2_out_en    <=  1'b1;
                else
                    data2_out_en    <=  1'b0;
            end    
            else begin
                nex_data_state <= st_data_idle;
                data2_out_en    <=  1'b0;
            end
        end  
    endcase
end

always@(posedge clk_out or negedge rst_n)begin
    if(!rst_n)
        tx_start_en<=1'b0;
    else if(((wr_data1_count==10'd512)&&(prog1_full))||((wr_data2_count==10'd512)&&(prog2_full)))
        tx_start_en<=1'b1;
    else    
        tx_start_en<=1'b0;
end

//使能data_out
//reg data_en_out   ;
reg data_out_flag0;
reg data_out_flag1;
assign data_out_flag = data_out_flag0 || data_out_flag1;
always@(posedge clk_out or negedge rst_n)begin
    if(!rst_n)begin
        data_out_flag0 <= 1'b0;
        data_out_flag1 <= 1'b0;   
    end
    else begin
        data_out_flag0 <= data_out_en   ;
        data_out_flag1 <= data_out_flag0;
    end
end
          
always@(posedge clk_out or negedge rst_n)begin
    if(!rst_n)begin
        data_en_out<=1'b0;
    end
    else begin
        if(data_out_flag)
           data_en_out<=1'b1;
         else
           data_en_out<=1'b0;
    end  
end

fifo_generator_0 u_fifo_generator_1(
  .rst          (~rst_n      ),  // input wire rst
  .wr_clk       (clk_in      ),  // input wire wr_clk
  .rd_clk       (clk_out     ),  // input wire rd_clk
  .din          (data_in     ),  // input wire [15 : 0] din
  .wr_en        (data1_in_en ),  // input wire wr_en
  .rd_en        (data1_out_en),  // input wire rd_en
  .dout         (data1_out   ),  // output wire [15 : 0] dout
  .full         (fifo1_full  ),  // output wire full
  .empty        (fifo1_empty ),  // output wire empty
  .rd_data_count(rd_data1_count),// output wire [9 : 0] rd_data_count
  .wr_data_count(wr_data1_count),// output wire [9 : 0] wr_data_count
  .prog_full    (prog1_full    ),// output wire prog_full
  .wr_rst_busy  (),              // output wire wr_rst_busy
  .rd_rst_busy  ()               // output wire rd_rst_busy
);    
    
fifo_generator_0 u_fifo_generator_2(
  .rst          (~rst_n        ),  // input wire rst
  .wr_clk       (clk_in        ),  // input wire wr_clk
  .rd_clk       (clk_out       ),  // input wire rd_clk
  .din          (data_in       ),  // input wire [15 : 0] din
  .wr_en        (data2_in_en   ),  // input wire wr_en
  .rd_en        (data2_out_en  ),  // input wire rd_en
  .dout         (data2_out     ),  // output wire [15 : 0] dout
  .full         (fifo2_full    ),  // output wire full
  .empty        (fifo2_empty   ),  // output wire empty
  .rd_data_count(rd_data2_count),  // output wire [9 : 0] rd_data_count
  .wr_data_count(wr_data2_count),  // output wire [9 : 0] wr_data_count
  .prog_full    (prog2_full    ),  // output wire prog_full
  .wr_rst_busy  (),                // output wire wr_rst_busy
  .rd_rst_busy  ()                 // output wire rd_rst_busy
);    
    
endmodule

四、仿真图

通过下面两张图可以很明显看到当fifo1写满之后，转台跳转到写fifo2，同时读状态开始读fifo1，至此异步fifo乒乓操作已实现。

五、总体工程文件（包含仿真）免费下载

基于vivado异步fifo IP乒乓操作工程文件
当然，如果想了解异步fifo乒乓操作RTL设计，而不是直接调用IP核的话，可以参考这个资源：异步fifo乒乓操作RTL设计