agentic-numerical-control 0.1.6 → 0.2.0

package/dist/server/analysis.js

@@ -0,0 +1,356 @@
+// Reads a G-code program the way a careful machinist would before running it:
+// how big it is, how long it takes, which tools it uses and where they change,
+// whether it fits the machine from the current zero, and anything the
+// controller won't do or that looks risky. Everything here is an estimate from
+// the program text and the controller's own settings; nothing touches the machine.
+const AXES = ["x", "y", "z"];
+const ASSUMED_RAPID = 1000; // mm/min, a cautious hobby-machine figure
+const LINE_SAMPLES = 5;
+const round = (n, d = 2) => Math.round(n * 10 ** d) / 10 ** d;
+function parseWords(code) {
+    const g = [];
+    const m = [];
+    const v = {};
+    for (const [, letter, num] of code.matchAll(/([A-Z])\s*([-+]?(?:\d+\.?\d*|\.\d+))/g)) {
+        const n = Number(num);
+        if (letter === "G")
+            g.push(n);
+        else if (letter === "M")
+            m.push(n);
+        else
+            v[letter] = n;
+    }
+    return { g, m, v };
+}
+/** Grbl and grblHAL both report as "Grbl" in CNCjs; grblHAL says so in its version line. */
+function controllerKind(machine) {
+    if (!machine?.controller)
+        return "unknown";
+    if (!/grbl/i.test(machine.controller))
+        return "other";
+    return /hal/i.test(machine.version ?? "") ? "grblhal" : "grbl";
+}
+export function analyzeGcode(gcode, machine) {
+    const settings = machine?.settings ?? null;
+    const setting = (n) => {
+        const raw = settings?.[`$${n}`];
+        const val = raw === undefined ? NaN : Number(raw);
+        return Number.isFinite(val) ? val : null;
+    };
+    const rapid = { x: setting(110), y: setting(111), z: setting(112) };
+    const rapidKnown = rapid.x !== null && rapid.y !== null && rapid.z !== null;
+    const found = new Map();
+    const flag = (code, severity, message, line) => {
+        const c = found.get(code) ?? { severity, message, lines: [] };
+        if (c.lines.length < LINE_SAMPLES && c.lines[c.lines.length - 1] !== line)
+            c.lines.push(line);
+        found.set(code, c);
+    };
+    let scale = 1; // inch programs are converted to mm
+    let units = "mm";
+    let absolute = true;
+    let plane = 17;
+    let motion = 0;
+    let feed = null;
+    let spindleOn = false;
+    let pos = { x: 0, y: 0, z: 0 };
+    let moved = false;
+    let pendingTool = null;
+    let pendingLabel = null;
+    let tool = null;
+    let lastComment = null;
+    const min = { x: Infinity, y: Infinity, z: Infinity };
+    const max = { x: -Infinity, y: -Infinity, z: -Infinity };
+    const feeds = new Set();
+    const speeds = new Set();
+    const tools = [];
+    let toolChanges = 0;
+    let cutLength = 0;
+    let rapidLength = 0;
+    let cuttingSeconds = 0;
+    let rapidSeconds = 0;
+    const runs = [];
+    const steps = [];
+    let step = null;
+    const openStep = (line) => {
+        step = { tool, label: pendingLabel, firstLine: line, lastLine: line, seconds: 0, cutLength: 0, minZ: null, feedRange: null };
+        steps.push(step);
+    };
+    const include = (p) => {
+        for (const a of AXES) {
+            if (p[a] < min[a])
+                min[a] = p[a];
+            if (p[a] > max[a])
+                max[a] = p[a];
+        }
+    };
+    const lines = gcode.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const lineNo = i + 1;
+        const raw = lines[i];
+        const comments = [...raw.matchAll(/\(([^)]*)\)|;(.*)$/g)].map((c) => (c[1] ?? c[2] ?? "").trim()).filter(Boolean);
+        if (comments.length)
+            lastComment = comments.join(" ");
+        const code = raw.replace(/\([^)]*\)/g, " ").replace(/;.*$/, "").toUpperCase().replace(/^\s*N\d+/, "");
+        if (!code.trim() || code.trim().startsWith("%"))
+            continue;
+        const { g, m, v } = parseWords(code);
+        for (const n of g) {
+            if (n === 20) {
+                scale = 25.4;
+                units = "inch";
+            }
+            else if (n === 21) {
+                scale = 1;
+                units = "mm";
+            }
+            else if (n === 90)
+                absolute = true;
+            else if (n === 91)
+                absolute = false;
+            else if (n === 17 || n === 18 || n === 19)
+                plane = n;
+            else if (n >= 0 && n <= 3 && Number.isInteger(n))
+                motion = n;
+            else if (n >= 81 && n <= 89) {
+                const kind = controllerKind(machine);
+                if (kind === "grbl")
+                    flag("canned-cycle", "problem", "Uses drilling cycles (G81–G89), which Grbl doesn't support. Post the program with cycles expanded to plain moves.", lineNo);
+                else if (kind !== "grblhal")
+                    flag("canned-cycle", "check", "Uses drilling cycles (G81–G89). Plain Grbl doesn't support them; grblHAL does.", lineNo);
+            }
+            else if (n === 41 || n === 42) {
+                flag("cutter-comp", "problem", "Uses cutter radius compensation (G41/G42), which Grbl doesn't support. Post the program with compensation in the computer.", lineNo);
+            }
+            else if (n === 28 || n === 30) {
+                flag("stored-position", "check", "Moves to a stored position (G28/G30). Check where it is set before running.", lineNo);
+            }
+            else if (n === 53) {
+                flag("machine-coords", "check", "Has moves in machine coordinates (G53), which ignore your zero.", lineNo);
+            }
+            else if (n >= 38 && n < 39) {
+                flag("probe", "check", "Probes (G38). Make sure the probe is connected.", lineNo);
+            }
+        }
+        if (v.F !== undefined)
+            feed = v.F * scale;
+        if (v.S !== undefined && v.S > 0)
+            speeds.add(v.S);
+        if (v.T !== undefined) {
+            pendingTool = v.T;
+            // CAM comments usually repeat the tool number ("T1 6 mm flat end mill").
+            pendingLabel = lastComment?.replace(/^T\d+\s*[:·-]?\s*/i, "") || null;
+        }
+        for (const n of m) {
+            if (n === 3 || n === 4)
+                spindleOn = true;
+            else if (n === 5)
+                spindleOn = false;
+            else if (n === 6) {
+                const next = pendingTool;
+                if (next !== null && next !== tool) {
+                    if (tool !== null || steps.length)
+                        toolChanges++;
+                    tool = next;
+                    if (!tools.includes(next))
+                        tools.push(next);
+                    step = null; // the next move opens a step for the new tool
+                }
+            }
+        }
+        // A T word with no M6 still names the tool, for programs that rely on the sender.
+        if (pendingTool !== null && tool === null && !m.includes(6)) {
+            tool = pendingTool;
+            if (!tools.includes(tool))
+                tools.push(tool);
+        }
+        // G28/G30/G53 moves don't land at the program's own coordinates; skip them.
+        if (g.some((n) => n === 28 || n === 30 || n === 53 || n === 92 || n === 10))
+            continue;
+        const hasAxis = v.X !== undefined || v.Y !== undefined || v.Z !== undefined;
+        if (!hasAxis)
+            continue;
+        const target = { ...pos };
+        for (const a of AXES) {
+            const val = v[a.toUpperCase()];
+            if (val === undefined)
+                continue;
+            target[a] = absolute ? val * scale : pos[a] + val * scale;
+        }
+        if (!step)
+            openStep(lineNo);
+        const s = step;
+        const runFeed = motion === 0 ? null : feed;
+        const lastRun = runs[runs.length - 1];
+        if (!lastRun || lastRun.feed !== runFeed || lastRun.tool !== tool)
+            runs.push({ line: lineNo, feed: runFeed, tool });
+        s.lastLine = lineNo;
+        const dx = target.x - pos.x;
+        const dy = target.y - pos.y;
+        const dz = target.z - pos.z;
+        if (motion === 0) {
+            const len = Math.hypot(dx, dy, dz);
+            rapidLength += len;
+            const t = rapidKnown
+                ? Math.max(Math.abs(dx) / rapid.x, Math.abs(dy) / rapid.y, Math.abs(dz) / rapid.z) * 60
+                : (len / ASSUMED_RAPID) * 60;
+            rapidSeconds += t;
+            s.seconds += t;
+            if (moved && target.z < 0 && (dx !== 0 || dy !== 0 || dz < 0)) {
+                flag("rapid-in-stock", "check", "Has rapid moves below Z 0, which may plunge or travel through the stock at full speed.", lineNo);
+            }
+        }
+        else {
+            let len = Math.hypot(dx, dy, dz);
+            if ((motion === 2 || motion === 3) && plane === 17) {
+                const cx = v.I !== undefined ? pos.x + v.I * scale : null;
+                const cy = v.J !== undefined ? pos.y + v.J * scale : null;
+                if (cx !== null || cy !== null || v.R !== undefined) {
+                    const ccx = cx ?? pos.x;
+                    const ccy = cy ?? pos.y;
+                    const r = v.R !== undefined ? Math.abs(v.R * scale) : Math.hypot(pos.x - ccx, pos.y - ccy);
+                    let sweep;
+                    if (v.R !== undefined) {
+                        const chord = Math.min(Math.hypot(dx, dy), 2 * r);
+                        sweep = 2 * Math.asin(chord / (2 * r || 1));
+                        if (v.R < 0)
+                            sweep = 2 * Math.PI - sweep;
+                    }
+                    else {
+                        const a0 = Math.atan2(pos.y - ccy, pos.x - ccx);
+                        const a1 = Math.atan2(target.y - ccy, target.x - ccx);
+                        sweep = motion === 2 ? a0 - a1 : a1 - a0;
+                        while (sweep <= 1e-9)
+                            sweep += 2 * Math.PI;
+                        // Arc bounds: include the circle's extreme points the sweep passes.
+                        for (let k = 0; k < 4; k++) {
+                            const ang = (k * Math.PI) / 2;
+                            const rel = motion === 2 ? a0 - ang : ang - a0;
+                            let d = rel % (2 * Math.PI);
+                            if (d < 0)
+                                d += 2 * Math.PI;
+                            if (d < sweep)
+                                include({ x: ccx + r * Math.cos(ang), y: ccy + r * Math.sin(ang), z: target.z });
+                        }
+                    }
+                    len = Math.hypot(r * sweep, dz);
+                }
+            }
+            cutLength += len;
+            s.cutLength += len;
+            if (feed === null || feed <= 0) {
+                flag("no-feed", "problem", "Has a cutting move before any feed rate (F) is set. Grbl refuses it.", lineNo);
+            }
+            else {
+                feeds.add(round(feed, 1));
+                const t = (len / feed) * 60;
+                cuttingSeconds += t;
+                s.seconds += t;
+                const f = feed;
+                s.feedRange = s.feedRange ? [Math.min(s.feedRange[0], f), Math.max(s.feedRange[1], f)] : [f, f];
+            }
+            if (!spindleOn && Math.min(pos.z, target.z) < 0) {
+                flag("spindle-off", "problem", "Cuts below Z 0 with the spindle off (no M3 before it).", lineNo);
+            }
+        }
+        include(pos);
+        include(target);
+        const lowZ = Math.min(pos.z, target.z);
+        s.minZ = s.minZ === null ? lowZ : Math.min(s.minZ, lowZ);
+        pos = target;
+        moved = true;
+    }
+    if (toolChanges > 0) {
+        found.set("tool-changes", {
+            severity: "check",
+            message: `Changes tool ${toolChanges} time${toolChanges === 1 ? "" : "s"}. Grbl doesn't stop for M6 by itself; CNCjs's tool change setting has to pause the job so you can swap the tool and set its length.`,
+            lines: steps.slice(1).map((s) => s.firstLine).slice(0, LINE_SAMPLES),
+        });
+    }
+    const bounds = Number.isFinite(min.x) ? { min: roundVec(min), max: roundVec(max) } : null;
+    const fit = fitCheck(bounds, machine, setting);
+    if (fit.status === "over") {
+        for (const a of fit.axes) {
+            found.set(`travel-${a.axis}`, {
+                severity: "problem",
+                message: `Goes ${round(a.over, 1)} mm past the ${a.axis.toUpperCase()} travel. From the current zero it runs past the machine's ${a.direction} ${a.axis.toUpperCase()} end; move the zero or the stock.`,
+                lines: [],
+            });
+        }
+    }
+    const checks = [...found.entries()]
+        .map(([code, c]) => ({ code, ...c }))
+        .sort((a, b) => (a.severity === b.severity ? 0 : a.severity === "problem" ? -1 : 1));
+    const feedList = [...feeds].sort((a, b) => a - b);
+    return {
+        units,
+        bounds,
+        size: bounds ? roundVec({ x: bounds.max.x - bounds.min.x, y: bounds.max.y - bounds.min.y, z: bounds.max.z - bounds.min.z }) : null,
+        deepestZ: bounds ? bounds.min.z : null,
+        time: {
+            totalSeconds: Math.round(cuttingSeconds + rapidSeconds),
+            cuttingSeconds: Math.round(cuttingSeconds),
+            rapidSeconds: Math.round(rapidSeconds),
+            rapidRate: rapidKnown ? "machine" : "assumed",
+        },
+        cutLength: round(cutLength, 1),
+        rapidLength: round(rapidLength, 1),
+        feedRange: feedList.length ? [feedList[0], feedList[feedList.length - 1]] : null,
+        spindleSpeeds: [...speeds].sort((a, b) => a - b),
+        tools,
+        toolChanges,
+        steps: steps.map((s) => ({
+            ...s,
+            seconds: Math.round(s.seconds),
+            cutLength: round(s.cutLength, 1),
+            minZ: s.minZ === null ? null : round(s.minZ, 3),
+            feedRange: s.feedRange ? [round(s.feedRange[0], 1), round(s.feedRange[1], 1)] : null,
+        })),
+        fit,
+        checks,
+        runs,
+    };
+}
+function roundVec(p) {
+    return { x: round(p.x, 3), y: round(p.y, 3), z: round(p.z, 3) };
+}
+/**
+ * Whether the program stays inside the machine's travel from the current
+ * work zero. Grbl's machine coordinates run from 0 at the homed corner into
+ * minus by $130-$132, unless $23 flips an axis to home towards minus. Without
+ * homing ($22 off) machine coordinates mean nothing, so the fit is unknown.
+ */
+function fitCheck(bounds, machine, setting) {
+    const unknown = (reason) => ({ status: "unknown", axes: [], reason });
+    if (!bounds)
+        return unknown("The program has no moves.");
+    if (!machine?.controller)
+        return unknown("No machine is connected.");
+    if (!/grbl/i.test(machine.controller))
+        return unknown("Only Grbl machines report their travel.");
+    if (!machine.mpos || !machine.wpos)
+        return unknown("The machine hasn't reported its position yet.");
+    const travel = { x: setting(130), y: setting(131), z: setting(132) };
+    if (travel.x === null || travel.y === null || travel.z === null)
+        return unknown("The machine hasn't reported its travel settings ($130–$132).");
+    if (!((setting(22) ?? 0) & 1))
+        return unknown("Homing is off ($22), so the machine doesn't know where its travel ends.");
+    const dirMask = setting(23) ?? 0;
+    const axes = [];
+    AXES.forEach((a, bit) => {
+        const offset = machine.mpos[a] - machine.wpos[a];
+        const towardsMinus = (dirMask >> bit) & 1;
+        const lo = towardsMinus ? 0 : -travel[a];
+        const hi = towardsMinus ? travel[a] : 0;
+        const from = bounds.min[a] + offset;
+        const to = bounds.max[a] + offset;
+        const tolerance = 0.01;
+        if (from < lo - tolerance)
+            axes.push({ axis: a, over: lo - from, direction: "minus" });
+        if (to > hi + tolerance)
+            axes.push({ axis: a, over: to - hi, direction: "plus" });
+    });
+    return axes.length
+        ? { status: "over", axes, reason: "From the current zero, the program leaves the machine's travel." }
+        : { status: "fits", axes, reason: "From the current zero, the program stays inside the machine's travel." };
+}