added back the vibrations profile measurement

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, gcode, printer, 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!')
+
+    # Check that input shaper is already configured
+    input_shaper = printer.lookup_object('input_shaper', None)
+    if input_shaper is None:
+        gcmd.error('Input shaper is not configured! Please run the shaper calibration macro first.')
+
+    # TODO: Add the kinematics check to define the main_angles
+    #       but this needs to retrieve it from the printer configuration
+    # {% if kinematics == "cartesian" %}
+    #     # Cartesian motors are on X and Y axis directly
+    #     RESPOND MSG="Cartesian kinematics mode"
+    #     {% set main_angles = [0, 90] %}
+    # {% elif kinematics == "corexy" %}
+    #     # CoreXY motors are on A and B axis (45 and 135 degrees)
+    #     RESPOND MSG="CoreXY kinematics mode"
+    #     {% set main_angles = [45, 135] %}
+    # {% else %}
+    #     { action_raise_error("Only Cartesian and CoreXY kinematics are supported at the moment for the vibrations measurement tool!") }
+    # {% endif %}
+    kinematics = 'cartesian'
+    main_angles = [0, 90]
+
+    systime = printer.get_reactor().monotonic()
+    toolhead = printer.lookup_object('toolhead')
+    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:
+        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
+
+            # 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()
+
+    # Get the motors and TMC configurations from Klipper
+    motors_config_parser = MotorsConfigParser(printer, motors=['stepper_x', 'stepper_y'])
+
+    # 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(kinematics, accel, motors_config_parser)
+    st_thread.run()