radio/src/keys.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "opentx.h"
  22
  23 #define KEY_LONG_DELAY              32  // long key press minimum duration (x10ms), must be less than KEY_REPEAT_DELAY
  24 #define KEY_REPEAT_DELAY            40  // press longer than this enables repeat (but does not fire it yet)
  25 #define KEY_REPEAT_TRIGGER          48  // repeat trigger, used in combination with m_state to produce decreasing times between repeat events
  26 #define KEY_REPEAT_PAUSE_DELAY      64
  27
  28 #ifdef SIMU
  29   #define FILTERBITS                1   // defines how many bits are used for debounce
  30 #else
  31   #define FILTERBITS                4   // defines how many bits are used for debounce
  32 #endif
  33
  34 #define KSTATE_OFF                  0
  35 #define KSTATE_RPTDELAY             95
  36 #define KSTATE_START                97
  37 #define KSTATE_PAUSE                98
  38 #define KSTATE_KILLED               99
  39
  40
  41 event_t s_evt;
  42 struct t_inactivity inactivity = {0};
  43 Key keys[NUM_KEYS];
  44
  45 #if defined(CPUARM)
  46 event_t getEvent(bool trim)
  47 {
  48   event_t evt = s_evt;
  49   int8_t k = EVT_KEY_MASK(s_evt) - TRM_BASE;
  50   bool trim_evt = (k>=0 && k<TRM_LAST-TRM_BASE+1);
  51
  52   if (trim == trim_evt) {
  53     s_evt = 0;
  54     return evt;
  55   }
  56   else {
  57     return 0;
  58   }
  59 }
  60 #else
  61 event_t getEvent()
  62 {
  63   event_t evt = s_evt;
  64   s_evt = 0;
  65   return evt;
  66 }
  67 #endif
  68
  69 void Key::input(bool val)
  70 {
  71   // store new value in the bits that hold the key state history (used for debounce)
  72   uint8_t t_vals = m_vals ;
  73   t_vals <<= 1 ;
  74   if (val) t_vals |= 1;
  75   m_vals = t_vals ;
  76
  77   m_cnt++;
  78
  79   if (m_state && m_vals == 0) {
  80     // key is released
  81     if (m_state != KSTATE_KILLED) {
  82       // TRACE("key %d BREAK", key());
  83       putEvent(EVT_KEY_BREAK(key()));
  84     }
  85     m_state = KSTATE_OFF;
  86     m_cnt = 0;
  87     return;
  88   }
  89
  90   switch (m_state) {
  91     case KSTATE_OFF:
  92       if (m_vals == ((1<<FILTERBITS)-1)) {
  93         m_state = KSTATE_START;
  94         m_cnt = 0;
  95       }
  96       break;
  97     case KSTATE_START:
  98       // TRACE("key %d FIRST", key());
  99       putEvent(EVT_KEY_FIRST(key()));
 100       inactivity.counter = 0;
 101       m_state = KSTATE_RPTDELAY;
 102       m_cnt = 0;
 103       break;
 104
 105     case KSTATE_RPTDELAY: // gruvin: delay state before first key repeat
 106       if (m_cnt == KEY_LONG_DELAY) {
 107         // generate long key press
 108         // TRACE("key %d LONG", key());
 109         putEvent(EVT_KEY_LONG(key()));
 110       }
 111       if (m_cnt == KEY_REPEAT_DELAY) {
 112         m_state = 16;
 113         m_cnt = 0;
 114       }
 115       break;
 116
 117     case 16:
 118     case 8:
 119     case 4:
 120     case 2:
 121       if (m_cnt >= KEY_REPEAT_TRIGGER) { //3 6 12 24 48 pulses in every 480ms
 122         m_state >>= 1;
 123         m_cnt = 0;
 124       }
 125       // no break
 126     case 1:
 127       if ((m_cnt & (m_state-1)) == 0) {
 128         // this produces repeat events that at first repeat slowly and then increase in speed
 129         // TRACE("key %d REPEAT", key());
 130         if (!IS_SHIFT_KEY(key()))
 131           putEvent(EVT_KEY_REPT(key()));
 132       }
 133       break;
 134
 135     case KSTATE_PAUSE: //pause repeat events
 136       if (m_cnt >= KEY_REPEAT_PAUSE_DELAY) {
 137         m_state = 8;
 138         m_cnt = 0;
 139       }
 140       break;
 141
 142     case KSTATE_KILLED: //killed
 143       break;
 144   }
 145 }
 146
 147 void Key::pauseEvents()
 148 {
 149   m_state = KSTATE_PAUSE;
 150   m_cnt = 0;
 151 }
 152
 153 void Key::killEvents()
 154 {
 155   // TRACE("key %d killed", key());
 156   m_state = KSTATE_KILLED;
 157 }
 158
 159
 160 uint8_t Key::key() const
 161 {
 162   return (this - keys);
 163 }
 164
 165 // Introduce a slight delay in the key repeat sequence
 166 void pauseEvents(event_t event)
 167 {
 168   event = EVT_KEY_MASK(event);
 169   if (event < (int)DIM(keys)) keys[event].pauseEvents();
 170 }
 171
 172 // Disables any further event generation (BREAK and REPEAT) for this key, until the key is released
 173 void killEvents(event_t event)
 174 {
 175 #if defined(ROTARY_ENCODERS)
 176   if (event == EVT_ROTARY_LONG) {
 177     killEvents(BTN_REa + g_eeGeneral.reNavigation - 1);
 178     return;
 179   }
 180 #endif
 181
 182   event = EVT_KEY_MASK(event);
 183   if (event < (int)DIM(keys)) {
 184     keys[event].killEvents();
 185   }
 186 }
 187
 188 #if defined(CPUARM)
 189 bool clearKeyEvents()
 190 {
 191 #if defined(PCBSKY9X)
 192   CoTickDelay(100);  // 200ms
 193 #endif
 194
 195   // loop until all keys are up
 196 #if !defined(BOOT)
 197   tmr10ms_t start = get_tmr10ms();
 198 #endif
 199
 200   while (keyDown()) {
 201
 202 #if defined(SIMU)
 203     SIMU_SLEEP_NORET(1/*ms*/);
 204 #else
 205     wdt_reset();
 206 #endif
 207
 208 #if !defined(BOOT)
 209     if ((get_tmr10ms() - start) >= 300) {  // wait no more than 3 seconds
 210       //timeout expired, at least one key stuck
 211       return false;
 212     }
 213 #endif
 214   }
 215
 216   memclear(keys, sizeof(keys));
 217   putEvent(0);
 218   return true;
 219 }
 220 #else
 221 void clearKeyEvents()
 222 {
 223   // loop until all keys are up
 224   while (keyDown()) {
 225
 226 #if defined(SIMU)
 227     SIMU_SLEEP(1/*ms*/);
 228 #else
 229     wdt_reset();
 230 #endif
 231
 232 #if defined(PCBSTD) && defined(ROTARY_ENCODER_NAVIGATION) && !defined(TELEMETREZ)
 233     rotencPoll();
 234 #endif
 235   }
 236
 237   memclear(keys, sizeof(keys));
 238   putEvent(0);
 239 }
 240 #endif   // #if defined(CPUARM)