quantum/rgblight.c

   1 #include <avr/eeprom.h>
   2 #include <avr/interrupt.h>
   3 #include <util/delay.h>
   4 #include "progmem.h"
   5 #include "timer.h"
   6 #include "rgblight.h"
   7 #include "debug.h"
   8
   9 // Lightness curve using the CIE 1931 lightness formula
  10 //Generated by the python script provided in http://jared.geek.nz/2013/feb/linear-led-pwm
  11 const uint8_t DIM_CURVE[] PROGMEM = {
  12     0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
  13     1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
  14     2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
  15     3, 4, 4, 4, 4, 4, 4, 5, 5, 5,
  16     5, 5, 6, 6, 6, 6, 6, 7, 7, 7,
  17     7, 8, 8, 8, 8, 9, 9, 9, 10, 10,
  18     10, 10, 11, 11, 11, 12, 12, 12, 13, 13,
  19     13, 14, 14, 15, 15, 15, 16, 16, 17, 17,
  20     17, 18, 18, 19, 19, 20, 20, 21, 21, 22,
  21     22, 23, 23, 24, 24, 25, 25, 26, 26, 27,
  22     28, 28, 29, 29, 30, 31, 31, 32, 32, 33,
  23     34, 34, 35, 36, 37, 37, 38, 39, 39, 40,
  24     41, 42, 43, 43, 44, 45, 46, 47, 47, 48,
  25     49, 50, 51, 52, 53, 54, 54, 55, 56, 57,
  26     58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
  27     68, 70, 71, 72, 73, 74, 75, 76, 77, 79,
  28     80, 81, 82, 83, 85, 86, 87, 88, 90, 91,
  29     92, 94, 95, 96, 98, 99, 100, 102, 103, 105,
  30     106, 108, 109, 110, 112, 113, 115, 116, 118, 120,
  31     121, 123, 124, 126, 128, 129, 131, 132, 134, 136,
  32     138, 139, 141, 143, 145, 146, 148, 150, 152, 154,
  33     155, 157, 159, 161, 163, 165, 167, 169, 171, 173,
  34     175, 177, 179, 181, 183, 185, 187, 189, 191, 193,
  35     196, 198, 200, 202, 204, 207, 209, 211, 214, 216,
  36     218, 220, 223, 225, 228, 230, 232, 235, 237, 240,
  37     242, 245, 247, 250, 252, 255,
  38     };
  39
  40 const uint8_t RGBLED_BREATHING_TABLE[] PROGMEM = {
  41   0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9,
  42   10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
  43   37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
  44   79, 82, 85, 88, 90, 93, 97, 100, 103, 106, 109, 112, 115, 118, 121, 124,
  45   127, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 162, 165, 167, 170, 173,
  46   176, 179, 182, 185, 188, 190, 193, 196, 198, 201, 203, 206, 208, 211, 213, 215,
  47   218, 220, 222, 224, 226, 228, 230, 232, 234, 235, 237, 238, 240, 241, 243, 244,
  48   245, 246, 248, 249, 250, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255,
  49   255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 251, 250, 250, 249, 248, 246,
  50   245, 244, 243, 241, 240, 238, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220,
  51   218, 215, 213, 211, 208, 206, 203, 201, 198, 196, 193, 190, 188, 185, 182, 179,
  52   176, 173, 170, 167, 165, 162, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131,
  53   128, 124, 121, 118, 115, 112, 109, 106, 103, 100, 97, 93, 90, 88, 85, 82,
  54   79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
  55   37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
  56   10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0
  57 };
  58 const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
  59 const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
  60 const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
  61 const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
  62 const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {100, 50, 20};
  63
  64 rgblight_config_t rgblight_config;
  65 rgblight_config_t inmem_config;
  66 struct cRGB led[RGBLED_NUM];
  67 uint8_t rgblight_inited = 0;
  68
  69
  70 void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) {
  71   uint8_t r = 0, g = 0, b = 0, base, color;
  72
  73   if (sat == 0) { // Acromatic color (gray). Hue doesn't mind.
  74     r = val;
  75     g = val;
  76     b = val;
  77   } else {
  78     base = ((255 - sat) * val) >> 8;
  79     color = (val - base) * (hue % 60) / 60;
  80
  81     switch (hue / 60) {
  82       case 0:
  83         r = val;
  84         g = base + color;
  85         b = base;
  86         break;
  87       case 1:
  88         r = val - color;
  89         g = val;
  90         b = base;
  91         break;
  92       case 2:
  93         r = base;
  94         g = val;
  95         b = base + color;
  96         break;
  97       case 3:
  98         r = base;
  99         g = val - color;
 100         b = val;
 101         break;
 102       case 4:
 103         r = base + color;
 104         g = base;
 105         b = val;
 106         break;
 107       case 5:
 108         r = val;
 109         g = base;
 110         b = val - color;
 111         break;
 112     }
 113   }
 114   r = pgm_read_byte(&DIM_CURVE[r]);
 115   g = pgm_read_byte(&DIM_CURVE[g]);
 116   b = pgm_read_byte(&DIM_CURVE[b]);
 117
 118   setrgb(r, g, b, led1);
 119 }
 120
 121 void setrgb(uint8_t r, uint8_t g, uint8_t b, struct cRGB *led1) {
 122   (*led1).r = r;
 123   (*led1).g = g;
 124   (*led1).b = b;
 125 }
 126
 127
 128 uint32_t eeconfig_read_rgblight(void) {
 129   return eeprom_read_dword(EECONFIG_RGBLIGHT);
 130 }
 131 void eeconfig_update_rgblight(uint32_t val) {
 132   eeprom_update_dword(EECONFIG_RGBLIGHT, val);
 133 }
 134 void eeconfig_update_rgblight_default(void) {
 135   dprintf("eeconfig_update_rgblight_default\n");
 136   rgblight_config.enable = 1;
 137   rgblight_config.mode = 1;
 138   rgblight_config.hue = 200;
 139   rgblight_config.sat = 204;
 140   rgblight_config.val = 204;
 141   eeconfig_update_rgblight(rgblight_config.raw);
 142 }
 143 void eeconfig_debug_rgblight(void) {
 144   dprintf("rgblight_config eprom\n");
 145   dprintf("rgblight_config.enable = %d\n", rgblight_config.enable);
 146   dprintf("rghlight_config.mode = %d\n", rgblight_config.mode);
 147   dprintf("rgblight_config.hue = %d\n", rgblight_config.hue);
 148   dprintf("rgblight_config.sat = %d\n", rgblight_config.sat);
 149   dprintf("rgblight_config.val = %d\n", rgblight_config.val);
 150 }
 151
 152 void rgblight_init(void) {
 153   debug_enable = 1; // Debug ON!
 154   dprintf("rgblight_init called.\n");
 155   rgblight_inited = 1;
 156   dprintf("rgblight_init start!\n");
 157   if (!eeconfig_is_enabled()) {
 158     dprintf("rgblight_init eeconfig is not enabled.\n");
 159     eeconfig_init();
 160     eeconfig_update_rgblight_default();
 161   }
 162   rgblight_config.raw = eeconfig_read_rgblight();
 163   if (!rgblight_config.mode) {
 164     dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
 165     eeconfig_update_rgblight_default();
 166     rgblight_config.raw = eeconfig_read_rgblight();
 167   }
 168   eeconfig_debug_rgblight(); // display current eeprom values
 169
 170   #if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
 171     rgblight_timer_init(); // setup the timer
 172   #endif
 173
 174   if (rgblight_config.enable) {
 175     rgblight_mode(rgblight_config.mode);
 176   }
 177 }
 178
 179 void rgblight_increase(void) {
 180   uint8_t mode = 0;
 181   if (rgblight_config.mode < RGBLIGHT_MODES) {
 182     mode = rgblight_config.mode + 1;
 183   }
 184   rgblight_mode(mode);
 185 }
 186 void rgblight_decrease(void) {
 187   uint8_t mode = 0;
 188   // Mode will never be < 1. If it ever is, eeprom needs to be initialized.
 189   if (rgblight_config.mode > 1) {
 190     mode = rgblight_config.mode - 1;
 191   }
 192   rgblight_mode(mode);
 193 }
 194 void rgblight_step(void) {
 195   uint8_t mode = 0;
 196   mode = rgblight_config.mode + 1;
 197   if (mode > RGBLIGHT_MODES) {
 198     mode = 1;
 199   }
 200   rgblight_mode(mode);
 201 }
 202
 203 void rgblight_mode(uint8_t mode) {
 204   if (!rgblight_config.enable) {
 205     return;
 206   }
 207   if (mode < 1) {
 208     rgblight_config.mode = 1;
 209   } else if (mode > RGBLIGHT_MODES) {
 210     rgblight_config.mode = RGBLIGHT_MODES;
 211   } else {
 212     rgblight_config.mode = mode;
 213   }
 214   eeconfig_update_rgblight(rgblight_config.raw);
 215   xprintf("rgblight mode: %u\n", rgblight_config.mode);
 216   if (rgblight_config.mode == 1) {
 217     #if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
 218       rgblight_timer_disable();
 219     #endif
 220   } else if (rgblight_config.mode >= 2 && rgblight_config.mode <= 23) {
 221     // MODE 2-5, breathing
 222     // MODE 6-8, rainbow mood
 223     // MODE 9-14, rainbow swirl
 224     // MODE 15-20, snake
 225     // MODE 21-23, knight
 226
 227     #if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
 228       rgblight_timer_enable();
 229     #endif
 230   }
 231   rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
 232 }
 233
 234 void rgblight_toggle(void) {
 235   rgblight_config.enable ^= 1;
 236   eeconfig_update_rgblight(rgblight_config.raw);
 237   xprintf("rgblight toggle: rgblight_config.enable = %u\n", rgblight_config.enable);
 238   if (rgblight_config.enable) {
 239     rgblight_mode(rgblight_config.mode);
 240   } else {
 241     #if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
 242       rgblight_timer_disable();
 243     #endif
 244     _delay_ms(50);
 245     rgblight_set();
 246   }
 247 }
 248
 249
 250 void rgblight_increase_hue(void) {
 251   uint16_t hue;
 252   hue = (rgblight_config.hue+RGBLIGHT_HUE_STEP) % 360;
 253   rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
 254 }
 255 void rgblight_decrease_hue(void) {
 256   uint16_t hue;
 257   if (rgblight_config.hue-RGBLIGHT_HUE_STEP < 0) {
 258     hue = (rgblight_config.hue + 360 - RGBLIGHT_HUE_STEP) % 360;
 259   } else {
 260     hue = (rgblight_config.hue - RGBLIGHT_HUE_STEP) % 360;
 261   }
 262   rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
 263 }
 264 void rgblight_increase_sat(void) {
 265   uint8_t sat;
 266   if (rgblight_config.sat + RGBLIGHT_SAT_STEP > 255) {
 267     sat = 255;
 268   } else {
 269     sat = rgblight_config.sat + RGBLIGHT_SAT_STEP;
 270   }
 271   rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
 272 }
 273 void rgblight_decrease_sat(void) {
 274   uint8_t sat;
 275   if (rgblight_config.sat - RGBLIGHT_SAT_STEP < 0) {
 276     sat = 0;
 277   } else {
 278     sat = rgblight_config.sat - RGBLIGHT_SAT_STEP;
 279   }
 280   rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
 281 }
 282 void rgblight_increase_val(void) {
 283   uint8_t val;
 284   if (rgblight_config.val + RGBLIGHT_VAL_STEP > 255) {
 285     val = 255;
 286   } else {
 287     val = rgblight_config.val + RGBLIGHT_VAL_STEP;
 288   }
 289   rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
 290 }
 291 void rgblight_decrease_val(void) {
 292   uint8_t val;
 293   if (rgblight_config.val - RGBLIGHT_VAL_STEP < 0) {
 294     val = 0;
 295   } else {
 296     val = rgblight_config.val - RGBLIGHT_VAL_STEP;
 297   }
 298   rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
 299 }
 300
 301 void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
 302   inmem_config.raw = rgblight_config.raw;
 303   if (rgblight_config.enable) {
 304     struct cRGB tmp_led;
 305     sethsv(hue, sat, val, &tmp_led);
 306     inmem_config.hue = hue;
 307     inmem_config.sat = sat;
 308     inmem_config.val = val;
 309     // dprintf("rgblight set hue [MEMORY]: %u,%u,%u\n", inmem_config.hue, inmem_config.sat, inmem_config.val);
 310     rgblight_setrgb(tmp_led.r, tmp_led.g, tmp_led.b);
 311   }
 312 }
 313 void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
 314   if (rgblight_config.enable) {
 315     if (rgblight_config.mode == 1) {
 316       // same static color
 317       rgblight_sethsv_noeeprom(hue, sat, val);
 318     } else {
 319       // all LEDs in same color
 320       if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
 321         // breathing mode, ignore the change of val, use in memory value instead
 322         val = rgblight_config.val;
 323       } else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 14) {
 324         // rainbow mood and rainbow swirl, ignore the change of hue
 325         hue = rgblight_config.hue;
 326       }
 327     }
 328     rgblight_config.hue = hue;
 329     rgblight_config.sat = sat;
 330     rgblight_config.val = val;
 331     eeconfig_update_rgblight(rgblight_config.raw);
 332     xprintf("rgblight set hsv [EEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
 333   }
 334 }
 335
 336 void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b) {
 337   // dprintf("rgblight set rgb: %u,%u,%u\n", r,g,b);
 338   for (uint8_t i = 0; i < RGBLED_NUM; i++) {
 339     led[i].r = r;
 340     led[i].g = g;
 341     led[i].b = b;
 342   }
 343   rgblight_set();
 344 }
 345
 346 void rgblight_set(void) {
 347   if (rgblight_config.enable) {
 348     ws2812_setleds(led, RGBLED_NUM);
 349   } else {
 350     for (uint8_t i = 0; i < RGBLED_NUM; i++) {
 351       led[i].r = 0;
 352       led[i].g = 0;
 353       led[i].b = 0;
 354     }
 355     ws2812_setleds(led, RGBLED_NUM);
 356   }
 357 }
 358
 359 #if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
 360
 361 // Animation timer -- AVR Timer3
 362 void rgblight_timer_init(void) {
 363   static uint8_t rgblight_timer_is_init = 0;
 364   if (rgblight_timer_is_init) {
 365     return;
 366   }
 367   rgblight_timer_is_init = 1;
 368   /* Timer 3 setup */
 369   TCCR3B = _BV(WGM32) //CTC mode OCR3A as TOP
 370         | _BV(CS30); //Clock selelct: clk/1
 371   /* Set TOP value */
 372   uint8_t sreg = SREG;
 373   cli();
 374   OCR3AH = (RGBLED_TIMER_TOP >> 8) & 0xff;
 375   OCR3AL = RGBLED_TIMER_TOP & 0xff;
 376   SREG = sreg;
 377 }
 378 void rgblight_timer_enable(void) {
 379   TIMSK3 |= _BV(OCIE3A);
 380   dprintf("TIMER3 enabled.\n");
 381 }
 382 void rgblight_timer_disable(void) {
 383   TIMSK3 &= ~_BV(OCIE3A);
 384   dprintf("TIMER3 disabled.\n");
 385 }
 386 void rgblight_timer_toggle(void) {
 387   TIMSK3 ^= _BV(OCIE3A);
 388   dprintf("TIMER3 toggled.\n");
 389 }
 390
 391 ISR(TIMER3_COMPA_vect) {
 392   // mode = 1, static light, do nothing here
 393   if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
 394     // mode = 2 to 5, breathing mode
 395     rgblight_effect_breathing(rgblight_config.mode - 2);
 396   } else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 8) {
 397     // mode = 6 to 8, rainbow mood mod
 398     rgblight_effect_rainbow_mood(rgblight_config.mode - 6);
 399   } else if (rgblight_config.mode >= 9 && rgblight_config.mode <= 14) {
 400     // mode = 9 to 14, rainbow swirl mode
 401     rgblight_effect_rainbow_swirl(rgblight_config.mode - 9);
 402   } else if (rgblight_config.mode >= 15 && rgblight_config.mode <= 20) {
 403     // mode = 15 to 20, snake mode
 404     rgblight_effect_snake(rgblight_config.mode - 15);
 405   } else if (rgblight_config.mode >= 21 && rgblight_config.mode <= 23) {
 406     // mode = 21 to 23, knight mode
 407     rgblight_effect_knight(rgblight_config.mode - 21);
 408   }
 409 }
 410
 411 // Effects
 412 void rgblight_effect_breathing(uint8_t interval) {
 413   static uint8_t pos = 0;
 414   static uint16_t last_timer = 0;
 415
 416   if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_BREATHING_INTERVALS[interval])) {
 417     return;
 418   }
 419   last_timer = timer_read();
 420
 421   rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, pgm_read_byte(&RGBLED_BREATHING_TABLE[pos]));
 422   pos = (pos + 1) % 256;
 423 }
 424 void rgblight_effect_rainbow_mood(uint8_t interval) {
 425   static uint16_t current_hue = 0;
 426   static uint16_t last_timer = 0;
 427
 428   if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_RAINBOW_MOOD_INTERVALS[interval])) {
 429     return;
 430   }
 431   last_timer = timer_read();
 432   rgblight_sethsv_noeeprom(current_hue, rgblight_config.sat, rgblight_config.val);
 433   current_hue = (current_hue + 1) % 360;
 434 }
 435 void rgblight_effect_rainbow_swirl(uint8_t interval) {
 436   static uint16_t current_hue = 0;
 437   static uint16_t last_timer = 0;
 438   uint16_t hue;
 439   uint8_t i;
 440   if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_RAINBOW_MOOD_INTERVALS[interval / 2])) {
 441     return;
 442   }
 443   last_timer = timer_read();
 444   for (i = 0; i < RGBLED_NUM; i++) {
 445     hue = (360 / RGBLED_NUM * i + current_hue) % 360;
 446     sethsv(hue, rgblight_config.sat, rgblight_config.val, &led[i]);
 447   }
 448   rgblight_set();
 449
 450   if (interval % 2) {
 451     current_hue = (current_hue + 1) % 360;
 452   } else {
 453     if (current_hue - 1 < 0) {
 454       current_hue = 359;
 455     } else {
 456       current_hue = current_hue - 1;
 457     }
 458   }
 459 }
 460 void rgblight_effect_snake(uint8_t interval) {
 461   static uint8_t pos = 0;
 462   static uint16_t last_timer = 0;
 463   uint8_t i, j;
 464   int8_t k;
 465   int8_t increment = 1;
 466   if (interval % 2) {
 467     increment = -1;
 468   }
 469   if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_SNAKE_INTERVALS[interval / 2])) {
 470     return;
 471   }
 472   last_timer = timer_read();
 473   for (i = 0; i < RGBLED_NUM; i++) {
 474     led[i].r = 0;
 475     led[i].g = 0;
 476     led[i].b = 0;
 477     for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) {
 478       k = pos + j * increment;
 479       if (k < 0) {
 480         k = k + RGBLED_NUM;
 481       }
 482       if (i == k) {
 483         sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), &led[i]);
 484       }
 485     }
 486   }
 487   rgblight_set();
 488   if (increment == 1) {
 489     if (pos - 1 < 0) {
 490       pos = RGBLED_NUM - 1;
 491     } else {
 492       pos -= 1;
 493     }
 494   } else {
 495     pos = (pos + 1) % RGBLED_NUM;
 496   }
 497 }
 498 void rgblight_effect_knight(uint8_t interval) {
 499   static int8_t pos = 0;
 500   static uint16_t last_timer = 0;
 501   uint8_t i, j, cur;
 502   int8_t k;
 503   struct cRGB preled[RGBLED_NUM];
 504   static int8_t increment = -1;
 505   if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_KNIGHT_INTERVALS[interval])) {
 506     return;
 507   }
 508   last_timer = timer_read();
 509   for (i = 0; i < RGBLED_NUM; i++) {
 510     preled[i].r = 0;
 511     preled[i].g = 0;
 512     preled[i].b = 0;
 513     for (j = 0; j < RGBLIGHT_EFFECT_KNIGHT_LENGTH; j++) {
 514       k = pos + j * increment;
 515       if (k < 0) {
 516         k = 0;
 517       }
 518       if (k >= RGBLED_NUM) {
 519         k = RGBLED_NUM - 1;
 520       }
 521       if (i == k) {
 522         sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, &preled[i]);
 523       }
 524     }
 525   }
 526   if (RGBLIGHT_EFFECT_KNIGHT_OFFSET) {
 527     for (i = 0; i < RGBLED_NUM; i++) {
 528       cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % RGBLED_NUM;
 529       led[i].r = preled[cur].r;
 530       led[i].g = preled[cur].g;
 531       led[i].b = preled[cur].b;
 532     }
 533   }
 534   rgblight_set();
 535   if (increment == 1) {
 536     if (pos - 1 < 0 - RGBLIGHT_EFFECT_KNIGHT_LENGTH) {
 537       pos = 0 - RGBLIGHT_EFFECT_KNIGHT_LENGTH;
 538       increment = -1;
 539     } else {
 540       pos -= 1;
 541     }
 542   } else {
 543     if (pos + 1 > RGBLED_NUM + RGBLIGHT_EFFECT_KNIGHT_LENGTH) {
 544       pos = RGBLED_NUM + RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;
 545       increment = 1;
 546     } else {
 547       pos += 1;
 548     }
 549   }
 550 }
 551
 552 #endif