meerk40t 0.9.7050__py2.py3-none-any.whl → 0.9.7900__py2.py3-none-any.whl

meerk40t/gui/wxutils.py

@@ -1650,58 +1650,31 @@ class wxCheckListBox(StaticBoxSizer):
         **kwargs,
     ):
         self.parent = parent
-        self.choices = choices
+        self.choices = []
         self._children = []
-        self._tool_tip = None
+        self._tool_tip = ""
         self._help = None
         super().__init__(
             parent=parent, id=wx.ID_ANY, label=label, orientation=wx.VERTICAL
         )
         self.majorDimension = majorDimension
         self.style = style
-        self._build_controls()
-
-    def _build_controls(self):
-        """
-        Build the controls for the CheckListBox.
-        This method is called during initialization to create the checkboxes.
-        """
-        if self.choices is None:
-            self.choices = []
-        if self.majorDimension == 0 or self.style == wx.RA_SPECIFY_ROWS:
-            self.majorDimension = 1000
-        container = None
-        for idx, c in enumerate(self.choices):
-            if idx % self.majorDimension == 0:
-                container = wx.BoxSizer(wx.HORIZONTAL)
-                self.Add(container, 0, wx.EXPAND, 0)
-            check_option = wx.CheckBox(self.parent, wx.ID_ANY, label=c)
-            container.Add(check_option, 1, wx.ALIGN_CENTER_VERTICAL, 0)
-            self._children.append(check_option)
-
-        if platform.system() == "Linux":
-
-            def on_mouse_over_check(ctrl):
-                def mouse(event=None):
-                    ctrl.SetToolTip(self._tool_tip)
-                    event.Skip()
-
-                return mouse
-
-            for ctrl in self._children:
-                ctrl.Bind(wx.EVT_MOTION, on_mouse_over_check(ctrl))
-
-        for ctrl in self._children:
-            ctrl.Bind(wx.EVT_CHECKBOX, self.on_check)
-            ctrl.Bind(wx.EVT_RIGHT_DOWN, self.on_right_click)
-
-        for ctrl in self._children:
-            set_color_according_to_theme(ctrl, "text_bg", "text_fg")
+        if choices is None:
+            choices = []
+        self.Set(choices)
 
     @property
     def Children(self):
         return self._children
 
+    def on_mouse_over_check(self, event):
+        """
+        Handle mouse over events to show tooltips on Linux.
+        """
+        if self._tool_tip:
+            event.GetEventObject().SetToolTip(self._tool_tip)
+        event.Skip()
+
     def GetParent(self):
         return self.parent
 
@@ -1764,6 +1737,11 @@ class wxCheckListBox(StaticBoxSizer):
             ),
             id=item.GetId(),
         )
+        # Test routines
+        # item = menu.Append(wx.ID_ANY, "Test-Routine to set few items", "")
+        # parent.Bind(wx.EVT_MENU, lambda e: self.Set(["A", "B", "C"]), id=item.GetId())
+        # item = menu.Append(wx.ID_ANY, "Test-Routine to set many items", "")
+        # parent.Bind(wx.EVT_MENU, lambda e: self.Set([f"Item {i}" for i in range(20)]), id=item.GetId())
         parent.PopupMenu(menu)
         menu.Destroy()
 
@@ -1843,9 +1821,55 @@ class wxCheckListBox(StaticBoxSizer):
         :param choices: A list of strings to set as choices.
         """
         # print (f"Setting choices for {self.GetLabel()}: {choices}")
-        self.Clear()
+        """
+        This is more efficient than clearing and rebuilding the controls.
+        Update the labels of existing controls to match new_choices.
+        If there are more controls than choices, extra controls are destroyed.
+        If there are fewer controls than choices, new controls are created.
+        """
+        # Update existing controls
+        if self.majorDimension == 0 or self.style == wx.RA_SPECIFY_ROWS:
+            self.majorDimension = 1000
+        last_container = None
+        for idx, choice in enumerate(choices):
+            if idx < len(self._children):
+                self._children[idx].SetLabel(choice)
+                # self._children[idx].Show(True)
+            else:
+                # Add new controls if needed
+                check_option = wx.CheckBox(self.parent, wx.ID_ANY, label=choice)
+                if self._tool_tip:
+                    check_option.SetToolTip(self._tool_tip)
+                check_option.Bind(wx.EVT_CHECKBOX, self.on_check)
+                check_option.Bind(wx.EVT_RIGHT_DOWN, self.on_right_click)
+                if platform.system() == "Linux":
+                    check_option.Bind(wx.EVT_MOTION, self.on_mouse_over_check)
+                set_color_according_to_theme(check_option, "text_bg", "text_fg")
+                self._children.append(check_option)
+                # Add to layout
+                # Find or create the appropriate container
+                if idx % self.majorDimension == 0:
+                    last_container = wx.BoxSizer(wx.HORIZONTAL)
+                    self.Add(last_container, 0, wx.EXPAND, 0)
+                else:
+                    # Find the last container
+                    if last_container is None:
+                        for c in self.GetChildren():
+                            if c.IsSizer():
+                                last_container = c.GetSizer()
+                    if last_container is None:
+                        # fallback: create new container
+                        last_container = wx.BoxSizer(wx.HORIZONTAL)
+                        self.Add(last_container, 0, wx.EXPAND, 0)
+                last_container.Add(check_option, 1, wx.ALIGN_CENTER_VERTICAL, 0)
+        # Remove extra controls
+        if len(self._children) > len(choices):
+            for idx in range(len(choices), len(self._children)):
+                self._children[idx].Destroy()
+            self._children = self._children[: len(choices)]
+        self.Layout()
+        self.parent.Layout()
         self.choices = list(choices)
-        self._build_controls()
 
 
 ##############

meerk40t/kernel/inhibitor.py

@@ -0,0 +1,120 @@
+"""
+This modules prevents the OS from sleeping / hibernating.
+It is used to ensure that the system remains active during long-running operations.
+It is not intended to be used for general-purpose tasks.
+"""
+
+import ctypes
+import platform
+import subprocess
+
+_ES_CONTINUOUS = 0x80000000
+_ES_SYSTEM_REQUIRED = 0x00000001
+
+# Extract common target list up top
+_SYSTEMCTL_TARGETS = [
+    "sleep.target",
+    "suspend.target",
+    "hibernate.target",
+    "hybrid-sleep.target",
+]
+
+
+def _run_systemctl(action: str):
+    try:
+        # Check if systemctl is available
+        proc = subprocess.run(["systemctl", action] + _SYSTEMCTL_TARGETS)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("systemctl is not available on this system.")
+        return False
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return False
+    # print(f"systemctl {action} returned {proc.returncode} [{proc}]")
+    return proc.returncode == 0
+
+
+def _darwin_inhibit():
+    try:
+        proc = subprocess.run(["caffeinate", "-i"])
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("caffeinate is not available on this system.")
+        return False
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return False
+    return proc.returncode == 0
+
+
+def _darwin_release():
+    try:
+        # Use killall to stop caffeinate
+        proc = subprocess.run(["killall", "caffeinate"])
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return False
+    return proc.returncode == 0
+
+
+def _linux_inhibit():
+    return _run_systemctl("mask")
+
+
+def _linux_release():
+    return _run_systemctl("unmask")
+
+
+def _windows_inhibit():
+    try:
+        # Set the thread execution state to prevent sleep
+        ctypes.windll.kernel32.SetThreadExecutionState(
+            _ES_CONTINUOUS | _ES_SYSTEM_REQUIRED
+        )
+    except Exception as e:
+        print(f"An error occurred while setting thread execution state: {e}")
+        return False
+    return True
+
+
+def _windows_release():
+    try:
+        # Reset the thread execution state to allow sleep
+        ctypes.windll.kernel32.SetThreadExecutionState(_ES_CONTINUOUS)
+    except Exception as e:
+        print(f"An error occurred while resetting thread execution state: {e}")
+        return False
+    return True
+
+
+# Darwin does not have a systemctl, but uses caffeinate
+# Linux uses systemctl to mask/unmask sleep targets
+# Windows uses SetThreadExecutionState to prevent sleep
+# NB: Darwin does not to work relaibly on my testsystem, so has been disabled
+_ACTIONS = {
+    # "Darwin": {"inhibit": _darwin_inhibit, "release": _darwin_release},
+    "Linux": {"inhibit": _linux_inhibit, "release": _linux_release},
+    "Windows": {"inhibit": _windows_inhibit, "release": _windows_release},
+}
+
+
+class Inhibitor:
+    def __init__(self):
+        self._os = platform.system()
+        self.active = False
+        self._actions = _ACTIONS.get(self._os)
+
+    @property
+    def available(self) -> bool:
+        return self._actions is not None
+
+    def inhibit(self):
+        if not self.available or self.active:
+            return
+        if self._actions["inhibit"]():
+            self.active = True
+
+    def release(self):
+        if not self.available or not self.active:
+            return
+        if self._actions["release"]():
+            self.active = False

meerk40t/kernel/kernel.py

@@ -19,6 +19,7 @@ from .functions import (
     console_option,
     get_safe_path,
 )
+from .inhibitor import Inhibitor
 from .jobs import ConsoleFunction, Job
 from .lifecycles import *
 from .module import Module
@@ -183,6 +184,7 @@ class Kernel(Settings):
         self.os_information = self._get_environment()
         self.show_aio_prompt = True
         self.silent_mode = False
+        self.inhibitor = Inhibitor()
 
     def __str__(self):
         return f"Kernel({self.name}, {self.profile}, {self.version})"
@@ -2855,6 +2857,42 @@ class Kernel(Settings):
                 channel(_("Syntax Error: timer<name> <times> <interval> <command>"))
             return
 
+        # ==========
+        # Sleep Commands
+        # ==========
+        @self.console_argument(
+            "mode", type=str, help=_("Mode to set: prevent/allow"), default=None
+        )
+        @self.console_command(
+            "system_hibernate", _("Prevent/allow system hibernation.")
+        )
+        def system_hibernate(channel, _, mode=None, **kwargs):
+            """
+            Prevent or allow system hibernation. This is a toggle command.
+            If no mode is specified, it will print the current state.
+            """
+            if not self.inhibitor.available:
+                channel(_("Inhibitor is not available on this system."))
+                return
+            if mode is not None:
+                if mode.lower() not in ("prevent", "allow"):
+                    channel(_("Please specify 'prevent' or 'allow'."))
+                    return
+                if mode.lower() == "prevent":
+                    self.inhibitor.inhibit()
+                else:
+                    self.inhibitor.release()
+            sudo_msg = _("You might need system administrator priviliges.")
+            if self.inhibitor.active:
+                channel(_("System hibernation is prevented."))
+            else:
+                channel(_("System hibernation is allowed."))
+            if self.os_information["OS_NAME"] == "Linux" and (
+                (mode == "prevent" and not self.inhibitor.active)
+                or (mode == "allow" and self.inhibitor.active)
+            ):
+                channel(sudo_msg)
+
         # ==========
         # CORE OBJECTS COMMANDS
         # ==========

meerk40t/lihuiyu/controller.py

@@ -124,10 +124,21 @@ def onewire_crc_lookup(line):
     @param line: line to be CRC'd
     @return: 8 bit crc of line.
     """
+
     crc = 0
     for i in range(0, 30):
         crc = line[i] ^ crc
         crc = crc_table[crc & 0x0F] ^ crc_table[16 + ((crc >> 4) & 0x0F)]
+
+    """ Print the line in hex and ascii format for debugging purposes.
+    def hex_repr(data):
+        return " ".join(f"{x:02x}" for x in data)
+
+    def ascii_repr(data):
+        return "".join(chr(x) if 32 <= x < 127 else "." for x in data)
+
+    print (f"Line ({len(line)} bytes): {hex_repr(line)} {ascii_repr(line)} CRC: {hex(crc)}")
+    """
     return crc
 
 
@@ -618,6 +629,16 @@ class LihuiyuController:
                 self._preempt.clear()
             self.update_buffer()
 
+    def debug_packet(self, packet):
+        """
+        Debugging function to print the packet in a readable format.
+        We will output both hex and ascii representation of the packet.
+        @param packet: Packet to debug.
+        """
+        hex_packet = " ".join(f"{b:02x}" for b in packet)
+        ascii_packet = "".join(chr(b) if 32 <= b < 127 else "." for b in packet)
+        print(f"Packet: {hex_packet} | ASCII: {ascii_packet} (len={len(packet)})")
+
     def process_queue(self):
         """
         Attempts to process the buffer/queue
@@ -662,6 +683,13 @@ class LihuiyuController:
         post_send_command = None
         default_checksum = True
 
+        if packet.startswith(b"AT"):
+            # This is as special case for the M3 only:
+            # AT command packages are padded with 0x00 and not 'F' as usal
+            if packet.endswith(b"\n"):
+                packet = packet[:-1]
+            c = b"\x00"
+            packet += c * (30 - len(packet))  # Padding with 0 character
         # find pipe commands.
         if packet.endswith(b"\n"):
             packet = packet[:-1]
@@ -691,7 +719,7 @@ class LihuiyuController:
                 self.update_state("terminate")
                 self.is_shutdown = True
                 packet = packet[:-1]
-            if packet.startswith(b"A"):
+            if packet.startswith(b"A") and not packet.startswith(b"AT"):
                 # This is a challenge code. A is only used for serial challenges.
                 post_send_command = self._confirm_serial
             if len(packet) != 0:
@@ -703,13 +731,14 @@ class LihuiyuController:
                         c = b"F"  # Packet was simply #. We can do nothing.
                     packet += bytes([c]) * (30 - len(packet))  # Padding. '\n'
                 else:
-                    packet += b"F" * (30 - len(packet))  # Padding. '\n'
+                    padder = b"\x00" if packet.startswith(b"AT") else b"F"
+                    packet += padder * (30 - len(packet))  # Padding. '\n'
         if not realtime and self.state in ("pause", "busy"):
             return False  # Processing normal queue, PAUSE and BUSY apply.
 
         # Packet is prepared and ready to send. Open Channel.
         self.open()
-
+        # print (f"Packet: {packet!r} (len={len(packet)})"    )
         if len(packet) == 30:
             # We have a sendable packet.
             if not self.pre_ok:
@@ -718,6 +747,7 @@ class LihuiyuController:
                 packet = b"\x00" + packet + bytes([onewire_crc_lookup(packet)])
             else:
                 packet = b"\x00" + packet + bytes([onewire_crc_lookup(packet) ^ 0xFF])
+            # self.debug_packet(packet)
             self.connection.write(packet)
             self.pre_ok = False
 

meerk40t/lihuiyu/device.py

@@ -129,6 +129,13 @@ class LihuiyuDevice(Service, Status):
         ]
         self.register_choices("bed_dim", choices)
 
+        def get_max_range():
+            """
+            Returns the maximum range of the device.
+            """
+            dev_mode = getattr(self.kernel.root, "developer_mode", False)
+            return 100 if dev_mode else 50
+
         choices = [
             {
                 "attr": "label",
@@ -153,6 +160,52 @@ class LihuiyuDevice(Service, Status):
                 "section": "_10_" + _("Configuration"),
                 "subsection": _("Board Setup"),
             },
+            {
+                "attr": "supports_pwm",
+                "object": self,
+                "default": False,
+                "type": bool,
+                "label": _("Hardware-PWM"),
+                "tip": _(
+                    "Does the board support Hardware-PWM. Only M3 and fireware >= 2024.01.18g support PWM. Earlier M3 revisions are just M2+."
+                ),
+                "section": "_10_" + _("Configuration"),
+                "subsection": _("Hardware-Laser-Power"),
+                "conditional": (self, "board", "M3"),
+                "signals": "pwm_mode_changed",
+            },
+            {
+                "attr": "pwm_speedcode",
+                "object": self,
+                "default": False,
+                "type": bool,
+                "label": _("Use PWM-Speedcode"),
+                "tip": _("PWM Method: set power as well in LHY-speedcodes."),
+                "section": "_10_" + _("Configuration"),
+                "subsection": _("Hardware-Laser-Power"),
+                "conditional": (self, "supports_pwm"),
+                "hidden": True,
+            },
+            {
+                "attr": "power_scale",
+                "object": self,
+                "default": 30,
+                "type": int,
+                "style": "slider",
+                "min": 1,
+                "max": get_max_range,
+                "label": _("Maximum Laser strength"),
+                "trailer": "%",
+                "tip": _(
+                    "Set the maximum laser power level, any operation power will be a fraction of this"
+                )
+                + "\n"
+                + _("Setting this too high may cause damage to your laser tube!"),
+                "section": "_10_" + _("Configuration"),
+                "subsection": _("Hardware-Laser-Power"),
+                "conditional": (self, "supports_pwm"),
+                "signals": "pwm_mode_changed",
+            },
             {
                 "attr": "flip_x",
                 "object": self,
@@ -547,12 +600,15 @@ class LihuiyuDevice(Service, Status):
             action="store_true",
             help=_("override one second laser fire pulse duration"),
         )
+        @self.console_option("power", "p", type=str, help=_("Power level"))
         @self.console_argument("time", type=float, help=_("laser fire pulse duration"))
         @self.console_command(
             "pulse",
             help=_("pulse <time>: Pulse the laser in place."),
         )
-        def pulse(command, channel, _, time=None, idonotlovemyhouse=False, **kwgs):
+        def pulse(
+            command, channel, _, time=None, power=None, idonotlovemyhouse=False, **kwgs
+        ):
             if time is None:
                 channel(_("Must specify a pulse time in milliseconds."))
                 return
@@ -568,16 +624,33 @@ class LihuiyuDevice(Service, Status):
                 except IndexError:
                     return
 
-            def timed_fire():
+            def timed_fire(withpower=None):
                 yield "wait_finish"
-                yield "laser_on"
+                if withpower is not None:
+                    yield "laser_on", withpower
+                else:
+                    yield "laser_on"
                 yield "wait", time
                 yield "laser_off"
 
+            if power is not None:
+                try:
+                    if power.endswith("%"):
+                        power = power[:-1]
+                        power = float(power) * 10
+                    else:
+                        power = float(power)
+                except ValueError:
+                    channel(_("Power must be valid value."))
+                    return
+                if not (0 <= power <= 1000):
+                    channel(_("Power must be between 0 and 1000."))
+                    return
+
             if self.spooler.is_idle:
                 label = _("Pulse laser for {time}ms").format(time=time)
                 self.spooler.laserjob(
-                    list(timed_fire()),
+                    list(timed_fire(withpower=power)),
                     label=label,
                     helper=True,
                     outline=[self.native] * 4,
@@ -892,6 +965,27 @@ class LihuiyuDevice(Service, Status):
                 code = b"A%s\n" % challenge
                 self.output.write(code)
 
+        def _validate_board(channel, board):
+            """
+            Validates the board type
+            """
+            if self.board != board:
+                channel(
+                    _(
+                        "This command is only available for {target} boards. This is a {board}."
+                    ).format(target=board, board=self.board)
+                )
+                return False
+            return True
+
+        @self.console_command(
+            "get_m3nano_info",
+            help=_("Request M3Nano+ board info"),
+        )
+        def get_m3nano_info(command, channel, _, remainder=None, **kwgs):
+            if _validate_board(channel, "M3"):
+                self.driver.get_m3_hardware_info()
+
         @self.console_command("start", help=_("Start Pipe to Controller"))
         def pipe_start(command, channel, _, **kwgs):
             self.controller.update_state("active")
@@ -1050,6 +1144,7 @@ class LihuiyuDevice(Service, Status):
     @signal_listener("plot_shift")
     @signal_listener("plot_phase_type")
     @signal_listener("plot_phase_value")
+    @signal_listener("supports_pwm")
     def plot_attributes_update(self, origin=None, *args):
         self.driver.plot_attribute_update()