异步fifo设计及验证verilog代码

已于 2022-09-03 13:34:14 修改
阅读量358 收藏 3
点赞数
分类专栏： system verilog 文章标签： fpga开发
于 2022-09-02 22:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41583914/article/details/126671279
版权

论文参考：The Design and Verification of a Synchronous First-In First-Out

博客参考：【原创】异步FIFO设计原理详解 (含RTL代码和Testbench代码)_锤王马加爵的博客-CSDN博客_fifo testbenchFIFO在硬件上是一种地址依次自增的Single Dul RAM，按读数据和写数据工作的时钟域是否相同分为同步FIFO和异步FIFO，其中同步FIFO是指读时钟和写时钟为同步时钟，常用于数据缓存和数据位宽转换；异步FIFO通常情况下是指读时钟和写时钟频率有差异，即由两个异步时钟驱动的FIFO，由于读写操作是独立的，故常用于多比特数据跨时钟域处理。本文仅讨论异步FIFO的设计。 因为FIFO的硬件本质是一块Single Dul RAM，无论它的内部结构和原理如何复杂，最核心的...https://blog.csdn.net/qq_40807206/article/details/109555162

代码中省略了转为格雷码的步骤，读者可自行添加。 

1.write_control.v

//FIFO parameters
`define FIFO_DEPTH 64
`define FIFO_MEM_ADDR_WIDTH 6
`define FIFO_HALFFULL 4

module write_control (
    input reset,
    input clk_write_logic,
    input wire [`FIFO_MEM_ADDR_WIDTH:0] read_pointer,
    input write_request,
    output reg w_enable,
    output reg write_ack,
    output reg [`FIFO_MEM_ADDR_WIDTH:0] write_pointer,
    output reg full_fifo_status,
    output reg halffull_fifo_status,
    input wire wc_scan_in0,// test scan mode data input
    // wc_scan_en, // test scan mode enable
    // wc_test_mode, // test mode select
    // output wc_scan_out0, // test scan mode data,
    output wire [`FIFO_MEM_ADDR_WIDTH-1:0] mem_addr_read,
    output reg [`FIFO_MEM_ADDR_WIDTH:0] rd_ff1,            // 读地址同步寄存器1
    output reg [`FIFO_MEM_ADDR_WIDTH:0] rd_ff2,            // 读地址同步寄存器2
    input reg init_done
    );

    wire [`FIFO_MEM_ADDR_WIDTH-1:0] mem_addr_write;

    assign mem_addr_read = read_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];
    assign mem_addr_write = write_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];
    
    //full_fifo_status = (111 111=63) && (1)，这是写满？出现(read_pointer=7'h66 write_pointer=7'h3f)、(7'h28 7'h7f)等为写满的情况
    //assign full_fifo_status = ((mem_addr_write == `FIFO_DEPTH - 1) && (read_pointer[`FIFO_MEM_ADDR_WIDTH] ^ write_pointer[`FIFO_MEM_ADDR_WIDTH]));
    


    // 读地址同步至写时钟域
    always @(posedge clk_write_logic or posedge reset) begin
        if(!reset) begin
            rd_ff1 <= 'b0;
            rd_ff2 <= 'b0;
        end
        else begin
            rd_ff1 <= read_pointer;
            rd_ff2 <= rd_ff1;
        end
    end

    //写使能判断
    // assign w_enable = (write_request && (full_fifo_status==0))?1:0;
    always @(*) begin
        // 写数据
        if(init_done) begin
            if(write_request == 1'b1 && full_fifo_status == 1'b0)begin
                w_enable = 1;
            end
            else begin
                w_enable = 0;
            end
        end
    end

    // 写地址自加一
    always@(posedge clk_write_logic or posedge reset) begin
        if(!reset) begin
            write_pointer <= 0;
            write_ack <= 0;
        end
        else begin
            //将满也不是64-mem_addr_write[5:0]，应该是本地写指针减去同步过来的读指针
            //halffull_fifo_status = ((`FIFO_DEPTH - mem_addr_write)<=(`FIFO_HALFFULL))?1:0;//逻辑小于等于
            // $display("halffull_fifo_status=%b",halffull_fifo_status);
            if(w_enable==1'b1 && full_fifo_status==1'b0) begin
                write_ack <= 1;
                write_pointer <= write_pointer + 1'b1;
            end
            else
                write_ack <= 0;
        end
    end

    //将满判断
    // assign full_fifo_status = (rd_ff2[`FIFO_MEM_ADDR_WIDTH]!=write_pointer[`FIFO_MEM_ADDR_WIDTH]) && (rd_ff2[`FIFO_MEM_ADDR_WIDTH-1:0]==write_pointer[`FIFO_MEM_ADDR_WIDTH-1:0])?1:0;
    always @(*) begin
        if(write_pointer[`FIFO_MEM_ADDR_WIDTH]==0 && rd_ff2[`FIFO_MEM_ADDR_WIDTH]==1)begin
            halffull_fifo_status = (`FIFO_DEPTH - (write_pointer + 2*`FIFO_DEPTH - rd_ff2)<=(`FIFO_HALFFULL))?1:0;
            $display("half_01=%b",halffull_fifo_status);
        end
        else begin
            halffull_fifo_status = (`FIFO_DEPTH - (write_pointer - rd_ff2)<=(`FIFO_HALFFULL))?1:0;
            $display("half=%b",halffull_fifo_status);
        end
        
    end

    //写满判断
    always @(*) begin
        if((rd_ff2[`FIFO_MEM_ADDR_WIDTH]!=write_pointer[`FIFO_MEM_ADDR_WIDTH]) && (rd_ff2[`FIFO_MEM_ADDR_WIDTH-1:0]==write_pointer[`FIFO_MEM_ADDR_WIDTH-1:0])) begin
            full_fifo_status = 1'b1;
        end
        else begin
            full_fifo_status = 1'b0;
        end
    end
endmodule

2.read_control.v

//FIFO parameters
`define FIFO_DEPTH 64
`define FIFO_MEM_ADDR_WIDTH 6
`define FIFO_HALFEMPTY 4

module read_control (
    input reset,
    input clk_read_logic,
    input wire [`FIFO_MEM_ADDR_WIDTH:0] write_pointer,
    input read_request,
    output reg r_enable,
    output reg read_ack,
    output reg [`FIFO_MEM_ADDR_WIDTH:0] read_pointer,
    output reg empty_fifo_status,
    output reg halfempty_fifo_status,
    input wire rc_scan_in0,
    input wire rc_scan_en,
    input wire rc_test_mode,
    output rc_scan_out0,
    output reg [`FIFO_MEM_ADDR_WIDTH:0] wr_ff1,			// 写地址同步寄存器1
	output reg [`FIFO_MEM_ADDR_WIDTH:0] wr_ff2,			// 写地址同步寄存器2
    input reg init_done

    );

    wire [`FIFO_MEM_ADDR_WIDTH-1:0] mem_addr_read;
    wire [`FIFO_MEM_ADDR_WIDTH-1:0] mem_addr_write;

    assign mem_addr_read = read_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];
    assign mem_addr_write = write_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];
   
    // always @(*) begin
    //     $display("$time=%p, mem_addr_read=%h", $time, mem_addr_read);
    //     $display("$time=%p, mem_addr_write=%h",$time, mem_addr_write);
    // end

    always@(posedge clk_read_logic or posedge reset) begin
        if(!reset) begin
            read_pointer <= 0;
            read_ack <= 0;
        end
        // else begin
            //halfempty_fifo_status = ((mem_addr_read)<=(`FIFO_HALFEMPTY))?1:0;
        //读指针自加1
        if(r_enable) begin
            read_ack <= 1;
            read_pointer <= read_pointer + 1'b1;
        end
        else
            read_ack <= 0;
        // end
    end

    // 写地址同步至读时钟域
	always @(posedge clk_read_logic or posedge reset) begin// rdclk是wrclk的两倍，因为写要快点，所以时间短节奏快，波形密
		if(!reset) begin
			wr_ff1 <= 'b0;
			wr_ff2 <= 'b0;
		end
		else begin
			wr_ff1 <= write_pointer;
			wr_ff2 <= wr_ff1;
		end
	end

    //读使能判断
    // assign r_enable = (read_request && (empty_fifo_status==0))?1:0;
    always @(*) begin
        //读数据
        if(init_done) begin
            if( read_request == 1'b1 && empty_fifo_status == 1'b0 )begin
                r_enable = 1;
            end
            else begin
                r_enable = 0;
            end
        end
    end
    //将空判断
    always @(*) begin
        halfempty_fifo_status = ((wr_ff2 - read_pointer)<=(`FIFO_HALFEMPTY))?1:0;
    end
    //读空判断
    // assign empty_fifo_status = ((mem_addr_read == 0) && (mem_addr_write == 0) && read_pointer[`FIFO_MEM_ADDR_WIDTH] == write_pointer[`FIFO_MEM_ADDR_WIDTH])?1:0;
	always @(*) begin
		if( wr_ff2==read_pointer ) begin
			empty_fifo_status = 1'b1;
		end
		else begin
			empty_fifo_status = 1'b0;
		end
	end

endmodule

3.memory_array.v

 //FIFO parameters
`define MEM_ADDR_WIDTH 6
`define MEM_DEPTH 64
`define MEM_DATA_WIDTH 16

module memory_array (
    input reset,
    input clk_write_logic,
    input clk_read_logic,
    input [`MEM_ADDR_WIDTH-1:0] w_addr,
    input [`MEM_ADDR_WIDTH-1:0] r_addr,
    input w_enable,
    input r_enable,
    input reg [`MEM_DATA_WIDTH-1:0] w_data,
    input reg mem_scan_in0,
    input reg mem_scan_en,
    input reg mem_test_mode,
    output reg [`MEM_DATA_WIDTH-1:0] r_data,
    output mem_scan_out0
    );

    reg [`MEM_DATA_WIDTH-1:0] memory [0:`MEM_DEPTH-1];

    always @(posedge clk_write_logic) begin
        if(w_enable)
            memory[w_addr] <= w_data;
            // $display("memory = 'p%p", memory);//64*16
        end

    always @(posedge clk_read_logic or posedge reset) begin
        if(!reset)
            r_data <= 'b0;
        else if(r_enable)
            r_data <= memory[r_addr];
    end

endmodule

4.SFIFO.v

`define FIFO_DEPTH 64
`define FIFO_MEM_ADDR_WIDTH 6
`define FIFO_MEM_DATA_WIDTH 16
`define FIFO_HALFEMPTY 4
`define FIFO_HALFFULL 4

`include "write_control.v"
`include "read_control.v"
`include "memory_array.v"
module SFIFO (
    input reset,// system reset
    input wire init_done,
    clk_write_logic,
    clk_read_logic,
    read_request,
    write_request,
    halffull_fifo_status,//it is input or output？
    write_ack,
    input wire [`FIFO_MEM_DATA_WIDTH-1:0] w_data,
    input wire scan_in0, // test scan mode data input
    input wire scan_en, // test scan mode enable
    input wire test_mode, // test mode select
    output wire [`FIFO_MEM_DATA_WIDTH-1:0] r_data,
    output wire read_ack,
    output w_enable,
    output r_enable,
    output empty_fifo_status,
    output wire halfempty_fifo_status,
    output full_fifo_status,
    output wire scan_out0, // test scan mode data output,
    output wire [`FIFO_MEM_ADDR_WIDTH:0] rd_ff1,			// 读地址同步寄存器1
	output wire [`FIFO_MEM_ADDR_WIDTH:0] rd_ff2,			// 读地址同步寄存器2
    output wire [`FIFO_MEM_ADDR_WIDTH:0] wr_ff1,			// 写地址同步寄存器1
	output wire [`FIFO_MEM_ADDR_WIDTH:0] wr_ff2			// 写地址同步寄存器2
    );

    wire [`FIFO_MEM_ADDR_WIDTH:0] read_pointer;
    wire [`FIFO_MEM_ADDR_WIDTH:0] write_pointer;

    wire [`FIFO_MEM_ADDR_WIDTH-1:0] w_addr;
    wire [`FIFO_MEM_ADDR_WIDTH-1:0] r_addr;

    assign w_addr = write_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];
    assign r_addr = read_pointer [`FIFO_MEM_ADDR_WIDTH-1:0];

    read_control READ_CONTROL_MOD (
    .reset                  (reset),
    .clk_read_logic         (clk_read_logic),
    .write_pointer          (write_pointer),
    .read_request           (read_request),
    .r_enable               (r_enable),
    .read_ack               (read_ack),
    .read_pointer           (read_pointer),
    .empty_fifo_status      (empty_fifo_status),
    .halfempty_fifo_status  (halfempty_fifo_status),
    .rc_scan_in0            (scan_in0),
    .rc_scan_en             (scan_en),
    .rc_test_mode           (test_mode),
    .rc_scan_out0           (scan_out0),
    .wr_ff1                 (wr_ff1),
    .wr_ff2                 (wr_ff2),
    .init_done              (init_done)
    );

    write_control WRITE_CONTROL_MOD (
    .reset                  (reset),
    .clk_write_logic        (clk_write_logic),
    .read_pointer           (read_pointer),
    .write_request          (write_request),
    .w_enable               (w_enable),
    .write_ack              (write_ack),
    .write_pointer          (write_pointer),
    .full_fifo_status       (full_fifo_status),
    .halffull_fifo_status   (halffull_fifo_status),
    .wc_scan_in0            (scan_in0),
    // .wc_scan_en             (scan_en),
    // .wc_test_mode           (test_mode),
    // .wc_scan_out0           (scan_out0),
    .rd_ff1                 (rd_ff1),
    .rd_ff2                 (rd_ff2),
    .init_done              (init_done)
    );


    memory_array MEM_ARRAY_MOD (
    .reset              (reset),
    .clk_write_logic    (clk_write_logic),
    .clk_read_logic     (clk_read_logic),
    .w_addr             (w_addr),
    .r_addr             (r_addr),
    .w_enable           (w_enable),
    .r_enable           (r_enable),
    .w_data             (w_data),
    .r_data             (r_data),
    .mem_scan_in0       (scan_in0),
    .mem_scan_en        (scan_en),
    .mem_test_mode      (test_mode),
    .mem_scan_out0      (scan_out0)
    );

endmodule

5.test_tb.v

// `timescale 1ns / 1ns
`timescale 1ns/100ps
`include "SFIFO.v"

module SFIFO_tb;
    parameter DATA_WIDTH = 16               ;
    reg                 reset               ;
   	// 写时钟域tb信号定义
	reg					clk_write_logic		;
	reg					write_request	  	;
	reg[DATA_WIDTH-1:0]	w_data				;
	wire				full_fifo_status	;
 
	// 读时钟域tb信号定义
	reg					clk_read_logic		;
	reg					read_request		;
	wire[DATA_WIDTH-1:0]r_data				;
	wire				empty_fifo_status	;
 
	// testbench自定义信号
	reg					init_done			;		// testbench初始化结束
    
	// FIFO初始化
	initial	begin
		// 输入信号初始化
		reset                 = 1	;
		clk_write_logic 	  = 0	;
		clk_read_logic 	      = 0	;
        write_request         = 0	;
        read_request          = 0	;
		w_data                = 'b0 ;
		init_done             = 0	;
		// FIFO复位
		#30 reset             = 0   ;
            write_request     = 0	;
            read_request      = 0	;
		#30 reset             = 1   ;
            write_request     = 1	;
            read_request      = 1	;
		// 初始化完毕
		#30 init_done         = 1   ;
	
		if (init_done)begin
						
			repeat(1000)begin				
				#4 read_request  = 1;
				   write_request = 1;									
				#8 read_request  = 0;//读请求 高两周期 低一周期 循环1000次
				   write_request = 0;//写请求 高两周期 低一周期 循环1000次
			end

			repeat(1000)begin
				#8 write_request = 1;					   
				   read_request  = 1;//写读请求 一直高两周期 循环1000次
			end

			repeat(1000)begin				
				#4 read_request  = 0;
				   write_request = 0;									
				#8 read_request  = 1;//读请求 低两周期 高一周期 循环1000次
				   write_request = 1;//写请求 低两周期 高一周期 循环1000次
			end

			repeat(1000)begin
				#8 write_request = 1;
				#4 write_request = 0;//写请求 高一周期 低两周期 读请求一直高电平 循环1000次
			end

			repeat(1000)begin
				     write_request = 1;//写请求80次，一次4ns
					 read_request  = 0;
				#320 read_request  = 1;//读请求35次
					 write_request = 0;
				#140 write_request = 1;//写请求10次
					 read_request  = 0;
				#40  read_request  = 1;//读请求10次
					 write_request = 0;
				#40  write_request = 1;//写请求35次
					 read_request  = 0;
				#140 read_request  = 1;//读请求160次
					 write_request = 0;
				#640;
			end
			
			repeat(1000)begin		
				   write_request   = 1;//写请求一直高电平
				#4 read_request    = 1;
				#8 read_request    = 0;//读请求 高两周期 低一周期  循环1000次
			end

		end
	end

	// 写时钟 写快读慢
	always
		#2 clk_write_logic = ~clk_write_logic;
 
	// 读时钟
	always
		#4 clk_read_logic = ~clk_read_logic;

	//再开一个initial write_request和read_request会乱
		// repeat(10)begin
		// 	if (init_done)
		// 		if(clk_write_logic)
		// 			write_request = 1;
		// 			read_request = 1;
		// 			#8; 
		// 			write_request = 0;//写请求 高两周期 低两周期 循环1000次
		// 			read_request = 0;//读请求 高两周期 低两周期 循环1000次			
		// 			#4; 
		// end
		// read_request = 1;
	// end


	// 写入数据自增
	always @(posedge clk_write_logic) begin
		if(init_done) begin
			if( write_request==1'b1 && full_fifo_status == 1'b0 )begin
				w_data <= w_data + 1;
				// $display("w_data = 'h%h", w_data);
			end
			else
				w_data <= w_data;
		end
		else begin
			w_data <= 'b0;
		end
	end

    SFIFO SFIFO_inst1 
    (
        .reset                 (reset                 ),
        .clk_write_logic       (clk_write_logic       ),
        .clk_read_logic        (clk_read_logic        ),
        .read_request          (read_request          ),
        .w_data                (w_data                ),
        .write_request         (write_request         ),
        .r_data                (r_data                ),
        .read_ack              (read_ack              ),
        .w_enable              (w_enable              ),
        .r_enable              (r_enable              ),
        .empty_fifo_status     (empty_fifo_status     ),
        .halfempty_fifo_status (halfempty_fifo_status ),
        .full_fifo_status      (full_fifo_status      ),
        .halffull_fifo_status  (halffull_fifo_status  ),
        .write_ack             (write_ack             ),
        .scan_in0              (scan_in0              ),
        .scan_en               (scan_en               ),
        .test_mode             (test_mode             ),
        .scan_out0             (scan_out0             ),
        .init_done             (init_done             )
    );
endmodule

观自在琉璃
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
异步fifo（UVM验证）
weixin_61098515的博客
10-16 1672
1.interface 2.fifo_transaction 3.fifo_driver 4.fifo _monitor 5.fifo _sequencer 6.fifo_agent 7.ref_module（在这里其实就是个接收来自i_agent的monitor的数据 和 发送数据到scoreboard） 8.scoreboard scb里面有个队列expect_quene [$]
基于Verilog HDL的异步FIFO设计与实现
08-05
本文提出一种新颖的异步FIFO设计方案，它通过先比较读写地址并结合象限检测法产生异步的空/满标志，再把异步的空/满标志同步到相应的时钟域。通过仿真验证，该方法是稳定有效的。
异步fifo设计及验证进阶（System Verilog）
qq_42922513的博客
06-12 174
本文使用system verilog语言建立包含多个组件的随机验证平台对异步fifo进行验证。
IC学习笔记3——异步FIFO
qq_32100199的博客
05-19 8714
IC学习笔记3——异步FIFO 异步FIFO的工作内容与同步FIFO类似，但是异步FIFO的控制并不像同步FIFO那么简单，因为异步FIFO工作在不同的时钟域，这将会带来一些问题，比如空满检测？是否还可以像同步FIFO通过计数器来判断？是否需要同步电路？这些问题将会在本章节一一讨论。 一、异步FIFO的空满检测 1. 同步FIFO的空满检测 因为同步FIFO工作在一个时钟域，可以通过一个计数器来判断空满。 当同步FIFO写入一次数据，计数器加1. 当同步FIFO读出一次数据，计数器减1. 当同步FIFO同时
异步FIFO实验小结
创芯人--fly的博客
09-25 4959
本小节内容主要针对异步FIFO进行设计验证，内容涵盖了对异步fifo的理解，时钟域的同步，格雷码使用，以及对验证功能点提取，覆盖率收集等内容，后续还会持续完善更多验证内容，以及添加一些面试的高频问题。
异步fifo的UVM验证（最终最终版）
qq_44674008的博客
08-29 2368
更新了refmdl以及scb
异步fifo的设计与验证
dadazhuang的博客
11-27 3822
书接上文，上一篇介绍了略简单的同步fifo,接下来开始较为复杂的异步fifo。 1.同步fifo与异步fifo的区别 当设计中只有一个时钟时，所有的寄存器否用同一个，不会出现传输速度不匹配的情况；但是当设计中存在多个时钟信号，并且在这几个时钟域中传递数据，就可能出现因时钟信号不匹配而产生数据丢失的现象，这时候需要异步fifo进行数据的缓存，保证数据能够正常的传输，因此一般异步fifo会包含一个双端口的ram. 2.异步fifo组成 图1.异步fifo 模块组成（6个）：顶层模块、双口RAM、.
[DV]FIFO功能驗證點總結
元直的博客
10-20 1418
前言：FIFO是數字電路中廣泛使用的模塊，那麼怎麼驗證FIFO的功能點呢？下面做一個簡單的總結。 （1）同時讀寫，讀寫數據正確性檢查 （2）FIFO滿標誌位檢查 （3）FIFO空標誌位檢查 （4）寫過程中發生寫復位，寫數據和FIFO滿標誌位被清空 （5）讀過程中發生讀復位，讀數據和讀空標誌位被清空 ......
异步FIFO的UVM验证（VCS+Verdi 附源代码）
Future Chaser的博客
05-17 8817
异步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，不规范的地方请指正。也不知是否正确完整。
异步fifo verilog设计（支持自定义的almost full，almost empty）
07-23
自己写的一个异步fifo，深度宽度都可自定义，包含binary到gray码，gray码到binary转换，异步时域通信，自定义almost full，almost empty等知识，以verilog写的~
异步FIFO_异步FIFO_
10-02
当使用异步信号时，一个好的设计将对异步信号执行同步处理。 同步通常使用多级D触发器级联处理，如下图所示。 该模型的大多数数据表明，在第一级寄存器生成亚稳态之后，第二级寄存器的稳定输出概率为90％，第三级寄存器的稳定输出概率为99％。 如果亚稳状态跟随电路，将其传递，那么具有较弱自我修复能力的系统将直接崩溃。
fifo_UVM.zip
08-14
数字IC验证初学入门者，UVM验证方法学，异步FIFO
异步FIFO模块的RTL代码文件、Testbench 代码文件、tcl和makefile脚本文件
05-17
博文【异步FIFO的设计和功能验证】的源码，包含异步FIFO模块的RTL代码文件、Testbench 代码文件、tcl和makefile脚本文件
Cadence NC_verilog仿真
08-10
NC可用于数模混合仿真，即用verilog语言给画的电路图添加输入激励信号，然后查看输出信号，以验证电路是否正确。。
异步fifo_tb设计代码
12-30
简单验证异步fifo功能的tb代码
async_fifo.rar_async fifo验证_异步FIFO
09-20
用verilog语言编写并经过综合验证的异步FIFO的源代码
一种基于音频解嵌的异步FIFO设计及FPGA实现
10-21
介绍了一种针对音频解嵌中的音频帧输出而采用的特定异步FIFO的设计。重点阐述了针对这一特定情况需要考虑到的FIFO深度及读写指针复位控制以及利用读写地址格雷码对FIFO的空、满标志信号的产生电路进行逻辑设计，用...
异步fifo的UVM验证（最终版）
qq_44674008的博客
05-31 5551
这一篇帖子我鸽子了好久，前俩周忙教研室课题还要做实验，今天五月最后一天就把这个验证的框架全部更新完了，我真的没有太监掉这个帖子。后续各位就可以在这个基础上自己写test文件来实现一些功能验证了。顺便我把代码放到gitee上了，有需要的小伙伴可以私聊我。 写在前面的一些总结（很重要）： ****之前我是将数据放置到数据包里面发送，但是我对于这个方式改了很久发现了几个bug实在是无法解决：第一个就是发送多个数据包的时候，读速度跟不上，在写满后，会直接结束仿真，而不是读出一个数据后继续发送。第二个就是数据包长
异步fifo的UVM验证（更新2）
qq_44674008的博客
05-16 1964
fifo_dirver更新 上一阶段我只是简单的搭建了一个环境，甚至都没有形成一个简单的框架。这里，我们先更新以下driver，给driver引入factory机制与objection机制。 factory机制需要利用宏定义，将driver注册进去。它的作用有很多，最简单的就是可以自动创建类并且调用其中的func or task。在上一节的top_tb中，有如下代码： initial begin fifo_driver drv; drv = new("drv",null); drv.ma
异步 fifo 寄存器 ram verilog 综合
最新发布
09-06
具体的实现包括FIFO原理简介、FIFO空、满信号的检测、二进制至格雷码的转换以及异步FIFO的Verilog代码实现等。 异步FIFO的基础是一个双时钟双端口RAM，读端口和写端口的时钟不一致。而其设计重点是跨时钟域的地址...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值