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

Validate AXIS task state flow

Browse Source
This commit is contained in:
wangdequan
2026-07-09 18:12:01 -04:00
parent f99ba2bbe8
commit f4b9911d45
57 changed files with 195248 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
wasm-port/tests/wasm/node/verify_task_hal_sdk.mjs
View File

@@ -32,6 +32,14 @@ function prepareHomedAuto() {
assert.equal(sdk.sendCommand({ type: "EMC_TASK_SET_MODE", mode: "AUTO" }), 0);
}
function assertNoLegacyStatusFields(status) {
assert.equal("taskTopLevelStatus" in status, false);
assert.equal("rcsStatus" in status, false);
assert.equal("task" in status, false);
assert.equal("servoCycle" in status, false);
assert.equal("motionStatus" in status, false);
}
sdk.initSession({
iniPath: "xyzac-trt.ini",
iniText: "[TRAJ]\nCOORDINATES = X Y Z A C\n",
@@ -43,42 +51,43 @@ assert.equal(sdk.sendCommand({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
assert.equal(sdk.runCycles({ taskCycles: 1 }), 0);
let status = sdk.readStatus();
assertNoLegacyStatusFields(status);
assert.equal(status.semanticBoundary, "linuxcnc_task_motion_hal_wasm_phase4_minimal");
assert.equal(status.taskRuntimeReady, true);
assert.equal(status.motionStatus.motion.programLine, 1);
assert.equal(status.motionStatus.axis.x, 3);
assert.equal(status.emcStatus.motion.programLine, 1);
assert.equal(status.emcStatus.motion.axisByName.x, 3);
assert.equal(status.halSnapshot.pins["motion.program-line"].value, 1);
assert.equal(status.task.motionPlanLoaded, false);
assert.equal(status.task.planId, 0);
assert.equal(status.emcStatus.task.motionPlanLoaded, false);
assert.equal(status.emcStatus.task.planId, 0);
assert.equal(status.emctaskSourceReuse.planReadCount > 0, true);
assert.equal(status.statusSource, "StandaloneEmcStatus");
assert.equal(status.schemaVersion, 1);
assert.equal(status.emcStatus.source, "StandaloneEmcStatus");
assert.equal(status.emcStatus.top.status, status.taskTopLevelStatus);
assert.equal(status.emcStatus.task.status, status.rcsStatus.task);
assert.equal(status.emcStatus.task.state, status.task.state);
assert.equal(status.emcStatus.task.mode, status.task.mode);
assert.equal(status.emcStatus.task.currentLine, status.task.currentLine);
assert.equal(status.emcStatus.task.readLine, status.task.readLine);
assert.equal(status.emcStatus.task.motionLine, status.task.motionLine);
assert.equal(status.emcStatus.motion.status, status.rcsStatus.motion);
assert.equal(status.emcStatus.motion.programLine, status.motionStatus.motion.programLine);
assert.equal(status.emcStatus.motion.traj.queue, status.motionStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.motionStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.motionStatus.motion.id);
assert.equal(status.emcStatus.motion.traj.actualPosition.x, status.motionStatus.axis.x);
assert.equal(status.emcStatus.motion.axisByName.x, status.motionStatus.axis.x);
assert.equal(typeof status.emcStatus.top.status, "string");
assert.equal(typeof status.emcStatus.task.status, "string");
assert.equal(status.emcStatus.task.state, "ON");
assert.equal(status.emcStatus.task.mode, "AUTO");
assert.equal(typeof status.emcStatus.task.currentLine, "number");
assert.equal(typeof status.emcStatus.task.readLine, "number");
assert.equal(typeof status.emcStatus.task.motionLine, "number");
assert.equal(typeof status.emcStatus.motion.status, "string");
assert.equal(typeof status.emcStatus.motion.programLine, "number");
assert.equal(status.emcStatus.motion.traj.queue, status.emcStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.emcStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.emcStatus.motion.motionId);
assert.equal(status.emcStatus.motion.traj.actualPosition.x, status.emcStatus.motion.axisByName.x);
assert.equal(typeof status.emcStatus.motion.axisByName.x, "number");
assert.equal(Array.isArray(status.emcStatus.motion.axis), true);
assert.equal(status.emcStatus.motion.axis[0].posFb, status.motionStatus.axis.x);
assert.equal(status.emcStatus.motion.joint[0].motorPosCmd, status.motionStatus.joint0.motorPosCmd);
assert.equal(status.emcStatus.io.status, status.rcsStatus.io);
assert.equal(status.emcStatus.motion.axis[0].posFb, status.emcStatus.motion.axisByName.x);
assert.equal(status.emcStatus.motion.joint[0].motorPosCmd, status.emcStatus.motion.joint0.motorPosCmd);
assert.equal(typeof status.emcStatus.io.status, "string");
assert.equal(status.emcStatus.io.tool.supported, false);
assert.equal(status.emcStatus.io.coolant.supported, false);
assert.equal(sdk.sendCommand({ type: "EMC_TASK_PLAN_EXECUTE", mdi: "M429" }), 0);
assert.equal(sdk.runCycles({ taskCycles: 1 }), 0);
status = sdk.readStatus();
assert.equal(status.motionStatus.motion.switchkinsType, 0);
assert.equal(status.emcStatus.motion.switchkinsType, 0);
assert.equal(status.emccanonSourceReuse.lastMotionOutputCommand, "SET_AUX_OUTPUT_VALUE");
assert.equal(status.emccanonSourceReuse.lastMotionOutputMessage, "EMC_MOTION_SET_AOUT");
assert.equal(status.emccanonSourceReuse.motionOutputTaskintfAoutCount > 0, true);
@@ -126,15 +135,15 @@ prepareHomedAuto();
assert.equal(sdk.sendCommand({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
assert.equal(sdk.runCycles({ taskCycles: 1, taskPeriodNs: 1000000000, servoPeriodNs: 1000000 }), 0);
status = sdk.readStatus();
assert.equal(status.motionStatus.motion.programLine, 1);
assert.equal(status.motionStatus.axis.x > 0 && status.motionStatus.axis.x < 2, true);
assert.equal(status.motionStatus.motion.currentVel, 1);
assert.equal(status.motionStatus.motion.currentVel !== 60, true);
assert.equal(status.emcStatus.motion.programLine, 1);
assert.equal(status.emcStatus.motion.axisByName.x > 0 && status.emcStatus.motion.axisByName.x < 2, true);
assert.equal(status.emcStatus.motion.currentVel, 1);
assert.equal(status.emcStatus.motion.currentVel !== 60, true);
assert.equal(sdk.runCycles({ taskCycles: 119, taskPeriodNs: 1000000000, servoPeriodNs: 1000000 }), 0);
status = sdk.readStatus();
assert.equal(status.motionStatus.motion.programLine, 2);
assert.equal(status.motionStatus.motion.currentVel, 10);
assert.equal(status.motionStatus.axis.x >= 120, true);
assert.equal(status.emcStatus.motion.programLine, 2);
assert.equal(status.emcStatus.motion.currentVel, 10);
assert.equal(status.emcStatus.motion.axisByName.x >= 120, true);
sdk.resetSession();
sdk.initSession({
@@ -181,19 +190,19 @@ prepareHomedAuto();
assert.equal(sdk.sendCommand({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
assert.equal(sdk.runCycles({ taskCycles: 1, taskPeriodNs: 500000000, servoPeriodNs: 1000000 }), 0);
status = sdk.readStatus();
assert.equal(status.task.openedLineCount, 6);
assert.equal(status.task.openedSourceLineCount, 6);
assert.equal(status.task.executableLineCount, 3);
assert.equal(status.motionStatus.motion.programLine, 3);
assert.equal(status.emcStatus.task.openedLineCount, 6);
assert.equal(status.emcStatus.task.openedSourceLineCount, 6);
assert.equal(status.emcStatus.task.executableLineCount, 3);
assert.equal(status.emcStatus.motion.programLine, 3);
assert.equal(status.halSnapshot.pins["motion.program-line"].value, 3);
assert.equal(sdk.runCycles({ taskCycles: 1, taskPeriodNs: 600000000, servoPeriodNs: 1000000 }), 0);
status = sdk.readStatus();
assert.equal(status.motionStatus.motion.programLine, 5);
assert.equal(status.emcStatus.motion.programLine, 5);
assert.equal(status.halSnapshot.pins["motion.program-line"].value, 5);
assert.equal(status.task.nextProgramLine, 5);
assert.equal(status.emcStatus.task.nextProgramLine, 5);
assert.equal(sdk.runCycles({ taskCycles: 1, taskPeriodNs: 1000000000, servoPeriodNs: 1000000 }), 0);
status = sdk.readStatus();
assert.equal(status.task.nextProgramLine, 6);
assert.equal(status.emcStatus.task.nextProgramLine, 6);
console.log("linuxcnc_task_hal_sdk=ok");
console.log("task_hal_sdk_status_snapshot=ok");

346
wasm-port/tests/wasm/node/verify_task_hal_wasm.mjs
View File

@@ -59,7 +59,9 @@ function sendMotion(command) {
}
function status() {
return readJson((outPtr, outLen) => runtime._lctask_read_status_json(outPtr, outLen));
const snapshot = readJson((outPtr, outLen) => runtime._lctask_read_status_json(outPtr, outLen));
assertNoLegacyStatusFields(snapshot);
return snapshot;
}
function motionStatus() {
@@ -70,6 +72,14 @@ function events() {
return readJson((outPtr, outLen) => runtime._lctask_read_events_json(outPtr, outLen)).events;
}
function assertNoLegacyStatusFields(snapshot) {
assert.equal("taskTopLevelStatus" in snapshot, false);
assert.equal("rcsStatus" in snapshot, false);
assert.equal("task" in snapshot, false);
assert.equal("servoCycle" in snapshot, false);
assert.equal("motionStatus" in snapshot, false);
}
const session = {
iniPath: "xyzac-trt.ini",
iniText: "[TRAJ]\nCOORDINATES = X Y Z A C\n",
@@ -112,48 +122,45 @@ assert.equal(snapshot.taskCommandsDriveMotionRuntime, true);
assert.equal(snapshot.nativeTaskReady, false);
assert.equal(snapshot.nativeHalSyncReady, false);
assert.equal(snapshot.fullLinuxCncProgramExecutionReady, false);
assert.equal(snapshot.taskTopLevelStatus, "EXEC");
assert.equal(snapshot.rcsStatus.top, "EXEC");
assert.equal(snapshot.rcsStatus.task, "EXEC");
assert.equal(snapshot.rcsStatus.motion, "DONE");
assert.equal(snapshot.rcsStatus.io, "DONE");
assert.equal(snapshot.emcStatus.top.status, "EXEC");
assert.equal(snapshot.emcStatus.task.status, "EXEC");
assert.equal(snapshot.emcStatus.motion.status, "DONE");
assert.equal(snapshot.emcStatus.io.status, "DONE");
assert.equal(snapshot.statusSource, "StandaloneEmcStatus");
assert.equal(snapshot.schemaVersion, 1);
assert.equal(snapshot.emcStatus.source, "StandaloneEmcStatus");
assert.equal(snapshot.emcStatus.valid, true);
assert.equal(snapshot.emcStatus.top.status, snapshot.taskTopLevelStatus);
assert.equal(snapshot.emcStatus.task.status, snapshot.rcsStatus.task);
assert.equal(snapshot.emcStatus.task.state, snapshot.task.state);
assert.equal(snapshot.emcStatus.task.mode, snapshot.task.mode);
assert.equal(snapshot.emcStatus.task.execState, snapshot.task.execState);
assert.equal(snapshot.emcStatus.task.currentLine, snapshot.task.currentLine);
assert.equal(snapshot.emcStatus.task.readLine, snapshot.task.readLine);
assert.equal(snapshot.emcStatus.task.motionLine, snapshot.task.motionLine);
assert.equal(snapshot.emcStatus.task.callLevel, snapshot.task.callLevel);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, snapshot.task.pendingCommandDepth);
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, snapshot.task.pendingExecuteMotionDepth);
assert.equal(snapshot.emcStatus.task.state, "ON");
assert.equal(snapshot.emcStatus.task.mode, "AUTO");
assert.equal(typeof snapshot.emcStatus.task.execState, "string");
assert.equal(typeof snapshot.emcStatus.task.currentLine, "number");
assert.equal(typeof snapshot.emcStatus.task.readLine, "number");
assert.equal(typeof snapshot.emcStatus.task.motionLine, "number");
assert.equal(typeof snapshot.emcStatus.task.callLevel, "number");
assert.equal(typeof snapshot.emcStatus.task.pendingCommandDepth, "number");
assert.equal(typeof snapshot.emcStatus.task.pendingExecuteMotionDepth, "number");
assert.equal(snapshot.emcStatus.motion.valid, true);
assert.equal(snapshot.emcStatus.motion.status, snapshot.rcsStatus.motion);
assert.equal(snapshot.emcStatus.motion.programLine, snapshot.motionStatus.motion.programLine);
assert.equal(snapshot.emcStatus.motion.motionId, snapshot.motionStatus.motion.motionId);
assert.equal(snapshot.emcStatus.motion.queueDepth, snapshot.motionStatus.queueDepth);
assert.equal(snapshot.emcStatus.motion.traj.queue, snapshot.motionStatus.motion.queueDepth);
assert.equal(snapshot.emcStatus.motion.traj.inpos, snapshot.motionStatus.motion.inPosition);
assert.equal(snapshot.emcStatus.motion.traj.id, snapshot.motionStatus.motion.id);
assert.equal(snapshot.emcStatus.motion.traj.activeQueue, snapshot.motionStatus.activeDepth);
assert.equal(snapshot.emcStatus.motion.traj.queueFull, snapshot.motionStatus.motion.queueFull);
assert.equal(snapshot.emcStatus.motion.traj.paused, snapshot.motionStatus.motion.paused);
assert.equal(snapshot.emcStatus.motion.traj.singleStepping, snapshot.motionStatus.motion.stepping);
assert.equal(snapshot.emcStatus.motion.traj.currentVel, snapshot.motionStatus.motion.currentVel);
assert.equal(snapshot.emcStatus.motion.traj.actualPosition.x, snapshot.motionStatus.axis.x);
assert.equal(snapshot.emcStatus.motion.axisByName.x, snapshot.motionStatus.axis.x);
assert.equal(typeof snapshot.emcStatus.motion.status, "string");
assert.equal(typeof snapshot.emcStatus.motion.programLine, "number");
assert.equal(typeof snapshot.emcStatus.motion.motionId, "number");
assert.equal(typeof snapshot.emcStatus.motion.queueDepth, "number");
assert.equal(snapshot.emcStatus.motion.traj.queue, snapshot.emcStatus.motion.queueDepth);
assert.equal(snapshot.emcStatus.motion.traj.inpos, snapshot.emcStatus.motion.inPosition);
assert.equal(snapshot.emcStatus.motion.traj.id, snapshot.emcStatus.motion.motionId);
assert.equal(snapshot.emcStatus.motion.traj.activeQueue, snapshot.emcStatus.motion.activeDepth);
assert.equal(snapshot.emcStatus.motion.traj.queueFull, snapshot.emcStatus.motion.queueFull);
assert.equal(snapshot.emcStatus.motion.traj.paused, snapshot.emcStatus.motion.paused);
assert.equal(snapshot.emcStatus.motion.traj.singleStepping, snapshot.emcStatus.motion.stepping);
assert.equal(snapshot.emcStatus.motion.traj.currentVel, snapshot.emcStatus.motion.currentVel);
assert.equal(snapshot.emcStatus.motion.traj.actualPosition.x, snapshot.emcStatus.motion.axisByName.x);
assert.equal(typeof snapshot.emcStatus.motion.axisByName.x, "number");
assert.equal(Array.isArray(snapshot.emcStatus.motion.axis), true);
assert.equal(Array.isArray(snapshot.emcStatus.motion.joint), true);
assert.equal(snapshot.emcStatus.motion.axis.length >= 5, true);
assert.equal(snapshot.emcStatus.motion.axis[0].posFb, snapshot.motionStatus.axis.x);
assert.equal(snapshot.emcStatus.motion.joint[0].motorPosCmd, snapshot.motionStatus.joint0.motorPosCmd);
assert.equal(snapshot.emcStatus.motion.joint[0].motorPosFb, snapshot.motionStatus.joint0.motorPosFb);
assert.equal(snapshot.emcStatus.io.status, snapshot.rcsStatus.io);
assert.equal(snapshot.emcStatus.motion.axis[0].posFb, snapshot.emcStatus.motion.axisByName.x);
assert.equal(snapshot.emcStatus.motion.joint[0].motorPosCmd, snapshot.emcStatus.motion.joint0.motorPosCmd);
assert.equal(snapshot.emcStatus.motion.joint[0].motorPosFb, snapshot.emcStatus.motion.joint0.motorPosFb);
assert.equal(typeof snapshot.emcStatus.io.status, "string");
assert.equal(snapshot.emcStatus.io.error, false);
assert.equal(snapshot.emcStatus.io.fault, false);
assert.equal(snapshot.emcStatus.io.reason, "");
@@ -178,7 +185,7 @@ assert.equal(
);
assert.equal(snapshot.emctaskSourceReuse.snapshotUpdateCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.updateInputSource, "motionSnapshot,ioSnapshot");
assert.equal(snapshot.task.taskPlanOpen, true);
assert.equal(snapshot.emcStatus.task.taskPlanOpen, true);
assert.equal(snapshot.emctaskSourceReuse.planIssueCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planSynchCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planOpenCount > 0, true);
@@ -253,97 +260,97 @@ assert.equal(
snapshot.emccanonSourceReuse.straightMotionAnchors,
"generate_fast_move,generate_move,STRAIGHT_TRAVERSE,STRAIGHT_FEED,EMC_TRAJ_LINEAR_MOVE,interp_list",
);
assert.equal(snapshot.task.state, "ON");
assert.equal(snapshot.task.mode, "AUTO");
assert.equal(snapshot.task.openedLineCount, 4);
assert.equal(snapshot.task.programOpen, true);
assert.equal(snapshot.task.motionPlanLoaded, false);
assert.equal(snapshot.task.planId, 0);
assert.equal(snapshot.task.allHomed, true);
assert.equal(Array.isArray(snapshot.task.homed), true);
assert.equal(snapshot.task.homed.every(Boolean), true);
assert.equal(snapshot.task.nextProgramLine >= 1, true);
assert.equal(snapshot.task.interpState, "READING");
assert.equal(snapshot.task.interpResumeState, "READING");
assert.equal(snapshot.emcStatus.task.state, "ON");
assert.equal(snapshot.emcStatus.task.mode, "AUTO");
assert.equal(snapshot.emcStatus.task.openedLineCount, 4);
assert.equal(snapshot.emcStatus.task.programOpen, true);
assert.equal(snapshot.emcStatus.task.motionPlanLoaded, false);
assert.equal(snapshot.emcStatus.task.planId, 0);
assert.equal(snapshot.emcStatus.task.allHomed, true);
assert.equal(Array.isArray(snapshot.emcStatus.task.homed), true);
assert.equal(snapshot.emcStatus.task.homed.every(Boolean), true);
assert.equal(snapshot.emcStatus.task.nextProgramLine >= 1, true);
assert.equal(snapshot.emcStatus.task.interpState, "READING");
assert.equal(snapshot.emcStatus.task.interpResumeState, "READING");
assert.equal(snapshot.emctaskSourceReuse.planReadCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planExecuteCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planCommandCount > 0, true);
assert.equal(snapshot.motionStatus.motion.programLine >= 1, true);
assert.equal(snapshot.motionStatus.motion.enabled, true);
assert.equal(snapshot.motionStatus.motion.nextMotionId >= 1, true);
assert.equal(snapshot.motionStatus.motion.queueDepth >= 0, true);
assert.equal(snapshot.motionStatus.motion.id > 0, true);
assert.equal(snapshot.motionStatus.motion.currentVel > 0, true);
assert.equal(snapshot.halSnapshot.pins["motion.program-line"].value, snapshot.motionStatus.motion.programLine);
assert.equal(snapshot.halSnapshot.pins["joint.0.motor-pos-cmd"].value, snapshot.motionStatus.axis.x);
assert.equal(snapshot.emcStatus.motion.programLine >= 1, true);
assert.equal(snapshot.emcStatus.motion.enabled, true);
assert.equal(snapshot.emcStatus.motion.nextMotionId >= 1, true);
assert.equal(snapshot.emcStatus.motion.queueDepth >= 0, true);
assert.equal(snapshot.emcStatus.motion.motionId > 0, true);
assert.equal(snapshot.emcStatus.motion.currentVel > 0, true);
assert.equal(snapshot.halSnapshot.pins["motion.program-line"].value, snapshot.emcStatus.motion.programLine);
assert.equal(snapshot.halSnapshot.pins["joint.0.motor-pos-cmd"].value, snapshot.emcStatus.motion.axisByName.x);
send({ type: "EMC_TASK_PLAN_PAUSE" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.task.interpState, "READING");
assert.equal(snapshot.motionStatus.motion.paused, false);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.task.interpState, "READING");
assert.equal(snapshot.emcStatus.motion.paused, false);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.task.interpResumeState), true);
assert.equal(snapshot.task.taskPaused, true);
assert.equal(snapshot.task.singleStepping, false);
assert.equal(snapshot.motionStatus.motion.paused, true);
assert.equal(snapshot.motionStatus.motion.currentVel, 0);
const pausedTaskLine = snapshot.task.nextProgramLine;
const pausedMotionLine = snapshot.motionStatus.motion.programLine;
const pausedMotionId = snapshot.motionStatus.motion.motionId;
const pausedQueueDepth = snapshot.motionStatus.commandQueueDepth;
const pausedAxis = { ...snapshot.motionStatus.axis };
assert.equal(snapshot.emcStatus.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.emcStatus.task.interpResumeState), true);
assert.equal(snapshot.emcStatus.task.taskPaused, true);
assert.equal(snapshot.emcStatus.task.singleStepping, false);
assert.equal(snapshot.emcStatus.motion.paused, true);
assert.equal(snapshot.emcStatus.motion.currentVel, 0);
const pausedTaskLine = snapshot.emcStatus.task.nextProgramLine;
const pausedMotionLine = snapshot.emcStatus.motion.programLine;
const pausedMotionId = snapshot.emcStatus.motion.motionId;
const pausedQueueDepth = snapshot.emcStatus.motion.commandQueueDepth;
const pausedAxis = { ...snapshot.emcStatus.motion.axisByName };
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 20), 0);
snapshot = status();
assert.equal(snapshot.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.task.interpResumeState), true);
assert.equal(snapshot.task.nextProgramLine, pausedTaskLine);
assert.equal(snapshot.motionStatus.motion.paused, true);
assert.equal(snapshot.motionStatus.motion.programLine, pausedMotionLine);
assert.equal(snapshot.motionStatus.motion.motionId, pausedMotionId);
assert.equal(snapshot.motionStatus.commandQueueDepth, pausedQueueDepth);
assert.deepEqual(snapshot.motionStatus.axis, pausedAxis);
assert.equal(snapshot.emcStatus.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.emcStatus.task.interpResumeState), true);
assert.equal(snapshot.emcStatus.task.nextProgramLine, pausedTaskLine);
assert.equal(snapshot.emcStatus.motion.paused, true);
assert.equal(snapshot.emcStatus.motion.programLine, pausedMotionLine);
assert.equal(snapshot.emcStatus.motion.motionId, pausedMotionId);
assert.equal(snapshot.emcStatus.motion.commandQueueDepth, pausedQueueDepth);
assert.deepEqual(snapshot.emcStatus.motion.axisByName, pausedAxis);
send({ type: "EMC_TASK_PLAN_RESUME" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.motionStatus.motion.paused, true);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.motion.paused, true);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(["READING", "IDLE"].includes(snapshot.task.interpState), true);
assert.equal(["READING", "IDLE"].includes(snapshot.task.interpResumeState), true);
assert.equal(snapshot.task.taskPaused, false);
assert.equal(snapshot.motionStatus.motion.paused, false);
assert.equal(snapshot.motionStatus.motion.programLine >= pausedMotionLine, true);
assert.equal(["READING", "IDLE"].includes(snapshot.emcStatus.task.interpState), true);
assert.equal(["READING", "IDLE"].includes(snapshot.emcStatus.task.interpResumeState), true);
assert.equal(snapshot.emcStatus.task.taskPaused, false);
assert.equal(snapshot.emcStatus.motion.paused, false);
assert.equal(snapshot.emcStatus.motion.programLine >= pausedMotionLine, true);
const motionIdBeforeStep = snapshot.motionStatus.motion.motionId;
const motionIdBeforeStep = snapshot.emcStatus.motion.motionId;
send({ type: "EMC_TASK_PLAN_PAUSE" });
send({ type: "EMC_TASK_PLAN_STEP" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 2);
assert.equal(snapshot.motionStatus.motion.motionId, motionIdBeforeStep);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 2);
assert.equal(snapshot.emcStatus.motion.motionId, motionIdBeforeStep);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.task.interpResumeState), true);
assert.equal(snapshot.task.taskPaused, true);
assert.equal(snapshot.task.singleStepping, false);
assert.equal(snapshot.motionStatus.motion.paused, true);
assert.equal(typeof snapshot.motionStatus.motion.stepping, "boolean");
assert.equal(snapshot.motionStatus.motion.programLine >= pausedMotionLine, true);
assert.equal(snapshot.motionStatus.motion.motionId > pausedMotionId, true);
assert.equal(snapshot.emcStatus.task.interpState, "PAUSED");
assert.equal(["READING", "IDLE"].includes(snapshot.emcStatus.task.interpResumeState), true);
assert.equal(snapshot.emcStatus.task.taskPaused, true);
assert.equal(snapshot.emcStatus.task.singleStepping, false);
assert.equal(snapshot.emcStatus.motion.paused, true);
assert.equal(typeof snapshot.emcStatus.motion.stepping, "boolean");
assert.equal(snapshot.emcStatus.motion.programLine >= pausedMotionLine, true);
assert.equal(snapshot.emcStatus.motion.motionId > pausedMotionId, true);
send({ type: "EMC_TASK_PLAN_RESUME" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.motionStatus.motion.paused, true);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.motion.paused, true);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.paused, false);
assert.equal(snapshot.motionStatus.motion.programLine >= pausedMotionLine, true);
assert.equal(snapshot.emcStatus.motion.paused, false);
assert.equal(snapshot.emcStatus.motion.programLine >= pausedMotionLine, true);
sendMotion({ type: "EMC_TRAJ_LINEAR_MOVE", line: 10, x: 10, y: 0, z: 0, velocity: 1 });
sendMotion({ type: "EMC_TRAJ_LINEAR_MOVE", line: 11, x: 11, y: 0, z: 0, velocity: 1 });
@@ -375,14 +382,14 @@ assert.equal(motionSnapshot.commandQueueDepth, 0);
send({ type: "EMC_TASK_PLAN_EXECUTE", mdi: "M428" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 0);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 0);
assert.equal(snapshot.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.motionStatus.motion.switchkinsType, 1);
assert.equal(snapshot.task.execState, "DONE");
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 0);
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.emcStatus.motion.switchkinsType, 1);
assert.equal(snapshot.emcStatus.task.execState, "DONE");
assert.equal(snapshot.halSnapshot.pins["motion.switchkins-type"].value, 1);
assert.equal(snapshot.taskintfSourceReuse.jogHomeSwitchkinsStructuredIssueCount >= 2, true);
assert.equal(snapshot.emccanonSourceReuse.motionOutputCount > 0, true);
@@ -396,11 +403,11 @@ assert.equal(snapshot.emccanonSourceReuse.lastMotionOutputNow, 1);
send({ type: "EMC_TASK_PLAN_EXECUTE", mdi: "M429" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.switchkinsType, 0);
assert.equal(snapshot.emcStatus.motion.switchkinsType, 0);
send({ type: "EMC_TASK_PLAN_EXECUTE", mdi: "M430" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.switchkinsType, 2);
assert.equal(snapshot.emcStatus.motion.switchkinsType, 2);
assert.equal(snapshot.emccanonSourceReuse.lastMotionOutputCommand, "SET_AUX_OUTPUT_VALUE");
assert.equal(snapshot.emccanonSourceReuse.lastMotionOutputValue, 2);
send({ type: "EMC_TASK_PLAN_EXECUTE", mdi: "M62 P1" });
@@ -470,25 +477,25 @@ assert.equal(
snapshot.emccanonSourceReuse.spindleToolAnchors,
"SET_SPINDLE_SPEED,START_SPINDLE_CLOCKWISE,START_SPINDLE_COUNTERCLOCKWISE,STOP_SPINDLE_TURNING,EMC_SPINDLE_SPEED,EMC_SPINDLE_ON,EMC_SPINDLE_OFF,SELECT_TOOL,CHANGE_TOOL,CHANGE_TOOL_NUMBER,RELOAD_TOOLDATA,EMC_TOOL_PREPARE,EMC_TOOL_LOAD,EMC_TOOL_SET_NUMBER,EMC_TOOL_LOAD_TOOL_TABLE,interp_list",
);
const xBeforeJog = snapshot.motionStatus.axis.x;
const xBeforeJog = snapshot.emcStatus.motion.axisByName.x;
send({ type: "EMC_JOG_INCR", axis: "X", distance: 0.25, velocity: 60 });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.motionStatus.axis.x, xBeforeJog);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.motion.axisByName.x, xBeforeJog);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 0);
assert.equal(snapshot.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.motionStatus.axis.x, xBeforeJog + 0.25);
assert.equal(snapshot.motionStatus.motion.teleopMode, 1);
assert.equal(snapshot.task.execState, "DONE");
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 0);
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.emcStatus.motion.axisByName.x, xBeforeJog + 0.25);
assert.equal(snapshot.emcStatus.motion.teleopMode, 1);
assert.equal(snapshot.emcStatus.task.execState, "DONE");
send({ type: "EMC_TASK_ABORT" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "DONE");
assert.equal(snapshot.motionStatus.motion.aborted, true);
assert.equal(snapshot.emcStatus.task.execState, "DONE");
assert.equal(snapshot.emcStatus.motion.aborted, true);
assert.equal(snapshot.taskintfMotionBridge.abortCount > 0, true);
const eventLog = events();
@@ -518,10 +525,10 @@ motionSnapshot = motionStatus();
assert.equal(motionSnapshot.motion.programLine, 21);
assert.equal(motionSnapshot.motion.motionId, 21);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.programLine, idleTaskSnapshot.motionStatus.motion.programLine);
assert.equal(snapshot.emcStatus.motion.programLine, idleTaskSnapshot.emcStatus.motion.programLine);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.programLine, 21);
assert.equal(snapshot.emcStatus.motion.programLine, 21);
assert.equal(runtime._lcmot_write_aout(0, 2, 2, 1), 0);
assert.equal(runtime._lcmot_step_servo(1000000, 1), 0);
motionSnapshot = motionStatus();
@@ -550,33 +557,32 @@ motionSnapshot = motionStatus();
assert.equal(motionSnapshot.commandQueueDepth, 64);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.motionStatus.motion.queueFull, true);
assert.equal(snapshot.emcStatus.motion.queueFull, true);
send({ type: "EMC_JOG_INCR", axis: "X", distance: 0.25, velocity: 60 });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "WAITING_FOR_MOTION_QUEUE");
assert.equal(snapshot.task.pendingExecuteMotionDepth, 1);
assert.equal(snapshot.motionStatus.motion.queueFull, true);
assert.equal(snapshot.emcStatus.task.execState, "WAITING_FOR_MOTION_QUEUE");
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 1);
assert.equal(snapshot.emcStatus.motion.queueFull, true);
sendMotion({ type: "EMCMOT_RESUME" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "WAITING_FOR_MOTION");
assert.equal(snapshot.task.pendingExecuteMotionDepth, 1);
assert.equal(snapshot.motionStatus.motion.queueFull, false);
assert.equal(snapshot.emcStatus.task.execState, "WAITING_FOR_MOTION");
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 1);
assert.equal(snapshot.emcStatus.motion.queueFull, false);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 50), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "DONE");
assert.equal(snapshot.task.status, "DONE");
assert.equal(snapshot.taskTopLevelStatus, "DONE");
assert.equal(snapshot.rcsStatus.top, "DONE");
assert.equal(snapshot.rcsStatus.task, "DONE");
assert.equal(snapshot.rcsStatus.motion, "DONE");
assert.equal(snapshot.rcsStatus.io, "DONE");
assert.equal(snapshot.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.motionStatus.commandQueueDepth, 0);
assert.equal(snapshot.emcStatus.task.execState, "DONE");
assert.equal(snapshot.emcStatus.task.status, "DONE");
assert.equal(snapshot.emcStatus.top.status, "DONE");
assert.equal(snapshot.emcStatus.task.status, "DONE");
assert.equal(snapshot.emcStatus.motion.status, "DONE");
assert.equal(snapshot.emcStatus.io.status, "DONE");
assert.equal(snapshot.emcStatus.task.pendingExecuteMotionDepth, 0);
assert.equal(snapshot.emcStatus.motion.commandQueueDepth, 0);
const queueEvents = events();
assert.equal(queueEvents.includes("task_waiting_for_motion_queue"), true);
assert.equal(queueEvents.includes("task_motion_queue_available"), true);
@@ -590,14 +596,13 @@ assert.equal(
sendMotion({ type: "EMCMOT_ABORT" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "ERROR");
assert.equal(snapshot.task.errorText, "MOTION_ABORTED");
assert.equal(snapshot.taskTopLevelStatus, "ERROR");
assert.equal(snapshot.rcsStatus.top, "ERROR");
assert.equal(snapshot.rcsStatus.task, "ERROR");
assert.equal(snapshot.rcsStatus.motion, "ERROR");
assert.equal(snapshot.rcsStatus.io, "DONE");
assert.equal(snapshot.motionStatus.motion.aborted, true);
assert.equal(snapshot.emcStatus.task.execState, "ERROR");
assert.equal(snapshot.emcStatus.task.errorText, "MOTION_ABORTED");
assert.equal(snapshot.emcStatus.top.status, "ERROR");
assert.equal(snapshot.emcStatus.task.status, "ERROR");
assert.equal(snapshot.emcStatus.motion.status, "ERROR");
assert.equal(snapshot.emcStatus.io.status, "DONE");
assert.equal(snapshot.emcStatus.motion.aborted, true);
assert.equal(snapshot.taskintfMotionBridge.lastErrorText, "MOTION_ABORTED");
const motionErrorEvents = events();
assert.equal(motionErrorEvents.includes("task_motion_error:MOTION_ABORTED"), true);
@@ -610,15 +615,13 @@ assert.equal(
sendMotion({ type: "EMCMOT_INJECT_ERROR" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "ERROR");
assert.equal(snapshot.task.errorText, "MOTION_ERROR");
assert.equal(snapshot.taskTopLevelStatus, "ERROR");
assert.equal(snapshot.rcsStatus.top, "ERROR");
assert.equal(snapshot.rcsStatus.task, "ERROR");
assert.equal(snapshot.rcsStatus.motion, "ERROR");
assert.equal(snapshot.rcsStatus.io, "DONE");
assert.equal(snapshot.motionStatus.motion.status, 2);
assert.equal(snapshot.motionStatus.motion.motionError, true);
assert.equal(snapshot.emcStatus.task.execState, "ERROR");
assert.equal(snapshot.emcStatus.task.errorText, "MOTION_ERROR");
assert.equal(snapshot.emcStatus.top.status, "ERROR");
assert.equal(snapshot.emcStatus.task.status, "ERROR");
assert.equal(snapshot.emcStatus.motion.status, "ERROR");
assert.equal(snapshot.emcStatus.io.status, "DONE");
assert.equal(snapshot.emcStatus.motion.motionError, true);
assert.equal(snapshot.taskintfMotionBridge.lastErrorText, "MOTION_ERROR");
const injectedMotionErrorEvents = events();
assert.equal(injectedMotionErrorEvents.includes("task_motion_error:MOTION_ERROR"), true);
@@ -631,15 +634,13 @@ assert.equal(
sendMotion({ type: "EMCMOT_INJECT_SOFT_LIMIT", axis: "X" });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "ERROR");
assert.equal(snapshot.task.errorText, "MOTION_SOFT_LIMIT");
assert.equal(snapshot.taskTopLevelStatus, "ERROR");
assert.equal(snapshot.rcsStatus.top, "ERROR");
assert.equal(snapshot.rcsStatus.task, "ERROR");
assert.equal(snapshot.rcsStatus.motion, "ERROR");
assert.equal(snapshot.rcsStatus.io, "DONE");
assert.equal(snapshot.motionStatus.motion.status, 2);
assert.equal(snapshot.motionStatus.motion.onSoftLimit, true);
assert.equal(snapshot.emcStatus.task.execState, "ERROR");
assert.equal(snapshot.emcStatus.task.errorText, "MOTION_SOFT_LIMIT");
assert.equal(snapshot.emcStatus.top.status, "ERROR");
assert.equal(snapshot.emcStatus.task.status, "ERROR");
assert.equal(snapshot.emcStatus.motion.status, "ERROR");
assert.equal(snapshot.emcStatus.io.status, "DONE");
assert.equal(snapshot.emcStatus.motion.onSoftLimit, true);
assert.equal(snapshot.taskintfMotionBridge.lastErrorText, "MOTION_SOFT_LIMIT");
const softLimitEvents = events();
assert.equal(softLimitEvents.includes("task_motion_error:MOTION_SOFT_LIMIT"), true);
@@ -651,16 +652,15 @@ assert.equal(
);
send({ type: "EMC_IO_INJECT_ERROR" });
snapshot = status();
assert.equal(snapshot.task.pendingCommandDepth, 1);
assert.equal(snapshot.emcStatus.task.pendingCommandDepth, 1);
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 1), 0);
snapshot = status();
assert.equal(snapshot.task.execState, "ERROR");
assert.equal(snapshot.task.errorText, "IO_ERROR");
assert.equal(snapshot.taskTopLevelStatus, "ERROR");
assert.equal(snapshot.rcsStatus.top, "ERROR");
assert.equal(snapshot.rcsStatus.task, "ERROR");
assert.equal(snapshot.rcsStatus.motion, "DONE");
assert.equal(snapshot.rcsStatus.io, "ERROR");
assert.equal(snapshot.emcStatus.task.execState, "ERROR");
assert.equal(snapshot.emcStatus.task.errorText, "IO_ERROR");
assert.equal(snapshot.emcStatus.top.status, "ERROR");
assert.equal(snapshot.emcStatus.task.status, "ERROR");
assert.equal(snapshot.emcStatus.motion.status, "DONE");
assert.equal(snapshot.emcStatus.io.status, "ERROR");
const ioErrorEvents = events();
assert.equal(ioErrorEvents.includes("task_io_error_injected"), true);
assert.equal(ioErrorEvents.includes("task_io_error:IO_ERROR"), true);
@@ -687,9 +687,9 @@ send({ type: "EMC_TASK_SET_MODE", mode: "AUTO" });
send({ type: "EMC_TASK_PLAN_RUN", line: 0 });
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, 6), 0);
snapshot = status();
assert.equal(snapshot.task.motionPlanLoaded, false);
assert.equal(snapshot.task.execState, "DONE");
assert.equal(snapshot.task.nextProgramLine >= 1, true);
assert.equal(snapshot.emcStatus.task.motionPlanLoaded, false);
assert.equal(snapshot.emcStatus.task.execState, "DONE");
assert.equal(snapshot.emcStatus.task.nextProgramLine >= 1, true);
assert.equal(snapshot.emctaskSourceReuse.planReadCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planExecuteCount > 0, true);
assert.equal(snapshot.emctaskSourceReuse.planLineCount > 0, true);

97
wasm-port/tests/wasm/node/verify_task_state_matrix.mjs
View File

@@ -43,7 +43,9 @@ function readStatus() {
const ptr = runtime._malloc(bytes);
try {
assert.equal(runtime._lctask_read_status_json(ptr, bytes), 0);
return JSON.parse(runtime.UTF8ToString(ptr));
const status = JSON.parse(runtime.UTF8ToString(ptr));
assertNoLegacyStatusFields(status);
return status;
} finally {
runtime._free(ptr);
}
@@ -103,29 +105,38 @@ function runTaskCycles(cycles = 1) {
assert.equal(runtime._lctask_run_cycles(10000000, 1000000, cycles), 0);
}
function assertNoLegacyStatusFields(status) {
assert.equal("taskTopLevelStatus" in status, false);
assert.equal("rcsStatus" in status, false);
assert.equal("task" in status, false);
assert.equal("servoCycle" in status, false);
assert.equal("motionStatus" in status, false);
}
function assertStandaloneEmcStatus(status) {
assertNoLegacyStatusFields(status);
assert.equal(status.statusSource, "StandaloneEmcStatus");
assert.equal(status.schemaVersion, 1);
assert.equal(status.emcStatus.source, "StandaloneEmcStatus");
assert.equal(status.emcStatus.valid, true);
assert.equal(status.emcStatus.top.status, status.taskTopLevelStatus);
assert.equal(status.emcStatus.task.status, status.rcsStatus.task);
assert.equal(status.emcStatus.task.state, status.task.state);
assert.equal(status.emcStatus.task.mode, status.task.mode);
assert.equal(status.emcStatus.task.currentLine, status.task.currentLine);
assert.equal(status.emcStatus.task.readLine, status.task.readLine);
assert.equal(status.emcStatus.task.motionLine, status.task.motionLine);
assert.equal(status.emcStatus.task.pendingCommandDepth, status.task.pendingCommandDepth);
assert.equal(status.emcStatus.motion.status, status.rcsStatus.motion);
assert.equal(typeof status.emcStatus.top.status, "string");
assert.equal(typeof status.emcStatus.task.status, "string");
assert.equal(typeof status.emcStatus.task.state, "string");
assert.equal(typeof status.emcStatus.task.mode, "string");
assert.equal(typeof status.emcStatus.task.currentLine, "number");
assert.equal(typeof status.emcStatus.task.readLine, "number");
assert.equal(typeof status.emcStatus.task.motionLine, "number");
assert.equal(typeof status.emcStatus.task.pendingCommandDepth, "number");
assert.equal(typeof status.emcStatus.motion.status, "string");
assert.equal(status.emcStatus.motion.valid, true);
assert.equal(status.emcStatus.motion.programLine, status.motionStatus.motion.programLine);
assert.equal(status.emcStatus.motion.queueDepth, status.motionStatus.queueDepth);
assert.equal(status.emcStatus.motion.traj.queue, status.motionStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.motionStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.motionStatus.motion.id);
assert.equal(typeof status.emcStatus.motion.programLine, "number");
assert.equal(typeof status.emcStatus.motion.queueDepth, "number");
assert.equal(status.emcStatus.motion.traj.queue, status.emcStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.emcStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.emcStatus.motion.motionId);
assert.equal(Array.isArray(status.emcStatus.motion.axis), true);
assert.equal(Array.isArray(status.emcStatus.motion.joint), true);
assert.equal(status.emcStatus.io.status, status.rcsStatus.io);
assert.equal(typeof status.emcStatus.io.status, "string");
assert.equal(typeof status.emcStatus.io.aux.estop, "boolean");
assert.equal(status.emcStatus.io.tool.supported, false);
assert.equal(status.emcStatus.io.coolant.supported, false);
@@ -137,24 +148,24 @@ function assertRejected(name, setup, expectedError) {
const rc = commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 });
assert.equal(rc, 0, name);
runTaskCycles();
assert.equal(readStatus().task.errorText, expectedError, name);
assert.equal(readStatus().emcStatus.task.errorText, expectedError, name);
}
reset();
let queuedStatus = readStatus();
assertStandaloneEmcStatus(queuedStatus);
assert.equal(queuedStatus.task.state, "ESTOP_RESET");
assert.equal(queuedStatus.emcStatus.task.state, "ESTOP_RESET");
assert.equal(commandRc({ type: "EMC_TASK_SET_STATE", state: "ON" }), 0);
queuedStatus = readStatus();
assert.equal(queuedStatus.task.state, "ESTOP_RESET");
assert.equal(queuedStatus.task.pendingCommandDepth, 1);
assert.equal(queuedStatus.emcStatus.task.state, "ESTOP_RESET");
assert.equal(queuedStatus.emcStatus.task.pendingCommandDepth, 1);
assert.equal(commandRc({ type: "UNSUPPORTED_HOST_COMMAND" }), -1);
queuedStatus = readStatus();
assert.equal(queuedStatus.task.pendingCommandDepth, 1);
assert.equal(queuedStatus.emcStatus.task.pendingCommandDepth, 1);
runTaskCycles();
queuedStatus = readStatus();
assert.equal(queuedStatus.task.state, "ON");
assert.equal(queuedStatus.task.pendingCommandDepth, 0);
assert.equal(queuedStatus.emcStatus.task.state, "ON");
assert.equal(queuedStatus.emcStatus.task.pendingCommandDepth, 0);
assertRejected("ESTOP blocks run", () => {
stageAndOpenProgram();
@@ -197,7 +208,7 @@ runTaskCycles();
assert.equal(commandRc({ type: "EMC_TASK_SET_MODE", mode: "AUTO" }), 0);
assert.equal(commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
runTaskCycles();
assert.equal(readStatus().task.errorText, "PROGRAM_OPEN_REQUIRED");
assert.equal(readStatus().emcStatus.task.errorText, "PROGRAM_OPEN_REQUIRED");
reset();
stageAndOpenProgram();
@@ -208,8 +219,8 @@ assert.equal(commandRc({ type: "EMC_TASK_SET_MODE", mode: "AUTO" }), 0);
assert.equal(commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
runTaskCycles(4);
const noJsonPlanStatus = readStatus();
assert.equal(noJsonPlanStatus.task.errorText, "");
assert.equal(noJsonPlanStatus.task.motionPlanLoaded, false);
assert.equal(noJsonPlanStatus.emcStatus.task.errorText, "");
assert.equal(noJsonPlanStatus.emcStatus.task.motionPlanLoaded, false);
assert.equal(noJsonPlanStatus.emctaskSourceReuse.planReadCount > 0, true);
assert.equal(noJsonPlanStatus.emctaskSourceReuse.planExecuteCount > 0, true);
assert.equal(noJsonPlanStatus.emctaskSourceReuse.interpListAppendCount > 0, true);
@@ -223,17 +234,17 @@ assert.equal(commandRc({ type: "EMC_TASK_SET_MODE", mode: "AUTO" }), 0);
assert.equal(commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
runTaskCycles();
let status = readStatus();
assert.equal(status.task.mode, "AUTO");
assert.equal(["READING", "IDLE"].includes(status.task.interpState), true);
assert.equal(status.task.taskPaused, false);
assert.equal(status.task.singleStepping, false);
assert.equal(status.task.programOpen, true);
assert.equal(status.task.motionPlanLoaded, false);
assert.equal(status.task.allHomed, true);
assert.equal(Array.isArray(status.task.homed), true);
assert.equal(status.task.homed.every(Boolean), true);
assert.equal(status.task.planId, 0);
assert.equal(status.task.errorText, "");
assert.equal(status.emcStatus.task.mode, "AUTO");
assert.equal(["READING", "IDLE"].includes(status.emcStatus.task.interpState), true);
assert.equal(status.emcStatus.task.taskPaused, false);
assert.equal(status.emcStatus.task.singleStepping, false);
assert.equal(status.emcStatus.task.programOpen, true);
assert.equal(status.emcStatus.task.motionPlanLoaded, false);
assert.equal(status.emcStatus.task.allHomed, true);
assert.equal(Array.isArray(status.emcStatus.task.homed), true);
assert.equal(status.emcStatus.task.homed.every(Boolean), true);
assert.equal(status.emcStatus.task.planId, 0);
assert.equal(status.emcStatus.task.errorText, "");
reset();
stageAndOpenProgram({ loadPlan: true });
@@ -244,8 +255,8 @@ assert.equal(commandRc({ type: "EMC_TASK_SET_MODE", mode: "AUTO" }), 0);
assert.equal(commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
runTaskCycles();
status = readStatus();
assert.equal(status.task.motionPlanLoaded, true);
assert.equal(status.task.planId > 0, true);
assert.equal(status.emcStatus.task.motionPlanLoaded, true);
assert.equal(status.emcStatus.task.planId > 0, true);
reset({ noForceHoming: true });
stageAndOpenProgram();
@@ -255,10 +266,10 @@ assert.equal(commandRc({ type: "EMC_TASK_PLAN_RUN", line: 0 }), 0);
runTaskCycles();
status = readStatus();
assertStandaloneEmcStatus(status);
assert.equal(status.task.noForceHoming, true);
assert.equal(status.task.allHomed, false);
assert.equal(status.task.homed.every(Boolean), false);
assert.equal(["READING", "IDLE"].includes(status.task.interpState), true);
assert.equal(status.emcStatus.task.noForceHoming, true);
assert.equal(status.emcStatus.task.allHomed, false);
assert.equal(status.emcStatus.task.homed.every(Boolean), false);
assert.equal(["READING", "IDLE"].includes(status.emcStatus.task.interpState), true);
console.log("task_state_matrix=ok");
console.log("run_gate_estop_rejected=ok");

50
wasm-port/tests/wasm/node/verify_task_status_json_contract.mjs
View File

@@ -38,12 +38,22 @@ function readStatus() {
const ptr = runtime._malloc(bytes);
try {
assert.equal(runtime._lctask_read_status_json(ptr, bytes), 0);
return JSON.parse(runtime.UTF8ToString(ptr));
const status = JSON.parse(runtime.UTF8ToString(ptr));
assertNoLegacyStatusFields(status);
return status;
} finally {
runtime._free(ptr);
}
}
function assertNoLegacyStatusFields(status) {
assert.equal("taskTopLevelStatus" in status, false);
assert.equal("rcsStatus" in status, false);
assert.equal("task" in status, false);
assert.equal("servoCycle" in status, false);
assert.equal("motionStatus" in status, false);
}
assert.equal(callJson("lctask_init_session", {
iniPath: "status-json-contract.ini",
iniText: "[TRAJ]\nCOORDINATES = X Y Z A B C\n",
@@ -71,35 +81,35 @@ const status = readStatus();
assert.equal(status.statusSource, "StandaloneEmcStatus");
assert.equal(status.schemaVersion, 1);
assert.equal(status.emcStatus.source, "StandaloneEmcStatus");
assert.equal(status.emcStatus.top.status, status.taskTopLevelStatus);
assert.equal(typeof status.emcStatus.top.status, "string");
assert.equal(status.emcStatus.task.currentLine, status.task.currentLine);
assert.equal(status.emcStatus.task.readLine, status.task.readLine);
assert.equal(status.emcStatus.task.motionLine, status.task.motionLine);
assert.equal(status.emcStatus.task.callLevel, status.task.callLevel);
assert.equal(typeof status.emcStatus.task.currentLine, "number");
assert.equal(typeof status.emcStatus.task.readLine, "number");
assert.equal(typeof status.emcStatus.task.motionLine, "number");
assert.equal(typeof status.emcStatus.task.callLevel, "number");
assert.equal(status.emcStatus.motion.traj.queue, status.motionStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.motionStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.motionStatus.motion.id);
assert.equal(status.emcStatus.motion.traj.activeQueue, status.motionStatus.activeDepth);
assert.equal(status.emcStatus.motion.traj.queueFull, status.motionStatus.motion.queueFull);
assert.equal(status.emcStatus.motion.traj.paused, status.motionStatus.motion.paused);
assert.equal(status.emcStatus.motion.traj.singleStepping, status.motionStatus.motion.stepping);
assert.equal(status.emcStatus.motion.traj.actualPosition.x, status.motionStatus.axis.x);
assert.equal(status.emcStatus.motion.traj.queue, status.emcStatus.motion.queueDepth);
assert.equal(status.emcStatus.motion.traj.inpos, status.emcStatus.motion.inPosition);
assert.equal(status.emcStatus.motion.traj.id, status.emcStatus.motion.motionId);
assert.equal(status.emcStatus.motion.traj.activeQueue, status.emcStatus.motion.activeDepth);
assert.equal(status.emcStatus.motion.traj.queueFull, status.emcStatus.motion.queueFull);
assert.equal(status.emcStatus.motion.traj.paused, status.emcStatus.motion.paused);
assert.equal(status.emcStatus.motion.traj.singleStepping, status.emcStatus.motion.stepping);
assert.equal(status.emcStatus.motion.traj.actualPosition.x, status.emcStatus.motion.axisByName.x);
assert.equal(status.emcStatus.motion.traj.position.x, status.emcStatus.motion.axis[0].posCmd);
assert.equal(status.emcStatus.motion.traj.currentVel, status.motionStatus.motion.currentVel);
assert.equal(status.emcStatus.motion.traj.currentVel, status.emcStatus.motion.currentVel);
assert.equal(Array.isArray(status.emcStatus.motion.axis), true);
assert.equal(Array.isArray(status.emcStatus.motion.joint), true);
assert.equal(status.emcStatus.motion.axis.length >= 6, true);
assert.equal(status.emcStatus.motion.joint.length >= 6, true);
assert.equal(status.emcStatus.motion.axis[0].letter, "X");
assert.equal(status.emcStatus.motion.axis[0].posFb, status.motionStatus.axis.x);
assert.equal(status.emcStatus.motion.axis[1].posFb, status.motionStatus.axis.y);
assert.equal(status.emcStatus.motion.joint[0].motorPosCmd, status.motionStatus.joint0.motorPosCmd);
assert.equal(status.emcStatus.motion.joint[0].motorPosFb, status.motionStatus.joint0.motorPosFb);
assert.equal(status.emcStatus.motion.axis[0].posFb, status.emcStatus.motion.axisByName.x);
assert.equal(status.emcStatus.motion.axis[1].posFb, status.emcStatus.motion.axisByName.y);
assert.equal(status.emcStatus.motion.joint[0].motorPosCmd, status.emcStatus.motion.joint0.motorPosCmd);
assert.equal(status.emcStatus.motion.joint[0].motorPosFb, status.emcStatus.motion.joint0.motorPosFb);
assert.equal(status.emcStatus.io.status, status.rcsStatus.io);
assert.equal(typeof status.emcStatus.io.status, "string");
assert.equal(status.emcStatus.io.fault, status.emcStatus.io.error);
assert.equal(status.emcStatus.io.reason, "");
assert.equal(typeof status.emcStatus.io.aux.estop, "boolean");