mirror of
https://github.com/esphome/esphome.git
synced 2026-10-03 09:46:03 +00:00
[climate][template] New template climate component (#14455)
This commit is contained in:
Ricardo Sanz
@@ -125,6 +125,19 @@ CLIMATE_SWING_MODES = {
|
||||
|
||||
validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True)
|
||||
|
||||
ClimateAction = climate_ns.enum("ClimateAction")
|
||||
CLIMATE_ACTIONS = {
|
||||
"OFF": ClimateAction.CLIMATE_ACTION_OFF,
|
||||
"COOLING": ClimateAction.CLIMATE_ACTION_COOLING,
|
||||
"HEATING": ClimateAction.CLIMATE_ACTION_HEATING,
|
||||
"IDLE": ClimateAction.CLIMATE_ACTION_IDLE,
|
||||
"DRYING": ClimateAction.CLIMATE_ACTION_DRYING,
|
||||
"FAN": ClimateAction.CLIMATE_ACTION_FAN,
|
||||
"DEFROSTING": ClimateAction.CLIMATE_ACTION_DEFROSTING,
|
||||
}
|
||||
|
||||
validate_climate_action = cv.enum(CLIMATE_ACTIONS, upper=True)
|
||||
|
||||
CONF_MIN_HUMIDITY = "min_humidity"
|
||||
CONF_MAX_HUMIDITY = "max_humidity"
|
||||
CONF_TARGET_HUMIDITY = "target_humidity"
|
||||
|
||||
@@ -0,0 +1,465 @@
|
||||
from esphome import automation
|
||||
import esphome.codegen as cg
|
||||
from esphome.components import climate, sensor
|
||||
from esphome.components.climate import climate_ns
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import (
|
||||
CONF_ACTION,
|
||||
CONF_CURRENT_TEMPERATURE,
|
||||
CONF_CUSTOM_FAN_MODE,
|
||||
CONF_CUSTOM_FAN_MODES,
|
||||
CONF_CUSTOM_PRESET,
|
||||
CONF_CUSTOM_PRESETS,
|
||||
CONF_FAN_MODE,
|
||||
CONF_HUMIDITY_SENSOR,
|
||||
CONF_ID,
|
||||
CONF_INITIAL_STATE,
|
||||
CONF_MODE,
|
||||
CONF_OPTIMISTIC,
|
||||
CONF_PRESET,
|
||||
CONF_RESTORE_MODE,
|
||||
CONF_SENSOR,
|
||||
CONF_SUPPORTED_FAN_MODES,
|
||||
CONF_SUPPORTED_MODES,
|
||||
CONF_SUPPORTED_PRESETS,
|
||||
CONF_SUPPORTED_SWING_MODES,
|
||||
CONF_SWING_MODE,
|
||||
CONF_TARGET_TEMPERATURE,
|
||||
CONF_TARGET_TEMPERATURE_HIGH,
|
||||
CONF_TARGET_TEMPERATURE_LOW,
|
||||
)
|
||||
from esphome.core import ID
|
||||
from esphome.cpp_generator import MockObj, TemplateArgsType
|
||||
from esphome.types import ConfigType
|
||||
|
||||
from .. import template_ns
|
||||
|
||||
CONF_CURRENT_HUMIDITY = "current_humidity"
|
||||
CONF_TARGET_HUMIDITY = "target_humidity"
|
||||
CONF_SUPPORTS_ACTION = "supports_action"
|
||||
CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE = "supports_two_point_target_temperature"
|
||||
CONF_SUPPORTS_TARGET_HUMIDITY = "supports_target_humidity"
|
||||
CONF_SUPPORTS_CURRENT_TEMPERATURE = "supports_current_temperature"
|
||||
CONF_SUPPORTS_CURRENT_HUMIDITY = "supports_current_humidity"
|
||||
CONF_SET_MODE_ACTION = "set_mode_action"
|
||||
CONF_SET_TARGET_TEMPERATURE_ACTION = "set_target_temperature_action"
|
||||
CONF_SET_TARGET_TEMPERATURE_LOW_ACTION = "set_target_temperature_low_action"
|
||||
CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION = "set_target_temperature_high_action"
|
||||
CONF_SET_TARGET_HUMIDITY_ACTION = "set_target_humidity_action"
|
||||
CONF_SET_FAN_MODE_ACTION = "set_fan_mode_action"
|
||||
CONF_SET_CUSTOM_FAN_MODE_ACTION = "set_custom_fan_mode_action"
|
||||
CONF_SET_SWING_MODE_ACTION = "set_swing_mode_action"
|
||||
CONF_SET_PRESET_ACTION = "set_preset_action"
|
||||
CONF_SET_CUSTOM_PRESET_ACTION = "set_custom_preset_action"
|
||||
|
||||
TemplateClimate = template_ns.class_("TemplateClimate", climate.Climate, cg.Component)
|
||||
TemplateClimatePublishAction = template_ns.class_(
|
||||
"TemplateClimatePublishAction",
|
||||
automation.Action,
|
||||
cg.Parented.template(TemplateClimate),
|
||||
)
|
||||
|
||||
TemplateClimateRestoreMode = template_ns.enum(
|
||||
"TemplateClimateRestoreMode", is_class=True
|
||||
)
|
||||
CLIMATE_RESTORE_MODES = {
|
||||
"NO_RESTORE": TemplateClimateRestoreMode.TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE,
|
||||
"RESTORE": TemplateClimateRestoreMode.TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE,
|
||||
}
|
||||
|
||||
# Per-field actions that forward a requested value on. The third item is the type of `x`.
|
||||
SET_ACTIONS = (
|
||||
(CONF_SET_MODE_ACTION, "get_set_mode_trigger", climate.ClimateMode),
|
||||
(
|
||||
CONF_SET_TARGET_TEMPERATURE_ACTION,
|
||||
"get_set_target_temperature_trigger",
|
||||
cg.float_,
|
||||
),
|
||||
(
|
||||
CONF_SET_TARGET_TEMPERATURE_LOW_ACTION,
|
||||
"get_set_target_temperature_low_trigger",
|
||||
cg.float_,
|
||||
),
|
||||
(
|
||||
CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION,
|
||||
"get_set_target_temperature_high_trigger",
|
||||
cg.float_,
|
||||
),
|
||||
(CONF_SET_TARGET_HUMIDITY_ACTION, "get_set_target_humidity_trigger", cg.float_),
|
||||
(CONF_SET_FAN_MODE_ACTION, "get_set_fan_mode_trigger", climate.ClimateFanMode),
|
||||
(
|
||||
CONF_SET_CUSTOM_FAN_MODE_ACTION,
|
||||
"get_set_custom_fan_mode_trigger",
|
||||
cg.StringRef,
|
||||
),
|
||||
(
|
||||
CONF_SET_SWING_MODE_ACTION,
|
||||
"get_set_swing_mode_trigger",
|
||||
climate.ClimateSwingMode,
|
||||
),
|
||||
(CONF_SET_PRESET_ACTION, "get_set_preset_trigger", climate.ClimatePreset),
|
||||
(CONF_SET_CUSTOM_PRESET_ACTION, "get_set_custom_preset_trigger", cg.StringRef),
|
||||
)
|
||||
|
||||
# supports_* keys have no default so that an omitted key can mean "derive it from the sensor or
|
||||
# set action that makes the trait useful", which is not expressible once a default fills it in.
|
||||
DERIVED_SUPPORTS = (
|
||||
(CONF_SUPPORTS_CURRENT_TEMPERATURE, (CONF_SENSOR,)),
|
||||
(CONF_SUPPORTS_CURRENT_HUMIDITY, (CONF_HUMIDITY_SENSOR,)),
|
||||
(
|
||||
CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
|
||||
(
|
||||
CONF_SET_TARGET_TEMPERATURE_LOW_ACTION,
|
||||
CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION,
|
||||
),
|
||||
),
|
||||
(CONF_SUPPORTS_TARGET_HUMIDITY, (CONF_SET_TARGET_HUMIDITY_ACTION,)),
|
||||
)
|
||||
|
||||
|
||||
# Custom fan modes/presets are opaque user-defined strings with no build-time correctness check
|
||||
# elsewhere (Climate::set_supported_custom_fan_modes()/set_supported_custom_presets() don't block
|
||||
# empty entries), so reject empty ones here -- they could never be selected at runtime anyway.
|
||||
validate_custom_climate_string = cv.All(cv.string_strict, cv.Length(min=1))
|
||||
|
||||
|
||||
def _validate_two_point(config: ConfigType) -> ConfigType:
|
||||
has_low = CONF_TARGET_TEMPERATURE_LOW in config
|
||||
has_high = CONF_TARGET_TEMPERATURE_HIGH in config
|
||||
if has_low != has_high:
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_TARGET_TEMPERATURE_LOW}' and '{CONF_TARGET_TEMPERATURE_HIGH}' must be used together"
|
||||
)
|
||||
if (has_low or has_high) and CONF_TARGET_TEMPERATURE in config:
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_TARGET_TEMPERATURE}' cannot be used together with "
|
||||
f"'{CONF_TARGET_TEMPERATURE_LOW}'/'{CONF_TARGET_TEMPERATURE_HIGH}'"
|
||||
)
|
||||
return config
|
||||
|
||||
|
||||
def _validate_set_actions(config: ConfigType) -> ConfigType:
|
||||
has_low = CONF_SET_TARGET_TEMPERATURE_LOW_ACTION in config
|
||||
has_high = CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION in config
|
||||
if has_low != has_high:
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_SET_TARGET_TEMPERATURE_LOW_ACTION}' and "
|
||||
f"'{CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION}' must be used together"
|
||||
)
|
||||
if (has_low or has_high) and CONF_SET_TARGET_TEMPERATURE_ACTION in config:
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_SET_TARGET_TEMPERATURE_ACTION}' cannot be used together with "
|
||||
f"'{CONF_SET_TARGET_TEMPERATURE_LOW_ACTION}'/'{CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION}'"
|
||||
)
|
||||
return config
|
||||
|
||||
|
||||
def _resolve_supports(config: ConfigType) -> ConfigType:
|
||||
# An explicit true stays valid without either, since climate.template.publish can report the
|
||||
# value; an explicit false that contradicts the configuration is an error, not a silent override.
|
||||
for key, sources in DERIVED_SUPPORTS:
|
||||
configured = [source for source in sources if source in config]
|
||||
if key not in config:
|
||||
config[key] = bool(configured)
|
||||
elif not config[key] and configured:
|
||||
raise cv.Invalid(
|
||||
f"'{key}' cannot be false while '{configured[0]}' is configured",
|
||||
path=[key],
|
||||
)
|
||||
return config
|
||||
|
||||
|
||||
def _validate_initial_state(config: ConfigType) -> ConfigType:
|
||||
# Climate keeps target_temperature and target_temperature_low in a union, so writing the wrong
|
||||
# one of the pair corrupts the setpoint with no runtime complaint.
|
||||
if (initial_state := config.get(CONF_INITIAL_STATE)) is None:
|
||||
return config
|
||||
|
||||
two_point = config[CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE]
|
||||
if two_point and CONF_TARGET_TEMPERATURE in initial_state:
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_TARGET_TEMPERATURE}' is not available while "
|
||||
f"'{CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE}' is enabled; use "
|
||||
f"'{CONF_TARGET_TEMPERATURE_LOW}'/'{CONF_TARGET_TEMPERATURE_HIGH}' instead",
|
||||
path=[CONF_INITIAL_STATE, CONF_TARGET_TEMPERATURE],
|
||||
)
|
||||
if not two_point:
|
||||
for key in (CONF_TARGET_TEMPERATURE_LOW, CONF_TARGET_TEMPERATURE_HIGH):
|
||||
if key in initial_state:
|
||||
raise cv.Invalid(
|
||||
f"'{key}' requires '{CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE}' to be enabled",
|
||||
path=[CONF_INITIAL_STATE, key],
|
||||
)
|
||||
if (
|
||||
CONF_TARGET_HUMIDITY in initial_state
|
||||
and not config[CONF_SUPPORTS_TARGET_HUMIDITY]
|
||||
):
|
||||
raise cv.Invalid(
|
||||
f"'{CONF_TARGET_HUMIDITY}' requires '{CONF_SUPPORTS_TARGET_HUMIDITY}' to be enabled",
|
||||
path=[CONF_INITIAL_STATE, CONF_TARGET_HUMIDITY],
|
||||
)
|
||||
return config
|
||||
|
||||
|
||||
# Same settable fields as climate.template.publish, minus current_temperature/current_humidity/
|
||||
# action: those are reported values (from a sensor or the device), not meaningful static defaults.
|
||||
INITIAL_STATE_SCHEMA = cv.All(
|
||||
cv.Schema(
|
||||
{
|
||||
cv.Optional(CONF_MODE): climate.validate_climate_mode,
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE): cv.temperature,
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.temperature,
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.temperature,
|
||||
cv.Optional(CONF_TARGET_HUMIDITY): cv.percentage_int,
|
||||
cv.Exclusive(CONF_FAN_MODE, "fan_mode"): climate.validate_climate_fan_mode,
|
||||
cv.Exclusive(
|
||||
CONF_CUSTOM_FAN_MODE, "fan_mode"
|
||||
): validate_custom_climate_string,
|
||||
cv.Optional(CONF_SWING_MODE): climate.validate_climate_swing_mode,
|
||||
cv.Exclusive(CONF_PRESET, "preset"): climate.validate_climate_preset,
|
||||
cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): validate_custom_climate_string,
|
||||
}
|
||||
),
|
||||
_validate_two_point,
|
||||
)
|
||||
|
||||
CONFIG_SCHEMA = cv.All(
|
||||
climate.climate_schema(TemplateClimate)
|
||||
.extend(
|
||||
{
|
||||
cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
|
||||
cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
|
||||
# action only ever arrives through climate.template.publish, so unlike the other
|
||||
# supports_* keys there is no set action to derive it from.
|
||||
cv.Optional(CONF_SUPPORTS_ACTION, default=False): cv.boolean,
|
||||
cv.Optional(CONF_SUPPORTS_CURRENT_TEMPERATURE): cv.boolean,
|
||||
cv.Optional(CONF_SUPPORTS_CURRENT_HUMIDITY): cv.boolean,
|
||||
cv.Optional(CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE): cv.boolean,
|
||||
cv.Optional(CONF_SUPPORTS_TARGET_HUMIDITY): cv.boolean,
|
||||
cv.Required(CONF_SUPPORTED_MODES): cv.All(
|
||||
cv.ensure_list(climate.validate_climate_mode), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_SUPPORTED_FAN_MODES): cv.All(
|
||||
cv.ensure_list(climate.validate_climate_fan_mode), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_CUSTOM_FAN_MODES): cv.All(
|
||||
cv.ensure_list(validate_custom_climate_string), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.All(
|
||||
cv.ensure_list(climate.validate_climate_swing_mode), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_SUPPORTED_PRESETS): cv.All(
|
||||
cv.ensure_list(climate.validate_climate_preset), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_CUSTOM_PRESETS): cv.All(
|
||||
cv.ensure_list(validate_custom_climate_string), cv.Unique()
|
||||
),
|
||||
cv.Optional(CONF_OPTIMISTIC, default=True): cv.boolean,
|
||||
cv.Optional(CONF_RESTORE_MODE, default="RESTORE"): cv.enum(
|
||||
CLIMATE_RESTORE_MODES, upper=True
|
||||
),
|
||||
cv.Optional(CONF_INITIAL_STATE): INITIAL_STATE_SCHEMA,
|
||||
cv.Optional(CONF_SET_MODE_ACTION): automation.validate_automation(
|
||||
single=True
|
||||
),
|
||||
cv.Optional(
|
||||
CONF_SET_TARGET_TEMPERATURE_ACTION
|
||||
): automation.validate_automation(single=True),
|
||||
cv.Optional(
|
||||
CONF_SET_TARGET_TEMPERATURE_LOW_ACTION
|
||||
): automation.validate_automation(single=True),
|
||||
cv.Optional(
|
||||
CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION
|
||||
): automation.validate_automation(single=True),
|
||||
cv.Optional(
|
||||
CONF_SET_TARGET_HUMIDITY_ACTION
|
||||
): automation.validate_automation(single=True),
|
||||
cv.Optional(CONF_SET_FAN_MODE_ACTION): automation.validate_automation(
|
||||
single=True
|
||||
),
|
||||
cv.Optional(
|
||||
CONF_SET_CUSTOM_FAN_MODE_ACTION
|
||||
): automation.validate_automation(single=True),
|
||||
cv.Optional(CONF_SET_SWING_MODE_ACTION): automation.validate_automation(
|
||||
single=True
|
||||
),
|
||||
cv.Optional(CONF_SET_PRESET_ACTION): automation.validate_automation(
|
||||
single=True
|
||||
),
|
||||
cv.Optional(CONF_SET_CUSTOM_PRESET_ACTION): automation.validate_automation(
|
||||
single=True
|
||||
),
|
||||
}
|
||||
)
|
||||
.extend(cv.COMPONENT_SCHEMA),
|
||||
_validate_set_actions,
|
||||
_resolve_supports,
|
||||
_validate_initial_state,
|
||||
)
|
||||
|
||||
|
||||
async def to_code(config: ConfigType) -> None:
|
||||
var = cg.new_Pvariable(config[CONF_ID])
|
||||
await cg.register_component(var, config)
|
||||
await climate.register_climate(var, config)
|
||||
|
||||
if (sens := config.get(CONF_SENSOR)) is not None:
|
||||
cg.add(var.set_sensor(await cg.get_variable(sens)))
|
||||
|
||||
if (sens := config.get(CONF_HUMIDITY_SENSOR)) is not None:
|
||||
cg.add(var.set_humidity_sensor(await cg.get_variable(sens)))
|
||||
|
||||
for key, flag in (
|
||||
(CONF_SUPPORTS_ACTION, climate_ns.CLIMATE_SUPPORTS_ACTION),
|
||||
(
|
||||
CONF_SUPPORTS_CURRENT_TEMPERATURE,
|
||||
climate_ns.CLIMATE_SUPPORTS_CURRENT_TEMPERATURE,
|
||||
),
|
||||
(CONF_SUPPORTS_CURRENT_HUMIDITY, climate_ns.CLIMATE_SUPPORTS_CURRENT_HUMIDITY),
|
||||
(
|
||||
CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
|
||||
climate_ns.CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
|
||||
),
|
||||
(CONF_SUPPORTS_TARGET_HUMIDITY, climate_ns.CLIMATE_SUPPORTS_TARGET_HUMIDITY),
|
||||
):
|
||||
if config[key]:
|
||||
cg.add(var.add_feature_flags(flag))
|
||||
|
||||
for mode in config[CONF_SUPPORTED_MODES]:
|
||||
cg.add(var.add_supported_mode(mode))
|
||||
|
||||
for mode in config.get(CONF_SUPPORTED_FAN_MODES, []):
|
||||
cg.add(var.add_supported_fan_mode(mode))
|
||||
|
||||
if CONF_CUSTOM_FAN_MODES in config:
|
||||
cg.add(
|
||||
var.set_supported_custom_fan_modes(
|
||||
cg.ArrayInitializer(*config[CONF_CUSTOM_FAN_MODES])
|
||||
)
|
||||
)
|
||||
|
||||
for mode in config.get(CONF_SUPPORTED_SWING_MODES, []):
|
||||
cg.add(var.add_supported_swing_mode(mode))
|
||||
|
||||
for preset in config.get(CONF_SUPPORTED_PRESETS, []):
|
||||
cg.add(var.add_supported_preset(preset))
|
||||
|
||||
if CONF_CUSTOM_PRESETS in config:
|
||||
cg.add(
|
||||
var.set_supported_custom_presets(
|
||||
cg.ArrayInitializer(*config[CONF_CUSTOM_PRESETS])
|
||||
)
|
||||
)
|
||||
|
||||
for key, trigger_getter, arg_type in SET_ACTIONS:
|
||||
if (conf := config.get(key)) is not None:
|
||||
await automation.build_automation(
|
||||
getattr(var, trigger_getter)(), [(arg_type, "x")], conf
|
||||
)
|
||||
|
||||
cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
|
||||
cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
|
||||
|
||||
if (initial_state := config.get(CONF_INITIAL_STATE)) is not None:
|
||||
if (v := initial_state.get(CONF_MODE)) is not None:
|
||||
cg.add(var.set_mode(v))
|
||||
if (v := initial_state.get(CONF_TARGET_TEMPERATURE)) is not None:
|
||||
cg.add(var.set_target_temperature(v))
|
||||
if (v := initial_state.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
|
||||
cg.add(var.set_target_temperature_low(v))
|
||||
if (v := initial_state.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
|
||||
cg.add(var.set_target_temperature_high(v))
|
||||
if (v := initial_state.get(CONF_TARGET_HUMIDITY)) is not None:
|
||||
cg.add(var.set_target_humidity(v))
|
||||
if (v := initial_state.get(CONF_FAN_MODE)) is not None:
|
||||
cg.add(var.set_fan_mode(v))
|
||||
if (v := initial_state.get(CONF_CUSTOM_FAN_MODE)) is not None:
|
||||
cg.add(var.set_custom_fan_mode(v))
|
||||
if (v := initial_state.get(CONF_SWING_MODE)) is not None:
|
||||
cg.add(var.set_swing_mode(v))
|
||||
if (v := initial_state.get(CONF_PRESET)) is not None:
|
||||
cg.add(var.set_preset(v))
|
||||
if (v := initial_state.get(CONF_CUSTOM_PRESET)) is not None:
|
||||
cg.add(var.set_custom_preset(v))
|
||||
|
||||
|
||||
CLIMATE_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.All(
|
||||
cv.Schema(
|
||||
{
|
||||
cv.GenerateID(): cv.use_id(TemplateClimate),
|
||||
cv.Optional(CONF_CURRENT_TEMPERATURE): cv.templatable(cv.temperature),
|
||||
cv.Optional(CONF_CURRENT_HUMIDITY): cv.templatable(cv.percentage_int),
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
|
||||
cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.templatable(cv.temperature),
|
||||
cv.Optional(CONF_TARGET_HUMIDITY): cv.templatable(cv.percentage_int),
|
||||
cv.Optional(CONF_MODE): cv.templatable(climate.validate_climate_mode),
|
||||
cv.Optional(CONF_ACTION): cv.templatable(climate.validate_climate_action),
|
||||
cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
|
||||
climate.validate_climate_fan_mode
|
||||
),
|
||||
cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.templatable(
|
||||
validate_custom_climate_string
|
||||
),
|
||||
cv.Optional(CONF_SWING_MODE): cv.templatable(
|
||||
climate.validate_climate_swing_mode
|
||||
),
|
||||
cv.Exclusive(CONF_PRESET, "preset"): cv.templatable(
|
||||
climate.validate_climate_preset
|
||||
),
|
||||
cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.templatable(
|
||||
validate_custom_climate_string
|
||||
),
|
||||
}
|
||||
),
|
||||
_validate_two_point,
|
||||
)
|
||||
|
||||
|
||||
@automation.register_action(
|
||||
"climate.template.publish",
|
||||
TemplateClimatePublishAction,
|
||||
CLIMATE_TEMPLATE_PUBLISH_ACTION_SCHEMA,
|
||||
synchronous=True,
|
||||
)
|
||||
async def climate_template_publish_to_code(
|
||||
config: ConfigType,
|
||||
action_id: ID,
|
||||
template_arg: cg.TemplateArguments,
|
||||
args: TemplateArgsType,
|
||||
) -> MockObj:
|
||||
var = cg.new_Pvariable(action_id, template_arg)
|
||||
await cg.register_parented(var, config[CONF_ID])
|
||||
|
||||
if (v := config.get(CONF_CURRENT_TEMPERATURE)) is not None:
|
||||
cg.add(var.set_current_temperature(await cg.templatable(v, args, cg.float_)))
|
||||
if (v := config.get(CONF_CURRENT_HUMIDITY)) is not None:
|
||||
cg.add(var.set_current_humidity(await cg.templatable(v, args, cg.float_)))
|
||||
if (v := config.get(CONF_TARGET_TEMPERATURE)) is not None:
|
||||
cg.add(var.set_target_temperature(await cg.templatable(v, args, cg.float_)))
|
||||
if (v := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
|
||||
cg.add(var.set_target_temperature_low(await cg.templatable(v, args, cg.float_)))
|
||||
if (v := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
|
||||
cg.add(
|
||||
var.set_target_temperature_high(await cg.templatable(v, args, cg.float_))
|
||||
)
|
||||
if (v := config.get(CONF_TARGET_HUMIDITY)) is not None:
|
||||
cg.add(var.set_target_humidity(await cg.templatable(v, args, cg.float_)))
|
||||
if (v := config.get(CONF_MODE)) is not None:
|
||||
cg.add(var.set_mode(await cg.templatable(v, args, climate.ClimateMode)))
|
||||
if (v := config.get(CONF_ACTION)) is not None:
|
||||
cg.add(var.set_action(await cg.templatable(v, args, climate.ClimateAction)))
|
||||
if (v := config.get(CONF_FAN_MODE)) is not None:
|
||||
cg.add(var.set_fan_mode(await cg.templatable(v, args, climate.ClimateFanMode)))
|
||||
if (v := config.get(CONF_CUSTOM_FAN_MODE)) is not None:
|
||||
cg.add(var.set_custom_fan_mode(await cg.templatable(v, args, cg.std_string)))
|
||||
if (v := config.get(CONF_SWING_MODE)) is not None:
|
||||
cg.add(
|
||||
var.set_swing_mode(await cg.templatable(v, args, climate.ClimateSwingMode))
|
||||
)
|
||||
if (v := config.get(CONF_PRESET)) is not None:
|
||||
cg.add(var.set_preset(await cg.templatable(v, args, climate.ClimatePreset)))
|
||||
if (v := config.get(CONF_CUSTOM_PRESET)) is not None:
|
||||
cg.add(var.set_custom_preset(await cg.templatable(v, args, cg.std_string)))
|
||||
|
||||
return var
|
||||
@@ -0,0 +1,57 @@
|
||||
#pragma once
|
||||
|
||||
#include "template_climate.h"
|
||||
#include "esphome/core/automation.h"
|
||||
|
||||
namespace esphome::template_ {
|
||||
|
||||
template<typename... Ts>
|
||||
class TemplateClimatePublishAction final : public Action<Ts...>, public Parented<TemplateClimate> {
|
||||
public:
|
||||
TEMPLATABLE_VALUE(float, current_temperature)
|
||||
TEMPLATABLE_VALUE(float, current_humidity)
|
||||
TEMPLATABLE_VALUE(float, target_temperature)
|
||||
TEMPLATABLE_VALUE(float, target_temperature_low)
|
||||
TEMPLATABLE_VALUE(float, target_temperature_high)
|
||||
TEMPLATABLE_VALUE(float, target_humidity)
|
||||
TEMPLATABLE_VALUE(climate::ClimateMode, mode)
|
||||
TEMPLATABLE_VALUE(climate::ClimateAction, action)
|
||||
TEMPLATABLE_VALUE(climate::ClimateFanMode, fan_mode)
|
||||
TEMPLATABLE_VALUE(std::string, custom_fan_mode)
|
||||
TEMPLATABLE_VALUE(climate::ClimateSwingMode, swing_mode)
|
||||
TEMPLATABLE_VALUE(climate::ClimatePreset, preset)
|
||||
TEMPLATABLE_VALUE(std::string, custom_preset)
|
||||
|
||||
void play(const Ts &...x) override {
|
||||
if (this->current_temperature_.has_value())
|
||||
this->parent_->current_temperature = this->current_temperature_.value(x...);
|
||||
if (this->current_humidity_.has_value())
|
||||
this->parent_->current_humidity = this->current_humidity_.value(x...);
|
||||
if (this->target_temperature_.has_value())
|
||||
this->parent_->set_target_temperature(this->target_temperature_.value(x...));
|
||||
if (this->target_temperature_low_.has_value())
|
||||
this->parent_->set_target_temperature_low(this->target_temperature_low_.value(x...));
|
||||
if (this->target_temperature_high_.has_value())
|
||||
this->parent_->set_target_temperature_high(this->target_temperature_high_.value(x...));
|
||||
if (this->target_humidity_.has_value())
|
||||
this->parent_->set_target_humidity(this->target_humidity_.value(x...));
|
||||
if (this->mode_.has_value())
|
||||
this->parent_->set_mode(this->mode_.value(x...));
|
||||
if (this->action_.has_value())
|
||||
this->parent_->action = this->action_.value(x...);
|
||||
if (this->fan_mode_.has_value())
|
||||
this->parent_->set_fan_mode(this->fan_mode_.value(x...));
|
||||
if (this->custom_fan_mode_.has_value())
|
||||
this->parent_->set_custom_fan_mode(StringRef(this->custom_fan_mode_.value(x...)));
|
||||
if (this->swing_mode_.has_value())
|
||||
this->parent_->set_swing_mode(this->swing_mode_.value(x...));
|
||||
if (this->preset_.has_value())
|
||||
this->parent_->set_preset(this->preset_.value(x...));
|
||||
if (this->custom_preset_.has_value())
|
||||
this->parent_->set_custom_preset(StringRef(this->custom_preset_.value(x...)));
|
||||
|
||||
this->parent_->publish_state();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace esphome::template_
|
||||
@@ -0,0 +1,164 @@
|
||||
#include "template_climate.h"
|
||||
#include "esphome/core/log.h"
|
||||
|
||||
namespace esphome::template_ {
|
||||
|
||||
static const char *const TAG = "template.climate";
|
||||
|
||||
void TemplateClimate::setup() {
|
||||
if (this->restore_mode_ == TemplateClimateRestoreMode::TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE) {
|
||||
auto restore = this->restore_state_();
|
||||
if (restore.has_value()) {
|
||||
restore->apply(this);
|
||||
}
|
||||
}
|
||||
|
||||
// Sensors publish every reading, not just changes, so only re-publish when the value moved.
|
||||
// NAN means the sensor went unavailable and is passed through rather than dropped; the second
|
||||
// check stops an unavailable sensor re-publishing forever, since NAN never equals NAN.
|
||||
#ifdef USE_SENSOR
|
||||
if (this->sensor_ != nullptr) {
|
||||
this->current_temperature = this->sensor_->state;
|
||||
this->sensor_->add_on_state_callback([this](float state) {
|
||||
if (state != this->current_temperature && !(std::isnan(state) && std::isnan(this->current_temperature))) {
|
||||
this->current_temperature = state;
|
||||
this->publish_state();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (this->humidity_sensor_ != nullptr) {
|
||||
this->current_humidity = this->humidity_sensor_->state;
|
||||
this->humidity_sensor_->add_on_state_callback([this](float state) {
|
||||
if (state != this->current_humidity && !(std::isnan(state) && std::isnan(this->current_humidity))) {
|
||||
this->current_humidity = state;
|
||||
this->publish_state();
|
||||
}
|
||||
});
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void TemplateClimate::dump_config() {
|
||||
LOG_CLIMATE("", "Template Climate", this);
|
||||
ESP_LOGCONFIG(TAG, " Optimistic: %s", YESNO(this->optimistic_));
|
||||
}
|
||||
|
||||
void TemplateClimate::control(const climate::ClimateCall &call) {
|
||||
// Each field present fires its set_*_action; on_control sees the whole call. optimistic: true
|
||||
// also applies the values right away, false waits for a climate.template.publish report.
|
||||
if (auto mode = call.get_mode()) {
|
||||
if (this->optimistic_)
|
||||
this->mode = *mode;
|
||||
this->set_mode_trigger_.trigger(*mode);
|
||||
}
|
||||
|
||||
if (auto target_temp = call.get_target_temperature()) {
|
||||
if (this->optimistic_)
|
||||
this->target_temperature = *target_temp;
|
||||
this->set_target_temperature_trigger_.trigger(*target_temp);
|
||||
}
|
||||
|
||||
if (auto target_temp_low = call.get_target_temperature_low()) {
|
||||
if (this->optimistic_)
|
||||
this->target_temperature_low = *target_temp_low;
|
||||
this->set_target_temperature_low_trigger_.trigger(*target_temp_low);
|
||||
}
|
||||
|
||||
if (auto target_temp_high = call.get_target_temperature_high()) {
|
||||
if (this->optimistic_)
|
||||
this->target_temperature_high = *target_temp_high;
|
||||
this->set_target_temperature_high_trigger_.trigger(*target_temp_high);
|
||||
}
|
||||
|
||||
if (auto target_humidity = call.get_target_humidity()) {
|
||||
if (this->optimistic_)
|
||||
this->target_humidity = *target_humidity;
|
||||
this->set_target_humidity_trigger_.trigger(*target_humidity);
|
||||
}
|
||||
|
||||
if (auto fan_mode = call.get_fan_mode()) {
|
||||
if (this->optimistic_)
|
||||
this->set_fan_mode_(*fan_mode);
|
||||
this->set_fan_mode_trigger_.trigger(*fan_mode);
|
||||
}
|
||||
|
||||
if (call.has_custom_fan_mode()) {
|
||||
if (this->optimistic_)
|
||||
this->set_custom_fan_mode_(call.get_custom_fan_mode());
|
||||
this->set_custom_fan_mode_trigger_.trigger(call.get_custom_fan_mode());
|
||||
}
|
||||
|
||||
if (auto swing_mode = call.get_swing_mode()) {
|
||||
if (this->optimistic_)
|
||||
this->swing_mode = *swing_mode;
|
||||
this->set_swing_mode_trigger_.trigger(*swing_mode);
|
||||
}
|
||||
|
||||
if (auto preset = call.get_preset()) {
|
||||
if (this->optimistic_)
|
||||
this->set_preset_(*preset);
|
||||
this->set_preset_trigger_.trigger(*preset);
|
||||
}
|
||||
|
||||
if (call.has_custom_preset()) {
|
||||
if (this->optimistic_)
|
||||
this->set_custom_preset_(call.get_custom_preset());
|
||||
this->set_custom_preset_trigger_.trigger(call.get_custom_preset());
|
||||
}
|
||||
|
||||
if (this->optimistic_)
|
||||
this->publish_state();
|
||||
}
|
||||
|
||||
// A climate.template.publish report (and initial_state:) never goes through ClimateCall::validate_(),
|
||||
// so check here instead -- otherwise a typo is published as state the receiving end will reject.
|
||||
void TemplateClimate::set_mode(climate::ClimateMode mode) {
|
||||
if (!this->traits_.supports_mode(mode)) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported mode %u", this->get_name().c_str(), static_cast<unsigned>(mode));
|
||||
return;
|
||||
}
|
||||
this->mode = mode;
|
||||
}
|
||||
|
||||
void TemplateClimate::set_swing_mode(climate::ClimateSwingMode swing_mode) {
|
||||
if (!this->traits_.supports_swing_mode(swing_mode)) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported swing mode %u", this->get_name().c_str(), static_cast<unsigned>(swing_mode));
|
||||
return;
|
||||
}
|
||||
this->swing_mode = swing_mode;
|
||||
}
|
||||
|
||||
void TemplateClimate::set_fan_mode(climate::ClimateFanMode fan_mode) {
|
||||
if (!this->traits_.supports_fan_mode(fan_mode)) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported fan mode %u", this->get_name().c_str(), static_cast<unsigned>(fan_mode));
|
||||
return;
|
||||
}
|
||||
this->set_fan_mode_(fan_mode);
|
||||
}
|
||||
|
||||
void TemplateClimate::set_preset(climate::ClimatePreset preset) {
|
||||
if (!this->traits_.supports_preset(preset)) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported preset %u", this->get_name().c_str(), static_cast<unsigned>(preset));
|
||||
return;
|
||||
}
|
||||
this->set_preset_(preset);
|
||||
}
|
||||
|
||||
void TemplateClimate::set_custom_fan_mode(StringRef mode) {
|
||||
if (this->find_custom_fan_mode_(mode.c_str(), mode.size()) == nullptr) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported custom fan mode '%s'", this->get_name().c_str(), mode.c_str());
|
||||
return;
|
||||
}
|
||||
this->set_custom_fan_mode_(mode);
|
||||
}
|
||||
|
||||
void TemplateClimate::set_custom_preset(StringRef preset) {
|
||||
if (this->find_custom_preset_(preset.c_str(), preset.size()) == nullptr) {
|
||||
ESP_LOGW(TAG, "'%s' - Unsupported custom preset '%s'", this->get_name().c_str(), preset.c_str());
|
||||
return;
|
||||
}
|
||||
this->set_custom_preset_(preset);
|
||||
}
|
||||
|
||||
} // namespace esphome::template_
|
||||
@@ -0,0 +1,92 @@
|
||||
#pragma once
|
||||
|
||||
#include "esphome/core/automation.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/components/climate/climate.h"
|
||||
#ifdef USE_SENSOR
|
||||
#include "esphome/components/sensor/sensor.h"
|
||||
#endif
|
||||
|
||||
namespace esphome::template_ {
|
||||
|
||||
enum class TemplateClimateRestoreMode {
|
||||
TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE,
|
||||
TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE,
|
||||
};
|
||||
|
||||
class TemplateClimate final : public climate::Climate, public Component {
|
||||
public:
|
||||
void setup() override;
|
||||
void dump_config() override;
|
||||
|
||||
climate::ClimateTraits traits() override { return this->traits_; }
|
||||
|
||||
void add_feature_flags(uint32_t flags) { this->traits_.add_feature_flags(flags); }
|
||||
|
||||
#ifdef USE_SENSOR
|
||||
// The matching feature flag is added from codegen, so the configuration alone decides it.
|
||||
void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
|
||||
void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }
|
||||
#endif
|
||||
|
||||
void add_supported_mode(climate::ClimateMode mode) { this->traits_.add_supported_mode(mode); }
|
||||
void add_supported_fan_mode(climate::ClimateFanMode mode) { this->traits_.add_supported_fan_mode(mode); }
|
||||
void add_supported_swing_mode(climate::ClimateSwingMode mode) { this->traits_.add_supported_swing_mode(mode); }
|
||||
void add_supported_preset(climate::ClimatePreset preset) { this->traits_.add_supported_preset(preset); }
|
||||
|
||||
void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
|
||||
void set_restore_mode(TemplateClimateRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
|
||||
|
||||
// Fired from control() for each field the call carries, so a device-backed config can forward
|
||||
// it on. Which of these are configured also decides the two-point/target-humidity traits.
|
||||
Trigger<climate::ClimateMode> *get_set_mode_trigger() { return &this->set_mode_trigger_; }
|
||||
Trigger<float> *get_set_target_temperature_trigger() { return &this->set_target_temperature_trigger_; }
|
||||
Trigger<float> *get_set_target_temperature_low_trigger() { return &this->set_target_temperature_low_trigger_; }
|
||||
Trigger<float> *get_set_target_temperature_high_trigger() { return &this->set_target_temperature_high_trigger_; }
|
||||
Trigger<float> *get_set_target_humidity_trigger() { return &this->set_target_humidity_trigger_; }
|
||||
Trigger<climate::ClimateFanMode> *get_set_fan_mode_trigger() { return &this->set_fan_mode_trigger_; }
|
||||
Trigger<StringRef> *get_set_custom_fan_mode_trigger() { return &this->set_custom_fan_mode_trigger_; }
|
||||
Trigger<climate::ClimateSwingMode> *get_set_swing_mode_trigger() { return &this->set_swing_mode_trigger_; }
|
||||
Trigger<climate::ClimatePreset> *get_set_preset_trigger() { return &this->set_preset_trigger_; }
|
||||
Trigger<StringRef> *get_set_custom_preset_trigger() { return &this->set_custom_preset_trigger_; }
|
||||
|
||||
// Used by TemplateClimatePublishAction, which is not a Climate subclass and so cannot reach the
|
||||
// protected setters, and by codegen to apply `initial_state:` before setup() runs.
|
||||
void set_target_temperature(float value) { this->target_temperature = value; }
|
||||
void set_target_temperature_low(float value) { this->target_temperature_low = value; }
|
||||
void set_target_temperature_high(float value) { this->target_temperature_high = value; }
|
||||
void set_target_humidity(float value) { this->target_humidity = value; }
|
||||
void set_mode(climate::ClimateMode mode);
|
||||
void set_swing_mode(climate::ClimateSwingMode mode);
|
||||
void set_fan_mode(climate::ClimateFanMode mode);
|
||||
void set_custom_fan_mode(const char *mode) { this->set_custom_fan_mode(StringRef(mode)); }
|
||||
void set_custom_fan_mode(StringRef mode);
|
||||
void set_preset(climate::ClimatePreset preset);
|
||||
void set_custom_preset(const char *preset) { this->set_custom_preset(StringRef(preset)); }
|
||||
void set_custom_preset(StringRef preset);
|
||||
|
||||
protected:
|
||||
void control(const climate::ClimateCall &call) override;
|
||||
|
||||
climate::ClimateTraits traits_;
|
||||
bool optimistic_{false};
|
||||
TemplateClimateRestoreMode restore_mode_{TemplateClimateRestoreMode::TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE};
|
||||
|
||||
#ifdef USE_SENSOR
|
||||
sensor::Sensor *sensor_{nullptr};
|
||||
sensor::Sensor *humidity_sensor_{nullptr};
|
||||
#endif
|
||||
|
||||
Trigger<climate::ClimateMode> set_mode_trigger_;
|
||||
Trigger<float> set_target_temperature_trigger_;
|
||||
Trigger<float> set_target_temperature_low_trigger_;
|
||||
Trigger<float> set_target_temperature_high_trigger_;
|
||||
Trigger<float> set_target_humidity_trigger_;
|
||||
Trigger<climate::ClimateFanMode> set_fan_mode_trigger_;
|
||||
Trigger<StringRef> set_custom_fan_mode_trigger_;
|
||||
Trigger<climate::ClimateSwingMode> set_swing_mode_trigger_;
|
||||
Trigger<climate::ClimatePreset> set_preset_trigger_;
|
||||
Trigger<StringRef> set_custom_preset_trigger_;
|
||||
};
|
||||
|
||||
} // namespace esphome::template_
|
||||
Reference in New Issue
Block a user