ESPHome 2025.9.0-dev
Loading...
Searching...
No Matches
light_state.cpp
Go to the documentation of this file.
1#include "esphome/core/log.h"
2
3#include "light_output.h"
4#include "light_state.h"
5#include "transformers.h"
6
7namespace esphome {
8namespace light {
9
10static const char *const TAG = "light";
11
12LightState::LightState(LightOutput *output) : output_(output) {}
13
19
21 this->output_->setup_state(this);
22 for (auto *effect : this->effects_) {
23 effect->init_internal(this);
24 }
25
26 // When supported color temperature range is known, initialize color temperature setting within bounds.
27 auto traits = this->get_traits();
28 float min_mireds = traits.get_min_mireds();
29 if (min_mireds > 0) {
30 this->remote_values.set_color_temperature(min_mireds);
31 this->current_values.set_color_temperature(min_mireds);
32 }
33
34 auto call = this->make_call();
35 LightStateRTCState recovered{};
36 if (this->initial_state_.has_value()) {
37 recovered = *this->initial_state_;
38 }
39 switch (this->restore_mode_) {
45 // Attempt to load from preferences, else fall back to default values
46 if (!this->rtc_.load(&recovered)) {
47 recovered.state = (this->restore_mode_ == LIGHT_RESTORE_DEFAULT_ON ||
51 // Inverted restore state
52 recovered.state = !recovered.state;
53 }
54 break;
58 this->rtc_.load(&recovered);
59 recovered.state = (this->restore_mode_ == LIGHT_RESTORE_AND_ON);
60 break;
62 recovered.state = false;
63 break;
64 case LIGHT_ALWAYS_ON:
65 recovered.state = true;
66 break;
67 }
68
69 call.set_color_mode_if_supported(recovered.color_mode);
70 call.set_state(recovered.state);
71 call.set_brightness_if_supported(recovered.brightness);
72 call.set_color_brightness_if_supported(recovered.color_brightness);
73 call.set_red_if_supported(recovered.red);
74 call.set_green_if_supported(recovered.green);
75 call.set_blue_if_supported(recovered.blue);
76 call.set_white_if_supported(recovered.white);
77 call.set_color_temperature_if_supported(recovered.color_temp);
78 call.set_cold_white_if_supported(recovered.cold_white);
79 call.set_warm_white_if_supported(recovered.warm_white);
80 if (recovered.effect != 0) {
81 call.set_effect(recovered.effect);
82 } else {
83 call.set_transition_length_if_supported(0);
84 }
85 call.perform();
86}
88 ESP_LOGCONFIG(TAG, "Light '%s'", this->get_name().c_str());
89 auto traits = this->get_traits();
90 if (traits.supports_color_capability(ColorCapability::BRIGHTNESS)) {
91 ESP_LOGCONFIG(TAG,
92 " Default Transition Length: %.1fs\n"
93 " Gamma Correct: %.2f",
94 this->default_transition_length_ / 1e3f, this->gamma_correct_);
95 }
96 if (traits.supports_color_capability(ColorCapability::COLOR_TEMPERATURE)) {
97 ESP_LOGCONFIG(TAG,
98 " Min Mireds: %.1f\n"
99 " Max Mireds: %.1f",
100 traits.get_min_mireds(), traits.get_max_mireds());
101 }
102}
104 // Apply effect (if any)
105 auto *effect = this->get_active_effect_();
106 if (effect != nullptr) {
107 effect->apply();
108 }
109
110 // Apply transformer (if any)
111 if (this->transformer_ != nullptr) {
112 auto values = this->transformer_->apply();
113 this->is_transformer_active_ = true;
114 if (values.has_value()) {
115 this->current_values = *values;
116 this->output_->update_state(this);
117 this->next_write_ = true;
118 }
119
120 if (this->transformer_->is_finished()) {
121 // if the transition has written directly to the output, current_values is outdated, so update it
122 this->current_values = this->transformer_->get_target_values();
123
124 this->transformer_->stop();
125 this->is_transformer_active_ = false;
126 this->transformer_ = nullptr;
128 }
129 }
130
131 // Write state to the light
132 if (this->next_write_) {
133 this->next_write_ = false;
134 this->output_->write_state(this);
135 }
136}
137
139
141
144 if (this->active_effect_index_ > 0) {
145 return this->effects_[this->active_effect_index_ - 1]->get_name();
146 } else {
147 return "None";
148 }
149}
150
151void LightState::add_new_remote_values_callback(std::function<void()> &&send_callback) {
152 this->remote_values_callback_.add(std::move(send_callback));
153}
154void LightState::add_new_target_state_reached_callback(std::function<void()> &&send_callback) {
155 this->target_state_reached_callback_.add(std::move(send_callback));
156}
157
159 this->default_transition_length_ = default_transition_length;
160}
163 this->flash_transition_length_ = flash_transition_length;
164}
167void LightState::set_restore_mode(LightRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
168void LightState::set_initial_state(const LightStateRTCState &initial_state) { this->initial_state_ = initial_state; }
169bool LightState::supports_effects() { return !this->effects_.empty(); }
170const std::vector<LightEffect *> &LightState::get_effects() const { return this->effects_; }
171void LightState::add_effects(const std::vector<LightEffect *> &effects) {
172 this->effects_.reserve(this->effects_.size() + effects.size());
173 for (auto *effect : effects) {
174 this->effects_.push_back(effect);
175 }
176}
177
180 this->current_values.as_brightness(brightness, this->gamma_correct_);
181}
182void LightState::current_values_as_rgb(float *red, float *green, float *blue, bool color_interlock) {
183 auto traits = this->get_traits();
184 this->current_values.as_rgb(red, green, blue, this->gamma_correct_, false);
185}
186void LightState::current_values_as_rgbw(float *red, float *green, float *blue, float *white, bool color_interlock) {
187 auto traits = this->get_traits();
188 this->current_values.as_rgbw(red, green, blue, white, this->gamma_correct_, false);
189}
190void LightState::current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white,
191 bool constant_brightness) {
192 this->current_values.as_rgbww(red, green, blue, cold_white, warm_white, this->gamma_correct_, constant_brightness);
193}
194void LightState::current_values_as_rgbct(float *red, float *green, float *blue, float *color_temperature,
195 float *white_brightness) {
196 auto traits = this->get_traits();
197 this->current_values.as_rgbct(traits.get_min_mireds(), traits.get_max_mireds(), red, green, blue, color_temperature,
198 white_brightness, this->gamma_correct_);
199}
200void LightState::current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness) {
201 auto traits = this->get_traits();
202 this->current_values.as_cwww(cold_white, warm_white, this->gamma_correct_, constant_brightness);
203}
204void LightState::current_values_as_ct(float *color_temperature, float *white_brightness) {
205 auto traits = this->get_traits();
206 this->current_values.as_ct(traits.get_min_mireds(), traits.get_max_mireds(), color_temperature, white_brightness,
207 this->gamma_correct_);
208}
209
211
213 this->stop_effect_();
214 if (effect_index == 0)
215 return;
216
217 this->active_effect_index_ = effect_index;
218 auto *effect = this->get_active_effect_();
219 effect->start_internal();
220}
222 if (this->active_effect_index_ == 0) {
223 return nullptr;
224 } else {
225 return this->effects_[this->active_effect_index_ - 1];
226 }
227}
229 auto *effect = this->get_active_effect_();
230 if (effect != nullptr) {
231 effect->stop();
232 }
233 this->active_effect_index_ = 0;
234}
235
236void LightState::start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
238 this->transformer_->setup(this->current_values, target, length);
239
240 if (set_remote_values) {
241 this->remote_values = target;
242 }
243}
244
245void LightState::start_flash_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
246 LightColorValues end_colors = this->remote_values;
247 // If starting a flash if one is already happening, set end values to end values of current flash
248 // Hacky but works
249 if (this->transformer_ != nullptr)
250 end_colors = this->transformer_->get_start_values();
251
252 this->transformer_ = make_unique<LightFlashTransformer>(*this);
253 this->transformer_->setup(end_colors, target, length);
254
255 if (set_remote_values) {
256 this->remote_values = target;
257 };
258}
259
260void LightState::set_immediately_(const LightColorValues &target, bool set_remote_values) {
261 this->is_transformer_active_ = false;
262 this->transformer_ = nullptr;
263 this->current_values = target;
264 if (set_remote_values) {
265 this->remote_values = target;
266 }
267 this->output_->update_state(this);
268 this->next_write_ = true;
269}
270
272 LightStateRTCState saved;
274 switch (this->restore_mode_) {
277 saved.state = (this->restore_mode_ == LIGHT_RESTORE_AND_ON);
278 break;
279 default:
280 saved.state = this->remote_values.is_on();
281 break;
282 }
285 saved.red = this->remote_values.get_red();
286 saved.green = this->remote_values.get_green();
287 saved.blue = this->remote_values.get_blue();
288 saved.white = this->remote_values.get_white();
292 saved.effect = this->active_effect_index_;
293 this->rtc_.save(&saved);
294}
295
296} // namespace light
297} // namespace esphome
bool save(const T *src)
Definition preferences.h:21
virtual ESPPreferenceObject make_preference(size_t length, uint32_t type, bool in_flash)=0
uint32_t get_object_id_hash()
const StringRef & get_name() const
This class represents a requested change in a light state.
Definition light_call.h:18
LightCall & set_state(optional< bool > state)
Set the binary ON/OFF state of the light.
This class represents the color state for a light object.
float get_brightness() const
Get the brightness property of these light color values. In range 0.0 to 1.0.
void as_ct(float color_temperature_cw, float color_temperature_ww, float *color_temperature, float *white_brightness, float gamma=0) const
Convert these light color values to a CT+BR representation with the given parameters.
float get_blue() const
Get the blue property of these light color values. In range 0.0 to 1.0.
float get_white() const
Get the white property of these light color values. In range 0.0 to 1.0.
float get_color_temperature() const
Get the color temperature property of these light color values in mired.
void as_rgb(float *red, float *green, float *blue, float gamma=0, bool color_interlock=false) const
Convert these light color values to an RGB representation and write them to red, green,...
float get_cold_white() const
Get the cold white property of these light color values. In range 0.0 to 1.0.
void as_cwww(float *cold_white, float *warm_white, float gamma=0, bool constant_brightness=false) const
Convert these light color values to an CWWW representation with the given parameters.
bool is_on() const
Get the binary true/false state of these light color values.
float get_green() const
Get the green property of these light color values. In range 0.0 to 1.0.
void set_color_temperature(float color_temperature)
Set the color temperature property of these light color values in mired.
float get_warm_white() const
Get the warm white property of these light color values. In range 0.0 to 1.0.
void as_binary(bool *binary) const
Convert these light color values to a binary representation and write them to binary.
void as_rgbw(float *red, float *green, float *blue, float *white, float gamma=0, bool color_interlock=false) const
Convert these light color values to an RGBW representation and write them to red, green,...
ColorMode get_color_mode() const
Get the color mode of these light color values.
float get_red() const
Get the red property of these light color values. In range 0.0 to 1.0.
float get_color_brightness() const
Get the color brightness property of these light color values. In range 0.0 to 1.0.
void as_brightness(float *brightness, float gamma=0) const
Convert these light color values to a brightness-only representation and write them to brightness.
void as_rgbct(float color_temperature_cw, float color_temperature_ww, float *red, float *green, float *blue, float *color_temperature, float *white_brightness, float gamma=0) const
Convert these light color values to an RGB+CT+BR representation with the given parameters.
void as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white, float gamma=0, bool constant_brightness=false) const
Convert these light color values to an RGBWW representation with the given parameters.
Interface to write LightStates to hardware.
virtual void write_state(LightState *state)=0
Called from loop() every time the light state has changed, and should should write the new state to h...
virtual std::unique_ptr< LightTransformer > create_default_transition()
Return the default transformer used for transitions.
virtual LightTraits get_traits()=0
Return the LightTraits of this LightOutput.
virtual void update_state(LightState *state)
Called on every update of the current values of the associated LightState, can optionally be used to ...
virtual void setup_state(LightState *state)
float gamma_correct_
Gamma correction factor for the light.
void start_effect_(uint32_t effect_index)
Internal method to start an effect with the given index.
void stop_effect_()
Internal method to stop the current effect (if one is active).
void current_values_as_rgbct(float *red, float *green, float *blue, float *color_temperature, float *white_brightness)
std::unique_ptr< LightTransformer > transformer_
The currently active transformer for this light (transition/flash).
const std::vector< LightEffect * > & get_effects() const
Get all effects for this light state.
void dump_config() override
LightColorValues remote_values
The remote color values reported to the frontend.
LightOutput * get_output() const
Get the light output associated with this object.
void set_flash_transition_length(uint32_t flash_transition_length)
Set the flash transition length.
LightState(LightOutput *output)
void current_values_as_binary(bool *binary)
The result of all the current_values_as_* methods have gamma correction applied.
void save_remote_values_()
Internal method to save the current remote_values to the preferences.
LightCall turn_on()
Make a light state call.
uint32_t get_default_transition_length() const
void set_immediately_(const LightColorValues &target, bool set_remote_values)
Internal method to set the color values to target immediately (with no transition).
optional< LightStateRTCState > initial_state_
Initial state of the light.
uint32_t get_flash_transition_length() const
std::string get_effect_name()
Return the name of the current effect, or if no effect is active "None".
void current_values_as_ct(float *color_temperature, float *white_brightness)
CallbackManager< void()> remote_values_callback_
Callback to call when new values for the frontend are available.
void current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness=false)
uint32_t flash_transition_length_
Transition length to use for flash transitions.
void publish_state()
Publish the currently active state to the frontend.
void current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white, bool constant_brightness=false)
void set_initial_state(const LightStateRTCState &initial_state)
Set the initial state of this light.
void add_new_remote_values_callback(std::function< void()> &&send_callback)
This lets front-end components subscribe to light change events.
void current_values_as_brightness(float *brightness)
void setup() override
Load state from preferences.
void add_effects(const std::vector< LightEffect * > &effects)
Add effects for this light state.
uint32_t active_effect_index_
Value for storing the index of the currently active effect. 0 if no effect is active.
void start_flash_(const LightColorValues &target, uint32_t length, bool set_remote_values)
Internal method to start a flash for the specified amount of time.
LightRestoreMode restore_mode_
Restore mode of the light.
std::vector< LightEffect * > effects_
List of effects for this light.
void add_new_target_state_reached_callback(std::function< void()> &&send_callback)
The callback is called once the state of current_values and remote_values are equal (when the transit...
void current_values_as_rgb(float *red, float *green, float *blue, bool color_interlock=false)
CallbackManager< void()> target_state_reached_callback_
Callback to call when the state of current_values and remote_values are equal This should be called o...
bool supports_effects()
Return whether the light has any effects that meet the trait requirements.
void current_values_as_rgbw(float *red, float *green, float *blue, float *white, bool color_interlock=false)
bool next_write_
Whether the light value should be written in the next cycle.
void start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values)
Internal method to start a transition to the target color with the given length.
float get_setup_priority() const override
Shortly after HARDWARE.
void set_restore_mode(LightRestoreMode restore_mode)
Set the restore mode of this light.
LightOutput * output_
Store the output to allow effects to have more access.
ESPPreferenceObject rtc_
Object used to store the persisted values of the light.
uint32_t default_transition_length_
Default transition length for all transitions in ms.
LightColorValues current_values
The current values of the light as outputted to the light.
Definition light_state.h:97
LightEffect * get_active_effect_()
Internal method to get the currently active effect.
bool is_transformer_active()
Indicator if a transformer (e.g.
void set_gamma_correct(float gamma_correct)
Set the gamma correction factor.
void set_default_transition_length(uint32_t default_transition_length)
Set the default transition length, i.e. the transition length when no transition is provided.
This class is used to represent the capabilities of a light.
@ LIGHT_RESTORE_INVERTED_DEFAULT_ON
Definition light_state.h:26
@ LIGHT_RESTORE_DEFAULT_OFF
Definition light_state.h:21
@ LIGHT_RESTORE_INVERTED_DEFAULT_OFF
Definition light_state.h:25
@ BRIGHTNESS
Master brightness of the light can be controlled.
@ COLOR_TEMPERATURE
Color temperature can be controlled.
const float HARDWARE
For components that deal with hardware and are very important like GPIO switch.
Definition component.cpp:49
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
float gamma_correct(float value, float gamma)
Applies gamma correction of gamma to value.
Definition helpers.cpp:482
ESPPreferences * global_preferences
uint16_t length
Definition tt21100.cpp:0