rgb_matrix.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740
  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 led_point_t k_rgb_matrix_center = {112, 32};
  27. #else
  28. const led_point_t k_rgb_matrix_center = RGB_MATRIX_CENTER;
  29. #endif
  30. __attribute__((weak)) RGB rgb_matrix_hsv_to_rgb(HSV hsv) {
  31. return hsv_to_rgb(hsv);
  32. }
  33. // Generic effect runners
  34. #include "rgb_matrix_runners.inc"
  35. // ------------------------------------------
  36. // -----Begin rgb effect includes macros-----
  37. #define RGB_MATRIX_EFFECT(name)
  38. #define RGB_MATRIX_CUSTOM_EFFECT_IMPLS
  39. #include "rgb_matrix_effects.inc"
  40. #ifdef RGB_MATRIX_CUSTOM_KB
  41. # include "rgb_matrix_kb.inc"
  42. #endif
  43. #ifdef RGB_MATRIX_CUSTOM_USER
  44. # include "rgb_matrix_user.inc"
  45. #endif
  46. #undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
  47. #undef RGB_MATRIX_EFFECT
  48. // -----End rgb effect includes macros-------
  49. // ------------------------------------------
  50. #if defined(RGB_DISABLE_AFTER_TIMEOUT) && !defined(RGB_DISABLE_TIMEOUT)
  51. # define RGB_DISABLE_TIMEOUT (RGB_DISABLE_AFTER_TIMEOUT * 1200UL)
  52. #endif
  53. #ifndef RGB_DISABLE_TIMEOUT
  54. # define RGB_DISABLE_TIMEOUT 0
  55. #endif
  56. #if !defined(RGB_MATRIX_MAXIMUM_BRIGHTNESS) || RGB_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX
  57. # undef RGB_MATRIX_MAXIMUM_BRIGHTNESS
  58. # define RGB_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX
  59. #endif
  60. #if !defined(RGB_MATRIX_HUE_STEP)
  61. # define RGB_MATRIX_HUE_STEP 8
  62. #endif
  63. #if !defined(RGB_MATRIX_SAT_STEP)
  64. # define RGB_MATRIX_SAT_STEP 16
  65. #endif
  66. #if !defined(RGB_MATRIX_VAL_STEP)
  67. # define RGB_MATRIX_VAL_STEP 16
  68. #endif
  69. #if !defined(RGB_MATRIX_SPD_STEP)
  70. # define RGB_MATRIX_SPD_STEP 16
  71. #endif
  72. #if !defined(RGB_MATRIX_STARTUP_MODE)
  73. # ifdef ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
  74. # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT
  75. # else
  76. // fallback to solid colors if RGB_MATRIX_CYCLE_LEFT_RIGHT is disabled in userspace
  77. # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_SOLID_COLOR
  78. # endif
  79. #endif
  80. #if !defined(RGB_MATRIX_STARTUP_HUE)
  81. # define RGB_MATRIX_STARTUP_HUE 0
  82. #endif
  83. #if !defined(RGB_MATRIX_STARTUP_SAT)
  84. # define RGB_MATRIX_STARTUP_SAT UINT8_MAX
  85. #endif
  86. #if !defined(RGB_MATRIX_STARTUP_VAL)
  87. # define RGB_MATRIX_STARTUP_VAL RGB_MATRIX_MAXIMUM_BRIGHTNESS
  88. #endif
  89. #if !defined(RGB_MATRIX_STARTUP_SPD)
  90. # define RGB_MATRIX_STARTUP_SPD UINT8_MAX / 2
  91. #endif
  92. // globals
  93. rgb_config_t rgb_matrix_config; // TODO: would like to prefix this with g_ for global consistancy, do this in another pr
  94. uint32_t g_rgb_timer;
  95. #ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS
  96. uint8_t g_rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS] = {{0}};
  97. #endif // RGB_MATRIX_FRAMEBUFFER_EFFECTS
  98. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  99. last_hit_t g_last_hit_tracker;
  100. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  101. // internals
  102. static bool suspend_state = false;
  103. static uint8_t rgb_last_enable = UINT8_MAX;
  104. static uint8_t rgb_last_effect = UINT8_MAX;
  105. static effect_params_t rgb_effect_params = {0, LED_FLAG_ALL, false};
  106. static rgb_task_states rgb_task_state = SYNCING;
  107. #if RGB_DISABLE_TIMEOUT > 0
  108. static uint32_t rgb_anykey_timer;
  109. #endif // RGB_DISABLE_TIMEOUT > 0
  110. // double buffers
  111. static uint32_t rgb_timer_buffer;
  112. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  113. static last_hit_t last_hit_buffer;
  114. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  115. // split rgb matrix
  116. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
  117. const uint8_t k_rgb_matrix_split[2] = RGB_MATRIX_SPLIT;
  118. #endif
  119. EECONFIG_DEBOUNCE_HELPER(rgb_matrix, EECONFIG_RGB_MATRIX, rgb_matrix_config);
  120. void eeconfig_update_rgb_matrix(void) {
  121. eeconfig_flush_rgb_matrix(true);
  122. }
  123. void eeconfig_update_rgb_matrix_default(void) {
  124. dprintf("eeconfig_update_rgb_matrix_default\n");
  125. rgb_matrix_config.enable = 1;
  126. rgb_matrix_config.mode = RGB_MATRIX_STARTUP_MODE;
  127. rgb_matrix_config.hsv = (HSV){RGB_MATRIX_STARTUP_HUE, RGB_MATRIX_STARTUP_SAT, RGB_MATRIX_STARTUP_VAL};
  128. rgb_matrix_config.speed = RGB_MATRIX_STARTUP_SPD;
  129. rgb_matrix_config.flags = LED_FLAG_ALL;
  130. eeconfig_flush_rgb_matrix(true);
  131. }
  132. void eeconfig_debug_rgb_matrix(void) {
  133. dprintf("rgb_matrix_config EEPROM\n");
  134. dprintf("rgb_matrix_config.enable = %d\n", rgb_matrix_config.enable);
  135. dprintf("rgb_matrix_config.mode = %d\n", rgb_matrix_config.mode);
  136. dprintf("rgb_matrix_config.hsv.h = %d\n", rgb_matrix_config.hsv.h);
  137. dprintf("rgb_matrix_config.hsv.s = %d\n", rgb_matrix_config.hsv.s);
  138. dprintf("rgb_matrix_config.hsv.v = %d\n", rgb_matrix_config.hsv.v);
  139. dprintf("rgb_matrix_config.speed = %d\n", rgb_matrix_config.speed);
  140. dprintf("rgb_matrix_config.flags = %d\n", rgb_matrix_config.flags);
  141. }
  142. void rgb_matrix_reload_from_eeprom(void) {
  143. rgb_matrix_disable_noeeprom();
  144. /* Reset back to what we have in eeprom */
  145. eeconfig_init_rgb_matrix();
  146. eeconfig_debug_rgb_matrix(); // display current eeprom values
  147. if (rgb_matrix_config.enable) {
  148. rgb_matrix_mode_noeeprom(rgb_matrix_config.mode);
  149. }
  150. }
  151. __attribute__((weak)) uint8_t rgb_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) {
  152. return 0;
  153. }
  154. uint8_t rgb_matrix_map_row_column_to_led(uint8_t row, uint8_t column, uint8_t *led_i) {
  155. uint8_t led_count = rgb_matrix_map_row_column_to_led_kb(row, column, led_i);
  156. uint8_t led_index = g_led_config.matrix_co[row][column];
  157. if (led_index != NO_LED) {
  158. led_i[led_count] = led_index;
  159. led_count++;
  160. }
  161. return led_count;
  162. }
  163. void rgb_matrix_update_pwm_buffers(void) {
  164. rgb_matrix_driver.flush();
  165. }
  166. void rgb_matrix_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
  167. rgb_matrix_driver.set_color(index, red, green, blue);
  168. }
  169. void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
  170. #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_SPLIT)
  171. for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++)
  172. rgb_matrix_set_color(i, red, green, blue);
  173. #else
  174. rgb_matrix_driver.set_color_all(red, green, blue);
  175. #endif
  176. }
  177. void process_rgb_matrix(uint8_t row, uint8_t col, bool pressed) {
  178. #ifndef RGB_MATRIX_SPLIT
  179. if (!is_keyboard_master()) return;
  180. #endif
  181. #if RGB_DISABLE_TIMEOUT > 0
  182. rgb_anykey_timer = 0;
  183. #endif // RGB_DISABLE_TIMEOUT > 0
  184. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  185. uint8_t led[LED_HITS_TO_REMEMBER];
  186. uint8_t led_count = 0;
  187. # if defined(RGB_MATRIX_KEYRELEASES)
  188. if (!pressed)
  189. # elif defined(RGB_MATRIX_KEYPRESSES)
  190. if (pressed)
  191. # endif // defined(RGB_MATRIX_KEYRELEASES)
  192. {
  193. led_count = rgb_matrix_map_row_column_to_led(row, col, led);
  194. }
  195. if (last_hit_buffer.count + led_count > LED_HITS_TO_REMEMBER) {
  196. memcpy(&last_hit_buffer.x[0], &last_hit_buffer.x[led_count], LED_HITS_TO_REMEMBER - led_count);
  197. memcpy(&last_hit_buffer.y[0], &last_hit_buffer.y[led_count], LED_HITS_TO_REMEMBER - led_count);
  198. memcpy(&last_hit_buffer.tick[0], &last_hit_buffer.tick[led_count], (LED_HITS_TO_REMEMBER - led_count) * 2); // 16 bit
  199. memcpy(&last_hit_buffer.index[0], &last_hit_buffer.index[led_count], LED_HITS_TO_REMEMBER - led_count);
  200. last_hit_buffer.count = LED_HITS_TO_REMEMBER - led_count;
  201. }
  202. for (uint8_t i = 0; i < led_count; i++) {
  203. uint8_t index = last_hit_buffer.count;
  204. last_hit_buffer.x[index] = g_led_config.point[led[i]].x;
  205. last_hit_buffer.y[index] = g_led_config.point[led[i]].y;
  206. last_hit_buffer.index[index] = led[i];
  207. last_hit_buffer.tick[index] = 0;
  208. last_hit_buffer.count++;
  209. }
  210. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  211. #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_RGB_MATRIX_TYPING_HEATMAP)
  212. # if defined(RGB_MATRIX_KEYRELEASES)
  213. if (!pressed)
  214. # else
  215. if (pressed)
  216. # endif // defined(RGB_MATRIX_KEYRELEASES)
  217. {
  218. if (rgb_matrix_config.mode == RGB_MATRIX_TYPING_HEATMAP) {
  219. process_rgb_matrix_typing_heatmap(row, col);
  220. }
  221. }
  222. #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_RGB_MATRIX_TYPING_HEATMAP)
  223. }
  224. void rgb_matrix_test(void) {
  225. // Mask out bits 4 and 5
  226. // Increase the factor to make the test animation slower (and reduce to make it faster)
  227. uint8_t factor = 10;
  228. switch ((g_rgb_timer & (0b11 << factor)) >> factor) {
  229. case 0: {
  230. rgb_matrix_set_color_all(20, 0, 0);
  231. break;
  232. }
  233. case 1: {
  234. rgb_matrix_set_color_all(0, 20, 0);
  235. break;
  236. }
  237. case 2: {
  238. rgb_matrix_set_color_all(0, 0, 20);
  239. break;
  240. }
  241. case 3: {
  242. rgb_matrix_set_color_all(20, 20, 20);
  243. break;
  244. }
  245. }
  246. }
  247. static bool rgb_matrix_none(effect_params_t *params) {
  248. if (!params->init) {
  249. return false;
  250. }
  251. rgb_matrix_set_color_all(0, 0, 0);
  252. return false;
  253. }
  254. static void rgb_task_timers(void) {
  255. #if defined(RGB_MATRIX_KEYREACTIVE_ENABLED) || RGB_DISABLE_TIMEOUT > 0
  256. uint32_t deltaTime = sync_timer_elapsed32(rgb_timer_buffer);
  257. #endif // defined(RGB_MATRIX_KEYREACTIVE_ENABLED) || RGB_DISABLE_TIMEOUT > 0
  258. rgb_timer_buffer = sync_timer_read32();
  259. // Update double buffer timers
  260. #if RGB_DISABLE_TIMEOUT > 0
  261. if (rgb_anykey_timer + deltaTime <= UINT32_MAX) {
  262. rgb_anykey_timer += deltaTime;
  263. }
  264. #endif // RGB_DISABLE_TIMEOUT > 0
  265. // Update double buffer last hit timers
  266. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  267. uint8_t count = last_hit_buffer.count;
  268. for (uint8_t i = 0; i < count; ++i) {
  269. if (UINT16_MAX - deltaTime < last_hit_buffer.tick[i]) {
  270. last_hit_buffer.count--;
  271. continue;
  272. }
  273. last_hit_buffer.tick[i] += deltaTime;
  274. }
  275. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  276. }
  277. static void rgb_task_sync(void) {
  278. eeconfig_flush_rgb_matrix(false);
  279. // next task
  280. if (sync_timer_elapsed32(g_rgb_timer) >= RGB_MATRIX_LED_FLUSH_LIMIT) rgb_task_state = STARTING;
  281. }
  282. static void rgb_task_start(void) {
  283. // reset iter
  284. rgb_effect_params.iter = 0;
  285. // update double buffers
  286. g_rgb_timer = rgb_timer_buffer;
  287. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  288. g_last_hit_tracker = last_hit_buffer;
  289. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  290. // next task
  291. rgb_task_state = RENDERING;
  292. }
  293. static void rgb_task_render(uint8_t effect) {
  294. bool rendering = false;
  295. rgb_effect_params.init = (effect != rgb_last_effect) || (rgb_matrix_config.enable != rgb_last_enable);
  296. if (rgb_effect_params.flags != rgb_matrix_config.flags) {
  297. rgb_effect_params.flags = rgb_matrix_config.flags;
  298. rgb_matrix_set_color_all(0, 0, 0);
  299. }
  300. // each effect can opt to do calculations
  301. // and/or request PWM buffer updates.
  302. switch (effect) {
  303. case RGB_MATRIX_NONE:
  304. rendering = rgb_matrix_none(&rgb_effect_params);
  305. break;
  306. // ---------------------------------------------
  307. // -----Begin rgb effect switch case macros-----
  308. #define RGB_MATRIX_EFFECT(name, ...) \
  309. case RGB_MATRIX_##name: \
  310. rendering = name(&rgb_effect_params); \
  311. break;
  312. #include "rgb_matrix_effects.inc"
  313. #undef RGB_MATRIX_EFFECT
  314. #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER)
  315. # define RGB_MATRIX_EFFECT(name, ...) \
  316. case RGB_MATRIX_CUSTOM_##name: \
  317. rendering = name(&rgb_effect_params); \
  318. break;
  319. # ifdef RGB_MATRIX_CUSTOM_KB
  320. # include "rgb_matrix_kb.inc"
  321. # endif
  322. # ifdef RGB_MATRIX_CUSTOM_USER
  323. # include "rgb_matrix_user.inc"
  324. # endif
  325. # undef RGB_MATRIX_EFFECT
  326. #endif
  327. // -----End rgb effect switch case macros-------
  328. // ---------------------------------------------
  329. // Factory default magic value
  330. case UINT8_MAX: {
  331. rgb_matrix_test();
  332. rgb_task_state = FLUSHING;
  333. }
  334. return;
  335. }
  336. rgb_effect_params.iter++;
  337. // next task
  338. if (!rendering) {
  339. rgb_task_state = FLUSHING;
  340. if (!rgb_effect_params.init && effect == RGB_MATRIX_NONE) {
  341. // We only need to flush once if we are RGB_MATRIX_NONE
  342. rgb_task_state = SYNCING;
  343. }
  344. }
  345. }
  346. static void rgb_task_flush(uint8_t effect) {
  347. // update last trackers after the first full render so we can init over several frames
  348. rgb_last_effect = effect;
  349. rgb_last_enable = rgb_matrix_config.enable;
  350. // update pwm buffers
  351. rgb_matrix_update_pwm_buffers();
  352. // next task
  353. rgb_task_state = SYNCING;
  354. }
  355. void rgb_matrix_task(void) {
  356. rgb_task_timers();
  357. // Ideally we would also stop sending zeros to the LED driver PWM buffers
  358. // while suspended and just do a software shutdown. This is a cheap hack for now.
  359. bool suspend_backlight = suspend_state ||
  360. #if RGB_DISABLE_TIMEOUT > 0
  361. (rgb_anykey_timer > (uint32_t)RGB_DISABLE_TIMEOUT) ||
  362. #endif // RGB_DISABLE_TIMEOUT > 0
  363. false;
  364. uint8_t effect = suspend_backlight || !rgb_matrix_config.enable ? 0 : rgb_matrix_config.mode;
  365. switch (rgb_task_state) {
  366. case STARTING:
  367. rgb_task_start();
  368. break;
  369. case RENDERING:
  370. rgb_task_render(effect);
  371. if (effect) {
  372. rgb_matrix_indicators();
  373. rgb_matrix_indicators_advanced(&rgb_effect_params);
  374. }
  375. break;
  376. case FLUSHING:
  377. rgb_task_flush(effect);
  378. break;
  379. case SYNCING:
  380. rgb_task_sync();
  381. break;
  382. }
  383. }
  384. void rgb_matrix_indicators(void) {
  385. rgb_matrix_indicators_kb();
  386. rgb_matrix_indicators_user();
  387. }
  388. __attribute__((weak)) void rgb_matrix_indicators_kb(void) {}
  389. __attribute__((weak)) void rgb_matrix_indicators_user(void) {}
  390. void rgb_matrix_indicators_advanced(effect_params_t *params) {
  391. /* special handling is needed for "params->iter", since it's already been incremented.
  392. * Could move the invocations to rgb_task_render, but then it's missing a few checks
  393. * and not sure which would be better. Otherwise, this should be called from
  394. * rgb_task_render, right before the iter++ line.
  395. */
  396. #if defined(RGB_MATRIX_LED_PROCESS_LIMIT) && RGB_MATRIX_LED_PROCESS_LIMIT > 0 && RGB_MATRIX_LED_PROCESS_LIMIT < DRIVER_LED_TOTAL
  397. uint8_t min = RGB_MATRIX_LED_PROCESS_LIMIT * (params->iter - 1);
  398. uint8_t max = min + RGB_MATRIX_LED_PROCESS_LIMIT;
  399. if (max > DRIVER_LED_TOTAL) max = DRIVER_LED_TOTAL;
  400. #else
  401. uint8_t min = 0;
  402. uint8_t max = DRIVER_LED_TOTAL;
  403. #endif
  404. rgb_matrix_indicators_advanced_kb(min, max);
  405. rgb_matrix_indicators_advanced_user(min, max);
  406. }
  407. __attribute__((weak)) void rgb_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {}
  408. __attribute__((weak)) void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {}
  409. void rgb_matrix_init(void) {
  410. rgb_matrix_driver.init();
  411. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  412. g_last_hit_tracker.count = 0;
  413. for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  414. g_last_hit_tracker.tick[i] = UINT16_MAX;
  415. }
  416. last_hit_buffer.count = 0;
  417. for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
  418. last_hit_buffer.tick[i] = UINT16_MAX;
  419. }
  420. #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
  421. if (!eeconfig_is_enabled()) {
  422. dprintf("rgb_matrix_init_drivers eeconfig is not enabled.\n");
  423. eeconfig_init();
  424. eeconfig_update_rgb_matrix_default();
  425. }
  426. eeconfig_init_rgb_matrix();
  427. if (!rgb_matrix_config.mode) {
  428. dprintf("rgb_matrix_init_drivers rgb_matrix_config.mode = 0. Write default values to EEPROM.\n");
  429. eeconfig_update_rgb_matrix_default();
  430. }
  431. eeconfig_debug_rgb_matrix(); // display current eeprom values
  432. }
  433. void rgb_matrix_set_suspend_state(bool state) {
  434. #ifdef RGB_DISABLE_WHEN_USB_SUSPENDED
  435. if (state && !suspend_state) { // only run if turning off, and only once
  436. rgb_task_render(0); // turn off all LEDs when suspending
  437. rgb_task_flush(0); // and actually flash led state to LEDs
  438. }
  439. suspend_state = state;
  440. #endif
  441. }
  442. bool rgb_matrix_get_suspend_state(void) {
  443. return suspend_state;
  444. }
  445. void rgb_matrix_toggle_eeprom_helper(bool write_to_eeprom) {
  446. rgb_matrix_config.enable ^= 1;
  447. rgb_task_state = STARTING;
  448. eeconfig_flag_rgb_matrix(write_to_eeprom);
  449. dprintf("rgb matrix toggle [%s]: rgb_matrix_config.enable = %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.enable);
  450. }
  451. void rgb_matrix_toggle_noeeprom(void) {
  452. rgb_matrix_toggle_eeprom_helper(false);
  453. }
  454. void rgb_matrix_toggle(void) {
  455. rgb_matrix_toggle_eeprom_helper(true);
  456. }
  457. void rgb_matrix_enable(void) {
  458. rgb_matrix_enable_noeeprom();
  459. eeconfig_flag_rgb_matrix(true);
  460. }
  461. void rgb_matrix_enable_noeeprom(void) {
  462. if (!rgb_matrix_config.enable) rgb_task_state = STARTING;
  463. rgb_matrix_config.enable = 1;
  464. }
  465. void rgb_matrix_disable(void) {
  466. rgb_matrix_disable_noeeprom();
  467. eeconfig_flag_rgb_matrix(true);
  468. }
  469. void rgb_matrix_disable_noeeprom(void) {
  470. if (rgb_matrix_config.enable) rgb_task_state = STARTING;
  471. rgb_matrix_config.enable = 0;
  472. }
  473. uint8_t rgb_matrix_is_enabled(void) {
  474. return rgb_matrix_config.enable;
  475. }
  476. void rgb_matrix_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
  477. if (!rgb_matrix_config.enable) {
  478. return;
  479. }
  480. if (mode < 1) {
  481. rgb_matrix_config.mode = 1;
  482. } else if (mode >= RGB_MATRIX_EFFECT_MAX) {
  483. rgb_matrix_config.mode = RGB_MATRIX_EFFECT_MAX - 1;
  484. } else {
  485. rgb_matrix_config.mode = mode;
  486. }
  487. rgb_task_state = STARTING;
  488. eeconfig_flag_rgb_matrix(write_to_eeprom);
  489. dprintf("rgb matrix mode [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.mode);
  490. }
  491. void rgb_matrix_mode_noeeprom(uint8_t mode) {
  492. rgb_matrix_mode_eeprom_helper(mode, false);
  493. }
  494. void rgb_matrix_mode(uint8_t mode) {
  495. rgb_matrix_mode_eeprom_helper(mode, true);
  496. }
  497. uint8_t rgb_matrix_get_mode(void) {
  498. return rgb_matrix_config.mode;
  499. }
  500. void rgb_matrix_step_helper(bool write_to_eeprom) {
  501. uint8_t mode = rgb_matrix_config.mode + 1;
  502. rgb_matrix_mode_eeprom_helper((mode < RGB_MATRIX_EFFECT_MAX) ? mode : 1, write_to_eeprom);
  503. }
  504. void rgb_matrix_step_noeeprom(void) {
  505. rgb_matrix_step_helper(false);
  506. }
  507. void rgb_matrix_step(void) {
  508. rgb_matrix_step_helper(true);
  509. }
  510. void rgb_matrix_step_reverse_helper(bool write_to_eeprom) {
  511. uint8_t mode = rgb_matrix_config.mode - 1;
  512. rgb_matrix_mode_eeprom_helper((mode < 1) ? RGB_MATRIX_EFFECT_MAX - 1 : mode, write_to_eeprom);
  513. }
  514. void rgb_matrix_step_reverse_noeeprom(void) {
  515. rgb_matrix_step_reverse_helper(false);
  516. }
  517. void rgb_matrix_step_reverse(void) {
  518. rgb_matrix_step_reverse_helper(true);
  519. }
  520. void rgb_matrix_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
  521. if (!rgb_matrix_config.enable) {
  522. return;
  523. }
  524. rgb_matrix_config.hsv.h = hue;
  525. rgb_matrix_config.hsv.s = sat;
  526. rgb_matrix_config.hsv.v = (val > RGB_MATRIX_MAXIMUM_BRIGHTNESS) ? RGB_MATRIX_MAXIMUM_BRIGHTNESS : val;
  527. eeconfig_flag_rgb_matrix(write_to_eeprom);
  528. 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);
  529. }
  530. void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
  531. rgb_matrix_sethsv_eeprom_helper(hue, sat, val, false);
  532. }
  533. void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
  534. rgb_matrix_sethsv_eeprom_helper(hue, sat, val, true);
  535. }
  536. HSV rgb_matrix_get_hsv(void) {
  537. return rgb_matrix_config.hsv;
  538. }
  539. uint8_t rgb_matrix_get_hue(void) {
  540. return rgb_matrix_config.hsv.h;
  541. }
  542. uint8_t rgb_matrix_get_sat(void) {
  543. return rgb_matrix_config.hsv.s;
  544. }
  545. uint8_t rgb_matrix_get_val(void) {
  546. return rgb_matrix_config.hsv.v;
  547. }
  548. void rgb_matrix_increase_hue_helper(bool write_to_eeprom) {
  549. 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);
  550. }
  551. void rgb_matrix_increase_hue_noeeprom(void) {
  552. rgb_matrix_increase_hue_helper(false);
  553. }
  554. void rgb_matrix_increase_hue(void) {
  555. rgb_matrix_increase_hue_helper(true);
  556. }
  557. void rgb_matrix_decrease_hue_helper(bool write_to_eeprom) {
  558. 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);
  559. }
  560. void rgb_matrix_decrease_hue_noeeprom(void) {
  561. rgb_matrix_decrease_hue_helper(false);
  562. }
  563. void rgb_matrix_decrease_hue(void) {
  564. rgb_matrix_decrease_hue_helper(true);
  565. }
  566. void rgb_matrix_increase_sat_helper(bool write_to_eeprom) {
  567. 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);
  568. }
  569. void rgb_matrix_increase_sat_noeeprom(void) {
  570. rgb_matrix_increase_sat_helper(false);
  571. }
  572. void rgb_matrix_increase_sat(void) {
  573. rgb_matrix_increase_sat_helper(true);
  574. }
  575. void rgb_matrix_decrease_sat_helper(bool write_to_eeprom) {
  576. 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);
  577. }
  578. void rgb_matrix_decrease_sat_noeeprom(void) {
  579. rgb_matrix_decrease_sat_helper(false);
  580. }
  581. void rgb_matrix_decrease_sat(void) {
  582. rgb_matrix_decrease_sat_helper(true);
  583. }
  584. void rgb_matrix_increase_val_helper(bool write_to_eeprom) {
  585. 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);
  586. }
  587. void rgb_matrix_increase_val_noeeprom(void) {
  588. rgb_matrix_increase_val_helper(false);
  589. }
  590. void rgb_matrix_increase_val(void) {
  591. rgb_matrix_increase_val_helper(true);
  592. }
  593. void rgb_matrix_decrease_val_helper(bool write_to_eeprom) {
  594. 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);
  595. }
  596. void rgb_matrix_decrease_val_noeeprom(void) {
  597. rgb_matrix_decrease_val_helper(false);
  598. }
  599. void rgb_matrix_decrease_val(void) {
  600. rgb_matrix_decrease_val_helper(true);
  601. }
  602. void rgb_matrix_set_speed_eeprom_helper(uint8_t speed, bool write_to_eeprom) {
  603. rgb_matrix_config.speed = speed;
  604. eeconfig_flag_rgb_matrix(write_to_eeprom);
  605. dprintf("rgb matrix set speed [%s]: %u\n", (write_to_eeprom) ? "EEPROM" : "NOEEPROM", rgb_matrix_config.speed);
  606. }
  607. void rgb_matrix_set_speed_noeeprom(uint8_t speed) {
  608. rgb_matrix_set_speed_eeprom_helper(speed, false);
  609. }
  610. void rgb_matrix_set_speed(uint8_t speed) {
  611. rgb_matrix_set_speed_eeprom_helper(speed, true);
  612. }
  613. uint8_t rgb_matrix_get_speed(void) {
  614. return rgb_matrix_config.speed;
  615. }
  616. void rgb_matrix_increase_speed_helper(bool write_to_eeprom) {
  617. rgb_matrix_set_speed_eeprom_helper(qadd8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP), write_to_eeprom);
  618. }
  619. void rgb_matrix_increase_speed_noeeprom(void) {
  620. rgb_matrix_increase_speed_helper(false);
  621. }
  622. void rgb_matrix_increase_speed(void) {
  623. rgb_matrix_increase_speed_helper(true);
  624. }
  625. void rgb_matrix_decrease_speed_helper(bool write_to_eeprom) {
  626. rgb_matrix_set_speed_eeprom_helper(qsub8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP), write_to_eeprom);
  627. }
  628. void rgb_matrix_decrease_speed_noeeprom(void) {
  629. rgb_matrix_decrease_speed_helper(false);
  630. }
  631. void rgb_matrix_decrease_speed(void) {
  632. rgb_matrix_decrease_speed_helper(true);
  633. }
  634. led_flags_t rgb_matrix_get_flags(void) {
  635. return rgb_matrix_config.flags;
  636. }
  637. void rgb_matrix_set_flags(led_flags_t flags) {
  638. rgb_matrix_config.flags = flags;
  639. }