meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

meerk40t/fill/patterns.py

@@ -154,12 +154,8 @@ class LivingHinges:
         if outer_path is None:
             return
         self.path = Geomstr()
-        clip = Geomstr()
-        for sp in outer_path.as_subpaths():
-            pts = list(sp.as_interpolated_points(interpolate=100))
-            # pts = [Path(sp).point(i / 100.0, error=1e4) for i in range(101)]
-            clip.polyline(pts)
-            # clip.end()
+
+        clip = outer_path
 
         q = Clip(clip)
         subject = Geomstr()

meerk40t/grbl/controller.py

@@ -2,6 +2,14 @@
 GRBL Controller
 
 Tasked with sending data to the different connection.
+
+Validation Stages.
+        Stage 0, we are disconnected and invalid.
+        Stage 1, we are connected and need to check if we are GRBL send $
+        Stage 2, we parsed $ and need to try $$ $G
+        Stage 3, we successfully parsed $$
+        Stage 4, we successfully parsed $G, send ?
+        Stage 5, we successfully parsed ?
 """
 import re
 import threading
@@ -12,6 +20,83 @@ from meerk40t.kernel import signal_listener
 SETTINGS_MESSAGE = re.compile(r"^\$([0-9]+)=(.*)")
 
 
+def hardware_settings(code):
+    """
+    Given a $# code returns the parameter and the units.
+
+    @param code: $$ code.
+    @return: parameter, units
+    """
+    if code == 0:
+        return 10, "step pulse time", "microseconds"
+    if code == 1:
+        return 25, "step idle delay", "milliseconds"
+    if code == 2:
+        return 0, "step pulse invert", "bitmask"
+    if code == 3:
+        return 0, "step direction invert", "bitmask"
+    if code == 4:
+        return 0, "invert step enable pin", "boolean"
+    if code == 5:
+        return 0, "invert limit pins", "boolean"
+    if code == 6:
+        return 0, "invert probe pin", "boolean"
+    if code == 10:
+        return 255, "status report options", "bitmask"
+    if code == 11:
+        return 0.010, "Junction deviation", "mm"
+    if code == 12:
+        return 0.002, "arc tolerance", "mm"
+    if code == 13:
+        return 0, "Report in inches", "boolean"
+    if code == 20:
+        return 0, "Soft limits enabled", "boolean"
+    if code == 21:
+        return 0, "hard limits enabled", "boolean"
+    if code == 22:
+        return 0, "Homing cycle enable", "boolean"
+    if code == 23:
+        return 0, "Homing direction invert", "bitmask"
+    if code == 24:
+        return 25.000, "Homing locate feed rate", "mm/min"
+    if code == 25:
+        return 500.000, "Homing search seek rate", "mm/min"
+    if code == 26:
+        return 250, "Homing switch debounce delay", "ms"
+    if code == 27:
+        return 1.000, "Homing switch pull-off distance", "mm"
+    if code == 30:
+        return 1000, "Maximum spindle speed", "RPM"
+    if code == 31:
+        return 0, "Minimum spindle speed", "RPM"
+    if code == 32:
+        return 1, "Laser mode enable", "boolean"
+    if code == 100:
+        return 250.000, "X-axis steps per millimeter", "steps"
+    if code == 101:
+        return 250.000, "Y-axis steps per millimeter", "steps"
+    if code == 102:
+        return 250.000, "Z-axis steps per millimeter", "steps"
+    if code == 110:
+        return 500.000, "X-axis max rate", "mm/min"
+    if code == 111:
+        return 500.000, "Y-axis max rate", "mm/min"
+    if code == 112:
+        return 500.000, "Z-axis max rate", "mm/min"
+    if code == 120:
+        return 10.000, "X-axis acceleration", "mm/s^2"
+    if code == 121:
+        return 10.000, "Y-axis acceleration", "mm/s^2"
+    if code == 122:
+        return 10.000, "Z-axis acceleration", "mm/s^2"
+    if code == 130:
+        return 200.000, "X-axis max travel", "mm"
+    if code == 131:
+        return 200.000, "Y-axis max travel", "mm"
+    if code == 132:
+        return 200.000, "Z-axis max travel", "mm"
+
+
 def grbl_error_code(code):
     long = ""
     short = f"Error #{code}"
@@ -156,53 +241,14 @@ class GrblController:
     def __init__(self, context):
         self.service = context
         self.connection = None
+        self._validation_stage = 0
 
         self.update_connection()
 
         self.driver = self.service.driver
-        self.grbl_settings = {
-            0: 10,  # step pulse microseconds
-            1: 25,  # step idle delay
-            2: 0,  # step pulse invert
-            3: 0,  # step direction invert
-            4: 0,  # invert step enable pin, boolean
-            5: 0,  # invert limit pins, boolean
-            6: 0,  # invert probe pin
-            10: 255,  # status report options
-            11: 0.010,  # Junction deviation, mm
-            12: 0.002,  # arc tolerance, mm
-            13: 0,  # Report in inches
-            20: 0,  # Soft limits enabled.
-            21: 0,  # hard limits enabled
-            22: 0,  # Homing cycle enable
-            23: 0,  # Homing direction invert
-            24: 25.000,  # Homing locate feed rate, mm/min
-            25: 500.000,  # Homing search seek rate, mm/min
-            26: 250,  # Homing switch debounce delay, ms
-            27: 1.000,  # Homing switch pull-off distance, mm
-            30: 1000,  # Maximum spindle speed, RPM
-            31: 0,  # Minimum spindle speed, RPM
-            32: 1,  # Laser mode enable, boolean
-            100: 250.000,  # X-axis steps per millimeter
-            101: 250.000,  # Y-axis steps per millimeter
-            102: 250.000,  # Z-axis steps per millimeter
-            110: 500.000,  # X-axis max rate mm/min
-            111: 500.000,  # Y-axis max rate mm/min
-            112: 500.000,  # Z-axis max rate mm/min
-            120: 10.000,  # X-axis acceleration, mm/s^2
-            121: 10.000,  # Y-axis acceleration, mm/s^2
-            122: 10.000,  # Z-axis acceleration, mm/s^2
-            130: 200.000,  # X-axis max travel mm.
-            131: 200.000,  # Y-axis max travel mm
-            132: 200.000,  # Z-axis max travel mm.
-        }
 
         # Welcome message into, indicates the device is initialized.
         self.welcome = self.service.setting(str, "welcome", "Grbl")
-        self._requires_validation = self.service.setting(
-            bool, "requires_validation", True
-        )
-        self._connection_validated = not self._requires_validation
 
         # Sending variables.
         self._sending_thread = None
@@ -321,6 +367,8 @@ class GrblController:
             self.log("Could not connect.", type="event")
             return
         self.log("Connecting to GRBL...", type="event")
+        self._validation_stage = 1
+        self.realtime("$\r\n")
 
     def close(self):
         """
@@ -331,8 +379,8 @@ class GrblController:
         if not self.connection.connected:
             return
         self.connection.disconnect()
-        self._connection_validated = not self._requires_validation
         self.log("Disconnecting from GRBL...", type="event")
+        self._validation_stage = 0
 
     def write(self, data):
         """
@@ -386,6 +434,7 @@ class GrblController:
             self.add_watcher(self._channel_log)
 
         if self._sending_thread is None:
+            self._sending_thread = True  # Avoid race condition.
             self._sending_thread = self.service.threaded(
                 self._sending,
                 thread_name=f"sender-{self.service.location()}",
@@ -393,6 +442,7 @@ class GrblController:
                 daemon=True,
             )
         if self._recving_thread is None:
+            self._recving_thread = True  # Avoid race condition.
             self._recving_thread = self.service.threaded(
                 self._recving,
                 thread_name=f"recver-{self.service.location()}",
@@ -454,6 +504,7 @@ class GrblController:
         if line is not None:
             self._send(line)
         if "\x18" in line:
+            self._paused = False
             with self._forward_lock:
                 self._forward_buffer.clear()
 
@@ -476,9 +527,7 @@ class GrblController:
         @return:
         """
         with self._loop_cond:
-            self.service.signal("pipe;running", False)
             self._loop_cond.wait()
-            self.service.signal("pipe;running", True)
 
     def _send_resume(self):
         """
@@ -497,21 +546,24 @@ class GrblController:
         @return:
 
         """
-        self.service.signal("pipe;running", True)
         while self.connection.connected:
             if self._realtime_queue:
                 # Send realtime data.
                 self._sending_realtime()
                 continue
-            if self._paused or not self._connection_validated:
-                # We are paused. We do not send anything other than realtime commands.
+            if self._paused or not self.fully_validated():
+                # We are paused or invalid. We do not send anything other than realtime commands.
                 time.sleep(0.05)
                 continue
             if not self._sending_queue:
                 # There is nothing to write/realtime
+                self.service.laser_status = "idle"
                 self._send_halt()
                 continue
             buffer = len(self._forward_buffer)
+            if buffer:
+                self.service.laser_status = "active"
+
             if self.service.buffer_mode == "sync":
                 if buffer:
                     # Any buffer is too much buffer. Halt.
@@ -525,7 +577,7 @@ class GrblController:
                     continue
             # Go for send_line
             self._sending_single_line()
-        self.service.signal("pipe;running", False)
+        self.service.laser_status = "idle"
 
     ####################
     # GRBL RECV ROUTINES
@@ -616,6 +668,9 @@ class GrblController:
                 self._process_feedback_message(response)
                 continue
             elif response.startswith("$"):
+                if self._validation_stage == 2:
+                    self.log("Stage 3: $$ was successfully parsed.", type="event")
+                    self._validation_stage = 3
                 self._process_settings_message(response)
                 continue
             elif response.startswith("ALARM"):
@@ -631,11 +686,15 @@ class GrblController:
             elif response.startswith(">"):
                 self.log(f"STARTUP: {response}", type="event")
             elif response.startswith(self.welcome):
-                self.log("Connection Confirmed.", type="event")
-                self._connection_validated = True
+                self.log("Device Reset, revalidation required", type="event")
+                if self.fully_validated():
+                    self._validation_stage = 1
+                    self.realtime("$\r\n")
             else:
                 self._assembled_response.append(response)
-        self.service.signal("pipe;running", False)
+
+    def fully_validated(self):
+        return self._validation_stage == 5
 
     def _process_status_message(self, response):
         message = response[1:-1]
@@ -655,6 +714,39 @@ class GrblController:
                 f, s = info.split(",")
                 self.service.signal("grbl:speed", float(f))
                 self.service.signal("grbl:power", float(s))
+            elif name == "MPos":
+                coords = info.split(",")
+                try:
+                    nx = float(coords[0])
+                    ny = float(coords[1])
+
+                    if not self.fully_validated():
+                        # During validation, we declare positions.
+                        self.driver.declare_position(nx, ny)
+                    ox = self.driver.mpos_x
+                    oy = self.driver.mpos_y
+
+                    x, y = self.service.view_mm.position(f"{nx}mm", f"{ny}mm")
+
+                    (
+                        self.driver.mpos_x,
+                        self.driver.mpos_y,
+                    ) = self.service.view_mm.scene_position(f"{x}mm", f"{y}mm")
+
+                    if len(coords) >= 3:
+                        self.driver.mpos_z = float(coords[2])
+                    self.service.signal(
+                        "status;position",
+                        (ox, oy, self.driver.mpos_x, self.driver.mpos_y),
+                    )
+                except ValueError:
+                    pass
+            elif name == "WPos":
+                coords = info.split(",")
+                self.driver.wpos_x = coords[0]
+                self.driver.wpos_y = coords[1]
+                if len(coords) >= 3:
+                    self.driver.wpos_z = coords[2]
             # See: https://github.com/grbl/grbl/blob/master/grbl/report.c#L421
             # MPos: Coord values. Machine Position.
             # WPos: MPos but with applied work coordinates. Work Position.
@@ -664,6 +756,9 @@ class GrblController:
             # Lim: limits states
             # Ctl: control pins and mask (binary).
             self.service.signal(f"grbl:status:{name}", info)
+        if self._validation_stage in (2, 3, 4):
+            self.log("Connection Confirmed.", type="event")
+            self._validation_stage = 5
 
     def _process_feedback_message(self, response):
         if response.startswith("[MSG:"):
@@ -671,11 +766,29 @@ class GrblController:
             self.log(message, type="event")
             self.service.channel("console")(message)
         elif response.startswith("[GC:"):
+            # Parsing $G
             message = response[4:-1]
+            states = list(message.split(" "))
+            if not self.fully_validated():
+                self.log("Stage 4: $G was successfully parsed.", type="event")
+                self.driver.declare_modals(states)
+                self._validation_stage = 4
+                self.realtime("?\r\n")
             self.log(message, type="event")
-            self.service.signal("grbl:states", list(message.split(" ")))
+            self.service.signal("grbl:states", states)
         elif response.startswith("[HLP:"):
+            # Parsing $
             message = response[5:-1]
+            if self._validation_stage == 1:
+                self.log("Stage 2: $ was successfully parsed.", type="event")
+                self._validation_stage = 2
+                if "$$" in message:
+                    self.realtime("$$\r\n")
+                if "$G" in message:
+                    self.realtime("$G\r\n")
+                elif "?" in message:
+                    # No $G just request status.
+                    self.realtime("?\r\n")
             self.log(message, type="event")
         elif response.startswith("[G54:"):
             message = response[5:-1]
@@ -782,6 +895,9 @@ class GrblController:
         match = SETTINGS_MESSAGE.match(response)
         if match:
             try:
-                self.grbl_settings[int(match.group(1))] = float(match.group(2))
+                key = int(match.group(1))
+                value = float(match.group(2))
+                self.service.hardware_config[key] = value
+                self.service.signal(f"grbl:hwsettings", key, value)
             except ValueError:
                 pass

meerk40t/grbl/device.py

@@ -10,22 +10,25 @@ from meerk40t.kernel import CommandSyntaxError, Service
 
 from ..core.laserjob import LaserJob
 from ..core.spoolers import Spooler
-from ..core.units import UNITS_PER_MIL, Length
+from ..core.units import MM_PER_INCH, Length
 from ..core.view import View
+from ..device.mixins import Status
 from .controller import GrblController
 from .driver import GRBLDriver
 
 
-class GRBLDevice(Service):
+class GRBLDevice(Service, Status):
     """
     GRBLDevice is driver for the Gcode Controllers
     """
 
     def __init__(self, kernel, path, *args, choices=None, **kwargs):
+        self.hardware_config = {}
         self.permit_tcp = True
         self.permit_serial = True
 
         Service.__init__(self, kernel, path)
+        Status.__init__(self)
         self.name = "GRBLDevice"
         self.extension = "gcode"
         if choices is not None:
@@ -232,6 +235,12 @@ class GRBLDevice(Service):
             dpi_x=1000.0,
             dpi_y=1000.0,
         )
+        self.view_mm = View(
+            self.bedwidth,
+            self.bedheight,
+            dpi_x=MM_PER_INCH,
+            dpi_y=MM_PER_INCH,
+        )
         self.realize()
         self.settings = dict()
         self.state = 0
@@ -451,17 +460,6 @@ class GRBLDevice(Service):
                 "conditional": (self, "use_red_dot"),
                 "section": "_10_Red Dot",
             },
-            {
-                "attr": "requires_validation",
-                "object": self,
-                "default": True,
-                "type": bool,
-                "label": _("Require validation for device"),
-                "tip": _(
-                    "Ensure device is completely initialized before sending data. This is usually known to be valid at the 'Grbl xx.x' version message."
-                ),
-                "section": "_40_Validation",
-            },
             {
                 "attr": "welcome",
                 "object": self,
@@ -471,7 +469,6 @@ class GRBLDevice(Service):
                 "tip": _(
                     "If for some reason the device needs a different welcome validator than 'Grbl' (default), for example, somewhat custom grbl-like firmware"
                 ),
-                "conditional": (self, "requires_validation"),
                 "section": "_40_Validation",
             },
         ]
@@ -523,7 +520,7 @@ class GRBLDevice(Service):
         )
         def soft_reset(command, channel, _, data=None, remainder=None, **kwgs):
             self.driver.reset()
-            self.signal("pipe;running", False)
+            self.laser_status = "idle"
 
         @self.console_command(
             "estop",
@@ -532,8 +529,7 @@ class GRBLDevice(Service):
         )
         def estop(command, channel, _, data=None, remainder=None, **kwgs):
             self.driver.reset()
-            self.signal("pipe;running", False)
-            self.signal("pause")
+            self.laser_status = "idle"
 
         @self.console_command(
             "clear_alarm",
@@ -542,7 +538,7 @@ class GRBLDevice(Service):
         )
         def clear_alarm(command, channel, _, data=None, remainder=None, **kwgs):
             self.driver.clear_alarm()
-            self.signal("pipe;running", False)
+            self.laser_status = "idle"
 
         @self.console_command(
             "pause",
@@ -755,6 +751,15 @@ class GRBLDevice(Service):
             flip_y=self.flip_y,
             swap_xy=self.swap_xy,
         )
+        self.view_mm.set_dims(self.bedwidth, self.bedheight)
+        self.view_mm.transform(
+            user_scale_x=self.scale_x,
+            user_scale_y=self.scale_y,
+            flip_x=self.flip_x,
+            flip_y=self.flip_y,
+            swap_xy=self.swap_xy,
+        )
+
         # rotary_active=self.rotary_active,
         # rotary_scale_x=self.rotary_scale_x,
         # rotary_scale_y=self.rotary_scale_y,

meerk40t/grbl/driver.py

@@ -34,6 +34,15 @@ class GRBLDriver(Parameters):
         self.paused = False
         self.native_x = 0
         self.native_y = 0
+
+        self.mpos_x = 0
+        self.mpos_y = 0
+        self.mpos_z = 0
+
+        self.wpos_x = 0
+        self.wpos_y = 0
+        self.wpos_z = 0
+
         self.stepper_step_size = UNITS_PER_MIL
 
         self.plot_planner = PlotPlanner(
@@ -254,6 +263,8 @@ class GRBLDriver(Parameters):
             self(f"M4{self.line_end}")
         for q in self.queue:
             while self.hold_work(0):
+                if self.service.kernel.is_shutdown:
+                    return
                 time.sleep(0.05)
             x = self.native_x
             y = self.native_y
@@ -517,6 +528,7 @@ class GRBLDriver(Parameters):
         """
         self.paused = True
         self(f"!{self.line_end}", real=True)
+        self.service.signal("pause")
 
     def resume(self, *args):
         """
@@ -529,6 +541,7 @@ class GRBLDriver(Parameters):
         """
         self.paused = False
         self(f"~{self.line_end}", real=True)
+        self.service.signal("pause")
 
     def clear_states(self):
         self.power_dirty = True
@@ -562,6 +575,7 @@ class GRBLDriver(Parameters):
         self.units_dirty = True
 
         self.paused = False
+        self.service.signal("pause")
 
     def clear_alarm(self):
         """
@@ -571,6 +585,31 @@ class GRBLDriver(Parameters):
         """
         self(f"$X{self.line_end}", real=True)
 
+    def declare_modals(self, modals):
+        self.move_mode = 0 if "G0" in modals else 1
+        if "G90" in modals:
+            self._g90_absolute()
+            self.absolute_dirty = False
+        if "G91" in modals:
+            self._g91_relative()
+            self.absolute_dirty = False
+        if "G94" in modals:
+            self._g94_feedrate()
+            self.feedrate_dirty = False
+        if "G93" in modals:
+            self._g93_feedrate()
+            self.feedrate_dirty = False
+        if "G20" in modals:
+            self._g20_units_inch()
+            self.units_dirty = False
+        if "G21" in modals:
+            self._g21_units_mm()
+            self.units_dirty = False
+
+    def declare_position(self, x, y):
+        self.native_x = x * self.unit_scale
+        self.native_y = y * self.unit_scale
+
     ####################
     # PROTECTED DRIVER CODE
     ####################