Subversion Repositories xmatchpro

--This library is free software; you can redistribute it and/or
--modify it under the terms of the GNU Lesser General Public
--License as published by the Free Software Foundation; either
--version 2.1 of the License, or (at your option) any later version.
 
--This library is distributed in the hope that it will be useful,
--but WITHOUT ANY WARRANTY; without even the implied warranty of
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--Lesser General Public License for more details.
 
--You should have received a copy of the GNU Lesser General Public
--License along with this library; if not, write to the Free Software
--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-- e_mail : j.l.nunez-yanez@byacom.co.uk
 
---------------------------------
--  ENTITY       = BSL_TC_2      --
--  version      = 2.0         --
--  last update  = 22/05/00    --
--  author       = Jose Nunez  --
---------------------------------
 
--  FUNCTION
--  Latches the block size synchronously under the control of
--  the LOAD signal (active LOW). The 16 bit number indicates the number of
--  tuples in the block.
 
--  The tuple counter is fully synchronous and is incremented on each
--  clock cycle if INC signal is LOW.
 
--  When the tuple counter reaches the required number of tuples within
--  the block minus one, the END OF BLOCK signal is activated. The counter
--  then remains locked in this state until cleared or reset.
 
 
--  PIN LIST
--  BLOCK_SIZE	= input block size
--  LOAD	= load block size (active LOW)
--  INC         = increment tuple counter (active LOW)
--  CLEAR       = asynchronously clear the tuple counter (active LOW) and the block size
--  CLK		= clock
--  EO_BLOCK    = end of block signal (active LOW)
 
--  WARNING - dzx.bit_arith is an INTERGRAPH SPECIFIC LIBRARY
--            take note of this if porting to another system!
--            It is required to allow the addition of two bit
--            vectors in the process TUPLE_COUNTER.
 
library ieee,dzx;
use ieee.std_logic_1164.all;
use dzx.bit_arith.all;
use dzx.attributes.all;
 
entity BSL_TC_2_D is
port
(
      BLOCK_SIZE : in bit_vector(31 downto 0) ;
      INC : in bit ;
      CLEAR : in bit ;
	  RESET : in bit;
      CLK : in bit ;
      EO_BLOCK : out bit ;
	FINISH_D_BUFFERS : out bit
);
 
end BSL_TC_2_D;
 
 
architecture COUNTER of BSL_TC_2_D is
 
 
 
-- indicates end of block (active LOW), i.e tuple count is equal
-- to decoded block size
signal EOB : bit;
 
-- indicates the number of tuples that have been processed
signal TUPLE_COUNT : bit_vector(29 downto 0);
 
 
begin
 
TUPLE_COUNTER : process(CLK,CLEAR) 
 
begin
	-- Since the increment is always with 4 bytes I use only 14 bit counter
	if (CLEAR = '0') then
	    	TUPLE_COUNT <= "000000000000000000000000000000";
	elsif ((CLK'event) and (CLK='1')) then 
		if (RESET = '0') then
	    	TUPLE_COUNT <= "000000000000000000000000000000";
		elsif ((INC = '1') and (EOB = '1')) then
			TUPLE_COUNT <= TUPLE_COUNT + "000000000000000000000000000001";
		end if;
	end if;
end process TUPLE_COUNTER;
 
 
END_OF_BLOCK : process (TUPLE_COUNT, BLOCK_SIZE)
begin
    if ((TUPLE_COUNT & "00") >= BLOCK_SIZE) then
    	    	EOB <= '0';
	else
				EOB <= '1';
    end if;
end process END_OF_BLOCK;
 
 
--  assign EOB to external EO_BLOCK signal			
EO_BLOCK <= EOB;
 
-- or not(INC);
 
-- to stop the buffers when the last data has been read from them
 
-- FINISH_D_BUFFERS <= '0' when (TUPLE_COUNT & "00" + "0000000000001100" = BS_LATCH) else '1'; 		
 
FINISH_D_BUFFERS <= EOB;
 
end COUNTER;