From d1f3c92fd7deae8971c5510a13bba38a617c9639 Mon Sep 17 00:00:00 2001 From: Maurice Makaay Date: Sun, 28 Mar 2021 00:26:26 +0100 Subject: [PATCH] Added a white light implementation. Firmware is now in a broken state, but transitioning to something good here. --- light.py | 12 +- white_light.h | 119 +++++++++ yeelight_bs2_light_output.h | 487 +++++++++++++++--------------------- 3 files changed, 323 insertions(+), 295 deletions(-) create mode 100644 white_light.h diff --git a/light.py b/light.py index 3495429..74ce17d 100644 --- a/light.py +++ b/light.py @@ -28,19 +28,19 @@ def to_code(config): yield light.register_light(var, config) led_red = yield cg.get_variable(config[CONF_RED]) - cg.add(var.set_red(led_red)) + cg.add(var.set_red_output(led_red)) led_green = yield cg.get_variable(config[CONF_GREEN]) - cg.add(var.set_green(led_green)) + cg.add(var.set_green_output(led_green)) led_blue = yield cg.get_variable(config[CONF_BLUE]) - cg.add(var.set_blue(led_blue)) + cg.add(var.set_blue_output(led_blue)) led_white = yield cg.get_variable(config[CONF_WHITE]) - cg.add(var.set_white(led_white)) + cg.add(var.set_white_output(led_white)) master1 = yield cg.get_variable(config[CONF_MASTER1]) - cg.add(var.set_master1(master1)) + cg.add(var.set_master1_output(master1)) master2 = yield cg.get_variable(config[CONF_MASTER2]) - cg.add(var.set_master2(master2)) + cg.add(var.set_master2_output(master2)) diff --git a/white_light.h b/white_light.h new file mode 100644 index 0000000..b0f349e --- /dev/null +++ b/white_light.h @@ -0,0 +1,119 @@ +#pragma once + +#include +#include + +namespace esphome { +namespace rgbww { +namespace yeelight_bs2 { + +// Same range as supported by the original Yeelight firmware. +static const int MIRED_MAX = 153; +static const int MIRED_MIN = 588; + +struct RgbwLevelsByTemperature { + float from_temperature; + float red; + float green; + float blue; + float white; +}; + +using RgbwLevelsTable = std::array; + +static const RgbwLevelsTable rgbw_levels_1_ {{ + { 501.0f, 87.3f, 90.7f, 100.0f, 6.3f }, + { 455.0f, 87.3f, 89.6f, 100.0f, 6.3f }, + { 417.0f, 87.3f, 89.1f, 100.0f, 6.8f }, + { 371.0f, 87.3f, 88.0f, 100.0f, 7.0f }, + { 334.0f, 87.3f, 88.7f, 100.0f, 8.8f }, + { 313.0f, 88.2f, 90.4f, 100.0f, 12.8f }, + { 295.0f, 94.7f, 100.0f, 96.8f, 14.5f }, + { 251.0f, 99.9f, 100.0f, 100.0f, 15.5f }, + { 223.0f, 100.0f, 89.9f, 92.1f, 13.0f }, + { 201.0f, 100.0f, 87.3f, 90.8f, 11.5f }, + { 182.0f, 100.0f, 87.3f, 90.1f, 10.3f }, + { 173.0f, 100.0f, 87.3f, 90.4f, 9.4f }, + { 167.0f, 100.0f, 87.3f, 89.1f, 9.8f }, + { 154.0f, 100.0f, 87.3f, 89.4f, 9.0f }, + { 153.0f, 100.0f, 87.3f, 89.2f, 8.8f } +}}; + +static const RgbwLevelsTable rgbw_levels_100_ {{ + { 501.0f, 0.0f, 34.4f, 100.0f, 6.8f }, + { 455.0f, 0.0f, 23.7f, 100.0f, 9.3f }, + { 417.0f, 0.0f, 18.6f, 100.0f, 12.0f }, + { 371.0f, 0.0f, 14.9f, 100.0f, 16.7f }, + { 334.0f, 0.0f, 13.5f, 100.0f, 32.5f }, + { 313.0f, 9.7f, 31.4f, 100.0f, 74.0f }, + { 295.0f, 74.5f, 100.0f, 95.3f, 90.5f }, + { 251.0f, 100.0f, 100.0f, 100.0f, 100.0f }, + { 223.0f, 100.0f, 26.7f, 48.5f, 76.5f }, + { 201.0f, 100.0f, 0.0f, 35.5f, 60.9f }, + { 182.0f, 100.0f, 0.0f, 28.2f, 48.9f }, + { 173.0f, 100.0f, 0.0f, 31.3f, 39.2f }, + { 167.0f, 100.0f, 0.0f, 18.0f, 42.2f }, + { 154.0f, 100.0f, 0.0f, 21.8f, 36.8f }, + { 153.0f, 100.0f, 0.0f, 18.7f, 33.5f } +}}; + +class WhiteLight +{ +public: + float red = 0; + float green = 0; + float blue = 0; + float white = 0; + + void set_color(float temperature, float brightness) + { + temperature = clamp_temperature_(temperature); + brightness = clamp_brightness_(brightness); + + auto levels_1 = lookup_in_table_(rgbw_levels_1_, temperature); + auto levels_100 = lookup_in_table_(rgbw_levels_100_, temperature); + + red = interpolate_(levels_1.red, levels_100.red, brightness); + green = interpolate_(levels_1.green, levels_100.green, brightness); + blue = interpolate_(levels_1.blue, levels_100.blue, brightness); + white = interpolate_(levels_1.white, levels_100.white, brightness); + } + +protected: + float clamp_temperature_(float temperature) + { + if (temperature < MIRED_MAX) + temperature = MIRED_MAX; + else if (temperature > MIRED_MIN) + temperature = MIRED_MIN; + return temperature; + } + + float clamp_brightness_(float brightness) + { + if (brightness < 0.01f) + brightness = 0.01f; + else if (brightness > 1.00f) + brightness = 1.00f; + return brightness; + } + + RgbwLevelsByTemperature lookup_in_table_(RgbwLevelsTable table, float temperature) + { + for (RgbwLevelsByTemperature& item : table) + if (temperature >= item.from_temperature) + return item; + throw std::invalid_argument("received too low temperature"); + } + + float interpolate_(float level_1, float level_100, float brightness) + { + auto coefficient = (level_100 - level_1) / 0.99f; + auto level = level_1 + (brightness - 0.01f) * coefficient; + return level; + } +}; + +} // namespace yeelight_bs2 +} // namespace rgbww +} // namespace esphome diff --git a/yeelight_bs2_light_output.h b/yeelight_bs2_light_output.h index 5799dfb..9b11843 100644 --- a/yeelight_bs2_light_output.h +++ b/yeelight_bs2_light_output.h @@ -22,313 +22,222 @@ // not be a problem. #define TRANSITION_TO_OFF_BUGFIX -namespace esphome -{ - namespace rgbww - { - static const char *TAG = "yeelight_bs2.light"; +namespace esphome { +namespace rgbww { - // Same range as supported by the original Yeelight firmware. - static const int HOME_ASSISTANT_MIRED_MIN = 153; - static const int HOME_ASSISTANT_MIRED_MAX = 588; - - // The PWM frequency as used by the original device - // for driving the LED circuitry. - const float PWM_FREQUENCY = 3000.0f; + static const char *TAG = "yeelight_bs2.light"; - class YeelightBS2LightOutput : public Component, public light::LightOutput - { - public: - void set_red(ledc::LEDCOutput *red) { red_ = red; red_->set_frequency(PWM_FREQUENCY); } - void set_green(ledc::LEDCOutput *green) { green_ = green; green_->set_frequency(PWM_FREQUENCY); } - void set_blue(ledc::LEDCOutput *blue) { blue_ = blue; blue_->set_frequency(PWM_FREQUENCY); } - void set_white(ledc::LEDCOutput *white) { white_ = white; white_->set_frequency(PWM_FREQUENCY); } - void set_master1(gpio::GPIOBinaryOutput *master1) { master1_ = master1; } - void set_master2(gpio::GPIOBinaryOutput *master2) { master2_ = master2; } - - light::LightTraits get_traits() override - { - auto traits = light::LightTraits(); - traits.set_supports_rgb(true); - traits.set_supports_color_temperature(true); - traits.set_supports_brightness(true); - traits.set_supports_rgb_white_value(false); - traits.set_supports_color_interlock(true); - traits.set_min_mireds(HOME_ASSISTANT_MIRED_MIN); - traits.set_max_mireds(HOME_ASSISTANT_MIRED_MAX); - return traits; - } + // Same range as supported by the original Yeelight firmware. + static const int HOME_ASSISTANT_MIRED_MIN = 153; + static const int HOME_ASSISTANT_MIRED_MAX = 588; + + // The PWM frequencies as used by the original device + // for driving the LED circuitry. + const float RGB_PWM_FREQUENCY = 3000.0f; + const float WHITE_PWM_FREQUENCY = 10000.0f; - void write_state(light::LightState *state) override - { - auto values = state->current_values; + class YeelightBS2LightOutput : public Component, public light::LightOutput + { + public: + light::LightTraits get_traits() override + { + auto traits = light::LightTraits(); + traits.set_supports_rgb(true); + traits.set_supports_color_temperature(true); + traits.set_supports_brightness(true); + traits.set_supports_rgb_white_value(false); + traits.set_supports_color_interlock(true); + traits.set_min_mireds(HOME_ASSISTANT_MIRED_MIN); + traits.set_max_mireds(HOME_ASSISTANT_MIRED_MAX); + return traits; + } + + void set_red_output(ledc::LEDCOutput *red) { + red_ = red; + red_->set_frequency(RGB_PWM_FREQUENCY); + } + + void set_green_output(ledc::LEDCOutput *green) { + green_ = green; + green_->set_frequency(RGB_PWM_FREQUENCY); + } + + void set_blue_output(ledc::LEDCOutput *blue) { + blue_ = blue; + blue_->set_frequency(RGB_PWM_FREQUENCY); + } + + void set_white_output(ledc::LEDCOutput *white) { + white_ = white; + white_->set_frequency(WHITE_PWM_FREQUENCY); + } + + void set_master1_output(gpio::GPIOBinaryOutput *master1) { + master1_ = master1; + } + + void set_master2_output(gpio::GPIOBinaryOutput *master2) { + master2_ = master2; + } + + void write_state(light::LightState *state) override + { + auto values = state->current_values; - ESP_LOGD(TAG, "B = State %f, RGB %f %f %f, BRI %f, TEMP %f", - values.get_state(), - values.get_red(), values.get_green(), values.get_blue(), - values.get_brightness(), values.get_color_temperature()); + ESP_LOGD(TAG, "B = State %f, RGB %f %f %f, BRI %f, TEMP %f", + values.get_state(), + values.get_red(), values.get_green(), values.get_blue(), + values.get_brightness(), values.get_color_temperature()); - // Power down the light when its state is 'off'. - if (values.get_state() == 0) - { - this->turn_off_(); + // Power down the light when its state is 'off'. + if (values.get_state() == 0) + { + this->turn_off_(); #ifdef TRANSITION_TO_OFF_BUGFIX - previous_state_ = -1; - previous_brightness_ = 0; + previous_state_ = -1; + previous_brightness_ = 0; #endif - return; - } + return; + } - auto brightness = values.get_brightness(); + auto brightness = values.get_brightness(); #ifdef TRANSITION_TO_OFF_BUGFIX - // Remember the brightness that is used when the light is fully ON. - if (values.get_state() == 1) { - previous_brightness_ = brightness; - } - // When transitioning towards zero brightness ... - else if (values.get_state() < previous_state_) { - // ... check if the prevous brightness is the same as the current - // brightness. If yes, then the brightness isn't being scaled ... - if (previous_brightness_ == brightness) { - // ... and we need to do that ourselves. - brightness = values.get_state() * brightness; - } - } - previous_state_ = values.get_state(); -#endif - - // Leave it to the default tooling to figure out the basics. - // Because of the color interlocking, there are two possible outcomes: - // - red, green, blue zero -> the light is in color temperature mode - // - cwhite, wwhite zero -> the light is in RGB mode - float red, green, blue, cwhite, wwhite; - state->current_values_as_rgbww(&red, &green, &blue, &cwhite, &wwhite, true, false); - - if (cwhite > 0 || wwhite > 0) - { - this->turn_on_in_color_temperature_mode_( - values.get_color_temperature(), brightness); - } - else - { - // The RGB mode does not use the RGB values as determined by - // current_values_as_rgbww(). The device has LED driving circuitry - // that takes care of the required brightness curve while ramping up - // the brightness. Therefore, the actual RGB values are passed here. - this->turn_on_in_rgb_mode_( - values.get_red(), values.get_green(), values.get_blue(), - brightness, values.get_state()); + // Remember the brightness that is used when the light is fully ON. + if (values.get_state() == 1) { + previous_brightness_ = brightness; + } + // When transitioning towards zero brightness ... + else if (values.get_state() < previous_state_) { + // ... check if the prevous brightness is the same as the current + // brightness. If yes, then the brightness isn't being scaled ... + if (previous_brightness_ == brightness) { + // ... and we need to do that ourselves. + brightness = values.get_state() * brightness; } } - - protected: - ledc::LEDCOutput *red_; - ledc::LEDCOutput *green_; - ledc::LEDCOutput *blue_; - ledc::LEDCOutput *white_; - esphome::gpio::GPIOBinaryOutput *master1_; - esphome::gpio::GPIOBinaryOutput *master2_; -#ifdef TRANSITION_TO_OFF_BUGFIX - float previous_state_ = 1; - float previous_brightness_ = -1; + previous_state_ = values.get_state(); #endif - void turn_off_() - { - red_->set_level(1); - green_->set_level(1); - blue_->set_level(1); - white_->turn_off(); - master2_->turn_off(); - master1_->turn_off(); - } + // Leave it to the default tooling to figure out the basics. + // Because of the color interlocking, there are two possible outcomes: + // - red, green, blue zero -> the light is in color temperature mode + // - cwhite, wwhite zero -> the light is in RGB mode + float red, green, blue, cwhite, wwhite; + state->current_values_as_rgbww(&red, &green, &blue, &cwhite, &wwhite, true, false); - void turn_on_in_rgb_mode_(float red, float green, float blue, float brightness, float state) + if (cwhite > 0 || wwhite > 0) { - ESP_LOGD(TAG, "Activate RGB %f, %f, %f, BRIGHTNESS %f", red, green, blue, brightness); - - // The brightness must be at least 3/100 to light up the LEDs. - // During transitions (where state is a fraction between 0 and 1, - // indicating the transition progress) we don't apply this to - // get smoother transitioning when turning on the light. - if (state == 1 && brightness < 0.03f) - brightness = 0.03f; - - // Apply proper color mixing around the RGB white point. - // Overall, the RGB colors are very usable when simply scaling the - // RGB channels with the brightness, but around the white point, - // the color is a bit on the red side of the spectrum. The following - // scaling was created to fix that. - // RGBW 0.432451, 0.013149, 0.556678 - // R 0.57 g 1 b 0.45 - auto red_w = (0.07f + brightness*(0.57f - 0.07f)) * red; - auto green_w = (0.13f + brightness*(1.00f - 0.13f)) * green; - auto blue_w = (0.06f + brightness*(0.45f - 0.06f)) * blue; - - // For other colors, we can simply scale the RGB channels with the - // requested brightness, resulting in a very usable color. Not 100% - // the same as the original firmware, but sometimes even better IMO. - auto red_c = red * brightness; - auto green_c = green * brightness; - auto blue_c = blue * brightness; - - // The actual RGB values are a weighed mix of the above two. - // The closer to the white point, the more the white point - // value applies. - auto level_red = (red_w * ((green+blue)/2)) + (red_c * (1-(green+blue)/2)); - auto level_green = (green_w * ((red+blue)/2)) + (green_c * (1-(red+blue)/2)); - auto level_blue = (blue_w * ((red+green)/2)) + (blue_c * (1-(red+green)/2)); - - // Invert the signal. The LEDs in the lamp's circuit are brighter - // when the pwm levels on the GPIO pins are lower. - level_red = 1.0f - level_red; - level_green = 1.0f - level_green; - level_blue = 1.0f - level_blue; - - ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f, off", level_red, level_green, level_blue); - - // Drive the LEDs. - master2_->turn_on(); - master1_->turn_on(); - red_->set_level(level_red); - green_->set_level(level_green); - blue_->set_level(level_blue); - white_->turn_off(); + turn_on_in_white_mode_(values.get_color_temperature(), brightness); } - - void turn_on_in_color_temperature_mode_(float temperature, float brightness) + else { - ESP_LOGD(TAG, "Activate TEMPERATURE %f, BRIGHTNESS %f", temperature, brightness); - - // Empirically determined during programming the temperature GPIO output - // code from below, by checking how far my outputs were off from the - // original lamp firmeware's outputs. This scaler is used for correcting - // my output towards the original output. - float scaler; - - float red = 1.0; - float green = 1.0; - float blue = 1.0; - float white = 1.0; - - // Temperature band 370 - 588 - if (temperature <= HOME_ASSISTANT_MIRED_MAX && temperature >= 371) - { - scaler = 3.23f; - - float start = 371; - float end = 588; - float band = end - start; - - float red_volt = 2.86f * (1.0f - brightness); - red = red_volt / scaler; - - float green_1 = 2.90f + (temperature - start) * (2.97f - 2.90f) / band; - float green_100 = 0.45f + (temperature - start) * (1.13f - 0.45f) / band; - float green_volt = green_1 + brightness * (green_100 - green_1); - green = green_volt / scaler; - - float white_1 = 0.28f - (temperature - start) * (0.28f - 0.19f) / band; - float white_100 = 1.07f - (temperature - start) * (1.07f - 0.22f) / band; - float white_volt = white_1 + brightness * (white_100 - white_1); - white = white_volt / scaler; - } - // Temperature band 334 - 370 - else if (temperature >= 334) - { - scaler = 3.23f; - - float red_volt = (1.0f - brightness) * 2.86f; - red = red_volt / scaler; - - float green_volt = 2.9f - brightness * (2.9f - 0.45f); - green = green_volt / scaler; - - float white_volt = 0.28f + brightness * (1.07f - 0.28f); - white = white_volt / scaler; - } - // Temperature band 313 - 333 - // - // The light becomes noticably brighter when moving from temperature 334 to - // temperature 333. There's a little jump in the lighting output here. - // Possibly this is a switch from warm to cold lighting as imposed by the - // LED circuitry, making this unavoidable. However, it would be interesting - // to see if we can smoothen this out. - // BTW: This behavior is in sync with the original firmware. - else if (temperature >= 313) - { - scaler = 3.23f; - - float red_volt = 2.89f - brightness * (2.89f - 0.32f); - red = red_volt / scaler; - - float green_volt = 2.96f - brightness * (2.96f - 1.03f); - green = green_volt / scaler; - - float white_volt = 0.42f + brightness * (2.43f - 0.42f); - float scaler_white = 3.45f; - white = white_volt / scaler_white; - } - // Temperature band 251 - 312 - else if (temperature >= 251) - { - scaler = 3.48f; - - float white_correction = 1.061; - float white_volt = 0.5f + brightness * (3.28f * white_correction - 0.5f); - white = white_volt / scaler; - } - // Temperature band 223 - 250 - else if (temperature >= 223) - { - scaler = 3.25f; - - float green_volt = 2.94f - brightness * (2.94f - 0.88f); - green = green_volt / scaler; - - float blue_volt = 3.02f - brightness * (3.02f - 1.59f); - blue = blue_volt / scaler; - - float white_correction = 1.024f; - float white_volt = 0.42f + brightness * (2.51f * white_correction - 0.42f); - float scaler_white = 3.36f; - white = white_volt / scaler_white; - } - // Temperature band 153 - 222 - else if (temperature >= HOME_ASSISTANT_MIRED_MIN) - { - float start = 153; - float end = 222; - float band = end - start; - - scaler = 3.23f; - - float green_volt = 2.86f - brightness * 2.86f; - green = green_volt / scaler; - - float blue_1 = 2.92f + (temperature - start) * (2.97f - 2.92f) / band; - float blue_100 = 0.62f + (temperature - start) * (1.17f - 0.62f) / band; - float blue_volt = blue_1 - brightness * (blue_1 - blue_100); - blue = blue_volt / scaler; - - float white_1 = 0.28f + (temperature - start) * (0.37f - 0.28f) / band; - float white_100 = 1.1f + (temperature - start) * (2.0f - 1.1f) / band; - float white_volt = white_1 + brightness * (white_100 - white_1); - float scaler_white = 3.27f; - white = white_volt / scaler_white; - } - - ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f, %f", red, green, blue, white); - - master2_->turn_on(); - master1_->turn_on(); - red_->set_level(red); - green_->set_level(green); - blue_->set_level(blue); - white_->set_level(white); + // The RGB mode does not use the RGB values as determined by + // current_values_as_rgbww(). The device has LED driving circuitry + // that takes care of the required brightness curve while ramping up + // the brightness. Therefore, the actual RGB values are passed here. + turn_on_in_rgb_mode_( + values.get_red(), values.get_green(), values.get_blue(), + brightness, values.get_state()); } - }; + } + + protected: + ledc::LEDCOutput *red_; + ledc::LEDCOutput *green_; + ledc::LEDCOutput *blue_; + ledc::LEDCOutput *white_; + esphome::gpio::GPIOBinaryOutput *master1_; + esphome::gpio::GPIOBinaryOutput *master2_; + esphome::rgbww::yeelight_bs2::WhiteLight white_light_; +#ifdef TRANSITION_TO_OFF_BUGFIX + float previous_state_ = 1; + float previous_brightness_ = -1; +#endif - } // namespace rgbww + void turn_off_() + { + red_->set_level(1); + green_->set_level(1); + blue_->set_level(1); + white_->turn_off(); + master2_->turn_off(); + master1_->turn_off(); + } + + void turn_on_in_rgb_mode_(float red, float green, float blue, float brightness, float state) + { + ESP_LOGD(TAG, "Activate RGB %f, %f, %f, BRIGHTNESS %f", red, green, blue, brightness); + + // The brightness must be at least 3/100 to light up the LEDs. + // During transitions (where state is a fraction between 0 and 1, + // indicating the transition progress) we don't apply this to + // get smoother transitioning when turning on the light. + if (state == 1 && brightness < 0.03f) + brightness = 0.03f; + + // Apply proper color mixing around the RGB white point. + // Overall, the RGB colors are very usable when simply scaling the + // RGB channels with the brightness, but around the white point, + // the color is a bit on the red side of the spectrum. The following + // scaling was created to fix that. + // RGBW 0.432451, 0.013149, 0.556678 + // R 0.57 g 1 b 0.45 + auto red_w = (0.07f + brightness*(0.57f - 0.07f)) * red; + auto green_w = (0.13f + brightness*(1.00f - 0.13f)) * green; + auto blue_w = (0.06f + brightness*(0.45f - 0.06f)) * blue; + + // For other colors, we can simply scale the RGB channels with the + // requested brightness, resulting in a very usable color. Not 100% + // the same as the original firmware, but sometimes even better IMO. + auto red_c = red * brightness; + auto green_c = green * brightness; + auto blue_c = blue * brightness; + + // The actual RGB values are a weighed mix of the above two. + // The closer to the white point, the more the white point + // value applies. + auto level_red = (red_w * ((green+blue)/2)) + (red_c * (1-(green+blue)/2)); + auto level_green = (green_w * ((red+blue)/2)) + (green_c * (1-(red+blue)/2)); + auto level_blue = (blue_w * ((red+green)/2)) + (blue_c * (1-(red+green)/2)); + + // Invert the signal. The LEDs in the lamp's circuit are brighter + // when the pwm levels on the GPIO pins are lower. + level_red = 1.0f - level_red; + level_green = 1.0f - level_green; + level_blue = 1.0f - level_blue; + + ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f, off", level_red, level_green, level_blue); + + // Drive the LEDs. + master2_->turn_on(); + master1_->turn_on(); + red_->set_level(level_red); + green_->set_level(level_green); + blue_->set_level(level_blue); + white_->turn_off(); + } + + void turn_on_in_white_mode_(float temperature, float brightness) + { + ESP_LOGD(TAG, "Activate TEMPERATURE %f, BRIGHTNESS %f", + temperature, brightness); + + white_light_.set_color(temperature, brightness); + + ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f, %f", + white_light_.red, white_light_.green, white_light_.blue, + white_light_.white); + + master2_->turn_on(); + master1_->turn_on(); + red_->set_level(white_light_.red); + green_->set_level(white_light_.green); + blue_->set_level(white_light_.blue); + white_->turn_on(); + white_->set_level(white_light_.white); + } + }; + +} // namespace rgbww } // namespace esphome