cyclecad 3.10.4 → 3.12.0

package/app/js/modules/pentacad-bridge.js

@@ -0,0 +1,216 @@
+/**
+ * @file pentacad-bridge.js
+ * @description Pentacad machine-bridge client. Connects the browser to the
+ *              controller-bridge service (running on LAN next to the machine)
+ *              over WebSocket, streams G-code downstream, and receives live
+ *              DRO / spindle / probe / alarm data upstream.
+ *
+ *              Scope for Phase 3:
+ *                - WebSocket connect/reconnect with token auth
+ *                - G-code streaming with pause/resume/abort
+ *                - Jog, feed override, spindle override
+ *                - DRO readback (X/Y/Z/A/B)
+ *                - Alarm/status channel
+ *                - E-stop is ALWAYS hardware-first — the bridge cannot override
+ *
+ * @version 0.1.0
+ * @author  Sachin Kumar <vvlars@googlemail.com>
+ * @license AGPL-3.0-only
+ * @module  pentacad-bridge
+ */
+
+'use strict';
+
+window.CycleCAD = window.CycleCAD || {};
+
+window.CycleCAD.PentacadBridge = (() => {
+  const VERSION = '0.1.0';
+  const DEFAULT_URL = 'ws://localhost:7777';
+
+  // ============================================================================
+  // STATE
+  // ============================================================================
+
+  const bridge = {
+    ws: null,
+    url: DEFAULT_URL,
+    status: 'disconnected',    // disconnected | connecting | connected | error
+    dro: { x: 0, y: 0, z: 0, a: 0, b: 0 },
+    spindle: { rpm: 0, load: 0 },
+    alarms: [],
+    lastPing: 0,
+    reconnectAttempts: 0,
+  };
+
+  // ============================================================================
+  // CONNECT
+  // ============================================================================
+
+  function connect(url) {
+    if (url) bridge.url = url;
+    if (bridge.ws) bridge.ws.close();
+
+    setStatus('connecting');
+    try {
+      bridge.ws = new WebSocket(bridge.url);
+    } catch (e) {
+      setStatus('error');
+      console.error('[pentacad-bridge] WebSocket creation failed:', e);
+      return;
+    }
+
+    bridge.ws.addEventListener('open', () => {
+      setStatus('connected');
+      bridge.reconnectAttempts = 0;
+      console.log(`[pentacad-bridge] Connected to ${bridge.url}`);
+    });
+
+    bridge.ws.addEventListener('message', (e) => {
+      try {
+        const msg = JSON.parse(e.data);
+        handleMessage(msg);
+      } catch (err) {
+        console.warn('[pentacad-bridge] Bad message:', e.data);
+      }
+    });
+
+    bridge.ws.addEventListener('close', () => {
+      setStatus('disconnected');
+      // Auto-reconnect with exponential backoff
+      const delay = Math.min(1000 * (2 ** bridge.reconnectAttempts), 30000);
+      bridge.reconnectAttempts++;
+      setTimeout(() => {
+        if (bridge.status === 'disconnected') connect(bridge.url);
+      }, delay);
+    });
+
+    bridge.ws.addEventListener('error', (e) => {
+      setStatus('error');
+      console.error('[pentacad-bridge] WebSocket error', e);
+    });
+  }
+
+  function disconnect() {
+    if (bridge.ws) bridge.ws.close();
+    bridge.ws = null;
+    setStatus('disconnected');
+  }
+
+  function setStatus(status) {
+    bridge.status = status;
+    window.dispatchEvent(new CustomEvent('pentacad:bridge-status', {
+      detail: { status, url: bridge.url },
+    }));
+    if (ctx?.state) ctx.state.bridgeStatus = status;
+  }
+
+  // ============================================================================
+  // MESSAGE HANDLING (upstream from bridge)
+  // ============================================================================
+
+  function handleMessage(msg) {
+    switch (msg.type) {
+      case 'dro':
+        bridge.dro = { ...bridge.dro, ...msg.position };
+        emit('dro', bridge.dro);
+        break;
+      case 'spindle':
+        bridge.spindle = { ...bridge.spindle, ...msg };
+        emit('spindle', bridge.spindle);
+        break;
+      case 'alarm':
+        bridge.alarms.push({ time: Date.now(), ...msg });
+        emit('alarm', msg);
+        break;
+      case 'pong':
+        bridge.lastPing = Date.now();
+        break;
+      default:
+        emit('message', msg);
+    }
+  }
+
+  function emit(eventName, detail) {
+    window.dispatchEvent(new CustomEvent(`pentacad:${eventName}`, { detail }));
+  }
+
+  // ============================================================================
+  // DOWNSTREAM (browser → bridge → machine)
+  // ============================================================================
+
+  function send(obj) {
+    if (bridge.status !== 'connected') {
+      console.warn('[pentacad-bridge] Not connected — message dropped');
+      return false;
+    }
+    bridge.ws.send(JSON.stringify(obj));
+    return true;
+  }
+
+  function streamGCode(gcode, options = {}) {
+    // TODO Phase 3: real drip-feed with ack per block
+    const lines = gcode.split(/\r?\n/).filter(l => l && !l.startsWith('(') && l !== '%');
+    console.log(`[pentacad-bridge] Streaming ${lines.length} G-code blocks (stub)`);
+    return send({ type: 'stream', lines, options });
+  }
+
+  function jog(axis, delta, feed) {
+    return send({ type: 'jog', axis, delta, feed });
+  }
+
+  function feedOverride(percent) {
+    return send({ type: 'feed-override', percent });
+  }
+
+  function pause()  { return send({ type: 'pause' }); }
+  function resume() { return send({ type: 'resume' }); }
+  function abort()  { return send({ type: 'abort' }); }
+
+  // ============================================================================
+  // INIT
+  // ============================================================================
+
+  let ctx = null;
+
+  function init(context) {
+    ctx = context;
+    console.log(`[pentacad-bridge] v${VERSION} initialized — default URL ${DEFAULT_URL}`);
+    // Do NOT auto-connect; the user must pick a machine and click connect.
+    // Autoconnecting on page load gets flagged as suspicious by some LAN setups.
+  }
+
+  function execute(request) {
+    const { method, params } = request || {};
+    if (method === 'bridge.connect')      return connect(params?.url);
+    if (method === 'bridge.disconnect')   return disconnect();
+    if (method === 'bridge.status')       return bridge.status;
+    if (method === 'bridge.dro')          return bridge.dro;
+    if (method === 'bridge.stream')       return streamGCode(params.gcode, params.options);
+    if (method === 'bridge.jog')          return jog(params.axis, params.delta, params.feed);
+    if (method === 'bridge.feedOverride') return feedOverride(params.percent);
+    if (method === 'bridge.pause')        return pause();
+    if (method === 'bridge.resume')       return resume();
+    if (method === 'bridge.abort')        return abort();
+    return { error: 'unknown_bridge_method', method };
+  }
+
+  // ============================================================================
+  // PUBLIC API
+  // ============================================================================
+
+  return {
+    version: VERSION,
+    init,
+    execute,
+    connect,
+    disconnect,
+    streamGCode,
+    jog,
+    feedOverride,
+    pause,
+    resume,
+    abort,
+    getStatus: () => bridge.status,
+    getDRO: () => bridge.dro,
+  };
+})();

package/app/js/modules/pentacad-cam.js

@@ -0,0 +1,184 @@
+/**
+ * @file pentacad-cam.js
+ * @description Pentacad CAM sub-module — 3+2 machining strategies + post-processor.
+ *              Part of the cycleCAD Suite / Pentacad extension.
+ *
+ *              Scope for Phase 2:
+ *                - 12 strategies: 2D contour, adaptive, pocket, drill, parallel,
+ *                  radial, scallop, projection, flow, bore/thread, chamfer, face
+ *                - 3+2 setup manager: tilt plane selection, WCS, stock, fixture
+ *                - Toolpath generation
+ *                - Post-processor emitting Pentamachine .ngc dialect
+ *                - Tool library integration
+ *
+ * @version 0.1.0
+ * @author  Sachin Kumar <vvlars@googlemail.com>
+ * @license AGPL-3.0-only
+ * @module  pentacad-cam
+ */
+
+'use strict';
+
+window.CycleCAD = window.CycleCAD || {};
+
+window.CycleCAD.PentacadCAM = (() => {
+  const VERSION = '0.1.0';
+
+  // ============================================================================
+  // STRATEGIES
+  // ============================================================================
+
+  const STRATEGIES = [
+    { id: '2d-contour',      name: '2D Contour',       kind: '2d' },
+    { id: 'adaptive-clear',  name: 'Adaptive Clear',   kind: '2d' },
+    { id: 'pocket',          name: 'Pocket',           kind: '2d' },
+    { id: 'drill',           name: 'Drill',            kind: 'drill' },
+    { id: 'parallel',        name: 'Parallel',         kind: '3d' },
+    { id: 'radial',          name: 'Radial',           kind: '3d' },
+    { id: 'scallop',         name: 'Scallop',          kind: '3d' },
+    { id: 'projection',      name: 'Projection',       kind: '3d' },
+    { id: 'flow',            name: 'Flow',             kind: '3d' },
+    { id: 'bore-thread',     name: 'Bore / Thread',    kind: 'drill' },
+    { id: 'chamfer-deburr',  name: 'Chamfer / Deburr', kind: '2d' },
+    { id: 'face',            name: 'Face',             kind: '2d' },
+  ];
+
+  // ============================================================================
+  // POST-PROCESSOR (Pentamachine V2 dialect — reverse-engineered from samples)
+  // ============================================================================
+
+  /**
+   * Emits G-code in the Pentamachine V2 dialect.
+   *
+   * Confirmed features from sample .ngc files:
+   *   - G20 (inch) units default; G21 (metric) supported via post config
+   *   - G17 (XY workplane)
+   *   - G90 (absolute), G91.1 (incremental IJK)
+   *   - G40 (no cutter comp)
+   *   - G94 (feed per minute) / G93 (inverse time, used during 5-axis moves)
+   *   - 5-axis: X, Y, Z, A (tilt), B (rotary)
+   *   - Tool change: Tn M6 (preceded by M5, followed by M3 S<rpm>)
+   *   - Coolant: M7 (mist), M8 (flood), M9 (off)
+   *   - WCS: G54 default
+   *
+   * @param {Array<Toolpath>} toolpaths
+   * @param {object} machine — loaded machine definition
+   * @returns {string} G-code text
+   */
+  function emitGCode(toolpaths, machine) {
+    const lines = [];
+    const meta = {
+      program: machine?.post?.programNumber ?? '1000',
+      units: machine?.post?.units ?? 'inch',
+    };
+
+    // Program header
+    lines.push('%');
+    lines.push('(AXIS,stop)');
+    lines.push(`(${meta.program})`);
+    lines.push('(PENTACAD GENERATED — Pentamachine V2 dialect)');
+
+    let n = 10;
+    const emit = (code) => { lines.push(`N${n} ${code}`); n += 5; };
+
+    // Modal setup
+    emit(meta.units === 'metric' ? 'G21' : 'G20');
+    emit('G90 G94 G40 G17 G91.1');
+    emit('G53 G0 Z0.');
+
+    // Emit each toolpath
+    for (const tp of toolpaths) {
+      lines.push(`(${tp.name ?? tp.strategy ?? 'OP'})`);
+      emit('M9');
+      emit('G49');
+      emit('M5');
+      if (tp.tool) {
+        emit(`T${tp.tool.number} M6`);
+        emit(`S${tp.tool.rpm} M3`);
+      }
+      emit('G54 G0');
+      // Moves — stub until Phase 2 implements real toolpaths
+      for (const m of tp.moves ?? []) {
+        if (m.type === 'rapid')  emit(`G0 ${axisStr(m)}`);
+        if (m.type === 'linear') emit(`G1 ${axisStr(m)} F${m.feed ?? 10}`);
+        if (m.type === 'arc')    emit(`${m.dir === 'cw' ? 'G2' : 'G3'} ${axisStr(m)} I${m.i} J${m.j} F${m.feed ?? 10}`);
+      }
+    }
+
+    // Program footer
+    emit('M9');
+    emit('G49');
+    emit('M5');
+    emit('G53 G0 Z0.');
+    emit('M30');
+    lines.push('%');
+    return lines.join('\n');
+  }
+
+  function axisStr(m) {
+    const parts = [];
+    ['X', 'Y', 'Z', 'A', 'B'].forEach(a => {
+      if (m[a.toLowerCase()] !== undefined) parts.push(`${a}${m[a.toLowerCase()].toFixed(4)}`);
+    });
+    return parts.join(' ');
+  }
+
+  // ============================================================================
+  // TOOLPATH GENERATION (stubs — real implementation in Phase 2)
+  // ============================================================================
+
+  function generateToolpath(operation, setup, machine) {
+    const strategy = STRATEGIES.find(s => s.id === operation.strategyId);
+    if (!strategy) throw new Error(`Unknown strategy: ${operation.strategyId}`);
+    return {
+      strategy: strategy.id,
+      name: `${strategy.name} — ${setup.name}`,
+      tool: operation.tool,
+      moves: [],               // TODO Phase 2: real toolpath
+      warnings: [`${strategy.id} toolpath generation is a Phase 2 deliverable`],
+    };
+  }
+
+  // ============================================================================
+  // INIT
+  // ============================================================================
+
+  let ctx = null;
+
+  function init(context) {
+    ctx = context;
+    console.log(`[pentacad-cam] v${VERSION} initialized — ${STRATEGIES.length} strategies registered`);
+  }
+
+  function execute(request) {
+    const { method, params } = request || {};
+    if (method === 'cam.listStrategies') return STRATEGIES;
+    if (method === 'cam.generate') {
+      const toolpaths = (ctx?.state?.operations ?? []).map(op => {
+        const setup = ctx.state.setups.find(s => s.id === op.setupId);
+        return generateToolpath(op, setup, ctx.state.machine);
+      });
+      ctx.state.toolpaths = toolpaths;
+      return toolpaths;
+    }
+    if (method === 'cam.post') {
+      const gcode = emitGCode(ctx.state.toolpaths, ctx.state.machine);
+      ctx.state.gcode = gcode;
+      return gcode;
+    }
+    return { error: 'unknown_cam_method', method };
+  }
+
+  // ============================================================================
+  // PUBLIC API
+  // ============================================================================
+
+  return {
+    version: VERSION,
+    init,
+    execute,
+    STRATEGIES,
+    generateToolpath,
+    emitGCode,
+  };
+})();

package/app/js/modules/pentacad-sim.js

@@ -0,0 +1,215 @@
+/**
+ * @file pentacad-sim.js
+ * @description Pentacad 5-axis G-code simulator. Parses G-code, runs forward
+ *              kinematics against a loaded machine definition, and animates
+ *              the tool + work envelope in the cycleCAD Three.js scene.
+ *
+ *              Scope for Phase 1:
+ *                - G-code parser (modal state, G0/G1/G2/G3, G93, WCS)
+ *                - 5-axis forward kinematics (axis angles → tool-tip XYZ)
+ *                - Soft-limit detection
+ *                - Material-removal simulation (voxel or dexel)
+ *                - Collision detection (tool, holder, fixture)
+ *
+ *              Acceptance test: replay samples/ring-aluminum-v2-50/*.ngc.
+ *
+ * @version 0.1.0
+ * @author  Sachin Kumar <vvlars@googlemail.com>
+ * @license AGPL-3.0-only
+ * @module  pentacad-sim
+ */
+
+'use strict';
+
+window.CycleCAD = window.CycleCAD || {};
+
+window.CycleCAD.PentacadSim = (() => {
+  const VERSION = '0.1.0';
+
+  // ============================================================================
+  // G-CODE PARSER (skeleton — Phase 1 fills this out)
+  // ============================================================================
+
+  /**
+   * Parses a G-code file line-by-line into a sequence of motion commands.
+   * Maintains modal state (feed mode, distance mode, active plane, active WCS).
+   *
+   * @param {string} gcode  full G-code text
+   * @returns {Array<Move>} { type, x?, y?, z?, a?, b?, feed?, rapid?, arcCenter? }
+   */
+  function parse(gcode) {
+    const moves = [];
+    const modal = {
+      distance: 'G90',       // absolute
+      plane: 'G17',          // XY
+      units: 'G20',          // inch
+      feedMode: 'G94',       // per-min
+      wcs: 'G54',
+      tool: null,
+      spindle: 0,
+      coolant: 'off',
+      lastPos: { x: 0, y: 0, z: 0, a: 0, b: 0 },
+    };
+    const warnings = [];
+
+    const lines = gcode.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const raw = lines[i].trim();
+      if (!raw || raw.startsWith('(') || raw.startsWith(';') || raw === '%') continue;
+
+      // Strip line number (Nxxx)
+      const body = raw.replace(/^N\d+\s*/, '');
+      // Collect tokens of the form LetterNumber (G1, X1.23, F10, etc.)
+      const tokens = body.match(/[A-Z][-+]?\d*\.?\d+/g) || [];
+      const t = {};
+      for (const tok of tokens) t[tok[0]] = parseFloat(tok.slice(1));
+
+      // Modal commands
+      if (t.G === 20 || t.G === 21) modal.units = `G${t.G}`;
+      if (t.G === 17 || t.G === 18 || t.G === 19) modal.plane = `G${t.G}`;
+      if (t.G === 90 || t.G === 91) modal.distance = `G${t.G}`;
+      if (t.G === 93 || t.G === 94) modal.feedMode = `G${t.G}`;
+      if (t.G >= 54 && t.G <= 59.3) modal.wcs = `G${t.G}`;
+
+      // Motion commands
+      if ([0, 1, 2, 3].includes(t.G)) {
+        const move = {
+          line: i + 1,
+          type: t.G === 0 ? 'rapid' : (t.G === 1 ? 'linear' : 'arc'),
+          dir: t.G === 2 ? 'cw' : (t.G === 3 ? 'ccw' : undefined),
+          from: { ...modal.lastPos },
+        };
+        ['X', 'Y', 'Z', 'A', 'B'].forEach(a => {
+          if (t[a] !== undefined) move[a.toLowerCase()] = t[a];
+        });
+        if (t.F) move.feed = t.F;
+        if (t.I !== undefined || t.J !== undefined || t.K !== undefined) {
+          move.arcCenter = { i: t.I ?? 0, j: t.J ?? 0, k: t.K ?? 0 };
+        }
+        moves.push(move);
+
+        // Update modal position
+        if (move.x !== undefined) modal.lastPos.x = move.x;
+        if (move.y !== undefined) modal.lastPos.y = move.y;
+        if (move.z !== undefined) modal.lastPos.z = move.z;
+        if (move.a !== undefined) modal.lastPos.a = move.a;
+        if (move.b !== undefined) modal.lastPos.b = move.b;
+      }
+
+      // Tool / spindle
+      if (t.T !== undefined) modal.tool = t.T;
+      if (t.S !== undefined) modal.spindle = t.S;
+      if (t.M === 7) modal.coolant = 'mist';
+      if (t.M === 8) modal.coolant = 'flood';
+      if (t.M === 9) modal.coolant = 'off';
+    }
+
+    return { moves, modal, warnings };
+  }
+
+  // ============================================================================
+  // KINEMATICS — forward 5-axis for Pentamachine A/B table geometry
+  // ============================================================================
+
+  /**
+   * Given axis values (X, Y, Z in linear, A tilt, B rotary), compute the
+   * tool-tip position in world space using the loaded machine kinematics.
+   *
+   * @param {object} axes — { x, y, z, a, b } (a, b in degrees)
+   * @param {object} kinematics — from machines/<id>/kinematics.json
+   * @returns {{x,y,z}} tool-tip in world coordinates
+   */
+  function forwardKin(axes, kinematics) {
+    if (!kinematics) return { x: axes.x, y: axes.y, z: axes.z };
+
+    // Pentamachine V2 is an A/B table machine:
+    //   - A rotates about X (tilts the work)
+    //   - B rotates about Z (spins the work)
+    //   - Spindle is fixed
+    //
+    // Full transform sequence (right to left):
+    //   tool-tip = T_xyz * R_a(A-axis) * T_a_to_table * R_b(B-axis) * T_b_to_a * workpiece
+    //
+    // For Phase 1 we'll implement this cleanly with THREE.Matrix4.
+    // For scaffold, return identity so UI renders without crashing.
+
+    console.warn('[pentacad-sim] forwardKin is a Phase 1 stub');
+    return { x: axes.x ?? 0, y: axes.y ?? 0, z: axes.z ?? 0 };
+  }
+
+  function isWithinLimits(axes, kinematics) {
+    if (!kinematics?.linear || !kinematics?.rotary) return { ok: true, warnings: ['no kinematics'] };
+    const warnings = [];
+    for (const [axis, range] of Object.entries(kinematics.linear)) {
+      const v = axes[axis];
+      if (v !== undefined && (v < range.min || v > range.max)) {
+        warnings.push(`${axis.toUpperCase()}=${v} outside [${range.min}, ${range.max}] ${range.unit}`);
+      }
+    }
+    for (const [axis, range] of Object.entries(kinematics.rotary)) {
+      const v = axes[axis];
+      if (v !== undefined && (v < range.min || v > range.max)) {
+        warnings.push(`${axis.toUpperCase()}=${v} outside [${range.min}, ${range.max}] ${range.unit}`);
+      }
+    }
+    return { ok: warnings.length === 0, warnings };
+  }
+
+  // ============================================================================
+  // REPLAY (Phase 1 — will animate in Three.js scene)
+  // ============================================================================
+
+  async function replay(gcode, onProgress) {
+    const parsed = parse(gcode);
+    let cumulative = 0;
+    for (let i = 0; i < parsed.moves.length; i++) {
+      if (typeof onProgress === 'function') {
+        onProgress({
+          index: i,
+          total: parsed.moves.length,
+          move: parsed.moves[i],
+          cumulative: cumulative += 1,
+        });
+      }
+    }
+    return {
+      moveCount: parsed.moves.length,
+      warnings: parsed.warnings,
+      modal: parsed.modal,
+    };
+  }
+
+  // ============================================================================
+  // INIT
+  // ============================================================================
+
+  let ctx = null;
+
+  function init(context) {
+    ctx = context;
+    console.log(`[pentacad-sim] v${VERSION} initialized — G-code parser ready`);
+  }
+
+  function execute(request) {
+    const { method, params } = request || {};
+    if (method === 'sim.parse')    return parse(params.gcode);
+    if (method === 'sim.replay')   return replay(params.gcode, params.onProgress);
+    if (method === 'sim.kin')      return forwardKin(params.axes, ctx?.state?.machine?.kinematics);
+    if (method === 'sim.limits')   return isWithinLimits(params.axes, ctx?.state?.machine?.kinematics);
+    return { error: 'unknown_sim_method', method };
+  }
+
+  // ============================================================================
+  // PUBLIC API
+  // ============================================================================
+
+  return {
+    version: VERSION,
+    init,
+    execute,
+    parse,
+    forwardKin,
+    isWithinLimits,
+    replay,
+  };
+})();