SolixBLE 3.7.0__tar.gz → 3.8.0__tar.gz

{solixble-3.7.0 → solixble-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SolixBLE
-Version: 3.7.0
+Version: 3.8.0
 Summary: Python module for monitoring & controlling Bluetooth Anker Solix devices
 Author-email: Harvey Lelliott <harveylelliott@duck.com>
 License: MIT License
@@ -138,3 +138,8 @@ pip install SolixBLE
 See the `Generic` class inside `SolixBLE/devices/generic.py` and the 
 [documentation](https://solixble.readthedocs.io/en/latest/new_devices.html)
 for guidance on how to add support for new devices.
+
+
+## Disclaimer
+
+SolixBLE is a software library designed to work with Anker Solix/Prime devices. ANKER is a registered trademark of Anker Innovations Limited. This project is not affiliated with, endorsed by, or sponsored by Anker Innovations Limited (Though I wouldn't mind being sponsored 😉). All other trademarks cited herein are the property of their respective owners.

{solixble-3.7.0 → solixble-3.8.0}/README.md

@@ -89,3 +89,8 @@ pip install SolixBLE
 See the `Generic` class inside `SolixBLE/devices/generic.py` and the 
 [documentation](https://solixble.readthedocs.io/en/latest/new_devices.html)
 for guidance on how to add support for new devices.
+
+
+## Disclaimer
+
+SolixBLE is a software library designed to work with Anker Solix/Prime devices. ANKER is a registered trademark of Anker Innovations Limited. This project is not affiliated with, endorsed by, or sponsored by Anker Innovations Limited (Though I wouldn't mind being sponsored 😉). All other trademarks cited herein are the property of their respective owners.

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE/__init__.py

@@ -16,6 +16,7 @@ from .devices import (
     Generic,
     PrimeCharger160w,
     PrimeCharger250w,
+    PrimePowerBank20k,
     Solarbank2,
     Solarbank3,
 )
@@ -25,9 +26,9 @@ from .states import (
     ChargingStatusF3800,
     DisplayTimeout,
     LightStatus,
+    PortOverload,
     PortStatus,
     TemperatureUnit,
-    PortOverload,
 )
 from .utilities import discover_devices
 
@@ -45,6 +46,7 @@ __all__ = [
     "Solarbank3",
     "PrimeCharger160w",
     "PrimeCharger250w",
+    "PrimePowerBank20k",
     "Generic",
     "ChargingStatus",
     "ChargingStatusF3800",

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE/device.py

@@ -52,6 +52,11 @@ _LOGGER = logging.getLogger(__name__)
 class SolixBLEDevice:
     """Solix BLE device object."""
 
+    #: Command codes (hex) that carry telemetry for this device. Subclasses can
+    #: override this if their model uses different telemetry command codes
+    #: (e.g the C1000 Gen 2 uses ``c421``/``c900`` instead of ``c402``/``c405``).
+    _TELEMETRY_COMMANDS: tuple[str, ...] = ("c402", "4300", "c405")
+
     def __init__(self, ble_device: BLEDevice) -> None:
         """Initialise device object. Does not connect automatically."""
 
@@ -195,6 +200,15 @@ class SolixBLEDevice:
         if self._disconnect_event.is_set():
             self._disconnect_event.clear()
 
+        # Run any device-specific post-connect setup (e.g sending a subscribe
+        # command to start telemetry). This runs on every (re)connection. Errors
+        # are logged but do not abort the connection; the automatic reconnect
+        # task will retry.
+        try:
+            await self._post_connect()
+        except Exception:
+            _LOGGER.exception(f"Error running post-connect setup for '{self.name}'!")
+
         # Start an automatic reconnect task if its not running already
         if self._auto_reconnect_task is None:
             self._auto_reconnect_task = asyncio.create_task(self._auto_reconnect())
@@ -205,6 +219,17 @@ class SolixBLEDevice:
 
         return True
 
+    async def _post_connect(self) -> None:
+        """Run device-specific setup after a negotiated connection is established.
+
+        Called by :meth:`connect` once the encrypted session has been negotiated
+        (so :meth:`_send_command` may be used) and on every automatic reconnect.
+        The default implementation does nothing; subclasses can override it to,
+        for example, send a subscribe command to start a telemetry stream (see
+        :class:`~SolixBLE.devices.c1000g2.C1000G2`).
+        """
+        pass
+
     async def disconnect(self) -> None:
         """Disconnect from device and reset internal state.
 
@@ -493,7 +518,9 @@ class SolixBLEDevice:
         )
         return cipher.encrypt(padded_data)
 
-    async def _process_telemetry_packet(self, payload: bytes, cmd: bytes = None) -> None:
+    async def _process_telemetry_packet(
+        self, payload: bytes, cmd: bytes = None
+    ) -> None:
         """Process a telemetry packet from the device.
 
         This performs the default processing of telemetry packets in which
@@ -533,14 +560,12 @@ class SolixBLEDevice:
             )
             del self._fragment_buffers[cmd_key]
             del self._fragment_totals[cmd_key]
-            _LOGGER.debug(
-                f"Reassembled payload: {len(payload)} bytes"
-            )
+            _LOGGER.debug(f"Reassembled payload: {len(payload)} bytes")
 
         else:
             # Strip fragment info
             payload = payload[1:]
-        
+
         decrypted_payload = self._decrypt_payload(payload)
         _LOGGER.debug(f"Decrypted payload: {decrypted_payload.hex()}")
         parameters = self._parse_payload(decrypted_payload)
@@ -615,51 +640,55 @@ class SolixBLEDevice:
         # Match against common message types
         match pattern.hex():
 
-            # Encryption negotiation
+            # Negotiation messages
             case "030001":
-                _LOGGER.debug("Received encryption negotiation message!")
+                _LOGGER.debug("Received negotiation message!")
                 return await self._process_negotiation(cmd, payload)
 
-            # Encrypted messages
+            # Session messages
             case "03010f" | "030111":
 
-                match cmd.hex():
-
-                    # Telemetry messages
-                    case "c402" | "4300" | "c405":
-                        _LOGGER.debug("Received telemetry message!")
-                        return await self._process_telemetry_packet(payload, cmd)
-
-                    # Unknown messages
-                    case _:
-                        _LOGGER.debug(f"Received unknown message of type: {cmd.hex()}")
-                        try:
-
-                            # If the payload is one byte too short and we are
-                            # using the default AES (CBC) then try putting the
-                            # last byte of the cmd in front of it
-                            if (
-                                len(payload) % 16 == 15
-                                and self._decrypt_payload
-                                is SolixBLEDevice._decrypt_payload
-                            ):
-                                _LOGGER.debug(
-                                    "Using special trick of embedded part of CMD in payload..."
-                                )
-                                payload = cmd[1].to_bytes() + payload
+                # Non-encrypted telemetry messages
+                if cmd.hex() == "0300":
+                    _LOGGER.debug("Received non-encrypted telemetry message!")
+                    parameters = self._parse_payload(payload)
+                    return await self._process_telemetry(parameters)
 
-                            decrypted_payload = self._decrypt_payload(payload)
-                            _LOGGER.debug(
-                                f"Decrypted payload: {decrypted_payload.hex()}"
-                            )
-                            parameters = self._parse_payload(decrypted_payload)
+                # Encrypted telemetry messages
+                elif cmd.hex() in self._TELEMETRY_COMMANDS:
+                    _LOGGER.debug("Received encrypted telemetry message!")
+                    return await self._process_telemetry_packet(payload, cmd)
+
+                # Unknown messages
+                else:
+                    _LOGGER.debug(f"Received unknown message of type: {cmd.hex()}")
+                    try:
+
+                        # If the payload is one byte too short and we are
+                        # using the default AES (CBC) then try putting the
+                        # last byte of the cmd in front of it
+                        if (
+                            len(payload) % 16 == 15
+                            and self._decrypt_payload
+                            is SolixBLEDevice._decrypt_payload
+                        ):
                             _LOGGER.debug(
-                                f"Parameters: {self._parameters_to_str(parameters, types=True)}"
-                            )
-                        except Exception:
-                            _LOGGER.exception(
-                                "Exception decrypting unknown message type"
+                                "Using special trick of embedded part of CMD in payload..."
                             )
+                            payload = cmd[1].to_bytes() + payload
+
+                        decrypted_payload = self._decrypt_payload(payload)
+                        _LOGGER.debug(
+                            f"Decrypted payload: {decrypted_payload.hex()}"
+                        )
+                        parameters = self._parse_payload(decrypted_payload)
+                        _LOGGER.debug(
+                            f"Parameters: {self._parameters_to_str(parameters, types=True)}"
+                        )
+                    except Exception:
+                        _LOGGER.exception(
+                            "Exception decrypting unknown message type"
+                        )
 
             case _:
                 _LOGGER.warning(

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE/devices/__init__.py

@@ -14,6 +14,7 @@ from .f3800 import F3800
 from .generic import Generic
 from .prime_charger_160w import PrimeCharger160w
 from .prime_charger_250w import PrimeCharger250w
+from .prime_power_bank_20k import PrimePowerBank20k
 from .solarbank2 import Solarbank2
 from .solarbank3 import Solarbank3
 
@@ -29,5 +30,6 @@ __all__ = [
     "Solarbank3",
     "PrimeCharger160w",
     "PrimeCharger250w",
+    "PrimePowerBank20k",
     "Generic",
 ]

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE/devices/c1000g2.py

@@ -4,33 +4,96 @@
 
 """
 
-from ..const import DEFAULT_METADATA_BOOL
 from ..device import SolixBLEDevice
 from ..states import PortStatus
 
+#: Command sent after connecting to start the telemetry stream. Unlike the gen-1
+#: models, the Gen 2 streams nothing until it receives this subscribe command.
+CMD_SUBSCRIBE = "4100"
+SUBSCRIBE_PAYLOAD = "a10121"
+
+CMD_AC_OUTPUT = "4101"
+CMD_DC_OUTPUT = "4102"
+
+PAYLOAD_ON = "a10121a2020101"
+PAYLOAD_OFF = "a10121a2020100"
+
 
 class C1000G2(SolixBLEDevice):
     """
     C1000(X) Gen 2 Power Station.
 
-    Use this class to connect and monitor a Gen 2 C1000(X) power station.
-    This model is also known as the A1763.
-
-    .. note::
-        This model was added using data from anker-solix-api. It has not been
-        tested!
-
-    .. note::
-        It should be possible to add more sensors. I think devices with lots of
-        telemetry values split them up into multiple messages but I have not
-        played around with this yet. That and I am being a bit conservative with
-        these initial implementations, if you want more sensors and are willing
-        to help with testing feel free to raise a GitHub issue.
+    Use this class to connect, monitor and control a Gen 2 C1000(X) power
+    station. This model is also known as the A1763.
 
+    The Gen 2 uses the same encryption and telemetry framing as the gen-1
+    models but with different command codes: it must be sent a subscribe command
+    (``4100``) after connecting before it streams any telemetry, its telemetry
+    arrives on commands ``c421``/``c900``, its AC output is controlled with
+    command ``4101`` and its DC output with command ``4102``. Telemetry and
+    AC/DC on/off control have been confirmed on real hardware.
     """
 
     _EXPECTED_TELEMETRY_LENGTH: int = 253
 
+    #: The Gen 2 pushes telemetry on different command codes to the gen-1 models.
+    _TELEMETRY_COMMANDS: tuple[str, ...] = ("c421", "c900")
+
+    async def _post_connect(self) -> None:
+        """Subscribe to telemetry once connected.
+
+        The Gen 2 streams no telemetry until it receives this command, so we send
+        it after every (re)connection.
+        """
+        await self._send_command(
+            cmd=bytes.fromhex(CMD_SUBSCRIBE),
+            payload=bytes.fromhex(SUBSCRIBE_PAYLOAD),
+        )
+
+    async def turn_ac_on(self) -> None:
+        """Turn the AC output on.
+
+        :raises ConnectionError: If not connected to device.
+        :raises BleakError: If command transmission fails.
+        """
+        await self._send_command(
+            cmd=bytes.fromhex(CMD_AC_OUTPUT), payload=bytes.fromhex(PAYLOAD_ON)
+        )
+
+    async def turn_ac_off(self) -> None:
+        """Turn the AC output off.
+
+        :raises ConnectionError: If not connected to device.
+        :raises BleakError: If command transmission fails.
+        """
+        await self._send_command(
+            cmd=bytes.fromhex(CMD_AC_OUTPUT), payload=bytes.fromhex(PAYLOAD_OFF)
+        )
+
+    async def turn_dc_on(self) -> None:
+        """Turn the DC (12 V) output on.
+
+        Confirmed on real hardware: the 12 V port physically switched and the
+        ``b2`` status byte latched on. The Gen 2 reuses the AC on/off payload on
+        a different command code (``4102``).
+
+        :raises ConnectionError: If not connected to device.
+        :raises BleakError: If command transmission fails.
+        """
+        await self._send_command(
+            cmd=bytes.fromhex(CMD_DC_OUTPUT), payload=bytes.fromhex(PAYLOAD_ON)
+        )
+
+    async def turn_dc_off(self) -> None:
+        """Turn the DC (12 V) output off.
+
+        :raises ConnectionError: If not connected to device.
+        :raises BleakError: If command transmission fails.
+        """
+        await self._send_command(
+            cmd=bytes.fromhex(CMD_DC_OUTPUT), payload=bytes.fromhex(PAYLOAD_OFF)
+        )
+
     @property
     def serial_number(self) -> str:
         """Device serial number.
@@ -73,7 +136,7 @@ class C1000G2(SolixBLEDevice):
 
     @property
     def power_out(self) -> int:
-        """Total Power Out.
+        """Total Power Out (watts).
 
         :returns: Total power out or default int value.
         """
@@ -81,7 +144,7 @@ class C1000G2(SolixBLEDevice):
 
     @property
     def ac_power_in(self) -> int:
-        """AC Power In.
+        """AC Power In (watts).
 
         :returns: Total AC power in or default int value.
         """
@@ -94,13 +157,24 @@ class C1000G2(SolixBLEDevice):
         PortStatus.NOT_CONNECTED signifies off.
         PortStatus.OUTPUT signifies on.
 
+        .. note::
+           :collapsible: closed
+
+           The AC port status is the first byte of the ``a7`` parameter,
+           mirroring the ``04 <status> <watts LE>`` per-port shape used by the
+           DC port (``b2``) and the USB ports; ``ac_power_out`` reads the watts
+           from this same ``a7`` TLV. Confirmed on hardware: ``a7[1]`` latches
+           ``01`` (OUTPUT) when AC is on and ``00`` when off, tracking the relay.
+           (The ``a4`` parameter is constant at the previously-used offset and
+           does NOT reflect the AC state.)
+
         :returns: Status of the AC port.
         """
         return PortStatus(self._parse_int("a7", begin=1, end=2))
 
     @property
     def ac_power_out(self) -> int:
-        """AC Power Out.
+        """AC Power Out (watts).
 
         :returns: Total AC power out or default int value.
         """
@@ -116,7 +190,9 @@ class C1000G2(SolixBLEDevice):
 
     @property
     def solar_power_in(self) -> int:
-        """Solar/DC Power In.
+        """Solar/DC Power In (watts).
+
+        .. note:: Offset inferred, not yet confirmed on hardware (no solar/DC-in capture taken).
 
         :returns: Solar/DC power in or default int value.
         """
@@ -164,7 +240,7 @@ class C1000G2(SolixBLEDevice):
 
     @property
     def usb_c3_power(self) -> int:
-        """USB C3 Power.
+        """USB C3 Power (watts).
 
         :returns: USB port C3 power or default int value.
         """
@@ -190,13 +266,19 @@ class C1000G2(SolixBLEDevice):
     def dc_output(self) -> PortStatus:
         """DC Port Status.
 
+        Confirmed on hardware: ``b2[1]`` latched ``01`` (OUTPUT) when the 12 V
+        port was switched on and ``00`` (NOT_CONNECTED) when off.
+
         :returns: Status of the DC output port.
         """
         return PortStatus(self._parse_int("b2", begin=1, end=2))
 
     @property
     def dc_power_out(self) -> int:
-        """DC Power Out.
+        """DC Power Out (watts).
+
+        Confirmed on hardware: ``b2`` [2:4] read 6 W with a 12 V load on the DC
+        output, matching the ``04 <status> <watts LE>`` per-port shape.
 
         :returns: DC power out or default int value.
         """

solixble-3.8.0/SolixBLE/devices/prime_power_bank_20k.py

@@ -0,0 +1,173 @@
+"""Anker Prime Power Bank 20k (220w) model.
+
+.. moduleauthor:: Harvey Lelliott (flip-dots) <harveylelliott@duck.com>
+
+"""
+
+from ..const import DEFAULT_METADATA_FLOAT
+from ..prime_device import PrimeDevice
+from ..states import PortStatus
+
+
+class PrimePowerBank20k(PrimeDevice):
+    """
+    Anker Prime Power Bank 20k (220w) model.
+
+    Use this class to connect and monitor the 220w power bank.
+    This model is also known as the A110B.
+    """
+
+    @property
+    def battery_percentage(self) -> int:
+        """Battery Percentage.
+
+        :returns: Percentage charge of battery or default int value.
+        """
+        return self._parse_int("a2", begin=1, end=2)
+
+    @property
+    def power_out(self) -> int:
+        """Total Power Out.
+
+        :returns: Total power out or default int value.
+        """
+        return self._parse_int("a6", begin=2, end=4) / 10.0
+
+    @property
+    def temperature(self) -> int:
+        """Temperature of the unit (C).
+
+        :returns: Temperature of the unit in degrees C.
+        """
+        return self._parse_int("af", begin=1, signed=True)
+
+    @property
+    def usb_port_c1(self) -> PortStatus:
+        """USB C1 Port Status.
+
+        :returns: Status of the USB C1 port.
+        """
+        return PortStatus(self._parse_int("a8", begin=1, end=2))
+
+    @property
+    def usb_c1_voltage(self) -> float:
+        """USB C1 Port voltage (V).
+
+        :returns: Voltage of the USB C1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a8", begin=2, end=4) / 10.0
+
+    @property
+    def usb_c1_current(self) -> float:
+        """USB C1 Port current (A).
+
+        :returns: Current of the USB C1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a8", begin=4, end=6) / 10.0
+
+    @property
+    def usb_c1_power(self) -> float:
+        """USB C1 Port power (W).
+
+         .. important::
+
+            There appears to be a firmware bug in the power bank which
+            causes the value of USB C1 power to latch to whatever its 
+            last value was when unplugged, this does not happen with
+            USB C2 power for some reason. This has been observed on 
+            version v1.6.0.5.
+
+        :returns: Power of the USB C1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a8", begin=6, end=8) / 10.0
+
+    @property
+    def usb_port_c2(self) -> PortStatus:
+        """USB C2 Port Status.
+
+        :returns: Status of the USB C2 port.
+        """
+        return PortStatus(self._parse_int("a9", begin=1, end=2))
+
+    @property
+    def usb_c2_voltage(self) -> float:
+        """USB C2 Port voltage (V).
+
+        :returns: Voltage of the USB C2 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a9", begin=2, end=4) / 10.0
+
+    @property
+    def usb_c2_current(self) -> float:
+        """USB C2 Port current (A).
+
+        :returns: Current of the USB C2 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a9", begin=4, end=6) / 10.0
+    
+    @property
+    def usb_c2_power(self) -> float:
+        """USB C2 Port power (W).
+
+        :returns: Power of the USB C2 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("a9", begin=6, end=8) / 10.0
+    
+    @property
+    def usb_port_a1(self) -> PortStatus:
+        """USB A1 Port Status.
+
+        :returns: Status of the USB A1 port.
+        """
+        return PortStatus(self._parse_int("ac", begin=1, end=2))
+
+    @property
+    def usb_a1_voltage(self) -> float:
+        """USB A1 Port voltage (V).
+
+        :returns: Voltage of the USB A1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("ac", begin=2, end=4) / 10.0
+
+    @property
+    def usb_a1_current(self) -> float:
+        """USB A1 Port current (A).
+
+        :returns: Current of the USB A1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("ac", begin=4, end=6) / 10.0
+    
+    @property
+    def usb_a1_power(self) -> float:
+        """USB A1 Port power (W).
+
+        :returns: Power of the USB A1 port or default float value.
+        """
+        if self._data is None:
+            return DEFAULT_METADATA_FLOAT
+
+        return self._parse_int("ac", begin=6, end=8) / 10.0

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE/prime_device.py

@@ -487,7 +487,9 @@ class PrimeDevice(SolixBLEDevice):
     # Packet processing #
     #####################
 
-    async def _process_telemetry_packet(self, payload: bytes, cmd: bytes = None) -> None:
+    async def _process_telemetry_packet(
+        self, payload: bytes, cmd: bytes = None
+    ) -> None:
         """
         Process a telemetry packet from an Anker Prime device.
 

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SolixBLE
-Version: 3.7.0
+Version: 3.8.0
 Summary: Python module for monitoring & controlling Bluetooth Anker Solix devices
 Author-email: Harvey Lelliott <harveylelliott@duck.com>
 License: MIT License
@@ -138,3 +138,8 @@ pip install SolixBLE
 See the `Generic` class inside `SolixBLE/devices/generic.py` and the 
 [documentation](https://solixble.readthedocs.io/en/latest/new_devices.html)
 for guidance on how to add support for new devices.
+
+
+## Disclaimer
+
+SolixBLE is a software library designed to work with Anker Solix/Prime devices. ANKER is a registered trademark of Anker Innovations Limited. This project is not affiliated with, endorsed by, or sponsored by Anker Innovations Limited (Though I wouldn't mind being sponsored 😉). All other trademarks cited herein are the property of their respective owners.

{solixble-3.7.0 → solixble-3.8.0}/SolixBLE.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ SolixBLE/devices/f3800.py
 SolixBLE/devices/generic.py
 SolixBLE/devices/prime_charger_160w.py
 SolixBLE/devices/prime_charger_250w.py
+SolixBLE/devices/prime_power_bank_20k.py
 SolixBLE/devices/solarbank2.py
 SolixBLE/devices/solarbank3.py
 tests/test_connection.py

{solixble-3.7.0 → solixble-3.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "SolixBLE"
-version = "3.7.0"
+version = "3.8.0"
 dependencies = [
   "bleak>=0.19.0",
   "cryptography",
@@ -27,6 +27,13 @@ classifiers = [
     "Programming Language :: Python :: 3.11"
 ]
 
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["D202", "D212", "D213", "G004"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
 [project.urls]
 Homepage = "https://github.com/flip-dots/SolixBLE"
 Documentation = "https://solixble.readthedocs.io/en/latest/"

{solixble-3.7.0 → solixble-3.8.0}/tests/test_devices.py

@@ -7,6 +7,7 @@
 import asyncio
 import logging
 from typing import Any
+from unittest import mock
 
 import pytest
 
@@ -22,6 +23,7 @@ from SolixBLE import (
     PortStatus,
     PrimeCharger160w,
     PrimeDevice,
+    PrimePowerBank20k,
     Solarbank2,
     SolixBLEDevice,
     TemperatureUnit,
@@ -265,6 +267,71 @@ from tests.helpers import MockDevice
             },
             id="c1000g2",
         ),
+        # The two cases below are decrypted telemetry frames captured from a real
+        # C1000 Gen 2 (A1763) on 2026-06-21 with the AC output physically off then
+        # on (idle, no load). They are identical except for the "a7" param, which
+        # locks in the AC output decode: ac_output is "a7" byte 1 (00=off, 01=on,
+        # latched) -- the same per-port "04 <status> <watts LE>" shape used by the
+        # DC port (b2) and USB ports. ("a4" byte 22 is NOT the AC state: it stayed
+        # 01 with the port physically off, so an a4-based decode reports a false
+        # OUTPUT.)
+        pytest.param(
+            C1000G2,
+            "a10131a221062011415043444b39363047313631303033393000054131373633030401010100a30e0400000000b0040064cc00580200a41b0400000000580232010000000000f0003c00010000000100500a00a506042400396400a60a04000000000000ab2a39a70704000000000000a80404000000aa0404000000ab0404000000ac0404000000ae0404000000b20404000000d91a04000019500a0000000000000000000000000000000000000000da18040000000000000000000001e00164057f00000000000000dc06040000000000f91d0403040101060005000000000000000000090300010000000006090200fa15040101010100170300000000000000000000000000fd0e0031373832303439353930383637fe050364f4376a",
+            {
+                "serial_number": "APCDK960G16100390",
+                "part_number": "A1763",
+                "temperature": 36,
+                "battery_percentage": 57,
+                "battery_health": 100,
+                "ac_output": PortStatus.NOT_CONNECTED,
+                "ac_power_in": 0,
+                "ac_power_out": 0,
+                "power_out": 0,
+                "solar_port": PortStatus.NOT_CONNECTED,
+                "dc_output": PortStatus.NOT_CONNECTED,
+                "max_battery_percentage": 80,
+                "min_battery_percentage": 10,
+            },
+            id="c1000g2_ac_off",
+        ),
+        pytest.param(
+            C1000G2,
+            "a10131a221062011415043444b39363047313631303033393000054131373633030401010100a30e0400000000b0040064cc00580200a41b0400000000580232010000000000f0003c00010000000100500a00a506042400396400a60a04000000000000ab2a39a70704010000000000a80404000000aa0404000000ab0404000000ac0404000000ae0404000000b20404000000d91a04000019500a0000000000000000000000000000000000000000da18040000000000000000000001e00164057f00000000000000dc06040000000000f91d0403040101060005000000000000000000090300010000000006090200fa15040101010100170300000000000000000000000000fd0e0031373832303439353930383637fe050369f4376a",
+            {
+                "serial_number": "APCDK960G16100390",
+                "part_number": "A1763",
+                "temperature": 36,
+                "battery_percentage": 57,
+                "battery_health": 100,
+                "ac_output": PortStatus.OUTPUT,
+                "ac_power_in": 0,
+                "ac_power_out": 0,
+                "power_out": 0,
+                "solar_port": PortStatus.NOT_CONNECTED,
+                "dc_output": PortStatus.NOT_CONNECTED,
+                "max_battery_percentage": 80,
+                "min_battery_percentage": 10,
+            },
+            id="c1000g2_ac_on",
+        ),
+        # Derived from the idle "c1000g2" frame above with only the "b2" param
+        # changed from 04000000 to 04010600 -- the value observed live on a real
+        # C1000 Gen 2 with the DC output on and a ~6 W 12 V load. This locks in
+        # the DC decode: dc_output is "b2" byte 1 (01 = OUTPUT) and dc_power_out
+        # is "b2" [2:4] little-endian watts (0x0006 = 6 W).
+        pytest.param(
+            C1000G2,
+            "a10134a221062011415043444b39363146333734303032393000054131373633060201010100a30b0400000000b0040058dc00a41b0400000000b0043201000000000000001e00010000000000640103a506041700646400a60a04000000000000ab2a64a70704000000010000a80404000000aa0404000000ab0404000000ac0404000000ae0404000000b20404010600d91a0400001964010000000100000000000000000000000000000000da18040000000000000000000001e00164057f00000000000000dc06040000000000f91d0406020101050005000000000005000500050300010000000000020200fa150401010101001f0300000000000000000000000000fd0e0031373634363538323735393838fe0503638c2e69f0",
+            {
+                "serial_number": "APCDK961F37400290",
+                "battery_percentage": 100,
+                "ac_output": PortStatus.NOT_CONNECTED,
+                "dc_output": PortStatus.OUTPUT,
+                "dc_power_out": 6,
+            },
+            id="c1000g2_dc_on",
+        ),
         pytest.param(
             C300,
             "a10131a2050300000000a3050300000000a40302ffffa503020000a603025400a703020000a803020000a903020000aa03020100ab03020000ac03020000ad03020000ae03025500af03020000b003020100b103021b04b20302fc01b30302fc01b403021c00b503027b00b603021b04b7020101b8020100b9020124ba020100bb020164bc020164bd020100be020100bf020100c0020101c1020100c2020100c3020100c4020100c51100415a5653424a30453339323030303438c603024a01c70302a005c803022c01c903023c00ca03020000cb020101cc020100cd020102ce020132cf020100d0020100d1020101",
@@ -482,6 +549,94 @@ from tests.helpers import MockDevice
             },
             id="prime_160w_all_three_charging",
         ),
+        pytest.param(
+            PrimePowerBank20k,
+            "a10131a203044d60a30404010000a4020101a50404000000a60404000000a7080400000000000000a80f0400000000009600ff00ffffffff00a90f0400000000000000ff00ffffffff00ac09040000000000000000af02011db002011eb103020900fe050300000000",
+            {
+                "battery_percentage": 77,
+                "temperature": 29,
+                "power_out": 0.0,
+                "usb_port_c1": PortStatus.NOT_CONNECTED,
+                "usb_c1_current": 0.0,
+                "usb_c1_power": 15.0,
+                "usb_c1_voltage": 0.0,
+                "usb_port_c2": PortStatus.NOT_CONNECTED,
+                "usb_c2_current": 0.0,
+                "usb_c2_power": 0.0,
+                "usb_c2_voltage": 0.0,
+                "usb_port_a1": PortStatus.NOT_CONNECTED,
+                "usb_a1_current": 0.0,
+                "usb_a1_power": 0.0,
+                "usb_a1_voltage": 0.0,
+            },
+            id="prime_power_bank_20k_idle",
+        ),
+        pytest.param(
+            PrimePowerBank20k,
+            "a10131a20304515ca30404010000a4020101a50404000000a60404013601a7080400000000000000a80f04019500140036010107ffffffff00a90f0400000000000000ff00ffffffff00ac09040000000000000000af02011ab002011bb103020900fe050300000000",
+            {
+                "battery_percentage": 81,
+                "temperature": 26,
+                "power_out": 31.0,
+                "usb_port_c1": PortStatus.OUTPUT,
+                "usb_c1_current": 2.0,
+                "usb_c1_power": 31.0,
+                "usb_c1_voltage": 14.9,
+                "usb_port_c2": PortStatus.NOT_CONNECTED,
+                "usb_c2_current": 0.0,
+                "usb_c2_power": 0.0,
+                "usb_c2_voltage": 0.0,
+                "usb_port_a1": PortStatus.NOT_CONNECTED,
+                "usb_a1_current": 0.0,
+                "usb_a1_power": 0.0,
+                "usb_a1_voltage": 0.0,
+            },
+            id="prime_power_bank_20k_discharge_c1",
+        ),
+        pytest.param(
+            PrimePowerBank20k,
+            "a10131a20304505ca30404010000a4020101a50404000000a60404013a01a7080400000000000000a80f0400000000003d01ff00ffffffff00a90f0401950014002a010107ffffffff00ac09040133000300100000af02011bb002011cb103020900fe050300000000",
+            {
+                "battery_percentage": 80,
+                "temperature": 27,
+                "power_out": 31.4,
+                "usb_port_c1": PortStatus.NOT_CONNECTED,
+                "usb_c1_current": 0.0,
+                "usb_c1_power": 31.7,
+                "usb_c1_voltage": 0.0,
+                "usb_port_c2": PortStatus.OUTPUT,
+                "usb_c2_current": 2.0,
+                "usb_c2_power": 29.8,
+                "usb_c2_voltage": 14.9,
+                "usb_port_a1": PortStatus.OUTPUT,
+                "usb_a1_current": 0.3,
+                "usb_a1_power": 1.6,
+                "usb_a1_voltage": 5.1,
+            },
+            id="prime_power_bank_20k_discharge_c2_a1",
+        ),
+        pytest.param(
+            PrimePowerBank20k,
+            "a10131a203044b5da30404010018a4020101a50404014102a6040401a300a7080400000000000000a80f04015900100096000107ffffffff00a90f0402c9001c004102ff07ffffffff00ac090401330002000d0000af02011cb002011db103020900fe050300000000",
+            {
+                "battery_percentage": 75,
+                "temperature": 28,
+                "power_out": 16.3,
+                "usb_port_c1": PortStatus.OUTPUT,
+                "usb_c1_current": 1.6,
+                "usb_c1_power": 15.0,
+                "usb_c1_voltage": 8.9,
+                "usb_port_c2": PortStatus.INPUT,
+                "usb_c2_current": 2.8,
+                "usb_c2_power": 57.7,
+                "usb_c2_voltage": 20.1,
+                "usb_port_a1": PortStatus.OUTPUT,
+                "usb_a1_current": 0.2,
+                "usb_a1_power": 1.3,
+                "usb_a1_voltage": 5.1,
+            },
+            id="prime_power_bank_20k_discharge_c1_a1_charge_c2",
+        ),
         pytest.param(
             C300DC,
             "a10131a2050300000000a303020000a403020000a503020000a603020000a703020000a803020000a903020000aa03020000ab03020000ac03020000ad03020000ae03020000af03020000b003020000b103020000b203020000b303020000b403020000b5020180b6020100b7020100b8020100b9020100ba020100bb020100bc020100bd020100be020100bf020100c0020100c1020100c2020100c3110020202020202020202020202020202020c403020000c503020000c603020000c7020100c8020100c9020100ca020100cb03020000cc020100cd020100f7050300000000f815040000000000000000000000000000000000000000",
@@ -684,6 +839,30 @@ async def test_values(
         ), f"Mismatch for property '{class_property}'!"
 
 
+@pytest.mark.asyncio
+async def test_c1000g2_dc_control() -> None:
+    """C1000 Gen 2 DC output control dispatches command 4102.
+
+    Confirmed on real hardware (the 12 V port physically switched and acked).
+    Here we just lock in that turn_dc_on/off send command 4102 with the same
+    on/off payloads as the AC output, which is the only difference between the
+    two on the Gen 2.
+    """
+    device = C1000G2(MOCK_BLE_DEVICE)
+    device._send_command = mock.AsyncMock()
+
+    await device.turn_dc_on()
+    device._send_command.assert_awaited_once_with(
+        cmd=bytes.fromhex("4102"), payload=bytes.fromhex("a10121a2020101")
+    )
+
+    device._send_command.reset_mock()
+    await device.turn_dc_off()
+    device._send_command.assert_awaited_once_with(
+        cmd=bytes.fromhex("4102"), payload=bytes.fromhex("a10121a2020100")
+    )
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "device_class,packets,secret",
@@ -753,6 +932,22 @@ async def test_values(
             "6a2c89888de58cce1e15d98eb22669898ec29bcb1519ce19f950439aac9dbcb5",
             id="solarbank2_1",
         ),
+        pytest.param(
+            PrimePowerBank20k,
+            [
+                "ff091e000300014801ab273ed3e27270c3f4d676ac7d69a00572793732a6",
+                "ff092b000300014803ab273ed0443800b35db54c6d4a6ec3d48171a04ea7ebce8bf749e5e48c5d991a5e67",
+                "ff0958000300014829ab273ed144326ada9fc66fa02508c5ddf549ade014d1eeb352fea11c0315b70b8aaa8a734ca5830f8d5827acbaa1224f05ad300b38d27bac9862a768d95c29daed0a89e92feb1d09163a094aa700ff",
+                "ff091b000300014805abab709a595a803dd04246b78a927453cf65",
+                "ff095d000300014821ab277f4e77c3b9e1f44367539f64f85d19969d0273c2c0ca93a06f3a010cf636e3b2df75d10791adf1e3c706a3238bcf0a858cd1e2d55d4cf1164a1b7db3b0058c47dfb24c71f11f8a96209d9f0924d420f03120",
+                "ff091b000300014822e520695552c2745a608fd21cf84bc6e3ccb9",
+                "ff091b000300014827e520695552c2745a608fd21cf84bc6e3ccbc",
+                "ff09df000301114a00e5a17fe3ebb89758b89ffb0e7d35a36ffeaeba3e991d79323680049a018c8e719bb706b6d00a142199a6cdc7f05bb5489f1ebb093fe3d134caf7ae5ad7b456867d9a58885cee8479bc10ea2d42d5b94d3b5a929cf4f4fd25f987e5a4922ae6fa744e22289080676583f390c1351a4b68ac5c1dabdcbf8e5e23416e47a0cea7a6062326dd8505464f821ba881f0f6f2c8ea050a7c978962980a539e90879aa1499b5be92fdceb53de533fc2bdd78b7998aec24493fdcfe3d2bc7e95b383744f92a4168819350e89d0d3142d1dbedcb779e45cfad12008",
+                "ff098300030111430044014f704abfd87d1d38fc0d7a35a36efdaf1f9f9f1c799493804dfaa6882d789fb7aeb4d117bd2330cd63c5f13f1e4a089ce80ac2442c66c85fa1f0dcb0d6867d9a58f7a3ee8479ec124724f6d7b84d8a58939c465ffb24e43754a1889be5f8c946d82d93806765835569e75bd67cbd3ac71071159c13a83bb9",
+            ],
+            "5609bc39f79166da75139feb7c335fb7524b3bf0d730db96bf6ebf450d3e165b",
+            id="prime_power_bank_20k",
+        ),
     ],
 )
 async def test_negotiation(
@@ -836,6 +1031,13 @@ async def test_negotiation(
             "a10131a20302e805a303020000a4020100a5080400000000000000a6080401d84e00000000a7080400000000000000a8020100a9020150aa020100ab090400001c50343b3b3bac0d0401002c0100002c0100000300ad0d0401002c0100002c0100000100ae0d0401002c0100002c0100000300af020101b0020101b1020100b2020101b30201ffb40d04fafffbff00000000fafffbffb50d04ffffffffffffffffffffffffe0050408000000e10b0400000000000000000000fe050300000000",
             id="prime_160w_telemetry_alt",
         ),
+        pytest.param(
+            PrimePowerBank20k,
+            "44014f704abfd87d1d38fc0d7a35a36efdaf1f9f9f1c799493804dfaa6882d789fb7aeb4d117bd2330cd63c5f13f1e4a089ce80ac2442c66c85fa1f0dcb0d6867d9a58f7a3ee8479ec124724f6d7b84d8a58939c465ffb24e43754a1889be5f8c946d82d93806765835569e75bd67cbd3ac71071159c13a83b",
+            "5609bc39f79166da75139feb7c335fb7524b3bf0d730db96bf6ebf450d3e165b",
+            "a10131a203044d60a30404010000a4020101a50404000000a60404000000a7080400000000000000a80f0400000000009600ff00ffffffff00a90f0400000000000000ff00ffffffff00ac09040000000000000000af02011db002011eb103020900fe050300000000",
+            id="prime_power_bank_telemetry",
+        ),
     ],
 )
 def test_payload_decryption(
@@ -989,6 +1191,28 @@ def test_payload_decryption(
             """{'a1': '31', 'a2': '02e805', 'a3': '020000', 'a4': '0100', 'a5': '0401a824fe0b3f0b', 'a6': '0400000000000000', 'a7': '0400000000000000', 'a8': '0103', 'a9': '0150', 'aa': '0100', 'ab': '0400000f0f0f000000', 'ac': '0401002c0100002c0100000203', 'ad': '0401002c0100002c0100000300', 'ae': '0401002c0100002c0100000300', 'af': '0100', 'b0': '0100', 'b1': '0101', 'b2': '0101', 'b3': '0101', 'b4': '04e8040000fafffbfffafffbff', 'b5': '04ffffffffffffffffffffffff', 'e0': '0408000000', 'e1': '0480034b53000000000000', 'fe': '0300000000'}""",
             id="prime_telemetry_packet",
         ),
+        # Test an Anker Prime power bank (single payload device) with a single telemetry packet.
+        pytest.param(
+            PrimePowerBank20k,
+            [
+                "ff098300030111430044014f704abfd87d1d38fc0d7a35a36efdaf1f9f9f1c799493804dfaa6882d789fb7aeb4d117bd2330cd63c5f13f1e4a089ce80ac2442c66c85fa1f0dcb0d6867d9a58f7a3ee8479ec124724f6d7b84d8a58939c465ffb24e43754a1889be5f8c946d82d93806765835569e75bd67cbd3ac71071159c13a83bb9"
+            ],
+            "5609bc39f79166da75139feb7c335fb7524b3bf0d730db96bf6ebf450d3e165b",
+            """{'a1': '31', 'a2': '044d60', 'a3': '04010000', 'a4': '0101', 'a5': '04000000', 'a6': '04000000', 'a7': '0400000000000000', 'a8': '0400000000009600ff00ffffffff00', 'a9': '0400000000000000ff00ffffffff00', 'ac': '040000000000000000', 'af': '011d', 'b0': '011e', 'b1': '020900', 'fe': '0300000000'}""",
+            id="prime_power_bank_telemetry_packet",
+        ),
+        # Test an Anker Prime device (single payload device) with a single telemetry packet
+        # from the logs of someone elses unit which for some reason transmits telemetry
+        # unencrypted
+        pytest.param(
+            PrimeCharger160w,
+            [
+                "ff09ca000301110300a10131a203024606a303020000a4020100a5080401d8459906bb0ba6080401e81300000000a7080400000000000000a8020103a9020150aa020100ab090400000000000b0b0bac0d0401002c0100002c0100000200ad0d0401002c0100002c0100000201ae0d0401002c0100002c0100000300af020100b0020100b1020100b2020101b30201ffb40d0400000000ac051573fafffbffb50d04ffffffffffffffffffffffffe0050448000000e10b0400000000000000000000fe0503000000006b"
+            ],
+            "5609bc39f79166da75139feb7c335fb7524b3bf0d730db96bf6ebf450d3e165b",
+            """{'a1': '31', 'a2': '024606', 'a3': '020000', 'a4': '0100', 'a5': '0401d8459906bb0b', 'a6': '0401e81300000000', 'a7': '0400000000000000', 'a8': '0103', 'a9': '0150', 'aa': '0100', 'ab': '0400000000000b0b0b', 'ac': '0401002c0100002c0100000200', 'ad': '0401002c0100002c0100000201', 'ae': '0401002c0100002c0100000300', 'af': '0100', 'b0': '0100', 'b1': '0100', 'b2': '0101', 'b3': '01ff', 'b4': '0400000000ac051573fafffbff', 'b5': '04ffffffffffffffffffffffff', 'e0': '0448000000', 'e1': '0400000000000000000000', 'fe': '0300000000'}""",
+            id="prime_telemetry_packet_plain_text",
+        ),
     ],
 )
 async def test_telemetry_packet_processing(
@@ -1045,6 +1269,81 @@ async def test_telemetry_packet_processing(
     assert parameters == device_parameters, "Parameters do not match expected!"
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "device_class, packets, secret, expected_logs",
+    [
+        # Telemetry packet from logs of someone elses Prime 160w charger.
+        # Interestingly this packet is not encrypted at all
+        pytest.param(
+            PrimeCharger160w,
+            [
+                "ff09ca000301110300a10131a203024606a303020000a4020100a5080401e042b105b209a6080401e81300000000a7080400000000000000a8020103a9020150aa020100ab090400000000000b0b0bac0d0401002c0100002c0100000200ad0d0401002c0100002c0100000201ae0d0401002c0100002c0100000300af020100b0020100b1020100b2020101b30201ffb40d0400000000ac051573fafffbffb50d04ffffffffffffffffffffffffe0050448000000e10b0400000000000000000000fe05030000000074"
+            ],
+            "5609bc39f79166da75139feb7c335fb7524b3bf0d730db96bf6ebf450d3e165b",
+            [
+                "Received non-encrypted telemetry message",
+                "Telemetry parameters: {'a1': '31', 'a2': '024606'",
+            ],
+            id="prime_160w_other",
+        ),
+    ],
+)
+async def test_generic_packet_processing(
+    caplog,
+    fast_sleep,
+    fast_timeouts,
+    device_class: type[SolixBLEDevice],
+    packets: list[str],
+    secret: str,
+    expected_logs: list[str],
+):
+    """
+    Test the _process_notification function when processing arbitrary
+    packets and check for expected log entries.
+
+    :param device_class: Class of device under test.
+    :param packets: List of packets to send to device.
+    :param secret: Shared secret used as AES key and IV.
+    :param expected_logs: List of expected entries in the debug log.
+    """
+
+    device = device_class(MOCK_BLE_DEVICE)
+
+    negotiation_responses = (
+        NEGOTIATION_RESPONSES_PRIME
+        if issubclass(device_class, PrimeDevice)
+        else NEGOTIATION_RESPONSES_SOLIX
+    )
+
+    async with MockDevice() as mock_bluetooth:
+        with caplog.at_level(logging.DEBUG):
+
+            # We first expect a negotiation
+            for expected, response in negotiation_responses.items():
+                mock_bluetooth.expect_ordered(
+                    bytes.fromhex(expected),
+                    [bytes.fromhex(x) for x in response],
+                )
+
+            # We expect the negotiations to succeed
+            assert await device.connect(), "Expected connect to return True"
+            await asyncio.sleep(0.5)
+            assert device.connected, "Expected connected to be True"
+            assert device.negotiated, "Expected connected to be True"
+            mock_bluetooth.check_assertions()
+
+            device._shared_secret = bytes.fromhex(secret)
+
+            for packet in packets:
+                await mock_bluetooth.send_data([bytes.fromhex(packet)])
+
+            for expected_log_entry in expected_logs:
+                assert (
+                    expected_log_entry in caplog.text
+                ), f"Expected to find '{expected_log_entry}' in logs but it was not found!"
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "device_class,payload,mapping,errors",