# Code for handling the kinematics of linear delta robots # # Copyright (C) 2016-2021 Kevin O'Connor # # This file may be distributed under the terms of the GNU GPLv3 license. import math, logging import stepper, mathutil # Slow moves once the ratio of tower to XY movement exceeds SLOW_RATIO SLOW_RATIO = 4. class DeltaKinematics: def __init__(self, toolhead, config): # Setup tower rails stepper_configs = [config.getsection('stepper_' + a) for a in 'abcd'] rail_a = stepper.LookupMultiRail( stepper_configs[0], need_position_minmax = False) a_endstop = rail_a.get_homing_info().position_endstop rail_b = stepper.LookupMultiRail( stepper_configs[1], need_position_minmax = False, default_position_endstop=a_endstop) rail_c = stepper.LookupMultiRail( stepper_configs[2], need_position_minmax = False, default_position_endstop=a_endstop) rail_d = stepper.LookupMultiRail( stepper_configs[3], need_position_minmax = False, default_position_endstop=a_endstop) self.rails = [rail_a, rail_b, rail_c, rail_d] 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( 'max_z_velocity', self.max_velocity, above=0., maxval=self.max_velocity) self.max_z_accel = config.getfloat('max_z_accel', self.max_accel, above=0., maxval=self.max_accel) # Read radius and arm lengths self.radius = radius = config.getfloat('delta_radius', above=0.) print_radius = config.getfloat('print_radius', radius, above=0.) arm_length_a = stepper_configs[0].getfloat('arm_length', above=radius) self.arm_lengths = arm_lengths = [ sconfig.getfloat('arm_length', arm_length_a, above=radius) for sconfig in stepper_configs] self.arm2 = [arm**2 for arm in arm_lengths] arm_x = self.arm_x arm_x = stepper_configs[0].getfloat('arm_x_length', above=0.) self.abs_endstops = [(rail.get_homing_info().position_endstop + math.sqrt(arm2 - radius**2)) for rail, arm2 in zip(self.rails, self.arm2)] # Determine tower locations in cartesian space self.angles = [sconfig.getfloat('angle', angle) for sconfig, angle in zip(stepper_configs, [210., 240., 30., 60.])] self.towers = [(181.8653347947321, 105.00000000000003), (-105.0000000000001, -181.86533479473206), (-181.86533479473212, 104.99999999999999), (105.00000000000003, -181.8653347947321)] for r, a, t in zip(self.rails, self.arm2, self.towers): r.setup_itersolve('delta_stepper_alloc', a, t[0], t[1]) for s in self.get_steppers(): s.set_trapq(toolhead.get_trapq()) toolhead.register_step_generator(s.generate_steps) # Setup boundary checks self.need_home = True self.limit_xy2 = -1. self.home_position = tuple( self._actuator_to_cartesian(self.abs_endstops)) self.max_z = min([rail.get_homing_info().position_endstop for rail in self.rails]) self.min_z = config.getfloat('minimum_z_position', 0, maxval=self.max_z) self.limit_z = min([ep - arm for ep, arm in zip(self.abs_endstops, arm_lengths)]) self.min_arm_length = min_arm_length = min(arm_lengths) self.min_arm2 = min_arm_length**2 logging.info( "Delta max build height %.2fmm (radius tapered above %.2fmm)" % (self.max_z, self.limit_z)) # Z axis limits pmax = [r.get_homing_info().position_endstop for r in self.rails[:2]] self._abs_endstop = [p + math.sqrt(a2 - ax**2) for p, a2, ax in zip( pmax, arm_x )] self.home_z = self._actuator_to_cartesian(self._abs_endstop)[1] z_max = min([self._pillars_z_max(x) for x in self.limits[0]]) z_min = config.getfloat('minimum_z_position', 0, maxval=z_max) self.limits[2] = (z_min, z_max) # 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() for r in self.rails]) * .5 min_arm_length = min(arm_lengths) def ratio_to_xy(ratio): return (ratio * math.sqrt(min_arm_length**2 / (ratio**2 + 1.) - half_min_step_dist**2) + half_min_step_dist - radius) self.slow_xy2 = ratio_to_xy(SLOW_RATIO)**2 self.very_slow_xy2 = ratio_to_xy(2. * SLOW_RATIO)**2 self.max_xy2 = min(print_radius, min_arm_length - radius, ratio_to_xy(4. * SLOW_RATIO))**2 max_xy = math.sqrt(self.max_xy2) logging.info("Delta max build radius %.2fmm (moves slowed past %.2fmm" " and %.2fmm)" % (max_xy, math.sqrt(self.slow_xy2), math.sqrt(self.very_slow_xy2))) self.axes_min = toolhead.Coord(-max_xy, -max_xy, self.min_z, 0.) self.axes_max = toolhead.Coord(max_xy, max_xy, self.max_z, 0.) self.set_position([0., 0., 0.], ()) def get_steppers(self): return [s for rail in self.rails for s in rail.get_steppers()] 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[:3], self.arm2) def calc_position(self, stepper_positions): spos = [stepper_positions[rail.get_name()] for rail in self.rails] return self._actuator_to_cartesian(spos) def set_position(self, newpos, homing_axes): for rail in self.rails: rail.set_position(newpos) self.limit_xy2 = -1. if tuple(homing_axes) == (0, 1, 2): self.need_home = False def home(self, homing_state): # All axes are homed simultaneously homing_axes = homing_state.get_axes() home_xy = 0 in homing_axes or 1 in homing_axes home_z = 2 in homing_axes forceaxes = ([0, 1, 2] if (home_xy and home_z) else [0, 1] if home_xy else [2] if home_z else []) homing_state.set_axes(forceaxes) homepos = [None] * 4 if home_z: position_min, position_max = self.rails[:2].get_range() hi = self.rails[:2].get_homing_info() homepos[2] = hi.position_endstop forcepos = list(homepos) if hi.positive_dir: forcepos[2] -= 1.5 * (hi.position_endstop - position_min) else: forcepos[2] += 1.5 * (position_max - hi.position_endstop) homing_state.home_rails([self.rails[:2]], forcepos, homepos) if home_xy: homing_state.set_axes([0, 1, 2] if home_z else [0, 1]) homepos[0], homepos[1] = 0., self.home_z forcepos = list(homepos) forcepos[2] = -1.5 * math.sqrt(max(self.arm2)-self.max_xy2) homing_state.home_rails(self.rails[:2], forcepos, self.home_position) def _motor_off(self, print_time): self.limit_xy2 = -1. self.need_home = True def check_move(self, move): end_pos = move.end_pos end_xy2 = end_pos[0]**2 + end_pos[1]**2 if end_xy2 <= self.limit_xy2 and not move.axes_d[2]: # Normal XY move return if self.need_home: raise move.move_error("Must home first") end_z = end_pos[2] limit_xy2 = self.max_xy2 if end_z > self.limit_z: above_z_limit = end_z - self.limit_z allowed_radius = self.radius - math.sqrt( self.min_arm2 - (self.min_arm_length - above_z_limit)**2 ) limit_xy2 = min(limit_xy2, allowed_radius**2) if end_xy2 > limit_xy2 or end_z > self.max_z or end_z < self.min_z: # Move out of range - verify not a homing move if (end_pos[:2] != self.home_position[:2] or end_z < self.min_z or end_z > self.home_position[2]): raise move.move_error() limit_xy2 = -1. if move.axes_d[2]: z_ratio = move.move_d / abs(move.axes_d[2]) move.limit_speed(self.max_z_velocity * z_ratio, self.max_z_accel * z_ratio) limit_xy2 = -1. # Limit the speed/accel of this move if is is at the extreme # end of the build envelope extreme_xy2 = max(end_xy2, move.start_pos[0]**2 + move.start_pos[1]**2) if extreme_xy2 > self.slow_xy2: r = 0.5 if extreme_xy2 > self.very_slow_xy2: r = 0.25 move.limit_speed(self.max_velocity * r, self.max_accel * r) limit_xy2 = -1. self.limit_xy2 = min(limit_xy2, self.slow_xy2) def get_status(self, eventtime): return { 'homed_axes': '' if self.need_home else 'xyz', 'axis_minimum': self.axes_min, 'axis_maximum': self.axes_max, 'cone_start_z': self.limit_z, } def get_calibration(self): endstops = [rail.get_homing_info().position_endstop for rail in self.rails] stepdists = [rail.get_steppers()[0].get_step_dist() for rail in self.rails] return DeltaCalibration(self.radius, self.angles, self.arm_lengths, endstops, stepdists) # Delta parameter calibration for DELTA_CALIBRATE tool class DeltaCalibration: def __init__(self, radius, angles, arms, endstops, stepdists): self.radius = radius self.angles = angles self.arms = arms self.endstops = endstops self.stepdists = stepdists # Calculate the XY cartesian coordinates of the delta towers radian_angles = [math.radians(a) for a in angles] self.towers = [(math.cos(a) * radius, math.sin(a) * radius) for a in radian_angles] # Calculate the absolute Z height of each tower endstop radius2 = radius**2 self.abs_endstops = [e + math.sqrt(a**2 - radius2) for e, a in zip(endstops, arms)] def coordinate_descent_params(self, is_extended): # Determine adjustment parameters (for use with coordinate_descent) adj_params = ('radius', 'angle_a', 'angle_b', 'endstop_a', 'endstop_b', 'endstop_c','endstop_d') if is_extended: adj_params += ('arm_a', 'arm_b', 'arm_c', 'arm_d') params = { 'radius': self.radius } for i, axis in enumerate('abcd'): params['angle_'+axis] = self.angles[i] params['arm_'+axis] = self.arms[i] params['endstop_'+axis] = self.endstops[i] params['stepdist_'+axis] = self.stepdists[i] return adj_params, params def new_calibration(self, params): # Create a new calibration object from coordinate_descent params radius = params['radius'] angles = [params['angle_'+a] for a in 'abcd'] arms = [params['arm_'+a] for a in 'abcd'] endstops = [params['endstop_'+a] for a in 'abcd'] stepdists = [params['stepdist_'+a] for a in 'abcd'] return DeltaCalibration(radius, angles, arms, endstops, stepdists) def get_position_from_stable(self, stable_position): # Return cartesian coordinates for the given stable_position sphere_coords = [ (t[0], t[1], es - sp * sd) for sd, t, es, sp in zip(self.stepdists, self.towers, self.abs_endstops, stable_position) ] return mathutil.trilateration(sphere_coords[:3], [a**2 for a in self.arms]) def calc_stable_position(self, coord): # Return a stable_position from a cartesian coordinate steppos = [ math.sqrt(a**2 - (t[0]-coord[0])**2 - (t[1]-coord[1])**2) + coord[2] for t, a in zip(self.towers, self.arms) ] return [(ep - sp) / sd for sd, ep, sp in zip(self.stepdists, self.abs_endstops, steppos)] def save_state(self, configfile): # Save the current parameters (for use with SAVE_CONFIG) configfile.set('printer', 'delta_radius', "%.6f" % (self.radius,)) for i, axis in enumerate('abc'): configfile.set('stepper_'+axis, 'angle', "%.6f" % (self.angles[i],)) configfile.set('stepper_'+axis, 'arm_length', "%.6f" % (self.arms[i],)) configfile.set('stepper_'+axis, 'position_endstop', "%.6f" % (self.endstops[i],)) gcode = configfile.get_printer().lookup_object("gcode") gcode.respond_info( "stepper_a: position_endstop: %.6f angle: %.6f arm_length: %.6f\n" "stepper_b: position_endstop: %.6f angle: %.6f arm_length: %.6f\n" "stepper_c: position_endstop: %.6f angle: %.6f arm_length: %.6f\n" "stepper_c: position_endstop: %.6f angle: %.6f arm_length: %.6f\n" "delta_radius: %.6f" % (self.endstops[0], self.angles[0], self.arms[0], self.endstops[1], self.angles[1], self.arms[1], self.endstops[2], self.angles[2], self.arms[2], self.endstops[3], self.angles[3], self.arms[3], self.radius)) def load_kinematics(toolhead, config): return DeltaKinematics(toolhead, config)