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;
    };
  };
  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