thermostat_climate.h

Go to the documentation of this file.

#pragma once

#include "esphome/core/component.h"
#include "esphome/core/automation.h"
#include "esphome/components/climate/climate.h"
#include "esphome/components/sensor/sensor.h"

#include <map>
#include <vector>

namespace esphome {
namespace thermostat {

enum ThermostatClimateTimerIndex : size_t {
  TIMER_COOLING_MAX_RUN_TIME = 0,
  TIMER_COOLING_OFF = 1,
  TIMER_COOLING_ON = 2,
  TIMER_FAN_MODE = 3,
  TIMER_FANNING_OFF = 4,
  TIMER_FANNING_ON = 5,
  TIMER_HEATING_MAX_RUN_TIME = 6,
  TIMER_HEATING_OFF = 7,
  TIMER_HEATING_ON = 8,
  TIMER_IDLE_ON = 9,
};

enum OnBootRestoreFrom : size_t { MEMORY = 0, DEFAULT_PRESET = 1 };
struct ThermostatClimateTimer {
  const std::string name;
  bool active;
  uint32_t time;
  std::function<void()> func;
};

struct ThermostatClimateTargetTempConfig {
 public:
  ThermostatClimateTargetTempConfig();
  ThermostatClimateTargetTempConfig(float default_temperature);
  ThermostatClimateTargetTempConfig(float default_temperature_low, float default_temperature_high);

  void set_fan_mode(climate::ClimateFanMode fan_mode) { this->fan_mode_ = fan_mode; }
  void set_swing_mode(climate::ClimateSwingMode swing_mode) { this->swing_mode_ = swing_mode; }
  void set_mode(climate::ClimateMode mode) { this->mode_ = mode; }

  float default_temperature{NAN};
  float default_temperature_low{NAN};
  float default_temperature_high{NAN};
  float cool_deadband_{NAN};
  float cool_overrun_{NAN};
  float heat_deadband_{NAN};
  float heat_overrun_{NAN};
  optional<climate::ClimateFanMode> fan_mode_{};
  optional<climate::ClimateSwingMode> swing_mode_{};
  optional<climate::ClimateMode> mode_{};
};

class ThermostatClimate : public climate::Climate, public Component {
 public:
  ThermostatClimate();
  void setup() override;
  void dump_config() override;

  void set_default_preset(const std::string &custom_preset);
  void set_default_preset(climate::ClimatePreset preset);
  void set_on_boot_restore_from(thermostat::OnBootRestoreFrom on_boot_restore_from);
  void set_set_point_minimum_differential(float differential);
  void set_cool_deadband(float deadband);
  void set_cool_overrun(float overrun);
  void set_heat_deadband(float deadband);
  void set_heat_overrun(float overrun);
  void set_supplemental_cool_delta(float delta);
  void set_supplemental_heat_delta(float delta);
  void set_cooling_maximum_run_time_in_sec(uint32_t time);
  void set_heating_maximum_run_time_in_sec(uint32_t time);
  void set_cooling_minimum_off_time_in_sec(uint32_t time);
  void set_cooling_minimum_run_time_in_sec(uint32_t time);
  void set_fan_mode_minimum_switching_time_in_sec(uint32_t time);
  void set_fanning_minimum_off_time_in_sec(uint32_t time);
  void set_fanning_minimum_run_time_in_sec(uint32_t time);
  void set_heating_minimum_off_time_in_sec(uint32_t time);
  void set_heating_minimum_run_time_in_sec(uint32_t time);
  void set_idle_minimum_time_in_sec(uint32_t time);
  void set_sensor(sensor::Sensor *sensor);
  void set_use_startup_delay(bool use_startup_delay);
  void set_supports_auto(bool supports_auto);
  void set_supports_heat_cool(bool supports_heat_cool);
  void set_supports_cool(bool supports_cool);
  void set_supports_dry(bool supports_dry);
  void set_supports_fan_only(bool supports_fan_only);
  void set_supports_fan_only_action_uses_fan_mode_timer(bool fan_only_action_uses_fan_mode_timer);
  void set_supports_fan_only_cooling(bool supports_fan_only_cooling);
  void set_supports_fan_with_cooling(bool supports_fan_with_cooling);
  void set_supports_fan_with_heating(bool supports_fan_with_heating);
  void set_supports_heat(bool supports_heat);
  void set_supports_fan_mode_on(bool supports_fan_mode_on);
  void set_supports_fan_mode_off(bool supports_fan_mode_off);
  void set_supports_fan_mode_auto(bool supports_fan_mode_auto);
  void set_supports_fan_mode_low(bool supports_fan_mode_low);
  void set_supports_fan_mode_medium(bool supports_fan_mode_medium);
  void set_supports_fan_mode_high(bool supports_fan_mode_high);
  void set_supports_fan_mode_middle(bool supports_fan_mode_middle);
  void set_supports_fan_mode_focus(bool supports_fan_mode_focus);
  void set_supports_fan_mode_diffuse(bool supports_fan_mode_diffuse);
  void set_supports_swing_mode_both(bool supports_swing_mode_both);
  void set_supports_swing_mode_horizontal(bool supports_swing_mode_horizontal);
  void set_supports_swing_mode_off(bool supports_swing_mode_off);
  void set_supports_swing_mode_vertical(bool supports_swing_mode_vertical);
  void set_supports_two_points(bool supports_two_points);

  void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config);
  void set_custom_preset_config(const std::string &name, const ThermostatClimateTargetTempConfig &config);

  Trigger<> *get_cool_action_trigger() const;
  Trigger<> *get_supplemental_cool_action_trigger() const;
  Trigger<> *get_dry_action_trigger() const;
  Trigger<> *get_fan_only_action_trigger() const;
  Trigger<> *get_heat_action_trigger() const;
  Trigger<> *get_supplemental_heat_action_trigger() const;
  Trigger<> *get_idle_action_trigger() const;
  Trigger<> *get_auto_mode_trigger() const;
  Trigger<> *get_cool_mode_trigger() const;
  Trigger<> *get_dry_mode_trigger() const;
  Trigger<> *get_fan_only_mode_trigger() const;
  Trigger<> *get_heat_mode_trigger() const;
  Trigger<> *get_off_mode_trigger() const;
  Trigger<> *get_fan_mode_on_trigger() const;
  Trigger<> *get_fan_mode_off_trigger() const;
  Trigger<> *get_fan_mode_auto_trigger() const;
  Trigger<> *get_fan_mode_low_trigger() const;
  Trigger<> *get_fan_mode_medium_trigger() const;
  Trigger<> *get_fan_mode_high_trigger() const;
  Trigger<> *get_fan_mode_middle_trigger() const;
  Trigger<> *get_fan_mode_focus_trigger() const;
  Trigger<> *get_fan_mode_diffuse_trigger() const;
  Trigger<> *get_swing_mode_both_trigger() const;
  Trigger<> *get_swing_mode_horizontal_trigger() const;
  Trigger<> *get_swing_mode_off_trigger() const;
  Trigger<> *get_swing_mode_vertical_trigger() const;
  Trigger<> *get_temperature_change_trigger() const;
  Trigger<> *get_preset_change_trigger() const;
  float cool_deadband();
  float cool_overrun();
  float heat_deadband();
  float heat_overrun();
  void refresh();
  bool climate_action_change_delayed();
  bool fan_mode_change_delayed();
  climate::ClimateAction delayed_climate_action();
  climate::ClimateFanMode locked_fan_mode();
  bool hysteresis_valid();  // returns true if valid
  void validate_target_temperature();
  void validate_target_temperatures();
  void validate_target_temperature_low();
  void validate_target_temperature_high();

 protected:
  void control(const climate::ClimateCall &call) override;

  void change_preset_(climate::ClimatePreset preset);
  void change_custom_preset_(const std::string &custom_preset);

  bool change_preset_internal_(const ThermostatClimateTargetTempConfig &config);

  climate::ClimateTraits traits() override;

  climate::ClimateAction compute_action_(bool ignore_timers = false);
  climate::ClimateAction compute_supplemental_action_();

  void switch_to_action_(climate::ClimateAction action, bool publish_state = true);
  void switch_to_supplemental_action_(climate::ClimateAction action);
  void trigger_supplemental_action_();

  void switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bool publish_state = true);

  void switch_to_mode_(climate::ClimateMode mode, bool publish_state = true);

  void switch_to_swing_mode_(climate::ClimateSwingMode swing_mode, bool publish_state = true);

  void check_temperature_change_trigger_();

  bool idle_action_ready_();
  bool cooling_action_ready_();
  bool drying_action_ready_();
  bool fan_mode_ready_();
  bool fanning_action_ready_();
  bool heating_action_ready_();

  void start_timer_(ThermostatClimateTimerIndex timer_index);
  bool cancel_timer_(ThermostatClimateTimerIndex timer_index);
  bool timer_active_(ThermostatClimateTimerIndex timer_index);
  uint32_t timer_duration_(ThermostatClimateTimerIndex timer_index);
  std::function<void()> timer_cbf_(ThermostatClimateTimerIndex timer_index);

  void cooling_max_run_time_timer_callback_();
  void cooling_off_timer_callback_();
  void cooling_on_timer_callback_();
  void fan_mode_timer_callback_();
  void fanning_off_timer_callback_();
  void fanning_on_timer_callback_();
  void heating_max_run_time_timer_callback_();
  void heating_off_timer_callback_();
  void heating_on_timer_callback_();
  void idle_on_timer_callback_();

  bool cooling_required_();
  bool fanning_required_();
  bool heating_required_();
  bool supplemental_cooling_required_();
  bool supplemental_heating_required_();

  void dump_preset_config_(const char *preset_name, const ThermostatClimateTargetTempConfig &config,
                           bool is_default_preset);

  sensor::Sensor *sensor_{nullptr};

  bool supports_auto_{false};
  bool supports_heat_cool_{false};
  bool supports_cool_{false};
  bool supports_dry_{false};
  bool supports_fan_only_{false};
  bool supports_heat_{false};
  bool supports_fan_only_action_uses_fan_mode_timer_{false};
  bool supports_fan_only_cooling_{false};
  bool supports_fan_with_cooling_{false};
  bool supports_fan_with_heating_{false};

  bool supports_fan_mode_on_{false};
  bool supports_fan_mode_off_{false};

  bool supports_fan_mode_auto_{false};

  bool supports_fan_mode_low_{false};
  bool supports_fan_mode_medium_{false};
  bool supports_fan_mode_high_{false};
  bool supports_fan_mode_middle_{false};
  bool supports_fan_mode_focus_{false};
  bool supports_fan_mode_diffuse_{false};

  bool supports_swing_mode_both_{false};
  bool supports_swing_mode_off_{false};
  bool supports_swing_mode_horizontal_{false};
  bool supports_swing_mode_vertical_{false};

  bool supports_two_points_{false};

  bool cooling_max_runtime_exceeded_{false};
  bool heating_max_runtime_exceeded_{false};

  bool use_startup_delay_{false};

  bool setup_complete_{false};

  Trigger<> *cool_action_trigger_{nullptr};
  Trigger<> *supplemental_cool_action_trigger_{nullptr};
  Trigger<> *cool_mode_trigger_{nullptr};

  Trigger<> *dry_action_trigger_{nullptr};
  Trigger<> *dry_mode_trigger_{nullptr};

  Trigger<> *heat_action_trigger_{nullptr};
  Trigger<> *supplemental_heat_action_trigger_{nullptr};
  Trigger<> *heat_mode_trigger_{nullptr};

  Trigger<> *auto_mode_trigger_{nullptr};

  Trigger<> *idle_action_trigger_{nullptr};
  Trigger<> *off_mode_trigger_{nullptr};

  Trigger<> *fan_only_action_trigger_{nullptr};
  Trigger<> *fan_only_mode_trigger_{nullptr};

  Trigger<> *fan_mode_on_trigger_{nullptr};

  Trigger<> *fan_mode_off_trigger_{nullptr};

  Trigger<> *fan_mode_auto_trigger_{nullptr};

  Trigger<> *fan_mode_low_trigger_{nullptr};

  Trigger<> *fan_mode_medium_trigger_{nullptr};

  Trigger<> *fan_mode_high_trigger_{nullptr};

  Trigger<> *fan_mode_middle_trigger_{nullptr};

  Trigger<> *fan_mode_focus_trigger_{nullptr};

  Trigger<> *fan_mode_diffuse_trigger_{nullptr};

  Trigger<> *swing_mode_both_trigger_{nullptr};

  Trigger<> *swing_mode_off_trigger_{nullptr};

  Trigger<> *swing_mode_horizontal_trigger_{nullptr};

  Trigger<> *swing_mode_vertical_trigger_{nullptr};

  Trigger<> *temperature_change_trigger_{nullptr};

  Trigger<> *preset_change_trigger_{nullptr};

  Trigger<> *prev_action_trigger_{nullptr};
  Trigger<> *prev_fan_mode_trigger_{nullptr};
  Trigger<> *prev_mode_trigger_{nullptr};
  Trigger<> *prev_swing_mode_trigger_{nullptr};

  climate::ClimateAction supplemental_action_{climate::CLIMATE_ACTION_OFF};
  climate::ClimateFanMode prev_fan_mode_{climate::CLIMATE_FAN_ON};
  climate::ClimateMode prev_mode_{climate::CLIMATE_MODE_OFF};
  climate::ClimateSwingMode prev_swing_mode_{climate::CLIMATE_SWING_OFF};

  float prev_target_temperature_{NAN};
  float prev_target_temperature_low_{NAN};
  float prev_target_temperature_high_{NAN};

  float set_point_minimum_differential_{0};

  float cooling_deadband_{0};
  float cooling_overrun_{0};
  float heating_deadband_{0};
  float heating_overrun_{0};

  float supplemental_cool_delta_{0};
  float supplemental_heat_delta_{0};

  const uint8_t min_timer_duration_{1};

  std::vector<ThermostatClimateTimer> timer_{
      {"cool_run", false, 0, std::bind(&ThermostatClimate::cooling_max_run_time_timer_callback_, this)},
      {"cool_off", false, 0, std::bind(&ThermostatClimate::cooling_off_timer_callback_, this)},
      {"cool_on", false, 0, std::bind(&ThermostatClimate::cooling_on_timer_callback_, this)},
      {"fan_mode", false, 0, std::bind(&ThermostatClimate::fan_mode_timer_callback_, this)},
      {"fan_off", false, 0, std::bind(&ThermostatClimate::fanning_off_timer_callback_, this)},
      {"fan_on", false, 0, std::bind(&ThermostatClimate::fanning_on_timer_callback_, this)},
      {"heat_run", false, 0, std::bind(&ThermostatClimate::heating_max_run_time_timer_callback_, this)},
      {"heat_off", false, 0, std::bind(&ThermostatClimate::heating_off_timer_callback_, this)},
      {"heat_on", false, 0, std::bind(&ThermostatClimate::heating_on_timer_callback_, this)},
      {"idle_on", false, 0, std::bind(&ThermostatClimate::idle_on_timer_callback_, this)}};

  std::map<climate::ClimatePreset, ThermostatClimateTargetTempConfig> preset_config_{};
  std::map<std::string, ThermostatClimateTargetTempConfig> custom_preset_config_{};

  climate::ClimatePreset default_preset_{};
  std::string default_custom_preset_{};

  thermostat::OnBootRestoreFrom on_boot_restore_from_{thermostat::OnBootRestoreFrom::MEMORY};
};

}  // namespace thermostat
}  // namespace esphome