From a33ed5e47b6ab889028650141e06053624b56e1b Mon Sep 17 00:00:00 2001 From: Keith Burzinski Date: Sat, 18 Oct 2025 22:25:53 -0500 Subject: [PATCH] [thermostat] Add humidity support (#11286) --- esphome/components/thermostat/climate.py | 59 +++++- .../thermostat/thermostat_climate.cpp | 168 +++++++++++++++++- .../thermostat/thermostat_climate.h | 53 +++++- tests/components/thermostat/common.yaml | 5 + 4 files changed, 278 insertions(+), 7 deletions(-) diff --git a/esphome/components/thermostat/climate.py b/esphome/components/thermostat/climate.py index 57abbc67b9..a928d208f3 100644 --- a/esphome/components/thermostat/climate.py +++ b/esphome/components/thermostat/climate.py @@ -71,9 +71,14 @@ from esphome.const import ( CONF_VISUAL, ) -CONF_PRESET_CHANGE = "preset_change" CONF_DEFAULT_PRESET = "default_preset" +CONF_HUMIDITY_CONTROL_DEHUMIDIFY_ACTION = "humidity_control_dehumidify_action" +CONF_HUMIDITY_CONTROL_HUMIDIFY_ACTION = "humidity_control_humidify_action" +CONF_HUMIDITY_CONTROL_OFF_ACTION = "humidity_control_off_action" +CONF_HUMIDITY_HYSTERESIS = "humidity_hysteresis" CONF_ON_BOOT_RESTORE_FROM = "on_boot_restore_from" +CONF_PRESET_CHANGE = "preset_change" +CONF_TARGET_HUMIDITY_CHANGE_ACTION = "target_humidity_change_action" CODEOWNERS = ["@kbx81"] @@ -241,6 +246,14 @@ def validate_thermostat(config): CONF_MAX_HEATING_RUN_TIME, CONF_SUPPLEMENTAL_HEATING_ACTION, ], + CONF_HUMIDITY_CONTROL_DEHUMIDIFY_ACTION: [ + CONF_HUMIDITY_CONTROL_OFF_ACTION, + CONF_HUMIDITY_SENSOR, + ], + CONF_HUMIDITY_CONTROL_HUMIDIFY_ACTION: [ + CONF_HUMIDITY_CONTROL_OFF_ACTION, + CONF_HUMIDITY_SENSOR, + ], } for config_trigger, req_triggers in requirements.items(): for req_trigger in req_triggers: @@ -338,7 +351,7 @@ def validate_thermostat(config): # Warn about using the removed CONF_DEFAULT_MODE and advise users if CONF_DEFAULT_MODE in config and config[CONF_DEFAULT_MODE] is not None: raise cv.Invalid( - f"{CONF_DEFAULT_MODE} is no longer valid. Please switch to using presets and specify a {CONF_DEFAULT_PRESET}." + f"{CONF_DEFAULT_MODE} is no longer valid. Please switch to using presets and specify a {CONF_DEFAULT_PRESET}" ) default_mode = config[CONF_DEFAULT_MODE] @@ -588,9 +601,24 @@ CONFIG_SCHEMA = cv.All( cv.Optional(CONF_SWING_VERTICAL_ACTION): automation.validate_automation( single=True ), + cv.Optional( + CONF_TARGET_HUMIDITY_CHANGE_ACTION + ): automation.validate_automation(single=True), cv.Optional( CONF_TARGET_TEMPERATURE_CHANGE_ACTION ): automation.validate_automation(single=True), + cv.Exclusive( + CONF_HUMIDITY_CONTROL_DEHUMIDIFY_ACTION, + group_of_exclusion="humidity_control", + ): automation.validate_automation(single=True), + cv.Exclusive( + CONF_HUMIDITY_CONTROL_HUMIDIFY_ACTION, + group_of_exclusion="humidity_control", + ): automation.validate_automation(single=True), + cv.Optional( + CONF_HUMIDITY_CONTROL_OFF_ACTION + ): automation.validate_automation(single=True), + cv.Optional(CONF_HUMIDITY_HYSTERESIS, default=1.0): cv.percentage, cv.Optional(CONF_DEFAULT_MODE, default=None): cv.valid, cv.Optional(CONF_DEFAULT_PRESET): cv.templatable(cv.string), cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature, @@ -882,12 +910,39 @@ async def to_code(config): config[CONF_SWING_VERTICAL_ACTION], ) cg.add(var.set_supports_swing_mode_vertical(True)) + if CONF_TARGET_HUMIDITY_CHANGE_ACTION in config: + await automation.build_automation( + var.get_humidity_change_trigger(), + [], + config[CONF_TARGET_HUMIDITY_CHANGE_ACTION], + ) if CONF_TARGET_TEMPERATURE_CHANGE_ACTION in config: await automation.build_automation( var.get_temperature_change_trigger(), [], config[CONF_TARGET_TEMPERATURE_CHANGE_ACTION], ) + if CONF_HUMIDITY_CONTROL_DEHUMIDIFY_ACTION in config: + cg.add(var.set_supports_dehumidification(True)) + await automation.build_automation( + var.get_humidity_control_dehumidify_action_trigger(), + [], + config[CONF_HUMIDITY_CONTROL_DEHUMIDIFY_ACTION], + ) + if CONF_HUMIDITY_CONTROL_HUMIDIFY_ACTION in config: + cg.add(var.set_supports_humidification(True)) + await automation.build_automation( + var.get_humidity_control_humidify_action_trigger(), + [], + config[CONF_HUMIDITY_CONTROL_HUMIDIFY_ACTION], + ) + if CONF_HUMIDITY_CONTROL_OFF_ACTION in config: + await automation.build_automation( + var.get_humidity_control_off_action_trigger(), + [], + config[CONF_HUMIDITY_CONTROL_OFF_ACTION], + ) + cg.add(var.set_humidity_hysteresis(config[CONF_HUMIDITY_HYSTERESIS])) if CONF_PRESET in config: for preset_config in config[CONF_PRESET]: diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp index 784b3cfb50..18efe3984e 100644 --- a/esphome/components/thermostat/thermostat_climate.cpp +++ b/esphome/components/thermostat/thermostat_climate.cpp @@ -32,6 +32,7 @@ void ThermostatClimate::setup() { if (this->humidity_sensor_ != nullptr) { this->humidity_sensor_->add_on_state_callback([this](float state) { this->current_humidity = state; + this->switch_to_humidity_control_action_(this->compute_humidity_control_action_()); this->publish_state(); }); this->current_humidity = this->humidity_sensor_->state; @@ -84,6 +85,8 @@ void ThermostatClimate::refresh() { this->switch_to_supplemental_action_(this->compute_supplemental_action_()); this->switch_to_fan_mode_(this->fan_mode.value(), false); this->switch_to_swing_mode_(this->swing_mode, false); + this->switch_to_humidity_control_action_(this->compute_humidity_control_action_()); + this->check_humidity_change_trigger_(); this->check_temperature_change_trigger_(); this->publish_state(); } @@ -129,6 +132,11 @@ bool ThermostatClimate::hysteresis_valid() { return true; } +bool ThermostatClimate::humidity_hysteresis_valid() { + return !std::isnan(this->humidity_hysteresis_) && this->humidity_hysteresis_ >= 0.0f && + this->humidity_hysteresis_ < 100.0f; +} + bool ThermostatClimate::limit_setpoints_for_heat_cool() { return this->mode == climate::CLIMATE_MODE_HEAT_COOL || (this->mode == climate::CLIMATE_MODE_AUTO && this->supports_heat_cool_); @@ -189,6 +197,16 @@ void ThermostatClimate::validate_target_temperature_high() { } } +void ThermostatClimate::validate_target_humidity() { + if (std::isnan(this->target_humidity)) { + this->target_humidity = + (this->get_traits().get_visual_max_humidity() - this->get_traits().get_visual_min_humidity()) / 2.0f; + } else { + this->target_humidity = clamp(this->target_humidity, this->get_traits().get_visual_min_humidity(), + this->get_traits().get_visual_max_humidity()); + } +} + void ThermostatClimate::control(const climate::ClimateCall &call) { bool target_temperature_high_changed = false; @@ -235,6 +253,10 @@ void ThermostatClimate::control(const climate::ClimateCall &call) { this->validate_target_temperature(); } } + if (call.get_target_humidity().has_value()) { + this->target_humidity = call.get_target_humidity().value(); + this->validate_target_humidity(); + } // make any changes happen this->refresh(); } @@ -250,6 +272,9 @@ climate::ClimateTraits ThermostatClimate::traits() { if (this->humidity_sensor_ != nullptr) traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY); + if (this->supports_humidification_ || this->supports_dehumidification_) + traits.add_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY); + if (this->supports_auto_) traits.add_supported_mode(climate::CLIMATE_MODE_AUTO); if (this->supports_heat_cool_) @@ -423,6 +448,28 @@ climate::ClimateAction ThermostatClimate::compute_supplemental_action_() { return target_action; } +HumidificationAction ThermostatClimate::compute_humidity_control_action_() { + auto target_action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF; + // if hysteresis value or current_humidity is not valid, we go to OFF + if (std::isnan(this->current_humidity) || !this->humidity_hysteresis_valid()) { + return THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF; + } + + // ensure set point is valid before computing the action + this->validate_target_humidity(); + // everything has been validated so we can now safely compute the action + if (this->dehumidification_required_() && this->humidification_required_()) { + // this is bad and should never happen, so just stop. + // target_action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF; + } else if (this->supports_dehumidification_ && this->dehumidification_required_()) { + target_action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY; + } else if (this->supports_humidification_ && this->humidification_required_()) { + target_action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY; + } + + return target_action; +} + void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool publish_state) { // setup_complete_ helps us ensure an action is called immediately after boot if ((action == this->action) && this->setup_complete_) { @@ -596,6 +643,44 @@ void ThermostatClimate::trigger_supplemental_action_() { } } +void ThermostatClimate::switch_to_humidity_control_action_(HumidificationAction action) { + // setup_complete_ helps us ensure an action is called immediately after boot + if ((action == this->humidification_action_) && this->setup_complete_) { + // already in target mode + return; + } + + Trigger<> *trig = this->humidity_control_off_action_trigger_; + switch (action) { + case THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF: + // trig = this->humidity_control_off_action_trigger_; + ESP_LOGVV(TAG, "Switching to HUMIDIFICATION_OFF action"); + break; + case THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY: + trig = this->humidity_control_dehumidify_action_trigger_; + ESP_LOGVV(TAG, "Switching to DEHUMIDIFY action"); + break; + case THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY: + trig = this->humidity_control_humidify_action_trigger_; + ESP_LOGVV(TAG, "Switching to HUMIDIFY action"); + break; + case THERMOSTAT_HUMIDITY_CONTROL_ACTION_NONE: + default: + action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF; + // trig = this->humidity_control_off_action_trigger_; + } + + if (this->prev_humidity_control_trigger_ != nullptr) { + this->prev_humidity_control_trigger_->stop_action(); + this->prev_humidity_control_trigger_ = nullptr; + } + this->humidification_action_ = action; + this->prev_humidity_control_trigger_ = trig; + if (trig != nullptr) { + trig->trigger(); + } +} + void ThermostatClimate::switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bool publish_state) { // setup_complete_ helps us ensure an action is called immediately after boot if ((fan_mode == this->prev_fan_mode_) && this->setup_complete_) { @@ -887,6 +972,20 @@ void ThermostatClimate::idle_on_timer_callback_() { this->switch_to_supplemental_action_(this->compute_supplemental_action_()); } +void ThermostatClimate::check_humidity_change_trigger_() { + if ((this->prev_target_humidity_ == this->target_humidity) && this->setup_complete_) { + return; // nothing changed, no reason to trigger + } else { + // save the new temperature so we can check it again later; the trigger will fire below + this->prev_target_humidity_ = this->target_humidity; + } + // trigger the action + Trigger<> *trig = this->humidity_change_trigger_; + if (trig != nullptr) { + trig->trigger(); + } +} + void ThermostatClimate::check_temperature_change_trigger_() { if (this->supports_two_points_) { // setup_complete_ helps us ensure an action is called immediately after boot @@ -996,6 +1095,32 @@ bool ThermostatClimate::supplemental_heating_required_() { (this->supplemental_action_ == climate::CLIMATE_ACTION_HEATING)); } +bool ThermostatClimate::dehumidification_required_() { + if (this->current_humidity > this->target_humidity + this->humidity_hysteresis_) { + // if the current humidity exceeds the target + hysteresis, dehumidification is required + return true; + } else if (this->current_humidity < this->target_humidity - this->humidity_hysteresis_) { + // if the current humidity is less than the target - hysteresis, dehumidification should stop + return false; + } + // if we get here, the current humidity is between target + hysteresis and target - hysteresis, + // so the action should not change + return this->humidification_action_ == THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY; +} + +bool ThermostatClimate::humidification_required_() { + if (this->current_humidity < this->target_humidity - this->humidity_hysteresis_) { + // if the current humidity is below the target - hysteresis, humidification is required + return true; + } else if (this->current_humidity > this->target_humidity + this->humidity_hysteresis_) { + // if the current humidity is above the target + hysteresis, humidification should stop + return false; + } + // if we get here, the current humidity is between target - hysteresis and target + hysteresis, + // so the action should not change + return this->humidification_action_ == THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY; +} + void ThermostatClimate::dump_preset_config_(const char *preset_name, const ThermostatClimateTargetTempConfig &config) { if (this->supports_heat_) { ESP_LOGCONFIG(TAG, " Default Target Temperature Low: %.1f°C", @@ -1152,8 +1277,12 @@ ThermostatClimate::ThermostatClimate() swing_mode_off_trigger_(new Trigger<>()), swing_mode_horizontal_trigger_(new Trigger<>()), swing_mode_vertical_trigger_(new Trigger<>()), + humidity_change_trigger_(new Trigger<>()), temperature_change_trigger_(new Trigger<>()), - preset_change_trigger_(new Trigger<>()) {} + preset_change_trigger_(new Trigger<>()), + humidity_control_dehumidify_action_trigger_(new Trigger<>()), + humidity_control_humidify_action_trigger_(new Trigger<>()), + humidity_control_off_action_trigger_(new Trigger<>()) {} void ThermostatClimate::set_default_preset(const std::string &custom_preset) { this->default_custom_preset_ = custom_preset; @@ -1217,6 +1346,9 @@ void ThermostatClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sen void ThermostatClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; } +void ThermostatClimate::set_humidity_hysteresis(float humidity_hysteresis) { + this->humidity_hysteresis_ = std::clamp(humidity_hysteresis, 0.0f, 100.0f); +} void ThermostatClimate::set_use_startup_delay(bool use_startup_delay) { this->use_startup_delay_ = use_startup_delay; } void ThermostatClimate::set_supports_heat_cool(bool supports_heat_cool) { this->supports_heat_cool_ = supports_heat_cool; @@ -1284,6 +1416,18 @@ void ThermostatClimate::set_supports_swing_mode_vertical(bool supports_swing_mod void ThermostatClimate::set_supports_two_points(bool supports_two_points) { this->supports_two_points_ = supports_two_points; } +void ThermostatClimate::set_supports_dehumidification(bool supports_dehumidification) { + this->supports_dehumidification_ = supports_dehumidification; + if (supports_dehumidification) { + this->supports_humidification_ = false; + } +} +void ThermostatClimate::set_supports_humidification(bool supports_humidification) { + this->supports_humidification_ = supports_humidification; + if (supports_humidification) { + this->supports_dehumidification_ = false; + } +} Trigger<> *ThermostatClimate::get_cool_action_trigger() const { return this->cool_action_trigger_; } Trigger<> *ThermostatClimate::get_supplemental_cool_action_trigger() const { @@ -1317,8 +1461,18 @@ Trigger<> *ThermostatClimate::get_swing_mode_both_trigger() const { return this- Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() const { return this->swing_mode_off_trigger_; } Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() const { return this->swing_mode_horizontal_trigger_; } Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() const { return this->swing_mode_vertical_trigger_; } +Trigger<> *ThermostatClimate::get_humidity_change_trigger() const { return this->humidity_change_trigger_; } Trigger<> *ThermostatClimate::get_temperature_change_trigger() const { return this->temperature_change_trigger_; } Trigger<> *ThermostatClimate::get_preset_change_trigger() const { return this->preset_change_trigger_; } +Trigger<> *ThermostatClimate::get_humidity_control_dehumidify_action_trigger() const { + return this->humidity_control_dehumidify_action_trigger_; +} +Trigger<> *ThermostatClimate::get_humidity_control_humidify_action_trigger() const { + return this->humidity_control_humidify_action_trigger_; +} +Trigger<> *ThermostatClimate::get_humidity_control_off_action_trigger() const { + return this->humidity_control_off_action_trigger_; +} void ThermostatClimate::dump_config() { LOG_CLIMATE("", "Thermostat", this); @@ -1422,7 +1576,12 @@ void ThermostatClimate::dump_config() { " OFF: %s\n" " HORIZONTAL: %s\n" " VERTICAL: %s\n" - " Supports TWO SET POINTS: %s", + " Supports TWO SET POINTS: %s\n" + " Supported Humidity Parameters:\n" + " CURRENT: %s\n" + " TARGET: %s\n" + " DEHUMIDIFICATION: %s\n" + " HUMIDIFICATION: %s", YESNO(this->supports_fan_mode_on_), YESNO(this->supports_fan_mode_off_), YESNO(this->supports_fan_mode_auto_), YESNO(this->supports_fan_mode_low_), YESNO(this->supports_fan_mode_medium_), YESNO(this->supports_fan_mode_high_), @@ -1430,7 +1589,10 @@ void ThermostatClimate::dump_config() { YESNO(this->supports_fan_mode_diffuse_), YESNO(this->supports_fan_mode_quiet_), YESNO(this->supports_swing_mode_both_), YESNO(this->supports_swing_mode_off_), YESNO(this->supports_swing_mode_horizontal_), YESNO(this->supports_swing_mode_vertical_), - YESNO(this->supports_two_points_)); + YESNO(this->supports_two_points_), + YESNO(this->get_traits().has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY)), + YESNO(this->supports_dehumidification_ || this->supports_humidification_), + YESNO(this->supports_dehumidification_), YESNO(this->supports_humidification_)); if (!this->preset_config_.empty()) { ESP_LOGCONFIG(TAG, " Supported PRESETS:"); diff --git a/esphome/components/thermostat/thermostat_climate.h b/esphome/components/thermostat/thermostat_climate.h index 526f07116e..363d2b09fc 100644 --- a/esphome/components/thermostat/thermostat_climate.h +++ b/esphome/components/thermostat/thermostat_climate.h @@ -13,6 +13,13 @@ namespace esphome { namespace thermostat { +enum HumidificationAction : uint8_t { + THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF = 0, + THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY = 1, + THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY = 2, + THERMOSTAT_HUMIDITY_CONTROL_ACTION_NONE, +}; + enum ThermostatClimateTimerIndex : uint8_t { THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME = 0, THERMOSTAT_TIMER_COOLING_OFF = 1, @@ -90,6 +97,7 @@ class ThermostatClimate : public climate::Climate, public Component { void set_idle_minimum_time_in_sec(uint32_t time); void set_sensor(sensor::Sensor *sensor); void set_humidity_sensor(sensor::Sensor *humidity_sensor); + void set_humidity_hysteresis(float humidity_hysteresis); 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); @@ -115,6 +123,8 @@ class ThermostatClimate : public climate::Climate, public Component { 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_dehumidification(bool supports_dehumidification); + void set_supports_humidification(bool supports_humidification); void set_supports_two_points(bool supports_two_points); void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config); @@ -148,8 +158,12 @@ class ThermostatClimate : public climate::Climate, public Component { Trigger<> *get_swing_mode_horizontal_trigger() const; Trigger<> *get_swing_mode_off_trigger() const; Trigger<> *get_swing_mode_vertical_trigger() const; + Trigger<> *get_humidity_change_trigger() const; Trigger<> *get_temperature_change_trigger() const; Trigger<> *get_preset_change_trigger() const; + Trigger<> *get_humidity_control_dehumidify_action_trigger() const; + Trigger<> *get_humidity_control_humidify_action_trigger() const; + Trigger<> *get_humidity_control_off_action_trigger() const; /// Get current hysteresis values float cool_deadband(); float cool_overrun(); @@ -166,11 +180,13 @@ class ThermostatClimate : public climate::Climate, public Component { climate::ClimateFanMode locked_fan_mode(); /// Set point and hysteresis validation bool hysteresis_valid(); // returns true if valid + bool humidity_hysteresis_valid(); // returns true if valid bool limit_setpoints_for_heat_cool(); // returns true if set points should be further limited within visual range void validate_target_temperature(); void validate_target_temperatures(bool pin_target_temperature_high); void validate_target_temperature_low(); void validate_target_temperature_high(); + void validate_target_humidity(); protected: /// Override control to change settings of the climate device. @@ -192,11 +208,13 @@ class ThermostatClimate : public climate::Climate, public Component { /// Re-compute the required action of this climate controller. climate::ClimateAction compute_action_(bool ignore_timers = false); climate::ClimateAction compute_supplemental_action_(); + HumidificationAction compute_humidity_control_action_(); /// Switch the climate device to the given climate 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_humidity_control_action_(HumidificationAction action); /// Switch the climate device to the given climate fan mode. void switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bool publish_state = true); @@ -207,6 +225,9 @@ class ThermostatClimate : public climate::Climate, public Component { /// Switch the climate device to the given climate swing mode. void switch_to_swing_mode_(climate::ClimateSwingMode swing_mode, bool publish_state = true); + /// Check if the humidity change trigger should be called. + void check_humidity_change_trigger_(); + /// Check if the temperature change trigger should be called. void check_temperature_change_trigger_(); @@ -243,6 +264,8 @@ class ThermostatClimate : public climate::Climate, public Component { bool heating_required_(); bool supplemental_cooling_required_(); bool supplemental_heating_required_(); + bool dehumidification_required_(); + bool humidification_required_(); void dump_preset_config_(const char *preset_name, const ThermostatClimateTargetTempConfig &config); @@ -259,6 +282,9 @@ class ThermostatClimate : public climate::Climate, public Component { /// The current supplemental action climate::ClimateAction supplemental_action_{climate::CLIMATE_ACTION_OFF}; + /// The current humidification action + HumidificationAction humidification_action_{THERMOSTAT_HUMIDITY_CONTROL_ACTION_NONE}; + /// Default standard preset to use on start up climate::ClimatePreset default_preset_{}; @@ -321,6 +347,12 @@ class ThermostatClimate : public climate::Climate, public Component { /// A false value means that the controller has no such support. bool supports_two_points_{false}; + /// Whether the controller supports dehumidification and/or humidification + /// + /// A false value means that the controller has no such support. + bool supports_dehumidification_{false}; + bool supports_humidification_{false}; + /// Flags indicating if maximum allowable run time was exceeded bool cooling_max_runtime_exceeded_{false}; bool heating_max_runtime_exceeded_{false}; @@ -331,9 +363,10 @@ class ThermostatClimate : public climate::Climate, public Component { /// setup_complete_ blocks modifying/resetting the temps immediately after boot bool setup_complete_{false}; - /// Store previously-known temperatures + /// Store previously-known humidity and temperatures /// - /// These are used to determine when the temperature change trigger/action needs to be called + /// These are used to determine when a temperature/humidity has changed + float prev_target_humidity_{NAN}; float prev_target_temperature_{NAN}; float prev_target_temperature_low_{NAN}; float prev_target_temperature_high_{NAN}; @@ -347,6 +380,9 @@ class ThermostatClimate : public climate::Climate, public Component { float heating_deadband_{0}; float heating_overrun_{0}; + /// Hysteresis values used for computing humidification action + float humidity_hysteresis_{0}; + /// Maximum allowable temperature deltas before engaging supplemental cooling/heating actions float supplemental_cool_delta_{0}; float supplemental_heat_delta_{0}; @@ -448,12 +484,24 @@ class ThermostatClimate : public climate::Climate, public Component { /// The trigger to call when the controller should switch the swing mode to "vertical". Trigger<> *swing_mode_vertical_trigger_{nullptr}; + /// The trigger to call when the target humidity changes. + Trigger<> *humidity_change_trigger_{nullptr}; + /// The trigger to call when the target temperature(s) change(es). Trigger<> *temperature_change_trigger_{nullptr}; /// The trigger to call when the preset mode changes Trigger<> *preset_change_trigger_{nullptr}; + /// The trigger to call when dehumidification is required + Trigger<> *humidity_control_dehumidify_action_trigger_{nullptr}; + + /// The trigger to call when humidification is required + Trigger<> *humidity_control_humidify_action_trigger_{nullptr}; + + /// The trigger to call when (de)humidification should stop + Trigger<> *humidity_control_off_action_trigger_{nullptr}; + /// A reference to the trigger that was previously active. /// /// This is so that the previous trigger can be stopped before enabling a new one @@ -462,6 +510,7 @@ class ThermostatClimate : public climate::Climate, public Component { Trigger<> *prev_fan_mode_trigger_{nullptr}; Trigger<> *prev_mode_trigger_{nullptr}; Trigger<> *prev_swing_mode_trigger_{nullptr}; + Trigger<> *prev_humidity_control_trigger_{nullptr}; /// Default custom preset to use on start up std::string default_custom_preset_{}; diff --git a/tests/components/thermostat/common.yaml b/tests/components/thermostat/common.yaml index d630a93efc..4aa87c0ac3 100644 --- a/tests/components/thermostat/common.yaml +++ b/tests/components/thermostat/common.yaml @@ -69,6 +69,11 @@ climate: - logger.log: swing_vertical_action swing_both_action: - logger.log: swing_both_action + humidity_control_humidify_action: + - logger.log: humidity_control_humidify_action + humidity_control_off_action: + - logger.log: humidity_control_off_action + humidity_hysteresis: 1.0 startup_delay: true supplemental_cooling_delta: 2.0 cool_deadband: 0.5