bluetti-bt-lib 0.0.1__tar.gz

bluetti_bt_lib-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Patrick762
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bluetti_bt_lib-0.0.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: bluetti-bt-lib
+Version: 0.0.1
+Summary: Bluetti BT
+Home-page: https://github.com/Patrick762/bluetti-bt-lib
+Author: Patrick762
+Author-email: <pip-bluetti-bt-lib@hosting-rt.de>
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: async_timeout
+Requires-Dist: asyncio
+Requires-Dist: bleak
+Requires-Dist: crcmod
+Requires-Dist: cryptography
+Requires-Dist: logging
+Requires-Dist: pyasn1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# bluetti-bt-lib
+Inofficial Library for basic communication to bluetti powerstations.
+
+## Disclaimer
+This library is provided without any warranty or support by Bluetti. I do not take responsibility for any problems it may cause in all cases. Use it at your own risk.
+
+## Installation
+
+```bash
+git clone https://github.com/Patrick762/bluetti-bt-lib.git
+pip install .
+```
+
+## Run
+
+```bash
+bluetti
+```
+
+## Supported Powerstations and data
+
+|Device Name|total_battery_percent|dc_input_power|ac_input_power|dc_output_power|ac_output_power|
+|-----------|---------------------|--------------|--------------|---------------|---------------|
+|AC70       |✅                   |✅            |✅            |✅             |✅             |
+|AC180      |✅                   |✅            |✅            |✅             |✅             |
+|EB3A       |✅                   |✅            |✅            |✅             |✅             |
+|Handsfree 1|✅                   |✅            |✅            |✅             |✅             |

bluetti_bt_lib-0.0.1/README.md

@@ -0,0 +1,27 @@
+# bluetti-bt-lib
+Inofficial Library for basic communication to bluetti powerstations.
+
+## Disclaimer
+This library is provided without any warranty or support by Bluetti. I do not take responsibility for any problems it may cause in all cases. Use it at your own risk.
+
+## Installation
+
+```bash
+git clone https://github.com/Patrick762/bluetti-bt-lib.git
+pip install .
+```
+
+## Run
+
+```bash
+bluetti
+```
+
+## Supported Powerstations and data
+
+|Device Name|total_battery_percent|dc_input_power|ac_input_power|dc_output_power|ac_output_power|
+|-----------|---------------------|--------------|--------------|---------------|---------------|
+|AC70       |✅                   |✅            |✅            |✅             |✅             |
+|AC180      |✅                   |✅            |✅            |✅             |✅             |
+|EB3A       |✅                   |✅            |✅            |✅             |✅             |
+|Handsfree 1|✅                   |✅            |✅            |✅             |✅             |

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: bluetti-bt-lib
+Version: 0.0.1
+Summary: Bluetti BT
+Home-page: https://github.com/Patrick762/bluetti-bt-lib
+Author: Patrick762
+Author-email: <pip-bluetti-bt-lib@hosting-rt.de>
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: async_timeout
+Requires-Dist: asyncio
+Requires-Dist: bleak
+Requires-Dist: crcmod
+Requires-Dist: cryptography
+Requires-Dist: logging
+Requires-Dist: pyasn1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# bluetti-bt-lib
+Inofficial Library for basic communication to bluetti powerstations.
+
+## Disclaimer
+This library is provided without any warranty or support by Bluetti. I do not take responsibility for any problems it may cause in all cases. Use it at your own risk.
+
+## Installation
+
+```bash
+git clone https://github.com/Patrick762/bluetti-bt-lib.git
+pip install .
+```
+
+## Run
+
+```bash
+bluetti
+```
+
+## Supported Powerstations and data
+
+|Device Name|total_battery_percent|dc_input_power|ac_input_power|dc_output_power|ac_output_power|
+|-----------|---------------------|--------------|--------------|---------------|---------------|
+|AC70       |✅                   |✅            |✅            |✅             |✅             |
+|AC180      |✅                   |✅            |✅            |✅             |✅             |
+|EB3A       |✅                   |✅            |✅            |✅             |✅             |
+|Handsfree 1|✅                   |✅            |✅            |✅             |✅             |

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/SOURCES.txt

@@ -0,0 +1,44 @@
+LICENSE
+README.md
+setup.py
+bluetti_bt_lib.egg-info/PKG-INFO
+bluetti_bt_lib.egg-info/SOURCES.txt
+bluetti_bt_lib.egg-info/dependency_links.txt
+bluetti_bt_lib.egg-info/entry_points.txt
+bluetti_bt_lib.egg-info/requires.txt
+bluetti_bt_lib.egg-info/top_level.txt
+src/__init__.py
+src/const.py
+src/scripts.py
+src/base_devices/BaseDeviceV1.py
+src/base_devices/BaseDeviceV2.py
+src/base_devices/BluettiDevice.py
+src/base_devices/__init__.py
+src/bluetooth/__init__.py
+src/bluetooth/device_reader.py
+src/bluetooth/device_recognizer.py
+src/bluetooth/encryption.py
+src/devices/__init__.py
+src/devices/ac180.py
+src/devices/ac70.py
+src/devices/eb3a.py
+src/devices/handsfree1.py
+src/fields/BoolField.py
+src/fields/DecimalArrayField.py
+src/fields/DecimalField.py
+src/fields/DeviceField.py
+src/fields/EnumField.py
+src/fields/FieldName.py
+src/fields/IntField.py
+src/fields/StringField.py
+src/fields/SwapStringField.py
+src/fields/UIntField.py
+src/fields/VersionField.py
+src/fields/__init__.py
+src/registers/DeviceRegister.py
+src/registers/ReadableRegisters.py
+src/registers/WriteableRegister.py
+src/registers/__init__.py
+src/utils/__init__.py
+src/utils/device_builder.py
+src/utils/device_info.py

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bluetti = src.scripts:start

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/requires.txt

@@ -0,0 +1,7 @@
+async_timeout
+asyncio
+bleak
+crcmod
+cryptography
+logging
+pyasn1

bluetti_bt_lib-0.0.1/bluetti_bt_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

bluetti_bt_lib-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bluetti_bt_lib-0.0.1/setup.py

@@ -0,0 +1,44 @@
+"""Setup for pypi package"""
+
+import os
+import codecs
+from setuptools import setup, find_packages
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+with codecs.open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
+    long_description = "\n" + fh.read()
+
+VERSION = "0.0.1"
+DESCRIPTION = "Bluetti BT"
+
+# Setting up
+setup(
+    name="bluetti-bt-lib",
+    version=VERSION,
+    author="Patrick762",
+    author_email="<pip-bluetti-bt-lib@hosting-rt.de>",
+    description=DESCRIPTION,
+    long_description_content_type="text/markdown",
+    long_description=long_description,
+    url="https://github.com/Patrick762/bluetti-bt-lib",
+    packages=find_packages(),
+    install_requires=[
+        "async_timeout",
+        "asyncio",
+        "bleak",
+        "crcmod",
+        "cryptography",
+        "logging",
+        "pyasn1",
+    ],
+    keywords=[],
+    entry_points={
+        "console_scripts": ["bluetti = src.scripts:start"],
+    },
+    classifiers=[
+        "Development Status :: 1 - Planning",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 3",
+    ],
+)

bluetti_bt_lib-0.0.1/src/__init__.py

@@ -0,0 +1,2 @@
+from .const import *
+from .scripts import *

bluetti_bt_lib-0.0.1/src/base_devices/BaseDeviceV1.py

@@ -0,0 +1,29 @@
+from typing import List
+
+from . import BluettiDevice
+from ..fields import DeviceField
+from ..fields import FieldName, StringField, UIntField
+from ..registers import ReadableRegisters
+
+
+class BaseDeviceV1(BluettiDevice):
+    def __init__(self, additional_fields: List[DeviceField] = []):
+        super().__init__(
+            [
+                StringField(FieldName.DEVICE_TYPE, 10, 6),
+                UIntField(FieldName.BATTERY_SOC, 43),
+                UIntField(FieldName.DC_INPUT_POWER, 36),
+                UIntField(FieldName.AC_INPUT_POWER, 37),
+                UIntField(FieldName.DC_OUTPUT_POWER, 38),
+                UIntField(FieldName.AC_OUTPUT_POWER, 39),
+            ]
+            + additional_fields,
+        )
+
+    def get_device_type_registers(self) -> List[ReadableRegisters]:
+        return [
+            ReadableRegisters(10, 6),
+        ]
+
+    def get_iot_version(self) -> int:
+        return 1

bluetti_bt_lib-0.0.1/src/base_devices/BaseDeviceV2.py

@@ -0,0 +1,25 @@
+from typing import List
+
+from . import BluettiDevice
+from ..fields import DeviceField
+from ..fields import FieldName, SwapStringField, UIntField
+from ..registers import ReadableRegisters
+
+
+class BaseDeviceV2(BluettiDevice):
+    def __init__(self, additional_fields: List[DeviceField] = []):
+        super().__init__(
+            [
+                SwapStringField(FieldName.DEVICE_TYPE, 110, 6),
+                UIntField(FieldName.BATTERY_SOC, 102),
+            ]
+            + additional_fields,
+        )
+
+    def get_device_type_registers(self) -> List[ReadableRegisters]:
+        return [
+            ReadableRegisters(110, 6),
+        ]
+
+    def get_iot_version(self) -> int:
+        return 2

bluetti_bt_lib-0.0.1/src/base_devices/BluettiDevice.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from ..registers import ReadableRegisters, DeviceRegister
+from ..fields import DeviceField
+
+
+class BluettiDevice:
+    def __init__(self, fields: List[DeviceField]):
+        self.fields = fields
+
+    def addFields(self, fields: List[DeviceField]):
+        for f in fields:
+            self.fields.append(f)
+
+    def get_polling_registers(self) -> List[ReadableRegisters]:
+        result = []
+
+        # TODO Optimize this to reduce amount of registers to separately request
+
+        for f in self.fields:
+            result.append(ReadableRegisters(f.address, f.size))
+
+        return result
+
+    def get_device_type_registers(self) -> List[ReadableRegisters]:
+        raise NotImplementedError
+
+    def get_iot_version(self) -> int:
+        raise NotImplementedError
+
+    def parse(self, starting_address: int, data: bytes) -> dict:
+        # Offsets and size are counted in 2 byte chunks, so for the range we
+        # need to divide the byte size by 2
+        data_size = int(len(data) / 2)
+
+        # Filter out fields not in range
+        r = range(starting_address, starting_address + data_size)
+        fields = [
+            f for f in self.fields if f.address in r and f.address + f.size - 1 in r
+        ]
+
+        # Parse fields
+        parsed = {}
+        for f in fields:
+            data_start = 2 * (f.address - starting_address)
+            field_data = data[data_start : data_start + 2 * f.size]
+            parsed[f.name] = f.parse(field_data)
+
+        return parsed

bluetti_bt_lib-0.0.1/src/base_devices/__init__.py

@@ -0,0 +1,3 @@
+from .BluettiDevice import *
+from .BaseDeviceV1 import *
+from .BaseDeviceV2 import *

bluetti_bt_lib-0.0.1/src/bluetooth/__init__.py

@@ -0,0 +1 @@
+from .device_reader import *

bluetti_bt_lib-0.0.1/src/bluetooth/device_reader.py

@@ -0,0 +1,202 @@
+import asyncio
+import logging
+import async_timeout
+from typing import Any, Callable, List, cast
+from bleak import BleakClient
+from bleak.exc import BleakError
+
+from .encryption import BluettiEncryption, Message, MessageType
+from ..registers import ReadableRegisters
+from ..const import NOTIFY_UUID, WRITE_UUID
+from ..base_devices import BluettiDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DeviceReaderConfig:
+    def __init__(self, timeout: int = 60, use_encryption: bool = False):
+        self.timeout = timeout
+        self.use_encryption = use_encryption
+
+
+class DeviceReader:
+    def __init__(
+        self,
+        bleak_client: BleakClient,
+        bluetti_device: BluettiDevice,
+        future_builder_method: Callable[[], asyncio.Future[Any]],
+        config: DeviceReaderConfig | None = None,
+    ):
+        self.client = bleak_client
+        self.bluetti_device = bluetti_device
+        self.create_future = future_builder_method
+
+        if config is not None:
+            self.config = config
+        else:
+            self.config = DeviceReaderConfig()
+
+        self.has_notifier = False
+        self.current_registers = None
+        self.notify_response = bytearray()
+        self.notify_future: asyncio.Future[Any] | None = None
+        self.encryption = BluettiEncryption()
+        self.polling_lock = asyncio.Lock()
+
+    async def read(
+        self, only_registers: List[ReadableRegisters] | None = None
+    ) -> dict | None:
+        registers = self.bluetti_device.get_polling_registers()
+
+        if only_registers is not None:
+            registers = only_registers
+
+        parsed_data: dict = {}
+
+        _LOGGER.debug("Reading device registers")
+
+        async with self.polling_lock:
+            try:
+                async with async_timeout.timeout(self.config.timeout):
+                    if not self.client.is_connected:
+                        _LOGGER.debug("Connecting to device")
+                        await self.client.connect()
+
+                    _LOGGER.debug("Connected to device")
+
+                    if not self.has_notifier:
+                        await self.client.start_notify(
+                            NOTIFY_UUID, self._notification_handler
+                        )
+                        self.has_notifier = True
+
+                    _LOGGER.debug("Notification handler setup complete")
+
+                    while (
+                        self.config.use_encryption
+                        and not self.encryption.is_ready_for_commands
+                    ):
+                        await asyncio.sleep(5)
+                        _LOGGER.debug("Encryption handshake not finished yet")
+
+                    for register in registers:
+                        body = register.parse_response(
+                            await self._async_send_command(register)
+                        )
+
+                        _LOGGER.debug("Raw data: %s", body)
+
+                        parsed = self.bluetti_device.parse(
+                            register.starting_address, body
+                        )
+
+                        _LOGGER.debug("Parsed data: %s", parsed)
+
+                        parsed_data.update(parsed)
+
+            except TimeoutError:
+                _LOGGER.warning("Timeout")
+                return None
+            except BleakError as err:
+                _LOGGER.warning("Bleak error: %s", err)
+                return None
+            except BaseException as err:
+                _LOGGER.warning("Unknown error: %s", err)
+                return None
+            finally:
+                if self.has_notifier:
+                    try:
+                        await self.client.stop_notify(NOTIFY_UUID)
+                        _LOGGER.debug("Stopped notifier")
+                    except:
+                        # Ignore errors here
+                        pass
+                    self.has_notifier = False
+                await self.client.disconnect()
+                _LOGGER.debug("Disconnected from device")
+
+            # Reset Encryption keys
+            self.encryption.reset()
+
+            # Check if dict is empty
+            if not parsed_data:
+                return None
+
+            return parsed_data
+
+    async def _async_send_command(self, registers: ReadableRegisters) -> bytes:
+        """Send command and return response"""
+        self.current_registers = registers
+        self.notify_response = bytearray()
+        self.notify_future = self.create_future()
+
+        command_bytes = bytes(registers)
+
+        # Encrypt command
+        if self.config.use_encryption is True:
+            if not self.encryption.is_ready_for_commands:
+                return bytes()
+            command_bytes = self.encryption.aes_encrypt(
+                command_bytes, self.encryption.secure_aes_key, None
+            )
+
+        try:
+            # Make request
+            await self.client.write_gatt_char(WRITE_UUID, command_bytes)
+
+            _LOGGER.debug("Request sent (%s)", registers)
+
+            # Wait for response
+            res = await asyncio.wait_for(self.notify_future, timeout=5)
+
+            _LOGGER.debug("Got response")
+
+            return cast(bytes, res)
+        except:
+            _LOGGER.warning("Error while reading data")
+
+        return bytes()
+
+    async def _notification_handler(self, _: int, data: bytearray):
+        """Handle bt data."""
+        _LOGGER.debug("Got new data")
+
+        if self.config.use_encryption is True:
+            message = Message(data)
+
+            if message.is_pre_key_exchange:
+                message.verify_checksum()
+
+                if message.type == MessageType.CHALLENGE:
+                    challenge_response = self.encryption.msg_challenge(message)
+                    await self.client.write_gatt_char(WRITE_UUID, challenge_response)
+                    return
+
+                if message.type == MessageType.CHALLENGE_ACCEPTED:
+                    _LOGGER.debug("Challenge accepted")
+                    return
+
+            if self.encryption.unsecure_aes_key is None:
+                _LOGGER.error("Received encrypted message before key initialization")
+
+            key, iv = self.encryption.getKeyIv()
+            decrypted = Message(self.encryption.aes_decrypt(message.buffer, key, iv))
+
+            if decrypted.is_pre_key_exchange:
+                decrypted.verify_checksum()
+
+                if decrypted.type == MessageType.PEER_PUBKEY:
+                    peer_pubkey_response = self.encryption.msg_peer_pubkey(decrypted)
+                    await self.client.write_gatt_char(WRITE_UUID, peer_pubkey_response)
+                    return
+
+                if decrypted.type == MessageType.PUBKEY_ACCEPTED:
+                    self.encryption.msg_key_accepted(decrypted)
+                    return
+
+            # Handle as message
+            data = decrypted.buffer
+
+        # Save data
+        self.notify_response.extend(data)
+        self.notify_future.set_result(self.notify_response)

bluetti_bt_lib-0.0.1/src/bluetooth/device_recognizer.py

@@ -0,0 +1,82 @@
+import asyncio
+import logging
+from typing import Any, Callable, List
+from bleak import BleakClient
+
+from ..base_devices import BluettiDevice, BaseDeviceV1, BaseDeviceV2
+from ..bluetooth import DeviceReader, DeviceReaderConfig
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DeviceRecognizerResult:
+    def __init__(self, name: str, iot_version: int, encrypted: bool):
+        self.name = name
+        self.iot_version = iot_version
+        self.encrypted = encrypted
+
+
+async def recognize_device(
+    bleak_client: BleakClient,
+    future_builder_method: Callable[[], asyncio.Future[Any]],
+) -> DeviceRecognizerResult | None:
+    # Since we don't know the type we use the base device
+    bluetti_devices: List[BluettiDevice] = [
+        BaseDeviceV2(),
+        BaseDeviceV1(),
+    ]
+
+    for bluetti_device in bluetti_devices:
+        # Create device builder
+        device_readers = [
+            DeviceReader(
+                bleak_client,
+                bluetti_device,
+                future_builder_method,
+                DeviceReaderConfig(
+                    timeout=8,
+                    use_encryption=True,
+                ),
+            ),
+            DeviceReader(
+                bleak_client,
+                bluetti_device,
+                future_builder_method,
+                DeviceReaderConfig(timeout=3),
+            ),
+        ]
+
+        for device_reader in device_readers:
+
+            # We only need 6 registers to get the device type
+            data = await device_reader.read(
+                bluetti_device.get_device_type_registers(),
+            )
+
+            if data is None:
+                # Should not happen
+                continue
+
+            field_data = data.get("device_type")
+
+            if field_data is None:
+                # We have a problem
+                _LOGGER.error("No data in device type field_data")
+                continue
+
+            if not isinstance(field_data, str):
+                # We have a problem
+                _LOGGER.error("Invalid data in device type field_data")
+                continue
+
+            if field_data == "":
+                # Empty string is not a valid device type
+                continue
+
+            return DeviceRecognizerResult(
+                field_data,
+                bluetti_device.get_iot_version(),
+                device_reader.config.use_encryption,
+            )
+
+    return None