mcu: Enhance itersolve stepper kinematics allocation

Allocate the stepper_kinematics directly in mcu.py - that way the
kinematic classes don't have to interact with the chelper code.

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

klippy/kinematics/cartesian.py

@@ -4,13 +4,17 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
-import stepper, homing, chelper
+import stepper, homing
 
 class CartKinematics:
     def __init__(self, toolhead, config):
         self.printer = config.get_printer()
+        # Setup axis rails
         self.rails = [stepper.LookupMultiRail(config.getsection('stepper_' + n))
                       for n in ['x', 'y', 'z']]
+        for rail, axis in zip(self.rails, 'xyz'):
+            rail.setup_itersolve('cartesian_stepper_alloc', axis)
+        # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
             'max_z_velocity', max_velocity, above=0., maxval=max_velocity)
@@ -18,10 +22,6 @@ class CartKinematics:
             'max_z_accel', max_accel, above=0., maxval=max_accel)
         self.need_motor_enable = True
         self.limits = [(1.0, -1.0)] * 3
-        # Setup iterative solver
-        ffi_main, ffi_lib = chelper.get_ffi()
-        for axis, rail in zip('xyz', self.rails):
-            rail.setup_cartesian_itersolve(axis)
         # Setup stepper max halt velocity
         max_halt_velocity = toolhead.get_max_axis_halt()
         self.rails[0].set_max_jerk(max_halt_velocity, max_accel)
@@ -36,7 +36,7 @@ class CartKinematics:
             dc_axis = dc_config.getchoice('axis', {'x': 'x', 'y': 'y'})
             self.dual_carriage_axis = {'x': 0, 'y': 1}[dc_axis]
             dc_rail = stepper.LookupMultiRail(dc_config)
-            dc_rail.setup_cartesian_itersolve(dc_axis)
+            dc_rail.setup_itersolve('cartesian_stepper_alloc', dc_axis)
             dc_rail.set_max_jerk(max_halt_velocity, max_accel)
             self.dual_carriage_rails = [
                 self.rails[self.dual_carriage_axis], dc_rail]

klippy/kinematics/corexy.py

@@ -4,15 +4,20 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging, math
-import stepper, homing, chelper
+import stepper, homing
 
 class CoreXYKinematics:
     def __init__(self, toolhead, config):
+        # Setup axis rails
         self.rails = [ stepper.PrinterRail(config.getsection('stepper_x')),
                        stepper.PrinterRail(config.getsection('stepper_y')),
                        stepper.LookupMultiRail(config.getsection('stepper_z')) ]
         self.rails[0].add_to_endstop(self.rails[1].get_endstops()[0][0])
         self.rails[1].add_to_endstop(self.rails[0].get_endstops()[0][0])
+        self.rails[0].setup_itersolve('corexy_stepper_alloc', '+')
+        self.rails[1].setup_itersolve('corexy_stepper_alloc', '-')
+        self.rails[2].setup_itersolve('cartesian_stepper_alloc', 'z')
+        # Setup boundary checks
         max_velocity, max_accel = toolhead.get_max_velocity()
         self.max_z_velocity = config.getfloat(
             'max_z_velocity', max_velocity, above=0., maxval=max_velocity)
@@ -20,13 +25,6 @@ class CoreXYKinematics:
             'max_z_accel', max_accel, above=0., maxval=max_accel)
         self.need_motor_enable = True
         self.limits = [(1.0, -1.0)] * 3
-        # Setup iterative solver
-        ffi_main, ffi_lib = chelper.get_ffi()
-        self.rails[0].setup_itersolve(ffi_main.gc(
-            ffi_lib.corexy_stepper_alloc('+'), ffi_lib.free))
-        self.rails[1].setup_itersolve(ffi_main.gc(
-            ffi_lib.corexy_stepper_alloc('-'), ffi_lib.free))
-        self.rails[2].setup_cartesian_itersolve('z')
         # Setup stepper max halt velocity
         max_halt_velocity = toolhead.get_max_axis_halt()
         max_xy_halt_velocity = max_halt_velocity * math.sqrt(2.)

klippy/kinematics/delta.py

@@ -4,7 +4,7 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import math, logging
-import stepper, homing, chelper, mathutil
+import stepper, homing, mathutil
 
 # Slow moves once the ratio of tower to XY movement exceeds SLOW_RATIO
 SLOW_RATIO = 3.
@@ -60,12 +60,8 @@ class DeltaKinematics:
         self.towers = [(math.cos(math.radians(angle)) * radius,
                         math.sin(math.radians(angle)) * radius)
                        for angle in self.angles]
-        # Setup iterative solver
-        ffi_main, ffi_lib = chelper.get_ffi()
         for r, a, t in zip(self.rails, self.arm2, self.towers):
-            sk = ffi_main.gc(ffi_lib.delta_stepper_alloc(a, t[0], t[1]),
-                             ffi_lib.free)
-            r.setup_itersolve(sk)
+            r.setup_itersolve('delta_stepper_alloc', a, t[0], t[1])
         # Find the point where an XY move could result in excessive
         # tower movement
         half_min_step_dist = min([r.get_steppers()[0].get_step_dist()

klippy/kinematics/extruder.py

@@ -51,8 +51,7 @@ class PrinterExtruder:
         ffi_main, ffi_lib = chelper.get_ffi()
         self.cmove = ffi_main.gc(ffi_lib.move_alloc(), ffi_lib.free)
         self.extruder_move_fill = ffi_lib.extruder_move_fill
-        sk = ffi_main.gc(ffi_lib.extruder_stepper_alloc(), ffi_lib.free)
-        self.stepper.setup_itersolve(sk)
+        self.stepper.setup_itersolve('extruder_stepper_alloc')
         # Setup SET_PRESSURE_ADVANCE command
         gcode = self.printer.lookup_object('gcode')
         if self.name in ('extruder', 'extruder0'):