200 lines
11 KiB
JavaScript
200 lines
11 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { readFile, writeFile } from "node:fs/promises";
|
|
import { createHash } from "node:crypto";
|
|
import { join, resolve } from "node:path";
|
|
import createModule from "../build-wasm/linuxcnc-sim-core.js";
|
|
import { loadSimulationCase, toWorkerConfiguration } from "../web/workspace/sim-case-loader.mjs";
|
|
import { XyzacSession, CONTEXT_ID } from "../web/worker/xyzac-session.mjs";
|
|
|
|
const ROOT = resolve(process.cwd());
|
|
const CASE = "linuxcnc/configs/sim/axis/vismach/5axis/table-rotary-tilting/xyzac-trt.ini";
|
|
const PROGRAM = "linuxcnc/configs/sim/axis/vismach/5axis/table-rotary-tilting/demos/xyzac_switchkins.ngc";
|
|
const SCHEMA = "xyzac-wasm-linuxcnc-tick-trace.v1";
|
|
const AXES = ["x", "y", "z", "a", "b", "c", "u", "v", "w"];
|
|
|
|
const sha256 = (value) => createHash("sha256").update(value).digest("hex");
|
|
const canonical = (value) => JSON.stringify(value, Object.keys(value).sort());
|
|
const poseArray = (pose) => Array.isArray(pose) ? pose.slice(0, 9).map(Number) : AXES.map((axis) => Number(pose?.[axis] ?? 0));
|
|
const modeCode = (mode) => ({ MANUAL: 1, AUTO: 2, MDI: 3 }[mode] ?? null);
|
|
const taskStateCode = (state) => ({ ESTOP: 1, ESTOP_RESET: 2, OFF: 3, READY: 4, RUNNING: 4, PAUSED: 4, STOPPED: 4 }[state] ?? null);
|
|
const interpCode = (status) => ({ idle: 1, loaded: 1, running: 2, paused: 3, completed: 1, aborted: 1, fault: 1 }[status] ?? null);
|
|
const execCode = (status, queueDepth) => (status === "running" ? 3 : Number(queueDepth) > 0 ? 3 : ({ paused: 2, loaded: 2, completed: 2, aborted: 2, idle: 2, fault: 4 }[status] ?? null));
|
|
|
|
function rowFrom(state, task, program, tick, feedbackPose = null, feedbackJoints = null, lineOverride = null, currentLineOverride = null) {
|
|
const position = state?.position ?? {};
|
|
const motion = task?.motion ?? {};
|
|
const visual = task?.visual ?? {};
|
|
const limits = motion.limits ?? {};
|
|
const hasPlannerJoints = Array.isArray(state?.joint_commanded);
|
|
const joints = hasPlannerJoints ? state.joint_commanded : Array.isArray(visual.joints) ? visual.joints : Array.isArray(motion.joints) ? motion.joints : [];
|
|
const canonicalJoints = !hasPlannerJoints && Number(state?.active_tag ?? 0) === 0 && joints.every((value) => Math.abs(Number(value)) < 1e-15)
|
|
? [Number(position.x ?? 0), Number(position.y ?? 0), Number(position.z ?? 0), Number(position.a ?? 0), Number(position.c ?? 0)]
|
|
: joints;
|
|
const homedAxes = Array.isArray(motion.homed_axes) ? motion.homed_axes : [];
|
|
const motionLine = lineOverride !== null ? Number(lineOverride) : Number(state?.active_id ?? 0) > 0 ? Number(state.active_id) : Number(program?.execution_source_line ?? program?.current_line ?? 0);
|
|
const currentLine = currentLineOverride !== null ? Number(currentLineOverride) : motionLine;
|
|
const feedbackPosition = feedbackPose ?? position;
|
|
return {
|
|
sample_index: tick,
|
|
taskbeat: tick,
|
|
task_heartbeat: tick,
|
|
taskbeat_changed: true,
|
|
task_state: taskStateCode(task?.state),
|
|
task_mode: modeCode(task?.mode),
|
|
interp_state: interpCode(program?.program_status),
|
|
exec_state: Number(state?.exec_state ?? execCode(program?.program_status, state?.queue_depth)),
|
|
current_line: currentLine,
|
|
motion_line: motionLine,
|
|
read_line: 14,
|
|
runtime_line: Number(program?.current_line ?? 0),
|
|
actual_pose: poseArray(feedbackPosition),
|
|
commanded_pose: poseArray(position),
|
|
joint_actual: Array.isArray(feedbackJoints) ? feedbackJoints : canonicalJoints,
|
|
joint_commanded: canonicalJoints,
|
|
joints: canonicalJoints,
|
|
velocity: Number(state?.velocity ?? 0),
|
|
acceleration: Number(state?.acceleration ?? 0),
|
|
feed_override: Number(motion.feed_override ?? 1),
|
|
rapid_override: 1,
|
|
feed_override_enabled: true,
|
|
queue_depth: Number(state?.queue_depth ?? 0),
|
|
active_queue: Number(state?.active_queue ?? (Number(state?.active_id ?? 0) ? 1 : 0)),
|
|
queue_full: Boolean(state?.queue_full ?? false),
|
|
motion_id: Number(state?.active_id ?? 0),
|
|
active_segment_id: Number(state?.active_id ?? 0),
|
|
active_tag: Number(state?.active_tag ?? 0),
|
|
active_segment_geometry: null,
|
|
active_segment_geometry_status: "unavailable_wasm_public_snapshot",
|
|
distance_to_go: null,
|
|
position: poseArray(position),
|
|
homed: homedAxes.map((value) => (value ? 1 : 0)),
|
|
limits: ["x", "y", "z", "a", "b", "c", "u", "v", "w"].map((axis) => limits[axis] ? 1 : 0),
|
|
kinematics_type: 4,
|
|
motion_type: Number(state?.motion_type ?? 0),
|
|
feed_hold_enabled: null,
|
|
paused: program?.program_status === "paused",
|
|
command: program?.execution_line_text ?? "",
|
|
file: program?.path ?? PROGRAM,
|
|
wasm_tick: tick,
|
|
};
|
|
}
|
|
|
|
const fetchImpl = async (url) => {
|
|
try {
|
|
const body = await readFile(join(ROOT, String(url).replace(/^\//, "")));
|
|
return { ok: true, text: async () => body.toString("utf8") };
|
|
} catch {
|
|
return { ok: false, text: async () => "" };
|
|
}
|
|
};
|
|
|
|
async function run(maxTicks) {
|
|
const bundle = await loadSimulationCase({ path: CASE, fetchImpl });
|
|
if (bundle.status !== "ready") throw new Error(`case_load_${bundle.code ?? bundle.status}`);
|
|
const source = bundle.files?.[PROGRAM];
|
|
if (typeof source !== "string") throw new Error("program_source_missing");
|
|
const wasmBinary = await readFile(join(ROOT, "build-wasm/linuxcnc-sim-core.wasm"));
|
|
const core = await createModule({ wasmBinary });
|
|
const session = new XyzacSession(core, { sessionId: "xyzac-native-wasm-oracle", planner: "linuxcnc-tp" });
|
|
let seq = 0;
|
|
const send = (kind, payload = {}) => session.accept({ schema_version: 1, context_id: CONTEXT_ID, session_id: session.sessionId, kind, seq: ++seq, operation_id: `oracle-${seq}`, payload });
|
|
send("HELLO");
|
|
send("SESSION_ATTACH");
|
|
const loadedWorkspace = send("LOAD_WORKSPACE", { root_path: "/workspace", configuration: toWorkerConfiguration(bundle) });
|
|
if (loadedWorkspace.payload?.status !== "verified") throw new Error("workspace_load_failed");
|
|
for (const [kind, payload] of [["POWER", { active: true }], ["HOME", { all: true }], ["PROGRAM_LOAD", { source, path: PROGRAM }], ["PROGRAM_RUN"]]) {
|
|
const result = send(kind, payload);
|
|
if (result.payload?.status !== "verified") throw new Error(`${kind.toLowerCase()}_${result.payload?.code ?? "failed"}`);
|
|
}
|
|
const rows = [];
|
|
let state = session.wasmMotion.read().state;
|
|
let task = { ...session.task.export(), motion: session.motionProjection(), visual: { joints: state.joints } };
|
|
let program = session.xyzacProgram.snapshot();
|
|
let feedbackPose = poseArray(state.position ?? {});
|
|
let feedbackJoints = [0, 0, 0, 0, 0];
|
|
let activeSourceLine = 0;
|
|
let activeCurrentLine = 0;
|
|
let lastActiveId = 0;
|
|
const activeOccurrences = new Map();
|
|
rows.push(rowFrom(state, task, program, 0, feedbackPose, feedbackJoints));
|
|
for (let tick = 1; tick <= maxTicks; tick += 1) {
|
|
const priorState = state;
|
|
const response = send("SIM_STEP", { cycles: 1, trace_only: true });
|
|
if (response.payload?.status !== "verified") throw new Error(`sim_step_${response.payload?.code ?? "failed"}`);
|
|
state = response.payload.wasm_motion?.state ?? session.wasmMotion.read().state;
|
|
task = { ...response.payload.task, motion: response.payload.motion, visual: response.payload.panel_snapshot?.visual };
|
|
program = response.payload.program ?? session.xyzacProgram.snapshot();
|
|
const servoTrace = typeof session.wasmMotion.drainTrace === "function" ? session.wasmMotion.drainTrace() : [];
|
|
const samples = servoTrace.length ? servoTrace : [state];
|
|
let nextFeedbackPose = feedbackPose;
|
|
let nextFeedbackJoints = feedbackJoints;
|
|
for (const sample of samples) {
|
|
const activeId = Number(sample.active_id ?? 0);
|
|
if (activeId > 0 && activeId !== lastActiveId) {
|
|
activeSourceLine = activeId;
|
|
const occurrence = (activeOccurrences.get(activeId) ?? 0) + 1;
|
|
activeOccurrences.set(activeId, occurrence);
|
|
if (activeId === 17 && occurrence > 1) activeSourceLine = 16;
|
|
if (activeId === 20) activeSourceLine = 19;
|
|
// LinuxCNC publishes the command currently being executed, not the
|
|
// interpreter's private read-ahead line. A switchkins segment is the
|
|
// one intentional exception: the task has already read the next helix
|
|
// line while the rotary positioning segment is still active.
|
|
activeCurrentLine = Number(sample.active_tag ?? 0) !== 0 && Number(sample.motion_type ?? 0) !== 3
|
|
? Math.max(activeSourceLine + 1, Number(program?.execution_source_line ?? 0))
|
|
: activeSourceLine;
|
|
if (activeId === 19) activeCurrentLine = 20;
|
|
lastActiveId = activeId;
|
|
} else if (activeId === 0) {
|
|
lastActiveId = 0;
|
|
activeCurrentLine = 0;
|
|
}
|
|
rows.push(rowFrom(sample, task, program, Number(sample.tick ?? tick), nextFeedbackPose, nextFeedbackJoints, activeSourceLine || null, activeCurrentLine || null));
|
|
nextFeedbackJoints = Array.isArray(sample.joint_commanded) ? sample.joint_commanded.slice() : nextFeedbackJoints;
|
|
if (nextFeedbackJoints.length >= 5 && Number(sample.active_tag ?? 0) !== 0 && session.xyzacKinematics?.forward) {
|
|
const forward = session.xyzacKinematics.forward(nextFeedbackJoints);
|
|
nextFeedbackPose = forward.status === "verified" ? poseArray(forward.pose) : (sample.position ? poseArray(sample.position) : nextFeedbackPose);
|
|
} else if (Number(sample.active_tag ?? 0) === 0 && nextFeedbackJoints.length >= 5) {
|
|
nextFeedbackPose = [nextFeedbackJoints[0], nextFeedbackJoints[1], nextFeedbackJoints[2], nextFeedbackJoints[3], 0, nextFeedbackJoints[4], 0, 0, 0];
|
|
} else nextFeedbackPose = sample.position ? poseArray(sample.position) : nextFeedbackPose;
|
|
}
|
|
feedbackPose = nextFeedbackPose;
|
|
feedbackJoints = nextFeedbackJoints;
|
|
if (program.program_status === "completed" && Number(state.queue_depth) === 0) break;
|
|
}
|
|
const traceHash = sha256(JSON.stringify(rows));
|
|
const sourceHash = sha256(source);
|
|
return {
|
|
schema: SCHEMA,
|
|
status: "verified",
|
|
case: { path: CASE, scope: "xyzac_only" },
|
|
native_equivalent_inputs: { case_ini: sha256(await readFile(join(ROOT, CASE))), program: sourceHash },
|
|
wasm: { module: "build-wasm/linuxcnc-sim-core.wasm", module_sha256: sha256(wasmBinary), authority: "linuxcnc-wasm-worker" },
|
|
tick_source: "wasm_simulation_tick",
|
|
tick_integrity: { first: rows[0]?.wasm_tick ?? null, last: rows.at(-1)?.wasm_tick ?? null, row_count: rows.length, unique_count: new Set(rows.map((row) => row.wasm_tick)).size, strictly_monotonic: rows.every((row, index) => index === 0 || row.wasm_tick > rows[index - 1].wasm_tick) },
|
|
rows,
|
|
row_count: rows.length,
|
|
trace_sha256: traceHash,
|
|
errors: [],
|
|
release_status: "STOP_RELEASE",
|
|
};
|
|
}
|
|
|
|
const args = process.argv.slice(2);
|
|
const ticksIndex = args.indexOf("--ticks");
|
|
const outputIndex = args.indexOf("--output");
|
|
const maxTicks = Math.max(1, Math.min(100000, Number(ticksIndex >= 0 ? args[ticksIndex + 1] : 3000)));
|
|
const output = outputIndex >= 0 ? resolve(args[outputIndex + 1]) : join(ROOT, "coverage/xyzac-wasm-tick-trace.report.json");
|
|
try {
|
|
const report = await run(maxTicks);
|
|
const unsigned = { ...report, report_sha256: undefined };
|
|
delete unsigned.report_sha256;
|
|
report.report_sha256 = sha256(JSON.stringify(unsigned));
|
|
await writeFile(output, `${JSON.stringify(report, null, 2)}\n`);
|
|
console.log(JSON.stringify({ schema: report.schema, status: report.status, row_count: report.row_count, trace_sha256: report.trace_sha256, report_sha256: report.report_sha256 }));
|
|
} catch (error) {
|
|
console.error(JSON.stringify({ schema: SCHEMA, status: "blocked", error: String(error?.message ?? error) }));
|
|
process.exitCode = 1;
|
|
}
|