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

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()
 

meerk40t/lihuiyu/driver.py

@@ -194,6 +194,18 @@ class LihuiyuDriver(Parameters):
     def __call__(self, e):
         self.out_pipe.write(e)
 
+    @property
+    def has_adjustable_maximum_power(self):
+        return self.service.supports_pwm
+
+    @property
+    def max_power_scale(self):
+        return self.service.power_scale
+
+    @max_power_scale.setter
+    def max_power_scale(self, value):
+        self.service.power_scale = value
+
     def get_internal_queue_status(self):
         return self._queue_current, self._queue_total
 
@@ -205,6 +217,7 @@ class LihuiyuDriver(Parameters):
         self.plot_planner.force_shift = self.service.plot_shift
         self.plot_planner.phase_type = self.service.plot_phase_type
         self.plot_planner.phase_value = self.service.plot_phase_value
+        self.plot_planner.set_ppi(not self.service.supports_pwm)
 
     def hold_work(self, priority):
         """
@@ -384,7 +397,7 @@ class LihuiyuDriver(Parameters):
         self.rapid_mode()
         self._move_relative(unit_dx, unit_dy)
 
-    def dwell(self, time_in_ms):
+    def dwell(self, time_in_ms, settings=None):
         """
         Requests that the laser fire in place for the given time period. This could be done in a series of commands,
         move to a location, turn laser on, wait, turn laser off. However, some drivers have specific laser-in-place
@@ -393,9 +406,12 @@ class LihuiyuDriver(Parameters):
         @param time_in_ms:
         @return:
         """
+        power = settings.get("power", None) if settings else None
         self.rapid_mode()
         self.wait_finish()
-        self.laser_on()  # This can't be sent early since these are timed operations.
+        self.laser_on(
+            power=power
+        )  # This can't be sent early since these are timed operations.
         self.wait(time_in_ms)
         self.laser_off()
 
@@ -421,7 +437,7 @@ class LihuiyuDriver(Parameters):
         self.laser = False
         return True
 
-    def laser_on(self):
+    def laser_on(self, power=None):
         """
         Turn laser on in place.
 
@@ -429,6 +445,9 @@ class LihuiyuDriver(Parameters):
         """
         if self.laser:
             return False
+        if power is not None and self.service.supports_pwm:
+            self.send_at_pwm_code(power, "laser_on")
+
         if self.state == DRIVER_STATE_RAPID:
             self(b"I")
             self(self.CODE_LASER_ON)
@@ -443,6 +462,18 @@ class LihuiyuDriver(Parameters):
         self.laser = True
         return True
 
+    def send_at_pwm_code(self, power: float = 1000.0):
+        if len(self.out_pipe) > 0:
+            self(b"\n")
+        self.wait_finish()
+        self.rapid_mode()
+        power = max(0.0, min(power, 1000.0)) * self.service.power_scale / 100.0
+        m = int(power / 254)
+        n = int(power % 254)
+        # AT commands will be flushed out immediately
+        packet = bytes((ord("A"), ord("T"), ord("1"), m, n, ord("\n")))
+        self(packet)
+
     def rapid_mode(self, *values):
         """
         Rapid mode sets the laser to rapid state. This is usually moving the laser around without it executing a large
@@ -537,6 +568,8 @@ class LihuiyuDriver(Parameters):
         else:
             # Unidirectional (step on forward swing - rasters only going forward)
             raster_step_value = self._raster_step_g_value, 0
+        # We don't allow in situ power changes in raster mode.
+        power_val = None
         speed_code = LaserSpeed(
             self.service.board,
             self.speed,
@@ -548,6 +581,7 @@ class LihuiyuDriver(Parameters):
             suffix_c=False,
             fix_speeds=self.service.fix_speeds,
             raster_horizontal=horizontal,
+            power_value=power_val,
         ).speedcode
         speed_code = bytes(speed_code, "utf8")
         self(speed_code)
@@ -593,7 +627,12 @@ class LihuiyuDriver(Parameters):
             self._leftward = False
             self._topward = False
             self._horizontal_major = False
-
+        if self.service.supports_pwm and self.service.pwm_speedcode:
+            # If we are using PWM speedcode, we need to set the power value.
+            power_val = self.power * self.service.power_scale / 100.0
+        else:
+            # If we are not using PWM speedcode, we do not set the power value.
+            power_val = None
         speed_code = LaserSpeed(
             self.service.board,
             self.speed,
@@ -605,6 +644,7 @@ class LihuiyuDriver(Parameters):
             suffix_c=suffix_c,
             fix_speeds=self.service.fix_speeds,
             raster_horizontal=self._horizontal_major,
+            power_value=power_val,
         ).speedcode
         speed_code = bytes(speed_code, "utf8")
         self(speed_code)
@@ -702,6 +742,7 @@ class LihuiyuDriver(Parameters):
                     self.rapid_mode()
                     self._move_absolute(start.real, start.imag)
                     self.wait_finish()
+                    self._set_power(sets.get("power", 1000.0))
                     self.dwell(sets.get("dwell_time"))
                 elif function == "wait":
                     self.plot_start()
@@ -1029,6 +1070,8 @@ class LihuiyuDriver(Parameters):
             self.power = 1000.0
         if self.power <= 0:
             self.power = 0.0
+        if self.service.supports_pwm:
+            self.send_at_pwm_code(self.power)
 
     def _set_ppi(self, power=1000.0):
         self.power = power
@@ -1463,4 +1506,18 @@ class LihuiyuDriver(Parameters):
             self._x_engaged = False
             self._y_engaged = True
             return x_dir + y_dir
-        
+
+    # def get_board_info(self):
+    #     try:
+    #         self.out_pipe.write_raw(b"\xac\x2e", 73 - 27)
+    #     except AttributeError:
+    #         pass
+
+    # def get_param_info(self):
+    #     try:
+    #         self.out_pipe.write_raw(b"\xac\xe0", 251 - 27)
+    #     except AttributeError:
+    #         pass
+
+    def get_m3_hardware_info(self):
+        self(b"AT01")