fix requirements.txt

Unittest fix

.dockerignore

@@ -0,0 +1,3 @@
+*/__pycache__/
+*.pyc
+.DS_Store

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: Patrick762

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -14,16 +14,10 @@ body:
       value: "An exception appeared"
     validations:
       required: true
-  - type: dropdown
+  - type: textarea
     id: version
     attributes:
-      label: Version
+      label: What version of our software are you running?
-      description: What version of our software are you running?
-      options:
-        - 0.0.11
-        - 0.0.10
-        - 0.0.9
-      default: 0
     validations:
       required: true
   - type: textarea

.github/workflows/test.yaml

@@ -0,0 +1,22 @@
+name: Unittests
+on:
+  push:
+  pull_request:
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: Run unittests
+      run: python3 -m unittest discover -s tests -p "*_test.py"

.gitignore

@@ -1,2 +1,3 @@
 */__pycache__/
 *.pyc
+.DS_Store

Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY tests ./tests
+COPY custom_components ./custom_components
+
+RUN python3 -m unittest discover -s tests -p "*_test.py"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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.

README.md

@@ -17,12 +17,14 @@ After the installation, you can use this button to install the integration:
 ### Supported devices:
 
 - AC60
+- AC70 (basic data)
+- AC70P (untested)
 - AC180 (basic data)
-- AC180P (basic data)
+- AC180P (tested)
 - AC200L (untested)
 - AC200M
 - AC300 (tested)
-- AC500
+- AC500 (tested)
 - EB3A
 - EP500
 - EP500P

custom_components/bluetti_bt/__init__.py

@@ -14,6 +14,7 @@ from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.exceptions import ConfigEntryNotReady
 
 from .const import (
+    CONF_ENCRYPTION,
     CONF_MAX_RETRIES,
     CONF_PERSISTENT_CONN,
     CONF_POLLING_INTERVAL,
@@ -33,15 +34,16 @@ _LOGGER = logging.getLogger(__name__)
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Bluetti Powerstation from a config entry."""
 
-    _LOGGER.debug("Init Bluetti BT Integration")
+    _LOGGER.debug("Init Bluetti BT Integration for device %s", entry.data.get(CONF_NAME))
 
     address = entry.data.get(CONF_ADDRESS)
     device_name = entry.data.get(CONF_NAME)
     use_controls = entry.data.get(CONF_USE_CONTROLS)
-    polling_interval = entry.data.get(CONF_POLLING_INTERVAL, 20)
+    polling_interval = entry.data.get(CONF_POLLING_INTERVAL, 60)
     persistent_conn = entry.data.get(CONF_PERSISTENT_CONN, False)
-    polling_timeout = entry.data.get(CONF_POLLING_TIMEOUT, 45)
+    polling_timeout = entry.data.get(CONF_POLLING_TIMEOUT, 120)
     max_retries = entry.data.get(CONF_MAX_RETRIES, 5)
+    use_encryption = entry.data.get(CONF_ENCRYPTION, False)
 
     if address is None:
         return False
@@ -56,7 +58,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     # Create coordinator for polling
     _LOGGER.debug("Creating coordinator")
-    coordinator = PollingCoordinator(hass, address, device_name, polling_interval, persistent_conn, polling_timeout, max_retries)
+    coordinator = PollingCoordinator(hass, address, device_name, polling_interval, persistent_conn, polling_timeout, max_retries, use_encryption)
     await coordinator.async_config_entry_first_refresh()
     hass.data[DOMAIN][entry.entry_id].setdefault(DATA_COORDINATOR, coordinator)
 

custom_components/bluetti_bt/binary_sensor.py

@@ -36,7 +36,7 @@ async def async_setup_entry(
 
     device_name = entry.data.get(CONF_NAME)
     address = entry.data.get(CONF_ADDRESS)
-    use_controls = entry.data.get(CONF_USE_CONTROLS)
+    use_controls = entry.data.get(CONF_USE_CONTROLS, False)
     if address is None:
         _LOGGER.error("Device has no address")
 
@@ -52,12 +52,7 @@ async def async_setup_entry(
     for field_key, field_config in all_fields.items():
         if bluetti_device.has_field(field_key):
             if field_config.type == FieldType.BOOL:
-                category = None
                 if field_config.setter is True:
-                    category = EntityCategory.DIAGNOSTIC
-
-                # Ignore setters if controls enabled
-                if field_config.setter is True and use_controls is True:
                     continue
 
                 sensors_to_add.append(
@@ -67,7 +62,6 @@ async def async_setup_entry(
                         address,
                         field_key,
                         field_config.name,
-                        category=category,
                     )
                 )
 
@@ -84,7 +78,6 @@ class BluettiBinarySensor(CoordinatorEntity, BinarySensorEntity):
         address,
         response_key: str,
         name: str,
-        category: EntityCategory | None = None,
     ):
         """Init battery entity."""
         super().__init__(coordinator)
@@ -93,17 +86,38 @@ class BluettiBinarySensor(CoordinatorEntity, BinarySensorEntity):
         e_name = f"{device_info.get('name')} {name}"
         self._address = address
         self._response_key = response_key
+        self._unavailable_counter = 5
 
         self._attr_device_info = device_info
         self._attr_name = name
         self._attr_available = False
         self._attr_unique_id = get_unique_id(e_name)
-        self._attr_entity_category = category
 
     @property
     def available(self) -> bool:
         """Return if entity is available."""
         return self._attr_available
+    
+    def _set_available(self):
+        """Set sensor as available."""
+        self._attr_available = True
+        self._unavailable_counter = 0
+        self._attr_extra_state_attributes = {}
+        self.async_write_ha_state()
+
+    def _set_unavailable(self, cause: str = "Unknown"):
+        """Set sensor as unavailable."""
+        self._unavailable_counter += 1
+
+        self._attr_extra_state_attributes = {
+            "unavailable_counter": self._unavailable_counter,
+            "unavailable_cause": cause,
+        }
+
+        if self._unavailable_counter >= 5:
+            self._attr_available = False
+
+        self.async_write_ha_state()
 
     @callback
     def _handle_coordinator_update(self) -> None:
@@ -111,20 +125,25 @@ class BluettiBinarySensor(CoordinatorEntity, BinarySensorEntity):
 
         if self.coordinator.reader.persistent_conn and not self.coordinator.reader.client.is_connected:
             return
+        
+        if self.coordinator.data is None:
+            _LOGGER.debug(
+                "Data from coordinator is None",
+            )
+            self._set_unavailable("Data is None")
+            return
 
         _LOGGER.debug("Updating state of %s", unique_id_loggable(self._attr_unique_id))
         if not isinstance(self.coordinator.data, dict):
             _LOGGER.debug(
                 "Invalid data from coordinator (binary_sensor.%s)", unique_id_loggable(self._attr_unique_id)
             )
-            self._attr_available = False
+            self._set_unavailable("Invalid data")
-            self.async_write_ha_state()
             return
 
         response_data = self.coordinator.data.get(self._response_key)
         if response_data is None:
-            self._attr_available = False
+            self._set_unavailable("No data")
-            self.async_write_ha_state()
             return
 
         if not isinstance(response_data, bool):
@@ -133,10 +152,9 @@ class BluettiBinarySensor(CoordinatorEntity, BinarySensorEntity):
                 unique_id_loggable(self._attr_unique_id),
                 response_data,
             )
-            self._attr_available = False
+            self._set_unavailable("Invalid data type")
-            self.async_write_ha_state()
             return
 
-        self._attr_available = True
+        self._set_available()
         self._attr_is_on = self.coordinator.data[self._response_key] is True
         self.async_write_ha_state()

custom_components/bluetti_bt/bluetti_bt_lib/base_devices/BluettiDevice.py

@@ -42,6 +42,11 @@ class BluettiDevice:
     def writable_ranges(self) -> List[range]:
         """The address ranges that are writable"""
         return []
+    
+    @property
+    def pack_num_field(self) -> List[ReadHoldingRegisters]:
+        """The address 'range' of the pack num result. Matches pack_num_result"""
+        return []
 
     def has_field(self, field: str):
         return any(f.name == field for f in self.struct.fields)

custom_components/bluetti_bt/bluetti_bt_lib/base_devices/ProtocolV1Device.py

@@ -14,6 +14,8 @@ class ProtocolV1Device(BluettiDevice):
         # Device info
         self.struct.add_string_field("device_type", 10, 6)
         self.struct.add_sn_field("serial_number", 17)
+        self.struct.add_version_field('arm_version', 23)
+        self.struct.add_version_field('dsp_version', 25)
 
         # Power IO
         self.struct.add_uint_field("dc_input_power", 36)
@@ -56,3 +58,9 @@ class ProtocolV1Device(BluettiDevice):
     @property
     def writable_ranges(self) -> List[range]:
         return [range(3006, 3009)]
+    
+    @property
+    def pack_num_field(self) -> List[ReadHoldingRegisters]:
+        return [
+            ReadHoldingRegisters(96, 1),
+        ]

custom_components/bluetti_bt/bluetti_bt_lib/bluetooth/device_reader.py

@@ -6,6 +6,8 @@ from typing import Any, Callable, List, cast
 import async_timeout
 from bleak import BleakClient, BleakError
 
+from custom_components.bluetti_bt.bluetti_bt_lib.bluetooth.encryption import BluettiEncryption, Message, MessageType
+
 from ..base_devices.BluettiDevice import BluettiDevice
 from ..const import NOTIFY_UUID, RESPONSE_TIMEOUT, WRITE_UUID
 from ..exceptions import BadConnectionError, ModbusError, ParseError
@@ -23,6 +25,7 @@ class DeviceReader:
         persistent_conn: bool = False,
         polling_timeout: int = 45,
         max_retries: int = 5,
+        encrypted: bool = False,
     ) -> None:
         self.client = bleak_client
         self.bluetti_device = bluetti_device
@@ -30,6 +33,7 @@ class DeviceReader:
         self.persistent_conn = persistent_conn
         self.polling_timeout = polling_timeout
         self.max_retries = max_retries
+        self.encrypted = encrypted
 
         self.has_notifier = False
         self.notify_future: asyncio.Future[Any] | None = None
@@ -39,6 +43,8 @@ class DeviceReader:
         # polling mutex to guard against switches
         self.polling_lock = asyncio.Lock()
 
+        self.encryption = BluettiEncryption()
+
     async def read_data(
         self, filter_registers: List[ReadHoldingRegisters] | None = None
     ) -> dict | None:
@@ -53,6 +59,8 @@ class DeviceReader:
         if filter_registers is not None:
             polling_commands = filter_registers
             pack_commands = []
+        _LOGGER.info("Polling commands: " + ",".join([f"{c.starting_address}-{c.starting_address + c.quantity - 1}" for c in polling_commands]))
+        _LOGGER.info("Pack comands: " + ",".join([f"{c.starting_address}-{c.starting_address + c.quantity - 1}" for c in pack_commands]))
 
         parsed_data: dict = {}
 
@@ -66,8 +74,8 @@ class DeviceReader:
                                 await self.client.connect()
                             break
                         except Exception as e:
-                            if attempt == self.max_retries or attempt == 1:
+                            if attempt == self.max_retries:
-                                raise  # pass exception on max_retries attempt
+                                raise e # pass exception on max_retries attempt
                             else:
                                 _LOGGER.warning(
                                     f"Connect unsucessful (attempt {attempt}): {e}. Retrying..."
@@ -81,6 +89,10 @@ class DeviceReader:
                         )
                         self.has_notifier = True
 
+                    while self.encrypted and not self.encryption.is_ready_for_commands:
+                        await asyncio.sleep(5)
+                        _LOGGER.debug("Encryption handshake not finished yet")
+
                     # Execute polling commands
                     for command in polling_commands:
                         try:
@@ -97,21 +109,31 @@ class DeviceReader:
                             _LOGGER.warning("Got a parse exception")
 
                     # Execute pack polling commands
-                    if len(pack_commands) > 0:
+                    if len(pack_commands) > 0 and len(self.bluetti_device.pack_num_field) == 1:
                         _LOGGER.debug("Polling battery packs")
                         for pack in range(1, self.bluetti_device.pack_num_max + 1):
+                            _LOGGER.debug("Setting pack_num to %i", pack)
+
                             # Set current pack number
-                            await self._async_send_command(
+                            command = self.bluetti_device.build_setter_command(
-                                self.bluetti_device.build_setter_command(
+                                "pack_num", pack
-                                    "pack_num", pack
-                                )
                             )
+                            body = command.parse_response(
+                                await self._async_send_command(command)
+                            )
+                            _LOGGER.debug("Raw data set: %s", body)
 
-                            # We need to wait after switching packs for the data to be available
+                            # Check set pack_num
-                            await asyncio.sleep(5)
+                            set_pack = int.from_bytes(body, byteorder='big')
-
+                            if set_pack is not pack:
-                            pack_ok = False
+                                _LOGGER.warning("Pack polling failed (pack_num %i doesn't match expected %i)", set_pack, pack)
+                                continue
 
+                            if self.bluetti_device.pack_num_max > 1:
+                                # We need to wait after switching packs 
+                                # for the data to be available
+                                await asyncio.sleep(5)
+                            
                             for command in pack_commands:
                                 # Request & parse result for each pack
                                 try:
@@ -123,28 +145,16 @@ class DeviceReader:
                                     )
                                     _LOGGER.debug("Parsed data: %s", parsed)
 
-                                    if not pack_ok: # Only check this once
-                                        pack_number = parsed.get("pack_num")
-                                        if (
-                                            not isinstance(pack_number, int)
-                                            or pack_number != pack
-                                        ):
-                                            _LOGGER.debug(
-                                                "Parsed pack_num(%s) does not match expected '%s'",
-                                                pack_number,
-                                                pack,
-                                            )
-                                            continue
-                                        pack_ok = True
-
                                     for key, value in parsed.items():
-                                        parsed_data.update({key + str(pack): value})
+                                        # Ignore likely unavailable pack data
+                                        if value != 0:
+                                            parsed_data.update({key + str(pack): value})
 
                                 except ParseError:
                                     _LOGGER.warning("Got a parse exception...")
 
-            except TimeoutError:
+            except TimeoutError as err:
-                _LOGGER.warning("Polling timed out. Trying again later")
+                _LOGGER.error(f"Polling timed out ({self.polling_timeout}s). Trying again later", exc_info=err)
                 return None
             except BleakError as err:
                 _LOGGER.error("Bleak error: %s", err)
@@ -165,6 +175,9 @@ class DeviceReader:
             if not parsed_data:
                 return None
 
+            # Reset Encryption keys
+            self.encryption.reset()
+
             return parsed_data
 
     async def _async_send_command(self, command: ReadHoldingRegisters) -> bytes:
@@ -177,7 +190,16 @@ class DeviceReader:
 
             # Make request
             _LOGGER.debug("Requesting %s", command)
-            await self.client.write_gatt_char(WRITE_UUID, bytes(command))
+
+            command_bytes = bytes(command)
+
+            # Encrypt command
+            if self.encrypted 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)
+
+            await self.client.write_gatt_char(WRITE_UUID, command_bytes)
 
             # Wait for response
             res = await asyncio.wait_for(self.notify_future, timeout=RESPONSE_TIMEOUT)
@@ -187,9 +209,9 @@ class DeviceReader:
             return cast(bytes, res)
 
         except TimeoutError:
-            _LOGGER.warning("Polling single command timed out")
+            _LOGGER.debug("Polling single command timed out")
         except ModbusError as err:
-            _LOGGER.warning(
+            _LOGGER.debug(
                 "Got an invalid request error for %s: %s",
                 command,
                 err,
@@ -201,9 +223,47 @@ class DeviceReader:
         # caught an exception, return empty bytes object
         return bytes()
 
-    def _notification_handler(self, _sender: int, data: bytearray):
+    async def _notification_handler(self, _sender: int, data: bytearray):
         """Handle bt data."""
 
+        # Handle encrypted data
+        if self.encrypted is True:
+            message = Message(data)
+
+            # Handle key exchange
+            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
+
         # Ignore notifications we don't expect
         if self.notify_future is None or self.notify_future.done():
             _LOGGER.warning("Unexpected notification")

custom_components/bluetti_bt/bluetti_bt_lib/bluetooth/encryption.py

@@ -0,0 +1,289 @@
+from enum import Enum
+import hashlib
+import logging
+import os
+import pyasn1.codec.der.decoder as der_decoder
+import pyasn1.codec.der.encoder as der_encoder
+from pyasn1.type import univ
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.exceptions import InvalidSignature
+
+from custom_components.bluetti_bt.bluetti_bt_lib.const import LOCAL_AES_KEY, PRIVATE_KEY_L1, PUBLIC_KEY_K2, SECP_256R1_PUBLIC_PREFIX
+
+
+_LOGGER = logging.getLogger(__name__)
+
+KEX_MAGIC = b"**"
+AES_BLOCK_SIZE = 16
+
+def hexsum(s, sz: int):
+    checksum = sum(s)
+    as_hex = f"{checksum:0{sz*2}x}"
+    return bytes.fromhex(as_hex)
+
+def hexxor(a: bytes, b: bytes) -> bytes | None:
+    if len(a) != len(b):
+        _LOGGER.error("Can only XOR two identical length byte strings")
+        return None
+    return bytes([x ^ y for x, y in zip(a, b)])
+
+def raw_ecdsa_to_der(sig):
+    # <byte r[32]> <byte s[32]>
+
+    if len(sig) != 64:
+        raise ValueError("ecdsa signature is the wrong size")
+
+    seq = univ.SequenceOf()
+    seq.extend(
+        [
+            univ.Integer(int.from_bytes(sig[:32], "big")),  # r
+            univ.Integer(int.from_bytes(sig[32:], "big")),  # s
+        ]
+    )
+    return der_encoder.encode(seq)
+
+def der_to_raw_ecdsa(sig):
+    # 30 45 02 20 1956307e59448178b47c222e4e1e6c8ef7d707bc230e5a9fa77f919ec44e5f74
+    # |  |  |  |  |> byte r[0x20]
+    # |  |  |  |---> Length
+    # |  |  |------> DER type (int)
+    # |  |---------> Payload size
+    # |------------> DER type (sequence)
+
+    #       02 21 00cfad6e11abd5e803fb6874c3838bc968db1f3c070ae6b85db9d8ed8936a1eb5c
+    #       |  |  |> byte s[0x21]
+    #       |  |---> Length
+    #       |------> DER type (int)
+
+    seq, remainder = der_decoder.decode(sig)
+    if remainder:
+        raise ValueError("Found trailing data")
+
+    return b"".join([int.to_bytes(int(x), 0x20, "big") for x in seq])
+
+def verify_and_extract_signed_data(message, signed_data_suffix: bytes | None):
+    # 64 bytes of data
+    # 64 bytes of signature
+    if len(message) != 128:
+        raise ValueError("Unexpected message length")
+
+    data = message[:64]
+    signature = message[64:]
+    signed_data = data.tobytes() + signed_data_suffix
+    der_signature = raw_ecdsa_to_der(signature)
+    try:
+        key_bytes = bytes.fromhex(PUBLIC_KEY_K2)
+        serialization.load_der_public_key(key_bytes).verify(
+            der_signature, signed_data, ec.ECDSA(hashes.SHA256())
+        )
+        _LOGGER.debug("Signature OK")
+    except InvalidSignature:
+        raise
+
+    return data
+
+def pubkey_from_bytes(data):
+    encoded_peer_pubkey = bytes.fromhex(SECP_256R1_PUBLIC_PREFIX) + data
+    return serialization.load_der_public_key(encoded_peer_pubkey)
+
+def generate_keypair():
+    private = ec.generate_private_key(ec.SECP256R1())
+    return (private.public_key(), private)
+
+def pubkey_to_bytes(pubkey):
+    out = pubkey.public_bytes(
+        encoding=serialization.Encoding.X962,
+        format=serialization.PublicFormat.UncompressedPoint,
+    )
+
+    if out[0] != 0x4 or len(out) != 65:
+        raise RuntimeError(
+            "First byte should be 04 for the uncompressed format, and total size 64"
+        )
+
+    return out[1:]
+
+class MessageType(Enum):
+    CHALLENGE = 1
+    CHALLENGE_ACCEPTED = 3
+    PEER_PUBKEY = 4
+    PUBKEY_ACCEPTED = 6
+
+class Message:
+    """
+    Two types of messages. The first one is for communication that happens before we have
+    a proper symmetric key available. These are fully handled by this file, it's purely
+    to setup the encryption protocol.
+
+    2a2a .... 0000
+    |         |> Body checksum
+    |    |-----> Body
+    |----------> Magic value for pre-key-exchange
+
+    The second type is for anything after. This can either contain the type 1 message above, or
+    anything else -- at this point we're just wrapping the regular protocol, and we just forward
+    the packets dowm the regular processing path after decrypting them.
+
+    See aes_decrypt() for the format.
+    """
+
+    def __init__(self, buffer: bytes):
+        self.buffer = buffer
+        self.view = memoryview(self.buffer)
+
+    @property
+    def header(self) -> memoryview:
+        return self.view[:2]
+
+    @property
+    def is_pre_key_exchange(self) -> bool:
+        return self.header == KEX_MAGIC
+
+    @property
+    def checksum(self) -> memoryview:
+        return self.view[-2:]
+
+    @property
+    def body(self) -> memoryview:
+        return self.view[len(self.header) : -len(self.checksum)]
+
+    @property
+    def data(self) -> memoryview:
+        return self.body[2:]
+
+    @property
+    def type(self) -> int:
+        return MessageType(self.body[0])
+
+    def verify_checksum(self):
+        message_checksum = self.checksum
+        computed_checksum = hexsum(self.body, len(message_checksum))
+        if computed_checksum != message_checksum:
+            _LOGGER.error("Checksum error!")
+        _LOGGER.debug("Checksum OK")
+
+class BluettiEncryption:
+    # Derived exclusively from data sent over the network
+    # Used for the initial handshake
+    unsecure_aes_key: bytes | None = None
+
+    # Predictably derived from a seed sent by the peer
+    # This is the same for all the messages encrypted
+    # with that key during the connection
+    unsecure_aes_iv: bytes | None = None
+
+    # Proper key exchange gives us another key,
+    # that is used for the remainder of the connection
+    # IV is random per message
+    secure_aes_key: bytes | None = None
+
+    # Received through key exchange
+    # The signing key for the key exchange is well-known
+    peer_pubkey: bytes | None = None
+
+    @property
+    def is_ready_for_commands(self) -> bool:
+        return self.secure_aes_key is not None and self.peer_pubkey is not None
+
+    def aes_decrypt(self, data: bytes, aes_key: bytes | None, iv: bytes | None):
+        data_len = (data[0] << 8) + data[1]
+
+        if iv is None:
+            iv = hashlib.md5(data[2:6]).digest()
+            encrypted = memoryview(data)[6:]
+        else:
+            encrypted = memoryview(data[2:])
+
+        if len(encrypted) % AES_BLOCK_SIZE != 0:
+            raise ValueError("Data not aligned on aes block size")
+
+        cipher = Cipher(algorithms.AES(aes_key), modes.CBC(iv))
+        decryptor = cipher.decryptor()
+        decrypted = decryptor.update(encrypted) + decryptor.finalize()
+        decrypted = decrypted[:data_len]
+
+        _LOGGER.debug(">PLAIN " + decrypted.hex())
+        return decrypted
+
+
+    def aes_encrypt(self, data: bytes, aes_key: bytes | None, iv: bytes | None):
+        message_header = int.to_bytes(len(data), 2, "big")
+
+        if iv is None:
+            iv_seed = os.urandom(4)
+            iv = hashlib.md5(iv_seed).digest()
+            message_header += iv_seed
+
+        padding = (AES_BLOCK_SIZE - len(data) % AES_BLOCK_SIZE) % AES_BLOCK_SIZE
+        data += bytes(padding)
+
+        cipher = Cipher(algorithms.AES(aes_key), modes.CBC(iv))
+        encryptor = cipher.encryptor()
+        encrypted = encryptor.update(data) + encryptor.finalize()
+        encrypted = message_header + encrypted
+
+        _LOGGER.debug("PLAIN> " + data.hex())
+        return encrypted
+    
+    def msg_challenge(self, message: Message) -> bytes | None:
+        _LOGGER.debug("Received challenge")
+
+        if len(message.data) != 4:
+            _LOGGER.error("Unexpected message length")
+            return None
+
+        self.unsecure_aes_iv = hashlib.md5(message.data[::-1].tobytes()).digest()
+        static_key = bytes.fromhex(LOCAL_AES_KEY)
+        self.unsecure_aes_key = hexxor(self.unsecure_aes_iv, static_key)
+
+        _LOGGER.info("Unsecure iv  " + self.unsecure_aes_iv.hex())
+        _LOGGER.info("Unsecure key " + self.unsecure_aes_key.hex())
+
+        body = bytes.fromhex("0204") + self.unsecure_aes_iv[8:12]
+        return b"".join([KEX_MAGIC, body, hexsum(body, 2)])
+
+    def msg_peer_pubkey(self, message: Message) -> bytes | None:
+        _LOGGER.debug("Received peer pubkey, checking signature")
+        data = verify_and_extract_signed_data(message.data, self.unsecure_aes_iv)
+        self.peer_pubkey = pubkey_from_bytes(data)
+
+        _LOGGER.debug("Generating a local keypair")
+        self.my_pubkey, self.my_privkey = generate_keypair()
+        my_pubkey_bytes = pubkey_to_bytes(self.my_pubkey)
+
+        _LOGGER.debug("Signing the local pubkey")
+        signing_secret = int.from_bytes(
+            bytes.fromhex(PRIVATE_KEY_L1), "big"
+        )
+        signing_key = ec.derive_private_key(signing_secret, ec.SECP256R1())
+        to_sign = my_pubkey_bytes + self.unsecure_aes_iv
+        signature = signing_key.sign(to_sign, ec.ECDSA(hashes.SHA256()))
+        raw_signature = der_to_raw_ecdsa(signature)
+
+        body = b"".join([bytes.fromhex("0580"), my_pubkey_bytes, raw_signature])
+        msg = b"".join([KEX_MAGIC, body, hexsum(body, 2)])
+        return self.aes_encrypt(msg, self.unsecure_aes_key, self.unsecure_aes_iv)
+    
+    def msg_key_accepted(self, message: Message) -> None:
+        _LOGGER.debug("Received key exchange confirmation, calculating shared secret")
+
+        if len(message.data) != 1:
+            raise ValueError("Unexpected message length")
+        if message.data[0] != 0:
+            raise ValueError("Key acceptance response is not 0")
+
+        self.secure_aes_key = self.my_privkey.exchange(ec.ECDH(), self.peer_pubkey)
+        _LOGGER.info("Secure key   " + self.secure_aes_key.hex())
+
+    def getKeyIv(self):
+        return (
+            (self.unsecure_aes_key, self.unsecure_aes_iv)
+                if self.secure_aes_key is None
+                else (self.secure_aes_key, None)
+        )
+    
+    def reset(self):
+        self.peer_pubkey = None
+        self.secure_aes_key = None

custom_components/bluetti_bt/bluetti_bt_lib/const.py

@@ -4,3 +4,8 @@ RESPONSE_TIMEOUT = 5
 WRITE_UUID = "0000ff02-0000-1000-8000-00805f9b34fb"
 NOTIFY_UUID = "0000ff01-0000-1000-8000-00805f9b34fb"
 DEVICE_NAME_UUID = "00002a00-0000-1000-8000-00805f9b34fb"
+
+LOCAL_AES_KEY = "459FC535808941F17091E0993EE3E93D"
+PRIVATE_KEY_L1 = "4F19A16E3E87BDD9BD24D3E5495B88041511943CBC8B969ADE9641D0F56AF337"
+PUBLIC_KEY_K2 = "3059301306072a8648ce3d020106082a8648ce3d03010703420004A73ABF5D2232C8C1C72E68304343C272495E3A8FD6F30EA96DE2F4B3CE60B251EE21AC667CF8A71E18B46B664EAEFFE3C489F24F695B6411DB7E22CCC85A8594"
+SECP_256R1_PUBLIC_PREFIX = "3059301306072a8648ce3d020106082a8648ce3d03010703420004"

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac180p.py

@@ -1,8 +1,52 @@
 """AC180P fields."""
 
-from ..base_devices.ProtocolV2Device import ProtocolV2Device
+from typing import List
 
+from ..field_enums import ChargingMode
+from ..utils.commands import ReadHoldingRegisters
+from ..base_devices.ProtocolV2Device import ProtocolV2Device
 
 class AC180P(ProtocolV2Device):
     def __init__(self, address: str, sn: str):
         super().__init__(address, "AC180P", sn)
+
+        # Power IO
+        self.struct.add_uint_field('dc_output_power', 140)
+        self.struct.add_uint_field('ac_output_power', 142)
+        self.struct.add_uint_field('dc_input_power', 144)
+        self.struct.add_uint_field('ac_input_power', 146)
+
+        # Input Details (1100 - 1300)
+        self.struct.add_decimal_field('ac_input_voltage', 1314, 1)
+
+        # Controls (2000)
+        self.struct.add_bool_field('ac_output_on_switch', 2011)
+        self.struct.add_bool_field('dc_output_on_switch', 2012)
+        self.struct.add_bool_field('silent_charging_on', 2020) # to be able to choose between normal and silent charging modes
+        self.struct.add_enum_field('charging_mode', 2020, ChargingMode) # can't be set from HA, custom switch needed
+        self.struct.add_bool_field('power_lifting_on', 2021)
+
+        # Controls (2200)
+        self.struct.add_bool_field('grid_enhancement_mode_on', 2225)
+
+    @property
+    def polling_commands(self) -> List[ReadHoldingRegisters]:
+        return super().polling_commands + [
+            ReadHoldingRegisters(140, 1),
+            ReadHoldingRegisters(142, 1),
+            ReadHoldingRegisters(144, 1),
+            ReadHoldingRegisters(146, 1),
+            ReadHoldingRegisters(1314, 1),
+            ReadHoldingRegisters(2011, 1),
+            ReadHoldingRegisters(2012, 1),
+            ReadHoldingRegisters(2020, 1),
+            ReadHoldingRegisters(2021, 1),
+            ReadHoldingRegisters(2225, 1),
+        ]
+
+    @property
+    def writable_ranges(self) -> List[range]:
+        return super().writable_ranges + [
+            range(2000, 2022),
+            range(2200, 2226)
+        ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac200l.py

@@ -13,21 +13,22 @@ class AC200L(ProtocolV1Device):
 
         # Details
         self.struct.add_enum_field("ac_output_mode", 70, OutputMode)
-        self.struct.add_decimal_field("internal_ac_voltage", 71, 1)
+        self.struct.add_decimal_field("internal_ac_voltage", 71, 1, multiplier=10)
         self.struct.add_decimal_field("internal_current_one", 72, 1)
         self.struct.add_uint_field("internal_power_one", 73)
-        self.struct.add_decimal_field("internal_ac_frequency", 74, 2)
+        self.struct.add_decimal_field("internal_ac_frequency", 74, 2, multiplier=10)
-        self.struct.add_uint_field("internal_dc_input_voltage", 86)
+        self.struct.add_uint_field("internal_dc_input_voltage", 86, multiplier=.1)
-        self.struct.add_decimal_field("internal_dc_input_power", 87, 1)
+        self.struct.add_decimal_field("internal_dc_input_power", 87, 1, multiplier=10)
         self.struct.add_decimal_field("internal_dc_input_current", 88, 2)
 
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
-        self.struct.add_decimal_field("total_battery_voltage", 92, 1)
+        self.struct.add_decimal_field("total_battery_voltage", 92, 1, multiplier=.1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
+        self.struct.add_version_field("pack_bms_version", 201)
 
         # Controls
         self.struct.add_bool_field("power_off", 3060)
@@ -39,11 +40,9 @@ class AC200L(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 5),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3060, 2),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -52,8 +51,6 @@ class AC200L(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
+            ReadHoldingRegisters(201, 2),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16)
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac200m.py

@@ -24,10 +24,11 @@ class AC200M(ProtocolV1Device):
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
         self.struct.add_decimal_field("total_battery_voltage", 92, 1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
+        self.struct.add_version_field("pack_bms_version", 201)
 
         # Controls
         self.struct.add_bool_field("power_off", 3060)
@@ -39,11 +40,9 @@ class AC200M(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 5),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3060, 2),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -52,8 +51,6 @@ class AC200M(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
+            ReadHoldingRegisters(201, 2),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16)
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac300.py

@@ -15,22 +15,22 @@ class AC300(ProtocolV1Device):
         self.struct.add_enum_field("ac_output_mode", 70, OutputMode)
         self.struct.add_decimal_field("internal_ac_voltage", 71, 1)
         self.struct.add_decimal_field("internal_current_one", 72, 1)
-        self.struct.add_uint_field("internal_power_one", 73)
+        self.struct.add_int_field("internal_power_one", 73)
         self.struct.add_decimal_field("internal_ac_frequency", 74, 2)
         self.struct.add_decimal_field("internal_current_two", 75, 1)
-        self.struct.add_uint_field("internal_power_two", 76)
+        self.struct.add_int_field("internal_power_two", 76)
         self.struct.add_decimal_field("ac_input_voltage", 77, 1)
         self.struct.add_decimal_field("internal_current_three", 78, 1, (0, 100))
-        self.struct.add_uint_field("internal_power_three", 79)
+        self.struct.add_int_field("internal_power_three", 79)
         self.struct.add_decimal_field("ac_input_frequency", 80, 2)
-        self.struct.add_uint_field("internal_dc_input_voltage", 86, scale=.1)
+        self.struct.add_uint_field("pv_input_voltage1", 86, multiplier=.1)
-        self.struct.add_decimal_field("internal_dc_input_power", 87, 1)
+        self.struct.add_decimal_field("pv_input_power1", 87, 1, multiplier=10)
-        self.struct.add_decimal_field("internal_dc_input_current", 88, 2)
+        self.struct.add_decimal_field("pv_input_current1", 88, 2, multiplier=10)
 
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
         self.struct.add_decimal_field("total_battery_voltage", 92, 1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
@@ -54,16 +54,9 @@ class AC300(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 11),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3001, 1),
-            ReadHoldingRegisters(3004, 2),
-            ReadHoldingRegisters(3011, 1),
-            ReadHoldingRegisters(3013, 1),
-            ReadHoldingRegisters(3015, 2),
-            ReadHoldingRegisters(3061, 1),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -75,9 +68,6 @@ class AC300(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16),
             ReadHoldingRegisters(201, 2),
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac500.py

@@ -15,25 +15,26 @@ class AC500(ProtocolV1Device):
         self.struct.add_enum_field("ac_output_mode", 70, OutputMode)
         self.struct.add_decimal_field("internal_ac_voltage", 71, 1)
         self.struct.add_decimal_field("internal_current_one", 72, 1)
-        self.struct.add_uint_field("internal_power_one", 73)
+        self.struct.add_int_field("internal_power_one", 73)
         self.struct.add_decimal_field("internal_ac_frequency", 74, 2)
         self.struct.add_decimal_field("internal_current_two", 75, 1)
-        self.struct.add_uint_field("internal_power_two", 76)
+        self.struct.add_int_field("internal_power_two", 76)
         self.struct.add_decimal_field("ac_input_voltage", 77, 1)
         self.struct.add_decimal_field("internal_current_three", 78, 1, (0, 100))
-        self.struct.add_uint_field("internal_power_three", 79)
+        self.struct.add_int_field("internal_power_three", 79)
         self.struct.add_decimal_field("ac_input_frequency", 80, 2)
-        self.struct.add_uint_field("internal_dc_input_voltage", 86, scale=.1)
+        self.struct.add_uint_field("pv_input_voltage1", 86, multiplier=.1)
-        self.struct.add_decimal_field("internal_dc_input_power", 87, 1)
+        self.struct.add_decimal_field("pv_input_power1", 87, 1, multiplier=10)
-        self.struct.add_decimal_field("internal_dc_input_current", 88, 2)
+        self.struct.add_decimal_field("pv_input_current1", 88, 2, multiplier=10)
 
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
         self.struct.add_decimal_field("total_battery_voltage", 92, 1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
+        self.struct.add_version_field('pack_bms_version', 201)
 
         # Controls
         self.struct.add_enum_field("ups_mode", 3001, UpsMode)
@@ -49,20 +50,13 @@ class AC500(ProtocolV1Device):
 
     @property
     def pack_num_max(self):
-        return 4
+        return 6
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 11),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3001, 1),
-            ReadHoldingRegisters(3004, 2),
-            ReadHoldingRegisters(3011, 1),
-            ReadHoldingRegisters(3013, 1),
-            ReadHoldingRegisters(3015, 2),
-            ReadHoldingRegisters(3061, 1),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -74,8 +68,6 @@ class AC500(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
+            ReadHoldingRegisters(201, 2),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16),
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac70.py

@@ -0,0 +1,8 @@
+"""AC70 fields."""
+
+from ..base_devices.ProtocolV2Device import ProtocolV2Device
+
+
+class AC70(ProtocolV2Device):
+    def __init__(self, address: str, sn: str):
+        super().__init__(address, "AC70", sn)

custom_components/bluetti_bt/bluetti_bt_lib/devices/ac70p.py

@@ -0,0 +1,8 @@
+"""AC70P fields."""
+
+from ..base_devices.ProtocolV2Device import ProtocolV2Device
+
+
+class AC70P(ProtocolV2Device):
+    def __init__(self, address: str, sn: str):
+        super().__init__(address, "AC70P", sn)

custom_components/bluetti_bt/bluetti_bt_lib/devices/eb3a.py

@@ -25,13 +25,7 @@ class EB3A(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers()
-            ReadHoldingRegisters(77, 1),
-            ReadHoldingRegisters(86, 1),
-            ReadHoldingRegisters(3034, 1),
-            ReadHoldingRegisters(3060, 1),
-            ReadHoldingRegisters(3063, 5),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:

custom_components/bluetti_bt/bluetti_bt_lib/devices/ep500.py

@@ -30,10 +30,11 @@ class EP500(ProtocolV1Device):
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
         self.struct.add_decimal_field("total_battery_voltage", 92, 1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
+        self.struct.add_version_field("pack_bms_version", 201)
 
         # Controls
         self.struct.add_enum_field("ups_mode", 3001, UpsMode)
@@ -49,16 +50,9 @@ class EP500(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 11),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3001, 1),
-            ReadHoldingRegisters(3004, 2),
-            ReadHoldingRegisters(3011, 1),
-            ReadHoldingRegisters(3013, 1),
-            ReadHoldingRegisters(3015, 2),
-            ReadHoldingRegisters(3061, 1),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -70,8 +64,6 @@ class EP500(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
+            ReadHoldingRegisters(201, 2),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16),
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ep500p.py

@@ -30,10 +30,11 @@ class EP500P(ProtocolV1Device):
         # Battery packs
         self.struct.add_uint_field("pack_num_max", 91)  # internal
         self.struct.add_decimal_field("total_battery_voltage", 92, 1)
-        self.struct.add_uint_field("pack_num", 96)  # internal
+        self.struct.add_uint_field("pack_num_result", 96)  # internal
         self.struct.add_decimal_field("pack_voltage", 98, 2)  # Full pack voltage
         self.struct.add_uint_field("pack_battery_percent", 99)
         self.struct.add_decimal_array_field("cell_voltages", 105, 16, 2)  # internal
+        self.struct.add_version_field("pack_bms_version", 201)
 
         # Controls
         self.struct.add_enum_field("ups_mode", 3001, UpsMode)
@@ -49,16 +50,9 @@ class EP500P(ProtocolV1Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers(
-            ReadHoldingRegisters(70, 11),
+            filter=lambda address: address <= 90 or address >= 256 # pack_polling_commands
-            ReadHoldingRegisters(86, 3),
+        )
-            ReadHoldingRegisters(3001, 1),
-            ReadHoldingRegisters(3004, 2),
-            ReadHoldingRegisters(3011, 1),
-            ReadHoldingRegisters(3013, 1),
-            ReadHoldingRegisters(3015, 2),
-            ReadHoldingRegisters(3061, 1),
-        ]
 
     @property
     def writable_ranges(self) -> List[range]:
@@ -70,8 +64,6 @@ class EP500P(ProtocolV1Device):
     @property
     def pack_polling_commands(self) -> List[ReadHoldingRegisters]:
         return [
-            ReadHoldingRegisters(91, 2),
+            ReadHoldingRegisters(91, 37),
-            ReadHoldingRegisters(96, 1),
+            ReadHoldingRegisters(201, 2),
-            ReadHoldingRegisters(98, 2),
-            ReadHoldingRegisters(105, 16),
         ]

custom_components/bluetti_bt/bluetti_bt_lib/devices/ep600.py

@@ -97,28 +97,4 @@ class EP600(ProtocolV2Device):
 
     @property
     def polling_commands(self) -> List[ReadHoldingRegisters]:
-        return super().polling_commands + [
+        return self.struct.get_read_holding_registers()
-            ReadHoldingRegisters(2022, 2),
-            ReadHoldingRegisters(2213, 5),
-            ReadHoldingRegisters(1212, 3),
-            ReadHoldingRegisters(1220, 3),
-            ReadHoldingRegisters(1228, 3),
-            ReadHoldingRegisters(1236, 3),
-            ReadHoldingRegisters(1244, 3),
-            ReadHoldingRegisters(1300, 1),
-            ReadHoldingRegisters(1313, 3),
-            ReadHoldingRegisters(1319, 3),
-            ReadHoldingRegisters(1325, 3),
-            ReadHoldingRegisters(1500, 1),
-            ReadHoldingRegisters(1510, 3),
-            ReadHoldingRegisters(1517, 3),
-            ReadHoldingRegisters(1524, 3),
-            ReadHoldingRegisters(152, 1),
-            ReadHoldingRegisters(156, 1),
-            ReadHoldingRegisters(158, 1),
-            # KM - Consumption
-            ReadHoldingRegisters(1430, 15),
-            # KM - Totals
-            ReadHoldingRegisters(142, 5),
-
-        ]

custom_components/bluetti_bt/bluetti_bt_lib/field_attributes.py

@@ -125,6 +125,14 @@ FIELD_ATTRIBUTES: dict[str, FieldAttributes] = {
     "ac_input_power": PowerFieldAttributes("AC Input Power"),
     "ac_output_power": PowerFieldAttributes("AC Output Power"),
     "dc_output_power": PowerFieldAttributes("DC Output Power"),
+    "dsp_version": FieldAttributes(
+        type=FieldType.NUMERIC,
+        name=f"DSP Version",
+    ),
+    "arm_version": FieldAttributes(
+        type=FieldType.NUMERIC,
+        name=f"ARM Version",
+    ),
     "power_generation": EnergyFieldAttributes("Total Power Generation"),
     "total_battery_percent": FieldAttributes(
         type=FieldType.NUMERIC,
@@ -316,6 +324,16 @@ FIELD_ATTRIBUTES: dict[str, FieldAttributes] = {
         setter=True,
         name="Power Lifting",
     ),
+    "grid_enhancement_mode_on": FieldAttributes(
+        type=FieldType.BOOL,
+        setter=True,
+        name="Grid Enhancement Mode",
+    ),
+    "silent_charging_on": FieldAttributes(
+        type=FieldType.BOOL,
+        setter=True,
+        name="Silent Charging",
+    ),
 }
 
 

custom_components/bluetti_bt/bluetti_bt_lib/utils/device_builder.py

@@ -3,6 +3,8 @@
 import re
 
 from ..devices.ac60 import AC60
+from ..devices.ac70 import AC70
+from ..devices.ac70p import AC70P
 from ..devices.ac180 import AC180
 from ..devices.ac180p import AC180P
 from ..devices.ac200l import AC200L
@@ -17,7 +19,7 @@ from ..devices.ep760 import EP760
 from ..devices.ep800 import EP800
 
 DEVICE_NAME_RE = re.compile(
-    r"^(AC60|AC180|AC180P|AC200L|AC200M|AC300|AC500|EB3A|EP500|EP500P|EP600|EP760|EP800)(\d+)$"
+    r"^(AC60|AC70|AC70P|AC180|AC180P|AC200L|AC200M|AC300|AC500|EB3A|EP500|EP500P|EP600|EP760|EP800)(\d+)$"
 )
 
 
@@ -25,6 +27,10 @@ def build_device(address: str, name: str):
     match = DEVICE_NAME_RE.match(name)
     if match[1] == "AC60":
         return AC60(address, match[2])
+    if match[1] == "AC70":
+        return AC70(address, match[2])
+    if match[1] == "AC70P":
+        return AC70P(address, match[2])
     if match[1] == "AC180":
         return AC180(address, match[2])
     if match[1] == "AC180P":
@@ -53,6 +59,6 @@ def build_device(address: str, name: str):
 
 def get_type_by_bt_name(bt_name: str):
     match = DEVICE_NAME_RE.match(bt_name)
-    if match is None or len(match) < 2:
+    if match is None:
         return "Unknown"
     return match[1]

custom_components/bluetti_bt/bluetti_bt_lib/utils/struct.py

@@ -4,6 +4,7 @@
 
 from decimal import Decimal
 from enum import Enum
+from .commands import ReadHoldingRegisters
 import struct
 from typing import Any, List, Optional, Tuple, Type
 
@@ -30,15 +31,15 @@ class DeviceField:
 
 
 class UintField(DeviceField):
-    def __init__(self, name: str, address: int, range: Optional[Tuple[int, int]], scale: int):
+    def __init__(self, name: str, address: int, range: Optional[Tuple[int, int]], multiplier: float):
         self.range = range
-        self.scale = scale
+        self.multiplier = multiplier
         super().__init__(name, address, 1)
 
     def parse(self, data: bytes) -> int:
         val = struct.unpack("!H", data)[0]
 
-        return val * self.scale
+        return val * self.multiplier
 
     def in_range(self, val: int) -> bool:
         if self.range is None:
@@ -82,15 +83,16 @@ class EnumField(DeviceField):
 
 class DecimalField(DeviceField):
     def __init__(
-        self, name: str, address: int, scale: int, range: Optional[Tuple[int, int]]
+        self, name: str, address: int, scale: int, range: Optional[Tuple[int, int]], multiplier: float
     ):
         self.scale = scale
         self.range = range
+        self.multiplier = multiplier
         super().__init__(name, address, 1)
 
     def parse(self, data: bytes) -> Decimal:
         val = Decimal(struct.unpack("!H", data)[0])
-        return val / 10 ** self.scale
+        return (val / 10 ** self.scale) * Decimal(self.multiplier)
 
     def in_range(self, val: Decimal) -> bool:
         if self.range is None:
@@ -147,8 +149,8 @@ class DeviceStruct:
     def __init__(self):
         self.fields = []
 
-    def add_uint_field(self, name: str, address: int, range: Tuple[int, int] = None, scale: int = 1):
+    def add_uint_field(self, name: str, address: int, range: Tuple[int, int] = None, multiplier: float = 1):
-        self.fields.append(UintField(name, address, range, scale))
+        self.fields.append(UintField(name, address, range, multiplier))
 
     def add_int_field(self, name: str, address: int, range: Tuple[int, int] = None):
         self.fields.append(IntField(name, address, range))
@@ -160,9 +162,9 @@ class DeviceStruct:
         self.fields.append(EnumField(name, address, enum))
 
     def add_decimal_field(
-        self, name: str, address: int, scale: int, range: Tuple[int, int] = None
+        self, name: str, address: int, scale: int, range: Tuple[int, int] = None, multiplier: float = 1
     ):
-        self.fields.append(DecimalField(name, address, scale, range))
+        self.fields.append(DecimalField(name, address, scale, range, multiplier))
 
     def add_decimal_array_field(self, name: str, address: int, size: int, scale: int):
         self.fields.append(DecimalArrayField(name, address, size, scale))
@@ -178,6 +180,35 @@ class DeviceStruct:
 
     def add_sn_field(self, name: str, address: int):
         self.fields.append(SerialNumberField(name, address))
+        
+    def get_read_holding_registers(self, tolerance=20, filter=lambda address: True):
+        address_set = set()
+        for field in self.fields:
+            for address in range(field.address, field.address + field.size):
+                address_set.add(address)
+        # Filter out addresses that we specificly 
+        # specified to exclude.
+        for address in set(address_set):
+            if not filter(address):
+                address_set.remove(address)
+        # Fast path: no addresses -> no commands.
+        if not address_set:
+            return []
+        
+        commands = []
+
+        address_list = sorted(address_set)
+        start = address_list[0]
+        last = address_list[0]
+        for address in address_list[1:]:
+            # Create a new group if there's a gap 
+            # in the addresses.
+            if address >= last + tolerance:
+                commands.append(ReadHoldingRegisters(start, last - start + 1))
+                start = address
+            last = address
+        commands.append(ReadHoldingRegisters(start, last - start + 1))    
+        return commands
 
     def parse(self, starting_address: int, data: bytes) -> dict:
         # Offsets and size are counted in 2 byte chunks, so for the range we

custom_components/bluetti_bt/config_flow.py

@@ -14,7 +14,7 @@ from homeassistant.components.bluetooth import (
     BluetoothServiceInfoBleak,
     async_discovered_service_info,
 )
-from homeassistant.const import CONF_ADDRESS, CONF_NAME
+from homeassistant.const import CONF_ADDRESS, CONF_NAME, CONF_TYPE
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers import selector
 
@@ -22,6 +22,7 @@ from .bluetti_bt_lib.utils.device_builder import get_type_by_bt_name
 from .bluetti_bt_lib.bluetooth.device_recognizer import recognize_device
 
 from .const import (
+    CONF_ENCRYPTION,
     CONF_MAX_RETRIES,
     CONF_PERSISTENT_CONN,
     CONF_POLLING_INTERVAL,
@@ -48,11 +49,20 @@ class BluettiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         await self.async_set_unique_id(discovery_info.address)
         self._abort_if_unique_id_configured()
 
+        if isinstance(discovery_info.name, str):
+            name = re.sub("[^A-Z0-9]+", "", discovery_info.name)
+            discovery_info.manufacturer_data = {
+                CONF_TYPE: get_type_by_bt_name(name)
+            }
+
         # Get device type if needed
         if isinstance(discovery_info.name, str) and discovery_info.name.startswith("PBOX"):
             bleak_device = BleakClient(discovery_info.device)
             device_type = await recognize_device(bleak_device, self.hass.loop.create_future)
             _LOGGER.info("Device identified as %s", device_type)
+            discovery_info.manufacturer_data = {
+                CONF_TYPE: device_type.strip(),
+            }
             discovery_info.name = discovery_info.name.replace("PBOX", device_type.strip())
 
         self._discovery_info = discovery_info
@@ -76,6 +86,7 @@ class BluettiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                 data={
                     CONF_ADDRESS: discovery_info.address,
                     CONF_NAME: name,
+                    CONF_TYPE: discovery_info.manufacturer_data.get(CONF_TYPE, "Unknown"),
                 },
             )
 
@@ -140,7 +151,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
             if user_input[CONF_MAX_RETRIES] < 1:
                 return self.async_abort(reason="invalid_retries")
 
-            changed = self.hass.config_entries.async_update_entry(
+            self.hass.config_entries.async_update_entry(
                 self.config_entry,
                 data={
                     **self.config_entry.data,
@@ -150,14 +161,10 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                         CONF_POLLING_INTERVAL: user_input[CONF_POLLING_INTERVAL],
                         CONF_POLLING_TIMEOUT: user_input[CONF_POLLING_TIMEOUT],
                         CONF_MAX_RETRIES: user_input[CONF_MAX_RETRIES],
+                        CONF_ENCRYPTION: user_input[CONF_ENCRYPTION],
                     },
                 },
             )
-            if changed is False:
-                _LOGGER.error(
-                    "Method OptionsFlowHandler.async_step_init: Config entry %s has not been changed",
-                    self.config_entry.entry_id,
-                )
             return self.async_create_entry(
                 title="",
                 data={
@@ -166,6 +173,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                     CONF_POLLING_INTERVAL: user_input[CONF_POLLING_INTERVAL],
                     CONF_POLLING_TIMEOUT: user_input[CONF_POLLING_TIMEOUT],
                     CONF_MAX_RETRIES: user_input[CONF_MAX_RETRIES],
+                    CONF_ENCRYPTION: user_input[CONF_ENCRYPTION],
                 },
             )
 
@@ -193,6 +201,10 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                         CONF_MAX_RETRIES,
                         default=self.config_entry.data.get(CONF_MAX_RETRIES, 5),
                     ): int,
+                    vol.Required(
+                        CONF_ENCRYPTION,
+                        default=self.config_entry.data.get(CONF_ENCRYPTION, False),
+                    ): selector.BooleanSelector(),
                 }
             ),
         )

custom_components/bluetti_bt/const.py

@@ -9,6 +9,7 @@ CONF_PERSISTENT_CONN = "persistent_conn"
 CONF_POLLING_INTERVAL = "polling_interval"
 CONF_POLLING_TIMEOUT = "polling_timeout"
 CONF_MAX_RETRIES = "max_retries"
+CONF_ENCRYPTION = "use_encryption"
 
 DATA_COORDINATOR = "coordinator"
 DATA_POLLING_RUNNING = "polling_running"
@@ -23,6 +24,7 @@ SUPPORTED_MODELS = [
     "EP500P",
     "EP600",
     "EP760",
+    "AC180P",
 ]
 
 CONTROL_FIELDS = [
@@ -31,6 +33,8 @@ CONTROL_FIELDS = [
     "power_off",
     "eco_on",
     "power_lifting_on",
+    "grid_enhancement_mode_on",
+    "silent_charging_on",
 ]
 
 DIAGNOSTIC_FIELDS = [
@@ -39,10 +43,13 @@ DIAGNOSTIC_FIELDS = [
     "max_ac_output_power",
     "max_ac_output_current",
     "bcu_version",
+    "dsp_version",
+    "arm_version",
     "safety_module_version",
     "high_voltage_module_version",
     "power_generation",
     "total_ac_consumption",
     "total_grid_consumption",
     "total_grid_feed",
+    "ac_input_voltage",
 ]

custom_components/bluetti_bt/coordinator.py

@@ -33,6 +33,7 @@ class PollingCoordinator(DataUpdateCoordinator):
         persistent_conn: bool,
         polling_timeout: int,
         max_retries: int,
+        encrypted: bool,
     ):
         """Initialize coordinator."""
         super().__init__(
@@ -60,6 +61,7 @@ class PollingCoordinator(DataUpdateCoordinator):
             persistent_conn=persistent_conn,
             polling_timeout=polling_timeout,
             max_retries=max_retries,
+            encrypted=encrypted,
         )
 
     async def _async_update_data(self):

custom_components/bluetti_bt/manifest.json

@@ -3,6 +3,7 @@
     "name": "Bluetti BT",
     "bluetooth": [
         { "local_name": "AC60*" },
+        { "local_name": "AC70*" },
         { "local_name": "AC180*" },
         { "local_name": "AC200L*" },
         { "local_name": "AC200M*" },
@@ -23,5 +24,5 @@
     "iot_class": "local_polling",
     "issue_tracker": "https://github.com/Patrick762/hassio-bluetti-bt/issues",
     "requirements": [],
-    "version": "0.0.24"
+    "version": "0.1.4"
 }

custom_components/bluetti_bt/sensor.py

@@ -57,7 +57,7 @@ async def async_setup_entry(
                 all_fields.update({name+str(pack): field})
 
     for field_key, field_config in all_fields.items():
-        if bluetti_device.has_field(field_key):
+        if bluetti_device.has_field(field_key) or (len(bluetti_device.pack_polling_commands) > 0 and field_key.startswith("pack_")):
             category = None
             if field_config.setter is True or field_key in DIAGNOSTIC_FIELDS:
                 category = EntityCategory.DIAGNOSTIC
@@ -114,6 +114,7 @@ class BluettiSensor(CoordinatorEntity, SensorEntity):
         e_name = f"{device_info.get('name')} {name}"
         self._address = address
         self._response_key = response_key
+        self._unavailable_counter = 0
 
         self._attr_device_info = device_info
         self._attr_name = name
@@ -130,6 +131,27 @@ class BluettiSensor(CoordinatorEntity, SensorEntity):
         """Return if entity is available."""
         return self._attr_available
 
+    def _set_available(self):
+        """Set sensor as available."""
+        self._attr_available = True
+        self._unavailable_counter = 0
+        self._attr_extra_state_attributes = {}
+        self.async_write_ha_state()
+
+    def _set_unavailable(self, cause: str = "Unknown"):
+        """Set sensor as unavailable."""
+        self._unavailable_counter += 1
+
+        self._attr_extra_state_attributes = {
+            "unavailable_counter": self._unavailable_counter,
+            "unavailable_cause": cause,
+        }
+
+        if self._unavailable_counter >= 5:
+            self._attr_available = False
+
+        self.async_write_ha_state()
+
     @callback
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
@@ -141,8 +163,7 @@ class BluettiSensor(CoordinatorEntity, SensorEntity):
             _LOGGER.debug(
                 "Data from coordinator is None",
             )
-            self._attr_available = False
+            self._set_unavailable("Data is None")
-            self.async_write_ha_state()
             return
 
         _LOGGER.debug("Updating state of %s", unique_id_loggable(self._attr_unique_id))
@@ -150,15 +171,13 @@ class BluettiSensor(CoordinatorEntity, SensorEntity):
             _LOGGER.warning(
                 "Invalid data from coordinator (sensor.%s)", unique_id_loggable(self._attr_unique_id)
             )
-            self._attr_available = False
+            self._set_unavailable("Invalid data")
-            self.async_write_ha_state()
             return
 
         response_data = self.coordinator.data.get(self._response_key)
         if response_data is None:
-            _LOGGER.warning("No data for available for (%s)", self._response_key)
+            _LOGGER.debug("No data for available for (%s)", self._response_key)
-            self._attr_available = False
+            self._set_unavailable("No data")
-            self.async_write_ha_state()
             return
 
         if (
@@ -174,11 +193,10 @@ class BluettiSensor(CoordinatorEntity, SensorEntity):
                 response_data,
                 type(response_data),
             )
-            self._attr_available = False
+            self._set_unavailable("Invalid data type")
-            self.async_write_ha_state()
             return
 
-        self._attr_available = True
+        self._set_available()
 
         # Different for enum and numeric
         if (

custom_components/bluetti_bt/translations/de.json

@@ -17,7 +17,8 @@
           "persistent_conn": "Dauerhafte Verbindung (Neustart erforderlich)",
           "polling_interval": "Datenabruf-Intervall in Sekunden (Neustart erforderlich)",
           "polling_timeout": "Datenabruf-Timeout in Sekunden (Neustart erforderlich)",
-          "max_retries": "Maximale Verbindungsversuche (Neustart erforderlich)"
+          "max_retries": "Maximale Verbindungsversuche (Neustart erforderlich)",
+          "use_encryption": "Verschlüsselte Verbindung (erforderlich für neue Firmware-Versionen)"
         }
       }
     },

custom_components/bluetti_bt/translations/en.json

@@ -17,7 +17,8 @@
           "persistent_conn": "Persistent connection (restart required)",
           "polling_interval": "Polling interval in seconds (restart required)",
           "polling_timeout": "Polling timeout in seconds (restart required)",
-          "max_retries": "Maximum amount of connection retries (restart required)"
+          "max_retries": "Maximum amount of connection retries (restart required)",
+          "use_encryption": "Encrypted connection (necessary for latest firmware versions)"
         }
       }
     },

deploy.sh

@@ -2,4 +2,7 @@
 
 # This script is only for development purposes
 
+sudo rm -rf /var/ha_config/custom_components/*/__pycache__
 sudo cp -r ./custom_components/* /var/ha_config/custom_components/
+docker restart homeassistant
+docker logs -f homeassistant

requirements.txt

@@ -0,0 +1,12 @@
+homeassistant
+bleak_retry_connector
+pyserial
+bluetooth_auto_recovery
+crcmod
+typing
+asyncio
+logging
+bleak
+async_timeout
+aiousbwatcher
+pyasn1

test.sh

@@ -1,4 +1,4 @@
 #!/bin/sh
 
-# Execute unittests of python library
+# Execute unittests of python library inside docker
-python3 -m unittest discover -s tests -p "*_test.py"
+sudo docker build --progress=plain -t bluetti-bt-tests .

tests/device_builder_test.py

@@ -4,8 +4,11 @@ import unittest
 
 from custom_components.bluetti_bt.bluetti_bt_lib.utils.device_builder import build_device
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac60 import AC60
+from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac70 import AC70
+from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac70p import AC70P
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac180 import AC180
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac180p import AC180P
+from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac200l import AC200L
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac200m import AC200M
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac300 import AC300
 from custom_components.bluetti_bt.bluetti_bt_lib.devices.ac500 import AC500
@@ -32,6 +35,22 @@ class TestDeviceBuilder(unittest.TestCase):
         self.assertIsInstance(built, AC60)
         self.assertEqual(built.address, bt_addr)
 
+    def test_build_ac70(self):
+        bt_addr = "aa:bb:cc:dd:ee:ff"
+        bt_name = "AC7056786746478"
+        built = build_device(bt_addr, bt_name)
+
+        self.assertIsInstance(built, AC70)
+        self.assertEqual(built.address, bt_addr)
+
+    def test_build_ac70p(self):
+        bt_addr = "aa:bb:cc:dd:ee:ff"
+        bt_name = "AC70P56786746478"
+        built = build_device(bt_addr, bt_name)
+
+        self.assertIsInstance(built, AC70P)
+        self.assertEqual(built.address, bt_addr)
+
     def test_build_ac180(self):
         bt_addr = "aa:bb:cc:dd:ee:ff"
         bt_name = "AC18056786746478"
@@ -48,6 +67,14 @@ class TestDeviceBuilder(unittest.TestCase):
         self.assertIsInstance(built, AC180P)
         self.assertEqual(built.address, bt_addr)
 
+    def test_build_ac200l(self):
+        bt_addr = "aa:bb:cc:dd:ee:ff"
+        bt_name = "AC200L56786746478"
+        built = build_device(bt_addr, bt_name)
+
+        self.assertIsInstance(built, AC200L)
+        self.assertEqual(built.address, bt_addr)
+
     def test_build_ac200m(self):
         bt_addr = "aa:bb:cc:dd:ee:ff"
         bt_name = "AC200M56786746478"

tests/device_struct_test.py

@@ -0,0 +1,24 @@
+"""Unittest for device struct."""
+
+import unittest
+
+from custom_components.bluetti_bt.bluetti_bt_lib.utils.commands import ReadHoldingRegisters
+from custom_components.bluetti_bt.bluetti_bt_lib.utils.struct import DeviceStruct
+
+class TestDeviceStruct(unittest.TestCase):
+    def test_get_read_holding_registers(self):
+        struct = DeviceStruct()
+
+        struct.add_swap_string_field("device_type", 110, 6)
+        struct.add_sn_field("serial_number", 116)
+        struct.add_decimal_field(
+            "power_generation", 154, 1
+        )
+        struct.add_uint_field("total_battery_percent", 102)
+
+        registers = struct.get_read_holding_registers()
+
+        self.assertGreater(len(registers), 0)
+
+        for reg in registers:
+            self.assertIsInstance(reg, ReadHoldingRegisters)