aiobmsble 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

aiobmsble/bms/seplos_v2_bms.py

@@ -0,0 +1,209 @@
+"""Module to support Seplos v2 BMS.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
+
+from typing import Final
+
+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_xmodem
+
+
+class BMS(BaseBMS):
+    """Seplos v2 BMS implementation."""
+
+    _HEAD: Final[bytes] = b"\x7e"
+    _TAIL: Final[bytes] = b"\x0d"
+    _CMD_VER: Final[int] = 0x10  # TX protocol version
+    _RSP_VER: Final[int] = 0x14  # RX protocol version
+    _MIN_LEN: Final[int] = 10
+    _MAX_SUBS: Final[int] = 0xF
+    _CELL_POS: Final[int] = 9
+    _PRB_MAX: Final[int] = 8  # max number of alarm event bytes
+    _PRB_MASK: Final[int] = ~0x82FFFF  # ignore byte 7-8 + byte 6 (bit 7,2)
+    _PFIELDS: Final[tuple[BMSdp, ...]] = (  # Seplos V2: single machine data
+        BMSdp("voltage", 2, 2, False, lambda x: x / 100),
+        BMSdp("current", 0, 2, True, lambda x: x / 100),  # /10 for 0x62
+        BMSdp("cycle_charge", 4, 2, False, lambda x: x / 100),  # /10 for 0x62
+        BMSdp("cycles", 13, 2, False, lambda x: x),
+        BMSdp("battery_level", 9, 2, False, lambda x: x / 10),
+    )
+    _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:
+        """Initialize BMS."""
+        super().__init__(ble_device, reconnect)
+        self._data_final: dict[int, bytearray] = {}
+        self._exp_len: int = BMS._MIN_LEN
+        self._exp_reply: set[int] = set()
+
+    @staticmethod
+    def matcher_dict_list() -> list[MatcherPattern]:
+        """Provide BluetoothMatcher definition."""
+        return [
+            {
+                "local_name": pattern,
+                "service_uuid": BMS.uuid_services()[0],
+                "connectable": True,
+            }
+            for pattern in ("BP0?", "BP1?", "BP2?")
+        ]
+
+    @staticmethod
+    def device_info() -> dict[str, str]:
+        """Return device information for the battery management system."""
+        return {"manufacturer": "Seplos", "model": "Smart BMS V2"}
+
+    @staticmethod
+    def uuid_services() -> list[str]:
+        """Return list of 128-bit UUIDs of services required by BMS."""
+        return [normalize_uuid_str("ff00")]
+
+    @staticmethod
+    def uuid_rx() -> str:
+        """Return 16-bit UUID of characteristic that provides notification/read property."""
+        return "ff01"
+
+    @staticmethod
+    def uuid_tx() -> str:
+        """Return 16-bit UUID of characteristic that provides write property."""
+        return "ff02"
+
+    @staticmethod
+    def _calc_values() -> frozenset[BMSvalue]:
+        return frozenset(
+            {
+                "battery_charging",
+                "cycle_capacity",
+                "delta_voltage",
+                "power",
+                "runtime",
+                "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)."""
+        if (
+            len(data) > BMS._MIN_LEN
+            and data.startswith(BMS._HEAD)
+            and len(self._data) >= self._exp_len
+        ):
+            self._exp_len = BMS._MIN_LEN + int.from_bytes(data[5:7])
+            self._data = bytearray()
+
+        self._data += data
+        self._log.debug(
+            "RX BLE data (%s): %s", "start" if data == self._data else "cnt.", data
+        )
+
+        # verify that data is long enough
+        if len(self._data) < self._exp_len:
+            return
+
+        if not self._data.endswith(BMS._TAIL):
+            self._log.debug("incorrect frame end: %s", self._data)
+            return
+
+        if self._data[1] != BMS._RSP_VER:
+            self._log.debug("unknown frame version: V%.1f", self._data[1] / 10)
+            return
+
+        if self._data[4]:
+            self._log.debug("BMS reported error code: 0x%X", self._data[4])
+            return
+
+        if (crc := crc_xmodem(self._data[1:-3])) != int.from_bytes(self._data[-3:-1]):
+            self._log.debug(
+                "invalid checksum 0x%X != 0x%X",
+                crc,
+                int.from_bytes(self._data[-3:-1]),
+            )
+            return
+
+        self._log.debug(
+            "address: 0x%X, function: 0x%X, return: 0x%X",
+            self._data[2],
+            self._data[3],
+            self._data[4],
+        )
+
+        self._data_final[self._data[3]] = self._data
+        try:
+            self._exp_reply.remove(self._data[3])
+            self._data_event.set()
+        except KeyError:
+            self._log.debug("unexpected reply: 0x%X", self._data[3])
+
+    async def _init_connection(
+        self, char_notify: BleakGATTCharacteristic | int | str | None = None
+    ) -> None:
+        """Initialize protocol state."""
+        await super()._init_connection()
+        self._exp_len = BMS._MIN_LEN
+
+    @staticmethod
+    def _cmd(cmd: int, address: int = 0, data: bytearray = bytearray()) -> bytes:
+        """Assemble a Seplos V2 BMS command."""
+        assert cmd in (0x47, 0x51, 0x61, 0x62, 0x04)  # allow only read commands
+        frame = bytearray([*BMS._HEAD, BMS._CMD_VER, address, 0x46, cmd])
+        frame += len(data).to_bytes(2, "big", signed=False) + data
+        frame += int.to_bytes(crc_xmodem(frame[1:]), 2, byteorder="big") + BMS._TAIL
+        return bytes(frame)
+
+    async def _async_update(self) -> BMSsample:
+        """Update battery status information."""
+
+        for cmd, data in BMS._CMDS:
+            self._exp_reply.add(cmd)
+            await self._await_reply(BMS._cmd(cmd, data=bytearray(data)))
+
+        result: BMSsample = {}
+        result["cell_count"] = self._data_final[0x61][BMS._CELL_POS]
+        result["temp_sensors"] = self._data_final[0x61][
+            BMS._CELL_POS + result["cell_count"] * 2 + 1
+        ]
+        ct_blk_len: Final[int] = (result["cell_count"] + result["temp_sensors"]) * 2 + 2
+
+        if (BMS._GSMD_LEN + ct_blk_len) > len(self._data_final[0x61]):
+            raise ValueError("message too short to decode data")
+
+        result |= BMS._decode_data(
+            BMS._PFIELDS, self._data_final[0x61], offset=BMS._CELL_POS + ct_blk_len
+        )
+
+        # get extention pack count from parallel data (main pack)
+        result["pack_count"] = self._data_final[0x51][42]
+
+        # get alarms from parallel data (main pack)
+        alarm_evt: Final[int] = min(self._data_final[0x62][46], BMS._PRB_MAX)
+        result["problem_code"] = (
+            int.from_bytes(self._data_final[0x62][47 : 47 + alarm_evt], byteorder="big")
+            & BMS._PRB_MASK
+        )
+
+        result["cell_voltages"] = BMS._cell_voltages(
+            self._data_final[0x61],
+            cells=self._data_final[0x61][BMS._CELL_POS],
+            start=10,
+        )
+        result["temp_values"] = BMS._temp_values(
+            self._data_final[0x61],
+            values=result["temp_sensors"],
+            start=BMS._CELL_POS + result.get("cell_count", 0) * 2 + 2,
+            signed=False,
+            offset=2731,
+            divider=10,
+        )
+
+        self._data_final.clear()
+
+        return result

aiobmsble/bms/tdt_bms.py

@@ -0,0 +1,203 @@
+"""Module to support TDT BMS.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
+
+from typing import Final
+
+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_modbus
+
+
+class BMS(BaseBMS):
+    """TDT BMS implementation."""
+
+    _UUID_CFG: Final[str] = "fffa"
+    _HEAD: Final[int] = 0x7E
+    _CMD_HEADS: list[int] = [0x7E, 0x1E]  # alternative command head
+    _TAIL: Final[int] = 0x0D
+    _CMD_VER: Final[int] = 0x00
+    _RSP_VER: Final[frozenset[int]] = frozenset({0x00, 0x04})
+    _CELL_POS: Final[int] = 0x8
+    _INFO_LEN: Final[int] = 10  # minimal frame length
+    _FIELDS: Final[tuple[BMSdp, ...]] = (
+        BMSdp("voltage", 2, 2, False, lambda x: x / 100, 0x8C),
+        BMSdp(
+            "current",
+            0,
+            2,
+            False,
+            lambda x: (x & 0x3FFF) / 10 * (-1 if x >> 15 else 1),
+            0x8C,
+        ),
+        BMSdp("cycle_charge", 4, 2, False, lambda x: x / 10, 0x8C),
+        BMSdp("battery_level", 13, 1, False, lambda x: x, 0x8C),
+        BMSdp("cycles", 8, 2, False, lambda x: x, 0x8C),
+    )  # 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:
+        """Initialize BMS."""
+        super().__init__(ble_device, reconnect)
+        self._data_final: dict[int, bytearray] = {}
+        self._cmd_heads: list[int] = BMS._CMD_HEADS
+        self._exp_len: int = 0
+
+    @staticmethod
+    def matcher_dict_list() -> list[MatcherPattern]:
+        """Provide BluetoothMatcher definition."""
+        return [{"manufacturer_id": 54976, "connectable": True}]
+
+    @staticmethod
+    def device_info() -> dict[str, str]:
+        """Return device information for the battery management system."""
+        return {"manufacturer": "TDT", "model": "Smart BMS"}
+
+    @staticmethod
+    def uuid_services() -> list[str]:
+        """Return list of 128-bit UUIDs of services required by BMS."""
+        return [normalize_uuid_str("fff0")]
+
+    @staticmethod
+    def uuid_rx() -> str:
+        """Return 16-bit UUID of characteristic that provides notification/read property."""
+        return "fff1"
+
+    @staticmethod
+    def uuid_tx() -> str:
+        """Return 16-bit UUID of characteristic that provides write property."""
+        return "fff2"
+
+    @staticmethod
+    def _calc_values() -> frozenset[BMSvalue]:
+        return frozenset(
+            {
+                "battery_charging",
+                "cycle_capacity",
+                "delta_voltage",
+                "power",
+                "runtime",
+                "temperature",
+            }
+        )  # calculate further values from BMS provided set ones
+
+    async def _init_connection(
+        self, char_notify: BleakGATTCharacteristic | int | str | None = None
+    ) -> None:
+        await self._await_reply(
+            data=b"HiLink", char=BMS._UUID_CFG, wait_for_notify=False
+        )
+        if (
+            ret := int.from_bytes(await self._client.read_gatt_char(BMS._UUID_CFG))
+        ) != 0x1:
+            self._log.debug("error unlocking BMS: %X", ret)
+
+        await super()._init_connection()
+
+    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 (
+            len(data) > BMS._INFO_LEN
+            and data[0] == BMS._HEAD
+            and len(self._data) >= self._exp_len
+        ):
+            self._exp_len = BMS._INFO_LEN + int.from_bytes(data[6:8])
+            self._data = bytearray()
+
+        self._data += data
+        self._log.debug(
+            "RX BLE data (%s): %s", "start" if data == self._data else "cnt.", data
+        )
+
+        # verify that data is long enough
+        if len(self._data) < max(BMS._INFO_LEN, self._exp_len):
+            return
+
+        if self._data[-1] != BMS._TAIL:
+            self._log.debug("frame end incorrect: %s", self._data)
+            return
+
+        if self._data[1] not in BMS._RSP_VER:
+            self._log.debug("unknown frame version: V%.1f", self._data[1] / 10)
+            return
+
+        if self._data[4]:
+            self._log.debug("BMS reported error code: 0x%X", self._data[4])
+            return
+
+        if (crc := crc_modbus(self._data[:-3])) != int.from_bytes(
+            self._data[-3:-1], "big"
+        ):
+            self._log.debug(
+                "invalid checksum 0x%X != 0x%X",
+                int.from_bytes(self._data[-3:-1], "big"),
+                crc,
+            )
+            return
+        self._data_final[self._data[5]] = self._data
+        self._data_event.set()
+
+    @staticmethod
+    def _cmd(cmd: int, data: bytearray = bytearray(), cmd_head: int = _HEAD) -> bytes:
+        """Assemble a TDT BMS command."""
+        assert cmd in (0x8C, 0x8D, 0x92)  # allow only read commands
+
+        frame = bytearray([cmd_head, BMS._CMD_VER, 0x1, 0x3, 0x0, cmd])
+        frame += len(data).to_bytes(2, "big", signed=False) + data
+        frame += crc_modbus(frame).to_bytes(2, "big") + bytes([BMS._TAIL])
+
+        return bytes(frame)
+
+    async def _async_update(self) -> BMSsample:
+        """Update battery status information."""
+
+        for head in self._cmd_heads:
+            try:
+                for cmd in BMS._CMDS:
+                    await self._await_reply(BMS._cmd(cmd, cmd_head=head))
+                self._cmd_heads = [head]  # set to single head for further commands
+                break
+            except TimeoutError:
+                ...  # try next command head
+        else:
+            raise TimeoutError
+
+        result: BMSsample = {"cell_count": self._data_final[0x8C][BMS._CELL_POS]}
+        result["temp_sensors"] = self._data_final[0x8C][
+            BMS._CELL_POS + result["cell_count"] * 2 + 1
+        ]
+
+        result["cell_voltages"] = BMS._cell_voltages(
+            self._data_final[0x8C],
+            cells=result.get("cell_count", 0),
+            start=BMS._CELL_POS + 1,
+        )
+        result["temp_values"] = BMS._temp_values(
+            self._data_final[0x8C],
+            values=result["temp_sensors"],
+            start=BMS._CELL_POS + result.get("cell_count", 0) * 2 + 2,
+            signed=False,
+            offset=2731,
+            divider=10,
+        )
+        idx: Final[int] = result.get("cell_count", 0) + result.get("temp_sensors", 0)
+
+        result |= BMS._decode_data(
+            BMS._FIELDS, self._data_final, offset=BMS._CELL_POS + idx * 2 + 2
+        )
+        result["problem_code"] = int.from_bytes(
+            self._data_final[0x8D][BMS._CELL_POS + idx + 6 : BMS._CELL_POS + idx + 8]
+        )
+
+        self._data_final.clear()
+
+        return result

aiobmsble/bms/tianpwr_bms.py

@@ -0,0 +1,142 @@
+"""Module to support TianPwr BMS.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
+
+from typing import Final
+
+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
+
+
+class BMS(BaseBMS):
+    """TianPwr BMS implementation."""
+
+    _HEAD: Final[bytes] = b"\x55"
+    _TAIL: Final[bytes] = b"\xaa"
+    _RDCMD: Final[bytes] = b"\x04"
+    _MAX_CELLS: Final[int] = 16
+    _MAX_TEMP: Final[int] = 6
+    _MIN_LEN: Final[int] = 4
+    _DEF_LEN: Final[int] = 20
+    _FIELDS: Final[tuple[BMSdp, ...]] = (
+        BMSdp("battery_level", 3, 2, False, lambda x: x, 0x83),
+        BMSdp("voltage", 5, 2, False, lambda x: x / 100, 0x83),
+        BMSdp("current", 13, 2, True, lambda x: x / 100, 0x83),
+        BMSdp("problem_code", 11, 8, False, lambda x: x, 0x84),
+        BMSdp("cell_count", 3, 1, False, lambda x: x, 0x84),
+        BMSdp("temp_sensors", 4, 1, False, lambda x: x, 0x84),
+        BMSdp("design_capacity", 5, 2, False, lambda x: x // 100, 0x84),
+        BMSdp("cycle_charge", 7, 2, False, lambda x: x / 100, 0x84),
+        BMSdp("cycles", 9, 2, False, lambda x: x, 0x84),
+    )
+    _CMDS: Final[set[int]] = set({field.idx for field in _FIELDS}) | set({0x87})
+
+    def __init__(self, ble_device: BLEDevice, reconnect: bool = False) -> None:
+        """Initialize BMS."""
+        super().__init__(ble_device, reconnect)
+        self._data_final: dict[int, bytearray] = {}
+
+    @staticmethod
+    def matcher_dict_list() -> list[MatcherPattern]:
+        """Provide BluetoothMatcher definition."""
+        return [{"local_name": "TP_*", "connectable": True}]
+
+    @staticmethod
+    def device_info() -> dict[str, str]:
+        """Return device information for the battery management system."""
+        return {"manufacturer": "TianPwr", "model": "SmartBMS"}
+
+    @staticmethod
+    def uuid_services() -> list[str]:
+        """Return list of 128-bit UUIDs of services required by BMS."""
+        return [normalize_uuid_str("ff00")]
+
+    @staticmethod
+    def uuid_rx() -> str:
+        """Return 16-bit UUID of characteristic that provides notification/read property."""
+        return "ff01"
+
+    @staticmethod
+    def uuid_tx() -> str:
+        """Return 16-bit UUID of characteristic that provides write property."""
+        return "ff02"
+
+    @staticmethod
+    def _calc_values() -> frozenset[BMSvalue]:
+        return frozenset(
+            {
+                "battery_charging",
+                "cycle_capacity",
+                "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)
+
+        # verify that data is long enough
+        if len(data) != BMS._DEF_LEN:
+            self._log.debug("incorrect frame length")
+            return
+
+        if not data.startswith(BMS._HEAD):
+            self._log.debug("incorrect SOF.")
+            return
+
+        if not data.endswith(BMS._TAIL):
+            self._log.debug("incorrect EOF.")
+            return
+
+        self._data_final[data[2]] = data.copy()
+        self._data_event.set()
+
+    @staticmethod
+    def _cmd(addr: int) -> bytes:
+        """Assemble a TianPwr BMS command."""
+        return BMS._HEAD + BMS._RDCMD + addr.to_bytes(1) + BMS._TAIL
+
+    async def _async_update(self) -> BMSsample:
+        """Update battery status information."""
+
+        self._data_final.clear()
+        for cmd in BMS._CMDS:
+            await self._await_reply(BMS._cmd(cmd))
+
+        result: BMSsample = BMS._decode_data(BMS._FIELDS, self._data_final)
+
+        for cmd in range(
+            0x88, 0x89 + min(result.get("cell_count", 0), BMS._MAX_CELLS) // 8
+        ):
+            await self._await_reply(BMS._cmd(cmd))
+            result["cell_voltages"] = result.setdefault(
+                "cell_voltages", []
+            ) + BMS._cell_voltages(
+                self._data_final.get(cmd, bytearray()), cells=8, start=3
+            )
+
+        if {0x83, 0x87}.issubset(self._data_final):
+            result["temp_values"] = [
+                int.from_bytes(
+                    self._data_final[0x83][idx : idx + 2], byteorder="big", signed=True
+                )
+                / 10
+                for idx in (7, 11)  # take ambient and mosfet temperature
+            ] + BMS._temp_values(
+                self._data_final.get(0x87, bytearray()),
+                values=min(BMS._MAX_TEMP, result.get("temp_sensors", 0)),
+                start=3,
+                divider=10,
+            )
+
+        return result

aiobmsble/utils.py

@@ -1,4 +1,8 @@
-"""Utilitiy/Support functions for aiobmsble."""
+"""Utilitiy/Support functions for aiobmsble.
+
+Project: aiobmsble, https://pypi.org/p/aiobmsble/
+License: Apache-2.0, http://www.apache.org/licenses/
+"""
 
 from fnmatch import translate
 from functools import lru_cache
@@ -6,11 +10,15 @@ import importlib
 import pkgutil
 import re
 from types import ModuleType
+from typing import Final
 
 from bleak.backends.scanner import AdvertisementData
 
 from aiobmsble import MatcherPattern
 from aiobmsble.basebms import BaseBMS
+import aiobmsble.bms
+
+_MODULE_POSTFIX: Final[str] = "_bms"
 
 
 def _advertisement_matches(
@@ -20,7 +28,7 @@ def _advertisement_matches(
     """Determine whether the given advertisement data matches the specified pattern.
 
     Args:
-        matcher (AdvertisementPattern): A dictionary containing the matching criteria.
+        matcher (MatcherPattern): A dictionary containing the matching criteria.
             Possible keys include:
             - "service_uuid" (str): A specific service 128-bit UUID to match.
             - "service_data_uuid" (str): A specific service data UUID to match.
@@ -78,8 +86,8 @@ def load_bms_plugins() -> set[ModuleType]:
     """
     return {
         importlib.import_module(f"aiobmsble.bms.{module_name}")
-        for _, module_name, _ in pkgutil.iter_modules(["aiobmsble/bms"])
-        if module_name.endswith("_bms")
+        for _, module_name, _ in pkgutil.iter_modules(aiobmsble.bms.__path__)
+        if module_name.endswith(_MODULE_POSTFIX)
     }
 
 
@@ -87,14 +95,16 @@ def bms_cls(name: str) -> type[BaseBMS] | None:
     """Return the BMS class that is defined by the name argument.
 
     Args:
-        name (str): The name of the BMS type
+        name (str): The name of the BMS type (filename of the module)
 
     Returns:
         type[BaseBMS] | None: If the BMS class defined by name is found, None otherwise.
 
     """
+    if not name.endswith(_MODULE_POSTFIX):
+        return None
     try:
-        bms_module: ModuleType = importlib.import_module(f"aiobmsble.bms.{name}_bms")
+        bms_module: ModuleType = importlib.import_module(f"aiobmsble.bms.{name}")
     except ModuleNotFoundError:
         return None
     return bms_module.BMS

{aiobmsble-0.2.0.dist-info → aiobmsble-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiobmsble
-Version: 0.2.0
+Version: 0.2.2
 Summary: Asynchronous Python library to query battery management systems via Bluetooth Low Energy.
 Author: Patrick Loschmidt
 Maintainer: Patrick Loschmidt
@@ -19,7 +19,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: bleak~=1.1.0
-Requires-Dist: bleak-retry-connector~=4.0.1
+Requires-Dist: bleak-retry-connector~=4.0.2
 Requires-Dist: asyncio
 Requires-Dist: logging
 Requires-Dist: statistics
@@ -29,6 +29,7 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Dynamic: license-file

aiobmsble-0.2.2.dist-info/RECORD

@@ -0,0 +1,36 @@
+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.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+aiobmsble-0.2.2.dist-info/METADATA,sha256=z4IqdTDc5FUFlbuYNltEDWTkm9zXS4EN59ELJf-NPu8,4711
+aiobmsble-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiobmsble-0.2.2.dist-info/entry_points.txt,sha256=HSC_C3nQikc3nk0a6mcG92RuIM7wAzozjBVfDojJceo,54
+aiobmsble-0.2.2.dist-info/top_level.txt,sha256=YHBVzg45mJ3vPz0sl_TpMB0edMqqhD61kwJj4EPAk9g,10
+aiobmsble-0.2.2.dist-info/RECORD,,