Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Add function to support split-keyboard in rgblight.[ch]. (#5020)

Browse source 
* add temporary file that is rgblight.c call graph

* add rgblight_update_hook()

* update rgblight-call-graph.dot (temporary file)

* add more hook point

* add TODO comment

* temporary Revert "add TODO comment"

This reverts commit df6165aac9b3a31d1d3e31ce52aadc134b84eac2.

* temporary Revert "add more hook point"

This reverts commit 64592b06f3bcdaac47c59f922018a273bef76776.

* temporary Revert "add rgblight_update_hook()"

This reverts commit 432b74c912ed4333e6633e20a1bcda10c6a10eaf.

* add rgblight_update_hook()

* add more hook point

* add TODO comment

* implement rgblight_update_hook()

* remove rgblight_update_hook(), add RGBLIGHT_SPLIT_SET_CHANGE_XXXX

rgblight_update_hook() is too large.
change to simple flag setting.

* shrink rgblight_config_t

* implement rgblight_update_sync()

Note: The animation synchronization process has not been implemented yet.

* update quantum/rgblight-call-graph.dot (temporary file)

* rmove quantum/rgblight-call-graph.dot (temporary file)

* update rgblight.c

* Add temporary code to Helix keyboard 'five_rows' keymap to test rgblight.c .

* fix build break rgblight_update_sync() when all animation off

* fix quantum/rgblight.c:rgblight_disable_XX() add RGBLIGHT_SPLIT_SET_CHANGE_MODE

* quantum/rgblight.c change code order: move rgblight_update_sync()

* add mode_base_table[] to quantum/rgblight.c

* quantum/rgblight.c use mode_base_table[] and rgblight_status.base_mode

* quantum/rgblkght.c animation timer integration

* quantum/rgblkght.c add animation sync for split keyboard

* fix mode_base_table[] and snake effect

* fix build break keyboards/mxss.

keyboards/mxss's local rgblight.c need old version rgblight.h

* rgblight.c: fix animation sync

* quantum/rgblight.c: fix snake effect sync

* quantum/rgblight.c: animation sync interverl 30 sec

* quantum/rgblight.c: fix rgblight_effect_rainbow_swirl() and rgblight_effect_knight()

* quantum/rgblight.c: add macro RGBLIGHT_SPLIT_ANIMATION

* cherry-pick from 'rgblight_modes.h sample implementation'

* fix RGBLIGHT_SPLIT_ANIMATION check position

* Update temporary code in Helix keyboard 'five_rows' keymap to test rgblight.c

* Reduce the firmware size by 1500 bytes when rgblight_effect_breathing() is enabled.

* Changed to rgblight_sethsv_eeprom_helper() for easier reading.

* add fail-safe code to quantum/rgblight.c:rgblight_task(),rgblight_timer_enable()

* remove temporary code in Helix keyboard 'five_rows' keymap

* quantum/rgblight.c: add split-keyboard master side sync functions

add functions:
  uint8_t rgblight_get_change_flags(void);
  void rgblight_clear_change_flags(void);
  void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo);

change function:
  void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom);

* Change rgblight_update_sync() to use write_to_eeprom.

* remove TODO comment from quantum/rgblight.h

* Revert "fix build break keyboards/mxss."

This reverts commit 90b9a1aa7d8af226751500e49e3ea0214cc4e024.
(Separated this change into the newly opened PR #5461.)

* Revert "Reduce the firmware size by 1500 bytes when rgblight_effect_breathing() is enabled."

This reverts commit b61004e63e82cf5334cee4def4ba10cffa88885f.

* update quantum/rgblight.c: Code size reduction when not using RGBLIGHT_SPLIT.

* Add temporary code to Helix keyboard 'five_rows' keymap to test rgblight.c .

* add temporary pdhelix(Patched Helix) code

* Add temporary code to split_common/transport.c to test rgblight.c.

* Finish testing rgblight.c with helix keyboard.

Revert "Add temporary code to Helix keyboard 'five_rows' keymap to test rgblight.c ."

This reverts commit 0bf81a4723a977adc0cb09b4272ee5c9b4f2bbbb.

* Finish testing rgblight.c with quantum/split_common code.

Revert "Add temporary code to split_common/transport.c to test rgblight.c."

This reverts commit 71db3e24eef40d4c455fb9fd1664e4487c9d927a.

* remove temporary pdhelix(Patched Helix) code

This reverts commit 5287e51a394741bcb6028c7cfc0dd0c984645f76.

* Added description of RGBLIGHT_SPLIT macro to docs/feature_rgblight.md.

* add RGBLIGHT_SPLIT_SET_CHANGE_HSVS to rgblight_init()

* Changed to restart animation only when changing mode.

When changing hue, sat and val, the animation is not restarted and continues.
This commit is contained in:
Takeshi ISHII 2019-04-20 07:05:51 +09:00 committed by Drashna Jaelre
parent dd64a4e738
commit dfab177f88
4 changed files with 386 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
docs/feature_rgblight.md
View file

@ -75,6 +75,7 @@ Your RGB lighting can be configured by placing these `#define`s in your `config.
|`RGBLIGHT_VAL_STEP` |`17` |The number of steps to increment the brightness by | |`RGBLIGHT_VAL_STEP` |`17` |The number of steps to increment the brightness by |
|`RGBLIGHT_LIMIT_VAL` |`255` |The maximum brightness level | |`RGBLIGHT_LIMIT_VAL` |`255` |The maximum brightness level |
|`RGBLIGHT_SLEEP` |*Not defined*|If defined, the RGB lighting will be switched off when the host goes to sleep| |`RGBLIGHT_SLEEP` |*Not defined*|If defined, the RGB lighting will be switched off when the host goes to sleep|
|`RGBLIGHT_SPLIT` |*Not defined*|If defined, synchronization functionality for split keyboards is added|
## Animations ## Animations

392
quantum/rgblight.c
View file

@ -34,14 +34,38 @@
#include "velocikey.h" #include "velocikey.h"
#endif #endif
#ifdef RGBLIGHT_SPLIT
/* for split keyboard */
#define RGBLIGHT_SPLIT_SET_CHANGE_MODE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_MODE
#define RGBLIGHT_SPLIT_SET_CHANGE_HSVS rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_HSVS
#define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_TIMER
#define RGBLIGHT_SPLIT_ANIMATION_TICK rgblight_status.change_flags |= RGBLIGHT_STATUS_ANIMATION_TICK
#else
#define RGBLIGHT_SPLIT_SET_CHANGE_MODE
#define RGBLIGHT_SPLIT_SET_CHANGE_HSVS
#define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
#define RGBLIGHT_SPLIT_ANIMATION_TICK
#endif
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_SINGLE_DYNAMIC(sym) #define _RGBM_SINGLE_DYNAMIC(sym)
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym) #define _RGBM_MULTI_DYNAMIC(sym)
#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_DYNAMIC(sym) #define _RGBM_TMP_DYNAMIC(sym, msym)
static uint8_t static_effect_table [] = { static uint8_t static_effect_table [] = {
#include "rgblight.h" #include "rgblight_modes.h"
};
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## msym,
#define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_ ## msym,
static uint8_t mode_base_table [] = {
0, // RGBLIGHT_MODE_zero
#include "rgblight_modes.h"
}; };
static inline int is_static_effect(uint8_t mode) { static inline int is_static_effect(uint8_t mode) {
@ -61,14 +85,18 @@ const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
#endif #endif
rgblight_config_t rgblight_config; rgblight_config_t rgblight_config;
rgblight_status_t rgblight_status = { .timer_enabled = false };
bool is_rgblight_initialized = false; bool is_rgblight_initialized = false;
#ifdef RGBLIGHT_USE_TIMER
animation_status_t animation_status = {};
#endif
#ifndef LED_ARRAY #ifndef LED_ARRAY
LED_TYPE led[RGBLED_NUM]; LED_TYPE led[RGBLED_NUM];
#define LED_ARRAY led #define LED_ARRAY led
#endif #endif
bool rgblight_timer_enabled = false;
static uint8_t clipping_start_pos = 0; static uint8_t clipping_start_pos = 0;
static uint8_t clipping_num_leds = RGBLED_NUM; static uint8_t clipping_num_leds = RGBLED_NUM;
@ -221,6 +249,7 @@ void rgblight_init(void) {
eeconfig_update_rgblight_default(); eeconfig_update_rgblight_default();
} }
rgblight_config.raw = eeconfig_read_rgblight(); rgblight_config.raw = eeconfig_read_rgblight();
RGBLIGHT_SPLIT_SET_CHANGE_HSVS;
if (!rgblight_config.mode) { if (!rgblight_config.mode) {
dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n"); dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
eeconfig_update_rgblight_default(); eeconfig_update_rgblight_default();
@ -321,6 +350,7 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
} else { } else {
rgblight_config.mode = mode; rgblight_config.mode = mode;
} }
RGBLIGHT_SPLIT_SET_CHANGE_MODE;
if (write_to_eeprom) { if (write_to_eeprom) {
eeconfig_update_rgblight(rgblight_config.raw); eeconfig_update_rgblight(rgblight_config.raw);
xprintf("rgblight mode [EEPROM]: %u\n", rgblight_config.mode); xprintf("rgblight mode [EEPROM]: %u\n", rgblight_config.mode);
@ -336,6 +366,9 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
rgblight_timer_enable(); rgblight_timer_enable();
#endif #endif
} }
#ifdef RGBLIGHT_USE_TIMER
animation_status.restart = true;
#endif
rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, rgblight_config.val); rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
} }
@ -389,6 +422,7 @@ void rgblight_disable(void) {
#ifdef RGBLIGHT_USE_TIMER #ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable(); rgblight_timer_disable();
#endif #endif
RGBLIGHT_SPLIT_SET_CHANGE_MODE;
wait_ms(50); wait_ms(50);
rgblight_set(); rgblight_set();
} }
@ -399,6 +433,7 @@ void rgblight_disable_noeeprom(void) {
#ifdef RGBLIGHT_USE_TIMER #ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable(); rgblight_timer_disable();
#endif #endif
RGBLIGHT_SPLIT_SET_CHANGE_MODE;
wait_ms(50); wait_ms(50);
rgblight_set(); rgblight_set();
} }
@ -505,11 +540,13 @@ void rgblight_decrease_val(void) {
} }
void rgblight_increase_speed(void) { void rgblight_increase_speed(void) {
rgblight_config.speed = increment( rgblight_config.speed, 1, 0, 3 ); rgblight_config.speed = increment( rgblight_config.speed, 1, 0, 3 );
//RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED?
eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
} }
void rgblight_decrease_speed(void) { void rgblight_decrease_speed(void) {
rgblight_config.speed = decrement( rgblight_config.speed, 1, 0, 3 ); rgblight_config.speed = decrement( rgblight_config.speed, 1, 0, 3 );
//RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED??
eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
} }
@ -524,6 +561,7 @@ void rgblight_sethsv_noeeprom_old(uint16_t hue, uint8_t sat, uint8_t val) {
void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) { void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
if (rgblight_config.enable) { if (rgblight_config.enable) {
rgblight_status.base_mode = mode_base_table[rgblight_config.mode];
if (rgblight_config.mode == RGBLIGHT_MODE_STATIC_LIGHT) { if (rgblight_config.mode == RGBLIGHT_MODE_STATIC_LIGHT) {
// same static color // same static color
LED_TYPE tmp_led; LED_TYPE tmp_led;
@ -534,33 +572,30 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
if ( 1 == 0 ) { //dummy if ( 1 == 0 ) { //dummy
} }
#ifdef RGBLIGHT_EFFECT_BREATHING #ifdef RGBLIGHT_EFFECT_BREATHING
else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING && else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING ) {
rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
// breathing mode, ignore the change of val, use in memory value instead // breathing mode, ignore the change of val, use in memory value instead
val = rgblight_config.val; val = rgblight_config.val;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD && else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
// rainbow mood, ignore the change of hue // rainbow mood, ignore the change of hue
hue = rgblight_config.hue; hue = rgblight_config.hue;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL && else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
// rainbow swirl, ignore the change of hue // rainbow swirl, ignore the change of hue
hue = rgblight_config.hue; hue = rgblight_config.hue;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
else if (rgblight_config.mode >= RGBLIGHT_MODE_STATIC_GRADIENT && else if (rgblight_status.base_mode == RGBLIGHT_MODE_STATIC_GRADIENT) {
rgblight_config.mode <= RGBLIGHT_MODE_STATIC_GRADIENT_end) {
// static gradient // static gradient
uint16_t _hue; uint16_t _hue;
int8_t direction = ((rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) % 2) ? -1 : 1; uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) / 2]); int8_t direction = (delta % 2) ? -1 : 1;
uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[delta / 2]);
for (uint8_t i = 0; i < RGBLED_NUM; i++) { for (uint8_t i = 0; i < RGBLED_NUM; i++) {
_hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360; _hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360;
dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range); dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range);
@ -570,6 +605,13 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
} }
#endif #endif
} }
#ifdef RGBLIGHT_SPLIT
if( rgblight_config.hue != hue ||
rgblight_config.sat != sat ||
rgblight_config.val != val ) {
RGBLIGHT_SPLIT_SET_CHANGE_HSVS;
}
#endif
rgblight_config.hue = hue; rgblight_config.hue = hue;
rgblight_config.sat = sat; rgblight_config.sat = sat;
rgblight_config.val = val; rgblight_config.val = val;
@ -711,10 +753,59 @@ void rgblight_set(void) {
} }
#endif #endif
#ifdef RGBLIGHT_SPLIT
/* for split keyboard master side */
uint8_t rgblight_get_change_flags(void) {
return rgblight_status.change_flags;
}
void rgblight_clear_change_flags(void) {
rgblight_status.change_flags = 0;
}
void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo) {
syncinfo->config = rgblight_config;
syncinfo->status = rgblight_status;
}
/* for split keyboard slave side */
void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom) {
if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_MODE) {
if (syncinfo->config.enable) {
rgblight_config.enable = 1; // == rgblight_enable_noeeprom();
rgblight_mode_eeprom_helper(syncinfo->config.mode, write_to_eeprom);
} else {
rgblight_disable_noeeprom();
}
}
if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_HSVS) {
rgblight_sethsv_eeprom_helper(syncinfo->config.hue, syncinfo->config.sat, syncinfo->config.val, write_to_eeprom);
// rgblight_config.speed = config->speed; // NEED???
}
#ifdef RGBLIGHT_USE_TIMER
if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_TIMER) {
if (syncinfo->status.timer_enabled) {
rgblight_timer_enable();
} else {
rgblight_timer_disable();
}
}
#ifndef RGBLIGHT_SPLIT_NO_ANIMATION_SYNC
if (syncinfo->status.change_flags & RGBLIGHT_STATUS_ANIMATION_TICK) {
animation_status.restart = true;
}
#endif /* RGBLIGHT_SPLIT_NO_ANIMATION_SYNC */
#endif /* RGBLIGHT_USE_TIMER */
}
#endif /* RGBLIGHT_SPLIT */
#ifdef RGBLIGHT_USE_TIMER #ifdef RGBLIGHT_USE_TIMER
// Animation timer -- AVR Timer3 typedef void (*effect_func_t)(animation_status_t *anim);
// Animation timer -- use system timer (AVR Timer0)
void rgblight_timer_init(void) { void rgblight_timer_init(void) {
// OLD!!!! Animation timer -- AVR Timer3
// static uint8_t rgblight_timer_is_init = 0; // static uint8_t rgblight_timer_is_init = 0;
// if (rgblight_timer_is_init) { // if (rgblight_timer_is_init) {
// return; // return;
@ -730,19 +821,29 @@ void rgblight_timer_init(void) {
// OCR3AL = RGBLED_TIMER_TOP & 0xff; // OCR3AL = RGBLED_TIMER_TOP & 0xff;
// SREG = sreg; // SREG = sreg;
rgblight_timer_enabled = true; rgblight_status.timer_enabled = false;
RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
} }
void rgblight_timer_enable(void) { void rgblight_timer_enable(void) {
rgblight_timer_enabled = true; if( !is_static_effect(rgblight_config.mode) ) {
dprintf("TIMER3 enabled.\n"); rgblight_status.timer_enabled = true;
}
animation_status.last_timer = timer_read();
RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
dprintf("rgblight timer enabled.\n");
} }
void rgblight_timer_disable(void) { void rgblight_timer_disable(void) {
rgblight_timer_enabled = false; rgblight_status.timer_enabled = false;
dprintf("TIMER3 disabled.\n"); RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
dprintf("rgblight timer disable.\n");
} }
void rgblight_timer_toggle(void) { void rgblight_timer_toggle(void) {
rgblight_timer_enabled ^= rgblight_timer_enabled; dprintf("rgblight timer toggle.\n");
dprintf("TIMER3 toggled.\n"); if(rgblight_status.timer_enabled) {
rgblight_timer_disable();
} else {
rgblight_timer_enable();
}
} }
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) { void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
@ -751,64 +852,116 @@ void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
rgblight_setrgb(r, g, b); rgblight_setrgb(r, g, b);
} }
void rgblight_task(void) { static void rgblight_effect_dummy(animation_status_t *anim) {
// do nothing
/********
dprintf("rgblight_task() what happened?\n");
dprintf("is_static_effect %d\n", is_static_effect(rgblight_config.mode));
dprintf("mode = %d, base_mode = %d, timer_enabled %d, ",
rgblight_config.mode, rgblight_status.base_mode,
rgblight_status.timer_enabled);
dprintf("last_timer = %d\n",anim->last_timer);
**/
}
void rgblight_task(void) {
if (rgblight_status.timer_enabled) {
effect_func_t effect_func = rgblight_effect_dummy;
uint16_t interval_time = 2000; // dummy interval
uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
animation_status.delta = delta;
if (rgblight_timer_enabled) {
// static light mode, do nothing here // static light mode, do nothing here
if ( 1 == 0 ) { //dummy if ( 1 == 0 ) { //dummy
} }
#ifdef RGBLIGHT_EFFECT_BREATHING #ifdef RGBLIGHT_EFFECT_BREATHING
else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING && else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING) {
rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
// breathing mode // breathing mode
rgblight_effect_breathing(rgblight_config.mode - RGBLIGHT_MODE_BREATHING ); interval_time = get_interval_time(&RGBLED_BREATHING_INTERVALS[delta], 1, 100);
effect_func = rgblight_effect_breathing;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD && else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
// rainbow mood mode // rainbow mood mode
rgblight_effect_rainbow_mood(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_MOOD); interval_time = get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS[delta], 5, 100);
effect_func = rgblight_effect_rainbow_mood;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL && else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
// rainbow swirl mode // rainbow swirl mode
rgblight_effect_rainbow_swirl(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_SWIRL); interval_time = get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS[delta / 2], 1, 100);
effect_func = rgblight_effect_rainbow_swirl;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_SNAKE #ifdef RGBLIGHT_EFFECT_SNAKE
else if (rgblight_config.mode >= RGBLIGHT_MODE_SNAKE && else if (rgblight_status.base_mode == RGBLIGHT_MODE_SNAKE) {
rgblight_config.mode <= RGBLIGHT_MODE_SNAKE_end) {
// snake mode // snake mode
rgblight_effect_snake(rgblight_config.mode - RGBLIGHT_MODE_SNAKE); interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[delta / 2], 1, 200);
effect_func = rgblight_effect_snake;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_KNIGHT #ifdef RGBLIGHT_EFFECT_KNIGHT
else if (rgblight_config.mode >= RGBLIGHT_MODE_KNIGHT && else if (rgblight_status.base_mode == RGBLIGHT_MODE_KNIGHT) {
rgblight_config.mode <= RGBLIGHT_MODE_KNIGHT_end) {
// knight mode // knight mode
rgblight_effect_knight(rgblight_config.mode - RGBLIGHT_MODE_KNIGHT); interval_time = get_interval_time(&RGBLED_KNIGHT_INTERVALS[delta], 5, 100);
effect_func = rgblight_effect_knight;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS #ifdef RGBLIGHT_EFFECT_CHRISTMAS
else if (rgblight_config.mode == RGBLIGHT_MODE_CHRISTMAS) { else if (rgblight_status.base_mode == RGBLIGHT_MODE_CHRISTMAS) {
// christmas mode // christmas mode
rgblight_effect_christmas(); interval_time = RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL;
effect_func = (effect_func_t)rgblight_effect_christmas;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST #ifdef RGBLIGHT_EFFECT_RGB_TEST
else if (rgblight_config.mode == RGBLIGHT_MODE_RGB_TEST) { else if (rgblight_status.base_mode == RGBLIGHT_MODE_RGB_TEST) {
// RGB test mode // RGB test mode
rgblight_effect_rgbtest(); interval_time = pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0]);
effect_func = (effect_func_t)rgblight_effect_rgbtest;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING #ifdef RGBLIGHT_EFFECT_ALTERNATING
else if (rgblight_config.mode == RGBLIGHT_MODE_ALTERNATING){ else if (rgblight_status.base_mode == RGBLIGHT_MODE_ALTERNATING){
rgblight_effect_alternating(); interval_time = 500;
effect_func = (effect_func_t)rgblight_effect_alternating;
} }
#endif #endif
if (animation_status.restart) {
animation_status.restart = false;
animation_status.last_timer = timer_read() - interval_time - 1;
animation_status.pos16 = 0; // restart signal to local each effect
}
if (timer_elapsed(animation_status.last_timer) >= interval_time) {
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
static uint16_t report_last_timer = 0;
static bool tick_flag = false;
uint16_t oldpos16;
if (tick_flag) {
tick_flag = false;
//dprintf("rgblight animation tick\n");
if (timer_elapsed(report_last_timer) >= 30000) {
report_last_timer = timer_read();
dprintf("rgblight animation tick report to slave\n");
RGBLIGHT_SPLIT_ANIMATION_TICK;
}
}
oldpos16 = animation_status.pos16;
//dprintf("call effect function\n");
#endif
animation_status.last_timer += interval_time;
effect_func(&animation_status);
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
//dprintf("pos16, oldpos16 = %d %d\n",
// animation_status.pos16,oldpos16);
if (animation_status.pos16 == 0 && oldpos16 != 0) {
//dprintf("flag on\n");
tick_flag = true;
}
#endif
}
} }
} }
@ -819,22 +972,13 @@ void rgblight_task(void) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5}; const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
void rgblight_effect_breathing(uint8_t interval) { void rgblight_effect_breathing(animation_status_t *anim) {
static uint8_t pos = 0;
static uint16_t last_timer = 0;
float val; float val;
uint8_t interval_time = get_interval_time(&RGBLED_BREATHING_INTERVALS[interval], 1, 100);
if (timer_elapsed(last_timer) < interval_time) {
return;
}
last_timer = timer_read();
// http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/ // http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/
val = (exp(sin((pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E)); val = (exp(sin((anim->pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val); rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);
pos = (pos + 1) % 256; anim->pos = (anim->pos + 1) % 256;
} }
#endif #endif
@ -842,18 +986,9 @@ void rgblight_effect_breathing(uint8_t interval) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30}; const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
void rgblight_effect_rainbow_mood(uint8_t interval) { void rgblight_effect_rainbow_mood(animation_status_t *anim) {
static uint16_t current_hue = 0; rgblight_sethsv_noeeprom_old(anim->current_hue, rgblight_config.sat, rgblight_config.val);
static uint16_t last_timer = 0; anim->current_hue = (anim->current_hue + 1) % 360;
uint8_t interval_time = get_interval_time(&RGBLED_RAINBOW_MOOD_INTERVALS[interval], 5, 100);
if (timer_elapsed(last_timer) < interval_time) {
return;
}
last_timer = timer_read();
rgblight_sethsv_noeeprom_old(current_hue, rgblight_config.sat, rgblight_config.val);
current_hue = (current_hue + 1) % 360;
} }
#endif #endif
@ -865,31 +1000,23 @@ void rgblight_effect_rainbow_mood(uint8_t interval) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20}; const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
void rgblight_effect_rainbow_swirl(uint8_t interval) { void rgblight_effect_rainbow_swirl(animation_status_t *anim) {
static uint16_t current_hue = 0;
static uint16_t last_timer = 0;
uint16_t hue; uint16_t hue;
uint8_t i; uint8_t i;
uint8_t interval_time = get_interval_time(&RGBLED_RAINBOW_SWIRL_INTERVALS[interval / 2], 1, 100);
if (timer_elapsed(last_timer) < interval_time) {
return;
}
last_timer = timer_read();
for (i = 0; i < RGBLED_NUM; i++) { for (i = 0; i < RGBLED_NUM; i++) {
hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + current_hue) % 360; hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + anim->current_hue) % 360;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
} }
rgblight_set(); rgblight_set();
if (interval % 2) { if (anim->delta % 2) {
current_hue = (current_hue + 1) % 360; anim->current_hue = (anim->current_hue + 1) % 360;
} else { } else {
if (current_hue - 1 < 0) { if (anim->current_hue - 1 < 0) {
current_hue = 359; anim->current_hue = 359;
} else { } else {
current_hue = current_hue - 1; anim->current_hue = anim->current_hue - 1;
} }
} }
} }
@ -899,22 +1026,27 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20}; const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
void rgblight_effect_snake(uint8_t interval) { void rgblight_effect_snake(animation_status_t *anim) {
static uint8_t pos = 0; static uint8_t pos = 0;
static uint16_t last_timer = 0;
uint8_t i, j; uint8_t i, j;
int8_t k; int8_t k;
int8_t increment = 1; int8_t increment = 1;
if (interval % 2) {
if (anim->delta % 2) {
increment = -1; increment = -1;
} }
uint8_t interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[interval / 2], 1, 200); #if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
if (anim->pos == 0) { // restart signal
if (timer_elapsed(last_timer) < interval_time) { if (increment == 1) {
return; pos = RGBLED_NUM - 1;
} else {
pos = 0;
} }
last_timer = timer_read(); anim->pos = 1;
}
#endif
for (i = 0; i < RGBLED_NUM; i++) { for (i = 0; i < RGBLED_NUM; i++) {
led[i].r = 0; led[i].r = 0;
led[i].g = 0; led[i].g = 0;
@ -925,7 +1057,9 @@ void rgblight_effect_snake(uint8_t interval) {
k = k + RGBLED_NUM; k = k + RGBLED_NUM;
} }
if (i == k) { if (i == k) {
sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), (LED_TYPE *)&led[i]); sethsv(rgblight_config.hue, rgblight_config.sat,
(uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH),
(LED_TYPE *)&led[i]);
} }
} }
} }
@ -933,11 +1067,20 @@ void rgblight_effect_snake(uint8_t interval) {
if (increment == 1) { if (increment == 1) {
if (pos - 1 < 0) { if (pos - 1 < 0) {
pos = RGBLED_NUM - 1; pos = RGBLED_NUM - 1;
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
anim->pos = 0;
#endif
} else { } else {
pos -= 1; pos -= 1;
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
anim->pos = 1;
#endif
} }
} else { } else {
pos = (pos + 1) % RGBLED_NUM; pos = (pos + 1) % RGBLED_NUM;
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
anim->pos = pos;
#endif
} }
} }
#endif #endif
@ -946,21 +1089,21 @@ void rgblight_effect_snake(uint8_t interval) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31}; const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
void rgblight_effect_knight(uint8_t interval) { void rgblight_effect_knight(animation_status_t *anim) {
static uint16_t last_timer = 0;
uint8_t interval_time = get_interval_time(&RGBLED_KNIGHT_INTERVALS[interval], 5, 100);
if (timer_elapsed(last_timer) < interval_time) {
return;
}
last_timer = timer_read();
static int8_t low_bound = 0; static int8_t low_bound = 0;
static int8_t high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1; static int8_t high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
static int8_t increment = 1; static int8_t increment = 1;
uint8_t i, cur; uint8_t i, cur;
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
if (anim->pos == 0) { // restart signal
anim->pos = 1;
low_bound = 0;
high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
increment = 1;
}
#endif
// Set all the LEDs to 0 // Set all the LEDs to 0
for (i = 0; i < RGBLED_NUM; i++) { for (i = 0; i < RGBLED_NUM; i++) {
led[i].r = 0; led[i].r = 0;
@ -988,23 +1131,23 @@ void rgblight_effect_knight(uint8_t interval) {
if (high_bound <= 0 || low_bound >= RGBLIGHT_EFFECT_KNIGHT_LED_NUM - 1) { if (high_bound <= 0 || low_bound >= RGBLIGHT_EFFECT_KNIGHT_LED_NUM - 1) {
increment = -increment; increment = -increment;
#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
if (increment == 1) {
anim->pos = 0;
}
#endif
} }
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS #ifdef RGBLIGHT_EFFECT_CHRISTMAS
void rgblight_effect_christmas(void) { void rgblight_effect_christmas(animation_status_t *anim) {
static uint16_t current_offset = 0;
static uint16_t last_timer = 0;
uint16_t hue; uint16_t hue;
uint8_t i; uint8_t i;
if (timer_elapsed(last_timer) < RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL) {
return; anim->current_offset = (anim->current_offset + 1) % 2;
}
last_timer = timer_read();
current_offset = (current_offset + 1) % 2;
for (i = 0; i < RGBLED_NUM; i++) { for (i = 0; i < RGBLED_NUM; i++) {
hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + current_offset) % 2) * 120; hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + anim->current_offset) % 2) * 120;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
} }
rgblight_set(); rgblight_set();
@ -1015,52 +1158,39 @@ void rgblight_effect_christmas(void) {
__attribute__ ((weak)) __attribute__ ((weak))
const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024}; const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024};
void rgblight_effect_rgbtest(void) { void rgblight_effect_rgbtest(animation_status_t *anim) {
static uint8_t pos = 0;
static uint16_t last_timer = 0;
static uint8_t maxval = 0; static uint8_t maxval = 0;
uint8_t g; uint8_t r; uint8_t b; uint8_t g; uint8_t r; uint8_t b;
if (timer_elapsed(last_timer) < pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0])) {
return;
}
if( maxval == 0 ) { if( maxval == 0 ) {
LED_TYPE tmp_led; LED_TYPE tmp_led;
sethsv(0, 255, RGBLIGHT_LIMIT_VAL, &tmp_led); sethsv(0, 255, RGBLIGHT_LIMIT_VAL, &tmp_led);
maxval = tmp_led.r; maxval = tmp_led.r;
} }
last_timer = timer_read();
g = r = b = 0; g = r = b = 0;
switch( pos ) { switch( anim->pos ) {
case 0: r = maxval; break; case 0: r = maxval; break;
case 1: g = maxval; break; case 1: g = maxval; break;
case 2: b = maxval; break; case 2: b = maxval; break;
} }
rgblight_setrgb(r, g, b); rgblight_setrgb(r, g, b);
pos = (pos + 1) % 3; anim->pos = (anim->pos + 1) % 3;
} }
#endif #endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING #ifdef RGBLIGHT_EFFECT_ALTERNATING
void rgblight_effect_alternating(void){ void rgblight_effect_alternating(animation_status_t *anim) {
static uint16_t last_timer = 0;
static uint16_t pos = 0;
if (timer_elapsed(last_timer) < 500) {
return;
}
last_timer = timer_read();
for(int i = 0; i<RGBLED_NUM; i++){ for(int i = 0; i<RGBLED_NUM; i++){
if(i<RGBLED_NUM/2 && pos){ if(i<RGBLED_NUM/2 && anim->pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}else if (i>=RGBLED_NUM/2 && !pos){ }else if (i>=RGBLED_NUM/2 && !anim->pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}else{ }else{
sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]); sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]);
} }
} }
rgblight_set(); rgblight_set();
pos = (pos + 1) % 2; anim->pos = (anim->pos + 1) % 2;
} }
#endif #endif

136
quantum/rgblight.h
View file

@ -68,11 +68,11 @@
#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym, #define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_ ## sym,
enum RGBLIGHT_EFFECT_MODE { enum RGBLIGHT_EFFECT_MODE {
RGBLIGHT_MODE_zero = 0, RGBLIGHT_MODE_zero = 0,
#include "rgblight.h" #include "rgblight_modes.h"
RGBLIGHT_MODE_last RGBLIGHT_MODE_last
}; };
@ -163,6 +163,33 @@ typedef union {
}; };
} rgblight_config_t; } rgblight_config_t;
typedef struct _rgblight_status_t {
uint8_t base_mode;
bool timer_enabled;
#ifdef RGBLIGHT_SPLIT
uint8_t change_flags;
#endif
} rgblight_status_t;
#ifdef RGBLIGHT_SPLIT
#define RGBLIGHT_STATUS_CHANGE_MODE (1<<0)
#define RGBLIGHT_STATUS_CHANGE_HSVS (1<<1)
#define RGBLIGHT_STATUS_CHANGE_TIMER (1<<2)
#define RGBLIGHT_STATUS_ANIMATION_TICK (1<<3)
typedef struct _rgblight_syncinfo_t {
rgblight_config_t config;
rgblight_status_t status;
} rgblight_syncinfo_t;
/* for split keyboard master side */
uint8_t rgblight_get_change_flags(void);
void rgblight_clear_change_flags(void);
void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo);
/* for split keyboard slave side */
void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom);
#endif
void rgblight_init(void); void rgblight_init(void);
void rgblight_increase(void); void rgblight_increase(void);
void rgblight_decrease(void); void rgblight_decrease(void);
@ -237,82 +264,33 @@ void rgblight_timer_init(void);
void rgblight_timer_enable(void); void rgblight_timer_enable(void);
void rgblight_timer_disable(void); void rgblight_timer_disable(void);
void rgblight_timer_toggle(void); void rgblight_timer_toggle(void);
void rgblight_effect_breathing(uint8_t interval);
void rgblight_effect_rainbow_mood(uint8_t interval); #ifdef RGBLIGHT_USE_TIMER
void rgblight_effect_rainbow_swirl(uint8_t interval);
void rgblight_effect_snake(uint8_t interval); typedef struct _animation_status_t {
void rgblight_effect_knight(uint8_t interval); uint16_t last_timer;
void rgblight_effect_christmas(void); uint8_t delta; /* mode - base_mode */
void rgblight_effect_rgbtest(void); bool restart;
void rgblight_effect_alternating(void); union {
uint16_t pos16;
uint8_t pos;
int16_t current_hue;
uint16_t current_offset;
};
} animation_status_t;
extern animation_status_t animation_status;
void rgblight_effect_breathing(animation_status_t *anim);
void rgblight_effect_rainbow_mood(animation_status_t *anim);
void rgblight_effect_rainbow_swirl(animation_status_t *anim);
void rgblight_effect_snake(animation_status_t *anim);
void rgblight_effect_knight(animation_status_t *anim);
void rgblight_effect_christmas(animation_status_t *anim);
void rgblight_effect_rgbtest(animation_status_t *anim);
void rgblight_effect_alternating(animation_status_t *anim);
#endif
#endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE #endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE
#endif // RGBLIGHT_H #endif // RGBLIGHT_H
#ifdef _RGBM_SINGLE_STATIC
_RGBM_SINGLE_STATIC( STATIC_LIGHT )
#ifdef RGBLIGHT_EFFECT_BREATHING
_RGBM_MULTI_DYNAMIC( BREATHING )
_RGBM_TMP_DYNAMIC( breathing_3 )
_RGBM_TMP_DYNAMIC( breathing_4 )
_RGBM_TMP_DYNAMIC( BREATHING_end )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
_RGBM_MULTI_DYNAMIC( RAINBOW_MOOD )
_RGBM_TMP_DYNAMIC( rainbow_mood_7 )
_RGBM_TMP_DYNAMIC( RAINBOW_MOOD_end )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
_RGBM_MULTI_DYNAMIC( RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_10 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_11 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_12 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_13 )
_RGBM_TMP_DYNAMIC( RAINBOW_SWIRL_end )
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
_RGBM_MULTI_DYNAMIC( SNAKE )
_RGBM_TMP_DYNAMIC( snake_16 )
_RGBM_TMP_DYNAMIC( snake_17 )
_RGBM_TMP_DYNAMIC( snake_18 )
_RGBM_TMP_DYNAMIC( snake_19 )
_RGBM_TMP_DYNAMIC( SNAKE_end )
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
_RGBM_MULTI_DYNAMIC( KNIGHT )
_RGBM_TMP_DYNAMIC( knight_22 )
_RGBM_TMP_DYNAMIC( KNIGHT_end )
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
_RGBM_SINGLE_DYNAMIC( CHRISTMAS )
#endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
_RGBM_MULTI_STATIC( STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_26 )
_RGBM_TMP_STATIC( static_gradient_27 )
_RGBM_TMP_STATIC( static_gradient_28 )
_RGBM_TMP_STATIC( static_gradient_29 )
_RGBM_TMP_STATIC( static_gradient_30 )
_RGBM_TMP_STATIC( static_gradient_31 )
_RGBM_TMP_STATIC( static_gradient_32 )
_RGBM_TMP_STATIC( static_gradient_33 )
_RGBM_TMP_STATIC( STATIC_GRADIENT_end )
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
_RGBM_SINGLE_DYNAMIC( RGB_TEST )
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
_RGBM_SINGLE_DYNAMIC( ALTERNATING )
#endif
//// Add a new mode here.
// #ifdef RGBLIGHT_EFFECT_<name>
// _RGBM_<SINGLE|MULTI>_<STATIC|DYNAMIC>( <name> )
// #endif
#endif
#undef _RGBM_SINGLE_STATIC
#undef _RGBM_SINGLE_DYNAMIC
#undef _RGBM_MULTI_STATIC
#undef _RGBM_MULTI_DYNAMIC
#undef _RGBM_TMP_STATIC
#undef _RGBM_TMP_DYNAMIC

67
quantum/rgblight_modes.h Normal file
View file

@ -0,0 +1,67 @@
#ifdef _RGBM_SINGLE_STATIC
_RGBM_SINGLE_STATIC( STATIC_LIGHT )
#ifdef RGBLIGHT_EFFECT_BREATHING
_RGBM_MULTI_DYNAMIC( BREATHING )
_RGBM_TMP_DYNAMIC( breathing_3, BREATHING )
_RGBM_TMP_DYNAMIC( breathing_4, BREATHING )
_RGBM_TMP_DYNAMIC( BREATHING_end, BREATHING )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
_RGBM_MULTI_DYNAMIC( RAINBOW_MOOD )
_RGBM_TMP_DYNAMIC( rainbow_mood_7, RAINBOW_MOOD )
_RGBM_TMP_DYNAMIC( RAINBOW_MOOD_end, RAINBOW_MOOD )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
_RGBM_MULTI_DYNAMIC( RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_10, RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_11, RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_12, RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_13, RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( RAINBOW_SWIRL_end, RAINBOW_SWIRL )
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
_RGBM_MULTI_DYNAMIC( SNAKE )
_RGBM_TMP_DYNAMIC( snake_16, SNAKE )
_RGBM_TMP_DYNAMIC( snake_17, SNAKE )
_RGBM_TMP_DYNAMIC( snake_18, SNAKE )
_RGBM_TMP_DYNAMIC( snake_19, SNAKE )
_RGBM_TMP_DYNAMIC( SNAKE_end, SNAKE )
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
_RGBM_MULTI_DYNAMIC( KNIGHT )
_RGBM_TMP_DYNAMIC( knight_22, KNIGHT )
_RGBM_TMP_DYNAMIC( KNIGHT_end, KNIGHT )
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
_RGBM_SINGLE_DYNAMIC( CHRISTMAS )
#endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
_RGBM_MULTI_STATIC( STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_26, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_27, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_28, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_29, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_30, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_31, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_32, STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_33, STATIC_GRADIENT )
_RGBM_TMP_STATIC( STATIC_GRADIENT_end, STATIC_GRADIENT )
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
_RGBM_SINGLE_DYNAMIC( RGB_TEST )
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
_RGBM_SINGLE_DYNAMIC( ALTERNATING )
#endif
//// Add a new mode here.
// #ifdef RGBLIGHT_EFFECT_<name>
// _RGBM_<SINGLE|MULTI>_<STATIC|DYNAMIC>( <name> )
// #endif
#endif
#undef _RGBM_SINGLE_STATIC
#undef _RGBM_SINGLE_DYNAMIC
#undef _RGBM_MULTI_STATIC
#undef _RGBM_MULTI_DYNAMIC
#undef _RGBM_TMP_STATIC
#undef _RGBM_TMP_DYNAMIC