stepper: Add get/set_tag_position() and convert calc_position()

Rename calc_position() to calc_tag_position() and have it calculate
the value of the position from the last stepper set_tag_position()
call.  This enables the calc_tag_position() code to be more flexible
as it can be run with arbitrary positions.

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

klippy/kinematics/cartesian.py

@@ -53,8 +53,8 @@ class CartKinematics:
         if flags == "Z":
             return self.rails[2].get_steppers()
         return [s for rail in self.rails for s in rail.get_steppers()]
-    def calc_position(self):
-        return [rail.get_commanded_position() for rail in self.rails]
+    def calc_tag_position(self):
+        return [rail.get_tag_position() for rail in self.rails]
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
@@ -125,8 +125,9 @@ class CartKinematics:
         self.rails[dc_axis].set_trapq(None)
         dc_rail.set_trapq(toolhead.get_trapq())
         self.rails[dc_axis] = dc_rail
-        extruder_pos = toolhead.get_position()[3]
-        toolhead.set_position(self.calc_position() + [extruder_pos])
+        pos = toolhead.get_position()
+        pos[dc_axis] = dc_rail.get_commanded_position()
+        toolhead.set_position(pos)
         if self.limits[dc_axis][0] <= self.limits[dc_axis][1]:
             self.limits[dc_axis] = dc_rail.get_range()
     cmd_SET_DUAL_CARRIAGE_help = "Set which carriage is active"

klippy/kinematics/corexy.py

@@ -43,8 +43,8 @@ class CoreXYKinematics:
         if flags == "Z":
             return self.rails[2].get_steppers()
         return [s for rail in self.rails for s in rail.get_steppers()]
-    def calc_position(self):
-        pos = [rail.get_commanded_position() for rail in self.rails]
+    def calc_tag_position(self):
+        pos = [rail.get_tag_position() for rail in self.rails]
         return [0.5 * (pos[0] + pos[1]), 0.5 * (pos[0] - pos[1]), pos[2]]
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):

klippy/kinematics/delta.py

@@ -92,8 +92,8 @@ class DeltaKinematics:
     def _actuator_to_cartesian(self, spos):
         sphere_coords = [(t[0], t[1], sp) for t, sp in zip(self.towers, spos)]
         return mathutil.trilateration(sphere_coords, self.arm2)
-    def calc_position(self):
-        spos = [rail.get_commanded_position() for rail in self.rails]
+    def calc_tag_position(self):
+        spos = [rail.get_tag_position() for rail in self.rails]
         return self._actuator_to_cartesian(spos)
     def set_position(self, newpos, homing_axes):
         for rail in self.rails:

klippy/kinematics/none.py

@@ -9,7 +9,7 @@ class NoneKinematics:
         pass
     def get_steppers(self, flags=""):
         return []
-    def calc_position(self):
+    def calc_tag_position(self):
         return [0, 0, 0]
     def set_position(self, newpos, homing_axes):
         pass

klippy/kinematics/polar.py

@@ -40,10 +40,10 @@ class PolarKinematics:
         if flags == "Z":
             return self.rails[1].get_steppers()
         return list(self.steppers)
-    def calc_position(self):
-        bed_angle = self.steppers[0].get_commanded_position()
-        arm_pos = self.rails[0].get_commanded_position()
-        z_pos = self.rails[1].get_commanded_position()
+    def calc_tag_position(self):
+        bed_angle = self.steppers[0].get_tag_position()
+        arm_pos = self.rails[0].get_tag_position()
+        z_pos = self.rails[1].get_tag_position()
         return [math.cos(bed_angle) * arm_pos, math.sin(bed_angle) * arm_pos,
                 z_pos]
     def set_position(self, newpos, homing_axes):

klippy/kinematics/winch.py

@@ -31,9 +31,9 @@ class WinchKinematics:
         self.set_position([0., 0., 0.], ())
     def get_steppers(self, flags=""):
         return list(self.steppers)
-    def calc_position(self):
+    def calc_tag_position(self):
         # Use only first three steppers to calculate cartesian position
-        spos = [s.get_commanded_position() for s in self.steppers[:3]]
+        spos = [s.get_tag_position() for s in self.steppers[:3]]
         return mathutil.trilateration(self.anchors[:3], [sp*sp for sp in spos])
     def set_position(self, newpos, homing_axes):
         for s in self.steppers: