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/>.
19 #include "rgb_matrix.h"
26 #include "lib/lib8tion/lib8tion.h"
28 #ifndef RGB_MATRIX_CENTER
29 const point_t k_rgb_matrix_center
= {112, 32};
31 const point_t k_rgb_matrix_center
= RGB_MATRIX_CENTER
;
34 // Generic effect runners
35 #include "rgb_matrix_runners/effect_runner_dx_dy_dist.h"
36 #include "rgb_matrix_runners/effect_runner_dx_dy.h"
37 #include "rgb_matrix_runners/effect_runner_i.h"
38 #include "rgb_matrix_runners/effect_runner_sin_cos_i.h"
39 #include "rgb_matrix_runners/effect_runner_reactive.h"
40 #include "rgb_matrix_runners/effect_runner_reactive_splash.h"
42 // ------------------------------------------
43 // -----Begin rgb effect includes macros-----
44 #define RGB_MATRIX_EFFECT(name)
45 #define RGB_MATRIX_CUSTOM_EFFECT_IMPLS
47 #include "rgb_matrix_animations/rgb_matrix_effects.inc"
48 #ifdef RGB_MATRIX_CUSTOM_KB
49 # include "rgb_matrix_kb.inc"
51 #ifdef RGB_MATRIX_CUSTOM_USER
52 # include "rgb_matrix_user.inc"
55 #undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
56 #undef RGB_MATRIX_EFFECT
57 // -----End rgb effect includes macros-------
58 // ------------------------------------------
60 #ifndef RGB_DISABLE_AFTER_TIMEOUT
61 # define RGB_DISABLE_AFTER_TIMEOUT 0
64 #ifndef RGB_DISABLE_WHEN_USB_SUSPENDED
65 # define RGB_DISABLE_WHEN_USB_SUSPENDED false
68 #if !defined(RGB_MATRIX_MAXIMUM_BRIGHTNESS) || RGB_MATRIX_MAXIMUM_BRIGHTNESS > UINT8_MAX
69 # undef RGB_MATRIX_MAXIMUM_BRIGHTNESS
70 # define RGB_MATRIX_MAXIMUM_BRIGHTNESS UINT8_MAX
73 #if !defined(RGB_MATRIX_HUE_STEP)
74 # define RGB_MATRIX_HUE_STEP 8
77 #if !defined(RGB_MATRIX_SAT_STEP)
78 # define RGB_MATRIX_SAT_STEP 16
81 #if !defined(RGB_MATRIX_VAL_STEP)
82 # define RGB_MATRIX_VAL_STEP 16
85 #if !defined(RGB_MATRIX_SPD_STEP)
86 # define RGB_MATRIX_SPD_STEP 16
89 #if !defined(RGB_MATRIX_STARTUP_MODE)
90 # ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
91 # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT
93 // fallback to solid colors if RGB_MATRIX_CYCLE_LEFT_RIGHT is disabled in userspace
94 # define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_SOLID_COLOR
98 bool g_suspend_state
= false;
100 rgb_config_t rgb_matrix_config
;
102 rgb_counters_t g_rgb_counters
;
103 static uint32_t rgb_counters_buffer
;
105 #ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS
106 uint8_t rgb_frame_buffer
[MATRIX_ROWS
][MATRIX_COLS
] = {{0}};
109 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
110 last_hit_t g_last_hit_tracker
;
111 static last_hit_t last_hit_buffer
;
112 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
114 void eeconfig_read_rgb_matrix(void) { eeprom_read_block(&rgb_matrix_config
, EECONFIG_RGB_MATRIX
, sizeof(rgb_matrix_config
)); }
116 void eeconfig_update_rgb_matrix(void) { eeprom_update_block(&rgb_matrix_config
, EECONFIG_RGB_MATRIX
, sizeof(rgb_matrix_config
)); }
118 void eeconfig_update_rgb_matrix_default(void) {
119 dprintf("eeconfig_update_rgb_matrix_default\n");
120 rgb_matrix_config
.enable
= 1;
121 rgb_matrix_config
.mode
= RGB_MATRIX_STARTUP_MODE
;
122 rgb_matrix_config
.hsv
= (HSV
){0, UINT8_MAX
, RGB_MATRIX_MAXIMUM_BRIGHTNESS
};
123 rgb_matrix_config
.speed
= UINT8_MAX
/ 2;
124 eeconfig_update_rgb_matrix();
127 void eeconfig_debug_rgb_matrix(void) {
128 dprintf("rgb_matrix_config eprom\n");
129 dprintf("rgb_matrix_config.enable = %d\n", rgb_matrix_config
.enable
);
130 dprintf("rgb_matrix_config.mode = %d\n", rgb_matrix_config
.mode
);
131 dprintf("rgb_matrix_config.hsv.h = %d\n", rgb_matrix_config
.hsv
.h
);
132 dprintf("rgb_matrix_config.hsv.s = %d\n", rgb_matrix_config
.hsv
.s
);
133 dprintf("rgb_matrix_config.hsv.v = %d\n", rgb_matrix_config
.hsv
.v
);
134 dprintf("rgb_matrix_config.speed = %d\n", rgb_matrix_config
.speed
);
137 __attribute__((weak
)) uint8_t rgb_matrix_map_row_column_to_led_kb(uint8_t row
, uint8_t column
, uint8_t *led_i
) { return 0; }
139 uint8_t rgb_matrix_map_row_column_to_led(uint8_t row
, uint8_t column
, uint8_t *led_i
) {
140 uint8_t led_count
= rgb_matrix_map_row_column_to_led_kb(row
, column
, led_i
);
141 uint8_t led_index
= g_led_config
.matrix_co
[row
][column
];
142 if (led_index
!= NO_LED
) {
143 led_i
[led_count
] = led_index
;
149 void rgb_matrix_update_pwm_buffers(void) { rgb_matrix_driver
.flush(); }
151 void rgb_matrix_set_color(int index
, uint8_t red
, uint8_t green
, uint8_t blue
) { rgb_matrix_driver
.set_color(index
, red
, green
, blue
); }
153 void rgb_matrix_set_color_all(uint8_t red
, uint8_t green
, uint8_t blue
) { rgb_matrix_driver
.set_color_all(red
, green
, blue
); }
155 bool process_rgb_matrix(uint16_t keycode
, keyrecord_t
*record
) {
156 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
157 uint8_t led
[LED_HITS_TO_REMEMBER
];
158 uint8_t led_count
= 0;
160 # if defined(RGB_MATRIX_KEYRELEASES)
161 if (!record
->event
.pressed
) {
162 led_count
= rgb_matrix_map_row_column_to_led(record
->event
.key
.row
, record
->event
.key
.col
, led
);
163 g_rgb_counters
.any_key_hit
= 0;
165 # elif defined(RGB_MATRIX_KEYPRESSES)
166 if (record
->event
.pressed
) {
167 led_count
= rgb_matrix_map_row_column_to_led(record
->event
.key
.row
, record
->event
.key
.col
, led
);
168 g_rgb_counters
.any_key_hit
= 0;
170 # endif // defined(RGB_MATRIX_KEYRELEASES)
172 if (last_hit_buffer
.count
+ led_count
> LED_HITS_TO_REMEMBER
) {
173 memcpy(&last_hit_buffer
.x
[0], &last_hit_buffer
.x
[led_count
], LED_HITS_TO_REMEMBER
- led_count
);
174 memcpy(&last_hit_buffer
.y
[0], &last_hit_buffer
.y
[led_count
], LED_HITS_TO_REMEMBER
- led_count
);
175 memcpy(&last_hit_buffer
.tick
[0], &last_hit_buffer
.tick
[led_count
], (LED_HITS_TO_REMEMBER
- led_count
) * 2); // 16 bit
176 memcpy(&last_hit_buffer
.index
[0], &last_hit_buffer
.index
[led_count
], LED_HITS_TO_REMEMBER
- led_count
);
177 last_hit_buffer
.count
--;
180 for (uint8_t i
= 0; i
< led_count
; i
++) {
181 uint8_t index
= last_hit_buffer
.count
;
182 last_hit_buffer
.x
[index
] = g_led_config
.point
[led
[i
]].x
;
183 last_hit_buffer
.y
[index
] = g_led_config
.point
[led
[i
]].y
;
184 last_hit_buffer
.index
[index
] = led
[i
];
185 last_hit_buffer
.tick
[index
] = 0;
186 last_hit_buffer
.count
++;
188 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
190 #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
191 if (rgb_matrix_config
.mode
== RGB_MATRIX_TYPING_HEATMAP
) {
192 process_rgb_matrix_typing_heatmap(record
);
194 #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP)
199 void rgb_matrix_test(void) {
200 // Mask out bits 4 and 5
201 // Increase the factor to make the test animation slower (and reduce to make it faster)
203 switch ((g_rgb_counters
.tick
& (0b11 << factor
)) >> factor
) {
205 rgb_matrix_set_color_all(20, 0, 0);
209 rgb_matrix_set_color_all(0, 20, 0);
213 rgb_matrix_set_color_all(0, 0, 20);
217 rgb_matrix_set_color_all(20, 20, 20);
223 static bool rgb_matrix_none(effect_params_t
*params
) {
228 RGB_MATRIX_USE_LIMITS(led_min
, led_max
);
229 for (uint8_t i
= led_min
; i
< led_max
; i
++) {
230 rgb_matrix_set_color(i
, 0, 0, 0);
232 return led_max
< DRIVER_LED_TOTAL
;
235 static uint8_t rgb_last_enable
= UINT8_MAX
;
236 static uint8_t rgb_last_effect
= UINT8_MAX
;
237 static effect_params_t rgb_effect_params
= {0, 0xFF};
238 static rgb_task_states rgb_task_state
= SYNCING
;
240 static void rgb_task_timers(void) {
241 // Update double buffer timers
242 uint16_t deltaTime
= timer_elapsed32(rgb_counters_buffer
);
243 rgb_counters_buffer
= timer_read32();
244 if (g_rgb_counters
.any_key_hit
< UINT32_MAX
) {
245 if (UINT32_MAX
- deltaTime
< g_rgb_counters
.any_key_hit
) {
246 g_rgb_counters
.any_key_hit
= UINT32_MAX
;
248 g_rgb_counters
.any_key_hit
+= deltaTime
;
252 // Update double buffer last hit timers
253 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
254 uint8_t count
= last_hit_buffer
.count
;
255 for (uint8_t i
= 0; i
< count
; ++i
) {
256 if (UINT16_MAX
- deltaTime
< last_hit_buffer
.tick
[i
]) {
257 last_hit_buffer
.count
--;
260 last_hit_buffer
.tick
[i
] += deltaTime
;
262 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
265 static void rgb_task_sync(void) {
267 if (timer_elapsed32(g_rgb_counters
.tick
) >= RGB_MATRIX_LED_FLUSH_LIMIT
) rgb_task_state
= STARTING
;
270 static void rgb_task_start(void) {
272 rgb_effect_params
.iter
= 0;
274 // update double buffers
275 g_rgb_counters
.tick
= rgb_counters_buffer
;
276 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
277 g_last_hit_tracker
= last_hit_buffer
;
278 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
281 rgb_task_state
= RENDERING
;
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
);
288 // each effect can opt to do calculations
289 // and/or request PWM buffer updates.
291 case RGB_MATRIX_NONE
:
292 rendering
= rgb_matrix_none(&rgb_effect_params
);
295 // ---------------------------------------------
296 // -----Begin rgb effect switch case macros-----
297 #define RGB_MATRIX_EFFECT(name, ...) \
298 case RGB_MATRIX_##name: \
299 rendering = name(&rgb_effect_params); \
301 #include "rgb_matrix_animations/rgb_matrix_effects.inc"
302 #undef RGB_MATRIX_EFFECT
304 #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER)
305 # define RGB_MATRIX_EFFECT(name, ...) \
306 case RGB_MATRIX_CUSTOM_##name: \
307 rendering = name(&rgb_effect_params); \
309 # ifdef RGB_MATRIX_CUSTOM_KB
310 # include "rgb_matrix_kb.inc"
312 # ifdef RGB_MATRIX_CUSTOM_USER
313 # include "rgb_matrix_user.inc"
315 # undef RGB_MATRIX_EFFECT
317 // -----End rgb effect switch case macros-------
318 // ---------------------------------------------
320 // Factory default magic value
323 rgb_task_state
= FLUSHING
;
328 rgb_effect_params
.iter
++;
332 rgb_task_state
= FLUSHING
;
333 if (!rgb_effect_params
.init
&& effect
== RGB_MATRIX_NONE
) {
334 // We only need to flush once if we are RGB_MATRIX_NONE
335 rgb_task_state
= SYNCING
;
340 static void rgb_task_flush(uint8_t effect
) {
341 // update last trackers after the first full render so we can init over several frames
342 rgb_last_effect
= effect
;
343 rgb_last_enable
= rgb_matrix_config
.enable
;
345 // update pwm buffers
346 rgb_matrix_update_pwm_buffers();
349 rgb_task_state
= SYNCING
;
352 void rgb_matrix_task(void) {
355 // Ideally we would also stop sending zeros to the LED driver PWM buffers
356 // while suspended and just do a software shutdown. This is a cheap hack for now.
357 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));
358 uint8_t effect
= suspend_backlight
|| !rgb_matrix_config
.enable
? 0 : rgb_matrix_config
.mode
;
360 switch (rgb_task_state
) {
365 rgb_task_render(effect
);
368 rgb_task_flush(effect
);
375 if (!suspend_backlight
) {
376 rgb_matrix_indicators();
380 void rgb_matrix_indicators(void) {
381 rgb_matrix_indicators_kb();
382 rgb_matrix_indicators_user();
385 __attribute__((weak
)) void rgb_matrix_indicators_kb(void) {}
387 __attribute__((weak
)) void rgb_matrix_indicators_user(void) {}
389 void rgb_matrix_init(void) {
390 rgb_matrix_driver
.init();
392 // TODO: put the 1 second startup delay here?
394 #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
395 g_last_hit_tracker
.count
= 0;
396 for (uint8_t i
= 0; i
< LED_HITS_TO_REMEMBER
; ++i
) {
397 g_last_hit_tracker
.tick
[i
] = UINT16_MAX
;
400 last_hit_buffer
.count
= 0;
401 for (uint8_t i
= 0; i
< LED_HITS_TO_REMEMBER
; ++i
) {
402 last_hit_buffer
.tick
[i
] = UINT16_MAX
;
404 #endif // RGB_MATRIX_KEYREACTIVE_ENABLED
406 if (!eeconfig_is_enabled()) {
407 dprintf("rgb_matrix_init_drivers eeconfig is not enabled.\n");
409 eeconfig_update_rgb_matrix_default();
412 eeconfig_read_rgb_matrix();
413 if (!rgb_matrix_config
.mode
) {
414 dprintf("rgb_matrix_init_drivers rgb_matrix_config.mode = 0. Write default values to EEPROM.\n");
415 eeconfig_update_rgb_matrix_default();
417 eeconfig_debug_rgb_matrix(); // display current eeprom values
420 void rgb_matrix_set_suspend_state(bool state
) {
421 if (RGB_DISABLE_WHEN_USB_SUSPENDED
&& state
) {
422 rgb_matrix_set_color_all(0, 0, 0); // turn off all LEDs when suspending
424 g_suspend_state
= state
;
427 void rgb_matrix_toggle(void) {
428 rgb_matrix_config
.enable
^= 1;
429 rgb_task_state
= STARTING
;
430 eeconfig_update_rgb_matrix();
433 void rgb_matrix_enable(void) {
434 rgb_matrix_enable_noeeprom();
435 eeconfig_update_rgb_matrix();
438 void rgb_matrix_enable_noeeprom(void) {
439 if (!rgb_matrix_config
.enable
) rgb_task_state
= STARTING
;
440 rgb_matrix_config
.enable
= 1;
443 void rgb_matrix_disable(void) {
444 rgb_matrix_disable_noeeprom();
445 eeconfig_update_rgb_matrix();
448 void rgb_matrix_disable_noeeprom(void) {
449 if (rgb_matrix_config
.enable
) rgb_task_state
= STARTING
;
450 rgb_matrix_config
.enable
= 0;
453 void rgb_matrix_step(void) {
454 rgb_matrix_config
.mode
++;
455 if (rgb_matrix_config
.mode
>= RGB_MATRIX_EFFECT_MAX
) rgb_matrix_config
.mode
= 1;
456 rgb_task_state
= STARTING
;
457 eeconfig_update_rgb_matrix();
460 void rgb_matrix_step_reverse(void) {
461 rgb_matrix_config
.mode
--;
462 if (rgb_matrix_config
.mode
< 1) rgb_matrix_config
.mode
= RGB_MATRIX_EFFECT_MAX
- 1;
463 rgb_task_state
= STARTING
;
464 eeconfig_update_rgb_matrix();
467 void rgb_matrix_increase_hue(void) {
468 rgb_matrix_config
.hsv
.h
+= RGB_MATRIX_HUE_STEP
;
469 eeconfig_update_rgb_matrix();
472 void rgb_matrix_decrease_hue(void) {
473 rgb_matrix_config
.hsv
.h
-= RGB_MATRIX_HUE_STEP
;
474 eeconfig_update_rgb_matrix();
477 void rgb_matrix_increase_sat(void) {
478 rgb_matrix_config
.hsv
.s
= qadd8(rgb_matrix_config
.hsv
.s
, RGB_MATRIX_SAT_STEP
);
479 eeconfig_update_rgb_matrix();
482 void rgb_matrix_decrease_sat(void) {
483 rgb_matrix_config
.hsv
.s
= qsub8(rgb_matrix_config
.hsv
.s
, RGB_MATRIX_SAT_STEP
);
484 eeconfig_update_rgb_matrix();
487 void rgb_matrix_increase_val(void) {
488 rgb_matrix_config
.hsv
.v
= qadd8(rgb_matrix_config
.hsv
.v
, RGB_MATRIX_VAL_STEP
);
489 if (rgb_matrix_config
.hsv
.v
> RGB_MATRIX_MAXIMUM_BRIGHTNESS
) rgb_matrix_config
.hsv
.v
= RGB_MATRIX_MAXIMUM_BRIGHTNESS
;
490 eeconfig_update_rgb_matrix();
493 void rgb_matrix_decrease_val(void) {
494 rgb_matrix_config
.hsv
.v
= qsub8(rgb_matrix_config
.hsv
.v
, RGB_MATRIX_VAL_STEP
);
495 eeconfig_update_rgb_matrix();
498 void rgb_matrix_increase_speed(void) {
499 rgb_matrix_config
.speed
= qadd8(rgb_matrix_config
.speed
, RGB_MATRIX_SPD_STEP
);
500 eeconfig_update_rgb_matrix();
503 void rgb_matrix_decrease_speed(void) {
504 rgb_matrix_config
.speed
= qsub8(rgb_matrix_config
.speed
, RGB_MATRIX_SPD_STEP
);
505 eeconfig_update_rgb_matrix();
508 led_flags_t
rgb_matrix_get_flags(void) { return rgb_effect_params
.flags
; }
510 void rgb_matrix_set_flags(led_flags_t flags
) { rgb_effect_params
.flags
= flags
; }
512 void rgb_matrix_mode(uint8_t mode
) {
513 rgb_matrix_config
.mode
= mode
;
514 rgb_task_state
= STARTING
;
515 eeconfig_update_rgb_matrix();
518 void rgb_matrix_mode_noeeprom(uint8_t mode
) { rgb_matrix_config
.mode
= mode
; }
520 uint8_t rgb_matrix_get_mode(void) { return rgb_matrix_config
.mode
; }
522 void rgb_matrix_sethsv(uint16_t hue
, uint8_t sat
, uint8_t val
) {
523 rgb_matrix_sethsv_noeeprom(hue
, sat
, val
);
524 eeconfig_update_rgb_matrix();
527 void rgb_matrix_sethsv_noeeprom(uint16_t hue
, uint8_t sat
, uint8_t val
) {
528 rgb_matrix_config
.hsv
.h
= hue
;
529 rgb_matrix_config
.hsv
.s
= sat
;
530 rgb_matrix_config
.hsv
.v
= val
;
531 if (rgb_matrix_config
.hsv
.v
> RGB_MATRIX_MAXIMUM_BRIGHTNESS
) rgb_matrix_config
.hsv
.v
= RGB_MATRIX_MAXIMUM_BRIGHTNESS
;