350 lines
13 KiB
Python
350 lines
13 KiB
Python
"""Platform to locally control Tuya-based cover devices."""
|
|
|
|
import asyncio
|
|
import logging
|
|
import time
|
|
from functools import partial
|
|
|
|
import voluptuous as vol
|
|
from homeassistant.components.cover import (
|
|
ATTR_POSITION,
|
|
DOMAIN,
|
|
CoverEntityFeature,
|
|
CoverEntity,
|
|
DEVICE_CLASSES_SCHEMA,
|
|
)
|
|
from homeassistant.const import CONF_DEVICE_CLASS
|
|
from .config_flow import col_to_select
|
|
from .entity import LocalTuyaEntity, async_setup_entry
|
|
from .const import (
|
|
CONF_COMMANDS_SET,
|
|
CONF_CURRENT_POSITION_DP,
|
|
CONF_POSITION_INVERTED,
|
|
CONF_POSITIONING_MODE,
|
|
CONF_SET_POSITION_DP,
|
|
CONF_SPAN_TIME,
|
|
CONF_STOP_SWITCH_DP,
|
|
)
|
|
|
|
|
|
# cover states.
|
|
STATE_OPENING = "opening"
|
|
STATE_CLOSING = "closing"
|
|
STATE_STOPPED = "stopped"
|
|
STATE_SET_CMD = "moving"
|
|
STATE_SET_OPENING = "set_opeing"
|
|
STATE_SET_CLOSING = "set_closing"
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
COVER_COMMANDS = {
|
|
"Open, Close and Stop": "open_close_stop",
|
|
"Open, Close and Continue": "open_close_continue",
|
|
"ON, OFF and Stop": "on_off_stop",
|
|
"fz, zz and Stop": "fz_zz_stop",
|
|
"zz, fz and Stop": "zz_fz_stop",
|
|
"1, 2 and 3": "1_2_3",
|
|
"0, 1 and 2": "0_1_2",
|
|
}
|
|
|
|
MODE_NONE = "none"
|
|
MODE_SET_POSITION = "position"
|
|
MODE_TIME_BASED = "timed"
|
|
COVER_MODES = {
|
|
"Neither": MODE_NONE,
|
|
"Set Position": MODE_SET_POSITION,
|
|
"Time Based": MODE_TIME_BASED,
|
|
}
|
|
|
|
COVER_TIMEOUT_TOLERANCE = 3.0
|
|
|
|
DEF_CMD_SET = list(COVER_COMMANDS.values())[0]
|
|
DEF_POS_MODE = list(COVER_MODES.values())[0]
|
|
DEFAULT_SPAN_TIME = 25.0
|
|
|
|
|
|
def flow_schema(dps):
|
|
"""Return schema used in config flow."""
|
|
return {
|
|
vol.Optional(CONF_COMMANDS_SET, default=DEF_CMD_SET): col_to_select(
|
|
COVER_COMMANDS
|
|
),
|
|
vol.Optional(CONF_POSITIONING_MODE, default=DEF_POS_MODE): col_to_select(
|
|
COVER_MODES
|
|
),
|
|
vol.Optional(CONF_CURRENT_POSITION_DP): col_to_select(dps, is_dps=True),
|
|
vol.Optional(CONF_SET_POSITION_DP): col_to_select(dps, is_dps=True),
|
|
vol.Optional(CONF_POSITION_INVERTED, default=False): bool,
|
|
vol.Optional(CONF_SPAN_TIME, default=DEFAULT_SPAN_TIME): vol.All(
|
|
vol.Coerce(float), vol.Range(min=1.0, max=300.0)
|
|
),
|
|
vol.Optional(CONF_STOP_SWITCH_DP): col_to_select(dps, is_dps=True),
|
|
vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
|
|
}
|
|
|
|
|
|
class LocalTuyaCover(LocalTuyaEntity, CoverEntity):
|
|
"""Tuya cover device."""
|
|
|
|
def __init__(self, device, config_entry, switchid, **kwargs):
|
|
"""Initialize a new LocalTuyaCover."""
|
|
super().__init__(device, config_entry, switchid, _LOGGER, **kwargs)
|
|
commands_set = DEF_CMD_SET
|
|
if self.has_config(CONF_COMMANDS_SET):
|
|
commands_set = self._config[CONF_COMMANDS_SET]
|
|
self._open_cmd = commands_set.split("_")[0]
|
|
self._close_cmd = commands_set.split("_")[1]
|
|
self._stop_cmd = commands_set.split("_")[2]
|
|
self._timer_start = time.time()
|
|
self._state = None
|
|
self._previous_state = None
|
|
self._current_cover_position = 0
|
|
self._current_state_action = STATE_STOPPED # Default.
|
|
self._set_new_position = int | None
|
|
self._stop_switch = self._config.get(CONF_STOP_SWITCH_DP)
|
|
self._position_inverted = self._config.get(CONF_POSITION_INVERTED)
|
|
self._current_task = None
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Flag supported features."""
|
|
supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
|
|
if not isinstance(self._open_cmd, bool):
|
|
supported_features |= CoverEntityFeature.STOP
|
|
if self._config[CONF_POSITIONING_MODE] != MODE_NONE:
|
|
supported_features |= CoverEntityFeature.SET_POSITION
|
|
return supported_features
|
|
|
|
@property
|
|
def _current_state(self) -> str:
|
|
"""Return the current state of the cover."""
|
|
state = self._current_state_action
|
|
curr_pos = self._current_cover_position
|
|
|
|
# Reset STATE when cover is fully closed or fully opened.
|
|
if (state == STATE_CLOSING and curr_pos == 0) or (
|
|
state == STATE_OPENING and curr_pos == 100
|
|
):
|
|
self._current_state_action = STATE_STOPPED
|
|
if state in (STATE_SET_CLOSING, STATE_SET_OPENING):
|
|
set_pos = self._set_new_position
|
|
# Reset state when cover reached the position.
|
|
if curr_pos - set_pos < 5 and curr_pos - set_pos >= -5:
|
|
self._current_state_action = STATE_STOPPED
|
|
|
|
return self._current_state_action
|
|
|
|
@property
|
|
def current_cover_position(self):
|
|
"""Return current cover position in percent."""
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_NONE:
|
|
return None
|
|
return self._current_cover_position
|
|
|
|
@property
|
|
def is_opening(self):
|
|
"""Return if cover is opening."""
|
|
return self._current_state in (STATE_OPENING, STATE_SET_OPENING)
|
|
|
|
@property
|
|
def is_closing(self):
|
|
"""Return if cover is closing."""
|
|
return self._current_state in (STATE_CLOSING, STATE_SET_CLOSING)
|
|
|
|
@property
|
|
def is_closed(self):
|
|
"""Return if the cover is closed or not."""
|
|
if isinstance(self._open_cmd, (bool, str)):
|
|
return self._current_cover_position == 0
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_NONE:
|
|
return None
|
|
return self.current_cover_position == 0 and self._current_state == STATE_STOPPED
|
|
|
|
async def async_set_cover_position(self, **kwargs):
|
|
"""Move the cover to a specific position."""
|
|
# Update device values IF the device is moving at the moment.
|
|
if self._current_state != STATE_STOPPED:
|
|
await self.async_stop_cover()
|
|
|
|
self.debug("Setting cover position: %r", kwargs[ATTR_POSITION])
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_TIME_BASED:
|
|
newpos = float(kwargs[ATTR_POSITION])
|
|
|
|
currpos = self.current_cover_position
|
|
posdiff = abs(newpos - currpos)
|
|
mydelay = posdiff / 100.0 * self._config[CONF_SPAN_TIME]
|
|
if newpos > currpos:
|
|
self.debug("Opening to %f: delay %f", newpos, mydelay)
|
|
await self.async_open_cover(delay=mydelay)
|
|
self.update_state(STATE_OPENING)
|
|
else:
|
|
self.debug("Closing to %f: delay %f", newpos, mydelay)
|
|
await self.async_close_cover(delay=mydelay)
|
|
self.update_state(STATE_CLOSING)
|
|
self.debug("Done")
|
|
|
|
elif self._config[CONF_POSITIONING_MODE] == MODE_SET_POSITION:
|
|
converted_position = int(kwargs[ATTR_POSITION])
|
|
if self._position_inverted:
|
|
converted_position = 100 - converted_position
|
|
if 0 <= converted_position <= 100 and self.has_config(CONF_SET_POSITION_DP):
|
|
await self._device.set_dp(
|
|
converted_position, self._config[CONF_SET_POSITION_DP]
|
|
)
|
|
# Give it a moment, to make sure hass updated current pos.
|
|
await asyncio.sleep(0.1)
|
|
self.update_state(STATE_SET_CMD, int(kwargs[ATTR_POSITION]))
|
|
|
|
async def async_stop_after_timeout(self, delay_sec):
|
|
"""Stop the cover if timeout (max movement span) occurred."""
|
|
try:
|
|
await asyncio.sleep(delay_sec)
|
|
self._current_task = None
|
|
await self.async_stop_cover()
|
|
except asyncio.CancelledError:
|
|
self._current_task = None
|
|
|
|
async def async_open_cover(self, **kwargs):
|
|
"""Open the cover."""
|
|
self.debug("Launching command %s to cover ", self._open_cmd)
|
|
await self._device.set_dp(self._open_cmd, self._dp_id)
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_TIME_BASED:
|
|
if self._current_task is not None:
|
|
self._current_task.cancel()
|
|
# for timed positioning, stop the cover after a full opening timespan
|
|
# instead of waiting the internal timeout
|
|
self._current_task = self.hass.async_create_task(
|
|
self.async_stop_after_timeout(
|
|
kwargs.get(
|
|
"delay", self._config[CONF_SPAN_TIME] + COVER_TIMEOUT_TOLERANCE
|
|
)
|
|
)
|
|
)
|
|
self.update_state(STATE_OPENING)
|
|
|
|
async def async_close_cover(self, **kwargs):
|
|
"""Close cover."""
|
|
self.debug("Launching command %s to cover ", self._close_cmd)
|
|
await self._device.set_dp(self._close_cmd, self._dp_id)
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_TIME_BASED:
|
|
if self._current_task is not None:
|
|
self._current_task.cancel()
|
|
# for timed positioning, stop the cover after a full opening timespan
|
|
# instead of waiting the internal timeout
|
|
self._current_task = self.hass.async_create_task(
|
|
self.async_stop_after_timeout(
|
|
kwargs.get(
|
|
"delay", self._config[CONF_SPAN_TIME] + COVER_TIMEOUT_TOLERANCE
|
|
)
|
|
)
|
|
)
|
|
self.update_state(STATE_CLOSING)
|
|
|
|
async def async_stop_cover(self, **kwargs):
|
|
"""Stop the cover."""
|
|
if self._current_task is not None:
|
|
self._current_task.cancel()
|
|
self.debug("Launching command %s to cover ", self._stop_cmd)
|
|
command = {self._dp_id: self._stop_cmd}
|
|
if self._stop_switch is not None:
|
|
command[self._stop_switch] = True
|
|
await self._device.set_dps(command)
|
|
self.update_state(STATE_STOPPED)
|
|
|
|
def status_restored(self, stored_state):
|
|
"""Restore the last stored cover status."""
|
|
if self._config[CONF_POSITIONING_MODE] == MODE_TIME_BASED:
|
|
stored_pos = stored_state.attributes.get("current_position")
|
|
if stored_pos is not None:
|
|
self._current_cover_position = stored_pos
|
|
self.debug("Restored cover position %s", self._current_cover_position)
|
|
|
|
def connection_made(self):
|
|
super().connection_made()
|
|
|
|
match self.dp_value(self._dp_id):
|
|
case str() as i if i.isupper():
|
|
self._open_cmd = self._open_cmd.upper()
|
|
self._close_cmd = self._close_cmd.upper()
|
|
self._stop_cmd = self._stop_cmd.upper()
|
|
case bool():
|
|
self._open_cmd = True
|
|
self._close_cmd = False
|
|
|
|
def status_updated(self):
|
|
"""Device status was updated."""
|
|
self._previous_state = self._state
|
|
self._state = self.dp_value(self._dp_id)
|
|
|
|
if self.has_config(CONF_CURRENT_POSITION_DP):
|
|
curr_pos = self.dp_value(CONF_CURRENT_POSITION_DP)
|
|
if isinstance(curr_pos, (bool, str)):
|
|
closed = curr_pos in (True, "fully_close")
|
|
stopped = (
|
|
self._previous_state is None or self._previous_state == self._state
|
|
)
|
|
curr_pos = 0 if stopped and closed else (100 if stopped else 50)
|
|
|
|
if self._position_inverted:
|
|
curr_pos = 100 - curr_pos
|
|
|
|
self._current_cover_position = curr_pos
|
|
|
|
if (
|
|
self._config[CONF_POSITIONING_MODE] == MODE_TIME_BASED
|
|
and self._state != self._previous_state
|
|
):
|
|
if self._previous_state != self._stop_cmd:
|
|
# the state has changed, and the cover was moving
|
|
time_diff = time.time() - self._timer_start
|
|
pos_diff = round(time_diff / self._config[CONF_SPAN_TIME] * 100.0)
|
|
if self._previous_state == self._close_cmd:
|
|
pos_diff = -pos_diff
|
|
self._current_cover_position = min(
|
|
100, max(0, self._current_cover_position + pos_diff)
|
|
)
|
|
|
|
change = "stopped" if self._state == self._stop_cmd else "inverted"
|
|
self.debug(
|
|
"Movement %s after %s sec., position difference %s",
|
|
change,
|
|
time_diff,
|
|
pos_diff,
|
|
)
|
|
|
|
# store the time of the last movement change
|
|
self._timer_start = time.time()
|
|
|
|
# Keep record in last_state as long as not during connection/re-connection,
|
|
# as last state will be used to restore the previous state
|
|
if (self._state is not None) and (not self._device.is_connecting):
|
|
self._last_state = self._state
|
|
|
|
def update_state(self, action, position=None):
|
|
"""Update cover current states."""
|
|
if (state := self._current_state_action) == action:
|
|
return
|
|
|
|
# using Commands.
|
|
if position is None:
|
|
self._current_state_action = action
|
|
# Set position cmd, check if target position weither close or open
|
|
if action == STATE_SET_CMD and position is not None:
|
|
curr_pos = self.current_cover_position
|
|
self._set_new_position = position
|
|
pos_diff = position - curr_pos
|
|
# Prevent stuck state when interrupted on middle of cmd
|
|
if state == STATE_STOPPED:
|
|
if pos_diff > 0:
|
|
self._current_state_action = STATE_SET_OPENING
|
|
elif pos_diff < 0:
|
|
self._current_state_action = STATE_SET_CLOSING
|
|
else:
|
|
self._current_state_action = STATE_STOPPED
|
|
# Write state data.
|
|
self.schedule_update_ha_state()
|
|
|
|
|
|
async_setup_entry = partial(async_setup_entry, DOMAIN, LocalTuyaCover, flow_schema)
|