Merge branch 'develop' into cross-belts

shaketune/measurement/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+from .axes_input_shaper import axes_shaper_calibration as axes_shaper_calibration
+from .axes_map import axes_map_calibration as axes_map_calibration
+from .belts_comparison import compare_belts_responses as compare_belts_responses
+from .static_freq import excitate_axis_at_freq as excitate_axis_at_freq
+from .vibrations_profile import create_vibrations_profile as create_vibrations_profile

shaketune/measurement/accelerometer.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+
+# This file provides a custom and internal Shake&Tune Accelerometer helper that is
+# an interface to Klipper's own accelerometer classes. It is used to start and
+# stop accelerometer measurements and write the data to a file in a blocking manner.
+
+import time
+
+# from ..helpers.console_output import ConsoleOutput
+
+
+class Accelerometer:
+    def __init__(self, klipper_accelerometer):
+        self._k_accelerometer = klipper_accelerometer
+        self._bg_client = None
+
+    @staticmethod
+    def find_axis_accelerometer(printer, axis: str = 'xy'):
+        accel_chip_names = printer.lookup_object('resonance_tester').accel_chip_names
+        for chip_axis, chip_name in accel_chip_names:
+            if axis in ['x', 'y'] and chip_axis == 'xy':
+                return chip_name
+            elif chip_axis == axis:
+                return chip_name
+        return None
+
+    def start_measurement(self):
+        if self._bg_client is None:
+            self._bg_client = self._k_accelerometer.start_internal_client()
+            # ConsoleOutput.print('Accelerometer measurements started')
+        else:
+            raise ValueError('measurements already started!')
+
+    def stop_measurement(self, name: str = None, append_time: bool = True):
+        if self._bg_client is None:
+            raise ValueError('measurements need to be started first!')
+
+        timestamp = time.strftime('%Y%m%d_%H%M%S')
+        if name is None:
+            name = timestamp
+        elif append_time:
+            name += f'_{timestamp}'
+
+        if not name.replace('-', '').replace('_', '').isalnum():
+            raise ValueError('invalid file name!')
+
+        bg_client = self._bg_client
+        self._bg_client = None
+        bg_client.finish_measurements()
+
+        filename = f'/tmp/shaketune-{name}.csv'
+        self._write_to_file(bg_client, filename)
+        # ConsoleOutput.print(f'Accelerometer measurements stopped. Data written to {filename}')
+
+    def _write_to_file(self, bg_client, filename):
+        with open(filename, 'w') as f:
+            f.write('#time,accel_x,accel_y,accel_z\n')
+            samples = bg_client.samples or bg_client.get_samples()
+            for t, accel_x, accel_y, accel_z in samples:
+                f.write('%.6f,%.6f,%.6f,%.6f\n' % (t, accel_x, accel_y, accel_z))

shaketune/measurement/axes_input_shaper.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+
+
+from ..helpers.common_func import AXIS_CONFIG
+from ..helpers.console_output import ConsoleOutput
+from ..shaketune_thread import ShakeTuneThread
+from .accelerometer import Accelerometer
+from .resonance_test import vibrate_axis
+
+
+def axes_shaper_calibration(gcmd, config, st_thread: ShakeTuneThread) -> None:
+    min_freq = gcmd.get_float('FREQ_START', default=5, minval=1)
+    max_freq = gcmd.get_float('FREQ_END', default=133.33, minval=1)
+    hz_per_sec = gcmd.get_float('HZ_PER_SEC', default=1, minval=1)
+    accel_per_hz = gcmd.get_float('ACCEL_PER_HZ', default=None)
+    axis_input = gcmd.get('AXIS', default='all').lower()
+    if axis_input not in ['x', 'y', 'all']:
+        gcmd.error('AXIS selection invalid. Should be either x, y, or all!')
+    scv = gcmd.get_float('SCV', default=None, minval=0)
+    max_sm = gcmd.get_float('MAX_SMOOTHING', default=None, minval=0)
+    feedrate_travel = gcmd.get_float('TRAVEL_SPEED', default=120.0, minval=20.0)
+    z_height = gcmd.get_float('Z_HEIGHT', default=None, minval=1)
+
+    printer = config.get_printer()
+    gcode = printer.lookup_object('gcode')
+    toolhead = printer.lookup_object('toolhead')
+    res_tester = printer.lookup_object('resonance_tester')
+    systime = printer.get_reactor().monotonic()
+
+    if scv is None:
+        toolhead_info = toolhead.get_status(systime)
+        scv = toolhead_info['square_corner_velocity']
+
+    if accel_per_hz is None:
+        accel_per_hz = res_tester.test.accel_per_hz
+    max_accel = max_freq * accel_per_hz
+
+    # Move to the starting point
+    test_points = res_tester.test.get_start_test_points()
+    if len(test_points) > 1:
+        gcmd.error('Only one test point in the [resonance_tester] section is supported by Shake&Tune.')
+    if test_points[0] == (-1, -1, -1):
+        if z_height is None:
+            gcmd.error(
+                'Z_HEIGHT parameter is required if the test_point in [resonance_tester] section is set to -1,-1,-1'
+            )
+        # Use center of bed in case the test point in [resonance_tester] is set to -1,-1,-1
+        # This is usefull to get something automatic and is also used in the Klippain modular config
+        kin_info = toolhead.kin.get_status(systime)
+        mid_x = (kin_info['axis_minimum'].x + kin_info['axis_maximum'].x) / 2
+        mid_y = (kin_info['axis_minimum'].y + kin_info['axis_maximum'].y) / 2
+        point = (mid_x, mid_y, z_height)
+    else:
+        x, y, z = test_points[0]
+        if z_height is not None:
+            z = z_height
+        point = (x, y, z)
+
+    toolhead.manual_move(point, feedrate_travel)
+
+    # Configure the graph creator
+    creator = st_thread.get_graph_creator()
+    creator.configure(scv, max_sm, accel_per_hz)
+
+    # set the needed acceleration values for the test
+    toolhead_info = toolhead.get_status(systime)
+    old_accel = toolhead_info['max_accel']
+    old_mcr = toolhead_info['minimum_cruise_ratio']
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={max_accel} MINIMUM_CRUISE_RATIO=0')
+
+    # Deactivate input shaper if it is active to get raw movements
+    input_shaper = printer.lookup_object('input_shaper', None)
+    if input_shaper is not None:
+        input_shaper.disable_shaping()
+    else:
+        input_shaper = None
+
+    # Filter axis configurations based on user input, assuming 'axis_input' can be 'x', 'y', 'all' (that means 'x' and 'y')
+    filtered_config = [
+        a for a in AXIS_CONFIG if a['axis'] == axis_input or (axis_input == 'all' and a['axis'] in ('x', 'y'))
+    ]
+    for config in filtered_config:
+        # First we need to find the accelerometer chip suited for the axis
+        accel_chip = Accelerometer.find_axis_accelerometer(printer, config['axis'])
+        if accel_chip is None:
+            gcmd.error(
+                'No suitable accelerometer found for measurement! Multi-accelerometer configurations are not supported for this macro.'
+            )
+        accelerometer = Accelerometer(printer.lookup_object(accel_chip))
+
+        # Then do the actual measurements
+        accelerometer.start_measurement()
+        vibrate_axis(toolhead, gcode, config['direction'], min_freq, max_freq, hz_per_sec, accel_per_hz)
+        accelerometer.stop_measurement(config['label'], append_time=True)
+
+        # And finally generate the graph for each measured axis
+        ConsoleOutput.print(f'{config["axis"].upper()} axis frequency profile generation...')
+        ConsoleOutput.print('This may take some time (1-3min)')
+        st_thread.run()
+
+    # Re-enable the input shaper if it was active
+    if input_shaper is not None:
+        input_shaper.enable_shaping()
+
+    # Restore the previous acceleration values
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={old_accel} MINIMUM_CRUISE_RATIO={old_mcr}')

shaketune/measurement/axes_map.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+
+from ..helpers.console_output import ConsoleOutput
+from ..shaketune_thread import ShakeTuneThread
+from .accelerometer import Accelerometer
+
+
+def axes_map_calibration(gcmd, config, st_thread: ShakeTuneThread) -> None:
+    z_height = gcmd.get_float('Z_HEIGHT', default=20.0)
+    speed = gcmd.get_float('SPEED', default=80.0, minval=20.0)
+    accel = gcmd.get_int('ACCEL', default=1500, minval=100)
+    feedrate_travel = gcmd.get_float('TRAVEL_SPEED', default=120.0, minval=20.0)
+    accel_chip = gcmd.get('ACCEL_CHIP', default=None)
+
+    printer = config.get_printer()
+    gcode = printer.lookup_object('gcode')
+    toolhead = printer.lookup_object('toolhead')
+    systime = printer.get_reactor().monotonic()
+
+    if accel_chip is None:
+        accel_chip = Accelerometer.find_axis_accelerometer(printer, 'xy')
+        if accel_chip is None:
+            gcmd.error(
+                'No accelerometer specified for measurement! Multi-accelerometer configurations are not supported for this macro.'
+            )
+    accelerometer = Accelerometer(printer.lookup_object(accel_chip))
+
+    toolhead_info = toolhead.get_status(systime)
+    old_accel = toolhead_info['max_accel']
+    old_mcr = toolhead_info['minimum_cruise_ratio']
+    old_sqv = toolhead_info['square_corner_velocity']
+
+    # set the wanted acceleration values
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={accel} MINIMUM_CRUISE_RATIO=0 SQUARE_CORNER_VELOCITY=5.0')
+
+    # Deactivate input shaper if it is active to get raw movements
+    input_shaper = printer.lookup_object('input_shaper', None)
+    if input_shaper is not None:
+        input_shaper.disable_shaping()
+    else:
+        input_shaper = None
+
+    kin_info = toolhead.kin.get_status(systime)
+    mid_x = (kin_info['axis_minimum'].x + kin_info['axis_maximum'].x) / 2
+    mid_y = (kin_info['axis_minimum'].y + kin_info['axis_maximum'].y) / 2
+    _, _, _, E = toolhead.get_position()
+
+    # Going to the start position
+    toolhead.move([mid_x - 15, mid_y - 15, z_height, E], feedrate_travel)
+    toolhead.dwell(0.5)
+
+    # Start the measurements and do the movements (+X, +Y and then +Z)
+    accelerometer.start_measurement()
+    toolhead.dwell(1)
+    toolhead.move([mid_x + 15, mid_y - 15, z_height, E], speed)
+    toolhead.dwell(1)
+    toolhead.move([mid_x + 15, mid_y + 15, z_height, E], speed)
+    toolhead.dwell(1)
+    toolhead.move([mid_x + 15, mid_y + 15, z_height + 15, E], speed)
+    toolhead.dwell(1)
+    accelerometer.stop_measurement('axemap')
+
+    # Re-enable the input shaper if it was active
+    if input_shaper is not None:
+        input_shaper.enable_shaping()
+
+    # Restore the previous acceleration values
+    gcode.run_script_from_command(
+        f'SET_VELOCITY_LIMIT ACCEL={old_accel} MINIMUM_CRUISE_RATIO={old_mcr} SQUARE_CORNER_VELOCITY={old_sqv}'
+    )
+    toolhead.wait_moves()
+
+    # Run post-processing
+    ConsoleOutput.print('Analysis of the movements...')
+    creator = st_thread.get_graph_creator()
+    creator.configure(accel)
+    st_thread.run()

shaketune/measurement/belts_comparison.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+
+
+from ..helpers.common_func import AXIS_CONFIG
+from ..helpers.console_output import ConsoleOutput
+from ..shaketune_thread import ShakeTuneThread
+from .accelerometer import Accelerometer
+from .motorsconfigparser import MotorsConfigParser
+from .resonance_test import vibrate_axis
+
+
+def compare_belts_responses(gcmd, config, st_thread: ShakeTuneThread) -> None:
+    min_freq = gcmd.get_float('FREQ_START', default=5.0, minval=1)
+    max_freq = gcmd.get_float('FREQ_END', default=133.33, minval=1)
+    hz_per_sec = gcmd.get_float('HZ_PER_SEC', default=1.0, minval=1)
+    accel_per_hz = gcmd.get_float('ACCEL_PER_HZ', default=None)
+    feedrate_travel = gcmd.get_float('TRAVEL_SPEED', default=120.0, minval=20.0)
+    z_height = gcmd.get_float('Z_HEIGHT', default=None, minval=1)
+
+    printer = config.get_printer()
+    gcode = printer.lookup_object('gcode')
+    toolhead = printer.lookup_object('toolhead')
+    res_tester = printer.lookup_object('resonance_tester')
+    systime = printer.get_reactor().monotonic()
+
+    accel_chip = Accelerometer.find_axis_accelerometer(printer, 'xy')
+    if accel_chip is None:
+        gcmd.error(
+            'No suitable accelerometer found for measurement! Multi-accelerometer configurations are not supported for this macro.'
+        )
+    accelerometer = Accelerometer(printer.lookup_object(accel_chip))
+
+    if accel_per_hz is None:
+        accel_per_hz = res_tester.test.accel_per_hz
+    max_accel = max_freq * accel_per_hz
+
+    # Move to the starting point
+    test_points = res_tester.test.get_start_test_points()
+    if len(test_points) > 1:
+        gcmd.error('Only one test point in the [resonance_tester] section is supported by Shake&Tune.')
+    if test_points[0] == (-1, -1, -1):
+        if z_height is None:
+            gcmd.error(
+                'Z_HEIGHT parameter is required if the test_point in [resonance_tester] section is set to -1,-1,-1'
+            )
+        # Use center of bed in case the test point in [resonance_tester] is set to -1,-1,-1
+        # This is usefull to get something automatic and is also used in the Klippain modular config
+        kin_info = toolhead.kin.get_status(systime)
+        mid_x = (kin_info['axis_minimum'].x + kin_info['axis_maximum'].x) / 2
+        mid_y = (kin_info['axis_minimum'].y + kin_info['axis_maximum'].y) / 2
+        point = (mid_x, mid_y, z_height)
+    else:
+        x, y, z = test_points[0]
+        if z_height is not None:
+            z = z_height
+        point = (x, y, z)
+
+    toolhead.manual_move(point, feedrate_travel)
+
+    # Configure the graph creator
+    motors_config_parser = MotorsConfigParser(config, motors=None)
+    creator = st_thread.get_graph_creator()
+    creator.configure(motors_config_parser.kinematics, accel_per_hz)
+
+    # set the needed acceleration values for the test
+    toolhead_info = toolhead.get_status(systime)
+    old_accel = toolhead_info['max_accel']
+    old_mcr = toolhead_info['minimum_cruise_ratio']
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={max_accel} MINIMUM_CRUISE_RATIO=0')
+
+    # Deactivate input shaper if it is active to get raw movements
+    input_shaper = printer.lookup_object('input_shaper', None)
+    if input_shaper is not None:
+        input_shaper.disable_shaping()
+    else:
+        input_shaper = None
+
+    # Filter axis configurations to get the A and B axis only
+    filtered_config = [a for a in AXIS_CONFIG if a['axis'] in ('a', 'b')]
+    for config in filtered_config:
+        accelerometer.start_measurement()
+        vibrate_axis(toolhead, gcode, config['direction'], min_freq, max_freq, hz_per_sec, accel_per_hz)
+        accelerometer.stop_measurement(config['label'], append_time=True)
+
+    # Re-enable the input shaper if it was active
+    if input_shaper is not None:
+        input_shaper.enable_shaping()
+
+    # Restore the previous acceleration values
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={old_accel} MINIMUM_CRUISE_RATIO={old_mcr}')
+
+    # Run post-processing
+    ConsoleOutput.print('Belts comparative frequency profile generation...')
+    ConsoleOutput.print('This may take some time (3-5min)')
+    st_thread.run()

shaketune/measurement/macros.cfg

@@ -0,0 +1,8 @@
+
+# [gcode_macro AXES_MAP_CALIBRATION]
+# gcode:
+#     {% set z_height = params.Z_HEIGHT|default(20)|int %} # z height to put the toolhead before starting the movements
+#     {% set speed = params.SPEED|default(80)|float * 60 %} # feedrate for the movements
+#     {% set accel = params.ACCEL|default(1500)|int %} # accel value used to move on the pattern
+#     {% set feedrate_travel = params.TRAVEL_SPEED|default(120)|int * 60 %} # travel feedrate between moves
+#     {% set accel_chip = params.ACCEL_CHIP|default("adxl345") %} # ADXL chip name in the config

shaketune/measurement/motorsconfigparser.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+
+# Classes to retrieve a couple of motors infos and extract the relevant information
+# from the Klipper configuration and the TMC registers
+# Written by Frix_x#0161 #
+
+from typing import Any, Dict, List, Optional
+
+TRINAMIC_DRIVERS = ['tmc2130', 'tmc2208', 'tmc2209', 'tmc2240', 'tmc2660', 'tmc5160']
+MOTORS = ['stepper_x', 'stepper_y', 'stepper_x1', 'stepper_y1', 'stepper_z', 'stepper_z1', 'stepper_z2', 'stepper_z3']
+RELEVANT_TMC_REGISTERS = ['CHOPCONF', 'PWMCONF', 'COOLCONF', 'TPWMTHRS', 'TCOOLTHRS']
+
+
+class Motor:
+    def __init__(self, name: str):
+        self.name: str = name
+        self._registers: Dict[str, Dict[str, Any]] = {}
+        self._config: Dict[str, Any] = {}
+
+    def set_register(self, register: str, value_dict: dict) -> None:
+        # First we filter out entries with a value of 0 to avoid having too much uneeded data
+        value_dict = {k: v for k, v in value_dict.items() if v != 0}
+
+        # Special parsing for CHOPCONF to extract meaningful values
+        if register == 'CHOPCONF':
+            # Add intpol=0 if missing from the register dump to force printing it as it's important
+            if 'intpol' not in value_dict:
+                value_dict['intpol'] = '0'
+            # Remove the microsteps entry as the format here is not easy to read and
+            # it's already read in the correct format directly from the Klipper config
+            if 'mres' in value_dict:
+                del value_dict['mres']
+
+        # Special parsing for CHOPCONF to avoid pwm_ before each values
+        if register == 'PWMCONF':
+            new_value_dict = {}
+            for key, val in value_dict.items():
+                if key.startswith('pwm_'):
+                    key = key[4:]
+                new_value_dict[key] = val
+            value_dict = new_value_dict
+
+        # Then gets merged all the thresholds into the same THRS virtual register
+        if register in ['TPWMTHRS', 'TCOOLTHRS']:
+            existing_thrs = self._registers.get('THRS', {})
+            merged_values = {**existing_thrs, **value_dict}
+            self._registers['THRS'] = merged_values
+        else:
+            self._registers[register] = value_dict
+
+    def get_register(self, register: str) -> Optional[Dict[str, Any]]:
+        return self._registers.get(register)
+
+    def get_registers(self) -> Dict[str, Dict[str, Any]]:
+        return self._registers
+
+    def set_config(self, field: str, value: Any) -> None:
+        self._config[field] = value
+
+    def get_config(self, field: str) -> Optional[Any]:
+        return self._config.get(field)
+
+    def __str__(self):
+        return f'Stepper: {self.name}\nKlipper config: {self._config}\nTMC Registers: {self._registers}'
+
+    # Return the other motor config and registers that are different from the current motor
+    def compare_to(self, other: 'Motor') -> Optional[Dict[str, Dict[str, Any]]]:
+        differences = {'config': {}, 'registers': {}}
+
+        # Compare Klipper config
+        all_keys = self._config.keys() | other._config.keys()
+        for key in all_keys:
+            val1 = self._config.get(key)
+            val2 = other._config.get(key)
+            if val1 != val2:
+                differences['config'][key] = val2
+
+        # Compare TMC registers
+        all_keys = self._registers.keys() | other._registers.keys()
+        for key in all_keys:
+            reg1 = self._registers.get(key, {})
+            reg2 = other._registers.get(key, {})
+            if reg1 != reg2:
+                reg_diffs = {}
+                sub_keys = reg1.keys() | reg2.keys()
+                for sub_key in sub_keys:
+                    reg_val1 = reg1.get(sub_key)
+                    reg_val2 = reg2.get(sub_key)
+                    if reg_val1 != reg_val2:
+                        reg_diffs[sub_key] = reg_val2
+                if reg_diffs:
+                    differences['registers'][key] = reg_diffs
+
+        # Clean up: remove empty sections if there are no differences
+        if not differences['config']:
+            del differences['config']
+        if not differences['registers']:
+            del differences['registers']
+
+        if not differences:
+            return None
+
+        return differences
+
+
+class MotorsConfigParser:
+    def __init__(self, config, motors: List[str] = MOTORS, drivers: List[str] = TRINAMIC_DRIVERS):
+        self._printer = config.get_printer()
+
+        self._motors: List[Motor] = []
+
+        if motors is not None:
+            for motor_name in motors:
+                for driver in drivers:
+                    tmc_object = self._printer.lookup_object(f'{driver} {motor_name}', None)
+                    if tmc_object is None:
+                        continue
+                    motor = self._create_motor(motor_name, driver, tmc_object)
+                    self._motors.append(motor)
+
+        pconfig = self._printer.lookup_object('configfile')
+        self.kinematics = pconfig.status_raw_config['printer']['kinematics']
+
+    # Create a Motor object with the given name, driver and TMC object
+    # and fill it with the relevant configuration and registers
+    def _create_motor(self, motor_name: str, driver: str, tmc_object: Any) -> Motor:
+        motor = Motor(motor_name)
+        motor.set_config('tmc', driver)
+        self._parse_klipper_config(motor, tmc_object)
+        self._parse_tmc_registers(motor, tmc_object)
+        return motor
+
+    def _parse_klipper_config(self, motor: Motor, tmc_object: Any) -> None:
+        # The TMCCommandHelper isn't a direct member of the TMC object... but we can still get it this way
+        tmc_cmdhelper = tmc_object.get_status.__self__
+
+        motor_currents = tmc_cmdhelper.current_helper.get_current()
+        motor.set_config('run_current', motor_currents[0])
+        motor.set_config('hold_current', motor_currents[1])
+
+        pconfig = self._printer.lookup_object('configfile')
+        motor.set_config('microsteps', int(pconfig.status_raw_config[motor.name]['microsteps']))
+
+        autotune_object = self._printer.lookup_object(f'autotune_tmc {motor.name}', None)
+        if autotune_object is not None:
+            motor.set_config('autotune_enabled', True)
+            motor.set_config('motor', autotune_object.motor)
+            motor.set_config('voltage', autotune_object.voltage)
+        else:
+            motor.set_config('autotune_enabled', False)
+
+    def _parse_tmc_registers(self, motor: Motor, tmc_object: Any) -> None:
+        # The TMCCommandHelper isn't a direct member of the TMC object... but we can still get it this way
+        tmc_cmdhelper = tmc_object.get_status.__self__
+
+        for register in RELEVANT_TMC_REGISTERS:
+            val = tmc_cmdhelper.fields.registers.get(register)
+            if (val is not None) and (register not in tmc_cmdhelper.read_registers):
+                # write-only register
+                fields_string = self._extract_register_values(tmc_cmdhelper, register, val)
+            elif register in tmc_cmdhelper.read_registers:
+                # readable register
+                val = tmc_cmdhelper.mcu_tmc.get_register(register)
+                if tmc_cmdhelper.read_translate is not None:
+                    register, val = tmc_cmdhelper.read_translate(register, val)
+                fields_string = self._extract_register_values(tmc_cmdhelper, register, val)
+
+            motor.set_register(register, fields_string)
+
+    def _extract_register_values(self, tmc_cmdhelper, register, val):
+        # Provide a dictionary of register values
+        reg_fields = tmc_cmdhelper.fields.all_fields.get(register, {})
+        reg_fields = sorted([(mask, name) for name, mask in reg_fields.items()])
+        fields = {}
+        for _, field_name in reg_fields:
+            field_value = tmc_cmdhelper.fields.get_field(field_name, val, register)
+            fields[field_name] = field_value
+        return fields
+
+    # Find and return the motor by its name
+    def get_motor(self, motor_name: str) -> Optional[Motor]:
+        for motor in self._motors:
+            if motor.name == motor_name:
+                return motor
+        return None
+
+    # Get all the motor list at once
+    def get_motors(self) -> List[Motor]:
+        return self._motors

shaketune/measurement/resonance_test.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+
+# The logic in this file was "extracted" from Klipper's orignal resonance_tester.py file
+# Courtesy of Dmitry Butyugin <dmbutyugin@google.com> for the original implementation
+
+# This derive a bit from Klipper's implementation as there are two main changes:
+# 1. Original code doesn't use euclidean distance for the moves calculation with projection. The new approach implemented here
+#    ensures that the vector's total length remains constant (= L), regardless of the direction components. It's especially
+#    important when the direction vector involves combinations of movements along multiple axes like for the diagonal belt tests.
+# 2. Original code doesn't allow Z axis movement that was added here for later use
+
+import math
+
+from ..helpers.console_output import ConsoleOutput
+
+
+# This function is used to vibrate the toolhead in a specific axis direction
+# to test the resonance frequency of the printer and its components
+def vibrate_axis(toolhead, gcode, axis_direction, min_freq, max_freq, hz_per_sec, accel_per_hz):
+    freq = min_freq
+    X, Y, Z, E = toolhead.get_position()  # Get current position
+    sign = 1.0
+
+    while freq <= max_freq + 0.000001:
+        t_seg = 0.25 / freq  # Time segment for one vibration cycle
+        accel = accel_per_hz * freq  # Acceleration for each half-cycle
+        max_v = accel * t_seg  # Max velocity for each half-cycle
+        toolhead.cmd_M204(gcode.create_gcode_command('M204', 'M204', {'S': accel}))
+        L = 0.5 * accel * t_seg**2  # Distance for each half-cycle
+
+        # Calculate move points based on axis direction (X, Y and Z)
+        magnitude = math.sqrt(sum([component**2 for component in axis_direction]))
+        normalized_direction = tuple(component / magnitude for component in axis_direction)
+        dX, dY, dZ = normalized_direction[0] * L, normalized_direction[1] * L, normalized_direction[2] * L
+        nX = X + sign * dX
+        nY = Y + sign * dY
+        nZ = Z + sign * dZ
+
+        # Execute movement
+        toolhead.move([nX, nY, nZ, E], max_v)
+        toolhead.move([X, Y, Z, E], max_v)
+        sign *= -1
+
+        # Increase frequency for next cycle
+        old_freq = freq
+        freq += 2 * t_seg * hz_per_sec
+        if int(freq) > int(old_freq):
+            ConsoleOutput.print(f'Testing frequency: {freq:.0f} Hz')
+
+    toolhead.wait_moves()

shaketune/measurement/static_freq.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+from ..helpers.common_func import AXIS_CONFIG
+from ..helpers.console_output import ConsoleOutput
+from .resonance_test import vibrate_axis
+
+
+def excitate_axis_at_freq(gcmd, config) -> None:
+    freq = gcmd.get_int('FREQUENCY', default=25, minval=1)
+    duration = gcmd.get_int('DURATION', default=10, minval=1)
+    accel_per_hz = gcmd.get_float('ACCEL_PER_HZ', default=None)
+    axis = gcmd.get('AXIS', default='x').lower()
+    feedrate_travel = gcmd.get_float('TRAVEL_SPEED', default=120.0, minval=20.0)
+    z_height = gcmd.get_float('Z_HEIGHT', default=None, minval=1)
+
+    axis_config = next((item for item in AXIS_CONFIG if item['axis'] == axis), None)
+    if axis_config is None:
+        gcmd.error('AXIS selection invalid. Should be either x, y, a or b!')
+
+    ConsoleOutput.print(f'Excitating {axis.upper()} axis at {freq}Hz for {duration} seconds')
+
+    printer = config.get_printer()
+    gcode = printer.lookup_object('gcode')
+    toolhead = printer.lookup_object('toolhead')
+    res_tester = printer.lookup_object('resonance_tester')
+    systime = printer.get_reactor().monotonic()
+
+    if accel_per_hz is None:
+        accel_per_hz = res_tester.test.accel_per_hz
+
+    # Move to the starting point
+    test_points = res_tester.test.get_start_test_points()
+    if len(test_points) > 1:
+        gcmd.error('Only one test point in the [resonance_tester] section is supported by Shake&Tune.')
+    if test_points[0] == (-1, -1, -1):
+        if z_height is None:
+            gcmd.error(
+                'Z_HEIGHT parameter is required if the test_point in [resonance_tester] section is set to -1,-1,-1'
+            )
+        # Use center of bed in case the test point in [resonance_tester] is set to -1,-1,-1
+        # This is usefull to get something automatic and is also used in the Klippain modular config
+        kin_info = toolhead.kin.get_status(systime)
+        mid_x = (kin_info['axis_minimum'].x + kin_info['axis_maximum'].x) / 2
+        mid_y = (kin_info['axis_minimum'].y + kin_info['axis_maximum'].y) / 2
+        point = (mid_x, mid_y, z_height)
+    else:
+        x, y, z = test_points[0]
+        if z_height is not None:
+            z = z_height
+        point = (x, y, z)
+
+    toolhead.manual_move(point, feedrate_travel)
+
+    min_freq = freq - 1
+    max_freq = freq + 1
+    hz_per_sec = 1 / (duration / 3)
+    vibrate_axis(toolhead, gcode, axis_config['direction'], min_freq, max_freq, hz_per_sec, accel_per_hz)

shaketune/measurement/vibrations_profile.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+
+
+import math
+
+from ..helpers.console_output import ConsoleOutput
+from ..shaketune_thread import ShakeTuneThread
+from .accelerometer import Accelerometer
+from .motorsconfigparser import MotorsConfigParser
+
+MIN_SPEED = 2  # mm/s
+
+
+def create_vibrations_profile(gcmd, config, st_thread: ShakeTuneThread) -> None:
+    size = gcmd.get_float('SIZE', default=100.0, minval=50.0)
+    z_height = gcmd.get_float('Z_HEIGHT', default=20.0)
+    max_speed = gcmd.get_float('MAX_SPEED', default=200.0, minval=10.0)
+    speed_increment = gcmd.get_float('SPEED_INCREMENT', default=2.0, minval=1.0)
+    accel = gcmd.get_int('ACCEL', default=3000, minval=100)
+    feedrate_travel = gcmd.get_float('TRAVEL_SPEED', default=120.0, minval=20.0)
+    accel_chip = gcmd.get('ACCEL_CHIP', default=None)
+
+    if (size / (max_speed / 60)) < 0.25:
+        gcmd.error('The size of the movement is too small for the given speed! Increase SIZE or decrease MAX_SPEED!')
+
+    printer = config.get_printer()
+    gcode = printer.lookup_object('gcode')
+    toolhead = printer.lookup_object('toolhead')
+    input_shaper = printer.lookup_object('input_shaper', None)
+    systime = printer.get_reactor().monotonic()
+
+    # Check that input shaper is already configured
+    if input_shaper is None:
+        gcmd.error('Input shaper is not configured! Please run the shaper calibration macro first.')
+
+    motors_config_parser = MotorsConfigParser(config, motors=['stepper_x', 'stepper_y'])
+
+    if motors_config_parser.kinematics == 'cartesian' or motors_config_parser.kinematics == 'corexz':
+        # Cartesian motors are on X and Y axis directly, same for CoreXZ
+        main_angles = [0, 90]
+    elif motors_config_parser.kinematics == 'corexy':
+        # CoreXY motors are on A and B axis (45 and 135 degrees)
+        main_angles = [45, 135]
+    else:
+        gcmd.error(
+            'Only Cartesian and CoreXY kinematics are supported at the moment for the vibrations measurement tool!'
+        )
+    ConsoleOutput.print(f'{motors_config_parser.kinematics.upper()} kinematics mode')
+
+    toolhead_info = toolhead.get_status(systime)
+    old_accel = toolhead_info['max_accel']
+    old_mcr = toolhead_info['minimum_cruise_ratio']
+    old_sqv = toolhead_info['square_corner_velocity']
+
+    # set the wanted acceleration values
+    gcode.run_script_from_command(f'SET_VELOCITY_LIMIT ACCEL={accel} MINIMUM_CRUISE_RATIO=0 SQUARE_CORNER_VELOCITY=5.0')
+
+    kin_info = toolhead.kin.get_status(systime)
+    mid_x = (kin_info['axis_minimum'].x + kin_info['axis_maximum'].x) / 2
+    mid_y = (kin_info['axis_minimum'].y + kin_info['axis_maximum'].y) / 2
+    X, Y, _, E = toolhead.get_position()
+
+    # Going to the start position
+    toolhead.move([X, Y, z_height, E], feedrate_travel / 10)
+    toolhead.move([mid_x - 15, mid_y - 15, z_height, E], feedrate_travel)
+    toolhead.dwell(0.5)
+
+    nb_speed_samples = int((max_speed - MIN_SPEED) / speed_increment + 1)
+    for curr_angle in main_angles:
+        ConsoleOutput.print(f'-> Measuring angle: {curr_angle} degrees...')
+        radian_angle = math.radians(curr_angle)
+
+        # Find the best accelerometer chip for the current angle if not specified
+        if curr_angle == 0:
+            accel_axis = 'x'
+        elif curr_angle == 90:
+            accel_axis = 'y'
+        else:
+            accel_axis = 'xy'
+        if accel_chip is None:
+            accel_chip = Accelerometer.find_axis_accelerometer(printer, accel_axis)
+            if accel_chip is None:
+                gcmd.error(
+                    'No accelerometer specified for measurement! Multi-accelerometer configurations are not supported for this macro.'
+                )
+        accelerometer = Accelerometer(printer.lookup_object(accel_chip))
+
+        # Sweep the speed range to record the vibrations at different speeds
+        for curr_speed_sample in range(nb_speed_samples):
+            curr_speed = MIN_SPEED + curr_speed_sample * speed_increment
+            ConsoleOutput.print(f'Current speed: {curr_speed} mm/s')
+
+            # Reduce the segments length for the lower speed range (0-100mm/s). The minimum length is 1/3 of the SIZE and is gradually increased
+            # to the nominal SIZE at 100mm/s. No further size changes are made above this speed. The goal is to ensure that the print head moves
+            # enough to collect enough data for vibration analysis, without doing unnecessary distance to save time. At higher speeds, the full
+            # segments lengths are used because the head moves faster and travels more distance in the same amount of time and we want enough data
+            if curr_speed < 100:
+                segment_length_multiplier = 1 / 5 + 4 / 5 * curr_speed / 100
+            else:
+                segment_length_multiplier = 1
+
+            # Calculate angle coordinates using trigonometry and length multiplier and move to start point
+            dX = (size / 2) * math.cos(radian_angle) * segment_length_multiplier
+            dY = (size / 2) * math.sin(radian_angle) * segment_length_multiplier
+            toolhead.move([mid_x - dX, mid_y - dY, z_height, E], feedrate_travel)
+
+            # Adjust the number of back and forth movements based on speed to also save time on lower speed range
+            # 3 movements are done by default, reduced to 2 between 150-250mm/s and to 1 under 150mm/s.
+            movements = 3
+            if curr_speed < 150:
+                movements = 1
+            elif curr_speed < 250:
+                movements = 2
+
+            # Back and forth movements to record the vibrations at constant speed in both direction
+            accelerometer.start_measurement()
+            for _ in range(movements):
+                toolhead.move([mid_x + dX, mid_y + dY, z_height, E], curr_speed)
+                toolhead.move([mid_x - dX, mid_y - dY, z_height, E], curr_speed)
+            name = f'vib_an{curr_angle:.2f}sp{curr_speed:.2f}'.replace('.', '_')
+            accelerometer.stop_measurement(name)
+
+            toolhead.dwell(0.3)
+            toolhead.wait_moves()
+
+    # Restore the previous acceleration values
+    gcode.run_script_from_command(
+        f'SET_VELOCITY_LIMIT ACCEL={old_accel} MINIMUM_CRUISE_RATIO={old_mcr} SQUARE_CORNER_VELOCITY={old_sqv}'
+    )
+    toolhead.wait_moves()
+
+    # Run post-processing
+    ConsoleOutput.print('Machine vibrations profile generation...')
+    ConsoleOutput.print('This may take some time (5-8min)')
+    creator = st_thread.get_graph_creator()
+    creator.configure(motors_config_parser.kinematics, accel, motors_config_parser)
+    st_thread.run()