sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-03-21 10:08:15 +00:00
Code Issues Releases Wiki Activity
esphome/esphome/components/thermostat/climate.py
Katherine Whitlock 085ad26afb Run ruff format
2025-02-18 22:59:18 -05:00

952 lines
38 KiB
Python
Raw Blame History

from esphome import automation
import esphome.codegen as cg
from esphome.components import climate, sensor
import esphome.config_validation as cv
from esphome.const import (
CONF_AUTO_MODE,
CONF_AWAY_CONFIG,
CONF_COOL_ACTION,
CONF_COOL_DEADBAND,
CONF_COOL_MODE,
CONF_COOL_OVERRUN,
CONF_DEFAULT_MODE,
CONF_DEFAULT_TARGET_TEMPERATURE_HIGH,
CONF_DEFAULT_TARGET_TEMPERATURE_LOW,
CONF_DRY_ACTION,
CONF_DRY_MODE,
CONF_FAN_MODE,
CONF_FAN_MODE_AUTO_ACTION,
CONF_FAN_MODE_DIFFUSE_ACTION,
CONF_FAN_MODE_FOCUS_ACTION,
CONF_FAN_MODE_HIGH_ACTION,
CONF_FAN_MODE_LOW_ACTION,
CONF_FAN_MODE_MEDIUM_ACTION,
CONF_FAN_MODE_MIDDLE_ACTION,
CONF_FAN_MODE_OFF_ACTION,
CONF_FAN_MODE_ON_ACTION,
CONF_FAN_MODE_QUIET_ACTION,
CONF_FAN_ONLY_ACTION,
CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER,
CONF_FAN_ONLY_COOLING,
CONF_FAN_ONLY_MODE,
CONF_FAN_WITH_COOLING,
CONF_FAN_WITH_HEATING,
CONF_HEAT_ACTION,
CONF_HEAT_DEADBAND,
CONF_HEAT_MODE,
CONF_HEAT_OVERRUN,
CONF_HUMIDITY_SENSOR,
CONF_ID,
CONF_IDLE_ACTION,
CONF_MAX_COOLING_RUN_TIME,
CONF_MAX_HEATING_RUN_TIME,
CONF_MAX_TEMPERATURE,
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
CONF_MIN_FAN_MODE_SWITCHING_TIME,
CONF_MIN_FANNING_OFF_TIME,
CONF_MIN_FANNING_RUN_TIME,
CONF_MIN_HEATING_OFF_TIME,
CONF_MIN_HEATING_RUN_TIME,
CONF_MIN_IDLE_TIME,
CONF_MIN_TEMPERATURE,
CONF_MODE,
CONF_NAME,
CONF_OFF_MODE,
CONF_PRESET,
CONF_SENSOR,
CONF_SET_POINT_MINIMUM_DIFFERENTIAL,
CONF_STARTUP_DELAY,
CONF_SUPPLEMENTAL_COOLING_ACTION,
CONF_SUPPLEMENTAL_COOLING_DELTA,
CONF_SUPPLEMENTAL_HEATING_ACTION,
CONF_SUPPLEMENTAL_HEATING_DELTA,
CONF_SWING_BOTH_ACTION,
CONF_SWING_HORIZONTAL_ACTION,
CONF_SWING_MODE,
CONF_SWING_OFF_ACTION,
CONF_SWING_VERTICAL_ACTION,
CONF_TARGET_TEMPERATURE_CHANGE_ACTION,
CONF_VISUAL,
)
CONF_PRESET_CHANGE = "preset_change"
CONF_DEFAULT_PRESET = "default_preset"
CONF_ON_BOOT_RESTORE_FROM = "on_boot_restore_from"
CODEOWNERS = ["@kbx81"]
climate_ns = cg.esphome_ns.namespace("climate")
thermostat_ns = cg.esphome_ns.namespace("thermostat")
ThermostatClimate = thermostat_ns.class_(
"ThermostatClimate", climate.Climate, cg.Component
)
ThermostatClimateTargetTempConfig = thermostat_ns.struct(
"ThermostatClimateTargetTempConfig"
)
OnBootRestoreFrom = thermostat_ns.enum("OnBootRestoreFrom")
ON_BOOT_RESTORE_FROM = {
"MEMORY": OnBootRestoreFrom.MEMORY,
"DEFAULT_PRESET": OnBootRestoreFrom.DEFAULT_PRESET,
}
validate_on_boot_restore_from = cv.enum(ON_BOOT_RESTORE_FROM, upper=True)
ClimateMode = climate_ns.enum("ClimateMode")
CLIMATE_MODES = {
"OFF": ClimateMode.CLIMATE_MODE_OFF,
"HEAT_COOL": ClimateMode.CLIMATE_MODE_HEAT_COOL,
"COOL": ClimateMode.CLIMATE_MODE_COOL,
"HEAT": ClimateMode.CLIMATE_MODE_HEAT,
"DRY": ClimateMode.CLIMATE_MODE_DRY,
"FAN_ONLY": ClimateMode.CLIMATE_MODE_FAN_ONLY,
"AUTO": ClimateMode.CLIMATE_MODE_AUTO,
}
validate_climate_mode = cv.enum(CLIMATE_MODES, upper=True)
ClimatePreset = climate_ns.enum("ClimatePreset")
PRESET_CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(ThermostatClimateTargetTempConfig),
cv.Required(CONF_NAME): cv.string_strict,
cv.Optional(CONF_MODE): validate_climate_mode,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
cv.Optional(CONF_FAN_MODE): cv.templatable(climate.validate_climate_fan_mode),
cv.Optional(CONF_SWING_MODE): cv.templatable(
climate.validate_climate_swing_mode
),
}
)
def validate_temperature_preset(preset, root_config, name, requirements):
# verify temperature settings for the provided preset / default / away configuration
for config_temp, req_actions in requirements.items():
for req_action in req_actions:
# verify corresponding default target temperature exists when a given climate action exists
if config_temp not in preset and req_action in root_config:
raise cv.Invalid(
f"{config_temp} must be defined in {name} config when using {req_action}"
)
# if a given climate action is NOT defined, it should not have a default target temperature
if config_temp in preset and req_action not in root_config:
raise cv.Invalid(
f"{config_temp} is defined in {name} config with no {req_action}"
)
def generate_comparable_preset(config, name):
comparable_preset = f"{CONF_PRESET}:\n - {CONF_NAME}: {name}\n"
if CONF_DEFAULT_TARGET_TEMPERATURE_LOW in config:
comparable_preset += f" {CONF_DEFAULT_TARGET_TEMPERATURE_LOW}: {config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW]}\n"
if CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in config:
comparable_preset += f" {CONF_DEFAULT_TARGET_TEMPERATURE_HIGH}: {config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]}\n"
return comparable_preset
def validate_thermostat(config):
# verify corresponding action(s) exist(s) for any defined climate mode or action
requirements = {
CONF_AUTO_MODE: [
CONF_COOL_ACTION,
CONF_HEAT_ACTION,
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
CONF_MIN_HEATING_OFF_TIME,
CONF_MIN_HEATING_RUN_TIME,
],
CONF_COOL_MODE: [
CONF_COOL_ACTION,
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
],
CONF_DRY_MODE: [
CONF_DRY_ACTION,
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
],
CONF_FAN_ONLY_MODE: [
CONF_FAN_ONLY_ACTION,
],
CONF_HEAT_MODE: [
CONF_HEAT_ACTION,
CONF_MIN_HEATING_OFF_TIME,
CONF_MIN_HEATING_RUN_TIME,
],
CONF_COOL_ACTION: [
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
],
CONF_DRY_ACTION: [
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
],
CONF_HEAT_ACTION: [
CONF_MIN_HEATING_OFF_TIME,
CONF_MIN_HEATING_RUN_TIME,
],
CONF_SUPPLEMENTAL_COOLING_ACTION: [
CONF_COOL_ACTION,
CONF_MAX_COOLING_RUN_TIME,
CONF_MIN_COOLING_OFF_TIME,
CONF_MIN_COOLING_RUN_TIME,
CONF_SUPPLEMENTAL_COOLING_DELTA,
],
CONF_SUPPLEMENTAL_HEATING_ACTION: [
CONF_HEAT_ACTION,
CONF_MAX_HEATING_RUN_TIME,
CONF_MIN_HEATING_OFF_TIME,
CONF_MIN_HEATING_RUN_TIME,
CONF_SUPPLEMENTAL_HEATING_DELTA,
],
CONF_MAX_COOLING_RUN_TIME: [
CONF_COOL_ACTION,
CONF_SUPPLEMENTAL_COOLING_ACTION,
CONF_SUPPLEMENTAL_COOLING_DELTA,
],
CONF_MAX_HEATING_RUN_TIME: [
CONF_HEAT_ACTION,
CONF_SUPPLEMENTAL_HEATING_ACTION,
CONF_SUPPLEMENTAL_HEATING_DELTA,
],
CONF_MIN_COOLING_OFF_TIME: [
CONF_COOL_ACTION,
],
CONF_MIN_COOLING_RUN_TIME: [
CONF_COOL_ACTION,
],
CONF_MIN_FANNING_OFF_TIME: [
CONF_FAN_ONLY_ACTION,
],
CONF_MIN_FANNING_RUN_TIME: [
CONF_FAN_ONLY_ACTION,
],
CONF_MIN_HEATING_OFF_TIME: [
CONF_HEAT_ACTION,
],
CONF_MIN_HEATING_RUN_TIME: [
CONF_HEAT_ACTION,
],
CONF_SUPPLEMENTAL_COOLING_DELTA: [
CONF_COOL_ACTION,
CONF_MAX_COOLING_RUN_TIME,
CONF_SUPPLEMENTAL_COOLING_ACTION,
],
CONF_SUPPLEMENTAL_HEATING_DELTA: [
CONF_HEAT_ACTION,
CONF_MAX_HEATING_RUN_TIME,
CONF_SUPPLEMENTAL_HEATING_ACTION,
],
}
for config_trigger, req_triggers in requirements.items():
for req_trigger in req_triggers:
if config_trigger in config and req_trigger not in config:
raise cv.Invalid(
f"{req_trigger} must be defined to use {config_trigger}"
)
if CONF_FAN_ONLY_ACTION in config:
# determine validation requirements based on fan_only_action_uses_fan_mode_timer setting
if config[CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER] is True:
requirements = [CONF_MIN_FAN_MODE_SWITCHING_TIME]
else:
requirements = [
CONF_MIN_FANNING_OFF_TIME,
CONF_MIN_FANNING_RUN_TIME,
]
for config_req_action in requirements:
if config_req_action not in config:
raise cv.Invalid(
f"{config_req_action} must be defined to use {CONF_FAN_ONLY_ACTION}"
)
# for any fan_mode action, confirm min_fan_mode_switching_time is defined
requirements = {
CONF_MIN_FAN_MODE_SWITCHING_TIME: [
CONF_FAN_MODE_ON_ACTION,
CONF_FAN_MODE_OFF_ACTION,
CONF_FAN_MODE_AUTO_ACTION,
CONF_FAN_MODE_LOW_ACTION,
CONF_FAN_MODE_MEDIUM_ACTION,
CONF_FAN_MODE_HIGH_ACTION,
CONF_FAN_MODE_MIDDLE_ACTION,
CONF_FAN_MODE_FOCUS_ACTION,
CONF_FAN_MODE_DIFFUSE_ACTION,
CONF_FAN_MODE_QUIET_ACTION,
],
}
for req_config_item, config_triggers in requirements.items():
for config_trigger in config_triggers:
if config_trigger in config and req_config_item not in config:
raise cv.Invalid(
f"{req_config_item} must be defined to use {config_trigger}"
)
# determine validation requirements based on fan_only_cooling setting
if config[CONF_FAN_ONLY_COOLING] is True:
requirements = {
CONF_DEFAULT_TARGET_TEMPERATURE_HIGH: [
CONF_COOL_ACTION,
CONF_FAN_ONLY_ACTION,
],
CONF_DEFAULT_TARGET_TEMPERATURE_LOW: [CONF_HEAT_ACTION],
}
else:
requirements = {
CONF_DEFAULT_TARGET_TEMPERATURE_HIGH: [CONF_COOL_ACTION],
CONF_DEFAULT_TARGET_TEMPERATURE_LOW: [CONF_HEAT_ACTION],
}
# Legacy high/low configs
if CONF_DEFAULT_TARGET_TEMPERATURE_LOW in config:
comparable_preset = generate_comparable_preset(config, "Your new preset")
raise cv.Invalid(
f"{CONF_DEFAULT_TARGET_TEMPERATURE_LOW} is no longer valid. Please switch to using a preset for an equivalent experience.\nEquivalent configuration:\n\n"
f"{comparable_preset}"
)
if CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in config:
comparable_preset = generate_comparable_preset(config, "Your new preset")
raise cv.Invalid(
f"{CONF_DEFAULT_TARGET_TEMPERATURE_HIGH} is no longer valid. Please switch to using a preset for an equivalent experience.\nEquivalent configuration:\n\n"
f"{comparable_preset}"
)
# Legacy away mode - raise an error instructing the user to switch to presets
if CONF_AWAY_CONFIG in config:
comparable_preset = generate_comparable_preset(config[CONF_AWAY_CONFIG], "Away")
raise cv.Invalid(
f"{CONF_AWAY_CONFIG} is no longer valid. Please switch to using a preset named "
"Away"
" for an equivalent experience.\nEquivalent configuration:\n\n"
f"{comparable_preset}"
)
# Validate temperature requirements for presets
if CONF_PRESET in config:
for preset_config in config[CONF_PRESET]:
validate_temperature_preset(
preset_config, config, preset_config[CONF_NAME], requirements
)
# 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}."
)
default_mode = config[CONF_DEFAULT_MODE]
requirements = {
"HEAT_COOL": [CONF_COOL_ACTION, CONF_HEAT_ACTION],
"COOL": [CONF_COOL_ACTION],
"HEAT": [CONF_HEAT_ACTION],
"DRY": [CONF_DRY_ACTION],
"FAN_ONLY": [CONF_FAN_ONLY_ACTION],
"AUTO": [CONF_COOL_ACTION, CONF_HEAT_ACTION],
"OFF": [],
}
actions_for_default_mode = requirements.get(default_mode, [])
for req in actions_for_default_mode:
if req not in config:
raise cv.Invalid(
f"{CONF_DEFAULT_MODE} is set to {default_mode} but {req} is not present in the configuration"
)
# Verify that the modes for presets are valid given the configuration
if CONF_PRESET in config:
# Preset temperature vs Visual temperature validation
# Default visual configuration from climate_traits.h
visual_min_temperature = 10.0
visual_max_temperature = 30.0
if CONF_VISUAL in config:
visual_config = config[CONF_VISUAL]
if CONF_MIN_TEMPERATURE in visual_config:
visual_min_temperature = visual_config[CONF_MIN_TEMPERATURE]
if CONF_MAX_TEMPERATURE in visual_config:
visual_max_temperature = visual_config[CONF_MAX_TEMPERATURE]
for preset_config in config[CONF_PRESET]:
if CONF_DEFAULT_TARGET_TEMPERATURE_LOW in preset_config:
preset_min_temperature = preset_config[
CONF_DEFAULT_TARGET_TEMPERATURE_LOW
]
if preset_min_temperature < visual_min_temperature:
raise cv.Invalid(
f"{CONF_DEFAULT_TARGET_TEMPERATURE_LOW} for {preset_config[CONF_NAME]} is set to {preset_min_temperature} which is less than the visual minimum temperature of {visual_min_temperature}"
)
if CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in preset_config:
preset_max_temperature = preset_config[
CONF_DEFAULT_TARGET_TEMPERATURE_HIGH
]
if preset_max_temperature > visual_max_temperature:
raise cv.Invalid(
f"{CONF_DEFAULT_TARGET_TEMPERATURE_HIGH} for {preset_config[CONF_NAME]} is set to {preset_max_temperature} which is more than the visual maximum temperature of {visual_max_temperature}"
)
# Mode validation
for preset_config in config[CONF_PRESET]:
if CONF_MODE not in preset_config:
continue
mode = preset_config[CONF_MODE]
for req in requirements[mode]:
if req not in config:
raise cv.Invalid(
f"{CONF_MODE} is set to {mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
)
# Fan mode requirements
requirements = {
"ON": [CONF_FAN_MODE_ON_ACTION],
"OFF": [CONF_FAN_MODE_OFF_ACTION],
"AUTO": [CONF_FAN_MODE_AUTO_ACTION],
"LOW": [CONF_FAN_MODE_LOW_ACTION],
"MEDIUM": [CONF_FAN_MODE_MEDIUM_ACTION],
"HIGH": [CONF_FAN_MODE_HIGH_ACTION],
"MIDDLE": [CONF_FAN_MODE_MIDDLE_ACTION],
"FOCUS": [CONF_FAN_MODE_FOCUS_ACTION],
"DIFFUSE": [CONF_FAN_MODE_DIFFUSE_ACTION],
"QUIET": [CONF_FAN_MODE_QUIET_ACTION],
}
for preset_config in config[CONF_PRESET]:
if CONF_FAN_MODE not in preset_config:
continue
fan_mode = preset_config[CONF_FAN_MODE]
for req in requirements[fan_mode]:
if req not in config:
raise cv.Invalid(
f"{CONF_FAN_MODE} is set to {fan_mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
)
# Swing mode requirements
requirements = {
"OFF": [CONF_SWING_OFF_ACTION],
"BOTH": [CONF_SWING_BOTH_ACTION],
"VERTICAL": [CONF_SWING_VERTICAL_ACTION],
"HORIZONTAL": [CONF_SWING_HORIZONTAL_ACTION],
}
for preset_config in config[CONF_PRESET]:
if CONF_SWING_MODE not in preset_config:
continue
swing_mode = preset_config[CONF_SWING_MODE]
for req in requirements[swing_mode]:
if req not in config:
raise cv.Invalid(
f"{CONF_SWING_MODE} is set to {swing_mode} for {preset_config[CONF_NAME]} but {req} is not present in the configuration"
)
# If a default preset is requested then ensure that preset is defined
if CONF_DEFAULT_PRESET in config:
default_preset = config[CONF_DEFAULT_PRESET]
if CONF_PRESET not in config:
raise cv.Invalid(
f"{CONF_DEFAULT_PRESET} is specified but no presets are defined"
)
presets = config[CONF_PRESET]
found_preset = False
for preset in presets:
if preset[CONF_NAME] == default_preset:
found_preset = True
break
if found_preset is False:
raise cv.Invalid(
f"{CONF_DEFAULT_PRESET} set to '{default_preset}' but no such preset has been defined. Available presets: {[preset[CONF_NAME] for preset in presets]}"
)
# If restoring default preset on boot is true then ensure we have a default preset
if (
CONF_ON_BOOT_RESTORE_FROM in config
and config[CONF_ON_BOOT_RESTORE_FROM] is OnBootRestoreFrom.DEFAULT_PRESET
):
if CONF_DEFAULT_PRESET not in config:
raise cv.Invalid(
f"{CONF_DEFAULT_PRESET} must be defined to use {CONF_ON_BOOT_RESTORE_FROM} in DEFAULT_PRESET mode"
)
if config[CONF_FAN_WITH_COOLING] is True and CONF_FAN_ONLY_ACTION not in config:
raise cv.Invalid(
f"{CONF_FAN_ONLY_ACTION} must be defined to use {CONF_FAN_WITH_COOLING}"
)
if config[CONF_FAN_WITH_HEATING] is True and CONF_FAN_ONLY_ACTION not in config:
raise cv.Invalid(
f"{CONF_FAN_ONLY_ACTION} must be defined to use {CONF_FAN_WITH_HEATING}"
)
# if min_fan_mode_switching_time is defined, at least one fan_mode action should be defined
if CONF_MIN_FAN_MODE_SWITCHING_TIME in config:
requirements = [
CONF_FAN_MODE_ON_ACTION,
CONF_FAN_MODE_OFF_ACTION,
CONF_FAN_MODE_AUTO_ACTION,
CONF_FAN_MODE_LOW_ACTION,
CONF_FAN_MODE_MEDIUM_ACTION,
CONF_FAN_MODE_HIGH_ACTION,
CONF_FAN_MODE_MIDDLE_ACTION,
CONF_FAN_MODE_FOCUS_ACTION,
CONF_FAN_MODE_DIFFUSE_ACTION,
CONF_FAN_MODE_QUIET_ACTION,
]
for config_req_action in requirements:
if config_req_action in config:
return config
raise cv.Invalid(
f"At least one of {CONF_FAN_MODE_ON_ACTION}, {CONF_FAN_MODE_OFF_ACTION}, {CONF_FAN_MODE_AUTO_ACTION}, {CONF_FAN_MODE_LOW_ACTION}, {CONF_FAN_MODE_MEDIUM_ACTION}, {CONF_FAN_MODE_HIGH_ACTION}, {CONF_FAN_MODE_MIDDLE_ACTION}, {CONF_FAN_MODE_FOCUS_ACTION}, {CONF_FAN_MODE_DIFFUSE_ACTION}, {CONF_FAN_MODE_QUIET_ACTION} must be defined to use {CONF_MIN_FAN_MODE_SWITCHING_TIME}"
)
return config
CONFIG_SCHEMA = cv.All(
climate.CLIMATE_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(ThermostatClimate),
cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_COOL_ACTION): automation.validate_automation(single=True),
cv.Optional(
CONF_SUPPLEMENTAL_COOLING_ACTION
): automation.validate_automation(single=True),
cv.Optional(CONF_DRY_ACTION): automation.validate_automation(single=True),
cv.Optional(CONF_FAN_ONLY_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_HEAT_ACTION): automation.validate_automation(single=True),
cv.Optional(
CONF_SUPPLEMENTAL_HEATING_ACTION
): automation.validate_automation(single=True),
cv.Optional(CONF_AUTO_MODE): automation.validate_automation(single=True),
cv.Optional(CONF_COOL_MODE): automation.validate_automation(single=True),
cv.Optional(CONF_DRY_MODE): automation.validate_automation(single=True),
cv.Optional(CONF_FAN_ONLY_MODE): automation.validate_automation(
single=True
),
cv.Optional(CONF_HEAT_MODE): automation.validate_automation(single=True),
cv.Optional(CONF_OFF_MODE): automation.validate_automation(single=True),
cv.Optional(CONF_FAN_MODE_ON_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_OFF_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_AUTO_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_LOW_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_MEDIUM_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_HIGH_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_MIDDLE_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_FOCUS_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_DIFFUSE_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_FAN_MODE_QUIET_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_SWING_BOTH_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_SWING_HORIZONTAL_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_SWING_OFF_ACTION): automation.validate_automation(
single=True
),
cv.Optional(CONF_SWING_VERTICAL_ACTION): automation.validate_automation(
single=True
),
cv.Optional(
CONF_TARGET_TEMPERATURE_CHANGE_ACTION
): automation.validate_automation(single=True),
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,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
cv.Optional(
CONF_SET_POINT_MINIMUM_DIFFERENTIAL, default=0.5
): cv.temperature_delta,
cv.Optional(CONF_COOL_DEADBAND, default=0.5): cv.temperature_delta,
cv.Optional(CONF_COOL_OVERRUN, default=0.5): cv.temperature_delta,
cv.Optional(CONF_HEAT_DEADBAND, default=0.5): cv.temperature_delta,
cv.Optional(CONF_HEAT_OVERRUN, default=0.5): cv.temperature_delta,
cv.Optional(CONF_MAX_COOLING_RUN_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MAX_HEATING_RUN_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_COOLING_OFF_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_COOLING_RUN_TIME): cv.positive_time_period_seconds,
cv.Optional(
CONF_MIN_FAN_MODE_SWITCHING_TIME
): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_FANNING_OFF_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_FANNING_RUN_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_HEATING_OFF_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_MIN_HEATING_RUN_TIME): cv.positive_time_period_seconds,
cv.Required(CONF_MIN_IDLE_TIME): cv.positive_time_period_seconds,
cv.Optional(CONF_SUPPLEMENTAL_COOLING_DELTA): cv.temperature_delta,
cv.Optional(CONF_SUPPLEMENTAL_HEATING_DELTA): cv.temperature_delta,
cv.Optional(
CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER, default=False
): cv.boolean,
cv.Optional(CONF_FAN_ONLY_COOLING, default=False): cv.boolean,
cv.Optional(CONF_FAN_WITH_COOLING, default=False): cv.boolean,
cv.Optional(CONF_FAN_WITH_HEATING, default=False): cv.boolean,
cv.Optional(CONF_STARTUP_DELAY, default=False): cv.boolean,
cv.Optional(CONF_AWAY_CONFIG): cv.Schema(
{
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
}
),
cv.Optional(CONF_PRESET): cv.ensure_list(PRESET_CONFIG_SCHEMA),
cv.Optional(CONF_ON_BOOT_RESTORE_FROM): validate_on_boot_restore_from,
cv.Optional(CONF_PRESET_CHANGE): automation.validate_automation(
single=True
),
}
).extend(cv.COMPONENT_SCHEMA),
cv.has_at_least_one_key(
CONF_COOL_ACTION, CONF_DRY_ACTION, CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION
),
validate_thermostat,
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await climate.register_climate(var, config)
heat_cool_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
two_points_available = CONF_HEAT_ACTION in config and (
CONF_COOL_ACTION in config
or (config[CONF_FAN_ONLY_COOLING] and CONF_FAN_ONLY_ACTION in config)
)
if two_points_available:
cg.add(var.set_supports_two_points(True))
sens = await cg.get_variable(config[CONF_SENSOR])
cg.add(
var.set_set_point_minimum_differential(
config[CONF_SET_POINT_MINIMUM_DIFFERENTIAL]
)
)
cg.add(var.set_sensor(sens))
if CONF_HUMIDITY_SENSOR in config:
sens = await cg.get_variable(config[CONF_HUMIDITY_SENSOR])
cg.add(var.set_humidity_sensor(sens))
cg.add(var.set_cool_deadband(config[CONF_COOL_DEADBAND]))
cg.add(var.set_cool_overrun(config[CONF_COOL_OVERRUN]))
cg.add(var.set_heat_deadband(config[CONF_HEAT_DEADBAND]))
cg.add(var.set_heat_overrun(config[CONF_HEAT_OVERRUN]))
if CONF_MAX_COOLING_RUN_TIME in config:
cg.add(
var.set_cooling_maximum_run_time_in_sec(config[CONF_MAX_COOLING_RUN_TIME])
)
if CONF_MAX_HEATING_RUN_TIME in config:
cg.add(
var.set_heating_maximum_run_time_in_sec(config[CONF_MAX_HEATING_RUN_TIME])
)
if CONF_MIN_COOLING_OFF_TIME in config:
cg.add(
var.set_cooling_minimum_off_time_in_sec(config[CONF_MIN_COOLING_OFF_TIME])
)
if CONF_MIN_COOLING_RUN_TIME in config:
cg.add(
var.set_cooling_minimum_run_time_in_sec(config[CONF_MIN_COOLING_RUN_TIME])
)
if CONF_MIN_FAN_MODE_SWITCHING_TIME in config:
cg.add(
var.set_fan_mode_minimum_switching_time_in_sec(
config[CONF_MIN_FAN_MODE_SWITCHING_TIME]
)
)
if CONF_MIN_FANNING_OFF_TIME in config:
cg.add(
var.set_fanning_minimum_off_time_in_sec(config[CONF_MIN_FANNING_OFF_TIME])
)
if CONF_MIN_FANNING_RUN_TIME in config:
cg.add(
var.set_fanning_minimum_run_time_in_sec(config[CONF_MIN_FANNING_RUN_TIME])
)
if CONF_MIN_HEATING_OFF_TIME in config:
cg.add(
var.set_heating_minimum_off_time_in_sec(config[CONF_MIN_HEATING_OFF_TIME])
)
if CONF_MIN_HEATING_RUN_TIME in config:
cg.add(
var.set_heating_minimum_run_time_in_sec(config[CONF_MIN_HEATING_RUN_TIME])
)
if CONF_SUPPLEMENTAL_COOLING_DELTA in config:
cg.add(var.set_supplemental_cool_delta(config[CONF_SUPPLEMENTAL_COOLING_DELTA]))
if CONF_SUPPLEMENTAL_HEATING_DELTA in config:
cg.add(var.set_supplemental_heat_delta(config[CONF_SUPPLEMENTAL_HEATING_DELTA]))
cg.add(var.set_idle_minimum_time_in_sec(config[CONF_MIN_IDLE_TIME]))
cg.add(
var.set_supports_fan_only_action_uses_fan_mode_timer(
config[CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER]
)
)
cg.add(var.set_supports_fan_only_cooling(config[CONF_FAN_ONLY_COOLING]))
cg.add(var.set_supports_fan_with_cooling(config[CONF_FAN_WITH_COOLING]))
cg.add(var.set_supports_fan_with_heating(config[CONF_FAN_WITH_HEATING]))
cg.add(var.set_use_startup_delay(config[CONF_STARTUP_DELAY]))
await automation.build_automation(
var.get_idle_action_trigger(), [], config[CONF_IDLE_ACTION]
)
if heat_cool_mode_available is True:
cg.add(var.set_supports_heat_cool(True))
else:
cg.add(var.set_supports_heat_cool(False))
if CONF_COOL_ACTION in config:
await automation.build_automation(
var.get_cool_action_trigger(), [], config[CONF_COOL_ACTION]
)
cg.add(var.set_supports_cool(True))
if CONF_SUPPLEMENTAL_COOLING_ACTION in config:
await automation.build_automation(
var.get_supplemental_cool_action_trigger(),
[],
config[CONF_SUPPLEMENTAL_COOLING_ACTION],
)
if CONF_DRY_ACTION in config:
await automation.build_automation(
var.get_dry_action_trigger(), [], config[CONF_DRY_ACTION]
)
cg.add(var.set_supports_dry(True))
if CONF_FAN_ONLY_ACTION in config:
await automation.build_automation(
var.get_fan_only_action_trigger(), [], config[CONF_FAN_ONLY_ACTION]
)
cg.add(var.set_supports_fan_only(True))
if CONF_HEAT_ACTION in config:
await automation.build_automation(
var.get_heat_action_trigger(), [], config[CONF_HEAT_ACTION]
)
cg.add(var.set_supports_heat(True))
if CONF_SUPPLEMENTAL_HEATING_ACTION in config:
await automation.build_automation(
var.get_supplemental_heat_action_trigger(),
[],
config[CONF_SUPPLEMENTAL_HEATING_ACTION],
)
if CONF_AUTO_MODE in config:
await automation.build_automation(
var.get_auto_mode_trigger(), [], config[CONF_AUTO_MODE]
)
if CONF_COOL_MODE in config:
await automation.build_automation(
var.get_cool_mode_trigger(), [], config[CONF_COOL_MODE]
)
cg.add(var.set_supports_cool(True))
if CONF_DRY_MODE in config:
await automation.build_automation(
var.get_dry_mode_trigger(), [], config[CONF_DRY_MODE]
)
cg.add(var.set_supports_dry(True))
if CONF_FAN_ONLY_MODE in config:
await automation.build_automation(
var.get_fan_only_mode_trigger(), [], config[CONF_FAN_ONLY_MODE]
)
cg.add(var.set_supports_fan_only(True))
if CONF_HEAT_MODE in config:
await automation.build_automation(
var.get_heat_mode_trigger(), [], config[CONF_HEAT_MODE]
)
cg.add(var.set_supports_heat(True))
if CONF_OFF_MODE in config:
await automation.build_automation(
var.get_off_mode_trigger(), [], config[CONF_OFF_MODE]
)
if CONF_FAN_MODE_ON_ACTION in config:
await automation.build_automation(
var.get_fan_mode_on_trigger(), [], config[CONF_FAN_MODE_ON_ACTION]
)
cg.add(var.set_supports_fan_mode_on(True))
if CONF_FAN_MODE_OFF_ACTION in config:
await automation.build_automation(
var.get_fan_mode_off_trigger(), [], config[CONF_FAN_MODE_OFF_ACTION]
)
cg.add(var.set_supports_fan_mode_off(True))
if CONF_FAN_MODE_AUTO_ACTION in config:
await automation.build_automation(
var.get_fan_mode_auto_trigger(), [], config[CONF_FAN_MODE_AUTO_ACTION]
)
cg.add(var.set_supports_fan_mode_auto(True))
if CONF_FAN_MODE_LOW_ACTION in config:
await automation.build_automation(
var.get_fan_mode_low_trigger(), [], config[CONF_FAN_MODE_LOW_ACTION]
)
cg.add(var.set_supports_fan_mode_low(True))
if CONF_FAN_MODE_MEDIUM_ACTION in config:
await automation.build_automation(
var.get_fan_mode_medium_trigger(), [], config[CONF_FAN_MODE_MEDIUM_ACTION]
)
cg.add(var.set_supports_fan_mode_medium(True))
if CONF_FAN_MODE_HIGH_ACTION in config:
await automation.build_automation(
var.get_fan_mode_high_trigger(), [], config[CONF_FAN_MODE_HIGH_ACTION]
)
cg.add(var.set_supports_fan_mode_high(True))
if CONF_FAN_MODE_MIDDLE_ACTION in config:
await automation.build_automation(
var.get_fan_mode_middle_trigger(), [], config[CONF_FAN_MODE_MIDDLE_ACTION]
)
cg.add(var.set_supports_fan_mode_middle(True))
if CONF_FAN_MODE_FOCUS_ACTION in config:
await automation.build_automation(
var.get_fan_mode_focus_trigger(), [], config[CONF_FAN_MODE_FOCUS_ACTION]
)
cg.add(var.set_supports_fan_mode_focus(True))
if CONF_FAN_MODE_DIFFUSE_ACTION in config:
await automation.build_automation(
var.get_fan_mode_diffuse_trigger(), [], config[CONF_FAN_MODE_DIFFUSE_ACTION]
)
cg.add(var.set_supports_fan_mode_diffuse(True))
if CONF_FAN_MODE_QUIET_ACTION in config:
await automation.build_automation(
var.get_fan_mode_quiet_trigger(), [], config[CONF_FAN_MODE_QUIET_ACTION]
)
cg.add(var.set_supports_fan_mode_quiet(True))
if CONF_SWING_BOTH_ACTION in config:
await automation.build_automation(
var.get_swing_mode_both_trigger(), [], config[CONF_SWING_BOTH_ACTION]
)
cg.add(var.set_supports_swing_mode_both(True))
if CONF_SWING_HORIZONTAL_ACTION in config:
await automation.build_automation(
var.get_swing_mode_horizontal_trigger(),
[],
config[CONF_SWING_HORIZONTAL_ACTION],
)
cg.add(var.set_supports_swing_mode_horizontal(True))
if CONF_SWING_OFF_ACTION in config:
await automation.build_automation(
var.get_swing_mode_off_trigger(), [], config[CONF_SWING_OFF_ACTION]
)
cg.add(var.set_supports_swing_mode_off(True))
if CONF_SWING_VERTICAL_ACTION in config:
await automation.build_automation(
var.get_swing_mode_vertical_trigger(),
[],
config[CONF_SWING_VERTICAL_ACTION],
)
cg.add(var.set_supports_swing_mode_vertical(True))
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_PRESET in config:
for preset_config in config[CONF_PRESET]:
name = preset_config[CONF_NAME]
standard_preset = None
if name.upper() in climate.CLIMATE_PRESETS:
standard_preset = climate.CLIMATE_PRESETS[name.upper()]
if two_points_available:
preset_target_config = ThermostatClimateTargetTempConfig(
preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW],
preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH],
)
elif CONF_DEFAULT_TARGET_TEMPERATURE_HIGH in preset_config:
preset_target_config = ThermostatClimateTargetTempConfig(
preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]
)
elif CONF_DEFAULT_TARGET_TEMPERATURE_LOW in preset_config:
preset_target_config = ThermostatClimateTargetTempConfig(
preset_config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW]
)
else:
preset_target_config = None
preset_target_variable = cg.new_variable(
preset_config[CONF_ID], preset_target_config
)
if CONF_MODE in preset_config:
cg.add(preset_target_variable.set_mode(preset_config[CONF_MODE]))
if CONF_FAN_MODE in preset_config:
cg.add(
preset_target_variable.set_fan_mode(preset_config[CONF_FAN_MODE])
)
if CONF_SWING_MODE in preset_config:
cg.add(
preset_target_variable.set_swing_mode(
preset_config[CONF_SWING_MODE]
)
)
if standard_preset is not None:
cg.add(var.set_preset_config(standard_preset, preset_target_variable))
else:
cg.add(var.set_custom_preset_config(name, preset_target_variable))
if CONF_DEFAULT_PRESET in config:
default_preset_name = config[CONF_DEFAULT_PRESET]
# if the name is a built in preset use the appropriate naming format
if default_preset_name.upper() in climate.CLIMATE_PRESETS:
climate_preset = climate.CLIMATE_PRESETS[default_preset_name.upper()]
cg.add(var.set_default_preset(climate_preset))
else:
cg.add(var.set_default_preset(default_preset_name))
if CONF_ON_BOOT_RESTORE_FROM in config:
cg.add(var.set_on_boot_restore_from(config[CONF_ON_BOOT_RESTORE_FROM]))
if CONF_PRESET_CHANGE in config:
await automation.build_automation(
var.get_preset_change_trigger(), [], config[CONF_PRESET_CHANGE]
)
Reference in New Issue View Git Blame Copy Permalink