FIFO(附Testbench)

介绍：此为设计AVS帧内预测与MD之间的接口FIFO，在已有的FIFO基础上设计得来：（1）其在满状态下若在输入数据，会冲掉前面第一个数据；（2）根据输入模式的不同，会选择从第几个数据开始为有效数据(即前面的为无效数据)。

内容：指标（1）由读写指针的移位来实现

        指标（2）由复位信号的初始值来实现

 FIFO module

  1 //-----------------------------------------------------
  2 // Design Name : syn_fifo
  3 // File Name   : syn_fifo.v
  4 // Function    : Synchronous (single clock) FIFO
  5 // Coder       : 
  6 //-----------------------------------------------------
  7 module syn_fifo (
  8 clk      , // Clock input
  9 rst      , // Active high reset
 10 wr_cs    , // Write chip select
 11 rd_cs    , // Read chipe select
 12 data_in  , // Data input
 13 rd_en    , // Read enable
 14 wr_en    , // Write Enable
 15 data_out , // Data Output
 16 empty    , // FIFO empty
 17 full     , // FIFO full
 18 mode       // Mode
 19 );    
 20  
 21 // FIFO constants
 22 parameter DATA_WIDTH = 8;
 23 parameter ADDR_WIDTH = 8;
 24 parameter RAM_DEPTH = (1 << ADDR_WIDTH);
 25 // Port Declarations
 26 input clk ;
 27 input rst ;
 28 input mode;
 29 input wr_cs ;
 30 input rd_cs ;
 31 input rd_en ;
 32 input wr_en ;
 33 input [DATA_WIDTH-1:0] data_in ;
 34 output full ;
 35 output empty ;
 36 output [DATA_WIDTH-1:0] data_out ;
 37 
 38 //-----------Internal variables-------------------
 39 reg [ADDR_WIDTH-1:0] wr_pointer;
 40 reg [ADDR_WIDTH-1:0] rd_pointer;
 41 reg [ADDR_WIDTH :0] status_cnt;
 42 reg [DATA_WIDTH-1:0] data_out ;
 43 wire [DATA_WIDTH-1:0] data_ram ;
 44 reg                  c;
 45 
 46 //-----------Variable assignments---------------
 47 assign full = (status_cnt == (RAM_DEPTH));
 48 assign empty = (status_cnt == 0);
 49 
 50 //-----------Code Start---------------------------
 51 always @ (posedge clk or posedge rst)
 52 begin : WRITE_POINTER
 53   if (rst) begin
 54      wr_pointer <= 0;
 55      c <= 0;
 56      end else if (wr_cs && wr_en ) 
 57                 begin
 58                    if(wr_pointer ==7)begin
 59                        c <= 1;
 60                        wr_pointer <=wr_pointer +1;
 61                        end 
 62                    else begin
 63                          wr_pointer <= wr_pointer + 1;
 64                         end 
 65                 end
 66  end
 67 
 68 always @ (posedge clk or posedge rst)
 69 begin : READ_POINTER
 70   if (rst) begin
 71             if(mode == 2)begin
 72                 rd_pointer <= 2;
 73                 end
 74             else if(mode == 1)begin
 75                    rd_pointer <= 1;
 76                    end
 77                   else if(mode == 0)begin  
 78                           rd_pointer <= 0;
 79                        end
 80   end else begin 
 81              if (rd_cs && rd_en ) begin
 82                rd_pointer <= rd_pointer + 1;    
 83               end   
 84           if(c==1 && wr_pointer ==rd_pointer + 1 )begin
 85     rd_pointer <= rd_pointer + 1;
 86      end  
 87   end
 88 end
 89 
 90 always  @ (posedge clk or posedge rst)
 91 begin : READ_DATA
 92   if (rst) begin
 93     data_out <= 0;
 94   end else if (rd_cs && rd_en ) begin
 95     data_out <= data_ram;
 96   end
 97 end
 98 
 99 always @ (posedge clk or posedge rst)
 begin : STATUS_COUNTER
   if (rst) begin
     status_cnt <= 0;
   // Read but no write.
   end else if ((rd_cs && rd_en) && !(wr_cs && wr_en) 
                 && (status_cnt != 0)) begin
     status_cnt <= status_cnt - 1;
   // Write but no read.
   end else if ((wr_cs && wr_en) && !(rd_cs && rd_en) 
                && (status_cnt != RAM_DEPTH)) begin
     status_cnt <= status_cnt + 1;
   end
 end 
    
 ram_dp_ar_aw #(DATA_WIDTH,ADDR_WIDTH)DP_RAM (
 .address_0 (wr_pointer) , // address_0 input 
 .data_0    (data_in)    , // data_0 bi-directional
 .cs_0      (wr_cs)      , // chip select
 .we_0      (wr_en)      , // write enable
 .oe_0      (1'b0)       , // output enable
 .address_1 (rd_pointer) , // address_q input
 .data_1    (data_ram)   , // data_1 bi-directional
 .cs_1      (rd_cs)      , // chip select
 .we_1      (1'b0)       , // Read enable
 .oe_1      (rd_en)        // output enable
 );     
 
 endmodule
 

ram_dp_ar_aw  module

 1 //-----------------------------------------------------
 2 // Design Name : ram_dp_ar_aw
 3 // File Name   : ram_dp_ar_aw.v
 4 // Function    : Asynchronous read write RAM
 5 // Coder       : 
 6 //-----------------------------------------------------
 7 module ram_dp_ar_aw (
 8 address_0 , // address_0 Input
 9 data_0    , // data_0 bi-directional
 cs_0      , // Chip Select
 we_0      , // Write Enable/Read Enable
 oe_0      , // Output Enable
 address_1 , // address_1 Input
 data_1    , // data_1 bi-directional
 cs_1      , // Chip Select
 we_1      , // Write Enable/Read Enable
 oe_1        // Output Enable
 ); 
 
 parameter DATA_WIDTH = 8 ;
 parameter ADDR_WIDTH = 3 ;
 parameter RAM_DEPTH = 1 << ADDR_WIDTH;
 
 //--------------Input Ports----------------------- 
 input [ADDR_WIDTH-1:0] address_0 ;
 input cs_0 ;
 input we_0 ;
 input oe_0 ; 
 input [ADDR_WIDTH-1:0] address_1 ;
 input cs_1 ;
 input we_1 ;
 input oe_1 ; 
 
 //--------------Inout Ports----------------------- 
 inout [DATA_WIDTH-1:0] data_0 ; 
 inout [DATA_WIDTH-1:0] data_1 ;
 
 //--------------Internal variables---------------- 
 reg [DATA_WIDTH-1:0] data_0_out ; 
 reg [DATA_WIDTH-1:0] data_1_out ;
 reg [DATA_WIDTH-1:0] mem [0:RAM_DEPTH-1];
 
 //--------------Code Starts Here------------------ 
 // Memory Write Block 
 // Write Operation : When we_0 = 1, cs_0 = 1
 always @ (/*address_0 or */cs_0 or we_0 or data_0
 or address_1 or cs_1 or we_1 or data_1)
 begin : MEM_WRITE
   if ( cs_0 && we_0 ) begin
      mem[address_0] <= data_0;
   end else if  (cs_1 && we_1) begin
      mem[address_1] <= data_1;
   end 
 end
 
 // Tri-State Buffer control 
 // output : When we_0 = 0, oe_0 = 1, cs_0 = 1
 assign data_0 = (cs_0 && oe_0 && !we_0) ? data_0_out : 8'bz; 
 
 // Memory Read Block 
 // Read Operation : When we_0 = 0, oe_0 = 1, cs_0 = 1
 always @ (address_0 or cs_0 or we_1 or oe_0)
 begin : MEM_READ_0
   if (cs_0 && !we_0 && oe_0) begin
     data_0_out <= mem[address_0]; 
   end else begin
     data_0_out <= 0; 
   end
 end   
 
 //Second Port of RAM
 // Tri-State Buffer control 
 // output : When we_0 = 0, oe_0 = 1, cs_0 = 1
 assign data_1 = (cs_1 && oe_1 && !we_1) ? data_1_out : 8'bz; 
 // Memory Read Block 1 
 // Read Operation : When we_1 = 0, oe_1 = 1, cs_1 = 1
 always @ (address_1 or cs_1 or we_1 or oe_1)
 begin : MEM_READ_1
   if (cs_1 && !we_1 && oe_1) begin
     data_1_out <= mem[address_1]; 
   end else begin
     data_1_out <= 0; 
   end
 end
 
 endmodule // End of Module ram_dp_ar_aw

Testbench

 1 module fifo_tb ();
 2 parameter DATA_WIDTH = 8;
 3 // Limit depth to 8
 4 parameter ADDR_WIDTH = 3; 
 5 
 6 reg clk, rst, rd_en, wr_en,mode;
 7 reg [DATA_WIDTH-1:0] data_in ;
 8 wire [DATA_WIDTH-1:0] data_out ;
 9 wire empty, full;
 integer i;
 
 initial begin
   $monitor ("%g wr:%h wr_data:%h rd:%h rd_data:%h", 
     $time, wr_en, data_in,  rd_en, data_out);
   clk = 0;
   rst = 0;
   rd_en = 0;
   wr_en = 0;
   data_in = 0;
   mode = 2;
   #5 rst = 1;
   #5 rst = 0;
   @ (negedge clk);
   wr_en = 1;
   // We are causing over flow
   for (i = 1 ; i < 11; i = i + 1) begin
      data_in  = i;
      @ (negedge clk);
   end
   wr_en  = 0;
   @ (negedge clk);
   
   rd_en = 1;
   // We are causing under flow 
   for (i = 1 ; i < 10; i = i + 1) begin
      @ (negedge clk);
   end
   wr_en = 1;
   
  /*  more 
   rd_en = 0;
   write again 
   for (i = 1 ; i < 10; i = i + 1) begin
      data_in  = i;
      @ (negedge clk);
    end
    wr_en = 0;
     @ (negedge clk);
   rd_en = 1; 
   read again 
   for (i = 1 ; i < 10; i = i + 1) begin
      @ (negedge clk);
   end  */  
   
   
   rd_en = 0;
   #100 $finish;
 end  
 
 always #1 clk = !clk;
 
 syn_fifo #(DATA_WIDTH,ADDR_WIDTH) fifo(
 .clk      (clk)     , // Clock input
 .rst      (rst)     , // Active high reset
 .wr_cs    (1'b1)    , // Write chip select
 .rd_cs    (1'b1)    , // Read chipe select
 .data_in  (data_in) , // Data input
 .rd_en    (rd_en)   , // Read enable
 .wr_en    (wr_en)   , // Write Enable
 .data_out (data_out), // Data Output
 .empty    (empty)   , // FIFO empty
 .full     (full)    , // FIFO full
 .mode     (mode)      // Mode
 );   
 
 endmodule