vee
1636 lines
72 KiB
Python
1636 lines
72 KiB
Python
"""Seat Controller self-repair application service.
|
||
|
||
The original HIL demo mixed HTTP hosting, business state, firmware tooling and
|
||
ZCANPRO process control in one script. This module keeps the proven state
|
||
machine and diagnostic rules while exposing them through the repository's
|
||
existing server. Every machine-specific path is supplied through environment
|
||
configuration or discovered standard installations; importing the module never
|
||
launches hardware tooling.
|
||
"""
|
||
|
||
from __future__ import unicode_literals
|
||
|
||
import json
|
||
import os
|
||
from pathlib import Path
|
||
import hashlib
|
||
import subprocess
|
||
import threading
|
||
import time
|
||
|
||
from .healing_model import (
|
||
PHASE_FAILED, PHASE_PASSED, SCENARIO_BY_ID, SelfHealingEngine,
|
||
public_scenarios,
|
||
run_self_test as run_healing_self_test,
|
||
)
|
||
from .signal_diagnostic import (
|
||
SignalDiagnosticModel, load_config,
|
||
run_self_test as run_signal_self_test,
|
||
)
|
||
from .zcan_bridge import (
|
||
ZcanBridgeManager, run_self_test as run_bridge_manager_self_test,
|
||
)
|
||
from .can_runtime import StandaloneCanRuntimeManager
|
||
from cognitive_agent.infrastructure.can.gateway import ZlgChannelConfig
|
||
from cognitive_agent.infrastructure.can.hardware import (
|
||
SeatHardwareSettings,
|
||
VehicleCanSettings,
|
||
)
|
||
from cognitive_agent.infrastructure.firmware.t2g_seat import (
|
||
EXPECTED_FIRMWARE_BUILD_ID,
|
||
EXPECTED_FIRMWARE_REVISION,
|
||
)
|
||
|
||
|
||
REPOSITORY_ROOT = Path(__file__).resolve().parents[4]
|
||
|
||
|
||
def _env_path(name, default):
|
||
value = os.getenv(name, "").strip()
|
||
return Path(value).expanduser() if value else Path(default)
|
||
|
||
|
||
def _env_or_installed_path(name, candidates, fallback):
|
||
value = os.getenv(name, "").strip()
|
||
if value:
|
||
return Path(value).expanduser()
|
||
for candidate in candidates:
|
||
path = Path(candidate)
|
||
if path.exists():
|
||
return path
|
||
return Path(fallback)
|
||
|
||
|
||
def _env_flag(name, default=False):
|
||
value = os.getenv(name)
|
||
if value is None:
|
||
return bool(default)
|
||
return value.strip().lower() in {"1", "true", "yes", "on"}
|
||
|
||
|
||
RUNTIME_DIR = _env_path(
|
||
"SELF_REPAIR_RUNTIME_DIR",
|
||
REPOSITORY_ROOT / "artifacts" / "tmp" / "self-repair" / "runtime",
|
||
)
|
||
PENDING_DIR = RUNTIME_DIR / "requests" / "pending"
|
||
STATUS_PATH = _env_path(
|
||
"SELF_REPAIR_BRIDGE_STATUS_PATH", RUNTIME_DIR / "bridge_status.json")
|
||
BRIDGE_SCRIPT_PATH = _env_path(
|
||
"SELF_REPAIR_BRIDGE_SCRIPT_PATH",
|
||
REPOSITORY_ROOT / "tools" / "zcan" / "seat_self_repair_bridge.py",
|
||
)
|
||
EMERGENCY_PATH = RUNTIME_DIR / "emergency_stop.json"
|
||
CONFIG_PATH = _env_path(
|
||
"SELF_REPAIR_DIAGNOSTIC_CONFIG",
|
||
REPOSITORY_ROOT / "config" / "self-repair" / "signal_diagnostic_config.json",
|
||
)
|
||
LOG_ROOT = _env_path(
|
||
"SELF_REPAIR_LOG_DIR",
|
||
REPOSITORY_ROOT / "artifacts" / "self-repair" / "software",
|
||
)
|
||
HARDWARE_LOG_ROOT = _env_path(
|
||
"SELF_REPAIR_HARDWARE_LOG_DIR",
|
||
REPOSITORY_ROOT / "artifacts" / "self-repair" / "hardware",
|
||
)
|
||
PROJECT_DIR = _env_path(
|
||
"SELF_REPAIR_FIRMWARE_ROOT",
|
||
REPOSITORY_ROOT / "firmware" / "t2g" / "Seat_Controller_demo")
|
||
IAR_PROJECT_PATH = PROJECT_DIR / "IAR" / "Seat_Controller_demo.ewp"
|
||
FIRMWARE_OUT_PATH = PROJECT_DIR / "IAR" / "rev_d" / "Exe" / \
|
||
"Seat_Controller_demo.out"
|
||
FIRMWARE_HEX_PATH = PROJECT_DIR / "IAR" / "rev_d" / "Exe" / \
|
||
"Seat_Controller_demo.hex"
|
||
IAR_INSTALL_ROOTS = (
|
||
Path(r"D:\Program Files\IAR Systems\Embedded Workbench 9.2"),
|
||
Path(r"C:\Program Files\IAR Systems\Embedded Workbench 9.2"),
|
||
Path(r"C:\Program Files\IAR Systems\Embedded Workbench 9.4"),
|
||
)
|
||
IAR_BUILD_PATH = _env_or_installed_path(
|
||
"SELF_REPAIR_IAR_BUILD_PATH",
|
||
tuple(root / "common" / "bin" / "iarbuild.exe"
|
||
for root in IAR_INSTALL_ROOTS),
|
||
REPOSITORY_ROOT / "__unconfigured_iar_build__")
|
||
CSPY_BAT_PATH = _env_or_installed_path(
|
||
"SELF_REPAIR_CSPY_BAT_PATH",
|
||
tuple(root / "common" / "bin" / "CSpyBat.exe"
|
||
for root in IAR_INSTALL_ROOTS),
|
||
REPOSITORY_ROOT / "__unconfigured_cspy__")
|
||
CSPY_GENERAL_PATH = _env_path(
|
||
"SELF_REPAIR_CSPY_GENERAL_PATH",
|
||
PROJECT_DIR / "IAR" / "settings" / "Seat_Controller_demo.rev_d.general.xcl",
|
||
)
|
||
CSPY_DRIVER_PATH = _env_path(
|
||
"SELF_REPAIR_CSPY_DRIVER_PATH",
|
||
PROJECT_DIR / "IAR" / "settings" / "Seat_Controller_demo.rev_d.driver.xcl",
|
||
)
|
||
FIRMWARE_LOG_ROOT = _env_path(
|
||
"SELF_REPAIR_FIRMWARE_LOG_DIR",
|
||
REPOSITORY_ROOT / "artifacts" / "self-repair" / "firmware",
|
||
)
|
||
FIRMWARE_SOURCE_ROOTS = tuple(
|
||
PROJECT_DIR / name for name in ("App", "Bsp", "Config", "Driver"))
|
||
FIRMWARE_SOURCE_SUFFIXES = frozenset((".c", ".h", ".s", ".asm"))
|
||
REQUIRED_BRIDGE_VERSION = "2026-08-10-legrest-runtime-v36"
|
||
ZCANPRO_ROOTS = (
|
||
Path(r"C:\Program Files (x86)\ZCANPRO"),
|
||
Path(r"C:\Program Files\ZCANPRO"),
|
||
)
|
||
ZCANPRO_EXE = _env_or_installed_path(
|
||
"SELF_REPAIR_ZCANPRO_EXE",
|
||
tuple(root / "ZCANPRO.exe" for root in ZCANPRO_ROOTS),
|
||
REPOSITORY_ROOT / "__unconfigured_zcanpro__")
|
||
ZCANPRO_SCRIPT_CONFIG = _env_or_installed_path(
|
||
"SELF_REPAIR_ZCANPRO_SCRIPT_CONFIG",
|
||
tuple(root / "config" / "extend_script.ini" for root in ZCANPRO_ROOTS),
|
||
REPOSITORY_ROOT / "__unconfigured_zcanpro_script_config__")
|
||
CAN_RUNTIME_BACKEND = os.getenv(
|
||
"COGNITIVE_AGENT_CAN_RUNTIME_BACKEND", "standalone-zlg"
|
||
).strip().lower()
|
||
|
||
|
||
def _build_bridge_manager():
|
||
auto_start = _env_flag("SELF_REPAIR_AUTO_START_BRIDGE", False)
|
||
if CAN_RUNTIME_BACKEND == "zcanpro":
|
||
return ZcanBridgeManager(
|
||
STATUS_PATH, BRIDGE_SCRIPT_PATH,
|
||
required_version=REQUIRED_BRIDGE_VERSION,
|
||
zcanpro_exe=ZCANPRO_EXE,
|
||
script_config_path=ZCANPRO_SCRIPT_CONFIG,
|
||
auto_start=auto_start,
|
||
)
|
||
if CAN_RUNTIME_BACKEND != "standalone-zlg":
|
||
raise ValueError(
|
||
"COGNITIVE_AGENT_CAN_RUNTIME_BACKEND must be standalone-zlg or zcanpro"
|
||
)
|
||
|
||
seat = SeatHardwareSettings.from_env(REPOSITORY_ROOT)
|
||
vehicle = VehicleCanSettings.from_env(REPOSITORY_ROOT)
|
||
seat_channel = int(seat.channel, 0)
|
||
channels = [
|
||
ZlgChannelConfig(
|
||
channel=seat_channel,
|
||
frame_format="classic_can",
|
||
arbitration_bitrate=seat.bitrate,
|
||
data_bitrate=vehicle.data_bitrate,
|
||
can_fd_iso=True,
|
||
termination_enabled=seat.termination_enabled,
|
||
)
|
||
]
|
||
if vehicle.enabled:
|
||
if vehicle.channel == seat_channel:
|
||
raise ValueError("seat CH0 and vehicle CH1 must use different channels")
|
||
if (
|
||
vehicle.device_type != seat.device_type
|
||
or vehicle.device_index != seat.device_index
|
||
or vehicle.zlg_python != seat.zlg_python
|
||
or vehicle.zlg_dll != seat.zlg_dll
|
||
):
|
||
raise ValueError(
|
||
"seat and vehicle channels must share one configured ZLG device runtime"
|
||
)
|
||
channels.append(vehicle.channel_config())
|
||
return StandaloneCanRuntimeManager(
|
||
STATUS_PATH,
|
||
BRIDGE_SCRIPT_PATH,
|
||
required_version=REQUIRED_BRIDGE_VERSION,
|
||
python_executable=seat.zlg_python,
|
||
zlg_bridge_script=seat.bridge_script,
|
||
dll_path=seat.zlg_dll,
|
||
device_type=seat.device_type,
|
||
device_index=seat.device_index,
|
||
channels=channels,
|
||
seat_channel=seat_channel,
|
||
firmware_programmer=(
|
||
seat._programmer() if seat.auto_flash_enabled else None
|
||
),
|
||
firmware_auto_flash=seat.auto_flash_enabled,
|
||
expected_firmware_revision=EXPECTED_FIRMWARE_REVISION,
|
||
expected_firmware_build_id=EXPECTED_FIRMWARE_BUILD_ID,
|
||
position_sync_enabled=seat.position_sync_enabled,
|
||
firmware_boot_wait_s=seat.firmware_boot_wait_ms / 1000.0,
|
||
auto_start=auto_start,
|
||
)
|
||
|
||
|
||
BRIDGE_MANAGER = _build_bridge_manager()
|
||
|
||
|
||
def _read_json(path):
|
||
try:
|
||
with path.open("r", encoding="utf-8") as stream:
|
||
return json.load(stream)
|
||
except (OSError, ValueError, TypeError):
|
||
return None
|
||
|
||
|
||
def _atomic_json(path, value):
|
||
path.parent.mkdir(parents=True, exist_ok=True)
|
||
temporary = path.with_name(
|
||
"%s.%s.%s.%s.tmp" %
|
||
(path.name, os.getpid(), threading.get_ident(), time.time_ns()))
|
||
try:
|
||
with temporary.open("w", encoding="utf-8") as stream:
|
||
json.dump(value, stream, ensure_ascii=False, indent=2,
|
||
sort_keys=True)
|
||
stream.flush()
|
||
os.fsync(stream.fileno())
|
||
for attempt in range(8):
|
||
try:
|
||
os.replace(str(temporary), str(path))
|
||
return
|
||
except PermissionError:
|
||
if attempt >= 7:
|
||
raise
|
||
# Windows may briefly deny replacement while the ZCAN bridge
|
||
# or an HTTP polling thread is closing the previous file.
|
||
time.sleep(0.01 * (attempt + 1))
|
||
finally:
|
||
try:
|
||
temporary.unlink()
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
class ConsoleState(object):
|
||
def __init__(self, bridge_manager):
|
||
self.lock = threading.RLock()
|
||
self.bridge_manager = bridge_manager
|
||
self.engine = SelfHealingEngine()
|
||
self.signal_model = SignalDiagnosticModel(load_config(CONFIG_PATH))
|
||
self.latest_report_path = None
|
||
self.batch = self._new_batch_state()
|
||
self.batch_thread = None
|
||
self.hardware_active = False
|
||
self.hardware_run_id = None
|
||
self.hardware_started_epoch = None
|
||
self.hardware_events = []
|
||
self.hardware_signatures = {}
|
||
self.hardware_result = self.signal_model.analyze(None)
|
||
self.hardware_report_path = None
|
||
self.hardware_self_test = None
|
||
self.hardware_request_id = None
|
||
self.hardware_prepare = {
|
||
"state": "IDLE",
|
||
"detail": "等待启动；诊断前将自动检查并按需烧录Seat_Controller_demo固件",
|
||
"automatic_flash": False,
|
||
"reason_code": None,
|
||
}
|
||
self.bench_request_id = None
|
||
self.bench_reset = {
|
||
"phase": "IDLE", "request_id": None,
|
||
"started_epoch": None, "finished_epoch": None,
|
||
"summary": "实物用例启动前须点击重置并完成四轴归零",
|
||
"details": None, "axes": [], "zero_count": 0,
|
||
"all_zero": False,
|
||
}
|
||
self.firmware_operation = {
|
||
"state": "IDLE", "message": "尚未执行固件烧录",
|
||
"hex_path": str(FIRMWARE_HEX_PATH), "probe_checked_epoch": 0.0,
|
||
}
|
||
self.cspy_process = None
|
||
|
||
@staticmethod
|
||
def _run_hidden(command, timeout_s):
|
||
creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
|
||
return subprocess.run(
|
||
[str(item) for item in command], cwd=str(PROJECT_DIR),
|
||
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
||
text=True, encoding="utf-8", errors="replace",
|
||
timeout=timeout_s, creationflags=creationflags, check=False)
|
||
|
||
@classmethod
|
||
def _programmer_status(cls):
|
||
script = (
|
||
"$items=Get-PnpDevice -PresentOnly -ErrorAction SilentlyContinue | "
|
||
"Where-Object {$_.FriendlyName -match "
|
||
"'CMSIS-DAP|DAPLink|fireDAP|KitProg|MiniProg|J-Link' "
|
||
"-or $_.InstanceId -match "
|
||
"'CMSIS|CYPRESS|INFINEON|SEGGER|VID_1FC9&PID_5601'}; "
|
||
"$items | ForEach-Object {"
|
||
"$bus=(Get-PnpDeviceProperty -InstanceId $_.InstanceId "
|
||
"-KeyName DEVPKEY_Device_BusReportedDeviceDesc "
|
||
"-ErrorAction SilentlyContinue).Data; "
|
||
"$name=if($bus){$bus}else{$_.FriendlyName}; "
|
||
"if($name -match "
|
||
"'CMSIS-DAP|DAPLink|fireDAP CMSIS-DAP|KitProg|MiniProg|J-Link'){"
|
||
"$_.Status + '|' + $name + '|' + $_.InstanceId}}")
|
||
try:
|
||
result = cls._run_hidden(
|
||
["powershell", "-NoProfile", "-Command", script], 10)
|
||
devices = [line.strip() for line in result.stdout.splitlines()
|
||
if line.strip()]
|
||
except (OSError, subprocess.SubprocessError):
|
||
devices = []
|
||
return {"detected": bool(devices), "devices": devices,
|
||
"required": "CMSIS-DAP"}
|
||
|
||
def _firmware_snapshot(self):
|
||
now = time.time()
|
||
if now - float(self.firmware_operation.get(
|
||
"probe_checked_epoch", 0.0)) > 5.0:
|
||
self.firmware_operation["programmer"] = \
|
||
self._programmer_status()
|
||
self.firmware_operation["probe_checked_epoch"] = now
|
||
value = dict(self.firmware_operation)
|
||
if FIRMWARE_HEX_PATH.exists():
|
||
value["hex_sha256"] = hashlib.sha256(
|
||
FIRMWARE_HEX_PATH.read_bytes()).hexdigest()
|
||
value["hex_mtime"] = FIRMWARE_HEX_PATH.stat().st_mtime
|
||
return value
|
||
|
||
@staticmethod
|
||
def _classify_firmware_issue(bridge, hex_exists, source_newer,
|
||
probe_detected):
|
||
"""Classify only failures that can reasonably be fixed by flashing.
|
||
|
||
CAN traffic alone proves the adapter and physical pair are alive; it
|
||
does not prove that the connected ECU runs Seat_Controller_demo. A
|
||
live bridge without fresh 0x301~0x305, a missing local image, or local
|
||
firmware sources newer than that image are treated as recoverable
|
||
firmware-qualification problems. A missing bridge is not: flashing
|
||
cannot repair a closed adapter or a stopped CAN runtime.
|
||
"""
|
||
bridge = bridge or {}
|
||
if not bridge.get("online"):
|
||
return {
|
||
"ready": False, "auto_flash": False,
|
||
"reason_code": "BRIDGE_OFFLINE",
|
||
"detail": "CAN Runtime未在线；该问题不能通过烧录修复",
|
||
}
|
||
if not hex_exists:
|
||
reason = "FIRMWARE_IMAGE_MISSING"
|
||
detail = "未找到Seat_Controller_demo固件镜像，需要自动构建并烧录"
|
||
elif source_newer:
|
||
reason = "FIRMWARE_SOURCE_NEWER"
|
||
detail = "检测到固件源码晚于当前镜像，需要自动重新构建并烧录"
|
||
elif not bridge.get("protocol_online"):
|
||
reason = ("CAN_TRAFFIC_PROTOCOL_MISSING" if
|
||
bridge.get("bus_traffic") else
|
||
"SEAT_PROTOCOL_MISSING")
|
||
detail = (
|
||
"CAN链路有流量但缺少0x301~0x305，判定为未烧录/固件不匹配类问题" if
|
||
bridge.get("bus_traffic") else
|
||
"桥接在线但座椅协议无报文，判定为未烧录/固件未运行类问题")
|
||
elif not bridge.get("firmware_revision_ok"):
|
||
reason = "FIRMWARE_REVISION_MISMATCH"
|
||
detail = (
|
||
"Seat_Controller_demo固件revision=%s，期望revision=%s，"
|
||
"需要自动重新构建并烧录" %
|
||
(bridge.get("firmware_revision", "未知"),
|
||
EXPECTED_FIRMWARE_REVISION))
|
||
elif not bridge.get("firmware_build_id_ok"):
|
||
reason = "FIRMWARE_BUILD_MISMATCH"
|
||
detail = (
|
||
"Seat_Controller_demo firmware build=%s, expected build=%s; "
|
||
"the repository image must be restored" %
|
||
(bridge.get("firmware_build_id", "unknown"),
|
||
EXPECTED_FIRMWARE_BUILD_ID))
|
||
else:
|
||
return {
|
||
"ready": True, "auto_flash": False,
|
||
"reason_code": "FIRMWARE_QUALIFIED",
|
||
"detail": "Seat_Controller_demo固件协议在线，无需重复烧录",
|
||
}
|
||
return {
|
||
"ready": False,
|
||
"auto_flash": bool(probe_detected),
|
||
"reason_code": reason,
|
||
"detail": (detail if probe_detected else
|
||
detail + "；未检测到CMSIS-DAP，无法自动烧录"),
|
||
}
|
||
|
||
@staticmethod
|
||
def _firmware_source_newer_than_image():
|
||
if not FIRMWARE_HEX_PATH.is_file():
|
||
return False, None
|
||
image_mtime = FIRMWARE_HEX_PATH.stat().st_mtime
|
||
newest_path = None
|
||
newest_mtime = 0.0
|
||
for root in FIRMWARE_SOURCE_ROOTS:
|
||
if not root.is_dir():
|
||
continue
|
||
for path in root.rglob("*"):
|
||
if (not path.is_file() or
|
||
path.suffix.lower() not in FIRMWARE_SOURCE_SUFFIXES):
|
||
continue
|
||
try:
|
||
modified = path.stat().st_mtime
|
||
except OSError:
|
||
continue
|
||
if modified > newest_mtime:
|
||
newest_path, newest_mtime = path, modified
|
||
return newest_mtime > image_mtime, newest_path
|
||
|
||
def _firmware_qualification(self, status=None, now=None):
|
||
now = time.time() if now is None else float(now)
|
||
status = _read_json(STATUS_PATH) if status is None else status
|
||
bridge = self._bridge_summary(status, now)
|
||
source_newer, newest_source = \
|
||
self._firmware_source_newer_than_image()
|
||
programmer = self._programmer_status()
|
||
value = self._classify_firmware_issue(
|
||
bridge, FIRMWARE_HEX_PATH.is_file(), source_newer,
|
||
programmer.get("detected", False))
|
||
value.update({
|
||
"checked_epoch": now,
|
||
"programmer": programmer,
|
||
"source_newer": source_newer,
|
||
"newest_source": (None if newest_source is None else
|
||
str(newest_source)),
|
||
"hex_path": str(FIRMWARE_HEX_PATH),
|
||
"bridge": bridge,
|
||
})
|
||
return value
|
||
|
||
def _wait_bridge(self, require_protocol=False, timeout_s=10.0):
|
||
deadline = time.time() + float(timeout_s)
|
||
last_status = None
|
||
last_bridge = None
|
||
while time.time() < deadline:
|
||
last_status = _read_json(STATUS_PATH)
|
||
last_bridge = self._bridge_summary(last_status, time.time())
|
||
if (last_bridge.get("online") and
|
||
(not require_protocol or
|
||
(last_bridge.get("protocol_online") and
|
||
last_bridge.get("firmware_revision_ok") and
|
||
last_bridge.get("firmware_build_id_ok")))):
|
||
return last_status, last_bridge
|
||
time.sleep(0.25)
|
||
return last_status, last_bridge or {}
|
||
|
||
def _prepare_firmware_for_hardware_diagnostic(self):
|
||
with self.lock:
|
||
self.hardware_prepare = {
|
||
"state": "CHECKING_FIRMWARE",
|
||
"detail": "正在检查CAN桥接、Seat_Controller_demo协议和固件镜像",
|
||
"automatic_flash": False,
|
||
"reason_code": None,
|
||
"started_epoch": time.time(),
|
||
}
|
||
self.bridge_manager.ensure_async()
|
||
status, bridge = self._wait_bridge(require_protocol=False,
|
||
timeout_s=10.0)
|
||
qualification = self._firmware_qualification(status, time.time())
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"reason_code": qualification.get("reason_code"),
|
||
"detail": qualification.get("detail"),
|
||
"qualification": qualification,
|
||
})
|
||
if qualification.get("ready"):
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "READY",
|
||
"finished_epoch": time.time(),
|
||
})
|
||
return status, bridge
|
||
if not qualification.get("auto_flash"):
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "FAILED",
|
||
"finished_epoch": time.time(),
|
||
})
|
||
raise ValueError(qualification.get("detail"))
|
||
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "AUTO_FLASHING",
|
||
"automatic_flash": True,
|
||
"detail": qualification.get("detail") +
|
||
"；正在自动构建并烧录",
|
||
})
|
||
firmware = self.build_and_flash_firmware(
|
||
confirmed_bench_clear=True, automatic=True,
|
||
trigger_reason=qualification.get("reason_code"))
|
||
status, bridge = self._wait_bridge(require_protocol=True,
|
||
timeout_s=12.0)
|
||
if (not bridge.get("protocol_online") or
|
||
not bridge.get("firmware_revision_ok") or
|
||
not bridge.get("firmware_build_id_ok")):
|
||
detail = ("自动烧录已执行，但仍未收到0x301~0x305；"
|
||
"硬件诊断未启动，请检查ECU供电或烧录日志")
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "FAILED", "detail": detail,
|
||
"firmware": firmware,
|
||
"finished_epoch": time.time(),
|
||
})
|
||
raise ValueError(detail)
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "READY",
|
||
"detail": "自动烧录完成，0x301~0x305已上线，开始21针检测",
|
||
"firmware": firmware,
|
||
"finished_epoch": time.time(),
|
||
})
|
||
return status, bridge
|
||
|
||
@staticmethod
|
||
def _new_batch_state(execution_mode="shadow"):
|
||
return {
|
||
"active": False, "total": len(public_scenarios()),
|
||
"execution_mode": execution_mode,
|
||
"completed": 0, "passed": 0, "failed": 0,
|
||
"current_case_id": None, "started_epoch": None,
|
||
"finished_epoch": None, "results": [],
|
||
}
|
||
|
||
@staticmethod
|
||
def _bridge_summary(status, now):
|
||
heartbeat = None if not isinstance(status, dict) else status.get(
|
||
"heartbeat_epoch")
|
||
age = None
|
||
if heartbeat is not None:
|
||
try:
|
||
age = max(0.0, now - float(heartbeat))
|
||
except (TypeError, ValueError):
|
||
age = None
|
||
version_ok = (isinstance(status, dict) and
|
||
status.get("bridge_version") ==
|
||
REQUIRED_BRIDGE_VERSION)
|
||
online = age is not None and age < 3.0 and version_ok
|
||
system = {} if not isinstance(status, dict) else (
|
||
status.get("system") or {})
|
||
firmware_revision = system.get("firmware_revision")
|
||
firmware_identity = {} if not isinstance(status, dict) else (
|
||
status.get("firmware_identity") or {})
|
||
firmware_build_id = firmware_identity.get("firmware_build_id")
|
||
frame_epochs = {} if not isinstance(status, dict) else (
|
||
status.get("frame_epochs") or {})
|
||
recent_frame_ids = []
|
||
for frame_id, epoch in frame_epochs.items():
|
||
if ":" in str(frame_id):
|
||
continue
|
||
try:
|
||
if max(0.0, now - float(epoch)) <= 1.5:
|
||
recent_frame_ids.append(str(frame_id))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
recent_frame_ids.sort()
|
||
protocol_required = {
|
||
"0x301", "0x302", "0x303", "0x304", "0x305", "0x306", "0x307"
|
||
}
|
||
protocol_online = online and protocol_required.issubset(
|
||
set(recent_frame_ids)
|
||
)
|
||
return {
|
||
"online": online,
|
||
"age_s": None if age is None else round(age, 2),
|
||
"state": "ONLINE" if online else "OFFLINE",
|
||
"bridge_state": None if not isinstance(status, dict) else status.get(
|
||
"bridge_state"),
|
||
"bridge_version": None if not isinstance(status, dict) else status.get(
|
||
"bridge_version"),
|
||
"bridge_version_ok": version_ok,
|
||
"current_request_id": None if not isinstance(status, dict) else status.get(
|
||
"current_request_id"),
|
||
"position_valid_mask": int(system.get("position_valid_mask", 0)),
|
||
"firmware_revision": firmware_revision,
|
||
"expected_firmware_revision": EXPECTED_FIRMWARE_REVISION,
|
||
"firmware_revision_ok":
|
||
firmware_revision == EXPECTED_FIRMWARE_REVISION,
|
||
"firmware_build_id": firmware_build_id,
|
||
"expected_firmware_build_id": EXPECTED_FIRMWARE_BUILD_ID,
|
||
"firmware_build_id_ok": (
|
||
firmware_build_id == EXPECTED_FIRMWARE_BUILD_ID
|
||
and bool(firmware_identity.get("qualified"))
|
||
),
|
||
"active_mask": int(system.get("active_mask", 0)),
|
||
"faulted_mask": int(system.get("faulted_mask", 0)),
|
||
"bus": {} if not isinstance(status, dict) else (
|
||
status.get("bus") or {}),
|
||
"bus_traffic": bool(recent_frame_ids),
|
||
"protocol_online": protocol_online,
|
||
"recent_frame_ids": recent_frame_ids,
|
||
"expected_frame_ids": [
|
||
"0x301", "0x302", "0x303", "0x304", "0x305", "0x306", "0x307"
|
||
],
|
||
"frame_epochs": frame_epochs,
|
||
}
|
||
|
||
@staticmethod
|
||
def _bench_twin_snapshot(status, now):
|
||
"""Convert raw 0x301~0x305 observations into a UI-safe live twin."""
|
||
if not isinstance(status, dict):
|
||
return {"online": False, "source": "NO_BENCH_DATA", "axes": [],
|
||
"thermal": {"fan_running": False, "heater_level": 0}}
|
||
frame_epochs = status.get("frame_epochs") or {}
|
||
system = status.get("system") or {}
|
||
motors = status.get("motors") or []
|
||
diagnostics = status.get("diagnostics") or []
|
||
currents = status.get("currents") or []
|
||
axes = []
|
||
labels = ("水平滑轨", "坐盆升降", "靠背角度", "腿托角度")
|
||
for motor in range(4):
|
||
state = motors[motor] if motor < len(motors) and \
|
||
isinstance(motors[motor], dict) else {}
|
||
diagnostic = diagnostics[motor] if motor < len(diagnostics) and \
|
||
isinstance(diagnostics[motor], dict) else {}
|
||
current = currents[motor] if motor < len(currents) and \
|
||
isinstance(currents[motor], dict) else {}
|
||
raw_position = state.get("position")
|
||
position = raw_position
|
||
hall = diagnostic.get("hall")
|
||
max_hall = diagnostic.get("max_hall")
|
||
# The production protocol deliberately publishes Position=0xFFFF
|
||
# while PositionValid is false. The mechanism still has live
|
||
# Hall feedback, so use Hall/MaxHall for the visual twin instead
|
||
# of making the model jump to 100% during fault stop and homing.
|
||
if (position is None or not state.get("position_valid", False) or
|
||
int(position) > 10000) and hall is not None and max_hall:
|
||
position = int(round(10000.0 * float(hall) /
|
||
float(max_hall)))
|
||
epoch = frame_epochs.get("0x302:M%d" % motor)
|
||
age = None
|
||
try:
|
||
age = max(0.0, now - float(epoch))
|
||
except (TypeError, ValueError):
|
||
pass
|
||
axes.append({
|
||
"motor": motor, "label": labels[motor],
|
||
"position": position,
|
||
"raw_position": raw_position,
|
||
"position_pct": None if position is None else round(
|
||
max(0.0, min(100.0, float(position) / 100.0)), 1),
|
||
"position_valid": bool(state.get("position_valid", False)),
|
||
"active": bool(state.get("active", False)),
|
||
"direction": int(state.get("direction", 0) or 0),
|
||
"hall": diagnostic.get("hall"),
|
||
"max_hall": diagnostic.get("max_hall"),
|
||
"speed_pps_x100": diagnostic.get("speed_pps_x100"),
|
||
"current_raw": current.get("raw"),
|
||
"fault": bool(state.get("stall") or
|
||
state.get("driver_fault") or
|
||
diagnostic.get("fault_flags")),
|
||
"fresh": age is not None and age <= 1.0,
|
||
"age_s": None if age is None else round(age, 2),
|
||
})
|
||
thermal = status.get("thermal_current") or {}
|
||
thermal_feedback = status.get("thermal") or []
|
||
thermal_epoch = frame_epochs.get("0x305")
|
||
try:
|
||
thermal_age = max(0.0, now - float(thermal_epoch))
|
||
except (TypeError, ValueError):
|
||
thermal_age = None
|
||
protocol_epoch = frame_epochs.get("0x301")
|
||
try:
|
||
online = max(0.0, now - float(protocol_epoch)) <= 0.8
|
||
except (TypeError, ValueError):
|
||
online = False
|
||
progress = status.get("self_healing_progress") or {}
|
||
progress_telemetry = progress.get("telemetry") or {}
|
||
return {
|
||
"online": online,
|
||
"source": "REAL_BENCH_CAN_0x301_0x305",
|
||
"generated_epoch": now,
|
||
"axes": axes,
|
||
"system": {
|
||
"active_mask": int(system.get("active_mask", 0) or 0),
|
||
"faulted_mask": int(system.get("faulted_mask", 0) or 0),
|
||
"position_valid_mask": int(
|
||
system.get("position_valid_mask", 0) or 0),
|
||
},
|
||
"thermal": {
|
||
"fan_running": bool(thermal.get("fan_running", False)) and
|
||
thermal_age is not None and thermal_age <= 1.0,
|
||
"heater_level": (int(thermal.get("heater_level", 0) or 0)
|
||
if thermal_age is not None and
|
||
thermal_age <= 1.0 else 0),
|
||
"fan_raw": thermal.get("fan_raw"),
|
||
"heater_raw": thermal.get("heater_raw"),
|
||
"fresh": thermal_age is not None and thermal_age <= 1.0,
|
||
"age_s": (None if thermal_age is None else
|
||
round(thermal_age, 2)),
|
||
"feedback_byte0": (thermal_feedback[0]
|
||
if thermal_feedback else None),
|
||
},
|
||
"task": {
|
||
"stage": progress_telemetry.get("operation_stage"),
|
||
"name": progress_telemetry.get("normal_task"),
|
||
"reaction": progress_telemetry.get("bench_reaction"),
|
||
"target_positions": progress_telemetry.get(
|
||
"task_target_positions"),
|
||
"restored": bool(progress_telemetry.get("task_restored")),
|
||
},
|
||
}
|
||
|
||
def _save_completed_report(self, healing, hardware, bridge):
|
||
if healing["phase"] not in (PHASE_PASSED, PHASE_FAILED):
|
||
return
|
||
if self.engine.report_saved:
|
||
return
|
||
run_id = healing.get("run_id") or "RUN-UNKNOWN"
|
||
report_dir = LOG_ROOT / run_id
|
||
report_path = report_dir / "self_healing_report.json"
|
||
report = {
|
||
"schema": "seat-self-healing-report-v1",
|
||
"generated_epoch": time.time(),
|
||
"healing": healing,
|
||
"bridge": bridge,
|
||
"hardware_diagnosis": hardware,
|
||
}
|
||
_atomic_json(report_path, report)
|
||
if healing["phase"] == PHASE_PASSED:
|
||
_atomic_json(report_dir / "diagnostic_snapshot_success.json", report)
|
||
self.engine.report_saved = True
|
||
self.latest_report_path = report_path
|
||
|
||
def _record_hardware_transitions(self, result, now):
|
||
for group in result.get("groups", []):
|
||
signature = (group.get("state"), group.get("summary"))
|
||
previous = self.hardware_signatures.get(group.get("key"))
|
||
self.hardware_signatures[group.get("key")] = signature
|
||
if previous == signature:
|
||
continue
|
||
self.hardware_events.append({
|
||
"time": time.strftime("%H:%M:%S", time.localtime(now)),
|
||
"epoch": now, "key": group.get("key"),
|
||
"name": group.get("name"), "state": group.get("state"),
|
||
"summary": group.get("summary"),
|
||
"evidence": list(group.get("evidence") or []),
|
||
})
|
||
self.hardware_events = self.hardware_events[-200:]
|
||
|
||
def _save_hardware_report(self, status, now):
|
||
self.hardware_active = False
|
||
if not self.hardware_run_id or self.hardware_report_path is not None:
|
||
return
|
||
active_test = (self.hardware_result or {}).get("active_test") or {}
|
||
test_phase = active_test.get("phase")
|
||
if test_phase in ("PASSED", "FAILED"):
|
||
self.hardware_prepare.update({
|
||
"state": "DIAGNOSTIC_%s" % test_phase,
|
||
"detail": active_test.get("detail") or
|
||
active_test.get("title") or
|
||
"21针主动检测已结束",
|
||
"finished_epoch": now,
|
||
})
|
||
report = {
|
||
"schema": "seat-hardware-diagnostic-report-v1",
|
||
"run_id": self.hardware_run_id,
|
||
"generated_epoch": now,
|
||
"events": list(self.hardware_events),
|
||
"diagnosis": self.hardware_result,
|
||
"startup_rule_check": self.hardware_self_test,
|
||
"active_pin_test": active_test,
|
||
"bridge": self._bridge_summary(status, now),
|
||
}
|
||
path = HARDWARE_LOG_ROOT / self.hardware_run_id / \
|
||
"hardware_diagnostic_report.json"
|
||
_atomic_json(path, report)
|
||
self.hardware_report_path = path
|
||
|
||
def _hardware_snapshot(self, status, now):
|
||
# Keep the read-only link summary current even before a diagnostic
|
||
# session starts. Event recording and report generation remain gated
|
||
# by ``hardware_active``.
|
||
self.hardware_result = self.signal_model.analyze(status, now=now)
|
||
active_test = {} if not isinstance(status, dict) else (
|
||
status.get("hardware_diagnostic") or {})
|
||
if (self.hardware_request_id and
|
||
active_test.get("request_id") == self.hardware_request_id):
|
||
pin_results = active_test.get("pin_results") or {}
|
||
group_pins = {
|
||
"can": ("JC1-1", "JC1-21"),
|
||
"m0": ("JA1-4", "JA1-5", "JC1-9"),
|
||
"m1": ("JB1-6", "JB1-8", "JC1-15"),
|
||
"m2": ("JB1-12", "JB1-15", "JC1-17"),
|
||
"m3": ("JB1-1", "JB1-3", "JC1-12"),
|
||
"fan": ("JA1-13",), "heater": ("JB1-18",),
|
||
"common": ("JA1-1", "JA1-10", "JA1-11",
|
||
"JC1-6", "JC1-18"),
|
||
}
|
||
ranks = {"OK": 0, "UNKNOWN": 1, "IDLE": 1,
|
||
"UNMONITORED": 1, "WARN": 2, "FAULT": 3}
|
||
for group in self.hardware_result.get("groups", []):
|
||
ids = group_pins.get(group.get("key"))
|
||
values = [pin_results.get(pin_id) for pin_id in (ids or ())]
|
||
values = [item for item in values if item]
|
||
if not values:
|
||
continue
|
||
group["state"] = max(
|
||
(item.get("state", "UNKNOWN") for item in values),
|
||
key=lambda state: ranks.get(state, 1))
|
||
group["summary"] = "主动检测：%s" % "；".join(
|
||
"%s %s" % (pin_id,
|
||
(pin_results.get(pin_id) or {}).get(
|
||
"state", "UNKNOWN"))
|
||
for pin_id in ids)
|
||
group["evidence"] = [
|
||
item.get("evidence") for item in values
|
||
if item.get("evidence")]
|
||
for connector, pins in self.hardware_result.get(
|
||
"connectors", {}).items():
|
||
for pin in pins:
|
||
pin_id = "%s-%s" % (connector, pin.get("number"))
|
||
evidence = pin_results.get(pin_id)
|
||
if not evidence:
|
||
continue
|
||
pin["state"] = evidence.get("state", pin.get("state"))
|
||
pin["active_evidence"] = evidence.get("evidence")
|
||
pin["evidence_kind"] = evidence.get("evidence_kind")
|
||
enabled = [pin for pins in self.hardware_result.get(
|
||
"connectors", {}).values() for pin in pins
|
||
if pin.get("enabled", True)]
|
||
pending = ("UNKNOWN", "IDLE", "UNMONITORED")
|
||
self.hardware_result["connector_ok_count"] = sum(
|
||
1 for pin in enabled if pin.get("state") == "OK")
|
||
self.hardware_result["connector_warn_count"] = sum(
|
||
1 for pin in enabled if pin.get("state") == "WARN")
|
||
self.hardware_result["connector_fault_count"] = sum(
|
||
1 for pin in enabled if pin.get("state") == "FAULT")
|
||
self.hardware_result["connector_pending_count"] = sum(
|
||
1 for pin in enabled if pin.get("state") in pending)
|
||
if self.hardware_result["connector_fault_count"]:
|
||
self.hardware_result["overall_state"] = "FAULT"
|
||
elif self.hardware_result["connector_warn_count"]:
|
||
self.hardware_result["overall_state"] = "WARN"
|
||
elif self.hardware_result["connector_pending_count"] == 0:
|
||
self.hardware_result["overall_state"] = "OK"
|
||
self.hardware_result["active_test"] = active_test
|
||
if self.hardware_active:
|
||
self._record_hardware_transitions(self.hardware_result, now)
|
||
if (active_test.get("request_id") == self.hardware_request_id and
|
||
active_test.get("phase") in ("PASSED", "FAILED")):
|
||
self._save_hardware_report(status, now)
|
||
return self.hardware_result
|
||
|
||
def _sync_bench_healing(self, status, now):
|
||
if self.engine.execution_mode != "bench" or not self.bench_request_id:
|
||
return
|
||
progress = {} if not isinstance(status, dict) else (
|
||
status.get("self_healing_progress") or {})
|
||
if progress.get("request_id") != self.bench_request_id:
|
||
return
|
||
self.engine.apply_external(
|
||
progress.get("phase"), telemetry=progress.get("telemetry"),
|
||
diagnosed_code=progress.get("diagnosed_code"),
|
||
title=progress.get("title"), detail=progress.get("detail"),
|
||
now=progress.get("epoch", now))
|
||
|
||
@staticmethod
|
||
def _bench_zero_snapshot(status):
|
||
status = status if isinstance(status, dict) else {}
|
||
motors = status.get("motors") or []
|
||
by_motor = {
|
||
int(value.get("motor", -1)): value for value in motors
|
||
if isinstance(value, dict)
|
||
}
|
||
axes = []
|
||
for motor in range(4):
|
||
value = by_motor.get(motor) or {}
|
||
position = int(value.get("position", -1))
|
||
at_zero = bool(
|
||
value.get("position_valid") and value.get("near") and
|
||
0 <= position <= 100 and not value.get("active"))
|
||
axes.append({
|
||
"motor": motor, "position": position,
|
||
"position_valid": bool(value.get("position_valid")),
|
||
"near": bool(value.get("near")),
|
||
"active": bool(value.get("active")),
|
||
"at_zero": at_zero,
|
||
})
|
||
system = status.get("system") or {}
|
||
all_zero = bool(
|
||
all(axis["at_zero"] for axis in axes) and
|
||
int(system.get("position_valid_mask", 0)) == 0x0F and
|
||
int(system.get("active_mask", 0)) == 0 and
|
||
int(system.get("faulted_mask", 0)) == 0)
|
||
return {
|
||
"axes": axes,
|
||
"zero_count": sum(1 for axis in axes if axis["at_zero"]),
|
||
"all_zero": all_zero,
|
||
}
|
||
|
||
def _sync_bench_reset(self, status, now):
|
||
zero = self._bench_zero_snapshot(status)
|
||
self.bench_reset.update(zero)
|
||
request_id = self.bench_reset.get("request_id")
|
||
if not request_id or self.bench_reset.get("phase") not in (
|
||
"QUEUED", "HOMING"):
|
||
return
|
||
current_request_id = None if not isinstance(status, dict) else \
|
||
status.get("current_request_id")
|
||
if current_request_id == request_id:
|
||
self.bench_reset["phase"] = "HOMING"
|
||
self.bench_reset["summary"] = \
|
||
"四轴依次归零中，当前%d/4轴已在零位" % zero["zero_count"]
|
||
return
|
||
last_result = {} if not isinstance(status, dict) else \
|
||
(status.get("last_result") or {})
|
||
if last_result.get("request_id") != request_id:
|
||
if now - float(self.bench_reset.get("started_epoch") or now) > 600.0:
|
||
self.bench_reset.update({
|
||
"phase": "FAILED", "finished_epoch": now,
|
||
"summary": "四轴归零等待超时，台架保持停止",
|
||
})
|
||
return
|
||
passed = last_result.get("result") == "PASS" and zero["all_zero"]
|
||
self.bench_reset.update({
|
||
"phase": "PASSED" if passed else "FAILED",
|
||
"finished_epoch": now,
|
||
"summary": ("四轴已归零，可启动一项实物故障用例" if passed else
|
||
(last_result.get("summary") or
|
||
"四轴归零反馈不完整，禁止故障注入")),
|
||
"details": last_result.get("details"),
|
||
})
|
||
|
||
def snapshot(self):
|
||
with self.lock:
|
||
now = time.time()
|
||
status = _read_json(STATUS_PATH)
|
||
self._sync_bench_reset(status, now)
|
||
self._sync_bench_healing(status, now)
|
||
hardware = self._hardware_snapshot(status, now)
|
||
bridge = self._bridge_summary(status, now)
|
||
healing = self.engine.snapshot(now)
|
||
self._save_completed_report(healing, hardware, bridge)
|
||
return {
|
||
"schema": "seat-self-healing-console-state-v1",
|
||
"generated_epoch": now,
|
||
"project": {
|
||
"name": "Seat_Controller_demo",
|
||
"controller": "T2G Seat Controller",
|
||
"ai_engine": "Seat-Heal Evidence Engine v1",
|
||
"execution_target": "影子故障模型 + 受控实物CAN写入闭环",
|
||
},
|
||
"scenarios": public_scenarios(),
|
||
"bridge": bridge,
|
||
"bench_twin": self._bench_twin_snapshot(status, now),
|
||
"bridge_manager": self.bridge_manager.snapshot(),
|
||
"healing": healing,
|
||
"bench_reset": dict(self.bench_reset),
|
||
"hardware": hardware,
|
||
"batch": dict(self.batch),
|
||
"hardware_session": {
|
||
"active": self.hardware_active,
|
||
"run_id": self.hardware_run_id,
|
||
"started_epoch": self.hardware_started_epoch,
|
||
"events": list(self.hardware_events),
|
||
"report_path": (None if self.hardware_report_path is None
|
||
else str(self.hardware_report_path)),
|
||
"self_test": self.hardware_self_test,
|
||
"request_id": self.hardware_request_id,
|
||
"progress": (self.hardware_result or {}).get(
|
||
"active_test"),
|
||
"prepare": dict(self.hardware_prepare),
|
||
},
|
||
"model": {
|
||
"available": True,
|
||
"type": "PROCEDURAL_SEAT",
|
||
"name": "Cognitive_Agent程序化座椅孪生",
|
||
},
|
||
"latest_report_path": (None if self.latest_report_path is None
|
||
else str(self.latest_report_path)),
|
||
"firmware": self._firmware_snapshot(),
|
||
}
|
||
|
||
def start(self, case_id, execution_mode="shadow", allow_batch=False):
|
||
with self.lock:
|
||
if execution_mode == "bench":
|
||
if (self.hardware_active or
|
||
(self.batch.get("active") and not allow_batch)):
|
||
raise ValueError("硬件诊断或批量验证正在运行，不能启动实物故障用例")
|
||
scenario = SCENARIO_BY_ID.get(case_id) or {}
|
||
if not (scenario.get("bench") or {}).get("supported", False):
|
||
raise ValueError(
|
||
"该用例没有安全的实物注入手段，请使用影子仿真")
|
||
self.bridge_manager.ensure_async()
|
||
now = time.time()
|
||
status, bridge = self._wait_bridge(
|
||
require_protocol=True, timeout_s=12.0)
|
||
now = time.time()
|
||
if not bridge.get("online"):
|
||
raise ValueError("CAN Runtime未在线，不能向实物ECU写入故障")
|
||
if not bridge.get("protocol_online"):
|
||
raise ValueError("未识别到本工程座椅ECU协议，不能执行台架故障注入")
|
||
self._sync_bench_reset(status, now)
|
||
zero = self._bench_zero_snapshot(status)
|
||
if (self.bench_reset.get("phase") != "PASSED" or
|
||
not zero.get("all_zero")):
|
||
raise ValueError(
|
||
"请先点击‘重置并四轴归零’，确认四轴均为零位后再启动该用例")
|
||
request_id = "SELF_HEAL_BENCH_%d" % int(now * 1000)
|
||
request = {
|
||
"schema": "seat-function-request-v1",
|
||
"request_id": request_id,
|
||
"created_epoch": now,
|
||
"armed_until_epoch": now + 60.0,
|
||
"source": "seat_self_healing_console",
|
||
"action": "execute_self_healing_case",
|
||
"payload": {"case_id": case_id},
|
||
}
|
||
self.latest_report_path = None
|
||
self.bench_request_id = request_id
|
||
value = self.engine.start(
|
||
case_id, now=now, execution_mode="bench")
|
||
self.engine.telemetry["bench_request_id"] = request_id
|
||
_atomic_json(PENDING_DIR / (request_id + ".json"), request)
|
||
self.bench_reset.update({
|
||
"phase": "CONSUMED",
|
||
"summary": "本次归零许可已用于%s；下一个用例前须重新归零" %
|
||
case_id,
|
||
})
|
||
return value
|
||
self.latest_report_path = None
|
||
self.bench_request_id = None
|
||
return self.engine.start(case_id, execution_mode="shadow")
|
||
|
||
def reset(self, execution_mode="shadow", allow_batch=False,
|
||
force_all_axes=True, home_nonzero_axes=False):
|
||
with self.lock:
|
||
if (self.engine.execution_mode == "bench" and
|
||
self.engine.phase not in ("IDLE", PHASE_PASSED,
|
||
PHASE_FAILED)):
|
||
raise ValueError("实物台架执行中不能重置，请使用STOP ALL")
|
||
if execution_mode not in ("shadow", "bench"):
|
||
raise ValueError("未知重置方式")
|
||
self.engine.reset()
|
||
self.bench_request_id = None
|
||
if execution_mode != "bench":
|
||
self.bench_reset.update({
|
||
"phase": "IDLE", "request_id": None,
|
||
"started_epoch": None, "finished_epoch": None,
|
||
"summary": "影子验证已重置",
|
||
"details": None,
|
||
})
|
||
return {"healing": self.engine.snapshot(),
|
||
"bench_reset": dict(self.bench_reset)}
|
||
if (self.hardware_active or
|
||
(self.batch.get("active") and not allow_batch)):
|
||
raise ValueError("硬件诊断或批量验证正在运行，不能执行四轴归零")
|
||
self.bridge_manager.ensure_async()
|
||
now = time.time()
|
||
status, bridge = self._wait_bridge(
|
||
require_protocol=True, timeout_s=12.0)
|
||
now = time.time()
|
||
if not bridge.get("online") or not bridge.get("protocol_online"):
|
||
raise ValueError("CAN桥接或座椅ECU协议未在线，不能执行四轴归零")
|
||
if (status or {}).get("current_request_id"):
|
||
raise ValueError("台架已有任务正在执行，不能开始四轴归零")
|
||
request_id = "RESET_HOME_ALL_%d" % int(now * 1000)
|
||
request = {
|
||
"schema": "seat-function-request-v1",
|
||
"request_id": request_id,
|
||
"created_epoch": now,
|
||
"armed_until_epoch": now + 600.0,
|
||
"source": "seat_self_healing_console",
|
||
"action": "initialize_known_ranges",
|
||
"payload": {
|
||
"force_all_axes": bool(force_all_axes),
|
||
"home_nonzero_axes": bool(home_nonzero_axes),
|
||
},
|
||
}
|
||
zero = self._bench_zero_snapshot(status)
|
||
self.bench_reset = {
|
||
"phase": "QUEUED", "request_id": request_id,
|
||
"started_epoch": now, "finished_epoch": None,
|
||
"summary": "已停止全部输出，等待四轴依次归零",
|
||
"details": None, **zero,
|
||
}
|
||
_atomic_json(PENDING_DIR / (request_id + ".json"), request)
|
||
return {"healing": self.engine.snapshot(),
|
||
"bench_reset": dict(self.bench_reset)}
|
||
|
||
def _wait_bench_reset(self, timeout_s=620.0):
|
||
"""Wait for the bridge-owned four-axis homing request to finish."""
|
||
deadline = time.time() + float(timeout_s)
|
||
last = None
|
||
while time.time() < deadline:
|
||
last = self.snapshot()
|
||
reset = last.get("bench_reset") or {}
|
||
if reset.get("phase") in ("PASSED", "FAILED"):
|
||
return reset
|
||
time.sleep(0.2)
|
||
with self.lock:
|
||
self.bench_reset.update({
|
||
"phase": "FAILED",
|
||
"finished_epoch": time.time(),
|
||
"summary": "四轴归零等待超时，批量验证已停止",
|
||
})
|
||
return dict(self.bench_reset)
|
||
|
||
@staticmethod
|
||
def _wait_bench_bridge_idle(timeout_s=8.0):
|
||
"""Wait until the bridge clears its just-published request result."""
|
||
deadline = time.time() + float(timeout_s)
|
||
while time.time() < deadline:
|
||
status = _read_json(STATUS_PATH) or {}
|
||
if not status.get("current_request_id"):
|
||
return True
|
||
time.sleep(0.05)
|
||
return False
|
||
|
||
def _batch_worker(self, execution_mode):
|
||
try:
|
||
for scenario in public_scenarios():
|
||
with self.lock:
|
||
self.batch["current_case_id"] = scenario["id"]
|
||
self.latest_report_path = None
|
||
if execution_mode == "bench":
|
||
if not self._wait_bench_bridge_idle():
|
||
raise ValueError(
|
||
"%s前台架桥接任务未在安全窗口内结束" % scenario["id"])
|
||
reset = {}
|
||
for reset_attempt in range(2):
|
||
self.reset(
|
||
"bench", allow_batch=True,
|
||
force_all_axes=False,
|
||
home_nonzero_axes=True)
|
||
reset = self._wait_bench_reset()
|
||
if (reset.get("phase") == "PASSED" and
|
||
reset.get("all_zero")):
|
||
break
|
||
if reset_attempt == 0:
|
||
time.sleep(1.0)
|
||
if (reset.get("phase") != "PASSED" or
|
||
not reset.get("all_zero")):
|
||
raise ValueError(
|
||
"%s前四轴自动归零失败：%s" %
|
||
(scenario["id"], reset.get("summary", "未知错误")))
|
||
self.start(
|
||
scenario["id"], execution_mode, allow_batch=True)
|
||
while True:
|
||
value = self.snapshot()
|
||
phase = value["healing"]["phase"]
|
||
if phase in (PHASE_PASSED, PHASE_FAILED):
|
||
break
|
||
time.sleep(0.12)
|
||
with self.lock:
|
||
passed = phase == PHASE_PASSED
|
||
result = {
|
||
"case_id": scenario["id"],
|
||
"title": scenario["short_title"],
|
||
"result": "PASS" if passed else "FAIL",
|
||
"run_id": value["healing"].get("run_id"),
|
||
"duration_s": value["healing"].get("elapsed_s"),
|
||
"diagnosed_code": value["healing"].get("diagnosed_code"),
|
||
"execution_mode": execution_mode,
|
||
"report_path": (None if self.latest_report_path is None else
|
||
str(self.latest_report_path)),
|
||
"snapshot_path": (
|
||
None if self.latest_report_path is None or not passed else
|
||
str(self.latest_report_path.parent /
|
||
"diagnostic_snapshot_success.json")),
|
||
}
|
||
self.batch["results"].append(result)
|
||
self.batch["completed"] += 1
|
||
self.batch["passed" if passed else "failed"] += 1
|
||
with self.lock:
|
||
self.batch["active"] = False
|
||
self.batch["current_case_id"] = None
|
||
self.batch["finished_epoch"] = time.time()
|
||
except Exception as error:
|
||
with self.lock:
|
||
self.batch["active"] = False
|
||
self.batch["failed"] += 1
|
||
self.batch["current_case_id"] = None
|
||
self.batch["finished_epoch"] = time.time()
|
||
self.batch["results"].append({
|
||
"case_id": "BATCH", "title": "批量验证执行器",
|
||
"result": "FAIL", "reason": str(error),
|
||
})
|
||
|
||
def start_batch(self, execution_mode="shadow"):
|
||
with self.lock:
|
||
if self.batch.get("active"):
|
||
raise ValueError("六项自动验证正在运行")
|
||
if execution_mode not in ("shadow", "bench"):
|
||
raise ValueError("未知批量验证方式")
|
||
if execution_mode == "bench":
|
||
if self.hardware_active:
|
||
raise ValueError("硬件诊断正在运行，不能启动实物批量验证")
|
||
self.bridge_manager.ensure_async()
|
||
self.batch = self._new_batch_state(execution_mode)
|
||
self.batch["active"] = True
|
||
self.batch["started_epoch"] = time.time()
|
||
self.batch_thread = threading.Thread(
|
||
target=self._batch_worker, name="seat-self-healing-batch",
|
||
args=(execution_mode,), daemon=True)
|
||
self.batch_thread.start()
|
||
return dict(self.batch)
|
||
|
||
def start_hardware(self):
|
||
try:
|
||
status, bridge = self._prepare_firmware_for_hardware_diagnostic()
|
||
self_test = self.run_hardware_self_test()
|
||
if self_test.get("result") != "PASS":
|
||
raise ValueError("内置诊断规则校验失败，未启动实物诊断：%s" %
|
||
self_test.get("reason", "未知错误"))
|
||
with self.lock:
|
||
now = time.time()
|
||
status = _read_json(STATUS_PATH) or status
|
||
bridge = self._bridge_summary(status, now)
|
||
if not bridge.get("online"):
|
||
raise ValueError(
|
||
"固件资格检查后CAN Runtime离线，未启动21针主动检测")
|
||
if not bridge.get("protocol_online"):
|
||
raise ValueError(
|
||
"固件资格检查后仍未识别0x301~0x305，未启动21针主动检测")
|
||
self.signal_model = SignalDiagnosticModel(
|
||
load_config(CONFIG_PATH))
|
||
self.hardware_active = True
|
||
self.hardware_started_epoch = now
|
||
self.hardware_run_id = \
|
||
"HW-RUN-%s" % time.strftime("%Y%m%d-%H%M%S")
|
||
self.hardware_request_id = \
|
||
"HARDWARE_PIN_%d" % int(now * 1000)
|
||
self.hardware_events = []
|
||
self.hardware_signatures = {}
|
||
self.hardware_report_path = None
|
||
self.hardware_result = self.signal_model.analyze(
|
||
status, now=now)
|
||
self._record_hardware_transitions(self.hardware_result, now)
|
||
request = {
|
||
"schema": "seat-function-request-v1",
|
||
"request_id": self.hardware_request_id,
|
||
"created_epoch": now,
|
||
"armed_until_epoch": now + 180.0,
|
||
"source": "seat_self_healing_console",
|
||
"action": "execute_hardware_diagnostic",
|
||
"payload": {
|
||
"enabled_pin_count": 21,
|
||
"repeat_per_direction": 2,
|
||
"bounded_output": True,
|
||
},
|
||
}
|
||
_atomic_json(
|
||
PENDING_DIR / (self.hardware_request_id + ".json"),
|
||
request)
|
||
self.hardware_prepare.update({
|
||
"state": "DIAGNOSTIC_RUNNING",
|
||
"detail": ("固件资格检查通过；21针主动检测已启动" if
|
||
not self.hardware_prepare.get(
|
||
"automatic_flash") else
|
||
"自动烧录与协议校验通过；21针主动检测已启动"),
|
||
})
|
||
return self.hardware_session()
|
||
except Exception as error:
|
||
with self.lock:
|
||
self.hardware_prepare.update({
|
||
"state": "FAILED", "detail": str(error),
|
||
"finished_epoch": time.time(),
|
||
})
|
||
if isinstance(error, ValueError):
|
||
raise
|
||
raise ValueError("硬件诊断启动前的自动固件处理失败：%s" % error)
|
||
|
||
def hardware_session(self):
|
||
return {
|
||
"active": self.hardware_active, "run_id": self.hardware_run_id,
|
||
"started_epoch": self.hardware_started_epoch,
|
||
"events": list(self.hardware_events),
|
||
"report_path": (None if self.hardware_report_path is None else
|
||
str(self.hardware_report_path)),
|
||
"self_test": self.hardware_self_test,
|
||
"request_id": self.hardware_request_id,
|
||
"progress": (self.hardware_result or {}).get("active_test"),
|
||
"prepare": dict(self.hardware_prepare),
|
||
}
|
||
|
||
def stop_hardware(self):
|
||
with self.lock:
|
||
now = time.time()
|
||
status = _read_json(STATUS_PATH)
|
||
self._save_hardware_report(status, now)
|
||
return self.hardware_session()
|
||
|
||
def run_hardware_self_test(self):
|
||
started = time.time()
|
||
try:
|
||
run_signal_self_test()
|
||
result = "PASS"
|
||
reason = ("启动前内部校验通过：JA1/JB1/JC1共72针映射、"
|
||
"21个启用针脚及检测阈值一致")
|
||
except Exception as error:
|
||
result = "FAIL"
|
||
reason = str(error)
|
||
value = {
|
||
"result": result, "reason": reason,
|
||
"duration_ms": round((time.time() - started) * 1000.0, 2),
|
||
"time": time.strftime("%Y-%m-%d %H:%M:%S"),
|
||
}
|
||
with self.lock:
|
||
self.hardware_self_test = value
|
||
path = HARDWARE_LOG_ROOT / "self_test_latest.json"
|
||
_atomic_json(path, value)
|
||
return value
|
||
|
||
def emergency_stop(self):
|
||
request_id = "SELF_HEAL_STOP_%d" % int(time.time() * 1000)
|
||
value = {
|
||
"schema": "seat-function-emergency-v1",
|
||
"request_id": request_id,
|
||
"created_epoch": time.time(),
|
||
"armed_until_epoch": time.time() + 5.0,
|
||
"stop_all": True,
|
||
"thermal_off": True,
|
||
"source": "seat_self_healing_console",
|
||
}
|
||
_atomic_json(EMERGENCY_PATH, value)
|
||
return value
|
||
|
||
def build_and_flash_firmware(self, confirmed_bench_clear=False,
|
||
automatic=False, trigger_reason=None):
|
||
if not confirmed_bench_clear:
|
||
raise ValueError("请先确认台架运动区域无人、座椅机构无遮挡且急停可用")
|
||
with self.lock:
|
||
if self.batch.get("active") or self.hardware_active:
|
||
raise ValueError("有台架验证正在运行，不能烧录固件")
|
||
if self.firmware_operation.get("state") in ("BUILDING", "FLASHING"):
|
||
raise ValueError("固件构建/烧录已在进行")
|
||
if (self.cspy_process is not None and
|
||
self.cspy_process.poll() is None):
|
||
raise ValueError("台架测试固件已由C-SPY运行，无需重复烧录")
|
||
if not IAR_BUILD_PATH.exists() or not CSPY_BAT_PATH.exists():
|
||
raise ValueError("未找到IAR构建或C-SPY命令行工具")
|
||
stamp = time.strftime("%Y%m%d_%H%M%S")
|
||
run_dir = FIRMWARE_LOG_ROOT / stamp
|
||
run_dir.mkdir(parents=True, exist_ok=True)
|
||
self.firmware_operation = {
|
||
"state": "BUILDING", "message": "正在构建台架测试固件",
|
||
"started_epoch": time.time(), "log_dir": str(run_dir),
|
||
"hex_path": str(FIRMWARE_HEX_PATH),
|
||
"probe_checked_epoch": 0.0,
|
||
"automatic": bool(automatic),
|
||
"trigger_reason": trigger_reason,
|
||
}
|
||
|
||
build = self._run_hidden(
|
||
[IAR_BUILD_PATH, IAR_PROJECT_PATH, "-build", "rev_d",
|
||
"-log", "errors"], 180)
|
||
build_log = run_dir / "iar_build.log"
|
||
build_log.write_text(build.stdout, encoding="utf-8")
|
||
if build.returncode != 0 or not FIRMWARE_OUT_PATH.exists():
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"state": "BUILD_FAILED", "message": "IAR构建失败",
|
||
"build_returncode": build.returncode,
|
||
"build_log": str(build_log),
|
||
})
|
||
raise ValueError("IAR构建失败，详见%s" % build_log)
|
||
|
||
programmer = self._programmer_status()
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"programmer": programmer,
|
||
"probe_checked_epoch": time.time(),
|
||
"build_returncode": build.returncode,
|
||
"build_log": str(build_log),
|
||
"hex_sha256": hashlib.sha256(
|
||
FIRMWARE_HEX_PATH.read_bytes()).hexdigest(),
|
||
})
|
||
if not programmer.get("detected"):
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"state": "BUILT_NO_PROBE",
|
||
"message": "固件已构建；未检测到CMSIS-DAP，未执行烧录",
|
||
})
|
||
raise ValueError(
|
||
"测试固件已成功构建，但Windows未枚举到CMSIS-DAP下载器；"
|
||
"连接下载器后可再次点击烧录")
|
||
|
||
self.emergency_stop()
|
||
time.sleep(0.5)
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"state": "FLASHING", "message": "正在通过CMSIS-DAP烧录并校验",
|
||
})
|
||
creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
|
||
flash = None
|
||
flash_log = None
|
||
flash_logs = []
|
||
flash_returncode = None
|
||
flash_error = None
|
||
protocol_online = False
|
||
max_flash_attempts = 3
|
||
for attempt in range(1, max_flash_attempts + 1):
|
||
flash_error = None
|
||
flash_log = run_dir / ("cspy_flash.log" if attempt == 1 else
|
||
"cspy_flash_attempt_%d.log" % attempt)
|
||
flash_logs.append(str(flash_log))
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"state": "FLASHING",
|
||
"message": "正在通过CMSIS-DAP烧录并校验（%d/%d）" %
|
||
(attempt, max_flash_attempts),
|
||
"flash_attempt": attempt,
|
||
"flash_attempts_max": max_flash_attempts,
|
||
"flash_logs": list(flash_logs),
|
||
})
|
||
try:
|
||
# Leave the flashed ECU running without an attached debugger.
|
||
# Otherwise an on-chip watchdog reset can be intercepted before
|
||
# the restarted firmware publishes recovery evidence. A macro
|
||
# parameter marks this as an authorized clean detach; unexpected
|
||
# debugger loss still forces the ECU safe.
|
||
with flash_log.open("w", encoding="utf-8") as stream:
|
||
flash = subprocess.Popen([
|
||
str(CSPY_BAT_PATH), "--silent", "--timeout", "3000",
|
||
"--leave_target_running", "--macro_param",
|
||
"seat_hil_leave_target_running=1",
|
||
"-f", str(CSPY_GENERAL_PATH), "--backend", "-f",
|
||
str(CSPY_DRIVER_PATH)], cwd=str(PROJECT_DIR),
|
||
stdout=stream, stderr=subprocess.STDOUT,
|
||
creationflags=creationflags)
|
||
self.cspy_process = flash
|
||
except OSError as error:
|
||
flash_error = str(error)
|
||
flash_returncode = None
|
||
else:
|
||
self.bridge_manager.ensure_async()
|
||
deadline = time.time() + 20.0
|
||
while time.time() < deadline:
|
||
flash_returncode = flash.poll()
|
||
if flash_returncode not in (None, 0):
|
||
break
|
||
bridge = self._bridge_summary(
|
||
_read_json(STATUS_PATH), time.time())
|
||
if (bridge.get("protocol_online") and
|
||
flash_returncode == 0):
|
||
protocol_online = True
|
||
break
|
||
time.sleep(0.25)
|
||
flash_returncode = flash.poll()
|
||
if flash_returncode is not None:
|
||
self.cspy_process = None
|
||
if protocol_online:
|
||
break
|
||
# Retry only a genuine probe/CPU connection failure. A zero
|
||
# return code means the image was downloaded successfully; if CAN
|
||
# is still silent, another download cannot repair the bus path.
|
||
# Likewise, do not launch a second debugger while the first one
|
||
# still owns the probe.
|
||
if flash_error is None and flash_returncode in (None, 0):
|
||
break
|
||
if attempt < max_flash_attempts:
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"message": ("CMSIS-DAP目标握手失败，%0.1f秒后自动重试" %
|
||
float(attempt)),
|
||
"flash_returncode": flash_returncode,
|
||
"flash_error": flash_error,
|
||
})
|
||
time.sleep(float(attempt))
|
||
|
||
if flash_returncode not in (None, 0) and not protocol_online:
|
||
with self.lock:
|
||
self.firmware_operation.update({
|
||
"state": "FLASH_FAILED",
|
||
"message": "C-SPY多次无法连接目标CPU",
|
||
"flash_returncode": flash_returncode,
|
||
"flash_error": flash_error,
|
||
"flash_log": str(flash_log),
|
||
"flash_logs": list(flash_logs),
|
||
"finished_epoch": time.time(),
|
||
})
|
||
raise ValueError(
|
||
"CMSIS-DAP已枚举，但%d次均无法连接目标CPU；"
|
||
"请检查座椅ECU 12V供电和SWD接线，日志：%s" %
|
||
(max_flash_attempts, flash_log))
|
||
|
||
with self.lock:
|
||
if flash_returncode is not None:
|
||
self.cspy_process = None
|
||
self.firmware_operation.update({
|
||
"state": "READY" if protocol_online else "FLASHED_WAITING_CAN",
|
||
"message": ("测试固件烧录成功且0x301~0x305已在线" if
|
||
protocol_online else
|
||
"C-SPY仍在运行，但20秒内未收到座椅协议"),
|
||
"flash_returncode": flash_returncode,
|
||
"flash_log": str(flash_log),
|
||
"flash_logs": list(flash_logs),
|
||
"cspy_pid": (flash.pid if flash is not None and
|
||
flash_returncode is None else None),
|
||
"target_mode": ("STANDALONE" if flash_returncode == 0 else
|
||
"CSPY_ATTACHED"),
|
||
"finished_epoch": time.time(),
|
||
"protocol_online": protocol_online,
|
||
})
|
||
return dict(self.firmware_operation)
|
||
|
||
def save_snapshot(self):
|
||
value = self.snapshot()
|
||
stamp = time.strftime("%Y%m%d_%H%M%S")
|
||
path = LOG_ROOT / ("snapshot_%s.json" % stamp)
|
||
_atomic_json(path, value)
|
||
self.latest_report_path = path
|
||
return path
|
||
|
||
def open_log_dir(self):
|
||
LOG_ROOT.mkdir(parents=True, exist_ok=True)
|
||
try:
|
||
os.startfile(str(LOG_ROOT))
|
||
return True
|
||
except (AttributeError, OSError):
|
||
return False
|
||
|
||
|
||
class SelfRepairService(object):
|
||
"""Repository-facing facade for the migrated self-repair runtime."""
|
||
|
||
def __init__(self):
|
||
self.bridge_manager = BRIDGE_MANAGER
|
||
self.state = ConsoleState(self.bridge_manager)
|
||
|
||
@staticmethod
|
||
def _configuration():
|
||
firmware_root_configured = PROJECT_DIR.is_dir()
|
||
return {
|
||
"runtime_dir": str(RUNTIME_DIR),
|
||
"diagnostic_config": str(CONFIG_PATH),
|
||
"bridge_status_path": str(STATUS_PATH),
|
||
"bridge_script_path": str(BRIDGE_SCRIPT_PATH),
|
||
"can_runtime_backend": CAN_RUNTIME_BACKEND,
|
||
"zcanpro_exe": str(ZCANPRO_EXE),
|
||
"firmware_root": str(PROJECT_DIR),
|
||
"iar_build_path": str(IAR_BUILD_PATH),
|
||
"cspy_bat_path": str(CSPY_BAT_PATH),
|
||
"bridge_script_available": BRIDGE_SCRIPT_PATH.is_file(),
|
||
"diagnostic_config_available": CONFIG_PATH.is_file(),
|
||
"zcanpro_configured": ZCANPRO_EXE.is_file(),
|
||
"standalone_can_runtime_configured": bool(
|
||
CAN_RUNTIME_BACKEND == "standalone-zlg"
|
||
and getattr(BRIDGE_MANAGER, "configured", False)
|
||
),
|
||
"can_runtime_configured": bool(
|
||
getattr(BRIDGE_MANAGER, "configured", False)
|
||
if CAN_RUNTIME_BACKEND == "standalone-zlg"
|
||
else ZCANPRO_EXE.is_file()
|
||
),
|
||
"firmware_root_configured": firmware_root_configured,
|
||
"firmware_tools_configured": (
|
||
firmware_root_configured
|
||
and IAR_BUILD_PATH.is_file()
|
||
and CSPY_BAT_PATH.is_file()
|
||
),
|
||
"auto_start_bridge": _env_flag("SELF_REPAIR_AUTO_START_BRIDGE", False),
|
||
}
|
||
|
||
def start(self):
|
||
self.bridge_manager.start()
|
||
|
||
def close(self):
|
||
self.bridge_manager.stop()
|
||
|
||
def health(self):
|
||
configuration = self._configuration()
|
||
return {
|
||
"ok": configuration["diagnostic_config_available"],
|
||
"service": "seat-self-repair",
|
||
"configuration": configuration,
|
||
"bridge_manager": self.bridge_manager.snapshot(),
|
||
}
|
||
|
||
def snapshot(self):
|
||
value = self.state.snapshot()
|
||
value["integration"] = self._configuration()
|
||
return value
|
||
|
||
def start_healing(self, payload):
|
||
return self.state.start(
|
||
payload.get("case_id"), payload.get("execution_mode", "shadow"))
|
||
|
||
def start_batch(self, payload):
|
||
return self.state.start_batch(payload.get("execution_mode", "shadow"))
|
||
|
||
def reset_healing(self, payload):
|
||
return self.state.reset(
|
||
payload.get("execution_mode", "shadow"),
|
||
force_all_axes=bool(payload.get("force_all_axes", True)),
|
||
home_nonzero_axes=bool(payload.get("home_nonzero_axes", False)))
|
||
|
||
def start_hardware(self):
|
||
return self.state.start_hardware()
|
||
|
||
def stop_hardware(self):
|
||
return self.state.stop_hardware()
|
||
|
||
def run_hardware_self_test(self):
|
||
return self.state.run_hardware_self_test()
|
||
|
||
def emergency_stop(self):
|
||
return self.state.emergency_stop()
|
||
|
||
def build_and_flash_firmware(self, payload):
|
||
return self.state.build_and_flash_firmware(
|
||
bool(payload.get("confirmed_bench_clear", False)))
|
||
|
||
def save_snapshot(self):
|
||
return self.state.save_snapshot()
|
||
|
||
def open_log_dir(self):
|
||
return self.state.open_log_dir()
|
||
|
||
@staticmethod
|
||
def run_self_test():
|
||
run_healing_self_test()
|
||
run_signal_self_test()
|
||
run_bridge_manager_self_test(
|
||
STATUS_PATH,
|
||
BRIDGE_SCRIPT_PATH,
|
||
zcanpro_exe=ZCANPRO_EXE,
|
||
script_config_path=ZCANPRO_SCRIPT_CONFIG,
|
||
)
|
||
return True
|