V4.4.20 Update

klippy/extras/probe.py

@@ -33,7 +33,7 @@ class PrinterProbe:
         # vibrate after retry failed 
         gcode_macro = self.printer.load_object(config, 'gcode_macro')
         self.vibrate_gcode = gcode_macro.load_template(
-             config.getsection('bed_mesh'), 'vibrate_gcode', '')
+            config.getsection('bed_mesh'), 'vibrate_gcode', '')
         self.probe_count = 0
         self.vibrate = config.getsection('bed_mesh').getint('vibrate', _NERVER)
         # Infer Z position to move to during a probe
@@ -49,7 +49,7 @@ class PrinterProbe:
         self.sample_count = config.getint('samples', 1, minval=1)
         self.sample_retract_dist = config.getfloat('sample_retract_dist', 2.,
                                                    above=0.)
-        atypes = {'median': 'median', 'average': 'average'}
+        atypes = {'median': 'median', 'average': 'average',"submaxmin":"submaxmin"}
         self.samples_result = config.getchoice('samples_result', atypes,
                                                'average')
         self.samples_tolerance = config.getfloat('samples_tolerance', 0.100,
@@ -177,6 +177,7 @@ class PrinterProbe:
         if must_notify_multi_probe:
             self.multi_probe_begin()
         probexy = self.printer.lookup_object('toolhead').get_position()[:2]
+        start_z = self.printer.lookup_object('toolhead').get_position()[2]
         retries = 0
         positions = []
         gcode = self.gcode
@@ -189,7 +190,15 @@ class PrinterProbe:
             z_positions = [p[2] for p in positions]
             if max(z_positions) - min(z_positions) > samples_tolerance:
                 if retries >= samples_retries:
-                    raise gcmd.error("Probe samples exceed samples_tolerance")
+                    #raise gcmd.error("Probe samples exceed samples_tolerance")
+                    self._move(probexy + [start_z], lift_speed)
+                    commands = [
+                            'Z_DOUDONG',
+                            'G4 P500',
+                    ]
+                    gcode._process_commands(commands, False)
+                    retries=0
+                    positions = []
                 gcmd.respond_info("Probe samples exceed tolerance. Retrying...")
                 last_probe_failed = True
                 retries += 1
@@ -197,8 +206,8 @@ class PrinterProbe:
                 self.probe_count += 1
             # Retract
             if len(positions) < sample_count:
+                self._move(probexy + [pos[2] + sample_retract_dist], lift_speed)
                 if last_probe_failed:
-                    self._move(probexy + [sample_retract_dist * 2], lift_speed)
                     if self.probe_count != 0 and self.probe_count % self.vibrate == 0:
                         gcode.respond_info('Probe ' + str(self.probe_count) + " times, start vibrating")
                         commands = [
@@ -210,13 +219,16 @@ class PrinterProbe:
                         gcode._process_commands(commands, False)
                         self.vibrate_gcode.run_gcode_from_command()
                     last_probe_failed = False
-                else:
-                    self._move(probexy + [pos[2] + sample_retract_dist], lift_speed)
         if must_notify_multi_probe:
             self.multi_probe_end()
         # Calculate and return result
         if samples_result == 'median':
             return self._calc_median(positions)
+        if samples_result == 'submaxmin':
+            z_sorted = sorted(positions, key=(lambda p: p[2]))
+            if len(positions)>=3:
+                z_sorted=z_sorted[1:-1]
+            return self._calc_mean(z_sorted)
         return self._calc_mean(positions)
     cmd_PROBE_help = "Probe Z-height at current XY position"
     def cmd_PROBE(self, gcmd):
@@ -421,7 +433,7 @@ class ProbePointsHelper:
         self.vibrate = config.getint('vibrate', 9999999)
         gcode_macro = self.printer.load_object(config, 'gcode_macro')
         self.vibrate_gcode = gcode_macro.load_template(
-            config, 'vibrate_gcode', '')
+            config.getsection('bed_mesh'), 'vibrate_gcode', '')
     def minimum_points(self,n):
         if len(self.probe_points) < n:
             raise self.printer.config_error(

klippy/extras/virtual_sdcard.py

@@ -30,9 +30,11 @@ class VirtualSD:
         gcode_macro = self.printer.load_object(config, 'gcode_macro')
         self.on_error_gcode = gcode_macro.load_template(
             config, 'on_error_gcode', '')
+        
         # power lose resume
         self.lines = 0
         self.save_every_n_lines = 50
+        
         # Register commands
         self.gcode = self.printer.lookup_object('gcode')
         for cmd in ['M20', 'M21', 'M23', 'M24', 'M25', 'M26', 'M27']:
@@ -236,20 +238,30 @@ class VirtualSD:
         partial_input = ""
         lines = []
         error_message = None
-        plr_file = open("/home/mks/scripts/plr/plr_record", 'w', buffering=0)
+
+        # Recreate the file to balance the wear on the eMMC
+        file_path = "/home/mks/scripts/plr/plr_record"
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        plr_file = open(file_path, 'w', buffering=0)
+
         while not self.must_pause_work:
             if not lines:
                 # Read more data
                 try:
                     data = self.current_file.read(8192)
                 except:
+
                     plr_file.close()
+
                     logging.exception("virtual_sdcard read")
                     break
                 if not data:
                     # End of file
+
                     self.lines = 0
                     plr_file.close()
+
                     self.current_file.close()
                     self.current_file = None
                     logging.info("Finished SD card print")
@@ -271,13 +283,13 @@ class VirtualSD:
             next_file_position = self.file_position + len(line) + 1
             self.next_file_position = next_file_position
             try:
+
                 self.lines += 1
                 if self.lines % self.save_every_n_lines == 0:
-                    # temp = "SAVE_VARIABLE VARIABLE=gcode_lines VALUE=" + str(self.lines)
-                    # self.gcode._process_commands([temp], need_ack=False)
                     plr_file.seek(0)
                     plr_file.write(str(self.lines))
                     plr_file.truncate()
+
                 self.gcode.run_script(line)
             except self.gcode.error as e:
                 error_message = str(e)
@@ -302,7 +314,9 @@ class VirtualSD:
                 lines = []
                 partial_input = ""
         logging.info("Exiting SD card print (position %d)", self.file_position)
+
         plr_file.close()
+
         self.work_timer = None
         self.cmd_from_sd = False
         if error_message is not None:
@@ -312,16 +326,6 @@ class VirtualSD:
         else:
             self.print_stats.note_complete()
         return self.reactor.NEVER
-    # cmd_TOGGLE_PLR_help = "enable or disable power lose resume"
-    # def cmd_TOGGLE_PLR(self, gcmd):
-    #     if self.plr_enable:
-    #         self.plr_enable = False
-    #         temp = "SAVE_VARIABLE VARIABLE=plr_enable VALUE=" + str(self.plr_enable)
-    #         self.gcode._process_commands([temp], need_ack=False)
-    #         gcmd.respond_raw("Power lose resume disabled")
-    #     else:
-    #         self.plr_enable = True
-    #         gcmd.respond_raw("Power lose resume enabled")
 
 def load_config(config):
     return VirtualSD(config)