logo

qmk_firmware

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

keyboard.c (19799B)

    

  1. /*
  2. Copyright 2011, 2012, 2013 Jun Wako <wakojun@gmail.com>
  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.
  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.
  14. You should have received a copy of the GNU General Public License
  15. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. */
  18. #include <stdint.h>
  19. #include "keyboard.h"
  20. #include "keycode_config.h"
  21. #include "matrix.h"
  22. #include "keymap_introspection.h"
  23. #include "host.h"
  24. #include "led.h"
  25. #include "keycode.h"
  26. #include "timer.h"
  27. #include "sync_timer.h"
  28. #include "print.h"
  29. #include "debug.h"
  30. #include "command.h"
  31. #include "util.h"
  32. #include "sendchar.h"
  33. #include "eeconfig.h"
  34. #include "action_layer.h"
  35. #ifdef BOOTMAGIC_ENABLE
  36. #    include "bootmagic.h"
  37. #endif
  38. #ifdef AUDIO_ENABLE
  39. #    include "audio.h"
  40. #endif
  41. #if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
  42. #    include "process_music.h"
  43. #endif
  44. #ifdef BACKLIGHT_ENABLE
  45. #    include "backlight.h"
  46. #endif
  47. #ifdef MOUSEKEY_ENABLE
  48. #    include "mousekey.h"
  49. #endif
  50. #ifdef PS2_MOUSE_ENABLE
  51. #    include "ps2_mouse.h"
  52. #endif
  53. #ifdef RGBLIGHT_ENABLE
  54. #    include "rgblight.h"
  55. #endif
  56. #ifdef LED_MATRIX_ENABLE
  57. #    include "led_matrix.h"
  58. #endif
  59. #ifdef RGB_MATRIX_ENABLE
  60. #    include "rgb_matrix.h"
  61. #endif
  62. #ifdef ENCODER_ENABLE
  63. #    include "encoder.h"
  64. #endif
  65. #ifdef HAPTIC_ENABLE
  66. #    include "haptic.h"
  67. #endif
  68. #ifdef AUTO_SHIFT_ENABLE
  69. #    include "process_auto_shift.h"
  70. #endif
  71. #ifdef COMBO_ENABLE
  72. #    include "process_combo.h"
  73. #endif
  74. #ifdef TAP_DANCE_ENABLE
  75. #    include "process_tap_dance.h"
  76. #endif
  77. #ifdef STENO_ENABLE
  78. #    include "process_steno.h"
  79. #endif
  80. #ifdef KEY_OVERRIDE_ENABLE
  81. #    include "process_key_override.h"
  82. #endif
  83. #ifdef SECURE_ENABLE
  84. #    include "secure.h"
  85. #endif
  86. #ifdef POINTING_DEVICE_ENABLE
  87. #    include "pointing_device.h"
  88. #endif
  89. #ifdef MIDI_ENABLE
  90. #    include "process_midi.h"
  91. #endif
  92. #ifdef JOYSTICK_ENABLE
  93. #    include "joystick.h"
  94. #endif
  95. #ifdef HD44780_ENABLE
  96. #    include "hd44780.h"
  97. #endif
  98. #ifdef OLED_ENABLE
  99. #    include "oled_driver.h"
  100. #endif
  101. #ifdef ST7565_ENABLE
  102. #    include "st7565.h"
  103. #endif
  104. #ifdef VIA_ENABLE
  105. #    include "via.h"
  106. #endif
  107. #ifdef DIP_SWITCH_ENABLE
  108. #    include "dip_switch.h"
  109. #endif
  110. #ifdef EEPROM_DRIVER
  111. #    include "eeprom_driver.h"
  112. #endif
  113. #if defined(CRC_ENABLE)
  114. #    include "crc.h"
  115. #endif
  116. #ifdef VIRTSER_ENABLE
  117. #    include "virtser.h"
  118. #endif
  119. #ifdef SLEEP_LED_ENABLE
  120. #    include "sleep_led.h"
  121. #endif
  122. #ifdef SPLIT_KEYBOARD
  123. #    include "split_util.h"
  124. #endif
  125. #ifdef BATTERY_DRIVER
  126. #    include "battery.h"
  127. #endif
  128. #ifdef BLUETOOTH_ENABLE
  129. #    include "bluetooth.h"
  130. #endif
  131. #ifdef CAPS_WORD_ENABLE
  132. #    include "caps_word.h"
  133. #endif
  134. #ifdef LEADER_ENABLE
  135. #    include "leader.h"
  136. #endif
  137. #ifdef UNICODE_COMMON_ENABLE
  138. #    include "unicode.h"
  139. #endif
  140. #ifdef WPM_ENABLE
  141. #    include "wpm.h"
  142. #endif
  143. #ifdef OS_DETECTION_ENABLE
  144. #    include "os_detection.h"
  145. #endif
  146. #ifdef LAYER_LOCK_ENABLE
  147. #    include "layer_lock.h"
  148. #endif
  149. #ifdef CONNECTION_ENABLE
  150. #    include "connection.h"
  151. #endif
  153. static uint32_t last_input_modification_time = 0;
  154. uint32_t        last_input_activity_time(void) {
  155.     return last_input_modification_time;
  156. }
  157. uint32_t last_input_activity_elapsed(void) {
  158.     return sync_timer_elapsed32(last_input_modification_time);
  159. }
  161. static uint32_t last_matrix_modification_time = 0;
  162. uint32_t        last_matrix_activity_time(void) {
  163.     return last_matrix_modification_time;
  164. }
  165. uint32_t last_matrix_activity_elapsed(void) {
  166.     return sync_timer_elapsed32(last_matrix_modification_time);
  167. }
  168. void last_matrix_activity_trigger(void) {
  169.     last_matrix_modification_time = last_input_modification_time = sync_timer_read32();
  170. }
  172. static uint32_t last_encoder_modification_time = 0;
  173. uint32_t        last_encoder_activity_time(void) {
  174.     return last_encoder_modification_time;
  175. }
  176. uint32_t last_encoder_activity_elapsed(void) {
  177.     return sync_timer_elapsed32(last_encoder_modification_time);
  178. }
  179. void last_encoder_activity_trigger(void) {
  180.     last_encoder_modification_time = last_input_modification_time = sync_timer_read32();
  181. }
  183. static uint32_t last_pointing_device_modification_time = 0;
  184. uint32_t        last_pointing_device_activity_time(void) {
  185.     return last_pointing_device_modification_time;
  186. }
  187. uint32_t last_pointing_device_activity_elapsed(void) {
  188.     return sync_timer_elapsed32(last_pointing_device_modification_time);
  189. }
  190. void last_pointing_device_activity_trigger(void) {
  191.     last_pointing_device_modification_time = last_input_modification_time = sync_timer_read32();
  192. }
  194. void set_activity_timestamps(uint32_t matrix_timestamp, uint32_t encoder_timestamp, uint32_t pointing_device_timestamp) {
  195.     last_matrix_modification_time          = matrix_timestamp;
  196.     last_encoder_modification_time         = encoder_timestamp;
  197.     last_pointing_device_modification_time = pointing_device_timestamp;
  198.     last_input_modification_time           = MAX(matrix_timestamp, MAX(encoder_timestamp, pointing_device_timestamp));
  199. }
  201. // Only enable this if console is enabled to print to
  202. #if defined(DEBUG_MATRIX_SCAN_RATE)
  203. static uint32_t matrix_timer           = 0;
  204. static uint32_t matrix_scan_count      = 0;
  205. static uint32_t last_matrix_scan_count = 0;
  207. void matrix_scan_perf_task(void) {
  208.     matrix_scan_count++;
  210.     uint32_t timer_now = timer_read32();
  211.     if (TIMER_DIFF_32(timer_now, matrix_timer) >= 1000) {
  212. #    if defined(CONSOLE_ENABLE)
  213.         dprintf("matrix scan frequency: %lu\n", matrix_scan_count);
  214. #    endif
  215.         last_matrix_scan_count = matrix_scan_count;
  216.         matrix_timer           = timer_now;
  217.         matrix_scan_count      = 0;
  218.     }
  219. }
  221. uint32_t get_matrix_scan_rate(void) {
  222.     return last_matrix_scan_count;
  223. }
  224. #else
  225. #    define matrix_scan_perf_task()
  226. #endif
  228. #ifdef MATRIX_HAS_GHOST
  229. static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata) {
  230.     matrix_row_t out = 0;
  231.     for (uint8_t col = 0; col < MATRIX_COLS; col++) {
  232.         // read each key in the row data and check if the keymap defines it as a real key
  233.         if (keycode_at_keymap_location(0, row, col) && (rowdata & (((matrix_row_t)1) << col))) {
  234.             // this creates new row data, if a key is defined in the keymap, it will be set here
  235.             out |= ((matrix_row_t)1) << col;
  236.         }
  237.     }
  238.     return out;
  239. }
  241. static inline bool popcount_more_than_one(matrix_row_t rowdata) {
  242.     rowdata &= rowdata - 1; // if there are less than two bits (keys) set, rowdata will become zero
  243.     return rowdata;
  244. }
  246. static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata) {
  247.     /* No ghost exists when less than 2 keys are down on the row.
  248.     If there are "active" blanks in the matrix, the key can't be pressed by the user,
  249.     there is no doubt as to which keys are really being pressed.
  250.     The ghosts will be ignored, they are KC_NO.   */
  251.     rowdata = get_real_keys(row, rowdata);
  252.     if ((popcount_more_than_one(rowdata)) == 0) {
  253.         return false;
  254.     }
  255.     /* Ghost occurs when the row shares a column line with other row,
  256.     and two columns are read on each row. Blanks in the matrix don't matter,
  257.     so they are filtered out.
  258.     If there are two or more real keys pressed and they match columns with
  259.     at least two of another row's real keys, the row will be ignored. Keep in mind,
  260.     we are checking one row at a time, not all of them at once.
  261.     */
  262.     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  263.         if (i != row && popcount_more_than_one(get_real_keys(i, matrix_get_row(i)) & rowdata)) {
  264.             return true;
  265.         }
  266.     }
  267.     return false;
  268. }
  270. #else
  272. static inline bool has_ghost_in_row(uint8_t row, matrix_row_t rowdata) {
  273.     return false;
  274. }
  276. #endif
  278. /** \brief matrix_setup
  279.  *
  280.  * FIXME: needs doc
  281.  */
  282. __attribute__((weak)) void matrix_setup(void) {}
  284. /** \brief keyboard_pre_init_user
  285.  *
  286.  * FIXME: needs doc
  287.  */
  288. __attribute__((weak)) void keyboard_pre_init_user(void) {}
  290. /** \brief keyboard_pre_init_kb
  291.  *
  292.  * FIXME: needs doc
  293.  */
  294. __attribute__((weak)) void keyboard_pre_init_kb(void) {
  295.     keyboard_pre_init_user();
  296. }
  298. /** \brief keyboard_pre_init_modules
  299.  *
  300.  * FIXME: needs doc
  301.  */
  302. __attribute__((weak)) void keyboard_pre_init_modules(void) {}
  304. /** \brief keyboard_pre_init_quantum
  305.  *
  306.  * FIXME: needs doc
  307.  */
  308. void keyboard_pre_init_quantum(void) {
  309.     keyboard_pre_init_modules();
  310.     keyboard_pre_init_kb();
  311. }
  313. /** \brief keyboard_post_init_user
  314.  *
  315.  * FIXME: needs doc
  316.  */
  318. __attribute__((weak)) void keyboard_post_init_user(void) {}
  320. /** \brief keyboard_post_init_kb
  321.  *
  322.  * FIXME: needs doc
  323.  */
  325. __attribute__((weak)) void keyboard_post_init_kb(void) {
  326.     keyboard_post_init_user();
  327. }
  329. /** \brief keyboard_post_init_modules
  330.  *
  331.  * FIXME: needs doc
  332.  */
  334. __attribute__((weak)) void keyboard_post_init_modules(void) {}
  336. /** \brief keyboard_post_init_quantum
  337.  *
  338.  * FIXME: needs doc
  339.  */
  341. void keyboard_post_init_quantum(void) {
  342.     keyboard_post_init_modules();
  343.     keyboard_post_init_kb();
  344. }
  346. /** \brief matrix_can_read
  347.  *
  348.  * Allows overriding when matrix scanning operations should be executed.
  349.  */
  350. __attribute__((weak)) bool matrix_can_read(void) {
  351.     return true;
  352. }
  354. /** \brief keyboard_setup
  355.  *
  356.  * FIXME: needs doc
  357.  */
  358. void keyboard_setup(void) {
  359.     print_set_sendchar(sendchar);
  360. #ifdef EEPROM_DRIVER
  361.     eeprom_driver_init();
  362. #endif
  363.     matrix_setup();
  364.     keyboard_pre_init_quantum();
  365. }
  367. #ifndef SPLIT_KEYBOARD
  369. /** \brief is_keyboard_master
  370.  *
  371.  * FIXME: needs doc
  372.  */
  373. __attribute__((weak)) bool is_keyboard_master(void) {
  374.     return true;
  375. }
  377. /** \brief is_keyboard_left
  378.  *
  379.  * FIXME: needs doc
  380.  */
  381. __attribute__((weak)) bool is_keyboard_left(void) {
  382.     return true;
  383. }
  385. #endif
  387. /** \brief should_process_keypress
  388.  *
  389.  * Override this function if you have a condition where keypresses processing should change:
  390.  *   - splits where the slave side needs to process for rgb/oled functionality
  391.  */
  392. __attribute__((weak)) bool should_process_keypress(void) {
  393.     return is_keyboard_master();
  394. }
  396. /** \brief housekeeping_task_modules
  397.  *
  398.  * Codegen will override this if community modules are enabled.
  399.  * This is specific to keyboard-level functionality.
  400.  */
  401. __attribute__((weak)) void housekeeping_task_modules(void) {}
  403. /** \brief housekeeping_task_kb
  404.  *
  405.  * Override this function if you have a need to execute code for every keyboard main loop iteration.
  406.  * This is specific to keyboard-level functionality.
  407.  */
  408. __attribute__((weak)) void housekeeping_task_kb(void) {}
  410. /** \brief housekeeping_task_user
  411.  *
  412.  * Override this function if you have a need to execute code for every keyboard main loop iteration.
  413.  * This is specific to user/keymap-level functionality.
  414.  */
  415. __attribute__((weak)) void housekeeping_task_user(void) {}
  417. /** \brief housekeeping_task
  418.  *
  419.  * Invokes hooks for executing code after QMK is done after each loop iteration.
  420.  */
  421. void housekeeping_task(void) {
  422.     housekeeping_task_modules();
  423.     housekeeping_task_kb();
  424.     housekeeping_task_user();
  425. }
  427. /** \brief quantum_init
  428.  *
  429.  * Init global state
  430.  */
  431. void quantum_init(void) {
  432.     /* check signature */
  433.     if (!eeconfig_is_enabled()) {
  434.         eeconfig_init();
  435.     }
  437.     /* init globals */
  438.     eeconfig_read_debug(&debug_config);
  439.     eeconfig_read_keymap(&keymap_config);
  441. #ifdef BOOTMAGIC_ENABLE
  442.     bootmagic();
  443. #endif
  445.     /* read here just incase bootmagic process changed its value */
  446.     layer_state_t default_layer = (layer_state_t)eeconfig_read_default_layer();
  447.     default_layer_set(default_layer);
  449.     /* Also initialize layer state to trigger callback functions for layer_state */
  450.     layer_state_set_kb((layer_state_t)layer_state);
  451. }
  453. /** \brief keyboard_init
  454.  *
  455.  * FIXME: needs doc
  456.  */
  457. void keyboard_init(void) {
  458.     timer_init();
  459.     sync_timer_init();
  460. #ifdef VIA_ENABLE
  461.     via_init();
  462. #endif
  463. #ifdef SPLIT_KEYBOARD
  464.     split_pre_init();
  465. #endif
  466. #ifdef ENCODER_ENABLE
  467.     encoder_init();
  468. #endif
  469.     matrix_init();
  470.     quantum_init();
  471. #ifdef CONNECTION_ENABLE
  472.     connection_init();
  473. #endif
  474.     led_init_ports();
  475. #ifdef BACKLIGHT_ENABLE
  476.     backlight_init_ports();
  477. #endif
  478. #ifdef AUDIO_ENABLE
  479.     audio_init();
  480. #endif
  481. #ifdef LED_MATRIX_ENABLE
  482.     led_matrix_init();
  483. #endif
  484. #ifdef RGB_MATRIX_ENABLE
  485.     rgb_matrix_init();
  486. #endif
  487. #if defined(UNICODE_COMMON_ENABLE)
  488.     unicode_input_mode_init();
  489. #endif
  490. #if defined(CRC_ENABLE)
  491.     crc_init();
  492. #endif
  493. #ifdef OLED_ENABLE
  494.     oled_init(OLED_ROTATION_0);
  495. #endif
  496. #ifdef ST7565_ENABLE
  497.     st7565_init(DISPLAY_ROTATION_0);
  498. #endif
  499. #ifdef PS2_MOUSE_ENABLE
  500.     ps2_mouse_init();
  501. #endif
  502. #ifdef BACKLIGHT_ENABLE
  503.     backlight_init();
  504. #endif
  505. #ifdef RGBLIGHT_ENABLE
  506.     rgblight_init();
  507. #endif
  508. #ifdef STENO_ENABLE_ALL
  509.     steno_init();
  510. #endif
  511. #if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
  512. #    pragma message "FORCE_NKRO option is now deprecated - Please migrate to NKRO_DEFAULT_ON instead."
  513.     keymap_config.nkro = 1;
  514.     eeconfig_update_keymap(&keymap_config);
  515. #endif
  516. #ifdef DIP_SWITCH_ENABLE
  517.     dip_switch_init();
  518. #endif
  519. #ifdef JOYSTICK_ENABLE
  520.     joystick_init();
  521. #endif
  522. #ifdef SLEEP_LED_ENABLE
  523.     sleep_led_init();
  524. #endif
  525. #ifdef VIRTSER_ENABLE
  526.     virtser_init();
  527. #endif
  528. #ifdef SPLIT_KEYBOARD
  529.     split_post_init();
  530. #endif
  531. #ifdef POINTING_DEVICE_ENABLE
  532.     // init after split init
  533.     pointing_device_init();
  534. #endif
  535. #ifdef BATTERY_DRIVER
  536.     battery_init();
  537. #endif
  538. #ifdef BLUETOOTH_ENABLE
  539.     bluetooth_init();
  540. #endif
  541. #ifdef HAPTIC_ENABLE
  542.     haptic_init();
  543. #endif
  545. #if defined(DEBUG_MATRIX_SCAN_RATE) && defined(CONSOLE_ENABLE)
  546.     debug_enable = true;
  547. #endif
  549.     keyboard_post_init_quantum(); /* Always keep this last */
  550. }
  552. /** \brief key_event_task
  553.  *
  554.  * This function is responsible for calling into other systems when they need to respond to electrical switch press events.
  555.  * This is differnet than keycode events as no layer processing, or filtering occurs.
  556.  */
  557. void switch_events(uint8_t row, uint8_t col, bool pressed) {
  558. #if defined(LED_MATRIX_ENABLE)
  559.     led_matrix_handle_key_event(row, col, pressed);
  560. #endif
  561. #if defined(RGB_MATRIX_ENABLE)
  562.     rgb_matrix_handle_key_event(row, col, pressed);
  563. #endif
  564. }
  566. /**
  567.  * @brief Generates a tick event at a maximum rate of 1KHz that drives the
  568.  * internal QMK state machine.
  569.  */
  570. static inline void generate_tick_event(void) {
  571.     static uint16_t last_tick = 0;
  572.     const uint16_t  now       = timer_read();
  573.     if (TIMER_DIFF_16(now, last_tick) != 0) {
  574.         action_exec(MAKE_TICK_EVENT);
  575.         last_tick = now;
  576.     }
  577. }
  579. /**
  580.  * @brief This task scans the keyboards matrix and processes any key presses
  581.  * that occur.
  582.  *
  583.  * @return true Matrix did change
  584.  * @return false Matrix didn't change
  585.  */
  586. static bool matrix_task(void) {
  587.     if (!matrix_can_read()) {
  588.         generate_tick_event();
  589.         return false;
  590.     }
  592.     static matrix_row_t matrix_previous[MATRIX_ROWS];
  594.     matrix_scan();
  595.     bool matrix_changed = false;
  596.     for (uint8_t row = 0; row < MATRIX_ROWS && !matrix_changed; row++) {
  597.         matrix_changed |= matrix_previous[row] ^ matrix_get_row(row);
  598.     }
  600.     matrix_scan_perf_task();
  602.     // Short-circuit the complete matrix processing if it is not necessary
  603.     if (!matrix_changed) {
  604.         generate_tick_event();
  605.         return matrix_changed;
  606.     }
  608.     if (debug_config.matrix) {
  609.         matrix_print();
  610.     }
  612.     const bool process_keypress = should_process_keypress();
  614.     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
  615.         const matrix_row_t current_row = matrix_get_row(row);
  616.         const matrix_row_t row_changes = current_row ^ matrix_previous[row];
  618.         if (!row_changes || has_ghost_in_row(row, current_row)) {
  619.             continue;
  620.         }
  622.         matrix_row_t col_mask = 1;
  623.         for (uint8_t col = 0; col < MATRIX_COLS; col++, col_mask <<= 1) {
  624.             if (row_changes & col_mask) {
  625.                 const bool key_pressed = current_row & col_mask;
  627.                 if (process_keypress) {
  628.                     action_exec(MAKE_KEYEVENT(row, col, key_pressed));
  629.                 }
  631.                 switch_events(row, col, key_pressed);
  632.             }
  633.         }
  635.         matrix_previous[row] = current_row;
  636.     }
  638.     return matrix_changed;
  639. }
  641. /** \brief Tasks previously located in matrix_scan_quantum
  642.  *
  643.  * TODO: rationalise against keyboard_task and current split role
  644.  */
  645. void quantum_task(void) {
  646. #ifdef SPLIT_KEYBOARD
  647.     // some tasks should only run on master
  648.     if (!is_keyboard_master()) return;
  649. #endif
  651. #if defined(AUDIO_ENABLE) && defined(AUDIO_INIT_DELAY)
  652.     // There are some tasks that need to be run a little bit
  653.     // after keyboard startup, or else they will not work correctly
  654.     // because of interaction with the USB device state, which
  655.     // may still be in flux...
  656.     //
  657.     // At the moment the only feature that needs this is the
  658.     // startup song.
  659.     static bool     delayed_tasks_run  = false;
  660.     static uint16_t delayed_task_timer = 0;
  661.     if (!delayed_tasks_run) {
  662.         if (!delayed_task_timer) {
  663.             delayed_task_timer = timer_read();
  664.         } else if (timer_elapsed(delayed_task_timer) > 300) {
  665.             audio_startup();
  666.             delayed_tasks_run = true;
  667.         }
  668.     }
  669. #endif
  671. #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
  672.     music_task();
  673. #endif
  675. #ifdef KEY_OVERRIDE_ENABLE
  676.     key_override_task();
  677. #endif
  679. #ifdef SEQUENCER_ENABLE
  680.     sequencer_task();
  681. #endif
  683. #ifdef TAP_DANCE_ENABLE
  684.     tap_dance_task();
  685. #endif
  687. #ifdef COMBO_ENABLE
  688.     combo_task();
  689. #endif
  691. #ifdef LEADER_ENABLE
  692.     leader_task();
  693. #endif
  695. #ifdef WPM_ENABLE
  696.     decay_wpm();
  697. #endif
  699. #ifdef DIP_SWITCH_ENABLE
  700.     dip_switch_task();
  701. #endif
  703. #ifdef AUTO_SHIFT_ENABLE
  704.     autoshift_matrix_scan();
  705. #endif
  707. #ifdef CAPS_WORD_ENABLE
  708.     caps_word_task();
  709. #endif
  711. #ifdef SECURE_ENABLE
  712.     secure_task();
  713. #endif
  715. #ifdef LAYER_LOCK_ENABLE
  716.     layer_lock_task();
  717. #endif
  718. }
  720. /** \brief Main task that is repeatedly called as fast as possible. */
  721. void keyboard_task(void) {
  722.     __attribute__((unused)) bool activity_has_occurred = false;
  723.     if (matrix_task()) {
  724.         last_matrix_activity_trigger();
  725.         activity_has_occurred = true;
  726.     }
  728.     quantum_task();
  730. #if defined(SPLIT_WATCHDOG_ENABLE)
  731.     split_watchdog_task();
  732. #endif
  734. #if defined(RGBLIGHT_ENABLE)
  735.     rgblight_task();
  736. #endif
  738. #ifdef LED_MATRIX_ENABLE
  739.     led_matrix_task();
  740. #endif
  741. #ifdef RGB_MATRIX_ENABLE
  742.     rgb_matrix_task();
  743. #endif
  745. #if defined(BACKLIGHT_ENABLE)
  746. #    if defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)
  747.     backlight_task();
  748. #    endif
  749. #endif
  751. #ifdef ENCODER_ENABLE
  752.     if (encoder_task()) {
  753.         last_encoder_activity_trigger();
  754.         activity_has_occurred = true;
  755.     }
  756. #endif
  758. #ifdef POINTING_DEVICE_ENABLE
  759.     if (pointing_device_task()) {
  760.         last_pointing_device_activity_trigger();
  761.         activity_has_occurred = true;
  762.     }
  763. #endif
  765. #ifdef OLED_ENABLE
  766.     oled_task();
  767. #    if OLED_TIMEOUT > 0
  768.     // Wake up oled if user is using those fabulous keys or spinning those encoders!
  769.     if (activity_has_occurred) oled_on();
  770. #    endif
  771. #endif
  773. #ifdef ST7565_ENABLE
  774.     st7565_task();
  775. #    if ST7565_TIMEOUT > 0
  776.     // Wake up display if user is using those fabulous keys or spinning those encoders!
  777.     if (activity_has_occurred) st7565_on();
  778. #    endif
  779. #endif
  781. #ifdef MOUSEKEY_ENABLE
  782.     // mousekey repeat & acceleration
  783.     mousekey_task();
  784. #endif
  786. #ifdef PS2_MOUSE_ENABLE
  787.     ps2_mouse_task();
  788. #endif
  790. #ifdef MIDI_ENABLE
  791.     midi_task();
  792. #endif
  794. #ifdef JOYSTICK_ENABLE
  795.     joystick_task();
  796. #endif
  798. #ifdef BATTERY_DRIVER
  799.     battery_task();
  800. #endif
  802. #ifdef BLUETOOTH_ENABLE
  803.     bluetooth_task();
  804. #endif
  806. #ifdef HAPTIC_ENABLE
  807.     haptic_task();
  808. #endif
  810.     led_task();
  812. #ifdef OS_DETECTION_ENABLE
  813.     os_detection_task();
  814. #endif
  815. }