casambi-bt-revamped 0.3.12.dev8__py3-none-any.whl → 0.3.12.dev10__py3-none-any.whl

CasambiBt/_casambi.py

@@ -206,16 +206,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

CasambiBt/_classic_crypto.py

@@ -4,28 +4,143 @@ 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) -> bytes:
-    """Compute the Classic CMAC (16 bytes) over connection hash + payload."""
+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(conn_hash8)
-    cmac.update(payload)
-    return cmac.finalize()
+    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
+    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."""
-    mac = classic_cmac(key, conn_hash8, payload)
+    """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"
+    # ),
+]
+

CasambiBt/_client.py

@@ -25,7 +25,13 @@ from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric import ec
 
 from ._constants import CASA_AUTH_CHAR_UUID, ConnectionState
-from ._constants import CASA_CLASSIC_DATA_CHAR_UUID, CASA_CLASSIC_HASH_CHAR_UUID
+from ._constants import (
+    CASA_CLASSIC_CA53_CHAR_UUID,
+    CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID,
+    CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID,
+    CASA_CLASSIC_DATA_CHAR_UUID,
+    CASA_CLASSIC_HASH_CHAR_UUID,
+)
 from ._classic_crypto import classic_cmac_prefix
 from ._encryption import Encryptor
 from ._network import Network
@@ -135,6 +141,12 @@ class CasambiClient:
         # - "legacy":     [sig][payload]
         # Ground truth: casambi-android `t1.P.n(...)` and `t1.P.o(...)`.
         self._classicHeaderMode: str | None = None  # "conformant" | "legacy"
+        # Classic transport diagnostics / channel selection.
+        self._classicTxCharUuid: str | None = None
+        self._classicNotifyCharUuids: set[str] = set()
+        self._classicHashSource: str | None = None  # "ca51" | "ca52_0001" | None
+        self._classicFirstRxTs: float | None = None
+        self._classicNoRxTask: asyncio.Task[None] | None = None
 
         # Rate limit WARNING logs (especially Classic RX) to keep HA usable.
         self._logLimiter = _LogBurstLimiter()
@@ -151,6 +163,11 @@ class CasambiClient:
         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
@@ -186,6 +203,23 @@ class CasambiClient:
         self._outPacketCount = 2
         self._inPacketCount = 1
 
+        # Reset protocol-specific state (important for reconnects).
+        self._protocolMode = None
+        self._dataCharUuid = None
+        self._deviceProtocolVersion = None
+
+        self._classicConnHash8 = None
+        self._classicTxSeq = 0
+        self._classicCmdDiv = 0
+        self._classicHeaderMode = None
+        self._classicTxCharUuid = None
+        self._classicNotifyCharUuids.clear()
+        self._classicHashSource = None
+        self._classicFirstRxTs = None
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
+
         # Reset callback queue
         self._callbackQueue = asyncio.Queue()
         self._callbackTask = asyncio.create_task(self._processCallbacks())
@@ -262,28 +296,43 @@ class CasambiClient:
         cloud_protocol = getattr(self._network, "protocolVersion", None)
         ca51_prefix: bytes | None = None
         ca51_err: str | None = None
+        ca52_notify_err: str | None = None
+        ca53_notify_err: str | None = None
         auth_prefix: bytes | None = None
         auth_err: str | None = None
+        c0002_prefix: bytes | None = None
+        c0002_err: str | None = None
+        c0003_notify_err: str | None = None
         device_nodeinfo_protocol: int | None = None
 
         def _log_probe_summary(mode: str, *, classic_variant: str | None = None) -> None:
             # One stable, high-signal line for testers.
             self._logger.warning(
                 "[CASAMBI_PROTOCOL_PROBE] address=%s mode=%s cloud_protocol=%s nodeinfo_b1=%s data_uuid=%s "
-                "classic_variant=%s ca51_hash8_present=%s conn_hash8_ready=%s "
-                "auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s",
+                "classic_variant=%s hash_source=%s classic_tx_uuid=%s classic_notify_uuids=%s "
+                "ca51_hash8_present=%s conn_hash8_ready=%s "
+                "auth_read_prefix=%s ca51_read_prefix=%s ca51_read_error=%s auth_read_error=%s "
+                "ca52_notify_error=%s ca53_notify_error=%s c0002_read_prefix=%s c0002_read_error=%s c0003_notify_error=%s",
                 self.address,
                 mode,
                 cloud_protocol,
                 device_nodeinfo_protocol,
                 self._dataCharUuid,
                 classic_variant,
+                self._classicHashSource,
+                self._classicTxCharUuid,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
                 bool(classic_hash and len(classic_hash) >= 8),
                 self._classicConnHash8 is not None,
                 auth_prefix,
                 ca51_prefix,
                 ca51_err,
                 auth_err,
+                ca52_notify_err,
+                ca53_notify_err,
+                c0002_prefix,
+                c0002_err,
+                c0003_notify_err,
             )
 
         classic_hash: bytes | None = None
@@ -305,7 +354,9 @@ class CasambiClient:
         if classic_hash and len(classic_hash) >= 8:
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
+            self._classicTxCharUuid = CASA_CLASSIC_DATA_CHAR_UUID
             self._classicHeaderMode = "legacy"
+            self._classicHashSource = "ca51"
 
             # Read connection hash (first 8 bytes are used for CMAC signing).
             raw_hash = classic_hash
@@ -330,6 +381,7 @@ class CasambiClient:
                     **notify_kwargs,
                 )
             except Exception as e:
+                ca52_notify_err = type(e).__name__
                 # Some firmwares may expose Classic signing on the EVO UUID instead.
                 # Fall through to auth-char probing if CA52 isn't available.
                 if self._logger.isEnabledFor(logging.DEBUG):
@@ -341,8 +393,25 @@ class CasambiClient:
                 self._protocolMode = None
                 self._dataCharUuid = None
                 self._classicConnHash8 = None
+                self._classicTxCharUuid = None
+                self._classicNotifyCharUuids.clear()
+                self._classicHeaderMode = None
+                self._classicHashSource = None
                 # continue detection below
             else:
+                self._classicNotifyCharUuids.add(CASA_CLASSIC_DATA_CHAR_UUID.lower())
+                # Some Classic firmwares also expose state/config notifications on CA53.
+                try:
+                    await self._gattClient.start_notify(
+                        CASA_CLASSIC_CA53_CHAR_UUID,
+                        self._queueCallback,
+                        **notify_kwargs,
+                    )
+                except Exception as e:
+                    ca53_notify_err = type(e).__name__
+                else:
+                    self._classicNotifyCharUuids.add(CASA_CLASSIC_CA53_CHAR_UUID.lower())
+
                 # Classic has no EVO-style key exchange/auth; we can send immediately.
                 self._connectionState = ConnectionState.AUTHENTICATED
                 self._logger.info("Protocol mode selected: CLASSIC")
@@ -354,10 +423,11 @@ class CasambiClient:
                         b2a(self._classicConnHash8),
                     )
                 self._logger.warning(
-                    "[CASAMBI_CLASSIC_SELECTED] address=%s variant=ca52_legacy data_uuid=%s start_notify_uuid=%s header_mode=%s conn_hash8_prefix=%s",
+                    "[CASAMBI_CLASSIC_SELECTED] address=%s variant=ca52_legacy data_uuid=%s tx_uuid=%s notify_uuids=%s header_mode=%s conn_hash8_prefix=%s",
                     self.address,
                     self._dataCharUuid,
-                    CASA_CLASSIC_DATA_CHAR_UUID,
+                    self._classicTxCharUuid,
+                    sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
                     self._classicHeaderMode,
                     b2a(self._classicConnHash8),
                 )
@@ -368,6 +438,8 @@ class CasambiClient:
                     getattr(self._network, "isManager", lambda: False)(),
                 )
                 _log_probe_summary("CLASSIC", classic_variant="ca52_legacy")
+                # Emit a warning if we never see Classic RX frames; this is a common failure mode.
+                self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
                 return
 
         # Conformant devices can expose the Classic signed channel on the EVO-style UUID too.
@@ -438,34 +510,79 @@ class CasambiClient:
 
             self._protocolMode = ProtocolMode.CLASSIC
             self._dataCharUuid = CASA_AUTH_CHAR_UUID
+            self._classicTxCharUuid = CASA_AUTH_CHAR_UUID
             self._classicHeaderMode = "conformant"
+            self._classicHashSource = "ca52_0001"
             self._classicConnHash8 = bytes(first[:8])
             self._classicCmdDiv = int.from_bytes(os.urandom(1), "big") or 1
             self._classicTxSeq = 0
 
+            # Probe mapped Classic CA51 (0002) for diagnostics; some firmwares use it for time/config.
+            try:
+                v = await self._gattClient.read_gatt_char(CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID)
+                c0002_prefix = b2a(v[:10]) if v else None
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] read classic-0002 ok len=%d prefix=%s",
+                        0 if v is None else len(v),
+                        c0002_prefix,
+                    )
+            except Exception as e:
+                c0002_err = type(e).__name__
+                if self._logger.isEnabledFor(logging.DEBUG):
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] read classic-0002 fail err=%s",
+                        c0002_err,
+                    )
+
             notify_kwargs: dict[str, Any] = {}
             notify_params = inspect.signature(self._gattClient.start_notify).parameters
             if "bluez" in notify_params:
                 notify_kwargs["bluez"] = {"use_start_notify": True}
-            await self._gattClient.start_notify(
-                CASA_AUTH_CHAR_UUID,
-                self._queueCallback,
-                **notify_kwargs,
-            )
+            try:
+                await self._gattClient.start_notify(
+                    CASA_AUTH_CHAR_UUID,
+                    self._queueCallback,
+                    **notify_kwargs,
+                )
+            except Exception as e:
+                ca52_notify_err = type(e).__name__
+            else:
+                self._classicNotifyCharUuids.add(CASA_AUTH_CHAR_UUID.lower())
+
+            # Probe mapped Classic CA53 (0003) notify: some firmwares may emit state/config here.
+            try:
+                await self._gattClient.start_notify(
+                    CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID,
+                    self._queueCallback,
+                    **notify_kwargs,
+                )
+            except Exception as e:
+                c0003_notify_err = type(e).__name__
+            else:
+                self._classicNotifyCharUuids.add(CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID.lower())
+
             self._connectionState = ConnectionState.AUTHENTICATED
             self._logger.info("Protocol mode selected: CLASSIC")
             if self._logger.isEnabledFor(logging.DEBUG):
-                self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
+                if ca52_notify_err is None:
+                    self._logger.debug("[CASAMBI_GATT_PROBE] start_notify auth ok (classic conformant)")
+                else:
+                    self._logger.debug(
+                        "[CASAMBI_GATT_PROBE] start_notify auth fail err=%s (classic conformant)",
+                        ca52_notify_err,
+                    )
                 self._logger.debug(
                     "[CASAMBI_CLASSIC_CONN_HASH] len=%d hash=%s",
                     len(self._classicConnHash8),
                     b2a(self._classicConnHash8),
                 )
             self._logger.warning(
-                "[CASAMBI_CLASSIC_SELECTED] address=%s variant=auth_uuid_conformant data_uuid=%s start_notify_uuid=%s header_mode=%s conn_hash8_prefix=%s",
+                "[CASAMBI_CLASSIC_SELECTED] address=%s variant=auth_uuid_conformant data_uuid=%s tx_uuid=%s notify_uuids=%s header_mode=%s conn_hash8_prefix=%s",
                 self.address,
                 self._dataCharUuid,
-                CASA_AUTH_CHAR_UUID,
+                self._classicTxCharUuid,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
                 self._classicHeaderMode,
                 b2a(self._classicConnHash8),
             )
@@ -476,6 +593,7 @@ class CasambiClient:
                 getattr(self._network, "isManager", lambda: False)(),
             )
             _log_probe_summary("CLASSIC", classic_variant="auth_uuid_conformant")
+            self._classicNoRxTask = asyncio.create_task(self._classic_no_rx_watchdog(30.0))
             return
 
         _log_probe_summary("UNKNOWN")
@@ -483,12 +601,45 @@ class CasambiClient:
             "No supported Casambi characteristics found (Classic ca51/ca52 or EVO/Classic-conformant auth char)."
         )
 
+    async def _classic_no_rx_watchdog(self, after_s: float) -> None:
+        """Emit one high-signal log if Classic RX stays silent after connect.
+
+        This helps testers capture actionable logs when Classic control/updates don't work yet.
+        """
+        try:
+            await asyncio.sleep(after_s)
+            if self._protocolMode != ProtocolMode.CLASSIC:
+                return
+            if self._classicFirstRxTs is not None:
+                return
+
+            self._logger.warning(
+                "[CASAMBI_CLASSIC_NO_RX] after_s=%s notify_uuids=%s tx_uuid=%s header_mode=%s "
+                "conn_hash8_prefix=%s visitor=%s manager=%s cloud_session_is_manager=%s",
+                after_s,
+                sorted(self._classicNotifyCharUuids) if self._classicNotifyCharUuids else None,
+                self._classicTxCharUuid,
+                self._classicHeaderMode,
+                None if self._classicConnHash8 is None else b2a(self._classicConnHash8),
+                self._network.classicVisitorKey() is not None,
+                self._network.classicManagerKey() is not None,
+                getattr(self._network, "isManager", lambda: False)(),
+            )
+        except asyncio.CancelledError:
+            return
+        except Exception:
+            # Never fail the connection because of diagnostics.
+            self._logger.debug("Classic no-RX watchdog failed.", exc_info=True)
+
     def _on_disconnect(self, client: BleakClient) -> None:
         if self._connectionState != ConnectionState.NONE:
             self._logger.info(f"Received disconnect callback from {self.address}")
         if self._connectionState == ConnectionState.AUTHENTICATED:
             self._logger.debug("Executing disconnect callback.")
             self._disconnectedCallback()
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
         self._connectionState = ConnectionState.NONE
 
     async def exchangeKey(self) -> None:
@@ -858,12 +1009,46 @@ 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:
             raise ProtocolError("Classic send called while not in Classic protocol mode.")
-        if not self._dataCharUuid:
-            raise ProtocolError("Classic data characteristic UUID not set.")
+        tx_uuid = self._classicTxCharUuid or self._dataCharUuid
+        if not tx_uuid:
+            raise ProtocolError("Classic TX characteristic UUID not set.")
         if self._classicConnHash8 is None:
             raise ClassicHandshakeError("Classic connection hash not available.")
 
@@ -974,12 +1159,13 @@ class CasambiClient:
         if self._logLimiter.allow("classic_tx", burst=50, window_s=60.0):
             auth_str = f"0x{auth_level:02x}" if header_mode == "conformant" else None
             self._logger.warning(
-                "[CASAMBI_CLASSIC_TX] header=%s key=%s signed=%s auth=%s sig_len=%d seq=%s "
+                "[CASAMBI_CLASSIC_TX] header=%s key=%s signed=%s tx_uuid=%s auth=%s sig_len=%d seq=%s "
                 "cmd_len=%d cmd_ord=%s target=%s div=%s lifetime=%s payload_len=%s "
                 "total_len=%d prefix=%s",
                 header_mode,
                 key_name,
                 signed,
+                tx_uuid,
                 auth_str,
                 sig_len,
                 None if seq is None else f"0x{seq:04x}",
@@ -995,11 +1181,59 @@ 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(self._dataCharUuid, 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),
+            )
 
     def _establishedNofityCallback(
         self, handle: BleakGATTCharacteristic, data: bytes
     ) -> None:
+        # Route notifications based on characteristic UUID when available.
+        # This helps with mixed/legacy setups where multiple Classic channels might be active.
+        try:
+            handle_uuid = str(getattr(handle, "uuid", "")).lower()
+        except Exception:
+            handle_uuid = ""
+        if handle_uuid and handle_uuid in self._classicNotifyCharUuids:
+            self._classicEstablishedNotifyCallback(handle, data)
+            return
         if self._protocolMode == ProtocolMode.CLASSIC:
             self._classicEstablishedNotifyCallback(handle, data)
             return
@@ -1074,8 +1308,26 @@ class CasambiClient:
         """
         self._inPacketCount += 1
         self._classicRxFrames += 1
+        rx_ts = time.monotonic()
+        if self._classicFirstRxTs is None:
+            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",
@@ -1265,6 +1517,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).
@@ -1681,6 +1963,10 @@ class CasambiClient:
     async def disconnect(self) -> None:
         self._logger.info("Disconnecting...")
 
+        if self._classicNoRxTask is not None:
+            self._classicNoRxTask.cancel()
+            self._classicNoRxTask = None
+
         if self._callbackTask is not None:
             # Cancel and await the background callback task to avoid
             # 'Task was destroyed but it is pending' warnings.
@@ -1702,3 +1988,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
+        }

CasambiBt/_constants.py

@@ -12,6 +12,15 @@ CASA_AUTH_CHAR_UUID: Final = "c9ffde48-ca5a-0001-ab83-8f519b482f77"
 CASA_UUID_CLASSIC: Final = "0000ca5a-0000-1000-8000-00805f9b34fb"
 CASA_CLASSIC_HASH_CHAR_UUID: Final = "0000ca51-0000-1000-8000-00805f9b34fb"
 CASA_CLASSIC_DATA_CHAR_UUID: Final = "0000ca52-0000-1000-8000-00805f9b34fb"
+CASA_CLASSIC_CA53_CHAR_UUID: Final = "0000ca53-0000-1000-8000-00805f9b34fb"
+
+# Classic "conformant" firmware maps the legacy CA5A/CA5x UUIDs onto the FE4D service.
+# Ground truth: casambi-android `t1.C1713d.e(UUID)` mapping:
+# - CA52 -> 0001 (same as CASA_AUTH_CHAR_UUID)
+# - CA51 -> 0002
+# - CA53 -> 0003
+CASA_CLASSIC_CONFORMANT_CA51_CHAR_UUID: Final = "c9ffde48-ca5a-0002-ab83-8f519b482f77"
+CASA_CLASSIC_CONFORMANT_CA53_CHAR_UUID: Final = "c9ffde48-ca5a-0003-ab83-8f519b482f77"
 
 
 @unique

CasambiBt/_network.py

@@ -291,7 +291,7 @@ class Network:
                         "[CASAMBI_CLOUD_UPDATE_RETRY] status=400 retry_with_token_clientInfo=true body_prefix=%r",
                         (res.text or "")[:200],
                     )
-                    payload2 = dict(payload)
+                    payload2: dict[str, Any] = dict(payload)
                     payload2["token"] = self._token
                     payload2["clientInfo"] = self._clientInfo
                     res = await self._httpClient.put(
@@ -301,26 +301,33 @@ class Network:
                     )
 
                 if res.status_code != httpx.codes.OK:
-                    self._logger.error(
-                        "Update failed: %s body_prefix=%r",
+                    body_prefix = (res.text or "")[:500]
+                    # If we have cached network data, do not fail setup; continue offline.
+                    # This is important for HA stability and for "cloud down / API changed" scenarios.
+                    have_cache = bool(self._networkRevision and self._networkRevision > 0 and self._rawNetworkData)
+                    self._logger.warning(
+                        "[CASAMBI_CLOUD_UPDATE_FAILED] status=%s cached_revision=%s continuing_offline=%s body_prefix=%r",
                         res.status_code,
-                        (res.text or "")[:500],
-                    )
-                    raise NetworkUpdateError("Could not update network!")
-
-                self._logger.debug(f"Network: {res.text}")
-
-                updateResult = res.json()
-                if updateResult["status"] != "UPTODATE":
-                    self._networkRevision = updateResult["network"]["revision"]
-                    self._rawNetworkData = updateResult
-                    async with self._cache as cachePath:
-                        cachedNetworkPah = cachePath / f"{self._id}.json"
-                        await cachedNetworkPah.write_bytes(res.content)
-                    network = updateResult
-                    self._logger.info(
-                        f"Fetched updated network with revision {self._networkRevision}"
+                        self._networkRevision,
+                        have_cache,
+                        body_prefix,
                     )
+                    if not have_cache:
+                        raise NetworkUpdateError("Could not update network!")
+                else:
+                    self._logger.debug(f"Network: {res.text}")
+
+                    updateResult = res.json()
+                    if updateResult["status"] != "UPTODATE":
+                        self._networkRevision = updateResult["network"]["revision"]
+                        self._rawNetworkData = updateResult
+                        async with self._cache as cachePath:
+                            cachedNetworkPah = cachePath / f"{self._id}.json"
+                            await cachedNetworkPah.write_bytes(res.content)
+                        network = updateResult
+                        self._logger.info(
+                            f"Fetched updated network with revision {self._networkRevision}"
+                        )
             except RequestError as err:
                 if self._networkRevision == 0:
                     raise NetworkUpdateError from err

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.dev8"
+__version__ = "0.3.12.dev10"

{casambi_bt_revamped-0.3.12.dev8.dist-info → casambi_bt_revamped-0.3.12.dev10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.12.dev8
+Version: 0.3.12.dev10
 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.dev10.dist-info/RECORD

@@ -0,0 +1,22 @@
+CasambiBt/__init__.py,sha256=iJdTF4oeXfj5d5gfGxQkacqUjtnQo0IW-zFPJvFjWWk,336
+CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
+CasambiBt/_casambi.py,sha256=9pWTxR1ZBARK-IB91PSRAQrcRoswU40jI-9AfLPpvW0,41649
+CasambiBt/_classic_crypto.py,sha256=XIp3JBaeY8hIUv5kB0ygVG_eRx9AgHHF4ts2--CFm78,4973
+CasambiBt/_client.py,sha256=EuaCwb3t6D0sbQR6XA84UWDEtkc3n7WBRozsM2kFu-Y,83927
+CasambiBt/_constants.py,sha256=86heoDdb5iPaRrPmK2DIIl-4uSxbFFcnCo9zlCvTLww,1290
+CasambiBt/_discover.py,sha256=jLc6H69JddrCURgtANZEjws6_UbSzXJtvJkbKTaIUHY,1849
+CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
+CasambiBt/_invocation.py,sha256=fkG4R0Gv5_amFfD_P6DKuIEe3oKWZW0v8RSU8zDjPdI,2985
+CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
+CasambiBt/_network.py,sha256=ai1o3EybsAhjyPohSOxeE0cWoFvEqdcc3PE3uFDaTfE,21346
+CasambiBt/_operation.py,sha256=Q5UccsrtNp_B_wWqwH_3eLFW_yF6A55FMmfUKDk2WrI,1059
+CasambiBt/_switch_events.py,sha256=S8OD0dBcw5T4J2C7qfmOQMnTJ7omIXRUYv4PqDOB87E,13137
+CasambiBt/_unit.py,sha256=nxbg_8UCCVB9WI8dUS21g2JrGyPKcefqKMSusMOhLOo,18721
+CasambiBt/_version.py,sha256=KfDHVZ0HvUoCJCQD90I4l0PCSgOKne4pUVo8Y_Hv5Xk,338
+CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
+CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+casambi_bt_revamped-0.3.12.dev10.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
+casambi_bt_revamped-0.3.12.dev10.dist-info/METADATA,sha256=VYoGQSXLxJqbL3RSHlXZbuwsMydhxXPvfIPYQnGfhac,5878
+casambi_bt_revamped-0.3.12.dev10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+casambi_bt_revamped-0.3.12.dev10.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
+casambi_bt_revamped-0.3.12.dev10.dist-info/RECORD,,

casambi_bt_revamped-0.3.12.dev8.dist-info/RECORD

@@ -1,22 +0,0 @@
-CasambiBt/__init__.py,sha256=iJdTF4oeXfj5d5gfGxQkacqUjtnQo0IW-zFPJvFjWWk,336
-CasambiBt/_cache.py,sha256=3bQil8vhSy4f4sf9JusMfEdQC7d3cJuva9qHhyKro-0,3808
-CasambiBt/_casambi.py,sha256=TN4ecgjm95nSJ4h9TsKayNn577Y82fdsGK4IGUZF23Q,40666
-CasambiBt/_classic_crypto.py,sha256=6DcCOdjLQo7k2cOOutNdUKupykOG_E2TDDwg6fH-ODM,998
-CasambiBt/_client.py,sha256=dG-VRlZ0n7Eng8ORc-Xk8rifCVAcXBexFroA4BLQ_w8,69657
-CasambiBt/_constants.py,sha256=sbElg5W8eeQvvL1rHn_E0jhP1wOrrabc7dFLLnlDMsU,810
-CasambiBt/_discover.py,sha256=jLc6H69JddrCURgtANZEjws6_UbSzXJtvJkbKTaIUHY,1849
-CasambiBt/_encryption.py,sha256=CLcoOOrggQqhJbnr_emBnEnkizpWDvb_0yFnitq4_FM,3831
-CasambiBt/_invocation.py,sha256=fkG4R0Gv5_amFfD_P6DKuIEe3oKWZW0v8RSU8zDjPdI,2985
-CasambiBt/_keystore.py,sha256=Jdiq0zMPDmhfpheSojKY6sTUpmVrvX_qOyO7yCYd3kw,2788
-CasambiBt/_network.py,sha256=nB_pRB9dZL6P7THeuOce7ctWd0wXyCWF13h67SauZVQ,20714
-CasambiBt/_operation.py,sha256=Q5UccsrtNp_B_wWqwH_3eLFW_yF6A55FMmfUKDk2WrI,1059
-CasambiBt/_switch_events.py,sha256=S8OD0dBcw5T4J2C7qfmOQMnTJ7omIXRUYv4PqDOB87E,13137
-CasambiBt/_unit.py,sha256=nxbg_8UCCVB9WI8dUS21g2JrGyPKcefqKMSusMOhLOo,18721
-CasambiBt/_version.py,sha256=RkpM6Fp6uH7xKTYzqUnnINOKTs0TrFqLrkU4nloEFrU,337
-CasambiBt/errors.py,sha256=1L_Q8og_N_BRYEKizghAQXr6tihlHykFgtcCHUDcBas,1961
-CasambiBt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-casambi_bt_revamped-0.3.12.dev8.dist-info/licenses/LICENSE,sha256=TAIIitFxpxEDi6Iju7foW4TDQmWvC-IhLVLhl67jKmQ,11341
-casambi_bt_revamped-0.3.12.dev8.dist-info/METADATA,sha256=d0oJkqNgiNr_ACzBbE_6Z2i93Wsa1oG_gZi54xgNiJo,5877
-casambi_bt_revamped-0.3.12.dev8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-casambi_bt_revamped-0.3.12.dev8.dist-info/top_level.txt,sha256=uNbqLjtecFosoFzpGAC89-5icikWODKI8rOjbi8v_sA,10
-casambi_bt_revamped-0.3.12.dev8.dist-info/RECORD,,