mirror of https://github.com/home-assistant/core
1011 lines
35 KiB
Python
1011 lines
35 KiB
Python
"""Device for Zigbee Home Automation."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from collections.abc import Callable
|
|
from datetime import timedelta
|
|
from enum import Enum
|
|
from functools import cached_property
|
|
import logging
|
|
import random
|
|
import time
|
|
from typing import TYPE_CHECKING, Any, Self
|
|
|
|
from zigpy import types
|
|
from zigpy.device import Device as ZigpyDevice
|
|
import zigpy.exceptions
|
|
from zigpy.profiles import PROFILES
|
|
import zigpy.quirks
|
|
from zigpy.quirks.v2 import CustomDeviceV2
|
|
from zigpy.types.named import EUI64, NWK
|
|
from zigpy.zcl.clusters import Cluster
|
|
from zigpy.zcl.clusters.general import Groups, Identify
|
|
from zigpy.zcl.foundation import Status as ZclStatus, ZCLCommandDef
|
|
import zigpy.zdo.types as zdo_types
|
|
|
|
from homeassistant.const import ATTR_COMMAND, ATTR_DEVICE_ID, ATTR_NAME
|
|
from homeassistant.core import HomeAssistant, callback
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
from homeassistant.helpers import device_registry as dr
|
|
from homeassistant.helpers.device_registry import DeviceEntry
|
|
from homeassistant.helpers.dispatcher import (
|
|
async_dispatcher_connect,
|
|
async_dispatcher_send,
|
|
)
|
|
from homeassistant.helpers.event import async_track_time_interval
|
|
|
|
from . import const, discovery
|
|
from .cluster_handlers import ClusterHandler, ZDOClusterHandler
|
|
from .const import (
|
|
ATTR_ACTIVE_COORDINATOR,
|
|
ATTR_ARGS,
|
|
ATTR_ATTRIBUTE,
|
|
ATTR_AVAILABLE,
|
|
ATTR_CLUSTER_ID,
|
|
ATTR_CLUSTER_TYPE,
|
|
ATTR_COMMAND_TYPE,
|
|
ATTR_DEVICE_TYPE,
|
|
ATTR_ENDPOINT_ID,
|
|
ATTR_ENDPOINT_NAMES,
|
|
ATTR_ENDPOINTS,
|
|
ATTR_IEEE,
|
|
ATTR_LAST_SEEN,
|
|
ATTR_LQI,
|
|
ATTR_MANUFACTURER,
|
|
ATTR_MANUFACTURER_CODE,
|
|
ATTR_MODEL,
|
|
ATTR_NEIGHBORS,
|
|
ATTR_NODE_DESCRIPTOR,
|
|
ATTR_NWK,
|
|
ATTR_PARAMS,
|
|
ATTR_POWER_SOURCE,
|
|
ATTR_QUIRK_APPLIED,
|
|
ATTR_QUIRK_CLASS,
|
|
ATTR_QUIRK_ID,
|
|
ATTR_ROUTES,
|
|
ATTR_RSSI,
|
|
ATTR_SIGNATURE,
|
|
ATTR_VALUE,
|
|
CLUSTER_COMMAND_SERVER,
|
|
CLUSTER_COMMANDS_CLIENT,
|
|
CLUSTER_COMMANDS_SERVER,
|
|
CLUSTER_TYPE_IN,
|
|
CLUSTER_TYPE_OUT,
|
|
CONF_CONSIDER_UNAVAILABLE_BATTERY,
|
|
CONF_CONSIDER_UNAVAILABLE_MAINS,
|
|
CONF_DEFAULT_CONSIDER_UNAVAILABLE_BATTERY,
|
|
CONF_DEFAULT_CONSIDER_UNAVAILABLE_MAINS,
|
|
CONF_ENABLE_IDENTIFY_ON_JOIN,
|
|
POWER_BATTERY_OR_UNKNOWN,
|
|
POWER_MAINS_POWERED,
|
|
SIGNAL_AVAILABLE,
|
|
SIGNAL_UPDATE_DEVICE,
|
|
UNKNOWN,
|
|
UNKNOWN_MANUFACTURER,
|
|
UNKNOWN_MODEL,
|
|
ZHA_OPTIONS,
|
|
)
|
|
from .endpoint import Endpoint
|
|
from .helpers import LogMixin, async_get_zha_config_value, convert_to_zcl_values
|
|
|
|
if TYPE_CHECKING:
|
|
from ..websocket_api import ClusterBinding
|
|
from .gateway import ZHAGateway
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
_UPDATE_ALIVE_INTERVAL = (60, 90)
|
|
_CHECKIN_GRACE_PERIODS = 2
|
|
|
|
|
|
def get_device_automation_triggers(
|
|
device: zigpy.device.Device,
|
|
) -> dict[tuple[str, str], dict[str, str]]:
|
|
"""Get the supported device automation triggers for a zigpy device."""
|
|
return {
|
|
("device_offline", "device_offline"): {"device_event_type": "device_offline"},
|
|
**getattr(device, "device_automation_triggers", {}),
|
|
}
|
|
|
|
|
|
class DeviceStatus(Enum):
|
|
"""Status of a device."""
|
|
|
|
CREATED = 1
|
|
INITIALIZED = 2
|
|
|
|
|
|
class ZHADevice(LogMixin):
|
|
"""ZHA Zigbee device object."""
|
|
|
|
_ha_device_id: str
|
|
|
|
def __init__(
|
|
self,
|
|
hass: HomeAssistant,
|
|
zigpy_device: zigpy.device.Device,
|
|
zha_gateway: ZHAGateway,
|
|
) -> None:
|
|
"""Initialize the gateway."""
|
|
self.hass: HomeAssistant = hass
|
|
self._zigpy_device: ZigpyDevice = zigpy_device
|
|
self._zha_gateway: ZHAGateway = zha_gateway
|
|
self._available_signal: str = f"{self.name}_{self.ieee}_{SIGNAL_AVAILABLE}"
|
|
self._checkins_missed_count: int = 0
|
|
self.unsubs: list[Callable[[], None]] = []
|
|
self.quirk_applied: bool = isinstance(
|
|
self._zigpy_device, zigpy.quirks.CustomDevice
|
|
)
|
|
self.quirk_class: str = (
|
|
f"{self._zigpy_device.__class__.__module__}."
|
|
f"{self._zigpy_device.__class__.__name__}"
|
|
)
|
|
self.quirk_id: str | None = getattr(self._zigpy_device, ATTR_QUIRK_ID, None)
|
|
|
|
if self.is_mains_powered:
|
|
self.consider_unavailable_time: int = async_get_zha_config_value(
|
|
self._zha_gateway.config_entry,
|
|
ZHA_OPTIONS,
|
|
CONF_CONSIDER_UNAVAILABLE_MAINS,
|
|
CONF_DEFAULT_CONSIDER_UNAVAILABLE_MAINS,
|
|
)
|
|
else:
|
|
self.consider_unavailable_time = async_get_zha_config_value(
|
|
self._zha_gateway.config_entry,
|
|
ZHA_OPTIONS,
|
|
CONF_CONSIDER_UNAVAILABLE_BATTERY,
|
|
CONF_DEFAULT_CONSIDER_UNAVAILABLE_BATTERY,
|
|
)
|
|
self._available: bool = self.is_coordinator or (
|
|
self.last_seen is not None
|
|
and time.time() - self.last_seen < self.consider_unavailable_time
|
|
)
|
|
self._zdo_handler: ZDOClusterHandler = ZDOClusterHandler(self)
|
|
self._power_config_ch: ClusterHandler | None = None
|
|
self._identify_ch: ClusterHandler | None = None
|
|
self._basic_ch: ClusterHandler | None = None
|
|
self.status: DeviceStatus = DeviceStatus.CREATED
|
|
|
|
self._endpoints: dict[int, Endpoint] = {}
|
|
for ep_id, endpoint in zigpy_device.endpoints.items():
|
|
if ep_id != 0:
|
|
self._endpoints[ep_id] = Endpoint.new(endpoint, self)
|
|
|
|
if not self.is_coordinator:
|
|
keep_alive_interval = random.randint(*_UPDATE_ALIVE_INTERVAL)
|
|
self.debug(
|
|
"starting availability checks - interval: %s", keep_alive_interval
|
|
)
|
|
self.unsubs.append(
|
|
async_track_time_interval(
|
|
self.hass,
|
|
self._check_available,
|
|
timedelta(seconds=keep_alive_interval),
|
|
)
|
|
)
|
|
|
|
@property
|
|
def device_id(self) -> str:
|
|
"""Return the HA device registry device id."""
|
|
return self._ha_device_id
|
|
|
|
def set_device_id(self, device_id: str) -> None:
|
|
"""Set the HA device registry device id."""
|
|
self._ha_device_id = device_id
|
|
|
|
@property
|
|
def device(self) -> zigpy.device.Device:
|
|
"""Return underlying Zigpy device."""
|
|
return self._zigpy_device
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""Return device name."""
|
|
return f"{self.manufacturer} {self.model}"
|
|
|
|
@property
|
|
def ieee(self) -> EUI64:
|
|
"""Return ieee address for device."""
|
|
return self._zigpy_device.ieee
|
|
|
|
@property
|
|
def manufacturer(self) -> str:
|
|
"""Return manufacturer for device."""
|
|
if self._zigpy_device.manufacturer is None:
|
|
return UNKNOWN_MANUFACTURER
|
|
return self._zigpy_device.manufacturer
|
|
|
|
@property
|
|
def model(self) -> str:
|
|
"""Return model for device."""
|
|
if self._zigpy_device.model is None:
|
|
return UNKNOWN_MODEL
|
|
return self._zigpy_device.model
|
|
|
|
@property
|
|
def manufacturer_code(self) -> int | None:
|
|
"""Return the manufacturer code for the device."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return None
|
|
|
|
return self._zigpy_device.node_desc.manufacturer_code
|
|
|
|
@property
|
|
def nwk(self) -> NWK:
|
|
"""Return nwk for device."""
|
|
return self._zigpy_device.nwk
|
|
|
|
@property
|
|
def lqi(self):
|
|
"""Return lqi for device."""
|
|
return self._zigpy_device.lqi
|
|
|
|
@property
|
|
def rssi(self):
|
|
"""Return rssi for device."""
|
|
return self._zigpy_device.rssi
|
|
|
|
@property
|
|
def last_seen(self) -> float | None:
|
|
"""Return last_seen for device."""
|
|
return self._zigpy_device.last_seen
|
|
|
|
@property
|
|
def is_mains_powered(self) -> bool | None:
|
|
"""Return true if device is mains powered."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return None
|
|
|
|
return self._zigpy_device.node_desc.is_mains_powered
|
|
|
|
@property
|
|
def device_type(self) -> str:
|
|
"""Return the logical device type for the device."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return UNKNOWN
|
|
|
|
return self._zigpy_device.node_desc.logical_type.name
|
|
|
|
@property
|
|
def power_source(self) -> str:
|
|
"""Return the power source for the device."""
|
|
return (
|
|
POWER_MAINS_POWERED if self.is_mains_powered else POWER_BATTERY_OR_UNKNOWN
|
|
)
|
|
|
|
@property
|
|
def is_router(self) -> bool | None:
|
|
"""Return true if this is a routing capable device."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return None
|
|
|
|
return self._zigpy_device.node_desc.is_router
|
|
|
|
@property
|
|
def is_coordinator(self) -> bool | None:
|
|
"""Return true if this device represents a coordinator."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return None
|
|
|
|
return self._zigpy_device.node_desc.is_coordinator
|
|
|
|
@property
|
|
def is_active_coordinator(self) -> bool:
|
|
"""Return true if this device is the active coordinator."""
|
|
if not self.is_coordinator:
|
|
return False
|
|
|
|
return self.ieee == self.gateway.state.node_info.ieee
|
|
|
|
@property
|
|
def is_end_device(self) -> bool | None:
|
|
"""Return true if this device is an end device."""
|
|
if self._zigpy_device.node_desc is None:
|
|
return None
|
|
|
|
return self._zigpy_device.node_desc.is_end_device
|
|
|
|
@property
|
|
def is_groupable(self) -> bool:
|
|
"""Return true if this device has a group cluster."""
|
|
return self.is_coordinator or (
|
|
self.available and bool(self.async_get_groupable_endpoints())
|
|
)
|
|
|
|
@property
|
|
def skip_configuration(self) -> bool:
|
|
"""Return true if the device should not issue configuration related commands."""
|
|
return self._zigpy_device.skip_configuration or bool(self.is_coordinator)
|
|
|
|
@property
|
|
def gateway(self):
|
|
"""Return the gateway for this device."""
|
|
return self._zha_gateway
|
|
|
|
@cached_property
|
|
def device_automation_commands(self) -> dict[str, list[tuple[str, str]]]:
|
|
"""Return the a lookup of commands to etype/sub_type."""
|
|
commands: dict[str, list[tuple[str, str]]] = {}
|
|
for etype_subtype, trigger in self.device_automation_triggers.items():
|
|
if command := trigger.get(ATTR_COMMAND):
|
|
commands.setdefault(command, []).append(etype_subtype)
|
|
return commands
|
|
|
|
@cached_property
|
|
def device_automation_triggers(self) -> dict[tuple[str, str], dict[str, str]]:
|
|
"""Return the device automation triggers for this device."""
|
|
return get_device_automation_triggers(self._zigpy_device)
|
|
|
|
@property
|
|
def available_signal(self) -> str:
|
|
"""Signal to use to subscribe to device availability changes."""
|
|
return self._available_signal
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return True if device is available."""
|
|
return self._available
|
|
|
|
@available.setter
|
|
def available(self, new_availability: bool) -> None:
|
|
"""Set device availability."""
|
|
self._available = new_availability
|
|
|
|
@property
|
|
def power_configuration_ch(self) -> ClusterHandler | None:
|
|
"""Return power configuration cluster handler."""
|
|
return self._power_config_ch
|
|
|
|
@power_configuration_ch.setter
|
|
def power_configuration_ch(self, cluster_handler: ClusterHandler) -> None:
|
|
"""Power configuration cluster handler setter."""
|
|
if self._power_config_ch is None:
|
|
self._power_config_ch = cluster_handler
|
|
|
|
@property
|
|
def basic_ch(self) -> ClusterHandler | None:
|
|
"""Return basic cluster handler."""
|
|
return self._basic_ch
|
|
|
|
@basic_ch.setter
|
|
def basic_ch(self, cluster_handler: ClusterHandler) -> None:
|
|
"""Set the basic cluster handler."""
|
|
if self._basic_ch is None:
|
|
self._basic_ch = cluster_handler
|
|
|
|
@property
|
|
def identify_ch(self) -> ClusterHandler | None:
|
|
"""Return power configuration cluster handler."""
|
|
return self._identify_ch
|
|
|
|
@identify_ch.setter
|
|
def identify_ch(self, cluster_handler: ClusterHandler) -> None:
|
|
"""Power configuration cluster handler setter."""
|
|
if self._identify_ch is None:
|
|
self._identify_ch = cluster_handler
|
|
|
|
@property
|
|
def zdo_cluster_handler(self) -> ZDOClusterHandler:
|
|
"""Return ZDO cluster handler."""
|
|
return self._zdo_handler
|
|
|
|
@property
|
|
def endpoints(self) -> dict[int, Endpoint]:
|
|
"""Return the endpoints for this device."""
|
|
return self._endpoints
|
|
|
|
@property
|
|
def zigbee_signature(self) -> dict[str, Any]:
|
|
"""Get zigbee signature for this device."""
|
|
return {
|
|
ATTR_NODE_DESCRIPTOR: str(self._zigpy_device.node_desc),
|
|
ATTR_ENDPOINTS: {
|
|
signature[0]: signature[1]
|
|
for signature in [
|
|
endpoint.zigbee_signature for endpoint in self._endpoints.values()
|
|
]
|
|
},
|
|
ATTR_MANUFACTURER: self.manufacturer,
|
|
ATTR_MODEL: self.model,
|
|
}
|
|
|
|
@property
|
|
def sw_version(self) -> str | None:
|
|
"""Return the software version for this device."""
|
|
device_registry = dr.async_get(self.hass)
|
|
reg_device: DeviceEntry | None = device_registry.async_get(self.device_id)
|
|
if reg_device is None:
|
|
return None
|
|
return reg_device.sw_version
|
|
|
|
@classmethod
|
|
def new(
|
|
cls,
|
|
hass: HomeAssistant,
|
|
zigpy_dev: zigpy.device.Device,
|
|
gateway: ZHAGateway,
|
|
) -> Self:
|
|
"""Create new device."""
|
|
zha_dev = cls(hass, zigpy_dev, gateway)
|
|
zha_dev.unsubs.append(
|
|
async_dispatcher_connect(
|
|
hass,
|
|
SIGNAL_UPDATE_DEVICE.format(str(zha_dev.ieee)),
|
|
zha_dev.async_update_sw_build_id,
|
|
)
|
|
)
|
|
discovery.PROBE.discover_device_entities(zha_dev)
|
|
return zha_dev
|
|
|
|
@callback
|
|
def async_update_sw_build_id(self, sw_version: int) -> None:
|
|
"""Update device sw version."""
|
|
if self.device_id is None:
|
|
return
|
|
|
|
device_registry = dr.async_get(self.hass)
|
|
device_registry.async_update_device(
|
|
self.device_id, sw_version=f"0x{sw_version:08x}"
|
|
)
|
|
|
|
async def _check_available(self, *_: Any) -> None:
|
|
# don't flip the availability state of the coordinator
|
|
if self.is_coordinator:
|
|
return
|
|
if self.last_seen is None:
|
|
self.debug("last_seen is None, marking the device unavailable")
|
|
self.update_available(False)
|
|
return
|
|
|
|
difference = time.time() - self.last_seen
|
|
if difference < self.consider_unavailable_time:
|
|
self.debug(
|
|
"Device seen - marking the device available and resetting counter"
|
|
)
|
|
self.update_available(True)
|
|
self._checkins_missed_count = 0
|
|
return
|
|
|
|
if self.hass.data[const.DATA_ZHA].allow_polling:
|
|
if (
|
|
self._checkins_missed_count >= _CHECKIN_GRACE_PERIODS
|
|
or self.manufacturer == "LUMI"
|
|
or not self._endpoints
|
|
):
|
|
self.debug(
|
|
(
|
|
"last_seen is %s seconds ago and ping attempts have been exhausted,"
|
|
" marking the device unavailable"
|
|
),
|
|
difference,
|
|
)
|
|
self.update_available(False)
|
|
return
|
|
|
|
self._checkins_missed_count += 1
|
|
self.debug(
|
|
"Attempting to checkin with device - missed checkins: %s",
|
|
self._checkins_missed_count,
|
|
)
|
|
if not self.basic_ch:
|
|
self.debug("does not have a mandatory basic cluster")
|
|
self.update_available(False)
|
|
return
|
|
res = await self.basic_ch.get_attribute_value(
|
|
ATTR_MANUFACTURER, from_cache=False
|
|
)
|
|
if res is not None:
|
|
self._checkins_missed_count = 0
|
|
|
|
def update_available(self, available: bool) -> None:
|
|
"""Update device availability and signal entities."""
|
|
self.debug(
|
|
(
|
|
"Update device availability - device available: %s - new availability:"
|
|
" %s - changed: %s"
|
|
),
|
|
self.available,
|
|
available,
|
|
self.available ^ available,
|
|
)
|
|
availability_changed = self.available ^ available
|
|
self.available = available
|
|
if availability_changed and available:
|
|
# reinit cluster handlers then signal entities
|
|
self.debug(
|
|
"Device availability changed and device became available,"
|
|
" reinitializing cluster handlers"
|
|
)
|
|
self.hass.async_create_task(self._async_became_available())
|
|
return
|
|
if availability_changed and not available:
|
|
self.debug("Device availability changed and device became unavailable")
|
|
self.zha_send_event(
|
|
{
|
|
"device_event_type": "device_offline",
|
|
},
|
|
)
|
|
async_dispatcher_send(self.hass, f"{self._available_signal}_entity")
|
|
|
|
@callback
|
|
def zha_send_event(self, event_data: dict[str, str | int]) -> None:
|
|
"""Relay events to hass."""
|
|
self.hass.bus.async_fire(
|
|
const.ZHA_EVENT,
|
|
{
|
|
const.ATTR_DEVICE_IEEE: str(self.ieee),
|
|
const.ATTR_UNIQUE_ID: str(self.ieee),
|
|
ATTR_DEVICE_ID: self.device_id,
|
|
**event_data,
|
|
},
|
|
)
|
|
|
|
async def _async_became_available(self) -> None:
|
|
"""Update device availability and signal entities."""
|
|
await self.async_initialize(False)
|
|
async_dispatcher_send(self.hass, f"{self._available_signal}_entity")
|
|
|
|
@property
|
|
def device_info(self) -> dict[str, Any]:
|
|
"""Return a device description for device."""
|
|
ieee = str(self.ieee)
|
|
time_struct = time.localtime(self.last_seen)
|
|
update_time = time.strftime("%Y-%m-%dT%H:%M:%S", time_struct)
|
|
return {
|
|
ATTR_IEEE: ieee,
|
|
ATTR_NWK: self.nwk,
|
|
ATTR_MANUFACTURER: self.manufacturer,
|
|
ATTR_MODEL: self.model,
|
|
ATTR_NAME: self.name or ieee,
|
|
ATTR_QUIRK_APPLIED: self.quirk_applied,
|
|
ATTR_QUIRK_CLASS: self.quirk_class,
|
|
ATTR_QUIRK_ID: self.quirk_id,
|
|
ATTR_MANUFACTURER_CODE: self.manufacturer_code,
|
|
ATTR_POWER_SOURCE: self.power_source,
|
|
ATTR_LQI: self.lqi,
|
|
ATTR_RSSI: self.rssi,
|
|
ATTR_LAST_SEEN: update_time,
|
|
ATTR_AVAILABLE: self.available,
|
|
ATTR_DEVICE_TYPE: self.device_type,
|
|
ATTR_SIGNATURE: self.zigbee_signature,
|
|
}
|
|
|
|
async def async_configure(self) -> None:
|
|
"""Configure the device."""
|
|
should_identify = async_get_zha_config_value(
|
|
self._zha_gateway.config_entry,
|
|
ZHA_OPTIONS,
|
|
CONF_ENABLE_IDENTIFY_ON_JOIN,
|
|
True,
|
|
)
|
|
self.debug("started configuration")
|
|
await self._zdo_handler.async_configure()
|
|
self._zdo_handler.debug("'async_configure' stage succeeded")
|
|
await asyncio.gather(
|
|
*(endpoint.async_configure() for endpoint in self._endpoints.values())
|
|
)
|
|
if isinstance(self._zigpy_device, CustomDeviceV2):
|
|
self.debug("applying quirks v2 custom device configuration")
|
|
await self._zigpy_device.apply_custom_configuration()
|
|
async_dispatcher_send(
|
|
self.hass,
|
|
const.ZHA_CLUSTER_HANDLER_MSG,
|
|
{
|
|
const.ATTR_TYPE: const.ZHA_CLUSTER_HANDLER_CFG_DONE,
|
|
},
|
|
)
|
|
self.debug("completed configuration")
|
|
|
|
if (
|
|
should_identify
|
|
and self.identify_ch is not None
|
|
and not self.skip_configuration
|
|
):
|
|
await self.identify_ch.trigger_effect(
|
|
effect_id=Identify.EffectIdentifier.Okay,
|
|
effect_variant=Identify.EffectVariant.Default,
|
|
)
|
|
|
|
async def async_initialize(self, from_cache: bool = False) -> None:
|
|
"""Initialize cluster handlers."""
|
|
self.debug("started initialization")
|
|
await self._zdo_handler.async_initialize(from_cache)
|
|
self._zdo_handler.debug("'async_initialize' stage succeeded")
|
|
|
|
# We intentionally do not use `gather` here! This is so that if, for example,
|
|
# three `device.async_initialize()`s are spawned, only three concurrent requests
|
|
# will ever be in flight at once. Startup concurrency is managed at the device
|
|
# level.
|
|
for endpoint in self._endpoints.values():
|
|
try:
|
|
await endpoint.async_initialize(from_cache)
|
|
except Exception: # pylint: disable=broad-exception-caught
|
|
self.debug("Failed to initialize endpoint", exc_info=True)
|
|
|
|
self.debug("power source: %s", self.power_source)
|
|
self.status = DeviceStatus.INITIALIZED
|
|
self.debug("completed initialization")
|
|
|
|
@callback
|
|
def async_cleanup_handles(self) -> None:
|
|
"""Unsubscribe the dispatchers and timers."""
|
|
for unsubscribe in self.unsubs:
|
|
unsubscribe()
|
|
|
|
@property
|
|
def zha_device_info(self) -> dict[str, Any]:
|
|
"""Get ZHA device information."""
|
|
device_info: dict[str, Any] = {}
|
|
device_info.update(self.device_info)
|
|
device_info[ATTR_ACTIVE_COORDINATOR] = self.is_active_coordinator
|
|
device_info["entities"] = [
|
|
{
|
|
"entity_id": entity_ref.reference_id,
|
|
ATTR_NAME: entity_ref.device_info[ATTR_NAME],
|
|
}
|
|
for entity_ref in self.gateway.device_registry[self.ieee]
|
|
]
|
|
|
|
topology = self.gateway.application_controller.topology
|
|
device_info[ATTR_NEIGHBORS] = [
|
|
{
|
|
"device_type": neighbor.device_type.name,
|
|
"rx_on_when_idle": neighbor.rx_on_when_idle.name,
|
|
"relationship": neighbor.relationship.name,
|
|
"extended_pan_id": str(neighbor.extended_pan_id),
|
|
"ieee": str(neighbor.ieee),
|
|
"nwk": str(neighbor.nwk),
|
|
"permit_joining": neighbor.permit_joining.name,
|
|
"depth": str(neighbor.depth),
|
|
"lqi": str(neighbor.lqi),
|
|
}
|
|
for neighbor in topology.neighbors[self.ieee]
|
|
]
|
|
|
|
device_info[ATTR_ROUTES] = [
|
|
{
|
|
"dest_nwk": str(route.DstNWK),
|
|
"route_status": str(route.RouteStatus.name),
|
|
"memory_constrained": bool(route.MemoryConstrained),
|
|
"many_to_one": bool(route.ManyToOne),
|
|
"route_record_required": bool(route.RouteRecordRequired),
|
|
"next_hop": str(route.NextHop),
|
|
}
|
|
for route in topology.routes[self.ieee]
|
|
]
|
|
|
|
# Return endpoint device type Names
|
|
names: list[dict[str, str]] = []
|
|
for endpoint in (ep for epid, ep in self.device.endpoints.items() if epid):
|
|
profile = PROFILES.get(endpoint.profile_id)
|
|
if profile and endpoint.device_type is not None:
|
|
# DeviceType provides undefined enums
|
|
names.append({ATTR_NAME: profile.DeviceType(endpoint.device_type).name})
|
|
else:
|
|
names.append(
|
|
{
|
|
ATTR_NAME: (
|
|
f"unknown {endpoint.device_type} device_type "
|
|
f"of 0x{(endpoint.profile_id or 0xFFFF):04x} profile id"
|
|
)
|
|
}
|
|
)
|
|
device_info[ATTR_ENDPOINT_NAMES] = names
|
|
|
|
device_registry = dr.async_get(self.hass)
|
|
reg_device = device_registry.async_get(self.device_id)
|
|
if reg_device is not None:
|
|
device_info["user_given_name"] = reg_device.name_by_user
|
|
device_info["device_reg_id"] = reg_device.id
|
|
device_info["area_id"] = reg_device.area_id
|
|
return device_info
|
|
|
|
@callback
|
|
def async_get_clusters(self) -> dict[int, dict[str, dict[int, Cluster]]]:
|
|
"""Get all clusters for this device."""
|
|
return {
|
|
ep_id: {
|
|
CLUSTER_TYPE_IN: endpoint.in_clusters,
|
|
CLUSTER_TYPE_OUT: endpoint.out_clusters,
|
|
}
|
|
for (ep_id, endpoint) in self._zigpy_device.endpoints.items()
|
|
if ep_id != 0
|
|
}
|
|
|
|
@callback
|
|
def async_get_groupable_endpoints(self):
|
|
"""Get device endpoints that have a group 'in' cluster."""
|
|
return [
|
|
ep_id
|
|
for (ep_id, clusters) in self.async_get_clusters().items()
|
|
if Groups.cluster_id in clusters[CLUSTER_TYPE_IN]
|
|
]
|
|
|
|
@callback
|
|
def async_get_std_clusters(self):
|
|
"""Get ZHA and ZLL clusters for this device."""
|
|
|
|
return {
|
|
ep_id: {
|
|
CLUSTER_TYPE_IN: endpoint.in_clusters,
|
|
CLUSTER_TYPE_OUT: endpoint.out_clusters,
|
|
}
|
|
for (ep_id, endpoint) in self._zigpy_device.endpoints.items()
|
|
if ep_id != 0 and endpoint.profile_id in PROFILES
|
|
}
|
|
|
|
@callback
|
|
def async_get_cluster(
|
|
self, endpoint_id: int, cluster_id: int, cluster_type: str = CLUSTER_TYPE_IN
|
|
) -> Cluster:
|
|
"""Get zigbee cluster from this entity."""
|
|
clusters: dict[int, dict[str, dict[int, Cluster]]] = self.async_get_clusters()
|
|
return clusters[endpoint_id][cluster_type][cluster_id]
|
|
|
|
@callback
|
|
def async_get_cluster_attributes(
|
|
self, endpoint_id, cluster_id, cluster_type=CLUSTER_TYPE_IN
|
|
):
|
|
"""Get zigbee attributes for specified cluster."""
|
|
cluster = self.async_get_cluster(endpoint_id, cluster_id, cluster_type)
|
|
if cluster is None:
|
|
return None
|
|
return cluster.attributes
|
|
|
|
@callback
|
|
def async_get_cluster_commands(
|
|
self, endpoint_id, cluster_id, cluster_type=CLUSTER_TYPE_IN
|
|
):
|
|
"""Get zigbee commands for specified cluster."""
|
|
cluster = self.async_get_cluster(endpoint_id, cluster_id, cluster_type)
|
|
if cluster is None:
|
|
return None
|
|
return {
|
|
CLUSTER_COMMANDS_CLIENT: cluster.client_commands,
|
|
CLUSTER_COMMANDS_SERVER: cluster.server_commands,
|
|
}
|
|
|
|
async def write_zigbee_attribute(
|
|
self,
|
|
endpoint_id,
|
|
cluster_id,
|
|
attribute,
|
|
value,
|
|
cluster_type=CLUSTER_TYPE_IN,
|
|
manufacturer=None,
|
|
):
|
|
"""Write a value to a zigbee attribute for a cluster in this entity."""
|
|
try:
|
|
cluster: Cluster = self.async_get_cluster(
|
|
endpoint_id, cluster_id, cluster_type
|
|
)
|
|
except KeyError as exc:
|
|
raise ValueError(
|
|
f"Cluster {cluster_id} not found on endpoint {endpoint_id} while"
|
|
f" writing attribute {attribute} with value {value}"
|
|
) from exc
|
|
|
|
try:
|
|
response = await cluster.write_attributes(
|
|
{attribute: value}, manufacturer=manufacturer
|
|
)
|
|
except zigpy.exceptions.ZigbeeException as exc:
|
|
raise HomeAssistantError(
|
|
f"Failed to set attribute: "
|
|
f"{ATTR_VALUE}: {value} "
|
|
f"{ATTR_ATTRIBUTE}: {attribute} "
|
|
f"{ATTR_CLUSTER_ID}: {cluster_id} "
|
|
f"{ATTR_ENDPOINT_ID}: {endpoint_id}"
|
|
) from exc
|
|
|
|
self.debug(
|
|
"set: %s for attr: %s to cluster: %s for ept: %s - res: %s",
|
|
value,
|
|
attribute,
|
|
cluster_id,
|
|
endpoint_id,
|
|
response,
|
|
)
|
|
return response
|
|
|
|
async def issue_cluster_command(
|
|
self,
|
|
endpoint_id: int,
|
|
cluster_id: int,
|
|
command: int,
|
|
command_type: str,
|
|
args: list | None,
|
|
params: dict[str, Any] | None,
|
|
cluster_type: str = CLUSTER_TYPE_IN,
|
|
manufacturer: int | None = None,
|
|
) -> None:
|
|
"""Issue a command against specified zigbee cluster on this device."""
|
|
try:
|
|
cluster: Cluster = self.async_get_cluster(
|
|
endpoint_id, cluster_id, cluster_type
|
|
)
|
|
except KeyError as exc:
|
|
raise ValueError(
|
|
f"Cluster {cluster_id} not found on endpoint {endpoint_id} while"
|
|
f" issuing command {command} with args {args}"
|
|
) from exc
|
|
commands: dict[int, ZCLCommandDef] = (
|
|
cluster.server_commands
|
|
if command_type == CLUSTER_COMMAND_SERVER
|
|
else cluster.client_commands
|
|
)
|
|
if args is not None:
|
|
self.warning(
|
|
(
|
|
"args [%s] are deprecated and should be passed with the params key."
|
|
" The parameter names are: %s"
|
|
),
|
|
args,
|
|
[field.name for field in commands[command].schema.fields],
|
|
)
|
|
response = await getattr(cluster, commands[command].name)(*args)
|
|
else:
|
|
assert params is not None
|
|
response = await getattr(cluster, commands[command].name)(
|
|
**convert_to_zcl_values(params, commands[command].schema)
|
|
)
|
|
self.debug(
|
|
"Issued cluster command: %s %s %s %s %s %s %s %s",
|
|
f"{ATTR_CLUSTER_ID}: [{cluster_id}]",
|
|
f"{ATTR_CLUSTER_TYPE}: [{cluster_type}]",
|
|
f"{ATTR_ENDPOINT_ID}: [{endpoint_id}]",
|
|
f"{ATTR_COMMAND}: [{command}]",
|
|
f"{ATTR_COMMAND_TYPE}: [{command_type}]",
|
|
f"{ATTR_ARGS}: [{args}]",
|
|
f"{ATTR_PARAMS}: [{params}]",
|
|
f"{ATTR_MANUFACTURER}: [{manufacturer}]",
|
|
)
|
|
if response is None:
|
|
return # client commands don't return a response
|
|
if isinstance(response, Exception):
|
|
raise HomeAssistantError("Failed to issue cluster command") from response
|
|
if response[1] is not ZclStatus.SUCCESS:
|
|
raise HomeAssistantError(
|
|
f"Failed to issue cluster command with status: {response[1]}"
|
|
)
|
|
|
|
async def async_add_to_group(self, group_id: int) -> None:
|
|
"""Add this device to the provided zigbee group."""
|
|
try:
|
|
# A group name is required. However, the spec also explicitly states that
|
|
# the group name can be ignored by the receiving device if a device cannot
|
|
# store it, so we cannot rely on it existing after being written. This is
|
|
# only done to make the ZCL command valid.
|
|
await self._zigpy_device.add_to_group(group_id, name=f"0x{group_id:04X}")
|
|
except (zigpy.exceptions.ZigbeeException, TimeoutError) as ex:
|
|
self.debug(
|
|
"Failed to add device '%s' to group: 0x%04x ex: %s",
|
|
self._zigpy_device.ieee,
|
|
group_id,
|
|
str(ex),
|
|
)
|
|
|
|
async def async_remove_from_group(self, group_id: int) -> None:
|
|
"""Remove this device from the provided zigbee group."""
|
|
try:
|
|
await self._zigpy_device.remove_from_group(group_id)
|
|
except (zigpy.exceptions.ZigbeeException, TimeoutError) as ex:
|
|
self.debug(
|
|
"Failed to remove device '%s' from group: 0x%04x ex: %s",
|
|
self._zigpy_device.ieee,
|
|
group_id,
|
|
str(ex),
|
|
)
|
|
|
|
async def async_add_endpoint_to_group(
|
|
self, endpoint_id: int, group_id: int
|
|
) -> None:
|
|
"""Add the device endpoint to the provided zigbee group."""
|
|
try:
|
|
await self._zigpy_device.endpoints[endpoint_id].add_to_group(
|
|
group_id, name=f"0x{group_id:04X}"
|
|
)
|
|
except (zigpy.exceptions.ZigbeeException, TimeoutError) as ex:
|
|
self.debug(
|
|
"Failed to add endpoint: %s for device: '%s' to group: 0x%04x ex: %s",
|
|
endpoint_id,
|
|
self._zigpy_device.ieee,
|
|
group_id,
|
|
str(ex),
|
|
)
|
|
|
|
async def async_remove_endpoint_from_group(
|
|
self, endpoint_id: int, group_id: int
|
|
) -> None:
|
|
"""Remove the device endpoint from the provided zigbee group."""
|
|
try:
|
|
await self._zigpy_device.endpoints[endpoint_id].remove_from_group(group_id)
|
|
except (zigpy.exceptions.ZigbeeException, TimeoutError) as ex:
|
|
self.debug(
|
|
(
|
|
"Failed to remove endpoint: %s for device '%s' from group: 0x%04x"
|
|
" ex: %s"
|
|
),
|
|
endpoint_id,
|
|
self._zigpy_device.ieee,
|
|
group_id,
|
|
str(ex),
|
|
)
|
|
|
|
async def async_bind_to_group(
|
|
self, group_id: int, cluster_bindings: list[ClusterBinding]
|
|
) -> None:
|
|
"""Directly bind this device to a group for the given clusters."""
|
|
await self._async_group_binding_operation(
|
|
group_id, zdo_types.ZDOCmd.Bind_req, cluster_bindings
|
|
)
|
|
|
|
async def async_unbind_from_group(
|
|
self, group_id: int, cluster_bindings: list[ClusterBinding]
|
|
) -> None:
|
|
"""Unbind this device from a group for the given clusters."""
|
|
await self._async_group_binding_operation(
|
|
group_id, zdo_types.ZDOCmd.Unbind_req, cluster_bindings
|
|
)
|
|
|
|
async def _async_group_binding_operation(
|
|
self,
|
|
group_id: int,
|
|
operation: zdo_types.ZDOCmd,
|
|
cluster_bindings: list[ClusterBinding],
|
|
) -> None:
|
|
"""Create or remove a direct zigbee binding between a device and a group."""
|
|
|
|
zdo = self._zigpy_device.zdo
|
|
op_msg = "0x%04x: %s %s, ep: %s, cluster: %s to group: 0x%04x"
|
|
destination_address = zdo_types.MultiAddress()
|
|
destination_address.addrmode = types.uint8_t(1)
|
|
destination_address.nwk = types.uint16_t(group_id)
|
|
|
|
tasks = []
|
|
|
|
for cluster_binding in cluster_bindings:
|
|
if cluster_binding.endpoint_id == 0:
|
|
continue
|
|
if (
|
|
cluster_binding.id
|
|
in self._zigpy_device.endpoints[
|
|
cluster_binding.endpoint_id
|
|
].out_clusters
|
|
):
|
|
op_params = (
|
|
self.nwk,
|
|
operation.name,
|
|
str(self.ieee),
|
|
cluster_binding.endpoint_id,
|
|
cluster_binding.id,
|
|
group_id,
|
|
)
|
|
zdo.debug(f"processing {op_msg}", *op_params)
|
|
tasks.append(
|
|
(
|
|
zdo.request(
|
|
operation,
|
|
self.ieee,
|
|
cluster_binding.endpoint_id,
|
|
cluster_binding.id,
|
|
destination_address,
|
|
),
|
|
op_msg,
|
|
op_params,
|
|
)
|
|
)
|
|
res = await asyncio.gather(*(t[0] for t in tasks), return_exceptions=True)
|
|
for outcome, log_msg in zip(res, tasks):
|
|
if isinstance(outcome, Exception):
|
|
fmt = f"{log_msg[1]} failed: %s"
|
|
else:
|
|
fmt = f"{log_msg[1]} completed: %s"
|
|
zdo.debug(fmt, *(log_msg[2] + (outcome,)))
|
|
|
|
def log(self, level: int, msg: str, *args: Any, **kwargs: Any) -> None:
|
|
"""Log a message."""
|
|
msg = f"[%s](%s): {msg}"
|
|
args = (self.nwk, self.model, *args)
|
|
_LOGGER.log(level, msg, *args, **kwargs)
|