logo

qmk_firmware

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

led_matrix.c (22138B)

    

  1. /* Copyright 2017 Jason Williams
  2.  * Copyright 2017 Jack Humbert
  3.  * Copyright 2018 Yiancar
  4.  * Copyright 2019 Clueboard
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation, either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  */
  20. #include "led_matrix.h"
  21. #include "progmem.h"
  22. #include "eeconfig.h"
  23. #include "keyboard.h"
  24. #include "sync_timer.h"
  25. #include "debug.h"
  26. #include <string.h>
  27. #include <math.h>
  28. #include <stdlib.h>
  29. #include "led_tables.h"
  31. #include <lib/lib8tion/lib8tion.h>
  33. #ifndef LED_MATRIX_CENTER
  34. const led_point_t k_led_matrix_center = {112, 32};
  35. #else
  36. const led_point_t k_led_matrix_center = LED_MATRIX_CENTER;
  37. #endif
  39. // Generic effect runners
  40. #include "led_matrix_runners.inc"
  42. // ------------------------------------------
  43. // -----Begin led effect includes macros-----
  44. #define LED_MATRIX_EFFECT(name)
  45. #define LED_MATRIX_CUSTOM_EFFECT_IMPLS
  47. #include "led_matrix_effects.inc"
  48. #ifdef COMMUNITY_MODULES_ENABLE
  49. #    include "led_matrix_community_modules.inc"
  50. #endif
  51. #ifdef LED_MATRIX_CUSTOM_KB
  52. #    include "led_matrix_kb.inc"
  53. #endif
  54. #ifdef LED_MATRIX_CUSTOM_USER
  55. #    include "led_matrix_user.inc"
  56. #endif
  58. #undef LED_MATRIX_CUSTOM_EFFECT_IMPLS
  59. #undef LED_MATRIX_EFFECT
  60. // -----End led effect includes macros-------
  61. // ------------------------------------------
  63. // globals
  64. led_eeconfig_t led_matrix_eeconfig; // TODO: would like to prefix this with g_ for global consistancy, do this in another pr
  65. uint32_t       g_led_timer;
  66. #ifdef LED_MATRIX_FRAMEBUFFER_EFFECTS
  67. uint8_t g_led_frame_buffer[MATRIX_ROWS][MATRIX_COLS] = {{0}};
  68. #endif // LED_MATRIX_FRAMEBUFFER_EFFECTS
  69. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  70. last_hit_t g_last_hit_tracker;
  71. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  73. // internals
  74. static bool            suspend_state     = false;
  75. static uint8_t         led_last_enable   = UINT8_MAX;
  76. static uint8_t         led_last_effect   = UINT8_MAX;
  77. static effect_params_t led_effect_params = {0, LED_FLAG_ALL, false};
  78. static led_task_states led_task_state    = SYNCING;
  80. // double buffers
  81. static uint32_t led_timer_buffer;
  82. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  83. static last_hit_t last_hit_buffer;
  84. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  86. // split led matrix
  87. #if defined(LED_MATRIX_SPLIT)
  88. const uint8_t k_led_matrix_split[2] = LED_MATRIX_SPLIT;
  89. #endif
  91. EECONFIG_DEBOUNCE_HELPER(led_matrix, led_matrix_eeconfig);
  93. void eeconfig_force_flush_led_matrix(void) {
  94.     eeconfig_flush_led_matrix(true);
  95. }
  97. void eeconfig_update_led_matrix_default(void) {
  98.     dprintf("eeconfig_update_led_matrix_default\n");
  99.     led_matrix_eeconfig.enable = LED_MATRIX_DEFAULT_ON;
  100.     led_matrix_eeconfig.mode   = LED_MATRIX_DEFAULT_MODE;
  101.     led_matrix_eeconfig.val    = LED_MATRIX_DEFAULT_VAL;
  102.     led_matrix_eeconfig.speed  = LED_MATRIX_DEFAULT_SPD;
  103.     led_matrix_eeconfig.flags  = LED_MATRIX_DEFAULT_FLAGS;
  104.     eeconfig_flush_led_matrix(true);
  105. }
  107. void eeconfig_debug_led_matrix(void) {
  108.     dprintf("led_matrix_eeconfig EEPROM\n");
  109.     dprintf("led_matrix_eeconfig.enable = %d\n", led_matrix_eeconfig.enable);
  110.     dprintf("led_matrix_eeconfig.mode = %d\n", led_matrix_eeconfig.mode);
  111.     dprintf("led_matrix_eeconfig.val = %d\n", led_matrix_eeconfig.val);
  112.     dprintf("led_matrix_eeconfig.speed = %d\n", led_matrix_eeconfig.speed);
  113.     dprintf("led_matrix_eeconfig.flags = %d\n", led_matrix_eeconfig.flags);
  114. }
  116. void led_matrix_reload_from_eeprom(void) {
  117.     led_matrix_disable_noeeprom();
  118.     /* Reset back to what we have in eeprom */
  119.     eeconfig_init_led_matrix();
  120.     eeconfig_debug_led_matrix(); // display current eeprom values
  121.     if (led_matrix_eeconfig.enable) {
  122.         led_matrix_mode_noeeprom(led_matrix_eeconfig.mode);
  123.     }
  124. }
  126. __attribute__((weak)) uint8_t led_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) {
  127.     return 0;
  128. }
  130. uint8_t led_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) {
  131.     uint8_t led_count = led_matrix_map_row_column_to_led_kb(row, column, led_i);
  132.     uint8_t led_index = g_led_config.matrix_co[row][column];
  133.     if (led_index != NO_LED) {
  134.         led_i[led_count] = led_index;
  135.         led_count++;
  136.     }
  137.     return led_count;
  138. }
  140. void led_matrix_update_pwm_buffers(void) {
  141.     led_matrix_driver.flush();
  142. }
  144. __attribute__((weak)) int led_matrix_led_index(int index) {
  145. #if defined(LED_MATRIX_SPLIT)
  146.     if (!is_keyboard_left() && index >= k_led_matrix_split[0]) {
  147.         return index - k_led_matrix_split[0];
  148.     }
  149. #endif
  150.     return index;
  151. }
  153. void led_matrix_set_value(int index, uint8_t value) {
  154. #ifdef USE_CIE1931_CURVE
  155.     value = pgm_read_byte(&CIE1931_CURVE[value]);
  156. #endif
  157.     led_matrix_driver.set_value(led_matrix_led_index(index), value);
  158. }
  160. void led_matrix_set_value_all(uint8_t value) {
  161. #if defined(LED_MATRIX_SPLIT)
  162.     for (uint8_t i = 0; i < LED_MATRIX_LED_COUNT; i++)
  163.         led_matrix_set_value(i, value);
  164. #else
  165. #    ifdef USE_CIE1931_CURVE
  166.     led_matrix_driver.set_value_all(pgm_read_byte(&CIE1931_CURVE[value]));
  167. #    else
  168.     led_matrix_driver.set_value_all(value);
  169. #    endif
  170. #endif
  171. }
  173. void led_matrix_handle_key_event(uint8_t row, uint8_t col, bool pressed) {
  174. #ifndef LED_MATRIX_SPLIT
  175.     if (!is_keyboard_master()) return;
  176. #endif
  178. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  179.     uint8_t led[LED_HITS_TO_REMEMBER];
  180.     uint8_t led_count = 0;
  182. #    if defined(LED_MATRIX_KEYRELEASES)
  183.     if (!pressed)
  184. #    elif defined(LED_MATRIX_KEYPRESSES)
  185.     if (pressed)
  186. #    endif // defined(LED_MATRIX_KEYRELEASES)
  187.     {
  188.         led_count = led_matrix_map_row_column_to_led(row, col, led);
  189.     }
  191.     if (last_hit_buffer.count + led_count > LED_HITS_TO_REMEMBER) {
  192.         memcpy(&last_hit_buffer.x[0], &last_hit_buffer.x[led_count], LED_HITS_TO_REMEMBER - led_count);
  193.         memcpy(&last_hit_buffer.y[0], &last_hit_buffer.y[led_count], LED_HITS_TO_REMEMBER - led_count);
  194.         memcpy(&last_hit_buffer.tick[0], &last_hit_buffer.tick[led_count], (LED_HITS_TO_REMEMBER - led_count) * 2); // 16 bit
  195.         memcpy(&last_hit_buffer.index[0], &last_hit_buffer.index[led_count], LED_HITS_TO_REMEMBER - led_count);
  196.         last_hit_buffer.count = LED_HITS_TO_REMEMBER - led_count;
  197.     }
  199.     for (uint8_t i = 0; i < led_count; i++) {
  200.         uint8_t index                = last_hit_buffer.count;
  201.         last_hit_buffer.x[index]     = g_led_config.point[led[i]].x;
  202.         last_hit_buffer.y[index]     = g_led_config.point[led[i]].y;
  203.         last_hit_buffer.index[index] = led[i];
  204.         last_hit_buffer.tick[index]  = 0;
  205.         last_hit_buffer.count++;
  206.     }
  207. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  209. #if defined(LED_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_LED_MATRIX_TYPING_HEATMAP)
  210.     if (led_matrix_eeconfig.mode == LED_MATRIX_TYPING_HEATMAP) {
  211.         process_led_matrix_typing_heatmap(row, col);
  212.     }
  213. #endif // defined(LED_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_LED_MATRIX_TYPING_HEATMAP)
  214. }
  216. static bool led_matrix_none(effect_params_t *params) {
  217.     if (!params->init) {
  218.         return false;
  219.     }
  221.     led_matrix_set_value_all(0);
  222.     return false;
  223. }
  225. static void led_task_timers(void) {
  226. #if defined(LED_MATRIX_KEYREACTIVE_ENABLED)
  227.     uint32_t deltaTime = sync_timer_elapsed32(led_timer_buffer);
  228. #endif // defined(LED_MATRIX_KEYREACTIVE_ENABLED)
  229.     led_timer_buffer = sync_timer_read32();
  231.     // Update double buffer last hit timers
  232. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  233.     uint8_t count = last_hit_buffer.count;
  234.     for (uint8_t i = 0; i < count; ++i) {
  235.         if (UINT16_MAX - deltaTime < last_hit_buffer.tick[i]) {
  236.             last_hit_buffer.count--;
  237.             continue;
  238.         }
  239.         last_hit_buffer.tick[i] += deltaTime;
  240.     }
  241. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  242. }
  244. static void led_task_sync(void) {
  245.     eeconfig_flush_led_matrix(false);
  246.     // next task
  247.     if (sync_timer_elapsed32(g_led_timer) >= LED_MATRIX_LED_FLUSH_LIMIT) led_task_state = STARTING;
  248. }
  250. static void led_task_start(void) {
  251.     // reset iter
  252.     led_effect_params.iter = 0;
  254.     // update double buffers
  255.     g_led_timer = led_timer_buffer;
  256. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  257.     g_last_hit_tracker = last_hit_buffer;
  258. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  260.     // next task
  261.     led_task_state = RENDERING;
  262. }
  264. static void led_task_render(uint8_t effect) {
  265.     bool rendering         = false;
  266.     led_effect_params.init = (effect != led_last_effect) || (led_matrix_eeconfig.enable != led_last_enable);
  267.     if (led_effect_params.flags != led_matrix_eeconfig.flags) {
  268.         led_effect_params.flags = led_matrix_eeconfig.flags;
  269.         led_matrix_set_value_all(0);
  270.     }
  272.     // each effect can opt to do calculations
  273.     // and/or request PWM buffer updates.
  274.     switch (effect) {
  275.         case LED_MATRIX_NONE:
  276.             rendering = led_matrix_none(&led_effect_params);
  277.             break;
  279. // ---------------------------------------------
  280. // -----Begin led effect switch case macros-----
  281. #define LED_MATRIX_EFFECT(name, ...)          \
  282.     case LED_MATRIX_##name:                   \
  283.         rendering = name(&led_effect_params); \
  284.         break;
  285. #include "led_matrix_effects.inc"
  286. #undef LED_MATRIX_EFFECT
  288. #ifdef COMMUNITY_MODULES_ENABLE
  289. #    define LED_MATRIX_EFFECT(name, ...)          \
  290.         case LED_MATRIX_COMMUNITY_MODULE_##name:  \
  291.             rendering = name(&led_effect_params); \
  292.             break;
  293. #    include "led_matrix_community_modules.inc"
  294. #    undef LED_MATRIX_EFFECT
  295. #endif
  297. #if defined(LED_MATRIX_CUSTOM_KB) || defined(LED_MATRIX_CUSTOM_USER)
  298. #    define LED_MATRIX_EFFECT(name, ...)          \
  299.         case LED_MATRIX_CUSTOM_##name:            \
  300.             rendering = name(&led_effect_params); \
  301.             break;
  302. #    ifdef LED_MATRIX_CUSTOM_KB
  303. #        include "led_matrix_kb.inc"
  304. #    endif
  305. #    ifdef LED_MATRIX_CUSTOM_USER
  306. #        include "led_matrix_user.inc"
  307. #    endif
  308. #    undef LED_MATRIX_EFFECT
  309. #endif
  310.             // -----End led effect switch case macros-------
  311.             // ---------------------------------------------
  312.     }
  314.     led_effect_params.iter++;
  316.     // next task
  317.     if (!rendering) {
  318.         led_task_state = FLUSHING;
  319.         if (!led_effect_params.init && effect == LED_MATRIX_NONE) {
  320.             // We only need to flush once if we are LED_MATRIX_NONE
  321.             led_task_state = SYNCING;
  322.         }
  323.     }
  324. }
  326. static void led_task_flush(uint8_t effect) {
  327.     // update last trackers after the first full render so we can init over several frames
  328.     led_last_effect = effect;
  329.     led_last_enable = led_matrix_eeconfig.enable;
  331.     // update pwm buffers
  332.     led_matrix_update_pwm_buffers();
  334.     // next task
  335.     led_task_state = SYNCING;
  336. }
  338. void led_matrix_task(void) {
  339.     led_task_timers();
  341.     // Ideally we would also stop sending zeros to the LED driver PWM buffers
  342.     // while suspended and just do a software shutdown. This is a cheap hack for now.
  343.     bool suspend_backlight = suspend_state ||
  344. #if LED_MATRIX_TIMEOUT > 0
  345.                              (last_input_activity_elapsed() > (uint32_t)LED_MATRIX_TIMEOUT) ||
  346. #endif // LED_MATRIX_TIMEOUT > 0
  347.                              false;
  349.     uint8_t effect = suspend_backlight || !led_matrix_eeconfig.enable ? 0 : led_matrix_eeconfig.mode;
  351.     switch (led_task_state) {
  352.         case STARTING:
  353.             led_task_start();
  354.             break;
  355.         case RENDERING:
  356.             led_task_render(effect);
  357.             if (effect) {
  358.                 if (led_task_state == FLUSHING) {
  359.                     led_matrix_indicators(); // ensure we only draw basic indicators once rendering is finished
  360.                 }
  361.                 led_matrix_indicators_advanced(&led_effect_params);
  362.             }
  363.             break;
  364.         case FLUSHING:
  365.             led_task_flush(effect);
  366.             break;
  367.         case SYNCING:
  368.             led_task_sync();
  369.             break;
  370.     }
  371. }
  373. __attribute__((weak)) bool led_matrix_indicators_modules(void) {
  374.     return true;
  375. }
  377. void led_matrix_indicators(void) {
  378.     led_matrix_indicators_modules();
  379.     led_matrix_indicators_kb();
  380. }
  382. __attribute__((weak)) bool led_matrix_indicators_kb(void) {
  383.     return led_matrix_indicators_user();
  384. }
  386. __attribute__((weak)) bool led_matrix_indicators_user(void) {
  387.     return true;
  388. }
  390. __attribute__((weak)) bool led_matrix_indicators_advanced_modules(uint8_t led_min, uint8_t led_max) {
  391.     return true;
  392. }
  394. void led_matrix_indicators_advanced(effect_params_t *params) {
  395.     /* special handling is needed for "params->iter", since it's already been incremented.
  396.      * Could move the invocations to led_task_render, but then it's missing a few checks
  397.      * and not sure which would be better. Otherwise, this should be called from
  398.      * led_task_render, right before the iter++ line.
  399.      */
  400.     LED_MATRIX_USE_LIMITS_ITER(min, max, params->iter - 1);
  401.     led_matrix_indicators_advanced_modules(min, max);
  402.     led_matrix_indicators_advanced_kb(min, max);
  403. }
  405. __attribute__((weak)) bool led_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {
  406.     return led_matrix_indicators_advanced_user(led_min, led_max);
  407. }
  409. __attribute__((weak)) bool led_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
  410.     return true;
  411. }
  413. struct led_matrix_limits_t led_matrix_get_limits(uint8_t iter) {
  414.     struct led_matrix_limits_t limits = {0};
  415. #if defined(LED_MATRIX_LED_PROCESS_LIMIT) && LED_MATRIX_LED_PROCESS_LIMIT > 0 && LED_MATRIX_LED_PROCESS_LIMIT < LED_MATRIX_LED_COUNT
  416. #    if defined(LED_MATRIX_SPLIT)
  417.     limits.led_min_index = LED_MATRIX_LED_PROCESS_LIMIT * (iter);
  418.     limits.led_max_index = limits.led_min_index + LED_MATRIX_LED_PROCESS_LIMIT;
  419.     if (limits.led_max_index > LED_MATRIX_LED_COUNT) limits.led_max_index = LED_MATRIX_LED_COUNT;
  420.     if (is_keyboard_left() && (limits.led_max_index > k_led_matrix_split[0])) limits.led_max_index = k_led_matrix_split[0];
  421.     if (!(is_keyboard_left()) && (limits.led_min_index < k_led_matrix_split[0])) limits.led_min_index = k_led_matrix_split[0];
  422. #    else
  423.     limits.led_min_index = LED_MATRIX_LED_PROCESS_LIMIT * (iter);
  424.     limits.led_max_index = limits.led_min_index + LED_MATRIX_LED_PROCESS_LIMIT;
  425.     if (limits.led_max_index > LED_MATRIX_LED_COUNT) limits.led_max_index = LED_MATRIX_LED_COUNT;
  426. #    endif
  427. #else
  428. #    if defined(LED_MATRIX_SPLIT)
  429.     limits.led_min_index = 0;
  430.     limits.led_max_index = LED_MATRIX_LED_COUNT;
  431.     if (is_keyboard_left() && (limits.led_max_index > k_led_matrix_split[0])) limits.led_max_index = k_led_matrix_split[0];
  432.     if (!(is_keyboard_left()) && (limits.led_min_index < k_led_matrix_split[0])) limits.led_min_index = k_led_matrix_split[0];
  433. #    else
  434.     limits.led_min_index = 0;
  435.     limits.led_max_index = LED_MATRIX_LED_COUNT;
  436. #    endif
  437. #endif
  438.     return limits;
  439. }
  441. void led_matrix_init(void) {
  442.     led_matrix_driver.init();
  444. #ifdef LED_MATRIX_KEYREACTIVE_ENABLED
  445.     g_last_hit_tracker.count = 0;
  446.     for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  447.         g_last_hit_tracker.tick[i] = UINT16_MAX;
  448.     }
  450.     last_hit_buffer.count = 0;
  451.     for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  452.         last_hit_buffer.tick[i] = UINT16_MAX;
  453.     }
  454. #endif // LED_MATRIX_KEYREACTIVE_ENABLED
  456.     eeconfig_init_led_matrix();
  457.     if (!led_matrix_eeconfig.mode) {
  458.         dprintf("led_matrix_init_drivers led_matrix_eeconfig.mode = 0. Write default values to EEPROM.\n");
  459.         eeconfig_update_led_matrix_default();
  460.     }
  461.     eeconfig_debug_led_matrix(); // display current eeprom values
  462. }
  464. void led_matrix_set_suspend_state(bool state) {
  465. #ifdef LED_MATRIX_SLEEP
  466.     if (state && !suspend_state && is_keyboard_master()) { // only run if turning off, and only once
  467.         led_task_render(0);                                // turn off all LEDs when suspending
  468.         led_task_flush(0);                                 // and actually flash led state to LEDs
  469.     }
  470.     suspend_state = state;
  471. #endif
  472. }
  474. bool led_matrix_get_suspend_state(void) {
  475.     return suspend_state;
  476. }
  478. void led_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
  479.     led_matrix_eeconfig.enable ^= 1;
  480.     led_task_state = STARTING;
  481.     eeconfig_flag_led_matrix(write_to_eeprom);
  482.     dprintf("led matrix toggle [%s]: led_matrix_eeconfig.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.enable);
  483. }
  484. void led_matrix_toggle_noeeprom(void) {
  485.     led_matrix_toggle_eeprom_helper(false);
  486. }
  487. void led_matrix_toggle(void) {
  488.     led_matrix_toggle_eeprom_helper(true);
  489. }
  491. void led_matrix_enable(void) {
  492.     led_matrix_enable_noeeprom();
  493.     eeconfig_flag_led_matrix(true);
  494. }
  496. void led_matrix_enable_noeeprom(void) {
  497.     if (!led_matrix_eeconfig.enable) led_task_state = STARTING;
  498.     led_matrix_eeconfig.enable = 1;
  499. }
  501. void led_matrix_disable(void) {
  502.     led_matrix_disable_noeeprom();
  503.     eeconfig_flag_led_matrix(true);
  504. }
  506. void led_matrix_disable_noeeprom(void) {
  507.     if (led_matrix_eeconfig.enable) led_task_state = STARTING;
  508.     led_matrix_eeconfig.enable = 0;
  509. }
  511. uint8_t led_matrix_is_enabled(void) {
  512.     return led_matrix_eeconfig.enable;
  513. }
  515. void led_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
  516.     if (!led_matrix_eeconfig.enable) {
  517.         return;
  518.     }
  519.     if (mode < 1) {
  520.         led_matrix_eeconfig.mode = 1;
  521.     } else if (mode >= LED_MATRIX_EFFECT_MAX) {
  522.         led_matrix_eeconfig.mode = LED_MATRIX_EFFECT_MAX - 1;
  523.     } else {
  524.         led_matrix_eeconfig.mode = mode;
  525.     }
  526.     led_task_state = STARTING;
  527.     eeconfig_flag_led_matrix(write_to_eeprom);
  528.     dprintf("led matrix mode [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.mode);
  529. }
  530. void led_matrix_mode_noeeprom(uint8_t mode) {
  531.     led_matrix_mode_eeprom_helper(mode, false);
  532. }
  533. void led_matrix_mode(uint8_t mode) {
  534.     led_matrix_mode_eeprom_helper(mode, true);
  535. }
  537. uint8_t led_matrix_get_mode(void) {
  538.     return led_matrix_eeconfig.mode;
  539. }
  541. void led_matrix_step_helper(bool write_to_eeprom) {
  542.     uint8_t mode = led_matrix_eeconfig.mode + 1;
  543.     led_matrix_mode_eeprom_helper((mode < LED_MATRIX_EFFECT_MAX) ? mode : 1, write_to_eeprom);
  544. }
  545. void led_matrix_step_noeeprom(void) {
  546.     led_matrix_step_helper(false);
  547. }
  548. void led_matrix_step(void) {
  549.     led_matrix_step_helper(true);
  550. }
  552. void led_matrix_step_reverse_helper(bool write_to_eeprom) {
  553.     uint8_t mode = led_matrix_eeconfig.mode - 1;
  554.     led_matrix_mode_eeprom_helper((mode < 1) ? LED_MATRIX_EFFECT_MAX - 1 : mode, write_to_eeprom);
  555. }
  556. void led_matrix_step_reverse_noeeprom(void) {
  557.     led_matrix_step_reverse_helper(false);
  558. }
  559. void led_matrix_step_reverse(void) {
  560.     led_matrix_step_reverse_helper(true);
  561. }
  563. void led_matrix_set_val_eeprom_helper(uint8_t val, bool write_to_eeprom) {
  564.     if (!led_matrix_eeconfig.enable) {
  565.         return;
  566.     }
  567.     led_matrix_eeconfig.val = (val > LED_MATRIX_MAXIMUM_BRIGHTNESS) ? LED_MATRIX_MAXIMUM_BRIGHTNESS : val;
  568.     eeconfig_flag_led_matrix(write_to_eeprom);
  569.     dprintf("led matrix set val [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.val);
  570. }
  571. void led_matrix_set_val_noeeprom(uint8_t val) {
  572.     led_matrix_set_val_eeprom_helper(val, false);
  573. }
  574. void led_matrix_set_val(uint8_t val) {
  575.     led_matrix_set_val_eeprom_helper(val, true);
  576. }
  578. uint8_t led_matrix_get_val(void) {
  579.     return led_matrix_eeconfig.val;
  580. }
  582. void led_matrix_increase_val_helper(bool write_to_eeprom) {
  583.     led_matrix_set_val_eeprom_helper(qadd8(led_matrix_eeconfig.val, LED_MATRIX_VAL_STEP), write_to_eeprom);
  584. }
  585. void led_matrix_increase_val_noeeprom(void) {
  586.     led_matrix_increase_val_helper(false);
  587. }
  588. void led_matrix_increase_val(void) {
  589.     led_matrix_increase_val_helper(true);
  590. }
  592. void led_matrix_decrease_val_helper(bool write_to_eeprom) {
  593.     led_matrix_set_val_eeprom_helper(qsub8(led_matrix_eeconfig.val, LED_MATRIX_VAL_STEP), write_to_eeprom);
  594. }
  595. void led_matrix_decrease_val_noeeprom(void) {
  596.     led_matrix_decrease_val_helper(false);
  597. }
  598. void led_matrix_decrease_val(void) {
  599.     led_matrix_decrease_val_helper(true);
  600. }
  602. void led_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) {
  603.     led_matrix_eeconfig.speed = speed;
  604.     eeconfig_flag_led_matrix(write_to_eeprom);
  605.     dprintf("led matrix set speed [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.speed);
  606. }
  607. void led_matrix_set_speed_noeeprom(uint8_t speed) {
  608.     led_matrix_set_speed_eeprom_helper(speed, false);
  609. }
  610. void led_matrix_set_speed(uint8_t speed) {
  611.     led_matrix_set_speed_eeprom_helper(speed, true);
  612. }
  614. uint8_t led_matrix_get_speed(void) {
  615.     return led_matrix_eeconfig.speed;
  616. }
  618. void led_matrix_increase_speed_helper(bool write_to_eeprom) {
  619.     led_matrix_set_speed_eeprom_helper(qadd8(led_matrix_eeconfig.speed, LED_MATRIX_SPD_STEP), write_to_eeprom);
  620. }
  621. void led_matrix_increase_speed_noeeprom(void) {
  622.     led_matrix_increase_speed_helper(false);
  623. }
  624. void led_matrix_increase_speed(void) {
  625.     led_matrix_increase_speed_helper(true);
  626. }
  628. void led_matrix_decrease_speed_helper(bool write_to_eeprom) {
  629.     led_matrix_set_speed_eeprom_helper(qsub8(led_matrix_eeconfig.speed, LED_MATRIX_SPD_STEP), write_to_eeprom);
  630. }
  631. void led_matrix_decrease_speed_noeeprom(void) {
  632.     led_matrix_decrease_speed_helper(false);
  633. }
  634. void led_matrix_decrease_speed(void) {
  635.     led_matrix_decrease_speed_helper(true);
  636. }
  638. void led_matrix_set_flags_eeprom_helper(led_flags_t flags, bool write_to_eeprom) {
  639.     led_matrix_eeconfig.flags = flags;
  640.     eeconfig_flag_led_matrix(write_to_eeprom);
  641.     dprintf("led matrix set flags [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", led_matrix_eeconfig.flags);
  642. }
  644. led_flags_t led_matrix_get_flags(void) {
  645.     return led_matrix_eeconfig.flags;
  646. }
  648. void led_matrix_set_flags(led_flags_t flags) {
  649.     led_matrix_set_flags_eeprom_helper(flags, true);
  650. }
  652. void led_matrix_set_flags_noeeprom(led_flags_t flags) {
  653.     led_matrix_set_flags_eeprom_helper(flags, false);
  654. }