def probe_finalize(self):
toolhead = self.printer.lookup_object('toolhead')
start_pos = toolhead.get_position()
self.deactivate_gcode.run_gcode_from_command()
if toolhead.get_position()[:3] != start_pos[:3]:
raise homing.CommandError(
"Toolhead moved during probe deactivate_gcode script")
def drip_move(self, newpos, speed):
# Validate move
move = Move(self, self.commanded_pos, newpos, speed)
if move.axes_d[3]:
raise homing.CommandError("Invalid drip move")
if not move.move_d or not move.is_kinematic_move:
return
self.kin.check_move(move)
speed = math.sqrt(move.max_cruise_v2)
# Transition to "Flushed" state and then to "Drip" state
self._full_flush()
self.special_queuing_state = "Drip"
self.need_check_stall = self.reactor.NEVER
self.reactor.update_timer(self.flush_timer, self.reactor.NEVER)
self.move_queue.set_flush_time(self.reactor.NEVER)
self.drip_completion = self.reactor.completion()
# Split move into many tiny moves and queue them
num_moves = max(1, int(math.ceil(move.min_move_t / DRIP_SEGMENT_TIME)))
inv_num_moves = 1. / float(num_moves)
submove_d = [d * inv_num_moves for d in move.axes_d]
prev_pos = move.start_pos
for i in range(num_moves - 1):
next_pos = [p + d for p, d in zip(prev_pos, submove_d)]
self.move_queue.add_move(Move(self, prev_pos, next_pos, speed))
prev_pos = next_pos
self.move_queue.add_move(Move(self, prev_pos, move.end_pos, speed))
# Transmit moves
self._calc_print_time()
try:
self.move_queue.flush()
except DripModeEndSignal as e:
self.move_queue.reset()
# Return to "Flushed" state
self._full_flush()
def do_homing_move(self, movepos, speed, accel, triggered):
if not self.can_home:
raise self.gcode.error("No endstop for this manual stepper")
# Start endstop checking
self.sync_print_time()
endstops = self.rail.get_endstops()
for mcu_endstop, name in endstops:
min_step_dist = min(
[s.get_step_dist() for s in mcu_endstop.get_steppers()])
mcu_endstop.home_start(self.next_cmd_time,
ENDSTOP_SAMPLE_TIME,
ENDSTOP_SAMPLE_COUNT,
min_step_dist / speed,
triggered=triggered)
# Issue move
self.do_move(movepos, speed, accel)
# Wait for endstops to trigger
error = None
for mcu_endstop, name in endstops:
try:
mcu_endstop.home_wait(self.next_cmd_time)
except mcu_endstop.TimeoutError as e:
if error is None:
error = "Failed to home %s: %s" % (name, str(e))
self.sync_print_time()
if error is not None:
raise homing.CommandError(error)
def home_prepare(self):
toolhead = self.printer.lookup_object('toolhead')
start_pos = toolhead.get_position()
self.activate_gcode.run_gcode_from_command()
if toolhead.get_position()[:3] != start_pos[:3]:
raise homing.CommandError(
"Toolhead moved during probe activate_gcode script")
self.mcu_endstop.home_prepare()
def run_probe(self, params={}):
speed = self.gcode.get_float("PROBE_SPEED",
params,
self.speed,
above=0.)
lift_speed = self.get_lift_speed(params)
sample_count = self.gcode.get_int("SAMPLES",
params,
self.sample_count,
minval=1)
sample_retract_dist = self.gcode.get_float("SAMPLE_RETRACT_DIST",
params,
self.sample_retract_dist,
above=0.)
samples_tolerance = self.gcode.get_float("SAMPLES_TOLERANCE",
params,
self.samples_tolerance,
minval=0.)
samples_retries = self.gcode.get_int("SAMPLES_TOLERANCE_RETRIES",
params,
self.samples_retries,
minval=0)
samples_result = self.gcode.get_str("SAMPLES_RESULT", params,
self.samples_result)
must_notify_multi_probe = not self.multi_probe_pending
if must_notify_multi_probe:
self.multi_probe_begin()
retries = 0
positions = []
while len(positions) < sample_count:
# Probe position
pos = self._probe(speed)
positions.append(pos)
# Check samples tolerance
z_positions = [p[2] for p in positions]
if max(z_positions) - min(z_positions) > samples_tolerance:
if retries >= samples_retries:
raise homing.CommandError(
"Probe samples exceed samples_tolerance")
self.gcode.respond_info(
"Probe samples exceed tolerance. Retrying...")
retries += 1
positions = []
# Retract
if len(positions) < sample_count:
liftpos = [None, None, pos[2] + sample_retract_dist]
self._move(liftpos, lift_speed)
if must_notify_multi_probe:
self.multi_probe_end()
# Calculate and return result
if samples_result == 'median':
return self._calc_median(positions)
return self._calc_mean(positions)
def finalize_probe(self):
endstops = [(self.mcu_probe, "probe")]
probe_instance, name = endstops[0]
if hasattr(probe_instance, 'stow_probe'):
probe_instance.stow_probe()
error = None
for mcu_endstop, name in endstops:
try:
mcu_endstop.home_finalize()
except homing.CommandError as e:
if error is None:
error = str(e)
if error is not None:
raise homing.CommandError(error)
def _probe(self, speed):
toolhead = self.printer.lookup_object('toolhead')
homing_state = homing.Homing(self.printer)
pos = toolhead.get_position()
pos[2] = self.z_position
endstops = [(self.mcu_probe, "probe")]
verify = self.printer.get_start_args().get('debugoutput') is None
try:
homing_state.homing_move(pos, endstops, speed,
probe_pos=True, verify_movement=verify)
except homing.CommandError as e:
reason = str(e)
if "Timeout during endstop homing" in reason:
reason += HINT_TIMEOUT
raise homing.CommandError(reason)
pos = toolhead.get_position()
self.gcode.respond_info("probe at %.3f,%.3f is z=%.6f" % (
pos[0], pos[1], pos[2]))
self.gcode.reset_last_position()
return pos[:3]
def _probe(self, speed):
pheater = self.printer.lookup_object('heater')
try:
heater_bed = pheater.lookup_heater("heater_bed")
except self.printer.config_error as e:
heater_bed = None
if heater_bed is not None and self.disable_bed_heater:
heated_bed_target_temp = heater_bed.target_temp
self.gcode.respond_info("Heated bed target temp before probe" +
" run: %.1f degrees"
% heated_bed_target_temp)
heater_bed.set_temp(0., 0.)
toolhead = self.printer.lookup_object('toolhead')
homing_state = homing.Homing(self.printer)
pos = toolhead.get_position()
pos[2] = self.z_position
endstops = [(self.mcu_probe, "probe")]
verify = self.printer.get_start_args().get('debugoutput') is None
try:
homing_state.homing_move(pos, endstops, speed,
probe_pos=True, verify_movement=verify)
except homing.CommandError as e:
reason = str(e)
if "Timeout during endstop homing" in reason:
reason += HINT_TIMEOUT
raise homing.CommandError(reason)
pos = toolhead.get_position()
self.gcode.respond_info("probe at %.3f,%.3f is z=%.6f" % (
pos[0], pos[1], pos[2]))
self.gcode.reset_last_position()
if heater_bed is not None and self.disable_bed_heater:
heater_bed.set_temp(0., heated_bed_target_temp)
self.gcode.respond_info("Heater bed reset to %.1f degrees"
% heated_bed_target_temp)
return pos[:3]
def do_homing_move(self, movepos, speed, accel, triggered, check_trigger):
if not self.can_home:
raise self.printer.command_error(
"No endstop for this manual stepper")
# Notify start of homing/probing move
endstops = self.rail.get_endstops()
self.printer.send_event("homing:homing_move_begin",
[es for es, name in endstops])
# Start endstop checking
self.sync_print_time()
endstops = self.rail.get_endstops()
for mcu_endstop, name in endstops:
min_step_dist = min(
[s.get_step_dist() for s in mcu_endstop.get_steppers()])
mcu_endstop.home_start(self.next_cmd_time,
ENDSTOP_SAMPLE_TIME,
ENDSTOP_SAMPLE_COUNT,
min_step_dist / speed,
triggered=triggered)
# Issue move
self.do_move(movepos, speed, accel)
# Wait for endstops to trigger
error = None
for mcu_endstop, name in endstops:
did_trigger = mcu_endstop.home_wait(self.next_cmd_time)
if not did_trigger and check_trigger and error is None:
error = "Failed to home %s: Timeout during homing" % (name, )
# Signal homing/probing move complete
try:
self.printer.send_event("homing:homing_move_end",
[es for es, name in endstops])
except CommandError as e:
if error is None:
error = str(e)
self.sync_print_time()
if error is not None:
raise homing.CommandError(error)
def get_heater(self):
raise homing.CommandError("Extruder not configured")
