climate.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/preferences.h"
#include "esphome/core/string_ref.h"
#include "climate_mode.h"
#include "climate_traits.h"
 
namespace esphome::climate {
 
#define LOG_CLIMATE(prefix, type, obj) \
  if ((obj) != nullptr) { \
    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
  }
 
class Climate;
 
class ClimateCall {
 public:
  explicit ClimateCall(Climate *parent) : parent_(parent) {}
  friend struct ClimateDeviceRestoreState;
 
  ClimateCall &set_mode(ClimateMode mode);
  ClimateCall &set_mode(optional<ClimateMode> mode);
  ClimateCall &set_mode(const std::string &mode);
  ClimateCall &set_mode(const char *mode, size_t len);
  ClimateCall &set_target_temperature(float target_temperature);
  ClimateCall &set_target_temperature(optional<float> target_temperature);
  ClimateCall &set_target_temperature_low(float target_temperature_low);
  ClimateCall &set_target_temperature_low(optional<float> target_temperature_low);
  ClimateCall &set_target_temperature_high(float target_temperature_high);
  ClimateCall &set_target_temperature_high(optional<float> target_temperature_high);
  ClimateCall &set_target_humidity(float target_humidity);
  ClimateCall &set_target_humidity(optional<float> target_humidity);
  ClimateCall &set_fan_mode(ClimateFanMode fan_mode);
  ClimateCall &set_fan_mode(optional<ClimateFanMode> fan_mode);
  ClimateCall &set_fan_mode(const std::string &fan_mode);
  ClimateCall &set_fan_mode(optional<std::string> fan_mode);
  ClimateCall &set_fan_mode(const char *custom_fan_mode);
  ClimateCall &set_fan_mode(const char *custom_fan_mode, size_t len);
  ClimateCall &set_swing_mode(ClimateSwingMode swing_mode);
  ClimateCall &set_swing_mode(optional<ClimateSwingMode> swing_mode);
  ClimateCall &set_swing_mode(const std::string &swing_mode);
  ClimateCall &set_swing_mode(const char *swing_mode, size_t len);
  ClimateCall &set_preset(ClimatePreset preset);
  ClimateCall &set_preset(optional<ClimatePreset> preset);
  ClimateCall &set_preset(const std::string &preset);
  ClimateCall &set_preset(optional<std::string> preset);
  ClimateCall &set_preset(const char *custom_preset);
  ClimateCall &set_preset(const char *custom_preset, size_t len);
 
  void perform();
 
  const optional<float> &get_target_temperature() const;
  const optional<float> &get_target_temperature_low() const;
  const optional<float> &get_target_temperature_high() const;
  const optional<float> &get_target_humidity() const;
 
  const optional<ClimateMode> &get_mode() const;
  const optional<ClimateFanMode> &get_fan_mode() const;
  const optional<ClimateSwingMode> &get_swing_mode() const;
  const optional<ClimatePreset> &get_preset() const;
  StringRef get_custom_fan_mode() const { return StringRef::from_maybe_nullptr(this->custom_fan_mode_); }
  StringRef get_custom_preset() const { return StringRef::from_maybe_nullptr(this->custom_preset_); }
  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
 
 protected:
  void validate_();
 
  Climate *const parent_;
  optional<float> target_temperature_;
  optional<float> target_temperature_low_;
  optional<float> target_temperature_high_;
  optional<float> target_humidity_;
  optional<ClimateMode> mode_;
  optional<ClimateFanMode> fan_mode_;
  optional<ClimateSwingMode> swing_mode_;
  optional<ClimatePreset> preset_;
 
 private:
  const char *custom_fan_mode_{nullptr};
  const char *custom_preset_{nullptr};
};
 
struct ClimateDeviceRestoreState {
  ClimateMode mode;
  bool uses_custom_fan_mode{false};
  union {
    ClimateFanMode fan_mode;
    uint8_t custom_fan_mode;
  };
  bool uses_custom_preset{false};
  union {
    ClimatePreset preset;
    uint8_t custom_preset;
  };
  ClimateSwingMode swing_mode;
  union {
    float target_temperature;
    struct {
      float target_temperature_low;
      float target_temperature_high;
    };
  } __attribute__((packed));
  float target_humidity;
 
  ClimateCall to_call(Climate *climate);
  void apply(Climate *climate);
} __attribute__((packed));
 
class Climate : public EntityBase {
 public:
  Climate() {}
 
  template<typename F> void add_on_state_callback(F &&callback) {
    this->state_callback_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_on_control_callback(F &&callback) {
    this->control_callback_.add(std::forward<F>(callback));
  }
 
  ClimateCall make_call();
 
  void publish_state();
 
  ClimateTraits get_traits();
 
#ifdef USE_CLIMATE_VISUAL_OVERRIDES
  void set_visual_min_temperature_override(float visual_min_temperature_override);
  void set_visual_max_temperature_override(float visual_max_temperature_override);
  void set_visual_temperature_step_override(float target, float current);
  void set_visual_min_humidity_override(float visual_min_humidity_override);
  void set_visual_max_humidity_override(float visual_max_humidity_override);
#endif
 
  void set_supported_custom_fan_modes(std::initializer_list<const char *> modes) {
    this->ensure_custom_fan_modes_().assign(modes.begin(), modes.end());
  }
  void set_supported_custom_fan_modes(const std::vector<const char *> &modes) {
    this->ensure_custom_fan_modes_() = modes;
  }
  template<size_t N> void set_supported_custom_fan_modes(const char *const (&modes)[N]) {
    this->ensure_custom_fan_modes_().assign(modes, modes + N);
  }
 
  void set_supported_custom_presets(std::initializer_list<const char *> presets) {
    this->ensure_custom_presets_().assign(presets.begin(), presets.end());
  }
  void set_supported_custom_presets(const std::vector<const char *> &presets) {
    this->ensure_custom_presets_() = presets;
  }
  template<size_t N> void set_supported_custom_presets(const char *const (&presets)[N]) {
    this->ensure_custom_presets_().assign(presets, presets + N);
  }
 
  bool has_custom_fan_mode() const { return this->custom_fan_mode_ != nullptr; }
 
  bool has_custom_preset() const { return this->custom_preset_ != nullptr; }
 
  float current_temperature{NAN};
 
  float current_humidity{NAN};
 
  union {
    float target_temperature;
    struct {
      float target_temperature_low{NAN};
      float target_temperature_high{NAN};
    };
  };
 
  float target_humidity;
 
  optional<ClimateFanMode> fan_mode;
 
  optional<ClimatePreset> preset;
 
  ClimateMode mode{CLIMATE_MODE_OFF};
 
  ClimateAction action{CLIMATE_ACTION_OFF};
 
  ClimateSwingMode swing_mode{CLIMATE_SWING_OFF};
 
  StringRef get_custom_fan_mode() const { return StringRef::from_maybe_nullptr(this->custom_fan_mode_); }
 
  StringRef get_custom_preset() const { return StringRef::from_maybe_nullptr(this->custom_preset_); }
 
 protected:
  friend ClimateCall;
  friend struct ClimateDeviceRestoreState;
 
  bool set_fan_mode_(ClimateFanMode mode);
 
  bool set_custom_fan_mode_(const char *mode) { return this->set_custom_fan_mode_(mode, strlen(mode)); }
  bool set_custom_fan_mode_(const char *mode, size_t len);
  bool set_custom_fan_mode_(StringRef mode) { return this->set_custom_fan_mode_(mode.c_str(), mode.size()); }
  void clear_custom_fan_mode_();
 
  bool set_preset_(ClimatePreset preset);
 
  bool set_custom_preset_(const char *preset) { return this->set_custom_preset_(preset, strlen(preset)); }
  bool set_custom_preset_(const char *preset, size_t len);
  bool set_custom_preset_(StringRef preset) { return this->set_custom_preset_(preset.c_str(), preset.size()); }
  void clear_custom_preset_();
 
  const char *find_custom_fan_mode_(const char *custom_fan_mode);
  const char *find_custom_fan_mode_(const char *custom_fan_mode, size_t len);
 
  const char *find_custom_preset_(const char *custom_preset);
  const char *find_custom_preset_(const char *custom_preset, size_t len);
 
  virtual ClimateTraits traits() = 0;
 
  virtual void control(const ClimateCall &call) = 0;
  optional<ClimateDeviceRestoreState> restore_state_();
  void save_state_(const ClimateTraits &traits);
  void save_state_() { this->save_state_(this->get_traits()); }
 
  void dump_traits_(const char *tag);
 
  LazyCallbackManager<void(Climate &)> state_callback_{};
  LazyCallbackManager<void(ClimateCall &)> control_callback_{};
  ESPPreferenceObject rtc_;
 
#ifdef USE_CLIMATE_VISUAL_OVERRIDES
  float visual_min_temperature_override_{NAN};
  float visual_max_temperature_override_{NAN};
  float visual_target_temperature_step_override_{NAN};
  float visual_current_temperature_step_override_{NAN};
  float visual_min_humidity_override_{NAN};
  float visual_max_humidity_override_{NAN};
#endif
 
 private:
  std::vector<const char *> &ensure_custom_fan_modes_() {
    if (!this->supported_custom_fan_modes_) {
      this->supported_custom_fan_modes_ = new std::vector<const char *>();  // NOLINT
    }
    return *this->supported_custom_fan_modes_;
  }
  std::vector<const char *> &ensure_custom_presets_() {
    if (!this->supported_custom_presets_) {
      this->supported_custom_presets_ = new std::vector<const char *>();  // NOLINT
    }
    return *this->supported_custom_presets_;
  }
 
  std::vector<const char *> *supported_custom_fan_modes_{nullptr};
  std::vector<const char *> *supported_custom_presets_{nullptr};
 
  const char *custom_fan_mode_{nullptr};
 
  const char *custom_preset_{nullptr};
};
 
}  // namespace esphome::climate