probe: Simplify HomingViaProbeHelper now that it is only a thin wrapper

The HomingViaProbeHelper emulates an mcu_endstop, but that emulation
doesn't need to actually do anything.

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

klippy/extras/bltouch.py

@@ -26,7 +26,6 @@ Commands = {
 class BLTouchProbe:
     def __init__(self, config):
         self.printer = config.get_printer()
-        self.position_endstop = config.getfloat('z_offset', minval=0.)
         self.stow_on_each_sample = config.getboolean('stow_on_each_sample',
                                                      True)
         self.probe_touch_mode = config.getboolean('probe_with_touch_mode',
@@ -220,8 +219,6 @@ class BLTouchProbe:
         if self.multi == 'OFF':
             self.verify_raise_probe()
         self.sync_print_time()
-    def get_position_endstop(self):
-        return self.position_endstop
     def set_output_mode(self, mode):
         # If this is inadvertently/purposely issued for a
         # BLTOUCH pre V3.0 and clones:

klippy/extras/probe.py

@@ -207,28 +207,33 @@ class LookupZSteppers:
 
 # Support homing via probe using the probe:z_virtual_endstop pseudo-pin
 class HomingViaProbeHelper:
-    def __init__(self, config, mcu_probe):
+    def __init__(self, config, position_endstop, query_endstop_cb=None):
         self.printer = config.get_printer()
-        self.mcu_probe = mcu_probe
+        self.position_endstop = position_endstop
+        self.query_endstop_cb = query_endstop_cb
         # Register z_virtual_endstop pin
         self.printer.lookup_object('pins').register_chip('probe', self)
+    def _raise_error(self):
+        raise self.printer.command_error(
+            "Internal error. Can't home via HomingViaProbeHelper.")
     # MCU_endstop interface
     def get_mcu(self):
-        return self.mcu_probe.get_mcu()
+        self._raise_error()
     def add_stepper(self, stepper):
-        self.mcu_probe.add_stepper(stepper)
+        pass
     def get_steppers(self):
-        return self.mcu_probe.get_steppers()
+        return []
     def home_start(self, print_time, sample_time, sample_count, rest_time,
                    triggered=True):
-        return self.mcu_probe.home_start(print_time, sample_time, sample_count,
-                                         rest_time, triggered)
+        self._raise_error()
     def home_wait(self, home_end_time):
-        return self.mcu_probe.home_wait(home_end_time)
+        self._raise_error()
     def query_endstop(self, print_time):
-        return self.mcu_probe.query_endstop(print_time)
+        if self.query_endstop_cb is None:
+            return False
+        return self.query_endstop_cb(print_time)
     def get_position_endstop(self):
-        return self.mcu_probe.get_position_endstop()
+        return self.position_endstop
     # Printer pins module setup_pin() interface
     def setup_pin(self, pin_type, pin_params):
         if pin_type != 'endstop' or pin_params['pin'] != 'z_virtual_endstop':
@@ -249,7 +254,8 @@ class DescendToEndstopHelper:
         self.z_min_position = lookup_minimum_z(config)
         self.results = []
         LookupZSteppers(config, self.mcu_probe.add_stepper)
-        HomingViaProbeHelper(config, mcu_probe)
+        HomingViaProbeHelper(config, probe_offsets.get_offsets()[2],
+                             mcu_probe.query_endstop)
     def start_probe_session(self, gcmd):
         self.mcu_probe.multi_probe_begin()
         self.results = []
@@ -563,7 +569,6 @@ def run_single_probe(probe, gcmd):
 class ProbeEndstopWrapper:
     def __init__(self, config):
         self.printer = config.get_printer()
-        self.position_endstop = config.getfloat('z_offset')
         self.stow_on_each_sample = config.getboolean(
             'deactivate_on_each_sample', True)
         gcode_macro = self.printer.load_object(config, 'gcode_macro')
@@ -614,8 +619,6 @@ class ProbeEndstopWrapper:
     def probe_finish(self):
         if self.multi == 'OFF':
             self._raise_probe()
-    def get_position_endstop(self):
-        return self.position_endstop
 
 # Main external probe interface
 class PrinterProbe:

klippy/extras/probe_eddy_current.py

@@ -572,6 +572,7 @@ class EddyDescend:
             self._descend_z = config.getfloat('descend_z', above=0.)
         self._z_min_position = probe.lookup_minimum_z(config)
         self._gather = None
+        probe.HomingViaProbeHelper(config, self._descend_z)
     def _prep_trigger_analog(self):
         sos_filter = self._trigger_analog.get_sos_filter()
         sos_filter.set_filter_design(None)
@@ -610,41 +611,6 @@ class EddyDescend:
         self._gather.finish()
         self._gather = None
 
-# Wrapper to emulate mcu_endstop for probe:z_virtual_endstop
-# Note that this does not provide accurate results
-class EddyEndstopWrapper:
-    def __init__(self, sensor_helper, eddy_descend):
-        self._sensor_helper = sensor_helper
-        self._eddy_descend = eddy_descend
-        self._hw_probe_session = None
-    # Interface for MCU_endstop
-    def get_mcu(self):
-        return self._sensor_helper.get_mcu()
-    def add_stepper(self, stepper):
-        pass
-    def get_steppers(self):
-        return self._eddy_descend._trigger_analog.get_steppers()
-    def home_start(self, print_time, sample_time, sample_count, rest_time,
-                   triggered=True):
-        return self._eddy_descend._trigger_analog.home_start(
-            print_time, sample_time, sample_count, rest_time, triggered)
-    def home_wait(self, home_end_time):
-        return self._eddy_descend._trigger_analog.home_wait(home_end_time)
-    def query_endstop(self, print_time):
-        return False # XXX
-    # Interface for HomingViaProbeHelper
-    def multi_probe_begin(self):
-        self._hw_probe_session = self._eddy_descend.start_probe_session(None)
-    def multi_probe_end(self):
-        self._hw_probe_session.end_probe_session()
-        self._hw_probe_session = None
-    def probe_prepare(self):
-        pass
-    def probe_finish(self):
-        pass
-    def get_position_endstop(self):
-        return self._eddy_descend._descend_z
-
 # Probing helper for "tap" requests
 class EddyTap:
     def __init__(self, config, sensor_helper, param_helper, trigger_analog):
@@ -1053,9 +1019,6 @@ class PrinterEddyProbe:
             self.param_helper, trig_analog)
         self.eddy_descend_session = probe.ProbeSessionHelper(
             config, self.param_helper, eddy_descend.start_probe_session)
-        # Create wrapper to support Z homing with probe
-        mcu_probe = EddyEndstopWrapper(self.sensor_helper, eddy_descend)
-        probe.HomingViaProbeHelper(config, mcu_probe)
         # Probing via "tap" interface
         eddy_tap = EddyTap(config, self.sensor_helper,
                            self.param_helper, trig_analog)

klippy/extras/smart_effector.py

@@ -64,7 +64,6 @@ class SmartEffectorProbe:
         self.query_endstop = self.probe_wrapper.query_endstop
         self.multi_probe_begin = self.probe_wrapper.multi_probe_begin
         self.multi_probe_end = self.probe_wrapper.multi_probe_end
-        self.get_position_endstop = self.probe_wrapper.get_position_endstop
         # Common probe implementation helpers
         self.cmd_helper = probe.ProbeCommandHelper(
             config, self, self.probe_wrapper.query_endstop)