jeans/esphome
jeans/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-08-07 10:57:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce light component memory usage by 50+ bytes per instance

Browse Source
This commit is contained in:
J. Nick Koston 2025-07-05 12:33:54 -05:00
parent 4e9e48e2e7
commit 0f3e6cccd9
No known key found for this signature in database
7 changed files with 238 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
esphome/components/light/addressable_light.h
View File

@ -97,12 +97,12 @@ class AddressableLight : public LightOutput, public Component {
} }
virtual ESPColorView get_view_internal(int32_t index) const = 0; virtual ESPColorView get_view_internal(int32_t index) const = 0;
bool effect_active_{false};
ESPColorCorrection correction_{}; ESPColorCorrection correction_{};
LightState *state_parent_{nullptr};
#ifdef USE_POWER_SUPPLY #ifdef USE_POWER_SUPPLY
power_supply::PowerSupplyRequester power_; power_supply::PowerSupplyRequester power_;
#endif #endif
LightState *state_parent_{nullptr}; bool effect_active_{false};
}; };
class AddressableLightTransformer : public LightTransitionTransformer { class AddressableLightTransformer : public LightTransitionTransformer {
@ -114,9 +114,9 @@ class AddressableLightTransformer : public LightTransitionTransformer {
protected: protected:
AddressableLight &light_; AddressableLight &light_;
Color target_color_{};
float last_transition_progress_{0.0f}; float last_transition_progress_{0.0f};
float accumulated_alpha_{0.0f}; float accumulated_alpha_{0.0f};
Color target_color_{};
}; };
} // namespace light } // namespace light

2
esphome/components/light/esp_color_correction.h
View File

@ -69,8 +69,8 @@ class ESPColorCorrection {
protected: protected:
uint8_t gamma_table_[256]; uint8_t gamma_table_[256];
uint8_t gamma_reverse_table_[256]; uint8_t gamma_reverse_table_[256];
uint8_t local_brightness_{255};
Color max_brightness_; Color max_brightness_;
uint8_t local_brightness_{255};
}; };
} // namespace light } // namespace light

379
esphome/components/light/light_call.cpp
View File

@ -2,12 +2,28 @@
#include "light_call.h" #include "light_call.h"
#include "light_state.h" #include "light_state.h"
#include "esphome/core/log.h" #include "esphome/core/log.h"
#include "esphome/core/optional.h"
namespace esphome { namespace esphome {
namespace light { namespace light {
static const char *const TAG = "light"; static const char *const TAG = "light";
// Macro to reduce repetitive setter code
#define IMPLEMENT_LIGHT_CALL_SETTER(name, type, flag) \
LightCall &LightCall::set_##name(optional<type> name) { \
if (name.has_value()) { \
this->name##_ = name.value(); \
} \
this->set_flag_(flag, name.has_value()); \
return *this; \
} \
LightCall &LightCall::set_##name(type name) { \
this->name##_ = name; \
this->set_flag_(flag, true); \
return *this; \
}
static const LogString *color_mode_to_human(ColorMode color_mode) { static const LogString *color_mode_to_human(ColorMode color_mode) {
if (color_mode == ColorMode::UNKNOWN) if (color_mode == ColorMode::UNKNOWN)
return LOG_STR("Unknown"); return LOG_STR("Unknown");
@ -32,41 +48,43 @@ void LightCall::perform() {
const char *name = this->parent_->get_name().c_str(); const char *name = this->parent_->get_name().c_str();
LightColorValues v = this->validate_(); LightColorValues v = this->validate_();
if (this->publish_) { if (this->get_publish_()) {
ESP_LOGD(TAG, "'%s' Setting:", name); ESP_LOGD(TAG, "'%s' Setting:", name);
// Only print color mode when it's being changed // Only print color mode when it's being changed
ColorMode current_color_mode = this->parent_->remote_values.get_color_mode(); ColorMode current_color_mode = this->parent_->remote_values.get_color_mode();
if (this->color_mode_.value_or(current_color_mode) != current_color_mode) { ColorMode target_color_mode = this->has_color_mode() ? this->color_mode_ : current_color_mode;
if (target_color_mode != current_color_mode) {
ESP_LOGD(TAG, " Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode()))); ESP_LOGD(TAG, " Color mode: %s", LOG_STR_ARG(color_mode_to_human(v.get_color_mode())));
} }
// Only print state when it's being changed // Only print state when it's being changed
bool current_state = this->parent_->remote_values.is_on(); bool current_state = this->parent_->remote_values.is_on();
if (this->state_.value_or(current_state) != current_state) { bool target_state = this->has_state() ? this->state_ : current_state;
if (target_state != current_state) {
ESP_LOGD(TAG, " State: %s", ONOFF(v.is_on())); ESP_LOGD(TAG, " State: %s", ONOFF(v.is_on()));
} }
if (this->brightness_.has_value()) { if (this->has_brightness()) {
ESP_LOGD(TAG, " Brightness: %.0f%%", v.get_brightness() * 100.0f); ESP_LOGD(TAG, " Brightness: %.0f%%", v.get_brightness() * 100.0f);
} }
if (this->color_brightness_.has_value()) { if (this->has_color_brightness()) {
ESP_LOGD(TAG, " Color brightness: %.0f%%", v.get_color_brightness() * 100.0f); ESP_LOGD(TAG, " Color brightness: %.0f%%", v.get_color_brightness() * 100.0f);
} }
if (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()) { if (this->has_red() || this->has_green() || this->has_blue()) {
ESP_LOGD(TAG, " Red: %.0f%%, Green: %.0f%%, Blue: %.0f%%", v.get_red() * 100.0f, v.get_green() * 100.0f, ESP_LOGD(TAG, " Red: %.0f%%, Green: %.0f%%, Blue: %.0f%%", v.get_red() * 100.0f, v.get_green() * 100.0f,
v.get_blue() * 100.0f); v.get_blue() * 100.0f);
} }
if (this->white_.has_value()) { if (this->has_white()) {
ESP_LOGD(TAG, " White: %.0f%%", v.get_white() * 100.0f); ESP_LOGD(TAG, " White: %.0f%%", v.get_white() * 100.0f);
} }
if (this->color_temperature_.has_value()) { if (this->has_color_temperature()) {
ESP_LOGD(TAG, " Color temperature: %.1f mireds", v.get_color_temperature()); ESP_LOGD(TAG, " Color temperature: %.1f mireds", v.get_color_temperature());
} }
if (this->cold_white_.has_value() || this->warm_white_.has_value()) { if (this->has_cold_white() || this->has_warm_white()) {
ESP_LOGD(TAG, " Cold white: %.0f%%, warm white: %.0f%%", v.get_cold_white() * 100.0f, ESP_LOGD(TAG, " Cold white: %.0f%%, warm white: %.0f%%", v.get_cold_white() * 100.0f,
v.get_warm_white() * 100.0f); v.get_warm_white() * 100.0f);
} }
@ -74,58 +92,57 @@ void LightCall::perform() {
if (this->has_flash_()) { if (this->has_flash_()) {
// FLASH // FLASH
if (this->publish_) { if (this->get_publish_()) {
ESP_LOGD(TAG, " Flash length: %.1fs", *this->flash_length_ / 1e3f); ESP_LOGD(TAG, " Flash length: %.1fs", this->flash_length_ / 1e3f);
} }
this->parent_->start_flash_(v, *this->flash_length_, this->publish_); this->parent_->start_flash_(v, this->flash_length_, this->get_publish_());
} else if (this->has_transition_()) { } else if (this->has_transition_()) {
// TRANSITION // TRANSITION
if (this->publish_) { if (this->get_publish_()) {
ESP_LOGD(TAG, " Transition length: %.1fs", *this->transition_length_ / 1e3f); ESP_LOGD(TAG, " Transition length: %.1fs", this->transition_length_ / 1e3f);
} }
// Special case: Transition and effect can be set when turning off // Special case: Transition and effect can be set when turning off
if (this->has_effect_()) { if (this->has_effect_()) {
if (this->publish_) { if (this->get_publish_()) {
ESP_LOGD(TAG, " Effect: 'None'"); ESP_LOGD(TAG, " Effect: 'None'");
} }
this->parent_->stop_effect_(); this->parent_->stop_effect_();
} }
this->parent_->start_transition_(v, *this->transition_length_, this->publish_); this->parent_->start_transition_(v, this->transition_length_, this->get_publish_());
} else if (this->has_effect_()) { } else if (this->has_effect_()) {
// EFFECT // EFFECT
auto effect = this->effect_;
const char *effect_s; const char *effect_s;
if (effect == 0u) { if (this->effect_ == 0u) {
effect_s = "None"; effect_s = "None";
} else { } else {
effect_s = this->parent_->effects_[*this->effect_ - 1]->get_name().c_str(); effect_s = this->parent_->effects_[this->effect_ - 1]->get_name().c_str();
} }
if (this->publish_) { if (this->get_publish_()) {
ESP_LOGD(TAG, " Effect: '%s'", effect_s); ESP_LOGD(TAG, " Effect: '%s'", effect_s);
} }
this->parent_->start_effect_(*this->effect_); this->parent_->start_effect_(this->effect_);
// Also set light color values when starting an effect // Also set light color values when starting an effect
// For example to turn off the light // For example to turn off the light
this->parent_->set_immediately_(v, true); this->parent_->set_immediately_(v, true);
} else { } else {
// INSTANT CHANGE // INSTANT CHANGE
this->parent_->set_immediately_(v, this->publish_); this->parent_->set_immediately_(v, this->get_publish_());
} }
if (!this->has_transition_()) { if (!this->has_transition_()) {
this->parent_->target_state_reached_callback_.call(); this->parent_->target_state_reached_callback_.call();
} }
if (this->publish_) { if (this->get_publish_()) {
this->parent_->publish_state(); this->parent_->publish_state();
} }
if (this->save_) { if (this->get_save_()) {
this->parent_->save_remote_values_(); this->parent_->save_remote_values_();
} }
} }
@ -135,82 +152,80 @@ LightColorValues LightCall::validate_() {
auto traits = this->parent_->get_traits(); auto traits = this->parent_->get_traits();
// Color mode check // Color mode check
if (this->color_mode_.has_value() && !traits.supports_color_mode(this->color_mode_.value())) { if (this->has_color_mode() && !traits.supports_color_mode(this->color_mode_)) {
ESP_LOGW(TAG, "'%s' does not support color mode %s", name, ESP_LOGW(TAG, "'%s' does not support color mode %s", name, LOG_STR_ARG(color_mode_to_human(this->color_mode_)));
LOG_STR_ARG(color_mode_to_human(this->color_mode_.value()))); this->set_flag_(FLAG_HAS_COLOR_MODE, false);
this->color_mode_.reset();
} }
// Ensure there is always a color mode set // Ensure there is always a color mode set
if (!this->color_mode_.has_value()) { if (!this->has_color_mode()) {
this->color_mode_ = this->compute_color_mode_(); this->color_mode_ = this->compute_color_mode_();
this->set_flag_(FLAG_HAS_COLOR_MODE, true);
} }
auto color_mode = *this->color_mode_; auto color_mode = this->color_mode_;
// Transform calls that use non-native parameters for the current mode. // Transform calls that use non-native parameters for the current mode.
this->transform_parameters_(); this->transform_parameters_();
// Brightness exists check // Brightness exists check
if (this->brightness_.has_value() && *this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) { if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
ESP_LOGW(TAG, "'%s': setting brightness not supported", name); ESP_LOGW(TAG, "'%s': setting brightness not supported", name);
this->brightness_.reset(); this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
} }
// Transition length possible check // Transition length possible check
if (this->transition_length_.has_value() && *this->transition_length_ != 0 && if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
!(color_mode & ColorCapability::BRIGHTNESS)) {
ESP_LOGW(TAG, "'%s': transitions not supported", name); ESP_LOGW(TAG, "'%s': transitions not supported", name);
this->transition_length_.reset(); this->set_flag_(FLAG_HAS_TRANSITION, false);
} }
// Color brightness exists check // Color brightness exists check
if (this->color_brightness_.has_value() && *this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) { if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
ESP_LOGW(TAG, "'%s': color mode does not support setting RGB brightness", name); ESP_LOGW(TAG, "'%s': color mode does not support setting RGB brightness", name);
this->color_brightness_.reset(); this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
} }
// RGB exists check // RGB exists check
if ((this->red_.has_value() && *this->red_ > 0.0f) || (this->green_.has_value() && *this->green_ > 0.0f) || if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
(this->blue_.has_value() && *this->blue_ > 0.0f)) { (this->has_blue() && this->blue_ > 0.0f)) {
if (!(color_mode & ColorCapability::RGB)) { if (!(color_mode & ColorCapability::RGB)) {
ESP_LOGW(TAG, "'%s': color mode does not support setting RGB color", name); ESP_LOGW(TAG, "'%s': color mode does not support setting RGB color", name);
this->red_.reset(); this->set_flag_(FLAG_HAS_RED, false);
this->green_.reset(); this->set_flag_(FLAG_HAS_GREEN, false);
this->blue_.reset(); this->set_flag_(FLAG_HAS_BLUE, false);
} }
} }
// White value exists check // White value exists check
if (this->white_.has_value() && *this->white_ > 0.0f && if (this->has_white() && this->white_ > 0.0f &&
!(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) { !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
ESP_LOGW(TAG, "'%s': color mode does not support setting white value", name); ESP_LOGW(TAG, "'%s': color mode does not support setting white value", name);
this->white_.reset(); this->set_flag_(FLAG_HAS_WHITE, false);
} }
// Color temperature exists check // Color temperature exists check
if (this->color_temperature_.has_value() && if (this->has_color_temperature() &&
!(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) { !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
ESP_LOGW(TAG, "'%s': color mode does not support setting color temperature", name); ESP_LOGW(TAG, "'%s': color mode does not support setting color temperature", name);
this->color_temperature_.reset(); this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
} }
// Cold/warm white value exists check // Cold/warm white value exists check
if ((this->cold_white_.has_value() && *this->cold_white_ > 0.0f) || if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
(this->warm_white_.has_value() && *this->warm_white_ > 0.0f)) {
if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) { if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
ESP_LOGW(TAG, "'%s': color mode does not support setting cold/warm white value", name); ESP_LOGW(TAG, "'%s': color mode does not support setting cold/warm white value", name);
this->cold_white_.reset(); this->set_flag_(FLAG_HAS_COLD_WHITE, false);
this->warm_white_.reset(); this->set_flag_(FLAG_HAS_WARM_WHITE, false);
} }
} }
#define VALIDATE_RANGE_(name_, upper_name, min, max) \ #define VALIDATE_RANGE_(name_, upper_name, min, max) \
if (name_##_.has_value()) { \ if (this->has_##name_()) { \
auto val = *name_##_; \ auto val = this->name_##_; \
if (val < (min) || val > (max)) { \ if (val < (min) || val > (max)) { \
ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_LITERAL(upper_name), val, \ ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_LITERAL(upper_name), val, \
(min), (max)); \ (min), (max)); \
name_##_ = clamp(val, (min), (max)); \ this->name_##_ = clamp(val, (min), (max)); \
} \ } \
} }
#define VALIDATE_RANGE(name, upper_name) VALIDATE_RANGE_(name, upper_name, 0.0f, 1.0f) #define VALIDATE_RANGE(name, upper_name) VALIDATE_RANGE_(name, upper_name, 0.0f, 1.0f)
@ -227,110 +242,116 @@ LightColorValues LightCall::validate_() {
VALIDATE_RANGE_(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds()) VALIDATE_RANGE_(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
// Flag whether an explicit turn off was requested, in which case we'll also stop the effect. // Flag whether an explicit turn off was requested, in which case we'll also stop the effect.
bool explicit_turn_off_request = this->state_.has_value() && !*this->state_; bool explicit_turn_off_request = this->has_state() && !this->state_;
// Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on). // Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on).
if (this->brightness_.has_value() && *this->brightness_ == 0.0f) { if (this->has_brightness() && this->brightness_ == 0.0f) {
this->state_ = optional<float>(false); this->state_ = false;
this->brightness_ = optional<float>(1.0f); this->set_flag_(FLAG_HAS_STATE, true);
this->brightness_ = 1.0f;
} }
// Set color brightness to 100% if currently zero and a color is set. // Set color brightness to 100% if currently zero and a color is set.
if (this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()) { if (this->has_red() || this->has_green() || this->has_blue()) {
if (!this->color_brightness_.has_value() && this->parent_->remote_values.get_color_brightness() == 0.0f) if (!this->has_color_brightness() && this->parent_->remote_values.get_color_brightness() == 0.0f) {
this->color_brightness_ = optional<float>(1.0f); this->color_brightness_ = 1.0f;
this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, true);
}
} }
// Create color values for the light with this call applied. // Create color values for the light with this call applied.
auto v = this->parent_->remote_values; auto v = this->parent_->remote_values;
if (this->color_mode_.has_value()) if (this->has_color_mode())
v.set_color_mode(*this->color_mode_); v.set_color_mode(this->color_mode_);
if (this->state_.has_value()) if (this->has_state())
v.set_state(*this->state_); v.set_state(this->state_);
if (this->brightness_.has_value()) if (this->has_brightness())
v.set_brightness(*this->brightness_); v.set_brightness(this->brightness_);
if (this->color_brightness_.has_value()) if (this->has_color_brightness())
v.set_color_brightness(*this->color_brightness_); v.set_color_brightness(this->color_brightness_);
if (this->red_.has_value()) if (this->has_red())
v.set_red(*this->red_); v.set_red(this->red_);
if (this->green_.has_value()) if (this->has_green())
v.set_green(*this->green_); v.set_green(this->green_);
if (this->blue_.has_value()) if (this->has_blue())
v.set_blue(*this->blue_); v.set_blue(this->blue_);
if (this->white_.has_value()) if (this->has_white())
v.set_white(*this->white_); v.set_white(this->white_);
if (this->color_temperature_.has_value()) if (this->has_color_temperature())
v.set_color_temperature(*this->color_temperature_); v.set_color_temperature(this->color_temperature_);
if (this->cold_white_.has_value()) if (this->has_cold_white())
v.set_cold_white(*this->cold_white_); v.set_cold_white(this->cold_white_);
if (this->warm_white_.has_value()) if (this->has_warm_white())
v.set_warm_white(*this->warm_white_); v.set_warm_white(this->warm_white_);
v.normalize_color(); v.normalize_color();
// Flash length check // Flash length check
if (this->has_flash_() && *this->flash_length_ == 0) { if (this->has_flash_() && this->flash_length_ == 0) {
ESP_LOGW(TAG, "'%s': flash length must be greater than zero", name); ESP_LOGW(TAG, "'%s': flash length must be greater than zero", name);
this->flash_length_.reset(); this->set_flag_(FLAG_HAS_FLASH, false);
} }
// validate transition length/flash length/effect not used at the same time // validate transition length/flash length/effect not used at the same time
bool supports_transition = color_mode & ColorCapability::BRIGHTNESS; bool supports_transition = color_mode & ColorCapability::BRIGHTNESS;
// If effect is already active, remove effect start // If effect is already active, remove effect start
if (this->has_effect_() && *this->effect_ == this->parent_->active_effect_index_) { if (this->has_effect_() && this->effect_ == this->parent_->active_effect_index_) {
this->effect_.reset(); this->set_flag_(FLAG_HAS_EFFECT, false);
} }
// validate effect index // validate effect index
if (this->has_effect_() && *this->effect_ > this->parent_->effects_.size()) { if (this->has_effect_() && this->effect_ > this->parent_->effects_.size()) {
ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, *this->effect_); ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, this->effect_);
this->effect_.reset(); this->set_flag_(FLAG_HAS_EFFECT, false);
} }
if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) { if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
ESP_LOGW(TAG, "'%s': effect cannot be used with transition/flash", name); ESP_LOGW(TAG, "'%s': effect cannot be used with transition/flash", name);
this->transition_length_.reset(); this->set_flag_(FLAG_HAS_TRANSITION, false);
this->flash_length_.reset(); this->set_flag_(FLAG_HAS_FLASH, false);
} }
if (this->has_flash_() && this->has_transition_()) { if (this->has_flash_() && this->has_transition_()) {
ESP_LOGW(TAG, "'%s': flash cannot be used with transition", name); ESP_LOGW(TAG, "'%s': flash cannot be used with transition", name);
this->transition_length_.reset(); this->set_flag_(FLAG_HAS_TRANSITION, false);
} }
if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || *this->effect_ == 0) && if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || this->effect_ == 0) &&
supports_transition) { supports_transition) {
// nothing specified and light supports transitions, set default transition length // nothing specified and light supports transitions, set default transition length
this->transition_length_ = this->parent_->default_transition_length_; this->transition_length_ = this->parent_->default_transition_length_;
this->set_flag_(FLAG_HAS_TRANSITION, true);
} }
if (this->transition_length_.value_or(0) == 0) { if (this->has_transition_() && this->transition_length_ == 0) {
// 0 transition is interpreted as no transition (instant change) // 0 transition is interpreted as no transition (instant change)
this->transition_length_.reset(); this->set_flag_(FLAG_HAS_TRANSITION, false);
} }
if (this->has_transition_() && !supports_transition) { if (this->has_transition_() && !supports_transition) {
ESP_LOGW(TAG, "'%s': transitions not supported", name); ESP_LOGW(TAG, "'%s': transitions not supported", name);
this->transition_length_.reset(); this->set_flag_(FLAG_HAS_TRANSITION, false);
} }
// If not a flash and turning the light off, then disable the light // If not a flash and turning the light off, then disable the light
// Do not use light color values directly, so that effects can set 0% brightness // Do not use light color values directly, so that effects can set 0% brightness
// Reason: When user turns off the light in frontend, the effect should also stop // Reason: When user turns off the light in frontend, the effect should also stop
if (!this->has_flash_() && !this->state_.value_or(v.is_on())) { bool target_state = this->has_state() ? this->state_ : v.is_on();
if (!this->has_flash_() && !target_state) {
if (this->has_effect_()) { if (this->has_effect_()) {
ESP_LOGW(TAG, "'%s': cannot start effect when turning off", name); ESP_LOGW(TAG, "'%s': cannot start effect when turning off", name);
this->effect_.reset(); this->set_flag_(FLAG_HAS_EFFECT, false);
} else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) { } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
// Auto turn off effect // Auto turn off effect
this->effect_ = 0; this->effect_ = 0;
this->set_flag_(FLAG_HAS_EFFECT, true);
} }
} }
// Disable saving for flashes // Disable saving for flashes
if (this->has_flash_()) if (this->has_flash_())
this->save_ = false; this->set_flag_(FLAG_SAVE, false);
return v; return v;
} }
@ -343,24 +364,27 @@ void LightCall::transform_parameters_() {
// - RGBWW lights with color_interlock=true, which also sets "brightness" and // - RGBWW lights with color_interlock=true, which also sets "brightness" and
// "color_temperature" (without color_interlock, CW/WW are set directly) // "color_temperature" (without color_interlock, CW/WW are set directly)
// - Legacy Home Assistant (pre-colormode), which sets "white" and "color_temperature" // - Legacy Home Assistant (pre-colormode), which sets "white" and "color_temperature"
if (((this->white_.has_value() && *this->white_ > 0.0f) || this->color_temperature_.has_value()) && // if (((this->has_white() && this->white_ > 0.0f) || this->has_color_temperature()) && //
(*this->color_mode_ & ColorCapability::COLD_WARM_WHITE) && // (this->color_mode_ & ColorCapability::COLD_WARM_WHITE) && //
!(*this->color_mode_ & ColorCapability::WHITE) && // !(this->color_mode_ & ColorCapability::WHITE) && //
!(*this->color_mode_ & ColorCapability::COLOR_TEMPERATURE) && // !(this->color_mode_ & ColorCapability::COLOR_TEMPERATURE) && //
traits.get_min_mireds() > 0.0f && traits.get_max_mireds() > 0.0f) { traits.get_min_mireds() > 0.0f && traits.get_max_mireds() > 0.0f) {
ESP_LOGD(TAG, "'%s': setting cold/warm white channels using white/color temperature values", ESP_LOGD(TAG, "'%s': setting cold/warm white channels using white/color temperature values",
this->parent_->get_name().c_str()); this->parent_->get_name().c_str());
if (this->color_temperature_.has_value()) { if (this->has_color_temperature()) {
const float color_temp = clamp(*this->color_temperature_, traits.get_min_mireds(), traits.get_max_mireds()); const float color_temp = clamp(this->color_temperature_, traits.get_min_mireds(), traits.get_max_mireds());
const float ww_fraction = const float ww_fraction =
(color_temp - traits.get_min_mireds()) / (traits.get_max_mireds() - traits.get_min_mireds()); (color_temp - traits.get_min_mireds()) / (traits.get_max_mireds() - traits.get_min_mireds());
const float cw_fraction = 1.0f - ww_fraction; const float cw_fraction = 1.0f - ww_fraction;
const float max_cw_ww = std::max(ww_fraction, cw_fraction); const float max_cw_ww = std::max(ww_fraction, cw_fraction);
this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, this->parent_->get_gamma_correct()); this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, this->parent_->get_gamma_correct());
this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, this->parent_->get_gamma_correct()); this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, this->parent_->get_gamma_correct());
this->set_flag_(FLAG_HAS_COLD_WHITE, true);
this->set_flag_(FLAG_HAS_WARM_WHITE, true);
} }
if (this->white_.has_value()) { if (this->has_white()) {
this->brightness_ = *this->white_; this->brightness_ = this->white_;
this->set_flag_(FLAG_HAS_BRIGHTNESS, true);
} }
} }
} }
@ -378,7 +402,7 @@ ColorMode LightCall::compute_color_mode_() {
// Don't change if the light is being turned off. // Don't change if the light is being turned off.
ColorMode current_mode = this->parent_->remote_values.get_color_mode(); ColorMode current_mode = this->parent_->remote_values.get_color_mode();
if (this->state_.has_value() && !*this->state_) if (this->has_state() && !this->state_)
return current_mode; return current_mode;
// If no color mode is specified, we try to guess the color mode. This is needed for backward compatibility to // If no color mode is specified, we try to guess the color mode. This is needed for backward compatibility to
@ -411,12 +435,12 @@ ColorMode LightCall::compute_color_mode_() {
return color_mode; return color_mode;
} }
std::set<ColorMode> LightCall::get_suitable_color_modes_() { std::set<ColorMode> LightCall::get_suitable_color_modes_() {
bool has_white = this->white_.has_value() && *this->white_ > 0.0f; bool has_white = this->has_white() && this->white_ > 0.0f;
bool has_ct = this->color_temperature_.has_value(); bool has_ct = this->has_color_temperature();
bool has_cwww = (this->cold_white_.has_value() && *this->cold_white_ > 0.0f) || bool has_cwww =
(this->warm_white_.has_value() && *this->warm_white_ > 0.0f); (this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f);
bool has_rgb = (this->color_brightness_.has_value() && *this->color_brightness_ > 0.0f) || bool has_rgb = (this->has_color_brightness() && this->color_brightness_ > 0.0f) ||
(this->red_.has_value() || this->green_.has_value() || this->blue_.has_value()); (this->has_red() || this->has_green() || this->has_blue());
#define KEY(white, ct, cwww, rgb) ((white) << 0 | (ct) << 1 | (cwww) << 2 | (rgb) << 3) #define KEY(white, ct, cwww, rgb) ((white) << 0 | (ct) << 1 | (cwww) << 2 | (rgb) << 3)
#define ENTRY(white, ct, cwww, rgb, ...) \ #define ENTRY(white, ct, cwww, rgb, ...) \
@ -549,110 +573,19 @@ LightCall &LightCall::set_warm_white_if_supported(float warm_white) {
this->set_warm_white(warm_white); this->set_warm_white(warm_white);
return *this; return *this;
} }
LightCall &LightCall::set_state(optional<bool> state) { IMPLEMENT_LIGHT_CALL_SETTER(state, bool, FLAG_HAS_STATE)
this->state_ = state; IMPLEMENT_LIGHT_CALL_SETTER(transition_length, uint32_t, FLAG_HAS_TRANSITION)
return *this; IMPLEMENT_LIGHT_CALL_SETTER(flash_length, uint32_t, FLAG_HAS_FLASH)
} IMPLEMENT_LIGHT_CALL_SETTER(brightness, float, FLAG_HAS_BRIGHTNESS)
LightCall &LightCall::set_state(bool state) { IMPLEMENT_LIGHT_CALL_SETTER(color_mode, ColorMode, FLAG_HAS_COLOR_MODE)
this->state_ = state; IMPLEMENT_LIGHT_CALL_SETTER(color_brightness, float, FLAG_HAS_COLOR_BRIGHTNESS)
return *this; IMPLEMENT_LIGHT_CALL_SETTER(red, float, FLAG_HAS_RED)
} IMPLEMENT_LIGHT_CALL_SETTER(green, float, FLAG_HAS_GREEN)
LightCall &LightCall::set_transition_length(optional<uint32_t> transition_length) { IMPLEMENT_LIGHT_CALL_SETTER(blue, float, FLAG_HAS_BLUE)
this->transition_length_ = transition_length; IMPLEMENT_LIGHT_CALL_SETTER(white, float, FLAG_HAS_WHITE)
return *this; IMPLEMENT_LIGHT_CALL_SETTER(color_temperature, float, FLAG_HAS_COLOR_TEMPERATURE)
} IMPLEMENT_LIGHT_CALL_SETTER(cold_white, float, FLAG_HAS_COLD_WHITE)
LightCall &LightCall::set_transition_length(uint32_t transition_length) { IMPLEMENT_LIGHT_CALL_SETTER(warm_white, float, FLAG_HAS_WARM_WHITE)
this->transition_length_ = transition_length;
return *this;
}
LightCall &LightCall::set_flash_length(optional<uint32_t> flash_length) {
this->flash_length_ = flash_length;
return *this;
}
LightCall &LightCall::set_flash_length(uint32_t flash_length) {
this->flash_length_ = flash_length;
return *this;
}
LightCall &LightCall::set_brightness(optional<float> brightness) {
this->brightness_ = brightness;
return *this;
}
LightCall &LightCall::set_brightness(float brightness) {
this->brightness_ = brightness;
return *this;
}
LightCall &LightCall::set_color_mode(optional<ColorMode> color_mode) {
this->color_mode_ = color_mode;
return *this;
}
LightCall &LightCall::set_color_mode(ColorMode color_mode) {
this->color_mode_ = color_mode;
return *this;
}
LightCall &LightCall::set_color_brightness(optional<float> brightness) {
this->color_brightness_ = brightness;
return *this;
}
LightCall &LightCall::set_color_brightness(float brightness) {
this->color_brightness_ = brightness;
return *this;
}
LightCall &LightCall::set_red(optional<float> red) {
this->red_ = red;
return *this;
}
LightCall &LightCall::set_red(float red) {
this->red_ = red;
return *this;
}
LightCall &LightCall::set_green(optional<float> green) {
this->green_ = green;
return *this;
}
LightCall &LightCall::set_green(float green) {
this->green_ = green;
return *this;
}
LightCall &LightCall::set_blue(optional<float> blue) {
this->blue_ = blue;
return *this;
}
LightCall &LightCall::set_blue(float blue) {
this->blue_ = blue;
return *this;
}
LightCall &LightCall::set_white(optional<float> white) {
this->white_ = white;
return *this;
}
LightCall &LightCall::set_white(float white) {
this->white_ = white;
return *this;
}
LightCall &LightCall::set_color_temperature(optional<float> color_temperature) {
this->color_temperature_ = color_temperature;
return *this;
}
LightCall &LightCall::set_color_temperature(float color_temperature) {
this->color_temperature_ = color_temperature;
return *this;
}
LightCall &LightCall::set_cold_white(optional<float> cold_white) {
this->cold_white_ = cold_white;
return *this;
}
LightCall &LightCall::set_cold_white(float cold_white) {
this->cold_white_ = cold_white;
return *this;
}
LightCall &LightCall::set_warm_white(optional<float> warm_white) {
this->warm_white_ = warm_white;
return *this;
}
LightCall &LightCall::set_warm_white(float warm_white) {
this->warm_white_ = warm_white;
return *this;
}
LightCall &LightCall::set_effect(optional<std::string> effect) { LightCall &LightCall::set_effect(optional<std::string> effect) {
if (effect.has_value()) if (effect.has_value())
this->set_effect(*effect); this->set_effect(*effect);
@ -660,18 +593,22 @@ LightCall &LightCall::set_effect(optional<std::string> effect) {
} }
LightCall &LightCall::set_effect(uint32_t effect_number) { LightCall &LightCall::set_effect(uint32_t effect_number) {
this->effect_ = effect_number; this->effect_ = effect_number;
this->set_flag_(FLAG_HAS_EFFECT, true);
return *this; return *this;
} }
LightCall &LightCall::set_effect(optional<uint32_t> effect_number) { LightCall &LightCall::set_effect(optional<uint32_t> effect_number) {
this->effect_ = effect_number; if (effect_number.has_value()) {
this->effect_ = effect_number.value();
}
this->set_flag_(FLAG_HAS_EFFECT, effect_number.has_value());
return *this; return *this;
} }
LightCall &LightCall::set_publish(bool publish) { LightCall &LightCall::set_publish(bool publish) {
this->publish_ = publish; this->set_flag_(FLAG_PUBLISH, publish);
return *this; return *this;
} }
LightCall &LightCall::set_save(bool save) { LightCall &LightCall::set_save(bool save) {
this->save_ = save; this->set_flag_(FLAG_SAVE, save);
return *this; return *this;
} }
LightCall &LightCall::set_rgb(float red, float green, float blue) { LightCall &LightCall::set_rgb(float red, float green, float blue) {

82
esphome/components/light/light_call.h
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include "esphome/core/optional.h"
#include "light_color_values.h" #include "light_color_values.h"
#include <set> #include <set>
@ -131,6 +130,19 @@ class LightCall {
/// Set whether this light call should trigger a save state to recover them at startup.. /// Set whether this light call should trigger a save state to recover them at startup..
LightCall &set_save(bool save); LightCall &set_save(bool save);
// Getter methods to check if values are set
bool has_state() const { return (flags_ & FLAG_HAS_STATE) != 0; }
bool has_brightness() const { return (flags_ & FLAG_HAS_BRIGHTNESS) != 0; }
bool has_color_brightness() const { return (flags_ & FLAG_HAS_COLOR_BRIGHTNESS) != 0; }
bool has_red() const { return (flags_ & FLAG_HAS_RED) != 0; }
bool has_green() const { return (flags_ & FLAG_HAS_GREEN) != 0; }
bool has_blue() const { return (flags_ & FLAG_HAS_BLUE) != 0; }
bool has_white() const { return (flags_ & FLAG_HAS_WHITE) != 0; }
bool has_color_temperature() const { return (flags_ & FLAG_HAS_COLOR_TEMPERATURE) != 0; }
bool has_cold_white() const { return (flags_ & FLAG_HAS_COLD_WHITE) != 0; }
bool has_warm_white() const { return (flags_ & FLAG_HAS_WARM_WHITE) != 0; }
bool has_color_mode() const { return (flags_ & FLAG_HAS_COLOR_MODE) != 0; }
/** Set the RGB color of the light by RGB values. /** Set the RGB color of the light by RGB values.
* *
* Please note that this only changes the color of the light, not the brightness. * Please note that this only changes the color of the light, not the brightness.
@ -170,27 +182,57 @@ class LightCall {
/// Some color modes also can be set using non-native parameters, transform those calls. /// Some color modes also can be set using non-native parameters, transform those calls.
void transform_parameters_(); void transform_parameters_();
bool has_transition_() { return this->transition_length_.has_value(); } enum FieldFlags : uint16_t {
bool has_flash_() { return this->flash_length_.has_value(); } FLAG_HAS_STATE = 1 << 0,
bool has_effect_() { return this->effect_.has_value(); } FLAG_HAS_TRANSITION = 1 << 1,
FLAG_HAS_FLASH = 1 << 2,
FLAG_HAS_EFFECT = 1 << 3,
FLAG_HAS_BRIGHTNESS = 1 << 4,
FLAG_HAS_COLOR_BRIGHTNESS = 1 << 5,
FLAG_HAS_RED = 1 << 6,
FLAG_HAS_GREEN = 1 << 7,
FLAG_HAS_BLUE = 1 << 8,
FLAG_HAS_WHITE = 1 << 9,
FLAG_HAS_COLOR_TEMPERATURE = 1 << 10,
FLAG_HAS_COLD_WHITE = 1 << 11,
FLAG_HAS_WARM_WHITE = 1 << 12,
FLAG_HAS_COLOR_MODE = 1 << 13,
FLAG_PUBLISH = 1 << 14,
FLAG_SAVE = 1 << 15,
};
bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
// Helper to set flag
void set_flag_(FieldFlags flag, bool value) {
if (value)
this->flags_ |= flag;
else
this->flags_ &= ~flag;
}
LightState *parent_; LightState *parent_;
optional<bool> state_; // Group 4-byte aligned members first
optional<uint32_t> transition_length_; uint32_t transition_length_;
optional<uint32_t> flash_length_; uint32_t flash_length_;
optional<ColorMode> color_mode_; uint32_t effect_;
optional<float> brightness_; float brightness_;
optional<float> color_brightness_; float color_brightness_;
optional<float> red_; float red_;
optional<float> green_; float green_;
optional<float> blue_; float blue_;
optional<float> white_; float white_;
optional<float> color_temperature_; float color_temperature_;
optional<float> cold_white_; float cold_white_;
optional<float> warm_white_; float warm_white_;
optional<uint32_t> effect_; // Group smaller members at the end for better packing
bool publish_{true}; uint16_t flags_{FLAG_PUBLISH | FLAG_SAVE}; // Default publish and save to true
bool save_{true}; ColorMode color_mode_;
bool state_;
}; };
} // namespace light } // namespace light

2
esphome/components/light/light_color_values.h
View File

@ -292,7 +292,6 @@ class LightColorValues {
void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); } void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); }
protected: protected:
ColorMode color_mode_;
float state_; ///< ON / OFF, float for transition float state_; ///< ON / OFF, float for transition
float brightness_; float brightness_;
float color_brightness_; float color_brightness_;
@ -303,6 +302,7 @@ class LightColorValues {
float color_temperature_; ///< Color Temperature in Mired float color_temperature_; ///< Color Temperature in Mired
float cold_white_; float cold_white_;
float warm_white_; float warm_white_;
ColorMode color_mode_;
}; };
} // namespace light } // namespace light

21
esphome/components/light/light_state.h
View File

@ -31,9 +31,7 @@ enum LightRestoreMode : uint8_t {
struct LightStateRTCState { struct LightStateRTCState {
LightStateRTCState(ColorMode color_mode, bool state, float brightness, float color_brightness, float red, float green, LightStateRTCState(ColorMode color_mode, bool state, float brightness, float color_brightness, float red, float green,
float blue, float white, float color_temp, float cold_white, float warm_white) float blue, float white, float color_temp, float cold_white, float warm_white)
: color_mode(color_mode), : brightness(brightness),
state(state),
brightness(brightness),
color_brightness(color_brightness), color_brightness(color_brightness),
red(red), red(red),
green(green), green(green),
@ -41,10 +39,12 @@ struct LightStateRTCState {
white(white), white(white),
color_temp(color_temp), color_temp(color_temp),
cold_white(cold_white), cold_white(cold_white),
warm_white(warm_white) {} warm_white(warm_white),
effect(0),
color_mode(color_mode),
state(state) {}
LightStateRTCState() = default; LightStateRTCState() = default;
ColorMode color_mode{ColorMode::UNKNOWN}; // Group 4-byte aligned members first
bool state{false};
float brightness{1.0f}; float brightness{1.0f};
float color_brightness{1.0f}; float color_brightness{1.0f};
float red{1.0f}; float red{1.0f};
@ -55,6 +55,9 @@ struct LightStateRTCState {
float cold_white{1.0f}; float cold_white{1.0f};
float warm_white{1.0f}; float warm_white{1.0f};
uint32_t effect{0}; uint32_t effect{0};
// Group smaller members at the end
ColorMode color_mode{ColorMode::UNKNOWN};
bool state{false};
}; };
/** This class represents the communication layer between the front-end MQTT layer and the /** This class represents the communication layer between the front-end MQTT layer and the
@ -216,6 +219,8 @@ class LightState : public EntityBase, public Component {
std::unique_ptr<LightTransformer> transformer_{nullptr}; std::unique_ptr<LightTransformer> transformer_{nullptr};
/// List of effects for this light. /// List of effects for this light.
std::vector<LightEffect *> effects_; std::vector<LightEffect *> effects_;
/// Object used to store the persisted values of the light.
ESPPreferenceObject rtc_;
/// Value for storing the index of the currently active effect. 0 if no effect is active /// Value for storing the index of the currently active effect. 0 if no effect is active
uint32_t active_effect_index_{}; uint32_t active_effect_index_{};
/// Default transition length for all transitions in ms. /// Default transition length for all transitions in ms.
@ -224,15 +229,11 @@ class LightState : public EntityBase, public Component {
uint32_t flash_transition_length_{}; uint32_t flash_transition_length_{};
/// Gamma correction factor for the light. /// Gamma correction factor for the light.
float gamma_correct_{}; float gamma_correct_{};
/// Whether the light value should be written in the next cycle. /// Whether the light value should be written in the next cycle.
bool next_write_{true}; bool next_write_{true};
// for effects, true if a transformer (transition) is active. // for effects, true if a transformer (transition) is active.
bool is_transformer_active_ = false; bool is_transformer_active_ = false;
/// Object used to store the persisted values of the light.
ESPPreferenceObject rtc_;
/** Callback to call when new values for the frontend are available. /** Callback to call when new values for the frontend are available.
* *
* "Remote values" are light color values that are reported to the frontend and have a lower * "Remote values" are light color values that are reported to the frontend and have a lower

4
esphome/components/light/transformers.h
View File

@ -59,9 +59,9 @@ class LightTransitionTransformer : public LightTransformer {
// transition from 0 to 1 on x = [0, 1] // transition from 0 to 1 on x = [0, 1]
static float smoothed_progress(float x) { return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f); } static float smoothed_progress(float x) { return x * x * x * (x * (x * 6.0f - 15.0f) + 10.0f); }
bool changing_color_mode_{false};
LightColorValues end_values_{}; LightColorValues end_values_{};
LightColorValues intermediate_values_{}; LightColorValues intermediate_values_{};
bool changing_color_mode_{false};
}; };
class LightFlashTransformer : public LightTransformer { class LightFlashTransformer : public LightTransformer {
@ -117,8 +117,8 @@ class LightFlashTransformer : public LightTransformer {
protected: protected:
LightState &state_; LightState &state_;
uint32_t transition_length_;
std::unique_ptr<LightTransformer> transformer_{nullptr}; std::unique_ptr<LightTransformer> transformer_{nullptr};
uint32_t transition_length_;
bool begun_lightstate_restore_; bool begun_lightstate_restore_;
}; };