// kbd_drv.h

//==================
#ifndef KBD_DRV_H

#define KBD_DRV_H

#include "kbd_drv.h"

#include "main_def_func.h"
//==================

//==================
#ifdef __PROJECT_MODE_WORK__
#define DEBOUNCE_DELAY 30
#define HOLD_1_DELAY 1500
#define HOLD_2_DELAY 2500

#define REPEAT_1_DELAY 150
#define REPEAT_2_DELAY 50
#endif

#ifdef __PROJECT_MODE_DEBUG__
#define DEBOUNCE_DELAY 3
#define HOLD_1_DELAY 5
#define HOLD_2_DELAY 7

#define REPEAT_1_DELAY 5
#define REPEAT_2_DELAY 3
#endif
//==================

//==================
#define KEY_ENTER          1
#define KEY_ENTER_BIT      1<<KEY_ENTER
//----------
#define KEY_MINUS          2
#define KEY_MINUS_BIT      1<<KEY_MINUS
//----------
#define KEY_PLUS           0
#define KEY_PLUS_BIT       1<<KEY_PLUS
//==================

//==================
#define KEYS_MASK          (KEY_ENTER_BIT | KEY_MINUS_BIT | KEY_PLUS_BIT)
//==================

//==================
typedef enum kbd_codes
{
   KEY_ENTER_COD = 1,
   KEY_MINUS_COD,
   KEY_PLUS_COD,
} kbd_codes;
//==================

//==================
#define HOLD   1<<7
#define REPEAT 1<<6

#define KEY_ENTER_HOLD_COD (KEY_ENTER_COD | HOLD)
#define KEY_MINUS_HOLD_COD (KEY_MINUS_COD | HOLD)
#define KEY_PLUS_HOLD_COD  (KEY_PLUS_COD  | HOLD)

#define KEY_ENTER_REPEAT_COD (KEY_ENTER_COD | REPEAT)
#define KEY_MINUS_REPEAT_COD (KEY_MINUS_COD | REPEAT)
#define KEY_PLUS_REPEAT_COD  (KEY_PLUS_COD  | REPEAT)
//==================

//==================
//#define KEY1_PRESSED() ((KEYS1_PIN & (1<<BIT_KEY1) == 0)
//#define KEY1_UNPRESSED() ((KEYS1_PIN & (1<<BIT_KEY1) == 1)

#define Set_Is_Key_Enter_Pressed() !(check_bit (spi_receive_buf [0], KEY_ENTER)) // Low level.
//#define Set_Is_Key_Enter_Pressed() check_bit (KEY_ENTER_PIN, KEY_ENTER) // High level.


#define Set_Is_Key_Minus_Pressed() !(check_bit (spi_receive_buf [0], KEY_MINUS)) // Low level.
//#define Set_Is_Key_Minus_Pressed() check_bit (KEY_MINUS_PIN, KEY_MINUS) // High level.

#define Set_Is_Key_Plus_Pressed()  !(check_bit (spi_receive_buf [0], KEY_PLUS)) // Low level.
//#define Set_Is_Key_Plus_Pressed()  check_bit (KEY_PLUS_PIN, KEY_PLUS) // High level.

// Ïðè ðàáîòå ñ áóôåðîì âõîäîâ (ðàñøèðåíèå ââîäà-âûâîäà):
// #define Set_Is_Key_Stop_Pressed()   check_bit (inputs_buf [0], KEY_STOP)
//==================

//==================
typedef enum _kbd_drv
{
   KBD_DRV_INIT = 0,
   KBD_DRV_NOCHANGE,
   KBD_DRV_CHANGE,
   KBD_DRV_HOLD_REPEAT,
} kbd_drv_t;
//==================

//==================
typedef enum kbd_drv_mode
{
   KBD_DRV_NO_MODE,
   KBD_DRV_NOUNPRESS,
   KBD_DRV_HOLD,
   KBD_DRV_REPEAT_1,
   KBD_DRV_REPEAT_2,
} kbd_drv_mode_t;
//==================

//==================
u08 scan_keys (void);

void kbd_drv (void);

void kbd_drv_init (void);
void kbd_drv_nochange (void);
void kbd_drv_change (void);
void kbd_drv_hold_repeat (void);

u08 recoding_keys (void);

u08 GetKeyCode (void);
//==================

#endif

//==================
#include "kbd_drv.h"
//==================

//==================
static kbd_drv_t _kbd_drv;
static kbd_drv_mode_t kbd_drv_mode;

static u08 keys_prev;
static u08 keys_curr;
static u08 keys_buf;

static soft_timer ST_KBD_1;
static soft_timer ST_KBD_2;
//==================

//==================
u08 scan_keys (void)
{
   u08 a = 0;

   if (Set_Is_Key_Enter_Pressed ())   a |= KEY_ENTER_BIT;
   if (Set_Is_Key_Plus_Pressed ())    a |= KEY_PLUS_BIT;
   if (Set_Is_Key_Minus_Pressed ())   a |= KEY_MINUS_BIT;

   return a;
}
//==================

//==================
void kbd_drv (void)
{
   keys_curr = scan_keys ();

   switch (_kbd_drv)
   {
      case KBD_DRV_INIT:        kbd_drv_init ();        break;
      case KBD_DRV_NOCHANGE:    kbd_drv_nochange ();    break;
      case KBD_DRV_CHANGE:      kbd_drv_change ();      break;
      case KBD_DRV_HOLD_REPEAT: kbd_drv_hold_repeat (); break;
   }
}
//==================

//==================
#ifdef __PROJECT_MODE_WORK__
#pragma inline = forced
#endif
void kbd_drv_init (void)
{
   #ifdef __PROJECT_MODE_DEBUG__
   spi_receive_buf [0] = 0xFF;
   #endif

   kbd_drv_mode = KBD_DRV_NOUNPRESS;
   keys_prev = 0xFF;
   _kbd_drv = KBD_DRV_NOCHANGE;
}
//----------
#ifdef __PROJECT_MODE_WORK__
#pragma inline = forced
#endif
void kbd_drv_nochange (void)
{
   if (keys_prev != keys_curr) // Если предыдущее состояние кнопок не равно предыдущему.
   {
      keys_prev = keys_curr;

      reset_soft_timer (ST_KBD_2);
      set_soft_timer (ST_KBD_1, DEBOUNCE_DELAY, 0); // Таймер подавления дребезга.
      _kbd_drv = KBD_DRV_CHANGE;
   }
}
//----------
#ifdef __PROJECT_MODE_WORK__
#pragma inline = forced
#endif
void kbd_drv_change (void)
{
   if (keys_prev == keys_curr)
   {
      if (handle_soft_timer (ST_KBD_1)) // Таймер подавления дребезга.
      {
         if (keys_curr)
         {
            Set_Event (EV_ID_KEY_PRESSED, USER_EVENT);
            keys_buf = recoding_keys ();

            set_soft_timer (ST_KBD_1, HOLD_1_DELAY, 0); // Установка таймера удержания.
            kbd_drv_mode = KBD_DRV_HOLD;

            _kbd_drv = KBD_DRV_HOLD_REPEAT;
         }
         else
         {
            if (kbd_drv_mode == KBD_DRV_NOUNPRESS)
               kbd_drv_mode = KBD_DRV_NO_MODE;
            else
               Set_Event (EV_ID_KEY_UNPRESSED, USER_EVENT);

            _kbd_drv = KBD_DRV_NOCHANGE;
         }
      }
   }
   else
      _kbd_drv = KBD_DRV_NOCHANGE;
}
//----------
#ifdef __PROJECT_MODE_WORK__
#pragma inline = forced
#endif
void kbd_drv_hold_repeat (void)
{
   if (keys_prev == keys_curr)
   {
      switch (kbd_drv_mode)
      {
         case KBD_DRV_HOLD:
            if (handle_soft_timer (ST_KBD_1))
            {
               Set_Event (EV_ID_KEY_PRESSED, USER_EVENT);
               keys_buf = (recoding_keys () | HOLD);

               set_soft_timer (ST_KBD_1, REPEAT_1_DELAY, REPEAT_1_DELAY);
               set_soft_timer (ST_KBD_2, HOLD_2_DELAY, 0);

               kbd_drv_mode = KBD_DRV_REPEAT_1;
            }
            break;

         case KBD_DRV_REPEAT_1:
            if (handle_soft_timer (ST_KBD_2))
            {
               set_soft_timer (ST_KBD_1, 0, REPEAT_2_DELAY);

               kbd_drv_mode = KBD_DRV_REPEAT_2;
               return;
            }

         case KBD_DRV_REPEAT_2:
            if (handle_soft_timer (ST_KBD_1))
            {
               Set_Event (EV_ID_KEY_PRESSED, USER_EVENT);
               keys_buf = (recoding_keys () | REPEAT);
            }
            break;
      }
   }
   else
      _kbd_drv = KBD_DRV_NOCHANGE;
}
//==================

//==================
u08 recoding_keys (void)
{
   switch (keys_curr)
   {
      case KEY_ENTER_BIT: return KEY_ENTER_COD;
      case KEY_PLUS_BIT:  return KEY_PLUS_COD;
      case KEY_MINUS_BIT: return KEY_MINUS_COD;
   }

   return 0;
}
//==================

//==================
u08 GetKeyCode (void)
{
   return keys_buf;
}
//==================

      // Чтение клавиатуры
      Key = 0;
      OldKey = 0;
      KeyCount = 0;
      do
         {
            Key = (~PIND) & (PINMODE|PINSET0|PINPLUS|PINMINUS);
            if (Key == OldKey)
            {
               KeyCount++;
            }
            else
            {
               KeyCount = 0;
               OldKey = Key;
            }
            _delay_ms(20);
         }
      while (KeyCount<5);