#!/usr/bin/env python3 """Windows ZLG CAN/CAN FD gateway for CAN_DEV's trusted command grammar. This is a platform adapter for the Windows ``zlgcan.dll`` installation. Its command whitelist, frame IDs, bit encodings, repeat intervals, feedback IDs, and stop-on-exit behavior are ported from CAN_DEV's ``native/canfd/can_read_trans.cpp``. It deliberately exposes no raw-frame API. """ from __future__ import annotations import argparse import ctypes import hashlib import hmac import json import math import os import re import threading import time from dataclasses import dataclass, field from http import HTTPStatus from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple from urllib.parse import urlparse ZCAN_TYPE_CANFD = 1 ZCAN_STATUS_OK = 1 MAX_BODY = 4096 class GatewayError(RuntimeError): pass class ZcanClassicInit(ctypes.Structure): _fields_ = [("acc_code", ctypes.c_uint32), ("acc_mask", ctypes.c_uint32), ("reserved", ctypes.c_uint32), ("filter", ctypes.c_uint8), ("timing0", ctypes.c_uint8), ("timing1", ctypes.c_uint8), ("mode", ctypes.c_uint8)] class ZcanFdInit(ctypes.Structure): _fields_ = [("acc_code", ctypes.c_uint32), ("acc_mask", ctypes.c_uint32), ("abit_timing", ctypes.c_uint32), ("dbit_timing", ctypes.c_uint32), ("brp", ctypes.c_uint32), ("filter", ctypes.c_uint8), ("mode", ctypes.c_uint8), ("pad", ctypes.c_uint16), ("reserved", ctypes.c_uint32)] class ZcanInitUnion(ctypes.Union): _fields_ = [("can", ZcanClassicInit), ("canfd", ZcanFdInit)] class ZcanChannelInit(ctypes.Structure): _anonymous_ = ("config",) _fields_ = [("can_type", ctypes.c_uint32), ("config", ZcanInitUnion)] class ZcanFrame(ctypes.Structure): _fields_ = [("can_id", ctypes.c_uint32), ("can_dlc", ctypes.c_uint8), ("pad", ctypes.c_uint8), ("reserved0", ctypes.c_uint8), ("reserved1", ctypes.c_uint8), ("data", ctypes.c_uint8 * 8)] class ZcanFdFrame(ctypes.Structure): _fields_ = [("can_id", ctypes.c_uint32), ("length", ctypes.c_uint8), ("flags", ctypes.c_uint8), ("reserved0", ctypes.c_uint8), ("reserved1", ctypes.c_uint8), ("data", ctypes.c_uint8 * 64)] class ZcanTransmitData(ctypes.Structure): _fields_ = [("frame", ZcanFrame), ("transmit_type", ctypes.c_uint32)] class ZcanTransmitFdData(ctypes.Structure): _fields_ = [("frame", ZcanFdFrame), ("transmit_type", ctypes.c_uint32)] class ZcanReceiveData(ctypes.Structure): _fields_ = [("frame", ZcanFrame), ("timestamp", ctypes.c_uint64)] class ZcanReceiveFdData(ctypes.Structure): _fields_ = [("frame", ZcanFdFrame), ("timestamp", ctypes.c_uint64)] class ZcanChannelErrorInfo(ctypes.Structure): _fields_ = [("error_code", ctypes.c_uint32), ("passive_error_data", ctypes.c_uint8 * 3), ("arbitration_lost_error_data", ctypes.c_uint8)] def get_bits(data: bytes, start: int, width: int) -> int: value = 0 for bit in range(width): source = start + bit if (data[source // 8] >> (source % 8)) & 1: value |= 1 << bit return value def set_bits(payload: bytearray, start: int, width: int, value: int) -> None: if width <= 0 or start + width > len(payload) * 8 or value < 0 or value >= 1 << width: raise GatewayError("CAN signal value is out of range") for bit in range(width): target = start + bit mask = 1 << (target % 8) if (value >> bit) & 1: payload[target // 8] |= mask else: payload[target // 8] &= ~mask @dataclass(frozen=True) class FrameStep: arbitration_id: int data: bytes fd: bool repeat: int = 1 interval_ms: int = 0 label: str = "" @dataclass class CompiledCommand: command: str domain: str steps: List[FrameStep] expected_ids: Tuple[int, ...] = () timeout_ms: int = 1500 matcher: Optional[Callable[[Dict[int, dict]], bool]] = None final_steps: List[FrameStep] = field(default_factory=list) WINDOW_BITS = {"front-left": 48, "rear-left": 56, "front-right": 51, "rear-right": 59} WINDOW_INDEX = {"front-left": 0, "rear-left": 1, "front-right": 2, "rear-right": 3} WINDOW_SCOPES = { "all": tuple(WINDOW_BITS), "front": ("front-left", "front-right"), "rear": ("rear-left", "rear-right"), **{name: (name,) for name in WINDOW_BITS}, } OUTLET_AXES = { "driver-left": (0x02, 24, 8), "driver-right": (0x02, 32, 16), "passenger-left": (0x03, 24, 8), "passenger-right": (0x03, 32, 16), } OUTLET_FEEDBACK_AXES = { 0x01: ("driver-left", "left-right"), 0x02: ("driver-left", "up-down"), 0x03: ("driver-right", "left-right"), 0x04: ("driver-right", "up-down"), 0x05: ("passenger-left", "left-right"), 0x06: ("passenger-left", "up-down"), 0x07: ("passenger-right", "left-right"), 0x08: ("passenger-right", "up-down"), } OUTLET_MODE_BITS = { "person": (8, 10), "avoid": (12, 14), "sweep-up-down": (16, 20), "sweep-left-right": (18, 22), "free": (24, 26), "close": (28, 30), } def _window_payload(names: Sequence[str], motion: int) -> bytes: payload = bytearray(8) for name in names: set_bits(payload, WINDOW_BITS[name], 3, motion) return bytes(payload) def _repeat_step(identifier: int, data: bytes, *, fd: bool, repeat: int = 3, interval_ms: int = 100, label: str = "") -> FrameStep: return FrameStep(identifier, data, fd, repeat, interval_ms, label) def _decode_state(identifier: int, data: bytes) -> dict: state: dict = {"frame_id": f"0x{identifier:03X}", "data_hex": data.hex(" ").upper()} if len(data) < 8: return state if identifier == 0x407: state.update({"domain": "door", "front_left": get_bits(data, 0, 2), "front_right": get_bits(data, 2, 2), "rear_left": get_bits(data, 4, 2), "rear_right": get_bits(data, 6, 2), "logical": get_bits(data, 10, 2)}) elif identifier == 0x388: state.update({"domain": "window", "positions": [value if value <= 100 else None for value in data[2:6]], "closed": [get_bits(data, 48 + index * 2, 2) for index in range(4)]}) elif identifier == 0x404: state.update({"domain": "climate", "power": get_bits(data, 8, 2), "control": get_bits(data, 10, 2), "mode": get_bits(data, 16, 4), "fan": get_bits(data, 20, 4), "driver_temp": data[4], "passenger_temp": data[5], "rear_temp": data[6]}) elif identifier == 0x4FA: state.update({"domain": "seat", "vent": get_bits(data, 0, 3), "heat": get_bits(data, 3, 3), "massage_mode": get_bits(data, 40, 4), "massage_strength": get_bits(data, 44, 4)}) elif identifier == 0x494: state.update({"domain": "seat_position", "initialized": [get_bits(data, bit, 1) for bit in (58, 59, 60, 61)]}) elif identifier == 0x42E: state.update({"domain": "light", "front_brightness": get_bits(data, 0, 4), "rear_brightness": get_bits(data, 4, 4), "front_color": get_bits(data, 8, 7), "rear_color": get_bits(data, 15, 7), "ambient": get_bits(data, 32, 3), "indoor": get_bits(data, 37, 2)}) elif identifier == 0x41A: position = data[1] state.update({"domain": "shade", "position": position if position <= 100 else None, "initialized": get_bits(data, 18, 2), "closed": get_bits(data, 22, 2), "action": get_bits(data, 27, 3), "location": get_bits(data, 44, 4), "thermal_protection": get_bits(data, 49, 1)}) elif identifier == 0x342: raw = get_bits(data, 24, 4) state.update({"domain": "vehicle_gear", "gear_raw": raw, "gear": {1: "P", 2: "R", 3: "N", 4: "D"}.get(raw, "invalid")}) elif identifier == 0x4EB and data[0] == 0x07: raw = get_bits(data, 8, 12) state.update({"domain": "vehicle_speed", "speed_raw": raw, "speed_kmh": None if raw == 0xFFF else round(raw * 0.06875, 3)}) elif identifier == 0x2F5 and data[0] in OUTLET_FEEDBACK_AXES: outlet, axis = OUTLET_FEEDBACK_AXES[data[0]] position = get_bits(data, 32, 16) response_error = get_bits(data, 8, 1) overheat = get_bits(data, 10, 2) electrical_fault = get_bits(data, 12, 2) blocked = get_bits(data, 20, 2) state.update({ "domain": "outlet", "outlet": outlet, "axis": axis, "position": None if position == 0x7FFF else position, "speed_state": get_bits(data, 28, 4), "stop_mode": get_bits(data, 62, 2), "fault": bool(response_error or overheat or electrical_fault or blocked), "fault_detail": { "response_error": response_error, "overheat": overheat, "electrical": electrical_fault, "blocked": blocked, }, }) return state class ZlgDriver: def __init__(self, args: argparse.Namespace): self.dll = ctypes.WinDLL(args.dll) self._declare() self.device = self.dll.ZCAN_OpenDevice(args.device_type, args.device_index, 0) if not self.device: raise GatewayError("ZCAN_OpenDevice failed; connect USBCANFD-200U and close ZCANPRO") self.channel = None self.args = args self.lock = threading.Lock() self.condition = threading.Condition(self.lock) self.latest: Dict[int, dict] = {} self.sequence = 0 self.rx_count = 0 self.tx_count = 0 self.stop_event = threading.Event() try: prefix = str(args.channel) if self.dll.ZCAN_SetValue(self.device, (prefix + "/canfd_abit_baud_rate").encode(), str(args.bitrate).encode()) != 1: raise GatewayError("ZCAN_SetValue(canfd_abit_baud_rate) failed") if self.dll.ZCAN_SetValue(self.device, (prefix + "/canfd_dbit_baud_rate").encode(), str(args.data_bitrate).encode()) != 1: raise GatewayError("ZCAN_SetValue(canfd_dbit_baud_rate) failed") init = ZcanChannelInit() init.can_type = ZCAN_TYPE_CANFD init.canfd.acc_code = 0 init.canfd.acc_mask = 0xFFFFFFFF init.canfd.filter = 0 init.canfd.mode = 0 self.channel = self.dll.ZCAN_InitCAN(self.device, args.channel, ctypes.byref(init)) if not self.channel or self.dll.ZCAN_StartCAN(self.channel) != 1: raise GatewayError("ZCAN CAN FD channel initialization failed") self.dll.ZCAN_ClearBuffer(self.channel) self.receiver = threading.Thread(target=self._receive_loop, name="zlg-canfd-rx", daemon=True) self.receiver.start() except Exception: self.close() raise def _declare(self) -> None: handle = ctypes.c_void_p declarations = { "ZCAN_OpenDevice": ([ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32], handle), "ZCAN_CloseDevice": ([handle], ctypes.c_uint32), "ZCAN_SetValue": ([handle, ctypes.c_char_p, ctypes.c_char_p], ctypes.c_uint32), "ZCAN_InitCAN": ([handle, ctypes.c_uint32, ctypes.POINTER(ZcanChannelInit)], handle), "ZCAN_StartCAN": ([handle], ctypes.c_uint32), "ZCAN_ResetCAN": ([handle], ctypes.c_uint32), "ZCAN_ClearBuffer": ([handle], ctypes.c_uint32), "ZCAN_Transmit": ([handle, ctypes.POINTER(ZcanTransmitData), ctypes.c_uint32], ctypes.c_uint32), "ZCAN_Receive": ([handle, ctypes.POINTER(ZcanReceiveData), ctypes.c_uint32, ctypes.c_int32], ctypes.c_uint32), "ZCAN_TransmitFD": ([handle, ctypes.POINTER(ZcanTransmitFdData), ctypes.c_uint32], ctypes.c_uint32), "ZCAN_ReceiveFD": ([handle, ctypes.POINTER(ZcanReceiveFdData), ctypes.c_uint32, ctypes.c_int32], ctypes.c_uint32), "ZCAN_ReadChannelErrInfo": ([handle, ctypes.POINTER(ZcanChannelErrorInfo)], ctypes.c_uint32), } for name, (arguments, result) in declarations.items(): if not hasattr(self.dll, name): raise GatewayError("zlgcan.dll missing required export: " + name) function = getattr(self.dll, name) function.argtypes, function.restype = arguments, result def _receive_loop(self) -> None: classic = (ZcanReceiveData * 100)() canfd = (ZcanReceiveFdData * 100)() while not self.stop_event.is_set(): received = False try: classic_count = int(self.dll.ZCAN_Receive(self.channel, classic, 100, 0)) for index in range(classic_count): frame = classic[index].frame self._record(int(frame.can_id & 0x1FFFFFFF), bytes(frame.data[:frame.can_dlc]), False, int(classic[index].timestamp)) received = True fd_count = int(self.dll.ZCAN_ReceiveFD(self.channel, canfd, 100, 0)) for index in range(fd_count): frame = canfd[index].frame self._record(int(frame.can_id & 0x1FFFFFFF), bytes(frame.data[:frame.length]), True, int(canfd[index].timestamp)) received = True except Exception: self.stop_event.set() break if not received: time.sleep(0.002) def _record(self, identifier: int, data: bytes, fd: bool, timestamp: int) -> None: decoded = _decode_state(identifier, data) with self.condition: self.sequence += 1 self.rx_count += 1 decoded.update({"sequence": self.sequence, "can_fd": fd, "timestamp_us": timestamp, "observed_at": time.time()}) if identifier == 0x2F5 and decoded.get("domain") == "outlet": previous_axes = dict((self.latest.get(identifier) or {}).get("axes") or {}) axis_key = f"{decoded['outlet']}.{decoded['axis']}" previous_axes[axis_key] = dict(decoded) decoded["axes"] = previous_axes self.latest[identifier] = decoded self.condition.notify_all() def send(self, step: FrameStep) -> list[dict]: sent: list[dict] = [] for index in range(step.repeat): if step.fd: transmit = ZcanTransmitFdData() transmit.frame.can_id = step.arbitration_id transmit.frame.length = len(step.data) transmit.frame.flags = 0x01 # BRS for offset, value in enumerate(step.data): transmit.frame.data[offset] = value count = self.dll.ZCAN_TransmitFD(self.channel, ctypes.byref(transmit), 1) else: transmit = ZcanTransmitData() transmit.frame.can_id = step.arbitration_id transmit.frame.can_dlc = len(step.data) for offset, value in enumerate(step.data): transmit.frame.data[offset] = value count = self.dll.ZCAN_Transmit(self.channel, ctypes.byref(transmit), 1) if count != 1: error = ZcanChannelErrorInfo() detail = "" if self.dll.ZCAN_ReadChannelErrInfo(self.channel, ctypes.byref(error)) == 1: detail = f" channel_error=0x{error.error_code:08X}" raise GatewayError("ZLG adapter did not accept CAN frame;" + detail) self.tx_count += 1 sent.append({"frame_id": f"0x{step.arbitration_id:03X}", "data_hex": step.data.hex(" ").upper(), "can_fd": step.fd, "brs": step.fd, "attempt": index + 1}) if index + 1 < step.repeat and step.interval_ms: time.sleep(step.interval_ms / 1000.0) return sent def snapshot(self) -> dict: with self.lock: states = {f"0x{identifier:03X}": dict(value) for identifier, value in self.latest.items() if value.get("domain")} return {"rx_count": self.rx_count, "tx_count": self.tx_count, "sequence": self.sequence, "states": states, "last_receive_age_ms": min( [round((time.time() - item["observed_at"]) * 1000) for item in self.latest.values()] or [-1])} def wait_feedback(self, plan: CompiledCommand, baseline: int) -> tuple[bool, bool, dict]: deadline = time.monotonic() + plan.timeout_ms / 1000.0 observed = False latest_by_id: Dict[int, dict] = {} with self.condition: while time.monotonic() < deadline: latest_by_id = {identifier: dict(self.latest[identifier]) for identifier in plan.expected_ids if identifier in self.latest and self.latest[identifier]["sequence"] > baseline} observed = bool(latest_by_id) if observed and plan.matcher is None: # Some command families expose only an acknowledgement or # an undecoded status frame. Record that feedback was # observed, but never claim the requested target matched. return True, False, {f"0x{k:03X}": v for k, v in latest_by_id.items()} if observed and plan.matcher(latest_by_id): return True, True, {f"0x{k:03X}": v for k, v in latest_by_id.items()} self.condition.wait(timeout=min(0.1, max(0.0, deadline - time.monotonic()))) return observed, False, {f"0x{k:03X}": v for k, v in latest_by_id.items()} def close(self) -> None: self.stop_event.set() if getattr(self, "receiver", None): self.receiver.join(timeout=1) if getattr(self, "channel", None): self.dll.ZCAN_ResetCAN(self.channel) self.channel = None if getattr(self, "device", None): self.dll.ZCAN_CloseDevice(self.device) self.device = None def _load_calibration(path: Path) -> dict: try: axes = json.loads(path.read_text(encoding="utf-8"))["axes"] except (OSError, KeyError, TypeError, json.JSONDecodeError) as exc: raise GatewayError("air outlet calibration is unavailable") from exc return axes def compile_command(command: str, latest: Dict[int, dict], calibration: dict) -> CompiledCommand: if not command or len(command) > 256 or "\n" in command or "\r" in command: raise GatewayError("invalid command") words = command.lower().split() if not words or words[0] not in {"door", "window", "ac", "outlet", "seat", "light", "shade"}: raise GatewayError("unsupported command family") if words[:2] == ["door", "rear"] and len(words) == 3 and words[2] in {"lock", "unlock"}: payload = bytearray(8); payload[0] = 0x0A; value = 1 if words[2] == "lock" else 2 set_bits(payload, 14, 2, value) matcher = lambda states, value=value: states.get(0x407, {}).get("rear_left") == (2 if value == 1 else 1) and states.get(0x407, {}).get("rear_right") == (2 if value == 1 else 1) return CompiledCommand(command, "door", [_repeat_step(0x32B, bytes(payload), fd=False, repeat=1)], (0x407,), matcher=matcher) if words[0] == "window" and len(words) in {3, 4} and words[1] in WINDOW_SCOPES: names = WINDOW_SCOPES[words[1]] if len(words) == 3 and words[2] in {"open", "close", "stop"}: motion = {"open": 1, "close": 2, "stop": 3}[words[2]] step = _repeat_step(0x431, _window_payload(names, motion), fd=True, label="window") if words[2] == "stop": return CompiledCommand(command, "window", [step]) expected = 2 if words[2] == "open" else 1 indexes = [WINDOW_INDEX[name] for name in names] matcher = lambda states, indexes=indexes, expected=expected: all(states.get(0x388, {}).get("closed", [None] * 4)[index] == expected for index in indexes) return CompiledCommand(command, "window", [step], (0x388,), 8000, matcher) if len(words) == 4 and words[2] == "position" and words[1] in WINDOW_INDEX: try: target = int(words[3]) except ValueError: raise GatewayError("window percentage must be an integer") if not 0 <= target <= 100: raise GatewayError("window percentage is out of range") current_state = latest.get(0x388) or {} index = WINDOW_INDEX[words[1]] positions = current_state.get("positions") or [None] * 4 if positions[index] is None or time.time() - current_state.get("observed_at", 0) > 2.5: raise GatewayError("fresh 0x388 window position is required") if abs(positions[index] - target) <= 3: return CompiledCommand(command, "window", [], (0x388,), 0, lambda states: True) motion = 1 if target > positions[index] else 2 main = _repeat_step(0x431, _window_payload((words[1],), motion), fd=True) stop = _repeat_step(0x431, _window_payload((words[1],), 3), fd=True) matcher = lambda states, index=index, target=target, motion=motion: ( states.get(0x388, {}).get("positions", [None] * 4)[index] is not None and (states[0x388]["positions"][index] >= target - 3 if motion == 1 else states[0x388]["positions"][index] <= target + 3)) return CompiledCommand(command, "window", [main], (0x388,), 8000, matcher, [stop]) if words[0] == "ac": payload = bytearray(8); repeat = 3; matcher = None if len(words) == 2 and words[1] in {"on", "off"}: value = 1 if words[1] == "on" else 2; set_bits(payload, 28, 2, value) matcher = lambda states, value=value: states.get(0x404, {}).get("power") == value elif len(words) == 3 and words[1] == "fan" and words[2].isdigit() and 1 <= int(words[2]) <= 7: value = int(words[2]); set_bits(payload, 4, 4, value) matcher = lambda states, value=value: states.get(0x404, {}).get("fan") == value elif len(words) == 3 and words[1] == "mode" and words[2] in {"face", "face-feet", "feet", "feet-defrost", "defrost", "face-feet-defrost", "face-defrost"}: value = ["", "face", "face-feet", "feet", "feet-defrost", "defrost", "face-feet-defrost", "face-defrost"].index(words[2]); set_bits(payload, 0, 4, value) matcher = lambda states, value=value: states.get(0x404, {}).get("mode") == value elif len(words) == 4 and words[1] == "temp" and words[2] in {"driver", "passenger", "rear"} and words[3].isdigit() and 18 <= int(words[3]) <= 32: value = int(words[3]); offset = {"driver": 4, "passenger": 5, "rear": 6}[words[2]]; payload[offset] = value repeat = 1 if words[2] == "rear" else 3 matcher = lambda states, field=words[2] + "_temp", value=value: states.get(0x404, {}).get(field) == value elif len(words) == 3 and words[1] == "control" and words[2] in {"manual", "auto"}: value = 1 if words[2] == "manual" else 2; set_bits(payload, 16, 2, value) matcher = lambda states, value=value: states.get(0x404, {}).get("control") == value else: raise GatewayError("invalid AC command") return CompiledCommand(command, "climate", [_repeat_step(0x1DE, bytes(payload), fd=False, repeat=repeat)], (0x404,), matcher=matcher) if words[0] == "outlet": if len(words) == 5 and words[1] in OUTLET_AXES and words[2] in {"percent", "position"}: try: horizontal, vertical = int(words[3]), int(words[4]) except ValueError: raise GatewayError("outlet coordinates must be integers") ranges = [calibration.get(words[1] + ".left-right"), calibration.get(words[1] + ".up-down")] if not all(ranges): raise GatewayError("outlet calibration is incomplete") if words[2] == "percent": if not (0 <= horizontal <= 100 and 0 <= vertical <= 100): raise GatewayError("outlet percentage is out of range") horizontal = ranges[0]["minimum"] + ((ranges[0]["maximum"] - ranges[0]["minimum"]) * horizontal + 50) // 100 vertical = ranges[1]["minimum"] + ((ranges[1]["maximum"] - ranges[1]["minimum"]) * vertical + 50) // 100 elif not (ranges[0]["minimum"] <= horizontal <= ranges[0]["maximum"] and ranges[1]["minimum"] <= vertical <= ranges[1]["maximum"]): raise GatewayError("outlet position is outside the calibrated range") sub_id, horizontal_bit, vertical_bit = OUTLET_AXES[words[1]] payload = bytearray([sub_id, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0xFF if sub_id == 2 else 0, 0xFF if sub_id == 2 else 0]) set_bits(payload, horizontal_bit, 8, horizontal + 128); set_bits(payload, vertical_bit, 8, vertical + 128) return CompiledCommand(command, "outlet", [_repeat_step(0x4EF, bytes(payload), fd=True)], (0x2F5, 0x37B), 1500) if len(words) >= 4 and words[1:3] in (["mode", "driver"], ["mode", "passenger"]): side = 0 if words[2] == "driver" else 1 if len(words) == 4 and words[3] in {"open", "close"}: signal, raw = "close", 2 if words[3] == "open" else 1 elif len(words) == 5 and words[3] in {"person", "avoid", "free"} and words[4] in {"on", "off"}: signal, raw = words[3], 1 if words[4] == "on" else 2 elif len(words) == 6 and words[3] == "sweep" and words[4] in {"up-down", "left-right"} and words[5] in {"start", "stop"}: signal, raw = "sweep-" + words[4], 1 if words[5] == "start" else 2 else: raise GatewayError("invalid outlet mode command") payload = bytearray(8); payload[0] = 0x04; set_bits(payload, OUTLET_MODE_BITS[signal][side], 2, raw) return CompiledCommand(command, "outlet", [_repeat_step(0x4EF, bytes(payload), fd=True, repeat=1)], (0x4BB, 0x4F1, 0x37B), 1500) if words[:2] == ["seat", "driver"]: if len(words) == 4 and words[2] in {"vent", "heat"} and words[3] in {"off", "low", "high"}: control = {"high": 1, "low": 2, "off": 3}[words[3]]; payload = bytearray(8) payload[1] = control << 4 if words[2] == "heat" else control expected = {1: 3, 2: 2, 3: 1}[control]; field = words[2] matcher = lambda states, field=field, expected=expected: states.get(0x4FA, {}).get(field) == expected return CompiledCommand(command, "seat", [_repeat_step(0x431, bytes(payload), fd=True)], (0x4FA,), matcher=matcher) if len(words) in {4, 5} and words[2] in {"horizontal", "height", "backrest", "basin"}: axis_bits = {"horizontal": 8, "height": 10, "backrest": 12, "basin": 14} allowed = {"horizontal": ("forward", "backward"), "backrest": ("forward", "backward"), "height": ("up", "down"), "basin": ("up", "down")} payload = bytearray(8); payload[0] = 0x05 stop_payload = bytes(payload) if words[3] == "stop" and len(words) == 4: return CompiledCommand(command, "seat", [_repeat_step(0x4C1, stop_payload, fd=True)]) if words[3] not in allowed[words[2]]: raise GatewayError("invalid seat direction") duration = int(words[4]) if len(words) == 5 and words[4].isdigit() else 500 if not 100 <= duration <= 2000: raise GatewayError("seat duration must be 100..2000 ms") direction = 1 if words[3] in {"forward", "up"} else 2 set_bits(payload, axis_bits[words[2]], 2, direction) main = _repeat_step(0x4C1, bytes(payload), fd=True, repeat=math.ceil(duration / 100)) stop = _repeat_step(0x4C1, stop_payload, fd=True) return CompiledCommand(command, "seat", [main], (0x494,), 1500, None, [stop]) if len(words) == 4 and words[2:4] == ["massage", "off"]: payload = bytes([0x12, 0, 0, 1, 0, 0, 0, 0]) matcher = lambda states: states.get(0x4FA, {}).get("massage_mode") == 1 return CompiledCommand(command, "seat", [_repeat_step(0x4C1, payload, fd=True)], (0x4FA,), matcher=matcher) if len(words) == 5 and words[2:4] == ["massage", "strength"] and words[4] in {"weak", "medium", "strong"}: value = {"weak": 1, "medium": 2, "strong": 3}[words[4]]; payload = bytes([0x12, value, 0, 0, 0, 0, 0, 0]) matcher = lambda states, value=value: states.get(0x4FA, {}).get("massage_strength") == value + 8 return CompiledCommand(command, "seat", [_repeat_step(0x4C1, payload, fd=True)], (0x4FA,), matcher=matcher) if len(words) == 5 and words[2:4] == ["massage", "mode"] and words[4] in {"wave", "pulse", "stretch", "slack", "relax"}: value = {"wave": 2, "pulse": 3, "stretch": 4, "slack": 5, "relax": 6}[words[4]]; payload = bytes([0x12, 0, 0, value, 0, 0, 0, 0]) matcher = lambda states, value=value: states.get(0x4FA, {}).get("massage_mode") == value return CompiledCommand(command, "seat", [_repeat_step(0x4C1, payload, fd=True)], (0x4FA,), matcher=matcher) if words[0] == "light": if (len(words) == 3 and words[1] == "indoor" and words[2] in {"on", "off"}) or (len(words) == 4 and words[1:3] == ["reading", "all"] and words[3] in {"on", "off"}): on = words[-1] == "on"; payload = bytearray([0, 0, 3, 0xFF, 0xFF, 0, 0, 0]); set_bits(payload, 50, 2, 2 if on else 1) matcher = lambda states, expected=2 if on else 1: states.get(0x42E, {}).get("indoor") == expected return CompiledCommand(command, "light", [_repeat_step(0x4F5, bytes(payload), fd=True)], (0x42E,), matcher=matcher) if len(words) == 3 and words[1] == "ambient" and words[2] in {"on", "off"}: on = words[2] == "on"; payload = bytes([0, 0x36 if on else 0x31, 0, 0x75, 0, 0x80, 0, 0]) matcher = lambda states, on=on: ((2 <= states.get(0x42E, {}).get("front_brightness", 0) <= 6 and 2 <= states.get(0x42E, {}).get("rear_brightness", 0) <= 6) if on else (states.get(0x42E, {}).get("front_brightness") == 1 and states.get(0x42E, {}).get("rear_brightness") == 1)) return CompiledCommand(command, "light", [_repeat_step(0x3FC, payload, fd=True)], (0x42E,), matcher=matcher) if len(words) == 4 and words[1:3] == ["ambient", "brightness"] and words[3].isdigit() and 1 <= int(words[3]) <= 5: level = int(words[3]); payload = bytes([0, 0x30 | (level + 1), 0, 0x75, 0, 0, 0, 0]) matcher = lambda states, raw=level + 1: states.get(0x42E, {}).get("front_brightness") == raw and states.get(0x42E, {}).get("rear_brightness") == raw return CompiledCommand(command, "light", [_repeat_step(0x3FC, payload, fd=True)], (0x42E,), matcher=matcher) if len(words) == 4 and words[1:3] == ["ambient", "color"] and words[3].isdigit() and 1 <= int(words[3]) <= 127: color = int(words[3]); payload = bytes([color, 0x30, 0, 0x75, 0, 0, 0, 0]) matcher = lambda states, color=color: states.get(0x42E, {}).get("front_color") == color and states.get(0x42E, {}).get("rear_color") == color return CompiledCommand(command, "light", [_repeat_step(0x3FC, payload, fd=True)], (0x42E,), matcher=matcher) if words[0] == "shade": motion_name = None if len(words) == 2 and words[1] in {"open", "close", "half", "stop"}: motion_name = words[1] elif len(words) == 3 and words[1] == "position" and words[2] in {"0", "50", "100"}: motion_name = {"0": "close", "50": "half", "100": "open"}[words[2]] if motion_name: motion = {"open": 1, "close": 2, "half": 3, "stop": 4}[motion_name] payload = bytearray(8); set_bits(payload, 4, 4, motion) if motion_name == "stop": return CompiledCommand(command, "shade", [_repeat_step(0x431, bytes(payload), fd=False, repeat=1)]) target = {"open": 100, "close": 0, "half": 50}[motion_name] matcher = lambda states, target=target: states.get(0x41A, {}).get("position") is not None and (states[0x41A]["position"] >= 98 if target == 100 else states[0x41A]["position"] <= 2 if target == 0 else 47 <= states[0x41A]["position"] <= 53) return CompiledCommand(command, "shade", [_repeat_step(0x431, bytes(payload), fd=False, repeat=1)], (0x41A,), 15000, matcher) raise GatewayError("command syntax or value is outside the trusted CAN_DEV whitelist") class GatewayService: def __init__(self, driver: ZlgDriver, *, control: bool, token: str, calibration: dict): self.driver, self.control, self.token, self.calibration = driver, control, token, calibration self.command_lock = threading.Lock() def runtime(self) -> dict: snapshot = self.driver.snapshot() return {"service": "cognitive-agent-native-can-windows", "running": not self.driver.stop_event.is_set(), "mode": "control" if self.control else "monitor_only", "control_token_configured": bool(self.token), "adapter": {"model": "USBCANFD-200U", "device_type": self.driver.args.device_type, "device_index": self.driver.args.device_index, "channel": self.driver.args.channel, "arbitration_bitrate": self.driver.args.bitrate, "data_bitrate": self.driver.args.data_bitrate, "termination_changed": False}, **snapshot} def validate(self, command: str) -> dict: compile_command(command, self.driver.latest, self.calibration) return {"valid": True, "command": command, "transmitted": False, "validator": "CAN_DEV can_read_trans whitelist / Windows ZLG adapter"} def execute(self, command: str, token: str) -> dict: if not self.control: raise PermissionError("CAN gateway is in monitor-only mode") if not self.token or not hmac.compare_digest(token, self.token): raise PermissionError("CAN approval token is missing or invalid") with self.command_lock: plan = compile_command(command, self.driver.latest, self.calibration) baseline = self.driver.sequence frames: list = [] try: for step in plan.steps: frames.extend(self.driver.send(step)) observed, matched, feedback = self.driver.wait_feedback(plan, baseline) if plan.expected_ids and plan.timeout_ms else (False, False, {}) finally: for step in plan.final_steps: frames.extend(self.driver.send(step)) return {"accepted": True, "command": command, "message": "CAN 命令已提交并收到目标状态反馈（不等同于实体机构确认）。" if matched else "CAN 命令已由适配器提交；尚未确认目标状态。", "execution": {"domain": plan.domain, "sdk_submitted": True, "feedback_observed": observed, "feedback_matched": matched, "target_state_confirmed": matched, "physical_state_confirmed": False, "frames_sent": frames, "feedback": feedback}} SERVICE: Optional[GatewayService] = None class Handler(BaseHTTPRequestHandler): server_version = "CognitiveAgentZlgGateway/1.0" def do_GET(self) -> None: # noqa: N802 path = urlparse(self.path).path if path == "/api/can/health": self._json({"status": "ok", "service": "cognitive-agent-native-can-windows"}) elif path in {"/api/can/runtime", "/api/can/status"}: self._json(SERVICE.runtime()) else: self._json({"error": "not_found"}, HTTPStatus.NOT_FOUND) def do_POST(self) -> None: # noqa: N802 path = urlparse(self.path).path try: length = int(self.headers.get("Content-Length", "0")) if not 0 < length <= MAX_BODY: raise GatewayError("invalid request size") command = self.rfile.read(length).decode("utf-8").strip() if path == "/api/can/validate": self._json(SERVICE.validate(command)) elif path == "/api/can/command": self._json(SERVICE.execute(command, self.headers.get("X-CAN-Approval-Token", ""))) else: self._json({"error": "not_found"}, HTTPStatus.NOT_FOUND) except PermissionError as exc: self._json({"error": "hardware_safety_gate", "message": str(exc)}, HTTPStatus.FORBIDDEN) except (GatewayError, UnicodeDecodeError, ValueError) as exc: self._json({"valid": False, "error": "invalid_command", "message": str(exc)}, HTTPStatus.BAD_REQUEST) except Exception as exc: self._json({"error": "gateway_failure", "message": str(exc)}, HTTPStatus.SERVICE_UNAVAILABLE) def log_message(self, message: str, *args: Any) -> None: print("[HTTP] " + message % args, flush=True) def _json(self, payload: dict, status: HTTPStatus = HTTPStatus.OK) -> None: body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") self.send_response(status); self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))); self.send_header("Cache-Control", "no-store") self.end_headers(); self.wfile.write(body) def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Windows ZLG CAN_DEV native gateway") parser.add_argument("--dll", default=r"C:\Program Files (x86)\ZCANPRO\zlgcan.dll") parser.add_argument("--device-type", type=int, default=41); parser.add_argument("--device-index", type=int, default=0) parser.add_argument("--channel", type=int, choices=(0, 1), default=0); parser.add_argument("--bitrate", type=int, default=500000) parser.add_argument("--data-bitrate", type=int, default=2000000); parser.add_argument("--host", default="127.0.0.1") parser.add_argument("--port", type=int, default=8765); parser.add_argument("--control", action="store_true") parser.add_argument("--calibration", default=str(Path(__file__).with_name("air_outlet_calibration.json"))) return parser.parse_args() def main() -> int: global SERVICE args = parse_args(); token = os.environ.get("COGNITIVE_AGENT_NATIVE_CAN_APPROVAL_TOKEN", "").strip() if args.control and len(token) < 6: raise SystemExit("--control requires COGNITIVE_AGENT_NATIVE_CAN_APPROVAL_TOKEN with at least 6 characters") calibration = _load_calibration(Path(args.calibration)); driver = ZlgDriver(args) SERVICE = GatewayService(driver, control=args.control, token=token, calibration=calibration) server = ThreadingHTTPServer((args.host, args.port), Handler) print(f"Windows ZLG native CAN gateway: http://{args.host}:{args.port} ({'control' if args.control else 'monitor-only'})", flush=True) try: server.serve_forever() except KeyboardInterrupt: pass finally: server.server_close(); driver.close() return 0 if __name__ == "__main__": raise SystemExit(main())