Merge branch 'development' of https://github.com/arendst/Sonoff-Tasmota into fix/better_colormode

sonoff/core_esp8266_wiring_pwm.c

@@ -191,6 +191,11 @@ extern void __analogWrite(uint8_t pin, int value)
         prep_pwm_steps();
         return;
     }
+    if(value == pwm_range) {
+        digitalWrite(pin, HIGH);
+        prep_pwm_steps();
+        return;
+    }
     if((pwm_mask & (1 << pin)) == 0) {
         if(pwm_mask == 0) {
             memset(&_pwm_isr_data, 0, sizeof(_pwm_isr_data));

sonoff/sonoff.h

@@ -244,7 +244,7 @@ enum DomoticzSensors {DZ_TEMP, DZ_TEMP_HUM, DZ_TEMP_HUM_BARO, DZ_POWER_ENERGY, D
 enum Ws2812ClockIndex { WS_SECOND, WS_MINUTE, WS_HOUR, WS_MARKER };
 enum Ws2812Color { WS_RED, WS_GREEN, WS_BLUE };
 
-enum LightSubtypes { LST_NONE, LST_SINGLE, LST_COLDWARM, LST_RGB,   LST_RGBW, LST_RGBWC };                   // Do not insert new fields
+enum LightSubtypes { LST_NONE, LST_SINGLE, LST_COLDWARM, LST_RGB,   LST_RGBW, LST_RGBWC, LST_MAX=5 };   // Do not insert new fields
 enum LightTypes    { LT_BASIC, LT_PWM1,    LT_PWM2,      LT_PWM3,   LT_PWM4,  LT_PWM5,  LT_PWM6, LT_PWM7,
                      LT_NU8,   LT_SERIAL1, LT_SERIAL2,   LT_WS2812, LT_RGBW,  LT_RGBWC, LT_NU14, LT_NU15 };  // Do not insert new fields
 

sonoff/xdrv_04_light.ino

@@ -22,6 +22,7 @@
  *
  * light_type  Module     Color  ColorTemp  Modules
  * ----------  ---------  -----  ---------  ----------------------------
+ *  0          -                 no         (Sonoff Basic)
  *  1          PWM1       W      no         (Sonoff BN-SZ)
  *  2          PWM2       CW     yes        (Sonoff Led)
  *  3          PWM3       RGB    no         (H801, MagicHome and Arilux LC01)
@@ -67,6 +68,56 @@
  *  - light_controller (LightControllerClass) is used to change light state
  *    and adjust all Settings and levels accordingly.
  *    Always use this object to change light status.
+ *
+ * As there have been lots of changes in light control, here is a summary out
+ * the whole flow from setting colors to drving the PMW pins.
+ *
+ * 1.  To change colors, always use 'light_controller' object.
+ *     'light_state' is only to be used to read current state.
+ *  .a For color bulbs, set color via changeRGB() or changeHS() for Hue/Sat.
+ *     Set the overall brightness changeBri(0..255) or changeDimmer(0..100%)
+ *     RGB and Hue/Sat are always kept in sync. Internally, RGB are stored at
+ *     full range (max brightness) so that when you reduce brightness and
+ *     raise it back again, colors don't change due to rounding errors.
+ *  .b For white bulbs with Cold/Warm colortone, use changeCW() or changeCT()
+ *     to change color-tone. Set overall brightness separately.
+ *     Color-tone temperature can range from 153 (Cold) to 500 (Warm).
+ *     CW channels are stored at full brightness to avoid rounding errors.
+ *  .c Alternatively, you can set all 5 channels at once with changeChannels(),
+ *     in this case it will also set the corresponding brightness.
+ *
+ * 2.a After any change, the Settings object is updated so that changes
+ *     survive a reboot and can be stored in flash - in saveSettings()
+ *  .b Actual channel values are computed from RGB or CT combined with brightness.
+ *     Range is still 0..255 (8 bits) - in getActualRGBCW()
+ *  .c The 5 internal channels RGBWC are mapped to the actual channels supproted
+ *     by the light_type: in calcLevels()
+ *     1 channel  - 0:Brightness
+ *     2 channels - 0:Warmwhite 1:Coldwhite
+ *     3 channels - 0:Red 1:Green 2:Blue
+ *     4 chennels - 0:Red 1:Green 2:Blue 3:White
+ *     5 chennels - 0:Red 1:Green 2:Blue 3:Warmwhite 4:Coldwhite
+ *
+ * 3.  In LightAnimate(), final PWM values are computed at next tick.
+ *  .a If color did not change since last tick - ignore.
+ *  .b Apply color balance correction from rgbwwTable[]
+ *  .c Extend resolution from 8 bits to 10 bits, which makes a significant
+ *     difference when applying gamma correction at low brightness.
+ *  .d Apply Gamma Correction if LedTable==1 (by default).
+ *     Gamma Correction uses an adaptative resolution table from 11 to 8 bits.
+ *  .e For Warm/Cold-white channels, Gamma correction is calculated in combined mode.
+ *     Ie. total white brightness (C+W) is used for Gamma correction and gives
+ *     the overall light power required. Then this light power is split among
+ *     Wamr/Cold channels.
+ *  .f Gamma correction is still applied to 8 bits channels for compatibility
+ *     with other non-PMW modules.
+ *  .g Avoid PMW values between 1008 and 1022, issue #1146
+ *  .h Scale ranges from 10 bits to 0..PWMRange (by default 1023) so no change
+ *     by default.
+ *  .i Apply port remapping from Option37
+ *  .j Invert PWM value if port is of type PMWxi instead of PMWx
+ *  .k Apply PWM value with analogWrite() - if pin is configured
+ *
 \*********************************************************************************************/
 
 #define XDRV_04              4
@@ -106,29 +157,76 @@ struct LCwColor {
 const uint8_t MAX_FIXED_COLD_WARM = 4;
 const LCwColor kFixedColdWarm[MAX_FIXED_COLD_WARM] PROGMEM = { 0,0, 255,0, 0,255, 128,128 };
 
-const uint8_t ledTable[] = {
+// New version of Gamma correction table, with adaptative resolution
-  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+// from 11 bits (lower values) to 8 bits (upper values).
-  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+// We're using the fact that lower values are small and can fit within 8 bits
-  1,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,  4,  4,
+// To save flash space, the array is only 8 bits uint
-  4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,
+const uint8_t _ledTable[] = {
-  8,  8,  9,  9,  9, 10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 14,
+  // 11 bits resolution
- 14, 15, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 22,
+    0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  // 11 bits, 0..2047
- 22, 23, 23, 24, 25, 25, 26, 26, 27, 28, 28, 29, 30, 30, 31, 32,
+    2,  2,  2,  2,  3,  3,  3,  3,  4,  4,  4,  5,  5,  6,  6,  7,  // 11 bits, 0..2047
- 33, 33, 34, 35, 36, 36, 37, 38, 39, 40, 40, 41, 42, 43, 44, 45,
+    7,  8,  8,  9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19,  // 11 bits, 0..2047
- 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+   20, 21, 22, 24, 25, 26, 28, 29, 30, 32, 33, 35, 37, 38, 40, 42,  // 11 bits, 0..2047
- 61, 62, 63, 64, 65, 67, 68, 69, 70, 71, 72, 73, 75, 76, 77, 78,
+  // 10 bits resolution
- 80, 81, 82, 83, 85, 86, 87, 89, 90, 91, 93, 94, 95, 97, 98, 99,
+   22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 36, 37, 38, 39,  // 10 bits, 0..1023
-101,102,104,105,107,108,110,111,113,114,116,117,119,121,122,124,
+   41, 42, 44, 45, 47, 48, 50, 51, 53, 55, 56, 58, 60, 62, 64, 65,  // 10 bits, 0..1023
-125,127,129,130,132,134,135,137,139,141,142,144,146,148,150,151,
+   67, 69, 71, 73, 75, 78, 80, 82, 84, 86, 89, 91, 93, 96, 98,101,  // 10 bits, 0..1023
-153,155,157,159,161,163,165,166,168,170,172,174,176,178,180,182,
+  103,106,108,111,114,116,119,122,125,128,131,134,137,140,143,146,  // 10 bits, 0..1023
-184,186,189,191,193,195,197,199,201,204,206,208,210,212,215,217,
+  // 9 bits resolution
-219,221,224,226,228,231,233,235,238,240,243,245,248,250,253,255 };
+   75, 77, 78, 80, 82, 84, 85, 87, 89, 91, 93, 94, 96, 98,100,102,  //  9 bits, 0..511
+  104,106,108,110,112,115,117,119,121,123,125,128,130,132,135,137,  //  9 bits, 0..511
+  140,142,144,147,149,152,155,157,160,163,165,168,171,173,176,179,  //  9 bits, 0..511
+  182,185,188,191,194,197,200,203,206,209,212,215,219,222,225,229,  //  9 bits, 0..511
+  // 8 bits resolution
+  116,118,120,121,123,125,127,128,130,132,134,136,138,139,141,143,  //  8 bits, 0..255
+  145,147,149,151,153,155,157,159,161,163,165,168,170,172,174,176,  //  8 bits, 0..255
+  178,181,183,185,187,190,192,194,197,199,201,204,206,209,211,214,  //  8 bits, 0..255
+  216,219,221,224,226,229,232,234,237,240,242,245,248,250,253,255   //  8 bits, 0..255
+};
 
-uint8_t light_entry_color[5];
+// For reference, below are the computed gamma tables, via ledGamma()
-uint8_t light_current_color[5];
+// for 8 bits output:
-uint8_t light_new_color[5];
+//  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-uint8_t light_last_color[5];
+//  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-uint8_t light_color_remap[5];
+//  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,
+//  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,  5,  5,  5,  5,  5,  6,
+//  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10, 10, 10,
+// 11, 11, 11, 12, 12, 12, 13, 13, 14, 14, 14, 15, 15, 16, 16, 17,
+// 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 23, 23, 24, 24, 25, 26,
+// 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 37,
+// 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 47, 48, 49, 50, 51,
+// 52, 53, 54, 55, 56, 58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69,
+// 70, 71, 72, 74, 75, 76, 78, 79, 80, 82, 83, 84, 86, 87, 88, 90,
+// 91, 93, 94, 96, 97, 99,100,102,103,105,106,108,110,111,113,115,
+//116,118,120,121,123,125,127,128,130,132,134,136,138,139,141,143,
+//145,147,149,151,153,155,157,159,161,163,165,168,170,172,174,176,
+//178,181,183,185,187,190,192,194,197,199,201,204,206,209,211,214,
+//216,219,221,224,226,229,232,234,237,240,242,245,248,250,253,255
+//
+// and for 10 bits output:
+//  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+//  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,  4,
+//  4,  4,  4,  5,  5,  5,  6,  6,  6,  7,  7,  8,  8,  9,  9, 10,
+// 10, 11, 11, 12, 13, 13, 14, 15, 15, 16, 17, 18, 19, 19, 20, 21,
+// 22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 36, 37, 38, 39,
+// 41, 42, 44, 45, 47, 48, 50, 51, 53, 55, 56, 58, 60, 62, 64, 65,
+// 67, 69, 71, 73, 75, 78, 80, 82, 84, 86, 89, 91, 93, 96, 98,101,
+//103,106,108,111,114,116,119,122,125,128,131,134,137,140,143,146,
+//151,155,157,161,165,169,171,175,179,183,187,189,193,197,201,205,
+//209,213,217,221,225,231,235,239,243,247,251,257,261,265,271,275,
+//281,285,289,295,299,305,311,315,321,327,331,337,343,347,353,359,
+//365,371,377,383,389,395,401,407,413,419,425,431,439,445,451,459,
+//467,475,483,487,495,503,511,515,523,531,539,547,555,559,567,575,
+//583,591,599,607,615,623,631,639,647,655,663,675,683,691,699,707,
+//715,727,735,743,751,763,771,779,791,799,807,819,827,839,847,859,
+//867,879,887,899,907,919,931,939,951,963,971,983,995,1003,1015,1023
+
+
+uint8_t light_entry_color[LST_MAX];
+uint8_t light_current_color[LST_MAX];
+uint8_t light_new_color[LST_MAX];
+uint8_t light_last_color[LST_MAX];
+uint8_t light_color_remap[LST_MAX];
 
 uint8_t light_wheel = 0;
 uint8_t light_subtype = 0;    // LST_ subtype
@@ -157,6 +255,10 @@ unsigned long strip_timer_counter = 0;    // Bars and Gradient
 //
 uint16_t changeUIntScale(uint16_t inum, uint16_t ifrom_min, uint16_t ifrom_max,
                                        uint16_t ito_min, uint16_t ito_max) {
+  // guard-rails
+  if ((ito_min >= ito_max) || (ifrom_min >= ifrom_max)) {
+    return ito_min;  // invalid input, return arbitrary value
+  }
   // convert to uint31, it's more verbose but code is more compact
   uint32_t num = inum;
   uint32_t from_min = ifrom_min;
@@ -856,6 +958,33 @@ public:
 LightStateClass light_state = LightStateClass();
 LightControllerClass light_controller = LightControllerClass(light_state);
 
+/*********************************************************************************************\
+ * Gamma correction
+\*********************************************************************************************/
+// Calculate the gamma corrected value for LEDS
+// You can request 11, 10, 9 or 8 bits resolution via 'bits_out' parameter
+uint16_t ledGamma(uint8_t v, uint16_t bits_out = 8) {
+  uint16_t result;
+  // bits_resolution: the resolution of _ledTable[v], between 8 and 11
+  uint32_t bits_resolution = 11 - (v / 64);                     // 8..11
+  int32_t  bits_correction = bits_out - bits_resolution;      // -3..3
+  uint32_t uncorrected_value = _ledTable[v];        // 0..255
+  if (0 == bits_correction) {
+    // we already match the required resolution, no change
+    result = uncorrected_value;
+  } else if (bits_correction > 0) {
+    // the output resolution is higher than our value, we need to extrapolate
+    // we shift by bits_correction, and force last bits to 1
+    uint32_t bits_mask = (1 << bits_correction) - 1;  // 1, 3, 7
+    result = (uncorrected_value << bits_correction) | bits_mask;
+  } else {  // bits_correction < 0
+    // our resolution is too high, we need to remove bits
+    // we add 1, 3 or 7 to force rouding to the nearest high value
+    uint32_t bits_mask = (1 << -bits_correction) - 1;  // 1, 3, 7
+    result = ((uncorrected_value + bits_mask) >> -bits_correction);
+  }
+  return result;
+}
 
 #ifdef USE_ARILUX_RF
 /*********************************************************************************************\
@@ -1199,7 +1328,7 @@ void LightInit(void)
   uint8_t max_scheme = LS_MAX -1;
 
   light_device = devices_present;
-  light_subtype = light_type &7;        // Always 0 - 7
+  light_subtype = (light_type & 7) > LST_MAX ? LST_MAX : (light_type & 7); // Always 0 - LST_MAX (5)
 
   light_controller.setSubType(light_subtype);
   light_controller.loadSettings();
@@ -1550,7 +1679,7 @@ void LightSetPower(void)
 
 void LightAnimate(void)
 {
-  uint8_t cur_col[5];
+  uint8_t cur_col[LST_MAX];
   uint16_t light_still_on = 0;
 
   strip_timer_counter++;
@@ -1637,29 +1766,75 @@ void LightAnimate(void)
       light_update = 1;
     }
     if (light_update) {
+      uint16_t cur_col_10bits[LST_MAX];   // 10 bits version of cur_col for PWM
       light_update = 0;
-      for (uint8_t i = 0; i < light_subtype; i++) {
+
+      // first adjust all colors to RgbwwTable if needed
+      for (uint8_t i = 0; i < LST_MAX; i++) {
         light_last_color[i] = light_new_color[i];
-        cur_col[i] = light_last_color[i]*Settings.rgbwwTable[i]/255;
+        // adjust from 0.255 to 0..Settings.rgbwwTable[i] -- RgbwwTable command
-        cur_col[i] = (Settings.light_correction) ? ledTable[cur_col[i]] : cur_col[i];
+        // protect against overflow of rgbwwTable which is of size 5
+        cur_col[i] = changeUIntScale(light_last_color[i], 0, 255, 0, (i<5)? Settings.rgbwwTable[i] : 255);
+        // Extend from 8 to 10 bits if no correction (in case no gamma correction is required)
+        cur_col_10bits[i] = changeUIntScale(cur_col[i], 0, 255, 0, 1023);
       }
 
-      // color remapping
+      // Apply gamma correction for 8 and 10 bits resolutions, if needed
-      uint8_t orig_col[5];
+      if (Settings.light_correction) {
+        // first apply gamma correction to all channels independently, from 8 bits value
+        for (uint8_t i = 0; i < LST_MAX; i++) {
+          cur_col_10bits[i] = ledGamma(cur_col[i], 10);
+        }
+        // then apply a different correction for CW white channels
+        if ((LST_COLDWARM == light_subtype) || (LST_RGBWC == light_subtype)) {
+          uint8_t w_idx[2] = {0, 1};        // if LST_COLDWARM, channels 0 and 1
+          if (LST_RGBWC == light_subtype) { // if LST_RGBWC, channels 3 and 4
+            w_idx[0] = 3;
+            w_idx[1] = 4;
+          }
+          uint16_t white_bri = cur_col[w_idx[0]] + cur_col[w_idx[1]];
+          // if sum of both channels is > 255, then channels are probablu uncorrelated
+          if (white_bri <= 255) {
+            // we calculate the gamma corrected sum of CW + WW
+            uint16_t white_bri_10bits = ledGamma(white_bri, 10);
+            // then we split the total energy among the cold and warm leds
+            cur_col_10bits[w_idx[0]] = changeUIntScale(cur_col[w_idx[0]], 0, white_bri, 0, white_bri_10bits);
+            cur_col_10bits[w_idx[1]] = changeUIntScale(cur_col[w_idx[1]], 0, white_bri, 0, white_bri_10bits);
+          }
+        }
+        // still keep an 8 bits gamma corrected version
+        for (uint8_t i = 0; i < LST_MAX; i++) {
+          cur_col[i] = ledGamma(cur_col[i]);
+        }
+      }
+
+      // final adjusments for PMW, post-gamma correction
+      for (uint8_t i = 0; i < LST_MAX; i++) {
+        // Fix unwanted blinking and PWM watchdog errors for values close to pwm_range (H801, Arilux and BN-SZ01)
+        // but keep value 1023 if full range (PWM will be deactivated in this case)
+        if ((cur_col_10bits[i] > 1008) && (cur_col_10bits[i] < 1023)) {
+          cur_col_10bits[i] = 1008;
+        }
+        // scale from 0..1023 to 0..pwm_range, but keep any non-zero value to at least 1
+        cur_col_10bits[i] = (cur_col_10bits[i] > 0) ? changeUIntScale(cur_col_10bits[i], 1, 1023, 1, Settings.pwm_range) : 0;
+      }
+
+      // apply port remapping on both 8 bits and 10 bits versions
+      uint8_t  orig_col[LST_MAX];
+      uint16_t orig_col_10bits[LST_MAX];
       memcpy(orig_col, cur_col, sizeof(orig_col));
-      for (uint8_t i = 0; i < 5; i++) {
+      memcpy(orig_col_10bits, cur_col_10bits, sizeof(orig_col_10bits));
+      for (uint8_t i = 0; i < LST_MAX; i++) {
         cur_col[i] = orig_col[light_color_remap[i]];
+        cur_col_10bits[i] = orig_col_10bits[light_color_remap[i]];
       }
 
+      // now apply the actual PWM values, adjusted and remapped 10-bits range
+      if (light_type < LT_PWM6) {   // only for direct PWM lights, not for Tuya, Armtronix...
         for (uint8_t i = 0; i < light_subtype; i++) {
-        if (light_type < LT_PWM6) {
           if (pin[GPIO_PWM1 +i] < 99) {
-            if (cur_col[i] > 0xFC) {
+            //AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION "Cur_Col%d 10 bits %d, Pwm%d %d"), i, cur_col[i], i+1, curcol);
-              cur_col[i] = 0xFC;   // Fix unwanted blinking and PWM watchdog errors for values close to pwm_range (H801, Arilux and BN-SZ01)
+            analogWrite(pin[GPIO_PWM1 +i], bitRead(pwm_inverted, i) ? Settings.pwm_range - cur_col_10bits[i] : cur_col_10bits[i]);
-            }
-            uint16_t curcol = cur_col[i] * (Settings.pwm_range / 255);
-//            AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION "Cur_Col%d %d, CurCol %d"), i, cur_col[i], curcol);
-            analogWrite(pin[GPIO_PWM1 +i], bitRead(pwm_inverted, i) ? Settings.pwm_range - curcol : curcol);
           }
         }
       }
@@ -1682,12 +1857,8 @@ void LightAnimate(void)
         // handle any PWM pins, skipping the first 3 values for sm16716
         for (uint8_t i = 3; i < light_subtype; i++) {
           if (pin[GPIO_PWM1 +i-3] < 99) {
-            if (cur_col[i] > 0xFC) {
+            //AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION "Cur_Col%d 10 bits %d, Pwm%d %d"), i, cur_col[i], i+1, curcol);
-              cur_col[i] = 0xFC;   // Fix unwanted blinking and PWM watchdog errors for values close to pwm_range (H801, Arilux and BN-SZ01)
+            analogWrite(pin[GPIO_PWM1 +i-3], bitRead(pwm_inverted, i-3) ? Settings.pwm_range - cur_col_10bits[i] : cur_col_10bits[i]);
-            }
-            uint16_t curcol = cur_col[i] * (Settings.pwm_range / 255);
-//            AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_LOG_APPLICATION "Cur_Col%d %d, CurCol %d"), i, cur_col[i], curcol);
-            analogWrite(pin[GPIO_PWM1 +i-3], bitRead(pwm_inverted, i-3) ? Settings.pwm_range - curcol : curcol);
           }
         }
         // handle sm16716 update
@@ -1736,7 +1907,7 @@ bool LightColorEntry(char *buffer, uint8_t buffer_length)
   if (strstr(buffer, ",") != nullptr) {             // Decimal entry
     int8_t i = 0;
     for (str = strtok_r(buffer, ",", &p); str && i < 6; str = strtok_r(nullptr, ",", &p)) {
-      if (i < 5) {
+      if (i < LST_MAX) {
         light_entry_color[i++] = atoi(str);
       }
     }

sonoff/xplg_ws2812.ino

@@ -99,11 +99,11 @@ void Ws2812StripShow(void)
   if (Settings.light_correction) {
     for (uint16_t i = 0; i < Settings.light_pixels; i++) {
       c = strip->GetPixelColor(i);
-      c.R = ledTable[c.R];
+      c.R = ledGamma(c.R);
-      c.G = ledTable[c.G];
+      c.G = ledGamma(c.G);
-      c.B = ledTable[c.B];
+      c.B = ledGamma(c.B);
 #if (USE_WS2812_CTYPE > NEO_3LED)
-      c.W = ledTable[c.W];
+      c.W = ledGamma(c.W);
 #endif
       strip->SetPixelColor(i, c);
     }