Verilog-异步FIFO

参考博文：https://blog.csdn.net/alangaixiaoxiao/article/details/81432144

1、概述

　　异步FIFO设计的关键是产生“写满”和“读空”信号，这两个信号的产生需要用到读指针rptr和写指针wptr构建组合逻辑进行判断，然而读指针属于读时钟域rclk，写指针属于写时钟域wclk，因此必须进行同步化处理以消除亚稳态。异步FIFO的设计一般采用2种手段进行同步化处理：

　　（1）将读指针rptr打2拍到写时钟域，将写指针wptr打两拍到读时钟域，消除亚稳态；

　　（2）由于读写指针都是多比特信号，直接对它们进行同步化容易产生亚稳态，且用组合逻辑进行判断容易产生毛刺，因此改用格雷码进行异步时钟域的传输。

2、代码

　　设计思路有以下几点：

　　（1）在指针中添加一个额外的位(extra bit)，当写指针增加并越过最后一个FIFO地址时，就将写指针这个未用的MSB加1，其它位回零。对读指针也进行同样的操作。此时，对于深度为2^n的FIFO，需要的读/写指针位宽为(n+1)位，如对于深度为8的FIFO，需要采用4bit的计数器，0000～0111、1000～1111，MSB作为折回标志位，而低3位作为地址指针。如果两个指针的MSB不同，说明写指针比读指针多折回了一次；如r_addr=0000,而w_addr = 1000,为满。如果两个指针完全相同，为空。

　　（2）使用gray码解决了一个问题，但同时也带来另一个问题，即在格雷码域如何判断空与满。空的判断标准仍是完全相同，满的判断标准需要满足：

　　　　■ 格雷码指针的最高位不同，因为wptr必须比rptr多折回一次。

　　　　■ wptr与rptr的次高位不相等，如下表的7（格雷码为0100）和15（格雷码为1000），转化为二进制对应的是0111和1111，MSB不同说明多折回一次，111相同代表同一位置。

　　　　■ 其余位完全相同

　　（3）对双口RAM的寻址采用二进制码，异步时钟域的交互采用格雷码。

`timescale 1ns / 1ps

module asynchronous_fifo

#(parameter ASIZE=,DSIZE=)

(

    // 读

    input rclk,

    input rrst_n,

    input rinc,

    output [DSIZE-:] rdata,

    output rempty,

    // 写

    input wclk,

    input wrst_n,

    input winc,

    input [DSIZE-:] wdata,

    output wfull

    );

// 读写地址,由wbin、rbin的低位生成

wire [ASIZE-:] waddr,raddr;

reg [ASIZE:] wbin,rbin;

// 读写指针（比地址位宽大1）

reg [ASIZE:] wgray,rgray;

wire [ASIZE:] wbinnext,wgraynext,rbinnext,rgraynext;

// 经打拍后的读写指针

reg [ASIZE:] rq1_wgray,rq2_wgray,wq1_rgray,wq2_rgray;

reg rempty_val,wfull_val;

// 双端口存储器

reg [DSIZE-:] mem [:(<<ASIZE)-];

reg [DSIZE-:] rdata_reg;

//assign rdata = mem[raddr];

always @(posedge wclk) begin

    if(!wfull && winc) mem[waddr] <= wdata;

end

always @(posedge rclk or negedge rrst_n) begin

    if(!rrst_n) rdata_reg <= ;

    else if(!rempty && rinc) rdata_reg <= mem[raddr];

    else rdata_reg <= {DSIZE{'bz}};  // 设成z态方便看波形

end

assign rdata = rdata_reg;

// 同步化处理

always @(posedge rclk or negedge rrst_n)begin

    if(!rrst_n) {rq1_wgray,rq2_wgray} <= ;

    else {rq1_wgray,rq2_wgray} <= {wgray,rq1_wgray};

end

always @(posedge wclk or negedge wrst_n) begin

    if(!wrst_n) {wq1_rgray,wq2_rgray} <= ;

    else {wq1_rgray,wq2_rgray} <= {rgray,wq1_rgray};

end

// 写地址和写满信号产生

always @(posedge wclk or negedge wrst_n) begin

    if(!wrst_n) {wbin,wgray} <= ;

    else {wbin,wgray} <= {wbinnext,wgraynext};

end

assign wbinnext = (~wfull & winc)? (wbin+'b1) : wbin;

assign waddr = wbin[ASIZE-:];

assign wgraynext = (wbinnext>>)^wbinnext;

always @(posedge wclk or negedge wrst_n) begin

    if(!wrst_n) wfull_val <= ; // 用同步到写时钟域的读指针与写指针进行比较,高两位不同其他位相同则满

    else wfull_val <= (wgraynext=={~wq2_rgray[ASIZE:ASIZE-],wq2_rgray[ASIZE-:]});

end

assign wfull = wfull_val;

// 读地址和读空信号

always @(posedge rclk or negedge rrst_n) begin

    if(!rrst_n) {rbin,rgray} <= ;

    else {rbin,rgray} <= {rbinnext,rgraynext};

end

assign rbinnext = (~rempty & rinc)? (rbin+'b1) : rbin;

assign raddr = rbin[ASIZE-:];

assign rgraynext = (rbinnext >> ) ^ rbinnext;

always @(posedge rclk or negedge rrst_n) begin

    if(!rrst_n) rempty_val <= ; // 用同步到读时钟域的写指针与读指针进行比较,各位都相同则满

    else rempty_val <= (rgraynext==rq2_wgray);

end

assign rempty = rempty_val;

endmodule

3、验证

　　（1）testbench

　　写8个数据（0-7）——触发wfull信号——读8个数据（0-7）——触发rempty信号——写8个数据（8-15）——触发wfull信号——读4个数据（8-11）——写4个数据（16-19）——触发wfull信号——读8个数据（12-19）——触发rempty信号

`timescale 1ns / 1ps

module asynchronous_fifo_tb;

    // Inputs

    reg rclk;

    reg rrst_n;

    reg rinc;

    reg wclk;

    reg wrst_n;

    reg winc;

    reg [:] wdata;

    // Outputs

    wire [:] rdata;

    wire rempty;

    wire wfull;

    integer i;

    // Instantiate the Unit Under Test (UUT)

    asynchronous_fifo uut (

        .rclk(rclk),

        .rrst_n(rrst_n),

        .rinc(rinc),

        .rdata(rdata),

        .rempty(rempty),

        .wclk(wclk),

        .wrst_n(wrst_n),

        .winc(winc),

        .wdata(wdata),

        .wfull(wfull)

    );

    initial begin

        // Initialize Inputs

        rclk = ;

        rrst_n = ;

        rinc = ;

        wclk = ;

        wrst_n = ;

        winc = ;

        wdata = ;

        // Wait 100 ns for global reset to finish

        #;

        rrst_n = ;

        wrst_n = ;

        @(negedge rclk);

        // Write

        for(i=;i<;i=i+) begin

            wdata = i;

            winc = ;

            @(negedge wclk);

        end

        winc = ;   //写满

        wdata = ;  

        //Read

        @(negedge rclk);

        for(i=;i<;i=i+) begin

            rinc = ;

            @(negedge rclk);

        end

        rinc = ;  //读空

        // Write

        @(negedge wclk);

        for(i=;i<;i=i+) begin

            wdata = i+;

            winc = ;

            @(negedge wclk);

        end

        winc = ;

        wdata = ;    // 写满

        //Read

        @(negedge rclk);

        for(i=;i<;i=i+) begin

            rinc = ;

            @(negedge rclk);

        end

        rinc = ;  // 读一半    

        // Write

        @(negedge wclk);

        for(i=;i<;i=i+) begin

            wdata = i+;

            winc = ;

            @(negedge wclk);

        end

        winc = ;

        wdata = ;    // 写一半        

        //Read

        @(negedge rclk);

        for(i=;i<;i=i+) begin

            rinc = ;

            @(negedge rclk);

        end

        rinc = ;  //读空        

        // Add stimulus here

    end

    always # wclk = ~wclk;

    always # rclk = ~rclk;

endmodule

　　（2）读空信号（rempty）存在几个周期的置0延迟，即在空状态写，写入数据后rempty不会立即置0，而是会经过几个周期以后才会置0，这跟跨异步时钟域的打拍有关，因为写指针需要2个周期才能同步到读时钟域与读指针进行比较。rempty在读状态下的置1不存在延迟，因为当前同步到读时钟域的写指针已经是最新的了，读指针的变化立即就可以触发置1，置0延迟置1不延迟对于实际使用是没有太大影响的，反之则有。同样写满信号（wfull）的置0也存在延迟。

巴特西

Verilog-异步FIFO

最新文章

热门文章