CalculateROI.vhd

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_MISC.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
Library work;
use work.klm_scint_pkg.all;


entity CalculateROI is
    generic (
        ARR_DEPTH_g         : integer;
        VEC_WIDTH_g         : integer
    );
    port (
        clk                 : in  std_logic := '0';
        ena                 : in  std_logic := '0';
        -- busy                : out std_logic := '0';
        vec_arr             : in  slv9(ARR_DEPTH_g - 1 downto 0);
        arr_mask            : in  std_logic_vector(ARR_DEPTH_g - 1 downto 0);
        first_vec           : out std_logic_vector(VEC_WIDTH_g - 1  downto 0);
        last_vec            : out std_logic_vector(VEC_WIDTH_g - 1  downto 0)
    );
end CalculateROI;


architecture Behavioral of CalculateROI is


    signal i_first_vec : std_logic_vector(VEC_WIDTH_g - 1 downto 0) := (others=>'0');
    signal i_last_vec  : std_logic_vector(VEC_WIDTH_g - 1 downto 0) := (others=>'0');

    signal count : integer range 0 to ARR_DEPTH_g - 1;

    type calculate_ROI_state_machine is (
        IDLE,
        COMPARING
    );
    signal ROI_state : calculate_ROI_state_machine := IDLE;

    signal i_ena : std_logic := '1';

----------------------------------------
begin

    process(clk)
    begin
        if rising_edge(clk) then
            i_ena <= ena;
            first_vec <= i_first_vec;
            last_vec <= i_last_vec;
        end if;
    end process;


    process(clk)
    begin
        if rising_edge(clk) then

            case ROI_state is

                when IDLE =>
                    if i_ena = '0' and ena = '1' then
                        for i in 0 to ARR_DEPTH_g - 1 loop
                            if arr_mask(i) = '1' then
                                i_first_vec <= vec_arr(i);
                                i_last_vec <= vec_arr(i);
                                count <= i;
                                exit;
                            end if;
                        end loop;
                        -- busy <= '1';
                        ROI_state <= COMPARING;
                    else
                        -- busy <= '0';
                        count <= 0;
                        ROI_state <= IDLE;
                    end if;

                when COMPARING =>
                    if arr_mask(count) = '1' then

                        -- find earliest
                        if vec_arr(count) <= i_first_vec then
                            if i_first_vec - vec_arr(count) > 2**(VEC_WIDTH_g - 1) then  --rollover detected
                                i_first_vec <= i_first_vec;
                            else
                                i_first_vec <= vec_arr(count);
                            end if;
                        else
                            if vec_arr(count) - i_first_vec > 2**(VEC_WIDTH_g - 1) then  --rollover detected
                                i_first_vec <= vec_arr(count);
                            else
                                i_first_vec <= i_first_vec;
                            end if;
                        end if;

                        -- find latest
                        if vec_arr(count) >= i_last_vec then
                            if vec_arr(count) - i_last_vec > 2**(VEC_WIDTH_g - 1) then --rollover detected
                                i_last_vec <= i_last_vec;
                            else
                                i_last_vec <= vec_arr(count);
                            end if;
                        else
                            if i_last_vec - vec_arr(count) > 2**(VEC_WIDTH_g - 1) then --rollover detected
                                i_last_vec <= vec_arr(count);
                            else
                                i_last_vec <= i_last_vec;
                            end if;
                        end if;
                    end if;

                    if count < ARR_DEPTH_g - 1 then
                        count <= count + 1;
                        ROI_state <= COMPARING;
                    else
                        count <= 0;
                        ROI_state <= IDLE;
                    end if;

            end case;
        end if;
    end process;
end Behavioral;