mirror of
https://github.com/bahmcloud/HA-KNX-Bridge.git
synced 2026-04-06 16:51:14 +00:00
Initial HA KNX Bridge scaffold
This commit is contained in:
307
custom_components/ha_knx_bridge/bridge.py
Normal file
307
custom_components/ha_knx_bridge/bridge.py
Normal file
@@ -0,0 +1,307 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
from homeassistant.config_entries import ConfigEntry
|
||||
from homeassistant.core import Event, HomeAssistant, State
|
||||
from homeassistant.exceptions import ConfigEntryNotReady
|
||||
from homeassistant.helpers import event as event_helper
|
||||
|
||||
from .const import (
|
||||
CONF_ANGLE_ADDRESS,
|
||||
CONF_ANGLE_STATE_ADDRESS,
|
||||
CONF_MOVE_LONG_ADDRESS,
|
||||
CONF_MOVE_SHORT_ADDRESS,
|
||||
CONF_POSITION_ADDRESS,
|
||||
CONF_POSITION_STATE_ADDRESS,
|
||||
CONF_STATE_ADDRESS,
|
||||
CONF_STOP_ADDRESS,
|
||||
)
|
||||
|
||||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
KNX_DOMAIN = "knx"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class BinarySensorPort:
|
||||
entity_id: str
|
||||
state_address: str | None
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CoverPort:
|
||||
entity_id: str
|
||||
move_long_address: str | None
|
||||
move_short_address: str | None
|
||||
stop_address: str | None
|
||||
position_address: str | None
|
||||
position_state_address: str | None
|
||||
angle_address: str | None
|
||||
angle_state_address: str | None
|
||||
|
||||
|
||||
class BridgeManager:
|
||||
def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
|
||||
self.hass = hass
|
||||
self.entry = entry
|
||||
self._unsub_listeners: list[callable] = []
|
||||
self._knx_event_unsub: callable | None = None
|
||||
self._address_handlers: dict[str, callable[[Event], Any]] = {}
|
||||
self._registered_addresses: list[tuple[str, str | None]] = []
|
||||
|
||||
async def async_setup(self) -> None:
|
||||
if not self.hass.services.has_service(KNX_DOMAIN, "send"):
|
||||
raise ConfigEntryNotReady("KNX integration services not available")
|
||||
|
||||
binary_ports, cover_ports = self._load_ports()
|
||||
self._register_outgoing(binary_ports, cover_ports)
|
||||
await self._register_incoming(cover_ports)
|
||||
|
||||
async def async_unload(self) -> None:
|
||||
for unsub in self._unsub_listeners:
|
||||
unsub()
|
||||
self._unsub_listeners.clear()
|
||||
|
||||
if self._knx_event_unsub is not None:
|
||||
self._knx_event_unsub()
|
||||
self._knx_event_unsub = None
|
||||
|
||||
await self._unregister_knx_events()
|
||||
|
||||
def _load_ports(self) -> tuple[list[BinarySensorPort], list[CoverPort]]:
|
||||
binary_ports: list[BinarySensorPort] = []
|
||||
cover_ports: list[CoverPort] = []
|
||||
|
||||
subentries = getattr(self.entry, "subentries", [])
|
||||
for subentry in subentries:
|
||||
data = subentry.data
|
||||
if subentry.type == "binary_sensor":
|
||||
binary_ports.append(
|
||||
BinarySensorPort(
|
||||
entity_id=data["entity_id"],
|
||||
state_address=_clean_address(data.get(CONF_STATE_ADDRESS)),
|
||||
)
|
||||
)
|
||||
elif subentry.type == "cover":
|
||||
cover_ports.append(
|
||||
CoverPort(
|
||||
entity_id=data["entity_id"],
|
||||
move_long_address=_clean_address(data.get(CONF_MOVE_LONG_ADDRESS)),
|
||||
move_short_address=_clean_address(data.get(CONF_MOVE_SHORT_ADDRESS)),
|
||||
stop_address=_clean_address(data.get(CONF_STOP_ADDRESS)),
|
||||
position_address=_clean_address(data.get(CONF_POSITION_ADDRESS)),
|
||||
position_state_address=_clean_address(
|
||||
data.get(CONF_POSITION_STATE_ADDRESS)
|
||||
),
|
||||
angle_address=_clean_address(data.get(CONF_ANGLE_ADDRESS)),
|
||||
angle_state_address=_clean_address(
|
||||
data.get(CONF_ANGLE_STATE_ADDRESS)
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
return binary_ports, cover_ports
|
||||
|
||||
def _register_outgoing(
|
||||
self, binary_ports: list[BinarySensorPort], cover_ports: list[CoverPort]
|
||||
) -> None:
|
||||
for port in binary_ports:
|
||||
if not port.state_address:
|
||||
continue
|
||||
self._unsub_listeners.append(
|
||||
event_helper.async_track_state_change_event(
|
||||
self.hass, [port.entity_id], self._binary_sensor_changed(port)
|
||||
)
|
||||
)
|
||||
|
||||
for port in cover_ports:
|
||||
if not (port.position_state_address or port.angle_state_address):
|
||||
continue
|
||||
self._unsub_listeners.append(
|
||||
event_helper.async_track_state_change_event(
|
||||
self.hass, [port.entity_id], self._cover_changed(port)
|
||||
)
|
||||
)
|
||||
|
||||
async def _register_incoming(self, cover_ports: list[CoverPort]) -> None:
|
||||
for port in cover_ports:
|
||||
self._register_knx_address(port.move_long_address, None, port, "move_long")
|
||||
self._register_knx_address(port.move_short_address, None, port, "move_short")
|
||||
self._register_knx_address(port.stop_address, None, port, "stop")
|
||||
self._register_knx_address(
|
||||
port.position_address, "percent", port, "position"
|
||||
)
|
||||
self._register_knx_address(
|
||||
port.angle_address, "percent", port, "angle"
|
||||
)
|
||||
|
||||
if self._address_handlers:
|
||||
self._knx_event_unsub = event_helper.async_track_event(
|
||||
self.hass, "knx_event", self._handle_knx_event
|
||||
)
|
||||
|
||||
await self._register_knx_events()
|
||||
|
||||
def _register_knx_address(
|
||||
self,
|
||||
address: str | None,
|
||||
value_type: str | None,
|
||||
port: CoverPort,
|
||||
action: str,
|
||||
) -> None:
|
||||
if not address:
|
||||
return
|
||||
|
||||
self._address_handlers[address] = lambda event: self._handle_cover_action(
|
||||
port, action, event
|
||||
)
|
||||
self._registered_addresses.append((address, value_type))
|
||||
|
||||
async def _register_knx_events(self) -> None:
|
||||
for address, value_type in self._registered_addresses:
|
||||
data: dict[str, Any] = {"address": address}
|
||||
if value_type:
|
||||
data["type"] = value_type
|
||||
await self.hass.services.async_call(
|
||||
KNX_DOMAIN, "event_register", data, blocking=False
|
||||
)
|
||||
|
||||
async def _unregister_knx_events(self) -> None:
|
||||
for address, value_type in self._registered_addresses:
|
||||
data: dict[str, Any] = {"address": address, "remove": True}
|
||||
if value_type:
|
||||
data["type"] = value_type
|
||||
await self.hass.services.async_call(
|
||||
KNX_DOMAIN, "event_register", data, blocking=False
|
||||
)
|
||||
self._registered_addresses.clear()
|
||||
|
||||
def _binary_sensor_changed(self, port: BinarySensorPort) -> callable[[Event], Any]:
|
||||
async def _handler(event: Event) -> None:
|
||||
new_state: State | None = event.data.get("new_state")
|
||||
if new_state is None:
|
||||
return
|
||||
if new_state.state not in ("on", "off"):
|
||||
return
|
||||
payload = 1 if new_state.state == "on" else 0
|
||||
await self._knx_send_raw(port.state_address, payload)
|
||||
|
||||
return _handler
|
||||
|
||||
def _cover_changed(self, port: CoverPort) -> callable[[Event], Any]:
|
||||
async def _handler(event: Event) -> None:
|
||||
new_state: State | None = event.data.get("new_state")
|
||||
if new_state is None:
|
||||
return
|
||||
|
||||
if port.position_state_address is not None:
|
||||
position = new_state.attributes.get("current_position")
|
||||
if position is not None:
|
||||
await self._knx_send_percent(port.position_state_address, position)
|
||||
|
||||
if port.angle_state_address is not None:
|
||||
angle = new_state.attributes.get("current_tilt_position")
|
||||
if angle is not None:
|
||||
await self._knx_send_percent(port.angle_state_address, angle)
|
||||
|
||||
return _handler
|
||||
|
||||
async def _handle_knx_event(self, event: Event) -> None:
|
||||
if event.data.get("direction") != "Incoming":
|
||||
return
|
||||
|
||||
destination = event.data.get("destination")
|
||||
if not destination:
|
||||
return
|
||||
|
||||
handler = self._address_handlers.get(destination)
|
||||
if handler is None:
|
||||
return
|
||||
|
||||
await handler(event)
|
||||
|
||||
async def _handle_cover_action(
|
||||
self, port: CoverPort, action: str, event: Event
|
||||
) -> None:
|
||||
value = _extract_event_value(event)
|
||||
if value is None:
|
||||
return
|
||||
|
||||
if action == "move_long":
|
||||
if value == 0:
|
||||
await self._call_cover_service(port.entity_id, "open_cover")
|
||||
elif value == 1:
|
||||
await self._call_cover_service(port.entity_id, "close_cover")
|
||||
elif action == "move_short":
|
||||
if value in (0, 1):
|
||||
await self._call_cover_service(port.entity_id, "stop_cover")
|
||||
elif action == "stop":
|
||||
if value in (0, 1):
|
||||
await self._call_cover_service(port.entity_id, "stop_cover")
|
||||
elif action == "position":
|
||||
await self._call_cover_service(
|
||||
port.entity_id, "set_cover_position", {"position": value}
|
||||
)
|
||||
elif action == "angle":
|
||||
await self._call_cover_service(
|
||||
port.entity_id, "set_cover_tilt_position", {"tilt_position": value}
|
||||
)
|
||||
|
||||
async def _call_cover_service(
|
||||
self, entity_id: str, service: str, service_data: dict[str, Any] | None = None
|
||||
) -> None:
|
||||
data = {"entity_id": entity_id}
|
||||
if service_data:
|
||||
data.update(service_data)
|
||||
await self.hass.services.async_call(
|
||||
"cover", service, data, blocking=False
|
||||
)
|
||||
|
||||
async def _knx_send_raw(self, address: str | None, payload: int) -> None:
|
||||
if not address:
|
||||
return
|
||||
await self.hass.services.async_call(
|
||||
KNX_DOMAIN,
|
||||
"send",
|
||||
{"address": address, "payload": payload, "payload_length": 0},
|
||||
blocking=False,
|
||||
)
|
||||
|
||||
async def _knx_send_percent(self, address: str | None, value: int) -> None:
|
||||
if not address:
|
||||
return
|
||||
await self.hass.services.async_call(
|
||||
KNX_DOMAIN,
|
||||
"send",
|
||||
{"address": address, "payload": value, "type": "percent"},
|
||||
blocking=False,
|
||||
)
|
||||
|
||||
|
||||
def _extract_event_value(event: Event) -> int | None:
|
||||
if "value" in event.data:
|
||||
try:
|
||||
return int(event.data["value"])
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
data = event.data.get("data")
|
||||
if data is None:
|
||||
return None
|
||||
if isinstance(data, list) and data:
|
||||
data = data[0]
|
||||
try:
|
||||
return int(data) & 1
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _clean_address(address: Any) -> str | None:
|
||||
if not address:
|
||||
return None
|
||||
if isinstance(address, str):
|
||||
stripped = address.strip()
|
||||
return stripped or None
|
||||
return None
|
||||
Reference in New Issue
Block a user