Quartus II FIFO学习

1. FIFO通常是双端口的存储器，其中一个端口用于写入数据，而另一个端口用于读出数据。可以同时对存储器字存储单元进行写入和读出操作。它的数据吞吐率是普通RAM的两倍。
2. 现在的FIFO存储器采用SRAM单元来实现。它是基于带两个指针的环行FIFO结构的。要写入的数据的存储地址放在写指针中，而FIFO结构中要读出的第一个数据的地址放在读指针中
3. 在复位后，两个指针都指向存储器的同一个字单元。每次写操作后，写指针指向下一个存储单元。对数据字的读取操作，会把读指针指向下一个要读取的数据字
4. 读指针就不断地跟随写指针，当读指针跟上写指针后，FIFO的结构里面为空。
5. 如果写指针追上读指针，FIFO结构里面的数据是满载的。

 

library   IEEE;
use   IEEE.Std_logic_1164.all;
entity   FIFOMXN   is
      generic(m,   n   :   Positive   :=   8);   --m   is   fifo   depth,   n   is   fifo   width
      port(RESET,   WRREQ,   RDREQ,   CLOCK   :   in   Std_logic;
                  DATAIN   :   in   Std_logic_vector((n-1)   downto   0);
                  DATAOUT   :   out   Std_logic_vector((n-1)   downto   0);
                  FULL,   EMPTY   :   inout   Std_logic);
end   FIFOMXN;
architecture   V2   of   FIFOMXN   is
      type   Fifo_array   is   array(0   to   (m-1))   of   Bit_vector((n-1)   downto   0);
      signal   Fifo_memory   :   Fifo_array;
      signal   Wraddr,   Rdaddr,   Offset   :   Natural   range   0   to   (m-1);
      signal   Rdpulse,   Wrpulse,   Q1,   Q2,   Q3,   Q4   :   Std_logic;
      signal   Databuffer   :   Bit_vector((n-1)   downto   0);
begin
--pulse   synchronisers   for   WRREQ   and   RDREQ
--modified   for   Synplify   to   a   process
sync_ffs   :   process
                begin
                                wait   until   rising_edge(CLOCK);
                                Q1   <=   WRREQ;
                                Q2   <=   Q1;
                                Q3   <=   RDREQ;
                                Q4   <=   Q3;
end   process;
--concurrent   logic   to   generate   pulses
Wrpulse   <=   Q2   and   not(Q1);
Rdpulse   <=   Q4   and   not(Q3);      
Fifo_read   :   process
      begin
            wait   until   rising_edge(CLOCK);
            if   RESET   =   '1 '   then
                  Rdaddr   <=   0;
                  Databuffer   <=   (others   =>   '0 ');
            elsif   (Rdpulse   =   '1 '   and   EMPTY   =   '0 ')   then
                  Databuffer   <=   Fifo_memory(Rdaddr);
                  Rdaddr   <=   (Rdaddr   +   1)   mod   m;
            end   if;
      end   process;
Fifo_write   :   process
      begin
            wait   until   rising_edge(CLOCK);
            if   RESET   =   '1 '   then
                  Wraddr   <=   0;
            elsif   (Wrpulse   =   '1 '   and   FULL   =   '0 ')   then
                  Fifo_memory(Wraddr)   <=   To_Bitvector(DATAIN);
                  Wraddr   <=   (Wraddr   +   1)   mod   m;
            end   if;
      end   process;
Offset   <=   (Wraddr   -   Rdaddr)   when   (Wraddr   >   Rdaddr)  
                        else   (m   -   (Rdaddr   -   Wraddr))   when   (Rdaddr   >   Wraddr)
                        else   0;
EMPTY   <=   '1 '   when   (Offset   =   0)   else   '0 ';
FULL   <=   '1 '   when   (Offset   =   (m-1))   else   '0 ';
DATAOUT   <=   To_Stdlogicvector(Databuffer)   when   RDREQ   =   '0 '  
                        else   (others   =>   'Z ');
end   V2;

上述代码实现了FIFO的功能，但是我对于红色部分暂时还不理解。

后来发现红色斜体部分似乎有错误，如果把Q1和Q2互换一下就好理解了（同理Q3和Q4互换）。

转载于:https://www.cnblogs.com/yucan/archive/2011/03/24/1994459.html