X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=quantum%2Frgblight.c;h=f569d6b9e3f4f35b1fe7711f11472845baf6fb72;hb=d686c0ea43d6a9db7768da64ee54c3ba25c018f7;hp=52e0be8ba01604e7a63ef8b3fa33eaedd3d29031;hpb=e3621c162c32dd12ede78f6e2936724fc1dabcf1;p=qmk_firmware.git

diff --git a/quantum/rgblight.c b/quantum/rgblight.c
index 52e0be8ba..f569d6b9e 100644
--- a/quantum/rgblight.c
+++ b/quantum/rgblight.c
@@ -28,93 +28,106 @@
 #include "progmem.h"
 #include "timer.h"
 #include "rgblight.h"
+#include "color.h"
 #include "debug.h"
 #include "led_tables.h"
+#include "lib/lib8tion/lib8tion.h"
 #ifdef VELOCIKEY_ENABLE
   #include "velocikey.h"
 #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_MODEHSVS     rgblight_status.change_flags |= (RGBLIGHT_STATUS_CHANGE_MODE|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_MODEHSVS
+  #define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
+  #define RGBLIGHT_SPLIT_ANIMATION_TICK
+#endif
+
 #define _RGBM_SINGLE_STATIC(sym)   RGBLIGHT_MODE_ ## sym,
 #define _RGBM_SINGLE_DYNAMIC(sym)
 #define _RGBM_MULTI_STATIC(sym)    RGBLIGHT_MODE_ ## sym,
 #define _RGBM_MULTI_DYNAMIC(sym)
-#define _RGBM_TMP_STATIC(sym)      RGBLIGHT_MODE_ ## sym,
-#define _RGBM_TMP_DYNAMIC(sym)
+#define _RGBM_TMP_STATIC(sym, msym)      RGBLIGHT_MODE_ ## sym,
+#define _RGBM_TMP_DYNAMIC(sym, msym)
 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) {
     return memchr(static_effect_table, mode, sizeof(static_effect_table)) != NULL;
 }
 
-#define MIN(a,b) (((a)<(b))?(a):(b))
-#define MAX(a,b) (((a)>(b))?(a):(b))
+#ifdef RGBLIGHT_LED_MAP
+const uint8_t led_map[] PROGMEM = RGBLIGHT_LED_MAP;
+#endif
 
 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
 __attribute__ ((weak))
-const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
+const uint8_t RGBLED_GRADIENT_RANGES[] PROGMEM = {255, 170, 127, 85, 64};
 #endif
 
 rgblight_config_t rgblight_config;
+rgblight_status_t rgblight_status = { .timer_enabled = false };
 bool is_rgblight_initialized = false;
 
+#ifdef RGBLIGHT_USE_TIMER
+animation_status_t animation_status = {};
+#endif
+
+#ifndef LED_ARRAY
 LED_TYPE led[RGBLED_NUM];
-bool rgblight_timer_enabled = false;
+  #define LED_ARRAY led
+#endif
 
-void sethsv(uint16_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) {
-  uint8_t r = 0, g = 0, b = 0, base, color;
 
-  if (val > RGBLIGHT_LIMIT_VAL) {
-      val=RGBLIGHT_LIMIT_VAL; // limit the val
-  }
+static uint8_t clipping_start_pos = 0;
+static uint8_t clipping_num_leds = RGBLED_NUM;
+static uint8_t effect_start_pos = 0;
+static uint8_t effect_end_pos = RGBLED_NUM;
+static uint8_t effect_num_leds = RGBLED_NUM;
 
-  if (sat == 0) { // Acromatic color (gray). Hue doesn't mind.
-    r = val;
-    g = val;
-    b = val;
-  } else {
-    base = ((255 - sat) * val) >> 8;
-    color = (val - base) * (hue % 60) / 60;
-
-    switch (hue / 60) {
-      case 0:
-        r = val;
-        g = base + color;
-        b = base;
-        break;
-      case 1:
-        r = val - color;
-        g = val;
-        b = base;
-        break;
-      case 2:
-        r = base;
-        g = val;
-        b = base + color;
-        break;
-      case 3:
-        r = base;
-        g = val - color;
-        b = val;
-        break;
-      case 4:
-        r = base + color;
-        g = base;
-        b = val;
-        break;
-      case 5:
-        r = val;
-        g = base;
-        b = val - color;
-        break;
-    }
-  }
-  r = pgm_read_byte(&CIE1931_CURVE[r]);
-  g = pgm_read_byte(&CIE1931_CURVE[g]);
-  b = pgm_read_byte(&CIE1931_CURVE[b]);
+void rgblight_set_clipping_range(uint8_t start_pos, uint8_t num_leds) {
+  clipping_start_pos = start_pos;
+  clipping_num_leds = num_leds;
+}
 
-  setrgb(r, g, b, led1);
+void rgblight_set_effect_range(uint8_t start_pos, uint8_t num_leds) {
+  if (start_pos >= RGBLED_NUM) return;
+  if (start_pos + num_leds > RGBLED_NUM) return;
+  effect_start_pos = start_pos;
+  effect_end_pos = start_pos + num_leds;
+  effect_num_leds = num_leds;
+}
+
+void sethsv_raw(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) {
+  HSV hsv = { hue, sat, val };
+  RGB rgb = hsv_to_rgb(hsv);
+  setrgb(rgb.r, rgb.g, rgb.b, led1);
+}
+
+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);
 }
 
 void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1) {
@@ -133,24 +146,9 @@ void rgblight_check_config(void) {
     rgblight_config.mode = RGBLIGHT_MODES;
   }
 
-  if (rgblight_config.hue < 0) {
-    rgblight_config.hue = 0;
-  } else if (rgblight_config.hue > 360) {
-    rgblight_config.hue %= 360;
-  }
-
-  if (rgblight_config.sat < 0) {
-    rgblight_config.sat = 0;
-  } else if (rgblight_config.sat > 255) {
-    rgblight_config.sat = 255;
-  }
-
-  if (rgblight_config.val < 0) {
-    rgblight_config.val = 0;
-  } else if (rgblight_config.val > RGBLIGHT_LIMIT_VAL) {
+  if (rgblight_config.val > RGBLIGHT_LIMIT_VAL) {
     rgblight_config.val = RGBLIGHT_LIMIT_VAL;
   }
-
 }
 
 uint32_t eeconfig_read_rgblight(void) {
@@ -169,18 +167,18 @@ void eeconfig_update_rgblight(uint32_t val) {
 }
 
 void eeconfig_update_rgblight_default(void) {
-  //dprintf("eeconfig_update_rgblight_default\n");
   rgblight_config.enable = 1;
   rgblight_config.mode = RGBLIGHT_MODE_STATIC_LIGHT;
   rgblight_config.hue = 0;
-  rgblight_config.sat = 255;
+  rgblight_config.sat = UINT8_MAX;
   rgblight_config.val = RGBLIGHT_LIMIT_VAL;
   rgblight_config.speed = 0;
+  RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS;
   eeconfig_update_rgblight(rgblight_config.raw);
 }
 
 void eeconfig_debug_rgblight(void) {
-  dprintf("rgblight_config eprom\n");
+  dprintf("rgblight_config EEPROM:\n");
   dprintf("rgblight_config.enable = %d\n", rgblight_config.enable);
   dprintf("rghlight_config.mode = %d\n", rgblight_config.mode);
   dprintf("rgblight_config.hue = %d\n", rgblight_config.hue);
@@ -204,6 +202,7 @@ void rgblight_init(void) {
     eeconfig_update_rgblight_default();
   }
   rgblight_config.raw = eeconfig_read_rgblight();
+  RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS;
   if (!rgblight_config.mode) {
     dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
     eeconfig_update_rgblight_default();
@@ -225,11 +224,15 @@ void rgblight_init(void) {
 
 }
 
+uint32_t rgblight_read_dword(void) {
+  return rgblight_config.raw;
+}
+
 void rgblight_update_dword(uint32_t dword) {
+  RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS;
   rgblight_config.raw = dword;
-  eeconfig_update_rgblight(rgblight_config.raw);
   if (rgblight_config.enable)
-    rgblight_mode(rgblight_config.mode);
+    rgblight_mode_noeeprom(rgblight_config.mode);
   else {
 #ifdef RGBLIGHT_USE_TIMER
       rgblight_timer_disable();
@@ -301,11 +304,12 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
   } else {
     rgblight_config.mode = mode;
   }
+  RGBLIGHT_SPLIT_SET_CHANGE_MODE;
   if (write_to_eeprom) {
     eeconfig_update_rgblight(rgblight_config.raw);
-    xprintf("rgblight mode [EEPROM]: %u\n", rgblight_config.mode);
+    dprintf("rgblight mode [EEPROM]: %u\n", rgblight_config.mode);
   } else {
-    xprintf("rgblight mode [NOEEPROM]: %u\n", rgblight_config.mode);
+    dprintf("rgblight mode [NOEEPROM]: %u\n", rgblight_config.mode);
   }
   if( is_static_effect(rgblight_config.mode) ) {
 #ifdef RGBLIGHT_USE_TIMER
@@ -316,6 +320,9 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
       rgblight_timer_enable();
 #endif
   }
+#ifdef RGBLIGHT_USE_TIMER
+    animation_status.restart = true;
+#endif
   rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
 }
 
@@ -329,7 +336,7 @@ void rgblight_mode_noeeprom(uint8_t mode) {
 
 
 void rgblight_toggle(void) {
-  xprintf("rgblight toggle [EEPROM]: rgblight_config.enable = %u\n", !rgblight_config.enable);
+  dprintf("rgblight toggle [EEPROM]: rgblight_config.enable = %u\n", !rgblight_config.enable);
   if (rgblight_config.enable) {
     rgblight_disable();
   }
@@ -339,7 +346,7 @@ void rgblight_toggle(void) {
 }
 
 void rgblight_toggle_noeeprom(void) {
-  xprintf("rgblight toggle [NOEEPROM]: rgblight_config.enable = %u\n", !rgblight_config.enable);
+  dprintf("rgblight toggle [NOEEPROM]: rgblight_config.enable = %u\n", !rgblight_config.enable);
   if (rgblight_config.enable) {
     rgblight_disable_noeeprom();
   }
@@ -352,54 +359,41 @@ void rgblight_enable(void) {
   rgblight_config.enable = 1;
   // No need to update EEPROM here. rgblight_mode() will do that, actually
   //eeconfig_update_rgblight(rgblight_config.raw);
-  xprintf("rgblight enable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
+  dprintf("rgblight enable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
   rgblight_mode(rgblight_config.mode);
 }
 
 void rgblight_enable_noeeprom(void) {
   rgblight_config.enable = 1;
-  xprintf("rgblight enable [NOEEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
+  dprintf("rgblight enable [NOEEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
   rgblight_mode_noeeprom(rgblight_config.mode);
 }
 
 void rgblight_disable(void) {
   rgblight_config.enable = 0;
   eeconfig_update_rgblight(rgblight_config.raw);
-  xprintf("rgblight disable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
+  dprintf("rgblight disable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
 #ifdef RGBLIGHT_USE_TIMER
       rgblight_timer_disable();
 #endif
+  RGBLIGHT_SPLIT_SET_CHANGE_MODE;
   wait_ms(50);
   rgblight_set();
 }
 
 void rgblight_disable_noeeprom(void) {
   rgblight_config.enable = 0;
-  xprintf("rgblight disable [noEEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
+  dprintf("rgblight disable [NOEEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
 #ifdef RGBLIGHT_USE_TIMER
     rgblight_timer_disable();
 #endif
+  RGBLIGHT_SPLIT_SET_CHANGE_MODE;
   wait_ms(50);
   rgblight_set();
 }
 
-
-// Deals with the messy details of incrementing an integer
-static uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
-    int16_t new_value = value;
-    new_value += step;
-    return MIN( MAX( new_value, min ), max );
-}
-
-static uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
-    int16_t new_value = value;
-    new_value -= step;
-    return MIN( MAX( new_value, min ), max );
-}
-
 void rgblight_increase_hue_helper(bool write_to_eeprom) {
-  uint16_t hue;
-  hue = (rgblight_config.hue+RGBLIGHT_HUE_STEP) % 360;
+  uint8_t hue = rgblight_config.hue + RGBLIGHT_HUE_STEP;
   rgblight_sethsv_eeprom_helper(hue, rgblight_config.sat, rgblight_config.val, write_to_eeprom);
 }
 void rgblight_increase_hue_noeeprom(void) {
@@ -409,12 +403,7 @@ void rgblight_increase_hue(void) {
   rgblight_increase_hue_helper(true);
 }
 void rgblight_decrease_hue_helper(bool write_to_eeprom) {
-  uint16_t hue;
-  if (rgblight_config.hue-RGBLIGHT_HUE_STEP < 0) {
-    hue = (rgblight_config.hue + 360 - RGBLIGHT_HUE_STEP) % 360;
-  } else {
-    hue = (rgblight_config.hue - RGBLIGHT_HUE_STEP) % 360;
-  }
+  uint8_t hue = rgblight_config.hue - RGBLIGHT_HUE_STEP;
   rgblight_sethsv_eeprom_helper(hue, rgblight_config.sat, rgblight_config.val, write_to_eeprom);
 }
 void rgblight_decrease_hue_noeeprom(void) {
@@ -424,12 +413,7 @@ void rgblight_decrease_hue(void) {
   rgblight_decrease_hue_helper(true);
 }
 void rgblight_increase_sat_helper(bool write_to_eeprom) {
-  uint8_t sat;
-  if (rgblight_config.sat + RGBLIGHT_SAT_STEP > 255) {
-    sat = 255;
-  } else {
-    sat = rgblight_config.sat + RGBLIGHT_SAT_STEP;
-  }
+  uint8_t sat = qadd8(rgblight_config.sat, RGBLIGHT_SAT_STEP);
   rgblight_sethsv_eeprom_helper(rgblight_config.hue, sat, rgblight_config.val, write_to_eeprom);
 }
 void rgblight_increase_sat_noeeprom(void) {
@@ -439,12 +423,7 @@ void rgblight_increase_sat(void) {
   rgblight_increase_sat_helper(true);
 }
 void rgblight_decrease_sat_helper(bool write_to_eeprom) {
-  uint8_t sat;
-  if (rgblight_config.sat - RGBLIGHT_SAT_STEP < 0) {
-    sat = 0;
-  } else {
-    sat = rgblight_config.sat - RGBLIGHT_SAT_STEP;
-  }
+  uint8_t sat = qsub8(rgblight_config.sat, RGBLIGHT_SAT_STEP);
   rgblight_sethsv_eeprom_helper(rgblight_config.hue, sat, rgblight_config.val, write_to_eeprom);
 }
 void rgblight_decrease_sat_noeeprom(void) {
@@ -454,12 +433,7 @@ void rgblight_decrease_sat(void) {
   rgblight_decrease_sat_helper(true);
 }
 void rgblight_increase_val_helper(bool write_to_eeprom) {
-  uint8_t val;
-  if (rgblight_config.val + RGBLIGHT_VAL_STEP > RGBLIGHT_LIMIT_VAL) {
-    val = RGBLIGHT_LIMIT_VAL;
-  } else {
-    val = rgblight_config.val + RGBLIGHT_VAL_STEP;
-  }
+  uint8_t val = qadd8(rgblight_config.val, RGBLIGHT_VAL_STEP);
   rgblight_sethsv_eeprom_helper(rgblight_config.hue, rgblight_config.sat, val, write_to_eeprom);
 }
 void rgblight_increase_val_noeeprom(void) {
@@ -469,12 +443,7 @@ void rgblight_increase_val(void) {
   rgblight_increase_val_helper(true);
 }
 void rgblight_decrease_val_helper(bool write_to_eeprom) {
-  uint8_t val;
-  if (rgblight_config.val - RGBLIGHT_VAL_STEP < 0) {
-    val = 0;
-  } else {
-    val = rgblight_config.val - RGBLIGHT_VAL_STEP;
-  }
+  uint8_t val = qsub8(rgblight_config.val, RGBLIGHT_VAL_STEP);
   rgblight_sethsv_eeprom_helper(rgblight_config.hue, rgblight_config.sat, val, write_to_eeprom);
 }
 void rgblight_decrease_val_noeeprom(void) {
@@ -484,26 +453,30 @@ void rgblight_decrease_val(void) {
   rgblight_decrease_val_helper(true);
 }
 void rgblight_increase_speed(void) {
-    rgblight_config.speed = increment( rgblight_config.speed, 1, 0, 3 );
+    if (rgblight_config.speed < 3)
+        rgblight_config.speed++;
+    //RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED?
     eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
 }
 
 void rgblight_decrease_speed(void) {
-    rgblight_config.speed = decrement( rgblight_config.speed, 1, 0, 3 );
+    if (rgblight_config.speed > 0)
+        rgblight_config.speed--;
+    //RGBLIGHT_SPLIT_SET_CHANGE_HSVS; // NEED??
     eeconfig_update_rgblight(rgblight_config.raw);//EECONFIG needs to be increased to support this
 }
 
-void rgblight_sethsv_noeeprom_old(uint16_t hue, uint8_t sat, uint8_t val) {
+void rgblight_sethsv_noeeprom_old(uint8_t hue, uint8_t sat, uint8_t val) {
   if (rgblight_config.enable) {
     LED_TYPE tmp_led;
     sethsv(hue, sat, val, &tmp_led);
-    // dprintf("rgblight set hue [MEMORY]: %u,%u,%u\n", inmem_config.hue, inmem_config.sat, inmem_config.val);
     rgblight_setrgb(tmp_led.r, tmp_led.g, tmp_led.b);
   }
 }
 
-void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
+void rgblight_sethsv_eeprom_helper(uint8_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
   if (rgblight_config.enable) {
+    rgblight_status.base_mode = mode_base_table[rgblight_config.mode];
     if (rgblight_config.mode == RGBLIGHT_MODE_STATIC_LIGHT) {
       // same static color
       LED_TYPE tmp_led;
@@ -514,63 +487,76 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
       if ( 1 == 0 ) { //dummy
       }
 #ifdef RGBLIGHT_EFFECT_BREATHING
-      else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING &&
-          rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
+      else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING ) {
         // breathing mode, ignore the change of val, use in memory value instead
         val = rgblight_config.val;
       }
 #endif
 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
-      else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
-                  rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
+      else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
         // rainbow mood, ignore the change of hue
         hue = rgblight_config.hue;
       }
 #endif
 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
-      else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
-               rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
+      else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
         // rainbow swirl, ignore the change of hue
         hue = rgblight_config.hue;
       }
 #endif
 #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
-      else if (rgblight_config.mode >= RGBLIGHT_MODE_STATIC_GRADIENT &&
-               rgblight_config.mode <= RGBLIGHT_MODE_STATIC_GRADIENT_end) {
+      else if (rgblight_status.base_mode == RGBLIGHT_MODE_STATIC_GRADIENT) {
         // static gradient
-        uint16_t _hue;
-        int8_t direction = ((rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) % 2) ? -1 : 1;
-        uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) / 2]);
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-          _hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360;
-          dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range);
-          sethsv(_hue, sat, val, (LED_TYPE *)&led[i]);
+        uint8_t delta = rgblight_config.mode - rgblight_status.base_mode;
+        bool direction = (delta % 2) == 0;
+#ifdef __AVR__
+        // probably due to how pgm_read_word is defined for ARM, but the ARM compiler really hates this line
+        uint8_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[delta / 2]);
+#else
+        uint8_t range = RGBLED_GRADIENT_RANGES[delta / 2];
+#endif
+        for (uint8_t i = 0; i < effect_num_leds; i++) {
+          uint8_t _hue = ((uint16_t)i * (uint16_t)range) / effect_num_leds;
+          if (direction) {
+            _hue = hue + _hue;
+          } else {
+            _hue = hue - _hue;
+          }
+          dprintf("rgblight rainbow set hsv: %d,%d,%d,%u\n", i, _hue, direction, range);
+          sethsv(_hue, sat, val, (LED_TYPE *)&led[i + effect_start_pos]);
         }
         rgblight_set();
       }
 #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.sat = sat;
     rgblight_config.val = val;
     if (write_to_eeprom) {
       eeconfig_update_rgblight(rgblight_config.raw);
-      xprintf("rgblight set hsv [EEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
+      dprintf("rgblight set hsv [EEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
     } else {
-      xprintf("rgblight set hsv [NOEEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
+      dprintf("rgblight set hsv [NOEEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
     }
   }
 }
 
-void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
+void rgblight_sethsv(uint8_t hue, uint8_t sat, uint8_t val) {
   rgblight_sethsv_eeprom_helper(hue, sat, val, true);
 }
 
-void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
+void rgblight_sethsv_noeeprom(uint8_t hue, uint8_t sat, uint8_t val) {
   rgblight_sethsv_eeprom_helper(hue, sat, val, false);
 }
 
-uint16_t rgblight_get_hue(void) {
+uint8_t rgblight_get_hue(void) {
   return rgblight_config.hue;
 }
 
@@ -585,7 +571,7 @@ uint8_t rgblight_get_val(void) {
 void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b) {
   if (!rgblight_config.enable) { return; }
 
-  for (uint8_t i = 0; i < RGBLED_NUM; i++) {
+  for (uint8_t i = effect_start_pos; i < effect_end_pos; i++) {
     led[i].r = r;
     led[i].g = g;
     led[i].b = b;
@@ -602,7 +588,7 @@ void rgblight_setrgb_at(uint8_t r, uint8_t g, uint8_t b, uint8_t index) {
   rgblight_set();
 }
 
-void rgblight_sethsv_at(uint16_t hue, uint8_t sat, uint8_t val, uint8_t index) {
+void rgblight_sethsv_at(uint8_t hue, uint8_t sat, uint8_t val, uint8_t index) {
   if (!rgblight_config.enable) { return; }
 
   LED_TYPE tmp_led;
@@ -614,7 +600,7 @@ void rgblight_sethsv_at(uint16_t hue, uint8_t sat, uint8_t val, uint8_t index) {
   || defined(RGBLIGHT_EFFECT_SNAKE) || defined(RGBLIGHT_EFFECT_KNIGHT)
 
 static uint8_t get_interval_time(const uint8_t* default_interval_address, uint8_t velocikey_min, uint8_t velocikey_max) {
-  return 
+  return
 #ifdef VELOCIKEY_ENABLE
     velocikey_enabled() ? velocikey_match_speed(velocikey_min, velocikey_max) :
 #endif
@@ -635,7 +621,7 @@ void rgblight_setrgb_range(uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8
   wait_ms(1);
 }
 
-void rgblight_sethsv_range(uint16_t hue, uint8_t sat, uint8_t val, uint8_t start, uint8_t end) {
+void rgblight_sethsv_range(uint8_t hue, uint8_t sat, uint8_t val, uint8_t start, uint8_t end) {
   if (!rgblight_config.enable) { return; }
 
   LED_TYPE tmp_led;
@@ -643,6 +629,7 @@ void rgblight_sethsv_range(uint16_t hue, uint8_t sat, uint8_t val, uint8_t start
   rgblight_setrgb_range(tmp_led.r, tmp_led.g, tmp_led.b, start, end);
 }
 
+#ifndef RGBLIGHT_SPLIT
 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);
 }
@@ -651,41 +638,97 @@ 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);
 }
 
-void rgblight_sethsv_master(uint16_t hue, uint8_t sat, uint8_t val) {
+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);
 }
 
-void rgblight_sethsv_slave(uint16_t hue, uint8_t sat, uint8_t val) {
+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);
 }
+#endif // ifndef RGBLIGHT_SPLIT
 
 #ifndef RGBLIGHT_CUSTOM_DRIVER
 void rgblight_set(void) {
-  if (rgblight_config.enable) {
-    #ifdef RGBW
-      ws2812_setleds_rgbw(led, RGBLED_NUM);
-    #else
-      ws2812_setleds(led, RGBLED_NUM);
-    #endif
-  } else {
-    for (uint8_t i = 0; i < RGBLED_NUM; i++) {
+  LED_TYPE *start_led;
+  uint16_t num_leds = clipping_num_leds;
+
+  if (!rgblight_config.enable) {
+    for (uint8_t i = effect_start_pos; i < effect_end_pos; i++) {
       led[i].r = 0;
       led[i].g = 0;
       led[i].b = 0;
     }
-    #ifdef RGBW
-      ws2812_setleds_rgbw(led, RGBLED_NUM);
-    #else
-      ws2812_setleds(led, RGBLED_NUM);
-    #endif
   }
+#ifdef RGBLIGHT_LED_MAP
+  LED_TYPE led0[RGBLED_NUM];
+  for(uint8_t i = 0; i < RGBLED_NUM; i++) {
+      led0[i] = led[pgm_read_byte(&led_map[i])];
+  }
+  start_led = led0 + clipping_start_pos;
+#else
+  start_led = led + clipping_start_pos;
+#endif
+#ifdef RGBW
+  ws2812_setleds_rgbw(start_led, num_leds);
+#else
+  ws2812_setleds(start_led, num_leds);
+#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
 
-// 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) {
+  // OLD!!!! Animation timer -- AVR Timer3
   // static uint8_t rgblight_timer_is_init = 0;
   // if (rgblight_timer_is_init) {
   //   return;
@@ -701,19 +744,29 @@ void rgblight_timer_init(void) {
   // OCR3AL = RGBLED_TIMER_TOP & 0xff;
   // SREG = sreg;
 
-  rgblight_timer_enabled = true;
+  rgblight_status.timer_enabled = false;
+  RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
 }
 void rgblight_timer_enable(void) {
-  rgblight_timer_enabled = true;
-  dprintf("TIMER3 enabled.\n");
+  if( !is_static_effect(rgblight_config.mode) ) {
+      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) {
-  rgblight_timer_enabled = false;
-  dprintf("TIMER3 disabled.\n");
+  rgblight_status.timer_enabled = false;
+  RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE;
+  dprintf("rgblight timer disable.\n");
 }
 void rgblight_timer_toggle(void) {
-  rgblight_timer_enabled ^= rgblight_timer_enabled;
-  dprintf("TIMER3 toggled.\n");
+  dprintf("rgblight timer toggle.\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) {
@@ -722,64 +775,111 @@ void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
   rgblight_setrgb(r, g, b);
 }
 
+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
     if ( 1 == 0 ) { //dummy
     }
 #ifdef RGBLIGHT_EFFECT_BREATHING
-    else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING  &&
-        rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_BREATHING) {
       // 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
 #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
-    else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
-               rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_MOOD) {
       // 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
 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
-    else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
-               rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_RAINBOW_SWIRL) {
       // 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
 #ifdef RGBLIGHT_EFFECT_SNAKE
-    else if (rgblight_config.mode >= RGBLIGHT_MODE_SNAKE &&
-               rgblight_config.mode <= RGBLIGHT_MODE_SNAKE_end) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_SNAKE) {
       // 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
 #ifdef RGBLIGHT_EFFECT_KNIGHT
-    else if (rgblight_config.mode >= RGBLIGHT_MODE_KNIGHT &&
-               rgblight_config.mode <= RGBLIGHT_MODE_KNIGHT_end) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_KNIGHT) {
       // 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
 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
-    else if (rgblight_config.mode == RGBLIGHT_MODE_CHRISTMAS) {
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_CHRISTMAS) {
       // christmas mode
-      rgblight_effect_christmas();
+      interval_time = RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL;
+      effect_func = (effect_func_t)rgblight_effect_christmas;
     }
 #endif
 #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
-      rgblight_effect_rgbtest();
+      interval_time = pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0]);
+      effect_func = (effect_func_t)rgblight_effect_rgbtest;
     }
 #endif
 #ifdef RGBLIGHT_EFFECT_ALTERNATING
-    else if (rgblight_config.mode == RGBLIGHT_MODE_ALTERNATING){
-      rgblight_effect_alternating();
+    else if (rgblight_status.base_mode == RGBLIGHT_MODE_ALTERNATING){
+      interval_time = 500;
+      effect_func = (effect_func_t)rgblight_effect_alternating;
+    }
+#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;
+        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;
+#endif
+      animation_status.last_timer += interval_time;
+      effect_func(&animation_status);
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+      if (animation_status.pos16 == 0 && oldpos16 != 0) {
+          tick_flag = true;
+      }
 #endif
+    }
   }
 }
 
@@ -787,25 +887,28 @@ void rgblight_task(void) {
 
 // Effects
 #ifdef RGBLIGHT_EFFECT_BREATHING
+
+#ifndef RGBLIGHT_EFFECT_BREATHE_CENTER
+  #ifndef RGBLIGHT_BREATHE_TABLE_SIZE
+    #define RGBLIGHT_BREATHE_TABLE_SIZE 256 // 256 or 128 or 64
+  #endif
+  #include <rgblight_breathe_table.h>
+#endif
+
 __attribute__ ((weak))
 const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
 
-void rgblight_effect_breathing(uint8_t interval) {
-  static uint8_t pos = 0;
-  static uint16_t last_timer = 0;
+void rgblight_effect_breathing(animation_status_t *anim) {
   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/
-  val = (exp(sin((pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
+#ifdef RGBLIGHT_EFFECT_BREATHE_TABLE
+  val = pgm_read_byte(&rgblight_effect_breathe_table[anim->pos / table_scale]);
+#else
+  val = (exp(sin((anim->pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
+#endif
   rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);
-  pos = (pos + 1) % 256;
+  anim->pos = (anim->pos + 1);
 }
 #endif
 
@@ -813,55 +916,34 @@ void rgblight_effect_breathing(uint8_t interval) {
 __attribute__ ((weak))
 const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
 
-void rgblight_effect_rainbow_mood(uint8_t interval) {
-  static uint16_t current_hue = 0;
-  static uint16_t last_timer = 0;
-
-  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;
+void rgblight_effect_rainbow_mood(animation_status_t *anim) {
+  rgblight_sethsv_noeeprom_old(anim->current_hue, rgblight_config.sat, rgblight_config.val);
+  anim->current_hue++;
 }
 #endif
 
 #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
 #ifndef RGBLIGHT_RAINBOW_SWIRL_RANGE
-  #define RGBLIGHT_RAINBOW_SWIRL_RANGE 360
+  #define RGBLIGHT_RAINBOW_SWIRL_RANGE 255
 #endif
 
 __attribute__ ((weak))
 const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
 
-void rgblight_effect_rainbow_swirl(uint8_t interval) {
-  static uint16_t current_hue = 0;
-  static uint16_t last_timer = 0;
-  uint16_t hue;
+void rgblight_effect_rainbow_swirl(animation_status_t *anim) {
+  uint8_t hue;
   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++) {
-    hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + current_hue) % 360;
-    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
+  for (i = 0; i < effect_num_leds; i++) {
+    hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / effect_num_leds * i + anim->current_hue);
+    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i + effect_start_pos]);
   }
   rgblight_set();
 
-  if (interval % 2) {
-    current_hue = (current_hue + 1) % 360;
+  if (anim->delta % 2) {
+    anim->current_hue++;
   } else {
-    if (current_hue - 1 < 0) {
-      current_hue = 359;
-    } else {
-      current_hue = current_hue - 1;
-    }
+    anim->current_hue--;
   }
 }
 #endif
@@ -870,45 +952,62 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
 __attribute__ ((weak))
 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 uint16_t last_timer = 0;
   uint8_t i, j;
   int8_t k;
   int8_t increment = 1;
-  if (interval % 2) {
+
+  if (anim->delta % 2) {
     increment = -1;
   }
 
-  uint8_t interval_time = get_interval_time(&RGBLED_SNAKE_INTERVALS[interval / 2], 1, 200);
-
-  if (timer_elapsed(last_timer) < interval_time) {
-    return;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+  if (anim->pos == 0) { // restart signal
+    if (increment == 1) {
+      pos = effect_num_leds - 1;
+    } else {
+      pos = 0;
+    }
+    anim->pos = 1;
   }
-  last_timer = timer_read();
-  for (i = 0; i < RGBLED_NUM; i++) {
-    led[i].r = 0;
-    led[i].g = 0;
-    led[i].b = 0;
+#endif
+
+  for (i = 0; i < effect_num_leds; i++) {
+    LED_TYPE *ledp = led + i + effect_start_pos;
+    ledp->r = 0;
+    ledp->g = 0;
+    ledp->b = 0;
     for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) {
       k = pos + j * increment;
       if (k < 0) {
-        k = k + RGBLED_NUM;
+        k = k + effect_num_leds;
       }
       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),
+               ledp);
       }
     }
   }
   rgblight_set();
   if (increment == 1) {
     if (pos - 1 < 0) {
-      pos = RGBLED_NUM - 1;
+      pos = effect_num_leds - 1;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+      anim->pos = 0;
+#endif
     } else {
       pos -= 1;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+      anim->pos = 1;
+#endif
     }
   } else {
-    pos = (pos + 1) % RGBLED_NUM;
+    pos = (pos + 1) % effect_num_leds;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+    anim->pos = pos;
+#endif
   }
 }
 #endif
@@ -917,30 +1016,30 @@ void rgblight_effect_snake(uint8_t interval) {
 __attribute__ ((weak))
 const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
 
-void rgblight_effect_knight(uint8_t interval) {
-  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();
+void rgblight_effect_knight(animation_status_t *anim) {
 
   static int8_t low_bound = 0;
   static int8_t high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
   static int8_t increment = 1;
   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
-  for (i = 0; i < RGBLED_NUM; i++) {
+  for (i = effect_start_pos; i < effect_end_pos; i++) {
     led[i].r = 0;
     led[i].g = 0;
     led[i].b = 0;
   }
   // Determine which LEDs should be lit up
   for (i = 0; i < RGBLIGHT_EFFECT_KNIGHT_LED_NUM; i++) {
-    cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % RGBLED_NUM;
+    cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % effect_num_leds + effect_start_pos;
 
     if (i >= low_bound && i <= high_bound) {
       sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[cur]);
@@ -959,24 +1058,24 @@ void rgblight_effect_knight(uint8_t interval) {
 
   if (high_bound <= 0 || low_bound >= RGBLIGHT_EFFECT_KNIGHT_LED_NUM - 1) {
     increment = -increment;
+#if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC)
+    if (increment == 1) {
+        anim->pos = 0;
+    }
+#endif
   }
 }
 #endif
 
 #ifdef RGBLIGHT_EFFECT_CHRISTMAS
-void rgblight_effect_christmas(void) {
-  static uint16_t current_offset = 0;
-  static uint16_t last_timer = 0;
-  uint16_t hue;
+void rgblight_effect_christmas(animation_status_t *anim) {
+  uint8_t hue;
   uint8_t i;
-  if (timer_elapsed(last_timer) < RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL) {
-    return;
-  }
-  last_timer = timer_read();
-  current_offset = (current_offset + 1) % 2;
-  for (i = 0; i < RGBLED_NUM; i++) {
-    hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + current_offset) % 2) * 120;
-    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
+
+  anim->current_offset = (anim->current_offset + 1) % 2;
+  for (i = 0; i < effect_num_leds; i++) {
+    hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + anim->current_offset) % 2) * 85;
+    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i + effect_start_pos]);
   }
   rgblight_set();
 }
@@ -986,52 +1085,40 @@ void rgblight_effect_christmas(void) {
 __attribute__ ((weak))
 const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024};
 
-void rgblight_effect_rgbtest(void) {
-  static uint8_t pos = 0;
-  static uint16_t last_timer = 0;
+void rgblight_effect_rgbtest(animation_status_t *anim) {
   static uint8_t maxval = 0;
   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 ) {
       LED_TYPE tmp_led;
       sethsv(0, 255, RGBLIGHT_LIMIT_VAL, &tmp_led);
       maxval = tmp_led.r;
   }
-  last_timer = timer_read();
   g = r = b = 0;
-  switch( pos ) {
+  switch( anim->pos ) {
     case 0: r = maxval; break;
     case 1: g = maxval; break;
     case 2: b = maxval; break;
   }
   rgblight_setrgb(r, g, b);
-  pos = (pos + 1) % 3;
+  anim->pos = (anim->pos + 1) % 3;
 }
 #endif
 
 #ifdef RGBLIGHT_EFFECT_ALTERNATING
-void rgblight_effect_alternating(void){
-  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++){
-      if(i<RGBLED_NUM/2 && pos){
-          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
-      }else if (i>=RGBLED_NUM/2 && !pos){
-          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
-      }else{
-          sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]);
+void rgblight_effect_alternating(animation_status_t *anim) {
+
+  for (int i = 0; i < effect_num_leds; i++) {
+      LED_TYPE *ledp = led + i + effect_start_pos;
+      if (i<effect_num_leds/2 && anim->pos) {
+          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, ledp);
+      } else if (i>=effect_num_leds/2 && !anim->pos) {
+          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, ledp);
+      } else {
+          sethsv(rgblight_config.hue, rgblight_config.sat, 0, ledp);
       }
   }
   rgblight_set();
-  pos = (pos + 1) % 2;
+  anim->pos = (anim->pos + 1) % 2;
 }
 #endif