climate.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/helpers.h"
#include "esphome/core/preferences.h"
#include "esphome/core/log.h"
#include "climate_mode.h"
#include "climate_traits.h"
 
namespace esphome {
namespace 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) {}
 
  ClimateCall &set_mode(ClimateMode mode);
  ClimateCall &set_mode(optional<ClimateMode> mode);
  ClimateCall &set_mode(const std::string &mode);
  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_swing_mode(ClimateSwingMode swing_mode);
  ClimateCall &set_swing_mode(optional<ClimateSwingMode> swing_mode);
  ClimateCall &set_swing_mode(const std::string &swing_mode);
  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);
 
  void perform();
 
  const optional<ClimateMode> &get_mode() const;
  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<ClimateFanMode> &get_fan_mode() const;
  const optional<ClimateSwingMode> &get_swing_mode() const;
  const optional<std::string> &get_custom_fan_mode() const;
  const optional<ClimatePreset> &get_preset() const;
  const optional<std::string> &get_custom_preset() const;
 
 protected:
  void validate_();
 
  Climate *const parent_;
  optional<ClimateMode> mode_;
  optional<float> target_temperature_;
  optional<float> target_temperature_low_;
  optional<float> target_temperature_high_;
  optional<float> target_humidity_;
  optional<ClimateFanMode> fan_mode_;
  optional<ClimateSwingMode> swing_mode_;
  optional<std::string> custom_fan_mode_;
  optional<ClimatePreset> preset_;
  optional<std::string> custom_preset_;
};
 
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() {}
 
  ClimateMode mode{CLIMATE_MODE_OFF};
 
  ClimateAction action{CLIMATE_ACTION_OFF};
 
  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;
 
  ClimateSwingMode swing_mode;
 
  optional<std::string> custom_fan_mode;
 
  optional<ClimatePreset> preset;
 
  optional<std::string> custom_preset;
 
  void add_on_state_callback(std::function<void(Climate &)> &&callback);
 
  void add_on_control_callback(std::function<void(ClimateCall &)> &&callback);
 
  ClimateCall make_call();
 
  void publish_state();
 
  ClimateTraits get_traits();
 
  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);
 
 protected:
  friend ClimateCall;
 
  bool set_fan_mode_(ClimateFanMode mode);
 
  bool set_custom_fan_mode_(const std::string &mode);
 
  bool set_preset_(ClimatePreset preset);
 
  bool set_custom_preset_(const std::string &preset);
 
  virtual ClimateTraits traits() = 0;
 
  virtual void control(const ClimateCall &call) = 0;
  optional<ClimateDeviceRestoreState> restore_state_();
  void save_state_();
 
  void dump_traits_(const char *tag);
 
  CallbackManager<void(Climate &)> state_callback_{};
  CallbackManager<void(ClimateCall &)> control_callback_{};
  ESPPreferenceObject rtc_;
  optional<float> visual_min_temperature_override_{};
  optional<float> visual_max_temperature_override_{};
  optional<float> visual_target_temperature_step_override_{};
  optional<float> visual_current_temperature_step_override_{};
  optional<float> visual_min_humidity_override_{};
  optional<float> visual_max_humidity_override_{};
};
 
}  // namespace climate
}  // namespace esphome