logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

sym_eager_pk.c (5039B)

    

  1. /*
  2. Copyright 2017 Alex Ong<the.onga@gmail.com>
  3. Copyright 2021 Simon Arlott
  4. This program is free software: you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation, either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14. */
  16. /*
  17. Basic per-key algorithm. Uses an 8-bit counter per key.
  18. After pressing a key, it immediately changes state, and sets a counter.
  19. No further inputs are accepted until DEBOUNCE milliseconds have occurred.
  20. */
  22. #include "debounce.h"
  23. #include "timer.h"
  24. #include <stdlib.h>
  26. #ifdef PROTOCOL_CHIBIOS
  27. #    if CH_CFG_USE_MEMCORE == FALSE
  28. #        error ChibiOS is configured without a memory allocator. Your keyboard may have set `#define CH_CFG_USE_MEMCORE FALSE`, which is incompatible with this debounce algorithm.
  29. #    endif
  30. #endif
  32. #ifndef DEBOUNCE
  33. #    define DEBOUNCE 5
  34. #endif
  36. // Maximum debounce: 255ms
  37. #if DEBOUNCE > UINT8_MAX
  38. #    undef DEBOUNCE
  39. #    define DEBOUNCE UINT8_MAX
  40. #endif
  42. #define ROW_SHIFTER ((matrix_row_t)1)
  44. typedef uint8_t debounce_counter_t;
  46. #if DEBOUNCE > 0
  47. static debounce_counter_t *debounce_counters;
  48. static fast_timer_t        last_time;
  49. static bool                counters_need_update;
  50. static bool                matrix_need_update;
  51. static bool                cooked_changed;
  53. #    define DEBOUNCE_ELAPSED 0
  55. static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time);
  56. static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
  58. // we use num_rows rather than MATRIX_ROWS to support split keyboards
  59. void debounce_init(uint8_t num_rows) {
  60.     debounce_counters = (debounce_counter_t *)malloc(num_rows * MATRIX_COLS * sizeof(debounce_counter_t));
  61.     int i             = 0;
  62.     for (uint8_t r = 0; r < num_rows; r++) {
  63.         for (uint8_t c = 0; c < MATRIX_COLS; c++) {
  64.             debounce_counters[i++] = DEBOUNCE_ELAPSED;
  65.         }
  66.     }
  67. }
  69. void debounce_free(void) {
  70.     free(debounce_counters);
  71.     debounce_counters = NULL;
  72. }
  74. bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) {
  75.     bool updated_last = false;
  76.     cooked_changed    = false;
  78.     if (counters_need_update) {
  79.         fast_timer_t now          = timer_read_fast();
  80.         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
  82.         last_time    = now;
  83.         updated_last = true;
  84.         if (elapsed_time > UINT8_MAX) {
  85.             elapsed_time = UINT8_MAX;
  86.         }
  88.         if (elapsed_time > 0) {
  89.             update_debounce_counters(num_rows, elapsed_time);
  90.         }
  91.     }
  93.     if (changed || matrix_need_update) {
  94.         if (!updated_last) {
  95.             last_time = timer_read_fast();
  96.         }
  98.         transfer_matrix_values(raw, cooked, num_rows);
  99.     }
  101.     return cooked_changed;
  102. }
  104. // If the current time is > debounce counter, set the counter to enable input.
  105. static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time) {
  106.     counters_need_update                 = false;
  107.     matrix_need_update                   = false;
  108.     debounce_counter_t *debounce_pointer = debounce_counters;
  109.     for (uint8_t row = 0; row < num_rows; row++) {
  110.         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  111.             if (*debounce_pointer != DEBOUNCE_ELAPSED) {
  112.                 if (*debounce_pointer <= elapsed_time) {
  113.                     *debounce_pointer  = DEBOUNCE_ELAPSED;
  114.                     matrix_need_update = true;
  115.                 } else {
  116.                     *debounce_pointer -= elapsed_time;
  117.                     counters_need_update = true;
  118.                 }
  119.             }
  120.             debounce_pointer++;
  121.         }
  122.     }
  123. }
  125. // upload from raw_matrix to final matrix;
  126. static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows) {
  127.     matrix_need_update                   = false;
  128.     debounce_counter_t *debounce_pointer = debounce_counters;
  129.     for (uint8_t row = 0; row < num_rows; row++) {
  130.         matrix_row_t delta        = raw[row] ^ cooked[row];
  131.         matrix_row_t existing_row = cooked[row];
  132.         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  133.             matrix_row_t col_mask = (ROW_SHIFTER << col);
  134.             if (delta & col_mask) {
  135.                 if (*debounce_pointer == DEBOUNCE_ELAPSED) {
  136.                     *debounce_pointer    = DEBOUNCE;
  137.                     counters_need_update = true;
  138.                     existing_row ^= col_mask; // flip the bit.
  139.                     cooked_changed = true;
  140.                 }
  141.             }
  142.             debounce_pointer++;
  143.         }
  144.         cooked[row] = existing_row;
  145.     }
  146. }
  148. #else
  149. #    include "none.c"
  150. #endif