1.定義

FIFO是英文First In First Out 的縮寫，是一種先進(jìn)先出的數(shù)據(jù)緩存器，他與普通存儲(chǔ)器的區(qū)別是沒有外部讀寫地址線，這樣使用起來非常簡(jiǎn)單，但缺點(diǎn)就是只能順序?qū)懭霐?shù)據(jù)，順序的讀出數(shù)據(jù)， 其數(shù)據(jù)地址由內(nèi)部讀寫指針自動(dòng)加1完成，不能像普通存儲(chǔ)器那樣可以由地址線決定讀取或?qū)懭肽硞€(gè)指定的地址。

FIFO一般用于不同時(shí)鐘域之間的數(shù)據(jù)傳輸，比如FIFO的一端是AD數(shù)據(jù)采集， 另一端是計(jì)算機(jī)的PCI總線，假設(shè)其AD采集的速率為16位 100K SPS，那么每秒的數(shù)據(jù)量為100K×16bit=1.6Mbps,而PCI總線的速度為33MHz，總線寬度32bit,其最大傳輸速率為 1056Mbps,在兩個(gè)不同的時(shí)鐘域間就可以采用FIFO來作為數(shù)據(jù)緩沖。另外對(duì)于不同寬度的數(shù)據(jù)接口也可以用FIFO，例如單片機(jī)位8位數(shù)據(jù)輸出，而 DSP可能是16位數(shù)據(jù)輸入，在單片機(jī)與DSP連接時(shí)就可以使用FIFO來達(dá)到數(shù)據(jù)匹配的目的。

FIFO的分類根均FIFO工作的時(shí)鐘域，可以將FIFO分為同步FIFO和異步FIFO。同步FIFO是指讀時(shí)鐘和寫時(shí)鐘為同一個(gè)時(shí)鐘。在時(shí)鐘沿來臨時(shí)同時(shí)發(fā)生讀寫操作。異步FIFO是指讀寫時(shí)鐘不一致，讀寫時(shí)鐘是互相獨(dú)立的。

FIFO設(shè)計(jì)的難點(diǎn) FIFO設(shè)計(jì)的難點(diǎn)在于怎樣判斷FIFO的空/滿狀態(tài)。為了保證數(shù)據(jù)正確的寫入或讀出，而不發(fā)生益處或讀空的狀態(tài)出現(xiàn)，必須保證FIFO在滿的情況下，不 能進(jìn)行寫操作。在空的狀態(tài)下不能進(jìn)行讀操作。怎樣判斷FIFO的滿/空就成了FIFO設(shè)計(jì)的核心問題。

1.同步FIFO之Verilog實(shí)現(xiàn)

同步FIFO的意思是說FIFO的讀寫時(shí)鐘是同一個(gè)時(shí)鐘，不同于異步FIFO，異步FIFO的讀寫時(shí)鐘是完全異步的。同步FIFO的對(duì)外接口包括時(shí)鐘，清零，讀請(qǐng)求，寫請(qǐng)求，數(shù)據(jù)輸入總線，數(shù)據(jù)輸出總線，空以及滿信號(hào)。下面分別對(duì)同步FIFO的對(duì)外接口信號(hào)作一描述：

1． 時(shí)鐘，輸入，用于同步FIFO的讀和寫，上升沿有效；

2． 清零，輸入，異步清零信號(hào)，低電平有效，該信號(hào)有效時(shí)，F(xiàn)IFO被清空；

3． 寫請(qǐng)求，輸入，低電平有效，該信號(hào)有效時(shí)，表明外部電路請(qǐng)求向FIFO寫入數(shù)據(jù)；

4． 讀請(qǐng)求，輸入，低電平有效，該信號(hào)有效時(shí)，表明外部電路請(qǐng)求從FIFO中讀取數(shù)據(jù)；

5． 數(shù)據(jù)輸入總線，輸入，當(dāng)寫信號(hào)有效時(shí)，數(shù)據(jù)輸入總線上的數(shù)據(jù)被寫入到FIFO中；

6． 數(shù)據(jù)輸出總線，輸出，當(dāng)讀信號(hào)有效時(shí)，數(shù)據(jù)從FIFO中被讀出并放到數(shù)據(jù)輸出總線上；

7． 空，輸出，高電平有效，當(dāng)該信號(hào)有效時(shí)，表明FIFO中沒有任何數(shù)據(jù)，全部為空；

8． 滿，輸出，高電平有效，當(dāng)該信號(hào)有效時(shí)，表明FIFO已經(jīng)滿了，沒有空間可用來存貯數(shù)據(jù)。

下面的框圖主要描述同步FIFO的內(nèi)部結(jié)構(gòu)，畫出框圖有助于對(duì)電路結(jié)構(gòu)的理解，同樣也有助于RTL代碼的編寫 ：

…………………………………………………………………………………………………………………………………………………………………………………………..

同步FIFO的Verilog代碼 之一
在modlesim中驗(yàn)證過。

/******************************************************
A fifo controller verilog description.
******************************************************/
module fifo(datain, rd, wr, rst, clk, dataout, full, empty);
input [7:0] datain;
input rd, wr, rst, clk;
output [7:0] dataout;
output full, empty;
wire [7:0] dataout;
reg full_in, empty_in;
reg [7:0] mem [15:0];
reg [3:0] rp, wp;
assign full = full_in;
assign empty = empty_in;
// memory read out
assign dataout = mem[rp];
// memory write in
always@(posedge clk) begin
    if(wr && ~full_in) mem[wp]<=datain;
end
// memory write pointer increment
always@(posedge clk or negedge rst) begin
    if(!rst) wp<=0;
    else begin
      if(wr && ~full_in) wp<= wp+1'b1;
    end
end
// memory read pointer increment
always@(posedge clk or negedge rst)begin
    if(!rst) rp <= 0;
    else begin
      if(rd && ~empty_in) rp <= rp + 1'b1;
    end
end
// Full signal generate
always@(posedge clk or negedge rst) begin
    if(!rst) full_in <= 1'b0;
    else begin
      if( (~rd && wr)&&((wp==rp-1)||(rp==4'h0&&wp==4'hf)))
          full_in <= 1'b1;
      else if(full_in && rd) full_in <= 1'b0;
    end
end
// Empty signal generate
always@(posedge clk or negedge rst) begin
    if(!rst) empty_in <= 1'b1;
    else begin
      if((rd&&~wr)&&(rp==wp-1 || (rp==4'hf&&wp==4'h0)))
        empty_in<=1'b1;
      else if(empty_in && wr) empty_in<=1'b0;
    end
end
endmodule

…………………………………………………………………………………………………………………………………………………………………………………………..

同步FIFO的Verilog代碼 之二 這一種設(shè)計(jì)的FIFO，是基于觸發(fā)器的。寬度，深度的擴(kuò)展更加方便，結(jié)構(gòu)化跟強(qiáng)。以下代碼在modelsim中驗(yàn)證過。

module fifo_cell (sys_clk, sys_rst_n, read_fifo, write_fifo, fifo_input_data,
                        next_cell_data, next_cell_full, last_cell_full, cell_data_out, cell_full);
                        parameter WIDTH =8;
                        parameter D = 2;
                        input sys_clk;
                        input sys_rst_n;
                        input read_fifo, write_fifo;
                        input [WIDTH-1:0] fifo_input_data;
                        input [WIDTH-1:0] next_cell_data;
                        input next_cell_full, last_cell_full;
                        output [WIDTH-1:0] cell_data_out;
                        output cell_full;
                        reg [WIDTH-1:0] cell_data_reg_array;
                        reg [WIDTH-1:0] cell_data_ld;
                        reg cell_data_ld_en;
                        reg cell_full;
                        reg cell_full_next;
                        assign cell_data_out=cell_data_reg_array;
                        always @(posedge sys_clk or negedge sys_rst_n)
                           if (!sys_rst_n)
                              cell_full <= #D 0;
                           else if (read_fifo || write_fifo)
                              cell_full <= #D cell_full_next;
                        always @(write_fifo or read_fifo or next_cell_full or last_cell_full or cell_full)
                           casex ({read_fifo, write_fifo})
                               2'b00: cell_full_next = cell_full;
                               2'b01: cell_full_next = next_cell_full;
                               2'b10: cell_full_next = last_cell_full;
                               2'b11: cell_full_next = cell_full;
                           endcase
                         always @(posedge sys_clk or negedge sys_rst_n)
                              if (!sys_rst_n)
                                 cell_data_reg_array [WIDTH-1:0] <= #D 0;
                              else if (cell_data_ld_en)
                                 cell_data_reg_array [WIDTH-1:0] <= #D cell_data_ld [WIDTH-1:0];
                         always @(write_fifo or read_fifo or cell_full or last_cell_full)   
                              casex ({write_fifo,read_fifo,cell_full,last_cell_full})
                                  4'bx1_xx: cell_data_ld_en = 1'b1;
                                  4'b10_01: cell_data_ld_en = 1'b1;
                                  default: cell_data_ld_en =1'b0;
                              endcase
                         always @(write_fifo or read_fifo or next_cell_full or cell_full or last_cell_full or fifo_input_data or next_cell_data)
                              casex ({write_fifo, read_fifo, next_cell_full, cell_full, last_cell_full})
                                 5'b10_x01: cell_data_ld[WIDTH-1:0] = fifo_input_data[WIDTH-1:0];
                                 5'b11_01x: cell_data_ld[WIDTH-1:0] = fifo_input_data[WIDTH-1:0];
                                 default: cell_data_ld[WIDTH-1:0] = next_cell_data[WIDTH-1:0];
                              endcase
endmodule



module fifo_4cell(sys_clk, sys_rst_n, fifo_input_data, write_fifo, fifo_out_data,
                  read_fifo, full_cell0, full_cell1, full_cell2, full_cell3);
                  parameter WIDTH = 8;
                  parameter D = 2;
                  input sys_clk;
                  input sys_rst_n;
                  input [WIDTH-1:0] fifo_input_data;
                  output [WIDTH-1:0] fifo_out_data;
                  input read_fifo, write_fifo;
                  output full_cell0, full_cell1, full_cell2, full_cell3;
                  wire [WIDTH-1:0] dara_out_cell0, data_out_cell1, data_out_cell2,
                                   data_out_cell3, data_out_cell4;
                  wire full_cell4;
                  fifo_cell #(WIDTH,D) cell0
                  ( .sys_clk (sys_clk),
                    .sys_rst_n (sys_rst_n),
                    .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                    .write_fifo (write_fifo),
                    .next_cell_data (data_out_cell1[WIDTH-1:0]),
                    .next_cell_full (full_cell1),
                    .last_cell_full (1'b1),
                    .cell_data_out (fifo_out_data [WIDTH-1:0]),
                    .read_fifo (read_fifo),
                    .cell_full (full_cell0)
                   );

                  fifo_cell #(WIDTH,D) cell1
                  ( .sys_clk (sys_clk),
                    .sys_rst_n (sys_rst_n),
                    .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                    .write_fifo (write_fifo),
                    .next_cell_data (data_out_cell2[WIDTH-1:0]),
                    .next_cell_full (full_cell2),
                    .last_cell_full (full_cell0),
                    .cell_data_out (data_out_cell1[WIDTH-1:0]),
                    .read_fifo (read_fifo),
                    .cell_full (full_cell1)
                   );                  
                  fifo_cell #(WIDTH,D) cell2
                  ( .sys_clk (sys_clk),
                    .sys_rst_n (sys_rst_n),
                    .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                    .write_fifo (write_fifo),
                    .next_cell_data (data_out_cell3[WIDTH-1:0]),
                    .next_cell_full (full_cell3),
                    .last_cell_full (full_cell1),
                    .cell_data_out (data_out_cell2[WIDTH-1:0]),
                    .read_fifo (read_fifo),
                    .cell_full (full_cell2)
                   );                  

                  fifo_cell #(WIDTH,D) cell3
                  ( .sys_clk (sys_clk),
                    .sys_rst_n (sys_rst_n),
                    .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                    .write_fifo (write_fifo),
                    .next_cell_data (data_out_cell4[WIDTH-1:0]),
                    .next_cell_full (full_cell4),
                    .last_cell_full (full_cell2),
                    .cell_data_out (data_out_cell3[WIDTH-1:0]),
                    .read_fifo (read_fifo),
                    .cell_full (full_cell3)
                   );     
                   assign data_out_cell4[WIDTH-1:0] = {WIDTH{1'B0}};
                   assign full_cell4 = 1'b0;
endmodule

2.異步FIFO之Verilog實(shí)現(xiàn)

FIFO （先進(jìn)先出隊(duì)列）是一種在電子系統(tǒng)得到廣泛應(yīng)用的器件，通常用于數(shù)據(jù)的緩存和用于容納異步信號(hào)的頻率或相位的差異。FIFO的實(shí)現(xiàn)通常是利用雙口RAM和讀寫地址產(chǎn)生模塊來實(shí)現(xiàn)的。FIFO的接口信號(hào)包括異步的寫時(shí)鐘（wr_clk）和讀時(shí)鐘（rd_clk）、與寫時(shí)鐘同步的寫有效（wren）和寫數(shù)據(jù)（wr_data）、與讀時(shí)鐘同步的讀有效（rden）和讀數(shù)據(jù)（rd_data）。為了實(shí)現(xiàn)正確的讀寫和避免FIFO的上溢或下溢，通常還應(yīng)該給出與讀時(shí)鐘和寫時(shí)鐘同步的FIFO的空標(biāo)志（empty）和滿標(biāo)志（full）以禁止讀寫操作。

1 異步FIFO功能描述

圖1給出了FIFO的接口信號(hào)和內(nèi)部模塊圖。
由圖1可以看出，寫地址產(chǎn)生模塊根據(jù)寫時(shí)鐘和寫有效信號(hào)產(chǎn)生遞增的寫地睛，讀地址產(chǎn)生模塊根據(jù)讀時(shí)鐘和讀有效信號(hào)產(chǎn)生遞增的讀地址。FIFO的操作如下：在寫時(shí)鐘wr_clk的升沿，當(dāng)wren有效時(shí)，將wr_data寫入雙口RAM中寫地址對(duì)應(yīng)的位置中；始終將讀地址對(duì)應(yīng)的雙口RAM中的數(shù)據(jù)輸出到讀數(shù)據(jù)總線上。這樣就實(shí)現(xiàn)了先進(jìn)先出的功能。

寫地址產(chǎn)生模塊還根據(jù)讀地址和寫地址關(guān)系產(chǎn)生FIFO的滿標(biāo)志。當(dāng)wren有效時(shí)，若寫地址+2=讀地址時(shí)，full為1；當(dāng)wren無效時(shí)，若寫地址+ 1=讀地址時(shí)，full為1。讀地址產(chǎn)生模塊還根據(jù)讀地址和寫地址的差產(chǎn)生FIFO的空標(biāo)志。當(dāng)rden有效時(shí)，若寫地址-1=讀地址時(shí)，empty為 1；當(dāng)rden無效時(shí)，若寫地址=讀地址時(shí)，empty為1。按照以上方式產(chǎn)生標(biāo)志信號(hào)是為了提前一個(gè)時(shí)鐘周期產(chǎn)生對(duì)應(yīng)的標(biāo)志信號(hào)。
由于空標(biāo)志和滿標(biāo)志控制了FIFO的操作，因此標(biāo)志錯(cuò)誤會(huì)引起操作的錯(cuò)誤。如上所述，標(biāo)志的產(chǎn)生是通過對(duì)讀寫地址的比較產(chǎn)生的，當(dāng)讀寫時(shí)鐘完全異步時(shí)，對(duì)讀寫地址進(jìn)行比較時(shí)，可能得出錯(cuò)誤的結(jié)果。例如，在讀地址變化過程中，由于讀地址的各位變化并不同步，計(jì)算讀寫地址的差值，可能產(chǎn)生錯(cuò)誤的差值，導(dǎo)致產(chǎn)生錯(cuò)誤的滿標(biāo)志信號(hào)。若將未滿標(biāo)志置為滿標(biāo)志時(shí)，可能降低了應(yīng)用的性能，降低寫數(shù)據(jù)速率；而將滿置標(biāo)志置為未滿時(shí)，執(zhí)行一次寫操作，則可能產(chǎn)生溢出錯(cuò)誤，這對(duì)于實(shí)際應(yīng)用來說是絕對(duì)應(yīng)該避免的。空標(biāo)志信號(hào)的產(chǎn)生也可能產(chǎn)生類似的錯(cuò)誤。

2 異步FIFO的改進(jìn)設(shè)計(jì)

從以上分析中可以看出，異步FIFO之所以會(huì)發(fā)生錯(cuò)誤是國為在地址變化時(shí)，由于多位地址各位變化時(shí)間不同，異步時(shí)鐘對(duì)其進(jìn)行采樣時(shí)數(shù)值可能為不同于地址變化喪后數(shù)值的其他值，異步產(chǎn)生錯(cuò)誤的空標(biāo)志和滿標(biāo)志，以致于產(chǎn)生FIFO的操作錯(cuò)誤。
格雷碼是一種在相鄰計(jì)數(shù)值之間只有一位發(fā)生變化的編碼方式?？梢钥闯觯糇x寫地址采用格雷碼編碼方式，就可以解決上面的問題。
為了應(yīng)用的靈活，還增加了兩個(gè)標(biāo)志信號(hào)，將滿（almosf_full）標(biāo)志和空（almost_empty）標(biāo)志分別定義如下：當(dāng)寫地址與讀地址的距離小于某個(gè)預(yù)先定義數(shù)值時(shí)，almost_full為1；當(dāng)讀地址與寫地址的距離小于這個(gè)預(yù)先定義的數(shù)值時(shí)，almost_empty為1。

3 異步FIFO的Verilog

…………………………………………………………………………………………………………………………………………………………………………………………………………………………….
異步FIFO的Verilog代碼 之一
這個(gè)是基于RAM的異步FIFO代碼，個(gè)人認(rèn)為代碼結(jié)構(gòu)簡(jiǎn)單易懂，非常適合于考試中填寫。記得10月份參加威盛的筆試的時(shí)候，就考過異步FIFO的實(shí)現(xiàn)。想當(dāng)初要是早點(diǎn)復(fù)習(xí)，可能就可以通過威盛的筆試了。

與之前的用RAM實(shí)現(xiàn)的同步FIFO的程序相比，異步更為復(fù)雜。增加了讀寫控制信號(hào)的跨時(shí)鐘域的同步。此外，判空與判滿的也稍有不同。

module fifo1(rdata, wfull, rempty, wdata, winc, wclk, wrst_n,rinc, rclk, rrst_n);
parameter DSIZE = 8; parameter ASIZE = 4;
output [DSIZE-1:0] rdata;
output wfull;
output rempty;
input [DSIZE-1:0] wdata;
input winc, wclk, wrst_n;
input rinc, rclk, rrst_n;
reg wfull,rempty;
reg [ASIZE:0] wptr, rptr, wq2_rptr, rq2_wptr, wq1_rptr,rq1_wptr;
reg [ASIZE:0] rbin, wbin;
reg [DSIZE-1:0] mem[0:(1<1];
wire [ASIZE-1:0] waddr, raddr;
wire [ASIZE:0] rgraynext, rbinnext,wgraynext,wbinnext;
wire rempty_val,wfull_val;
//-----------------雙口RAM存儲(chǔ)器--------------------
assign rdata=mem[raddr];
always@(posedge wclk)
if (winc && !wfull) mem[waddr] <= wdata;
//-------------同步rptr 指針-------------------------
always @(posedge wclk or negedge wrst_n)
if (!wrst_n) {wq2_rptr,wq1_rptr} <= 0;
else {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr};
//-------------同步wptr指針---------------------------
always @(posedge rclk or negedge rrst_n)
if (!rrst_n) {rq2_wptr,rq1_wptr} <= 0;
else {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr};
//-------------rempty產(chǎn)生與raddr產(chǎn)生-------------------
always @(posedge rclk or negedge rrst_n) // GRAYSTYLE2 pointer
begin
if (!rrst_n) {rbin, rptr} <= 0;
else {rbin, rptr} <= {rbinnext, rgraynext};
end
// Memory read-address pointer (okay to use binary to address memory)
assign raddr = rbin[ASIZE-1:0];
assign rbinnext = rbin + (rinc & ~rempty);
assign rgraynext = (rbinnext>>1) ^ rbinnext;
// FIFO empty when the next rptr == synchronized wptr or on reset
assign rempty_val = (rgraynext == rq2_wptr);
always @(posedge rclk or negedge rrst_n)
begin
if (!rrst_n) rempty <= 1'b1;
else rempty <= rempty_val;
end
//---------------wfull產(chǎn)生與waddr產(chǎn)生------------------------------
always @(posedge wclk or negedge wrst_n) // GRAYSTYLE2 pointer
if (!wrst_n) {wbin, wptr} <= 0;
else {wbin, wptr} <= {wbinnext, wgraynext};
// Memory write-address pointer (okay to use binary to address memory)
assign waddr = wbin[ASIZE-1:0];
assign wbinnext = wbin + (winc & ~wfull);
assign wgraynext = (wbinnext>>1) ^ wbinnext;
assign wfull_val = (wgraynext=={~wq2_rptr[ASIZE:ASIZE-1], wq2_rptr[ASIZE-2:0]}); //:ASIZE-1]
always @(posedge wclk or negedge wrst_n)
if (!wrst_n) wfull <= 1'b0;
else wfull <= wfull_val;
endmodule

………………………………………………………………………………………………………………………………………………………………

異步FIFO的Verilog代碼 之二
與前一段異步FIFO代碼的主要區(qū)別在于，空/滿狀態(tài)標(biāo)志的不同算法。

第一個(gè)算法：Clifford E. Cummings的文章中提到的STYLE #1，構(gòu)造一個(gè)指針寬度為N+1，深度為2^N字節(jié)的FIFO（為便方比較將格雷碼指針轉(zhuǎn)換為二進(jìn)制指針）。當(dāng)指針的二進(jìn)制碼中最高位不一致而其它N位都 相等時(shí)，F(xiàn)IFO為滿（在Clifford E. Cummings的文章中以格雷碼表示是前兩位均不相同，而后兩位LSB相同為滿，這與換成二進(jìn)制表示的MSB不同其他相同為滿是一樣的）。當(dāng)指針完全相 等時(shí)，F(xiàn)IFO為空。

這種方法思路非常明了，為了比較不同時(shí)鐘產(chǎn)生的指針，需要把不同時(shí)鐘域的信號(hào)同步到本時(shí)鐘域中來，而使用Gray碼的目的就是使這個(gè)異步同步化的過 程發(fā)生亞穩(wěn)態(tài)的機(jī)率最小，而為什么要構(gòu)造一個(gè)N+1的指針，Clifford E. Cummings也闡述的很明白，有興趣的讀者可以看下作者原文是怎么論述的，Clifford E. Cummings的這篇文章有Rev1.1 Rev1.2兩個(gè)版本，兩者在比較Gray碼指針時(shí)的方法略有不同，個(gè)Rev1.2版更為精簡(jiǎn)。

第二種算法：Clifford E. Cummings的文章中提到的STYLE #2。它將FIFO地址分成了4部分，每部分分別用高兩位的MSB 00 、01、 11、 10決定FIFO是否為going full 或going empty (即將滿或空)。如果寫指針的高兩位MSB小于讀指針的高兩位MSB則FIFO為“幾乎滿”，若寫指針的高兩位MSB大于讀指針的高兩位MSB則FIFO 為“幾乎空”。

它是利用將地址空間分成4個(gè)象限（也就是四個(gè)等大小的區(qū)域），然后觀察兩個(gè)指針的相對(duì)位置，如果寫指針落后讀指針一個(gè)象限（25%的距離，呵呵）， 則證明很可能要寫滿，反之則很可能要讀空，這個(gè)時(shí)候分別設(shè)置兩個(gè)標(biāo)志位dirset和dirrst，然后在地址完全相等的情況下，如果dirset有效就 是寫滿，如果dirrst有效就是讀空。

這種方法對(duì)深度為2^N字節(jié)的FIFO只需N位的指針即可，處理的速度也較第一種方法快。

這段是說明的原話，算法一，還好理解。算法二，似乎沒有說清楚，不太明白。有興趣的可以查查論文，詳細(xì)研究下。

總之，第二種寫法是推薦的寫法。因?yàn)楫惒降亩鄷r(shí)鐘設(shè)計(jì)應(yīng)按以下幾個(gè)原則進(jìn)行設(shè)計(jì)：
1，盡可能的將多時(shí)鐘的邏輯電路（非同步器）分割為多個(gè)單時(shí)鐘的模塊，這樣有利于靜態(tài)時(shí)序分析工具來進(jìn)行時(shí)序驗(yàn)證。
2，同步器的實(shí)現(xiàn)應(yīng)使得所有輸入來自同一個(gè)時(shí)鐘域，而使用另一個(gè)時(shí)鐘域的異步時(shí)鐘信號(hào)采樣數(shù)據(jù)。
3，面向時(shí)鐘信號(hào)的命名方式可以幫助我們確定那些在不同異步時(shí)鐘域間需要處理的信號(hào)。
4，當(dāng)存在多個(gè)跨時(shí)鐘域的控制信號(hào)時(shí)，我們必須特別注意這些信號(hào)，保證這些控制信號(hào)到達(dá)新的時(shí)鐘域仍然能夠保持正確的順序。

module fifo2 (rdata, wfull, rempty, wdata,
winc, wclk, wrst_n, rinc, rclk, rrst_n);
parameter DSIZE = 8;
parameter ASIZE = 4;
output [DSIZE-1:0] rdata;
output wfull;
output rempty;
input [DSIZE-1:0] wdata;
input winc, wclk, wrst_n;
input rinc, rclk, rrst_n;
wire [ASIZE-1:0] wptr, rptr;
wire [ASIZE-1:0] waddr, raddr;
async_cmp #(ASIZE) async_cmp(.aempty_n(aempty_n),
.afull_n(afull_n),
.wptr(wptr), .rptr(rptr),
.wrst_n(wrst_n));
fifomem2 #(DSIZE, ASIZE) fifomem2(.rdata(rdata),
.wdata(wdata),
.waddr(wptr),
.raddr(rptr),
.wclken(winc),
.wclk(wclk));
rptr_empty2 #(ASIZE) rptr_empty2(.rempty(rempty),
.rptr(rptr),
.aempty_n(aempty_n),
.rinc(rinc),
.rclk(rclk),
.rrst_n(rrst_n));
wptr_full2 #(ASIZE) wptr_full2(.wfull(wfull),
.wptr(wptr),
.afull_n(afull_n),
.winc(winc),
.wclk(wclk),
.wrst_n(wrst_n));
endmodule
module fifomem2 (rdata, wdata, waddr, raddr, wclken, wclk);
parameter DATASIZE = 8; // Memory data word width
parameter ADDRSIZE = 4; // Number of memory address bits
parameter DEPTH = 1<// DEPTH = 2**ADDRSIZE
output [DATASIZE-1:0] rdata;
input [DATASIZE-1:0] wdata;
input [ADDRSIZE-1:0] waddr, raddr;
input wclken, wclk;
`ifdef VENDORRAM
// instantiation of a vendor's dual-port RAM
VENDOR_RAM MEM (.dout(rdata), .din(wdata),
.waddr(waddr), .raddr(raddr),
.wclken(wclken), .clk(wclk));
`else
reg [DATASIZE-1:0] MEM [0:DEPTH-1];
assign rdata = MEM[raddr];
always @(posedge wclk)
if (wclken) MEM[waddr] <= wdata;
`endif
endmodule
module async_cmp (aempty_n, afull_n, wptr, rptr, wrst_n);
parameter ADDRSIZE = 4;
parameter N = ADDRSIZE-1;
output aempty_n, afull_n;
input [N:0] wptr, rptr;
input wrst_n;
reg direction;
wire high = 1'b1;
wire dirset_n = ~( (wptr[N]^rptr[N-1]) & ~(wptr[N-1]^rptr[N]));
wire dirclr_n = ~((~(wptr[N]^rptr[N-1]) & (wptr[N-1]^rptr[N])) |
~wrst_n);
always @(posedge high or negedge dirset_n or negedge dirclr_n)
if (!dirclr_n) direction <= 1'b0;
else if (!dirset_n) direction <= 1'b1;
else direction <= high;
//always @(negedge dirset_n or negedge dirclr_n)
//if (!dirclr_n) direction <= 1'b0;
//else direction <= 1'b1;
assign aempty_n = ~((wptr == rptr) && !direction);
assign afull_n = ~((wptr == rptr) && direction);
endmodule
module rptr_empty2 (rempty, rptr, aempty_n, rinc, rclk, rrst_n);
parameter ADDRSIZE = 4;
output rempty;
output [ADDRSIZE-1:0] rptr;
input aempty_n;
input rinc, rclk, rrst_n;
reg [ADDRSIZE-1:0] rptr, rbin;
reg rempty, rempty2;
wire [ADDRSIZE-1:0] rgnext, rbnext;
//---------------------------------------------------------------
// GRAYSTYLE2 pointer
//---------------------------------------------------------------
always @(posedge rclk or negedge rrst_n)
if (!rrst_n) begin
rbin <= 0;
rptr <= 0;
end
else begin
rbin <= rbnext;
rptr <= rgnext;
end
//---------------------------------------------------------------
// increment the binary count if not empty
//---------------------------------------------------------------
assign rbnext = !rempty ? rbin + rinc : rbin;
assign rgnext = (rbnext>>1) ^ rbnext; // binary-to-gray conversion
always @(posedge rclk or negedge aempty_n)
if (!aempty_n) {rempty,rempty2} <= 2'b11;
else {rempty,rempty2} <= {rempty2,~aempty_n};
endmodule
module wptr_full2 (wfull, wptr, afull_n, winc, wclk, wrst_n);
parameter ADDRSIZE = 4;
output wfull;
output [ADDRSIZE-1:0] wptr;
input afull_n;
input winc, wclk, wrst_n;
reg [ADDRSIZE-1:0] wptr, wbin;
reg wfull, wfull2;
wire [ADDRSIZE-1:0] wgnext, wbnext;
//---------------------------------------------------------------
// GRAYSTYLE2 pointer
//---------------------------------------------------------------
always @(posedge wclk or negedge wrst_n)
if (!wrst_n) begin
wbin <= 0;
wptr <= 0;
end
else begin
wbin <= wbnext;
wptr <= wgnext;
end
//---------------------------------------------------------------
// increment the binary count if not full
//---------------------------------------------------------------
assign wbnext = !wfull ? wbin + winc : wbin;
assign wgnext = (wbnext>>1) ^ wbnext; // binary-to-gray conversion
always @(posedge wclk or negedge wrst_n or negedge afull_n)
if (!wrst_n ) {wfull,wfull2} <= 2'b00;
else if (!afull_n) {wfull,wfull2} <= 2'b11;
else {wfull,wfull2} <= {wfull2,~afull_n};
endmodule

審核編輯 ：李倩