light_state.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/optional.h"
#include "esphome/core/preferences.h"
#include "esphome/core/string_ref.h"
#include "light_call.h"
#include "light_color_values.h"
#include "light_effect.h"
#include "light_traits.h"
#include "light_transformer.h"
 
#include <vector>
#include <strings.h>
 
namespace esphome {
namespace light {
 
class LightOutput;
 
enum LightRestoreMode : uint8_t {
  LIGHT_RESTORE_DEFAULT_OFF,
  LIGHT_RESTORE_DEFAULT_ON,
  LIGHT_ALWAYS_OFF,
  LIGHT_ALWAYS_ON,
  LIGHT_RESTORE_INVERTED_DEFAULT_OFF,
  LIGHT_RESTORE_INVERTED_DEFAULT_ON,
  LIGHT_RESTORE_AND_OFF,
  LIGHT_RESTORE_AND_ON,
};
 
struct LightStateRTCState {
  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)
      : brightness(brightness),
        color_brightness(color_brightness),
        red(red),
        green(green),
        blue(blue),
        white(white),
        color_temp(color_temp),
        cold_white(cold_white),
        warm_white(warm_white),
        effect(0),
        color_mode(color_mode),
        state(state) {}
  LightStateRTCState() = default;
  // Group 4-byte aligned members first
  float brightness{1.0f};
  float color_brightness{1.0f};
  float red{1.0f};
  float green{1.0f};
  float blue{1.0f};
  float white{1.0f};
  float color_temp{1.0f};
  float cold_white{1.0f};
  float warm_white{1.0f};
  uint32_t effect{0};
  // Group smaller members at the end
  ColorMode color_mode{ColorMode::UNKNOWN};
  bool state{false};
};
 
class LightState : public EntityBase, public Component {
 public:
  LightState(LightOutput *output);
 
  LightTraits get_traits();
 
  LightCall turn_on();
  LightCall turn_off();
  LightCall toggle();
  LightCall make_call();
 
  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
  void setup() override;
  void dump_config() override;
  void loop() override;
  float get_setup_priority() const override;
 
  LightColorValues current_values;
 
  LightColorValues remote_values;
 
  void publish_state();
 
  LightOutput *get_output() const;
 
  std::string get_effect_name();
  StringRef get_effect_name_ref();
 
  void add_new_remote_values_callback(std::function<void()> &&send_callback);
 
  void add_new_target_state_reached_callback(std::function<void()> &&send_callback);
 
  void set_default_transition_length(uint32_t default_transition_length);
  uint32_t get_default_transition_length() const;
 
  void set_flash_transition_length(uint32_t flash_transition_length);
  uint32_t get_flash_transition_length() const;
 
  void set_gamma_correct(float gamma_correct);
  float get_gamma_correct() const { return this->gamma_correct_; }
 
  void set_restore_mode(LightRestoreMode restore_mode);
 
  void set_initial_state(const LightStateRTCState &initial_state);
 
  bool supports_effects();
 
  const std::vector<LightEffect *> &get_effects() const;
 
  void add_effects(const std::vector<LightEffect *> &effects);
 
  size_t get_effect_count() const { return this->effects_.size(); }
 
  uint32_t get_current_effect_index() const { return this->active_effect_index_; }
 
  uint32_t get_effect_index(const std::string &effect_name) const {
    if (strcasecmp(effect_name.c_str(), "none") == 0) {
      return 0;
    }
    for (size_t i = 0; i < this->effects_.size(); i++) {
      if (strcasecmp(effect_name.c_str(), this->effects_[i]->get_name().c_str()) == 0) {
        return i + 1;  // Effects are 1-indexed in active_effect_index_
      }
    }
    return 0;  // Effect not found
  }
 
  LightEffect *get_effect_by_index(uint32_t index) const {
    if (index == 0 || index > this->effects_.size()) {
      return nullptr;
    }
    return this->effects_[index - 1];  // Effects are 1-indexed in active_effect_index_
  }
 
  std::string get_effect_name_by_index(uint32_t index) const {
    if (index == 0) {
      return "None";
    }
    if (index > this->effects_.size()) {
      return "";  // Invalid index
    }
    return this->effects_[index - 1]->get_name();
  }
 
  void current_values_as_binary(bool *binary);
 
  void current_values_as_brightness(float *brightness);
 
  void current_values_as_rgb(float *red, float *green, float *blue, bool color_interlock = false);
 
  void current_values_as_rgbw(float *red, float *green, float *blue, float *white, bool color_interlock = false);
 
  void current_values_as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white,
                               bool constant_brightness = false);
 
  void current_values_as_rgbct(float *red, float *green, float *blue, float *color_temperature,
                               float *white_brightness);
 
  void current_values_as_cwww(float *cold_white, float *warm_white, bool constant_brightness = false);
 
  void current_values_as_ct(float *color_temperature, float *white_brightness);
 
  bool is_transformer_active();
 
 protected:
  friend LightOutput;
  friend LightCall;
  friend class AddressableLight;
 
  void start_effect_(uint32_t effect_index);
  LightEffect *get_active_effect_();
  void stop_effect_();
  void start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values);
 
  void start_flash_(const LightColorValues &target, uint32_t length, bool set_remote_values);
 
  void set_immediately_(const LightColorValues &target, bool set_remote_values);
 
  void save_remote_values_();
 
  LightOutput *output_;
  std::unique_ptr<LightTransformer> transformer_{nullptr};
  std::vector<LightEffect *> effects_;
  ESPPreferenceObject rtc_;
  uint32_t active_effect_index_{};
  uint32_t default_transition_length_{};
  uint32_t flash_transition_length_{};
  float gamma_correct_{};
  bool next_write_{true};
  // for effects, true if a transformer (transition) is active.
  bool is_transformer_active_ = false;
 
  CallbackManager<void()> remote_values_callback_{};
 
  CallbackManager<void()> target_state_reached_callback_{};
 
  optional<LightStateRTCState> initial_state_{};
 
  LightRestoreMode restore_mode_;
};
 
}  // namespace light
}  // namespace esphome