probe: Convert probing_move() callback to use regular probe sessions system

Use the normal probe_session_start(), run_probe(),
pull_probed_results(), and end_probe_session() API from
ProbeSessionHelper.  This removes the custom probing_move() callback.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>

klippy/extras/probe.py

@@ -188,6 +188,7 @@ class HomingViaProbeHelper:
         self.param_helper = param_helper
         self.multi_probe_pending = False
         self.z_min_position = lookup_minimum_z(config)
+        self.results = []
         # Register z_virtual_endstop pin
         self.printer.lookup_object('pins').register_chip('probe', self)
         # Register event handlers
@@ -238,13 +239,24 @@ class HomingViaProbeHelper:
             raise pins.error("Can not pullup/invert probe virtual endstop")
         return self.mcu_probe
     # Helper to convert probe based commands to use homing module
-    def probing_move(self, gcmd):
+    def start_probe_session(self, gcmd):
+        self.mcu_probe.multi_probe_begin()
+        self.results = []
+        return self
+    def run_probe(self, gcmd):
         toolhead = self.printer.lookup_object('toolhead')
         pos = toolhead.get_position()
         pos[2] = self.z_min_position
         speed = self.param_helper.get_probe_params(gcmd)['probe_speed']
         phoming = self.printer.lookup_object('homing')
-        return phoming.probing_move(self.mcu_probe, pos, speed)
+        self.results.append(phoming.probing_move(self.mcu_probe, pos, speed))
+    def pull_probed_results(self):
+        res = self.results
+        self.results = []
+        return res
+    def end_probe_session(self):
+        self.results = []
+        self.mcu_probe.multi_probe_end()
 
 # Helper to read multi-sample parameters from config
 class ProbeParameterHelper:
@@ -288,19 +300,18 @@ class ProbeParameterHelper:
 
 # Helper to track multiple probe attempts in a single command
 class ProbeSessionHelper:
-    def __init__(self, config, mcu_probe, param_helper, probing_move_cb=None):
+    def __init__(self, config, param_helper, start_session_cb):
         self.printer = config.get_printer()
-        self.mcu_probe = mcu_probe
         self.param_helper = param_helper
-        self.probing_move_cb = probing_move_cb
+        self.start_session_cb = start_session_cb
         # Session state
-        self.multi_probe_pending = False
+        self.hw_probe_session = None
         self.results = []
         # Register event handlers
         self.printer.register_event_handler("gcode:command_error",
                                             self._handle_command_error)
     def _handle_command_error(self):
-        if self.multi_probe_pending:
+        if self.hw_probe_session is not None:
             try:
                 self.end_probe_session()
             except:
@@ -309,25 +320,26 @@ class ProbeSessionHelper:
         raise self.printer.command_error(
             "Internal probe error - start/end probe session mismatch")
     def start_probe_session(self, gcmd):
-        if self.multi_probe_pending:
+        if self.hw_probe_session is not None:
             self._probe_state_error()
-        self.mcu_probe.multi_probe_begin()
+        self.hw_probe_session = self.start_session_cb(gcmd)
-        self.multi_probe_pending = True
         self.results = []
         return self
     def end_probe_session(self):
-        if not self.multi_probe_pending:
+        hw_probe_session = self.hw_probe_session
+        if hw_probe_session is None:
             self._probe_state_error()
         self.results = []
-        self.multi_probe_pending = False
+        self.hw_probe_session = None
-        self.mcu_probe.multi_probe_end()
+        hw_probe_session.end_probe_session()
     def _probe(self, gcmd):
         toolhead = self.printer.lookup_object('toolhead')
         curtime = self.printer.get_reactor().monotonic()
         if 'z' not in toolhead.get_status(curtime)['homed_axes']:
             raise self.printer.command_error("Must home before probe")
         try:
-            epos = self.probing_move_cb(gcmd)
+            self.hw_probe_session.run_probe(gcmd)
+            epos = self.hw_probe_session.pull_probed_results()[0]
         except self.printer.command_error as e:
             reason = str(e)
             if "Timeout during endstop homing" in reason:
@@ -341,7 +353,7 @@ class ProbeSessionHelper:
                            % (epos[0], epos[1], epos[2]))
         return epos[:3]
     def run_probe(self, gcmd):
-        if not self.multi_probe_pending:
+        if self.hw_probe_session is None:
             self._probe_state_error()
         params = self.param_helper.get_probe_params(gcmd)
         toolhead = self.printer.lookup_object('toolhead')
@@ -381,8 +393,7 @@ class ProbeEndstopSessionHelper:
         self.homing_helper = HomingViaProbeHelper(config, mcu_probe,
                                                   self.param_helper)
         self.probe_session = ProbeSessionHelper(
-            config, mcu_probe, self.param_helper,
+            config, self.param_helper, self.homing_helper.start_probe_session)
-            self.homing_helper.probing_move)
         # Main printer probe session starting API
         self.start_probe_session = self.probe_session.start_probe_session
         self.get_probe_params = self.param_helper.get_probe_params

klippy/extras/probe_eddy_current.py

@@ -348,8 +348,11 @@ class EddyEndstopWrapper:
         return trigger_time
     def query_endstop(self, print_time):
         return False # XXX
-    # Interface for ProbeEndstopWrapper
+    # Probe session interface
-    def probing_move(self, gcmd):
+    def start_probe_session(self, gcmd):
+        self.multi_probe_begin()
+        return self
+    def run_probe(self, gcmd):
         toolhead = self._printer.lookup_object('toolhead')
         pos = toolhead.get_position()
         pos[2] = self._z_min_position
@@ -364,7 +367,11 @@ class EddyEndstopWrapper:
         end_time = start_time + 0.100
         toolhead_pos = toolhead.get_position()
         self._gather.note_probe(start_time, end_time, toolhead_pos)
-        return self._gather.pull_probed()[0]
+    def pull_probed_results(self):
+        return self._gather.pull_probed()
+    def end_probe_session(self):
+        self.multi_probe_end()
+    # Interface for ProbeEndstopWrapper
     def multi_probe_begin(self):
         self._gather = EddyGatherSamples(self._printer, self._sensor_helper,
                                          self._calibration, self._z_offset)
@@ -437,8 +444,7 @@ class PrinterEddyProbe:
         self.homing_helper = probe.HomingViaProbeHelper(config, self.mcu_probe,
                                                         self.param_helper)
         self.probe_session = probe.ProbeSessionHelper(
-            config, self.mcu_probe, self.param_helper,
+            config, self.param_helper, self.mcu_probe.start_probe_session)
-            self.mcu_probe.probing_move)
         self.printer.add_object('probe', self)
     def add_client(self, cb):
         self.sensor_helper.add_client(cb)