aiobmsble 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/__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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info → aiobmsble-0.3.0.dist-info}/METADATA

@@ -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.3.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+aiobmsble/__init__.py,sha256=7Qg39LPp9W98ymZX67uOZzbPspJ4JuSUenSxLm12jlo,3119
+aiobmsble/__main__.py,sha256=1r0MZLjx3lxJ6dw8pLha4tdUPvUcgU0hzXa50N3w3ks,3157
+aiobmsble/basebms.py,sha256=p18gHcy7rL_NEiZZEFwF0z5b6nZH9fd1zKGJpcyK5LA,19818
+aiobmsble/utils.py,sha256=ckcOXMLTpm4oCxbGKco88cPVP4nOgiTJ16ebFlvsj_E,5805
+aiobmsble/bms/__init__.py,sha256=ZE4Uezyd5fs3os4_bt6Pnzsfrp38LTXItdvJ9-zBiR0,165
+aiobmsble/bms/abc_bms.py,sha256=ug4AeTHiOcMWB4MVTjKI69mbq1wk-J89BbIE2-LeH-w,5993
+aiobmsble/bms/ant_bms.py,sha256=3kNX0Oy7EDxlb1pynARnttTi-QnzSsFovR5MgrveUOo,7236
+aiobmsble/bms/ant_leg_bms.py,sha256=Cz0mi3P7_TaKDodZjGs0dcBq0Mjdk8YhwSfs--ijyMQ,5711
+aiobmsble/bms/braunpwr_bms.py,sha256=fINnmqN3jxZPcKXPcjGPkptU65xxTtuIrilkWlKaWeI,5977
+aiobmsble/bms/cbtpwr_bms.py,sha256=r2EGxFhGJCQvn8iRa1SJY-7xey64Q6MhaKKTfsgo_T0,6277
+aiobmsble/bms/cbtpwr_vb_bms.py,sha256=hivPpOXCc946RH4Z8kQXEC9GkFUTtxJC2KSaIjAvBd0,6626
+aiobmsble/bms/daly_bms.py,sha256=XVz5_sOBBPhBWqlq6PLOXpwglPa1YCfMqOBOT2cQpss,5850
+aiobmsble/bms/dpwrcore_bms.py,sha256=ATUw4bnXPgm7TvAA2ej7H0GKkDMhWfDUqi9CrLE1mps,6666
+aiobmsble/bms/dummy_bms.py,sha256=gso6-0Bs5veVJfp6XNjZiigVAr6JAb_o9hFu-zlsURw,3503
+aiobmsble/bms/ecoworthy_bms.py,sha256=-Y6TEktbTwcIfCUEfAQkRIdqxPH0B93-Fhhm93oeGKk,5410
+aiobmsble/bms/ective_bms.py,sha256=GGcZgqC8BB7v0xm_st7wGvGNmayxCBYq-rhOrevaMzg,5851
+aiobmsble/bms/ej_bms.py,sha256=8AiS26r2_uapXMLI34d-eECh5wKXOHhD2eRIeKhApLQ,8174
+aiobmsble/bms/felicity_bms.py,sha256=oDXlJzYlZF5TtXVC1VYfMybzti1yEKjzGETop12vGYk,4738
+aiobmsble/bms/jbd_bms.py,sha256=wy1EAjxZZkDps9Y5H7cGTgaV8dYz_3n1iQUxP-ImqA4,7167
+aiobmsble/bms/jikong_bms.py,sha256=DOxYo2FwVZOdGtaxRwL3HzffuX0_z3pYZrsckia18Ik,11153
+aiobmsble/bms/neey_bms.py,sha256=dTdyThI2MMNVfEQ2ArPbY5bDkKMGn6NSfz2G68qYZ6Q,7666
+aiobmsble/bms/ogt_bms.py,sha256=gIEt1h1e0ZXESgmL_VwzH34FiyH0pvIfGwjpc3hgIZ0,7988
+aiobmsble/bms/pro_bms.py,sha256=TyAbjZBYaWOLtZ4rWWVWHag8o6x-roeujWobMlnb14A,5079
+aiobmsble/bms/redodo_bms.py,sha256=p6lvJ9fzJS-CkjaB7dSz3_j9-a5Ls3ul1jGBI0p6Ezk,4484
+aiobmsble/bms/renogy_bms.py,sha256=q_SO0LvW0MLtdNvretnactt4UoYnq5Zje3iDrRAum9k,5080
+aiobmsble/bms/renogy_pro_bms.py,sha256=EsPlnrtdn7F4o-LRIIwTnVLIkvm4yfc5uEpeJlG3bCU,3969
+aiobmsble/bms/roypow_bms.py,sha256=ZNuHrMYxQLIGJuao1-DR7pNE2tH6OVGpMaZZxHl2o9I,6169
+aiobmsble/bms/seplos_bms.py,sha256=R4A77uwjy5XDbbPNwzfqOZxaQfIvGs-Vnd-0Ch0zw-s,9532
+aiobmsble/bms/seplos_v2_bms.py,sha256=un6vvMwWXnFzAUgOnHYg69Jokd9MH-9MjqELOQD6Uok,7494
+aiobmsble/bms/tdt_bms.py,sha256=ksGPwTAcn4WDrjSh8a0OzokDhWqrOcixLU3XfndfPyI,7033
+aiobmsble/bms/tianpwr_bms.py,sha256=2EdaCnY4_PxfRUUrU1hQgwvst5fHDz6yvGS7FU_zYxs,4947
+aiobmsble-0.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+aiobmsble-0.3.0.dist-info/METADATA,sha256=Qba-JrJA3Pl0oXx8agKIsc_jq7BuM-d4jetgvtPpDoE,4755
+aiobmsble-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiobmsble-0.3.0.dist-info/entry_points.txt,sha256=HSC_C3nQikc3nk0a6mcG92RuIM7wAzozjBVfDojJceo,54
+aiobmsble-0.3.0.dist-info/top_level.txt,sha256=YHBVzg45mJ3vPz0sl_TpMB0edMqqhD61kwJj4EPAk9g,10
+aiobmsble-0.3.0.dist-info/RECORD,,

aiobmsble-0.2.3.dist-info/RECORD

@@ -1,36 +0,0 @@
-aiobmsble/__init__.py,sha256=zIqeiJBneqIUo61GIeqHh0gt9itp19OierNrMLEw25Y,3049
-aiobmsble/__main__.py,sha256=swsFTPO4Cz8fsFwfGfjCv0M6EI9g8VDhC-5HaCo-spI,3113
-aiobmsble/basebms.py,sha256=pPhzj6pJUFtVnbHR5bauRi4BpuWJwQ9GXFueEDCVIZw,18813
-aiobmsble/utils.py,sha256=ckcOXMLTpm4oCxbGKco88cPVP4nOgiTJ16ebFlvsj_E,5805
-aiobmsble/bms/__init__.py,sha256=ZE4Uezyd5fs3os4_bt6Pnzsfrp38LTXItdvJ9-zBiR0,165
-aiobmsble/bms/abc_bms.py,sha256=wud4DTj5Cbo9CjsQ96Tn12CXOSoozvKTIa9pWGpEo1s,5992
-aiobmsble/bms/ant_bms.py,sha256=3YY3Nod6KhylBqYFo2vDgy76MpdYtKbckzDC0SDoEZM,7159
-aiobmsble/bms/braunpwr_bms.py,sha256=_Fl9yQQtzmQyveCQNso6ahX0O1PHxrf5LL4Ef7k5GHg,5976
-aiobmsble/bms/cbtpwr_bms.py,sha256=p4bS3oyVirUFC2-2nbF2EfCrShx8ynpjXEkLPdC0llA,6276
-aiobmsble/bms/cbtpwr_vb_bms.py,sha256=AJhesOKX2yzrsfXQcXufG9E7iX2YJMo-syLKwSMeMLw,6625
-aiobmsble/bms/daly_bms.py,sha256=Ql7Ajv06OSp0m_16vcUy9y_W1JeLOPFWChghD0xr59U,5849
-aiobmsble/bms/dpwrcore_bms.py,sha256=6o4cKtEs8_Fic_se7W32BXlP9K5d3T4_CHiNnnFnMHo,6665
-aiobmsble/bms/dummy_bms.py,sha256=1OvcZByFAPtHhz53JyAaDVZ02a1JkCissTRHQKcYyog,3504
-aiobmsble/bms/ecoworthy_bms.py,sha256=VL3pbU1AtrNBwAIlhjinTiy86Lu8ITvwe55A66GXwGU,5409
-aiobmsble/bms/ective_bms.py,sha256=jvkXaJe0_MvHeV8BiDg7oxCzT_z0WvBvuxybzbbY8Sk,5850
-aiobmsble/bms/ej_bms.py,sha256=B8KWs0Py91TrvvxLKIIwgQ5ppkeQtq8tsQ024jQCeKA,8028
-aiobmsble/bms/felicity_bms.py,sha256=RPTvmnDuedErIiVKdsUR-w8zhF7_IOj_gmk7A2VIHTo,4737
-aiobmsble/bms/jbd_bms.py,sha256=eWXbKIgWEDlj18TWho5Q2K3YfLyhCJVJOgC6tc5VfxU,7166
-aiobmsble/bms/jikong_bms.py,sha256=vl5XQx5-ksYMUaopHdd8Pzw_Rw88zF_0I8m23TPD6BE,11152
-aiobmsble/bms/neey_bms.py,sha256=DsIqt2MP9E6lJACw0wDlkx0gMyIPpCwMvIGLz36Otbc,7665
-aiobmsble/bms/ogt_bms.py,sha256=t1mxa0l2umlH7p3AKSHclieqQGHRYtgt_iFMVQ7ry8U,7987
-aiobmsble/bms/pro_bms.py,sha256=PwP6OeXOj6W3Svu80LOgvqnFaUSdGIm6uTO5If2VhKk,5078
-aiobmsble/bms/redodo_bms.py,sha256=EVFWurOvkCuHplHjn7NTqaY-0TmbRBUtFDjrBXqvUcM,4369
-aiobmsble/bms/renogy_bms.py,sha256=Pju6kZea0G1uGNONcxQymJ_TW6rk02ovGgIn1-dE_68,5079
-aiobmsble/bms/renogy_pro_bms.py,sha256=PO7Q0NaPAf9vzU24PvVubxk7k64L241rQESrk26ul4c,3968
-aiobmsble/bms/roypow_bms.py,sha256=l9oJvTPcvS54DDjgeu8Wn74nvwYaEbaK5F4JHGAt_RE,6168
-aiobmsble/bms/seplos_bms.py,sha256=mgNcYy1E9KMyE-J8jk8mxF2RZ1D3AZtMYNePVq3d0bs,9517
-aiobmsble/bms/seplos_v2_bms.py,sha256=nmzOLHqcaxDnZBCb1i_E1qdF7NN8K10-FAGnnIfjtjA,7493
-aiobmsble/bms/tdt_bms.py,sha256=9mFrjmkNo6YY_7klfvJi1_qq8J53o_Ivep9bPO2El3A,7032
-aiobmsble/bms/tianpwr_bms.py,sha256=U_du6TzYj_SXZ_f_DHVYVCDhku5hwWWdkkITtJJLNX8,4946
-aiobmsble-0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-aiobmsble-0.2.3.dist-info/METADATA,sha256=uT1jajia9dsgQWZzlbuNmBr-N1zS8AoL_VLEKUNBhZg,4711
-aiobmsble-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiobmsble-0.2.3.dist-info/entry_points.txt,sha256=HSC_C3nQikc3nk0a6mcG92RuIM7wAzozjBVfDojJceo,54
-aiobmsble-0.2.3.dist-info/top_level.txt,sha256=YHBVzg45mJ3vPz0sl_TpMB0edMqqhD61kwJj4EPAk9g,10
-aiobmsble-0.2.3.dist-info/RECORD,,