PySwitchbot 0.58.0__tar.gz → 0.59.0__tar.gz

pyswitchbot-0.59.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PySwitchbot
+Version: 0.59.0
+Summary: A library to communicate with Switchbot
+Home-page: https://github.com/sblibs/pySwitchbot/
+Author: Daniel Hjelseth Hoyer
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: bleak>=0.19.0
+Requires-Dist: bleak-retry-connector>=3.4.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: pyOpenSSL>=23.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

pyswitchbot-0.59.0/PySwitchbot.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: PySwitchbot
+Version: 0.59.0
+Summary: A library to communicate with Switchbot
+Home-page: https://github.com/sblibs/pySwitchbot/
+Author: Daniel Hjelseth Hoyer
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: bleak>=0.19.0
+Requires-Dist: bleak-retry-connector>=3.4.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: pyOpenSSL>=23.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ switchbot/adv_parsers/ceiling_light.py
 switchbot/adv_parsers/contact.py
 switchbot/adv_parsers/curtain.py
 switchbot/adv_parsers/hub2.py
+switchbot/adv_parsers/hubmini_matter.py
 switchbot/adv_parsers/humidifier.py
 switchbot/adv_parsers/keypad.py
 switchbot/adv_parsers/leak.py
@@ -33,6 +34,7 @@ switchbot/adv_parsers/motion.py
 switchbot/adv_parsers/plug.py
 switchbot/adv_parsers/relay_switch.py
 switchbot/adv_parsers/remote.py
+switchbot/adv_parsers/roller_shade.py
 switchbot/const/__init__.py
 switchbot/const/evaporative_humidifier.py
 switchbot/const/hub2.py
@@ -56,10 +58,12 @@ switchbot/devices/meter.py
 switchbot/devices/motion.py
 switchbot/devices/plug.py
 switchbot/devices/relay_switch.py
+switchbot/devices/roller_shade.py
 tests/test_adv_parser.py
 tests/test_base_cover.py
 tests/test_blind_tilt.py
 tests/test_curtain.py
 tests/test_evaporative_humidifier.py
 tests/test_hub2.py
-tests/test_relay_switch.py
+tests/test_relay_switch.py
+tests/test_roller_shade.py

pyswitchbot-0.59.0/README.md

@@ -0,0 +1,102 @@
+# pySwitchbot [![Build Status](https://travis-ci.org/sblibs/pySwitchbot.svg?branch=master)](https://travis-ci.org/sblibs/pySwitchbot)
+
+Library to control Switchbot IoT devices https://www.switch-bot.com/bot
+
+## Obtaining encryption key for Switchbot Locks
+
+Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.
+
+Usage:
+
+```shell
+$ python3 get_encryption_key.py MAC USERNAME
+Key ID: XX
+Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+
+Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
+If authentication succeeds then script should output your key id and encryption key.
+
+## Examples:
+
+#### WoLock (Lock-Pro)
+
+Unlock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).unlock()
+
+
+asyncio.run(main())
+```
+
+Lock:
+
+```python
+import asyncio
+from switchbot.discovery import GetSwitchbotDevices
+from switchbot.devices import lock
+from switchbot.const import SwitchbotModel
+
+BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
+KEY_ID="XX" # The key-ID of your encryption-key for your lock
+ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
+LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)
+
+
+async def main():
+    wolock = await GetSwitchbotDevices().get_locks()
+    await lock.SwitchbotLock(
+        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
+    ).lock()
+
+
+asyncio.run(main())
+```
+
+#### WoCurtain (Curtain 3)
+
+```python
+import asyncio
+from pprint import pprint
+from switchbot import GetSwitchbotDevices
+from switchbot.devices import curtain
+
+
+async def main():
+    # get the BLE advertisement data of all switchbot devices in the vicinity
+    advertisement_data = await GetSwitchbotDevices().discover()
+
+    for i in advertisement_data.values():
+        pprint(i)
+        print()  # print newline so that devices' data is separated visually
+
+    # find your device's BLE address by inspecting the above printed debug logs, example below
+    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
+    # get the BLE device (via its address) and construct a curtain device
+    ble_device = advertisement_data[ble_address].device
+    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)
+
+    pprint(await curtain_device.get_device_data())
+    pprint(await curtain_device.get_basic_info())
+    await curtain_device.set_position(100)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/setup.py

@@ -20,7 +20,7 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.58.0",
+    version="0.59.0",
     description="A library to communicate with Switchbot",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/switchbot/__init__.py

@@ -29,6 +29,7 @@ from .devices.light_strip import SwitchbotLightStrip
 from .devices.lock import SwitchbotLock
 from .devices.plug import SwitchbotPlugMini
 from .devices.relay_switch import SwitchbotRelaySwitch
+from .devices.roller_shade import SwitchbotRollerShade
 from .discovery import GetSwitchbotDevices
 from .models import SwitchBotAdvertisement
 
@@ -58,6 +59,7 @@ __all__ = [
     "SwitchbotPlugMini",
     "SwitchbotPlugMini",
     "SwitchbotRelaySwitch",
+    "SwitchbotRollerShade",
     "SwitchbotSupportedType",
     "SwitchbotSupportedType",
     "close_stale_connections",

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/switchbot/adv_parser.py

@@ -17,6 +17,7 @@ from .adv_parsers.ceiling_light import process_woceiling
 from .adv_parsers.contact import process_wocontact
 from .adv_parsers.curtain import process_wocurtain
 from .adv_parsers.hub2 import process_wohub2
+from .adv_parsers.hubmini_matter import process_hubmini_matter
 from .adv_parsers.humidifier import process_evaporative_humidifier, process_wohumidifier
 from .adv_parsers.keypad import process_wokeypad
 from .adv_parsers.leak import process_leak
@@ -30,6 +31,7 @@ from .adv_parsers.relay_switch import (
     process_worelay_switch_1pm,
 )
 from .adv_parsers.remote import process_woremote
+from .adv_parsers.roller_shade import process_worollershade
 from .const import SwitchbotModel
 from .models import SwitchBotAdvertisement
 
@@ -216,6 +218,18 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "func": process_woremote,
         "manufacturer_id": 89,
     },
+    ",": {
+        "modelName": SwitchbotModel.ROLLER_SHADE,
+        "modelFriendlyName": "Roller Shade",
+        "func": process_worollershade,
+        "manufacturer_id": 2409,
+    },
+    "%": {
+        "modelName": SwitchbotModel.HUBMINI_MATTER,
+        "modelFriendlyName": "HubMini Matter",
+        "func": process_hubmini_matter,
+        "manufacturer_id": 2409,
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR = {

pyswitchbot-0.59.0/switchbot/adv_parsers/hubmini_matter.py

@@ -0,0 +1,37 @@
+"""Hubmini matter parser."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def process_hubmini_matter(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, Any]:
+    """Process Hubmini matter sensor manufacturer data."""
+    temp_data = None
+
+    if mfr_data:
+        temp_data = mfr_data[13:16]
+
+    if not temp_data:
+        return {}
+
+    _temp_sign = 1 if temp_data[1] & 0b10000000 else -1
+    _temp_c = _temp_sign * (
+        (temp_data[1] & 0b01111111) + ((temp_data[0] & 0b00001111) / 10)
+    )
+    _temp_f = (_temp_c * 9 / 5) + 32
+    _temp_f = (_temp_f * 10) / 10
+    humidity = temp_data[2] & 0b01111111
+
+    if _temp_c == 0 and humidity == 0:
+        return {}
+
+    paraser_data = {
+        "temp": {"c": _temp_c, "f": _temp_f},
+        "temperature": _temp_c,
+        "fahrenheit": bool(temp_data[2] & 0b10000000),
+        "humidity": humidity,
+    }
+    return paraser_data

pyswitchbot-0.59.0/switchbot/adv_parsers/roller_shade.py

@@ -0,0 +1,29 @@
+"""Library to handle connection with Switchbot."""
+
+from __future__ import annotations
+
+
+def process_worollershade(
+    data: bytes | None, mfr_data: bytes | None, reverse: bool = True
+) -> dict[str, bool | int]:
+    """Process woRollerShade services data."""
+    if mfr_data is None:
+        return {}
+
+    device_data = mfr_data[6:]
+
+    _position = max(min(device_data[2] & 0b01111111, 100), 0)
+    _calibrated = bool(device_data[2] & 0b10000000)
+    _in_motion = bool(device_data[1] & 0b00000110)
+    _light_level = (device_data[3] >> 4) & 0b00001111
+    _device_chain = device_data[3] & 0b00001111
+
+    return {
+        "calibration": _calibrated,
+        "battery": data[2] & 0b01111111 if data else None,
+        "inMotion": _in_motion,
+        "position": (100 - _position) if reverse else _position,
+        "lightLevel": _light_level,
+        "deviceChain": _device_chain,
+        "sequence_number": device_data[0],
+    }

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/switchbot/const/__init__.py

@@ -63,3 +63,5 @@ class SwitchbotModel(StrEnum):
     RELAY_SWITCH_1 = "Relay Switch 1"
     REMOTE = "WoRemote"
     EVAPORATIVE_HUMIDIFIER = "Evaporative Humidifier"
+    ROLLER_SHADE = "Roller Shade"
+    HUBMINI_MATTER = "HubMini Matter"

{pyswitchbot-0.58.0 → pyswitchbot-0.59.0}/switchbot/devices/base_cover.py

@@ -10,6 +10,8 @@ from .device import REQ_HEADER, SwitchbotDevice, update_after_operation
 
 # Cover keys
 COVER_COMMAND = "4501"
+ROLLERSHADE_COMMAND = "4701"
+CONTROL_SOURCE = "00"
 
 # For second element of open and close arrs we should add two bytes i.e. ff00
 # First byte [ff] stands for speed (00 or ff - normal, 01 - slow) *

pyswitchbot-0.59.0/switchbot/devices/roller_shade.py

@@ -0,0 +1,129 @@
+"""Library to handle connection with Switchbot."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..models import SwitchBotAdvertisement
+from .base_cover import CONTROL_SOURCE, ROLLERSHADE_COMMAND, SwitchbotBaseCover
+from .device import REQ_HEADER, SwitchbotSequenceDevice, update_after_operation
+
+_LOGGER = logging.getLogger(__name__)
+
+
+OPEN_KEYS = [
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}01{CONTROL_SOURCE}0100",
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}05{CONTROL_SOURCE}0000",
+]
+CLOSE_KEYS = [
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}01{CONTROL_SOURCE}0164",
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}05{CONTROL_SOURCE}0064",
+]
+POSITION_KEYS = [
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}01{CONTROL_SOURCE}01",
+    f"{REQ_HEADER}{ROLLERSHADE_COMMAND}05{CONTROL_SOURCE}",
+]  # +actual_position
+STOP_KEYS = [f"{REQ_HEADER}{ROLLERSHADE_COMMAND}00{CONTROL_SOURCE}01"]
+
+
+class SwitchbotRollerShade(SwitchbotBaseCover, SwitchbotSequenceDevice):
+    """Representation of a Switchbot Roller Shade."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Switchbot roller shade constructor."""
+        # The position of the roller shade is saved returned with 0 = open and 100 = closed.
+        # the definition of position is the same as in Home Assistant.
+
+        self._reverse: bool = kwargs.pop("reverse_mode", True)
+        super().__init__(self._reverse, *args, **kwargs)
+
+    def _set_parsed_data(
+        self, advertisement: SwitchBotAdvertisement, data: dict[str, Any]
+    ) -> None:
+        """Set data."""
+        in_motion = data["inMotion"]
+        previous_position = self._get_adv_value("position")
+        new_position = data["position"]
+        self._update_motion_direction(in_motion, previous_position, new_position)
+        super()._set_parsed_data(advertisement, data)
+
+    @update_after_operation
+    async def open(self, mode: int = 0) -> bool:
+        """Send open command. 0 - performance mode, 1 - unfelt mode."""
+        self._is_opening = True
+        self._is_closing = False
+        return await self._send_multiple_commands(OPEN_KEYS)
+
+    @update_after_operation
+    async def close(self, speed: int = 0) -> bool:
+        """Send close command. 0 - performance mode, 1 - unfelt mode."""
+        self._is_closing = True
+        self._is_opening = False
+        return await self._send_multiple_commands(CLOSE_KEYS)
+
+    @update_after_operation
+    async def stop(self) -> bool:
+        """Send stop command to device."""
+        self._is_opening = self._is_closing = False
+        return await self._send_multiple_commands(STOP_KEYS)
+
+    @update_after_operation
+    async def set_position(self, position: int, mode: int = 0) -> bool:
+        """Send position command (0-100) to device. 0 - performance mode, 1 - unfelt mode."""
+        position = (100 - position) if self._reverse else position
+        self._update_motion_direction(True, self._get_adv_value("position"), position)
+        return await self._send_multiple_commands(
+            [
+                f"{POSITION_KEYS[0]}{position:02X}",
+                f"{POSITION_KEYS[1]}{mode:02X}{position:02X}",
+            ]
+        )
+
+    def get_position(self) -> Any:
+        """Return cached position (0-100) of Curtain."""
+        # To get actual position call update() first.
+        return self._get_adv_value("position")
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (_data := await self._get_basic_info()):
+            return None
+
+        _position = max(min(_data[5], 100), 0)
+        _direction_adjusted_position = (100 - _position) if self._reverse else _position
+        _previous_position = self._get_adv_value("position")
+        _in_motion = bool(_data[4] & 0b00000011)
+        self._update_motion_direction(
+            _in_motion, _previous_position, _direction_adjusted_position
+        )
+
+        return {
+            "battery": _data[1],
+            "firmware": _data[2] / 10.0,
+            "chainLength": _data[3],
+            "openDirection": (
+                "clockwise" if _data[4] & 0b10000000 == 128 else "anticlockwise"
+            ),
+            "fault": bool(_data[4] & 0b00010000),
+            "solarPanel": bool(_data[4] & 0b00001000),
+            "calibration": bool(_data[4] & 0b00000100),
+            "calibrated": bool(_data[4] & 0b00000100),
+            "inMotion": _in_motion,
+            "position": _direction_adjusted_position,
+            "timers": _data[6],
+        }
+
+    def _update_motion_direction(
+        self, in_motion: bool, previous_position: int | None, new_position: int
+    ) -> None:
+        """Update opening/closing status based on movement."""
+        if previous_position is None:
+            return
+        if in_motion is False:
+            self._is_closing = self._is_opening = False
+            return
+
+        if new_position != previous_position:
+            self._is_opening = new_position > previous_position
+            self._is_closing = new_position < previous_position