Subversion Repositories scarts

-----------------------------------------------------------------------

-- This file is part of SCARTS.

-- 

-- SCARTS is free software: you can redistribute it and/or modify

-- it under the terms of the GNU General Public License as published by

-- the Free Software Foundation, either version 3 of the License, or

-- (at your option) any later version.

-- 

-- SCARTS 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 General Public License for more details.

-- 

-- You should have received a copy of the GNU General Public License

-- along with SCARTS.  If not, see <http://www.gnu.org/licenses/>.

-----------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

use work.debounce_pkg.all;

architecture beh of key_matrix is

  constant CLK_PERIOD : time := 1E9 / CLK_FREQ * 1 ns;

  constant CNT_MAX : integer := SCAN_TIME_INTERVAL / CLK_PERIOD;

  signal rows_debounced : std_logic_vector(ROW_COUNT - 1 downto 0);

  type debounce_signal_array is array(0 to COLUMN_COUNT - 1, ROW_COUNT - 1 downto 0) of std_logic;

  signal rows_debounced_old, rows_debounced_old_next : debounce_signal_array;

  signal debouncer_reinit : std_logic;

  signal debouncer_reinit_value : std_logic_vector(ROW_COUNT - 1 downto 0);

  type KEY_MATRIX_STATE_TYPE is (STATE_FIRST_COLUMN, STATE_NEXT_COLUMN, STATE_REINIT_DEBOUNCER, STATE_EXECUTE);

  signal key_matrix_state, key_matrix_state_next : KEY_MATRIX_STATE_TYPE;

  signal interval, interval_next : integer range 0 to CNT_MAX;

  signal current_column, current_column_next : integer range 0 to COLUMN_COUNT - 1;

  signal key_next : std_logic_vector(log2c(ROW_COUNT * COLUMN_COUNT) - 1 downto 0);

  signal decode_data : std_logic;

begin

  process(current_column)

  begin

    columns <= (others => '0');

    columns(current_column) <= '1';

  end process;

  debouncer_gen : for i in 0 to ROW_COUNT - 1 generate

    debouncer_inst : debounce

      generic map

      (

        CLK_FREQ => CLK_FREQ,

        SYNC_STAGES => SYNC_STAGES,

        TIMEOUT => DEBOUNCE_TIMEOUT

      )

      port map

      (

        sys_clk => sys_clk,

        sys_res_n => sys_res_n,

        data_in => rows(i),

        data_out => rows_debounced(i),

        reinit => debouncer_reinit,

        reinit_value => debouncer_reinit_value(i)

      );

  end generate debouncer_gen;

  process(key_matrix_state, interval, current_column)

  begin

    key_matrix_state_next <= key_matrix_state;

    case key_matrix_state is

      when STATE_FIRST_COLUMN =>

        key_matrix_state_next <= STATE_REINIT_DEBOUNCER;

      when STATE_NEXT_COLUMN =>

        key_matrix_state_next <= STATE_REINIT_DEBOUNCER;

      when STATE_REINIT_DEBOUNCER =>

        key_matrix_state_next <= STATE_EXECUTE;

      when STATE_EXECUTE =>

        if interval = CNT_MAX - 1 then

          if current_column = COLUMN_COUNT - 1 then

            key_matrix_state_next <= STATE_FIRST_COLUMN;

          else

            key_matrix_state_next <= STATE_NEXT_COLUMN;

          end if;

        end if;

    end case;

  end process;

  process(key_matrix_state, interval, current_column, rows_debounced, rows_debounced_old)

  begin

    current_column_next <= current_column;

    debouncer_reinit <= '0';

    debouncer_reinit_value <= (others => '0');

    rows_debounced_old_next <= rows_debounced_old;

    interval_next <= 0;

    decode_data <= '0';

    case key_matrix_state is

      when STATE_FIRST_COLUMN =>

        current_column_next <= 0;

      when STATE_NEXT_COLUMN =>

        current_column_next <= current_column + 1;

      when STATE_REINIT_DEBOUNCER =>

        debouncer_reinit <= '1';

        for i in 0 to ROW_COUNT - 1 loop

          debouncer_reinit_value(i) <= rows_debounced_old(current_column, i);

        end loop;

      when STATE_EXECUTE =>

        interval_next <= interval + 1;

        for i in 0 to ROW_COUNT - 1 loop

          rows_debounced_old_next(current_column, i) <= rows_debounced(i);

        end loop;

        decode_data <= '1';

    end case;

  end process;

  process(sys_clk, sys_res_n)

  begin

    if sys_res_n = '0' then

      current_column <= 0;

      rows_debounced_old <= (others => (others => '0'));

      interval <= 0;

      key_matrix_state <= STATE_FIRST_COLUMN;

      key <= (others => '0');

    elsif rising_edge(sys_clk) then

      current_column <= current_column_next;

      interval <= interval_next;

      rows_debounced_old <= rows_debounced_old_next;

      key_matrix_state <= key_matrix_state_next;

      key <= key_next;

    end if;

  end process;

  process(decode_data, rows_debounced, rows_debounced_old, current_column)

    variable key_int : integer range 0 to ROW_COUNT * COLUMN_COUNT;

    variable found, valid : boolean;

  begin

    key_next <= (others => '0');

    if decode_data = '1' then

      key_int := 0;

      found := false;

      valid := true;

      for i in 0 to ROW_COUNT - 1 loop

        if rows_debounced(i) = '1' then

          if found = true then -- Only one key may be pressed at once

            valid := false;

          end if;

          if rows_debounced_old(current_column, i) = '1' then -- Only valid the first time the key is pressed

            valid := false;

          end if;

          found := true;

        end if;

        -- Calculate the key number (i * COLUMN_COUNT)

        -- = Addition of column count until the key is found

        if not found then

          key_int := key_int + COLUMN_COUNT;

        end if;

      end loop;

      if valid and found then

        -- If a valid key was found, correct the key number to the correct column

        key_int := key_int + current_column + 1;

      else

        key_int := 0;

      end if;

      key_next <= std_logic_vector(to_unsigned(key_int, log2c(ROW_COUNT * COLUMN_COUNT)));

    end if;

  end process;

end architecture beh;