Import LinuxCNC source tree

lib/python/mtc/lcnc_source.py

@@ -0,0 +1,279 @@
+# Copyright (C) 2026 LinuxCNC contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+# Read live machine state from LinuxCNC and normalize it for MTConnect.
+#
+# Wraps linuxcnc.stat() (poll-on-demand) and produces:
+#   * sample_values(): {dataitem_id: value} for the streaming DataItems
+#   * tool_assets():   list of CuttingToolAsset for /assets
+#
+# The module is import-safe without the linuxcnc extension so the rest of the
+# agent (and its tests) can be exercised offline.  The value/enum mappings
+# mirror src/emc/usr_intf/axis/extensions/emcmodule.cc.
+
+import os
+from dataclasses import dataclass
+
+from .observations import axis_index
+from .kinematics import LINEAR_LETTERS
+
+UNAVAILABLE = "UNAVAILABLE"
+
+# linuxcnc task_state / task_mode / interp_state enum values.  Read from the
+# linuxcnc module so they track the running build rather than a hardcoded ABI
+# assumption; the literals are only a fallback that keeps this module importable
+# without the extension (offline tooling and tests).
+try:
+    import linuxcnc as _lc
+except Exception:
+    _lc = None
+
+
+def _enum(name, fallback):
+    return getattr(_lc, name, fallback) if _lc is not None else fallback
+
+
+_STATE_ESTOP = _enum("STATE_ESTOP", 1)
+_MODE_MANUAL = _enum("MODE_MANUAL", 1)
+_MODE_AUTO = _enum("MODE_AUTO", 2)
+_MODE_MDI = _enum("MODE_MDI", 3)
+_INTERP_IDLE = _enum("INTERP_IDLE", 1)
+_INTERP_READING = _enum("INTERP_READING", 2)
+_INTERP_PAUSED = _enum("INTERP_PAUSED", 3)
+_INTERP_WAITING = _enum("INTERP_WAITING", 4)
+
+
+@dataclass
+class ToolAsset:
+    tool_no: int
+    pocket: int
+    in_spindle: bool
+    diameter: float = 0.0
+    length_z: float = 0.0      # Z length offset
+    length_x: float = 0.0      # X length offset (lathe)
+    orientation: int = 0
+    comment: str = ""
+
+    @property
+    def asset_id(self):
+        return "tool-%d" % self.tool_no
+
+
+class LcncSource:
+    def __init__(self, model, config):
+        self.model = model
+        self.config = config
+        # Native-length -> millimetre factor; every emitted length is canonical.
+        self._lin = getattr(config, "linear_scale", 1.0)
+        self.stat = None
+        self._live = False   # True once a poll has succeeded against a running instance
+        try:
+            import linuxcnc
+            self.stat = linuxcnc.stat()
+        except Exception as exc:  # no extension installed
+            self._import_error = exc
+
+    def available(self):
+        return self.stat is not None and self._live
+
+    def poll(self):
+        # stat() constructs even with no running LinuxCNC; poll() is what fails
+        # ("emcStatusBuffer invalid").  Tolerate it so the agent can start before
+        # task is up (and so offline tooling works) -- data appears once it does.
+        if self.stat is None:
+            return
+        try:
+            self.stat.poll()
+            self._live = True
+        except Exception:
+            self._live = False
+
+    # -- streaming values ----------------------------------------------------
+
+    def sample_values(self):
+        """Return {dataitem_id: value}; empty (-> UNAVAILABLE) when not live."""
+        if not self.available():
+            return {}
+        s = self.stat
+        vals = {}
+
+        vals["avail"] = "AVAILABLE"
+        vals["estop"] = "TRIGGERED" if _get(s, "task_state") == _STATE_ESTOP else "ARMED"
+        vals["mode"] = _MODE_NAMES.get(_get(s, "task_mode"), UNAVAILABLE)
+        vals["execution"] = _execution(s)
+        vals["program"] = _basename(_get(s, "file")) or UNAVAILABLE
+        # LINE_NUMBER subType=ACTUAL is the line being *executed*, so use
+        # motion_line (the motion controller's current segment,
+        # motion.traj.id) -- current_line is the interpreter read-ahead position,
+        # which races to the end of the program while the machine lags behind.
+        vals["line"] = _get(s, "motion_line", 0)
+        vals["pathfeed"] = round(_get(s, "current_vel", 0.0) * self._lin, 6)
+        vals["coolant_flood"] = "ON" if _get(s, "flood", 0) else "OFF"
+        vals["coolant_mist"] = "ON" if _get(s, "mist", 0) else "OFF"
+        vals["feedovr"] = round(_get(s, "feedrate", 1.0) * 100.0, 1)
+        vals["toolnum"] = _get(s, "tool_in_spindle", 0)
+        tool_no = _get(s, "tool_in_spindle", 0)
+        vals["toolasset"] = "tool-%d" % tool_no if tool_no and tool_no > 0 else UNAVAILABLE
+
+        vals["workoffset"] = self._work_offsets(s)
+        vals["tooloffset"] = self._tool_offset(s)
+        vals["xyrotation"] = round(_get(s, "rotation_xy", 0.0) or 0.0, 6)
+
+        actual = _get(s, "actual_position") or ()
+        commanded = _get(s, "position") or ()
+        for axis in self.model.axes:
+            idx = axis_index(axis.letter)
+            aid = axis.letter.lower()
+            scale = self._lin if axis.kind == "LINEAR" else 1.0  # angles stay deg
+            if idx < len(actual):
+                vals["pos_%s" % aid] = round(actual[idx] * scale, 6)
+            if idx < len(commanded):
+                vals["poscmd_%s" % aid] = round(commanded[idx] * scale, 6)
+
+        spindles = _get(s, "spindle") or ()
+        if spindles:
+            sp = spindles[0]
+            speed = sp.get("speed", 0.0)
+            override = sp.get("override", 1.0) if sp.get("override_enabled", True) else 1.0
+            vals["spdl_speed_cmd"] = round(speed, 3)
+            vals["spdl_speed"] = round(speed * override, 3)
+            direction = sp.get("direction", 0)
+            vals["spdl_dir"] = ("CLOCKWISE" if direction > 0
+                                else "COUNTER_CLOCKWISE" if direction < 0 else "UNAVAILABLE")
+            vals["spdl_mode"] = "SPINDLE"
+        return vals
+
+    def _work_offsets(self, s):
+        """Active G5x work offset (+ G92) as {name: {axis: value}}."""
+        letters = [a.letter for a in self.model.axes]
+        table = {}
+        name = _G5X_NAMES.get(_get(s, "g5x_index", 1), "G54")
+        g5x = _get(s, "g5x_offset") or ()
+        table[name] = _pose_cells(g5x, letters, self._lin)
+        g92 = _get(s, "g92_offset") or ()
+        g92_cells = _pose_cells(g92, letters, self._lin)
+        if any(v != 0.0 for v in g92_cells.values()):
+            table["G92"] = g92_cells
+        return table
+
+    def _tool_offset(self, s):
+        """Applied tool length offset (G43) as {tool_key: {axis: value}}."""
+        letters = [a.letter for a in self.model.axes]
+        cells = _pose_cells(_get(s, "tool_offset") or (), letters, self._lin)
+        tool = _get(s, "tool_in_spindle", 0)
+        key = "T%d" % tool if tool and tool > 0 else "G43"
+        return {key: cells}
+
+    # -- assets --------------------------------------------------------------
+
+    def tool_assets(self):
+        """Return the current tool table as ToolAsset entries."""
+        if not self.available():
+            return []
+        s = self.stat
+        in_spindle = _get(s, "tool_in_spindle", 0)
+        assets = []
+        for entry in (_get(s, "tool_table") or ()):
+            tool_no = getattr(entry, "id", 0)
+            if tool_no <= 0:
+                continue  # index 0 is the "fake pocket" spindle mirror
+            info = self._toolinfo(tool_no)
+            assets.append(ToolAsset(
+                tool_no=tool_no,
+                # tool_table entries carry no real pocket; only toolinfo() does.
+                # On a random toolchanger the pocket != the tool number.
+                pocket=_as_int(info.get("pocketno"), tool_no),
+                in_spindle=(tool_no == in_spindle),
+                diameter=getattr(entry, "diameter", 0.0) * self._lin,
+                length_z=getattr(entry, "zoffset", 0.0) * self._lin,
+                length_x=getattr(entry, "xoffset", 0.0) * self._lin,
+                orientation=getattr(entry, "orientation", 0),
+                comment=(info.get("comment", "") or "").strip(),
+            ))
+        return assets
+
+    def _toolinfo(self, tool_no):
+        """Return stat.toolinfo(tool_no) as a dict, or {} if unavailable.
+
+        stat.tool_table entries omit the comment (the struct-sequence binding
+        drops it) and carry no real pocket number; stat.toolinfo(toolno) returns
+        a dict with both.  toolinfo rejects toolno==0 and may raise before
+        tooldata is ready.
+        """
+        info = getattr(self.stat, "toolinfo", None)
+        if info is None or tool_no <= 0:
+            return {}
+        try:
+            return info(tool_no) or {}
+        except Exception:
+            return {}
+
+
+_MODE_NAMES = {
+    _MODE_MANUAL: "MANUAL",
+    _MODE_AUTO: "AUTOMATIC",
+    _MODE_MDI: "MANUAL_DATA_INPUT",
+}
+
+
+def _execution(stat):
+    interp = _get(stat, "interp_state", _INTERP_IDLE)
+    if _get(stat, "task_paused", 0):
+        return "INTERRUPTED"
+    if interp == _INTERP_IDLE:
+        return "READY"
+    if interp == _INTERP_WAITING:
+        return "ACTIVE"
+    if interp in (_INTERP_READING, _INTERP_PAUSED):
+        return "ACTIVE" if interp == _INTERP_READING else "INTERRUPTED"
+    return "ACTIVE"
+
+
+_G5X_NAMES = {1: "G54", 2: "G55", 3: "G56", 4: "G57", 5: "G58",
+              6: "G59", 7: "G59.1", 8: "G59.2", 9: "G59.3"}
+
+
+def _pose_cells(pose, letters, lin_scale=1.0):
+    """Map an EmcPose 9-tuple to {axis_letter: value} for configured axes.
+
+    Linear components (X Y Z U V W) are converted to millimetres; angular
+    components (A B C) are left in degrees.
+    """
+    cells = {}
+    for letter in letters:
+        idx = axis_index(letter)
+        if idx < len(pose):
+            scale = lin_scale if letter in LINEAR_LETTERS else 1.0
+            cells[letter] = round(pose[idx] * scale, 6)
+    return cells
+
+
+def _get(stat, attr, default=None):
+    try:
+        return getattr(stat, attr)
+    except Exception:
+        return default
+
+
+def _basename(path):
+    return os.path.basename(path) if path else ""
+
+
+def _as_int(value, default):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default