toolhead: Move kinematic modules to new kinematics/ directory

Move extruder.py, cartesian.py, corexy.py, and delta.py to a new
kinematics/ sub-directory.  This is intended to make adding new
kinematics a little easier.

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

1 files changed, 253 insertions, 0 deletions

diff --git a/klippy/kinematics/extruder.py b/klippy/kinematics/extruder.py
new file mode 100644
index 00000000..8e564d62
--- /dev/null
+++ b/klippy/kinematics/extruder.py
@@ -0,0 +1,253 @@
+# Code for handling printer nozzle extruders
+#
+# Copyright (C) 2016-2018  Kevin O'Connor <kevin@koconnor.net>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+import math, logging
+import stepper, homing, chelper
+
+EXTRUDE_DIFF_IGNORE = 1.02
+
+class PrinterExtruder:
+    def __init__(self, config):
+        self.printer = config.get_printer()
+        self.name = config.get_name()
+        shared_heater = config.get('shared_heater', None)
+        pheater = self.printer.lookup_object('heater')
+        if shared_heater is None:
+            self.heater = pheater.setup_heater(config)
+        else:
+            self.heater = pheater.lookup_heater(shared_heater)
+        self.stepper = stepper.PrinterStepper(config)
+        self.nozzle_diameter = config.getfloat('nozzle_diameter', above=0.)
+        filament_diameter = config.getfloat(
+            'filament_diameter', minval=self.nozzle_diameter)
+        self.filament_area = math.pi * (filament_diameter * .5)**2
+        max_cross_section = config.getfloat(
+            'max_extrude_cross_section', 4. * self.nozzle_diameter**2
+            , above=0.)
+        self.max_extrude_ratio = max_cross_section / self.filament_area
+        logging.info("Extruder max_extrude_ratio=%.6f", self.max_extrude_ratio)
+        toolhead = self.printer.lookup_object('toolhead')
+        max_velocity, max_accel = toolhead.get_max_velocity()
+        self.max_e_velocity = config.getfloat(
+            'max_extrude_only_velocity', max_velocity * self.max_extrude_ratio
+            , above=0.)
+        self.max_e_accel = config.getfloat(
+            'max_extrude_only_accel', max_accel * self.max_extrude_ratio
+            , above=0.)
+        self.stepper.set_max_jerk(9999999.9, 9999999.9)
+        self.max_e_dist = config.getfloat(
+            'max_extrude_only_distance', 50., minval=0.)
+        self.activate_gcode = config.get('activate_gcode', '')
+        self.deactivate_gcode = config.get('deactivate_gcode', '')
+        self.pressure_advance = config.getfloat(
+            'pressure_advance', 0., minval=0.)
+        self.pressure_advance_lookahead_time = config.getfloat(
+            'pressure_advance_lookahead_time', 0.010, minval=0.)
+        self.need_motor_enable = True
+        self.extrude_pos = 0.
+        # Setup iterative solver
+        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)
+        # Setup SET_PRESSURE_ADVANCE command
+        gcode = self.printer.lookup_object('gcode')
+        if self.name in ('extruder', 'extruder0'):
+            gcode.register_mux_command("SET_PRESSURE_ADVANCE", "EXTRUDER", None,
+                                       self.cmd_default_SET_PRESSURE_ADVANCE,
+                                       desc=self.cmd_SET_PRESSURE_ADVANCE_help)
+        gcode.register_mux_command("SET_PRESSURE_ADVANCE", "EXTRUDER", self.name,
+                                   self.cmd_SET_PRESSURE_ADVANCE,
+                                   desc=self.cmd_SET_PRESSURE_ADVANCE_help)
+    def get_heater(self):
+        return self.heater
+    def set_active(self, print_time, is_active):
+        return self.extrude_pos
+    def get_activate_gcode(self, is_active):
+        if is_active:
+            return self.activate_gcode
+        return self.deactivate_gcode
+    def stats(self, eventtime):
+        return self.heater.stats(eventtime)
+    def motor_off(self, print_time):
+        self.stepper.motor_enable(print_time, 0)
+        self.need_motor_enable = True
+    def check_move(self, move):
+        move.extrude_r = move.axes_d[3] / move.move_d
+        move.extrude_max_corner_v = 0.
+        if not self.heater.can_extrude:
+            raise homing.EndstopError(
+                "Extrude below minimum temp\n"
+                "See the 'min_extrude_temp' config option for details")
+        if not move.is_kinematic_move or move.extrude_r < 0.:
+            # Extrude only move (or retraction move) - limit accel and velocity
+            if abs(move.axes_d[3]) > self.max_e_dist:
+                raise homing.EndstopError(
+                    "Extrude only move too long (%.3fmm vs %.3fmm)\n"
+                    "See the 'max_extrude_only_distance' config"
+                    " option for details" % (move.axes_d[3], self.max_e_dist))
+            inv_extrude_r = 1. / abs(move.extrude_r)
+            move.limit_speed(self.max_e_velocity * inv_extrude_r
+                             , self.max_e_accel * inv_extrude_r)
+        elif move.extrude_r > self.max_extrude_ratio:
+            if move.axes_d[3] <= self.nozzle_diameter * self.max_extrude_ratio:
+                # Permit extrusion if amount extruded is tiny
+                move.extrude_r = self.max_extrude_ratio
+                return
+            area = move.axes_d[3] * self.filament_area / move.move_d
+            logging.debug("Overextrude: %s vs %s (area=%.3f dist=%.3f)",
+                          move.extrude_r, self.max_extrude_ratio,
+                          area, move.move_d)
+            raise homing.EndstopError(
+                "Move exceeds maximum extrusion (%.3fmm^2 vs %.3fmm^2)\n"
+                "See the 'max_extrude_cross_section' config option for details"
+                % (area, self.max_extrude_ratio * self.filament_area))
+    def calc_junction(self, prev_move, move):
+        extrude = move.axes_d[3]
+        prev_extrude = prev_move.axes_d[3]
+        if extrude or prev_extrude:
+            if not extrude or not prev_extrude:
+                # Extrude move to non-extrude move - disable lookahead
+                return 0.
+            if ((move.extrude_r > prev_move.extrude_r * EXTRUDE_DIFF_IGNORE
+                 or prev_move.extrude_r > move.extrude_r * EXTRUDE_DIFF_IGNORE)
+                and abs(move.move_d * prev_move.extrude_r - extrude) >= .001):
+                # Extrude ratio between moves is too different
+                return 0.
+            move.extrude_r = prev_move.extrude_r
+        return move.max_cruise_v2
+    def lookahead(self, moves, flush_count, lazy):
+        lookahead_t = self.pressure_advance_lookahead_time
+        if not self.pressure_advance or not lookahead_t:
+            return flush_count
+        # Calculate max_corner_v - the speed the head will accelerate
+        # to after cornering.
+        for i in range(flush_count):
+            move = moves[i]
+            if not move.decel_t:
+                continue
+            cruise_v = move.cruise_v
+            max_corner_v = 0.
+            sum_t = lookahead_t
+            for j in range(i+1, flush_count):
+                fmove = moves[j]
+                if not fmove.max_start_v2:
+                    break
+                if fmove.cruise_v > max_corner_v:
+                    if (not max_corner_v
+                        and not fmove.accel_t and not fmove.cruise_t):
+                        # Start timing after any full decel moves
+                        continue
+                    if sum_t >= fmove.accel_t:
+                        max_corner_v = fmove.cruise_v
+                    else:
+                        max_corner_v = max(
+                            max_corner_v, fmove.start_v + fmove.accel * sum_t)
+                    if max_corner_v >= cruise_v:
+                        break
+                sum_t -= fmove.accel_t + fmove.cruise_t + fmove.decel_t
+                if sum_t <= 0.:
+                    break
+            else:
+                if lazy:
+                    return i
+            move.extrude_max_corner_v = max_corner_v
+        return flush_count
+    def move(self, print_time, move):
+        if self.need_motor_enable:
+            self.stepper.motor_enable(print_time, 1)
+            self.need_motor_enable = False
+        axis_d = move.axes_d[3]
+        axis_r = axis_d / move.move_d
+        accel = move.accel * axis_r
+        start_v = move.start_v * axis_r
+        cruise_v = move.cruise_v * axis_r
+        accel_t, cruise_t, decel_t = move.accel_t, move.cruise_t, move.decel_t
+
+        # Update for pressure advance
+        extra_accel_v = extra_decel_v = 0.
+        start_pos = self.extrude_pos
+        if (axis_d >= 0. and (move.axes_d[0] or move.axes_d[1])
+            and self.pressure_advance):
+            # Calculate extra_accel_v
+            pressure_advance = self.pressure_advance * move.extrude_r
+            prev_pressure_d = start_pos - move.start_pos[3]
+            if accel_t:
+                npd = move.cruise_v * pressure_advance
+                extra_accel_d = npd - prev_pressure_d
+                if extra_accel_d > 0.:
+                    extra_accel_v = extra_accel_d / accel_t
+                    axis_d += extra_accel_d
+                    prev_pressure_d += extra_accel_d
+            # Calculate extra_decel_v
+            emcv = move.extrude_max_corner_v
+            if decel_t and emcv < move.cruise_v:
+                npd = max(emcv, move.end_v) * pressure_advance
+                extra_decel_d = npd - prev_pressure_d
+                if extra_decel_d < 0.:
+                    axis_d += extra_decel_d
+                    extra_decel_v = extra_decel_d / decel_t
+
+        # Generate steps
+        self.extruder_move_fill(
+            self.cmove, print_time, accel_t, cruise_t, decel_t, start_pos,
+            start_v, cruise_v, accel, extra_accel_v, extra_decel_v)
+        self.stepper.step_itersolve(self.cmove)
+        self.extrude_pos = start_pos + axis_d
+    cmd_SET_PRESSURE_ADVANCE_help = "Set pressure advance parameters"
+    def cmd_default_SET_PRESSURE_ADVANCE(self, params):
+        extruder = self.printer.lookup_object('toolhead').get_extruder()
+        extruder.cmd_SET_PRESSURE_ADVANCE(params)
+    def cmd_SET_PRESSURE_ADVANCE(self, params):
+        self.printer.lookup_object('toolhead').get_last_move_time()
+        gcode = self.printer.lookup_object('gcode')
+        pressure_advance = gcode.get_float(
+            'ADVANCE', params, self.pressure_advance, minval=0.)
+        pressure_advance_lookahead_time = gcode.get_float(
+            'ADVANCE_LOOKAHEAD_TIME', params,
+            self.pressure_advance_lookahead_time, minval=0.)
+        self.pressure_advance = pressure_advance
+        self.pressure_advance_lookahead_time = pressure_advance_lookahead_time
+        msg = ("pressure_advance: %.6f\n"
+               "pressure_advance_lookahead_time: %.6f" % (
+                   pressure_advance, pressure_advance_lookahead_time))
+        self.printer.set_rollover_info(self.name, "%s: %s" % (self.name, msg))
+        gcode.respond_info(msg)
+
+# Dummy extruder class used when a printer has no extruder at all
+class DummyExtruder:
+    def set_active(self, print_time, is_active):
+        return 0.
+    def motor_off(self, move_time):
+        pass
+    def check_move(self, move):
+        raise homing.EndstopMoveError(
+            move.end_pos, "Extrude when no extruder present")
+    def calc_junction(self, prev_move, move):
+        return move.max_cruise_v2
+    def lookahead(self, moves, flush_count, lazy):
+        return flush_count
+
+def add_printer_objects(config):
+    printer = config.get_printer()
+    for i in range(99):
+        section = 'extruder%d' % (i,)
+        if not config.has_section(section):
+            if not i and config.has_section('extruder'):
+                pe = PrinterExtruder(config.getsection('extruder'))
+                printer.add_object('extruder0', pe)
+                continue
+            break
+        printer.add_object(section, PrinterExtruder(config.getsection(section)))
+
+def get_printer_extruders(printer):
+    out = []
+    for i in range(99):
+        extruder = printer.lookup_object('extruder%d' % (i,), None)
+        if extruder is None:
+            break
+        out.append(extruder)
+    return out