From 1286d3006c355a0fc7c51736a2466794ede00612 Mon Sep 17 00:00:00 2001 From: Kevin O'Connor Date: Mon, 17 Aug 2020 00:05:41 -0400 Subject: [PATCH] gcode_move: Move GCodeMove class from gcode.py to new extras module Signed-off-by: Kevin O'Connor --- docs/Code_Overview.md | 13 +- klippy/extras/bed_mesh.py | 2 +- klippy/extras/bed_tilt.py | 2 +- klippy/extras/gcode_arcs.py | 2 +- klippy/extras/gcode_move.py | 280 +++++++++++++++++++++++++++++++ klippy/extras/homing_override.py | 1 + klippy/extras/print_stats.py | 2 +- klippy/extras/safe_z_home.py | 1 + klippy/extras/tuning_tower.py | 2 +- klippy/gcode.py | 272 ------------------------------ klippy/toolhead.py | 3 +- 11 files changed, 296 insertions(+), 284 deletions(-) create mode 100644 klippy/extras/gcode_move.py diff --git a/docs/Code_Overview.md b/docs/Code_Overview.md index 73111870..f7d14463 100644 --- a/docs/Code_Overview.md +++ b/docs/Code_Overview.md @@ -125,12 +125,13 @@ of a typical move command. The [kinematics](Kinematics.md) document provides further information on the mechanics of moves. * Processing for a move command starts in gcode.py. The goal of - gcode.py is to translate G-code into internal calls. Changes in - origin (eg, G92), changes in relative vs absolute positions (eg, - G90), and unit changes (eg, F6000=100mm/s) are handled here. The - code path for a move is: `_process_data() -> _process_commands() -> - cmd_G1()`. Ultimately the ToolHead class is invoked to execute the - actual request: `cmd_G1() -> ToolHead.move()` + gcode.py is to translate G-code into internal calls. A G1 command + will invoke cmd_G1() in klippy/extras/gcode_move.py. The + gcode_move.py code handles changes in origin (eg, G92), changes in + relative vs absolute positions (eg, G90), and unit changes (eg, + F6000=100mm/s). The code path for a move is: `_process_data() -> + _process_commands() -> cmd_G1()`. Ultimately the ToolHead class is + invoked to execute the actual request: `cmd_G1() -> ToolHead.move()` * The ToolHead class (in toolhead.py) handles "look-ahead" and tracks the timing of printing actions. The main codepath for a move is: diff --git a/klippy/extras/bed_mesh.py b/klippy/extras/bed_mesh.py index b1c0f6b8..595d7abb 100644 --- a/klippy/extras/bed_mesh.py +++ b/klippy/extras/bed_mesh.py @@ -88,7 +88,7 @@ class BedMesh: 'BED_MESH_CLEAR', self.cmd_BED_MESH_CLEAR, desc=self.cmd_BED_MESH_CLEAR_help) # Register transform - gcode_move = self.printer.lookup_object('gcode_move') + gcode_move = self.printer.load_object(config, 'gcode_move') gcode_move.set_move_transform(self) def handle_ready(self): self.toolhead = self.printer.lookup_object('toolhead') diff --git a/klippy/extras/bed_tilt.py b/klippy/extras/bed_tilt.py index dfcb682f..cd1ce177 100644 --- a/klippy/extras/bed_tilt.py +++ b/klippy/extras/bed_tilt.py @@ -19,7 +19,7 @@ class BedTilt: BedTiltCalibrate(config, self) self.toolhead = None # Register move transform with g-code class - gcode_move = self.printer.lookup_object('gcode_move') + gcode_move = self.printer.load_object(config, 'gcode_move') gcode_move.set_move_transform(self) def handle_connect(self): self.toolhead = self.printer.lookup_object('toolhead') diff --git a/klippy/extras/gcode_arcs.py b/klippy/extras/gcode_arcs.py index ad973562..71f83ffb 100644 --- a/klippy/extras/gcode_arcs.py +++ b/klippy/extras/gcode_arcs.py @@ -17,7 +17,7 @@ class ArcSupport: self.printer = config.get_printer() self.mm_per_arc_segment = config.getfloat('resolution', 1., above=0.0) - self.gcode_move = self.printer.lookup_object('gcode_move') + self.gcode_move = self.printer.load_object(config, 'gcode_move') self.gcode = self.printer.lookup_object('gcode') self.gcode.register_command("G2", self.cmd_G2) self.gcode.register_command("G3", self.cmd_G2) diff --git a/klippy/extras/gcode_move.py b/klippy/extras/gcode_move.py new file mode 100644 index 00000000..08c926e9 --- /dev/null +++ b/klippy/extras/gcode_move.py @@ -0,0 +1,280 @@ +# G-Code G1 movement commands (and associated coordinate manipulation) +# +# Copyright (C) 2016-2020 Kevin O'Connor +# +# This file may be distributed under the terms of the GNU GPLv3 license. +import logging +import homing + +class GCodeMove: + def __init__(self, config): + self.printer = printer = config.get_printer() + printer.register_event_handler("klippy:ready", self._handle_ready) + printer.register_event_handler("klippy:shutdown", self._handle_shutdown) + printer.register_event_handler("toolhead:set_position", + self.reset_last_position) + printer.register_event_handler("toolhead:manual_move", + self.reset_last_position) + printer.register_event_handler("gcode:command_error", + self.reset_last_position) + printer.register_event_handler("extruder:activate_extruder", + self._handle_activate_extruder) + self.is_printer_ready = False + # Register g-code commands + gcode = printer.lookup_object('gcode') + handlers = [ + 'G1', 'G28', 'G20', 'G21', + 'M82', 'M83', 'G90', 'G91', 'G92', 'M220', 'M221', + 'SET_GCODE_OFFSET', 'SAVE_GCODE_STATE', 'RESTORE_GCODE_STATE', + ] + for cmd in handlers: + func = getattr(self, 'cmd_' + cmd) + desc = getattr(self, 'cmd_' + cmd + '_help', None) + gcode.register_command(cmd, func, False, desc) + gcode.register_command('G0', self.cmd_G1) + gcode.register_command('M114', self.cmd_M114, True) + gcode.register_command('GET_POSITION', self.cmd_GET_POSITION, True) + # G-Code coordinate manipulation + self.absolute_coord = self.absolute_extrude = True + self.base_position = [0.0, 0.0, 0.0, 0.0] + self.last_position = [0.0, 0.0, 0.0, 0.0] + self.homing_position = [0.0, 0.0, 0.0, 0.0] + self.speed = 25. + self.speed_factor = 1. / 60. + self.extrude_factor = 1. + # G-Code state + self.saved_states = {} + self.move_transform = self.move_with_transform = None + self.position_with_transform = (lambda: [0., 0., 0., 0.]) + def _handle_ready(self): + self.is_printer_ready = True + if self.move_transform is None: + toolhead = self.printer.lookup_object('toolhead') + self.move_with_transform = toolhead.move + self.position_with_transform = toolhead.get_position + def _handle_shutdown(self): + if not self.is_printer_ready: + return + self.is_printer_ready = False + logging.info("gcode state: absolute_coord=%s absolute_extrude=%s" + " base_position=%s last_position=%s homing_position=%s" + " speed_factor=%s extrude_factor=%s speed=%s", + self.absolute_coord, self.absolute_extrude, + self.base_position, self.last_position, + self.homing_position, self.speed_factor, + self.extrude_factor, self.speed) + def _handle_activate_extruder(self): + self.reset_last_position() + self.extrude_factor = 1. + self.base_position[3] = self.last_position[3] + def set_move_transform(self, transform, force=False): + if self.move_transform is not None and not force: + raise self.printer.config_error( + "G-Code move transform already specified") + old_transform = self.move_transform + if old_transform is None: + old_transform = self.printer.lookup_object('toolhead', None) + self.move_transform = transform + self.move_with_transform = transform.move + self.position_with_transform = transform.get_position + return old_transform + def _get_gcode_position(self): + p = [lp - bp for lp, bp in zip(self.last_position, self.base_position)] + p[3] /= self.extrude_factor + return p + def _get_gcode_speed(self): + return self.speed / self.speed_factor + def _get_gcode_speed_override(self): + return self.speed_factor * 60. + def get_status(self, eventtime=None): + move_position = self._get_gcode_position() + return { + 'speed_factor': self._get_gcode_speed_override(), + 'speed': self._get_gcode_speed(), + 'extrude_factor': self.extrude_factor, + 'absolute_coordinates': self.absolute_coord, + 'absolute_extrude': self.absolute_extrude, + 'homing_origin': homing.Coord(*self.homing_position), + 'position': homing.Coord(*self.last_position), + 'gcode_position': homing.Coord(*move_position), + } + def reset_last_position(self): + if self.is_printer_ready: + self.last_position = self.position_with_transform() + # G-Code movement commands + def cmd_G1(self, gcmd): + # Move + params = gcmd.get_command_parameters() + try: + for pos, axis in enumerate('XYZ'): + if axis in params: + v = float(params[axis]) + if not self.absolute_coord: + # value relative to position of last move + self.last_position[pos] += v + else: + # value relative to base coordinate position + self.last_position[pos] = v + self.base_position[pos] + if 'E' in params: + v = float(params['E']) * self.extrude_factor + if not self.absolute_coord or not self.absolute_extrude: + # value relative to position of last move + self.last_position[3] += v + else: + # value relative to base coordinate position + self.last_position[3] = v + self.base_position[3] + if 'F' in params: + gcode_speed = float(params['F']) + if gcode_speed <= 0.: + raise gcmd.error("Invalid speed in '%s'" + % (gcmd.get_commandline(),)) + self.speed = gcode_speed * self.speed_factor + except ValueError as e: + raise gcmd.error("Unable to parse move '%s'" + % (gcmd.get_commandline(),)) + self.move_with_transform(self.last_position, self.speed) + def cmd_G28(self, gcmd): + # Move to origin + axes = [] + for pos, axis in enumerate('XYZ'): + if gcmd.get(axis, None) is not None: + axes.append(pos) + if not axes: + axes = [0, 1, 2] + homing_state = homing.Homing(self.printer) + homing_state.home_axes(axes) + for axis in homing_state.get_axes(): + self.base_position[axis] = self.homing_position[axis] + # G-Code coordinate manipulation + def cmd_G20(self, gcmd): + # Set units to inches + raise gcmd.error('Machine does not support G20 (inches) command') + def cmd_G21(self, gcmd): + # Set units to millimeters + pass + def cmd_M82(self, gcmd): + # Use absolute distances for extrusion + self.absolute_extrude = True + def cmd_M83(self, gcmd): + # Use relative distances for extrusion + self.absolute_extrude = False + def cmd_G90(self, gcmd): + # Use absolute coordinates + self.absolute_coord = True + def cmd_G91(self, gcmd): + # Use relative coordinates + self.absolute_coord = False + def cmd_G92(self, gcmd): + # Set position + offsets = [ gcmd.get_float(a, None) for a in 'XYZE' ] + for i, offset in enumerate(offsets): + if offset is not None: + if i == 3: + offset *= self.extrude_factor + self.base_position[i] = self.last_position[i] - offset + if offsets == [None, None, None, None]: + self.base_position = list(self.last_position) + def cmd_M114(self, gcmd): + # Get Current Position + p = self._get_gcode_position() + gcmd.respond_raw("X:%.3f Y:%.3f Z:%.3f E:%.3f" % tuple(p)) + def cmd_M220(self, gcmd): + # Set speed factor override percentage + value = gcmd.get_float('S', 100., above=0.) / (60. * 100.) + self.speed = self._get_gcode_speed() * value + self.speed_factor = value + def cmd_M221(self, gcmd): + # Set extrude factor override percentage + new_extrude_factor = gcmd.get_float('S', 100., above=0.) / 100. + last_e_pos = self.last_position[3] + e_value = (last_e_pos - self.base_position[3]) / self.extrude_factor + self.base_position[3] = last_e_pos - e_value * new_extrude_factor + self.extrude_factor = new_extrude_factor + cmd_SET_GCODE_OFFSET_help = "Set a virtual offset to g-code positions" + def cmd_SET_GCODE_OFFSET(self, gcmd): + move_delta = [0., 0., 0., 0.] + for pos, axis in enumerate('XYZE'): + offset = gcmd.get_float(axis, None) + if offset is None: + offset = gcmd.get_float(axis + '_ADJUST', None) + if offset is None: + continue + offset += self.homing_position[pos] + delta = offset - self.homing_position[pos] + move_delta[pos] = delta + self.base_position[pos] += delta + self.homing_position[pos] = offset + # Move the toolhead the given offset if requested + if gcmd.get_int('MOVE', 0): + speed = gcmd.get_float('MOVE_SPEED', self.speed, above=0.) + for pos, delta in enumerate(move_delta): + self.last_position[pos] += delta + self.move_with_transform(self.last_position, speed) + cmd_SAVE_GCODE_STATE_help = "Save G-Code coordinate state" + def cmd_SAVE_GCODE_STATE(self, gcmd): + state_name = gcmd.get('NAME', 'default') + self.saved_states[state_name] = { + 'absolute_coord': self.absolute_coord, + 'absolute_extrude': self.absolute_extrude, + 'base_position': list(self.base_position), + 'last_position': list(self.last_position), + 'homing_position': list(self.homing_position), + 'speed': self.speed, 'speed_factor': self.speed_factor, + 'extrude_factor': self.extrude_factor, + } + cmd_RESTORE_GCODE_STATE_help = "Restore a previously saved G-Code state" + def cmd_RESTORE_GCODE_STATE(self, gcmd): + state_name = gcmd.get('NAME', 'default') + state = self.saved_states.get(state_name) + if state is None: + raise gcmd.error("Unknown g-code state: %s" % (state_name,)) + # Restore state + self.absolute_coord = state['absolute_coord'] + self.absolute_extrude = state['absolute_extrude'] + self.base_position = list(state['base_position']) + self.homing_position = list(state['homing_position']) + self.speed = state['speed'] + self.speed_factor = state['speed_factor'] + self.extrude_factor = state['extrude_factor'] + # Restore the relative E position + e_diff = self.last_position[3] - state['last_position'][3] + self.base_position[3] += e_diff + # Move the toolhead back if requested + if gcmd.get_int('MOVE', 0): + speed = gcmd.get_float('MOVE_SPEED', self.speed, above=0.) + self.last_position[:3] = state['last_position'][:3] + self.move_with_transform(self.last_position, speed) + def cmd_GET_POSITION(self, gcmd): + toolhead = self.printer.lookup_object('toolhead', None) + if toolhead is None: + raise gcmd.error("Printer not ready") + kin = toolhead.get_kinematics() + steppers = kin.get_steppers() + mcu_pos = " ".join(["%s:%d" % (s.get_name(), s.get_mcu_position()) + for s in steppers]) + for s in steppers: + s.set_tag_position(s.get_commanded_position()) + stepper_pos = " ".join(["%s:%.6f" % (s.get_name(), s.get_tag_position()) + for s in steppers]) + kin_pos = " ".join(["%s:%.6f" % (a, v) + for a, v in zip("XYZ", kin.calc_tag_position())]) + toolhead_pos = " ".join(["%s:%.6f" % (a, v) for a, v in zip( + "XYZE", toolhead.get_position())]) + gcode_pos = " ".join(["%s:%.6f" % (a, v) + for a, v in zip("XYZE", self.last_position)]) + base_pos = " ".join(["%s:%.6f" % (a, v) + for a, v in zip("XYZE", self.base_position)]) + homing_pos = " ".join(["%s:%.6f" % (a, v) + for a, v in zip("XYZ", self.homing_position)]) + gcmd.respond_info("mcu: %s\n" + "stepper: %s\n" + "kinematic: %s\n" + "toolhead: %s\n" + "gcode: %s\n" + "gcode base: %s\n" + "gcode homing: %s" + % (mcu_pos, stepper_pos, kin_pos, toolhead_pos, + gcode_pos, base_pos, homing_pos)) + +def load_config(config): + return GCodeMove(config) diff --git a/klippy/extras/homing_override.py b/klippy/extras/homing_override.py index 9d683537..149bd022 100644 --- a/klippy/extras/homing_override.py +++ b/klippy/extras/homing_override.py @@ -13,6 +13,7 @@ class HomingOverride: gcode_macro = self.printer.load_object(config, 'gcode_macro') self.template = gcode_macro.load_template(config, 'gcode') self.in_script = False + self.printer.load_object(config, 'gcode_move') self.gcode = self.printer.lookup_object('gcode') self.prev_G28 = self.gcode.register_command("G28", None) self.gcode.register_command("G28", self.cmd_G28) diff --git a/klippy/extras/print_stats.py b/klippy/extras/print_stats.py index 67bb2f33..d8ab7eb8 100644 --- a/klippy/extras/print_stats.py +++ b/klippy/extras/print_stats.py @@ -7,7 +7,7 @@ class PrintStats: def __init__(self, config): printer = config.get_printer() - self.gcode_move = printer.lookup_object('gcode_move') + self.gcode_move = printer.load_object(config, 'gcode_move') self.reactor = printer.get_reactor() self.reset() def _update_filament_usage(self, eventtime): diff --git a/klippy/extras/safe_z_home.py b/klippy/extras/safe_z_home.py index 21d6f12e..c2f98866 100644 --- a/klippy/extras/safe_z_home.py +++ b/klippy/extras/safe_z_home.py @@ -20,6 +20,7 @@ class SafeZHoming: self.max_z = config.getsection('stepper_z').getfloat('position_max') self.speed = config.getfloat('speed', 50.0, above=0.) self.move_to_previous = config.getboolean('move_to_previous', False) + self.printer.load_object(config, 'gcode_move') self.gcode = self.printer.lookup_object('gcode') self.prev_G28 = self.gcode.register_command("G28", None) self.gcode.register_command("G28", self.cmd_G28) diff --git a/klippy/extras/tuning_tower.py b/klippy/extras/tuning_tower.py index e16192d5..fa1ea536 100644 --- a/klippy/extras/tuning_tower.py +++ b/klippy/extras/tuning_tower.py @@ -15,7 +15,7 @@ class TuningTower: self.last_z = self.start = self.factor = self.band = 0. self.last_command_value = None self.command_fmt = "" - self.gcode_move = self.printer.lookup_object("gcode_move") + self.gcode_move = self.printer.load_object(config, "gcode_move") # Register command self.gcode = self.printer.lookup_object("gcode") self.gcode.register_command("TUNING_TOWER", self.cmd_TUNING_TOWER, diff --git a/klippy/gcode.py b/klippy/gcode.py index ec5439de..d2ce232f 100644 --- a/klippy/gcode.py +++ b/klippy/gcode.py @@ -325,277 +325,6 @@ class GCodeDispatch: cmdhelp.append("%-10s: %s" % (cmd, self.gcode_help[cmd])) gcmd.respond_info("\n".join(cmdhelp), log=False) -# G1 movement commands (and associated coordinate manipulation) -class GCodeMove: - def __init__(self, printer): - self.printer = printer - printer.register_event_handler("klippy:ready", self._handle_ready) - printer.register_event_handler("klippy:shutdown", self._handle_shutdown) - printer.register_event_handler("toolhead:set_position", - self.reset_last_position) - printer.register_event_handler("toolhead:manual_move", - self.reset_last_position) - printer.register_event_handler("gcode:command_error", - self.reset_last_position) - printer.register_event_handler("extruder:activate_extruder", - self._handle_activate_extruder) - self.is_printer_ready = False - # Register g-code commands - gcode = self.printer.lookup_object('gcode') - handlers = [ - 'G1', 'G28', 'G20', 'G21', - 'M82', 'M83', 'G90', 'G91', 'G92', 'M220', 'M221', - 'SET_GCODE_OFFSET', 'SAVE_GCODE_STATE', 'RESTORE_GCODE_STATE', - ] - for cmd in handlers: - func = getattr(self, 'cmd_' + cmd) - desc = getattr(self, 'cmd_' + cmd + '_help', None) - gcode.register_command(cmd, func, False, desc) - gcode.register_command('G0', self.cmd_G1) - gcode.register_command('M114', self.cmd_M114, True) - gcode.register_command('GET_POSITION', self.cmd_GET_POSITION, True) - # G-Code coordinate manipulation - self.absolute_coord = self.absolute_extrude = True - self.base_position = [0.0, 0.0, 0.0, 0.0] - self.last_position = [0.0, 0.0, 0.0, 0.0] - self.homing_position = [0.0, 0.0, 0.0, 0.0] - self.speed = 25. - self.speed_factor = 1. / 60. - self.extrude_factor = 1. - # G-Code state - self.saved_states = {} - self.move_transform = self.move_with_transform = None - self.position_with_transform = (lambda: [0., 0., 0., 0.]) - def _handle_ready(self): - self.is_printer_ready = True - if self.move_transform is None: - toolhead = self.printer.lookup_object('toolhead') - self.move_with_transform = toolhead.move - self.position_with_transform = toolhead.get_position - def _handle_shutdown(self): - if not self.is_printer_ready: - return - self.is_printer_ready = False - logging.info("gcode state: absolute_coord=%s absolute_extrude=%s" - " base_position=%s last_position=%s homing_position=%s" - " speed_factor=%s extrude_factor=%s speed=%s", - self.absolute_coord, self.absolute_extrude, - self.base_position, self.last_position, - self.homing_position, self.speed_factor, - self.extrude_factor, self.speed) - def _handle_activate_extruder(self): - self.reset_last_position() - self.extrude_factor = 1. - self.base_position[3] = self.last_position[3] - def set_move_transform(self, transform, force=False): - if self.move_transform is not None and not force: - raise self.printer.config_error( - "G-Code move transform already specified") - old_transform = self.move_transform - if old_transform is None: - old_transform = self.printer.lookup_object('toolhead', None) - self.move_transform = transform - self.move_with_transform = transform.move - self.position_with_transform = transform.get_position - return old_transform - def _get_gcode_position(self): - p = [lp - bp for lp, bp in zip(self.last_position, self.base_position)] - p[3] /= self.extrude_factor - return p - def _get_gcode_speed(self): - return self.speed / self.speed_factor - def _get_gcode_speed_override(self): - return self.speed_factor * 60. - def get_status(self, eventtime=None): - move_position = self._get_gcode_position() - return { - 'speed_factor': self._get_gcode_speed_override(), - 'speed': self._get_gcode_speed(), - 'extrude_factor': self.extrude_factor, - 'absolute_coordinates': self.absolute_coord, - 'absolute_extrude': self.absolute_extrude, - 'homing_origin': homing.Coord(*self.homing_position), - 'position': homing.Coord(*self.last_position), - 'gcode_position': homing.Coord(*move_position), - } - def reset_last_position(self): - if self.is_printer_ready: - self.last_position = self.position_with_transform() - # G-Code movement commands - def cmd_G1(self, gcmd): - # Move - params = gcmd._params - try: - for pos, axis in enumerate('XYZ'): - if axis in params: - v = float(params[axis]) - if not self.absolute_coord: - # value relative to position of last move - self.last_position[pos] += v - else: - # value relative to base coordinate position - self.last_position[pos] = v + self.base_position[pos] - if 'E' in params: - v = float(params['E']) * self.extrude_factor - if not self.absolute_coord or not self.absolute_extrude: - # value relative to position of last move - self.last_position[3] += v - else: - # value relative to base coordinate position - self.last_position[3] = v + self.base_position[3] - if 'F' in params: - gcode_speed = float(params['F']) - if gcode_speed <= 0.: - raise gcmd.error("Invalid speed in '%s'" - % (gcmd.get_commandline(),)) - self.speed = gcode_speed * self.speed_factor - except ValueError as e: - raise gcmd.error("Unable to parse move '%s'" - % (gcmd.get_commandline(),)) - self.move_with_transform(self.last_position, self.speed) - def cmd_G28(self, gcmd): - # Move to origin - axes = [] - for pos, axis in enumerate('XYZ'): - if gcmd.get(axis, None) is not None: - axes.append(pos) - if not axes: - axes = [0, 1, 2] - homing_state = homing.Homing(self.printer) - homing_state.home_axes(axes) - for axis in homing_state.get_axes(): - self.base_position[axis] = self.homing_position[axis] - # G-Code coordinate manipulation - def cmd_G20(self, gcmd): - # Set units to inches - raise gcmd.error('Machine does not support G20 (inches) command') - def cmd_G21(self, gcmd): - # Set units to millimeters - pass - def cmd_M82(self, gcmd): - # Use absolute distances for extrusion - self.absolute_extrude = True - def cmd_M83(self, gcmd): - # Use relative distances for extrusion - self.absolute_extrude = False - def cmd_G90(self, gcmd): - # Use absolute coordinates - self.absolute_coord = True - def cmd_G91(self, gcmd): - # Use relative coordinates - self.absolute_coord = False - def cmd_G92(self, gcmd): - # Set position - offsets = [ gcmd.get_float(a, None) for a in 'XYZE' ] - for i, offset in enumerate(offsets): - if offset is not None: - if i == 3: - offset *= self.extrude_factor - self.base_position[i] = self.last_position[i] - offset - if offsets == [None, None, None, None]: - self.base_position = list(self.last_position) - def cmd_M114(self, gcmd): - # Get Current Position - p = self._get_gcode_position() - gcmd.respond_raw("X:%.3f Y:%.3f Z:%.3f E:%.3f" % tuple(p)) - def cmd_M220(self, gcmd): - # Set speed factor override percentage - value = gcmd.get_float('S', 100., above=0.) / (60. * 100.) - self.speed = self._get_gcode_speed() * value - self.speed_factor = value - def cmd_M221(self, gcmd): - # Set extrude factor override percentage - new_extrude_factor = gcmd.get_float('S', 100., above=0.) / 100. - last_e_pos = self.last_position[3] - e_value = (last_e_pos - self.base_position[3]) / self.extrude_factor - self.base_position[3] = last_e_pos - e_value * new_extrude_factor - self.extrude_factor = new_extrude_factor - cmd_SET_GCODE_OFFSET_help = "Set a virtual offset to g-code positions" - def cmd_SET_GCODE_OFFSET(self, gcmd): - move_delta = [0., 0., 0., 0.] - for pos, axis in enumerate('XYZE'): - offset = gcmd.get_float(axis, None) - if offset is None: - offset = gcmd.get_float(axis + '_ADJUST', None) - if offset is None: - continue - offset += self.homing_position[pos] - delta = offset - self.homing_position[pos] - move_delta[pos] = delta - self.base_position[pos] += delta - self.homing_position[pos] = offset - # Move the toolhead the given offset if requested - if gcmd.get_int('MOVE', 0): - speed = gcmd.get_float('MOVE_SPEED', self.speed, above=0.) - for pos, delta in enumerate(move_delta): - self.last_position[pos] += delta - self.move_with_transform(self.last_position, speed) - cmd_SAVE_GCODE_STATE_help = "Save G-Code coordinate state" - def cmd_SAVE_GCODE_STATE(self, gcmd): - state_name = gcmd.get('NAME', 'default') - self.saved_states[state_name] = { - 'absolute_coord': self.absolute_coord, - 'absolute_extrude': self.absolute_extrude, - 'base_position': list(self.base_position), - 'last_position': list(self.last_position), - 'homing_position': list(self.homing_position), - 'speed': self.speed, 'speed_factor': self.speed_factor, - 'extrude_factor': self.extrude_factor, - } - cmd_RESTORE_GCODE_STATE_help = "Restore a previously saved G-Code state" - def cmd_RESTORE_GCODE_STATE(self, gcmd): - state_name = gcmd.get('NAME', 'default') - state = self.saved_states.get(state_name) - if state is None: - raise gcmd.error("Unknown g-code state: %s" % (state_name,)) - # Restore state - self.absolute_coord = state['absolute_coord'] - self.absolute_extrude = state['absolute_extrude'] - self.base_position = list(state['base_position']) - self.homing_position = list(state['homing_position']) - self.speed = state['speed'] - self.speed_factor = state['speed_factor'] - self.extrude_factor = state['extrude_factor'] - # Restore the relative E position - e_diff = self.last_position[3] - state['last_position'][3] - self.base_position[3] += e_diff - # Move the toolhead back if requested - if gcmd.get_int('MOVE', 0): - speed = gcmd.get_float('MOVE_SPEED', self.speed, above=0.) - self.last_position[:3] = state['last_position'][:3] - self.move_with_transform(self.last_position, speed) - def cmd_GET_POSITION(self, gcmd): - toolhead = self.printer.lookup_object('toolhead', None) - if toolhead is None: - raise gcmd.error("Printer not ready") - kin = toolhead.get_kinematics() - steppers = kin.get_steppers() - mcu_pos = " ".join(["%s:%d" % (s.get_name(), s.get_mcu_position()) - for s in steppers]) - for s in steppers: - s.set_tag_position(s.get_commanded_position()) - stepper_pos = " ".join(["%s:%.6f" % (s.get_name(), s.get_tag_position()) - for s in steppers]) - kin_pos = " ".join(["%s:%.6f" % (a, v) - for a, v in zip("XYZ", kin.calc_tag_position())]) - toolhead_pos = " ".join(["%s:%.6f" % (a, v) for a, v in zip( - "XYZE", toolhead.get_position())]) - gcode_pos = " ".join(["%s:%.6f" % (a, v) - for a, v in zip("XYZE", self.last_position)]) - base_pos = " ".join(["%s:%.6f" % (a, v) - for a, v in zip("XYZE", self.base_position)]) - homing_pos = " ".join(["%s:%.6f" % (a, v) - for a, v in zip("XYZ", self.homing_position)]) - gcmd.respond_info("mcu: %s\n" - "stepper: %s\n" - "kinematic: %s\n" - "toolhead: %s\n" - "gcode: %s\n" - "gcode base: %s\n" - "gcode homing: %s" - % (mcu_pos, stepper_pos, kin_pos, toolhead_pos, - gcode_pos, base_pos, homing_pos)) - # Support reading gcode from a pseudo-tty interface class GCodeIO: def __init__(self, printer): @@ -696,5 +425,4 @@ class GCodeIO: def add_early_printer_objects(printer): printer.add_object('gcode', GCodeDispatch(printer)) - printer.add_object('gcode_move', GCodeMove(printer)) printer.add_object('gcode_io', GCodeIO(printer)) diff --git a/klippy/toolhead.py b/klippy/toolhead.py index c0b72d84..ae668429 100644 --- a/klippy/toolhead.py +++ b/klippy/toolhead.py @@ -268,7 +268,8 @@ class ToolHead: desc=self.cmd_SET_VELOCITY_LIMIT_help) gcode.register_command('M204', self.cmd_M204) # Load some default modules - modules = ["idle_timeout", "statistics", "manual_probe", "tuning_tower"] + modules = ["gcode_move", "idle_timeout", "statistics", "manual_probe", + "tuning_tower"] for module_name in modules: self.printer.load_object(config, module_name) # Print time tracking