Merge branch 'bugfix/lightbulb_power_cal_check' into 'master'

fix(lightbulb): Adjust the power calculation algorithm

See merge request ae_group/esp-iot-solution!1275

Author: Ye Zicheng

components/led/lightbulb_driver/CHANGELOG.md

@@ -1,5 +1,12 @@
 # ChangeLog
 
+## v1.8.2 - 2025-04-17
+
+### Bug Fix:
+
+- Adjust the power calculation algorithm
+- Adjust the upper limit of pwm resolution to 12bit
+
 ## v1.8.1 - 2025-04-17
 
 ### Bug Fix:

components/led/lightbulb_driver/drivers/pwm/pwm.c

@@ -96,7 +96,7 @@ esp_err_t pwm_init(driver_pwm_t *config, void(*hook_func)(void *))
     s_pwm->ledc_config.speed_mode = LEDC_LOW_SPEED_MODE;
     s_pwm->ledc_config.clk_cfg = LEDC_USE_XTAL_CLK;
 #endif
-    uint32_t preset_bit = LEDC_TIMER_13_BIT;
+    uint32_t preset_bit = LEDC_TIMER_12_BIT;
     for (s_pwm->ledc_config.duty_resolution = preset_bit; s_pwm->ledc_config.duty_resolution >= LEDC_TIMER_10_BIT; s_pwm->ledc_config.duty_resolution--) {
         err = ledc_timer_config(&s_pwm->ledc_config);
         if (err == ESP_OK) {

components/led/lightbulb_driver/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.8.1"
+version: "1.8.2"
 description: Provide multiple dimming driver solutions to easily build lightbulb applications
 url: https://github.com/espressif/esp-iot-solution/tree/master/components/led/lightbulb_driver
 dependencies:

components/led/lightbulb_driver/src/hal_driver.c

@@ -28,7 +28,7 @@ static const char *TAG = "hal_manage";
 #define PROBE_GPIO 4
 #define FADE_DEBUG_LOG_OUTPUT 0
 
-static void create_gpio_probe(int gpio_num, int level)
+void create_gpio_probe(int gpio_num, int level)
 {
     gpio_config_t io_conf;
     io_conf.intr_type = GPIO_INTR_DISABLE;
@@ -40,7 +40,7 @@ static void create_gpio_probe(int gpio_num, int level)
     gpio_set_level(gpio_num, level);
 }
 
-static void gpio_reverse(int gpio_num)
+void gpio_reverse(int gpio_num)
 {
     static int level = 0;
     gpio_set_level(gpio_num, (level++) % 2);
@@ -102,6 +102,7 @@ typedef struct {
     bool use_hw_fade;
     bool enable_multi_ch_write;
     uint16_t *table_group;
+    uint16_t table_size;
     // R G B C W
     float balance_coefficient[5];
     SemaphoreHandle_t fade_mutex;
@@ -530,12 +531,13 @@ esp_err_t hal_output_init(hal_config_t *config, lightbulb_gamma_config_t *gamma,
         s_hal_obj->enable_multi_ch_write = true;
     }
 
-    s_hal_obj->table_group = calloc(table_size, sizeof(uint16_t));
+    s_hal_obj->table_size = table_size;
+    s_hal_obj->table_group = calloc(s_hal_obj->table_size, sizeof(uint16_t));
     LIGHTBULB_CHECK(s_hal_obj->table_group, "curve table buffer alloc fail", goto EXIT);
 
     //Currently only used as a mapping table, it will be used for fade to achieve curve sliding changes in the future
     float curve_coe = DEFAULT_CURVE_COE;
-    hal_gamma_table_create(s_hal_obj->table_group, table_size, curve_coe, s_hal_obj->interface->hardware_allow_max_input_value);
+    hal_gamma_table_create(s_hal_obj->table_group, s_hal_obj->table_size, curve_coe, s_hal_obj->interface->hardware_allow_max_input_value);
 
     for (int i = 0; i < 5; i++) {
         float balance = gamma ? gamma->balance_coefficient[i] : 1.0;

components/led/lightbulb_driver/src/lightbulb.c

@@ -304,7 +304,7 @@ static uint8_t precise_kelvin_convert_to_percentage(uint16_t kelvin)
  * @param brightness Brightness value in the range 0-100
  * @param white_value Array to store the calculated cold and warm values for white output
  */
-static void cct_and_brightness_convert_and_power_limit(lightbulb_led_beads_comb_t led_beads, float multiple, uint8_t cct, uint8_t brightness, uint16_t white_value[])
+static esp_err_t cct_and_brightness_convert_and_power_limit(lightbulb_led_beads_comb_t led_beads, float multiple, uint8_t cct, uint8_t brightness, uint16_t white_value[])
 {
     uint16_t max_value = 0;
     hal_get_driver_feature(QUERY_MAX_INPUT_VALUE, &max_value);
@@ -353,6 +353,18 @@ static void cct_and_brightness_convert_and_power_limit(lightbulb_led_beads_comb_
             hal_get_curve_table_value((uint16_t)value, &white_value[i]);
         }
     }
+
+#if CONFIG_ENABLE_LIGHTBULB_DEBUG
+    uint16_t test_power =  white_value[0] + white_value[1] + white_value[2] + white_value[3] +  white_value[4];
+    uint16_t limit_power = max_value * multiple * (brightness / 100.0);
+
+    if (test_power > limit_power) {
+        ESP_LOGE(TAG, "Power exceeds expected, current: %d, expected:%d", test_power, limit_power);
+        return ESP_FAIL;
+    }
+#endif
+
+    return ESP_OK;
 }
 
 /**
@@ -414,33 +426,72 @@ static uint8_t process_white_brightness_limit(uint8_t brightness)
 /**
  * @brief Recalculate color power
  * @attention 300% = 100% + 100% + 100% : Full power output on each channel. If single channel output is 3w then total output is 9w.
- * @note
- *      input           output(color_max_power = 100)       output(color_max_power = 200)       output(color_max_power = 300)
- *      255,255,0       127,127,0                           255,255,0                           255,255,0
- *      127,127,0       63,63,0                             127,127,0                           127,127,0
- *      63,63,0         31,31,0                             63,63,0                             63,63,0
- *      255,255,255     85,85,85                            170,170,170                         255,255,255
- *      127,127,127     42,42,42                            84,84,84                            127,127,127
- *      63,63,63        21,21,21                            42,42,42                            63,63,63
  *
+ * lightbulb_power_limit_t limit = {
+ *   .color_max_power = 100,
+ *   .color_max_value = 100,
+ *   .color_min_value = 10,
+ *   .white_max_power = 100,
+ *   .white_max_brightness = 100,
+ *   .white_min_brightness = 10
+ * };
+ *
+ * lightbulb_gamma_config_t Gamma = {
+ *  .balance_coefficient = {1.0, 1.0, 1.0, 1.0, 1.0},
+ *  .color_curve_coefficient = 2.0,
+ *  .white_curve_coefficient = 2.0,
+ * };
+ *
+ * @note
+ *      input(hsv)          output(color_max_power = 100)       output(color_max_power = 200)       output(color_max_power = 300)
+ *      0,100,100           255,0,0                             255,0,0                             255,0,0
+ *      0,100,1             79,0,0                              79,0,0                              79,0,0
+ *      60,100,100          127,127,0                           255,255,0                           255,255,0
+ *      60,100,1            39,39,0                             79,79,0                             79,79,0
+ *      0,50,100            127,63,63                           255,127,127                         255,127,127
+ *      0,50,1              40,19,19                            79,38,38                            79,38,38
+ *      60,50,100           102,102,50                          204,204,101                         254,254,126
+ *      60,50,1             31,31,15                            63,63,30                            79,79,38
+ *      0,0,100             85,85,85                            170,170,170                         255,255,255
+ *      0,0,1               26,26,26                            52,52,52                            79,79,79
  */
-static void process_color_power_limit(float multiple, float rgbcw[5], uint16_t value, uint16_t out[5])
+static esp_err_t process_color_power_limit(float multiple, float rgbcw[5], uint16_t value, uint16_t out[5])
 {
     uint16_t max_value;
-    float max_power;
     hal_get_driver_feature(QUERY_MAX_INPUT_VALUE, &max_value);
-    max_power = multiple * (max_value);
-
-    float baseline = MAX(rgbcw[0], rgbcw[1]);
-    baseline = MAX(baseline, rgbcw[2]);
-    baseline = MAX(baseline, rgbcw[3]);
-    baseline = MAX(baseline, rgbcw[4]);
-    max_power = MIN(max_power, max_value / baseline);
-    ESP_LOGD(TAG, "%f, %d, %f", max_power, max_value, baseline);
-    for (int i = 0; i < 5; i++) {
-        float value = round(max_power * rgbcw[i]);
-        hal_get_curve_table_value((uint16_t)value, &out[i]);
+
+    float scaled[5];
+    float max_scale = 0.0f;
+    float max_scale_limit = (float)max_value;
+
+    for (int i = 0; i < 5; ++i) {
+        scaled[i] = rgbcw[i] * multiple;
+        if (scaled[i] > max_scale) {
+            max_scale = scaled[i];
+        }
     }
+
+    float scale_factor = 1.0f;
+    if (max_scale > 1.0f) {
+        scale_factor = max_scale_limit / (max_scale * max_scale_limit);
+    }
+
+    for (int i = 0; i < 5; ++i) {
+        float value_f = scaled[i] * scale_factor * max_value * (value / 100.0);
+        hal_get_curve_table_value((uint16_t)value_f, &out[i]);
+    }
+
+#if CONFIG_ENABLE_LIGHTBULB_DEBUG
+    uint16_t test_power = out[0] + out[1] + out[2] + out[3] + out[4];
+    uint16_t limit_power = max_value * multiple * (value / 100.0);
+
+    if (test_power > limit_power) {
+        ESP_LOGE(TAG, "Power exceeds expected, current: %d, expected:%d", test_power, limit_power);
+        return ESP_FAIL;
+    }
+#endif
+
+    return ESP_OK;
 }
 
 static void timercb(TimerHandle_t tmr)
@@ -1247,11 +1298,11 @@ static esp_err_t lightbulb_hsv2rgb_adjusted(uint16_t hue, uint8_t saturation, ui
         }
     }
 
-    *red = interpolated_rgbcw[0] * value / 100.0;
-    *green = interpolated_rgbcw[1] * value / 100.0;
-    *blue = interpolated_rgbcw[2] * value / 100.0;
-    *cold = interpolated_rgbcw[3] * value / 100.0;
-    *warm = interpolated_rgbcw[4] * value / 100.0;
+    *red = interpolated_rgbcw[0];
+    *green = interpolated_rgbcw[1];
+    *blue = interpolated_rgbcw[2];
+    *cold = interpolated_rgbcw[3];
+    *warm = interpolated_rgbcw[4];
 
     return ESP_OK;
 }
@@ -1265,14 +1316,21 @@ static esp_err_t _lightbulb_hsv2rgb(uint16_t hue, uint8_t saturation, uint8_t va
 
     ESP_LOGI(TAG, "Convert 8 bit value [r:%d g:%d b:%d]", _red, _green, _blue);
 
-    *red = _red / 255.0;
-    *green = _green / 255.0;
-    *blue = _blue / 255.0;
+    if (value == 0) {
+        *red = 0;
+        *green = 0;
+        *blue = 0;
+    } else {
+        *red = _red / 255.0;
+        *green = _green / 255.0;
+        *blue = _blue / 255.0;
+        float total = *red + *green + *blue;
+
+        *red = *red / total;
+        *green = *green / total;
+        *blue = *blue / total;
+    }
 
-    float total = *red + *green + *blue;
-    *red = *red / total;
-    *green = *green / total;
-    *blue = *blue / total;
     *cold = 0;
     *warm = 0;
 
@@ -1486,10 +1544,10 @@ esp_err_t lightbulb_set_hsv(uint16_t hue, uint8_t saturation, uint8_t value)
         ESP_LOGI(TAG, "Convert write value [r:%0.2f%% g:%0.2f%% b:%0.2f%% c:%0.2f%% w:%0.2f%%]", color_param[0] * 100, color_param[1] * 100, color_param[2] * 100, color_param[3] * 100, color_param[4] * 100);
 
         // 3. Redistribute power
-        process_color_power_limit(s_lb_obj->power.color_max_power / 100.0, color_param, _value, color_value);
+        err |= process_color_power_limit(s_lb_obj->power.color_max_power / 100.0, color_param, _value, color_value);
         ESP_LOGI(TAG, "hal write value [r:%d g:%d b:%d c:%d w:%d], channel_mask:%d fade_ms:%d", color_value[0], color_value[1], color_value[2], color_value[3], color_value[4], channel_mask, fade_time);
 
-        err = hal_set_channel_group(color_value, channel_mask, fade_time);
+        err |= hal_set_channel_group(color_value, channel_mask, fade_time);
         LIGHTBULB_CHECK(err == ESP_OK, "set hal channel group fail", goto EXIT);
 
         s_lb_obj->status.on = true;
@@ -1623,10 +1681,10 @@ esp_err_t lightbulb_set_cctb(uint16_t cct, uint8_t brightness)
         _brightness = process_white_brightness_limit(_brightness);
 
         // 2. convert to cold warm and redistribute power
-        cct_and_brightness_convert_and_power_limit(s_lb_obj->cap.led_beads, s_lb_obj->power.white_max_power / 100.0, cct, _brightness, white_value);
+        err |= cct_and_brightness_convert_and_power_limit(s_lb_obj->cap.led_beads, s_lb_obj->power.white_max_power / 100.0, cct, _brightness, white_value);
         ESP_LOGI(TAG, "hal write value [r:%d g:%d b:%d c:%d w:%d], channel_mask:%d fade_ms:%d", white_value[0], white_value[1], white_value[2], white_value[3], white_value[4], channel_mask, fade_time);
 
-        err = hal_set_channel_group(white_value, channel_mask, fade_time);
+        err |= hal_set_channel_group(white_value, channel_mask, fade_time);
         LIGHTBULB_CHECK(err == ESP_OK, "set hal channel group fail", goto EXIT);
 
         s_lb_obj->status.on = true;