Add support to create KNX Cover entities from UI

homeassistant/components/knx/const.py

@@ -160,6 +160,7 @@ class FanZeroMode(StrEnum):
 
 SUPPORTED_PLATFORMS_UI: Final = {
     Platform.BINARY_SENSOR,
+    Platform.COVER,
     Platform.LIGHT,
     Platform.SWITCH,
 }
@@ -182,3 +183,13 @@ class FanZeroMode(StrEnum):
     HVACMode.FAN_ONLY: HVACAction.FAN,
     HVACMode.DRY: HVACAction.DRYING,
 }
+
+
+class CoverConf:
+    """Common config keys for cover."""
+
+    TRAVELLING_TIME_DOWN: Final = "travelling_time_down"
+    TRAVELLING_TIME_UP: Final = "travelling_time_up"
+    INVERT_UPDOWN: Final = "invert_updown"
+    INVERT_POSITION: Final = "invert_position"
+    INVERT_ANGLE: Final = "invert_angle"

homeassistant/components/knx/cover.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable
-from typing import Any
+from typing import Any, Literal
 
+from xknx import XKNX
 from xknx.devices import Cover as XknxCover
 
 from homeassistant import config_entries
@@ -22,66 +22,76 @@
     Platform,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    async_get_current_platform,
+)
 from homeassistant.helpers.typing import ConfigType
 
 from . import KNXModule
-from .const import KNX_MODULE_KEY
-from .entity import KnxYamlEntity
+from .const import CONF_SYNC_STATE, DOMAIN, KNX_MODULE_KEY, CoverConf
+from .entity import KnxUiEntity, KnxUiEntityPlatformController, KnxYamlEntity
 from .schema import CoverSchema
+from .storage.const import (
+    CONF_ENTITY,
+    CONF_GA_ANGLE,
+    CONF_GA_PASSIVE,
+    CONF_GA_POSITION_SET,
+    CONF_GA_POSITION_STATE,
+    CONF_GA_STATE,
+    CONF_GA_STEP,
+    CONF_GA_STOP,
+    CONF_GA_UP_DOWN,
+    CONF_GA_WRITE,
+)
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: config_entries.ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up cover(s) for KNX platform."""
+    """Set up the KNX cover platform."""
     knx_module = hass.data[KNX_MODULE_KEY]
-    config: list[ConfigType] = knx_module.config_yaml[Platform.COVER]
+    platform = async_get_current_platform()
+    knx_module.config_store.add_platform(
+        platform=Platform.COVER,
+        controller=KnxUiEntityPlatformController(
+            knx_module=knx_module,
+            entity_platform=platform,
+            entity_class=KnxUiCover,
+        ),
+    )
 
-    async_add_entities(KNXCover(knx_module, entity_config) for entity_config in config)
+    entities: list[KnxYamlEntity | KnxUiEntity] = []
+    if yaml_platform_config := knx_module.config_yaml.get(Platform.COVER):
+        entities.extend(
+            KnxYamlCover(knx_module, entity_config)
+            for entity_config in yaml_platform_config
+        )
+    if ui_config := knx_module.config_store.data["entities"].get(Platform.COVER):
+        entities.extend(
+            KnxUiCover(knx_module, unique_id, config)
+            for unique_id, config in ui_config.items()
+        )
+    if entities:
+        async_add_entities(entities)
 
 
-class KNXCover(KnxYamlEntity, CoverEntity):
+class _KnxCover(CoverEntity):
     """Representation of a KNX cover."""
 
     _device: XknxCover
 
-    def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
-        """Initialize the cover."""
-        super().__init__(
-            knx_module=knx_module,
-            device=XknxCover(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address_long=config.get(CoverSchema.CONF_MOVE_LONG_ADDRESS),
-                group_address_short=config.get(CoverSchema.CONF_MOVE_SHORT_ADDRESS),
-                group_address_stop=config.get(CoverSchema.CONF_STOP_ADDRESS),
-                group_address_position_state=config.get(
-                    CoverSchema.CONF_POSITION_STATE_ADDRESS
-                ),
-                group_address_angle=config.get(CoverSchema.CONF_ANGLE_ADDRESS),
-                group_address_angle_state=config.get(
-                    CoverSchema.CONF_ANGLE_STATE_ADDRESS
-                ),
-                group_address_position=config.get(CoverSchema.CONF_POSITION_ADDRESS),
-                travel_time_down=config[CoverSchema.CONF_TRAVELLING_TIME_DOWN],
-                travel_time_up=config[CoverSchema.CONF_TRAVELLING_TIME_UP],
-                invert_updown=config[CoverSchema.CONF_INVERT_UPDOWN],
-                invert_position=config[CoverSchema.CONF_INVERT_POSITION],
-                invert_angle=config[CoverSchema.CONF_INVERT_ANGLE],
-            ),
-        )
-        self._unsubscribe_auto_updater: Callable[[], None] | None = None
-
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+    def init_base(self) -> None:
+        """Initialize common attributes - may be based on xknx device instance."""
         _supports_tilt = False
         self._attr_supported_features = (
-            CoverEntityFeature.CLOSE
-            | CoverEntityFeature.OPEN
-            | CoverEntityFeature.SET_POSITION
+            CoverEntityFeature.CLOSE | CoverEntityFeature.OPEN
         )
+        if self._device.supports_position or self._device.supports_stop:
+            # when stop is supported, xknx travelcalculator can set position
+            self._attr_supported_features |= CoverEntityFeature.SET_POSITION
         if self._device.step.writable:
             _supports_tilt = True
             self._attr_supported_features |= (
@@ -97,13 +107,7 @@
             if _supports_tilt:
                 self._attr_supported_features |= CoverEntityFeature.STOP_TILT
 
-        self._attr_device_class = config.get(CONF_DEVICE_CLASS) or (
-            CoverDeviceClass.BLIND if _supports_tilt else None
-        )
-        self._attr_unique_id = (
-            f"{self._device.updown.group_address}_"
-            f"{self._device.position_target.group_address}"
-        )
+        self._attr_device_class = CoverDeviceClass.BLIND if _supports_tilt else None
 
     @property
     def current_cover_position(self) -> int | None:
@@ -180,3 +184,102 @@
     async def async_stop_cover_tilt(self, **kwargs: Any) -> None:
         """Stop the cover tilt."""
         await self._device.stop()
+
+
+class KnxYamlCover(_KnxCover, KnxYamlEntity):
+    """Representation of a KNX cover configured from YAML."""
+
+    _device: XknxCover
+
+    def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
+        """Initialize the cover."""
+        super().__init__(
+            knx_module=knx_module,
+            device=XknxCover(
+                xknx=knx_module.xknx,
+                name=config[CONF_NAME],
+                group_address_long=config.get(CoverSchema.CONF_MOVE_LONG_ADDRESS),
+                group_address_short=config.get(CoverSchema.CONF_MOVE_SHORT_ADDRESS),
+                group_address_stop=config.get(CoverSchema.CONF_STOP_ADDRESS),
+                group_address_position_state=config.get(
+                    CoverSchema.CONF_POSITION_STATE_ADDRESS
+                ),
+                group_address_angle=config.get(CoverSchema.CONF_ANGLE_ADDRESS),
+                group_address_angle_state=config.get(
+                    CoverSchema.CONF_ANGLE_STATE_ADDRESS
+                ),
+                group_address_position=config.get(CoverSchema.CONF_POSITION_ADDRESS),
+                travel_time_down=config[CoverConf.TRAVELLING_TIME_DOWN],
+                travel_time_up=config[CoverConf.TRAVELLING_TIME_UP],
+                invert_updown=config[CoverConf.INVERT_UPDOWN],
+                invert_position=config[CoverConf.INVERT_POSITION],
+                invert_angle=config[CoverConf.INVERT_ANGLE],
+            ),
+        )
+        self.init_base()
+
+        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+        self._attr_unique_id = (
+            f"{self._device.updown.group_address}_"
+            f"{self._device.position_target.group_address}"
+        )
+        if custom_device_class := config.get(CONF_DEVICE_CLASS):
+            self._attr_device_class = custom_device_class
+
+
+def _create_ui_cover(xknx: XKNX, knx_config: ConfigType, name: str) -> XknxCover:
+    """Return a KNX Light device to be used within XKNX."""
+
+    def get_address(
+        key: str, address_type: Literal["write", "state"] = CONF_GA_WRITE
+    ) -> str | None:
+        """Get a single group address for given key."""
+        return knx_config[key][address_type] if key in knx_config else None
+
+    def get_addresses(
+        key: str, address_type: Literal["write", "state"] = CONF_GA_STATE
+    ) -> list[Any] | None:
+        """Get group address including passive addresses as list."""
+        return (
+            [knx_config[key][address_type], *knx_config[key][CONF_GA_PASSIVE]]
+            if key in knx_config
+            else None
+        )
+
+    return XknxCover(
+        xknx=xknx,
+        name=name,
+        group_address_long=get_addresses(CONF_GA_UP_DOWN, CONF_GA_WRITE),
+        group_address_short=get_addresses(CONF_GA_STEP, CONF_GA_WRITE),
+        group_address_stop=get_addresses(CONF_GA_STOP, CONF_GA_WRITE),
+        group_address_position=get_addresses(CONF_GA_POSITION_SET, CONF_GA_WRITE),
+        group_address_position_state=get_addresses(CONF_GA_POSITION_STATE),
+        group_address_angle=get_address(CONF_GA_ANGLE),
+        group_address_angle_state=get_addresses(CONF_GA_ANGLE),
+        travel_time_down=knx_config[CoverConf.TRAVELLING_TIME_DOWN],
+        travel_time_up=knx_config[CoverConf.TRAVELLING_TIME_UP],
+        invert_updown=knx_config.get(CoverConf.INVERT_UPDOWN, False),
+        invert_position=knx_config.get(CoverConf.INVERT_POSITION, False),
+        invert_angle=knx_config.get(CoverConf.INVERT_ANGLE, False),
+        sync_state=knx_config[CONF_SYNC_STATE],
+    )
+
+
+class KnxUiCover(_KnxCover, KnxUiEntity):
+    """Representation of a KNX cover configured from the UI."""
+
+    _device: XknxCover
+
+    def __init__(
+        self, knx_module: KNXModule, unique_id: str, config: dict[str, Any]
+    ) -> None:
+        """Initialize KNX cover."""
+        super().__init__(
+            knx_module=knx_module,
+            unique_id=unique_id,
+            entity_config=config[CONF_ENTITY],
+        )
+        self._device = _create_ui_cover(
+            knx_module.xknx, config[DOMAIN], config[CONF_ENTITY][CONF_NAME]
+        )
+        self.init_base()

homeassistant/components/knx/schema.py

@@ -56,6 +56,7 @@
     CONF_SYNC_STATE,
     KNX_ADDRESS,
     ColorTempModes,
+    CoverConf,
     FanZeroMode,
 )
 from .validation import (
@@ -453,11 +454,6 @@ class CoverSchema(KNXPlatformSchema):
     CONF_POSITION_STATE_ADDRESS = "position_state_address"
     CONF_ANGLE_ADDRESS = "angle_address"
     CONF_ANGLE_STATE_ADDRESS = "angle_state_address"
-    CONF_TRAVELLING_TIME_DOWN = "travelling_time_down"
-    CONF_TRAVELLING_TIME_UP = "travelling_time_up"
-    CONF_INVERT_UPDOWN = "invert_updown"
-    CONF_INVERT_POSITION = "invert_position"
-    CONF_INVERT_ANGLE = "invert_angle"
 
     DEFAULT_TRAVEL_TIME = 25
     DEFAULT_NAME = "KNX Cover"
@@ -474,14 +470,14 @@ class CoverSchema(KNXPlatformSchema):
                 vol.Optional(CONF_ANGLE_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_ANGLE_STATE_ADDRESS): ga_list_validator,
                 vol.Optional(
-                    CONF_TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME
+                    CoverConf.TRAVELLING_TIME_DOWN, default=DEFAULT_TRAVEL_TIME
                 ): cv.positive_float,
                 vol.Optional(
-                    CONF_TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME
+                    CoverConf.TRAVELLING_TIME_UP, default=DEFAULT_TRAVEL_TIME
                 ): cv.positive_float,
-                vol.Optional(CONF_INVERT_UPDOWN, default=False): cv.boolean,
-                vol.Optional(CONF_INVERT_POSITION, default=False): cv.boolean,
-                vol.Optional(CONF_INVERT_ANGLE, default=False): cv.boolean,
+                vol.Optional(CoverConf.INVERT_UPDOWN, default=False): cv.boolean,
+                vol.Optional(CoverConf.INVERT_POSITION, default=False): cv.boolean,
+                vol.Optional(CoverConf.INVERT_ANGLE, default=False): cv.boolean,
                 vol.Optional(CONF_DEVICE_CLASS): COVER_DEVICE_CLASSES_SCHEMA,
                 vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }

homeassistant/components/knx/storage/const.py

@@ -27,3 +27,9 @@
 CONF_GA_WHITE_SWITCH: Final = "ga_white_switch"
 CONF_GA_HUE: Final = "ga_hue"
 CONF_GA_SATURATION: Final = "ga_saturation"
+CONF_GA_UP_DOWN: Final = "ga_up_down"
+CONF_GA_STOP: Final = "ga_stop"
+CONF_GA_STEP: Final = "ga_step"
+CONF_GA_POSITION_SET: Final = "ga_position_set"
+CONF_GA_POSITION_STATE: Final = "ga_position_state"
+CONF_GA_ANGLE: Final = "ga_angle"