1c8b5838cd
* Fire events for ISY994 control events This allows hass to react directly to Insteon button presses (on switches and remotes), including presses, double-presses, and long holds * Move change event subscription to after entity is added to hass The event handler method requires `self.hass` to exist, which doesn't have a value until the async_added_to_hass method is called. Should eliminate a race condition. * Overhaul binary sensors in ISY994 to be functional "out of the box" We now smash all of the subnodes from the ISY994 in to one Hass binary_sensor, and automatically support both paradigms of state reporting that Insteon sensors can do. Sometimes a single node's state represents the sensor's state, other times two nodes are used and only "ON" events are sent from each. The logic between the two forunately do not conflict so we can support both without knowing which mode the device is in. This also allows us to handle the heartbeat functionality that certain sensors have - we simply store the timestamp of the heartbeat as an attribute on the sensor device. It defaults to Unknown on bootup if and only if the device supports heartbeats, due to the presence of subnode 4. * Parse the binary sensor device class from the ISY's device "type" Now we automatically know which sensors are moisture, motion, and openings! (We also reverse the moisture sensor state, because Insteon reports ON for dry on the primary node.) * Code review tweaks The one material change here is that the event subscribers were moved to the `async_added_to_hass` method, as the handlers depend on things that only exist after the entity has been added. * Handle cases where a sensor's state is unknown When the ISY first boots up, if a battery-powered sensor has not reported in yet (due to heartbeat or a change in state), the state is unknown until it does. * Clean up from code review Fix coroutine await, remove unnecessary exception check, and return None when state is unknown * Unknown value from PyISY is now -inf rather than -1 * Move heartbeat handling to a separate sensor Now all heartbeat-compatible sensors will have a separate `binary_sensor` device that represents the battery state (on = dead) * Add support for Unknown state, which is being added in next PyISY PyISY will report unknown states as the number "-inf". This is implemented in the base ISY994 component, but subcomponents that override the `state` method needed some extra logic to handle it as well. * Change a couple try blocks to explicit None checks * Bump PyISY to 1.1.0, now that it has been published! * Remove -inf checking from base component The implementation of the -inf checking was improved in another branch which has been merged in to this branch already. * Restrict negative-node and heartbeat support to known compatible types Not all Insteon sensors use the same subnode IDs for the same things, so we need to use different logic depending on device type. Negative node and heartbeat support is now only used for leak sensors and open/close sensors. * Use new style string formatting * Add binary sensor detection for pre-5.x firmware Meant to do this originally; writing documentation revealed that this requirement was missed!
110 lines
3.5 KiB
Python
110 lines
3.5 KiB
Python
"""
|
|
Support for ISY994 covers.
|
|
|
|
For more details about this platform, please refer to the documentation at
|
|
https://home-assistant.io/components/cover.isy994/
|
|
"""
|
|
import logging
|
|
from typing import Callable # noqa
|
|
|
|
from homeassistant.components.cover import CoverDevice, DOMAIN
|
|
import homeassistant.components.isy994 as isy
|
|
from homeassistant.const import STATE_OPEN, STATE_CLOSED, STATE_UNKNOWN
|
|
from homeassistant.helpers.typing import ConfigType
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
VALUE_TO_STATE = {
|
|
0: STATE_CLOSED,
|
|
101: STATE_UNKNOWN,
|
|
}
|
|
|
|
UOM = ['97']
|
|
STATES = [STATE_OPEN, STATE_CLOSED, 'closing', 'opening', 'stopped']
|
|
|
|
|
|
# pylint: disable=unused-argument
|
|
def setup_platform(hass, config: ConfigType,
|
|
add_devices: Callable[[list], None], discovery_info=None):
|
|
"""Set up the ISY994 cover platform."""
|
|
if isy.ISY is None or not isy.ISY.connected:
|
|
_LOGGER.error("A connection has not been made to the ISY controller")
|
|
return False
|
|
|
|
devices = []
|
|
|
|
for node in isy.filter_nodes(isy.NODES, units=UOM, states=STATES):
|
|
devices.append(ISYCoverDevice(node))
|
|
|
|
for program in isy.PROGRAMS.get(DOMAIN, []):
|
|
try:
|
|
status = program[isy.KEY_STATUS]
|
|
actions = program[isy.KEY_ACTIONS]
|
|
assert actions.dtype == 'program', 'Not a program'
|
|
except (KeyError, AssertionError):
|
|
pass
|
|
else:
|
|
devices.append(ISYCoverProgram(program.name, status, actions))
|
|
|
|
add_devices(devices)
|
|
|
|
|
|
class ISYCoverDevice(isy.ISYDevice, CoverDevice):
|
|
"""Representation of an ISY994 cover device."""
|
|
|
|
def __init__(self, node: object):
|
|
"""Initialize the ISY994 cover device."""
|
|
isy.ISYDevice.__init__(self, node)
|
|
|
|
@property
|
|
def current_cover_position(self) -> int:
|
|
"""Return the current cover position."""
|
|
return sorted((0, self.value, 100))[1]
|
|
|
|
@property
|
|
def is_closed(self) -> bool:
|
|
"""Get whether the ISY994 cover device is closed."""
|
|
return self.state == STATE_CLOSED
|
|
|
|
@property
|
|
def state(self) -> str:
|
|
"""Get the state of the ISY994 cover device."""
|
|
if self.is_unknown():
|
|
return None
|
|
else:
|
|
return VALUE_TO_STATE.get(self.value, STATE_OPEN)
|
|
|
|
def open_cover(self, **kwargs) -> None:
|
|
"""Send the open cover command to the ISY994 cover device."""
|
|
if not self._node.on(val=100):
|
|
_LOGGER.error("Unable to open the cover")
|
|
|
|
def close_cover(self, **kwargs) -> None:
|
|
"""Send the close cover command to the ISY994 cover device."""
|
|
if not self._node.off():
|
|
_LOGGER.error("Unable to close the cover")
|
|
|
|
|
|
class ISYCoverProgram(ISYCoverDevice):
|
|
"""Representation of an ISY994 cover program."""
|
|
|
|
def __init__(self, name: str, node: object, actions: object) -> None:
|
|
"""Initialize the ISY994 cover program."""
|
|
ISYCoverDevice.__init__(self, node)
|
|
self._name = name
|
|
self._actions = actions
|
|
|
|
@property
|
|
def state(self) -> str:
|
|
"""Get the state of the ISY994 cover program."""
|
|
return STATE_CLOSED if bool(self.value) else STATE_OPEN
|
|
|
|
def open_cover(self, **kwargs) -> None:
|
|
"""Send the open cover command to the ISY994 cover program."""
|
|
if not self._actions.runThen():
|
|
_LOGGER.error("Unable to open the cover")
|
|
|
|
def close_cover(self, **kwargs) -> None:
|
|
"""Send the close cover command to the ISY994 cover program."""
|
|
if not self._actions.runElse():
|
|
_LOGGER.error("Unable to close the cover")
|