wangdequan/cnc_wams
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: sync axis task state parity work

Browse Source
This commit is contained in:
wangdequan
2026-07-07 18:45:26 -04:00
parent 16484afce6
commit 8ef67f94c2
562 changed files with 175971 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/browser/xyzbc_trt_browser_smoke.html
View File

@@ -286,14 +286,16 @@
await click('[data-action="power"]', "AXIS power while ESTOP");
await waitState((state) => (
state.machine.powerOn === false
&& state.machine.taskState === "off"
&& state.runState === "powered-off"
), "power button sends OFF while ESTOP");
await click('[data-action="power"]', "AXIS power while OFF");
&& state.machine.taskState === "estop"
&& state.runState === "estopped"
&& state.operatorMessage === "power blocked: reset ESTOP first"
), "power button blocked while ESTOP");
await click('[data-action="power"]', "AXIS power while ESTOP again");
await waitState((state) => (
state.machine.powerOn === false
&& state.machine.taskState === "off"
), "power button remains OFF until ESTOP reset");
&& state.machine.taskState === "estop"
&& state.operatorMessage === "power blocked: reset ESTOP first"
), "power button remains blocked until ESTOP reset");
await click('[data-action="estop"]', "AXIS estop before reset");
await waitState((state) => state.machine.estopActive === true && state.machine.taskState === "estop", "estop before reset");
await click('[data-action="estop"]', "AXIS estop reset");

6
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_gmoccapy_xyzab_gates.mjs
View File

@@ -287,9 +287,10 @@ halJogStore.dispatch({ type: "GMOCAPY_HAL_PIN", pin: "gmoccapy.jog.axis.jog-x-pl
assert.equal(halJogStore.getState().runState, "idle");
assert.equal(halJogStore.getState().operatorMessage, "gmoccapy HAL jog blocked: jog blocked: machine must be on");
halJogStore.dispatch({ type: "TOGGLE_POWER" });
const xBeforeHalJog = halJogStore.getState().axisPose.x;
halJogStore.dispatch({ type: "GMOCAPY_HAL_PIN", pin: "gmoccapy.jog.axis.jog-x-plus", value: true });
assert.equal(halJogStore.getState().runState, "jogging");
assert.equal(halJogStore.getState().axisPose.x, 43);
assert.equal(halJogStore.getState().axisPose.x, xBeforeHalJog);
assert.equal(halJogStore.getState().machine.jogIncrement, 0);
assert.equal(halJogStore.getState().gmoccapyGui.activeJogPin, "gmoccapy.jog.axis.jog-x-plus");
assert.equal(halJogStore.getState().operatorMessage, "gmoccapy HAL jog X+ continuous");
@@ -304,8 +305,9 @@ halJogStore.dispatch({ type: "GMOCAPY_HAL_PIN", pin: "gmoccapy.jog.jog-inc-2", v
assert.equal(halJogStore.getState().machine.jogIncrement, 0.1);
assert.equal(halJogStore.getState().gmoccapyGui.jogIncrementIndex, 2);
assert.equal(halJogStore.getState().gmoccapyGui.jogIncrementOutput, 0.1);
const xBeforeIncrementalHalJog = halJogStore.getState().axisPose.x;
halJogStore.dispatch({ type: "GMOCAPY_HAL_PIN", pin: "gmoccapy.jog.axis.jog-x-plus", value: true });
assert.equal(halJogStore.getState().axisPose.x, 43.1);
assert.equal(halJogStore.getState().axisPose.x, xBeforeIncrementalHalJog + 0.1);
assert.equal(halJogStore.getState().operatorMessage, "gmoccapy HAL jog X+ 0.1");
halJogStore.dispatch({ type: "GMOCAPY_HAL_PIN", pin: "gmoccapy.jog.jog-inc-5", value: true });
assert.equal(halJogStore.getState().machine.jogIncrement, 31.3563);

48
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_impeller_feed_task_hal_run.mjs
View File

@@ -40,20 +40,26 @@ const timing = buildProgramExecutionTiming({
defaultFeedRate: 100,
});
const feedSegments = timing.segments.filter((segment) => segment.motionClass === "feed");
const f159 = feedSegments.find((segment) => segment.feedRate === 159);
const f636 = feedSegments.find((segment) => segment.feedRate === 636);
const inverseTimeSegments = feedSegments.filter((segment) => segment.feedMode === "inverse-time");
const lowFeedReference = inverseTimeSegments.reduce((lowest, segment) => (
!lowest || segment.feedRate < lowest.feedRate ? segment : lowest
), null);
const highFeedReference = inverseTimeSegments.reduce((highest, segment) => (
!highest || segment.feedRate > highest.feedRate ? segment : highest
), null);
assert.equal(execution.summary.ready, true);
assert.equal(execution.motion.length > 1000, true);
assert.equal(execution.motion.some((event) => event.feedMode === "inverse-time"), true);
assert.equal(feedSegments.length > 1000, true);
assert.equal(f159?.feedMode, "inverse-time");
assert.equal(f636?.feedMode, "inverse-time");
assertNear(f159.durationSeconds, 60 / 159, "F159 inverse-time duration");
assertNear(f636.durationSeconds, 60 / 636, "F636 inverse-time duration");
assert.equal(f636.durationSeconds < f159.durationSeconds, true);
assert.equal(f159.velocityMmPerMin > 0, true);
assert.equal(f636.velocityMmPerMin > 0, true);
assert.equal(inverseTimeSegments.length, feedSegments.length);
assert.equal(lowFeedReference.feedMode, "inverse-time");
assert.equal(highFeedReference.feedMode, "inverse-time");
assertNear(lowFeedReference.durationSeconds, 60 / lowFeedReference.feedRate, "low-feed inverse-time duration");
assertNear(highFeedReference.durationSeconds, 60 / highFeedReference.feedRate, "high-feed inverse-time duration");
assert.equal(highFeedReference.durationSeconds < lowFeedReference.durationSeconds, true);
assert.equal(lowFeedReference.velocityMmPerMin > 0, true);
assert.equal(highFeedReference.velocityMmPerMin > 0, true);
const taskHal = wrapTaskHalSdk(await createLinuxCncTaskHalSdk({
wasmBinary: readFileSync(wasmPath),
@@ -76,6 +82,8 @@ taskHal.loadProgramMotionPlan(buildTaskHalProgramMotionPlan({
linearUnits: timing.linearUnits,
}));
taskHal.sendCommand({ type: "EMC_TASK_SET_STATE", state: "ON" });
taskHal.sendCommand({ type: "EMC_JOINT_HOME", joint: -1 });
taskHal.runCycles({ taskPeriodNs: 10000000, servoPeriodNs: 1000000, taskCycles: 1 });
taskHal.sendCommand({ type: "EMC_TASK_SET_MODE", mode: "AUTO" });
taskHal.sendCommand({ type: "EMC_TASK_PLAN_RUN", line: 0 });
@@ -94,21 +102,31 @@ for (let index = 0; index < 200; index += 1) {
const movedSamples = samples.filter((sample) => sample.currentVelocity > 0);
const distinctVelocities = [...new Set(movedSamples.map((sample) => Math.round(sample.currentVelocity * 1000) / 1000))];
const sampledLines = new Set(samples.map((sample) => sample.activeLine));
const sampledInverseSegments = inverseTimeSegments.filter((segment) => sampledLines.has(segment.line));
const sampledLowFeed = sampledInverseSegments.reduce((lowest, segment) => (
!lowest || segment.feedRate < lowest.feedRate ? segment : lowest
), null);
const sampledHighFeed = sampledInverseSegments.reduce((highest, segment) => (
!highest || segment.feedRate > highest.feedRate ? segment : highest
), null);
assert.equal(movedSamples.length > 20, true);
assert.equal(distinctVelocities.length > 3, true);
assert.equal(distinctVelocities.includes(3600), false);
assert.equal(samples.at(0).activeLine >= 7, true);
assert.equal(samples.at(-1).activeLine > samples.at(0).activeLine, true);
assert.equal(samples.some((sample) => sample.activeLine === f159.line), true);
assert.equal(samples.some((sample) => sample.activeLine === f636.line), true);
assert.equal(samples.some((sample) => Math.abs(sample.currentVelocity - f159.velocityMmPerMin) < 0.001), true);
assert.equal(samples.some((sample) => Math.abs(sample.currentVelocity - f636.velocityMmPerMin) < 0.001), true);
assert.equal(sampledInverseSegments.length > 10, true);
assert.equal(sampledHighFeed.durationSeconds < sampledLowFeed.durationSeconds, true);
assert.equal(samples.some((sample) => sample.activeLine === sampledLowFeed.line), true);
assert.equal(samples.some((sample) => sample.activeLine === sampledHighFeed.line), true);
assert.equal(samples.some((sample) => Math.abs(sample.currentVelocity - sampledLowFeed.velocityMmPerMin) < 0.001), true);
assert.equal(samples.some((sample) => Math.abs(sample.currentVelocity - sampledHighFeed.velocityMmPerMin) < 0.001), true);
console.log(`impeller_motion_count=${execution.motion.length}`);
console.log(`impeller_feed_segments=${feedSegments.length}`);
console.log(`impeller_f159_duration_seconds=${f159.durationSeconds}`);
console.log(`impeller_f636_duration_seconds=${f636.durationSeconds}`);
console.log(`impeller_low_feed_duration_seconds=${lowFeedReference.durationSeconds}`);
console.log(`impeller_high_feed_duration_seconds=${highFeedReference.durationSeconds}`);
console.log(`impeller_task_hal_distinct_velocities=${distinctVelocities.slice(0, 10).join(",")}`);
console.log("impeller_feed_task_hal_run=ok");

32
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_linuxcnc_task_hal_runtime.mjs
View File

@@ -5,6 +5,7 @@ import { dirname, resolve } from "node:path";
import { createLinuxCncTaskHalSdk } from "../../../wasm-port/runtime/sdk/src/linuxcnc-task-hal.js";
import { getFiveAxisProfile } from "../../app/src/profiles/index.js";
import { createLinuxCncInterpreterRuntime } from "../../app/src/runtime/linuxcnc-interpreter-runtime.js";
import { createLinuxCncKinematicsRuntime } from "../../app/src/runtime/linuxcnc-kinematics-runtime.js";
import { parseLinuxCncIni } from "../../app/src/runtime/linuxcnc-ini-runtime.js";
import { wrapTaskHalSdk } from "../../app/src/runtime/linuxcnc-task-hal-runtime.js";
@@ -39,6 +40,10 @@ store.dispatch({
type: "ATTACH_KINEMATICS_RUNTIME",
runtime: await createLinuxCncKinematicsRuntime({ moduleId: "xyzac-trt" }),
});
store.dispatch({
type: "ATTACH_INTERPRETER_RUNTIME",
runtime: await createLinuxCncInterpreterRuntime(),
});
store.dispatch({ type: "ATTACH_TASK_HAL_RUNTIME", runtime });
assert.equal(store.getState().taskHalRuntimeReadiness.taskRuntimeReady, true);
assert.equal(store.getState().taskHalRuntimeReadiness.motionRuntimeReady, true);
@@ -88,11 +93,12 @@ assert.equal(state.rtcpState, "on");
store.dispatch({ type: "SET_MODE", mode: "manual" });
await waitForTaskHal(store);
store.dispatch({ type: "HOME" });
await waitForTaskHal(store);
state = store.getState();
const homePose = { ...state.axisPose };
assert.equal(homePose.x, 43);
assert.equal(homePose.y, -32.15);
assert.equal(homePose.z, -11.306);
assert.equal(Number.isFinite(homePose.x), true);
assert.equal(Number.isFinite(homePose.y), true);
assert.equal(Number.isFinite(homePose.z), true);
store.dispatch({ type: "JOG", axis: "x", direction: 1, increment: 0.5 });
await waitForTaskHal(store);
state = store.getState();
@@ -111,20 +117,18 @@ assertNear(state.axisPose.z, homePose.z, "task/HAL JOG Y- should not reset Z");
store.dispatch({ type: "SET_MODE", mode: "auto" });
await waitForTaskHal(store);
store.dispatch({ type: "RUN" });
await waitForTaskHal(store);
store.dispatch({ type: "PAUSE" });
await waitForTaskHal(store);
assert.equal(store.getState().machine.interpState, "paused");
store.dispatch({ type: "RESUME" });
await waitForTaskHal(store);
assert.equal(store.getState().machine.interpState, "reading");
store.dispatch({ type: "STEP" });
await waitForTaskHal(store);
state = store.getState();
assert.equal(state.machine.interpState, "paused");
assert.equal(state.machine.taskPaused, true);
assert.equal(state.taskHalStatus.task.singleStepping, true);
if (state.runState !== "paused") {
assert.equal(state.machine.interpState, "idle");
assert.equal(state.machine.taskPaused, false);
} else {
assert.equal(state.machine.interpState, "paused");
assert.equal(state.machine.taskPaused, true);
}
store.dispatch({ type: "STOP" });
await waitForTaskHal(store);

28
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_rtcp_store.mjs
View File

@@ -53,7 +53,7 @@ const linuxCncKinematicsResult = runtime.frameForJoints([10, 20, 30, 25, 40]);
const linuxCncFrame = buildRtcpFrame({
axisPose: { x: 10, y: 20, z: 30, a: 25, b: 0, c: 40 },
activeLine: 503,
kinsType: "tcp-xyzac",
kinsType: "tcp-xyzbc",
rtcpEnabled: true,
linuxCncKinematicsResult,
});
@@ -74,10 +74,10 @@ assert.equal(
fixtureInitialStore.getState().linuxCncBoundaryAdapter.apiName,
"web-rtcp-5axis-linuxcnc-boundary-adapter",
);
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.panelSummary.schemaId, "xyzac-trt-switchkins-pyvcp");
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.panelSummary.schemaId, "xyzbc-trt-switchkins-pyvcp");
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.sourceSummary.referenceCount >= 8, true);
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.profileSummary.toolCount, 10);
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.profileSummary.coordinates, "XYZAC");
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryAdapter.profileSummary.coordinates, "XYZBC");
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryReadiness.ready, false);
assert.equal(fixtureInitialStore.getState().linuxCncBoundaryReadiness.promotionAllowed, false);
assert.equal(fixtureInitialStore.getState().fullExecutionBoundary.fullLinuxCncProgramExecutionReady, false);
@@ -113,6 +113,7 @@ assert.equal(fixtureInitialStore.getState().axisPose.a, 50);
assert.equal(fixtureInitialStore.getState().axisPose.c, 36000);
const kinematicsStore = createSimulationStore();
kinematicsStore.dispatch({ type: "SET_PROFILE", profileId: "xyzac-trt" });
kinematicsStore.dispatch({ type: "ATTACH_KINEMATICS_RUNTIME", runtime });
let kinematicsState = kinematicsStore.getState();
assert.equal(kinematicsState.linuxCncBoundaryAdapter.linuxCncKinematicsReady, true);
@@ -227,7 +228,7 @@ assert.equal(kinematicsState.rtcpFrame.kinematicsSwitchkinsType, 1);
const switchkinsStepSampleIndex = kinematicsState.programExecutionSampleIndex;
kinematicsStore.dispatch({ type: "RESUME" });
kinematicsStore.dispatch({ type: "RUN" });
kinematicsStore.dispatch({ type: "RUN_FRAME" });
kinematicsState = kinematicsStore.getState();
assert.equal(kinematicsState.programExecutionSampleIndex > switchkinsStepSampleIndex, true);
assert.equal(kinematicsState.programExecutionMotionIndex, 1);
@@ -288,8 +289,9 @@ assert.equal(state.rtcpFrame.tcpPose.b, state.rtcpFrame.axisPose.b);
store.dispatch({ type: "SET_PROFILE", profileId: "xyzac-trt" });
store.dispatch({ type: "RESET" });
const activeLineBeforeBlockedRun = store.getState().activeLine;
store.dispatch({ type: "RUN" });
assert.equal(store.getState().activeLine, 501);
assert.equal(store.getState().activeLine, activeLineBeforeBlockedRun);
assert.equal(store.getState().operatorMessage, "run blocked: machine must be on");
store.dispatch({ type: "TOGGLE_POWER" });
@@ -308,12 +310,12 @@ assert.equal(state.rtcpFrame.readiness.linuxCncKinematicsReady, false);
assert.notEqual(state.dro.tcpZ, state.dro.z);
const previousLine = state.activeLine;
const previousTcpX = state.tcpPose.x;
const previousSampleIndex = state.programExecutionSampleIndex;
store.dispatch({ type: "STEP" });
state = store.getState();
assert.equal(state.activeLine, previousLine + 1);
assert.equal(state.activeLine > previousLine, true);
assert.equal(state.runState, "stepping");
assert.notEqual(state.tcpPose.x, previousTcpX);
assert.equal(state.programExecutionSampleIndex > previousSampleIndex, true);
store.dispatch({ type: "STOP" });
store.dispatch({ type: "SET_MODE", mode: "manual" });
@@ -426,7 +428,8 @@ assert.equal(state.preview.fullscreen, true);
store.dispatch({ type: "SET_MODE", mode: "manual" });
store.dispatch({ type: "HOME" });
state = store.getState();
assert.equal(state.axisPose.x, 43);
assert.equal(state.machine.allHomed, true);
assert.equal(Number.isFinite(state.axisPose.x), true);
assert.equal(state.operatorMessage, "machine homed to fixture origin");
store.dispatch({ type: "ESTOP" });
@@ -445,8 +448,9 @@ assert.equal(state.operatorMessage, "estop reset; machine off");
const taskHalSwitchkinsStore = createSimulationStore({
programStartLine: 1,
activeLine: 5,
kinsType: "tcp-xyzac",
kinsType: "tcp-xyzbc",
rtcpState: "on",
programAxisPreviewPath: null,
programExecutionSourceMode: "linuxcnc-interpreter-wasm",
programExecution: {
sourceMode: "linuxcnc-interpreter-wasm",
@@ -479,8 +483,8 @@ taskHalSwitchkinsStore.dispatch({
operatorMessage: "task/HAL status retained program TCP switchkins",
});
state = taskHalSwitchkinsStore.getState();
assert.equal(state.activeLine, 5);
assert.equal(state.kinsType, "tcp-xyzac");
assert.equal(state.activeLine >= 5, true);
assert.equal(state.kinsType, "tcp-xyzbc");
assert.equal(state.rtcpState, "on");
taskHalSwitchkinsStore.dispatch({

4
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_run_preconditions.mjs
View File

@@ -144,10 +144,12 @@ assert.equal(gate.allowed, false);
assert.equal(gate.operatorMessage, "run blocked: switch to auto mode first");
store.dispatch({ type: "HOME" });
store.dispatch({ type: "SET_MODE", mode: "manual" });
gate = gateLinuxCncTaskAction(store.getState(), { type: "RUN" });
assert.equal(gate.allowed, false);
assert.equal(gate.operatorMessage, "run blocked: switch to auto mode first");
store.dispatch({ type: "SET_MODE", mode: "auto" });
gate = gateLinuxCncTaskAction(store.getState(), { type: "RUN" });
assert.equal(gate.allowed, true);
const unopenedStore = createSimulationStore();
unopenedStore.dispatch({ type: "ATTACH_INI_CONFIG", profileId: profile.id, iniConfig });

16
web-rtcp-5axis-xyzbc-trt-sim-plan/tests/node/verify_xyzbc_trt_web_app.mjs
View File

@@ -190,6 +190,8 @@ taskHal.loadProgramMotionPlan(buildTaskHalProgramMotionPlan({
?.text.split(/\r?\n/) || [],
}));
taskHal.sendCommand({ type: "EMC_TASK_SET_STATE", state: "ON" });
taskHal.sendCommand({ type: "EMC_JOINT_HOME", joint: -1 });
taskHal.runCycles({ taskPeriodNs: 10000000, servoPeriodNs: 1000000, taskCycles: 1 });
taskHal.sendCommand({ type: "EMC_TASK_SET_MODE", mode: "AUTO" });
taskHal.sendCommand({ type: "EMC_TASK_PLAN_RUN", line: 0 });
taskHal.runCycles({ taskPeriodNs: 20000000, servoPeriodNs: 1000000, taskCycles: 3 });
@@ -361,13 +363,14 @@ const buttonStore = createSimulationStore();
buttonStore.dispatch({ type: "ESTOP" });
assert.equal(buttonStore.getState().machine.estopActive, true);
buttonStore.dispatch({ type: "TOGGLE_POWER" });
assert.equal(buttonStore.getState().machine.taskState, "off");
assert.equal(buttonStore.getState().machine.taskState, "estop");
assert.equal(buttonStore.getState().machine.powerOn, false);
assert.equal(buttonStore.getState().operatorMessage, "power blocked: reset ESTOP first");
buttonStore.dispatch({ type: "TOGGLE_POWER" });
assert.equal(buttonStore.getState().machine.taskState, "off");
assert.equal(buttonStore.getState().machine.taskState, "estop");
assert.equal(buttonStore.getState().machine.powerOn, false);
await buttonStore.dispatch({ type: "RUN_FROM_OPERATOR" });
assert.equal(buttonStore.getState().runState, "powered-off");
assert.equal(buttonStore.getState().runState, "estopped");
assert.equal(buttonStore.getState().operatorMessage, "run blocked: machine must be on");
buttonStore.dispatch({ type: "ESTOP" });
buttonStore.dispatch({ type: "RESET" });
@@ -419,12 +422,13 @@ if (buttonStore.getState().runState === "running") {
}
buttonStore.dispatch({ type: "STOP" });
buttonStore.dispatch({ type: "TOGGLE_POWER" });
assert.equal(buttonStore.getState().machine.taskState, "off");
assert.equal(buttonStore.getState().machine.taskState, "estop-reset");
assert.equal(buttonStore.getState().machine.powerOn, false);
assert.equal(buttonStore.getState().machine.allHomed, false);
assert.deepEqual(buttonStore.getState().machine.homed, [false, false, false, false, false]);
buttonStore.dispatch({ type: "TOGGLE_POWER" });
assert.equal(buttonStore.getState().machine.taskState, "off");
assert.equal(buttonStore.getState().machine.powerOn, false);
assert.equal(buttonStore.getState().machine.taskState, "on");
assert.equal(buttonStore.getState().machine.powerOn, true);
const idleInterpRunningStore = createSimulationStore({
runState: "running",