SamplingMask.vhd

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.numeric_std.all;
library work;
use work.klm_scint_pkg.all;


entity SamplingMask is
    generic (N_WINS_PADDING : std_logic_vector(8 downto 0) := "000000010");
    port (
        clk              : in  std_logic;
        rst              : in  std_logic := '0';
        ena              : in  std_logic := '0';
        new_bit          : in  std_logic := '1';
        win_start        : in  std_logic_vector(8 downto 0) := (others=>'0');
        N_win            : in  std_logic_vector(3 downto 0) := (others=>'0');
        wr_ena_mask      : out std_logic_vector(511 downto 0) := (others=>'1')
    );
end SamplingMask;
architecture Behavioral of SamplingMask is


    signal ena_i         : std_logic_vector(1 downto 0) := "00";
    signal i_win : std_logic_vector(8 downto 0) := (others=>'0');
    signal n_win_i : std_logic_vector(3 downto 0) := (others=>'0');
    signal new_bit_i : std_logic := '1';

    type masking_state_machine is (
        IDLE,
        MODIFY_MASK
    );
    signal masking_state : masking_state_machine := IDLE;


begin

    ena_i(0) <= ena;
    process (clk, ena)
    begin
        if rising_edge(clk) then
            ena_i(1) <= ena;
        end if;
    end process;


    process(clk, rst, ena_i, new_bit, win_start, n_win, n_win_i)
        -- variable i_win : std_logic_vector(8 downto 0);
        variable count : std_logic_vector(3 downto 0);
    begin
        if rising_edge(clk) then
            if rst = '1' then
                masking_state <= IDLE;
                wr_ena_mask <= (others=>'1');
            else
                case( masking_state ) is

                    when IDLE =>
                        if ena_i = "01"  then
                            count := "0000";
                            i_win <= win_start - N_WINS_PADDING;
                            n_win_i <= n_win;
                            new_bit_i <= new_bit;
                            masking_state <= MODIFY_MASK;
                        else
                            masking_state <= IDLE;
                        end if;

                    when MODIFY_MASK =>
                        wr_ena_mask(to_integer(unsigned(i_win))) <= new_bit_i;
                        if count = n_win_i + 2*to_integer(unsigned(N_WINS_PADDING)) then
                            masking_state <= IDLE;
                        else
                            count := count + '1';
                            i_win <= i_win + '1';
                            masking_state <= MODIFY_MASK;
                        end if;
                end case;
            end if;
        end if;
    end process;



end Behavioral;