input shaper for idex printers

Author: rogerlz

docs/Config_Reference.md

@@ -2096,13 +2096,19 @@ the [command reference](G-Codes.md#input_shaper).
 #   input shapers, this parameter can be set from different
 #   considerations. The default value is 0, which disables input
 #   shaping for X axis.
+#   For printers with dual toolheads (dual_carriage), this parameter can
+#   be specified as a comma-separated list to provide different values for
+#   each toolhead/mode: "freq_toolhead0, freq_toolhead1" or
+#   "freq_toolhead0_primary, freq_toolhead1_primary, freq_copy, freq_mirror".
 #shaper_freq_y: 0
 #   A frequency (in Hz) of the input shaper for Y axis. This is
 #   usually a resonance frequency of Y axis that the input shaper
 #   should suppress. For more complex shapers, like 2- and 3-hump EI
 #   input shapers, this parameter can be set from different
 #   considerations. The default value is 0, which disables input
 #   shaping for Y axis.
+#   For printers with dual toolheads, this parameter supports comma-separated
+#   lists as described in shaper_freq_x.
 #shaper_type: mzv
 #   A type of the input shaper to use for both X and Y axes. Supported
 #   shapers are zv, mzv, zvd, ei, 2hump_ei, and 3hump_ei. The default
@@ -2112,12 +2118,18 @@ the [command reference](G-Codes.md#input_shaper).
 #   If shaper_type is not set, these two parameters can be used to
 #   configure different input shapers for X and Y axes. The same
 #   values are supported as for shaper_type parameter.
+#   For printers with dual toolheads (dual_carriage), these parameters can
+#   be specified as comma-separated lists to provide different values for
+#   each toolhead/mode, following the same format as described in shaper_freq_x.
 #damping_ratio_x: 0.1
 #damping_ratio_y: 0.1
 #   Damping ratios of vibrations of X and Y axes used by input shapers
 #   to improve vibration suppression. Default value is 0.1 which is a
 #   good all-round value for most printers. In most circumstances this
 #   parameter requires no tuning and should not be changed.
+#   For printers with dual toolheads (dual_carriage), these parameters can
+#   be specified as comma-separated lists to provide different values for
+#   each toolhead/mode, following the same format as described in shaper_freq_x.
 ```
 
 ### [adxl345]

docs/G-Codes.md

@@ -941,14 +941,27 @@ been enabled (also see the
 `SET_INPUT_SHAPER [SHAPER_FREQ_X=<shaper_freq_x>]
 [SHAPER_FREQ_Y=<shaper_freq_y>] [DAMPING_RATIO_X=<damping_ratio_x>]
 [DAMPING_RATIO_Y=<damping_ratio_y>] [SHAPER_TYPE=<shaper>]
-[SHAPER_TYPE_X=<shaper_type_x>] [SHAPER_TYPE_Y=<shaper_type_y>]`:
+[SHAPER_TYPE_X=<shaper_type_x>] [SHAPER_TYPE_Y=<shaper_type_y>]
+[TOOLHEAD=<toolhead_index>]`:
 Modify input shaper parameters. Note that SHAPER_TYPE parameter resets
 input shaper for both X and Y axes even if different shaper types have
 been configured in [input_shaper] section. SHAPER_TYPE cannot be used
 together with either of SHAPER_TYPE_X and SHAPER_TYPE_Y parameters.
+
+For printers with dual toolheads (dual_carriage), the TOOLHEAD parameter
+can be used to specify which toolhead's input shaper parameters should be
+modified (0 or 1). If not specified, the parameters for all toolheads will
+be updated.
+
 See [config reference](Config_Reference.md#input_shaper) for more
 details on each of these parameters.
 
+#### GET_INPUT_SHAPER
+`GET_INPUT_SHAPER`:
+Reports the current input shaper settings. For printers with dual toolheads,
+it displays the active toolhead and mode along with the current input shaper
+parameters for each axis.
+
 ### [manual_probe]
 
 The manual_probe module is automatically loaded.

docs/Kalico_Additions.md

@@ -20,6 +20,7 @@
 
 - [`canbus_query.py`](./CANBUS.md#finding-the-canbus_uuid-for-new-micro-controllers) now responds with all Kalico devices, even after they've been assigned a node_id.
 - Input shaper calibration now warns about active fans that may affect measurement accuracy.
+- Input shaper now supports multiple toolheads for dual carriage configurations, allowing different input shaper parameters for each toolhead and mode (PRIMARY/COPY/MIRROR).
 - [`BED_MESH_CHECK`](./G-Codes.md#bed_mesh_check) validates the current bed mesh against specified criteria, allowing you to check maximum deviation and slope between adjacent points before printing.
 
 ## New Kalico Modules

klippy/extras/input_shaper.py

@@ -13,21 +13,52 @@ class InputShaperParams:
     def __init__(self, axis, config):
         self.axis = axis
         self.shapers = {s.name: s.init_func for s in shaper_defs.INPUT_SHAPERS}
+
+        # parse shaper types
         shaper_type = config.get("shaper_type", "mzv")
-        self.shaper_type = config.get("shaper_type_" + axis, shaper_type)
-        if self.shaper_type not in self.shapers:
-            raise config.error(
-                "Unsupported shaper type: %s" % (self.shaper_type,)
-            )
-        self.damping_ratio = config.getfloat(
-            "damping_ratio_" + axis,
-            shaper_defs.DEFAULT_DAMPING_RATIO,
-            minval=0.0,
-            maxval=1.0,
-        )
-        self.shaper_freq = config.getfloat(
-            "shaper_freq_" + axis, 0.0, minval=0.0
+        shaper_type_axis = config.get("shaper_type_" + axis, shaper_type)
+        self.shaper_types = [
+            s.strip() for s in shaper_type_axis.split(",") if s.strip()
+        ]
+        if not self.shaper_types:
+            self.shaper_types = [shaper_type]
+
+        for st in self.shaper_types:
+            if st not in self.shapers:
+                raise config.error("Unsupported shaper type: %s" % (st,))
+
+        # parse damping ratios
+        damping_ratio = config.get(
+            "damping_ratio_" + axis, str(shaper_defs.DEFAULT_DAMPING_RATIO)
         )
+        self.damping_ratios = [
+            float(dr.strip()) for dr in damping_ratio.split(",") if dr.strip()
+        ]
+        if not self.damping_ratios:
+            self.damping_ratios = [shaper_defs.DEFAULT_DAMPING_RATIO]
+
+        for dr in self.damping_ratios:
+            if dr < 0.0 or dr > 1.0:
+                raise config.error(
+                    "Damping ratio must be between 0.0 and 1.0: %s" % (dr,)
+                )
+
+        # parse frequencies
+        freq = config.get("shaper_freq_" + axis, "0.0")
+        self.shaper_freqs = [
+            float(f.strip()) for f in freq.split(",") if f.strip()
+        ]
+        if not self.shaper_freqs:
+            self.shaper_freqs = [0.0]
+
+        for f in self.shaper_freqs:
+            if f < 0.0:
+                raise config.error("Frequency must be non-negative: %s" % (f,))
+
+        # use first value as default
+        self.damping_ratio = self.damping_ratios[0]
+        self.shaper_type = self.shaper_types[0]
+        self.shaper_freq = self.shaper_freqs[0]
 
     def update(self, gcmd):
         axis = self.axis.upper()
@@ -69,6 +100,8 @@ def __init__(self, axis, config):
         self.params = InputShaperParams(axis, config)
         self.n, self.A, self.T = self.params.get_shaper()
         self.saved = None
+        self.toolhead_idx = 0
+        self.mode_idx = 0  # 0 = PRIMARY, 1 = COPY/MIRROR
 
     def get_name(self):
         return "shaper_" + self.axis
@@ -80,6 +113,45 @@ def update(self, gcmd):
         self.params.update(gcmd)
         self.n, self.A, self.T = self.params.get_shaper()
 
+    def set_toolhead_mode(self, toolhead_idx, mode_idx):
+        self.toolhead_idx = toolhead_idx
+        self.mode_idx = mode_idx
+        param_idx = self._get_param_index()
+        self._update_params_for_index(param_idx)
+
+    def _get_param_index(self):
+        # for single toolhead or single parameter, always use index 0
+        if len(self.params.shaper_types) == 1:
+            return 0
+
+        # for dual toolhead with 2 parameters, use toolhead index
+        elif len(self.params.shaper_types) == 2:
+            return self.toolhead_idx
+
+        # for dual toolhead with 4 parameters, calculate based on toolhead and mode
+        elif len(self.params.shaper_types) == 4:
+            if self.mode_idx == 0:  # PRIMARY mode
+                return self.toolhead_idx  # 0 for toolhead 0, 1 for toolhead 1
+            else:  # COPY/MIRROR mode
+                return (
+                    self.mode_idx + 1
+                )  # 2 for COPY (mode_idx=1), 3 for MIRROR (mode_idx=2)
+
+        # Default to first parameter
+        return 0
+
+    def _update_params_for_index(self, idx):
+        idx = min(idx, len(self.params.shaper_types) - 1)
+
+        self.params.shaper_type = self.params.shaper_types[idx]
+        self.params.damping_ratio = self.params.damping_ratios[
+            min(idx, len(self.params.damping_ratios) - 1)
+        ]
+        self.params.shaper_freq = self.params.shaper_freqs[
+            min(idx, len(self.params.shaper_freqs) - 1)
+        ]
+        self.n, self.A, self.T = self.params.get_shaper()
+
     def set_shaper_kinematics(self, sk):
         ffi_main, ffi_lib = chelper.get_ffi()
         success = (
@@ -129,19 +201,38 @@ def __init__(self, config):
         ]
         self.input_shaper_stepper_kinematics = []
         self.orig_stepper_kinematics = []
+        self.dual_carriage = None
+        self.active_toolhead = 0
+        self.active_mode = 0  # 0 = PRIMARY, 1 = COPY/MIRROR
+
         # Register gcode commands
         gcode = self.printer.lookup_object("gcode")
         gcode.register_command(
             "SET_INPUT_SHAPER",
             self.cmd_SET_INPUT_SHAPER,
             desc=self.cmd_SET_INPUT_SHAPER_help,
         )
+        gcode.register_command(
+            "GET_INPUT_SHAPER",
+            self.cmd_GET_INPUT_SHAPER,
+            desc=self.cmd_GET_INPUT_SHAPER_help,
+        )
+
+        self.printer.register_event_handler(
+            "dual_carriage:mode_change", self.handle_dual_carriage_mode_change
+        )
 
     def get_shapers(self):
         return self.shapers
 
     def connect(self):
         self.toolhead = self.printer.lookup_object("toolhead")
+
+        try:
+            self.dual_carriage = self.printer.lookup_object("dual_carriage")
+        except self.printer.config_error:
+            self.dual_carriage = None
+
         # Configure initial values
         self._update_input_shaping(error=self.printer.config_error)
 
@@ -204,15 +295,55 @@ def enable_shaping(self):
         self._update_input_shaping()
 
     cmd_SET_INPUT_SHAPER_help = "Set cartesian parameters for input shaper"
+    cmd_GET_INPUT_SHAPER_help = "Get current input shaper parameters"
+
+    def handle_dual_carriage_mode_change(self, carriage_idx, mode):
+        self.active_toolhead = carriage_idx
+        self.active_mode = 0 if mode == "PRIMARY" else 1
+
+        for shaper in self.shapers:
+            shaper.set_toolhead_mode(self.active_toolhead, self.active_mode)
+
+        self._update_input_shaping()
 
     def cmd_SET_INPUT_SHAPER(self, gcmd):
         if gcmd.get_command_parameters():
+            toolhead_idx = gcmd.get_int("TOOLHEAD", None)
+            mode_idx = gcmd.get_int("MODE", None)
+
+            if toolhead_idx is not None or mode_idx is not None:
+                th_idx = (
+                    self.active_toolhead
+                    if toolhead_idx is None
+                    else toolhead_idx
+                )
+                m_idx = self.active_mode if mode_idx is None else mode_idx
+
+                if th_idx not in [0, 1]:
+                    raise gcmd.error("Invalid TOOLHEAD index: %d" % th_idx)
+                if m_idx not in [0, 1]:
+                    raise gcmd.error("Invalid MODE index: %d" % m_idx)
+
+                for shaper in self.shapers:
+                    shaper.set_toolhead_mode(th_idx, m_idx)
+
             for shaper in self.shapers:
                 shaper.update(gcmd)
             self._update_input_shaping()
         for shaper in self.shapers:
             shaper.report(gcmd)
 
+    def cmd_GET_INPUT_SHAPER(self, gcmd):
+        gcmd.respond_info(
+            "Active toolhead: %d, Mode: %s"
+            % (
+                self.active_toolhead,
+                "PRIMARY" if self.active_mode == 0 else "COPY/MIRROR",
+            )
+        )
+        for shaper in self.shapers:
+            shaper.report(gcmd)
+
 
 def load_config(config):
     return InputShaper(config)

klippy/kinematics/idex_modes.py

@@ -184,6 +184,8 @@ def activate_dc_mode(self, index, mode):
             self.dc[index].activate(mode, toolhead.get_position())
         kin.update_limits(self.axis, self.get_kin_range(toolhead, mode))
 
+        self.printer.send_event("dual_carriage:mode_change", index, mode)
+
     def _handle_ready(self):
         # Apply the transform later during Klipper initialization to make sure
         # that input shaping can pick up the correct stepper kinematic flags.

test/conftest.py

@@ -34,7 +34,10 @@ def pytest_sessionstart(session):
 
     @session.config.add_cleanup
     def clean_symlink():
-        os.unlink(link_path)
+        try:
+            os.unlink(link_path)
+        except FileNotFoundError:
+            pass
 
 
 @pytest.fixture