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         putEvent(EVT_KEY_REPT(key()));
 131       }
 132       break;
 133
 134     case KSTATE_PAUSE: //pause repeat events
 135       if (m_cnt >= KEY_REPEAT_PAUSE_DELAY) {
 136         m_state = 8;
 137         m_cnt = 0;
 138       }
 139       break;
 140
 141     case KSTATE_KILLED: //killed
 142       break;
 143   }
 144 }
 145
 146 void Key::pauseEvents()
 147 {
 148   m_state = KSTATE_PAUSE;
 149   m_cnt = 0;
 150 }
 151
 152 void Key::killEvents()
 153 {
 154   // TRACE("key %d killed", key());
 155   m_state = KSTATE_KILLED;
 156 }
 157
 158
 159 uint8_t Key::key() const
 160 {
 161   return (this - keys);
 162 }
 163
 164 // Introduce a slight delay in the key repeat sequence
 165 void pauseEvents(event_t event)
 166 {
 167   event = EVT_KEY_MASK(event);
 168   if (event < (int)DIM(keys)) keys[event].pauseEvents();
 169 }
 170
 171 // Disables any further event generation (BREAK and REPEAT) for this key, until the key is released
 172 void killEvents(event_t event)
 173 {
 174 #if defined(ROTARY_ENCODERS)
 175   if (event == EVT_ROTARY_LONG) {
 176     killEvents(BTN_REa + g_eeGeneral.reNavigation - 1);
 177     return;
 178   }
 179 #endif
 180
 181   event = EVT_KEY_MASK(event);
 182   if (event < (int)DIM(keys)) {
 183     keys[event].killEvents();
 184   }
 185 }
 186
 187 #if defined(CPUARM)
 188 bool clearKeyEvents()
 189 {
 190 #if defined(PCBSKY9X)
 191   CoTickDelay(100);  // 200ms
 192 #endif
 193
 194   // loop until all keys are up
 195 #if !defined(BOOT)
 196   tmr10ms_t start = get_tmr10ms();
 197 #endif
 198
 199   while (keyDown()) {
 200
 201 #if defined(SIMU)
 202     SIMU_SLEEP_NORET(1/*ms*/);
 203 #else
 204     wdt_reset();
 205 #endif
 206
 207 #if !defined(BOOT)
 208     if ((get_tmr10ms() - start) >= 300) {  // wait no more than 3 seconds
 209       //timeout expired, at least one key stuck
 210       return false;
 211     }
 212 #endif
 213   }
 214
 215   memclear(keys, sizeof(keys));
 216   putEvent(0);
 217   return true;
 218 }
 219 #else
 220 void clearKeyEvents()
 221 {
 222   // loop until all keys are up
 223   while (keyDown()) {
 224
 225 #if defined(SIMU)
 226     SIMU_SLEEP(1/*ms*/);
 227 #else
 228     wdt_reset();
 229 #endif
 230
 231 #if defined(PCBSTD) && defined(ROTARY_ENCODER_NAVIGATION) && !defined(TELEMETREZ)
 232     rotencPoll();
 233 #endif
 234   }
 235
 236   memclear(keys, sizeof(keys));
 237   putEvent(0);
 238 }
 239 #endif   // #if defined(CPUARM)
 240
 241