aiobmsble 0.2.3__py3-none-any.whl → 0.4__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

@@ -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/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/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