498 lines
21 KiB
Python
498 lines
21 KiB
Python
#!/usr/bin/env python3
|
||
"""ecat_client.py — EtherCAT native 客户端（端口探测 / 裸 socket HTTP / ESF1 快发）。
|
||
|
||
从 esp32_server.py 外提（R8）。本模块只做「怎么跟 ecat_native 说话」：
|
||
|
||
- 路径归一化（R9：桥与代理共用 normalize_ecat_api_path）
|
||
- 端口探测（8090..8095 漂移）与裸 socket HTTP/1.0 客户端
|
||
- ESF1 二进制快发打包/解包 + 持久 TCP
|
||
- 代理重发策略（R1/P0：非幂等不重发、先复用健康实例由 proc 负责）
|
||
|
||
双路径说明（R10）——两条入口，同一 ecat_client：
|
||
|
||
- 浏览器 = HTTP 代理：
|
||
页面 fetch POST /ecat/api/* → esp32_server.Handler.do_POST
|
||
→ ecat_client.ecat_proxy → _ecat_post
|
||
- 桌面 APP = GuiApi 桥：
|
||
JS window.pywebview.api.ecat_api → esp32_server._GuiApi.ecat_api
|
||
→ ecat_client.api_call → ecat_proxy → _ecat_post
|
||
|
||
两者最终都走本模块的 normalize_ecat_api_path + _ecat_post/_ecat_proxy。
|
||
不删桥的理由：桌面桥少一跳 HTTP（GUI 进程直连 native）；浏览器没有
|
||
pywebview.api，只能走同源代理。外部 API 语义不变。
|
||
|
||
进程治理（autostart / kill / RealTime / 跨进程锁）在 ecat_proc.py。
|
||
本模块通过 set_autostart_hook 接收回调，避免 ecat_client ↔ ecat_proc
|
||
循环 import。BASE_DIR 只在 esp32_server 定义一次并传给 ecat_proc.init。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import socket
|
||
import struct
|
||
import threading
|
||
|
||
# ── EtherCAT 后端反向代理常量 ──────────────────────────────────────────
|
||
# 电机页的 EtherCAT 传输要打 tools/ecat 的 ecat_native.exe 的 /api/motor/*,
|
||
# 但那个服务**只绑 127.0.0.1 且完全没有 CORS**。本服务做同源转发。
|
||
# 端口自动探测: EtherCAT 服务(含 native)会在 8090..8095 间漂移。
|
||
ECAT_PROXY_PREFIX = "/ecat/api/"
|
||
ECAT_PORTS = (8090, 8091, 8092, 8093, 8094, 8095)
|
||
g_ecat_port = None # 记住上次探到的端口, 避免每次请求都从 8090 试起
|
||
|
||
# ── PDO 快发（ESF1）── tools/ecat ecat_native 的二进制直通 ──────────
|
||
# 布局与 docs/compose/spec/pdo-fast-send.md 一致。**仅** native 专用 TCP 口
|
||
# (health.fast_send_port)；2026-09-23 堵死慢发：已删除 HTTP/JSON 回落。
|
||
# 持久连接：连接阶段不设 timeout（Windows 非阻塞 connect 会撞
|
||
# ~10ms 调度粒度，见 _ecat_post 注释）；连上后再 settimeout。
|
||
ESF_MAGIC = 0x31465345
|
||
FSOK_MAGIC = 0x4B4F5346
|
||
ESF_FRAME_W = 72
|
||
g_fast_send_port = 0 # 从 native health 发现的快发 TCP 口；0=未知/不可用
|
||
g_fast_sock = None
|
||
g_fast_sock_lock = threading.Lock()
|
||
|
||
# ── R1/P0: 代理重发策略 ────────────────────────────────────────────────
|
||
# 连接失败后 autostart 再打一次同一 POST，对写路径 = 可能二次执行。
|
||
# 仅对明确只读/可安全重试的路由允许 autostart 后自动重发一次。
|
||
_ECAT_IDEMPOTENT_TAILS = frozenset({
|
||
"status", "native/health", "app/load", "motor/state", "motor/rx",
|
||
"motor/version", "motor/dbg", "load",
|
||
})
|
||
|
||
# ecat_proc.init 注入的进程拉起回调: () -> (port|None, log_lines)
|
||
_autostart_hook = None
|
||
|
||
|
||
def set_autostart_hook(fn):
|
||
"""由 ecat_proc.init 调用：注入 autostart，避免循环 import。"""
|
||
global _autostart_hook
|
||
_autostart_hook = fn
|
||
|
||
|
||
def _autostart():
|
||
if _autostart_hook is None:
|
||
return None, ["EtherCAT 进程管理未初始化（ecat_proc.init 未调用）"]
|
||
return _autostart_hook()
|
||
|
||
|
||
# ── R9: 桥与代理共用的路径归一化 ──────────────────────────────────────
|
||
def normalize_ecat_api_path(path):
|
||
"""任意形态 ECAT API 路径 → (proxy_path, native_target)。
|
||
|
||
输入可为：
|
||
"motor/send" | "api/motor/send" | "/api/motor/send"
|
||
| "/ecat/api/motor/send" | "ecat/api/motor/send"
|
||
返回：
|
||
proxy_path = "/ecat/api/<tail>" # 浏览器 HTTP 代理路径
|
||
native_target = "/api/<tail>" # 直连 native 的路径
|
||
|
||
_GuiApi.ecat_api（桌面桥）与 _ecat_proxy（浏览器代理）共用本函数，
|
||
删除两边各自实现的剥前缀逻辑（R9）。
|
||
"""
|
||
p = str(path or "").strip()
|
||
p = p.split("?", 1)[0]
|
||
while p.startswith("/"):
|
||
p = p[1:]
|
||
if p.startswith("ecat/api/"):
|
||
p = p[len("ecat/"):] # → api/<tail>
|
||
elif p.startswith("ecat/"):
|
||
p = p[len("ecat/"):]
|
||
if p.startswith("api/"):
|
||
tail = p[len("api/"):]
|
||
else:
|
||
tail = p
|
||
proxy_path = ECAT_PROXY_PREFIX + tail
|
||
native_target = "/api/" + tail
|
||
return proxy_path, native_target
|
||
|
||
|
||
# ── 端口探测 ──────────────────────────────────────────────────────────
|
||
def _port_taken(port):
|
||
"""Windows 的 SO_REUSEADDR 允许同端口重复 bind(实测会双监听、连接随机落),
|
||
故先用一次真实连接探测占用, 不能只靠 bind 是否抛错。"""
|
||
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
|
||
s.settimeout(0.3)
|
||
return s.connect_ex(("127.0.0.1", port)) == 0
|
||
|
||
|
||
def _ecat_find_port():
|
||
"""返回正在监听的 ecat 服务端口, 没有则 None。"""
|
||
ports = ([g_ecat_port] if g_ecat_port else []) + \
|
||
[p for p in ECAT_PORTS if p != g_ecat_port]
|
||
for p in ports:
|
||
if _port_taken(p):
|
||
return p
|
||
return None
|
||
|
||
|
||
# ── ESF1 打包/解包 ────────────────────────────────────────────────────
|
||
def _hex_to_bytes64(data) -> bytes:
|
||
"""帧 data → 64 字节（短则右侧补 0）。"""
|
||
if data is None:
|
||
return b"\x00" * 64
|
||
if isinstance(data, (bytes, bytearray)):
|
||
b = bytes(data)[:64]
|
||
return b + b"\x00" * (64 - len(b))
|
||
s = str(data).strip().replace(" ", "")
|
||
if s.lower().startswith("0x"):
|
||
s = s[2:]
|
||
if len(s) % 2:
|
||
s = "0" + s
|
||
b = bytes.fromhex(s)[:64] if s else b""
|
||
return b + b"\x00" * (64 - len(b))
|
||
|
||
|
||
def pack_esf(frames) -> bytes:
|
||
"""frames=[{ch,id,dlc,data(hex)}] → ESF1 请求体。"""
|
||
items = list(frames or [])
|
||
n = len(items)
|
||
if n < 1 or n > 64:
|
||
raise ValueError(f"frames 数量必须 1..64，收到 {n}")
|
||
out = bytearray(struct.pack("<IBBH", ESF_MAGIC, n, 0, 0))
|
||
for fr in items:
|
||
if not isinstance(fr, dict):
|
||
raise ValueError(f"帧必须是对象，收到 {type(fr).__name__}")
|
||
ch = int(fr.get("ch", 0))
|
||
dlc = int(fr.get("dlc", 0) or 0)
|
||
if ch < 0 or ch > 2:
|
||
raise ValueError(f"通道必须是 0/1/2，收到 {ch}")
|
||
if dlc < 0 or dlc > 64:
|
||
raise ValueError(f"DLC 超出 CANFD 上限 64: {dlc}")
|
||
fid = fr.get("id", 0)
|
||
if isinstance(fid, str):
|
||
fid = int(fid, 0)
|
||
data = _hex_to_bytes64(fr.get("data"))
|
||
out += struct.pack("<BBHI", ch & 0xFF, dlc & 0xFF, 0, int(fid) & 0xFFFFFFFF)
|
||
out += data
|
||
return bytes(out)
|
||
|
||
|
||
def unpack_fsok(resp8: bytes) -> dict:
|
||
if not resp8 or len(resp8) < 8:
|
||
return {"ok": False, "queued": 0, "backlog": 0, "log": ["FSOK 响应过短"]}
|
||
magic, ok, queued, backlog = struct.unpack_from("<IBBH", resp8, 0)
|
||
if magic != FSOK_MAGIC:
|
||
return {"ok": False, "queued": 0, "backlog": 0, "log": ["FSOK magic 不匹配"]}
|
||
return {
|
||
"ok": bool(ok),
|
||
"queued": int(queued),
|
||
"backlog": int(backlog),
|
||
"log": [] if ok else ["native 快发拒绝（未连接/解析失败）"],
|
||
}
|
||
|
||
|
||
def _note_fast_port(obj) -> None:
|
||
global g_fast_send_port
|
||
if isinstance(obj, dict):
|
||
p = obj.get("fast_send_port")
|
||
if isinstance(p, (int, float)) and int(p) > 0:
|
||
g_fast_send_port = int(p)
|
||
|
||
|
||
def _discover_fast_send_port(timeout=2.0, force=False) -> int:
|
||
global g_fast_send_port
|
||
if g_fast_send_port and not force:
|
||
return g_fast_send_port
|
||
try:
|
||
_status, data = _ecat_proxy(ECAT_PROXY_PREFIX + "native/health", b"{}", timeout)
|
||
obj = json.loads(data.decode("utf-8", "replace") or "{}")
|
||
_note_fast_port(obj)
|
||
if force and not isinstance(obj, dict):
|
||
g_fast_send_port = 0
|
||
except Exception:
|
||
if force:
|
||
g_fast_send_port = 0
|
||
return g_fast_send_port
|
||
|
||
|
||
def _close_fast_sock() -> None:
|
||
global g_fast_sock
|
||
with g_fast_sock_lock:
|
||
s = g_fast_sock
|
||
g_fast_sock = None
|
||
if s is not None:
|
||
try:
|
||
s.close()
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _fast_sock_connect(port: int, timeout: float):
|
||
sock = socket.create_connection(("127.0.0.1", int(port)), timeout=None)
|
||
sock.settimeout(timeout)
|
||
try:
|
||
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
|
||
except Exception:
|
||
pass
|
||
return sock
|
||
|
||
|
||
def ecat_send_raw_frames(frames, timeout_ms=2000) -> dict:
|
||
"""ESF1 快发：**仅**持久 TCP → native fast_send_port。
|
||
|
||
2026-09-23 用户要求堵死慢发：删除 HTTP send_raw / JSON motor/send 回落。
|
||
失败即 ok:false，由前端暴露错误；不自动走慢路径。
|
||
持久连接上的 sendall/recv **必须整段持锁**，否则并发请求会把 FSOK
|
||
错配到别的帧。连接失败时清掉缓存端口并重探一次（仍只走 TCP）。
|
||
"""
|
||
global g_fast_sock, g_fast_send_port
|
||
try:
|
||
body = pack_esf(frames)
|
||
except Exception as e:
|
||
return {"ok": False, "queued": 0, "backlog": 0, "path": "none",
|
||
"log": [f"ESF 打包失败: {e}"]}
|
||
timeout = max(0.2, float(timeout_ms or 2000) / 1000.0)
|
||
|
||
def _tcp_once(port: int) -> dict:
|
||
nonlocal body, timeout
|
||
global g_fast_sock
|
||
r = None
|
||
with g_fast_sock_lock:
|
||
if g_fast_sock is None:
|
||
g_fast_sock = _fast_sock_connect(port, timeout)
|
||
sock = g_fast_sock
|
||
sock.sendall(body)
|
||
resp = b""
|
||
while len(resp) < 8:
|
||
chunk = sock.recv(8 - len(resp))
|
||
if not chunk:
|
||
raise OSError("快发口连接已关闭")
|
||
resp += chunk
|
||
r = unpack_fsok(resp)
|
||
r["path"] = "fast_tcp"
|
||
return r
|
||
|
||
last_err = None
|
||
for attempt in (0, 1):
|
||
port = _discover_fast_send_port(timeout, force=(attempt == 1))
|
||
if not port:
|
||
last_err = "native 无 fast_send_port（服务未起或版本过旧）"
|
||
break
|
||
try:
|
||
return _tcp_once(port)
|
||
except Exception as e:
|
||
last_err = f"快发口异常: {e}"
|
||
_close_fast_sock()
|
||
g_fast_send_port = 0
|
||
if attempt == 0:
|
||
continue
|
||
return {
|
||
"ok": False,
|
||
"queued": 0,
|
||
"backlog": 0,
|
||
"path": "fast_tcp",
|
||
"log": [last_err or "二进制快发失败（已禁用 HTTP/JSON 回落）"],
|
||
}
|
||
|
||
|
||
# ── 幂等判定 / 连接拒绝判定（P0 保留）────────────────────────────────
|
||
def _ecat_target_idempotent(target: str) -> bool:
|
||
"""/api/<tail> 是否允许 autostart 后自动重发。默认 False（偏安全）。"""
|
||
tail = target[len("/api/"):] if target.startswith("/api/") else target.lstrip("/")
|
||
tail = tail.split("?", 1)[0].strip("/")
|
||
if tail in _ECAT_IDEMPOTENT_TAILS:
|
||
return True
|
||
# 显式只读前缀
|
||
if tail.startswith(("native/", "diag/")) and "stop" not in tail and "kill" not in tail:
|
||
return True
|
||
return False
|
||
|
||
|
||
def _ecat_connect_refused(exc) -> bool:
|
||
"""异常是否属于「根本没连上」（请求未发出，重发安全）。"""
|
||
if isinstance(exc, ConnectionRefusedError):
|
||
return True
|
||
if isinstance(exc, OSError):
|
||
if getattr(exc, "winerror", None) in (10061, 10065):
|
||
return True
|
||
if getattr(exc, "errno", None) in (111, 10061):
|
||
return True
|
||
msg = str(exc).lower()
|
||
return ("refused" in msg) or ("actively refused" in msg)
|
||
|
||
|
||
# ── 裸 socket HTTP 客户端 + 代理 ──────────────────────────────────────
|
||
def _ecat_post(port, path, body, timeout, connect_timeout=None, ctype=None):
|
||
"""向 EtherCAT 后端(native)转发一次 POST, 返回 (status, body_bytes)。
|
||
|
||
**不要改回 urllib/http.client 并给它传 timeout。** 那样每次请求会多花约 10ms:
|
||
给 socket 设 timeout 会让 Python 把它切成非阻塞模式, 而 Windows 上非阻塞
|
||
connect 要靠 select 轮询完成, 于是撞上约 10ms 的系统调度粒度。实测
|
||
(本机回环, /api/motor/state):
|
||
urllib.urlopen(req, timeout=5) p50 11.0 ms
|
||
http.client + timeout p50 10.7 ms
|
||
裸 socket 连接阶段不设 timeout p50 0.58 ms
|
||
后端自己只用 0.58ms, 那 10ms 全是这一层白交的过路费 ——
|
||
电机页 EtherCAT 链路的刷新上限直接被它按在 ~76Hz。
|
||
|
||
所以这里手写最小 HTTP/1.0 客户端: 连接阶段**不设** timeout(本机回环连接
|
||
要么立刻成功要么立刻 ECONNREFUSED, 不会挂住), 连上之后才设读写超时。
|
||
|
||
connect_timeout: 只给冷路径(逐个试漂移端口)用的连接超时。**热路径(缓存
|
||
端口)必须保持 None(阻塞连接)**——本机对死端口无论阻塞还是 settimeout 都
|
||
不是秒拒(阻塞 ~2s, settimeout(0.3) 吃满 0.3s 才回 WOULDBLOCK), 但活端口
|
||
的阻塞 connect 只要 ~0.6ms, 两害相权取其轻。
|
||
"""
|
||
payload = (
|
||
f"POST {path} HTTP/1.0\r\n"
|
||
f"Host: 127.0.0.1:{port}\r\n"
|
||
f"Content-Type: {ctype or 'application/json'}\r\n"
|
||
f"Content-Length: {len(body or b'')}\r\n"
|
||
"Connection: close\r\n"
|
||
"\r\n"
|
||
).encode("ascii") + (body or b"")
|
||
|
||
sock = socket.create_connection(("127.0.0.1", port), timeout=connect_timeout)
|
||
try:
|
||
sock.settimeout(timeout) # 连上之后再设: 只作用于收发, 不影响已完成的 connect
|
||
sock.sendall(payload)
|
||
chunks = []
|
||
while True:
|
||
chunk = sock.recv(65536)
|
||
if not chunk:
|
||
break
|
||
chunks.append(chunk)
|
||
finally:
|
||
sock.close()
|
||
|
||
raw = b"".join(chunks)
|
||
head, _, data = raw.partition(b"\r\n\r\n")
|
||
first = head.split(b"\r\n", 1)[0].split(b" ", 2)
|
||
if len(first) < 2 or not first[1].isdigit():
|
||
raise OSError(f"EtherCAT 后端回了无法解析的响应头: {head[:120]!r}")
|
||
# 404 等业务错误要原样透传: 后端的 404 体里带
|
||
# "服务在改动之后没重启" 的排查提示, 吞掉它会让人白排查半天。
|
||
return int(first[1]), data
|
||
|
||
|
||
def ecat_proxy(path, body, timeout=6.0, ctype=None):
|
||
"""把 /ecat/api/xxx 转发到 EtherCAT 后端的 /api/xxx。
|
||
|
||
返回 (status, body_bytes)。路径归一化与桌面桥共用 normalize_ecat_api_path（R9）。
|
||
端口在 ECAT_PORTS 里探测并缓存到 g_ecat_port:
|
||
EtherCAT 后端会在 8090..8095 之间漂移(端口被占就挪),
|
||
写死 8090 会在它挪了之后表现为"页面点了没反应"。
|
||
|
||
连不上时返回 503 + 与后端同构的 {"ok":false,"log":[...]} 信封,
|
||
这样前端只有一条错误处理路径 —— 它不需要知道中间还隔着一层代理。
|
||
|
||
2026-09-12: 先用 _port_taken 快探，全灭则立刻 autostart；
|
||
不再对 6 个死端口各等 timeout 秒（那样要 30s+ 才会拉起服务）。
|
||
ctype: 可选 Content-Type（ESF1 二进制 body 用 application/octet-stream）。
|
||
|
||
P0/R1: 非幂等请求 autostart 后**不**自动重发，返回 503 由用户/前端显式重试。
|
||
"""
|
||
global g_ecat_port
|
||
# R9: 与 GuiApi 桥共用归一化。"motor/state" | "/api/motor/state"
|
||
# | "/ecat/api/motor/state" → target="/api/motor/state"
|
||
_proxy_path, target = normalize_ecat_api_path(path)
|
||
idem = _ecat_target_idempotent(target)
|
||
# 端口尝试顺序: 先缓存口, 失败再试其余漂移口(带短连接超时), 全灭才拉起。
|
||
# **健康路径上绝不能对死端口做预探测** —— 本机 Windows 对回环死端口的
|
||
# connect 不是秒拒(阻塞 ~2s, settimeout(0.3) 吃满 0.3s 回 WOULDBLOCK),
|
||
# 2026-09-12 实测每请求预探 5 个死端口 = 恒定 1.5s, 电机页"本页请求耗时
|
||
# 1517ms"、刷新被按到 0.66Hz 皆此。缓存口命中的代价只有 ~0.6ms。
|
||
ports = ([g_ecat_port] if g_ecat_port else []) + \
|
||
[p for p in ECAT_PORTS if p != g_ecat_port]
|
||
last = None
|
||
for port in ports:
|
||
try:
|
||
# 缓存口连不上大概率是后端挪了/死了, 阻塞 connect ~2s 可接受;
|
||
# 其余候选口用 0.3s 连接超时, 避免逐口 2s(全灭时 12s+)。
|
||
status, data = _ecat_post(
|
||
port, target, body, timeout,
|
||
connect_timeout=None if port == g_ecat_port else 0.3,
|
||
ctype=ctype)
|
||
g_ecat_port = port
|
||
return status, data
|
||
except Exception as e: # 连不上/超时 → 视情况试下一个端口
|
||
last = e
|
||
if g_ecat_port == port:
|
||
g_ecat_port = None # 缓存端口失效, 下轮重新全量探测
|
||
# P0/R1: 非幂等请求一旦可能已到达旧实例（超时/非连接拒绝），
|
||
# 禁止再打其它端口——否则 flash/motor/send 等会被重复执行。
|
||
if not idem and not _ecat_connect_refused(e):
|
||
break
|
||
|
||
# 无存活端口或全失败 → 单实例拉起；**非幂等路径禁止自动重发**
|
||
start_logs = []
|
||
try:
|
||
port, start_logs = _autostart()
|
||
except Exception as e:
|
||
last = e
|
||
port = None
|
||
start_logs = [f"autostart 异常: {type(e).__name__}: {e}"]
|
||
if port:
|
||
g_ecat_port = port
|
||
if not idem:
|
||
# 源请求可能已在旧实例上执行，或在超时途中被接收。
|
||
# 自动重发会二次写 flash / 重复 motor/start。返回 503，
|
||
# 由前端/用户显式重试（后端已就绪，重试通常一次即成功）。
|
||
msg = (
|
||
f"EtherCAT 服务已自动拉起，但 {target} 为非幂等路径，"
|
||
"已按约定不自动重发，请重试一次"
|
||
)
|
||
body = json.dumps(
|
||
{"ok": False, "log": start_logs + [msg]},
|
||
ensure_ascii=False).encode("utf-8")
|
||
return 503, body
|
||
try:
|
||
status, data = _ecat_post(port, target, body, timeout, ctype=ctype)
|
||
return status, data
|
||
except Exception as e:
|
||
last = e
|
||
|
||
msg = (f"EtherCAT 服务不可用: {type(last).__name__ if last else 'unknown'}")
|
||
body = json.dumps({"ok": False, "log": start_logs + [msg]},
|
||
ensure_ascii=False).encode("utf-8")
|
||
return 503, body
|
||
|
||
|
||
# 原名兼容：server / 脚本 / 测试 patch 点
|
||
_ecat_proxy = ecat_proxy
|
||
|
||
|
||
def _body_to_bytes(body) -> bytes:
|
||
"""桥/代理共用的 body 序列化：dict → JSON，str/bytes 原样。"""
|
||
if body is None:
|
||
return b"{}"
|
||
if isinstance(body, (bytes, bytearray)):
|
||
return bytes(body)
|
||
if isinstance(body, str):
|
||
return body.encode("utf-8")
|
||
try:
|
||
return json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
||
except Exception as e:
|
||
raise ValueError(f"body 序列化失败: {type(e).__name__}: {e}") from e
|
||
|
||
|
||
def api_call(path, body=None, timeout_ms=4000) -> dict:
|
||
"""统一 ECAT API 调用入口（R10）。桌面桥 GuiApi.ecat_api 直接调这里。
|
||
|
||
浏览器路径不经过本函数（HTTP → Handler → ecat_proxy），但两者最终
|
||
共用 normalize_ecat_api_path + ecat_proxy/_ecat_post，无第二套协议栈。
|
||
返回与 native 同构的 dict（ok/log/...）。
|
||
"""
|
||
proxy_path, _target = normalize_ecat_api_path(path)
|
||
try:
|
||
raw = _body_to_bytes(body)
|
||
except ValueError as e:
|
||
return {"ok": False, "log": [f"原生桥 {e}"]}
|
||
timeout = max(0.2, float(timeout_ms or 4000) / 1000.0)
|
||
try:
|
||
status, data = ecat_proxy(proxy_path, raw, timeout)
|
||
except Exception as e:
|
||
return {"ok": False, "log": [f"原生桥异常: {type(e).__name__}: {e}"]}
|
||
try:
|
||
obj = json.loads(data.decode("utf-8", "replace") or "{}")
|
||
except Exception:
|
||
obj = {"ok": False, "log": ["原生桥响应非 JSON"]}
|
||
if not isinstance(obj, dict):
|
||
obj = {"ok": False, "log": ["原生桥响应不是对象"]}
|
||
obj.setdefault("ok", status == 200)
|
||
if status >= 400 and "log" not in obj:
|
||
obj["log"] = [f"HTTP {status}"]
|
||
_note_fast_port(obj)
|
||
return obj
|