aiobmsble 0.2.3__tar.gz → 0.3.0__tar.gz

{aiobmsble-0.2.3/aiobmsble.egg-info → aiobmsble-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiobmsble
-Version: 0.2.3
+Version: 0.3.0
 Summary: Asynchronous Python library to query battery management systems via Bluetooth Low Energy.
 Author: Patrick Loschmidt
 Maintainer: Patrick Loschmidt
@@ -18,12 +18,8 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bleak~=1.1.0
+Requires-Dist: bleak>=1.0.1
 Requires-Dist: bleak-retry-connector>=4.0.2
-Requires-Dist: asyncio
-Requires-Dist: logging
-Requires-Dist: statistics
-Requires-Dist: typing
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
@@ -31,7 +27,7 @@ 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; extra == "dev"
+Requires-Dist: ruff~=0.12.1; extra == "dev"
 Dynamic: license-file
 
 [![License][license-shield]](LICENSE)
@@ -55,7 +51,11 @@ from the command line after [installation](#installation). In case you need the
 ### 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 senosr data."""
+"""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
@@ -66,9 +66,9 @@ from bleak.backends.device import BLEDevice
 from bleak.exc import BleakError
 
 from aiobmsble import BMSsample
-from aiobmsble.bms.dummy_bms import BMS  # use the right BMS class for your device
+from aiobmsble.bms.dummy_bms import BMS  # TODO: use the right BMS class for your device
 
-NAME: Final[str] = "BT Device Name"  # Replace with the name of your BLE device
+NAME: Final[str] = "BT Device Name"  # TODO: replace with the name of your BLE device
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -84,11 +84,11 @@ async def main(dev_name) -> None:
         return
 
     logger.info("Found device: %s (%s)", device.name, device.address)
-    bms = BMS(ble_device=device, reconnect=True)
     try:
-        logger.info("Updating BMS data...")
-        data: BMSsample = await bms.async_update()
-        logger.info("BMS data: %s", repr(data).replace(", ", ",\n\t"))
+        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__)
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/README.md

@@ -19,7 +19,11 @@ from the command line after [installation](#installation). In case you need the
 ### 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 senosr data."""
+"""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
@@ -30,9 +34,9 @@ from bleak.backends.device import BLEDevice
 from bleak.exc import BleakError
 
 from aiobmsble import BMSsample
-from aiobmsble.bms.dummy_bms import BMS  # use the right BMS class for your device
+from aiobmsble.bms.dummy_bms import BMS  # TODO: use the right BMS class for your device
 
-NAME: Final[str] = "BT Device Name"  # Replace with the name of your BLE device
+NAME: Final[str] = "BT Device Name"  # TODO: replace with the name of your BLE device
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -48,11 +52,11 @@ async def main(dev_name) -> None:
         return
 
     logger.info("Found device: %s (%s)", device.name, device.address)
-    bms = BMS(ble_device=device, reconnect=True)
     try:
-        logger.info("Updating BMS data...")
-        data: BMSsample = await bms.async_update()
-        logger.info("BMS data: %s", repr(data).replace(", ", ",\n\t"))
+        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__)
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/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.3.0}/aiobmsble/__main__.py

@@ -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.3.0}/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),
@@ -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.3.0}/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.3.0}/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.3.0/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

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/braunpwr_bms.py

@@ -38,9 +38,9 @@ class BMS(BaseBMS):
         0xF5,  # BMS boot version
     }
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: dict[int, bytearray] = {}
         self._exp_reply: tuple[int] = (0x01,)
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/cbtpwr_bms.py

@@ -37,9 +37,9 @@ class BMS(BaseBMS):
     )
     _CMDS: Final[list[int]] = list({field.idx for field in _FIELDS})
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
 
     @staticmethod
     def matcher_dict_list() -> list[MatcherPattern]:

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/cbtpwr_vb_bms.py

@@ -35,9 +35,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 15, 6, False, lambda x: x & 0xFFF000FF000F),
     )
 
-    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._exp_len: int = 0
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/daly_bms.py

@@ -39,9 +39,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 116, 8, False, lambda x: x % 2**64),
     )
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
 
     @staticmethod
     def matcher_dict_list() -> list[MatcherPattern]:

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/dpwrcore_bms.py

@@ -55,9 +55,9 @@ class BMS(BaseBMS):
     )
     _CMDS: Final[set[Cmd]] = {Cmd(field.idx) for field in _FIELDS}
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         assert self._ble_device.name is not None  # required for unlock
         self._data_final: dict[int, bytearray] = {}
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/dummy_bms.py

@@ -19,9 +19,9 @@ class BMS(BaseBMS):
     # _TAIL: Final[bytes] = b"\xAA"  # end of frame
     # _FRAME_LEN: Final[int] = 10  # length of frame, including SOF and checksum
 
-    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)
 
     @staticmethod
     def matcher_dict_list() -> list[MatcherPattern]:
@@ -84,7 +84,7 @@ class BMS(BaseBMS):
         self._log.debug("replace with command to UUID %s", BMS.uuid_tx())
         # await self._await_reply(b"<some_command>")
 
-        # # TODO: parse data from self._data here
+        # TODO: parse data from self._data here
 
         return {
             "voltage": 12,

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/ecoworthy_bms.py

@@ -42,9 +42,9 @@ class BMS(BaseBMS):
 
     _CMDS: Final[set[int]] = set({field.idx for field in _FIELDS_V1})
 
-    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._mac_head: Final[tuple] = tuple(
             int(self._ble_device.address.replace(":", ""), 16).to_bytes(6) + head
             for head in BMS._HEAD

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/ective_bms.py

@@ -33,9 +33,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 37, 2, False, lambda x: x),
     )
 
-    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()
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/ej_bms.py

@@ -45,9 +45,9 @@ class BMS(BaseBMS):
         ),  # mask status bits
     )
 
-    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()
 
     @staticmethod
@@ -65,7 +65,6 @@ class BMS(BaseBMS):
                     "connectable": True,
                 },
                 {"local_name": "SV12V*", "manufacturer_id": 33384, "connectable": True},
-                {"local_name": "LT-24*", "manufacturer_id": 22618, "connectable": True},
             ]
             + [  # LiTime
                 MatcherPattern(  # LiTime based on ser#
@@ -75,6 +74,13 @@ class BMS(BaseBMS):
                 )
                 for m_id in (33384, 22618)
             ]
+            + [  # LiTime based on ser#
+                {
+                    "local_name": "LT-24???B-A00[0-2]*",
+                    "manufacturer_id": 22618,
+                    "connectable": True,
+                }
+            ]
         )
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/felicity_bms.py

@@ -36,9 +36,9 @@ class BMS(BaseBMS):
         ("battery_level", "BatsocList", lambda x: x[0][0] / 100),
     ]
 
-    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 = {}
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/jbd_bms.py

@@ -32,9 +32,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 20, 2, False, lambda x: x),
     )  # general protocol v4
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._valid_reply: int = 0x00
         self._data_final: bytearray = bytearray()
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/jikong_bms.py

@@ -35,9 +35,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 166, 4, False, lambda x: x),
     )
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: bytearray = bytearray()
         self._char_write_handle: int = -1
         self._bms_info: dict[str, str] = {}

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/neey_bms.py

@@ -34,9 +34,9 @@ class BMS(BaseBMS):
         ("balance_current", 217, "<f", lambda x: round(x, 3)),
     ]
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: bytearray = bytearray()
         self._bms_info: dict[str, str] = {}
         self._exp_len: int = BMS._MIN_FRAME

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/ogt_bms.py

@@ -30,9 +30,9 @@ class BMS(BaseBMS):
         reg: int
         value: int
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._type: str = (
             self.name[9]
             if len(self.name) >= 10 and set(self.name[10:]).issubset(digits)

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/pro_bms.py

@@ -52,9 +52,9 @@ class BMS(BaseBMS):
         BMSdp("power", 32, 4, False, lambda x: x / 100),
     )
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Initialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._valid_reply: int = BMS._RT_DATA
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/redodo_bms.py

@@ -29,9 +29,9 @@ class BMS(BaseBMS):
         BMSdp("problem_code", 76, 4, False, lambda x: x),
     )
 
-    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)
 
     @staticmethod
     def matcher_dict_list() -> list[MatcherPattern]:
@@ -56,6 +56,9 @@ class BMS(BaseBMS):
                 "L-24*",
                 "L-51*",
                 "LT-12???BG-A0[7-9]*",  # LiTime based on ser#
+                "LT-24???B-A00[3-9]*",
+                "LT-24???B-A0[1-9]*",
+                "LT-24???B-A[1-9]*",
                 "LT-51*",
             )
         ]

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/renogy_bms.py

@@ -28,9 +28,9 @@ class BMS(BaseBMS):
         BMSdp("cycles", 15, 2, False, lambda x: x),
     )
 
-    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)
 
     @staticmethod
     def matcher_dict_list() -> list[MatcherPattern]:

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/renogy_pro_bms.py

@@ -24,9 +24,9 @@ class BMS(RenogyBMS):
         BMSdp("cycles", 15, 2, False, lambda x: x),
     )
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._char_write_handle: int = -1
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/roypow_bms.py

@@ -47,9 +47,9 @@ class BMS(BaseBMS):
     )
     _CMDS: Final[set[int]] = set({field.idx for field in _FIELDS})
 
-    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_len: int = 0
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/seplos_bms.py

@@ -57,9 +57,9 @@ class BMS(BaseBMS):
         field[2] for field in PQUERY.values()
     }
 
-    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+    def __init__(self, ble_device: BLEDevice, keep_alive: bool = True) -> None:
         """Intialize private BMS members."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._data_final: dict[int, bytearray] = {}
         self._pack_count: int = 0  # number of battery packs
         self._pkglen: int = 0  # expected packet length
@@ -73,7 +73,7 @@ class BMS(BaseBMS):
                 "service_uuid": BMS.uuid_services()[0],
                 "connectable": True,
             }
-            for pattern in {f"SP{num}?B*" for num in range(10)} | {"CSY*"}
+            for pattern in {f"SP{num}?B*" for num in range(10)} | {"CSY*"} | {"SP1??B*"}
         ]
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/seplos_v2_bms.py

@@ -36,9 +36,9 @@ class BMS(BaseBMS):
     _GSMD_LEN: Final[int] = _CELL_POS + max((dp.pos + dp.size) for dp in _PFIELDS) + 3
     _CMDS: Final[list[tuple[int, bytes]]] = [(0x51, b""), (0x61, b"\x00"), (0x62, b"")]
 
-    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_len: int = BMS._MIN_LEN
         self._exp_reply: set[int] = set()

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/tdt_bms.py

@@ -41,9 +41,9 @@ class BMS(BaseBMS):
     )  # problem code is not included in the list, but extra
     _CMDS: Final[list[int]] = [*list({field.idx for field in _FIELDS}), 0x8D]
 
-    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._cmd_heads: list[int] = BMS._CMD_HEADS
         self._exp_len: int = 0

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble/bms/tianpwr_bms.py

@@ -37,9 +37,9 @@ class BMS(BaseBMS):
     )
     _CMDS: Final[set[int]] = set({field.idx for field in _FIELDS}) | set({0x87})
 
-    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] = {}
 
     @staticmethod

{aiobmsble-0.2.3 → aiobmsble-0.3.0/aiobmsble.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiobmsble
-Version: 0.2.3
+Version: 0.3.0
 Summary: Asynchronous Python library to query battery management systems via Bluetooth Low Energy.
 Author: Patrick Loschmidt
 Maintainer: Patrick Loschmidt
@@ -18,12 +18,8 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bleak~=1.1.0
+Requires-Dist: bleak>=1.0.1
 Requires-Dist: bleak-retry-connector>=4.0.2
-Requires-Dist: asyncio
-Requires-Dist: logging
-Requires-Dist: statistics
-Requires-Dist: typing
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
@@ -31,7 +27,7 @@ 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; extra == "dev"
+Requires-Dist: ruff~=0.12.1; extra == "dev"
 Dynamic: license-file
 
 [![License][license-shield]](LICENSE)
@@ -55,7 +51,11 @@ from the command line after [installation](#installation). In case you need the
 ### 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 senosr data."""
+"""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
@@ -66,9 +66,9 @@ from bleak.backends.device import BLEDevice
 from bleak.exc import BleakError
 
 from aiobmsble import BMSsample
-from aiobmsble.bms.dummy_bms import BMS  # use the right BMS class for your device
+from aiobmsble.bms.dummy_bms import BMS  # TODO: use the right BMS class for your device
 
-NAME: Final[str] = "BT Device Name"  # Replace with the name of your BLE device
+NAME: Final[str] = "BT Device Name"  # TODO: replace with the name of your BLE device
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -84,11 +84,11 @@ async def main(dev_name) -> None:
         return
 
     logger.info("Found device: %s (%s)", device.name, device.address)
-    bms = BMS(ble_device=device, reconnect=True)
     try:
-        logger.info("Updating BMS data...")
-        data: BMSsample = await bms.async_update()
-        logger.info("BMS data: %s", repr(data).replace(", ", ",\n\t"))
+        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__)
 

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ aiobmsble.egg-info/top_level.txt
 aiobmsble/bms/__init__.py
 aiobmsble/bms/abc_bms.py
 aiobmsble/bms/ant_bms.py
+aiobmsble/bms/ant_leg_bms.py
 aiobmsble/bms/braunpwr_bms.py
 aiobmsble/bms/cbtpwr_bms.py
 aiobmsble/bms/cbtpwr_vb_bms.py

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/aiobmsble.egg-info/requires.txt

@@ -1,9 +1,5 @@
-bleak~=1.1.0
+bleak>=1.0.1
 bleak-retry-connector>=4.0.2
-asyncio
-logging
-statistics
-typing
 
 [dev]
 pytest
@@ -12,4 +8,4 @@ pytest-cov
 pytest-xdist
 hypothesis
 mypy
-ruff
+ruff~=0.12.1

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiobmsble"
-version = "0.2.3"
+version = "0.3.0"
 requires-python = ">=3.12"
 description = "Asynchronous Python library to query battery management systems via Bluetooth Low Energy."
 readme = "README.md"
@@ -27,16 +27,12 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules"
 ]
 dependencies = [
-  "bleak~=1.1.0",
+  "bleak>=1.0.1",
   "bleak-retry-connector>=4.0.2",
-  "asyncio",
-  "logging",
-  "statistics",
-  "typing"
 ]
 
 [project.optional-dependencies]
-dev = ["pytest", "pytest-asyncio", "pytest-cov", "pytest-xdist", "hypothesis", "mypy", "ruff"]
+dev = ["pytest", "pytest-asyncio", "pytest-cov", "pytest-xdist", "hypothesis", "mypy", "ruff~=0.12.1"]
 
 [project.urls]
 Homepage = "https://github.com/patman15/aiobmsble/"
@@ -181,7 +177,7 @@ ignore = [
     "PLR0913", # Too many arguments to function call ({c_args} > {max_args})
 #    "PLR0915", # Too many statements ({statements} > {max_statements})
     "PLR2004", # Magic value used in comparison, consider replacing {value} with a constant variable
-    "PLW1641", # __eq__ without __hash__
+#    "PLW1641", # __eq__ without __hash__
 #    "PLW2901", # Outer {outer_kind} variable {name} overwritten by inner {inner_kind} target
 #    "PT011",   # pytest.raises({exception}) is too broad, set the `match` parameter or use a more specific exception
     "PT018",   # Assertion should be broken down into multiple parts

{aiobmsble-0.2.3 → aiobmsble-0.3.0}/tests/test_basebms.py

@@ -112,10 +112,10 @@ class WMTestBMS(MinTestBMS):
         self,
         char_tx_properties: list[str],
         ble_device: BLEDevice,
-        reconnect: bool = False,
+        keep_alive: bool = True,
     ) -> None:
         """Initialize BMS."""
-        super().__init__(ble_device, reconnect)
+        super().__init__(ble_device, keep_alive)
         self._char_tx_properties: list[str] = char_tx_properties
 
     def _wr_response(self, char: int | str) -> bool:
@@ -198,6 +198,14 @@ def test_calc_battery_level() -> None:
     assert bms_data == ref | {"battery_level": 42.8, "problem": False}
 
 
+def test_calc_cycles() -> None:
+    """Check if missing cycle is correctly calculated."""
+    bms_data: BMSsample = {"total_charge": 1234567, "design_capacity": 256}
+    ref: BMSsample = bms_data.copy()
+    BaseBMS._add_missing_values(bms_data, frozenset({"cycles"}))
+    assert bms_data == ref | {"cycles": 4822, "problem": False}
+
+
 @pytest.mark.parametrize(
     ("problem_sample"),
     [
@@ -328,7 +336,7 @@ async def test_no_notify(
     """Test BMS update without waiting for notification event."""
     patch_bleak_client(MockBleakClient)
 
-    bms: MinTestBMS = MinTestBMS(generate_ble_device(), reconnect=True)
+    bms: MinTestBMS = MinTestBMS(generate_ble_device(), keep_alive=False)
     with caplog.at_level(DEBUG):
         result: BMSsample = await bms.async_update()
     assert "MockBleakClient write_gatt_char afe2, data: b'mock_command'" in caplog.text
@@ -349,7 +357,7 @@ async def test_disconnect_fail(
     monkeypatch.setattr(MockBleakClient, "disconnect", _raise_bleak_error)
     patch_bleak_client(MockBleakClient)
 
-    bms: MinTestBMS = MinTestBMS(generate_ble_device(), reconnect=True)
+    bms: MinTestBMS = MinTestBMS(generate_ble_device(), keep_alive=False)
     with caplog.at_level(DEBUG):
         result: BMSsample = await bms.async_update()
     assert result == {"problem_code": 21}
@@ -375,6 +383,18 @@ async def test_init_connect_fail(
         await bms.async_update()
 
 
+async def test_context_mgr_fail(
+    patch_bleak_client: Callable[..., None],
+) -> None:
+    """Check that context manager enforces `keep_alive=True`."""
+
+    patch_bleak_client(MockBleakClient)
+
+    with pytest.raises(ValueError, match="usage of context manager*"):
+        async with MinTestBMS(generate_ble_device(), keep_alive=False) as bms:
+            await bms.async_update()
+
+
 def test_crc_calculations() -> None:
     """Check if CRC calculations are correct."""
     # Example data for CRC calculation
@@ -487,6 +507,32 @@ def test_cell_voltages(data, cells, start, size, byteorder, divider, expected) -
         (bytearray([0x00, 0x7D]), 0, 0, 2, "big", True, 0, 1, []),
         # Divider = 1, offset = 7
         (bytearray([0x00, 0x14]), 1, 0, 2, "big", True, 7, 1, [13]),
+        # no offset, div = 10
+        (
+            bytearray(b"\x65\x64\x00\x40"),
+            4,
+            0,
+            1,
+            "big",
+            True,
+            0,
+            10,
+            [10.1, 10.0, 0.0, 6.4],
+        ),
+        # offset -40, div = 10
+        (
+            bytearray(b"\x65\x64\x00\x40"),
+            4,
+            0,
+            1,
+            "big",
+            True,
+            40,
+            10,
+            [6.1, 6.0, 2.4],
+        ),
+        # offset -25, div = 1
+        (bytearray(b"\x65\x64\x00\x40"), 4, 0, 1, "big", True, 25, 1, [76, 75, 39]),
     ],
     ids=[
         "two_signed_big_endian",
@@ -496,6 +542,9 @@ def test_cell_voltages(data, cells, start, size, byteorder, divider, expected) -
         "not_enough_data",
         "zero_values",
         "divider1_offset10",
+        "no offset",
+        "offset-40",
+        "div-1",
     ],
 )
 def test_temp_values(