同步fifo与异步fifo
参考以下帖子:
https://blog.csdn.net/hengzo/article/details/49683707
https://blog.csdn.net/Times_poem/article/details/51917648
https://www.cnblogs.com/aslmer/p/6114216.html
https://www.cnblogs.com/ylsm-kb/p/9068449.html
https://blog.csdn.net/Pieces_thinking/article/details/78026326
1.定义
FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部读写指针自动加1完成,不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。
FIFO一般用于不同时钟域之间的数据传输,比如FIFO的一端是AD数据采集, 另一端是计算机的PCI总线,假设其AD采集的速率为16位 100K SPS,那么每秒的数据量为100K×16bit=1.6Mbps,而PCI总线的速度为33MHz,总线宽度32bit,其最大传输速率为 1056Mbps,在两个不同的时钟域间就可以采用FIFO来作为数据缓冲。另外对于不同宽度的数据接口也可以用FIFO,例如单片机位8位数据输出,而 DSP可能是16位数据输入,在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的。
FIFO的分类根据FIFO工作的时钟域,可以将FIFO分为同步FIFO和异步FIFO。同步FIFO是指读时钟和写时钟为同一个时钟。在时钟沿来临时同时发生读写操作。异步FIFO是指读写时钟不一致,读写时钟是互相独立的。
FIFO设计的难点在于怎样判断FIFO的空/满状态。为了保证数据正确的写入或读出,而不发生溢出或读空的状态出现,必须保证FIFO在满的情况下,不能进行写操作。在空的状态下不能进行读操作。怎样判断FIFO的满/空就成了FIFO设计的核心问题。
2.同步FIFO之Verilog实现
同步FIFO的意思是说FIFO的读写时钟频率相同,不同于异步FIFO,异步FIFO的读写时钟频率是不同的。同步FIFO的对外接口包括时钟,清零,读请求,写请求,数据输入总线,数据输出总线,空以及满信号。下面分别对同步FIFO的对外接口信号作一描述:
1. 时钟,输入,用于同步FIFO的读和写,上升沿有效;
2. 清零,输入,异步清零信号,低电平有效,该信号有效时,FIFO被清空;
3. 写请求,输入,高电平有效,该信号有效时,表明外部电路请求向FIFO写入数据;
4. 读请求,输入,高电平有效,该信号有效时,表明外部电路请求从FIFO中读取数据;
5. 数据输入总线,输入,当写信号有效时,数据输入总线上的数据被写入到FIFO中;
6. 数据输出总线,输出,当读信号有效时,数据从FIFO中被读出并放到数据输出总线上;
7. 空,输出,高电平有效,当该信号有效时,表明FIFO中没有任何数据,全部为空;
8. 满,输出,高电平有效,当该信号有效时,表明FIFO已经满了,没有空间可用来存贮数据。
下面的框图主要描述同步FIFO的内部结构 :
verilog 代码和波形文件如下:
fifo_sync.v
/*use a extra counter to calcuate current fifo filled numberits bit is fifo width + 1, such as fifo depth is 8, then it is 0,...,7, we use 4 bits counter, if counter = 8, then express full,counter is 0, then it is empty */ module fifo_sync #( parameter FIFO_WIDTH = 32, //every fifo unit 's bit number, default is 32bits, a dword parameter ADDR_WIDTH = 3, //2^3=FIFO_DEPTH, so addr with is 3 bits if depth=8 parameter FIFO_DEPTH = 8 //fifo depth, first in, first out. ) (input clk,input rst_n,input [FIFO_WIDTH-1:0] wr_data,input rq, //read requestinput wq, //write requestoutput reg [FIFO_WIDTH-1:0] rd_data,output full,output empty ); //internal signal reg[FIFO_WIDTH-1:0] fifo_mem[FIFO_DEPTH-1:0]; reg[ADDR_WIDTH:0] counter; //extra one bit for counter reg[ADDR_WIDTH-1:0] rd_ptr; reg[ADDR_WIDTH-1:0] wr_ptr;//set full and empty assign full=(counter==FIFO_DEPTH); assign empty=(counter==0);//set current fifo counter value always @(posedge clk or negedge rst_n) beginif(!rst_n)counter<=0;else if((wq && !full)&&(rq && !empty)) // read and write meanwhile,counter keep no changecounter <= counter;else if(rq&&!empty)counter <= counter - 1;else if(wq&&!full)counter <= counter + 1;elsecounter <= counter; //no read, no write, keep no change end //read data if no empty and read enable always @(posedge clk or negedge rst_n ) beginif(!rst_n) beginrd_data <= 0;endif(rq && !empty)rd_data <= fifo_mem[rd_ptr]; end //write data if no full and write enable always @(posedge clk) beginif(wq && !full)fifo_mem[wr_ptr] <= wr_data; end //update read and write ptr always @(posedge clk or negedge rst_n) beginif(!rst_n)beginwr_ptr <= 0;rd_ptr <= 0;endelsebeginif(!full && wq)beginwr_ptr <= wr_ptr + 1;// we can omit these two lines, for it will change to// 0 if overflow.//if(wr_ptr==(FIFO_DEPTH-1))// wr_ptr<=0;endif(!empty && rq)beginrd_ptr <= rd_ptr + 1;//if(rd_ptr==(FIFO_DEPTH-1))// rd_ptr<=0;endend endendmodule
View Code
fifo_sync_tb.v
module fifo_sync_tb;reg clk,rst_n;reg wq,rq;reg [7:0] wr_data; // data input to be pushed to bufferwire [7:0] rd_data; // port to output the data using pop.wire empty,full; // buffer empty and full indicationfifo_sync #(.FIFO_WIDTH(8), .ADDR_WIDTH(3), .FIFO_DEPTH(8)) fifo_inst(.clk(clk),.rst_n(rst_n),.wr_data(wr_data),.rq(rq),.wq(wq),.rd_data(rd_data),.full(full),.empty(empty));always #10 clk = ~clk;reg [7:0] tempdata = 0;initial beginclk = 0;rst_n = 0;wq = 0;rq = 0;wr_data = 0;#15;rst_n = 1;push(1);forkpush(2);pop(tempdata);join //push and pop togetherpush(10);push(20);push(30);push(40);push(50);push(60);push(70);push(80);push(90);push(100);push(110);push(120);push(130);pop(tempdata);push(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);push(140);pop(tempdata);push(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);pop(tempdata);push(5);pop(tempdata);#1000 $finish;endinitialbegin$dumpfile("dump.vcd");$dumpvars;$fsdbDumpfile("dump.fsdb");$fsdbDumpvars("+all");endtask push (input [7:0] data);if(full)$display("---Cannot push %d: Buffer Full---",data);else begin$display("Push",,data);wr_data = data;wq = 1;@(posedge clk);#5 wq = 0;endendtasktask pop(output[7:0] data);if(empty)$display("---Cannot Pop: Buffer Empty---");else beginrq = 1;@(posedge clk);#3 rq = 0;data = rd_data;$display("------Poped:",,data);endendtaskendmodule
View Code
Makefile
# VCS flags, if want to use dump fsdb in verilog file, need to add args -fsdb, otherwise will be compiled fail VCS_FLAGS = -sverilog -full64 -fsdb -debug_all +v2k -timescale=1ns/1ns# Source files SRC_FILES = fifo_sync.v \fifo_sync_tb.v# Source directories INCDIR = +incdir+./all:vcs $(VCS_FLAGS) $(INCDIR) $(SRC_FILES) clean:rm -rf ./csrc *.daidir ./csrc *.log novas.* *.vpd *.vdb simv* *.key *race.out* *vcd *fsdb debug:verdi -sv -ssf dump.fsdb -f verdi.f &
View Code
verdi.f
fifo_sync.v fifo_sync_tb.v
View Code
从波形中可以看出执行结果是正确的。
3.异步FIFO之Verilog实现
FIFO (先进先出队列)是一种在电子系统得到广泛应用的器件,通常用于数据的缓存和用于容纳异步信号的频率或相位的差异。FIFO的实现通常是利用双口RAM和读写地址产生模块来实现的。FIFO的接口信号包括异步的写时钟(wr_clk)和读时钟(rd_clk)、与写时钟同步的写有效(wren)和写数据(wr_data)、与读时钟同步的读有效(rden)和读数据(rd_data)。为了实现正确的读写和避免FIFO的上溢或下溢,通常还应该给出与读时钟和写时钟同步的FIFO的空标志(empty)和满标志(full)以禁止读写操作。
1 异步FIFO功能描述
下图给出了FIFO的接口信号和内部模块图。
由图可以看出,写地址产生模块根据写时钟和写有效信号产生递增的写地址,读地址产生模块根据读时钟和读有效信号产生递增的读地址。FIFO的操作如下:在写时钟wr_clk的上升沿,当wren有效时,将wr_data写入双口RAM中写地址对应的位置中;始终将读地址对应的双口RAM中的数据输出到读数据总线上。这样就实现了先进先出的功能。
这里写图片描述
写地址产生模块还根据读地址和写地址关系产生FIFO的满标志。当wren有效时,若写地址+2=读地址时,full为1;当wren无效时,若写地址+ 1=读地址时,full为1。读地址产生模块还根据读地址和写地址的差产生FIFO的空标志。当rden有效时,若写地址-1=读地址时,empty为 1;当rden无效时,若写地址=读地址时,empty为1。按照以上方式产生标志信号是为了提前一个时钟周期产生对应的标志信号。
由于空标志和满标志控制了FIFO的操作,因此标志错误会引起操作的错误。如上所述,标志的产生是通过对读写地址的比较产生的,当读写时钟完全异步时,对读写地址进行比较时,可能得出错误的结果。例如,在读地址变化过程中,由于读地址的各位变化并不同步,计算读写地址的差值,可能产生错误的差值,导致产生错误的满标志信号。若将未满标志置为满标志时,可能降低了应用的性能,降低写数据速率;而将满置标志置为未满时,执行一次写操作,则可能产生溢出错误,这对于实际应用来说是绝对应该避免的。空标志信号的产生也可能产生类似的错误。
2 异步FIFO的改进设计
从以上分析中可以看出,异步FIFO之所以会发生错误是因为在地址变化时,由于多位地址各位变化时间不同,异步时钟对其进行采样时数值可能为不同于地址变化后数值的其它值,异步产生错误的空标志和满标志,以致于产生FIFO的操作错误。
格雷码是一种在相邻计数值之间只有一位发生变化的编码方式。可以看出,若读写地址采用格雷码编码方式,就可以解决上面的问题。
为了应用的灵活,还增加了两个标志信号,将满(almosf_full)标志和空(almost_empty)标志分别定义如下:当写地址与读地址的距离小于某个预先定义数值时,almost_full为1;当读地址与写地址的距离小于这个预先定义的数值时,almost_empty为1。
格雷码细节:https://www.cnblogs.com/mikewolf2002/
3 异步FIFO的Verilog
…………………………………………………………………………………………………………………………………………………………………………………………………………………………….
异步FIFO的Verilog代码 之一,与之前的用RAM实现的同步FIFO的程序相比,异步更为复杂。增加了读写控制信号的跨时钟域的同步。此外,判空与判满的也稍有不同。满空判断以及格雷码生成的细节在https://www.cnblogs.com/mikewolf2002/
fifo_async.v
module fifomem #(parameter DATASIZE = 8, // Memory data word widthparameter ADDRSIZE = 4 // depth is 2^(ADDRSIZE-1),extra one bit is to judge empty or full ) // Number of mem address bits (output [DATASIZE-1:0] read_data,input [DATASIZE-1:0] write_data,input [ADDRSIZE-1:0] waddr, raddr,input wq, wfull, wclk );localparam DEPTH = 1<<ADDRSIZE; //depth is 2^4 reg [DATASIZE-1:0] mem [0:DEPTH-1]; //fifo mem assign read_data = mem[raddr]; always @(posedge wclk)if (wq && !wfull)mem[waddr] <= write_data; endmodulemodule sync_r2w #(parameter ADDRSIZE = 4 ) (output reg [ADDRSIZE:0] wq2_rptr, //read ptr sync to write clock domaininput [ADDRSIZE:0] rptr, //gray code pointerinput wclk, wrst_n );reg [ADDRSIZE:0] wq1_rptr;always @(posedge wclk or negedge wrst_n)if (!wrst_n) beginwq1_rptr <= 0;wq2_rptr <= 0;endelse beginwq1_rptr<= rptr;wq2_rptr<=wq1_rptr;end endmodulemodule sync_w2r #(parameter ADDRSIZE = 4) (output reg [ADDRSIZE:0] rq2_wptr, //input [ADDRSIZE:0] wptr, //input rclk, rrst_n );reg [ADDRSIZE:0] rq1_wptr;always @(posedge rclk or negedge rrst_n)if (!rrst_n)beginrq1_wptr <= 0;rq2_wptr <= 0;endelse beginrq1_wptr <= wptr;rq2_wptr <= rq1_wptr;endendmodulemodule rptr_empty #(parameter ADDRSIZE = 4 ) (output reg rempty,output [ADDRSIZE-1:0] raddr, //binary ptroutput reg [ADDRSIZE :0] rptr, //gray code ptrinput [ADDRSIZE :0] rq2_wptr, //pointer after syncinput rq, rclk, rrst_n );reg [ADDRSIZE:0] rbin;wire [ADDRSIZE:0] rgraynext, rbinnext;// GRAYSTYLE2 pointer// sync graycode read pointer with binary read pointeralways @(posedge rclk or negedge rrst_n)if (!rrst_n) beginrbin <= 0;rptr <= 0;endelse beginrbin<=rbinnext;rptr<=rgraynext; //output to sync_r2w.vend// Memory read-address pointer (okay to use binary to address memory)assign raddr = rbin[ADDRSIZE-1:0]; //assign rbinnext = rbin + (rq & ~rempty); //not empty and read request, then plus 1assign rgraynext = (rbinnext>>1) ^ rbinnext; //graycode// FIFO empty when the next rptr == synchronized wptr or on resetassign rempty_val = (rgraynext == rq2_wptr); //empty when read graycode equal write prt after syncalways @(posedge rclk or negedge rrst_n)if (!rrst_n)rempty <= 1'b1;elserempty <= rempty_val;endmodule module wptr_full #(parameter ADDRSIZE = 4 ) (output reg wfull,output [ADDRSIZE-1:0] waddr,output reg [ADDRSIZE :0] wptr,input [ADDRSIZE :0] wq2_rptr,input wq, wclk, wrst_n );reg [ADDRSIZE:0] wbin;wire [ADDRSIZE:0] wgraynext, wbinnext;// GRAYSTYLE2 pointeralways @(posedge wclk or negedge wrst_n)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[ADDRSIZE-1:0];assign wbinnext = wbin + (wq & ~wfull);assign wgraynext = (wbinnext>>1) ^ wbinnext; ////-----------------------------------------------------------------//msb not equal msb -1 bit, and other bits are same, then fullassign wfull_val = (wgraynext=={~wq2_rptr[ADDRSIZE:ADDRSIZE-1],wq2_rptr[ADDRSIZE-2:0]});always @(posedge wclk or negedge wrst_n)if (!wrst_n)wfull <= 1'b0;elsewfull <= wfull_val;endmodule module fifo_async #(parameter DSIZE = 8,parameter ASIZE = 4)(input rclk, rrst_n,rq,input wclk, wrst_n,wq,input [DSIZE-1:0] write_data,output [DSIZE-1:0] read_data,output wfull,output rempty);wire [ASIZE-1:0] waddr, raddr;wire [ASIZE:0] wptr, rptr, wq2_rptr, rq2_wptr; // synchronize the read pointer into the write-clock domainsync_r2w sync_r2w(.wq2_rptr (wq2_rptr),.rptr (rptr ),.wclk (wclk ),.wrst_n (wrst_n ));// synchronize the write pointer into the read-clock domainsync_w2r sync_w2r(.rq2_wptr(rq2_wptr),.wptr(wptr),.rclk(rclk),.rrst_n(rrst_n));//this is the FIFO memory buffer that is accessed by both the write and read clock domains. //This buffer is most likely an instantiated, synchronous dual-port RAM. //Other memory styles can be adapted to function as the FIFO buffer.fifomem#(DSIZE, ASIZE)fifomem(.read_data(read_data),.write_data(write_data),.waddr(waddr),.raddr(raddr),.wq(wq),.wfull(wfull),.wclk(wclk));//this module is completely synchronous to the read-clock domain and contains the FIFO read pointer and empty-flag logic.rptr_empty#(ASIZE)rptr_empty(.rempty(rempty),.raddr(raddr),.rptr(rptr),.rq2_wptr(rq2_wptr),.rq(rq),.rclk(rclk),.rrst_n(rrst_n));//this module is completely synchronous to the write-clock domain and contains the FIFO write pointer and full-flag logicwptr_full#(ASIZE)wptr_full(.wfull(wfull),.waddr(waddr),.wptr(wptr),.wq2_rptr(wq2_rptr),.wq(wq),.wclk(wclk),.wrst_n(wrst_n)); endmodule
View Code
fifo_async_tb.v
module fifo_async_tb; reg wclk,wrst_n; reg rclk,rrst_n; reg wq,rq; reg [7:0] write_data; // data input to be pushed to buffer wire [7:0] read_data; // port to output the data using pop. wire rempty,wfull; // buffer empty and full indicationfifo_async #(.DSIZE(8), .ASIZE(4)) fifo_inst(.rclk(rclk),.rrst_n(rrst_n),.rq(rq),.wclk(wclk),.wrst_n(wrst_n),.wq(wq),.write_data(write_data),.read_data(read_data),.wfull(wfull),.rempty(rempty));always #10 wclk = ~wclk; always #20 rclk = ~rclk;reg [7:0] tempdata = 0;initial beginrclk = 0;wclk = 0;#5000 $finish;endinitial beginwrst_n = 1;#2;wrst_n = 0;#60;wrst_n = 1;endinitial beginrrst_n = 1;#2;rrst_n = 0;#120;rrst_n = 1;endalways @(posedge wclk or negedge wrst_n)beginif(wrst_n==1'b0)beginwq <= 0;rq <= 0;endelse beginwq <= $random;endendalways @(posedge rclk or negedge rrst_n)if(rrst_n==1'b0)rq <= 0;elserq <= $random;always@(*)if(wq == 1)beginwrite_data= $random ;endelsewrite_data = 0;always @(write_data,read_data)begin$monitor($time, "write data:%d, read data:%d",write_data,read_data);endinitialbegin//$dumpfile("dump.vcd");//$dumpvars;$fsdbDumpfile("dump.fsdb");$fsdbDumpvars("+all");endendmodule
View Code
Makefile
# VCS flags, if want to use dump fsdb in verilog file, need to add args -fsdb, otherwise will be compiled fail VCS_FLAGS = -sverilog -full64 -fsdb -debug_all +v2k -timescale=1ns/1ns# Source files SRC_FILES = fifo_async.v \fifo_async_tb.v# Source directories INCDIR = +incdir+./all:vcs $(VCS_FLAGS) $(INCDIR) $(SRC_FILES) clean:rm -rf ./csrc *.daidir ./csrc novas.* *.log *.vpd *.vdb simv* *.key *race.out* *vcd *fsdb debug:verdi -sv -ssf dump.fsdb -f verdi.f &
View Code
verdi.f
fifo_async.v fifo_async_tb.v
View Code
下面的fifo_async.v中,所有的代码在一个module中,接口和功能和前面一样。
module fifo_async #( parameter DSIZE = 8, parameter ASIZE = 4 ) (input wclk,wrst_n,rclk,rrst_n,rq,wq,input [DSIZE-1:0] write_data,output [DSIZE-1:0] read_data,output 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<<ASIZE)-1]; wire [ASIZE-1:0] waddr, raddr; wire [ASIZE:0] rgraynext, rbinnext,wgraynext,wbinnext; wire rempty_val,wfull_val; //double port ram assign read_data=mem[raddr]; always@(posedge wclk)if (wq && !wfull) mem[waddr] <= write_data; //rprt sync to write clock domain always @(posedge wclk or negedge wrst_n)if (!wrst_n) {wq2_rptr,wq1_rptr} <= 0;else {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr}; //wptr sync to read clock domain always @(posedge rclk or negedge rrst_n)if (!rrst_n) {rq2_wptr,rq1_wptr} <= 0;else {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr}; //rempty and rptr generate always @(posedge rclk or negedge rrst_n) // GRAYSTYLE2 pointer beginif (!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 + (rq & ~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) beginif (!rrst_n) rempty <= 1'b1;else rempty <= rempty_val; end //---------------wfull and wprt generate always @(posedge wclk or negedge wrst_n) // GRAYSTYLE2 pointerif (!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 + (wq & ~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
View Code
异步FIFO的Verilog代码 之二
与前一段异步FIFO代码的主要区别在于,空/满状态标志的不同算法。
第一个算法:Clifford E. Cummings的文章中提到的STYLE #1,构造一个指针宽度为N+1,深度为2^N字节的FIFO(为便方比较将格雷码指针转换为二进制指针)。当指针的二进制码中最高位不一致而其它N位都 相等时,FIFO为满(在Clifford E. Cummings的文章中以格雷码表示是前两位均不相同,而后两位LSB相同为满,这与换成二进制表示的MSB不同其他相同为满是一样的)。当指针完全相 等时,FIFO为空。
这种方法思路非常明了,为了比较不同时钟产生的指针,需要把不同时钟域的信号同步到本时钟域中来,而使用Gray码的目的就是使这个异步同步化的过 程发生亚稳态的机率最小,而为什么要构造一个N+1的指针,Clifford E. Cummings也阐述的很明白,有兴趣的读者可以看下作者原文是怎么论述的,Clifford E. Cummings的这篇文章有Rev1.1 \ Rev1.2两个版本,两者在比较Gray码指针时的方法略有不同,个Rev1.2版更为精简。
第二种算法:Clifford E. Cummings的文章中提到的STYLE #2。它将FIFO地址分成了4部分,每部分分别用高两位的MSB 00 、01、 11、 10决定FIFO是否为going full 或going empty (即将满或空)。如果写指针的高两位MSB小于读指针的高两位MSB则FIFO为“几乎满”,若写指针的高两位MSB大于读指针的高两位MSB则FIFO 为“几乎空”。
它是利用将地址空间分成4个象限(也就是四个等大小的区域),然后观察两个指针的相对位置,如果写指针落后读指针一个象限(25%的距离,呵呵), 则证明很可能要写满,反之则很可能要读空,这个时候分别设置两个标志位dirset和dirrst,然后在地址完全相等的情况下,如果dirset有效就 是写满,如果dirrst有效就是读空。
这种方法对深度为2^N字节的FIFO只需N位的指针即可,处理的速度也较第一种方法快。
这段是说明的原话,算法一,还好理解。算法二,似乎没有说清楚,不太明白。有兴趣的可以查查论文,详细研究下。
总之,第二种写法是推荐的写法。因为异步的多时钟设计应按以下几个原则进行设计:
1,尽可能的将多时钟的逻辑电路(非同步器)分割为多个单时钟的模块,这样有利于静态时序分析工具来进行时序验证。
2,同步器的实现应使得所有输入来自同一个时钟域,而使用另一个时钟域的异步时钟信号采样数据。
3,面向时钟信号的命名方式可以帮助我们确定那些在不同异步时钟域间需要处理的信号。
4,当存在多个跨时钟域的控制信号时,我们必须特别注意这些信号,保证这些控制信号到达新的时钟域仍然能够保持正确的顺序。
第二种异步fifo实现方式代码如下,testbench文件和Makefile文件和前面的第一种方法相同。
fifo_async.v
module fifo_async (read_data, wfull, rempty, write_data,wq, wclk, wrst_n, rq, rclk, rrst_n); parameter DSIZE = 8; parameter ASIZE = 4; output [DSIZE-1:0] read_data; output wfull; output rempty; input [DSIZE-1:0] write_data; input wq, wclk, wrst_n; input rq, 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(.read_data(read_data),.write_data(write_data),.waddr(wptr),.raddr(rptr),.wq(wq),.wclk(wclk)); rptr_empty2 #(ASIZE) rptr_empty2(.rempty(rempty),.rptr(rptr),.aempty_n(aempty_n),.rq(rq),.rclk(rclk),.rrst_n(rrst_n)); wptr_full2 #(ASIZE) wptr_full2(.wfull(wfull),.wptr(wptr),.afull_n(afull_n),.wq(wq),.wclk(wclk),.wrst_n(wrst_n)); endmodulemodule fifomem2 #(parameter DATASIZE = 8, // Memory data word widthparameter ADDRSIZE = 4 // depth is 2^(ADDRSIZE-1),extra one bit is to judge empty or full ) // Number of mem address bits (output [DATASIZE-1:0] read_data,input [DATASIZE-1:0] write_data,input [ADDRSIZE-1:0] waddr, raddr,input wq, wclk );localparam DEPTH = 1<<ADDRSIZE; // DEPTH = 2**ADDRSIZEreg [DATASIZE-1:0] MEM [0:DEPTH-1];assign read_data = MEM[raddr];always @(posedge wclk)if (wq)MEM[waddr] <= write_data; endmodulemodule async_cmp #(parameter ADDRSIZE = 4 // depth is 2^(ADDRSIZE-1),extra one bit is to judge empty or full ) (input [ADDRSIZE-1:0] wptr, rptr,input wrst_n,output aempty_n, afull_n );localparam N = ADDRSIZE-1; //internal signals 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;elsedirection <= high; assign aempty_n = ~((wptr == rptr) && !direction); assign afull_n = ~((wptr == rptr) && direction);endmodulemodule rptr_empty2 #(parameter ADDRSIZE = 4 // depth is 2^(ADDRSIZE-1),extra one bit is to judge empty or full ) (input aempty_n,input rq,rclk,rrst_n,output reg rempty,output reg [ADDRSIZE-1:0] rptr ); reg [ADDRSIZE-1:0] rbin; reg rempty2; wire [ADDRSIZE-1:0] rgnext, rbnext; //--------------------------------------------------------------- // GRAYSTYLE2 pointer //--------------------------------------------------------------- always @(posedge rclk or negedge rrst_n)if (!rrst_n)beginrbin <= 0;rptr <= 0;endelsebeginrbin <= rbnext;rptr <= rgnext;end//---------------------------------------------------------------// increment the binary count if not empty//--------------------------------------------------------------- assign rbnext = !rempty ? rbin + rq : 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}; endmodulemodule wptr_full2 #(parameter ADDRSIZE = 4 // depth is 2^(ADDRSIZE-1),extra one bit is to judge empty or full ) (input afull_n, wq, wclk,wrst_n,output reg wfull,output reg [ADDRSIZE-1:0] wptr );reg [ADDRSIZE-1:0] wbin; reg wfull2; wire [ADDRSIZE-1:0] wgnext, wbnext; //--------------------------------------------------------------- // GRAYSTYLE2 pointer //--------------------------------------------------------------- always @(posedge wclk or negedge wrst_n)if (!wrst_n) beginwbin <= 0;wptr <= 0;endelse beginwbin <= wbnext;wptr <= wgnext;end//---------------------------------------------------------------// increment the binary count if not full assign wbnext = !wfull ? wbin + wq : 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
View Code
转载于:https://www.cnblogs.com/mikewolf2002/p/10945488.html
同步fifo与异步fifo相关推荐
- 7 centos 时钟跟物理机同步_同步FIFO和异步FIFO
1.定义 FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出 ...
- (87)FPGA面试题-同步FIFO与异步FIFO区别?异步FIFO代码设计
1.1 FPGA面试题-同步FIFO与异步FIFO区别?异步FIFO代码设计 1.1.1 本节目录 1)本节目录: 2)本节引言: 3)FPGA简介: 4)FPGA面试题-同步FIFO与异步FIFO区 ...
- 同步FIFO和异步FIFO的Verilog实现
FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其 ...
- 同步FIFO和异步FIFO
1.定义 FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出 ...
- IC设计 — 同步FIFO和异步FIFO设计实现(一)
文章目录 1. FIFO介绍 1.1 FIFO参数 1.2 full/empty 检测 1.3 同步FIFO和异步FIFO 2. FIFO设计 2.1 二进制和格雷码 2.2 同步FIFO 2.3 异 ...
- 同步FIFO和异步FIFO总结
文章目录 1. FIFO简介 2. 使用场景 3. 分类 4. FIFO的常见参数 5. FIFO设计 5.1 空满标志生成 5.2 异步FIFO的设计还要注意跨时钟域问题 5.3 gray码如何判断 ...
- 【FPGA——基础篇】同步FIFO与异步FIFO——Verilog实现
FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其 ...
- 数字IC设计系列----单端口RAM、双端口RAM、同步FIFO、异步FIFO
目录 一.单端口RAM原理及实现 1.1.原理 1.2.Verilog实现 1.3.优缺点分析 2.双端口RAM原理及实现 2.1.原理 2.2.Verilog实现 2.3.优缺点分析 ...
- 【FIFO】异步 FIFO 设计
目录 写在前面 简介 传递多个异步信号 同步 FIFO 指针 异步FIFO指针 二进制 FIFO 指针注意事项 FIFO测试问题 格雷码计数器 ‑ 样式 #1 格雷码模式 格雷码计数器基础 额外的格雷 ...
最新文章
- 成为多编程语言人才的诀窍你想知道吗
- 【机器学习】通俗的k-近邻算法算法解析和应用
- (二十六)、Java数组在内存中如何存放与分配
- 不就是发个短信吗?这你都会?
- vs2010 asp.net mysql,安装VS2010后,更改iis的asp.net版本 | 吴小强的博客
- 文献读的越多,离原创越远
- .net去除html标签代码
- SelectedNode与e.node的区别
- python对ip地址排序、对列表进行去重
- 【动态规划】P1004 方格取数(四维dp模板题)
- [Leetcode] Climbing Stairs
- Spring Boot 整合监听器
- liunx中常用命令 -大数据
- 威纶通触摸屏离线模拟正常,为什么下载到屏幕后部分按钮开关等不显示?
- Tabular Editor学习笔记_1
- 实现上一篇明日方舟官网仿制的代码
- 电压源和电流的关联参考方向_电压电流为关联参考方向.PPT
- Gateway之过滤器
- ubuntu php开发工具
- 北大计算机系女神每天必看必学的IT公众号
热门文章
- Qt - QTChart绘制图表
- 幼儿体能五项技能测试软件,卓艺湖畔幼儿园教师五项体能培训--器械游戏分享...
- 面对互联网裁员潮,我们该怎么提升自己核心知识能力
- HTML5 canvas 行星环绕
- 生产级搭建openresty+waf防火墙
- 如何合并磁盘分区 windows7调整分区大小方法
- 【报告分享】 2020年汽车产销数据及汽车工业运行情况-中国汽车工业协会(附下载)
- The following tasks did not complete: first,Did you forget to signal async completion?问题
- HDMI、AV音视频端子介绍
- 浅析人工智能体系建设