127 lines
4.8 KiB
JavaScript
127 lines
4.8 KiB
JavaScript
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
linearUnitsToMetersFactor,
|
|
linearUnitsToMillimetersFactor,
|
|
linearValueToMeters,
|
|
linearValueToMillimeters,
|
|
normalizeLinearUnits,
|
|
resolveStateLinearUnits,
|
|
} from "../../app/src/runtime/linear-units.js";
|
|
import { createLinuxCncInterpreterRuntime } from "../../app/src/runtime/linuxcnc-interpreter-runtime.js";
|
|
import { buildProgramExecutionTiming } from "../../app/src/runtime/execution-timing.js";
|
|
import { axesToSceneMeters } from "../../app/src/visualization/five-axis-scene.js";
|
|
|
|
function assertNear(actual, expected, label) {
|
|
assert.equal(Math.abs(actual - expected) < 1e-9, true, `${label}: expected ${expected}, got ${actual}`);
|
|
}
|
|
|
|
assert.equal(normalizeLinearUnits("MM"), "mm");
|
|
assert.equal(normalizeLinearUnits("inch"), "inch");
|
|
assert.equal(normalizeLinearUnits("meters"), "m");
|
|
assertNear(linearUnitsToMetersFactor("mm"), 0.001, "mm to m factor");
|
|
assertNear(linearUnitsToMetersFactor("inch"), 0.0254, "inch to m factor");
|
|
assertNear(linearUnitsToMetersFactor("m"), 1, "m to m factor");
|
|
assertNear(linearUnitsToMillimetersFactor("inch"), 25.4, "inch to mm factor");
|
|
assertNear(linearValueToMeters(25.4, "mm"), 0.0254, "25.4 mm to meters");
|
|
assertNear(linearValueToMeters(1, "inch"), 0.0254, "1 inch to meters");
|
|
assertNear(linearValueToMillimeters(0.5, "m"), 500, "0.5 m to millimeters");
|
|
|
|
const mmState = { profile: { traj: { linearUnits: "mm" } } };
|
|
const inchState = { profile: { traj: { linearUnits: "inch" } } };
|
|
const meterState = { profile: { traj: { linearUnits: "m" } } };
|
|
const iniState = {
|
|
linuxCncIniConfig: { traj: { linearUnits: "inch" } },
|
|
profile: { traj: { linearUnits: "mm" } },
|
|
};
|
|
|
|
assert.equal(resolveStateLinearUnits(iniState), "inch");
|
|
assert.deepEqual(axesToSceneMeters({ x: 25.4, y: -10, z: 2000 }, mmState), {
|
|
x: 0.0254,
|
|
y: -0.01,
|
|
z: 2,
|
|
});
|
|
assert.deepEqual(axesToSceneMeters({ x: 1, y: -0.5, z: 2 }, inchState), {
|
|
x: 0.0254,
|
|
y: -0.0127,
|
|
z: 0.0508,
|
|
});
|
|
assert.deepEqual(axesToSceneMeters({ x: 0.1, y: -0.2, z: 0.3 }, meterState), {
|
|
x: 0.1,
|
|
y: -0.2,
|
|
z: 0.3,
|
|
});
|
|
|
|
const inchTiming = buildProgramExecutionTiming({
|
|
profile: {
|
|
traj: {
|
|
linearUnits: "inch",
|
|
maxLinearVelocity: 2,
|
|
defaultLinearVelocity: 1,
|
|
},
|
|
},
|
|
defaultFeedRate: 1,
|
|
motion: [
|
|
{ type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 } },
|
|
{ type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 } },
|
|
],
|
|
});
|
|
|
|
assert.equal(inchTiming.linearUnits, "inch");
|
|
assertNear(inchTiming.segments[1].linearDistanceMm, 25.4, "inch segment distance in mm");
|
|
assertNear(inchTiming.segments[1].velocityMmPerMin, 25.4, "inch feed velocity in mm/min");
|
|
|
|
const mixedUnitsTiming = buildProgramExecutionTiming({
|
|
profile: {
|
|
traj: {
|
|
linearUnits: "mm",
|
|
maxLinearVelocity: 100,
|
|
defaultLinearVelocity: 10,
|
|
},
|
|
},
|
|
motion: [
|
|
{ type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
|
|
{ type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
|
|
{ type: "STRAIGHT_FEED", line: 3, axes: { x: 25.4, y: 0, z: 0 }, linearUnits: "mm", feedRate: 100 },
|
|
],
|
|
});
|
|
assertNear(mixedUnitsTiming.segments[1].linearDistanceMm, 25.4, "mixed units inch segment distance");
|
|
assertNear(mixedUnitsTiming.segments[2].linearDistanceMm, 0, "mixed units unchanged position distance");
|
|
|
|
const inverseTimeTiming = buildProgramExecutionTiming({
|
|
profile: {
|
|
traj: {
|
|
linearUnits: "mm",
|
|
maxLinearVelocity: 100,
|
|
defaultLinearVelocity: 10,
|
|
},
|
|
},
|
|
motion: [
|
|
{ type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
|
|
{ type: "STRAIGHT_FEED", line: 2, axes: { x: 10, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
|
|
],
|
|
});
|
|
assertNear(inverseTimeTiming.segments[1].durationSeconds, 0.5, "G93 inverse-time F120 duration");
|
|
assertNear(inverseTimeTiming.segments[1].velocityMmPerMin, 1200, "G93 inverse-time velocity");
|
|
|
|
const interpreterRuntime = await createLinuxCncInterpreterRuntime();
|
|
const inchExecution = interpreterRuntime.runProgram("G20 G90\nG1 X1 F10\nM2");
|
|
const metricExecution = interpreterRuntime.runProgram("G21 G90\nG1 X25.4 F100\nM2");
|
|
const inverseExecution = interpreterRuntime.runProgram("G21 G90 G93\nG1 X1 F120\nM2");
|
|
|
|
assert.equal(inchExecution.motion[0].linearUnits, "inch");
|
|
assert.equal(metricExecution.motion[0].linearUnits, "mm");
|
|
assert.equal(inverseExecution.motion[0].feedMode, "inverse-time");
|
|
assertNear(
|
|
axesToSceneMeters(inchExecution.motion[0].axes, mmState, inchExecution.motion[0].linearUnits).x,
|
|
0.0254,
|
|
"G20 interpreter motion uses inch scene conversion",
|
|
);
|
|
assertNear(
|
|
axesToSceneMeters(metricExecution.motion[0].axes, mmState, metricExecution.motion[0].linearUnits).x,
|
|
0.0254,
|
|
"G21 interpreter motion uses millimeter scene conversion",
|
|
);
|
|
|
|
console.log("linear_unit_conversion_smoke=ok");
|