以异步fifo为例使用vcs进行仿真（一）：建立asyn_fifo仿真工程

最新推荐文章于 2023-05-17 16:18:40 发布
最新推荐文章于 2023-05-17 16:18:40 发布
阅读量748 收藏 4
点赞数 1
文章标签： verilog fpga
原文链接：https://blog.csdn.net/alangaixiaoxiao/article/details/81432144
版权

fifo具体理论可以参考https://blog.csdn.net/alangaixiaoxiao/article/details/81432144

主要点：

  1. 时钟之间通过打两拍进行同步，减小亚稳态的概率（不一定逻辑是正确的）
  2. 地址采用格雷码。因为二进制可能同时有多位进行变化，相对于每次只发生一位变化的格雷码易发生亚稳态。

                                                                     异步FIFO结构图

知识延伸：

  1. 亚稳态：亚稳态是指触发器无法在 某个规定的时间段 内达到可以确认的状态。一旦触发器进入亚稳态，则既无法预测触发器的输出电平，也无法预测什么时候稳定在某个确认的电平上。此时的触发器输出端Q在较长时间内处于震荡状态且不等于输入端D，并且这种无用的输出电平可以沿信号通道上的各个触发器级联式传播下去。在同步系统中，输入信号总是与系统时钟同步，能够达到寄存器的时序要求，所以亚稳态不会发生。亚稳态通常发生在跨时钟域信号传输以及异步信号采集上。
  2. 格雷码和独热码： 二进制编码、格雷码编码使用最少的触发器，消耗较多的组合逻辑，而独热码编码反之。独热码编码的最大优势在于状态比较时仅仅需要比较一个位，从而一定程度上简化了译码逻辑。虽然在需要表示同样的状态数时，独热编码占用较多的位，也就是消耗较多的触发器，但这些额外触发器占用的面积可与译码电路省下来的面积相抵消。

FIFO代码如下：

       RAM 模块

module Ram # (
	parameter	DATA_WIDTH = 4,
	parameter	ADDR_WIDTH = 8
)
(
	input			[ADDR_WIDTH-1:0]    wr_addr,
	input			[ADDR_WIDTH-1:0]    rd_addr,
    input                               arst_n,
    input                               wr_clk,
    input				           		rd_clk,
    input	        [DATA_WIDTH-1:0]	wr_data,
	output	reg     [DATA_WIDTH-1:0]	rd_data
);
    
    localparam  DEPTH = 1 << ADDR_WIDTH;
    
    //建立memory
    reg     [DATA_WIDTH-1:0]    Ram_mem     [0:DEPTH-1];
    integer i;

    //初始化memory，并在写时钟读对应地址的数据
    always@(posedge wr_clk or negedge arst_n)  begin
        if(!arst_n) begin
            for(i = 0;i < DEPTH;i = i + 1)
                Ram_mem[i] <= 8'b0;
        end
        else 
        	Ram_mem[wr_addr] <= wr_data;
    end
    
    //在读时钟域读取数据（可以写成组合逻辑，看个人习惯）
    always@(posedge rd_clk or negedge arst_n) begin
    	if(!arst_n) begin
    		rd_data <= 0;
    	end
    	else
    		rd_data <= Ram_mem[rd_addr];
    end
endmodule

地址在异步时钟域同步模块 

module syn_r2w #(
	parameter	ADDR_WIDTH = 8
	)
(
	input	     [ADDR_WIDTH:0]	rptr,
	input			       		wclk,
	input		    			arst_n,
	output	reg [ADDR_WIDTH:0]  ptr_r2w
	);
	
	reg		[ADDR_WIDTH:0]	pad_rptr;

    //打两排实现地址在时钟域上的同步，降低亚稳态概率
	always @(posedge wclk or negedge arst_n) begin
		if (!arst_n) begin
			{ptr_r2w,pad_rptr} <= 0;
		end
		else begin
		     {ptr_r2w,pad_rptr} <= {pad_rptr,rptr};
		end
	end


endmodule
module syn_w2r #(
	parameter	ADDR_WIDTH = 8
	)
(
	input	        [ADDR_WIDTH:0]	wptr,
	input				          	rclk,
	input			           		arst_n,
	output	reg     [ADDR_WIDTH:0]  ptr_w2r
	);
	
	reg		[ADDR_WIDTH:0]	pad_wptr;

	always @(posedge rclk or negedge arst_n) begin
		if (!arst_n) begin
			{ptr_w2r,pad_wptr} <= 0;
		end
		else begin
			{ptr_w2r,pad_wptr} <= {pad_wptr,wptr};
		end
	end


endmodule

读时钟域判空模块

module rptr_empty #(
	parameter	ADDR_WIDTH = 8
	)
(
	output		reg							rempty,
	output		    	[ADDR_WIDTH-1:0]	raddr,//写到RAM的二进制地址
	output		reg		[ADDR_WIDTH:0]		rptr,//输入到写时钟域的格雷码地址
	input  				[ADDR_WIDTH:0]		ptr_w2r,//同步到读时钟域的写格雷码地址
	input									rinc,//读使能
	input									rclk,
	input									arst_n
	);
	
	reg		[ADDR_WIDTH:0]		rbin;
	wire	[ADDR_WIDTH:0]		rgaynext,rbinnext;
	wire	                    rempty_val;

    //时序逻辑二进制和格雷码地址，负责初始化和时序逻辑
	always @(posedge rclk or negedge arst_n) begin
		if (!arst_n) begin
			rbin <= 0;
			rptr <= 0;
		end
		else begin
			rbin <= rbinnext;
			rptr <= rgaynext;
		end
	end

    //根据使能信号判断是否对读地址加一
	assign rbinnext  = !arst_n ? 0: 
							!rinc? rbin : 
								rempty ? rbin : 
											(rbin+1);
    //格雷码地址转换
	assign rgaynext = !arst_n ? 0 : 
						(rbinnext>>1)^(rbinnext);
    //给RAM的实际地址
	assign raddr = rbin[ADDR_WIDTH-1:0];

	//判空逻辑
	assign rempty_val = !arst_n ? 1:
							(rgaynext == ptr_w2r);

    //时序逻辑完成同步
	always @(posedge rclk or negedge arst_n) begin
		if (!arst_n) begin
			rempty <= 1'b1;
		end
		else begin
			rempty <= rempty_val;
		end
	end



endmodule

写时钟判满模块 

module wptr_full #(
	parameter	ADDR_WIDTH = 8
	)
(
	output	reg							wfull,
	output	     	[ADDR_WIDTH-1:0]	waddr,
	output	reg		[ADDR_WIDTH:0]		wptr,
	input			[ADDR_WIDTH:0]		ptr_r2w,
	input								winc,//写使胿
	input								wclk,
	input								arst_n						
	);
	
	reg		[ADDR_WIDTH:0]		wbin;
	wire		[ADDR_WIDTH:0]		wgraynext,wbinnext,r2w_graytmp;
	wire	wfull_eval;

	always @(posedge wclk or negedge arst_n) begin
		if (!arst_n) begin
			wbin <= 0;
			wptr <= 0;
		end
		else begin
			wbin <= wbinnext;
			wptr <= wgraynext;
		end
	end

	assign wbinnext = !arst_n ? 0 :
								!winc ? wbin : 
										( wfull ? wbin : 
													( wbin+1 ) );
	assign wgraynext = !arst_n ? 0:
							(wbinnext >> 1)^(wbinnext);
	assign waddr = wbin[ADDR_WIDTH-1:0];
	
	assign r2w_graytmp = !arst_n ? 0:
	                   {~ptr_r2w[ADDR_WIDTH:ADDR_WIDTH-1],ptr_r2w[ADDR_WIDTH-2:0]};

	assign wfull_eval = !arst_n ? 0:
						( wgraynext == r2w_graytmp );

	always @(posedge wclk or negedge arst_n) begin
		if (!arst_n) begin
			wfull <= 1'b1;
		end
		else begin
			wfull <= wfull_eval;
		end
	end


endmodule

FIFO顶层模块

module asyn_fifo #(
		parameter	ADDR_WIDTH = 4,
		parameter	DATA_WIDTH = 2
	)
(
	input								arst_n,
	input			[DATA_WIDTH-1:0]	wdata,
	input								winc,
	input								wclk,
	output			[DATA_WIDTH-1:0]	rdata,
	input								rinc,
	input								rclk,
	output								rempty,
	output								wfull,
	//接出两个接口看信息
	output			[ADDR_WIDTH-1:0]	waddr,
	output			[ADDR_WIDTH-1:0]	raddr
	);


	wire	[ADDR_WIDTH-1:0]	waddr,raddr;
	wire	[ADDR_WIDTH:0]	wptr,rptr,ptr_r2w,ptr_w2r;

	syn_r2w #(
	.ADDR_WIDTH(ADDR_WIDTH)
	)
	fifo_syn_r2w(
	.rptr(rptr),
	.wclk(wclk),
	.arst_n(arst_n),
	.ptr_r2w(ptr_r2w)
	);

	syn_w2r #(
	.ADDR_WIDTH(ADDR_WIDTH)
	)
	fifo_syn_w2r(
	.wptr(wptr),
	.rclk(rclk),
	.arst_n(arst_n),
	.ptr_w2r(ptr_w2r)
	);

	Ram # (
	.DATA_WIDTH(DATA_WIDTH),
	.ADDR_WIDTH(ADDR_WIDTH)
	)
	fifo_Ram(
	    .wr_addr(waddr),
	    .rd_addr(raddr),
        .arst_n(arst_n),
        .wr_clk(wclk),
        .rd_clk(rclk),
        .wr_data(wdata),
	    .rd_data(rdata)
	);

 	rptr_empty #(
	.ADDR_WIDTH(ADDR_WIDTH)
	)
	fifo_rptr_empty(
	.rempty(rempty),
	.raddr(raddr),//写到RAM的二进制地址
	.rptr(rptr),//写到读时钟域的格雷码地址
	.ptr_w2r(ptr_w2r),//读时钟域的写格雷码地坿
	.rinc(rinc),//写使胿
	.rclk(rclk),
	.arst_n(arst_n)
	);

	wptr_full #(
	.ADDR_WIDTH(ADDR_WIDTH)
	)
	fifo_wptr_full(
	.wfull(wfull),
	.waddr(waddr),
	.wptr(wptr),
	.ptr_r2w(ptr_r2w),
	.winc(winc),//写使胿
	.wclk(wclk),
	.arst_n(arst_n)						
	);

endmodule

testbench

`timescale 1ns / 1ps


module tb_asyn_fifo;

	parameter	ADDR_WIDTH = 4;
	parameter	DATA_WIDTH = 2;
	
	localparam	DEPTH = 1 << ADDR_WIDTH;

	reg 						tb_arst_n,tb_wclk,tb_rclk,tb_winc,tb_rinc;
	reg		[DATA_WIDTH-1:0]	tb_wdata;
	wire						tb_rempty,tb_wfull;
	wire	[DATA_WIDTH-1:0]	tb_rdata;
	wire	[ADDR_WIDTH-1:0]	tb_waddr,tb_raddr;
	
	initial begin
		tb_arst_n = 0;tb_wclk = 0;tb_rclk = 0;tb_wdata = 0;
		tb_winc = 0;tb_rinc = 0;
        #11
		tb_arst_n = 1;
		#500
		tb_arst_n = 0;
	end

//    initial begin
//        $vcdpluson;
//    end
	
	initial begin
		#21
		read_data();
	end
	
	initial begin
	   #41
		write_data();
	end
	
	always #2 tb_wclk = ~tb_wclk;
	always #5 tb_rclk = ~tb_rclk;


asyn_fifo #(
	.ADDR_WIDTH(ADDR_WIDTH),
	.DATA_WIDTH(DATA_WIDTH)
	)
 uut_asyn_fifo(
	.arst_n(tb_arst_n),
	.wdata(tb_wdata),
	.winc(tb_winc),
	.wclk(tb_wclk),
	.rdata(tb_rdata),
	.rinc(tb_rinc),
	.rclk(tb_rclk),
	.rempty(tb_rempty),
	.wfull(tb_wfull),
	.waddr(tb_waddr),
	.raddr(tb_raddr)
	);

task write_data;
	begin
		forever begin
			@(posedge tb_wclk) begin
				tb_winc <= 1;
				tb_wdata <= ($random)%4;
			end
		end
	end
endtask

task read_data;
	begin
		forever begin
			@(posedge tb_rclk) begin
				tb_rinc <= 1;
			end
		end
	end
endtask
endmodule

仿真结果： 

 

feifan1996
关注
(3)异步FIFO设计及仿真验证(中)
CAUC_learner的博客
01-19 732
RTL设计可以边写边完善自己的思路，然后一点点修改，循序渐进
以异步fifo为例使用vcs进行仿真（二）：使用vcs对异步fifo进行仿真
feifan1996的博客
03-27 1294
对vcs需要掌握的东西： 一、使用vcs做仿真 二、使用vcs进行debug 三、使用dve进行debug 四、使用vcd+file进行后仿 五、检测仿真不匹配 六、快速RTL级仿真 七、快速门级仿真 八、代码覆盖率 一、使用vcs做仿真 ...
asyn_fifo
weixin_30377461的博客
02-01 127
1 //Module Name:afifo_ctrl 2 //Description:parameterized afifo 3 4 module afifo_ctrl( 5 clk_push, 6 rst_push_n, 7 clk_pop, 8 rst_pop_n, 9 push, 10 push_data,...
异步FIFO的UVM验证（VCS+Verdi 附源代码）
Future Chaser的博客
05-17 9663
异步FIFO的UVM 验证环境，详细介绍，结合波形，更好理解异步fifo的工作过程。 VCS+verdi Makefile 附代码，包含覆盖率收集 目录1.DUT 设计2.UVM 验证2.1 环境搭建2.2 功能仿真测试2.2.x 写满及读空 异常测试 2.2.x1 带有复位的读写测试 1.DUT 设计 本设计框图如下，经典asyn_fifo 2.UVM 验证 结合波形，更好理解异步fifo的读写过程！初入门的野路子verifier，不规范的地方请指正。也不知是否正确完整。
async_fifo学习
qq_45926544的博客
12-24 485
async_fifo学习
异步FIFO
qq_43053845的博客
08-17 323
异步FIFO(Asynchronous First In First Out) 1. 前言 ​ 由于EDA工具的广泛支持，采用同步电路设计的方法是目前Soc设计的基本要求，但在一个功能复杂的Soc系统中，难免会有异步信号与同步电路交互的问题。特别是在由许多核组成的Soc中，通常采用全局异步局部同步(GALS)的设计。而跨时钟域传输数据时很容易造成亚稳态的现象，本文主要讲解Asyn_FIFO来解决跨时钟域传输多bit信号的问题。 2. Asyn_FIFO的结构与原理 Asyn_FIFO: 写数据wdata在写
FIFO.rar_FIFO时序仿真_VHDL语言fifo_fifo vhdl_异步FIFO_异步fifo VHDL
09-19
在本项目中，我们探讨的是如何使用VHDL语言实现一个异步FIFO，并进行时序和功能仿真的验证。VHDL是一种硬件描述语言，广泛用于数字逻辑的设计和验证。 首先，理解异步FIFO的关键在于其接口是与主时钟域和从时钟域...
Asyn_FIFO_Design.rar_Asyn_FIFO_Design_fifo_fifo source code_vhdl
07-15
文件"Asyn_FIFO_Design_1.pdf"和"Asyn_FIFO_Design_2.pdf"很可能包含设计原理、设计步骤、注意事项以及可能的优化技术。这些文档可能详细讨论了如何处理时钟同步、数据对齐、空满判断以及如何避免数据丢失等问题。 ...
fifo.rar_fifo vhdl_fifo仿真_vhdl fifo异步_异步fifo VHDL
09-19
在这个“fifo.rar_fifo vhdl_fifo仿真_vhdl fifo异步_异步fifo VHDL”压缩包中，包含的是一个关于异步FIFO的VHDL实现和仿真项目。 首先，我们来理解一下异步FIFO的基本概念。异步FIFO是指读写端口的工作时钟可能...
asyn_fifo.zip_asynchronous_fifo_tent7ei_异步FIFO_数据 异步
07-15
自定义异步FIFO设计，用于数字ic及fpga设计中的数据缓存
asyn_syn_fifo.pdf
07-23
verilog语言中易犯的错误，自己写的异步fifo的源代码，同步fifo的源代码。数字ic设计流程，低功耗技术，MOS管，FPGA中LUT的原理等等
一个Verilog的FIFO存储器代码
02-26
这是一个FIFO得存储器代码，里面可以去除前端代码的一些不需要的数据
async_fifo实现与注意要点
Fortune77的博客
09-16 645
异步fifo的设计要点以及设计代码
使用Synopsys VCS仿真Vivado FIFO IP
u010170039的博客
03-11 4395
使用VCS仿真xilinx IP出现VHDL syntactic or semantic error/warnings
异步FIFO（Asyn FIFO）学习笔记
AD7533的博客
11-03 460
设计思路 w_clk与r_clk不同步，跨时钟域 需要模块： 1、读控制 2、写控制 3、双口RAM 4、Bin2Gray（跨时钟域---亚稳态---需要使用格雷码---减少亚稳态的概率） 5、SYN同步（将w_addr送到读控制模块----比较地址差判断空满，需要r_clk对w_addr同步） （将r_addr送到写控制模块----比较地址差判断空满，需要w_clk对r_addr同步） 简单来说两级同步就是打两拍、用于跨时钟域设计 采样情况 只有1bit发...
可综合的异步FIFO的设计与仿真
啦啦啦啦啦
10-23 2162
可综合的异步FIFO的设计与仿真综述FIFO（First in First out），经常用来对跨时钟域多bit数据的同步处理。常用的有同步FIFO与异步FIFO，本文主要处理异步FIFO的问题。首先，试图将多个变化的信号从一个时钟域同步到一个新的时钟域，并确保所有变化的信号都同步到新时钟域的同一个时钟周期，已经被证明是有问题的，在CDC部分中已经进行了说明，后续也会进一步的解释。这也是为什么引入格雷码来做数据同步的原因。在FIFO设计中判断FIFO的空满状态，是一个关键性的问题。
async_fifo深度计算
qq_45926544的博客
12-27 629
1.吞吐量知识补充 吞吐量是指对网络、设备、端口、虚电路或其他设施，单位时间内成功地传送数据的数量（以比特、字节、分组等测量）。 吞吐量的英文单词是“throughput”，也很形象，就是“穿越流量”，单位为bit/s，如果有一个入接口每秒收到1M bit 流量，这1M bit 流量又从其它出接口流走，那么吞吐量 = 1M bit/s。 单位时间内接收的所有数据的速率之和。 单位时间数据的写入或者读出量 总数据量/吞吐量=下载时间 数字带宽：理想带宽 吞吐量：用户体...
VCS仿真命令详解 1
最新发布
heiguang2005的专栏
05-17 5146
可以在任何模块或文件中指定的模块上的指定信号上进行过滤。2禁用在celldefine编译器指令定义的所有模块中或在用-v或-y编译时选项指定的库中定义的所有模块中记录网络和寄存器的转换时间以及网络和寄存器的值，无论这些库中的模块是否在`celldefine编译器指令是否存在。-cm_hier ：在为行，条件，FSM或翻转覆盖率进行编译时，指定一个配置文件，该文件指定模块定义，源文件或模块实例及其子层次结构，您希望VCS从覆盖范围中排除它，或者将其作为为覆盖而编译的设计的唯一部分。
VCS仿真与调试
热门推荐
Holden_Liu的博客
02-09 3万+
-cc指定C编译器，默认使用
FPGA工程实践：异步FIFO设计与仿真
资源摘要信息:"本资源提供了一个使用Verilog语言在Xilinx Vivado环境下编写的异步FIFO（First-In-First-Out）工程代码。异步FIFO主要用于解决不同时钟域之间数据传输的问题，它是FPGA设计中常用的一种缓存机制，尤其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值