提交 xyzbc-trt 界面与验证更新

web-rtcp-5axis-xyzbc-trt-sim-plan/app/dist/src/state/linuxcnc-task-policy.js

@@ -0,0 +1,244 @@
+export const LINUXCNC_TASK_POLICY = {
+  apiName: "web-rtcp-5axis-linuxcnc-task-policy",
+  sourceMode: "linuxcnc-task-source-referenced-policy",
+  semanticBoundary: "linuxcnc_task_state_mode_command_gate",
+  sourceReferences: [
+    {
+      path: "linuxcnc/src/emc/nml_intf/emc.hh",
+      symbols: ["EMC_TASK_MODE", "EMC_TASK_STATE", "EMC_TASK_INTERP"],
+    },
+    {
+      path: "linuxcnc/src/emc/task/emctaskmain.cc",
+      symbols: [
+        "emcTaskPlan",
+        "EMC_TASK_PLAN_RUN",
+        "EMC_TASK_PLAN_EXECUTE",
+        "EMC_TASK_PLAN_PAUSE",
+        "EMC_TASK_PLAN_RESUME",
+        "EMC_TASK_ABORT",
+        "EMC_JOG_INCR",
+        "EMC_JOINT_HOME",
+      ],
+    },
+    {
+      path: "linuxcnc/src/emc/task/emctask.cc",
+      symbols: ["emcTaskSetState", "determineState"],
+    },
+  ],
+};
+
+export const LINUXCNC_TASK_MODES = new Set(["manual", "auto", "mdi"]);
+export const LINUXCNC_TASK_STATES = new Set(["estop", "estop-reset", "off", "on"]);
+export const LINUXCNC_INTERP_STATES = new Set(["idle", "reading", "paused", "waiting"]);
+
+export function normalizeLinuxCncTaskMode(mode) {
+  if (mode === "jog") return "manual";
+  return LINUXCNC_TASK_MODES.has(mode) ? mode : "manual";
+}
+
+export function normalizeLinuxCncTaskState(machine = {}) {
+  if (LINUXCNC_TASK_STATES.has(machine.taskState)) return machine.taskState;
+  if (machine.estopActive) return "estop";
+  if (machine.powerOn) return "on";
+  return "estop-reset";
+}
+
+export function normalizeLinuxCncInterpState(machine = {}, runState = "idle") {
+  if (LINUXCNC_INTERP_STATES.has(machine.interpState)) return machine.interpState;
+  if (runState === "running") return "reading";
+  if (runState === "paused" || runState === "stepping") return "paused";
+  return "idle";
+}
+
+export function createLinuxCncTaskPolicyStatus(state) {
+  const taskState = normalizeLinuxCncTaskState(state.machine);
+  const taskMode = normalizeLinuxCncTaskMode(state.machine.mode);
+  const interpState = normalizeLinuxCncInterpState(state.machine, state.runState);
+  const allHomed = Boolean(state.machine.allHomed);
+  const noForceHoming = Boolean(state.machine.noForceHoming);
+  const machineFileStaging = state.machineFileStaging || {};
+  const profileId = state.profile?.id || state.machineProfile || null;
+  const taskHalReadiness = state.taskHalRuntimeReadiness || {};
+  const taskHalRuntimeReady = Boolean(
+    state.taskHalRuntime?.loaded &&
+    taskHalReadiness.taskRuntimeReady === true &&
+    taskHalReadiness.motionRuntimeReady === true &&
+    taskHalReadiness.halRuntimeReady === true,
+  );
+  const iniLoaded = state.iniConfigReadiness?.loaded === true && state.iniConfigReadiness?.ready === true;
+  const machineFileStaged = machineFileStaging.status === "staged" && Boolean(machineFileStaging.save?.files?.length);
+  const machineFileOpened = profileId === "gmoccapy-xyzab"
+    ? Boolean(machineFileStaging.selectedGcodeSourceRel)
+    : Boolean(machineFileStaging.selectedGcodeSourceRel || state.activeProgram);
+  const interpIdle = interpState === "idle";
+  const running = taskMode === "auto" &&
+    (state.runState === "running" || interpState === "reading" || interpState === "waiting");
+  const referenceOnly = state.profile?.tcpCapable === false || state.profile?.promotionAllowed === false;
+
+  return {
+    ...LINUXCNC_TASK_POLICY,
+    taskState,
+    taskMode,
+    interpState,
+    runState: state.runState || "idle",
+    allHomed,
+    noForceHoming,
+    iniLoaded,
+    machineFileStaged,
+    machineFileOpened,
+    taskHalRuntimeReady,
+    interpIdle,
+    referenceOnly,
+    profileId,
+    powerOn: taskState === "on",
+    estopActive: taskState === "estop",
+    canMove: taskState === "on",
+    canJog: taskState === "on" && taskMode === "manual" && !running,
+    canHome: taskState === "on" && taskMode === "manual" && !running,
+    canRunAuto: taskState === "on" && taskMode === "auto" && (allHomed || noForceHoming),
+    canRunAutoStrict: taskState === "on" && taskMode === "auto" && (allHomed || noForceHoming) &&
+      interpIdle && iniLoaded && machineFileStaged && machineFileOpened && taskHalRuntimeReady,
+    canExecuteMdi: taskState === "on" && taskMode === "mdi" && (allHomed || noForceHoming),
+    canPause: taskState === "on" && (taskMode === "auto" || taskMode === "mdi"),
+    canResume: taskState === "on" && (taskMode === "auto" || taskMode === "mdi") && interpState === "paused",
+    canAbort: true,
+    canSpindle: taskState === "on",
+    canCoolant: taskState === "on",
+    canOverride: taskState === "on",
+    canLeaveAuto: taskMode !== "auto" || interpState === "idle",
+  };
+}
+
+export function gateLinuxCncTaskAction(state, action) {
+  const status = createLinuxCncTaskPolicyStatus(state);
+  const type = typeof action === "string" ? action : action?.type;
+  const requestedMode = typeof action === "object" ? action.mode : undefined;
+
+  switch (type) {
+    case "TOGGLE_POWER":
+      if (status.taskState === "estop") {
+        return block(status, "power on blocked: reset estop first");
+      }
+      return allow(status);
+    case "SET_MODE":
+      return gateMode(status, requestedMode);
+    case "JOG":
+      if (status.taskState !== "on") return block(status, "jog blocked: machine must be on");
+      if (status.taskMode !== "manual") return block(status, "jog blocked: switch to manual mode first");
+      if (status.taskMode === "auto" &&
+          (status.runState === "running" || status.interpState === "reading" || status.interpState === "waiting")) {
+        return block(status, "jog blocked: interpreter must be idle");
+      }
+      return allow(status);
+    case "HOME":
+      if (status.taskState !== "on") return block(status, "home blocked: machine must be on");
+      if (status.taskMode !== "manual") return block(status, "home blocked: switch to manual mode first");
+      if (status.taskMode === "auto" &&
+          (status.runState === "running" || status.interpState === "reading" || status.interpState === "waiting")) {
+        return block(status, "home blocked: interpreter must be idle");
+      }
+      return allow(status);
+    case "RUN_MDI":
+      if (status.taskState !== "on") return block(status, "MDI blocked: machine must be on");
+      if (status.taskMode !== "mdi") return block(status, "MDI blocked: switch to MDI mode first");
+      if (!status.allHomed && !status.noForceHoming) return block(status, "MDI blocked: home machine first");
+      if (status.interpState === "reading" || status.interpState === "waiting") {
+        return block(status, "MDI blocked: interpreter must be idle");
+      }
+      return allow(status);
+    case "RUN":
+    case "STEP":
+    case "RUN_FRAME":
+      if (status.taskState !== "on") return block(status, `${type.toLowerCase()} blocked: machine must be on`);
+      if (status.taskMode !== "auto") return block(status, `${type.toLowerCase()} blocked: switch to auto mode first`);
+      if (!status.allHomed && !status.noForceHoming) return block(status, `${type.toLowerCase()} blocked: home machine first`);
+      if (type === "RUN" && status.interpState === "paused") return block(status, "run blocked: resume paused program first");
+      if (type === "RUN" && status.profileId === "gmoccapy-xyzab") {
+        const strictGate = gateGmoccapyXyzabRun(status);
+        if (!strictGate.allowed) return strictGate;
+      }
+      return allow(status);
+    case "PAUSE":
+      if (status.taskState !== "on") return block(status, "pause blocked: machine must be on");
+      if (status.taskMode !== "auto" && status.taskMode !== "mdi") {
+        return block(status, "pause blocked: task mode must be auto or MDI");
+      }
+      return allow(status);
+    case "RESUME":
+      if (status.taskState !== "on") return block(status, "resume blocked: machine must be on");
+      if (status.taskMode !== "auto" && status.taskMode !== "mdi") {
+        return block(status, "resume blocked: task mode must be auto or MDI");
+      }
+      if (status.interpState !== "paused") return block(status, "resume blocked: interpreter is not paused");
+      return allow(status);
+    case "STOP":
+    case "ABORT":
+      return allow(status);
+    case "SET_SPINDLE_DIRECTION":
+    case "SPINDLE":
+      return gateSpindle(status, typeof action === "object" ? action.direction : undefined);
+    case "TOGGLE_COOLANT":
+    case "COOLANT":
+      if (status.taskState !== "on") return block(status, "coolant blocked: machine must be on");
+      return allow(status);
+    case "ADJUST_OVERRIDE":
+    case "ADJUST_SPINDLE_OVERRIDE":
+    case "OVERRIDE":
+      if (status.taskState !== "on") return block(status, "override blocked: machine must be on");
+      return allow(status);
+    default:
+      return allow(status);
+  }
+}
+
+function gateGmoccapyXyzabRun(status) {
+  if (!status.iniLoaded) return block(status, "run blocked: LinuxCNC INI not loaded");
+  if (!status.machineFileStaged) return block(status, "run blocked: LinuxCNC machine files not staged");
+  if (!status.machineFileOpened) return block(status, "run blocked: no machine-file G-code opened for task/HAL session");
+  if (!status.interpIdle) return block(status, "run blocked: interpreter must be idle");
+  if (!status.taskHalRuntimeReady) return block(status, "run blocked: task/HAL runtime not ready");
+  return allow(status);
+}
+
+function gateSpindle(status, direction = "stop") {
+  if (status.taskState !== "on") return block(status, "spindle blocked: machine must be on");
+  const requested = String(direction || "stop").toLowerCase();
+  if ((requested === "forward" || requested === "reverse") &&
+      (status.interpState === "reading" || status.interpState === "waiting")) {
+    return block(status, "spindle blocked: interpreter is running");
+  }
+  return allow(status);
+}
+
+function gateMode(status, requestedMode) {
+  const targetMode = normalizeLinuxCncTaskMode(requestedMode);
+  if (!LINUXCNC_TASK_MODES.has(targetMode)) {
+    return block(status, `mode blocked: invalid LinuxCNC task mode ${requestedMode}`);
+  }
+  if (status.taskMode === "auto" && status.interpState !== "idle" && targetMode !== "auto") {
+    return block(status, "mode blocked: AUTO interpreter is not idle");
+  }
+  if (status.taskState !== "on") {
+    return block(status, `mode blocked: machine must be on before ${targetMode.toUpperCase()}`);
+  }
+  if ((targetMode === "mdi" || targetMode === "auto") && !status.allHomed && !status.noForceHoming) {
+    return block(status, `mode blocked: home machine before ${targetMode.toUpperCase()}`);
+  }
+  return allow(status);
+}
+
+function allow(status) {
+  return {
+    allowed: true,
+    status,
+    operatorMessage: null,
+  };
+}
+
+function block(status, operatorMessage) {
+  return {
+    allowed: false,
+    status,
+    operatorMessage,
+  };
+}