#pragma once #include "esphome/core/component.h" #include "esphome/components/ledc/ledc_output.h" #include "esphome/components/light/light_output.h" #include "esphome/components/gpio/output/gpio_binary_output.h" // What seems to be a bug in ESPHome transitioning: when turning on // the device, the brightness is scaled along with the state (which // runs from 0 to 1), but when turning off the device, the brightness // is kept the same while the state goes down from 1 to 0. As a result // when turning off the lamp with a transition time of 1s, the light // stays on for 1s and then turn itself off abruptly. // // Reported the issue + fix at: // https://github.com/esphome/esphome/pull/1643 // // A work-around for this issue can be enabled using this define: #define TRANSITION_TO_OFF_BUGFIX //#define YEELIGHT_DEBUG_LOG namespace esphome { namespace rgbww { static const char *TAG = "yeelight_bs2.light"; // 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; 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; } void write_state(light::LightState *state) override { auto values = state->current_values; #ifdef YEELIGHT_DEBUG_LOG 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()); #endif // Power down the light when its state is 'off'. if (values.get_state() == 0) { this->turn_off_(); #ifdef YEELIGHT_DEBUG_LOG previous_state_ = -1; previous_brightness_ = 0; #endif return; } 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()); } } 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; #endif void turn_off_() { // Using set_level() calls for the RGB GPIOs, and not // turn_off(), because turn_off() causes some unwanted // flashing when powering off at low brightness. red_->set_level(1); green_->set_level(1); blue_->set_level(1); white_->turn_off(); master1_->turn_off(); master2_->turn_off(); } void turn_on_in_rgb_mode_(float red, float green, float blue, float brightness, float state) { #ifdef YEELIGHT_DEBUG_LOG ESP_LOGD(TAG, "Activate RGB %f, %f, %f, BRIGHTNESS %f", red, green, blue, brightness); #endif // 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 brightness. red = red * brightness; green = green * brightness; blue = blue * brightness; // Inverse the signal. The LEDs in the lamp's circuit are brighter // when the pwm levels on the GPIO pins are lower. red = 1.0f - red; green = 1.0f - green; blue = 1.0f - blue; #ifdef YEELIGHT_DEBUG_LOG ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f", red, green, blue); #endif // Drive the LEDs. red_->set_level(red); green_->set_level(green); blue_->set_level(blue); white_->turn_off(); master1_->turn_on(); master2_->turn_on(); } void turn_on_in_color_temperature_mode_(float temperature, float brightness) { #ifdef YEELIGHT_DEBUG_LOG ESP_LOGD(TAG, "Activate TEMPERATURE %f, BRIGHTNESS %f", temperature, brightness); #endif // 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; } #ifdef YEELIGHT_DEBUG_LOG ESP_LOGD(TAG, "New LED state : RGBW %f, %f, %f, %f", red, green, blue, white); #endif red_->set_level(red); green_->set_level(green); blue_->set_level(blue); white_->set_level(white); master2_->turn_on(); master1_->turn_on(); } }; } // namespace rgbww } // namespace esphome