You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

647 lines
24 KiB

2020 November 28 Breaking Changes Update (#11053) * Branch point for 2020 November 28 Breaking Change * Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183) * Add support for soft serial to ATmega32U2 (#10204) * Change MIDI velocity implementation to allow direct control of velocity value (#9940) * Add ability to build a subset of all keyboards based on platform. * Actually use eeprom_driver_init(). * Make bootloader_jump weak for ChibiOS. (#10417) * Joystick 16-bit support (#10439) * Per-encoder resolutions (#10259) * Share button state from mousekey to pointing_device (#10179) * Add hotfix for chibios keyboards not wake (#10088) * Add advanced/efficient RGB Matrix Indicators (#8564) * Naming change. * Support for STM32 GPIOF,G,H,I,J,K (#10206) * Add milc as a dependency and remove the installed milc (#10563) * ChibiOS upgrade: early init conversions (#10214) * ChibiOS upgrade: configuration file migrator (#9952) * Haptic and solenoid cleanup (#9700) * XD75 cleanup (#10524) * OLED display update interval support (#10388) * Add definition based on currently-selected serial driver. (#10716) * New feature: Retro Tapping per key (#10622) * Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638) * Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530) * Rescale both ChibiOS and AVR backlighting. * Reduce Helix keyboard build variation (#8669) * Minor change to behavior allowing display updates to continue between task ticks (#10750) * Some GPIO manipulations in matrix.c change to atomic. (#10491) * qmk cformat (#10767) * [Keyboard] Update the Speedo firmware for v3.0 (#10657) * Maartenwut/Maarten namechange to evyd13/Evy (#10274) * [quantum] combine repeated lines of code (#10837) * Add step sequencer feature (#9703) * aeboards/ext65 refactor (#10820) * Refactor xelus/dawn60 for Rev2 later (#10584) * add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824) * [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549) * update chibios os usb for the otg driver (#8893) * Remove HD44780 References, Part 4 (#10735) * [Keyboard] Add Valor FRL TKL (+refactor) (#10512) * Fix cursor position bug in oled_write_raw functions (#10800) * Fixup version.h writing when using SKIP_VERSION=yes (#10972) * Allow for certain code in the codebase assuming length of string. (#10974) * Add AT90USB support for serial.c (#10706) * Auto shift: support repeats and early registration (#9826) * Rename ledmatrix.h to match .c file (#7949) * Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231) * Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840) * Merge point for 2020 Nov 28 Breaking Change
3 years ago
2020 November 28 Breaking Changes Update (#11053) * Branch point for 2020 November 28 Breaking Change * Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183) * Add support for soft serial to ATmega32U2 (#10204) * Change MIDI velocity implementation to allow direct control of velocity value (#9940) * Add ability to build a subset of all keyboards based on platform. * Actually use eeprom_driver_init(). * Make bootloader_jump weak for ChibiOS. (#10417) * Joystick 16-bit support (#10439) * Per-encoder resolutions (#10259) * Share button state from mousekey to pointing_device (#10179) * Add hotfix for chibios keyboards not wake (#10088) * Add advanced/efficient RGB Matrix Indicators (#8564) * Naming change. * Support for STM32 GPIOF,G,H,I,J,K (#10206) * Add milc as a dependency and remove the installed milc (#10563) * ChibiOS upgrade: early init conversions (#10214) * ChibiOS upgrade: configuration file migrator (#9952) * Haptic and solenoid cleanup (#9700) * XD75 cleanup (#10524) * OLED display update interval support (#10388) * Add definition based on currently-selected serial driver. (#10716) * New feature: Retro Tapping per key (#10622) * Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638) * Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530) * Rescale both ChibiOS and AVR backlighting. * Reduce Helix keyboard build variation (#8669) * Minor change to behavior allowing display updates to continue between task ticks (#10750) * Some GPIO manipulations in matrix.c change to atomic. (#10491) * qmk cformat (#10767) * [Keyboard] Update the Speedo firmware for v3.0 (#10657) * Maartenwut/Maarten namechange to evyd13/Evy (#10274) * [quantum] combine repeated lines of code (#10837) * Add step sequencer feature (#9703) * aeboards/ext65 refactor (#10820) * Refactor xelus/dawn60 for Rev2 later (#10584) * add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824) * [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549) * update chibios os usb for the otg driver (#8893) * Remove HD44780 References, Part 4 (#10735) * [Keyboard] Add Valor FRL TKL (+refactor) (#10512) * Fix cursor position bug in oled_write_raw functions (#10800) * Fixup version.h writing when using SKIP_VERSION=yes (#10972) * Allow for certain code in the codebase assuming length of string. (#10974) * Add AT90USB support for serial.c (#10706) * Auto shift: support repeats and early registration (#9826) * Rename ledmatrix.h to match .c file (#7949) * Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231) * Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840) * Merge point for 2020 Nov 28 Breaking Change
3 years ago
2020 November 28 Breaking Changes Update (#11053) * Branch point for 2020 November 28 Breaking Change * Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183) * Add support for soft serial to ATmega32U2 (#10204) * Change MIDI velocity implementation to allow direct control of velocity value (#9940) * Add ability to build a subset of all keyboards based on platform. * Actually use eeprom_driver_init(). * Make bootloader_jump weak for ChibiOS. (#10417) * Joystick 16-bit support (#10439) * Per-encoder resolutions (#10259) * Share button state from mousekey to pointing_device (#10179) * Add hotfix for chibios keyboards not wake (#10088) * Add advanced/efficient RGB Matrix Indicators (#8564) * Naming change. * Support for STM32 GPIOF,G,H,I,J,K (#10206) * Add milc as a dependency and remove the installed milc (#10563) * ChibiOS upgrade: early init conversions (#10214) * ChibiOS upgrade: configuration file migrator (#9952) * Haptic and solenoid cleanup (#9700) * XD75 cleanup (#10524) * OLED display update interval support (#10388) * Add definition based on currently-selected serial driver. (#10716) * New feature: Retro Tapping per key (#10622) * Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638) * Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530) * Rescale both ChibiOS and AVR backlighting. * Reduce Helix keyboard build variation (#8669) * Minor change to behavior allowing display updates to continue between task ticks (#10750) * Some GPIO manipulations in matrix.c change to atomic. (#10491) * qmk cformat (#10767) * [Keyboard] Update the Speedo firmware for v3.0 (#10657) * Maartenwut/Maarten namechange to evyd13/Evy (#10274) * [quantum] combine repeated lines of code (#10837) * Add step sequencer feature (#9703) * aeboards/ext65 refactor (#10820) * Refactor xelus/dawn60 for Rev2 later (#10584) * add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824) * [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549) * update chibios os usb for the otg driver (#8893) * Remove HD44780 References, Part 4 (#10735) * [Keyboard] Add Valor FRL TKL (+refactor) (#10512) * Fix cursor position bug in oled_write_raw functions (#10800) * Fixup version.h writing when using SKIP_VERSION=yes (#10972) * Allow for certain code in the codebase assuming length of string. (#10974) * Add AT90USB support for serial.c (#10706) * Auto shift: support repeats and early registration (#9826) * Rename ledmatrix.h to match .c file (#7949) * Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231) * Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840) * Merge point for 2020 Nov 28 Breaking Change
3 years ago
  1. /* Copyright 2017 Jason Williams
  2. * Copyright 2017 Jack Humbert
  3. * Copyright 2018 Yiancar
  4. *
  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. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17. */
  18. #include "rgb_matrix.h"
  19. #include "progmem.h"
  20. #include "config.h"
  21. #include "eeprom.h"
  22. #include <string.h>
  23. #include <math.h>
  24. #include <lib/lib8tion/lib8tion.h>
  25. #ifndef RGB_MATRIX_CENTER
  26. const point_t k_rgb_matrix_center = {112, 32};
  27. #else
  28. const point_t k_rgb_matrix_center = RGB_MATRIX_CENTER;
  29. #endif
  30. __attribute__((weak)) RGB rgb_matrix_hsv_to_rgb(HSV hsv) { return hsv_to_rgb(hsv); }
  31. // Generic effect runners
  32. #include "rgb_matrix_runners/effect_runner_dx_dy_dist.h"
  33. #include "rgb_matrix_runners/effect_runner_dx_dy.h"
  34. #include "rgb_matrix_runners/effect_runner_i.h"
  35. #include "rgb_matrix_runners/effect_runner_sin_cos_i.h"
  36. #include "rgb_matrix_runners/effect_runner_reactive.h"
  37. #include "rgb_matrix_runners/effect_runner_reactive_splash.h"
  38. // ------------------------------------------
  39. // -----Begin rgb effect includes macros-----
  40. #define RGB_MATRIX_EFFECT(name)
  41. #define RGB_MATRIX_CUSTOM_EFFECT_IMPLS
  42. #include "rgb_matrix_animations/rgb_matrix_effects.inc"
  43. #ifdef RGB_MATRIX_CUSTOM_KB
  44. # include "rgb_matrix_kb.inc"
  45. #endif
  46. #ifdef RGB_MATRIX_CUSTOM_USER
  47. # include "rgb_matrix_user.inc"
  48. #endif
  49. #undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
  50. #undef RGB_MATRIX_EFFECT
  51. // -----End rgb effect includes macros-------
  52. // ------------------------------------------
  53. #if defined(RGB_DISABLE_AFTER_TIMEOUT) && !defined(RGB_DISABLE_TIMEOUT)
  54. # define RGB_DISABLE_TIMEOUT (RGB_DISABLE_AFTER_TIMEOUT * 1200UL)
  55. #endif
  56. #ifndef RGB_DISABLE_TIMEOUT
  57. # define RGB_DISABLE_TIMEOUT 0
  58. #endif
  59. #if RGB_DISABLE_WHEN_USB_SUSPENDED == false
  60. # undef RGB_DISABLE_WHEN_USB_SUSPENDED
  61. #endif
  62. #if !defined(RGB_MATRIX_MAXIMUM_BRIGHTNESS) || RGB_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX
  63. # undef RGB_MATRIX_MAXIMUM_BRIGHTNESS
  64. # define RGB_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX
  65. #endif
  66. #if !defined(RGB_MATRIX_HUE_STEP)
  67. # define RGB_MATRIX_HUE_STEP 8
  68. #endif
  69. #if !defined(RGB_MATRIX_SAT_STEP)
  70. # define RGB_MATRIX_SAT_STEP 16
  71. #endif
  72. #if !defined(RGB_MATRIX_VAL_STEP)
  73. # define RGB_MATRIX_VAL_STEP 16
  74. #endif
  75. #if !defined(RGB_MATRIX_SPD_STEP)
  76. # define RGB_MATRIX_SPD_STEP 16
  77. #endif
  78. #if !defined(RGB_MATRIX_STARTUP_MODE)
  79. # ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
  80. # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT
  81. # else
  82. // fallback to solid colors if RGB_MATRIX_CYCLE_LEFT_RIGHT is disabled in userspace
  83. # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_SOLID_COLOR
  84. # endif
  85. #endif
  86. #if !defined(RGB_MATRIX_STARTUP_HUE)
  87. # define RGB_MATRIX_STARTUP_HUE 0
  88. #endif
  89. #if !defined(RGB_MATRIX_STARTUP_SAT)
  90. # define RGB_MATRIX_STARTUP_SAT UINT8_MAX
  91. #endif
  92. #if !defined(RGB_MATRIX_STARTUP_VAL)
  93. # define RGB_MATRIX_STARTUP_VAL RGB_MATRIX_MAXIMUM_BRIGHTNESS
  94. #endif
  95. #if !defined(RGB_MATRIX_STARTUP_SPD)
  96. # define RGB_MATRIX_STARTUP_SPD UINT8_MAX / 2
  97. #endif
  98. // globals
  99. rgb_config_t rgb_matrix_config; // TODO: would like to prefix this with g_ for global consistancy, do this in another pr
  100. uint32_t g_rgb_timer;
  101. #ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS
  102. uint8_t g_rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS] = {{0}};
  103. #endif // RGB_MATRIX_FRAMEBUFFER_EFFECTS
  104. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  105. last_hit_t g_last_hit_tracker;
  106. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  107. // internals
  108. static bool suspend_state = false;
  109. static uint8_t rgb_last_enable = UINT8_MAX;
  110. static uint8_t rgb_last_effect = UINT8_MAX;
  111. static effect_params_t rgb_effect_params = {0, LED_FLAG_ALL, false};
  112. static rgb_task_states rgb_task_state = SYNCING;
  113. #if RGB_DISABLE_TIMEOUT > 0
  114. static uint32_t rgb_anykey_timer;
  115. #endif // RGB_DISABLE_TIMEOUT > 0
  116. // double buffers
  117. static uint32_t rgb_timer_buffer;
  118. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  119. static last_hit_t last_hit_buffer;
  120. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  121. // split rgb matrix
  122. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
  123. const uint8_t k_rgb_matrix_split[2] = RGB_MATRIX_SPLIT;
  124. #endif
  125. void eeconfig_read_rgb_matrix(void) { eeprom_read_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config)); }
  126. void eeconfig_update_rgb_matrix(void) { eeprom_update_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config)); }
  127. void eeconfig_update_rgb_matrix_default(void) {
  128. dprintf("eeconfig_update_rgb_matrix_default\n");
  129. rgb_matrix_config.enable = 1;
  130. rgb_matrix_config.mode = RGB_MATRIX_STARTUP_MODE;
  131. rgb_matrix_config.hsv = (HSV){RGB_MATRIX_STARTUP_HUE, RGB_MATRIX_STARTUP_SAT, RGB_MATRIX_STARTUP_VAL};
  132. rgb_matrix_config.speed = RGB_MATRIX_STARTUP_SPD;
  133. rgb_matrix_config.flags = LED_FLAG_ALL;
  134. eeconfig_update_rgb_matrix();
  135. }
  136. void eeconfig_debug_rgb_matrix(void) {
  137. dprintf("rgb_matrix_config EEPROM\n");
  138. dprintf("rgb_matrix_config.enable = %d\n", rgb_matrix_config.enable);
  139. dprintf("rgb_matrix_config.mode = %d\n", rgb_matrix_config.mode);
  140. dprintf("rgb_matrix_config.hsv.h = %d\n", rgb_matrix_config.hsv.h);
  141. dprintf("rgb_matrix_config.hsv.s = %d\n", rgb_matrix_config.hsv.s);
  142. dprintf("rgb_matrix_config.hsv.v = %d\n", rgb_matrix_config.hsv.v);
  143. dprintf("rgb_matrix_config.speed = %d\n", rgb_matrix_config.speed);
  144. dprintf("rgb_matrix_config.flags = %d\n", rgb_matrix_config.flags);
  145. }
  146. __attribute__((weak)) uint8_t rgb_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) { return 0; }
  147. uint8_t rgb_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) {
  148. uint8_t led_count = rgb_matrix_map_row_column_to_led_kb(row, column, led_i);
  149. uint8_t led_index = g_led_config.matrix_co[row][column];
  150. if (led_index != NO_LED) {
  151. led_i[led_count] = led_index;
  152. led_count++;
  153. }
  154. return led_count;
  155. }
  156. void rgb_matrix_update_pwm_buffers(void) { rgb_matrix_driver.flush(); }
  157. void rgb_matrix_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
  158. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
  159. if (!is_keyboard_left() && index >= k_rgb_matrix_split[0])
  160. rgb_matrix_driver.set_color(index - k_rgb_matrix_split[0], red, green, blue);
  161. else if (is_keyboard_left() && index < k_rgb_matrix_split[0])
  162. #endif
  163. rgb_matrix_driver.set_color(index, red, green, blue);
  164. }
  165. void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
  166. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
  167. for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) rgb_matrix_set_color(i, red, green, blue);
  168. #else
  169. rgb_matrix_driver.set_color_all(red, green, blue);
  170. #endif
  171. }
  172. void process_rgb_matrix(uint8_t row, uint8_t col, bool pressed) {
  173. #ifndef RGB_MATRIX_SPLIT
  174. if (!is_keyboard_master()) return;
  175. #endif
  176. #if RGB_DISABLE_TIMEOUT > 0
  177. rgb_anykey_timer = 0;
  178. #endif // RGB_DISABLE_TIMEOUT > 0
  179. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  180. uint8_t led[LED_HITS_TO_REMEMBER];
  181. uint8_t led_count = 0;
  182. # if defined(RGB_MATRIX_KEYRELEASES)
  183. if (!pressed)
  184. # elif defined(RGB_MATRIX_KEYPRESSES)
  185. if (pressed)
  186. # endif // defined(RGB_MATRIX_KEYRELEASES)
  187. {
  188. led_count = rgb_matrix_map_row_column_to_led(row, col, led);
  189. }
  190. if (last_hit_buffer.count + led_count > LED_HITS_TO_REMEMBER) {
  191. memcpy(&last_hit_buffer.x[0], &last_hit_buffer.x[led_count], LED_HITS_TO_REMEMBER - led_count);
  192. memcpy(&last_hit_buffer.y[0], &last_hit_buffer.y[led_count], LED_HITS_TO_REMEMBER - led_count);
  193. memcpy(&last_hit_buffer.tick[0], &last_hit_buffer.tick[led_count], (LED_HITS_TO_REMEMBER - led_count) * 2); // 16 bit
  194. memcpy(&last_hit_buffer.index[0], &last_hit_buffer.index[led_count], LED_HITS_TO_REMEMBER - led_count);
  195. last_hit_buffer.count--;
  196. }
  197. for (uint8_t i = 0; i < led_count; i++) {
  198. uint8_t index = last_hit_buffer.count;
  199. last_hit_buffer.x[index] = g_led_config.point[led[i]].x;
  200. last_hit_buffer.y[index] = g_led_config.point[led[i]].y;
  201. last_hit_buffer.index[index] = led[i];
  202. last_hit_buffer.tick[index] = 0;
  203. last_hit_buffer.count++;
  204. }
  205. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  206. #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
  207. if (rgb_matrix_config.mode == RGB_MATRIX_TYPING_HEATMAP) {
  208. process_rgb_matrix_typing_heatmap(row, col);
  209. }
  210. #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
  211. }
  212. void rgb_matrix_test(void) {
  213. // Mask out bits 4 and 5
  214. // Increase the factor to make the test animation slower (and reduce to make it faster)
  215. uint8_t factor = 10;
  216. switch ((g_rgb_timer & (0b11 << factor)) >> factor) {
  217. case 0: {
  218. rgb_matrix_set_color_all(20, 0, 0);
  219. break;
  220. }
  221. case 1: {
  222. rgb_matrix_set_color_all(0, 20, 0);
  223. break;
  224. }
  225. case 2: {
  226. rgb_matrix_set_color_all(0, 0, 20);
  227. break;
  228. }
  229. case 3: {
  230. rgb_matrix_set_color_all(20, 20, 20);
  231. break;
  232. }
  233. }
  234. }
  235. static bool rgb_matrix_none(effect_params_t *params) {
  236. if (!params->init) {
  237. return false;
  238. }
  239. rgb_matrix_set_color_all(0, 0, 0);
  240. return false;
  241. }
  242. static void rgb_task_timers(void) {
  243. #if defined(RGB_MATRIX_KEYREACTIVE_ENABLED) || RGB_DISABLE_TIMEOUT > 0
  244. uint32_t deltaTime = sync_timer_elapsed32(rgb_timer_buffer);
  245. #endif // defined(RGB_MATRIX_KEYREACTIVE_ENABLED) || RGB_DISABLE_TIMEOUT > 0
  246. rgb_timer_buffer = sync_timer_read32();
  247. // Update double buffer timers
  248. #if RGB_DISABLE_TIMEOUT > 0
  249. if (rgb_anykey_timer < UINT32_MAX) {
  250. if (UINT32_MAX - deltaTime < rgb_anykey_timer) {
  251. rgb_anykey_timer = UINT32_MAX;
  252. } else {
  253. rgb_anykey_timer += deltaTime;
  254. }
  255. }
  256. #endif // RGB_DISABLE_TIMEOUT > 0
  257. // Update double buffer last hit timers
  258. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  259. uint8_t count = last_hit_buffer.count;
  260. for (uint8_t i = 0; i < count; ++i) {
  261. if (UINT16_MAX - deltaTime < last_hit_buffer.tick[i]) {
  262. last_hit_buffer.count--;
  263. continue;
  264. }
  265. last_hit_buffer.tick[i] += deltaTime;
  266. }
  267. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  268. }
  269. static void rgb_task_sync(void) {
  270. // next task
  271. if (sync_timer_elapsed32(g_rgb_timer) >= RGB_MATRIX_LED_FLUSH_LIMIT) rgb_task_state = STARTING;
  272. }
  273. static void rgb_task_start(void) {
  274. // reset iter
  275. rgb_effect_params.iter = 0;
  276. // update double buffers
  277. g_rgb_timer = rgb_timer_buffer;
  278. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  279. g_last_hit_tracker = last_hit_buffer;
  280. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  281. // next task
  282. rgb_task_state = RENDERING;
  283. }
  284. static void rgb_task_render(uint8_t effect) {
  285. bool rendering = false;
  286. rgb_effect_params.init = (effect != rgb_last_effect) || (rgb_matrix_config.enable != rgb_last_enable);
  287. if (rgb_effect_params.flags != rgb_matrix_config.flags) {
  288. rgb_effect_params.flags = rgb_matrix_config.flags;
  289. rgb_matrix_set_color_all(0, 0, 0);
  290. }
  291. // each effect can opt to do calculations
  292. // and/or request PWM buffer updates.
  293. switch (effect) {
  294. case RGB_MATRIX_NONE:
  295. rendering = rgb_matrix_none(&rgb_effect_params);
  296. break;
  297. // ---------------------------------------------
  298. // -----Begin rgb effect switch case macros-----
  299. #define RGB_MATRIX_EFFECT(name, ...) \
  300. case RGB_MATRIX_##name: \
  301. rendering = name(&rgb_effect_params); \
  302. break;
  303. #include "rgb_matrix_animations/rgb_matrix_effects.inc"
  304. #undef RGB_MATRIX_EFFECT
  305. #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER)
  306. # define RGB_MATRIX_EFFECT(name, ...) \
  307. case RGB_MATRIX_CUSTOM_##name: \
  308. rendering = name(&rgb_effect_params); \
  309. break;
  310. # ifdef RGB_MATRIX_CUSTOM_KB
  311. # include "rgb_matrix_kb.inc"
  312. # endif
  313. # ifdef RGB_MATRIX_CUSTOM_USER
  314. # include "rgb_matrix_user.inc"
  315. # endif
  316. # undef RGB_MATRIX_EFFECT
  317. #endif
  318. // -----End rgb effect switch case macros-------
  319. // ---------------------------------------------
  320. // Factory default magic value
  321. case UINT8_MAX: {
  322. rgb_matrix_test();
  323. rgb_task_state = FLUSHING;
  324. }
  325. return;
  326. }
  327. rgb_effect_params.iter++;
  328. // next task
  329. if (!rendering) {
  330. rgb_task_state = FLUSHING;
  331. if (!rgb_effect_params.init && effect == RGB_MATRIX_NONE) {
  332. // We only need to flush once if we are RGB_MATRIX_NONE
  333. rgb_task_state = SYNCING;
  334. }
  335. }
  336. }
  337. static void rgb_task_flush(uint8_t effect) {
  338. // update last trackers after the first full render so we can init over several frames
  339. rgb_last_effect = effect;
  340. rgb_last_enable = rgb_matrix_config.enable;
  341. // update pwm buffers
  342. rgb_matrix_update_pwm_buffers();
  343. // next task
  344. rgb_task_state = SYNCING;
  345. }
  346. void rgb_matrix_task(void) {
  347. rgb_task_timers();
  348. // Ideally we would also stop sending zeros to the LED driver PWM buffers
  349. // while suspended and just do a software shutdown. This is a cheap hack for now.
  350. bool suspend_backlight =
  351. suspend_state ||
  352. #if RGB_DISABLE_TIMEOUT > 0
  353. (rgb_anykey_timer > (uint32_t)RGB_DISABLE_TIMEOUT) ||
  354. #endif // RGB_DISABLE_TIMEOUT > 0
  355. false;
  356. uint8_t effect = suspend_backlight || !rgb_matrix_config.enable ? 0 : rgb_matrix_config.mode;
  357. switch (rgb_task_state) {
  358. case STARTING:
  359. rgb_task_start();
  360. break;
  361. case RENDERING:
  362. rgb_task_render(effect);
  363. if (effect) {
  364. rgb_matrix_indicators();
  365. rgb_matrix_indicators_advanced(&rgb_effect_params);
  366. }
  367. break;
  368. case FLUSHING:
  369. rgb_task_flush(effect);
  370. break;
  371. case SYNCING:
  372. rgb_task_sync();
  373. break;
  374. }
  375. }
  376. void rgb_matrix_indicators(void) {
  377. rgb_matrix_indicators_kb();
  378. rgb_matrix_indicators_user();
  379. }
  380. __attribute__((weak)) void rgb_matrix_indicators_kb(void) {}
  381. __attribute__((weak)) void rgb_matrix_indicators_user(void) {}
  382. void rgb_matrix_indicators_advanced(effect_params_t *params) {
  383. /* special handling is needed for "params->iter", since it's already been incremented.
  384. * Could move the invocations to rgb_task_render, but then it's missing a few checks
  385. * and not sure which would be better. Otherwise, this should be called from
  386. * rgb_task_render, right before the iter++ line.
  387. */
  388. #if defined(RGB_MATRIX_LED_PROCESS_LIMIT) && RGB_MATRIX_LED_PROCESS_LIMIT > 0 && RGB_MATRIX_LED_PROCESS_LIMIT < DRIVER_LED_TOTAL
  389. uint8_t min = RGB_MATRIX_LED_PROCESS_LIMIT * (params->iter - 1);
  390. uint8_t max = min + RGB_MATRIX_LED_PROCESS_LIMIT;
  391. if (max > DRIVER_LED_TOTAL) max = DRIVER_LED_TOTAL;
  392. #else
  393. uint8_t min = 0;
  394. uint8_t max = DRIVER_LED_TOTAL;
  395. #endif
  396. rgb_matrix_indicators_advanced_kb(min, max);
  397. rgb_matrix_indicators_advanced_user(min, max);
  398. }
  399. __attribute__((weak)) void rgb_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {}
  400. __attribute__((weak)) void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {}
  401. void rgb_matrix_init(void) {
  402. rgb_matrix_driver.init();
  403. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  404. g_last_hit_tracker.count = 0;
  405. for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  406. g_last_hit_tracker.tick[i] = UINT16_MAX;
  407. }
  408. last_hit_buffer.count = 0;
  409. for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  410. last_hit_buffer.tick[i] = UINT16_MAX;
  411. }
  412. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  413. if (!eeconfig_is_enabled()) {
  414. dprintf("rgb_matrix_init_drivers eeconfig is not enabled.\n");
  415. eeconfig_init();
  416. eeconfig_update_rgb_matrix_default();
  417. }
  418. eeconfig_read_rgb_matrix();
  419. if (!rgb_matrix_config.mode) {
  420. dprintf("rgb_matrix_init_drivers rgb_matrix_config.mode = 0. Write default values to EEPROM.\n");
  421. eeconfig_update_rgb_matrix_default();
  422. }
  423. eeconfig_debug_rgb_matrix(); // display current eeprom values
  424. }
  425. void rgb_matrix_set_suspend_state(bool state) {
  426. #ifdef RGB_DISABLE_WHEN_USB_SUSPENDED
  427. if (state) {
  428. rgb_matrix_set_color_all(0, 0, 0); // turn off all LEDs when suspending
  429. }
  430. suspend_state = state;
  431. #endif
  432. }
  433. bool rgb_matrix_get_suspend_state(void) { return suspend_state; }
  434. void rgb_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
  435. rgb_matrix_config.enable ^= 1;
  436. rgb_task_state = STARTING;
  437. if (write_to_eeprom) {
  438. eeconfig_update_rgb_matrix();
  439. }
  440. dprintf("rgb matrix toggle [%s]: rgb_matrix_config.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.enable);
  441. }
  442. void rgb_matrix_toggle_noeeprom(void) { rgb_matrix_toggle_eeprom_helper(false); }
  443. void rgb_matrix_toggle(void) { rgb_matrix_toggle_eeprom_helper(true); }
  444. void rgb_matrix_enable(void) {
  445. rgb_matrix_enable_noeeprom();
  446. eeconfig_update_rgb_matrix();
  447. }
  448. void rgb_matrix_enable_noeeprom(void) {
  449. if (!rgb_matrix_config.enable) rgb_task_state = STARTING;
  450. rgb_matrix_config.enable = 1;
  451. }
  452. void rgb_matrix_disable(void) {
  453. rgb_matrix_disable_noeeprom();
  454. eeconfig_update_rgb_matrix();
  455. }
  456. void rgb_matrix_disable_noeeprom(void) {
  457. if (rgb_matrix_config.enable) rgb_task_state = STARTING;
  458. rgb_matrix_config.enable = 0;
  459. }
  460. uint8_t rgb_matrix_is_enabled(void) { return rgb_matrix_config.enable; }
  461. void rgb_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
  462. if (!rgb_matrix_config.enable) {
  463. return;
  464. }
  465. if (mode < 1) {
  466. rgb_matrix_config.mode = 1;
  467. } else if (mode >= RGB_MATRIX_EFFECT_MAX) {
  468. rgb_matrix_config.mode = RGB_MATRIX_EFFECT_MAX - 1;
  469. } else {
  470. rgb_matrix_config.mode = mode;
  471. }
  472. rgb_task_state = STARTING;
  473. if (write_to_eeprom) {
  474. eeconfig_update_rgb_matrix();
  475. }
  476. dprintf("rgb matrix mode [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.mode);
  477. }
  478. void rgb_matrix_mode_noeeprom(uint8_t mode) { rgb_matrix_mode_eeprom_helper(mode, false); }
  479. void rgb_matrix_mode(uint8_t mode) { rgb_matrix_mode_eeprom_helper(mode, true); }
  480. uint8_t rgb_matrix_get_mode(void) { return rgb_matrix_config.mode; }
  481. void rgb_matrix_step_helper(bool write_to_eeprom) {
  482. uint8_t mode = rgb_matrix_config.mode + 1;
  483. rgb_matrix_mode_eeprom_helper((mode < RGB_MATRIX_EFFECT_MAX) ? mode : 1, write_to_eeprom);
  484. }
  485. void rgb_matrix_step_noeeprom(void) { rgb_matrix_step_helper(false); }
  486. void rgb_matrix_step(void) { rgb_matrix_step_helper(true); }
  487. void rgb_matrix_step_reverse_helper(bool write_to_eeprom) {
  488. uint8_t mode = rgb_matrix_config.mode - 1;
  489. rgb_matrix_mode_eeprom_helper((mode < 1) ? RGB_MATRIX_EFFECT_MAX - 1 : mode, write_to_eeprom);
  490. }
  491. void rgb_matrix_step_reverse_noeeprom(void) { rgb_matrix_step_reverse_helper(false); }
  492. void rgb_matrix_step_reverse(void) { rgb_matrix_step_reverse_helper(true); }
  493. void rgb_matrix_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
  494. if (!rgb_matrix_config.enable) {
  495. return;
  496. }
  497. rgb_matrix_config.hsv.h = hue;
  498. rgb_matrix_config.hsv.s = sat;
  499. rgb_matrix_config.hsv.v = (val > RGB_MATRIX_MAXIMUM_BRIGHTNESS) ? RGB_MATRIX_MAXIMUM_BRIGHTNESS : val;
  500. if (write_to_eeprom) {
  501. eeconfig_update_rgb_matrix();
  502. }
  503. dprintf("rgb matrix set hsv [%s]: %u,%u,%u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v);
  504. }
  505. void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) { rgb_matrix_sethsv_eeprom_helper(hue, sat, val, false); }
  506. void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val) { rgb_matrix_sethsv_eeprom_helper(hue, sat, val, true); }
  507. HSV rgb_matrix_get_hsv(void) { return rgb_matrix_config.hsv; }
  508. uint8_t rgb_matrix_get_hue(void) { return rgb_matrix_config.hsv.h; }
  509. uint8_t rgb_matrix_get_sat(void) { return rgb_matrix_config.hsv.s; }
  510. uint8_t rgb_matrix_get_val(void) { return rgb_matrix_config.hsv.v; }
  511. void rgb_matrix_increase_hue_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h + RGB_MATRIX_HUE_STEP, rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v, write_to_eeprom); }
  512. void rgb_matrix_increase_hue_noeeprom(void) { rgb_matrix_increase_hue_helper(false); }
  513. void rgb_matrix_increase_hue(void) { rgb_matrix_increase_hue_helper(true); }
  514. void rgb_matrix_decrease_hue_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h - RGB_MATRIX_HUE_STEP, rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v, write_to_eeprom); }
  515. void rgb_matrix_decrease_hue_noeeprom(void) { rgb_matrix_decrease_hue_helper(false); }
  516. void rgb_matrix_decrease_hue(void) { rgb_matrix_decrease_hue_helper(true); }
  517. void rgb_matrix_increase_sat_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, qadd8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP), rgb_matrix_config.hsv.v, write_to_eeprom); }
  518. void rgb_matrix_increase_sat_noeeprom(void) { rgb_matrix_increase_sat_helper(false); }
  519. void rgb_matrix_increase_sat(void) { rgb_matrix_increase_sat_helper(true); }
  520. void rgb_matrix_decrease_sat_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, qsub8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP), rgb_matrix_config.hsv.v, write_to_eeprom); }
  521. void rgb_matrix_decrease_sat_noeeprom(void) { rgb_matrix_decrease_sat_helper(false); }
  522. void rgb_matrix_decrease_sat(void) { rgb_matrix_decrease_sat_helper(true); }
  523. void rgb_matrix_increase_val_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, qadd8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP), write_to_eeprom); }
  524. void rgb_matrix_increase_val_noeeprom(void) { rgb_matrix_increase_val_helper(false); }
  525. void rgb_matrix_increase_val(void) { rgb_matrix_increase_val_helper(true); }
  526. void rgb_matrix_decrease_val_helper(bool write_to_eeprom) { rgb_matrix_sethsv_eeprom_helper(rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, qsub8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP), write_to_eeprom); }
  527. void rgb_matrix_decrease_val_noeeprom(void) { rgb_matrix_decrease_val_helper(false); }
  528. void rgb_matrix_decrease_val(void) { rgb_matrix_decrease_val_helper(true); }
  529. void rgb_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) {
  530. rgb_matrix_config.speed = speed;
  531. if (write_to_eeprom) {
  532. eeconfig_update_rgb_matrix();
  533. }
  534. dprintf("rgb matrix set speed [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.speed);
  535. }
  536. void rgb_matrix_set_speed_noeeprom(uint8_t speed) { rgb_matrix_set_speed_eeprom_helper(speed, false); }
  537. void rgb_matrix_set_speed(uint8_t speed) { rgb_matrix_set_speed_eeprom_helper(speed, true); }
  538. uint8_t rgb_matrix_get_speed(void) { return rgb_matrix_config.speed; }
  539. void rgb_matrix_increase_speed_helper(bool write_to_eeprom) { rgb_matrix_set_speed_eeprom_helper(qadd8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP), write_to_eeprom); }
  540. void rgb_matrix_increase_speed_noeeprom(void) { rgb_matrix_increase_speed_helper(false); }
  541. void rgb_matrix_increase_speed(void) { rgb_matrix_increase_speed_helper(true); }
  542. void rgb_matrix_decrease_speed_helper(bool write_to_eeprom) { rgb_matrix_set_speed_eeprom_helper(qsub8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP), write_to_eeprom); }
  543. void rgb_matrix_decrease_speed_noeeprom(void) { rgb_matrix_decrease_speed_helper(false); }
  544. void rgb_matrix_decrease_speed(void) { rgb_matrix_decrease_speed_helper(true); }
  545. led_flags_t rgb_matrix_get_flags(void) { return rgb_matrix_config.flags; }
  546. void rgb_matrix_set_flags(led_flags_t flags) { rgb_matrix_config.flags = flags; }