1 /* Copyright 2016-2017 Yang Liu
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 # include <avr/eeprom.h>
20 # include <avr/interrupt.h>
25 #ifdef STM32_EEPROM_ENABLE
27 # include "eeprom_stm32.h"
35 #include "led_tables.h"
36 #include "lib/lib8tion/lib8tion.h"
37 #ifdef VELOCIKEY_ENABLE
38 # include "velocikey.h"
42 /* for split keyboard */
43 # define RGBLIGHT_SPLIT_SET_CHANGE_MODE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_MODE
44 # define RGBLIGHT_SPLIT_SET_CHANGE_HSVS rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_HSVS
45 # define RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS rgblight_status.change_flags |= (RGBLIGHT_STATUS_CHANGE_MODE | RGBLIGHT_STATUS_CHANGE_HSVS)
46 # define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_TIMER
47 # define RGBLIGHT_SPLIT_ANIMATION_TICK rgblight_status.change_flags |= RGBLIGHT_STATUS_ANIMATION_TICK
49 # define RGBLIGHT_SPLIT_SET_CHANGE_MODE
50 # define RGBLIGHT_SPLIT_SET_CHANGE_HSVS
51 # define RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS
52 # define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
53 # define RGBLIGHT_SPLIT_ANIMATION_TICK
56 #define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_##sym,
57 #define _RGBM_SINGLE_DYNAMIC(sym)
58 #define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_##sym,
59 #define _RGBM_MULTI_DYNAMIC(sym)
60 #define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_##sym,
61 #define _RGBM_TMP_DYNAMIC(sym, msym)
62 static uint8_t static_effect_table
[] = {
63 #include "rgblight_modes.h"
66 #define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_##sym,
67 #define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_##sym,
68 #define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_##sym,
69 #define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_##sym,
70 #define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_##msym,
71 #define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_##msym,
72 static uint8_t mode_base_table
[] = {
73 0, // RGBLIGHT_MODE_zero
74 #include "rgblight_modes.h"
77 static inline int is_static_effect(uint8_t mode
) { return memchr(static_effect_table
, mode
, sizeof(static_effect_table
)) != NULL
; }
79 #ifdef RGBLIGHT_LED_MAP
80 const uint8_t led_map
[] PROGMEM
= RGBLIGHT_LED_MAP
;
83 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
84 __attribute__((weak
)) const uint8_t RGBLED_GRADIENT_RANGES
[] PROGMEM
= {255, 170, 127, 85, 64};
87 rgblight_config_t rgblight_config
;
88 rgblight_status_t rgblight_status
= {.timer_enabled
= false};
89 bool is_rgblight_initialized
= false;
91 #ifdef RGBLIGHT_USE_TIMER
92 animation_status_t animation_status
= {};
96 LED_TYPE led
[RGBLED_NUM
];
97 # define LED_ARRAY led
100 static uint8_t clipping_start_pos
= 0;
101 static uint8_t clipping_num_leds
= RGBLED_NUM
;
102 static uint8_t effect_start_pos
= 0;
103 static uint8_t effect_end_pos
= RGBLED_NUM
;
104 static uint8_t effect_num_leds
= RGBLED_NUM
;
106 void rgblight_set_clipping_range(uint8_t start_pos
, uint8_t num_leds
) {
107 clipping_start_pos
= start_pos
;
108 clipping_num_leds
= num_leds
;
111 void rgblight_set_effect_range(uint8_t start_pos
, uint8_t num_leds
) {
112 if (start_pos
>= RGBLED_NUM
) return;
113 if (start_pos
+ num_leds
> RGBLED_NUM
) return;
114 effect_start_pos
= start_pos
;
115 effect_end_pos
= start_pos
+ num_leds
;
116 effect_num_leds
= num_leds
;
119 void sethsv_raw(uint8_t hue
, uint8_t sat
, uint8_t val
, LED_TYPE
*led1
) {
120 HSV hsv
= {hue
, sat
, val
};
121 RGB rgb
= hsv_to_rgb(hsv
);
122 setrgb(rgb
.r
, rgb
.g
, rgb
.b
, led1
);
125 void sethsv(uint8_t hue
, uint8_t sat
, uint8_t val
, LED_TYPE
*led1
) { sethsv_raw(hue
, sat
, val
> RGBLIGHT_LIMIT_VAL
? RGBLIGHT_LIMIT_VAL
: val
, led1
); }
127 void setrgb(uint8_t r
, uint8_t g
, uint8_t b
, LED_TYPE
*led1
) {
136 void rgblight_check_config(void) {
137 /* Add some out of bound checks for RGB light config */
139 if (rgblight_config
.mode
< RGBLIGHT_MODE_STATIC_LIGHT
) {
140 rgblight_config
.mode
= RGBLIGHT_MODE_STATIC_LIGHT
;
141 } else if (rgblight_config
.mode
> RGBLIGHT_MODES
) {
142 rgblight_config
.mode
= RGBLIGHT_MODES
;
145 if (rgblight_config
.val
> RGBLIGHT_LIMIT_VAL
) {
146 rgblight_config
.val
= RGBLIGHT_LIMIT_VAL
;
150 uint32_t eeconfig_read_rgblight(void) {
152 return eeprom_read_dword(EECONFIG_RGBLIGHT
);
158 void eeconfig_update_rgblight(uint32_t val
) {
160 rgblight_check_config();
161 eeprom_update_dword(EECONFIG_RGBLIGHT
, val
);
165 void eeconfig_update_rgblight_current(void) { eeconfig_update_rgblight(rgblight_config
.raw
); }
167 void eeconfig_update_rgblight_default(void) {
168 rgblight_config
.enable
= 1;
169 rgblight_config
.mode
= RGBLIGHT_MODE_STATIC_LIGHT
;
170 rgblight_config
.hue
= 0;
171 rgblight_config
.sat
= UINT8_MAX
;
172 rgblight_config
.val
= RGBLIGHT_LIMIT_VAL
;
173 rgblight_config
.speed
= 0;
174 RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS
;
175 eeconfig_update_rgblight(rgblight_config
.raw
);
178 void eeconfig_debug_rgblight(void) {
179 dprintf("rgblight_config EEPROM:\n");
180 dprintf("rgblight_config.enable = %d\n", rgblight_config
.enable
);
181 dprintf("rghlight_config.mode = %d\n", rgblight_config
.mode
);
182 dprintf("rgblight_config.hue = %d\n", rgblight_config
.hue
);
183 dprintf("rgblight_config.sat = %d\n", rgblight_config
.sat
);
184 dprintf("rgblight_config.val = %d\n", rgblight_config
.val
);
185 dprintf("rgblight_config.speed = %d\n", rgblight_config
.speed
);
188 void rgblight_init(void) {
189 /* if already initialized, don't do it again.
190 If you must do it again, extern this and set to false, first.
191 This is a dirty, dirty hack until proper hooks can be added for keyboard startup. */
192 if (is_rgblight_initialized
) {
196 dprintf("rgblight_init called.\n");
197 dprintf("rgblight_init start!\n");
198 if (!eeconfig_is_enabled()) {
199 dprintf("rgblight_init eeconfig is not enabled.\n");
201 eeconfig_update_rgblight_default();
203 rgblight_config
.raw
= eeconfig_read_rgblight();
204 RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS
;
205 if (!rgblight_config
.mode
) {
206 dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
207 eeconfig_update_rgblight_default();
208 rgblight_config
.raw
= eeconfig_read_rgblight();
210 rgblight_check_config();
212 eeconfig_debug_rgblight(); // display current eeprom values
214 #ifdef RGBLIGHT_USE_TIMER
215 rgblight_timer_init(); // setup the timer
218 if (rgblight_config
.enable
) {
219 rgblight_mode_noeeprom(rgblight_config
.mode
);
222 is_rgblight_initialized
= true;
225 uint32_t rgblight_read_dword(void) { return rgblight_config
.raw
; }
227 void rgblight_update_dword(uint32_t dword
) {
228 RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS
;
229 rgblight_config
.raw
= dword
;
230 if (rgblight_config
.enable
)
231 rgblight_mode_noeeprom(rgblight_config
.mode
);
233 #ifdef RGBLIGHT_USE_TIMER
234 rgblight_timer_disable();
240 void rgblight_increase(void) {
242 if (rgblight_config
.mode
< RGBLIGHT_MODES
) {
243 mode
= rgblight_config
.mode
+ 1;
247 void rgblight_decrease(void) {
249 // Mode will never be < 1. If it ever is, eeprom needs to be initialized.
250 if (rgblight_config
.mode
> RGBLIGHT_MODE_STATIC_LIGHT
) {
251 mode
= rgblight_config
.mode
- 1;
255 void rgblight_step_helper(bool write_to_eeprom
) {
257 mode
= rgblight_config
.mode
+ 1;
258 if (mode
> RGBLIGHT_MODES
) {
261 rgblight_mode_eeprom_helper(mode
, write_to_eeprom
);
263 void rgblight_step_noeeprom(void) { rgblight_step_helper(false); }
264 void rgblight_step(void) { rgblight_step_helper(true); }
265 void rgblight_step_reverse_helper(bool write_to_eeprom
) {
267 mode
= rgblight_config
.mode
- 1;
269 mode
= RGBLIGHT_MODES
;
271 rgblight_mode_eeprom_helper(mode
, write_to_eeprom
);
273 void rgblight_step_reverse_noeeprom(void) { rgblight_step_reverse_helper(false); }
274 void rgblight_step_reverse(void) { rgblight_step_reverse_helper(true); }
276 uint8_t rgblight_get_mode(void) {
277 if (!rgblight_config
.enable
) {
281 return rgblight_config
.mode
;
284 void rgblight_mode_eeprom_helper(uint8_t mode
, bool write_to_eeprom
) {
285 if (!rgblight_config
.enable
) {
288 if (mode
< RGBLIGHT_MODE_STATIC_LIGHT
) {
289 rgblight_config
.mode
= RGBLIGHT_MODE_STATIC_LIGHT
;
290 } else if (mode
> RGBLIGHT_MODES
) {
291 rgblight_config
.mode
= RGBLIGHT_MODES
;
293 rgblight_config
.mode
= mode
;
295 RGBLIGHT_SPLIT_SET_CHANGE_MODE
;
296 if (write_to_eeprom
) {
297 eeconfig_update_rgblight(rgblight_config
.raw
);
298 dprintf("rgblight mode [EEPROM]: %u\n", rgblight_config
.mode
);
300 dprintf("rgblight mode [NOEEPROM]: %u\n", rgblight_config
.mode
);
302 if (is_static_effect(rgblight_config
.mode
)) {
303 #ifdef RGBLIGHT_USE_TIMER
304 rgblight_timer_disable();
307 #ifdef RGBLIGHT_USE_TIMER
308 rgblight_timer_enable();
311 #ifdef RGBLIGHT_USE_TIMER
312 animation_status
.restart
= true;
314 rgblight_sethsv_noeeprom(rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
);
317 void rgblight_mode(uint8_t mode
) { rgblight_mode_eeprom_helper(mode
, true); }
319 void rgblight_mode_noeeprom(uint8_t mode
) { rgblight_mode_eeprom_helper(mode
, false); }
321 void rgblight_toggle(void) {
322 dprintf("rgblight toggle [EEPROM]: rgblight_config.enable = %u\n", !rgblight_config
.enable
);
323 if (rgblight_config
.enable
) {
330 void rgblight_toggle_noeeprom(void) {
331 dprintf("rgblight toggle [NOEEPROM]: rgblight_config.enable = %u\n", !rgblight_config
.enable
);
332 if (rgblight_config
.enable
) {
333 rgblight_disable_noeeprom();
335 rgblight_enable_noeeprom();
339 void rgblight_enable(void) {
340 rgblight_config
.enable
= 1;
341 // No need to update EEPROM here. rgblight_mode() will do that, actually
342 // eeconfig_update_rgblight(rgblight_config.raw);
343 dprintf("rgblight enable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config
.enable
);
344 rgblight_mode(rgblight_config
.mode
);
347 void rgblight_enable_noeeprom(void) {
348 rgblight_config
.enable
= 1;
349 dprintf("rgblight enable [NOEEPROM]: rgblight_config.enable = %u\n", rgblight_config
.enable
);
350 rgblight_mode_noeeprom(rgblight_config
.mode
);
353 void rgblight_disable(void) {
354 rgblight_config
.enable
= 0;
355 eeconfig_update_rgblight(rgblight_config
.raw
);
356 dprintf("rgblight disable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config
.enable
);
357 #ifdef RGBLIGHT_USE_TIMER
358 rgblight_timer_disable();
360 RGBLIGHT_SPLIT_SET_CHANGE_MODE
;
365 void rgblight_disable_noeeprom(void) {
366 rgblight_config
.enable
= 0;
367 dprintf("rgblight disable [NOEEPROM]: rgblight_config.enable = %u\n", rgblight_config
.enable
);
368 #ifdef RGBLIGHT_USE_TIMER
369 rgblight_timer_disable();
371 RGBLIGHT_SPLIT_SET_CHANGE_MODE
;
376 void rgblight_increase_hue_helper(bool write_to_eeprom
) {
377 uint8_t hue
= rgblight_config
.hue
+ RGBLIGHT_HUE_STEP
;
378 rgblight_sethsv_eeprom_helper(hue
, rgblight_config
.sat
, rgblight_config
.val
, write_to_eeprom
);
380 void rgblight_increase_hue_noeeprom(void) { rgblight_increase_hue_helper(false); }
381 void rgblight_increase_hue(void) { rgblight_increase_hue_helper(true); }
382 void rgblight_decrease_hue_helper(bool write_to_eeprom
) {
383 uint8_t hue
= rgblight_config
.hue
- RGBLIGHT_HUE_STEP
;
384 rgblight_sethsv_eeprom_helper(hue
, rgblight_config
.sat
, rgblight_config
.val
, write_to_eeprom
);
386 void rgblight_decrease_hue_noeeprom(void) { rgblight_decrease_hue_helper(false); }
387 void rgblight_decrease_hue(void) { rgblight_decrease_hue_helper(true); }
388 void rgblight_increase_sat_helper(bool write_to_eeprom
) {
389 uint8_t sat
= qadd8(rgblight_config
.sat
, RGBLIGHT_SAT_STEP
);
390 rgblight_sethsv_eeprom_helper(rgblight_config
.hue
, sat
, rgblight_config
.val
, write_to_eeprom
);
392 void rgblight_increase_sat_noeeprom(void) { rgblight_increase_sat_helper(false); }
393 void rgblight_increase_sat(void) { rgblight_increase_sat_helper(true); }
394 void rgblight_decrease_sat_helper(bool write_to_eeprom
) {
395 uint8_t sat
= qsub8(rgblight_config
.sat
, RGBLIGHT_SAT_STEP
);
396 rgblight_sethsv_eeprom_helper(rgblight_config
.hue
, sat
, rgblight_config
.val
, write_to_eeprom
);
398 void rgblight_decrease_sat_noeeprom(void) { rgblight_decrease_sat_helper(false); }
399 void rgblight_decrease_sat(void) { rgblight_decrease_sat_helper(true); }
400 void rgblight_increase_val_helper(bool write_to_eeprom
) {
401 uint8_t val
= qadd8(rgblight_config
.val
, RGBLIGHT_VAL_STEP
);
402 rgblight_sethsv_eeprom_helper(rgblight_config
.hue
, rgblight_config
.sat
, val
, write_to_eeprom
);
404 void rgblight_increase_val_noeeprom(void) { rgblight_increase_val_helper(false); }
405 void rgblight_increase_val(void) { rgblight_increase_val_helper(true); }
406 void rgblight_decrease_val_helper(bool write_to_eeprom
) {
407 uint8_t val
= qsub8(rgblight_config
.val
, RGBLIGHT_VAL_STEP
);
408 rgblight_sethsv_eeprom_helper(rgblight_config
.hue
, rgblight_config
.sat
, val
, write_to_eeprom
);
410 void rgblight_decrease_val_noeeprom(void) { rgblight_decrease_val_helper(false); }
411 void rgblight_decrease_val(void) { rgblight_decrease_val_helper(true); }
412 void rgblight_increase_speed(void) {
413 if (rgblight_config
.speed
< 3) rgblight_config
.speed
++;
414 // RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED?
415 eeconfig_update_rgblight(rgblight_config
.raw
); // EECONFIG needs to be increased to support this
418 void rgblight_decrease_speed(void) {
419 if (rgblight_config
.speed
> 0) rgblight_config
.speed
--;
420 // RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED??
421 eeconfig_update_rgblight(rgblight_config
.raw
); // EECONFIG needs to be increased to support this
424 void rgblight_sethsv_noeeprom_old(uint8_t hue
, uint8_t sat
, uint8_t val
) {
425 if (rgblight_config
.enable
) {
427 sethsv(hue
, sat
, val
, &tmp_led
);
428 rgblight_setrgb(tmp_led
.r
, tmp_led
.g
, tmp_led
.b
);
432 void rgblight_sethsv_eeprom_helper(uint8_t hue
, uint8_t sat
, uint8_t val
, bool write_to_eeprom
) {
433 if (rgblight_config
.enable
) {
434 rgblight_status
.base_mode
= mode_base_table
[rgblight_config
.mode
];
435 if (rgblight_config
.mode
== RGBLIGHT_MODE_STATIC_LIGHT
) {
438 sethsv(hue
, sat
, val
, &tmp_led
);
439 rgblight_setrgb(tmp_led
.r
, tmp_led
.g
, tmp_led
.b
);
441 // all LEDs in same color
442 if (1 == 0) { // dummy
444 #ifdef RGBLIGHT_EFFECT_BREATHING
445 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_BREATHING
) {
446 // breathing mode, ignore the change of val, use in memory value instead
447 val
= rgblight_config
.val
;
450 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
451 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_RAINBOW_MOOD
) {
452 // rainbow mood, ignore the change of hue
453 hue
= rgblight_config
.hue
;
456 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
457 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_RAINBOW_SWIRL
) {
458 // rainbow swirl, ignore the change of hue
459 hue
= rgblight_config
.hue
;
462 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
463 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_STATIC_GRADIENT
) {
465 uint8_t delta
= rgblight_config
.mode
- rgblight_status
.base_mode
;
466 bool direction
= (delta
% 2) == 0;
468 // probably due to how pgm_read_word is defined for ARM, but the ARM compiler really hates this line
469 uint8_t range
= pgm_read_word(&RGBLED_GRADIENT_RANGES
[delta
/ 2]);
471 uint8_t range
= RGBLED_GRADIENT_RANGES
[delta
/ 2];
473 for (uint8_t i
= 0; i
< effect_num_leds
; i
++) {
474 uint8_t _hue
= ((uint16_t)i
* (uint16_t)range
) / effect_num_leds
;
480 dprintf("rgblight rainbow set hsv: %d,%d,%d,%u\n", i
, _hue
, direction
, range
);
481 sethsv(_hue
, sat
, val
, (LED_TYPE
*)&led
[i
+ effect_start_pos
]);
487 #ifdef RGBLIGHT_SPLIT
488 if (rgblight_config
.hue
!= hue
|| rgblight_config
.sat
!= sat
|| rgblight_config
.val
!= val
) {
489 RGBLIGHT_SPLIT_SET_CHANGE_HSVS
;
492 rgblight_config
.hue
= hue
;
493 rgblight_config
.sat
= sat
;
494 rgblight_config
.val
= val
;
495 if (write_to_eeprom
) {
496 eeconfig_update_rgblight(rgblight_config
.raw
);
497 dprintf("rgblight set hsv [EEPROM]: %u,%u,%u\n", rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
);
499 dprintf("rgblight set hsv [NOEEPROM]: %u,%u,%u\n", rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
);
504 void rgblight_sethsv(uint8_t hue
, uint8_t sat
, uint8_t val
) { rgblight_sethsv_eeprom_helper(hue
, sat
, val
, true); }
506 void rgblight_sethsv_noeeprom(uint8_t hue
, uint8_t sat
, uint8_t val
) { rgblight_sethsv_eeprom_helper(hue
, sat
, val
, false); }
508 uint8_t rgblight_get_speed(void) { return rgblight_config
.speed
; }
510 void rgblight_set_speed_eeprom_helper(uint8_t speed
, bool write_to_eeprom
) {
511 rgblight_config
.speed
= speed
;
512 if (write_to_eeprom
) {
513 eeconfig_update_rgblight(rgblight_config
.raw
); // EECONFIG needs to be increased to support this
514 dprintf("rgblight set speed [EEPROM]: %u\n", rgblight_config
.speed
);
516 dprintf("rgblight set speed [NOEEPROM]: %u\n", rgblight_config
.speed
);
520 void rgblight_set_speed(uint8_t speed
) { rgblight_set_speed_eeprom_helper(speed
, true); }
522 void rgblight_set_speed_noeeprom(uint8_t speed
) { rgblight_set_speed_eeprom_helper(speed
, false); }
524 uint8_t rgblight_get_hue(void) { return rgblight_config
.hue
; }
526 uint8_t rgblight_get_sat(void) { return rgblight_config
.sat
; }
528 uint8_t rgblight_get_val(void) { return rgblight_config
.val
; }
530 void rgblight_setrgb(uint8_t r
, uint8_t g
, uint8_t b
) {
531 if (!rgblight_config
.enable
) {
535 for (uint8_t i
= effect_start_pos
; i
< effect_end_pos
; i
++) {
546 void rgblight_setrgb_at(uint8_t r
, uint8_t g
, uint8_t b
, uint8_t index
) {
547 if (!rgblight_config
.enable
|| index
>= RGBLED_NUM
) {
560 void rgblight_sethsv_at(uint8_t hue
, uint8_t sat
, uint8_t val
, uint8_t index
) {
561 if (!rgblight_config
.enable
) {
566 sethsv(hue
, sat
, val
, &tmp_led
);
567 rgblight_setrgb_at(tmp_led
.r
, tmp_led
.g
, tmp_led
.b
, index
);
570 #if defined(RGBLIGHT_EFFECT_BREATHING) || defined(RGBLIGHT_EFFECT_RAINBOW_MOOD) || defined(RGBLIGHT_EFFECT_RAINBOW_SWIRL) || defined(RGBLIGHT_EFFECT_SNAKE) || defined(RGBLIGHT_EFFECT_KNIGHT)
572 static uint8_t get_interval_time(const uint8_t *default_interval_address
, uint8_t velocikey_min
, uint8_t velocikey_max
) {
574 # ifdef VELOCIKEY_ENABLE
575 velocikey_enabled() ? velocikey_match_speed(velocikey_min
, velocikey_max
) :
577 pgm_read_byte(default_interval_address
);
582 void rgblight_setrgb_range(uint8_t r
, uint8_t g
, uint8_t b
, uint8_t start
, uint8_t end
) {
583 if (!rgblight_config
.enable
|| start
< 0 || start
>= end
|| end
> RGBLED_NUM
) {
587 for (uint8_t i
= start
; i
< end
; i
++) {
599 void rgblight_sethsv_range(uint8_t hue
, uint8_t sat
, uint8_t val
, uint8_t start
, uint8_t end
) {
600 if (!rgblight_config
.enable
) {
605 sethsv(hue
, sat
, val
, &tmp_led
);
606 rgblight_setrgb_range(tmp_led
.r
, tmp_led
.g
, tmp_led
.b
, start
, end
);
609 #ifndef RGBLIGHT_SPLIT
610 void rgblight_setrgb_master(uint8_t r
, uint8_t g
, uint8_t b
) { rgblight_setrgb_range(r
, g
, b
, 0, (uint8_t)RGBLED_NUM
/ 2); }
612 void rgblight_setrgb_slave(uint8_t r
, uint8_t g
, uint8_t b
) { rgblight_setrgb_range(r
, g
, b
, (uint8_t)RGBLED_NUM
/ 2, (uint8_t)RGBLED_NUM
); }
614 void rgblight_sethsv_master(uint8_t hue
, uint8_t sat
, uint8_t val
) { rgblight_sethsv_range(hue
, sat
, val
, 0, (uint8_t)RGBLED_NUM
/ 2); }
616 void rgblight_sethsv_slave(uint8_t hue
, uint8_t sat
, uint8_t val
) { rgblight_sethsv_range(hue
, sat
, val
, (uint8_t)RGBLED_NUM
/ 2, (uint8_t)RGBLED_NUM
); }
617 #endif // ifndef RGBLIGHT_SPLIT
619 #ifndef RGBLIGHT_CUSTOM_DRIVER
620 void rgblight_set(void) {
622 uint16_t num_leds
= clipping_num_leds
;
624 if (!rgblight_config
.enable
) {
625 for (uint8_t i
= effect_start_pos
; i
< effect_end_pos
; i
++) {
635 # ifdef RGBLIGHT_LED_MAP
636 LED_TYPE led0
[RGBLED_NUM
];
637 for (uint8_t i
= 0; i
< RGBLED_NUM
; i
++) {
638 led0
[i
] = led
[pgm_read_byte(&led_map
[i
])];
640 start_led
= led0
+ clipping_start_pos
;
642 start_led
= led
+ clipping_start_pos
;
646 for (uint8_t i
= 0; i
< num_leds
; i
++) {
647 convert_rgb_to_rgbw(&start_led
[i
]);
650 ws2812_setleds(start_led
, num_leds
);
654 #ifdef RGBLIGHT_SPLIT
655 /* for split keyboard master side */
656 uint8_t rgblight_get_change_flags(void) { return rgblight_status
.change_flags
; }
658 void rgblight_clear_change_flags(void) { rgblight_status
.change_flags
= 0; }
660 void rgblight_get_syncinfo(rgblight_syncinfo_t
*syncinfo
) {
661 syncinfo
->config
= rgblight_config
;
662 syncinfo
->status
= rgblight_status
;
665 /* for split keyboard slave side */
666 void rgblight_update_sync(rgblight_syncinfo_t
*syncinfo
, bool write_to_eeprom
) {
667 if (syncinfo
->status
.change_flags
& RGBLIGHT_STATUS_CHANGE_MODE
) {
668 if (syncinfo
->config
.enable
) {
669 rgblight_config
.enable
= 1; // == rgblight_enable_noeeprom();
670 rgblight_mode_eeprom_helper(syncinfo
->config
.mode
, write_to_eeprom
);
672 rgblight_disable_noeeprom();
675 if (syncinfo
->status
.change_flags
& RGBLIGHT_STATUS_CHANGE_HSVS
) {
676 rgblight_sethsv_eeprom_helper(syncinfo
->config
.hue
, syncinfo
->config
.sat
, syncinfo
->config
.val
, write_to_eeprom
);
677 // rgblight_config.speed = config->speed; // NEED???
679 # ifdef RGBLIGHT_USE_TIMER
680 if (syncinfo
->status
.change_flags
& RGBLIGHT_STATUS_CHANGE_TIMER
) {
681 if (syncinfo
->status
.timer_enabled
) {
682 rgblight_timer_enable();
684 rgblight_timer_disable();
687 # ifndef RGBLIGHT_SPLIT_NO_ANIMATION_SYNC
688 if (syncinfo
->status
.change_flags
& RGBLIGHT_STATUS_ANIMATION_TICK
) {
689 animation_status
.restart
= true;
691 # endif /* RGBLIGHT_SPLIT_NO_ANIMATION_SYNC */
692 # endif /* RGBLIGHT_USE_TIMER */
694 #endif /* RGBLIGHT_SPLIT */
696 #ifdef RGBLIGHT_USE_TIMER
698 typedef void (*effect_func_t
)(animation_status_t
*anim
);
700 // Animation timer -- use system timer (AVR Timer0)
701 void rgblight_timer_init(void) {
702 // OLD!!!! Animation timer -- AVR Timer3
703 // static uint8_t rgblight_timer_is_init = 0;
704 // if (rgblight_timer_is_init) {
707 // rgblight_timer_is_init = 1;
708 // /* Timer 3 setup */
709 // TCCR3B = _BV(WGM32) // CTC mode OCR3A as TOP
710 // | _BV(CS30); // Clock selelct: clk/1
711 // /* Set TOP value */
712 // uint8_t sreg = SREG;
714 // OCR3AH = (RGBLED_TIMER_TOP >> 8) & 0xff;
715 // OCR3AL = RGBLED_TIMER_TOP & 0xff;
718 rgblight_status
.timer_enabled
= false;
719 RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
;
721 void rgblight_timer_enable(void) {
722 if (!is_static_effect(rgblight_config
.mode
)) {
723 rgblight_status
.timer_enabled
= true;
725 animation_status
.last_timer
= timer_read();
726 RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
;
727 dprintf("rgblight timer enabled.\n");
729 void rgblight_timer_disable(void) {
730 rgblight_status
.timer_enabled
= false;
731 RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
;
732 dprintf("rgblight timer disable.\n");
734 void rgblight_timer_toggle(void) {
735 dprintf("rgblight timer toggle.\n");
736 if (rgblight_status
.timer_enabled
) {
737 rgblight_timer_disable();
739 rgblight_timer_enable();
743 void rgblight_show_solid_color(uint8_t r
, uint8_t g
, uint8_t b
) {
745 rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT
);
746 rgblight_setrgb(r
, g
, b
);
749 static void rgblight_effect_dummy(animation_status_t
*anim
) {
752 dprintf("rgblight_task() what happened?\n");
753 dprintf("is_static_effect %d\n", is_static_effect(rgblight_config.mode));
754 dprintf("mode = %d, base_mode = %d, timer_enabled %d, ",
755 rgblight_config.mode, rgblight_status.base_mode,
756 rgblight_status.timer_enabled);
757 dprintf("last_timer = %d\n",anim->last_timer);
761 void rgblight_task(void) {
762 if (rgblight_status
.timer_enabled
) {
763 effect_func_t effect_func
= rgblight_effect_dummy
;
764 uint16_t interval_time
= 2000; // dummy interval
765 uint8_t delta
= rgblight_config
.mode
- rgblight_status
.base_mode
;
766 animation_status
.delta
= delta
;
768 // static light mode, do nothing here
769 if (1 == 0) { // dummy
771 # ifdef RGBLIGHT_EFFECT_BREATHING
772 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_BREATHING
) {
774 interval_time
= get_interval_time(&RGBLED_BREATHING_INTERVALS
[delta
], 1, 100);
775 effect_func
= rgblight_effect_breathing
;
778 # ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
779 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_RAINBOW_MOOD
) {
781 interval_time
= get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS
[delta
], 5, 100);
782 effect_func
= rgblight_effect_rainbow_mood
;
785 # ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
786 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_RAINBOW_SWIRL
) {
787 // rainbow swirl mode
788 interval_time
= get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS
[delta
/ 2], 1, 100);
789 effect_func
= rgblight_effect_rainbow_swirl
;
792 # ifdef RGBLIGHT_EFFECT_SNAKE
793 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_SNAKE
) {
795 interval_time
= get_interval_time(&RGBLED_SNAKE_INTERVALS
[delta
/ 2], 1, 200);
796 effect_func
= rgblight_effect_snake
;
799 # ifdef RGBLIGHT_EFFECT_KNIGHT
800 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_KNIGHT
) {
802 interval_time
= get_interval_time(&RGBLED_KNIGHT_INTERVALS
[delta
], 5, 100);
803 effect_func
= rgblight_effect_knight
;
806 # ifdef RGBLIGHT_EFFECT_CHRISTMAS
807 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_CHRISTMAS
) {
809 interval_time
= RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL
;
810 effect_func
= (effect_func_t
)rgblight_effect_christmas
;
813 # ifdef RGBLIGHT_EFFECT_RGB_TEST
814 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_RGB_TEST
) {
816 interval_time
= pgm_read_word(&RGBLED_RGBTEST_INTERVALS
[0]);
817 effect_func
= (effect_func_t
)rgblight_effect_rgbtest
;
820 # ifdef RGBLIGHT_EFFECT_ALTERNATING
821 else if (rgblight_status
.base_mode
== RGBLIGHT_MODE_ALTERNATING
) {
823 effect_func
= (effect_func_t
)rgblight_effect_alternating
;
826 if (animation_status
.restart
) {
827 animation_status
.restart
= false;
828 animation_status
.last_timer
= timer_read() - interval_time
- 1;
829 animation_status
.pos16
= 0; // restart signal to local each effect
831 if (timer_elapsed(animation_status
.last_timer
) >= interval_time
) {
832 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
833 static uint16_t report_last_timer
= 0;
834 static bool tick_flag
= false;
838 if (timer_elapsed(report_last_timer
) >= 30000) {
839 report_last_timer
= timer_read();
840 dprintf("rgblight animation tick report to slave\n");
841 RGBLIGHT_SPLIT_ANIMATION_TICK
;
844 oldpos16
= animation_status
.pos16
;
846 animation_status
.last_timer
+= interval_time
;
847 effect_func(&animation_status
);
848 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
849 if (animation_status
.pos16
== 0 && oldpos16
!= 0) {
857 #endif /* RGBLIGHT_USE_TIMER */
860 #ifdef RGBLIGHT_EFFECT_BREATHING
862 # ifndef RGBLIGHT_EFFECT_BREATHE_CENTER
863 # ifndef RGBLIGHT_BREATHE_TABLE_SIZE
864 # define RGBLIGHT_BREATHE_TABLE_SIZE 256 // 256 or 128 or 64
866 # include <rgblight_breathe_table.h>
869 __attribute__((weak
)) const uint8_t RGBLED_BREATHING_INTERVALS
[] PROGMEM
= {30, 20, 10, 5};
871 void rgblight_effect_breathing(animation_status_t
*anim
) {
874 // http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/
875 # ifdef RGBLIGHT_EFFECT_BREATHE_TABLE
876 val
= pgm_read_byte(&rgblight_effect_breathe_table
[anim
->pos
/ table_scale
]);
878 val
= (exp(sin((anim
->pos
/ 255.0) * M_PI
)) - RGBLIGHT_EFFECT_BREATHE_CENTER
/ M_E
) * (RGBLIGHT_EFFECT_BREATHE_MAX
/ (M_E
- 1 / M_E
));
880 rgblight_sethsv_noeeprom_old(rgblight_config
.hue
, rgblight_config
.sat
, val
);
881 anim
->pos
= (anim
->pos
+ 1);
885 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
886 __attribute__((weak
)) const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS
[] PROGMEM
= {120, 60, 30};
888 void rgblight_effect_rainbow_mood(animation_status_t
*anim
) {
889 rgblight_sethsv_noeeprom_old(anim
->current_hue
, rgblight_config
.sat
, rgblight_config
.val
);
894 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
895 # ifndef RGBLIGHT_RAINBOW_SWIRL_RANGE
896 # define RGBLIGHT_RAINBOW_SWIRL_RANGE 255
899 __attribute__((weak
)) const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS
[] PROGMEM
= {100, 50, 20};
901 void rgblight_effect_rainbow_swirl(animation_status_t
*anim
) {
905 for (i
= 0; i
< effect_num_leds
; i
++) {
906 hue
= (RGBLIGHT_RAINBOW_SWIRL_RANGE
/ effect_num_leds
* i
+ anim
->current_hue
);
907 sethsv(hue
, rgblight_config
.sat
, rgblight_config
.val
, (LED_TYPE
*)&led
[i
+ effect_start_pos
]);
911 if (anim
->delta
% 2) {
919 #ifdef RGBLIGHT_EFFECT_SNAKE
920 __attribute__((weak
)) const uint8_t RGBLED_SNAKE_INTERVALS
[] PROGMEM
= {100, 50, 20};
922 void rgblight_effect_snake(animation_status_t
*anim
) {
923 static uint8_t pos
= 0;
926 int8_t increment
= 1;
928 if (anim
->delta
% 2) {
932 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
933 if (anim
->pos
== 0) { // restart signal
934 if (increment
== 1) {
935 pos
= effect_num_leds
- 1;
943 for (i
= 0; i
< effect_num_leds
; i
++) {
944 LED_TYPE
*ledp
= led
+ i
+ effect_start_pos
;
951 for (j
= 0; j
< RGBLIGHT_EFFECT_SNAKE_LENGTH
; j
++) {
952 k
= pos
+ j
* increment
;
953 if (k
> RGBLED_NUM
) {
957 k
= k
+ effect_num_leds
;
960 sethsv(rgblight_config
.hue
, rgblight_config
.sat
, (uint8_t)(rgblight_config
.val
* (RGBLIGHT_EFFECT_SNAKE_LENGTH
- j
) / RGBLIGHT_EFFECT_SNAKE_LENGTH
), ledp
);
965 if (increment
== 1) {
967 pos
= effect_num_leds
- 1;
968 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
973 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
978 pos
= (pos
+ 1) % effect_num_leds
;
979 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
986 #ifdef RGBLIGHT_EFFECT_KNIGHT
987 __attribute__((weak
)) const uint8_t RGBLED_KNIGHT_INTERVALS
[] PROGMEM
= {127, 63, 31};
989 void rgblight_effect_knight(animation_status_t
*anim
) {
990 static int8_t low_bound
= 0;
991 static int8_t high_bound
= RGBLIGHT_EFFECT_KNIGHT_LENGTH
- 1;
992 static int8_t increment
= 1;
995 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
996 if (anim
->pos
== 0) { // restart signal
999 high_bound
= RGBLIGHT_EFFECT_KNIGHT_LENGTH
- 1;
1003 // Set all the LEDs to 0
1004 for (i
= effect_start_pos
; i
< effect_end_pos
; i
++) {
1012 // Determine which LEDs should be lit up
1013 for (i
= 0; i
< RGBLIGHT_EFFECT_KNIGHT_LED_NUM
; i
++) {
1014 cur
= (i
+ RGBLIGHT_EFFECT_KNIGHT_OFFSET
) % effect_num_leds
+ effect_start_pos
;
1016 if (i
>= low_bound
&& i
<= high_bound
) {
1017 sethsv(rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
, (LED_TYPE
*)&led
[cur
]);
1029 // Move from low_bound to high_bound changing the direction we increment each
1030 // time a boundary is hit.
1031 low_bound
+= increment
;
1032 high_bound
+= increment
;
1034 if (high_bound
<= 0 || low_bound
>= RGBLIGHT_EFFECT_KNIGHT_LED_NUM
- 1) {
1035 increment
= -increment
;
1036 # if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
1037 if (increment
== 1) {
1045 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
1046 void rgblight_effect_christmas(animation_status_t
*anim
) {
1050 anim
->current_offset
= (anim
->current_offset
+ 1) % 2;
1051 for (i
= 0; i
< effect_num_leds
; i
++) {
1052 hue
= 0 + ((i
/ RGBLIGHT_EFFECT_CHRISTMAS_STEP
+ anim
->current_offset
) % 2) * 85;
1053 sethsv(hue
, rgblight_config
.sat
, rgblight_config
.val
, (LED_TYPE
*)&led
[i
+ effect_start_pos
]);
1059 #ifdef RGBLIGHT_EFFECT_RGB_TEST
1060 __attribute__((weak
)) const uint16_t RGBLED_RGBTEST_INTERVALS
[] PROGMEM
= {1024};
1062 void rgblight_effect_rgbtest(animation_status_t
*anim
) {
1063 static uint8_t maxval
= 0;
1070 sethsv(0, 255, RGBLIGHT_LIMIT_VAL
, &tmp_led
);
1074 switch (anim
->pos
) {
1085 rgblight_setrgb(r
, g
, b
);
1086 anim
->pos
= (anim
->pos
+ 1) % 3;
1090 #ifdef RGBLIGHT_EFFECT_ALTERNATING
1091 void rgblight_effect_alternating(animation_status_t
*anim
) {
1092 for (int i
= 0; i
< effect_num_leds
; i
++) {
1093 LED_TYPE
*ledp
= led
+ i
+ effect_start_pos
;
1094 if (i
< effect_num_leds
/ 2 && anim
->pos
) {
1095 sethsv(rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
, ledp
);
1096 } else if (i
>= effect_num_leds
/ 2 && !anim
->pos
) {
1097 sethsv(rgblight_config
.hue
, rgblight_config
.sat
, rgblight_config
.val
, ledp
);
1099 sethsv(rgblight_config
.hue
, rgblight_config
.sat
, 0, ledp
);
1103 anim
->pos
= (anim
->pos
+ 1) % 2;