Add HA custom integration; fix bleak 3.x write-without-response regression
The OneControl panel's command characteristic is a streaming (Write Without Response) endpoint. Bleak 3.x changed write_gatt_char to default to write-with-response when the char advertises the "write" property, so every command (incl. switch turn_on/off) got rejected by the panel with ATT 0x0E (Unlikely Error), surfaced as BleakGATTProtocolError. Force response=False on the command write (matching the auth key write) to restore control. Also commits the productionized custom_components integration (config flow, coordinator, switch/sensor/cover entities, key-seed TEA auth, COBS codec) and the matching src/ RE client/COBS fixes (big-endian framing, table-driven CRC8, status-event decoding) that were developed but never tracked. Verified live on the campsite HAOS Pi: switch.exterior_lights / interior_lights toggle the physical panel with no GATT error. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
+110
-81
@@ -2,121 +2,150 @@
|
||||
# COBS encoding/decoding and CRC8 implementation for Lippert OneControl
|
||||
# Based on decompiled source from IDS.Portable.Common.COBS/CobsEncoder.cs and Crc8.cs
|
||||
|
||||
from typing import List
|
||||
|
||||
|
||||
class Crc8:
|
||||
"""CRC8 with init value 0x55 (from Crc8.cs)"""
|
||||
POLY = 0x07
|
||||
"""CRC8 using the exact lookup table from IDS.Portable.Common/Crc8.cs (init=0x55)."""
|
||||
|
||||
def __init__(self, init: int = 0x55):
|
||||
self.value = init
|
||||
_TABLE = [
|
||||
0, 94, 188, 226, 97, 63, 221, 131, 194, 156,
|
||||
126, 32, 163, 253, 31, 65, 157, 195, 33, 127,
|
||||
252, 162, 64, 30, 95, 1, 227, 189, 62, 96,
|
||||
130, 220, 35, 125, 159, 193, 66, 28, 254, 160,
|
||||
225, 191, 93, 3, 128, 222, 60, 98, 190, 224,
|
||||
2, 92, 223, 129, 99, 61, 124, 34, 192, 158,
|
||||
29, 67, 161, 255, 70, 24, 250, 164, 39, 121,
|
||||
155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
|
||||
219, 133, 103, 57, 186, 228, 6, 88, 25, 71,
|
||||
165, 251, 120, 38, 196, 154, 101, 59, 217, 135,
|
||||
4, 90, 184, 230, 167, 249, 27, 69, 198, 152,
|
||||
122, 36, 248, 166, 68, 26, 153, 199, 37, 123,
|
||||
58, 100, 134, 216, 91, 5, 231, 185, 140, 210,
|
||||
48, 110, 237, 179, 81, 15, 78, 16, 242, 172,
|
||||
47, 113, 147, 205, 17, 79, 173, 243, 112, 46,
|
||||
204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
|
||||
175, 241, 19, 77, 206, 144, 114, 44, 109, 51,
|
||||
209, 143, 12, 82, 176, 238, 50, 108, 142, 208,
|
||||
83, 13, 239, 177, 240, 174, 76, 18, 145, 207,
|
||||
45, 115, 202, 148, 118, 40, 171, 245, 23, 73,
|
||||
8, 86, 180, 234, 105, 55, 213, 139, 87, 9,
|
||||
235, 181, 54, 104, 138, 212, 149, 203, 41, 119,
|
||||
244, 170, 72, 22, 233, 183, 85, 11, 136, 214,
|
||||
52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
|
||||
116, 42, 200, 150, 21, 75, 169, 247, 182, 232,
|
||||
10, 84, 215, 137, 107, 53,
|
||||
]
|
||||
|
||||
def update(self, byte: int):
|
||||
self.value ^= byte
|
||||
for _ in range(8):
|
||||
if self.value & 0x80:
|
||||
self.value = ((self.value << 1) ^ self.POLY) & 0xFF
|
||||
else:
|
||||
self.value = (self.value << 1) & 0xFF
|
||||
|
||||
def update_buffer(self, data: bytes):
|
||||
for b in data:
|
||||
self.update(b)
|
||||
RESET_VALUE = 0x55
|
||||
|
||||
@staticmethod
|
||||
def calculate(data: bytes, init: int = 0x55) -> int:
|
||||
crc = Crc8(init)
|
||||
crc.update_buffer(data)
|
||||
return crc.value
|
||||
def calculate(data: bytes) -> int:
|
||||
crc = Crc8.RESET_VALUE
|
||||
for b in data:
|
||||
crc = Crc8._TABLE[(crc ^ b) & 0xFF]
|
||||
return crc
|
||||
|
||||
|
||||
class CobsEncoder:
|
||||
"""COBS Encoder matching CobsEncoder.cs (numDataBits=6, prependStartFrame=true, useCrc=true).
|
||||
|
||||
Code byte format: num_data_bytes + (num_consecutive_zeros * 64)
|
||||
This differs from standard COBS — zeros are packed into the code byte, not output inline.
|
||||
"""
|
||||
COBS Encoder matching DirectConnectionMyRvLinkBle.cs:44
|
||||
prependStartFrame=true, useCrc=true, frameByte=0, numDataBits=6
|
||||
"""
|
||||
|
||||
LSB = 1 << 6 # 64 (FrameByteCountLsb)
|
||||
MAX_DATA = LSB - 1 # 63 (MaxDataBytes)
|
||||
MAX_ZEROS = 255 - MAX_DATA # 192 (MaxCompressedFrameBytes)
|
||||
|
||||
def __init__(self):
|
||||
self.frame_byte = 0x00
|
||||
self.max_data_bytes = (1 << 6) - 1 # 63 bytes (6-bit)
|
||||
|
||||
def encode(self, source: bytes) -> bytes:
|
||||
"""Encode with CRC8 and COBS"""
|
||||
if not source:
|
||||
return bytes([self.frame_byte])
|
||||
|
||||
# 1. Calculate CRC8
|
||||
"""Encode source bytes with CRC8 appended, using Lippert COBS variant."""
|
||||
crc = Crc8.calculate(source)
|
||||
data_with_crc = source + bytes([crc])
|
||||
|
||||
# 2. COBS encode
|
||||
output = bytearray([self.frame_byte]) # Prepend start frame
|
||||
data = source + bytes([crc])
|
||||
|
||||
output = bytearray([self.frame_byte]) # Start frame
|
||||
i = 0
|
||||
while i < len(data_with_crc):
|
||||
while i < len(data):
|
||||
code_index = len(output)
|
||||
output.append(0xFF) # Placeholder for code byte
|
||||
output.append(0) # Placeholder for code byte
|
||||
num6 = 0
|
||||
|
||||
count = 0
|
||||
while i < len(data_with_crc) and count < self.max_data_bytes:
|
||||
byte = data_with_crc[i]
|
||||
if byte == self.frame_byte:
|
||||
# Collect non-zero data bytes (up to MAX_DATA)
|
||||
while i < len(data) and num6 < self.MAX_DATA:
|
||||
b = data[i]
|
||||
if b == self.frame_byte:
|
||||
break
|
||||
output.append(byte)
|
||||
i += 1
|
||||
count += 1
|
||||
|
||||
# Update code byte
|
||||
output[code_index] = count + 1
|
||||
|
||||
# Skip frame bytes
|
||||
while i < len(data_with_crc) and data_with_crc[i] == self.frame_byte:
|
||||
output.append(b)
|
||||
num6 += 1
|
||||
i += 1
|
||||
|
||||
output.append(self.frame_byte) # Append end frame
|
||||
# Collect consecutive zero bytes, packing each as +LSB in the code byte
|
||||
while i < len(data):
|
||||
if data[i] != self.frame_byte:
|
||||
break
|
||||
num6 += self.LSB
|
||||
i += 1
|
||||
if num6 >= self.MAX_ZEROS:
|
||||
break
|
||||
|
||||
output[code_index] = num6
|
||||
|
||||
output.append(self.frame_byte) # End frame
|
||||
return bytes(output)
|
||||
|
||||
|
||||
class CobsDecoder:
|
||||
"""COBS Decoder for responses"""
|
||||
"""COBS Decoder — stateful byte-at-a-time algorithm matching CobsDecoder.cs.
|
||||
|
||||
Code byte encoding (numDataBits=6):
|
||||
code_byte = (num_zeros_to_insert << 6) | num_data_bytes_before_trigger
|
||||
When the lower 6 bits of the running code_byte reach 0, the upper bits
|
||||
tell how many zero bytes to insert. This differs from standard COBS.
|
||||
"""
|
||||
|
||||
NUM_DATA_BITS = 6
|
||||
LSB = 1 << NUM_DATA_BITS # 64
|
||||
MAX_DATA_MASK = LSB - 1 # 63 (0x3F)
|
||||
|
||||
def __init__(self):
|
||||
self.frame_byte = 0x00
|
||||
|
||||
def decode(self, encoded: bytes) -> bytes:
|
||||
"""Decode COBS packet"""
|
||||
if not encoded or encoded[0] != self.frame_byte:
|
||||
raise ValueError("Invalid COBS packet")
|
||||
|
||||
"""Decode one complete COBS packet (start frame … end frame)."""
|
||||
output = bytearray()
|
||||
i = 1 # Skip start frame
|
||||
code_byte = 0
|
||||
|
||||
while i < len(encoded):
|
||||
code = encoded[i]
|
||||
if code == 0:
|
||||
break
|
||||
for b in encoded:
|
||||
if b == self.frame_byte:
|
||||
# Frame byte — either start (no data yet) or end (complete packet)
|
||||
if code_byte != 0 or len(output) == 0:
|
||||
# Start frame or error: reset state
|
||||
output.clear()
|
||||
code_byte = 0
|
||||
continue
|
||||
# End frame: strip CRC and return
|
||||
if len(output) < 1:
|
||||
raise ValueError("Empty COBS packet")
|
||||
received_crc = output[-1]
|
||||
data = output[:-1]
|
||||
calc_crc = Crc8.calculate(data)
|
||||
if received_crc != calc_crc:
|
||||
raise ValueError(f"CRC mismatch: received 0x{received_crc:02x} != calculated 0x{calc_crc:02x}")
|
||||
return bytes(data)
|
||||
|
||||
i += 1
|
||||
count = code - 1
|
||||
if code_byte <= 0:
|
||||
# Code byte: encodes data-count (low 6 bits) + zero-count (high bits)
|
||||
code_byte = b
|
||||
else:
|
||||
# Data byte
|
||||
code_byte -= 1
|
||||
output.append(b)
|
||||
|
||||
# Copy data bytes
|
||||
for _ in range(count):
|
||||
if i >= len(encoded):
|
||||
break
|
||||
output.append(encoded[i])
|
||||
i += 1
|
||||
# When lower NUM_DATA_BITS of code_byte hit zero, insert implied zeros
|
||||
if (code_byte & self.MAX_DATA_MASK) == 0:
|
||||
while code_byte > 0:
|
||||
output.append(self.frame_byte)
|
||||
code_byte -= self.LSB
|
||||
|
||||
# Add frame byte if not at end
|
||||
if code < 0xFF and i < len(encoded):
|
||||
output.append(self.frame_byte)
|
||||
|
||||
# Verify CRC
|
||||
if len(output) > 0:
|
||||
data = output[:-1]
|
||||
received_crc = output[-1]
|
||||
calculated_crc = Crc8.calculate(bytes(data))
|
||||
if received_crc != calculated_crc:
|
||||
raise ValueError(f"CRC mismatch: {received_crc:02x} != {calculated_crc:02x}")
|
||||
|
||||
return bytes(output[:-1]) # Remove CRC
|
||||
raise ValueError("Incomplete COBS packet — no end frame received")
|
||||
|
||||
+156
-48
@@ -21,13 +21,24 @@ RV_LINK_CYPHER = 612643285 # MyRvLinkBleGatewayScanResult.RvLinkKeySeedCypher
|
||||
|
||||
|
||||
def _tea_encrypt(cypher: int, seed: int) -> int:
|
||||
"""Modified TEA used by Lippert OneControl for BLE auth."""
|
||||
"""Modified TEA used by Lippert OneControl for BLE auth.
|
||||
C# uint arithmetic truncates to 32 bits at each step — every intermediate
|
||||
shift/add must be masked independently, not just the final result."""
|
||||
M = 0xFFFFFFFF
|
||||
DELTA = 2654435769 # 0x9E3779B9
|
||||
num = DELTA
|
||||
for _ in range(32):
|
||||
seed = (seed + (((cypher << 4) + 1131376761) ^ (cypher + num) ^ ((cypher >> 5) + 1919510376))) & 0xFFFFFFFF
|
||||
cypher = (cypher + (((seed << 4) + 1948272964) ^ (seed + num) ^ ((seed >> 5) + 1400073827))) & 0xFFFFFFFF
|
||||
num = (num + DELTA) & 0xFFFFFFFF
|
||||
t = (((cypher << 4) & M) + 1131376761) & M
|
||||
t ^= (cypher + num) & M
|
||||
t ^= ((cypher >> 5) + 1919510376) & M
|
||||
seed = (seed + t) & M
|
||||
|
||||
t = (((seed << 4) & M) + 1948272964) & M
|
||||
t ^= (seed + num) & M
|
||||
t ^= ((seed >> 5) + 1400073827) & M
|
||||
cypher = (cypher + t) & M
|
||||
|
||||
num = (num + DELTA) & M
|
||||
return seed
|
||||
|
||||
|
||||
@@ -54,20 +65,26 @@ async def perform_auth(client: BleakClient) -> bool:
|
||||
await asyncio.sleep(5)
|
||||
continue
|
||||
|
||||
seed = struct.unpack_from("<I", seed_bytes, 0)[0]
|
||||
seed = struct.unpack_from(">I", seed_bytes, 0)[0] # big-endian: Endian.Big=0
|
||||
if seed == 0:
|
||||
print("Auth: seed is zero, retrying...")
|
||||
await asyncio.sleep(5)
|
||||
continue
|
||||
|
||||
key = _tea_encrypt(RV_LINK_CYPHER, seed)
|
||||
key_bytes = struct.pack("<I", key)
|
||||
key_bytes = struct.pack(">I", key) # big-endian: Endian.Big=0
|
||||
print(f"Auth: seed=0x{seed:08x} → key=0x{key:08x}")
|
||||
|
||||
try:
|
||||
await client.write_gatt_char(KEY_CHAR, key_bytes)
|
||||
await client.write_gatt_char(KEY_CHAR, key_bytes, response=False)
|
||||
await asyncio.sleep(0.5)
|
||||
print("Auth: key written, handshake complete")
|
||||
# Verify: 0012 should now return b"unlocked"
|
||||
verify = await client.read_gatt_char(SEED_CHAR)
|
||||
print(f"Auth: verify read = {verify!r} ({verify.hex()})")
|
||||
if verify.lower() == b"unlocked":
|
||||
print("Auth: confirmed unlocked!")
|
||||
else:
|
||||
print("Auth: key written but 'unlocked' not confirmed — may still work")
|
||||
return True
|
||||
except Exception as e:
|
||||
print(f"Auth: failed to write key (attempt {attempt+1}): {e}")
|
||||
@@ -113,13 +130,17 @@ class OneControlClient:
|
||||
|
||||
async def connect(self):
|
||||
"""Connect to OneControl device and perform key-seed auth handshake."""
|
||||
self.client = BleakClient(self.address)
|
||||
self.client = BleakClient(self.address, disconnected_callback=self._on_disconnect)
|
||||
await self.client.connect(timeout=20.0)
|
||||
if not await perform_auth(self.client):
|
||||
await self.client.disconnect()
|
||||
raise RuntimeError("Auth handshake failed")
|
||||
await asyncio.sleep(1.0) # Give panel a moment after auth before commands
|
||||
await self.client.start_notify(self.READ_CHAR, self._notification_handler)
|
||||
|
||||
def _on_disconnect(self, _client: BleakClient):
|
||||
print("[!] Device disconnected unexpectedly")
|
||||
|
||||
async def disconnect(self):
|
||||
"""Disconnect from device"""
|
||||
if self.client and self.client.is_connected:
|
||||
@@ -129,55 +150,151 @@ class OneControlClient:
|
||||
"""Handle notifications from device"""
|
||||
try:
|
||||
decoded = self.decoder.decode(data)
|
||||
# print(f"Received raw: {decoded.hex()}")
|
||||
|
||||
# Response Structure: [Event(1)] [Seq(2)] [RespType(1)] [Payload...]
|
||||
if len(decoded) < 4:
|
||||
return
|
||||
|
||||
event_type = decoded[0]
|
||||
seq = struct.unpack("<H", decoded[1:3])[0]
|
||||
seq = struct.unpack(">H", decoded[1:3])[0]
|
||||
resp_type = decoded[3]
|
||||
payload = decoded[4:]
|
||||
|
||||
# resp_type: 1=SuccessMultiple, 129=SuccessCompleted, 2=FailureMultiple, 130=FailureCompleted
|
||||
completed = resp_type >= 128
|
||||
|
||||
# 2 = DeviceCommand response
|
||||
if event_type == 2:
|
||||
cmd_type = self._pending_commands.get(seq)
|
||||
if cmd_type:
|
||||
if cmd_type == CommandType.GET_DEVICES:
|
||||
self._parse_get_devices_response(payload)
|
||||
if completed and len(payload) == 5:
|
||||
# Completion packet: [CRC32 (4 bytes BE)][DeviceCount (1)]
|
||||
crc = struct.unpack_from(">I", payload, 0)[0]
|
||||
count = payload[4]
|
||||
print(f"GetDevices complete: {count} devices, table CRC=0x{crc:08x}")
|
||||
else:
|
||||
self._parse_get_devices_response(payload)
|
||||
elif cmd_type == CommandType.ACTION_SWITCH:
|
||||
print(f"Switch Command Response (Seq {seq}): {payload.hex()}")
|
||||
print(f"Switch Response (Seq {seq}) resp=0x{resp_type:02x}: {payload.hex()}")
|
||||
else:
|
||||
print(f"Response (Seq {seq}, Cmd {cmd_type}): {payload.hex()}")
|
||||
print(f"Response (Seq {seq}, Cmd {cmd_type}) resp=0x{resp_type:02x}: {payload.hex()}")
|
||||
|
||||
# 0x81 (129) = SuccessCompleted, 0x82 (130) = FailureCompleted
|
||||
if resp_type >= 128:
|
||||
if completed:
|
||||
self._pending_commands.pop(seq, None)
|
||||
else:
|
||||
print(f"Received Response for unknown Seq {seq}: {payload.hex()}")
|
||||
print(f"Response for unknown Seq {seq} resp=0x{resp_type:02x}: {payload.hex()}")
|
||||
else:
|
||||
print(f"Received Event {event_type}: {decoded.hex()}")
|
||||
self._handle_status_event(event_type, decoded)
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error decoding: {e}")
|
||||
|
||||
DEVICE_NAMES = {
|
||||
4: "water pump",
|
||||
5: "gas water heater",
|
||||
6: "exterior lights",
|
||||
7: "interior lights",
|
||||
8: "grey tank 2",
|
||||
9: "grey tank 1",
|
||||
10: "black tank",
|
||||
11: "fresh water tank",
|
||||
}
|
||||
|
||||
_QUIET_EVENTS = {1, 3, 4, 26, 32} # noisy bookkeeping events suppressed from output
|
||||
|
||||
_EVENT_NAMES = {
|
||||
5: "RelayLatchingType1", 8: "DimmableLightStatus",
|
||||
9: "RgbLightStatus", 11: "HvacStatus",
|
||||
13: "HBridgeType1", 14: "HBridgeType2",
|
||||
}
|
||||
|
||||
def _handle_status_event(self, event_type: int, decoded: bytes):
|
||||
"""Decode and print unsolicited status broadcasts."""
|
||||
if event_type == 7 and len(decoded) >= 6:
|
||||
# RvStatus: battery voltage + optional external temp
|
||||
v_raw = struct.unpack_from(">H", decoded, 1)[0]
|
||||
t_raw = struct.unpack_from(">H", decoded, 3)[0]
|
||||
features = decoded[5]
|
||||
if features & 1 and v_raw != 0xFFFF:
|
||||
voltage = v_raw / 256.0
|
||||
print(f"[Battery] {voltage:.2f}V", end="")
|
||||
else:
|
||||
print(f"[Battery] N/A", end="")
|
||||
if features & 2 and t_raw != 0x7FFF:
|
||||
temp_c = struct.unpack_from(">h", decoded, 3)[0] / 256.0
|
||||
print(f" [Ext Temp] {temp_c:.1f}°C / {temp_c*9/5+32:.1f}°F", end="")
|
||||
print()
|
||||
|
||||
elif event_type == 12:
|
||||
# TankSensorStatus: [event][table][devId][pct] repeated
|
||||
i = 2
|
||||
while i + 1 < len(decoded):
|
||||
dev_id = decoded[i]
|
||||
pct = decoded[i + 1]
|
||||
name = self.DEVICE_NAMES.get(dev_id, f"tank DevID={dev_id}")
|
||||
print(f"[Tank] {name}: {pct}%")
|
||||
i += 2
|
||||
|
||||
elif event_type == 6:
|
||||
# RelayBasicLatchingStatusType2: [event][table] then 7 bytes per device
|
||||
# [devId][state_byte][5 more bytes]
|
||||
i = 2
|
||||
while i + 1 < len(decoded):
|
||||
dev_id = decoded[i]
|
||||
state_byte = decoded[i + 1]
|
||||
on = bool(state_byte & 0x01)
|
||||
name = self.DEVICE_NAMES.get(dev_id, f"DevID={dev_id}")
|
||||
print(f"[Switch] {name}: {'ON' if on else 'OFF'}")
|
||||
i += 7
|
||||
|
||||
else:
|
||||
if event_type not in self._QUIET_EVENTS:
|
||||
name = self._EVENT_NAMES.get(event_type, f"Event{event_type}")
|
||||
print(f"[{name}] {decoded.hex()}")
|
||||
|
||||
def _parse_get_devices_response(self, payload: bytes):
|
||||
"""Parse GetDevices response payload and print each device entry"""
|
||||
"""Parse GetDevices intermediate response payload.
|
||||
|
||||
ExtendedData layout (payload = bytes 4+ of decoded packet):
|
||||
[TableId (1)][StartingDeviceId (1)][DeviceCount (1)][device entries...]
|
||||
|
||||
Each device entry: [Protocol (1)][PayloadSize (1)][PayloadSize bytes]
|
||||
Protocol 1 (IdsCan): PayloadSize=10
|
||||
[DeviceType (1)][DeviceInstance (1)][ProductId (2 BE)][MAC (4)]
|
||||
Protocol 2 (Host): varies
|
||||
"""
|
||||
if not payload:
|
||||
print("GetDevices: empty payload")
|
||||
return
|
||||
# Raw hex first — useful for cross-referencing against PROTOCOL_FINDINGS.md
|
||||
print(f"GetDevices raw payload: {payload.hex()}")
|
||||
# Each device entry is 4 bytes: [DeviceID, DeviceType, TableID, Status]
|
||||
# Structure inferred from protocol docs — verify against real hardware
|
||||
entry_size = 4
|
||||
for i in range(0, len(payload) - (entry_size - 1), entry_size):
|
||||
device_id = payload[i]
|
||||
device_type = payload[i + 1]
|
||||
table_id = payload[i + 2]
|
||||
status = payload[i + 3]
|
||||
print(f" Device ID={device_id} Type=0x{device_type:02x} Table={table_id} Status=0x{status:02x}")
|
||||
if len(payload) < 3:
|
||||
return
|
||||
table_id = payload[0]
|
||||
start_id = payload[1]
|
||||
dev_count = payload[2]
|
||||
print(f" TableId={table_id} StartId={start_id} DeviceCount={dev_count}")
|
||||
|
||||
PROTOCOL_NAMES = {0: "None", 1: "IdsCan", 2: "Host"}
|
||||
i = 3
|
||||
entry_num = start_id
|
||||
while i + 1 < len(payload):
|
||||
protocol = payload[i]
|
||||
payload_size = payload[i + 1]
|
||||
entry_data = payload[i + 2 : i + 2 + payload_size]
|
||||
proto_name = PROTOCOL_NAMES.get(protocol, f"Proto{protocol}")
|
||||
|
||||
if protocol == 1 and payload_size >= 10: # IdsCan
|
||||
dev_type = entry_data[0]
|
||||
dev_instance = entry_data[1]
|
||||
product_id = struct.unpack_from(">H", entry_data, 2)[0]
|
||||
mac = entry_data[4:8].hex(":")
|
||||
print(f" [{entry_num}] {proto_name} DevType=0x{dev_type:02x} Instance={dev_instance} ProductId=0x{product_id:04x} MAC={mac}")
|
||||
else:
|
||||
print(f" [{entry_num}] {proto_name} data={entry_data.hex()}")
|
||||
|
||||
i += 2 + payload_size
|
||||
entry_num += 1
|
||||
|
||||
def _next_seq(self) -> int:
|
||||
"""Get next sequence number"""
|
||||
@@ -192,11 +309,13 @@ class OneControlClient:
|
||||
seq = self._next_seq()
|
||||
self._pending_commands[seq] = cmd_type
|
||||
|
||||
packet = struct.pack("<HBB", seq, cmd_type, table_id) + payload
|
||||
packet = struct.pack(">HBB", seq, cmd_type, table_id) + payload
|
||||
encoded = self.encoder.encode(packet)
|
||||
|
||||
await self.client.write_gatt_char(self.WRITE_CHAR, encoded)
|
||||
print(f"Sent (Seq {seq}): {packet.hex()}")
|
||||
# Write-without-response (Command) — panel rejects write-with-response
|
||||
# with ATT 0x0E. See client/onecontrol_client.py for details.
|
||||
await self.client.write_gatt_char(self.WRITE_CHAR, encoded, response=False)
|
||||
print(f"Sent (Seq {seq}): raw={packet.hex()} encoded={encoded.hex()}")
|
||||
|
||||
async def get_devices(self, start_id: int = 0, max_count: int = 255):
|
||||
"""Get list of devices (Command 1)"""
|
||||
@@ -252,20 +371,7 @@ async def scan_for_onecontrol():
|
||||
|
||||
|
||||
async def main():
|
||||
found = await scan_for_onecontrol()
|
||||
|
||||
if len(found) == 1:
|
||||
address = found[0].address
|
||||
print(f"Auto-connecting to {found[0].name} ({address})")
|
||||
elif len(found) > 1:
|
||||
print("Multiple OneControl devices found — set ADDRESS manually:")
|
||||
for d in found:
|
||||
print(f" {d.name} ({d.address})")
|
||||
return
|
||||
else:
|
||||
ADDRESS = "30:C6:F7:E0:80:8E"
|
||||
address = ADDRESS
|
||||
print(f"No device found via scan, trying known address {address}")
|
||||
address = "30:C6:F7:E0:80:8E"
|
||||
|
||||
client = OneControlClient(address)
|
||||
|
||||
@@ -274,8 +380,10 @@ async def main():
|
||||
await client.connect()
|
||||
print("Connected! Requesting device list...")
|
||||
|
||||
await client.get_devices()
|
||||
await asyncio.sleep(5) # Wait for all response packets
|
||||
# Panel has ~30s idle timeout — send a periodic ping to stay connected
|
||||
while True:
|
||||
await asyncio.sleep(20)
|
||||
await client.get_devices()
|
||||
|
||||
finally:
|
||||
await client.disconnect()
|
||||
|
||||
Reference in New Issue
Block a user