aiobmsble 0.2.3__tar.gz → 0.4__tar.gz

aiobmsble-0.4/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: aiobmsble
+Version: 0.4
+Summary: Asynchronous Python library to query battery management systems via Bluetooth Low Energy.
+Author: Patrick Loschmidt
+Maintainer: Patrick Loschmidt
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/patman15/aiobmsble/
+Project-URL: Documentation, https://github.com/patman15/aiobmsble/README
+Project-URL: Source Code, https://github.com/patman15/aiobmsble/
+Project-URL: Bug Reports, https://github.com/patman15/aiobmsble/issues
+Keywords: BMS,BLE,battery,bluetooth
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak>=1.0.1
+Requires-Dist: bleak-retry-connector>=4.0.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff<0.14.0,>=0.12.1; extra == "dev"
+Dynamic: license-file
+
+[![GitHub Release][releases-shield]](https://pypi.org/p/aiobmsble/)
+[![License][license-shield]](LICENSE)
+
+# Aiobmsble
+Requires Python 3 and uses [asyncio](https://pypi.org/project/asyncio/) and [bleak](https://pypi.org/project/bleak/)
+
+## Asynchronous Library to Query Battery Management Systems via Bluetooth LE
+This library is intended to query data from battery management systems that use Bluetooth LE. This library can be used stand-alone in any Python environment (with necessary dependencies installed). It is developed to support [BMS_BLE-HA integration](https://github.com/patman15/BMS_BLE-HA/) that was written to make BMS data available to Home Assistant, but can be hopefully usefull for other use-cases as well.
+
+* [Features](#features)
+* [Usage](#usage)
+* [Installation](#installation)
+* [Troubleshooting](#troubleshooting)
+
+## Features
+- Support for autodetecting compatible BLE BMSs
+- Automatic detection of compatible BLE write mode
+- Asynchronous operation using [asyncio](https://pypi.org/project/asyncio/)
+- Any number of batteries in parallel
+- 100% test coverage plus fuzz tests for BLE data
+
+### Supported Devices
+The [list of supported devices](https://github.com/patman15/BMS_BLE-HA/blob/feature-aiobmsble/README.md#supported-devices) is maintained in the repository of the related [Home Assistant integration](https://github.com/patman15/BMS_BLE-HA).
+
+## Usage
+In order to identify all devices that are reachable and supported by the library, simply run
+```bash
+aiobmsble
+```
+from the command line after [installation](#installation). 
+
+### From your Python code
+In case you need a reference to include the code into your library, please see [\_\_main\_\_.py](/aiobmsble/__main__.py).
+
+### From a Script
+This example can also be found as an [example](/examples/minimal.py) in the respective [folder](/main/examples).
+```python
+"""Example of using the aiobmsble library to find a BLE device by name and print its sensor data.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
+
+import asyncio
+import logging
+from typing import Final
+
+from bleak import BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.exc import BleakError
+
+from aiobmsble import BMSsample
+from aiobmsble.bms.dummy_bms import BMS  # TODO: use the right BMS class for your device
+
+NAME: Final[str] = "BT Device Name"  # TODO: replace with the name of your BLE device
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+async def main(dev_name) -> None:
+    """Find a BLE device by name and update its sensor data."""
+
+    device: BLEDevice | None = await BleakScanner.find_device_by_name(dev_name)
+    if device is None:
+        logger.error("Device '%s' not found.", dev_name)
+        return
+
+    logger.info("Found device: %s (%s)", device.name, device.address)
+    try:
+        async with BMS(ble_device=device) as bms:
+            logger.info("Updating BMS data...")
+            data: BMSsample = await bms.async_update()
+            logger.info("BMS data: %s", repr(data).replace(", ", ",\n\t"))
+    except BleakError as ex:
+        logger.error("Failed to update BMS: %s", type(ex).__name__)
+
+
+if __name__ == "__main__":
+    asyncio.run(main(NAME))  # pragma: no cover
+```
+
+### Testing
+For integrations tests (using pytest) the library provides advertisement data that can be used to verify detection of BMSs. To use it, include the following line into your `conftest.py`:
+```python
+pytest_plugins: list[str] = ["aiobmsble.test_data"]
+```
+
+For your tests you can then use
+```python
+def test_advertisements(bms_advertisements) -> None:
+    """Run some tests with the advertisements"""
+    for advertisement, bms_type, _comments in bms_advertisements:
+        ...
+```
+
+## Installation
+Install python and pip if you have not already, then run:
+```bash
+pip3 install pip --upgrade
+pip3 install wheel
+```
+
+### For Production:
+
+```bash
+pip3 install aiobmsble
+```
+This will install the latest library release and all of it's python dependencies.
+
+### For Development:
+```bash
+git clone https://github.com/patman15/aiobmsble.git
+cd aiobmsble
+pip3 install -e .[dev]
+```
+This gives you the latest library code from the main branch.
+
+## Troubleshooting
+In case you have problems with the library, please enable debug logging. You can also run `aiobmsble -v` from the command line in order to query all known BMS that are reachable.
+
+### In case you have troubles you'd like to have help with 
+
+- please record a debug log using `aiobmsble -v -l debug.log`,
+- [open an issue](https://github.com/patman15/aiobmsble/issues/new?assignees=&labels=question&projects=&template=support.yml) with a good description of what your question/issue is and attach the log, or
+- [open a bug](https://github.com/patman15/aiobmsble/issues/new?assignees=&labels=Bug&projects=&template=bug.yml) if you think the behaviour you see is misbehaviour of the library, including a good description of what happened, your expectations,
+- and put the `debug.log` **as attachement** to the issue.
+
+[license-shield]: https://img.shields.io/github/license/patman15/aiobmsble?style=for-the-badge&cacheSeconds=86400
+[releases-shield]: https://img.shields.io/pypi/v/aiobmsble?style=for-the-badge

aiobmsble-0.4/README.md

@@ -0,0 +1,131 @@
+[![GitHub Release][releases-shield]](https://pypi.org/p/aiobmsble/)
+[![License][license-shield]](LICENSE)
+
+# Aiobmsble
+Requires Python 3 and uses [asyncio](https://pypi.org/project/asyncio/) and [bleak](https://pypi.org/project/bleak/)
+
+## Asynchronous Library to Query Battery Management Systems via Bluetooth LE
+This library is intended to query data from battery management systems that use Bluetooth LE. This library can be used stand-alone in any Python environment (with necessary dependencies installed). It is developed to support [BMS_BLE-HA integration](https://github.com/patman15/BMS_BLE-HA/) that was written to make BMS data available to Home Assistant, but can be hopefully usefull for other use-cases as well.
+
+* [Features](#features)
+* [Usage](#usage)
+* [Installation](#installation)
+* [Troubleshooting](#troubleshooting)
+
+## Features
+- Support for autodetecting compatible BLE BMSs
+- Automatic detection of compatible BLE write mode
+- Asynchronous operation using [asyncio](https://pypi.org/project/asyncio/)
+- Any number of batteries in parallel
+- 100% test coverage plus fuzz tests for BLE data
+
+### Supported Devices
+The [list of supported devices](https://github.com/patman15/BMS_BLE-HA/blob/feature-aiobmsble/README.md#supported-devices) is maintained in the repository of the related [Home Assistant integration](https://github.com/patman15/BMS_BLE-HA).
+
+## Usage
+In order to identify all devices that are reachable and supported by the library, simply run
+```bash
+aiobmsble
+```
+from the command line after [installation](#installation). 
+
+### From your Python code
+In case you need a reference to include the code into your library, please see [\_\_main\_\_.py](/aiobmsble/__main__.py).
+
+### From a Script
+This example can also be found as an [example](/examples/minimal.py) in the respective [folder](/main/examples).
+```python
+"""Example of using the aiobmsble library to find a BLE device by name and print its sensor data.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
+
+import asyncio
+import logging
+from typing import Final
+
+from bleak import BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.exc import BleakError
+
+from aiobmsble import BMSsample
+from aiobmsble.bms.dummy_bms import BMS  # TODO: use the right BMS class for your device
+
+NAME: Final[str] = "BT Device Name"  # TODO: replace with the name of your BLE device
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+async def main(dev_name) -> None:
+    """Find a BLE device by name and update its sensor data."""
+
+    device: BLEDevice | None = await BleakScanner.find_device_by_name(dev_name)
+    if device is None:
+        logger.error("Device '%s' not found.", dev_name)
+        return
+
+    logger.info("Found device: %s (%s)", device.name, device.address)
+    try:
+        async with BMS(ble_device=device) as bms:
+            logger.info("Updating BMS data...")
+            data: BMSsample = await bms.async_update()
+            logger.info("BMS data: %s", repr(data).replace(", ", ",\n\t"))
+    except BleakError as ex:
+        logger.error("Failed to update BMS: %s", type(ex).__name__)
+
+
+if __name__ == "__main__":
+    asyncio.run(main(NAME))  # pragma: no cover
+```
+
+### Testing
+For integrations tests (using pytest) the library provides advertisement data that can be used to verify detection of BMSs. To use it, include the following line into your `conftest.py`:
+```python
+pytest_plugins: list[str] = ["aiobmsble.test_data"]
+```
+
+For your tests you can then use
+```python
+def test_advertisements(bms_advertisements) -> None:
+    """Run some tests with the advertisements"""
+    for advertisement, bms_type, _comments in bms_advertisements:
+        ...
+```
+
+## Installation
+Install python and pip if you have not already, then run:
+```bash
+pip3 install pip --upgrade
+pip3 install wheel
+```
+
+### For Production:
+
+```bash
+pip3 install aiobmsble
+```
+This will install the latest library release and all of it's python dependencies.
+
+### For Development:
+```bash
+git clone https://github.com/patman15/aiobmsble.git
+cd aiobmsble
+pip3 install -e .[dev]
+```
+This gives you the latest library code from the main branch.
+
+## Troubleshooting
+In case you have problems with the library, please enable debug logging. You can also run `aiobmsble -v` from the command line in order to query all known BMS that are reachable.
+
+### In case you have troubles you'd like to have help with 
+
+- please record a debug log using `aiobmsble -v -l debug.log`,
+- [open an issue](https://github.com/patman15/aiobmsble/issues/new?assignees=&labels=question&projects=&template=support.yml) with a good description of what your question/issue is and attach the log, or
+- [open a bug](https://github.com/patman15/aiobmsble/issues/new?assignees=&labels=Bug&projects=&template=bug.yml) if you think the behaviour you see is misbehaviour of the library, including a good description of what happened, your expectations,
+- and put the `debug.log` **as attachement** to the issue.
+
+[license-shield]: https://img.shields.io/github/license/patman15/aiobmsble?style=for-the-badge&cacheSeconds=86400
+[releases-shield]: https://img.shields.io/pypi/v/aiobmsble?style=for-the-badge

{aiobmsble-0.2.3 → aiobmsble-0.4}/aiobmsble/__init__.py

@@ -19,6 +19,7 @@ type BMSvalue = Literal[
     "cycles",
     "cycle_capacity",
     "cycle_charge",
+    "total_charge",
     "delta_voltage",
     "problem",
     "runtime",
@@ -69,6 +70,7 @@ class BMSsample(TypedDict, total=False):
     cell_count: int  # [#]
     cell_voltages: list[float]  # [V]
     cycle_charge: int | float  # [Ah]
+    total_charge: int  # [Ah], overall discharged
     design_capacity: int  # [Ah]
     pack_count: int  # [#]
     temp_sensors: int  # [#]

{aiobmsble-0.2.3 → aiobmsble-0.4}/aiobmsble/__main__.py

@@ -31,7 +31,7 @@ async def scan_devices() -> dict[str, tuple[BLEDevice, AdvertisementData]]:
     scan_result: dict[str, tuple[BLEDevice, AdvertisementData]] = (
         await BleakScanner.discover(return_adv=True)
     )
-    logger.info(scan_result)
+    logger.debug(scan_result)
     logger.info("%i BT devices in range.", len(scan_result))
     return scan_result
 
@@ -51,7 +51,7 @@ async def detect_bms() -> None:
 
         if bms_cls := bms_identify(advertisement):
             logger.info("Found matching BMS type: %s", bms_cls.device_id())
-            bms: BaseBMS = bms_cls(ble_device=ble_dev, reconnect=True)
+            bms: BaseBMS = bms_cls(ble_device=ble_dev)
 
             try:
                 logger.info("Updating BMS data...")
@@ -59,6 +59,8 @@ async def detect_bms() -> None:
                 logger.info("BMS data: %s", repr(data).replace(", '", ",\n\t'"))
             except (BleakError, TimeoutError) as exc:
                 logger.error("Failed to update BMS: %s", type(exc).__name__)
+            finally:
+                await bms.disconnect()
 
     logger.info("done.")
 

{aiobmsble-0.2.3 → aiobmsble-0.4}/aiobmsble/basebms.py

@@ -9,7 +9,8 @@ import asyncio
 from collections.abc import Callable, MutableMapping
 import logging
 from statistics import fmean
-from typing import Any, Final, Literal
+from types import TracebackType
+from typing import Any, Final, Literal, Self
 
 from bleak import BleakClient
 from bleak.backends.characteristic import BleakGATTCharacteristic
@@ -44,26 +45,28 @@ class BaseBMS(ABC):
     def __init__(
         self,
         ble_device: BLEDevice,
-        reconnect: bool = False,
+        keep_alive: bool = True,
         logger_name: str = "",
     ) -> None:
         """Intialize the BMS.
 
-        notification_handler: the callback function used for notifications from 'uuid_rx()'
+        `_notification_handler`: the callback function used for notifications from `uuid_rx()`
             characteristic. Not defined as abstract in this base class, as it can be both,
             a normal or async function
 
         Args:
-            logger_name (str): name of the logger for the BMS instance (usually file name)
             ble_device (BLEDevice): the Bleak device to connect to
-            reconnect (bool): if true, the connection will be closed after each update
+            keep_alive (bool): if true, the connection will be kept active after each update.
+                Make sure to call `disconnect()` when done using the BMS class or better use
+                `async with` context manager (requires `keep_alive=True`).
+            logger_name (str): name of the logger for the BMS instance, default: module name
 
         """
         assert (
             getattr(self, "_notification_handler", None) is not None
         ), "BMS class must define _notification_handler method"
         self._ble_device: Final[BLEDevice] = ble_device
-        self._reconnect: Final[bool] = reconnect
+        self._keep_alive: Final[bool] = keep_alive
         self.name: Final[str] = self._ble_device.name or "undefined"
         self._inv_wr_mode: bool | None = None  # invert write mode (WNR <-> W)
         logger_name = logger_name or self.__class__.__module__
@@ -83,6 +86,22 @@ class BaseBMS(ABC):
         self._data: bytearray = bytearray()
         self._data_event: Final[asyncio.Event] = asyncio.Event()
 
+    async def __aenter__(self) -> Self:
+        """Asynchronous context manager to implement `async with` functionality."""
+        if not self._keep_alive:
+            raise ValueError("usage of context manager requires `keep_alive=True`.")
+        await self._connect()
+        return self
+
+    async def __aexit__(
+        self,
+        typ: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        """Asynchronous context manager exit functionality."""
+        await self.disconnect()
+
     @classmethod
     def get_bms_module(cls) -> str:
         """Return BMS module name, e.g. aiobmsble.bms.dummy_bms."""
@@ -177,6 +196,10 @@ class BaseBMS(ABC):
                 {"voltage", "cycle_charge"},
                 lambda: round(data.get("voltage", 0) * data.get("cycle_charge", 0), 3),
             ),
+            "cycles": (
+                {"design_capacity", "total_charge"},
+                lambda: data.get("total_charge", 0) // data.get("design_capacity", 0),
+            ),
             "power": (
                 {"voltage", "current"},
                 lambda: round(data.get("voltage", 0) * current, 3),
@@ -356,8 +379,8 @@ class BaseBMS(ABC):
             if reset:
                 self._inv_wr_mode = None  # reset write mode
             await self._client.disconnect()
-        except BleakError:
-            self._log.warning("disconnect failed!")
+        except (BleakError, TimeoutError) as exc:
+            self._log.error("disconnect failed! (%s)", type(exc).__name__)
 
     async def _wait_event(self) -> None:
         """Wait for data event and clear it."""
@@ -384,7 +407,7 @@ class BaseBMS(ABC):
         data: BMSsample = await self._async_update()
         self._add_missing_values(data, self._calc_values())
 
-        if self._reconnect:
+        if not self._keep_alive:
             # disconnect after data update to force reconnect next time (slow!)
             await self.disconnect()
 
@@ -478,16 +501,18 @@ class BaseBMS(ABC):
 
         """
         return [
-            value / divider if divider != 1 else value
+            (value - offset) / divider
             for idx in range(values)
             if (len(data) >= start + (idx + 1) * size)
             and (
-                value := int.from_bytes(
-                    data[start + idx * size : start + (idx + 1) * size],
-                    byteorder=byteorder,
-                    signed=signed,
+                (
+                    value := int.from_bytes(
+                        data[start + idx * size : start + (idx + 1) * size],
+                        byteorder=byteorder,
+                        signed=signed,
+                    )
                 )
-                - offset
+                or (offset == 0)
             )
         ]
 

{aiobmsble-0.2.3 → aiobmsble-0.4}/aiobmsble/bms/abc_bms.py

@@ -47,9 +47,9 @@ class BMS(BaseBMS):
     )
     _RESPS: Final[set[int]] = {field.idx for field in _FIELDS} | {0xF4}  # cell voltages
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Initialize BMS."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: dict[int, bytearray] = {}
         self._exp_reply: set[int] = set()
 

{aiobmsble-0.2.3 → aiobmsble-0.4}/aiobmsble/bms/ant_bms.py

@@ -41,13 +41,14 @@ class BMS(BaseBMS):
             | ((x & 0xF) if (x & 0xF) not in (0x1, 0x4, 0xB, 0xC, 0xF) else 0),
         ),
         BMSdp("cycle_charge", 54, 4, False, lambda x: x / 1e6),
+        BMSdp("total_charge", 58, 4, False, lambda x: x // 1000),
         BMSdp("delta_voltage", 82, 2, False, lambda x: x / 1000),
         BMSdp("power", 62, 4, True, lambda x: x / 1),
     )
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Initialize BMS."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: bytearray = bytearray()
         self._valid_reply: int = BMS._CMD_STAT | 0x10  # valid reply mask
         self._exp_len: int = BMS._MIN_LEN
@@ -87,7 +88,7 @@ class BMS(BaseBMS):
     @staticmethod
     def _calc_values() -> frozenset[BMSvalue]:
         return frozenset(
-            {"cycle_capacity", "temperature"}
+            {"cycle_capacity", "cycles", "temperature"}
         )  # calculate further values from BMS provided set ones
 
     async def _init_connection(

aiobmsble-0.4/aiobmsble/bms/ant_leg_bms.py

@@ -0,0 +1,177 @@
+"""Module to support ANT BMS."""
+
+import contextlib
+from enum import IntEnum
+from typing import Final, override
+
+from bleak.backends.characteristic import BleakGATTCharacteristic
+from bleak.backends.device import BLEDevice
+from bleak.uuids import normalize_uuid_str
+
+from aiobmsble import BMSdp, BMSsample, BMSvalue, MatcherPattern
+from aiobmsble.basebms import BaseBMS, crc_sum
+
+
+class BMS(BaseBMS):
+    """ANT BMS (legacy) implementation."""
+
+    class CMD(IntEnum):
+        """Command codes for ANT BMS."""
+
+        GET = 0xDB
+        SET = 0xA5
+
+    class ADR(IntEnum):
+        """Address codes for ANT BMS."""
+
+        STATUS = 0x00
+
+    _RX_HEADER: Final[bytes] = b"\xaa\x55\xaa"
+    _RX_HEADER_RSP_STAT: Final[bytes] = b"\xaa\x55\xaa\xff"
+
+    _RSP_STAT: Final[int] = 0xFF
+    _RSP_STAT_LEN: Final[int] = 140
+
+    _FIELDS: Final[tuple[BMSdp, ...]] = (
+        BMSdp("voltage", 4, 2, False, lambda x: x / 10),
+        BMSdp("current", 70, 4, True, lambda x: x / -10),
+        BMSdp("battery_level", 74, 1, False),
+        BMSdp("design_capacity", 75, 4, False, lambda x: x // 1e6),
+        BMSdp("cycle_charge", 79, 4, False, lambda x: x / 1e6),
+        BMSdp("total_charge", 83, 4, False, lambda x: x // 1000),
+        BMSdp("runtime", 87, 4, False),
+        BMSdp("cell_count", 123, 1, False),
+    )
+
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
+        """Initialize BMS."""
+        super().__init__(ble_device, keep_alive)
+        self._data_final: bytearray
+
+    @staticmethod
+    @override
+    def matcher_dict_list() -> list[MatcherPattern]:
+        """Provide BluetoothMatcher definition."""
+        return [
+            {
+                "local_name": "ANT-BLE*",
+                "service_uuid": BMS.uuid_services()[0],
+                "manufacturer_id": 1623,
+                "connectable": True,
+            }
+        ]
+
+    @staticmethod
+    @override
+    def device_info() -> dict[str, str]:
+        """Return device information for the battery management system."""
+        return {"manufacturer": "ANT", "model": "Smart BMS"}
+
+    @staticmethod
+    @override
+    def uuid_services() -> list[str]:
+        """Return list of 128-bit UUIDs of services required by BMS."""
+        return [normalize_uuid_str("ffe0")]  # change service UUID here!
+
+    @staticmethod
+    @override
+    def uuid_rx() -> str:
+        """Return 16-bit UUID of characteristic that provides notification/read property."""
+        return "ffe1"
+
+    @staticmethod
+    @override
+    def uuid_tx() -> str:
+        """Return 16-bit UUID of characteristic that provides write property."""
+        return "ffe1"
+
+    @staticmethod
+    @override
+    def _calc_values() -> frozenset[BMSvalue]:
+        return frozenset(
+            (
+                "battery_charging",
+                "cycle_capacity",
+                "cycles",
+                "delta_voltage",
+                "power",
+                "temperature",
+            )
+        )  # calculate further values from BMS provided set ones
+
+    def _notification_handler(
+        self, _sender: BleakGATTCharacteristic, data: bytearray
+    ) -> None:
+        """Handle the RX characteristics notify event (new data arrives)."""
+
+        self._log.debug("RX BLE data: %s", data)
+
+        if data.startswith(BMS._RX_HEADER_RSP_STAT):
+            self._data = bytearray()
+        elif not self._data:
+            self._log.debug("invalid start of frame")
+            return
+
+        self._data += data
+
+        _data_len: Final[int] = len(self._data)
+        if _data_len < BMS._RSP_STAT_LEN:
+            return
+
+        if _data_len > BMS._RSP_STAT_LEN:
+            self._log.debug("invalid length %d > %d", _data_len, BMS._RSP_STAT_LEN)
+            self._data.clear()
+            return
+
+        if (local_crc := crc_sum(self._data[4:-2], 2)) != (
+            remote_crc := int.from_bytes(self._data[-2:], byteorder="big", signed=False)
+        ):
+            self._log.debug("invalid checksum 0x%X != 0x%X", local_crc, remote_crc)
+            self._data.clear()
+            return
+
+        self._data_final = self._data.copy()
+        self._data.clear()
+        self._data_event.set()
+
+    @staticmethod
+    def _cmd(cmd: CMD, adr: ADR, value: int = 0x0000) -> bytes:
+        """Assemble a ANT BMS command."""
+        _frame = bytearray((cmd, cmd, adr))
+        _frame += value.to_bytes(2, "big")
+        _frame += crc_sum(_frame[2:], 1).to_bytes(1, "big")
+        return bytes(_frame)
+
+    @override
+    async def _async_update(self) -> BMSsample:
+        """Update battery status information."""
+        await self._await_reply(BMS._cmd(BMS.CMD.GET, BMS.ADR.STATUS))
+
+        _data: bytearray = self._data_final
+        result: BMSsample = BMS._decode_data(
+            BMS._FIELDS, _data, byteorder="big", offset=0
+        )
+
+        result["cell_voltages"] = BMS._cell_voltages(
+            _data,
+            cells=result["cell_count"],
+            start=6,
+            size=2,
+            byteorder="big",
+            divider=1000,
+        )
+
+        if not result["design_capacity"]:
+            # Workaround for some BMS always reporting 0 for design_capacity
+            result.pop("design_capacity")
+            with contextlib.suppress(ZeroDivisionError):
+                result["design_capacity"] = int(
+                    round((result["cycle_charge"] / result["battery_level"]) * 100, -1)
+                )  # leads to `cycles` not available when level == 0
+
+        # ANT-BMS carries 6 slots for temp sensors but only 4 looks like being connected by default
+        result["temp_values"] = BMS._temp_values(
+            _data, values=4, start=91, size=2, byteorder="big", signed=True
+        )
+
+        return result