casambi-bt-revamped 0.3.7.dev11__tar.gz → 0.3.7.dev13__tar.gz

{casambi_bt_revamped-0.3.7.dev11/src/casambi_bt_revamped.egg-info → casambi_bt_revamped-0.3.7.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.7.dev11
+Version: 0.3.7.dev13
 Summary: Enhanced Casambi Bluetooth client library with switch event support
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie

{casambi_bt_revamped-0.3.7.dev11 → casambi_bt_revamped-0.3.7.dev13}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = casambi-bt-revamped
-version = 0.3.7.dev11
+version = 0.3.7.dev13
 author = rankjie
 author_email = rankjie@gmail.com
 description = Enhanced Casambi Bluetooth client library with switch event support

{casambi_bt_revamped-0.3.7.dev11 → casambi_bt_revamped-0.3.7.dev13}/src/CasambiBt/_casambi.py

@@ -551,6 +551,270 @@ class Casambi:
                     exc_info=True,
                 )
 
+    async def setParameter(self, unitId: int, parameterTag: int, parameterData: bytes) -> None:
+        """Send a SetParameter command to a unit.
+        
+        Args:
+            unitId: The ID of the unit to send the command to
+            parameterTag: The parameter tag/ID to update
+            parameterData: The raw parameter data to send
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        
+        # Build payload: [parameter_tag][parameter_data]
+        # Note: SetParameter supports max 31 bytes after the tag.
+        payload = bytes([parameterTag]) + parameterData[:31]
+        
+        # Send using OpCode.SetParameter (26)
+        opPkt = self._opContext.prepareOperation(OpCode.SetParameter, (unitId << 8) | 0x01, payload)
+        await self._casaClient.send(opPkt)
+
+    async def send_ext_packet(self, unit_id: int, seq: int, chunk: bytes, *, lifetime: int = 9) -> None:
+        """Send an extended packet (ExtPacketSend / opcode 43) to a unit.
+
+        Payload is framed as: [0x29][seq][chunk...]
+
+        Notes:
+        - Total payload must be <= 63 bytes, so len(chunk) <= 61.
+        - Lifetime defaults to 9 to mirror longer-running multi-chunk ops seen on Android.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+
+        if seq < 0 or seq > 255:
+            raise ValueError("seq must be 0..255")
+        if len(chunk) > 61:
+            raise ValueError("chunk too large; max 61 bytes to fit ExtPacket payload")
+
+        payload = bytes([0x29, seq & 0xFF]) + chunk
+        target = (int(unit_id) << 8) | 0x01
+        opPkt = self._opContext.prepareOperation(
+            OpCode.ExtPacketSend,
+            target,
+            payload,
+            lifetime=lifetime,
+        )
+        await self._casaClient.send(opPkt)
+
+    async def start_switch_session(self, unit_id: int, *, payload: bytes = b"", lifetime: int = 9) -> None:
+        """Experimental: send AcquireSwitchSession (opcode 42).
+
+        Payload is device-specific and currently unknown for switchConfig; by default
+        sends an empty payload. Use for experimentation only until framing is confirmed.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if len(payload) > 63:
+            raise ValueError("payload too large; max 63 bytes")
+        target = (int(unit_id) << 8) | 0x01
+        opPkt = self._opContext.prepareOperation(
+            OpCode.AcquireSwitchSession,
+            target,
+            payload,
+            lifetime=lifetime,
+        )
+        await self._casaClient.send(opPkt)
+
+    async def apply_switch_config_ble(self, unit_id: int, *, parameter_tag: int | None = None) -> None:
+        """Attempt to push the unit's switchConfig to the device over BLE.
+
+        This method currently supports only very small configurations that fit
+        into a single SetParameter payload (max 31 bytes after the tag).
+
+        Args:
+            unit_id: The ID of the unit to update.
+            parameter_tag: Optional override for the parameter tag; if not provided,
+                           a default of 1 is used (subject to device variation).
+
+        Raises:
+            RuntimeError: If not connected or no raw network data.
+            ValueError: If the encoded switchConfig is too large for SetParameter.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if not self._casaNetwork or not self._casaNetwork.rawNetworkData:
+            raise RuntimeError("No raw network data available; connect and update first")
+
+        units = self._casaNetwork.rawNetworkData.get("network", {}).get("units", [])
+        unit_data = next((u for u in units if u.get("deviceID") == unit_id), None)
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+
+        import json
+        config_bytes = json.dumps(switch_config, separators=(",", ":")).encode("utf-8")
+
+        # Protocol restriction: SetParameter accepts max 31 bytes after tag.
+        if len(config_bytes) > 31:
+            raise ValueError(
+                "switchConfig exceeds 31 bytes; multi-packet BLE apply is required. "
+                "This library will need an extended writer (AcquireSwitchSession/ExtPacketSend) to support large configs."
+            )
+
+        tag = 1 if parameter_tag is None else int(parameter_tag)
+        await self.setParameter(unit_id, tag, config_bytes)
+        self._logger.info(
+            "Applied switchConfig via SetParameter (tag=%s, bytes=%s) for unit %s",
+            tag,
+            len(config_bytes),
+            unit_id,
+        )
+
+    async def apply_switch_config_ble_large(self, unit_id: int) -> None:
+        """Experimental: attempt to push switchConfig using ExtPacketSend in chunks.
+
+        WARNING: Framing is not fully confirmed for switchConfig updates. This method
+        sends raw JSON bytes chunked as consecutive ExtPacket frames with header
+        [0x29][seq]. Use only for experimentation and logs; correctness is not guaranteed.
+        """
+        if not self._casaClient:
+            raise RuntimeError("Not connected to network")
+        if not self._casaNetwork or not self._casaNetwork.rawNetworkData:
+            raise RuntimeError("No raw network data available; connect and update first")
+
+        units = self._casaNetwork.rawNetworkData.get("network", {}).get("units", [])
+        unit_data = next((u for u in units if u.get("deviceID") == unit_id), None)
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+        import json
+        data = json.dumps(switch_config, separators=(",", ":")).encode("utf-8")
+
+        # Attempt to start a switch session before sending chunks. Some devices
+        # expect an AcquireSwitchSession (opcode 42) handshake prior to ExtPacketSend.
+        try:
+            await self.start_switch_session(unit_id)
+            self._logger.info("Started switch session (AcquireSwitchSession) for unit %s", unit_id)
+        except Exception as e:
+            # Non-fatal: proceed without session if device doesn't require it.
+            self._logger.info(
+                "AcquireSwitchSession not acknowledged or unsupported for unit %s (%s); proceeding with ExtPacketSend only.",
+                unit_id,
+                e,
+            )
+
+        # Chunk into 61-byte pieces (ExtPacket payload allows 63 total minus 2-byte header)
+        max_chunk = 61
+        seq = 0
+        for off in range(0, len(data), max_chunk):
+            chunk = data[off : off + max_chunk]
+            await self.send_ext_packet(unit_id, seq, chunk, lifetime=9)
+            self._logger.debug(
+                "ExtPacket chunk sent: unit=%s seq=%s size=%s/%s", unit_id, seq, len(chunk), len(data)
+            )
+            seq = (seq + 1) & 0xFF
+        self._logger.info(
+            "ExtPacket switchConfig attempt complete (unit=%s, total_bytes=%s, chunks=%s)",
+            unit_id,
+            len(data),
+            (len(data) + max_chunk - 1) // max_chunk,
+        )
+
+    async def update_button_config(
+        self,
+        unit_id: int,
+        button_index: int,
+        action_type: str,
+        target_id: int | None = None,
+        *,
+        exclusive_scenes: bool | None = None,
+        long_press_all_off: bool | None = None,
+        toggle_disabled: bool | None = None,
+    ) -> dict:
+        """Update one button entry in a unit's switchConfig in the cached network data.
+
+        Android mapping for actions (EnumC0105q):
+        - none -> 0, target 0
+        - scene -> 1, target=sceneID
+        - control_unit -> 2, target=deviceID
+        - control_group -> 3, target=groupID
+        - all_units -> 4, target=255
+        - resume_automation -> 6, target=0
+        - resume_automation_group -> 7, target=groupID
+
+        Returns the updated switchConfig dict.
+        """
+        if button_index < 0 or button_index > 7:
+            raise ValueError("button_index must be in range 0..7")
+
+        raw = self.rawNetworkData
+        if not raw:
+            raise RuntimeError("No raw network data loaded. Connect and update first.")
+
+        # Locate the unit's JSON entry
+        units = raw.get("network", {}).get("units", [])
+        unit_data = None
+        for u in units:
+            if u.get("deviceID") == unit_id:
+                unit_data = u
+                break
+        if not unit_data:
+            raise ValueError(f"Unit {unit_id} not found in raw network data")
+
+        switch_config = unit_data.get("switchConfig") or {}
+        buttons: list[dict] = switch_config.get("buttons") or []
+
+        action_map = {
+            "none": 0,
+            "scene": 1,
+            "control_unit": 2,
+            "control_group": 3,
+            "all_units": 4,
+            "resume_automation": 6,
+            "resume_automation_group": 7,
+        }
+        if action_type not in action_map:
+            raise ValueError(
+                "Unsupported action_type. Use one of: none, scene, control_unit, "
+                "control_group, all_units, resume_automation, resume_automation_group"
+            )
+        action_code = action_map[action_type]
+
+        if action_type == "all_units":
+            resolved_target = 255
+        elif action_type in ("none", "resume_automation"):
+            resolved_target = 0
+        else:
+            if target_id is None:
+                raise ValueError(f"target_id is required for action_type '{action_type}'")
+            resolved_target = int(target_id)
+
+        # Find or create entry for this button index
+        existing = None
+        for b in buttons:
+            if b.get("type") == button_index:
+                existing = b
+                break
+        entry = existing or {"type": button_index, "action": 0, "target": 0}
+        entry["action"] = action_code
+        entry["target"] = resolved_target
+        if not existing:
+            buttons.append(entry)
+
+        # Persist and apply optional flags
+        switch_config["buttons"] = buttons
+        if exclusive_scenes is not None:
+            switch_config["exclusiveScenes"] = bool(exclusive_scenes)
+        if long_press_all_off is not None:
+            switch_config["longPressAllOff"] = bool(long_press_all_off)
+        if toggle_disabled is not None:
+            switch_config["toggleDisabled"] = bool(toggle_disabled)
+
+        unit_data["switchConfig"] = switch_config
+
+        self._logger.info(
+            "Updated switchConfig (unit=%s, button=%s, action=%s, target=%s)",
+            unit_id,
+            button_index,
+            action_type,
+            resolved_target,
+        )
+
+        return switch_config
+
     async def disconnect(self) -> None:
         """Disconnect from the network."""
         if self._casaClient:

{casambi_bt_revamped-0.3.7.dev11 → casambi_bt_revamped-0.3.7.dev13}/src/CasambiBt/_client.py

@@ -497,11 +497,20 @@ class CasambiClient:
             f"Parsing incoming switch event packet #{packet_seq}... Data: {b2a(data)}"
         )
 
-        # Special handling for message type 0x29 - not a switch event
+        # Special handling for message type 0x29 - likely an extended/aux message
         if len(data) >= 1 and data[0] == 0x29:
-            self._logger.debug(
-                f"Ignoring message type 0x29 (not a switch event): {b2a(data)}"
-            )
+            # Log details so we can correlate with outgoing ExtPacketSend trials
+            if len(data) >= 3:
+                length = ((data[2] >> 4) & 15) + 1
+                parameter = data[2] & 15
+                payload = data[3 : 3 + min(length, max(0, len(data) - 3))]
+                self._logger.info(
+                    f"Ext-like message at packet head: flags=0x{data[1]:02x}, param={parameter}, payload={b2a(payload)}"
+                )
+            else:
+                self._logger.info(
+                    f"Ext-like message 0x29 at packet head with insufficient length: {b2a(data)}"
+                )
             return
 
         pos = 0
@@ -543,21 +552,32 @@ class CasambiClient:
                 # Process based on message type
                 if message_type == 0x08 or message_type == 0x10:  # Switch/button events
                     switch_events_found += 1
-                    # Extract button ID - try both upper and lower nibbles
-                    button_lower = parameter & 0x0F
-                    button_upper = (parameter >> 4) & 0x0F
-
-                    # Use upper 4 bits if lower 4 bits are 0, otherwise use lower 4 bits
-                    if button_lower == 0 and button_upper != 0:
-                        button = button_upper
+                    
+                    # Button extraction differs between type 0x08 and type 0x10
+                    if message_type == 0x08:
+                        # For type 0x08, the lower nibble is a code that maps to physical button id
+                        # Using formula: ((code + 2) % 4) + 1 based on reverse engineering findings
+                        code_nibble = parameter & 0x0F
+                        button = ((code_nibble + 2) % 4) + 1
                         self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}"
+                            f"Type 0x08 button extraction: parameter=0x{parameter:02x}, code={code_nibble}, button={button}"
                         )
                     else:
-                        button = button_lower
-                        self._logger.debug(
-                            f"EVO button extraction: parameter=0x{parameter:02x}, using lower nibble, button={button}"
-                        )
+                        # For type 0x10, use existing logic
+                        button_lower = parameter & 0x0F
+                        button_upper = (parameter >> 4) & 0x0F
+
+                        # Use upper 4 bits if lower 4 bits are 0, otherwise use lower 4 bits
+                        if button_lower == 0 and button_upper != 0:
+                            button = button_upper
+                            self._logger.debug(
+                                f"Type 0x10 button extraction: parameter=0x{parameter:02x}, using upper nibble, button={button}"
+                            )
+                        else:
+                            button = button_lower
+                            self._logger.debug(
+                                f"Type 0x10 button extraction: parameter=0x{parameter:02x}, using lower nibble, button={button}"
+                            )
 
                     # For type 0x10 messages, we need to pass additional data beyond the declared payload
                     if message_type == 0x10:
@@ -577,8 +597,10 @@ class CasambiClient:
                         raw_packet,
                     )
                 elif message_type == 0x29:
-                    # This shouldn't happen due to check above, but just in case
-                    self._logger.debug("Ignoring embedded type 0x29 message")
+                    # Extended/aux message embedded in switch event packet
+                    self._logger.info(
+                        f"Embedded 0x29 ext-like msg: flags=0x{flags:02x}, param=0x{parameter & 0x0F:01x}, payload={b2a(payload)}"
+                    )
                 elif message_type in [0x00, 0x06, 0x09, 0x1F, 0x2A]:
                     # Known non-switch message types - log at debug level
                     self._logger.debug(
@@ -694,13 +716,12 @@ class CasambiClient:
             f"action={action_display} ({event_string}), flags=0x{flags:02x}"
         )
 
-        # Filter out all type 0x08 messages
+        # Log detailed info about type 0x08 messages (now processed, not filtered)
         if message_type == 0x08:
-            self._logger.debug(
-                f"Filtering out type 0x08 event: button={button}, unit_id={unit_id}, "
-                f"action={action_display}, flags=0x{flags:02x}"
+            self._logger.info(
+                f"Type 0x08 event processed: button={button}, unit_id={unit_id}, "
+                f"action={action_display}, event={event_string}, flags=0x{flags:02x}"
             )
-            return
 
         self._dataCallback(
             IncommingPacketType.SwitchEvent,

{casambi_bt_revamped-0.3.7.dev11 → casambi_bt_revamped-0.3.7.dev13}/src/CasambiBt/_operation.py

@@ -11,6 +11,9 @@ class OpCode(IntEnum):
     SetWhite = 5
     SetColor = 7
     SetSlider = 12
+    SetParameter = 26
+    AcquireSwitchSession = 42
+    ExtPacketSend = 43
     SetState = 48
     SetColorXY = 54
 
@@ -20,11 +23,19 @@ class OperationsContext:
         self.origin: int = 1
         self.lifetime: int = 5
 
-    def prepareOperation(self, op: OpCode, target: int, payload: bytes) -> bytes:
+    def prepareOperation(
+        self,
+        op: OpCode,
+        target: int,
+        payload: bytes,
+        *,
+        lifetime: int | None = None,
+    ) -> bytes:
         if len(payload) > 63:
             raise ValueError("Payload too long")
 
-        flags = (self.lifetime & 15) << 11 | len(payload)
+        lt = self.lifetime if lifetime is None else int(lifetime)
+        flags = (lt & 15) << 11 | len(payload)
 
         # Ensure that origin can't overflow.
         # TODO: Check that unsigned is actually correct here.

{casambi_bt_revamped-0.3.7.dev11 → casambi_bt_revamped-0.3.7.dev13/src/casambi_bt_revamped.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: casambi-bt-revamped
-Version: 0.3.7.dev11
+Version: 0.3.7.dev13
 Summary: Enhanced Casambi Bluetooth client library with switch event support
 Home-page: https://github.com/rankjie/casambi-bt
 Author: rankjie