Simplify kinematic set_position() and clear_homing_state() calls

klippy/extras/dockable_probe.py

@@ -852,7 +852,7 @@ def _force_z_hop(self):
         )
         self.toolhead.manual_move([None, None, self.z_hop], self.lift_speed)
         kin = self.toolhead.get_kinematics()
-        kin.clear_homing_state([2])
+        kin.clear_homing_state("z")
         self.last_z = self.toolhead.get_position()[2]
 
     #######################################################################

klippy/extras/force_move.py

@@ -174,17 +174,16 @@ def cmd_SET_KINEMATIC_POSITION(self, gcmd):
         x = gcmd.get_float("X", curpos[0])
         y = gcmd.get_float("Y", curpos[1])
         z = gcmd.get_float("Z", curpos[2])
-        clear = gcmd.get("CLEAR", "").upper()
-        axes = ["X", "Y", "Z"]
-        clear_axes = [axes.index(a) for a in axes if a in clear]
+        clear = gcmd.get("CLEAR", "").lower()
+        clear_axes = "".join([a for a in "xyz" if a in clear])
         logging.info(
             "SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f clear=%s",
             x,
             y,
             z,
-            ",".join((axes[i] for i in clear_axes)),
+            clear_axes,
         )
-        toolhead.set_position([x, y, z, curpos[3]], homing_axes=(0, 1, 2))
+        toolhead.set_position([x, y, z, curpos[3]], homing_axes="xyz")
         toolhead.get_kinematics().clear_homing_state(clear_axes)
 
 

klippy/extras/homing.py

@@ -282,8 +282,7 @@ def _set_homing_current(self, homing_axes, pre_homing):
         print_time = self.toolhead.get_last_move_time()
         affected_rails = set()
         for axis in homing_axes:
-            axis_name = "xyz"[axis]  # only works for cartesian
-            partial_rails = self.toolhead.get_active_rails_for_axis(axis_name)
+            partial_rails = self.toolhead.get_active_rails_for_axis(axis)
             affected_rails = affected_rails | set(partial_rails)
 
         dwell_time = 0.0
@@ -310,8 +309,9 @@ def _reset_endstop_states(self, endstops):
     def home_rails(self, rails, forcepos, movepos):
         # Notify of upcoming homing operation
         self.printer.send_event("homing:home_rails_begin", self, rails)
-        # Alter kinematics class to think printer is at forcepo
-        homing_axes = [axis for axis in range(3) if forcepos[axis] is not None]
+        # Alter kinematics class to think printer is at forcepos
+        force_axes = [axis for axis in range(3) if forcepos[axis] is not None]
+        homing_axes = "".join(["xyz"[i] for i in force_axes])
         startpos = self._fill_coord(forcepos)
         homepos = self._fill_coord(movepos)
         self.toolhead.set_position(startpos, homing_axes=homing_axes)
@@ -330,7 +330,7 @@ def home_rails(self, rails, forcepos, movepos):
 
         needs_rehome = False
         retract_dist = hi.retract_dist
-        if hmove.moved_less_than_dist(hi.min_home_dist, homing_axes):
+        if hmove.moved_less_than_dist(hi.min_home_dist, force_axes):
             needs_rehome = True
             retract_dist = hi.min_home_dist
 
@@ -412,7 +412,7 @@ def home_rails(self, rails, forcepos, movepos):
                 for s in kin.get_steppers()
             }
             newpos = kin.calc_position(kin_spos)
-            for axis in homing_axes:
+            for axis in force_axes:
                 homepos[axis] = newpos[axis]
             self.toolhead.set_position(homepos)
 

klippy/extras/homing_override.py

@@ -49,11 +49,11 @@ def cmd_G28(self, gcmd):
         # Calculate forced position (if configured)
         toolhead = self.printer.lookup_object("toolhead")
         pos = toolhead.get_position()
-        homing_axes = []
+        homing_axes = ""
         for axis, loc in enumerate(self.start_pos):
             if loc is not None:
                 pos[axis] = loc
-                homing_axes.append(axis)
+                homing_axes += "xyz"[axis]
         toolhead.set_position(pos, homing_axes=homing_axes)
         # Perform homing
         context = self.template.create_template_context()

klippy/extras/manual_stepper.py

@@ -146,7 +146,7 @@ def flush_step_generation(self):
     def get_position(self):
         return [self.rail.get_commanded_position(), 0.0, 0.0, 0.0]
 
-    def set_position(self, newpos, homing_axes=()):
+    def set_position(self, newpos, homing_axes=""):
         self.do_set_position(newpos[0])
 
     def get_last_move_time(self):

klippy/extras/safe_z_home.py

@@ -45,9 +45,9 @@ def cmd_G28(self, gcmd):
             if "z" not in kin_status["homed_axes"]:
                 # Always perform the z_hop if the Z axis is not homed
                 pos[2] = 0
-                toolhead.set_position(pos, homing_axes=[2])
+                toolhead.set_position(pos, homing_axes="z")
                 toolhead.manual_move([None, None, self.z_hop], self.z_hop_speed)
-                toolhead.get_kinematics().clear_homing_state((2,))
+                toolhead.get_kinematics().clear_homing_state("z")
             elif pos[2] < self.z_hop:
                 # If the Z axis is homed, and below z_hop, lift it to z_hop
                 toolhead.manual_move([None, None, self.z_hop], self.z_hop_speed)

klippy/extras/stepper_enable.py

@@ -111,6 +111,7 @@ def motor_off(self):
         print_time = toolhead.get_last_move_time()
         for el in self.enable_lines.values():
             el.motor_disable(print_time)
+        toolhead.get_kinematics().clear_homing_state("xyz")
         self.printer.send_event("stepper_enable:motor_off", print_time)
         toolhead.dwell(DISABLE_STALL_TIME)
 

klippy/kinematics/cartesian.py

@@ -47,9 +47,6 @@ def __init__(self, toolhead, config):
         for s in self.get_steppers():
             s.set_trapq(toolhead.get_trapq())
             toolhead.register_step_generator(s.generate_steps)
-        self.printer.register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
@@ -84,20 +81,21 @@ def update_limits(self, i, range):
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-        for axis in homing_axes:
+        for axis_name in homing_axes:
+            axis = "xyz".index(axis_name)
             if self.dc_module and axis == self.dc_module.axis:
                 rail = self.dc_module.get_primary_rail().get_rail()
             else:
                 rail = self.rails[axis]
             self.limits[axis] = rail.get_range()
 
     def note_z_not_homed(self):
-        self.clear_homing_state([2])
+        self.clear_homing_state("z")
 
-    def clear_homing_state(self, axes):
-        for i, _ in enumerate(self.limits):
-            if i in axes:
-                self.limits[i] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                self.limits[axis] = (1.0, -1.0)
 
     def home_axis(self, homing_state, axis, rail):
         # Determine movement
@@ -121,9 +119,6 @@ def home(self, homing_state):
             else:
                 self.home_axis(homing_state, axis, self.rails[axis])
 
-    def _motor_off(self, print_time):
-        self.clear_homing_state((0, 1, 2))
-
     def _check_endstops(self, move):
         end_pos = move.end_pos
         for i in (0, 1, 2):

klippy/kinematics/corexy.py

@@ -23,9 +23,6 @@ def __init__(self, toolhead, config):
         for s in self.get_steppers():
             s.set_trapq(toolhead.get_trapq())
             toolhead.register_step_generator(s.generate_steps)
-        config.get_printer().register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
@@ -50,16 +47,16 @@ def calc_position(self, stepper_positions):
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-            if i in homing_axes:
+            if "xyz"[i] in homing_axes:
                 self.limits[i] = rail.get_range()
 
     def note_z_not_homed(self):
-        self.clear_homing_state([2])
+        self.clear_homing_state("z")
 
-    def clear_homing_state(self, axes):
-        for i, _ in enumerate(self.limits):
-            if i in axes:
-                self.limits[i] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                self.limits[axis] = (1.0, -1.0)
 
     def home(self, homing_state):
         # Each axis is homed independently and in order
@@ -78,9 +75,6 @@ def home(self, homing_state):
             # Perform homing
             homing_state.home_rails([rail], forcepos, homepos)
 
-    def _motor_off(self, print_time):
-        self.clear_homing_state((0, 1, 2))
-
     def _check_endstops(self, move):
         end_pos = move.end_pos
         for i in (0, 1, 2):

klippy/kinematics/corexz.py

@@ -23,9 +23,6 @@ def __init__(self, toolhead, config):
         for s in self.get_steppers():
             s.set_trapq(toolhead.get_trapq())
             toolhead.register_step_generator(s.generate_steps)
-        config.get_printer().register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
@@ -50,16 +47,16 @@ def calc_position(self, stepper_positions):
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-            if i in homing_axes:
+            if "xyz"[i] in homing_axes:
                 self.limits[i] = rail.get_range()
 
     def note_z_not_homed(self):
-        self.clear_homing_state([2])
+        self.clear_homing_state("z")
 
-    def clear_homing_state(self, axes):
-        for i, _ in enumerate(self.limits):
-            if i in axes:
-                self.limits[i] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                self.limits[axis] = (1.0, -1.0)
 
     def home(self, homing_state):
         # Each axis is homed independently and in order
@@ -78,9 +75,6 @@ def home(self, homing_state):
             # Perform homing
             homing_state.home_rails([rail], forcepos, homepos)
 
-    def _motor_off(self, print_time):
-        self.clear_homing_state((0, 1, 2))
-
     def _check_endstops(self, move):
         end_pos = move.end_pos
         for i in (0, 1, 2):

klippy/kinematics/delta.py

@@ -29,9 +29,6 @@ def __init__(self, toolhead, config):
             default_position_endstop=a_endstop,
         )
         self.rails = [rail_a, rail_b, rail_c]
-        config.get_printer().register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         # Setup max velocity
         self.max_velocity, self.max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
@@ -123,8 +120,7 @@ def ratio_to_xy(ratio):
         )
         self.axes_min = toolhead.Coord(-max_xy, -max_xy, self.min_z, 0.0)
         self.axes_max = toolhead.Coord(max_xy, max_xy, self.max_z, 0.0)
-        self.set_position([0.0, 0.0, 0.0], ())
-        self.supports_dual_carriage = False
+        self.set_position([0.0, 0.0, 0.0], "")
 
     def get_steppers(self):
         return [s for rail in self.rails for s in rail.get_steppers()]
@@ -141,12 +137,15 @@ def set_position(self, newpos, homing_axes):
         for rail in self.rails:
             rail.set_position(newpos)
         self.limit_xy2 = -1.0
-        if tuple(homing_axes) == (0, 1, 2):
+        if homing_axes == "xyz":
             self.need_home = False
 
-    def clear_homing_state(self, axes):
+    def note_z_not_homed(self):
+        self.clear_homing_state("z")
+
+    def clear_homing_state(self, clear_axes):
         # Clearing homing state for each axis individually is not implemented
-        if 0 in axes or 1 in axes or 2 in axes:
+        if clear_axes:
             self.limit_xy2 = -1
             self.need_home = True
 
@@ -157,9 +156,6 @@ def home(self, homing_state):
         forcepos[2] = -1.5 * math.sqrt(max(self.arm2) - self.max_xy2)
         homing_state.home_rails(self.rails, forcepos, self.home_position)
 
-    def _motor_off(self, print_time):
-        self.clear_homing_state((0, 1, 2))
-
     def check_move(self, move):
         end_pos = move.end_pos
         end_xy2 = end_pos[0] ** 2 + end_pos[1] ** 2

klippy/kinematics/deltesian.py

@@ -50,9 +50,6 @@ def __init__(self, toolhead, config):
         for s in self.get_steppers():
             s.set_trapq(toolhead.get_trapq())
             toolhead.register_step_generator(s.generate_steps)
-        config.get_printer().register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         self.limits = [(1.0, -1.0)] * 3
         # X axis limits
         min_angle = config.getfloat(
@@ -119,8 +116,7 @@ def __init__(self, toolhead, config):
         self.axes_min = toolhead.Coord(*[l[0] for l in self.limits], e=0.0)
         self.axes_max = toolhead.Coord(*[l[1] for l in self.limits], e=0.0)
         self.homed_axis = [False] * 3
-        self.set_position([0.0, 0.0, 0.0], ())
-        self.supports_dual_carriage = False
+        self.set_position([0.0, 0.0, 0.0], "")
 
     def get_steppers(self):
         return [s for rail in self.rails for s in rail.get_steppers()]
@@ -153,13 +149,17 @@ def calc_position(self, stepper_positions):
     def set_position(self, newpos, homing_axes):
         for rail in self.rails:
             rail.set_position(newpos)
-        for n in homing_axes:
-            self.homed_axis[n] = True
+        for axis_name in homing_axes:
+            axis = "xyz".index(axis_name)
+            self.homed_axis[axis] = True
+
+    def note_z_not_homed(self):
+        self.clear_homing_state("z")
 
-    def clear_homing_state(self, axes):
-        for i, _ in enumerate(self.limits):
-            if i in axes:
-                self.homed_axis[i] = False
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                self.homed_axis[axis] = False
 
     def home(self, homing_state):
         homing_axes = homing_state.get_axes()
@@ -194,9 +194,6 @@ def home(self, homing_state):
                 forcepos[1] += 1.5 * (position_max - hi.position_endstop)
             homing_state.home_rails([self.rails[2]], forcepos, homepos)
 
-    def _motor_off(self, print_time):
-        self.homed_axis = [False] * 3
-
     def check_move(self, move):
         limits = list(map(list, self.limits))
         spos, epos = move.start_pos, move.end_pos

klippy/kinematics/hybrid_corexy.py

@@ -59,9 +59,6 @@ def __init__(self, toolhead, config):
         for s in self.get_steppers():
             s.set_trapq(toolhead.get_trapq())
             toolhead.register_step_generator(s.generate_steps)
-        self.printer.register_event_handler(
-            "stepper_enable:motor_off", self._motor_off
-        )
         # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
@@ -101,20 +98,21 @@ def update_limits(self, i, range):
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-        for axis in homing_axes:
+        for axis_name in homing_axes:
+            axis = "xyz".index(axis_name)
             if self.dc_module and axis == self.dc_module.axis:
                 rail = self.dc_module.get_primary_rail().get_rail()
             else:
                 rail = self.rails[axis]
             self.limits[axis] = rail.get_range()
 
     def note_z_not_homed(self):
-        self.clear_homing_state([2])
+        self.clear_homing_state("z")
 
-    def clear_homing_state(self, axes):
-        for i, _ in enumerate(self.limits):
-            if i in axes:
-                self.limits[i] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                self.limits[axis] = (1.0, -1.0)
 
     def home_axis(self, homing_state, axis, rail):
         position_min, position_max = rail.get_range()
@@ -136,9 +134,6 @@ def home(self, homing_state):
             else:
                 self.home_axis(homing_state, axis, self.rails[axis])
 
-    def _motor_off(self, print_time):
-        self.clear_homing_state((0, 1, 2))
-
     def _check_endstops(self, move):
         end_pos = move.end_pos
         for i in (0, 1, 2):