1 /* Copyright 2017 Jason Williams
2 * Copyright 2017 Jack Humbert
3 * Copyright 2018 Yiancar
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.
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.
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/>.
20 #include "rgb_matrix.h"
27 #include "lib/lib8tion/lib8tion.h"
29 #ifndef RGB_MATRIX_CENTER
30 const point_t k_rgb_matrix_center = { 112, 32 };
32 const point_t k_rgb_matrix_center = RGB_MATRIX_CENTER;
35 // Generic effect runners
36 #include "rgb_matrix_runners/effect_runner_dx_dy_dist.h"
37 #include "rgb_matrix_runners/effect_runner_dx_dy.h"
38 #include "rgb_matrix_runners/effect_runner_i.h"
39 #include "rgb_matrix_runners/effect_runner_sin_cos_i.h"
40 #include "rgb_matrix_runners/effect_runner_reactive.h"
41 #include "rgb_matrix_runners/effect_runner_reactive_splash.h"
43 // ------------------------------------------
44 // -----Begin rgb effect includes macros-----
45 #define RGB_MATRIX_EFFECT(name)
46 #define RGB_MATRIX_CUSTOM_EFFECT_IMPLS
48 #include "rgb_matrix_animations/rgb_matrix_effects.inc"
49 #ifdef RGB_MATRIX_CUSTOM_KB
50 #include "rgb_matrix_kb.inc"
52 #ifdef RGB_MATRIX_CUSTOM_USER
53 #include "rgb_matrix_user.inc"
56 #undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
57 #undef RGB_MATRIX_EFFECT
58 // -----End rgb effect includes macros-------
59 // ------------------------------------------
61 #ifndef RGB_DISABLE_AFTER_TIMEOUT
62 #define RGB_DISABLE_AFTER_TIMEOUT 0
65 #ifndef RGB_DISABLE_WHEN_USB_SUSPENDED
66 #define RGB_DISABLE_WHEN_USB_SUSPENDED false
69 #if !defined(RGB_MATRIX_MAXIMUM_BRIGHTNESS) || RGB_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX
70 #undef RGB_MATRIX_MAXIMUM_BRIGHTNESS
71 #define RGB_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX
74 #if !defined(RGB_MATRIX_HUE_STEP)
75 #define RGB_MATRIX_HUE_STEP 8
78 #if !defined(RGB_MATRIX_SAT_STEP)
79 #define RGB_MATRIX_SAT_STEP 16
82 #if !defined(RGB_MATRIX_VAL_STEP)
83 #define RGB_MATRIX_VAL_STEP 16
86 #if !defined(RGB_MATRIX_SPD_STEP)
87 #define RGB_MATRIX_SPD_STEP 16
90 #if !defined(RGB_MATRIX_STARTUP_MODE)
91 #ifndef DISABLE_RGB_MATRIX_CYCLE_ALL
92 #define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT
94 // fallback to solid colors if RGB_MATRIX_CYCLE_LEFT_RIGHT is disabled in userspace
95 #define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_SOLID_COLOR
99 bool g_suspend_state = false;
101 rgb_config_t rgb_matrix_config;
103 rgb_counters_t g_rgb_counters;
104 static uint32_t rgb_counters_buffer;
106 #ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS
107 uint8_t rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS] = {{0}};
110 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
111 last_hit_t g_last_hit_tracker;
112 static last_hit_t last_hit_buffer;
113 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
115 void eeconfig_read_rgb_matrix(void) {
116 eeprom_read_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config));
119 void eeconfig_update_rgb_matrix(void) {
120 eeprom_update_block(&rgb_matrix_config, EECONFIG_RGB_MATRIX, sizeof(rgb_matrix_config));
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){ 0, UINT8_MAX, RGB_MATRIX_MAXIMUM_BRIGHTNESS };
128 rgb_matrix_config.speed = UINT8_MAX / 2;
129 eeconfig_update_rgb_matrix();
132 void eeconfig_debug_rgb_matrix(void) {
133 dprintf("rgb_matrix_config eprom\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);
142 __attribute__ ((weak))
143 uint8_t rgb_matrix_map_row_column_to_led_kb(uint8_t row, uint8_t column, uint8_t *led_i) {
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;
157 void rgb_matrix_update_pwm_buffers(void) {
158 rgb_matrix_driver.flush();
161 void rgb_matrix_set_color( int index, uint8_t red, uint8_t green, uint8_t blue ) {
162 rgb_matrix_driver.set_color(index, red, green, blue);
165 void rgb_matrix_set_color_all( uint8_t red, uint8_t green, uint8_t blue ) {
166 rgb_matrix_driver.set_color_all(red, green, blue);
169 bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record) {
170 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
171 uint8_t led[LED_HITS_TO_REMEMBER];
172 uint8_t led_count = 0;
174 #if defined(RGB_MATRIX_KEYRELEASES)
175 if (!record->event.pressed) {
176 led_count = rgb_matrix_map_row_column_to_led(record->event.key.row, record->event.key.col, led);
177 g_rgb_counters.any_key_hit = 0;
179 #elif defined(RGB_MATRIX_KEYPRESSES)
180 if (record->event.pressed) {
181 led_count = rgb_matrix_map_row_column_to_led(record->event.key.row, record->event.key.col, led);
182 g_rgb_counters.any_key_hit = 0;
184 #endif // defined(RGB_MATRIX_KEYRELEASES)
186 if (last_hit_buffer.count + led_count > LED_HITS_TO_REMEMBER) {
187 memcpy(&last_hit_buffer.x[0], &last_hit_buffer.x[led_count], LED_HITS_TO_REMEMBER - led_count);
188 memcpy(&last_hit_buffer.y[0], &last_hit_buffer.y[led_count], LED_HITS_TO_REMEMBER - led_count);
189 memcpy(&last_hit_buffer.tick[0], &last_hit_buffer.tick[led_count], (LED_HITS_TO_REMEMBER - led_count) * 2); // 16 bit
190 memcpy(&last_hit_buffer.index[0], &last_hit_buffer.index[led_count], LED_HITS_TO_REMEMBER - led_count);
191 last_hit_buffer.count--;
194 for(uint8_t i = 0; i < led_count; i++) {
195 uint8_t index = last_hit_buffer.count;
196 last_hit_buffer.x[index] = g_led_config.point[led[i]].x;
197 last_hit_buffer.y[index] = g_led_config.point[led[i]].y;
198 last_hit_buffer.index[index] = led[i];
199 last_hit_buffer.tick[index] = 0;
200 last_hit_buffer.count++;
202 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
204 #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
205 if (rgb_matrix_config.mode == RGB_MATRIX_TYPING_HEATMAP) {
206 process_rgb_matrix_typing_heatmap(record);
208 #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
213 void rgb_matrix_test(void) {
214 // Mask out bits 4 and 5
215 // Increase the factor to make the test animation slower (and reduce to make it faster)
217 switch ( (g_rgb_counters.tick & (0b11 << factor)) >> factor )
220 rgb_matrix_set_color_all( 20, 0, 0 );
224 rgb_matrix_set_color_all( 0, 20, 0 );
228 rgb_matrix_set_color_all( 0, 0, 20 );
232 rgb_matrix_set_color_all( 20, 20, 20 );
238 static bool rgb_matrix_none(effect_params_t* params) {
243 RGB_MATRIX_USE_LIMITS(led_min, led_max);
244 for (uint8_t i = led_min; i < led_max; i++) {
245 rgb_matrix_set_color(i, 0, 0, 0);
247 return led_max < DRIVER_LED_TOTAL;
250 static uint8_t rgb_last_enable = UINT8_MAX;
251 static uint8_t rgb_last_effect = UINT8_MAX;
252 static effect_params_t rgb_effect_params = { 0, 0xFF };
253 static rgb_task_states rgb_task_state = SYNCING;
255 static void rgb_task_timers(void) {
256 // Update double buffer timers
257 uint16_t deltaTime = timer_elapsed32(rgb_counters_buffer);
258 rgb_counters_buffer = timer_read32();
259 if (g_rgb_counters.any_key_hit < UINT32_MAX) {
260 if (UINT32_MAX - deltaTime < g_rgb_counters.any_key_hit) {
261 g_rgb_counters.any_key_hit = UINT32_MAX;
263 g_rgb_counters.any_key_hit += deltaTime;
267 // Update double buffer last hit timers
268 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
269 uint8_t count = last_hit_buffer.count;
270 for (uint8_t i = 0; i < count; ++i) {
271 if (UINT16_MAX - deltaTime < last_hit_buffer.tick[i]) {
272 last_hit_buffer.count--;
275 last_hit_buffer.tick[i] += deltaTime;
277 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
280 static void rgb_task_sync(void) {
282 if (timer_elapsed32(g_rgb_counters.tick) >= RGB_MATRIX_LED_FLUSH_LIMIT)
283 rgb_task_state = STARTING;
286 static void rgb_task_start(void) {
288 rgb_effect_params.iter = 0;
290 // update double buffers
291 g_rgb_counters.tick = rgb_counters_buffer;
292 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
293 g_last_hit_tracker = last_hit_buffer;
294 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
297 rgb_task_state = RENDERING;
300 static void rgb_task_render(uint8_t effect) {
301 bool rendering = false;
302 rgb_effect_params.init = (effect != rgb_last_effect) || (rgb_matrix_config.enable != rgb_last_enable);
304 // each effect can opt to do calculations
305 // and/or request PWM buffer updates.
307 case RGB_MATRIX_NONE:
308 rendering = rgb_matrix_none(&rgb_effect_params);
311 // ---------------------------------------------
312 // -----Begin rgb effect switch case macros-----
313 #define RGB_MATRIX_EFFECT(name, ...) \
314 case RGB_MATRIX_##name: \
315 rendering = name(&rgb_effect_params); \
317 #include "rgb_matrix_animations/rgb_matrix_effects.inc"
318 #undef RGB_MATRIX_EFFECT
320 #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER)
321 #define RGB_MATRIX_EFFECT(name, ...) \
322 case RGB_MATRIX_CUSTOM_##name: \
323 rendering = name(&rgb_effect_params); \
325 #ifdef RGB_MATRIX_CUSTOM_KB
326 #include "rgb_matrix_kb.inc"
328 #ifdef RGB_MATRIX_CUSTOM_USER
329 #include "rgb_matrix_user.inc"
331 #undef RGB_MATRIX_EFFECT
333 // -----End rgb effect switch case macros-------
334 // ---------------------------------------------
336 // Factory default magic value
339 rgb_task_state = FLUSHING;
344 rgb_effect_params.iter++;
348 rgb_task_state = FLUSHING;
349 if (!rgb_effect_params.init && effect == RGB_MATRIX_NONE) {
350 // We only need to flush once if we are RGB_MATRIX_NONE
351 rgb_task_state = SYNCING;
356 static void rgb_task_flush(uint8_t effect) {
357 // update last trackers after the first full render so we can init over several frames
358 rgb_last_effect = effect;
359 rgb_last_enable = rgb_matrix_config.enable;
361 // update pwm buffers
362 rgb_matrix_update_pwm_buffers();
365 rgb_task_state = SYNCING;
368 void rgb_matrix_task(void) {
371 // Ideally we would also stop sending zeros to the LED driver PWM buffers
372 // while suspended and just do a software shutdown. This is a cheap hack for now.
373 bool suspend_backlight = ((g_suspend_state && RGB_DISABLE_WHEN_USB_SUSPENDED) || (RGB_DISABLE_AFTER_TIMEOUT > 0 && g_rgb_counters.any_key_hit > RGB_DISABLE_AFTER_TIMEOUT * 60 * 20));
374 uint8_t effect = suspend_backlight || !rgb_matrix_config.enable ? 0 : rgb_matrix_config.mode;
376 switch (rgb_task_state) {
381 rgb_task_render(effect);
384 rgb_task_flush(effect);
391 if (!suspend_backlight) {
392 rgb_matrix_indicators();
396 void rgb_matrix_indicators(void) {
397 rgb_matrix_indicators_kb();
398 rgb_matrix_indicators_user();
401 __attribute__((weak))
402 void rgb_matrix_indicators_kb(void) {}
404 __attribute__((weak))
405 void rgb_matrix_indicators_user(void) {}
407 void rgb_matrix_init(void) {
408 rgb_matrix_driver.init();
410 // TODO: put the 1 second startup delay here?
412 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
413 g_last_hit_tracker.count = 0;
414 for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
415 g_last_hit_tracker.tick[i] = UINT16_MAX;
418 last_hit_buffer.count = 0;
419 for (uint8_t i = 0; i < LED_HITS_TO_REMEMBER; ++i) {
420 last_hit_buffer.tick[i] = UINT16_MAX;
422 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
424 if (!eeconfig_is_enabled()) {
425 dprintf("rgb_matrix_init_drivers eeconfig is not enabled.\n");
427 eeconfig_update_rgb_matrix_default();
430 eeconfig_read_rgb_matrix();
431 if (!rgb_matrix_config.mode) {
432 dprintf("rgb_matrix_init_drivers rgb_matrix_config.mode = 0. Write default values to EEPROM.\n");
433 eeconfig_update_rgb_matrix_default();
435 eeconfig_debug_rgb_matrix(); // display current eeprom values
438 void rgb_matrix_set_suspend_state(bool state) {
439 g_suspend_state = state;
442 void rgb_matrix_toggle(void) {
443 rgb_matrix_config.enable ^= 1;
444 rgb_task_state = STARTING;
445 eeconfig_update_rgb_matrix();
448 void rgb_matrix_enable(void) {
449 rgb_matrix_enable_noeeprom();
450 eeconfig_update_rgb_matrix();
453 void rgb_matrix_enable_noeeprom(void) {
454 if (!rgb_matrix_config.enable)
455 rgb_task_state = STARTING;
456 rgb_matrix_config.enable = 1;
459 void rgb_matrix_disable(void) {
460 rgb_matrix_disable_noeeprom();
461 eeconfig_update_rgb_matrix();
464 void rgb_matrix_disable_noeeprom(void) {
465 if (rgb_matrix_config.enable)
466 rgb_task_state = STARTING;
467 rgb_matrix_config.enable = 0;
470 void rgb_matrix_step(void) {
471 rgb_matrix_config.mode++;
472 if (rgb_matrix_config.mode >= RGB_MATRIX_EFFECT_MAX)
473 rgb_matrix_config.mode = 1;
474 rgb_task_state = STARTING;
475 eeconfig_update_rgb_matrix();
478 void rgb_matrix_step_reverse(void) {
479 rgb_matrix_config.mode--;
480 if (rgb_matrix_config.mode < 1)
481 rgb_matrix_config.mode = RGB_MATRIX_EFFECT_MAX - 1;
482 rgb_task_state = STARTING;
483 eeconfig_update_rgb_matrix();
486 void rgb_matrix_increase_hue(void) {
487 rgb_matrix_config.hsv.h += RGB_MATRIX_HUE_STEP;
488 eeconfig_update_rgb_matrix();
491 void rgb_matrix_decrease_hue(void) {
492 rgb_matrix_config.hsv.h -= RGB_MATRIX_HUE_STEP;
493 eeconfig_update_rgb_matrix();
496 void rgb_matrix_increase_sat(void) {
497 rgb_matrix_config.hsv.s = qadd8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP);
498 eeconfig_update_rgb_matrix();
501 void rgb_matrix_decrease_sat(void) {
502 rgb_matrix_config.hsv.s = qsub8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP);
503 eeconfig_update_rgb_matrix();
506 void rgb_matrix_increase_val(void) {
507 rgb_matrix_config.hsv.v = qadd8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP);
508 if (rgb_matrix_config.hsv.v > RGB_MATRIX_MAXIMUM_BRIGHTNESS)
509 rgb_matrix_config.hsv.v = RGB_MATRIX_MAXIMUM_BRIGHTNESS;
510 eeconfig_update_rgb_matrix();
513 void rgb_matrix_decrease_val(void) {
514 rgb_matrix_config.hsv.v = qsub8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP);
515 eeconfig_update_rgb_matrix();
518 void rgb_matrix_increase_speed(void) {
519 rgb_matrix_config.speed = qadd8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP);
520 eeconfig_update_rgb_matrix();
523 void rgb_matrix_decrease_speed(void) {
524 rgb_matrix_config.speed = qsub8(rgb_matrix_config.speed, RGB_MATRIX_SPD_STEP);
525 eeconfig_update_rgb_matrix();
528 led_flags_t rgb_matrix_get_flags(void) {
529 return rgb_effect_params.flags;
532 void rgb_matrix_set_flags(led_flags_t flags) {
533 rgb_effect_params.flags = flags;
536 void rgb_matrix_mode(uint8_t mode) {
537 rgb_matrix_config.mode = mode;
538 rgb_task_state = STARTING;
539 eeconfig_update_rgb_matrix();
542 void rgb_matrix_mode_noeeprom(uint8_t mode) {
543 rgb_matrix_config.mode = mode;
546 uint8_t rgb_matrix_get_mode(void) {
547 return rgb_matrix_config.mode;
550 void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
551 rgb_matrix_sethsv_noeeprom(hue, sat, val);
552 eeconfig_update_rgb_matrix();
555 void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
556 rgb_matrix_config.hsv.h = hue;
557 rgb_matrix_config.hsv.s = sat;
558 rgb_matrix_config.hsv.v = val;
559 if (rgb_matrix_config.hsv.v > RGB_MATRIX_MAXIMUM_BRIGHTNESS)
560 rgb_matrix_config.hsv.v = RGB_MATRIX_MAXIMUM_BRIGHTNESS;