casambi-bt-revamped 0.3.12.dev9__tar.gz → 0.3.12.dev11__tar.gz

{casambi_bt_revamped-0.3.12.dev9/src/casambi_bt_revamped.egg-info → casambi_bt_revamped-0.3.12.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev9
+Version: 0.3.12.dev11
 Summary: Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev11}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = casambi-bt-revamped
-version = 0.3.12.dev9
+version = 0.3.12.dev11
 author = rankjie
 author_email = rankjie@gmail.com
 description = Forked Casambi Bluetooth client library with switch event support, use original if no special need. https://github.com/lkempf/casambi-bt

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev11}/src/CasambiBt/_casambi.py

@@ -169,10 +169,15 @@ class Casambi:
         self._casaClient = cast(CasambiClient, self._casaClient)
         await self._casaClient.connect()
         try:
-            # EVO requires key exchange + authenticate; Classic is ready after `connect()`.
             if self._casaClient.protocolMode == ProtocolMode.EVO:
+                # EVO requires key exchange + authenticate.
                 await self._casaClient.exchangeKey()
                 await self._casaClient.authenticate()
+            elif self._casaClient.protocolMode == ProtocolMode.CLASSIC:
+                # Classic needs an init write to trigger state broadcasts.
+                # In EVO the key exchange/auth handshake implicitly signals the
+                # device; Classic has no such handshake so we send a time-sync.
+                await self._casaClient.classicSendInit()
         except ProtocolError as e:
             await self._casaClient.disconnect()
             raise e
@@ -206,16 +211,33 @@ class Casambi:
 
         # Classic protocol uses signed command frames (u1.C1753e / u1.EnumC1754f).
         if self._casaClient is not None and self._casaClient.protocolMode == ProtocolMode.CLASSIC:
-            # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
-            # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
-            if isinstance(target, Unit):
-                cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
-            elif isinstance(target, Group):
-                cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
-            elif target is None:
-                cmd = self._casaClient.buildClassicCommand(4, payload)
+            # Check if we should use the alternative simple format from BLE captures
+            import os
+            use_simple = os.environ.get("CASAMBI_BT_CLASSIC_FORMAT", "").lower() == "simple"
+
+            if use_simple:
+                # Simple format: [counter][unit_id][param_len][dimmer]
+                # For "all units", use unit_id=0xFF
+                if isinstance(target, Unit):
+                    cmd = self._casaClient.buildClassicCommandSimple(target.deviceId, level)
+                elif isinstance(target, Group):
+                    # Groups in simple format: not fully confirmed, try group ID
+                    cmd = self._casaClient.buildClassicCommandSimple(target.groudId, level)
+                elif target is None:
+                    cmd = self._casaClient.buildClassicCommandSimple(0xFF, level)
+                else:
+                    raise TypeError(f"Unkown target type {type(target)}")
             else:
-                raise TypeError(f"Unkown target type {type(target)}")
+                # EnumC1754f ordinals (ground truth: casambi-android u1.EnumC1754f):
+                # - AllUnitsLevel=4, UnitLevel=7, GroupLevel=26
+                if isinstance(target, Unit):
+                    cmd = self._casaClient.buildClassicCommand(7, payload, target_id=target.deviceId)
+                elif isinstance(target, Group):
+                    cmd = self._casaClient.buildClassicCommand(26, payload, target_id=target.groudId)
+                elif target is None:
+                    cmd = self._casaClient.buildClassicCommand(4, payload)
+                else:
+                    raise TypeError(f"Unkown target type {type(target)}")
 
             await self._casaClient.send(cmd)
             return

casambi_bt_revamped-0.3.12.dev11/src/CasambiBt/_classic_crypto.py

@@ -0,0 +1,146 @@
+"""Classic Casambi protocol helpers (CMAC signing/verification).
+
+Ground truth:
+- casambi-android `t1.P.o(...)` calculates a CMAC over:
+    connection_hash[0:8] + payload
+  and stores the CMAC (prefix) into the packet header.
+
+The CMAC input structure from t1.P.o():
+    kVar.i(rVar.f16699L, 0, 8);  // connection_hash[0:8]
+    kVar.i(b(), this.f16551t + i9, (c() - i9) - this.f16551t);  // payload starting at seq offset
+
+For "conformant" classic (rVar.Z=true):
+    CMAC input = conn_hash[0:8] || seq(2 bytes BE) || command_bytes
+
+For "legacy" classic (rVar.Z=false):
+    CMAC input = conn_hash[0:8] || command_bytes
+
+Test vectors based on community BLE captures (GitHub lkempf/casambi-bt#17):
+
+Capture from sMauldaeschle:
+    Raw packet: 0215db43c40004040200b3
+    - Byte 0: 02 (auth level = visitor)
+    - Bytes 1-4: 15db43c4 (4-byte CMAC signature)
+    - Byte 5: 00 (padding/marker)
+    - Byte 6: 04 (counter/sequence)
+    - Byte 7: 04 (unit id)
+    - Byte 8: 02 (length of parameters)
+    - Byte 9: 00 (dimmer value)
+    - Byte 10: b3 (temperature/vertical value)
+
+Capture from FliegenKLATSCH:
+    Raw packet: 0200 43A2 9600 0203 0254 FF
+    - Bytes 0-1: 0200 (auth 02, then...)
+    - Bytes 2-5: 43A2 9600 (first 4 bytes of CMAC)
+    - The CMAC input was: <8 bytes connection hash> 00 0203 0254 FF
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from cryptography.hazmat.primitives.cmac import CMAC
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+if TYPE_CHECKING:
+    pass
+
+_logger = logging.getLogger(__name__)
+
+
+def classic_cmac(key: bytes, conn_hash8: bytes, payload: bytes, *, debug: bool = False) -> bytes:
+    """Compute the Classic CMAC (16 bytes) over connection hash + payload.
+
+    Args:
+        key: 16-byte AES key (visitor or manager key from cloud)
+        conn_hash8: First 8 bytes of the connection hash read from CA51/auth char
+        payload: The data to sign (for conformant: seq + command; for legacy: command only)
+        debug: If True, log CMAC input/output for debugging
+
+    Returns:
+        16-byte CMAC
+    """
+    if len(conn_hash8) != 8:
+        raise ValueError("conn_hash8 must be 8 bytes")
+
+    cmac_input = conn_hash8 + payload
+    cmac = CMAC(AES(key))
+    cmac.update(cmac_input)
+    result = cmac.finalize()
+
+    if debug:
+        _logger.warning(
+            "[CLASSIC_CMAC_DEBUG] key_len=%d conn_hash8=%s payload_len=%d payload_prefix=%s cmac=%s",
+            len(key),
+            conn_hash8.hex(),
+            len(payload),
+            payload[:16].hex() if len(payload) > 16 else payload.hex(),
+            result.hex(),
+        )
+
+    return result
+
+
+def classic_cmac_prefix(
+    key: bytes, conn_hash8: bytes, payload: bytes, prefix_len: int, *, debug: bool = False
+) -> bytes:
+    """Return the prefix bytes that are embedded into the Classic packet header.
+
+    Args:
+        key: 16-byte AES key
+        conn_hash8: First 8 bytes of connection hash
+        payload: Data to sign
+        prefix_len: Number of CMAC bytes to use (4 for visitor, 16 for manager)
+        debug: If True, log CMAC computation
+
+    Returns:
+        First prefix_len bytes of the CMAC
+    """
+    mac = classic_cmac(key, conn_hash8, payload, debug=debug)
+    return mac[:prefix_len]
+
+
+def verify_classic_cmac(
+    key: bytes, conn_hash8: bytes, payload: bytes, expected_prefix: bytes
+) -> bool:
+    """Verify a Classic CMAC signature prefix.
+
+    Args:
+        key: 16-byte AES key
+        conn_hash8: First 8 bytes of connection hash
+        payload: Data that was signed
+        expected_prefix: The CMAC prefix from the packet header
+
+    Returns:
+        True if the computed CMAC prefix matches expected_prefix
+    """
+    computed = classic_cmac_prefix(key, conn_hash8, payload, len(expected_prefix))
+    return computed == expected_prefix
+
+
+# Test vectors from RFC 4493 (AES-CMAC) - used in test_classic_protocol.py
+# These confirm our CMAC implementation is correct.
+RFC4493_TEST_KEY = bytes.fromhex("2b7e151628aed2a6abf7158809cf4f3c")
+RFC4493_VECTORS = [
+    # (message, expected_cmac)
+    (bytes.fromhex("6bc1bee22e409f96e93d7e117393172a"),
+     bytes.fromhex("070a16b46b4d4144f79bdd9dd04a287c")),
+    (bytes.fromhex("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51"),
+     bytes.fromhex("ce0cbf1738f4df6428b1d93bf12081c9")),
+]
+
+# Placeholder for real Casambi test vectors once we have them from captures
+# Format: (visitor_key, conn_hash8, payload_after_header, expected_cmac_prefix_4, description)
+CASAMBI_CLASSIC_TEST_VECTORS: list[tuple[bytes, bytes, bytes, bytes, str]] = [
+    # These will be populated from real BLE captures
+    # Example structure (not verified yet):
+    # (
+    #     bytes.fromhex("...16 byte key..."),
+    #     bytes.fromhex("...8 byte conn hash..."),
+    #     bytes.fromhex("...payload after auth byte..."),
+    #     bytes.fromhex("...4 byte expected cmac..."),
+    #     "Description of what this packet does"
+    # ),
+]
+

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev11}/src/CasambiBt/_client.py

@@ -159,10 +159,16 @@ class CasambiClient:
         self._classicRxType9 = 0
         self._classicRxCmdStream = 0
         self._classicRxUnknown = 0
+        self._classicRxClassicStates = 0
         # Per-kind sample counters to ensure we emit at least a few examples for reverse engineering.
         self._classicRxKindSamples: dict[str, int] = {}
         self._classicRxLastStatsTs = time.monotonic()
 
+        # Classic diagnostic packet history (for dump_classic_diagnostics service)
+        self._classicTxHistory: list[dict[str, Any]] = []
+        self._classicRxHistory: list[dict[str, Any]] = []
+        self._classicDiagMaxHistory = 50  # Keep last 50 TX and RX packets
+
     @property
     def protocolMode(self) -> ProtocolMode | None:
         return self._protocolMode
@@ -1004,6 +1010,39 @@ class CasambiClient:
 
         return bytes(b)
 
+    def buildClassicCommandSimple(
+        self,
+        unit_id: int,
+        dimmer: int,
+        extra: int | None = None,
+    ) -> bytes:
+        """Build a Classic command using the simple format from BLE captures.
+
+        This alternative format was observed in real BLE captures and differs from
+        the Android u1.C1753e command record format. Use with env variable
+        CASAMBI_BT_CLASSIC_FORMAT=simple to experiment.
+
+        Format (before header added by _sendClassic):
+        [counter:1][unit_id:1][param_len:1][dimmer:1][extra:1?]
+
+        The header (added by _sendClassic) is:
+        - Conformant: [auth:1][cmac:4|16][seq:2]
+        - Legacy: [cmac:4]
+
+        Args:
+            unit_id: Target unit ID (0-255, use 0xFF for "all units")
+            dimmer: Dimmer/level value (0-255)
+            extra: Optional extra parameter (e.g., temperature/vertical value)
+
+        Returns:
+            Command bytes to pass to _sendClassic
+        """
+        counter = self._classic_next_div()
+        if extra is not None:
+            return bytes([counter, unit_id & 0xFF, 2, dimmer & 0xFF, extra & 0xFF])
+        else:
+            return bytes([counter, unit_id & 0xFF, 1, dimmer & 0xFF])
+
     async def _sendClassic(self, command_bytes: bytes) -> None:
         self._checkState(ConnectionState.AUTHENTICATED)
         if self._protocolMode != ProtocolMode.CLASSIC:
@@ -1143,7 +1182,115 @@ class CasambiClient:
 
         # Classic packets can exceed 20 bytes when using a 16-byte manager signature.
         # Bleak needs a write-with-response for long writes on most backends.
-        await self._gattClient.write_gatt_char(tx_uuid, bytes(pkt), response=True)
+        tx_result = "pending"
+        try:
+            await self._gattClient.write_gatt_char(tx_uuid, bytes(pkt), response=True)
+            tx_result = "ok"
+        except Exception as e:
+            tx_result = f"error: {type(e).__name__}: {e}"
+            raise
+        finally:
+            # Record TX in diagnostic history
+            tx_entry = {
+                "timestamp": time.monotonic(),
+                "header_mode": header_mode,
+                "key": key_name,
+                "signed": signed,
+                "tx_uuid": tx_uuid,
+                "auth_level": auth_level if header_mode == "conformant" else None,
+                "sig_len": sig_len,
+                "seq": seq,
+                "cmd_ordinal": cmd_ordinal,
+                "cmd_target": cmd_target,
+                "cmd_div": cmd_div,
+                "cmd_lifetime": cmd_lifetime,
+                "cmd_payload_len": cmd_payload_len,
+                "total_len": len(pkt),
+                "pre_sign_hex": b2a(command_bytes).decode("ascii"),
+                "post_sign_hex": b2a(bytes(pkt)).decode("ascii"),
+                "result": tx_result,
+            }
+            self._classicTxHistory.append(tx_entry)
+            if len(self._classicTxHistory) > self._classicDiagMaxHistory:
+                self._classicTxHistory = self._classicTxHistory[-self._classicDiagMaxHistory:]
+
+            # Enhanced TX diagnostic log
+            self._logger.warning(
+                "[CLASSIC_DIAG_TX_RESULT] result=%s header=%s seq=%s total_len=%d",
+                tx_result,
+                header_mode,
+                None if seq is None else f"0x{seq:04x}",
+                len(pkt),
+            )
+
+    async def classicSendInit(self) -> None:
+        """Send Classic post-connection initialization (time-sync).
+
+        Ground truth: casambi-android AbstractC1717h.X() (lines 254-345).
+        The Android app sends this as the first packet after Classic connection.
+        In EVO, the key exchange/auth handshake implicitly signals the device;
+        Classic has no such handshake, so an explicit init write is needed to
+        trigger the device to start broadcasting state notifications.
+
+        The payload is sent raw via _sendClassic (NOT wrapped in buildClassicCommand).
+        """
+        self._checkState(ConnectionState.AUTHENTICATED)
+        if self._protocolMode != ProtocolMode.CLASSIC:
+            return
+
+        import datetime as _dt
+
+        now = _dt.datetime.now()
+
+        # Timezone offset in minutes from UTC.
+        local_tz = _dt.datetime.now(_dt.timezone.utc).astimezone().tzinfo
+        utc_offset_minutes = 0
+        if local_tz is not None:
+            offset = local_tz.utcoffset(now)
+            if offset is not None:
+                utc_offset_minutes = int(offset.total_seconds()) // 60
+
+        # Build the time-sync payload.
+        # Format: [10][year:2BE][month:1][day:1][hour:1][min:1][sec:1]
+        #         [tz_offset:2BE signed][dst_transition:4BE][dst_change:1]
+        #         [timestamp1:4BE][timestamp2:4BE][zero:2][millis:3BE]
+        payload = bytearray()
+        payload.append(10)  # Classic time-sync command byte
+        payload.extend(struct.pack(">H", now.year))
+        payload.append(now.month)
+        payload.append(now.day)
+        payload.append(now.hour)
+        payload.append(now.minute)
+        payload.append(now.second)
+        payload.extend(struct.pack(">h", utc_offset_minutes))
+        # DST transition data and change minutes (0 = no DST info).
+        payload.extend(struct.pack(">I", 0))
+        payload.append(0)
+        # Classic extra bytes: timestamps, zero short, millis.
+        # Start with zeros - refine after tester feedback if needed.
+        payload.extend(struct.pack(">I", 0))  # timestamp1
+        payload.extend(struct.pack(">I", 0))  # timestamp2
+        payload.extend(struct.pack(">H", 0))  # zero
+        # j() in Android is a 3-byte big-endian write.
+        millis_val = now.microsecond // 1000 * 1000
+        payload.append((millis_val >> 16) & 0xFF)
+        payload.append((millis_val >> 8) & 0xFF)
+        payload.append(millis_val & 0xFF)
+
+        self._logger.warning(
+            "[CASAMBI_CLASSIC_INIT] sending time-sync len=%d hex=%s",
+            len(payload),
+            b2a(bytes(payload)),
+        )
+
+        try:
+            await self._sendClassic(bytes(payload))
+            self._logger.warning("[CASAMBI_CLASSIC_INIT] time-sync sent successfully")
+        except Exception:
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_INIT] time-sync send failed",
+                exc_info=True,
+            )
 
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
@@ -1231,10 +1378,26 @@ class CasambiClient:
         """
         self._inPacketCount += 1
         self._classicRxFrames += 1
+        rx_ts = time.monotonic()
         if self._classicFirstRxTs is None:
-            self._classicFirstRxTs = time.monotonic()
+            self._classicFirstRxTs = rx_ts
 
         raw = bytes(data)
+
+        # Enhanced RX diagnostic logging
+        try:
+            handle_uuid = str(getattr(handle, "uuid", "unknown")).lower()
+        except Exception:
+            handle_uuid = "unknown"
+
+        self._logger.warning(
+            "[CLASSIC_DIAG_RX] #%d handle=%s len=%d hex=%s",
+            self._classicRxFrames,
+            handle_uuid,
+            len(raw),
+            b2a(raw[: min(len(raw), 48)]).decode("ascii") + ("..." if len(raw) > 48 else ""),
+        )
+
         if self._logger.isEnabledFor(logging.DEBUG):
             self._logger.debug(
                 "[CASAMBI_CLASSIC_RX_RAW] len=%d hex=%s",
@@ -1424,6 +1587,36 @@ class CasambiClient:
         elif verified is None:
             self._classicRxUnverifiable += 1
 
+        # Record RX in diagnostic history
+        rx_entry = {
+            "timestamp": rx_ts,
+            "handle_uuid": handle_uuid,
+            "header_mode": best["mode"],
+            "verified": verified,
+            "auth_level": best["auth_level"],
+            "sig_len": best["sig_len"],
+            "seq": best["seq"],
+            "payload_len": len(payload),
+            "raw_hex": b2a(raw).decode("ascii"),
+            "payload_hex": b2a(payload).decode("ascii"),
+            "score": best["score"],
+        }
+        self._classicRxHistory.append(rx_entry)
+        if len(self._classicRxHistory) > self._classicDiagMaxHistory:
+            self._classicRxHistory = self._classicRxHistory[-self._classicDiagMaxHistory:]
+
+        # Enhanced RX parse result log
+        self._logger.warning(
+            "[CLASSIC_DIAG_RX_PARSE] mode=%s verified=%s auth=%s sig_len=%d seq=%s score=%d payload_len=%d",
+            best["mode"],
+            verified,
+            None if best["auth_level"] is None else f"0x{best['auth_level']:02x}",
+            best["sig_len"],
+            None if best["seq"] is None else f"0x{best['seq']:04x}",
+            best["score"],
+            len(payload),
+        )
+
         # Auto-correct header mode if the other format parses much better.
         if best["mode"] != preferred:
             # Only switch if we got a stronger signal (verified or plausible payload with fewer assumptions).
@@ -1456,7 +1649,7 @@ class CasambiClient:
             self._classicRxLastStatsTs = now
             self._logger.warning(
                 "[CASAMBI_CLASSIC_RX_STATS] frames=%d verified=%d unverifiable=%d parse_fail=%d header=%s "
-                "type6=%d type7=%d type9=%d cmdstream=%d unknown=%d",
+                "type6=%d type7=%d type9=%d cmdstream=%d unknown=%d classic_states=%d",
                 self._classicRxFrames,
                 self._classicRxVerified,
                 self._classicRxUnverifiable,
@@ -1467,8 +1660,17 @@ class CasambiClient:
                 self._classicRxType9,
                 self._classicRxCmdStream,
                 self._classicRxUnknown,
+                self._classicRxClassicStates,
             )
 
+        # Classic payloads use a completely different format from EVO.
+        # Classic: byte 0 is a type indicator (0=netconfig, 255=log, else=unit_id).
+        # EVO: byte 0 is a packet type (6=UnitState, 7=Switch, 9=NetConfig).
+        # Dispatch Classic through its own parser to avoid misinterpretation.
+        if self._protocolMode == ProtocolMode.CLASSIC:
+            self._dispatchClassicPayload(payload)
+            return
+
         # If the payload starts with a known EVO packet type, reuse existing parsers.
         packet_type = payload[0]
         if packet_type in (IncommingPacketType.UnitState, IncommingPacketType.SwitchEvent, IncommingPacketType.NetworkConfig):
@@ -1579,6 +1781,146 @@ class CasambiClient:
                 b2a(payload[pos:]),
             )
 
+    def _dispatchClassicPayload(self, payload: bytes) -> None:
+        """Dispatch a verified Classic payload based on its type indicator.
+
+        Classic payloads (from C1751c.V()) use a different format from EVO:
+        - byte 0 == 0: network config data
+        - byte 0 == 255: log message
+        - otherwise: unit state stream (byte 0 is the first unit_id)
+        """
+        if not payload:
+            return
+
+        first_byte = payload[0]
+
+        # Log full payload for the first 10 Classic payloads regardless of type.
+        if self._classicRxClassicStates < 10:
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_DISPATCH] #%d type_byte=%d len=%d hex=%s",
+                self._classicRxClassicStates,
+                first_byte,
+                len(payload),
+                b2a(payload[: min(len(payload), 64)]).decode("ascii")
+                + ("..." if len(payload) > 64 else ""),
+            )
+
+        if first_byte == 0:
+            self._logger.debug("[CASAMBI_CLASSIC_NETCONFIG] len=%d", len(payload))
+            return
+
+        if first_byte == 255:
+            self._logger.debug("[CASAMBI_CLASSIC_LOG] len=%d", len(payload))
+            return
+
+        # Unit state stream: entire payload is passed (first byte is the first unit_id).
+        self._classicRxClassicStates += 1
+        self._parseClassicUnitStates(payload)
+
+    def _parseClassicUnitStates(self, data: bytes) -> None:
+        """Parse Classic unit state records.
+
+        Ground truth: casambi-android C1751c.V() (line 301+).
+        Format is completely different from EVO _parseUnitStates:
+        - flags lower nibble = state_len (EVO uses a separate byte)
+        - flags bit 5 = extra1 present, bit 6 = extra2 present, bit 7 = offline
+        - unit_id 0xF0 = command response (skip)
+        """
+        self._logger.debug("Parsing Classic unit states...")
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._logger.debug("[CASAMBI_CLASSIC_STATES_RAW] len=%d hex=%s", len(data), b2a(data))
+
+        pos = 0
+        old_pos = 0
+        records_parsed = 0
+        try:
+            while pos + 2 <= len(data):
+                unit_id = data[pos]
+                flags = data[pos + 1]
+                pos += 2
+
+                state_len = flags & 0x0F
+                has_extra1 = (flags & 0x20) != 0
+                has_extra2 = (flags & 0x40) != 0
+                is_offline = (flags & 0x80) != 0
+
+                # 0xF0 = command response record, skip state_len bytes.
+                if unit_id == 0xF0:
+                    pos += state_len
+                    continue
+
+                extra1 = 0
+                if has_extra1:
+                    if pos >= len(data):
+                        break
+                    extra1 = data[pos]
+                    pos += 1
+
+                extra2 = 0
+                if has_extra2:
+                    if pos >= len(data):
+                        break
+                    extra2 = data[pos]
+                    pos += 1
+
+                if pos + state_len > len(data):
+                    break
+
+                state = data[pos : pos + state_len]
+                pos += state_len
+                records_parsed += 1
+
+                # Log the first few parsed records at WARNING level for tester visibility.
+                if records_parsed <= 10 or self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.warning(
+                        "[CASAMBI_CLASSIC_STATE_PARSED] unit=%d flags=0x%02x state_len=%d "
+                        "offline=%s extra1=%d extra2=%d state=%s",
+                        unit_id,
+                        flags,
+                        state_len,
+                        is_offline,
+                        extra1,
+                        extra2,
+                        b2a(state),
+                    )
+
+                online = not is_offline
+                # Let Unit.is_on derive actual on/off from state bytes (dimmer, onoff).
+                on = True
+
+                self._dataCallback(
+                    IncommingPacketType.UnitState,
+                    {
+                        "id": unit_id,
+                        "online": online,
+                        "on": on,
+                        "state": state,
+                        "flags": flags,
+                        "prio": 0,
+                        "state_len": state_len,
+                        "padding_len": 0,
+                        "con": None,
+                        "sid": None,
+                        "extra_byte": extra1,
+                        "extra_float": extra1 / 255.0 if extra1 else 0.0,
+                    },
+                )
+
+                old_pos = pos
+        except IndexError:
+            self._logger.error(
+                "Ran out of data while parsing Classic unit state! Remaining data %s in %s.",
+                b2a(data[old_pos:]),
+                b2a(data),
+            )
+
+        if records_parsed > 0:
+            self._logger.debug(
+                "[CASAMBI_CLASSIC_STATES_DONE] records=%d remaining=%d",
+                records_parsed,
+                len(data) - pos,
+            )
+
     def _parseUnitStates(self, data: bytes) -> None:
         # Ground truth: casambi-android `v1.C1775b.V(Q2.h)` parses decrypted packet type=6
         # as a stream of unit state records. Records have optional bytes depending on flags.
@@ -1865,3 +2207,39 @@ class CasambiClient:
 
         self._connectionState = ConnectionState.NONE
         self._logger.info("Disconnected.")
+
+    def getClassicDiagnostics(self) -> dict[str, Any]:
+        """Return Classic protocol diagnostic state for external services.
+
+        This method provides a snapshot of Classic protocol state including:
+        - Connection parameters (hash, mode, UUIDs)
+        - RX/TX statistics
+        - Last N TX and RX packets
+        - Any detected errors or anomalies
+
+        Safe to call from HA services for dump_classic_diagnostics.
+        """
+        return {
+            "protocol_mode": self._protocolMode.name if self._protocolMode else None,
+            "classic_header_mode": self._classicHeaderMode,
+            "classic_hash_source": self._classicHashSource,
+            "classic_conn_hash8_hex": b2a(self._classicConnHash8).decode("ascii") if self._classicConnHash8 else None,
+            "classic_tx_uuid": self._classicTxCharUuid,
+            "classic_notify_uuids": sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else [],
+            "classic_first_rx_ts": self._classicFirstRxTs,
+            "classic_rx_stats": {
+                "frames": self._classicRxFrames,
+                "verified": self._classicRxVerified,
+                "unverifiable": self._classicRxUnverifiable,
+                "parse_fail": self._classicRxParseFail,
+                "type6_unitstate": self._classicRxType6,
+                "type7_switch": self._classicRxType7,
+                "type9_netconf": self._classicRxType9,
+                "cmdstream": self._classicRxCmdStream,
+                "unknown": self._classicRxUnknown,
+            },
+            "classic_tx_count": len(self._classicTxHistory),
+            "classic_rx_count": len(self._classicRxHistory),
+            "classic_tx_history": self._classicTxHistory[-20:],  # Last 20
+            "classic_rx_history": self._classicRxHistory[-20:],  # Last 20
+        }

{casambi_bt_revamped-0.3.12.dev9 → casambi_bt_revamped-0.3.12.dev11}/src/CasambiBt/_version.py

@@ -7,4 +7,4 @@ Avoid using importlib.metadata in hot paths by providing a static version string
 __all__ = ["__version__"]
 
 # NOTE: Must match `casambi-bt/setup.cfg` [metadata] version.
-__version__ = "0.3.12.dev9"
+__version__ = "0.3.12.dev10"