logo

qmk_firmware

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

sym_defer_pk.c (4938B)

    

  1. /*
  2. Copyright 2017 Alex Ong<the.onga@gmail.com>
  3. Copyright 2020 Andrei Purdea<andrei@purdea.ro>
  4. Copyright 2021 Simon Arlott
  5. This program is free software: you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation, either version 2 of the License, or
  8. (at your option) any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15. */
  17. /*
  18. Basic symmetric per-key algorithm. Uses an 8-bit counter per key.
  19. When no state changes have occured for DEBOUNCE milliseconds, we push the state.
  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                cooked_changed;
  52. #    define DEBOUNCE_ELAPSED 0
  54. static void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t elapsed_time);
  55. static void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
  57. // we use num_rows rather than MATRIX_ROWS to support split keyboards
  58. void debounce_init(uint8_t num_rows) {
  59.     debounce_counters = (debounce_counter_t *)malloc(num_rows * MATRIX_COLS * sizeof(debounce_counter_t));
  60.     int i             = 0;
  61.     for (uint8_t r = 0; r < num_rows; r++) {
  62.         for (uint8_t c = 0; c < MATRIX_COLS; c++) {
  63.             debounce_counters[i++] = DEBOUNCE_ELAPSED;
  64.         }
  65.     }
  66. }
  68. void debounce_free(void) {
  69.     free(debounce_counters);
  70.     debounce_counters = NULL;
  71. }
  73. bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) {
  74.     bool updated_last = false;
  75.     cooked_changed    = false;
  77.     if (counters_need_update) {
  78.         fast_timer_t now          = timer_read_fast();
  79.         fast_timer_t elapsed_time = TIMER_DIFF_FAST(now, last_time);
  81.         last_time    = now;
  82.         updated_last = true;
  83.         if (elapsed_time > UINT8_MAX) {
  84.             elapsed_time = UINT8_MAX;
  85.         }
  87.         if (elapsed_time > 0) {
  88.             update_debounce_counters_and_transfer_if_expired(raw, cooked, num_rows, elapsed_time);
  89.         }
  90.     }
  92.     if (changed) {
  93.         if (!updated_last) {
  94.             last_time = timer_read_fast();
  95.         }
  97.         start_debounce_counters(raw, cooked, num_rows);
  98.     }
  100.     return cooked_changed;
  101. }
  103. static void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t elapsed_time) {
  104.     counters_need_update                 = false;
  105.     debounce_counter_t *debounce_pointer = debounce_counters;
  106.     for (uint8_t row = 0; row < num_rows; row++) {
  107.         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  108.             if (*debounce_pointer != DEBOUNCE_ELAPSED) {
  109.                 if (*debounce_pointer <= elapsed_time) {
  110.                     *debounce_pointer        = DEBOUNCE_ELAPSED;
  111.                     matrix_row_t cooked_next = (cooked[row] & ~(ROW_SHIFTER << col)) | (raw[row] & (ROW_SHIFTER << col));
  112.                     cooked_changed |= cooked[row] ^ cooked_next;
  113.                     cooked[row] = cooked_next;
  114.                 } else {
  115.                     *debounce_pointer -= elapsed_time;
  116.                     counters_need_update = true;
  117.                 }
  118.             }
  119.             debounce_pointer++;
  120.         }
  121.     }
  122. }
  124. static void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows) {
  125.     debounce_counter_t *debounce_pointer = debounce_counters;
  126.     for (uint8_t row = 0; row < num_rows; row++) {
  127.         matrix_row_t delta = raw[row] ^ cooked[row];
  128.         for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  129.             if (delta & (ROW_SHIFTER << col)) {
  130.                 if (*debounce_pointer == DEBOUNCE_ELAPSED) {
  131.                     *debounce_pointer    = DEBOUNCE;
  132.                     counters_need_update = true;
  133.                 }
  134.             } else {
  135.                 *debounce_pointer = DEBOUNCE_ELAPSED;
  136.             }
  137.             debounce_pointer++;
  138.         }
  139.     }
  140. }
  142. #else
  143. #    include "none.c"
  144. #endif