mcu: Disable waiting in send_wait_ack() if in debugging mode

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>

.github/workflows/build-test.yaml

@@ -4,7 +4,7 @@ on: [push, pull_request]
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v3
 

config/example-generic-caretesian.cfg

@@ -0,0 +1,138 @@
+# This file is an example config file for cartesian style printers.
+# One may copy and edit this file to configure a new printer with
+# a generic cartesian kinematics.
+
+# DO NOT COPY THIS FILE WITHOUT CAREFULLY READING AND UPDATING IT
+# FIRST. Incorrectly configured parameters may cause damage.
+
+# See docs/Config_Reference.md for a description of parameters.
+
+[carriage x]
+position_endstop: 0
+position_max: 300
+homing_speed: 50
+endstop_pin: ^PE5
+
+[carriage y]
+position_endstop: 0
+position_max: 200
+homing_speed: 50
+endstop_pin: ^PJ1
+
+[extra_carriage y1]
+primary_carriage: y
+endstop_pin: ^PB6
+
+[carriage z]
+position_endstop: 0.5
+position_max: 100
+endstop_pin: ^PD3
+
+[dual_carriage u]
+primary_carriage: x
+position_endstop: 300
+position_max: 300
+homing_speed: 50
+endstop_pin: ^PE4
+
+[stepper my_stepper_x]
+carriages: x+y
+step_pin: PF0
+dir_pin: PF1
+enable_pin: !PD7
+microsteps: 16
+rotation_distance: 40
+
+[stepper my_stepper_u]
+carriages: u-y1
+step_pin: PH1
+dir_pin: PH0
+enable_pin: !PA1
+microsteps: 16
+rotation_distance: 40
+
+[stepper my_stepper_y0]
+carriages: y
+step_pin: PF6
+dir_pin: !PF7
+enable_pin: !PF2
+microsteps: 16
+rotation_distance: 40
+
+[stepper my_stepper_y1]
+carriages: y1
+step_pin: PE3
+dir_pin: !PH6
+enable_pin: !PG5
+microsteps: 16
+rotation_distance: 40
+
+[stepper my_stepper_z0]
+carriages: z
+step_pin: PL3
+dir_pin: PL1
+enable_pin: !PK0
+microsteps: 16
+rotation_distance: 8
+
+[stepper my_stepper_z1]
+carriages: z
+step_pin: PG1
+dir_pin: PG0
+enable_pin: !PH3
+microsteps: 16
+rotation_distance: 8
+
+[extruder]
+step_pin: PA4
+dir_pin: PA6
+enable_pin: !PA2
+microsteps: 16
+rotation_distance: 33.5
+nozzle_diameter: 0.400
+filament_diameter: 1.750
+heater_pin: PB4
+sensor_type: EPCOS 100K B57560G104F
+sensor_pin: PK5
+control: pid
+pid_Kp: 22.2
+pid_Ki: 1.08
+pid_Kd: 114
+min_temp: 0
+max_temp: 250
+
+[extruder1]
+step_pin: PC1
+dir_pin: PC3
+enable_pin: !PC7
+microsteps: 16
+rotation_distance: 33.5
+nozzle_diameter: 0.400
+filament_diameter: 1.750
+heater_pin: PB5
+sensor_type: EPCOS 100K B57560G104F
+sensor_pin: PK7
+control: pid
+pid_Kp: 22.2
+pid_Ki: 1.08
+pid_Kd: 114
+min_temp: 0
+max_temp: 250
+
+[heater_bed]
+heater_pin: PH5
+sensor_type: EPCOS 100K B57560G104F
+sensor_pin: PK6
+control: watermark
+min_temp: 0
+max_temp: 110
+
+[mcu]
+serial: /dev/ttyACM0
+
+[printer]
+kinematics: generic_cartesian
+max_velocity: 500
+max_accel: 3000
+max_z_velocity: 20
+max_z_accel: 100

config/generic-bigtreetech-manta-m8p-v1.0.cfg

@@ -39,7 +39,7 @@ position_max: 270
 # Motor4
 # The M8P only has 4 heater outputs which leaves an extra stepper
 # This can be used for a second Z stepper, dual_carriage, extruder co-stepper,
-# or other accesory such as an MMU
+# or other accessory such as an MMU
 #[stepper_]
 #step_pin: PD3
 #dir_pin: PD2

config/generic-bigtreetech-manta-m8p-v1.1.cfg

@@ -40,7 +40,7 @@ position_max: 270
 # Motor4
 # The M8P only has 4 heater outputs which leaves an extra stepper
 # This can be used for a second Z stepper, dual_carriage, extruder co-stepper,
-# or other accesory such as an MMU
+# or other accessory such as an MMU
 #[stepper_]
 #step_pin: PD3
 #dir_pin: PD2

config/generic-bigtreetech-octopus-max-ez.cfg

@@ -43,7 +43,7 @@ position_max: 200
 # Motor-4
 # The Octopus only has 4 heater outputs which leaves an extra stepper
 # This can be used for a second Z stepper, dual_carriage, extruder co-stepper,
-# or other accesory such as an MMU
+# or other accessory such as an MMU
 #[stepper_]
 #step_pin: PB8
 #dir_pin: PB9

config/generic-bigtreetech-octopus-v1.1.cfg

@@ -52,7 +52,7 @@ position_max: 200
 # Driver3
 # The Octopus only has 4 heater outputs which leaves an extra stepper
 # This can be used for a second Z stepper, dual_carriage, extruder co-stepper,
-# or other accesory such as an MMU
+# or other accessory such as an MMU
 #[stepper_]
 #step_pin: PG4
 #dir_pin: PC1

config/generic-bigtreetech-skr-2.cfg

@@ -153,3 +153,48 @@ aliases:
 #uart_pin: PD12
 #run_current: 0.600
 #diag_pin:
+
+########################################
+# TMC2130 configuration
+########################################
+
+#[tmc2130 stepper_x]
+#cs_pin: PE0
+#spi_software_miso_pin: PA14
+#spi_software_mosi_pin: PE14
+#spi_software_sclk_pin: PE15
+#run_current: 0.800
+#diag1_pin: PC1
+
+#[tmc2130 stepper_y]
+#cs_pin: PD3
+#spi_software_miso_pin: PA14
+#spi_software_mosi_pin: PE14
+#spi_software_sclk_pin: PE15
+#run_current: 0.800
+#diag1_pin: PC3
+
+#[tmc2130 stepper_z]
+#cs_pin: PD0
+#spi_software_miso_pin: PA14
+#spi_software_mosi_pin: PE14
+#spi_software_sclk_pin: PE15
+#run_current: 0.800
+#diag1_pin: PC0
+
+#[tmc2130 extruder]
+#cs_pin: PC6
+#spi_software_miso_pin: PA14
+#spi_software_mosi_pin: PE14
+#spi_software_sclk_pin: PE15
+#run_current: 0.600
+#diag1_pin: PC2
+
+#[tmc2130 extruder1]
+#cs_pin: PD12
+#spi_software_miso_pin: PA14
+#spi_software_mosi_pin: PE14
+#spi_software_sclk_pin: PE15
+#run_current: 0.600
+#stealthchop_threshold: 999999
+#diag1_pin: PA0

config/generic-bigtreetech-skr-mini-mz.cfg

@@ -122,6 +122,12 @@ max_z_accel: 100
 [static_digital_output usb_pullup_enable]
 pins: !PA14
 
+#[neopixel my_neopixel]
+#pin: PA8
+
+[output_pin red_led]
+pin: PA13
+
 [board_pins]
 aliases:
     # EXP1 header

config/generic-mightyboard.cfg

@@ -89,32 +89,32 @@ max_z_velocity: 5
 max_z_accel: 100
 
 [mcp4018 x_axis_pot]
-scl_pin: PJ5
-sda_pin: PF3
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PF3
 wiper: 0.50
 scale: 0.773
 
 [mcp4018 y_axis_pot]
-scl_pin: PJ5
-sda_pin: PF7
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PF7
 wiper: 0.50
 scale: 0.773
 
 [mcp4018 z_axis_pot]
-scl_pin: PJ5
-sda_pin: PK3
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PK3
 wiper: 0.50
 scale: 0.773
 
 [mcp4018 a_axis_pot]
-scl_pin: PJ5
-sda_pin: PA5
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PA5
 wiper: 0.50
 scale: 0.773
 
 [mcp4018 b_axis_pot]
-scl_pin: PJ5
-sda_pin: PJ6
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PJ6
 wiper: 0.50
 scale: 0.773
 

config/kit-voron2-250mm.cfg

@@ -19,7 +19,7 @@
 # FSR switch (z endstop) location       [homing_override] section
 # FSR switch (z endstop) offset for Z0  [stepper_z] section
 # Probe points                          [quad_gantry_level] section
-# Min & Max gantry corner postions      [quad_gantry_level] section
+# Min & Max gantry corner positions     [quad_gantry_level] section
 # PID tune                              [extruder] and [heater_bed] sections
 # Fine tune E steps                     [extruder] section
 

config/kit-zav3d-2019.cfg

@@ -20,7 +20,7 @@
 # FSR switch (z endstop) location       [homing_override] section
 # FSR switch (z endstop) offset for Z0  [stepper_z] section
 # Probe points                          [quad_gantry_level] section
-# Min & Max gantry corner postions      [quad_gantry_level] section
+# Min & Max gantry corner positions     [quad_gantry_level] section
 # PID tune                              [extruder] and [heater_bed] sections
 # Fine tune E steps                     [extruder] section
 

config/printer-anycubic-kossel-2016.cfg

@@ -17,7 +17,7 @@ endstop_pin: ^PE4
 homing_speed: 60
 # The next parameter needs to be adjusted for
 # your printer. You may want to start with 280
-# and meassure the distance from nozzle to bed.
+# and measure the distance from nozzle to bed.
 # This value then needs to be added.
 position_endstop: 273.0
 arm_length: 229.4

config/printer-creality-cr10-v3-2020.cfg

@@ -43,7 +43,7 @@ position_max: 400
 #Uncomment if you have a BL-Touch:
 #position_min: -4
 #endstop_pin: probe:z_virtual_endstop
-#and comment the follwing lines:
+#and comment the following lines:
 position_endstop: 0.0
 endstop_pin: ^PD3 #ar18
 

config/printer-creality-cr6se-2020.cfg

@@ -1,4 +1,5 @@
-# This file contains pin mappings for the stock 2020 Creality CR6-SE.
+# This file contains pin mappings for the stock 2020 Creality CR6-SE
+# with the early 4.5.2 board only.
 # To use this config, during "make menuconfig" select the STM32F103
 # with a "28KiB bootloader" and serial (on USART1 PA10/PA9)
 # communication.

config/printer-creality-cr6se-2021.cfg

@@ -1,4 +1,6 @@
-# This file contains pin mappings for the Creality CR6-SE with Rev. 4.5.3 Motherboard (Late 2020/2021) as the heater pins changed.
+# This file contains pin mappings for the Creality CR6-SE
+# with Rev. 4.5.3 Motherboard (Late 2020/2021) as the heater pins changed.
+# This config also works for the CR-ERA_V1.1.0.3
 # To use this config, during "make menuconfig" select the STM32F103
 # with a "28KiB bootloader" and serial (on USART1 PA10/PA9)
 # communication.

config/printer-creality-ender5-s1-2023.cfg

@@ -81,7 +81,7 @@ pin: PA0
 kick_start_time: 0.5
 
 # Hotend fan
-# set fan runnig when extruder temperature is over 60
+# set fan running when extruder temperature is over 60
 [heater_fan heatbreak_fan]
 pin: PC0
 heater:extruder

config/printer-flashforge-creator-pro-2018.cfg

@@ -127,32 +127,32 @@ max_z_velocity: 5
 max_z_accel: 100
 
 [mcp4018 x_axis_pot]
-scl_pin: PJ5
-sda_pin: PF3
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PF3
 wiper: 118
 scale: 127
 
 [mcp4018 y_axis_pot]
-scl_pin: PJ5
-sda_pin: PF7
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PF7
 wiper: 118
 scale: 127
 
 [mcp4018 z_axis_pot]
-scl_pin: PJ5
-sda_pin: PK3
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PK3
 wiper: 40
 scale: 127
 
 [mcp4018 a_axis_pot]
-scl_pin: PJ5
-sda_pin: PA5
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PA5
 wiper: 118
 scale: 127
 
 [mcp4018 b_axis_pot]
-scl_pin: PJ5
-sda_pin: PJ6
+i2c_software_scl_pin: PJ5
+i2c_software_sda_pin: PJ6
 wiper: 118
 scale: 127
 

config/printer-lulzbot-mini1-2016.cfg

@@ -195,7 +195,7 @@ samples_tolerance: 0.200
 samples_tolerance_retries: 2
 
 [bed_tilt]
-# Enable bed tilt measurments using the probe we defined above
+# Enable bed tilt measurements using the probe we defined above
 # Probe points using X0 Y0 offsets @ 0.01mm/step
 points: -2, -6
         156, -6

config/printer-lulzbot-taz6-dual-v3-2017.cfg

@@ -183,7 +183,7 @@ samples: 2
 samples_tolerance: 0.100
 
 [bed_tilt]
-#Enable bed tilt measurments using the probe we defined above
+#Enable bed tilt measurements using the probe we defined above
 #Probe points using X0 Y0 offsets @ 0.01mm/step
 points: -3, -6
         282, -6

config/printer-robo3d-r2-2017.cfg

@@ -37,7 +37,7 @@ microsteps: 16
 rotation_distance: 4
 # Required if not using probe for the virtual endstop
 # endstop_pin: ^PD3
-# position_endstop: 250 # Will need ajustment
+# position_endstop: 250 # Will need adjustment
 endstop_pin: probe:z_virtual_endstop
 homing_speed: 10.0
 position_max: 250

config/printer-seemecnc-rostock-max-v2-2015.cfg

@@ -1,4 +1,4 @@
-# This file constains the pin mappings for the SeeMeCNC Rostock Max
+# This file contains the pin mappings for the SeeMeCNC Rostock Max
 # (version 2) delta printer from 2015. To use this config, the
 # firmware should be compiled for the AVR atmega2560.
 

config/sample-corexyuv.cfg

@@ -0,0 +1,177 @@
+# This file contains a configuration snippet for a CoreXYUV
+# printer with an independent dual extruder moving over X and Y axes.
+
+# See docs/Config_Reference.md for a description of parameters.
+
+[carriage x]
+position_endstop: 0
+position_max: 300
+homing_speed: 50
+endstop_pin: ^PE5
+
+[carriage y]
+position_endstop: 0
+position_max: 200
+homing_speed: 50
+endstop_pin: ^PJ1
+
+[dual_carriage u]
+primary_carriage: x
+safe_distance: 70
+position_endstop: 300
+position_max: 300
+homing_speed: 50
+endstop_pin: ^PE4
+
+[dual_carriage v]
+primary_carriage: y
+safe_distance: 50
+position_endstop: 200
+position_max: 200
+homing_speed: 50
+endstop_pin: ^PD4
+
+[stepper a]
+carriages: x+y
+step_pin: PF0
+dir_pin: PF1
+enable_pin: !PD7
+microsteps: 16
+rotation_distance: 40
+
+[stepper b]
+carriages: u-v
+step_pin: PH1
+dir_pin: PH0
+enable_pin: !PA1
+microsteps: 16
+rotation_distance: 40
+
+[stepper c]
+carriages: x-y
+step_pin: PF6
+dir_pin: !PF7
+enable_pin: !PF2
+microsteps: 16
+rotation_distance: 40
+
+[stepper d]
+carriages: u+v
+step_pin: PE3
+dir_pin: !PH6
+enable_pin: !PG5
+microsteps: 16
+rotation_distance: 40
+
+[extruder]
+step_pin: PA4
+dir_pin: PA6
+enable_pin: !PA2
+microsteps: 16
+rotation_distance: 33.5
+nozzle_diameter: 0.400
+filament_diameter: 1.750
+heater_pin: PB4
+sensor_type: EPCOS 100K B57560G104F
+sensor_pin: PK5
+control: pid
+pid_Kp: 22.2
+pid_Ki: 1.08
+pid_Kd: 114
+min_temp: 0
+max_temp: 250
+
+[gcode_macro PARK_extruder]
+gcode:
+    SET_DUAL_CARRIAGE CARRIAGE=x
+    SET_DUAL_CARRIAGE CARRIAGE=y
+    G90
+    G1 X0 Y0
+
+[gcode_macro T0]
+gcode:
+    PARK_{printer.toolhead.extruder}
+    ACTIVATE_EXTRUDER EXTRUDER=extruder
+    SET_DUAL_CARRIAGE CARRIAGE=x
+    SET_DUAL_CARRIAGE CARRIAGE=y
+
+[extruder1]
+step_pin: PC1
+dir_pin: PC3
+enable_pin: !PC7
+microsteps: 16
+rotation_distance: 33.5
+nozzle_diameter: 0.400
+filament_diameter: 1.750
+heater_pin: PB5
+sensor_type: EPCOS 100K B57560G104F
+sensor_pin: PK7
+control: pid
+pid_Kp: 22.2
+pid_Ki: 1.08
+pid_Kd: 114
+min_temp: 0
+max_temp: 250
+
+[gcode_macro PARK_extruder1]
+gcode:
+    SET_DUAL_CARRIAGE CARRIAGE=u
+    SET_DUAL_CARRIAGE CARRIAGE=v
+    G90
+    G1 X300 Y200
+
+[gcode_macro T1]
+gcode:
+    PARK_{printer.toolhead.extruder}
+    ACTIVATE_EXTRUDER EXTRUDER=extruder1
+    SET_DUAL_CARRIAGE CARRIAGE=u
+    SET_DUAL_CARRIAGE CARRIAGE=v
+
+# A helper script to activate copy mode
+[gcode_macro ACTIVATE_COPY_MODE]
+gcode:
+    SET_DUAL_CARRIAGE CARRIAGE=x MODE=PRIMARY
+    SET_DUAL_CARRIAGE CARRIAGE=y MODE=PRIMARY
+    G1 X0 Y0
+    ACTIVATE_EXTRUDER EXTRUDER=extruder
+    SET_DUAL_CARRIAGE CARRIAGE=u MODE=PRIMARY
+    SET_DUAL_CARRIAGE CARRIAGE=v MODE=PRIMARY
+    G1 X150 Y100
+    SET_DUAL_CARRIAGE CARRIAGE=u MODE=COPY
+    SET_DUAL_CARRIAGE CARRIAGE=v MODE=COPY
+    SYNC_EXTRUDER_MOTION EXTRUDER=extruder1 MOTION_QUEUE=extruder
+
+# A helper script to activate mirror mode
+[gcode_macro ACTIVATE_MIRROR_MODE]
+gcode:
+    SET_DUAL_CARRIAGE CARRIAGE=x MODE=PRIMARY
+    SET_DUAL_CARRIAGE CARRIAGE=y MODE=PRIMARY
+    G1 X0 Y0
+    ACTIVATE_EXTRUDER EXTRUDER=extruder
+    SET_DUAL_CARRIAGE CARRIAGE=u MODE=PRIMARY
+    SET_DUAL_CARRIAGE CARRIAGE=v MODE=PRIMARY
+    G1 X300 Y100
+    SET_DUAL_CARRIAGE CARRIAGE=u MODE=MIRROR
+    SET_DUAL_CARRIAGE CARRIAGE=v MODE=COPY
+    SYNC_EXTRUDER_MOTION EXTRUDER=extruder1 MOTION_QUEUE=extruder
+
+[printer]
+kinematics: generic_cartesian
+max_velocity: 300
+max_accel: 3000
+max_z_velocity: 5
+max_z_accel: 100
+
+## An optional input shaper support
+#[input_shaper]
+## The section is intentionally empty
+#
+#[delayed_gcode init_shaper]
+#initial_duration: 0.1
+#gcode:
+#    SET_DUAL_CARRIAGE CARRIAGE=u
+#    SET_DUAL_CARRIAGE CARRIAGE=v
+#    SET_INPUT_SHAPER SHAPER_TYPE_X=<dual_carriage_x_shaper> SHAPER_FREQ_X=<dual_carriage_x_freq> SHAPER_TYPE_Y=<dual_carriage_y_shaper> SHAPER_FREQ_Y=<dual_carriage_y_freq>
+#    SET_DUAL_CARRIAGE CARRIAGE=x MODE=PRIMARY
+#    SET_DUAL_CARRIAGE CARRIAGE=y MODE=PRIMARY
+#    SET_INPUT_SHAPER SHAPER_TYPE_X=<primary_carriage_x_shaper> SHAPER_FREQ_X=<primary_carriage_x_freq> SHAPER_TYPE_Y=<primary_carriage_y_shaper> SHAPER_FREQ_Y=<primary_carriage_y_freq>

config/sample-duet3-1lc.cfg

@@ -6,7 +6,7 @@
 # Communication interface of "CAN bus (on PA25/PA24)"
 
 # To flash the board use a debugger, or use a raspberry pi and follow
-# the instructions at docs/Bootloaders.md fot the SAMC21. You may
+# the instructions at docs/Bootloaders.md for the SAMC21. You may
 # supply power to the 1LC by connecting the 3.3v rail on the Pi to the
 # 5v input of the SWD header on the 1LC.
 

config/sample-mmu2s-diy.cfg

@@ -96,7 +96,7 @@ switch_pin: !P1.28 # P1.28 for X-max
 # variable_pause_z               : z lift when MMU2S need intervention and the printer is paused
 # variable_min_temp_extruder     : minimal required heater temperature to load/unload filament from the extruder gear to the nozzle
 # variable_extruder_eject_temp   : heater temperature used to eject filament during home if the filament is already loaded
-# variable_enable_5in1           : pass from MMU2S standart (0) to MMU2S-5in1 mode with splitter
+# variable_enable_5in1           : pass from MMU2S standard (0) to MMU2S-5in1 mode with splitter
 #
 ################################
 [gcode_macro VAR_MMU2S]
@@ -394,7 +394,7 @@ gcode:
     {% endif %}
     {% endif %}
 
-# Retry unload, try correct misalignement of bondtech gear
+# Retry unload, try correct misalignment of bondtech gear
 [gcode_macro RETRY_UNLOAD_FILAMENT_IN_EXTRUDER]
 gcode:
     {% if printer["filament_switch_sensor ir_sensor"].filament_detected == True %}
@@ -444,7 +444,7 @@ gcode:
     {% endif %}
     {% endif %}
 
-# Ramming process for standart PLA, code extracted from slic3r gcode
+# Ramming process for standard PLA, code extracted from slic3r gcode
 [gcode_macro RAMMING_SLICER]
 gcode:
     G91

docs/API_Server.md

@@ -364,37 +364,42 @@ and might later produce asynchronous messages such as:
 The "header" field in the initial query response is used to describe
 the fields found in later "data" responses.
 
-### hx71x/dump_hx71x
+### load_cell/dump_force
 
-This endpoint is used to subscribe to raw HX711 and HX717 ADC data.
-Obtaining these low-level ADC updates may be useful for diagnostic
-and debugging purposes. Using this endpoint may increase Klipper's
-system load.
+This endpoint is used to subscribe to force data produced by a load_cell.
+Using this endpoint may increase Klipper's system load.
 
 A request may look like:
-`{"id": 123, "method":"hx71x/dump_hx71x",
+`{"id": 123, "method":"load_cell/dump_force",
 "params": {"sensor": "load_cell", "response_template": {}}}`
 and might return:
-`{"id": 123,"result":{"header":["time","counts","value"]}}`
+`{"id": 123,"result":{"header":["time", "force (g)", "counts", "tare_counts"]}}`
 and might later produce asynchronous messages such as:
-`{"params":{"data":[[3292.432935, 562534, 0.067059278],
-[3292.4394937, 5625322, 0.670590639]]}}`
+`{"params":{"data":[[3292.432935, 40.65, 562534, -234467]]}}`
 
-### ads1220/dump_ads1220
+The "header" field in the initial query response is used to describe
+the fields found in later "data" responses.
 
-This endpoint is used to subscribe to raw ADS1220 ADC data.
-Obtaining these low-level ADC updates may be useful for diagnostic
-and debugging purposes. Using this endpoint may increase Klipper's
-system load.
+### load_cell_probe/dump_taps
+
+This endpoint is used to subscribe to details of probing "tap" events.
+Using this endpoint may increase Klipper's system load.
 
 A request may look like:
-`{"id": 123, "method":"ads1220/dump_ads1220",
+`{"id": 123, "method":"load_cell/dump_force",
 "params": {"sensor": "load_cell", "response_template": {}}}`
 and might return:
-`{"id": 123,"result":{"header":["time","counts","value"]}}`
+`{"id": 123,"result":{"header":["probe_tap_event"]}}`
 and might later produce asynchronous messages such as:
-`{"params":{"data":[[3292.432935, 562534, 0.067059278],
-[3292.4394937, 5625322, 0.670590639]]}}`
+```
+{"params":{"tap":'{
+   "time": [118032.28039, 118032.2834, ...],
+   "force": [-459.4213119680034, -458.1640702543264, ...],
+}}}
+```
+
+This data can be used to render:
+* The time/force graph
 
 ### pause_resume/cancel
 

docs/Axis_Twist_Compensation.md

@@ -1,6 +1,6 @@
 # Axis Twist Compensation
 
-This document describes the [axis_twist_compensation] module.
+This document describes the `[axis_twist_compensation]` module.
 
 Some printers may have a small twist in their X rail which can skew the results
 of a probe attached to the X carriage.
@@ -25,7 +25,7 @@ try to probe the bed without attaching the probe if you use it.
 > correctly set as they greatly influence calibration.
 
 ### Basic Usage: X-Axis Calibration
-1. After setting up the ```[axis_twist_compensation]``` module, run:
+1. After setting up the `[axis_twist_compensation]` module, run:
 ```
 AXIS_TWIST_COMPENSATION_CALIBRATE
 ```
@@ -39,8 +39,8 @@ SAMPLE_COUNT=<value>
 ``
 
 2. **Adjust Your Z Offset:**
-After completing the calibration, be sure to [adjust your Z offset]
-(Probe_Calibrate.md#calibrating-probe-z-offset).
+After completing the calibration, be sure to
+[adjust your Z offset](Probe_Calibrate.md#calibrating-probe-z-offset).
 
 3. **Perform Bed Leveling Operations:**
 Use probe-based operations as needed, such as:
@@ -61,22 +61,13 @@ AXIS_TWIST_COMPENSATION_CALIBRATE AXIS=Y
 ```
 This will guide you through the same measuring process as for the X-axis.
 
-### Automatic Calibration for Both Axes
-To perform automatic calibration for both the X and Y axes without manual
-intervention, use:
-```
-AXIS_TWIST_COMPENSATION_CALIBRATE AUTO=True
-```
-In this mode, the calibration process will run for both axes automatically.
-
-
 > **Tip:** Bed temperature and nozzle temperature and size do not seem to have
 > an influence to the calibration process.
 
 ## [axis_twist_compensation] setup and commands
 
-Configuration options for [axis_twist_compensation] can be found in the
+Configuration options for `[axis_twist_compensation]` can be found in the
 [Configuration Reference](Config_Reference.md#axis_twist_compensation).
 
-Commands for [axis_twist_compensation] can be found in the
+Commands for `[axis_twist_compensation]` can be found in the
 [G-Codes Reference](G-Codes.md#axis_twist_compensation)

docs/Bed_Mesh.md

@@ -267,7 +267,7 @@ by heat or interference.  This can make calculating the probe's z-offset
 challenging, particularly at different bed temperatures.  As such, some
 printers use an endstop for homing the Z axis and a probe for calibrating the
 mesh. In this configuration it is possible offset the mesh so that the (X, Y)
-`reference position` applies zero adjustment.  The `reference postion` should
+`reference position` applies zero adjustment.  The `reference position` should
 be the location on the bed where a
 [Z_ENDSTOP_CALIBRATE](./Manual_Level.md#calibrating-a-z-endstop)
 paper test is performed.  The bed_mesh module provides the
@@ -292,33 +292,6 @@ probe_count: 5, 3
   z-offset.  Note that this coordinate must NOT be in a location specified as
   a `faulty_region` if a probe is necessary.
 
-#### The deprecated relative_reference_index
-
-Existing configurations using the `relative_reference_index` option must be
-updated to use the `zero_reference_position`.  The response to the
-[BED_MESH_OUTPUT PGP=1](#output) gcode command will include the (X, Y)
-coordinate associated with the index;  this position may be used as the value for
-the `zero_reference_position`. The output will look similar to the following:
-
-```
-// bed_mesh: generated points
-// Index | Tool Adjusted | Probe
-// 0 | (1.0, 1.0) | (24.0, 6.0)
-// 1 | (36.7, 1.0) | (59.7, 6.0)
-// 2 | (72.3, 1.0) | (95.3, 6.0)
-// 3 | (108.0, 1.0) | (131.0, 6.0)
-... (additional generated points)
-// bed_mesh: relative_reference_index 24 is (131.5, 108.0)
-```
-
-_Note:  The above output is also printed in `klippy.log` during initialization._
-
-Using the example above we see that the `relative_reference_index` is
-printed along with its coordinate.  Thus the `zero_reference_position`
-is `131.5, 108`.
-
-
-
 ### Faulty Regions
 
 It is possible for some areas of a bed to report inaccurate results when
@@ -497,7 +470,8 @@ _Default Adaptive Margin: 0_
 
 Initiates the probing procedure for Bed Mesh Calibration.
 
-The mesh will be saved into a profile specified by the `PROFILE` parameter,
+The mesh will be immediately ready to use when the command completes and saved
+into a profile specified by the `PROFILE` parameter,
 or `default` if unspecified. The `METHOD` parameter takes one of the following
 values:
 
@@ -561,6 +535,10 @@ load the `default` profile it is recommended to add
 `BED_MESH_PROFILE LOAD=default` to either their `START_PRINT` macro or their
 slicer's "Start G-Code" configuration, whichever is applicable.
 
+Note that this is not required if a new mesh is generated with
+`BED_MESH_CALIBRATE` in the `START_PRINT` macro or the slicer's "Start G-Code"
+and may produce unexpected results, especially with adaptive meshing.
+
 Alternatively the old behavior of loading a profile at startup can be
 restored with a `[delayed_gcode]`:
 

docs/Benchmarks.md

@@ -250,23 +250,22 @@ results were obtained by running an STM32F407 binary on an STM32F446
 
 ### STM32H7 step rate benchmark
 
-The following configuration sequence is used on a STM32H743VIT6:
+The following configuration sequence is used on STM32H723:
 ```
 allocate_oids count=3
-config_stepper oid=0 step_pin=PD4 dir_pin=PD3 invert_step=-1 step_pulse_ticks=0
-config_stepper oid=1 step_pin=PA15 dir_pin=PA8 invert_step=-1 step_pulse_ticks=0
-config_stepper oid=2 step_pin=PE2 dir_pin=PE3 invert_step=-1 step_pulse_ticks=0
+config_stepper oid=0 step_pin=PA13 dir_pin=PB5 invert_step=-1 step_pulse_ticks=52
+config_stepper oid=1 step_pin=PB2 dir_pin=PB6 invert_step=-1 step_pulse_ticks=52
+config_stepper oid=2 step_pin=PB3 dir_pin=PB7 invert_step=-1 step_pulse_ticks=52
 finalize_config crc=0
 ```
 
-The test was last run on commit `00191b5c` with gcc version
-`arm-none-eabi-gcc (15:8-2019-q3-1+b1) 8.3.1 20190703 (release)
-[gcc-8-branch revision 273027]`.
+The test was last run on commit `554ae78d` with gcc version
+`arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0`.
 
-| stm32h7              | ticks |
+| stm32h723            | ticks |
 | -------------------- | ----- |
-| 1 stepper            | 44    |
-| 3 stepper            | 198   |
+| 1 stepper            | 70    |
+| 3 stepper            | 181   |
 
 ### STM32G0B1 step rate benchmark
 
@@ -287,6 +286,25 @@ The test was last run on commit `247cd753` with gcc version
 | 1 stepper        | 58    |
 | 3 stepper        | 243   |
 
+### STM32G4 step rate benchmark
+
+The following configuration sequence is used on the STM32G431:
+```
+allocate_oids count=3
+config_stepper oid=0 step_pin=PA0 dir_pin=PB5 invert_step=-1 step_pulse_ticks=17
+config_stepper oid=1 step_pin=PB2 dir_pin=PB6 invert_step=-1 step_pulse_ticks=17
+config_stepper oid=2 step_pin=PB3 dir_pin=PB7 invert_step=-1 step_pulse_ticks=17
+finalize_config crc=0
+```
+
+The test was last run on commit `cfa48fe3` with gcc version
+`arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0`.
+
+| stm32g431        | ticks |
+| ---------------- | ----- |
+| 1 stepper        | 47    |
+| 3 stepper        | 208   |
+
 ### LPC176x step rate benchmark
 
 The following configuration sequence is used on the LPC176x:
@@ -407,14 +425,14 @@ config_stepper oid=2 step_pin=gpio27 dir_pin=gpio5 invert_step=-1 step_pulse_tic
 finalize_config crc=0
 ```
 
-The test was last run on commit `f6718291` with gcc version
+The test was last run on commit `14c105b8` with gcc version
 `arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0` on Raspberry Pi
 Pico and Pico 2 boards.
 
 | rp2040 (*)           | ticks |
 | -------------------- | ----- |
-| 1 stepper            | 5     |
-| 3 stepper            | 22    |
+| 1 stepper            | 3     |
+| 3 stepper            | 14    |
 
 | rp2350               | ticks |
 | -------------------- | ----- |
@@ -422,9 +440,9 @@ Pico and Pico 2 boards.
 | 3 stepper            | 169   |
 
 (*) Note that the reported rp2040 ticks are relative to a 12Mhz
-scheduling timer and do not correspond to its 125Mhz internal ARM
-processing rate. It is expected that 5 scheduling ticks corresponds to
-~47 ARM core cycles and 22 scheduling ticks corresponds to ~224 ARM
+scheduling timer and do not correspond to its 200Mhz internal ARM
+processing rate. It is expected that 3 scheduling ticks corresponds to
+~42 ARM core cycles and 14 scheduling ticks corresponds to ~225 ARM
 core cycles.
 
 ### Linux MCU step rate benchmark
@@ -464,18 +482,23 @@ When the test completes, determine the difference between the clocks
 reported in the two "uptime" response messages. The total number of
 commands per second is then `100000 * mcu_frequency / clock_diff`.
 
-Note that this test may saturate the USB/CPU capacity of a Raspberry
-Pi. If running on a Raspberry Pi, Beaglebone, or similar host computer
-then increase the delay (eg, `DELAY {clock + 20*freq} get_uptime`).
-Where applicable, the benchmarks below are with console.py running on
-a desktop class machine with the device connected via a high-speed
-hub.
+The USB tests may exceed the CPU capacity of a Raspberry Pi. If
+running on a Raspberry Pi, Beaglebone, or similar host computer then
+increase the delay (eg, `DELAY {clock + 20*freq} get_uptime`). Where
+applicable, the benchmarks below are with console.py running on a
+desktop class machine with the device connected via a super-speed hub.
+
+The CAN bus tests may saturate the USB host controller of a Raspberry
+Pi (when testing via a standard gs_usb USB to CAN bus adapter). Where
+applicable, the CAN bus benchmarks below are with console.py running
+on a desktop class machine with a USB to CAN bus adapter connected via
+a super-speed USB hub.
 
 | MCU                 | Rate | Build    | Build compiler      |
 | ------------------- | ---- | -------- | ------------------- |
-| stm32f042 (CAN)     |  18K | c105adc8 | arm-none-eabi-gcc (GNU Tools 7-2018-q3-update) 7.3.1 |
 | atmega2560 (serial) |  23K | b161a69e | avr-gcc (GCC) 4.8.1 |
 | sam3x8e (serial)    |  23K | b161a69e | arm-none-eabi-gcc (Fedora 7.1.0-5.fc27) 7.1.0 |
+| rp2350 (CAN)        |  59K | 17b8ce4c | arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0 |
 | at90usb1286 (USB)   |  75K | 01d2183f | avr-gcc (GCC) 5.4.0 |
 | ar100 (serial)      | 138K | 08d037c6 | or1k-linux-musl-gcc 9.3.0 |
 | samd21 (USB)        | 223K | 01d2183f | arm-none-eabi-gcc (Fedora 7.4.0-1.fc30) 7.4.0 |

docs/Bootloaders.md

@@ -194,7 +194,7 @@ Alternatively, one can use a
 
 When using OpenOCD with the SAMC21, extra steps must be taken to first
 put the chip into Cold Plugging mode if the board makes use of the
-SWD pins for other purposes. If using OpenOCD on a Rasberry Pi, this
+SWD pins for other purposes. If using OpenOCD on a Raspberry Pi, this
 can be done by running the following commands before invoking OpenOCD.
 ```
 SWCLK=25

docs/CANBUS.md

@@ -125,10 +125,14 @@ iface can0 can static
   frequency. As a result, it is recommended to use a CAN bus frequency
   of 1000000 when using "USB to CAN bus bridge mode".
 
-  Even at a CAN bus frequency of 1000000, there may not be sufficient
-  bandwidth to run a `SHAPER_CALIBRATE` test if both the XY steppers
-  and the accelerometer all communicate via a single "USB to CAN bus"
-  interface.
+* It is only valid to use USB to CAN bridge mode if there is a
+  functioning CAN bus with at least one other node available (in
+  addition to the bridge node itself). Use a standard USB
+  configuration if the goal is to communicate only with the single USB
+  device. Using USB to CAN bridge mode without a fully functioning CAN
+  bus (including terminating resistors and an additional node) may
+  result in sporadic errors even when communicating with the bridge
+  node.
 
 * A USB to CAN bridge board will not appear as a USB serial device, it
   will not show up when running `ls /dev/serial/by-id`, and it can not

docs/CANBUS_Troubleshooting.md

@@ -37,20 +37,36 @@ hours or more frequently) then it is an indication of a severe
 problem.
 
 Incrementing `bytes_invalid` on a CAN bus connection is a symptom of
-reordered messages on the CAN bus. There are two known causes of
-reordered messages:
-1. Old versions of the popular candlight_firmware for USB CAN adapters
-   had a bug that could cause reordered messages. If using a USB CAN
-   adapter running this firmware then make sure to update to the
-   latest firmware if incrementing `bytes_invalid` is observed.
-2. Some Linux kernel builds for embedded devices have been known to
-   reorder CAN bus messages. It may be necessary to use an alternative
-   Linux kernel or to use alternative hardware that supports
-   mainstream Linux kernels that do not exhibit this problem.
+reordered messages on the CAN bus. If seen, make sure to:
+* Use a Linux kernel version 6.6.0 or later.
+* If using a USB-to-CANBUS adapter running candlelight firmware, use
+  v2.0 or later of candleLight_fw.
+* If using Klipper's USB-to-CANBUS bridge mode, make sure the bridge
+  node is flashed with Klipper v0.12.0 or later.
 
 Reordered messages is a severe problem that must be fixed. It will
 result in unstable behavior and can lead to confusing errors at any
-part of a print.
+part of a print. An incrementing `bytes_invalid` is not caused by
+wiring or similar hardware issues and can only be fixed by identifying
+and updating the faulty software.
+
+Older versions of the Linux kernel had a bug in the gs_usb canbus
+driver code that could cause reordered canbus packets.  The issue is
+thought to be fixed in
+[Linux commit 24bc41b4](https://github.com/torvalds/linux/commit/24bc41b4558347672a3db61009c339b1f5692169)
+which was released in v6.6.0. In some cases, older Linux versions may
+not show the problem (due to how hardware interrupts are configured),
+however if problems are seen the recommended solution is to upgrade to
+a newer kernel.
+
+Older versions of candlelight firmware could reorder canbus packets,
+and the issue is thought to be fixed in
+[candlelight_fw commit 8b3a7b45](https://github.com/candle-usb/candleLight_fw/commit/8b3a7b4565a3c9521b762b154c94c72c5acb2bcf).
+
+Older versions of Klipper's USB-to-CANBUS bridge code could
+incorrectly drop canbus messages. This is not as severe as reordering
+messages, but it should still be fixed. It is thought to be fixed with
+[Klipper PR #6175](https://github.com/Klipper3d/klipper/pull/6175).
 
 ## Use an appropriate txqueuelen setting
 
@@ -102,6 +118,23 @@ necessary to increase the `txqueuelen` above the recommended value
 of 128. However, as above, care should be taken when selecting a new
 value to avoid excessive round-trip-time latency.
 
+## Use `canbus_query.py` only to identify nodes never previously seen
+
+It is only valid to use the
+[`canbus_query.py` tool](CANBUS.md#finding-the-canbus_uuid-for-new-micro-controllers)
+to identify micro-controllers that have never been previously
+identified. Once all nodes on a bus are identified, record the
+resulting uuids in the printer.cfg, and avoid running the tool
+unnecessarily.
+
+The tool is implemented using a low-level mechanism that can cause
+nodes to internally observe bus errors. These internal errors may
+result in communication interruptions and may result is some nodes
+disconnecting from the bus.
+
+It is not valid to use the tool to "ping" if a node is connected. Do
+not run the tool during an active print.
+
 ## Obtaining candump logs
 
 The CAN bus messages sent to and from the micro-controller are handled

docs/CONTRIBUTING.md

@@ -323,7 +323,7 @@ a month without updates.
 
 Once the requirements are met, you need to:
 
-1. update klipper-tranlations repository
+1. update klipper-translations repository
 [active_translations](https://github.com/Klipper3d/klipper-translations/blob/translations/active_translations)
 2. Optional: add a manual-index.md file in klipper-translations repository's
 `docs\locals\<lang>` folder to replace the language specific index.md (generated

docs/Code_Overview.md

@@ -286,6 +286,11 @@ The following may also be useful:
   during the `load_config()` or "connect event" phases. Use either
   `raise config.error("my error")` or `raise printer.config_error("my
   error")` to report the error.
+* Do not store a reference to the `config` object in a class member
+  variable (nor in any similar location that may persist past initial
+  module loading). The `config` object is a reference to a "config
+  loading phase" class and it is not valid to invoke its methods after
+  the "config loading phase" has completed.
 * Use the "pins" module to configure a pin on a micro-controller. This
   is typically done with something similar to
   `printer.lookup_object("pins").setup_pin("pwm",

docs/Config_Changes.md

@@ -8,6 +8,41 @@ All dates in this document are approximate.
 
 ## Changes
 
+20250811: Support for the `max_accel_to_decel` parameter in the
+`[printer]` config section has been removed and support for the
+`ACCEL_TO_DECEL` parameter in the `SET_VELOCITY_LIMIT` command has
+been removed. These capabilities were deprecated on 20240313.
+
+20250721: The `[pca9632]` and `[mcp4018]` modules no longer accept the
+`scl_pin` and `sda_pin` options. Use `i2c_software_scl_pin` and
+`i2c_software_sda_pin` instead.
+
+20250428: The maximum `cycle_time` for pwm `[output_pin]`,
+`[pwm_cycle_time]`, `[pwm_tool]`, and similar config sections is now 3
+seconds (reduced from 5 seconds). The `maximum_mcu_duration` in
+`[pwm_tool]` is now also 3 seconds.
+
+20250418: The manual_stepper `STOP_ON_ENDSTOP` feature may now take
+less time to complete. Previously, the command would wait the entire
+time the move could possibly take even if the endstop triggered
+earlier. Now, the command finishes shortly after the endstop trigger.
+
+20250417: SPI devices using "software SPI" are now rate limited.
+Previously, the `spi_speed` in the config was ignored and the
+transmission speed was only limited by the processing speed of the
+micro-controller. Now, speeds are limited by the `spi_speed` config
+parameter (actual hardware speeds are likely to be lower than the
+configured value due to software overhead).
+
+20250411: Klipper v0.13.0 released.
+
+20250308: The `AUTO` parameter of the
+`AXIS_TWIST_COMPENSATION_CALIBRATE` command has been removed.
+
+20250131: Option `VARIABLE=<name>` in `SAVE_VARIABLE` requires lowercase
+value. For example, `extruder` instead of mixedcase `Extruder` or
+uppercase `EXTRUDER`. Using any uppercase letter will raise an error.
+
 20241203: The resonance test has been changed to include slow sweeping
 moves. This change requires that testing point(s) have some clearance
 in X/Y plane (+/- 30 mm from the test point should suffice when using
@@ -32,7 +67,7 @@ object were issued faster than the minimum scheduling time (typically
 100ms) then actual updates could be queued far into the future. Now if
 many updates are issued in rapid succession then it is possible that
 only the latest request will be applied. If the previous behavior is
-requried then consider adding explicit `G4` delay commands between
+required then consider adding explicit `G4` delay commands between
 updates.
 
 20240912: Support for `maximum_mcu_duration` and `static_value`
@@ -105,7 +140,7 @@ carriage are exported as `printer.dual_carriage.carriage_0` and
 `printer.dual_carriage.carriage_1`.
 
 20230619: The `relative_reference_index` option has been deprecated
-and superceded by the `zero_reference_position` option.  Refer to the
+and superseded by the `zero_reference_position` option.  Refer to the
 [Bed Mesh Documentation](./Bed_Mesh.md#the-deprecated-relative_reference_index)
 for details on how to update the configuration.  With this deprecation
 the `RELATIVE_REFERENCE_INDEX` is no longer available as a parameter
@@ -339,7 +374,7 @@ endstop phases by running the ENDSTOP_PHASE_CALIBRATE command.
 `gear_ratio` for their rotary steppers, and they may no longer specify
 a `step_distance` parameter.  See the
 [config reference](Config_Reference.md#stepper) for the format of the
-new gear_ratio paramter.
+new gear_ratio parameter.
 
 20201213: It is not valid to specify a Z "position_endstop" when using
 "probe:z_virtual_endstop".  An error will now be raised if a Z

docs/Config_Reference.md

@@ -84,8 +84,9 @@ The printer section controls high level printer settings.
 [printer]
 kinematics:
 #   The type of printer in use. This option may be one of: cartesian,
-#   corexy, corexz, hybrid_corexy, hybrid_corexz, rotary_delta, delta,
-#   deltesian, polar, winch, or none. This parameter must be specified.
+#   corexy, corexz, hybrid_corexy, hybrid_corexz, generic_cartesian,
+#   rotary_delta, delta, deltesian, polar, winch, or none.
+#   This parameter must be specified.
 max_velocity:
 #   Maximum velocity (in mm/s) of the toolhead (relative to the
 #   print). This value may be changed at runtime using the
@@ -125,8 +126,6 @@ max_accel:
 #   decelerate to zero at each corner. The value specified here may be
 #   changed at runtime using the SET_VELOCITY_LIMIT command. The
 #   default is 5mm/s.
-#max_accel_to_decel:
-#   This parameter is deprecated and should no longer be used.
 ```
 
 ### [stepper]
@@ -712,6 +711,171 @@ anchor_z:
 #   These parameters must be provided.
 ```
 
+### Generic Cartesian Kinematics
+
+See [example-generic-cartesian.cfg](../config/example-generic-caretesian.cfg)
+for an example generic Cartesian kinematics config file.
+
+This printer kinematic class allows a user to define in a pretty flexible
+manner an arbitrary Cartesian-style kinematics. In principle, the regular
+cartesian, corexy, hybrid_corexy can be defined this way too. However,
+more importantly, various otherwise unsupported kinematics such as
+inverted hybrid_corexy or corexyuv can be defined using this kinematic.
+
+Notably, the definition of a generic Cartesian kinematic deviates
+significantly from the other kinematic types. It follows the following
+convention: a user defines a set of carriages with certain range of motion
+that can move independently from each other (they should move over the
+Cartesian axes X, Y, and Z, hence the name of the kinematic) and
+corresponding endstops that allow the firmware to determine the position
+of carriages during homing, as well as a set of steppers that move those
+carriages. The `[printer]` section must specify the kinematic and
+other printer-level settings same as the regular Cartesian kinematic:
+```
+[printer]
+kinematics: generic_cartesian
+max_velocity:
+max_accel:
+#minimum_cruise_ratio:
+#square_corner_velocity:
+#max_z_velocity:
+#max_z_accel:
+
+```
+
+Then a user must define the following three carriages: `[carriage x]`,
+`[carriage y]`, and `[carriage z]`, e.g.
+```
+[carriage x]
+endstop_pin:
+#   Endstop switch detection pin. If this endstop pin is on a
+#   different mcu than the stepper motor(s) moving this carriage,
+#   then it enables "multi-mcu homing". This parameter must be provided.
+#position_min: 0
+#   Minimum valid distance (in mm) the user may command the carriage to
+#   move to.  The default is 0mm.
+position_endstop:
+#   Location of the endstop (in mm). This parameter must be provided.
+position_max:
+#   Maximum valid distance (in mm) the user may command the stepper to
+#   move to. This parameter must be provided.
+#homing_speed: 5.0
+#   Maximum velocity (in mm/s) of the carriage when homing. The default
+#   is 5mm/s.
+#homing_retract_dist: 5.0
+#   Distance to backoff (in mm) before homing a second time during
+#   homing. Set this to zero to disable the second home. The default
+#   is 5mm.
+#homing_retract_speed:
+#   Speed to use on the retract move after homing in case this should
+#   be different from the homing speed, which is the default for this
+#   parameter
+#second_homing_speed:
+#   Velocity (in mm/s) of the carriage when performing the second home.
+#   The default is homing_speed/2.
+#homing_positive_dir:
+#   If true, homing will cause the carriage to move in a positive
+#   direction (away from zero); if false, home towards zero. It is
+#   better to use the default than to specify this parameter. The
+#   default is true if position_endstop is near position_max and false
+#   if near position_min.
+```
+
+Afterwards, a user specifies the stepper motors that move these carriages,
+for instance
+```
+[stepper my_stepper]
+carriages:
+#   A string describing the carriages the stepper moves. All defined
+#   carriages can be specified here, as well as their linear combinations,
+#   e.g. x, x+y, y-0.5*z, x-z, etc. This parameter must be provided.
+step_pin:
+dir_pin:
+enable_pin:
+rotation_distance:
+microsteps:
+#full_steps_per_rotation: 200
+#gear_ratio:
+#step_pulse_duration:
+```
+See [stepper](#stepper) section for more information on the regular
+stepper parameters. The `carriages` parameter defines how the stepper
+affects the motion of the carriages. For example, `x+y` indicates that
+the motion of the stepper in the positive direction by the distance `d`
+moves the carriages `x` and `y` by the same distance `d` in the positive
+direction, while `x-0.5*y` means the motion of the stepper in the positive
+direction by the distance `d` moves the carriage `x` by the distance `d`
+in the positive direction, but the carriage `y` will travel distance `d/2`
+in the negative direction.
+
+More than a single stepper motor can be defined to drive the same axis
+or belt. For example, on a CoreXY AWD setups two motors driving the same
+belt can be defined as
+```
+[carriage x]
+endstop_pin: ...
+...
+
+[carriage y]
+endstop_pin: ...
+...
+
+[stepper a0]
+carriages: x-y
+step_pin: ...
+dir_pin: ...
+enable_pin: ...
+rotation_distance: ...
+...
+
+[stepper a1]
+carriages: x-y
+step_pin: ...
+dir_pin: ...
+enable_pin: ...
+rotation_distance: ...
+...
+```
+with `a0` and `a1` steppers having their own control pins, but
+sharing the same `carriages` and corresponding endstops.
+
+There are situations when a user wants to have more than one endstop
+per axis. Examples of such configurations include Y axis driven by
+two independent stepper motors with belts attached to both ends of the
+X beam, with effectively two carriages on Y axis each having an
+independent endstop, and multi-stepper Z axis with each stepper having
+its own endstop (not to be confused with the configurations with
+multiple Z motors but only a single endstop). These configurations
+can be declared by specifying additional carriage(s) with their endstops:
+
+```
+[extra_carriage my_carriage]
+primary_carriage:
+#   The name of the primary carriage this carriage corresponds to.
+#   It also effectively defines the axis the carriage moves over.
+#   This parameter must be provided.
+endstop_pin:
+#   Endstop switch detection pin. This parameter must be provided.
+```
+
+and the corresponding stepper motors, for example:
+```
+[extra_carriage y1]
+primary_carriage: y
+endstop_pin: ...
+
+[stepper sy1]
+carriages: y1
+...
+```
+Notably, an `[extra_carriage]` does not define parameters such as
+`position_min`, `position_max`, and `position_endstop`, but instead
+inherits them from the specified `primary_carriage`, thus sharing
+the same range of motion with the primary carriage.
+
+For the references on how to configure IDEX setups, see the
+[dual carriage](#dual-carriage) section.
+
 ### None Kinematics
 
 It is possible to define a special "none" kinematics to disable
@@ -1669,6 +1833,25 @@ cs_pin:
 #   measurements.
 ```
 
+### [icm20948]
+
+Support for icm20948 accelerometers.
+
+```
+[icm20948]
+#i2c_address:
+#   Default is 104 (0x68). If AD0 is high, it would be 0x69 instead.
+#i2c_mcu:
+#i2c_bus:
+#i2c_software_scl_pin:
+#i2c_software_sda_pin:
+#i2c_speed: 400000
+#   See the "common I2C settings" section for a description of the
+#   above parameters. The default "i2c_speed" is 400000.
+#axes_map: x, y, z
+#   See the "adxl345" section for information on this parameter.
+```
+
 ### [lis2dw]
 
 Support for LIS2DW accelerometers.
@@ -2065,6 +2248,9 @@ Support for eddy current inductive probes. One may define this section
 sensor_type: ldc1612
 #   The sensor chip used to perform eddy current measurements. This
 #   parameter must be provided and must be set to ldc1612.
+#frequency:
+#   The external crystal frequency (in Hz) of the LDC1612 chip.
+#   The default is 12000000.
 #intb_pin:
 #   MCU gpio pin connected to the ldc1612 sensor's INTB pin (if
 #   available). The default is to not use the INTB pin.
@@ -2185,8 +2371,8 @@ for an example configuration.
 
 ### [dual_carriage]
 
-Support for cartesian and hybrid_corexy/z printers with dual carriages
-on a single axis. The carriage mode can be set via the
+Support for cartesian, generic_cartesian and hybrid_corexy/z printers with
+dual carriages on a single axis. The carriage mode can be set via the
 SET_DUAL_CARRIAGE extended g-code command. For example,
 "SET_DUAL_CARRIAGE CARRIAGE=1" command will activate the carriage defined
 in this section (CARRIAGE=0 will return activation to the primary carriage).
@@ -2213,7 +2399,7 @@ typically be achieved with
 or a similar command.
 
 See [sample-idex.cfg](../config/sample-idex.cfg) for an example
-configuration.
+configuration with a regular Cartesian kinematic.
 
 ```
 [dual_carriage]
@@ -2227,7 +2413,7 @@ axis:
 #   error. If safe_distance is not provided, it will be inferred from
 #   position_min and position_max for the dual and primary carriages. If set
 #   to 0 (or safe_distance is unset and position_min and position_max are
-#   identical for the primary and dual carraiges), the carriages proximity
+#   identical for the primary and dual carriages), the carriages proximity
 #   checks will be disabled.
 #step_pin:
 #dir_pin:
@@ -2241,6 +2427,83 @@ axis:
 #   See the "stepper" section for the definition of the above parameters.
 ```
 
+For an example of dual carriage configuration with `generic_cartesian`
+kinematic, see the following configuration
+[sample](../config/example-generic-caretesian.cfg).
+Please note that in this case the `[dual_carriage]` configuration deviates
+from the configuration described above:
+```
+[dual_carriage my_dc_carriage]
+primary_carriage:
+#   Defines the matching primary carriage of this dual carriage and
+#   the corresponding IDEX axis. Valid choices are x, y, z.
+#   This parameter must be provided.
+#safe_distance:
+#   The minimum distance (in mm) to enforce between the dual and the primary
+#   carriages. If a G-Code command is executed that will bring the carriages
+#   closer than the specified limit, such a command will be rejected with an
+#   error. If safe_distance is not provided, it will be inferred from
+#   position_min and position_max for the dual and primary carriages. If set
+#   to 0 (or safe_distance is unset and position_min and position_max are
+#   identical for the primary and dual carriages), the carriages proximity
+#   checks will be disabled.
+endstop_pin:
+#position_min:
+position_endstop:
+position_max:
+#homing_speed:
+#homing_retract_dist:
+#homing_retract_speed:
+#second_homing_speed:
+#homing_positive_dir:
+...
+```
+Refer to [generic cartesian](#generic-cartesian) section for more information
+on the regular `carriage` parameters.
+
+Then a user must define one or more stepper motors moving the dual carriage
+(and other carriages as appropriate), for instance
+```
+[carriage x]
+...
+
+[carriage y]
+...
+
+[dual_carriage u]
+primary_carriage: x
+...
+
+[stepper dc_stepper]
+carriages: u-y
+...
+```
+
+`[dual_carriage]` requires special configuration for the input shaper.
+In general, it is necessary to run input shaper calibration twice -
+for the `dual_carriage` and its `primary_carriage` for the axis they
+share. Then the input shaper can be configured as follows, assuming the
+example above:
+```
+[input_shaper]
+# Intentionally empty
+
+[delayed_gcode init_shaper]
+initial_duration: 0.1
+gcode:
+  SET_DUAL_CARRIAGE CARRIAGE=u
+  SET_INPUT_SHAPER SHAPER_TYPE_X=<dual_carriage_x_shaper> SHAPER_FREQ_X=<dual_carriage_x_freq> SHAPER_TYPE_Y=<y_shaper> SHAPER_FREQ_Y=<y_freq>
+  SET_DUAL_CARRIAGE CARRIAGE=x
+  SET_INPUT_SHAPER SHAPER_TYPE_X=<primary_carriage_x_shaper> SHAPER_FREQ_X=<primary_carriage_x_freq> SHAPER_TYPE_Y=<y_shaper> SHAPER_FREQ_Y=<y_freq>
+```
+Note that `SHAPER_TYPE_Y` and `SHAPER_FREQ_Y` must be the same in both
+commands in this case, since the same motors drive Y axis when either
+of the `x` and `u` carriages are active.
+
+It is worth noting that `generic_cartesian` kinematic can support two
+dual carriages for X and Y axes. For reference, see for instance a
+[sample](../config/sample-corexyuv.cfg) of CoreXYUV configuration.
+
 ### [extruder_stepper]
 
 Support for additional steppers synchronized to the movement of an
@@ -2295,6 +2558,13 @@ printer kinematics.
 #   Endstop switch detection pin. If specified, then one may perform
 #   "homing moves" by adding a STOP_ON_ENDSTOP parameter to
 #   MANUAL_STEPPER movement commands.
+#position_min:
+#position_max:
+#   The minimum and maximum position the stepper can be commanded to
+#   move to. If specified then one may not command the stepper to move
+#   past the given position. Note that these limits do not prevent
+#   setting an arbitrary position with the `MANUAL_STEPPER
+#   SET_POSITION=x` command. The default is to not enforce a limit.
 ```
 
 ## Custom heaters and sensors
@@ -3204,11 +3474,6 @@ PCA9632 LED support. The PCA9632 is used on the FlashForge Dreamer.
 #i2c_speed:
 #   See the "common I2C settings" section for a description of the
 #   above parameters.
-#scl_pin:
-#sda_pin:
-#   Alternatively, if the pca9632 is not connected to a hardware I2C
-#   bus, then one may specify the "clock" (scl_pin) and "data"
-#   (sda_pin) pins. The default is to use hardware I2C.
 #color_order: RGBW
 #   Set the pixel order of the LED (using a string containing the
 #   letters R, G, B, W). The default is RGBW.
@@ -3278,6 +3543,10 @@ pin:
 #   A list of G-Code commands to execute when the button is released.
 #   G-Code templates are supported. The default is to not run any
 #   commands on a button release.
+#debounce_delay:
+#   A period of time in seconds to debounce events prior to running the
+#   button gcode. If the button is pressed and released during this
+#   delay, the entire button press is ignored. Default is 0.
 ```
 
 ### [output_pin]
@@ -3456,8 +3725,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -3506,6 +3776,7 @@ run_current:
 #driver_PWM_FREQ: 1
 #driver_PWM_GRAD: 4
 #driver_PWM_AMPL: 128
+#driver_FREEWHEEL: 0
 #driver_SGT: 0
 #driver_SEMIN: 0
 #driver_SEUP: 0
@@ -3569,8 +3840,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #driver_MULTISTEP_FILT: True
 #driver_IHOLDDELAY: 8
 #driver_TPOWERDOWN: 20
@@ -3585,6 +3857,7 @@ run_current:
 #driver_PWM_FREQ: 1
 #driver_PWM_GRAD: 14
 #driver_PWM_OFS: 36
+#driver_FREEWHEEL: 0
 #   Set the given register during the configuration of the TMC2208
 #   chip. This may be used to set custom motor parameters. The
 #   defaults for each parameter are next to the parameter name in the
@@ -3634,6 +3907,7 @@ run_current:
 #driver_PWM_FREQ: 1
 #driver_PWM_GRAD: 14
 #driver_PWM_OFS: 36
+#driver_FREEWHEEL: 0
 #driver_SGTHRS: 0
 #driver_SEMIN: 0
 #driver_SEUP: 0
@@ -3772,8 +4046,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -3906,8 +4181,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -4113,16 +4389,21 @@ prefix).
 
 ### [mcp4018]
 
-Statically configured MCP4018 digipot connected via two gpio "bit
-banging" pins (one may define any number of sections with an "mcp4018"
-prefix).
+Statically configured MCP4018 digipot connected via i2c (one may
+define any number of sections with an "mcp4018" prefix).
 
 ```
 [mcp4018 my_digipot]
-scl_pin:
-#   The SCL "clock" pin. This parameter must be provided.
-sda_pin:
-#   The SDA "data" pin. This parameter must be provided.
+#i2c_address: 47
+#   The i2c address that the chip is using on the i2c bus. The default
+#   is 47.
+#i2c_mcu:
+#i2c_bus:
+#i2c_software_scl_pin:
+#i2c_software_sda_pin:
+#i2c_speed:
+#   See the "common I2C settings" section for a description of the
+#   above parameters.
 wiper:
 #   The value to statically set the given MCP4018 "wiper" to. This is
 #   typically set to a number between 0.0 and 1.0 with 1.0 being the
@@ -4637,6 +4918,11 @@ more information.
 #   dispatch and execution of the runout_gcode. It may be useful to
 #   increase this delay if OctoPrint exhibits strange pause behavior.
 #   Default is 0.5 seconds.
+#debounce_delay:
+#   A period of time in seconds to debounce events prior to running the
+#   switch gcode. The switch must he held in a single state for at least
+#   this long to activate. If the switch is toggled on/off during this delay,
+#   the event is ignored. Default is 0.
 #switch_pin:
 #   The pin on which the switch is connected. This parameter must be
 #   provided.
@@ -4754,6 +5040,16 @@ scale.
 [load_cell]
 sensor_type:
 #   This must be one of the supported sensor types, see below.
+#counts_per_gram:
+#   The floating point number of sensor counts that indicates 1 gram of force.
+#   This value is calculated by the LOAD_CELL_CALIBRATE command.
+#reference_tare_counts:
+#   The integer tare value, in raw sensor counts, taken when LOAD_CELL_CALIBRATE
+#   is run. This is the default tare value when klipper starts up.
+#sensor_orientation:
+#   Change the sensor's orientation. Can be either 'normal' or 'inverted'.
+#   The default is 'normal'. Use 'inverted' if the sensor reports a
+#   decreasing force value when placed under load.
 ```
 
 #### HX711
@@ -4850,6 +5146,65 @@ data_ready_pin:
 #   and 'analog_supply'. Default is 'internal'.
 ```
 
+### [load_cell_probe]
+Load Cell Probe. This combines the functionality of a [probe] and a [load_cell].
+
+```
+[load_cell_probe]
+sensor_type:
+#   This must be one of the supported bulk ADC sensor types and support
+#   load cell endstops on the mcu.
+#counts_per_gram:
+#reference_tare_counts:
+#sensor_orientation:
+#   These parameters must be configured before the probe will operate.
+#   See the [load_cell] section for further details.
+#force_safety_limit: 2000
+#   The safe limit for probing force relative to the reference_tare_counts on
+#   the load_cell. The default is +/-2Kg.
+#trigger_force: 75.0
+#   The force that the probe will trigger at. 75g is the default.
+#drift_filter_cutoff_frequency: 0.8
+#   Enable optional continuous taring while homing & probing to reject drift.
+#   The value is a frequency, in Hz, below which drift will be ignored. This
+#   option requires the SciPy library. Default: None
+#drift_filter_delay: 2
+#   The delay, or 'order', of the drift filter. This controls the number of
+#   samples required to make a trigger detection. Can be 1 or 2, the default
+#   is 2.
+#buzz_filter_cutoff_frequency: 100.0
+#   The value is a frequency, in Hz, above which high frequency noise in the
+#   load cell will be igfiltered outnored. This option requires the SciPy
+#   library. Default: None
+#buzz_filter_delay: 2
+#   The delay, or 'order', of the buzz filter. This controls the number of
+#   samples required to make a trigger detection. Can be 1 or 2, the default
+#   is 2.
+#notch_filter_frequencies: 50, 60
+#   1 or 2 frequencies, in Hz, to filter out of the load cell data. This is
+#   intended to reject power line noise. This option requires the SciPy
+#   library.  Default: None
+#notch_filter_quality: 2.0
+#   Controls how narrow the range of frequencies are that the notch filter
+#   removes. Larger numbers produce a narrower filter. Minimum value is 0.5 and
+#   maximum is 3.0. Default: 2.0
+#tare_time:
+#   The rime in seconds used for taring the load_cell before each probe. The
+#   default value is: 4 / 60 = 0.066. This collects samples from 4 cycles of
+#   60Hz mains power to cancel power line noise.
+#z_offset:
+#speed:
+#samples:
+#sample_retract_dist:
+#lift_speed:
+#samples_result:
+#samples_tolerance:
+#samples_tolerance_retries:
+#activate_gcode:
+#deactivate_gcode:
+#   See the "[probe]" section for a description of the above parameters.
+```
+
 ## Board specific hardware support
 
 ### [sx1509]
@@ -4956,7 +5311,7 @@ chip: ADS1115
 #   scales all values read from the ADC. Options are: 6.144V, 4.096V, 2.048V,
 #   1.024V, 0.512V, 0.256V
 #adc_voltage: 3.3
-#   The suppy voltage for the device. This allows additional software scaling
+#   The supply voltage for the device. This allows additional software scaling
 #   for all values read from the ADC.
 i2c_mcu: host
 i2c_bus: i2c.1
@@ -4975,7 +5330,7 @@ sensor_pin: my_ads1x1x:AIN0
 #   A combination of the name of the ads1x1x chip and the pin. Possible
 #   pin values are AIN0, AIN1, AIN2 and AIN3 for single ended lines and
 #   DIFF01, DIFF03, DIFF13 and DIFF23 for differential between their
-#   correspoding lines. For example
+#   corresponding lines. For example
 #   DIFF03 measures the differential between line 0 and 3. Only specific
 #   combinations for the differentials are allowed.
 ```
@@ -5061,7 +5416,7 @@ Octoprint as they will conflict, and 1 will fail to initialize
 properly likely aborting your print.
 
 If you use Octoprint and stream gcode over the serial port instead of
-printing from virtual_sd, then remo **M1** and **M0** from *Pausing commands*
+printing from virtual_sd, then remove **M1** and **M0** from *Pausing commands*
 in *Settings > Serial Connection > Firmware & protocol* will prevent
 the need to start print on the Palette 2 and unpausing in Octoprint
 for your print to begin.

docs/Features.md

@@ -102,11 +102,13 @@ Klipper supports many standard 3d printer features:
   printers.
 
 * Automatic bed leveling support. Klipper can be configured for basic
-  bed tilt detection or full mesh bed leveling. If the bed uses
+  bed tilt detection or full mesh bed leveling. The bed mesh can be
+  customized to the print size (adaptive bed mesh). If the bed uses
   multiple Z steppers then Klipper can also level by independently
   manipulating the Z steppers. Most Z height probes are supported,
   including BL-Touch probes and servo activated probes. Probes may be
-  calibrated for axis twist compensation.
+  calibrated for axis twist compensation. If using an "eddy current
+  probe" then one can utilize fast bed mesh scanning,
 
 * Automatic delta calibration support. The calibration tool can
   perform basic height calibration as well as an enhanced X and Y
@@ -118,7 +120,7 @@ Klipper supports many standard 3d printer features:
 
 * Support for common temperature sensors (eg, common thermistors,
   AD595, AD597, AD849x, PT100, PT1000, MAX6675, MAX31855, MAX31856,
-  MAX31865, BME280, HTU21D, DS18B20, AHT10, and LM75). Custom
+  MAX31865, BME280, HTU21D, DS18B20, AHT10, SHT3x, and LM75). Custom
   thermistors and custom analog temperature sensors can also be
   configured. One can monitor the internal micro-controller
   temperature sensor and the internal temperature sensor of a
@@ -128,7 +130,8 @@ Klipper supports many standard 3d printer features:
 
 * Support for standard fans, nozzle fans, and temperature controlled
   fans. No need to keep fans running when the printer is idle. Fan
-  speed can be monitored on fans that have a tachometer.
+  speed can be monitored on fans that have a tachometer. One can
+  assign a "math formula" to a fan for automatic fan speed updating.
 
 * Support for run-time configuration of TMC2130, TMC2208/TMC2224,
   TMC2209, TMC2240, TMC2660, and TMC5160 stepper motor drivers. There
@@ -154,7 +157,7 @@ Klipper supports many standard 3d printer features:
   filament width sensors.
 
 * Support for measuring and recording acceleration using adxl345,
-  mpu9250, mpu6050, and lis2dw12 accelerometers.
+  mpu9250, mpu6050, lis2dw12, lis3dh, and icm20948 accelerometers.
 
 * Support for limiting the top speed of short "zigzag" moves to reduce
   printer vibration and noise. See the [kinematics](Kinematics.md)
@@ -184,15 +187,16 @@ represent total number of steps per second on the micro-controller.
 | SAM4S8C                         | 1690K             | 1385K             |
 | LPC1768                         | 1923K             | 1351K             |
 | LPC1769                         | 2353K             | 1622K             |
-| RP2040                          | 2400K             | 1636K             |
 | SAM4E8E                         | 2500K             | 1674K             |
 | SAMD51                          | 3077K             | 1885K             |
 | AR100                           | 3529K             | 2507K             |
+| STM32G431                       | 3617K             | 2452K             |
 | STM32F407                       | 3652K             | 2459K             |
 | STM32F446                       | 3913K             | 2634K             |
+| RP2040                          | 4000K             | 2571K             |
 | RP2350                          | 4167K             | 2663K             |
 | SAME70                          | 6667K             | 4737K             |
-| STM32H743                       | 9091K             | 6061K             |
+| STM32H723                       | 7429K             | 8619K             |
 
 If unsure of the micro-controller on a particular board, find the
 appropriate [config file](../config/), and look for the

docs/G-Codes.md

@@ -154,8 +154,7 @@ The following commands are available when the
 section](Config_Reference.md#axis_twist_compensation) is enabled.
 
 #### AXIS_TWIST_COMPENSATION_CALIBRATE
-`AXIS_TWIST_COMPENSATION_CALIBRATE [AXIS=<X|Y>] [AUTO=<True|False>]
-[SAMPLE_COUNT=<value>]`
+`AXIS_TWIST_COMPENSATION_CALIBRATE [AXIS=<X|Y>] [SAMPLE_COUNT=<value>]`
 
 Calibrates axis twist compensation by specifying the target axis or
 enabling automatic calibration.
@@ -163,11 +162,6 @@ enabling automatic calibration.
 - **AXIS:** Define the axis (`X` or `Y`) for which the twist compensation
 will be calibrated. If not specified, the axis defaults to `'X'`.
 
-- **AUTO:** Enables automatic calibration mode. When `AUTO=True`, the
-calibration will run for both the X and Y axes. In this mode, `AXIS`
-cannot be specified. If both `AXIS` and `AUTO` are provided, an error
-will be raised.
-
 ### [bed_mesh]
 
 The following commands are available when the
@@ -180,8 +174,10 @@ The following commands are available when the
 [ADAPTIVE_MARGIN=<value>]`: This command probes the bed using generated points
 specified by the parameters in the config. After probing, a mesh is generated
 and z-movement is adjusted according to the mesh.
+The mesh is immediately active after successful completion of `BED_MESH_CALIBRATE`.
 The mesh will be saved into a profile specified by the `PROFILE` parameter,
-or `default` if unspecified.
+or `default` if unspecified. If ADAPTIVE=1 is specified then the profile
+name will begin with `adaptive-` and should not be saved for reuse.
 See the PROBE command for details on the optional probe parameters. If
 METHOD=manual is specified then the manual probing tool is activated - see the
 MANUAL_PROBE command above for details on the additional commands available
@@ -347,15 +343,18 @@ The following command is available when the
 enabled.
 
 #### SET_DUAL_CARRIAGE
-`SET_DUAL_CARRIAGE CARRIAGE=[0|1] [MODE=[PRIMARY|COPY|MIRROR]]`:
+`SET_DUAL_CARRIAGE CARRIAGE=<carriage> [MODE=[PRIMARY|COPY|MIRROR]]`:
 This command will change the mode of the specified carriage.
-If no `MODE` is provided it defaults to `PRIMARY`. Setting the mode
-to `PRIMARY` deactivates the other carriage and makes the specified
-carriage execute subsequent G-Code commands as-is. `COPY` and `MIRROR`
-modes are supported only for `CARRIAGE=1`. When set to either of these
-modes, carriage 1 will then track the subsequent moves of the carriage 0
-and either copy relative movements of it (in `COPY` mode) or execute them
-in the opposite (mirror) direction (in `MIRROR` mode).
+If no `MODE` is provided it defaults to `PRIMARY`. `<carriage>` must
+reference a defined primary or dual carriage for `generic_cartesian`
+kinematics or be 0 (for primary carriage) or 1 (for dual carriage)
+for all other kinematics supporting IDEX. Setting the mode to `PRIMARY`
+deactivates the other carriage and makes the specified carriage execute
+subsequent G-Code commands as-is. `COPY` and `MIRROR` modes are supported
+only for dual carriages. When set to either of these modes, dual carriage
+will then track the subsequent moves of its primary carriage and either
+copy relative movements of it (in `COPY` mode) or execute them in the
+opposite (mirror) direction (in `MIRROR` mode).
 
 #### SAVE_DUAL_CARRIAGE_STATE
 `SAVE_DUAL_CARRIAGE_STATE [NAME=<state_name>]`: Save the current positions
@@ -373,7 +372,7 @@ restored and "MOVE_SPEED" is specified, then the toolhead moves will be
 performed with the given speed (in mm/s); otherwise the toolhead move will
 use the rail homing speed. Note that the carriages restore their positions
 only over their own axis, which may be necessary to correctly restore COPY
-and MIRROR mode of the dual carraige.
+and MIRROR mode of the dual carriage.
 
 ### [endstop_phase]
 
@@ -585,18 +584,51 @@ state; issue a G28 afterwards to reset the kinematics. This command is
 intended for low-level diagnostics and debugging.
 
 #### SET_KINEMATIC_POSITION
+
 `SET_KINEMATIC_POSITION [X=<value>] [Y=<value>] [Z=<value>]
-[CLEAR=<[X][Y][Z]>]`: Force the low-level kinematic code to believe the
-toolhead is at the given cartesian position. This is a diagnostic and
-debugging command; use SET_GCODE_OFFSET and/or G92 for regular axis
-transformations. If an axis is not specified then it will default to the
-position that the head was last commanded to. Setting an incorrect or
-invalid position may lead to internal software errors. Use the CLEAR
-parameter to forget the homing state for the given axes. Note that CLEAR
-will not override the previous functionality; if an axis is not specified
-to CLEAR it will have its kinematic position set as per above. This
-command may invalidate future boundary checks; issue a G28 afterwards to
-reset the kinematics.
+[SET_HOMED=<[X][Y][Z]>] [CLEAR_HOMED=<[X][Y][Z]>]`: Force the
+low-level kinematic code to believe the toolhead is at the given
+cartesian position and set/clear homed status. This is a diagnostic
+and debugging command; use SET_GCODE_OFFSET and/or G92 for regular
+axis transformations. Setting an incorrect or invalid position may
+lead to internal software errors.
+
+The `X`, `Y`, and `Z` parameters are used to alter the low-level
+kinematic position tracking. If any of these parameters are not set
+then the position is not changed - for example `SET_KINEMATIC_POSITION
+Z=10` would set all axes as homed, set the internal Z position to 10,
+and leave the X and Y positions unchanged. Changing the internal
+position tracking is not dependent on the internal homing state - one
+may alter the position for both homed and not homed axes, and
+similarly one may set or clear the homing state of an axis without
+altering its internal position.
+
+The `SET_HOMED` parameter defaults to `XYZ` which instructs the
+kinematics to consider all axes as homed. A bare
+`SET_KINEMATIC_POSITION` command will result in all axes being
+considered homed (and not change its current position). If it is not
+desired to change the state of homed axes then assign `SET_HOMED` to
+an empty string - for example:
+`SET_KINEMATIC_POSITION SET_HOMED= X=10`. It is also possible to
+request an individual axis be considered homed (eg, `SET_HOMED=X`),
+but note that non-cartesian style kinematics (such as delta
+kinematics) may not support setting an individual axis as homed.
+
+The `CLEAR_HOMED` parameter instructs the kinematics to consider the
+given axes as not homed. For example, `CLEAR_HOMED=XYZ` would request
+all axes to be considered not homed (and thus require homing prior to
+movement on those axes). The default is `SET_HOMED=XYZ` even if
+`CLEAR_HOMED` is present, so the command `SET_KINEMATIC_POSITION
+CLEAR_HOMED=Z` will set X and Y as homed and clear the homing state
+for Z.  Use `SET_KINEMATIC_POSITION SET_HOMED= CLEAR_HOMED=Z` if the
+goal is to clear only the Z homing state. If an axis is specified in
+neither `SET_HOMED` nor `CLEAR_HOMED` then its homing state is not
+changed and if it is specified in both then `CLEAR_HOMED` has
+precedence. It is possible to request clearing of an individual axis,
+but on non-cartesian style kinematics (such as delta kinematics) doing
+so may result in clearing the homing state of additional axes. Note
+the `CLEAR` parameter is currently an alias for the `CLEAR_HOMED`
+parameter, but this alias will be removed in the future.
 
 ### [gcode]
 
@@ -688,6 +720,46 @@ is specified then the toolhead move will be performed with the given
 speed (in mm/s); otherwise the toolhead move will use the restored
 g-code speed.
 
+### [generic_cartesian]
+The commands in this section become automatically available when
+`kinematics: generic_cartesian` is specified as the printer kinematics.
+
+#### SET_STEPPER_CARRIAGES
+`SET_STEPPER_CARRIAGES STEPPER=<stepper_name> CARRIAGES=<carriages>
+[DISABLE_CHECKS=[0|1]]`: Set or update the stepper carriages.
+`<stepper_name>` must reference an existing stepper defined in `printer.cfg`,
+and `<carriages>` describes the carriages the stepper moves. See
+[Generic Cartesian Kinematics](Config_Reference.md#generic-cartesian-kinematics)
+for a more detailed overview of the `carriages` parameter in the
+stepper configuration section. Note that it is only possible
+to change the coefficients or signs of the carriages with this
+command, but a user cannot add or remove the carriages that the stepper
+controls.
+
+`SET_STEPPER_CARRIAGES` is an advanced tool, and the user is advised
+to exercise an extreme caution using it, since specifying incorrect
+configuration may physically damage the printer.
+
+Note that `SET_STEPPER_CARRIAGES` performs certain internal validations
+of the new printer kinematics after the change. Keep in mind that if it
+detects an issue, it may leave printer kinematics in an invalid state.
+This means that if `SET_STEPPER_CARRIAGES` reports an error, it is unsafe
+to issue other GCode commands, and the user must inspect the error message
+and either fix the problem, or manually restore the previous stepper(s)
+configuration.
+
+Since `SET_STEPPER_CARRIAGES` can update a configuration of a single
+stepper at a time, some sequences of changes can lead to invalid
+intermediate kinematic configurations, even if the final configuration
+is valid. In such cases a user can pass `DISABLE_CHECKS=1` parameters to
+all but the last command to disable intermediate checks. For example,
+if `stepper a` and `stepper b` initially have `x-y` and `x+y` carriages
+correspondingly, then the following sequence of commands will let a user
+effectively swap the carriage controls:
+`SET_STEPPER_CARRIAGES STEPPER=a CARRIAGES=x+y DISABLE_CHECKS=1`
+and `SET_STEPPER_CARRIAGES STEPPER=b CARRIAGES=x-y`, while
+still validating the final kinematics state.
+
 ### [hall_filament_width_sensor]
 
 The following commands are available when the
@@ -766,6 +838,116 @@ together with either of SHAPER_TYPE_X and SHAPER_TYPE_Y parameters.
 See [config reference](Config_Reference.md#input_shaper) for more
 details on each of these parameters.
 
+### [led]
+
+The following command is available when any of the
+[led config sections](Config_Reference.md#leds) are enabled.
+
+#### SET_LED
+`SET_LED LED=<config_name> RED=<value> GREEN=<value> BLUE=<value>
+WHITE=<value> [INDEX=<index>] [TRANSMIT=0] [SYNC=1]`: This sets the
+LED output. Each color `<value>` must be between 0.0 and 1.0. The
+WHITE option is only valid on RGBW LEDs. If the LED supports multiple
+chips in a daisy-chain then one may specify INDEX to alter the color
+of just the given chip (1 for the first chip, 2 for the second,
+etc.). If INDEX is not provided then all LEDs in the daisy-chain will
+be set to the provided color. If TRANSMIT=0 is specified then the
+color change will only be made on the next SET_LED command that does
+not specify TRANSMIT=0; this may be useful in combination with the
+INDEX parameter to batch multiple updates in a daisy-chain. By
+default, the SET_LED command will sync it's changes with other ongoing
+gcode commands.  This can lead to undesirable behavior if LEDs are
+being set while the printer is not printing as it will reset the idle
+timeout. If careful timing is not needed, the optional SYNC=0
+parameter can be specified to apply the changes without resetting the
+idle timeout.
+
+#### SET_LED_TEMPLATE
+`SET_LED_TEMPLATE LED=<led_name> TEMPLATE=<template_name>
+[<param_x>=<literal>] [INDEX=<index>]`: Assign a
+[display_template](Config_Reference.md#display_template) to a given
+[LED](Config_Reference.md#leds). For example, if one defined a
+`[display_template my_led_template]` config section then one could
+assign `TEMPLATE=my_led_template` here. The display_template should
+produce a comma separated string containing four floating point
+numbers corresponding to red, green, blue, and white color settings.
+The template will be continuously evaluated and the LED will be
+automatically set to the resulting colors. One may set
+display_template parameters to use during template evaluation
+(parameters will be parsed as Python literals). If INDEX is not
+specified then all chips in the LED's daisy-chain will be set to the
+template, otherwise only the chip with the given index will be
+updated. If TEMPLATE is an empty string then this command will clear
+any previous template assigned to the LED (one can then use `SET_LED`
+commands to manage the LED's color settings).
+
+### [load_cell]
+
+The following commands are enabled if a
+[load_cell config section](Config_Reference.md#load_cell) has been enabled.
+
+### LOAD_CELL_DIAGNOSTIC
+`LOAD_CELL_DIAGNOSTIC [LOAD_CELL=<config_name>]`: This command collects 10
+seconds of load cell data and reports statistics that can help you verify proper
+operation of the load cell. This command can be run on both calibrated and
+uncalibrated load cells.
+
+### LOAD_CELL_CALIBRATE
+`LOAD_CELL_CALIBRATE [LOAD_CELL=<config_name>]`: Start the guided calibration
+utility. Calibration is a 3 step process:
+1. First you remove all load from the load cell and run the `TARE` command
+2. Next you apply a known load to the load cell and run the
+`CALIBRATE GRAMS=nnn` command
+3. Finally use the `ACCEPT` command to save the results
+
+You can cancel the calibration process at any time with `ABORT`.
+
+### LOAD_CELL_TARE
+`LOAD_CELL_TARE [LOAD_CELL=<config_name>]`: This works just like the tare button
+on digital scale. It sets the current raw reading of the load cell to be the
+zero point reference value. The response is the percentage of the sensors range
+that was read and the raw value in counts. If the load cell is calibrated a
+force in grams is also reported.
+
+### LOAD_CELL_READ load_cell="name"
+`LOAD_CELL_READ [LOAD_CELL=<config_name>]`:
+This command takes a reading from the load cell. The response is the percentage
+of the sensors range that was read and the raw value in counts. If the load cell
+is calibrated a force in grams is also reported.
+
+### [load_cell_probe]
+
+The following commands are enabled if a
+[load_cell config section](Config_Reference.md#load_cell_probe) has been
+enabled.
+
+### LOAD_CELL_TEST_TAP
+`LOAD_CELL_TEST_TAP [TAPS=<taps>] [TIMEOUT=<timeout>]`: Run a testing routine
+that reports taps on the load cell. The toolhead will not move but the load cell
+probe will sense taps just as if it was probing. This can be used as a
+sanity check to make sure that the probe works. This tool replaces
+QUERY_ENDSTOPS and QUERY_PROBE for load cell probes.
+- `TAPS`: the number of taps the tool expects
+- `TIMEOOUT`: the time, in seconds, that the tool waits for each tab before
+  aborting.
+
+### Load Cell Command Extensions
+Commands that perform probes, such as [`PROBE`](#probe),
+[`PROBE_ACCURACY`](#probe_accuracy),
+[`BED_MESH_CALIBRATE`](#bed_mesh_calibrate) etc. will accept additional
+parameters if a `[load_cell_probe]` is defined. The parameters override the
+corresponding settings from the
+[`[load_cell_probe]`](./Config_Reference.md#load_cell_probe) configuration:
+- `FORCE_SAFETY_LIMIT=<grams>`
+- `TRIGGER_FORCE=<grams>`
+- `DRIFT_FILTER_CUTOFF_FREQUENCY=<frequency_hz>`
+- `DRIFT_FILTER_DELAY=<1|2>`
+- `BUZZ_FILTER_CUTOFF_FREQUENCY=<frequency_hz>`
+- `BUZZ_FILTER_DELAY=<1|2>`
+- `NOTCH_FILTER_FREQUENCIES=<list of frequency_hz>`
+- `NOTCH_FILTER_QUALITY=<quality>`
+- `TARE_TIME=<seconds>`
+
 ### [manual_probe]
 
 The manual_probe module is automatically loaded.
@@ -822,6 +1004,25 @@ scheduled to run after the stepper move completes, however if a manual
 stepper move uses SYNC=0 then future G-Code movement commands may run
 in parallel with the stepper movement.
 
+`MANUAL_STEPPER STEPPER=config_name GCODE_AXIS=[A-Z]
+[LIMIT_VELOCITY=<velocity>] [LIMIT_ACCEL=<accel>]
+[INSTANTANEOUS_CORNER_VELOCITY=<velocity>]`: If the `GCODE_AXIS`
+parameter is specified then it configures the stepper motor as an
+extra axis on `G1` move commands.  For example, if one were to issue a
+`MANUAL_STEPPER ... GCODE_AXIS=R` command then one could issue
+commands like `G1 X10 Y20 R30` to move the stepper motor.  The
+resulting moves will occur synchronously with the associated toolhead
+xyz movements.  If the motor is associated with a `GCODE_AXIS` then
+one may no longer issue movements using the above `MANUAL_STEPPER`
+command - one may unregister the stepper with a `MANUAL_STEPPER
+... GCODE_AXIS=` command to resume manual control of the motor. The
+`LIMIT_VELOCITY` and `LIMIT_ACCEL` parameters allow one to reduce the
+speed of `G1` moves if those moves would result in a velocity or
+acceleration above the specified limits. The
+`INSTANTANEOUS_CORNER_VELOCITY` specifies the maximum instantaneous
+velocity change (in mm/s) of the motor during the junction of two
+moves (the default is 1mm/s).
+
 ### [mcp4018]
 
 The following command is available when a
@@ -836,49 +1037,6 @@ be between 0.0 and 1.0, unless a 'scale' is defined in the config.
 When 'scale' is defined, then this value should be  between 0.0 and
 'scale'.
 
-### [led]
-
-The following command is available when any of the
-[led config sections](Config_Reference.md#leds) are enabled.
-
-#### SET_LED
-`SET_LED LED=<config_name> RED=<value> GREEN=<value> BLUE=<value>
-WHITE=<value> [INDEX=<index>] [TRANSMIT=0] [SYNC=1]`: This sets the
-LED output. Each color `<value>` must be between 0.0 and 1.0. The
-WHITE option is only valid on RGBW LEDs. If the LED supports multiple
-chips in a daisy-chain then one may specify INDEX to alter the color
-of just the given chip (1 for the first chip, 2 for the second,
-etc.). If INDEX is not provided then all LEDs in the daisy-chain will
-be set to the provided color. If TRANSMIT=0 is specified then the
-color change will only be made on the next SET_LED command that does
-not specify TRANSMIT=0; this may be useful in combination with the
-INDEX parameter to batch multiple updates in a daisy-chain. By
-default, the SET_LED command will sync it's changes with other ongoing
-gcode commands.  This can lead to undesirable behavior if LEDs are
-being set while the printer is not printing as it will reset the idle
-timeout. If careful timing is not needed, the optional SYNC=0
-parameter can be specified to apply the changes without resetting the
-idle timeout.
-
-#### SET_LED_TEMPLATE
-`SET_LED_TEMPLATE LED=<led_name> TEMPLATE=<template_name>
-[<param_x>=<literal>] [INDEX=<index>]`: Assign a
-[display_template](Config_Reference.md#display_template) to a given
-[LED](Config_Reference.md#leds). For example, if one defined a
-`[display_template my_led_template]` config section then one could
-assign `TEMPLATE=my_led_template` here. The display_template should
-produce a comma separated string containing four floating point
-numbers corresponding to red, green, blue, and white color settings.
-The template will be continuously evaluated and the LED will be
-automatically set to the resulting colors. One may set
-display_template parameters to use during template evaluation
-(parameters will be parsed as Python literals). If INDEX is not
-specified then all chips in the LED's daisy-chain will be set to the
-template, otherwise only the chip with the given index will be
-updated. If TEMPLATE is an empty string then this command will clear
-any previous template assigned to the LED (one can then use `SET_LED`
-commands to manage the LED's color settings).
-
 ### [output_pin]
 
 The following command is available when an
@@ -941,20 +1099,6 @@ Palette 2 once the loading has been completed. This command is the
 same as pressing **Smart Load** directly on the Palette 2 screen after
 the filament load is complete.
 
-### [pid_calibrate]
-
-The pid_calibrate module is automatically loaded if a heater is defined
-in the config file.
-
-#### PID_CALIBRATE
-`PID_CALIBRATE HEATER=<config_name> TARGET=<temperature>
-[WRITE_FILE=1]`: Perform a PID calibration test. The specified heater
-will be enabled until the specified target temperature is reached, and
-then the heater will be turned off and on for several cycles. If the
-WRITE_FILE parameter is enabled, then the file /tmp/heattest.txt will
-be created with a log of all temperature samples taken during the
-test.
-
 ### [pause_resume]
 
 The following commands are available when the
@@ -980,6 +1124,20 @@ the paused state is fresh for each print.
 #### CANCEL_PRINT
 `CANCEL_PRINT`: Cancels the current print.
 
+### [pid_calibrate]
+
+The pid_calibrate module is automatically loaded if a heater is defined
+in the config file.
+
+#### PID_CALIBRATE
+`PID_CALIBRATE HEATER=<config_name> TARGET=<temperature>
+[WRITE_FILE=1]`: Perform a PID calibration test. The specified heater
+will be enabled until the specified target temperature is reached, and
+then the heater will be turned off and on for several cycles. If the
+WRITE_FILE parameter is enabled, then the file /tmp/heattest.txt will
+be created with a log of all temperature samples taken during the
+test.
+
 ### [print_stats]
 
 The print_stats module is automatically loaded.
@@ -1201,8 +1359,9 @@ has been enabled.
 
 #### SAVE_VARIABLE
 `SAVE_VARIABLE VARIABLE=<name> VALUE=<value>`: Saves the variable to
-disk so that it can be used across restarts. All stored variables are
-loaded into the `printer.save_variables.variables` dict at startup and
+disk so that it can be used across restarts. The VARIABLE must be lowercase.
+All stored variables are loaded into the
+`printer.save_variables.variables` dict at startup and
 can be used in gcode macros. The provided VALUE is parsed as a Python
 literal.
 
@@ -1346,6 +1505,42 @@ temperature_fan. If a target is not supplied, it is set to the
 specified temperature in the config file. If speeds are not supplied,
 no change is applied.
 
+### [temperature_probe]
+
+The following commands are available when a
+[temperature_probe config section](Config_Reference.md#temperature_probe)
+is enabled.
+
+#### TEMPERATURE_PROBE_CALIBRATE
+`TEMPERATURE_PROBE_CALIBRATE [PROBE=<probe name>] [TARGET=<value>] [STEP=<value>]`:
+Initiates probe drift calibration for eddy current based probes.  The `TARGET`
+is a target temperature for the last sample.  When the temperature recorded
+during a sample exceeds the `TARGET` calibration will complete.  The `STEP`
+parameter sets temperature delta (in C) between samples. After a sample has
+been taken, this delta is used to schedule a call to `TEMPERATURE_PROBE_NEXT`.
+The default `STEP` is 2.
+
+#### TEMPERATURE_PROBE_NEXT
+`TEMPERATURE_PROBE_NEXT`: After calibration has started this command is run to
+take the next sample.  It is automatically scheduled to run when the delta
+specified by `STEP` has been reached, however its also possible to manually run
+this command to force a new sample.  This command is only available during
+calibration.
+
+#### TEMPERATURE_PROBE_COMPLETE:
+`TEMPERATURE_PROBE_COMPLETE`:  Can be used to end calibration and save the
+current result before the `TARGET` temperature is reached.  This command
+is only available during calibration.
+
+#### ABORT
+`ABORT`:  Aborts the calibration process, discarding the current results.
+This command is only available during drift calibration.
+
+### TEMPERATURE_PROBE_ENABLE
+`TEMPERATURE_PROBE_ENABLE ENABLE=[0|1]`: Sets temperature drift
+compensation on or off. If ENABLE is set to 0, drift compensation
+will be disabled, if set to 1 it is enabled.
+
 ### [tmcXXXX]
 
 The following commands are available when any of the
@@ -1481,39 +1676,3 @@ independent adjustments to each Z stepper to compensate for tilt. See
 the PROBE command for details on the optional probe parameters. The
 optional `RETRIES`, `RETRY_TOLERANCE`, and `HORIZONTAL_MOVE_Z` values
 override those options specified in the config file.
-
-### [temperature_probe]
-
-The following commands are available when a
-[temperature_probe config section](Config_Reference.md#temperature_probe)
-is enabled.
-
-#### TEMPERATURE_PROBE_CALIBRATE
-`TEMPERATURE_PROBE_CALIBRATE [PROBE=<probe name>] [TARGET=<value>] [STEP=<value>]`:
-Initiates probe drift calibration for eddy current based probes.  The `TARGET`
-is a target temperature for the last sample.  When the temperature recorded
-during a sample exceeds the `TARGET` calibration will complete.  The `STEP`
-parameter sets temperature delta (in C) between samples. After a sample has
-been taken, this delta is used to schedule a call to `TEMPERATURE_PROBE_NEXT`.
-The default `STEP` is 2.
-
-#### TEMPERATURE_PROBE_NEXT
-`TEMPERATURE_PROBE_NEXT`: After calibration has started this command is run to
-take the next sample.  It is automatically scheduled to run when the delta
-specified by `STEP` has been reached, however its also possible to manually run
-this command to force a new sample.  This command is only available during
-calibration.
-
-#### TEMPERATURE_PROBE_COMPLETE:
-`TEMPERATURE_PROBE_COMPLETE`:  Can be used to end calibration and save the
-current result before the `TARGET` temperature is reached.  This command
-is only available during calibration.
-
-#### ABORT
-`ABORT`:  Aborts the calibration process, discarding the current results.
-This command is only available during drift calibration.
-
-### TEMPERATURE_PROBE_ENABLE
-`TEMPERATURE_PROBE_ENABLE ENABLE=[0|1]`: Sets temperature drift
-compensation on or off. If ENABLE is set to 0, drift compensation
-will be disabled, if set to 1 it is enabled.

docs/Installation.md

@@ -1,14 +1,14 @@
 # Installation
 
-These instructions assume the software will run on a linux based host
-running a Klipper compatible front end. It is recommended that a
-SBC(Small Board Computer) such as a Raspberry Pi or Debian based Linux
+These instructions assume the software will run on a Linux-based host
+running a Klipper-compatible front end. It is recommended that a
+SBC(Small Board Computer) such as a Raspberry Pi or Debian-based Linux
 device be used as the host machine (see the
 [FAQ](FAQ.md#can-i-run-klipper-on-something-other-than-a-raspberry-pi-3)
 for other options).
 
-For the purposes of these instructions host relates to the Linux device and
-mcu relates to the printboard. SBC relates to the term Small Board Computer
+For the purposes of these instructions, host relates to the Linux device and
+mcu relates to the printer board. SBC relates to the term Small Board Computer
 such as the Raspberry Pi.
 
 ## Obtain a Klipper Configuration File
@@ -56,13 +56,13 @@ make an informed decision.
 ## Obtaining an OS image for SBC's
 
 There are many ways to obtain an OS image for Klipper for SBC use, most depend on
-what front end you wish to use. Some manafactures of these SBC boards also provide
+what front end you wish to use. Some manufacturers of these SBC boards also provide
 their own Klipper-centric images.
 
-The two main Moonraker based front ends are [Fluidd](https://docs.fluidd.xyz/)
+The two main Moonraker-based front ends are [Fluidd](https://docs.fluidd.xyz/)
 and [Mainsail](https://docs.mainsail.xyz/), the latter of which has a premade install
-image ["MainsailOS"](http://docs.mainsailOS.xyz), this has the option for Raspberry Pi
-and some OrangePi varianta.
+image ["MainsailOS"](https://docs-os.mainsail.xyz/), this has the option for Raspberry Pi
+and some OrangePi variants.
 
 Fluidd can be installed via KIAUH(Klipper Install And Update Helper), which
 is explained below and is a 3rd party installer for all things Klipper.
@@ -73,12 +73,12 @@ process is explained in [OctoPrint.md](OctoPrint.md)
 ## Installing via KIAUH
 
 Normally you would start with a base image for your SBC, RPiOS Lite for example,
-or in the case of a x86 Linux device, Ubuntu Server. Please note that Desktop
+or in the case of an x86 Linux device, Ubuntu Server. Please note that Desktop
 variants are not recommended due to certain helper programs that can stop some
-Klipper functions working and even mask access to some print boards.
+Klipper functions from working and even mask access to some printer boards.
 
 KIAUH can be used to install Klipper and its associated programs on a variety
-of Linux based systems that run a form of Debian. More information can be found
+of Linux-based systems that run a form of Debian. More information can be found
 at https://github.com/dw-0/kiauh
 
 ## Building and flashing the micro-controller
@@ -106,7 +106,7 @@ make
 If the comments at the top of the
 [printer configuration file](#obtain-a-klipper-configuration-file)
 describe custom steps for "flashing" the final image to the printer
-control board then follow those steps and then proceed to
+control board, then follow those steps and then proceed to
 [configuring OctoPrint](#configuring-octoprint-to-use-klipper).
 
 Otherwise, the following steps are often used to "flash" the printer
@@ -132,12 +132,31 @@ run the command again, the missing item will be your print board(see the
 [FAQ](FAQ.md#wheres-my-serial-port) for more information).
 
 For common micro-controllers with STM32 or clone chips, LPC chips and
-others it is usual that these need an initial Klipper flash via SD card.
+others, it is usual that these need an initial Klipper flash via SD card.
 
 When flashing with this method, it is important to make sure that the
 print board is not connected with USB to the host, due to some boards
 being able to feed power back to the board and stopping a flash from
-occuring.
+occurring.
+
+Please note, that most print boards that use SD cards for flash will
+implement some kind of flash loop protection for when the sd card is left
+in place. There are two common methods:
+
+Filename Change Required (usually "stock" print boards):
+
+These boards require the firmware file to have a different name each
+time you flash (for example, firmware1.bin, firmware2.bin, etc.).
+If you reuse the same filename, the board may ignore it and not update.
+
+Automatic File Renaming (usually aftermarket print boards:
+
+Other boards allow using the same filename, commonly firmware.bin,
+but after flashing, the board renames the file to firmware.cur.
+This helps indicate the firmware was successfully flashed and prevents
+it from flashing again on the next startup.
+
+Before flashing, make sure to check which behavior your board follows.
 
 For common micro-controllers using Atmega chips, for example the 2560,
 the code can be flashed with something
@@ -172,7 +191,7 @@ The next step is to copy the
 the host.
 
 Arguably the easiest way to set the Klipper configuration file is using the
-built in editors in Mainsail or Fluidd. These will allow the user to open
+built-in editors in Mainsail or Fluidd. These will allow the user to open
 the configuration examples and save them to be printer.cfg.
 
 Another option is to use a desktop editor that supports editing files
@@ -183,7 +202,7 @@ named "printer.cfg" in the home directory of the pi user
 (ie, /home/pi/printer.cfg).
 
 Alternatively, one can also copy and edit the file directly on the
-host via ssh. That may look something like the following (be
+host via SSH. That may look something like the following (be
 sure to update the command to use the appropriate printer config
 filename):
 
@@ -214,9 +233,9 @@ the `[mcu]` section to look something similar to:
 serial: /dev/serial/by-id/usb-1a86_USB2.0-Serial-if00-port0
 ```
 
-After creating and editing the file it will be necessary to issue a
+After creating and editing the file, it will be necessary to issue a
 "restart" command in the command console to load the config. A
-"status" command will report the printer is ready if the Klipper
+"status" command will report that the printer is ready if the Klipper
 config file is successfully read and the micro-controller is
 successfully found and configured.
 
@@ -225,10 +244,10 @@ Klipper to report a configuration error. If an error occurs, make any
 necessary corrections to the printer config file and issue "restart"
 until "status" reports the printer is ready.
 
-Klipper reports error messages via the command console and via pop up in
+Klipper reports error messages via the command console and pop-ups in
 Fluidd and Mainsail. The "status" command can be used to re-report error
-messages. A log is available and usually located in ~/printer_data/logs
-this is named klippy.log
+messages. A log is available and usually located at
+`~/printer_data/logs/klippy.log`.
 
 After Klipper reports that the printer is ready, proceed to the
 [config check document](Config_checks.md) to perform some basic checks

docs/Load_Cell.md

@@ -0,0 +1,489 @@
+# Load Cells
+
+This document describes Klipper's support for load cells. Basic load cell
+functionality can be used to read force data and to weigh things like filament.
+A calibrated force sensor is an important part of a load cell based probe.
+
+## Related Documentation
+
+* [load_cell Config Reference](Config_Reference.md#load_cell)
+* [load_cell G-Code Commands](G-Codes.md#load_cell)
+* [load_cell Status Reference](Status_Reference.md#load_cell)
+
+## Using `LOAD_CELL_DIAGNOSTIC`
+
+When you first connect a load cell its good practice to check for issues by
+running `LOAD_CELL_DIAGNOSTIC`. This tool collects 10 seconds of data from the
+load cell and resport statistics:
+
+```
+$ LOAD_CELL_DIAGNOSTIC
+// Collecting load cell data for 10 seconds...
+// Samples Collected: 3211
+// Measured samples per second: 332.0
+// Good samples: 3211, Saturated samples: 0, Unique values: 900
+// Sample range: [4.01% to 4.02%]
+// Sample range / sensor capacity: 0.00524%
+```
+
+Things you can check with this data:
+
+* The configured sample rate of the sensor should be close to the 'Measured
+  samples per second' value. If it is not you may have a configuration or wiring
+  issue.
+* 'Saturated samples' should be 0. If you have saturated samples it means the
+  load sell is seeing more force than it can measure.
+* 'Unique values' should be a large percentage of the 'Samples
+  Collected' value. If 'Unique values' is 1 it is very likely a wiring issue.
+* Tap or push on the sensor while `LOAD_CELL_DIAGNOSTIC` runs. If
+  things are working correctly this should increase the 'Sample range'.
+
+## Calibrating a Load Cell
+
+Load cells are calibrated using the `LOAD_CELL_CALIBRATE` command. This is an
+interactive calibration utility that walks you though a 3 step process:
+
+1. First use the `TARE` command to establish the zero force value. This is the
+   `reference_tare_counts` config value.
+2. Next you apply a known load or force to the load cell and run the
+   `CALIBRATE GRAMS=nnn` command. From this the `counts_per_gram` value is
+   calculated. See [the next section](#applying-a-known-force-or-load) for some
+   suggestions on how to do this.
+3. Finally, use the `ACCEPT` command to save the results.
+
+You can cancel the calibration process at any time with `ABORT`.
+
+### Applying a Known Force or Load
+
+The `CALIBRATE GRAMS=nnn` step can be accomplished in a number of ways. If your
+load cell is under a platform like a bed or filament holder it might be easiest
+to put a known mass on the platform. E.g. you could use a couple of 1KG filament
+spools.
+
+If your load cell is in the printer's toolhead a different approach is easier.
+Put a digital scale on the printers bed and gently lower the toolhead onto the
+scale (or raise the bed into the toolhead if your bed moves). You may be able to
+do this using the `FORCE_MOVE` command. But more likely you will have to
+manually moving the z axis with the motors off until the toolhead presses on the
+scale.
+
+A good calibration force would ideally be a large percentage of the load cell's
+rated capacity. E.g. if you have a 5Kg load cell you would ideally calibrate it
+with a 5kg mass. This might work well with under-bed sensors that have to
+support a lot of weight. For toolhead probes this may not be a load that your
+printer bed or toolhead can tolerate without damage. Do try to use at least 1Kg
+of force, most printers should tolerate this without issue.
+
+When calibrating make careful note of the values reported:
+
+```
+$ CALIBRATE GRAMS=555
+// Calibration value: -2.78% (-59803108), Counts/gram: 73039.78739,
+Total capacity: +/- 29.14Kg
+```
+
+The `Total capacity` should be close to the theoretical rating of the load cell
+based on the sensor's capacity. If it is much larger you could have used a
+higher gain setting in the sensor or a more sensitive load cell. This isn't as
+critical for 32bit and 24bit sensors but is much more critical for low bit width
+sensors.
+
+## Reading Force Data
+Force data can be read with a GCode command:
+
+```
+LOAD_CELL_READ
+// 10.6g (1.94%)
+```
+
+Data is also continuously read and can be consumed from the load_cell printer
+object in a macro:
+
+```
+{% set grams = printer.load_cell.force_g %}
+```
+
+This provides an average force over the last 1 second, similar to how
+temperature sensors work.
+
+## Taring a Load Cell
+Taring, sometimes called zeroing, sets the current weight reported by the
+load_cell to 0. This is useful for measuring relative to a known weight. e.g.
+when measuring a filament spool, using `LOAD_CELL_TARE` sets the weight to 0.
+Then as filament is printed the load_cell will report the weight of the
+filament used.
+
+```
+LOAD_CELL_TARE
+// Load cell tare value: 5.32% (445903)
+```
+
+The current tare value is reported in the printers status and can be read in
+a macro:
+
+```
+{% set tare_counts = printer.load_cell.tare_counts %}
+```
+
+# Load Cell Probes
+
+## Related Documentation
+
+* [load_cell_probe Config Reference](Config_Reference.md#load_cell_probe)
+* [load_cell_probe G-Code Commands](G-Codes.md#load_cell_probe)
+* [load_cell_probe Statuc Reference](Status_Reference.md#load_cell_probe)
+
+## Load Cell Probe Safety
+
+Because load cells are a direct nozzle contact probe there is a risk of
+damage to your printer if too much force is used. The load cell probing system
+includes a number of safety checks that try to keep your machine safe from
+excessive force to the toolhead. It's important to understand what they are
+and how they work as you can defeat most of them with poorly chosen config
+values.
+
+#### Calibration Check
+Every time a homing move starts, load_cell_probe checks
+that the load_cell is calibrated. If not it will stop the move with an error:
+`!! Load Cell not calibrated`.
+
+#### `counts_per_gram`
+This setting is used to convert raw sensor counts into grams. All the safety
+limits are in gram units for your convenience. If the `counts_per_gram`
+setting is not accurate you can easily exceed the safe force on the toolhead.
+You should never guess this value. Use `LOAD_CELL_CALIBRATE` to find your load
+cells actual `counts_per_gram`.
+
+#### `trigger_force`
+This is the force in grams that triggers the endstop to halt the homing move.
+When a homing move starts the endstop tares itself with the current reading
+from the load cell. `trigger_force` is measured from that tare value. There is
+always some overshoot of this value when the probe collides with the bed,
+so be conservative. e.g. a setting of 100g could result in 350g of peak force
+before the toolhead stops. This overshoot will increase with faster probing
+`speed`, a low ADC sample rate or [multi MCU homing](Multi_MCU_Homing.md).
+
+#### `reference_tare_counts`
+This is the baseline tare value that is set by `LOAD_CELL_CALIBRATE`.
+This value works with `force_safety_limit` to limit the maximum force on the
+toolhead.
+
+#### `force_safety_limit`
+This is the maximum absolute force, relative to `reference_tare_counts`,
+that the probe will allow while homing or probing. If the MCU sees this
+force exceeded it will shut down the printer with the error `!! Load cell
+endstop: too much force!`. There are a number of ways this can be triggered:
+
+The first risk this protects against is picking too large of a value for
+`drift_filter_cutoff_frequency`. This can cause the drift filter to filter out
+a probe event and continue the homing move. If this happens the
+`force_safety_limit` acts as a backup protection.
+
+The second problem is probing repeatedly in one place. Klipper does not retract
+the probe when doing a single `PROBE` command. This can result
+in force applied to the toolhead at the end of a probing cycle. Because
+external forces can vary greatly between probing locations,
+`load_cell_probe` performs a tare before beginning each probe. If you repeat
+the `PROBE` command, load_cell_probe will tare the endstop at the current force.
+Multiple cycles of this will result in ever-increasing force on the toolhead.
+`force_safety_limit` stops this cycle from running out of control.
+
+Another way this run-away can happen is damage to a strain gauge. If the metal
+part is permanently bent it will change the `reference_tare_counts` of the
+device. This puts the starting tare value much closer to the limit making it
+more likely to be violated. You want to be notified if this is happening
+because your hardware has been permanently damaged.
+
+The final way this can be triggered is due to temperature changes. If your
+strain gauges are heated their `reference_tare_counts` may be very different
+at ambient temperature vs operating temperature. In this case you may need
+to increase the `force_safety_limit` to allow for thermal changes.
+
+#### Load Cell Endstop Watchdog Task
+When homing the load_cell_endstop starts a task on the MCU to trac
+measurements arriving from the sensor. If the sensor fails to send
+measurements for 2 sample periods the watchdog will shut down the printer
+with an error `!! LoadCell Endstop timed out waiting on ADC data`.
+
+If this happens, the most likely cause is a fault from the ADC. Inadequate
+grounding of your printer can be the root cause. The frame, power supply
+case and pint bed should all be connected to ground. You may need to ground
+the frame in multiple places. Anodized aluminum extrusions do not conduct
+electricity well. You might need to sand the area where the grounding wire
+is attached to make good electrical contact.
+
+## Load Cell Probe Setup
+
+This section covers the process for commissioning a load cell probe.
+
+### Verify the Load Cell First
+
+A `[load_cell_probe]` is also a `[load_cell]` and G-code commands related to
+`[load_cell]` work with `[load_cell_probe]`. Before attempting to use a load
+cell probe, follow the directions for
+[calibrating the load cell](Load_Cell.md#calibrating-a-load-cell) with
+`CALIBRATE_LOAD_CELL` and checking its operation with `LOAD_CELL_DIAGNOSTIC`.
+
+### Verify Probe Operation With LOAD_CELL_TEST_TAP
+
+Use the command `LOAD_CELL_TEST_TAP` to test the operation of the load cell
+probe before actually trying to probe with it. This command detects taps,
+just like the PROBE command, but it does not move the z axis. By default, it
+listens for 3 taps before ending the test. You have 30 seconds to do each
+tap, if no taps are detected the command will time out.
+
+If this test fails, check your configuration and `LOAD_CELL_DIAGNOSTIC`
+carefully to look for issues.
+
+Load cell probes don't support the `QUERY_ENDSTOPS` or `QUERY_PROBE`
+commands. Use `LOAD_CELL_TEST_TAP` for testing functionality before probing.
+
+### Homing Macros
+
+Load cell probe is not an endstop and doesn't support `endstop:
+prove:z_virtual_endstop`. For the time being you'll need to configure your z
+axis with an MCU pin as its endstop. You won't actually be using the pin but
+for the time being you have to configure something.
+
+To home the axis with just the probe you need to set up a custom homing
+macro. This requires setting up
+[homing_override](Config_Reference.md#homing_override).
+
+Here is a simple macro that can accomplish this. Note that the
+`_HOME_Z_FROM_LAST_PROBE` macro has to be separate because of the way macros
+work. The sub-call is needed so that the `_HOME_Z_FROM_LAST_PROBE` macro can
+see the result of the probe in `printer.probe.last_z_result`.
+
+```gcode
+[gcode_macro _HOME_Z_FROM_LAST_PROBE]
+gcode:
+    {% set z_probed = printer.probe.last_z_result %}
+    {% set z_position = printer.toolhead.position[2] %}
+    {% set z_actual = z_position - z_probed %}
+    SET_KINEMATIC_POSITION Z={z_actual}
+
+[gcode_macro _HOME_Z]
+gcode:
+    SET_GCODE_OFFSET Z=0  # load cell probes dont need a Z offset
+    # position toolhead for homing Z, edit for your printers size
+    #G90  # absolute move
+    #G1 Y50 X50 F{5 * 60}  # move to X/Y position for homing
+
+    # soft home the z axis to its limit so it can be moved:
+    SET_KINEMATIC_POSITION Z={printer.toolhead.axis_maximum[2]}
+
+    # Fast approach and tap
+    PROBE PROBE_SPEED={5 * 60}  # override the speed for faster homing
+    _HOME_Z_FROM_LAST_PROBE
+
+    # lift z to 2mm
+    G91  # relative move
+    G1 Z2 F{5 * 60}
+
+    # probe at standard speed
+    PROBE
+    _HOME_Z_FROM_LAST_PROBE
+
+    # lift z to 10mm for clearance
+    G91  # relative move
+    G1 Z10 F{5 * 60}
+```
+
+### Suggested Probing Temperature
+
+Currently, we suggest keeping the nozzle temperature below the level that causes
+the filament to ooze while homing and probing. 140C is a good starting
+point. This temperature is also low enough not to scar PEI build surfaces.
+
+Fouling of the nozzle and the print bed due to oozing filament is the #1 source
+of probing error with the load cell probe. Klipper does not yet have a universal
+way to detect poor quality taps due to filament ooze. The existing code may
+decide that a tap is valid when it is of poor quality. Classifying these poor
+quality taps is an area of active research.
+
+Klipper also lacks support for re-locating a probe point if the
+location has become fouled by filament ooze. Modules like `quad_gantry_level`
+will repeatedly probe the same coordinates even if a probe previously failed
+there.
+
+Give the above it is strongly suggested not to probe at printing temperatures.
+
+### Hot Nozzle Protection
+
+The Voron project has a great macro for protecting your print surface from the
+hot nozzle. See [Voron Tap's
+`activate_gcode`](https://github.com/VoronDesign/Voron-Tap/blob/main/config/tap_klipper_instructions.md)
+
+It is highly suggested to add something like this to your config.
+
+### Nozzle Cleaning
+
+Before probing the nozzle should be clean. You could do this manually before
+every print. You can also implement a nozzle scrubber and automate the process.
+Here is a suggested sequence:
+
+1. Wait for the nozzle to heat up to probing temp (e.g. `M109 S140`)
+1. Home the machine (`G28`)
+1. Scrub the nozzle on a brush
+1. Heat soak the print bed
+1. Perform probing tasks: QGL, bed mesh etc.
+
+### Temperature Compensation for Nozzle Growth
+
+If you are probing at a safe temperature, the nozzle will expand after
+heating to printing temperatures. This will cause the nozzle to get longer
+and closer to the print surface. You can compensate for this with
+[[z_thermal_adjust]](Config_Reference.md#z_thermal_adjust). This adjustment will
+work across a range of printing
+temperatures from PLA to PC.
+
+#### Calculating the `temp_coeff` for `[z_thermal_adjust]`
+
+The easiest way to do this is to measure at 2 different temperatures.
+Ideally these should be the upper and lower limits of the printing
+temperature range. E.g. 180C and 290C. You can perform a `PROBE_ACCURACY` at
+both temperatures and then calculate the difference of the `average z` at both.
+
+The adjustment value is the change in nozzle length divided by the change in
+temperature. e.g.
+
+```
+temp_coeff = -0.05 / (290 - 180) = -0.00045455
+```
+
+The expected result is a negative number. Positive values for `temp_coeff` move
+the nozzle closer to the bed and negative values move it further away.
+Expect to have to move the nozzle further away as it gets longer when hot.
+
+#### Configure `[z_thermal_adjust]`
+Set up z_thermal_adjust to reference the `extruder` as the source of temperature
+data. E.g.:
+
+```
+[z_thermal_adjust nozzle]
+temp_coeff=-0.00045455
+sensor_type: temperature_combined
+sensor_list: extruder
+combination_method: max
+min_temp: 0
+max_temp: 400
+max_z_adjustment: 0.1
+```
+
+## Continuous Tare Filters for Toolhead Load Cells
+
+Klipper implements a configurable IIR filter on the MCU to provide continuous
+tareing of the load cell while probing. Continuous taring means the 0 value
+moves with drift caused by external factors like bowden tubes and thermal
+changes. This is aimed at toolhead sensors and moving beds that experience lots
+of external forces that change while probing.
+
+### Installing SciPy
+
+The filtering code uses the excellent [SciPy](https://scipy.org/) library to
+compute the filter coefficients based on the values your enter into the config.
+
+Pre-compiled SciPi builds are available for Python 3 on 32 bit Raspberry Pi
+systems. 32 bit + Python 3 is strongly recommended because it will streamline
+your installation experience. It does work with Python 2 but installation can
+take 30+ minutes and require installing additional tools.
+
+```bash
+~/klippy-env/bin/pip install scipy
+```
+
+### Filter Workbench
+
+The filter parameters should be selected based on drift seen on the printer
+during normal operation. A Jupyter notebook is provided in scripts,
+[filter_workbench.ipynb](../scripts/filter_workbench.ipynb), to perform a
+detailed investigation with real captured data and FFTs.
+
+### Filtering Suggestions
+
+For those just trying to get a filter working follow these suggestions:
+
+* The only essential option is `drift_filter_cutoff_frequency`. A conservative
+  starting value is `0.5`Hz. Prusa shipped the MK4 with a setting of `0.8`Hz and
+  the XL with `11.2`Hz. This is probably a safe range to experiment with. This
+  value should be increased only until normal drift due to bowden tube force is
+  eliminated. Setting this value too high will result in slow triggering and
+  excess force going through the toolhead.
+* Keep `trigger_force` low. The default is `75`g. The drift filter keeps the
+  internal grams value very close to 0 so a large trigger force is not needed.
+* Keep `force_safety_limit` to a conservative value. The default value is 2Kg
+  and should keep your toolhead safe while experimenting. If you hit this limit
+  the `drift_filter_cutoff_frequency` value may be too high.
+
+## Suggestions for Load Cell Tool Boards
+
+This section covers suggestions for those developing toolhead boards that want
+to support [load_cell_probe]
+
+### ADC Sensor Selection & Board Development Hints
+
+Ideally a sensor would meet these criteria:
+
+* At least 24 bits wide
+* Use SPI communications
+* Has a pin can be used to indicate sample ready without SPI communications.
+  This is often called the "data ready" or "DRDY" pin. Checking a pin is much
+  faster than running an SPI query.
+* Has a programmable gain amplifier gain setting of 128. This should eliminate
+  the need for a separate amplifier.
+* Indicates via SPI if the sensor has been reset. Detecting resets avoids
+  timing errors in homing and using noisy data at startup. It can also help
+  users
+  track down wiring and grounding issues.
+* A selectable sample rate between 350Hz and 2Khz. Very high sample rates don't
+  turn out to be beneficial in our 3D printers because they produce so much
+  noise
+  when moving fast. Sample rates below 250Hz will require slower probing speeds.
+  They also increase the force on the toolhead due to longer delays between
+  measurements. E.g. a 500Hz sensor moving at 5mm/s has the same safety factor
+  as
+  a 100Hz sensor moving at only 1mm/s.
+* If designing for under-bed applications, and you want to sense multiple load
+  cells, use a chip that can sample all of its inputs simultaneously. Multiplex
+  ADCs that require switching channels have a settling of several samples after
+  each channel switch making them unsuitable for probing applications.
+
+Implementing support for a new sensor chip is not particularly difficult with
+Klipper's `bulk_sensor` and `load_cell_endstop` infrastructure.
+
+### 5V Power Filtering
+
+It is strongly suggested to use larger capacitors than specified by the ADC chip
+manufacturer. ADC chips are usually targeted at low noise environments, like
+battery powered devices. Sensor manufacturers suggested application notes
+generally assume a quiet power supply. Treat their suggested capacitor values as
+minimums.
+
+3D printers put huge amounts of noise onto the 5V bus and this can ruin the
+sensor's accuracy. Test the sensor on the board with a typical 3D printer power
+supply and active stepper drivers before deciding on smoothing capacitor sizes.
+
+### Grounding & Ground Planes
+
+Analog ADC chips contain components that are very vulnerable to noise and
+ESD. A large ground plane on the first board layer under the chip can help with
+noise. Keep the chip away from power sections and DC to DC converters. The board
+should have proper grounding back to the DC supply.
+
+### HX711 and HX717 Notes
+
+This sensor is popular because of its low cost and availability in the
+supply chain. However, this is a sensor with some drawbacks:
+
+* The HX71x sensors use bit-bang communication which has a high overhead on the
+  MCU. Using a sensor that communicates via SPI would save resources on the tool
+  board's CPU.
+* The HX71x lacks a way to communicate reset events to the MCU. Klipper detects
+  resets with a timing heuristic but this is not ideal. Resets indicate a
+  problem with wiring or grounding.
+* For probing applications the HX717 version is strongly preferred because
+  of its higher sample rate (320 vs 80). Probing speed on the HX711 should be
+  limited to less than 2mm/s.
+* The sample rate on the HX71x cannot be set from klipper's config. If you have
+  the 10SPS version of the sensor (which is widely distributed) it needs to
+  be physically re-wired to run at 80SPS.

docs/Measuring_Resonances.md

@@ -18,9 +18,9 @@ board designs and different clones of them. If it is going to be connected to a
 For ADXL345s, make sure that the board supports SPI mode (a small number of
 boards appear to be hard-configured for I2C by pulling SDO to GND).
 
-For MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500s and LIS2DW/LIS3DH there are also
-a variety of board designs and clones with different I2C pull-up resistors which
-will need supplementing.
+For MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500/ICM20948s and LIS2DW/LIS3DH there
+are also a variety of board designs and clones with different I2C pull-up resistors
+which will need supplementing.
 
 ## MCUs with Klipper I2C *fast-mode* Support
 
@@ -136,7 +136,7 @@ GND+SCL
 
 Note that unlike a cable shield, any GND(s) should be connected at both ends.
 
-#### MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500
+#### MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500/ICM20948
 
 These accelerometers have been tested to work over I2C on the RPi, RP2040 (Pico)
 and AVR at 400kbit/s (*fast mode*). Some MPU accelerometer modules include
@@ -152,7 +152,7 @@ Recommended connection scheme for I2C on the Raspberry Pi:
 | SDA | 03 | GPIO02 (SDA1) |
 | SCL | 05 | GPIO03 (SCL1) |
 
-The RPi has buit-in 1.8K pull-ups on both SCL and SDA.
+The RPi has built-in 1.8K pull-ups on both SCL and SDA.
 
 ![MPU-9250 connected to Pi](img/mpu9250-PI-fritzing.png)
 
@@ -355,6 +355,7 @@ accel_chip: mpu9250
 probe_points:
     100, 100, 20  # an example
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 #### Configure MPU-9520 Compatibles With Pico
 
@@ -377,6 +378,7 @@ probe_points:
 [static_digital_output pico_3V3pwm] # Improve power stability
 pins: pico:gpio23
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 #### Configure MPU-9520 Compatibles with AVR
 
@@ -395,6 +397,7 @@ accel_chip: mpu9250
 probe_points:
     100, 100, 20  # an example
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 Restart Klipper via the `RESTART` command.
 

docs/Overview.md

@@ -101,3 +101,4 @@ communication with the Klipper developers.
 - [TSL1401CL filament width sensor](TSL1401CL_Filament_Width_Sensor.md)
 - [Hall filament width sensor](Hall_Filament_Width_Sensor.md)
 - [Eddy Current Inductive probe](Eddy_Probe.md)
+- [Load Cells](Load_Cell.md)

docs/Pressure_Advance.md

@@ -22,7 +22,7 @@ Use a slicer to generate g-code for the large hollow square found in
 [docs/prints/square_tower.stl](prints/square_tower.stl). Use a high
 speed (eg, 100mm/s), zero infill, and a coarse layer height (the layer
 height should be around 75% of the nozzle diameter). Make sure any
-"dynamic acceleration control" is disabled in the slicer.
+"dynamic acceleration control" and "scarf joint" seams are disabled in the slicer.
 
 Prepare for the test by issuing the following G-Code command:
 ```

docs/Releases.md

@@ -3,6 +3,35 @@
 History of Klipper releases. Please see
 [installation](Installation.md) for information on installing Klipper.
 
+## Klipper 0.13.0
+
+Available on 20250411. Major changes in this release:
+* New "sweeping vibrations" resonance testing mechanism for input
+  shaper.
+* Fans and GPIO pins can now be assigned a formula (via Jinja2
+  "templates").
+* The bed_mesh code now supports "adaptive bed mesh". The area probed
+  can be adjusted for the size of the print.
+* A new `minimum_cruise_ratio` kinematic parameter has been added (it
+  replaces the previous `max_accel_to_decel` parameter).
+* Several new sensors added:
+  * Support for ldc1612 "eddy" current sensors. This includes probing
+    support, fast "scan" probing, and temperature calibration.
+  * New support for "load cell" measurements. Support for connecting
+    these load cells to hx71x and ads1220 ADC sensors.
+  * Support for BMP180, BMP388, and SHT3x temperature sensors. Support
+    for measuring temperature with ADS1x1x ADC chips.
+  * New lis3dh and icm20948 accelerometer support.
+  * Support for mt6816 and mt6826s "hall angle" sensors.
+* New micro-controller improvements:
+  * New support for rp2350 micro-controllers.
+  * Existing rp2040 chips now run at 200MHz (up from 125Mhz).
+  * The micro-controller code can now define many more commands (up to
+    16384 from 128).
+* Other modules added: aip31068_spi, canbus_stats, error_mcu,
+  garbage_collection, pwm_cycle_time, pwm_tool, garbage_collection.
+* Several bug fixes and code cleanups.
+
 ## Klipper 0.12.0
 
 Available on 20231110. Major changes in this release:

docs/Skew_Correction.md

@@ -31,7 +31,7 @@ AD do not include the flats on the corners that some test objects provide.
 ## Configure your skew
 
 Make sure `[skew_correction]` is in printer.cfg.  You may now use the `SET_SKEW`
-gcode to configure skew_correcton.  For example, if your measured lengths
+gcode to configure skew_correction.  For example, if your measured lengths
 along XY are as follows:
 
 ```

docs/Slicers.md

@@ -121,5 +121,5 @@ M104 S0
 before the macro call. Also note that SuperSlicer has a
 "custom gcode only" button option, which achieves the same outcome.
 
-An example of a START_PRINT macro using these paramaters can
+An example of a START_PRINT macro using these parameters can
 be found in config/sample-macros.cfg

docs/Status_Reference.md

@@ -31,7 +31,7 @@ The following information is available in the
 ## bed_screws
 
 The following information is available in the
-`Config_Reference.md#bed_screws` object:
+[bed_screws](Config_Reference.md#bed_screws) object:
 - `is_active`: Returns True if the bed screws adjustment tool is currently
 active.
 - `state`: The bed screws adjustment tool state. It is one of
@@ -39,6 +39,27 @@ the following strings: "adjust", "fine".
 - `current_screw`: The index for the current screw being adjusted.
 - `accepted_screws`: The number of accepted screws.
 
+## canbus_stats
+
+The following information is available in the `canbus_stats
+some_mcu_name` object (this object is automatically available if an
+mcu is configured to use canbus):
+- `rx_error`: The number of receive errors detected by the
+  micro-controller canbus hardware.
+- `tx_error`: The number of transmit errors detected by the
+  micro-controller canbus hardware.
+- `tx_retries`: The number of transmit attempts that were retried due
+  to bus contention or errors.
+- `bus_state`: The status of the interface (typically "active" for a
+  bus in normal operation, "warn" for a bus with recent errors,
+  "passive" for a bus that will no longer transmit canbus error
+  frames, or "off" for a bus that will no longer transmit or receive
+  messages).
+
+Note that only the rp2XXX micro-controllers report a non-zero
+`tx_retries` field and the rp2XXX micro-controllers always report
+`tx_error` as zero and `bus_state` as "active".
+
 ## configfile
 
 The following information is available in the `configfile` object
@@ -221,6 +242,8 @@ The following information is available in the `gcode_move` object
 The following information is available in the
 [hall_filament_width_sensor](Config_Reference.md#hall_filament_width_sensor)
 object:
+- all items from
+  [filament_switch_sensor](Status_Reference.md#filament_switch_sensor)
 - `is_active`: Returns True if the sensor is currently active.
 - `Diameter`: The last reading from the sensor in mm.
 - `Raw`: The last raw ADC reading from the sensor.
@@ -268,6 +291,9 @@ is always available):
 - `printing_time`: The amount of time (in seconds) the printer has
   been in the "Printing" state (as tracked by the idle_timeout
   module).
+- `idle_timeout`: The current 'timeout' (in seconds)
+   to wait for the gcode to be triggered.
+   (as set by [SET_IDLE_TIMEOUT](G-Codes.md#set_idle_timeout))
 
 ## led
 
@@ -277,11 +303,31 @@ The following information is available for each `[led led_name]`,
 - `color_data`: A list of color lists containing the RGBW values for a
   led in the chain. Each value is represented as a float from 0.0 to
   1.0. Each color list contains 4 items (red, green, blue, white) even
-  if the underyling LED supports fewer color channels. For example,
+  if the underlying LED supports fewer color channels. For example,
   the blue value (3rd item in color list) of the second neopixel in a
   chain could be accessed at
   `printer["neopixel <config_name>"].color_data[1][2]`.
 
+## load_cell
+
+The following information is available for each `[load_cell name]`:
+- 'is_calibrated': True/False is the load cell calibrated
+- 'counts_per_gram': The number of raw sensor counts that equals 1 gram of force
+- 'reference_tare_counts': The reference number of raw sensor counts for 0 force
+- 'tare_counts': The current number of raw sensor counts for 0 force
+- 'force_g': The force in grams, averaged over the last polling period.
+- 'min_force_g': The minimum force in grams, over the last polling period.
+- 'max_force_g': The maximum force in grams, over the last polling period.
+
+## load_cell_probe
+
+The following information is available for `[load_cell_probe]`:
+- all items from [load_cell](Status_Reference.md#load_cell)
+- all items from [probe](Status_Reference.md#probe)
+- 'endstop_tare_counts': the load cell probe keeps a tare value independent of
+the load cell. This re-set at the start of each probe.
+- 'last_trigger_time': timestamp of the last homing trigger
+
 ## manual_probe
 
 The following information is available in the
@@ -426,6 +472,12 @@ The following information is available in
 - `printer["servo <config_name>"].value`: The last setting of the PWM
   pin (a value between 0.0 and 1.0) associated with the servo.
 
+## skew_correction.py
+
+The following information is available in the `skew_correction` object (this
+object is available if any skew_correction is defined):
+- `current_profile_name`: Returns the name of the currently loaded SKEW_PROFILE.
+
 ## stepper_enable
 
 The following information is available in the `stepper_enable` object (this
@@ -530,6 +582,12 @@ on a cartesian, hybrid_corexy or hybrid_corexz robot
 - `carriage_1`: The mode of the carriage 1. Possible values are:
   "INACTIVE", "PRIMARY", "COPY", and "MIRROR".
 
+On a `generic_cartesian` kinematic, the following information is
+available in `dual_carriage`:
+- `carriages["<carriage>"]`: The mode of the carriage `<carriage>`. Possible
+  values are "INACTIVE" and "PRIMARY" for the primary carriage and "INACTIVE",
+  "PRIMARY", "COPY", and "MIRROR" for the dual carriage.
+
 ## virtual_sdcard
 
 The following information is available in the

docs/TMC_Drivers.md

@@ -83,6 +83,10 @@ setting `stealthchop_threshold` to 999999). Unfortunately, the drivers
 often produce poor and confusing results if the mode changes while the
 motor is at a non-zero velocity.
 
+Note that the `stealthchop_threshold` config option does not impact
+sensorless homing as Klipper automatically switches the TMC driver to
+an appropriate mode during sensorless homing operations.
+
 ## TMC interpolate setting introduces small position deviation
 
 The TMC driver `interpolate` setting may reduce the audible noise of

docs/_klipper3d/README

@@ -8,13 +8,13 @@ directory, the docs/CNAME file also controls the website generation.
 To test deploy the main English site locally one can use commands
 similar to the following:
 
-virtualenv ~/mkdocs-env && ~/python-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
+virtualenv ~/mkdocs-env && ~/mkdocs-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
 cd ~/klipper && ~/mkdocs-env/bin/mkdocs serve --config-file ~/klipper/docs/_klipper3d/mkdocs.yml -a 0.0.0.0:8000
 
 To test deploy the multi-language site locally one can use commands
 similar to the following:
 
-virtualenv ~/mkdocs-env && ~/python-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
+virtualenv ~/mkdocs-env && ~/mkdocs-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
 source ~/mkdocs-env/bin/activate
 cd ~/klipper && ./docs/_klipper3d/build-translations.sh
 cd ~/klipper/site/ && python3 -m http.server 8000

docs/_klipper3d/mkdocs-requirements.txt

@@ -1,5 +1,5 @@
 # Python virtualenv module requirements for mkdocs
-jinja2==3.1.4
+jinja2==3.1.6
 mkdocs==1.2.4
 mkdocs-material==8.1.3
 mkdocs-simple-hooks==0.1.3

docs/_klipper3d/mkdocs.yml

@@ -141,4 +141,5 @@ nav:
     - TSL1401CL_Filament_Width_Sensor.md
     - Hall_Filament_Width_Sensor.md
     - Eddy_Probe.md
+    - Load_Cell.md
   - Sponsors.md

docs/index.md

@@ -8,14 +8,12 @@ title: Welcome
 
 The Klipper firmware controls 3d-Printers. It combines the power of a
 general purpose computer with one or more micro-controllers. See the
-[features document](https://www.klipper3d.org/Features.html) for more
-information on why you should use the Klipper software.
+[features document](Features.md) for more information on why you
+should use the Klipper software.
 
-Start by [installing Klipper software](https://www.klipper3d.org/Installation.html).
+Start by [installing Klipper software](Installation.md).
 
 Klipper software is Free Software. Read the
-[documentation](https://www.klipper3d.org/Overview.html), see the
-[license](COPYING), or
+[documentation](Overview.md), see the [license](../COPYING), or
 [download](https://github.com/Klipper3d/Klipper) the software. We
-depend on the generous support from our
-[sponsors](https://www.klipper3d.org/Sponsors.html).
+depend on the generous support from our [sponsors](Sponsors.md).

klippy/chelper/__init__.py

@@ -17,16 +17,16 @@ COMPILE_ARGS = ("-Wall -g -O2 -shared -fPIC"
                 " -o %s %s")
 SSE_FLAGS = "-mfpmath=sse -msse2"
 SOURCE_FILES = [
-    'pyhelper.c', 'serialqueue.c', 'stepcompress.c', 'itersolve.c', 'trapq.c',
-    'pollreactor.c', 'msgblock.c', 'trdispatch.c',
+    'pyhelper.c', 'serialqueue.c', 'stepcompress.c', 'steppersync.c',
+    'itersolve.c', 'trapq.c', 'pollreactor.c', 'msgblock.c', 'trdispatch.c',
     'kin_cartesian.c', 'kin_corexy.c', 'kin_corexz.c', 'kin_delta.c',
     'kin_deltesian.c', 'kin_polar.c', 'kin_rotary_delta.c', 'kin_winch.c',
-    'kin_extruder.c', 'kin_shaper.c', 'kin_idex.c',
+    'kin_extruder.c', 'kin_shaper.c', 'kin_idex.c', 'kin_generic.c'
 ]
 DEST_LIB = "c_helper.so"
 OTHER_FILES = [
-    'list.h', 'serialqueue.h', 'stepcompress.h', 'itersolve.h', 'pyhelper.h',
-    'trapq.h', 'pollreactor.h', 'msgblock.h'
+    'list.h', 'serialqueue.h', 'stepcompress.h', 'steppersync.h',
+    'itersolve.h', 'pyhelper.h', 'trapq.h', 'pollreactor.h', 'msgblock.h'
 ]
 
 defs_stepcompress = """
@@ -54,25 +54,28 @@ defs_stepcompress = """
     int stepcompress_extract_old(struct stepcompress *sc
         , struct pull_history_steps *p, int max
         , uint64_t start_clock, uint64_t end_clock);
+    void stepcompress_set_stepper_kinematics(struct stepcompress *sc
+        , struct stepper_kinematics *sk);
+"""
 
+defs_steppersync = """
     struct steppersync *steppersync_alloc(struct serialqueue *sq
         , struct stepcompress **sc_list, int sc_num, int move_num);
     void steppersync_free(struct steppersync *ss);
     void steppersync_set_time(struct steppersync *ss
         , double time_offset, double mcu_freq);
-    int steppersync_flush(struct steppersync *ss, uint64_t move_clock
-        , uint64_t clear_history_clock);
+    int32_t steppersync_generate_steps(struct steppersync *ss
+        , double gen_steps_time, uint64_t flush_clock);
+    void steppersync_history_expire(struct steppersync *ss, uint64_t end_clock);
+    int steppersync_flush(struct steppersync *ss, uint64_t move_clock);
 """
 
 defs_itersolve = """
-    int32_t itersolve_generate_steps(struct stepper_kinematics *sk
-        , double flush_time);
     double itersolve_check_active(struct stepper_kinematics *sk
         , double flush_time);
     int32_t itersolve_is_active_axis(struct stepper_kinematics *sk, char axis);
-    void itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq);
-    void itersolve_set_stepcompress(struct stepper_kinematics *sk
-        , struct stepcompress *sc, double step_dist);
+    void itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq
+        , double step_dist);
     double itersolve_calc_position_from_coord(struct stepper_kinematics *sk
         , double x, double y, double z);
     void itersolve_set_position(struct stepper_kinematics *sk
@@ -106,6 +109,12 @@ defs_trapq = """
 defs_kin_cartesian = """
     struct stepper_kinematics *cartesian_stepper_alloc(char axis);
 """
+defs_kin_generic_cartesian = """
+    struct stepper_kinematics *generic_cartesian_stepper_alloc(double a_x
+        , double a_y, double a_z);
+    void generic_cartesian_stepper_set_coeffs(struct stepper_kinematics *sk
+        , double a_x, double a_y, double a_z);
+"""
 
 defs_kin_corexy = """
     struct stepper_kinematics *corexy_stepper_alloc(char type);
@@ -154,6 +163,7 @@ defs_kin_shaper = """
         , int n, double a[], double t[]);
     int input_shaper_set_sk(struct stepper_kinematics *sk
         , struct stepper_kinematics *orig_sk);
+    void input_shaper_update_sk(struct stepper_kinematics *sk);
     struct stepper_kinematics * input_shaper_alloc(void);
 """
 
@@ -175,7 +185,7 @@ defs_serialqueue = """
     };
 
     struct serialqueue *serialqueue_alloc(int serial_fd, char serial_fd_type
-        , int client_id);
+        , int client_id, char name[16]);
     void serialqueue_exit(struct serialqueue *sq);
     void serialqueue_free(struct serialqueue *sq);
     struct command_queue *serialqueue_alloc_commandqueue(void);
@@ -212,6 +222,7 @@ defs_trdispatch = """
 defs_pyhelper = """
     void set_python_logging_callback(void (*func)(const char *));
     double get_monotonic(void);
+    int set_thread_name(char name[16]);
 """
 
 defs_std = """
@@ -220,10 +231,11 @@ defs_std = """
 
 defs_all = [
     defs_pyhelper, defs_serialqueue, defs_std, defs_stepcompress,
-    defs_itersolve, defs_trapq, defs_trdispatch,
+    defs_steppersync, defs_itersolve, defs_trapq, defs_trdispatch,
     defs_kin_cartesian, defs_kin_corexy, defs_kin_corexz, defs_kin_delta,
     defs_kin_deltesian, defs_kin_polar, defs_kin_rotary_delta, defs_kin_winch,
     defs_kin_extruder, defs_kin_shaper, defs_kin_idex,
+    defs_kin_generic_cartesian,
 ]
 
 # Update filenames to an absolute path
@@ -262,11 +274,33 @@ def do_build_code(cmd):
         logging.error(msg)
         raise Exception(msg)
 
+# Build the main c_helper.so c code library
+def check_build_c_library():
+    srcdir = os.path.dirname(os.path.realpath(__file__))
+    srcfiles = get_abs_files(srcdir, SOURCE_FILES)
+    ofiles = get_abs_files(srcdir, OTHER_FILES)
+    destlib = get_abs_files(srcdir, [DEST_LIB])[0]
+    if not check_build_code(srcfiles+ofiles+[__file__], destlib):
+        # Code already built
+        return destlib
+    # Select command line options
+    if check_gcc_option(SSE_FLAGS):
+        cmd = "%s %s %s" % (GCC_CMD, SSE_FLAGS, COMPILE_ARGS)
+    else:
+        cmd = "%s %s" % (GCC_CMD, COMPILE_ARGS)
+    # Invoke compiler
+    logging.info("Building C code module %s", DEST_LIB)
+    tempdestlib = get_abs_files(srcdir, ["_temp_" + DEST_LIB])[0]
+    do_build_code(cmd % (tempdestlib, ' '.join(srcfiles)))
+    # Rename from temporary file to final file name
+    os.rename(tempdestlib, destlib)
+    return destlib
+
 FFI_main = None
 FFI_lib = None
 pyhelper_logging_callback = None
 
-# Hepler invoked from C errorf() code to log errors
+# Helper invoked from C errorf() code to log errors
 def logging_callback(msg):
     logging.error(FFI_main.string(msg))
 
@@ -274,17 +308,9 @@ def logging_callback(msg):
 def get_ffi():
     global FFI_main, FFI_lib, pyhelper_logging_callback
     if FFI_lib is None:
-        srcdir = os.path.dirname(os.path.realpath(__file__))
-        srcfiles = get_abs_files(srcdir, SOURCE_FILES)
-        ofiles = get_abs_files(srcdir, OTHER_FILES)
-        destlib = get_abs_files(srcdir, [DEST_LIB])[0]
-        if check_build_code(srcfiles+ofiles+[__file__], destlib):
-            if check_gcc_option(SSE_FLAGS):
-                cmd = "%s %s %s" % (GCC_CMD, SSE_FLAGS, COMPILE_ARGS)
-            else:
-                cmd = "%s %s" % (GCC_CMD, COMPILE_ARGS)
-            logging.info("Building C code module %s", DEST_LIB)
-            do_build_code(cmd % (destlib, ' '.join(srcfiles)))
+        # Check if library needs to be built, and build if so
+        destlib = check_build_c_library()
+        # Open library
         FFI_main = cffi.FFI()
         for d in defs_all:
             FFI_main.cdef(d)

klippy/chelper/itersolve.c

@@ -26,8 +26,8 @@ struct timepos {
 
 // Generate step times for a portion of a move
 static int32_t
-itersolve_gen_steps_range(struct stepper_kinematics *sk, struct move *m
-                          , double abs_start, double abs_end)
+itersolve_gen_steps_range(struct stepper_kinematics *sk, struct stepcompress *sc
+                          , struct move *m, double abs_start, double abs_end)
 {
     sk_calc_callback calc_position_cb = sk->calc_position_cb;
     double half_step = .5 * sk->step_dist;
@@ -37,7 +37,7 @@ itersolve_gen_steps_range(struct stepper_kinematics *sk, struct move *m
     if (end > m->move_t)
         end = m->move_t;
     struct timepos old_guess = {start, sk->commanded_pos}, guess = old_guess;
-    int sdir = stepcompress_get_step_dir(sk->sc);
+    int sdir = stepcompress_get_step_dir(sc);
     int is_dir_change = 0, have_bracket = 0, check_oscillate = 0;
     double target = sk->commanded_pos + (sdir ? half_step : -half_step);
     double last_time=start, low_time=start, high_time=start + SEEK_TIME_RESET;
@@ -99,13 +99,13 @@ itersolve_gen_steps_range(struct stepper_kinematics *sk, struct move *m
             if (!have_bracket || high_time - low_time > .000000001) {
                 if (!is_dir_change && rel_dist >= -half_step)
                     // Avoid rollback if stepper fully reaches step position
-                    stepcompress_commit(sk->sc);
+                    stepcompress_commit(sc);
                 // Guess is not close enough - guess again with new time
                 continue;
             }
         }
         // Found next step - submit it
-        int ret = stepcompress_append(sk->sc, sdir, m->print_time, guess.time);
+        int ret = stepcompress_append(sc, sdir, m->print_time, guess.time);
         if (ret)
             return ret;
         target = sdir ? target+half_step+half_step : target-half_step-half_step;
@@ -143,8 +143,9 @@ check_active(struct stepper_kinematics *sk, struct move *m)
 }
 
 // Generate step times for a range of moves on the trapq
-int32_t __visible
-itersolve_generate_steps(struct stepper_kinematics *sk, double flush_time)
+int32_t
+itersolve_generate_steps(struct stepper_kinematics *sk, struct stepcompress *sc
+                         , double flush_time)
 {
     double last_flush_time = sk->last_flush_time;
     sk->last_flush_time = flush_time;
@@ -170,15 +171,15 @@ itersolve_generate_steps(struct stepper_kinematics *sk, double flush_time)
                 while (--skip_count && pm->print_time > abs_start)
                     pm = list_prev_entry(pm, node);
                 do {
-                    int32_t ret = itersolve_gen_steps_range(sk, pm, abs_start
-                                                            , flush_time);
+                    int32_t ret = itersolve_gen_steps_range(
+                        sk, sc, pm, abs_start, flush_time);
                     if (ret)
                         return ret;
                     pm = list_next_entry(pm, node);
                 } while (pm != m);
             }
             // Generate steps for this move
-            int32_t ret = itersolve_gen_steps_range(sk, m, last_flush_time
+            int32_t ret = itersolve_gen_steps_range(sk, sc, m, last_flush_time
                                                     , flush_time);
             if (ret)
                 return ret;
@@ -195,8 +196,8 @@ itersolve_generate_steps(struct stepper_kinematics *sk, double flush_time)
                 double abs_end = force_steps_time;
                 if (abs_end > flush_time)
                     abs_end = flush_time;
-                int32_t ret = itersolve_gen_steps_range(sk, m, last_flush_time
-                                                        , abs_end);
+                int32_t ret = itersolve_gen_steps_range(
+                    sk, sc, m, last_flush_time, abs_end);
                 if (ret)
                     return ret;
                 skip_count = 1;
@@ -240,16 +241,10 @@ itersolve_is_active_axis(struct stepper_kinematics *sk, char axis)
 }
 
 void __visible
-itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq)
+itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq
+                    , double step_dist)
 {
     sk->tq = tq;
-}
-
-void __visible
-itersolve_set_stepcompress(struct stepper_kinematics *sk
-                           , struct stepcompress *sc, double step_dist)
-{
-    sk->sc = sc;
     sk->step_dist = step_dist;
 }
 

klippy/chelper/itersolve.h

@@ -26,12 +26,11 @@ struct stepper_kinematics {
 };
 
 int32_t itersolve_generate_steps(struct stepper_kinematics *sk
-                                 , double flush_time);
+                                 , struct stepcompress *sc, double flush_time);
 double itersolve_check_active(struct stepper_kinematics *sk, double flush_time);
 int32_t itersolve_is_active_axis(struct stepper_kinematics *sk, char axis);
-void itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq);
-void itersolve_set_stepcompress(struct stepper_kinematics *sk
-                                , struct stepcompress *sc, double step_dist);
+void itersolve_set_trapq(struct stepper_kinematics *sk, struct trapq *tq
+                         , double step_dist);
 double itersolve_calc_position_from_coord(struct stepper_kinematics *sk
                                           , double x, double y, double z);
 void itersolve_set_position(struct stepper_kinematics *sk

klippy/chelper/kin_generic.c

@@ -0,0 +1,52 @@
+// Generic cartesian kinematics stepper position calculation
+//
+// Copyright (C) 2024  Dmitry Butyugin <dmbutyugin@google.com>
+//
+// This file may be distributed under the terms of the GNU GPLv3 license.
+
+#include <stddef.h> // offsetof
+#include <stdlib.h> // malloc
+#include <string.h> // memset
+#include "compiler.h" // __visible
+#include "itersolve.h" // struct stepper_kinematics
+#include "trapq.h" // move_get_coord
+
+struct generic_cartesian_stepper {
+    struct stepper_kinematics sk;
+    struct coord a;
+};
+
+static double
+generic_cartesian_stepper_calc_position(struct stepper_kinematics *sk
+                                        , struct move *m, double move_time)
+{
+    struct generic_cartesian_stepper *cs = container_of(
+            sk, struct generic_cartesian_stepper, sk);
+    struct coord c = move_get_coord(m, move_time);
+    return cs->a.x * c.x + cs->a.y * c.y + cs->a.z * c.z;
+}
+
+void __visible
+generic_cartesian_stepper_set_coeffs(struct stepper_kinematics *sk
+                                     , double a_x, double a_y, double a_z)
+{
+    struct generic_cartesian_stepper *cs = container_of(
+            sk, struct generic_cartesian_stepper, sk);
+    cs->a.x = a_x;
+    cs->a.y = a_y;
+    cs->a.z = a_z;
+    cs->sk.active_flags = 0;
+    if (a_x) cs->sk.active_flags |= AF_X;
+    if (a_y) cs->sk.active_flags |= AF_Y;
+    if (a_z) cs->sk.active_flags |= AF_Z;
+}
+
+struct stepper_kinematics * __visible
+generic_cartesian_stepper_alloc(double a_x, double a_y, double a_z)
+{
+    struct generic_cartesian_stepper *cs = malloc(sizeof(*cs));
+    memset(cs, 0, sizeof(*cs));
+    cs->sk.calc_position_cb = generic_cartesian_stepper_calc_position;
+    generic_cartesian_stepper_set_coeffs(&cs->sk, a_x, a_y, a_z);
+    return &cs->sk;
+}

klippy/chelper/kin_idex.c

@@ -77,5 +77,6 @@ dual_carriage_alloc(void)
     struct dual_carriage_stepper *dc = malloc(sizeof(*dc));
     memset(dc, 0, sizeof(*dc));
     dc->m.move_t = 2. * DUMMY_T;
+    dc->x_scale = dc->y_scale = 1.0;
     return &dc->sk;
 }

klippy/chelper/kin_shaper.c

@@ -156,25 +156,14 @@ shaper_xy_calc_position(struct stepper_kinematics *sk, struct move *m
     return is->orig_sk->calc_position_cb(is->orig_sk, &is->m, DUMMY_T);
 }
 
-int __visible
-input_shaper_set_sk(struct stepper_kinematics *sk
-                    , struct stepper_kinematics *orig_sk)
+// A callback that forwards post_cb call to the original kinematics
+static void
+shaper_commanded_pos_post_fixup(struct stepper_kinematics *sk)
 {
     struct input_shaper *is = container_of(sk, struct input_shaper, sk);
-    if (orig_sk->active_flags == AF_X)
-        is->sk.calc_position_cb = shaper_x_calc_position;
-    else if (orig_sk->active_flags == AF_Y)
-        is->sk.calc_position_cb = shaper_y_calc_position;
-    else if (orig_sk->active_flags & (AF_X | AF_Y))
-        is->sk.calc_position_cb = shaper_xy_calc_position;
-    else
-        return -1;
-    is->sk.active_flags = orig_sk->active_flags;
-    is->orig_sk = orig_sk;
-    is->sk.commanded_pos = orig_sk->commanded_pos;
-    is->sk.last_flush_time = orig_sk->last_flush_time;
-    is->sk.last_move_time = orig_sk->last_move_time;
-    return 0;
+    is->orig_sk->commanded_pos = sk->commanded_pos;
+    is->orig_sk->post_cb(is->orig_sk);
+    sk->commanded_pos = is->orig_sk->commanded_pos;
 }
 
 static void
@@ -195,6 +184,44 @@ shaper_note_generation_time(struct input_shaper *is)
     is->sk.gen_steps_post_active = post_active;
 }
 
+void __visible
+input_shaper_update_sk(struct stepper_kinematics *sk)
+{
+    struct input_shaper *is = container_of(sk, struct input_shaper, sk);
+    if ((is->orig_sk->active_flags & (AF_X | AF_Y)) == (AF_X | AF_Y))
+        is->sk.calc_position_cb = shaper_xy_calc_position;
+    else if (is->orig_sk->active_flags & AF_X)
+        is->sk.calc_position_cb = shaper_x_calc_position;
+    else if (is->orig_sk->active_flags & AF_Y)
+        is->sk.calc_position_cb = shaper_y_calc_position;
+    is->sk.active_flags = is->orig_sk->active_flags;
+    shaper_note_generation_time(is);
+}
+
+int __visible
+input_shaper_set_sk(struct stepper_kinematics *sk
+                    , struct stepper_kinematics *orig_sk)
+{
+    struct input_shaper *is = container_of(sk, struct input_shaper, sk);
+    if (orig_sk->active_flags == AF_X)
+        is->sk.calc_position_cb = shaper_x_calc_position;
+    else if (orig_sk->active_flags == AF_Y)
+        is->sk.calc_position_cb = shaper_y_calc_position;
+    else if (orig_sk->active_flags & (AF_X | AF_Y))
+        is->sk.calc_position_cb = shaper_xy_calc_position;
+    else
+        return -1;
+    is->sk.active_flags = orig_sk->active_flags;
+    is->orig_sk = orig_sk;
+    is->sk.commanded_pos = orig_sk->commanded_pos;
+    is->sk.last_flush_time = orig_sk->last_flush_time;
+    is->sk.last_move_time = orig_sk->last_move_time;
+    if (orig_sk->post_cb) {
+        is->sk.post_cb = shaper_commanded_pos_post_fixup;
+    }
+    return 0;
+}
+
 int __visible
 input_shaper_set_shaper_params(struct stepper_kinematics *sk, char axis
                                , int n, double a[], double t[])

klippy/chelper/pyhelper.c

@@ -10,6 +10,8 @@
 #include <stdio.h> // fprintf
 #include <string.h> // strerror
 #include <time.h> // struct timespec
+#include <linux/prctl.h>  // PR_SET_NAME
+#include <sys/prctl.h>  // prctl
 #include "compiler.h" // __visible
 #include "pyhelper.h" // get_monotonic
 
@@ -92,3 +94,10 @@ dump_string(char *outbuf, int outbuf_size, char *inbuf, int inbuf_size)
     *o = '\0';
     return outbuf;
 }
+
+// Set custom thread names
+int __visible
+set_thread_name(char name[16])
+{
+    return prctl(PR_SET_NAME, name);
+}

klippy/chelper/pyhelper.h

@@ -7,5 +7,6 @@ void set_python_logging_callback(void (*func)(const char *));
 void errorf(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
 void report_errno(char *where, int rc);
 char *dump_string(char *outbuf, int outbuf_size, char *inbuf, int inbuf_size);
+int set_thread_name(char name[16]);
 
 #endif // pyhelper.h

klippy/chelper/serialqueue.c

@@ -43,6 +43,7 @@ struct serialqueue {
     uint8_t need_sync;
     int input_pos;
     // Threading
+    char name[16];
     pthread_t tid;
     pthread_mutex_t lock; // protects variables below
     pthread_cond_t cond;
@@ -612,6 +613,7 @@ static void *
 background_thread(void *data)
 {
     struct serialqueue *sq = data;
+    set_thread_name(sq->name);
     pollreactor_run(sq->pr);
 
     pthread_mutex_lock(&sq->lock);
@@ -623,13 +625,16 @@ background_thread(void *data)
 
 // Create a new 'struct serialqueue' object
 struct serialqueue * __visible
-serialqueue_alloc(int serial_fd, char serial_fd_type, int client_id)
+serialqueue_alloc(int serial_fd, char serial_fd_type, int client_id
+                  , char name[16])
 {
     struct serialqueue *sq = malloc(sizeof(*sq));
     memset(sq, 0, sizeof(*sq));
     sq->serial_fd = serial_fd;
     sq->serial_fd_type = serial_fd_type;
     sq->client_id = client_id;
+    strncpy(sq->name, name, sizeof(sq->name));
+    sq->name[sizeof(sq->name)-1] = '\0';
 
     int ret = pipe(sq->pipe_fds);
     if (ret)

klippy/chelper/serialqueue.h

@@ -27,7 +27,7 @@ struct pull_queue_message {
 
 struct serialqueue;
 struct serialqueue *serialqueue_alloc(int serial_fd, char serial_fd_type
-                                      , int client_id);
+                                      , int client_id, char name[16]);
 void serialqueue_exit(struct serialqueue *sq);
 void serialqueue_free(struct serialqueue *sq);
 struct command_queue *serialqueue_alloc_commandqueue(void);

klippy/chelper/stepcompress.c

@@ -1,6 +1,6 @@
 // Stepper pulse schedule compression
 //
-// Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
+// Copyright (C) 2016-2025  Kevin O'Connor <kevin@koconnor.net>
 //
 // This file may be distributed under the terms of the GNU GPLv3 license.
 
@@ -21,6 +21,7 @@
 #include <stdlib.h> // malloc
 #include <string.h> // memset
 #include "compiler.h" // DIV_ROUND_UP
+#include "itersolve.h" // itersolve_generate_steps
 #include "pyhelper.h" // errorf
 #include "serialqueue.h" // struct queue_message
 #include "stepcompress.h" // stepcompress_alloc
@@ -46,6 +47,8 @@ struct stepcompress {
     // History tracking
     int64_t last_position;
     struct list_head history_list;
+    // Itersolve reference
+    struct stepper_kinematics *sk;
 };
 
 struct step_move {
@@ -276,9 +279,9 @@ stepcompress_set_invert_sdir(struct stepcompress *sc, uint32_t invert_sdir)
     }
 }
 
-// Helper to free items from the history_list
-static void
-free_history(struct stepcompress *sc, uint64_t end_clock)
+// Expire the stepcompress history older than the given clock
+void
+stepcompress_history_expire(struct stepcompress *sc, uint64_t end_clock)
 {
     while (!list_empty(&sc->history_list)) {
         struct history_steps *hs = list_last_entry(
@@ -290,13 +293,6 @@ free_history(struct stepcompress *sc, uint64_t end_clock)
     }
 }
 
-// Expire the stepcompress history older than the given clock
-static void
-stepcompress_history_expire(struct stepcompress *sc, uint64_t end_clock)
-{
-    free_history(sc, end_clock);
-}
-
 // Free memory associated with a 'stepcompress' object
 void __visible
 stepcompress_free(struct stepcompress *sc)
@@ -305,7 +301,7 @@ stepcompress_free(struct stepcompress *sc)
         return;
     free(sc->queue);
     message_queue_free(&sc->msg_queue);
-    free_history(sc, UINT64_MAX);
+    stepcompress_history_expire(sc, UINT64_MAX);
     free(sc);
 }
 
@@ -321,6 +317,12 @@ stepcompress_get_step_dir(struct stepcompress *sc)
     return sc->next_step_dir;
 }
 
+struct list_head *
+stepcompress_get_msg_queue(struct stepcompress *sc)
+{
+    return &sc->msg_queue;
+}
+
 // Determine the "print time" of the last_step_clock
 static void
 calc_last_step_print_time(struct stepcompress *sc)
@@ -330,7 +332,7 @@ calc_last_step_print_time(struct stepcompress *sc)
 }
 
 // Set the conversion rate of 'print_time' to mcu clock
-static void
+void
 stepcompress_set_time(struct stepcompress *sc
                       , double time_offset, double mcu_freq)
 {
@@ -664,164 +666,25 @@ stepcompress_extract_old(struct stepcompress *sc, struct pull_history_steps *p
     return res;
 }
 
-
-/****************************************************************
- * Step compress synchronization
- ****************************************************************/
-
-// The steppersync object is used to synchronize the output of mcu
-// step commands.  The mcu can only queue a limited number of step
-// commands - this code tracks when items on the mcu step queue become
-// free so that new commands can be transmitted.  It also ensures the
-// mcu step queue is ordered between steppers so that no stepper
-// starves the other steppers of space in the mcu step queue.
-
-struct steppersync {
-    // Serial port
-    struct serialqueue *sq;
-    struct command_queue *cq;
-    // Storage for associated stepcompress objects
-    struct stepcompress **sc_list;
-    int sc_num;
-    // Storage for list of pending move clocks
-    uint64_t *move_clocks;
-    int num_move_clocks;
-};
-
-// Allocate a new 'steppersync' object
-struct steppersync * __visible
-steppersync_alloc(struct serialqueue *sq, struct stepcompress **sc_list
-                  , int sc_num, int move_num)
-{
-    struct steppersync *ss = malloc(sizeof(*ss));
-    memset(ss, 0, sizeof(*ss));
-    ss->sq = sq;
-    ss->cq = serialqueue_alloc_commandqueue();
-
-    ss->sc_list = malloc(sizeof(*sc_list)*sc_num);
-    memcpy(ss->sc_list, sc_list, sizeof(*sc_list)*sc_num);
-    ss->sc_num = sc_num;
-
-    ss->move_clocks = malloc(sizeof(*ss->move_clocks)*move_num);
-    memset(ss->move_clocks, 0, sizeof(*ss->move_clocks)*move_num);
-    ss->num_move_clocks = move_num;
-
-    return ss;
-}
-
-// Free memory associated with a 'steppersync' object
+// Store a reference to stepper_kinematics
 void __visible
-steppersync_free(struct steppersync *ss)
+stepcompress_set_stepper_kinematics(struct stepcompress *sc
+                                    , struct stepper_kinematics *sk)
 {
-    if (!ss)
-        return;
-    free(ss->sc_list);
-    free(ss->move_clocks);
-    serialqueue_free_commandqueue(ss->cq);
-    free(ss);
+    sc->sk = sk;
 }
 
-// Set the conversion rate of 'print_time' to mcu clock
-void __visible
-steppersync_set_time(struct steppersync *ss, double time_offset
-                     , double mcu_freq)
+// Generate steps (via itersolve) and flush
+int32_t
+stepcompress_generate_steps(struct stepcompress *sc, double gen_steps_time
+                            , uint64_t flush_clock)
 {
-    int i;
-    for (i=0; i<ss->sc_num; i++) {
-        struct stepcompress *sc = ss->sc_list[i];
-        stepcompress_set_time(sc, time_offset, mcu_freq);
-    }
-}
-
-// Expire the stepcompress history before the given clock time
-static void
-steppersync_history_expire(struct steppersync *ss, uint64_t end_clock)
-{
-    int i;
-    for (i = 0; i < ss->sc_num; i++)
-    {
-        struct stepcompress *sc = ss->sc_list[i];
-        stepcompress_history_expire(sc, end_clock);
-    }
-}
-
-// Implement a binary heap algorithm to track when the next available
-// 'struct move' in the mcu will be available
-static void
-heap_replace(struct steppersync *ss, uint64_t req_clock)
-{
-    uint64_t *mc = ss->move_clocks;
-    int nmc = ss->num_move_clocks, pos = 0;
-    for (;;) {
-        int child1_pos = 2*pos+1, child2_pos = 2*pos+2;
-        uint64_t child2_clock = child2_pos < nmc ? mc[child2_pos] : UINT64_MAX;
-        uint64_t child1_clock = child1_pos < nmc ? mc[child1_pos] : UINT64_MAX;
-        if (req_clock <= child1_clock && req_clock <= child2_clock) {
-            mc[pos] = req_clock;
-            break;
-        }
-        if (child1_clock < child2_clock) {
-            mc[pos] = child1_clock;
-            pos = child1_pos;
-        } else {
-            mc[pos] = child2_clock;
-            pos = child2_pos;
-        }
-    }
-}
-
-// Find and transmit any scheduled steps prior to the given 'move_clock'
-int __visible
-steppersync_flush(struct steppersync *ss, uint64_t move_clock
-                  , uint64_t clear_history_clock)
-{
-    // Flush each stepcompress to the specified move_clock
-    int i;
-    for (i=0; i<ss->sc_num; i++) {
-        int ret = stepcompress_flush(ss->sc_list[i], move_clock);
+    if (!sc->sk)
+        return 0;
+    // Generate steps
+    int32_t ret = itersolve_generate_steps(sc->sk, sc, gen_steps_time);
     if (ret)
         return ret;
-    }
-
-    // Order commands by the reqclock of each pending command
-    struct list_head msgs;
-    list_init(&msgs);
-    for (;;) {
-        // Find message with lowest reqclock
-        uint64_t req_clock = MAX_CLOCK;
-        struct queue_message *qm = NULL;
-        for (i=0; i<ss->sc_num; i++) {
-            struct stepcompress *sc = ss->sc_list[i];
-            if (!list_empty(&sc->msg_queue)) {
-                struct queue_message *m = list_first_entry(
-                    &sc->msg_queue, struct queue_message, node);
-                if (m->req_clock < req_clock) {
-                    qm = m;
-                    req_clock = m->req_clock;
-                }
-            }
-        }
-        if (!qm || (qm->min_clock && req_clock > move_clock))
-            break;
-
-        uint64_t next_avail = ss->move_clocks[0];
-        if (qm->min_clock)
-            // The qm->min_clock field is overloaded to indicate that
-            // the command uses the 'move queue' and to store the time
-            // that move queue item becomes available.
-            heap_replace(ss, qm->min_clock);
-        // Reset the min_clock to its normal meaning (minimum transmit time)
-        qm->min_clock = next_avail;
-
-        // Batch this command
-        list_del(&qm->node);
-        list_add_tail(&qm->node, &msgs);
-    }
-
-    // Transmit commands
-    if (!list_empty(&msgs))
-        serialqueue_send_batch(ss->sq, ss->cq, &msgs);
-
-    steppersync_history_expire(ss, clear_history_clock);
-    return 0;
+    // Flush steps
+    return stepcompress_flush(sc, flush_clock);
 }

klippy/chelper/stepcompress.h

@@ -17,9 +17,13 @@ void stepcompress_fill(struct stepcompress *sc, uint32_t max_error
                        , int32_t set_next_step_dir_msgtag);
 void stepcompress_set_invert_sdir(struct stepcompress *sc
                                   , uint32_t invert_sdir);
+void stepcompress_history_expire(struct stepcompress *sc, uint64_t end_clock);
 void stepcompress_free(struct stepcompress *sc);
 uint32_t stepcompress_get_oid(struct stepcompress *sc);
 int stepcompress_get_step_dir(struct stepcompress *sc);
+struct list_head *stepcompress_get_msg_queue(struct stepcompress *sc);
+void stepcompress_set_time(struct stepcompress *sc
+                           , double time_offset, double mcu_freq);
 int stepcompress_append(struct stepcompress *sc, int sdir
                         , double print_time, double step_time);
 int stepcompress_commit(struct stepcompress *sc);
@@ -34,15 +38,11 @@ int stepcompress_queue_mq_msg(struct stepcompress *sc, uint64_t req_clock
 int stepcompress_extract_old(struct stepcompress *sc
                              , struct pull_history_steps *p, int max
                              , uint64_t start_clock, uint64_t end_clock);
-
-struct serialqueue;
-struct steppersync *steppersync_alloc(
-    struct serialqueue *sq, struct stepcompress **sc_list, int sc_num
-    , int move_num);
-void steppersync_free(struct steppersync *ss);
-void steppersync_set_time(struct steppersync *ss, double time_offset
-                          , double mcu_freq);
-int steppersync_flush(struct steppersync *ss, uint64_t move_clock
-                      , uint64_t clear_history_clock);
+struct stepper_kinematics;
+void stepcompress_set_stepper_kinematics(struct stepcompress *sc
+                                         , struct stepper_kinematics *sk);
+int32_t stepcompress_generate_steps(struct stepcompress *sc
+                                    , double gen_steps_time
+                                    , uint64_t flush_clock);
 
 #endif // stepcompress.h

klippy/chelper/steppersync.c

@@ -0,0 +1,177 @@
+// Stepper step transmit synchronization
+//
+// Copyright (C) 2016-2025  Kevin O'Connor <kevin@koconnor.net>
+//
+// This file may be distributed under the terms of the GNU GPLv3 license.
+
+// The steppersync object is used to synchronize the output of mcu
+// step commands.  The mcu can only queue a limited number of step
+// commands - this code tracks when items on the mcu step queue become
+// free so that new commands can be transmitted.  It also ensures the
+// mcu step queue is ordered between steppers so that no stepper
+// starves the other steppers of space in the mcu step queue.
+
+#include <stddef.h> // offsetof
+#include <stdlib.h> // malloc
+#include <string.h> // memset
+#include "compiler.h" // __visible
+#include "serialqueue.h" // struct queue_message
+#include "stepcompress.h" // stepcompress_flush
+#include "steppersync.h" // steppersync_alloc
+
+struct steppersync {
+    // Serial port
+    struct serialqueue *sq;
+    struct command_queue *cq;
+    // Storage for associated stepcompress objects
+    struct stepcompress **sc_list;
+    int sc_num;
+    // Storage for list of pending move clocks
+    uint64_t *move_clocks;
+    int num_move_clocks;
+};
+
+// Allocate a new 'steppersync' object
+struct steppersync * __visible
+steppersync_alloc(struct serialqueue *sq, struct stepcompress **sc_list
+                  , int sc_num, int move_num)
+{
+    struct steppersync *ss = malloc(sizeof(*ss));
+    memset(ss, 0, sizeof(*ss));
+    ss->sq = sq;
+    ss->cq = serialqueue_alloc_commandqueue();
+
+    ss->sc_list = malloc(sizeof(*sc_list)*sc_num);
+    memcpy(ss->sc_list, sc_list, sizeof(*sc_list)*sc_num);
+    ss->sc_num = sc_num;
+
+    ss->move_clocks = malloc(sizeof(*ss->move_clocks)*move_num);
+    memset(ss->move_clocks, 0, sizeof(*ss->move_clocks)*move_num);
+    ss->num_move_clocks = move_num;
+
+    return ss;
+}
+
+// Free memory associated with a 'steppersync' object
+void __visible
+steppersync_free(struct steppersync *ss)
+{
+    if (!ss)
+        return;
+    free(ss->sc_list);
+    free(ss->move_clocks);
+    serialqueue_free_commandqueue(ss->cq);
+    free(ss);
+}
+
+// Set the conversion rate of 'print_time' to mcu clock
+void __visible
+steppersync_set_time(struct steppersync *ss, double time_offset
+                     , double mcu_freq)
+{
+    int i;
+    for (i=0; i<ss->sc_num; i++) {
+        struct stepcompress *sc = ss->sc_list[i];
+        stepcompress_set_time(sc, time_offset, mcu_freq);
+    }
+}
+
+// Generate steps and flush stepcompress objects
+int32_t __visible
+steppersync_generate_steps(struct steppersync *ss, double gen_steps_time
+                           , uint64_t flush_clock)
+{
+    int i;
+    for (i=0; i<ss->sc_num; i++) {
+        struct stepcompress *sc = ss->sc_list[i];
+        int32_t ret = stepcompress_generate_steps(sc, gen_steps_time
+                                                  , flush_clock);
+        if (ret)
+            return ret;
+    }
+    return 0;
+}
+
+// Expire the stepcompress history before the given clock time
+void __visible
+steppersync_history_expire(struct steppersync *ss, uint64_t end_clock)
+{
+    int i;
+    for (i = 0; i < ss->sc_num; i++) {
+        struct stepcompress *sc = ss->sc_list[i];
+        stepcompress_history_expire(sc, end_clock);
+    }
+}
+
+// Implement a binary heap algorithm to track when the next available
+// 'struct move' in the mcu will be available
+static void
+heap_replace(struct steppersync *ss, uint64_t req_clock)
+{
+    uint64_t *mc = ss->move_clocks;
+    int nmc = ss->num_move_clocks, pos = 0;
+    for (;;) {
+        int child1_pos = 2*pos+1, child2_pos = 2*pos+2;
+        uint64_t child2_clock = child2_pos < nmc ? mc[child2_pos] : UINT64_MAX;
+        uint64_t child1_clock = child1_pos < nmc ? mc[child1_pos] : UINT64_MAX;
+        if (req_clock <= child1_clock && req_clock <= child2_clock) {
+            mc[pos] = req_clock;
+            break;
+        }
+        if (child1_clock < child2_clock) {
+            mc[pos] = child1_clock;
+            pos = child1_pos;
+        } else {
+            mc[pos] = child2_clock;
+            pos = child2_pos;
+        }
+    }
+}
+
+// Find and transmit any scheduled steps prior to the given 'move_clock'
+int __visible
+steppersync_flush(struct steppersync *ss, uint64_t move_clock)
+{
+    // Order commands by the reqclock of each pending command
+    struct list_head msgs;
+    list_init(&msgs);
+    for (;;) {
+        // Find message with lowest reqclock
+        uint64_t req_clock = MAX_CLOCK;
+        struct queue_message *qm = NULL;
+        int i;
+        for (i=0; i<ss->sc_num; i++) {
+            struct stepcompress *sc = ss->sc_list[i];
+            struct list_head *sc_mq = stepcompress_get_msg_queue(sc);
+            if (!list_empty(sc_mq)) {
+                struct queue_message *m = list_first_entry(
+                    sc_mq, struct queue_message, node);
+                if (m->req_clock < req_clock) {
+                    qm = m;
+                    req_clock = m->req_clock;
+                }
+            }
+        }
+        if (!qm || (qm->min_clock && req_clock > move_clock))
+            break;
+
+        uint64_t next_avail = ss->move_clocks[0];
+        if (qm->min_clock)
+            // The qm->min_clock field is overloaded to indicate that
+            // the command uses the 'move queue' and to store the time
+            // that move queue item becomes available.
+            heap_replace(ss, qm->min_clock);
+        // Reset the min_clock to its normal meaning (minimum transmit time)
+        qm->min_clock = next_avail;
+
+        // Batch this command
+        list_del(&qm->node);
+        list_add_tail(&qm->node, &msgs);
+    }
+
+    // Transmit commands
+    if (!list_empty(&msgs))
+        serialqueue_send_batch(ss->sq, ss->cq, &msgs);
+
+    return 0;
+}

klippy/chelper/steppersync.h

@@ -0,0 +1,18 @@
+#ifndef STEPPERSYNC_H
+#define STEPPERSYNC_H
+
+#include <stdint.h> // uint64_t
+
+struct serialqueue;
+struct steppersync *steppersync_alloc(
+    struct serialqueue *sq, struct stepcompress **sc_list, int sc_num
+    , int move_num);
+void steppersync_free(struct steppersync *ss);
+void steppersync_set_time(struct steppersync *ss, double time_offset
+                          , double mcu_freq);
+int32_t steppersync_generate_steps(struct steppersync *ss, double gen_steps_time
+                                   , uint64_t flush_clock);
+void steppersync_history_expire(struct steppersync *ss, uint64_t end_clock);
+int steppersync_flush(struct steppersync *ss, uint64_t move_clock);
+
+#endif // steppersync.h

klippy/extras/ads1220.py

@@ -95,11 +95,8 @@ class ADS1220:
         self.batch_bulk = bulk_sensor.BatchBulkHelper(
             self.printer, self._process_batch, self._start_measurements,
             self._finish_measurements, UPDATE_INTERVAL)
-        # publish raw samples to the socket
-        hdr = {'header': ('time', 'counts', 'value')}
-        self.batch_bulk.add_mux_endpoint("ads1220/dump_ads1220", "sensor",
-                                         self.name, hdr)
         # Command Configuration
+        self.attach_probe_cmd = None
         mcu.add_config_cmd(
             "config_ads1220 oid=%d spi_oid=%d data_ready_pin=%s"
             % (self.oid, self.spi.get_oid(), self.data_ready_pin))
@@ -112,6 +109,8 @@ class ADS1220:
         cmdqueue = self.spi.get_command_queue()
         self.query_ads1220_cmd = self.mcu.lookup_command(
             "query_ads1220 oid=%c rest_ticks=%u", cq=cmdqueue)
+        self.attach_probe_cmd = self.mcu.lookup_command(
+            "ads1220_attach_load_cell_probe oid=%c load_cell_probe_oid=%c")
         self.ffreader.setup_query_command("query_ads1220_status oid=%c",
                                           oid=self.oid, cq=cmdqueue)
 
@@ -130,6 +129,9 @@ class ADS1220:
     def add_client(self, callback):
         self.batch_bulk.add_client(callback)
 
+    def attach_load_cell_probe(self, load_cell_probe_oid):
+        self.attach_probe_cmd.send([self.oid, load_cell_probe_oid])
+
     # Measurement decoding
     def _convert_samples(self, samples):
         adc_factor = 1. / (1 << 23)

klippy/extras/ads1x1x.py

@@ -210,28 +210,28 @@ class ADS1X1X_chip:
                 raise pins.error('ADS1x1x pin %s is not valid' % \
                                  pin_params['pin'])
 
-            config = 0
-            config |= (ADS1X1X_OS['OS_SINGLE'] & \
+            pcfg = 0
+            pcfg |= (ADS1X1X_OS['OS_SINGLE'] & \
                      ADS1X1X_REG_CONFIG['OS_MASK'])
-            config |= (ADS1X1X_MUX[pin_params['pin']] & \
+            pcfg |= (ADS1X1X_MUX[pin_params['pin']] & \
                      ADS1X1X_REG_CONFIG['MULTIPLEXER_MASK'])
-            config |= (self.pga & ADS1X1X_REG_CONFIG['PGA_MASK'])
+            pcfg |= (self.pga & ADS1X1X_REG_CONFIG['PGA_MASK'])
             # Have to use single mode, because in continuous, it never reaches
             # idle state, which we use to determine if the sampling is done.
-            config |= (ADS1X1X_MODE['single'] & \
+            pcfg |= (ADS1X1X_MODE['single'] & \
                        ADS1X1X_REG_CONFIG['MODE_MASK'])
             # lowest sample rate per default, until report time has been set in
             # setup_adc_sample
-            config |= (self.comp_mode \
+            pcfg |= (self.comp_mode \
                      & ADS1X1X_REG_CONFIG['COMPARATOR_MODE_MASK'])
-            config |= (self.comp_polarity \
+            pcfg |= (self.comp_polarity \
                      & ADS1X1X_REG_CONFIG['COMPARATOR_POLARITY_MASK'])
-            config |= (self.comp_latching \
+            pcfg |= (self.comp_latching \
                      & ADS1X1X_REG_CONFIG['COMPARATOR_LATCHING_MASK'])
-            config |= (self.comp_queue \
+            pcfg |= (self.comp_queue \
                      & ADS1X1X_REG_CONFIG['COMPARATOR_QUEUE_MASK'])
 
-            pin_obj = ADS1X1X_pin(self, config)
+            pin_obj = ADS1X1X_pin(self, pcfg)
             if pin in self._pins:
                 raise pins.error(
                     'pin %s for chip %s is used multiple times' \
@@ -250,8 +250,8 @@ class ADS1X1X_chip:
             logging.exception("ADS1X1X: error while resetting device")
 
     def is_ready(self):
-        config = self._read_register(ADS1X1X_REG_POINTER['CONFIG'])
-        return bool((config & ADS1X1X_REG_CONFIG['OS_MASK']) == \
+        cfg = self._read_register(ADS1X1X_REG_POINTER['CONFIG'])
+        return bool((cfg & ADS1X1X_REG_CONFIG['OS_MASK']) == \
                     ADS1X1X_OS['OS_IDLE'])
 
     def calculate_sample_rate(self):
@@ -281,7 +281,7 @@ class ADS1X1X_chip:
         (sample_rate, sample_rate_bits) = self.calculate_sample_rate()
 
         for pin in self._pins.values():
-            pin.config = (pin.config & ~ADS1X1X_REG_CONFIG['DATA_RATE_MASK']) \
+            pin.pcfg = (pin.pcfg & ~ADS1X1X_REG_CONFIG['DATA_RATE_MASK']) \
                 | (sample_rate_bits & ADS1X1X_REG_CONFIG['DATA_RATE_MASK'])
 
         self.delay = 1 / float(sample_rate)
@@ -289,7 +289,7 @@ class ADS1X1X_chip:
     def sample(self, pin):
         with self._mutex:
             try:
-                self._write_register(ADS1X1X_REG_POINTER['CONFIG'], pin.config)
+                self._write_register(ADS1X1X_REG_POINTER['CONFIG'], pin.pcfg)
                 self._reactor.pause(self._reactor.monotonic() + self.delay)
                 start_time = self._reactor.monotonic()
                 while not self.is_ready():
@@ -318,10 +318,10 @@ class ADS1X1X_chip:
         self._i2c.i2c_write(data)
 
 class ADS1X1X_pin:
-    def __init__(self, chip, config):
+    def __init__(self, chip, pcfg):
         self.mcu = chip.mcu
         self.chip = chip
-        self.config = config
+        self.pcfg = pcfg
 
         self.invalid_count = 0
 

klippy/extras/adxl345.py

@@ -166,12 +166,12 @@ class AccelCommandHelper:
                           % (accel_x, accel_y, accel_z))
     cmd_ACCELEROMETER_DEBUG_READ_help = "Query register (for debugging)"
     def cmd_ACCELEROMETER_DEBUG_READ(self, gcmd):
-        reg = gcmd.get("REG", minval=0, maxval=126, parser=lambda x: int(x, 0))
+        reg = gcmd.get("REG", minval=0, maxval=127, parser=lambda x: int(x, 0))
         val = self.chip.read_reg(reg)
         gcmd.respond_info("Accelerometer REG[0x%x] = 0x%x" % (reg, val))
     cmd_ACCELEROMETER_DEBUG_WRITE_help = "Set register (for debugging)"
     def cmd_ACCELEROMETER_DEBUG_WRITE(self, gcmd):
-        reg = gcmd.get("REG", minval=0, maxval=126, parser=lambda x: int(x, 0))
+        reg = gcmd.get("REG", minval=0, maxval=127, parser=lambda x: int(x, 0))
         val = gcmd.get("VAL", minval=0, maxval=255, parser=lambda x: int(x, 0))
         self.chip.set_reg(reg, val)
 

klippy/extras/angle.py

@@ -97,7 +97,7 @@ class AngleCalibration:
                 return None
         return self.mcu_stepper.mcu_to_commanded_position(self.mcu_pos_offset)
     def load_calibration(self, angles):
-        # Calculate linear intepolation calibration buckets by solving
+        # Calculate linear interpolation calibration buckets by solving
         # linear equations
         angle_max = 1 << ANGLE_BITS
         calibration_count = 1 << CALIBRATION_BITS

klippy/extras/axis_twist_compensation.py

@@ -125,9 +125,8 @@ class Calibrater:
 
     def _handle_connect(self):
         self.probe = self.printer.lookup_object('probe', None)
-        if (self.probe is None):
-            config = self.printer.lookup_object('configfile')
-            raise config.error(
+        if self.probe is None:
+            raise self.printer.config_error(
                 "AXIS_TWIST_COMPENSATION requires [probe] to be defined")
         self.lift_speed = self.probe.get_probe_params()['lift_speed']
         self.probe_x_offset, self.probe_y_offset, _ = \
@@ -150,20 +149,7 @@ class Calibrater:
     def cmd_AXIS_TWIST_COMPENSATION_CALIBRATE(self, gcmd):
         self.gcmd = gcmd
         sample_count = gcmd.get_int('SAMPLE_COUNT', DEFAULT_SAMPLE_COUNT)
-        axis = gcmd.get('AXIS', None)
-        auto = gcmd.get('AUTO', False)
-
-        if axis is not None and auto:
-            raise self.gcmd.error(
-                "Cannot use both 'AXIS' and 'AUTO' at the same time."
-            )
-
-        if auto:
-            self._start_autocalibration(sample_count)
-            return
-
-        if axis is None and not auto:
-            axis = 'X'
+        axis = gcmd.get('AXIS', 'X')
 
         # check for valid sample_count
         if sample_count < 2:
@@ -244,153 +230,6 @@ class Calibrater:
         self.current_axis = axis
         self._calibration(probe_points, nozzle_points, interval_dist)
 
-    def _calculate_corrections(self, coordinates):
-        # Extracting x, y, and z values from coordinates
-        x_coords = [coord[0] for coord in coordinates]
-        y_coords = [coord[1] for coord in coordinates]
-        z_coords = [coord[2] for coord in coordinates]
-
-        # Calculate the desired point (average of all corner points in z)
-        # For a general case, we should extract the unique
-        # combinations of corner points
-        z_corners = [z_coords[i] for i, coord in enumerate(coordinates)
-                        if (coord[0] in [x_coords[0], x_coords[-1]])
-                        and (coord[1] in [y_coords[0], y_coords[-1]])]
-        z_desired = sum(z_corners) / len(z_corners)
-
-
-        # Calculate average deformation per axis
-        unique_x_coords = sorted(set(x_coords))
-        unique_y_coords = sorted(set(y_coords))
-
-        avg_z_x = []
-        for x in unique_x_coords:
-            indices = [i for i, coord in enumerate(coordinates)
-                        if coord[0] == x]
-            avg_z = sum(z_coords[i] for i in indices) / len(indices)
-            avg_z_x.append(avg_z)
-
-        avg_z_y = []
-        for y in unique_y_coords:
-            indices = [i for i, coord in enumerate(coordinates)
-                        if coord[1] == y]
-            avg_z = sum(z_coords[i] for i in indices) / len(indices)
-            avg_z_y.append(avg_z)
-
-        # Calculate corrections to reach the desired point
-        x_corrections = [z_desired - avg for avg in avg_z_x]
-        y_corrections = [z_desired - avg for avg in avg_z_y]
-
-        return x_corrections, y_corrections
-
-    def _start_autocalibration(self, sample_count):
-
-        if not all([
-                self.x_start_point[0],
-                self.x_end_point[0],
-                self.y_start_point[0],
-                self.y_end_point[0]
-                ]):
-                raise self.gcmd.error(
-                    """AXIS_TWIST_COMPENSATION_AUTOCALIBRATE requires
-                    calibrate_start_x, calibrate_end_x, calibrate_start_y
-                    and calibrate_end_y to be defined
-                    """
-                    )
-
-        # check for valid sample_count
-        if sample_count is None or sample_count < 2:
-            raise self.gcmd.error(
-                "SAMPLE_COUNT to probe must be at least 2")
-
-        # verify no other manual probe is in progress
-        manual_probe.verify_no_manual_probe(self.printer)
-
-        # clear the current config
-        self.compensation.clear_compensations()
-
-        min_x = self.x_start_point[0]
-        max_x = self.x_end_point[0]
-        min_y = self.y_start_point[1]
-        max_y = self.y_end_point[1]
-
-        # calculate x positions
-        interval_x = (max_x - min_x) / (sample_count - 1)
-        xps = [min_x + interval_x * i for i in range(sample_count)]
-
-        # Calculate points array
-        interval_y = (max_y - min_y) / (sample_count - 1)
-        flip = False
-
-        points = []
-        for i in range(sample_count):
-            for j in range(sample_count):
-                if(not flip):
-                    idx = j
-                else:
-                    idx = sample_count -1 - j
-                points.append([xps[i], min_y + interval_y * idx ])
-            flip = not flip
-
-
-        # calculate the points to put the nozzle at, and probe
-        probe_points = []
-
-        for i in range(len(points)):
-            x = points[i][0] - self.probe_x_offset
-            y = points[i][1] - self.probe_y_offset
-            probe_points.append([x, y, self._auto_calibration((x,y))[2]])
-
-        # calculate corrections
-        x_corr, y_corr = self._calculate_corrections(probe_points)
-
-        x_corr_str = ', '.join(["{:.6f}".format(x)
-                                    for x in x_corr])
-
-        y_corr_str = ', '.join(["{:.6f}".format(x)
-                                    for x in y_corr])
-
-        # finalize
-        configfile = self.printer.lookup_object('configfile')
-        configfile.set(self.configname, 'z_compensations', x_corr_str)
-        configfile.set(self.configname, 'compensation_start_x',
-                    self.x_start_point[0])
-        configfile.set(self.configname, 'compensation_end_x',
-                    self.x_end_point[0])
-
-
-        configfile.set(self.configname, 'zy_compensations', y_corr_str)
-        configfile.set(self.configname, 'compensation_start_y',
-                    self.y_start_point[1])
-        configfile.set(self.configname, 'compensation_end_y',
-                    self.y_end_point[1])
-
-        self.gcode.respond_info(
-            "AXIS_TWIST_COMPENSATION state has been saved "
-            "for the current session.  The SAVE_CONFIG command will "
-            "update the printer config file and restart the printer.")
-        # output result
-        self.gcmd.respond_info(
-            "AXIS_TWIST_COMPENSATION_AUTOCALIBRATE: Calibration complete: ")
-        self.gcmd.respond_info("\n".join(map(str, [x_corr, y_corr])), log=False)
-
-    def _auto_calibration(self, probe_point):
-
-        # horizontal_move_z (to prevent probe trigger or hitting bed)
-        self._move_helper((None, None, self.horizontal_move_z))
-
-        # move to point to probe
-        self._move_helper((probe_point[0],
-                            probe_point[1], None))
-
-        # probe the point
-        pos = probe.run_single_probe(self.probe, self.gcmd)
-
-        # horizontal_move_z (to prevent probe trigger or hitting bed)
-        self._move_helper((None, None, self.horizontal_move_z))
-
-        return pos
-
     def _calculate_probe_points(self, nozzle_points,
         probe_x_offset, probe_y_offset):
         # calculate the points to put the nozzle at

klippy/extras/bed_mesh.py

@@ -34,7 +34,7 @@ def constrain(val, min_val, max_val):
 def lerp(t, v0, v1):
     return (1. - t) * v0 + t * v1
 
-# retreive commma separated pair from config
+# retrieve comma separated pair from config
 def parse_config_pair(config, option, default, minval=None, maxval=None):
     pair = config.getintlist(option, (default, default))
     if len(pair) != 2:
@@ -54,7 +54,7 @@ def parse_config_pair(config, option, default, minval=None, maxval=None):
                 % (option, str(maxval)))
     return pair
 
-# retreive commma separated pair from a g-code command
+# retrieve comma separated pair from a g-code command
 def parse_gcmd_pair(gcmd, name, minval=None, maxval=None):
     try:
         pair = [int(v.strip()) for v in gcmd.get(name).split(',')]
@@ -74,7 +74,7 @@ def parse_gcmd_pair(gcmd, name, minval=None, maxval=None):
                              % (name, maxval))
     return pair
 
-# retreive commma separated coordinate from a g-code command
+# retrieve comma separated coordinate from a g-code command
 def parse_gcmd_coord(gcmd, name):
     try:
         v1, v2 = [float(v.strip()) for v in gcmd.get(name).split(',')]
@@ -133,7 +133,7 @@ class BedMesh:
         self.update_status()
     def handle_connect(self):
         self.toolhead = self.printer.lookup_object('toolhead')
-        self.bmc.print_generated_points(logging.info)
+        self.bmc.print_generated_points(logging.info, truncate=True)
     def set_mesh(self, mesh):
         if mesh is not None and self.fade_end != self.FADE_DISABLE:
             self.log_fade_complete = True
@@ -186,7 +186,8 @@ class BedMesh:
             self.last_position[2] -= self.fade_target
         else:
             # return current position minus the current z-adjustment
-            x, y, z, e = self.toolhead.get_position()
+            cur_pos = self.toolhead.get_position()
+            x, y, z = cur_pos[:3]
             max_adj = self.z_mesh.calc_z(x, y)
             factor = 1.
             z_adj = max_adj - self.fade_target
@@ -202,19 +203,19 @@ class BedMesh:
                           (self.fade_dist - z_adj))
                 factor = constrain(factor, 0., 1.)
             final_z_adj = factor * z_adj + self.fade_target
-            self.last_position[:] = [x, y, z - final_z_adj, e]
+            self.last_position[:] = [x, y, z - final_z_adj] + cur_pos[3:]
         return list(self.last_position)
     def move(self, newpos, speed):
         factor = self.get_z_factor(newpos[2])
         if self.z_mesh is None or not factor:
             # No mesh calibrated, or mesh leveling phased out.
-            x, y, z, e = newpos
+            x, y, z = newpos[:3]
             if self.log_fade_complete:
                 self.log_fade_complete = False
                 logging.info(
                     "bed_mesh fade complete: Current Z: %.4f fade_target: %.4f "
                     % (z, self.fade_target))
-            self.toolhead.move([x, y, z + self.fade_target, e], speed)
+            self.toolhead.move([x, y, z + self.fade_target] + newpos[3:], speed)
         else:
             self.splitter.build_move(self.last_position, newpos, factor)
             while not self.splitter.traverse_complete:
@@ -346,7 +347,7 @@ class BedMeshCalibrate:
         self.gcode.register_command(
             'BED_MESH_CALIBRATE', self.cmd_BED_MESH_CALIBRATE,
             desc=self.cmd_BED_MESH_CALIBRATE_help)
-    def print_generated_points(self, print_func):
+    def print_generated_points(self, print_func, truncate=False):
         x_offset = y_offset = 0.
         probe = self.printer.lookup_object('probe', None)
         if probe is not None:
@@ -355,6 +356,10 @@ class BedMeshCalibrate:
                    " |  Tool Adjusted  |   Probe")
         points = self.probe_mgr.get_base_points()
         for i, (x, y) in enumerate(points):
+            if i >= 50 and truncate:
+                end = len(points) - 1
+                print_func("...points %d through %d truncated" % (i, end))
+                break
             adj_pt = "(%.1f, %.1f)" % (x - x_offset, y - y_offset)
             mesh_pt = "(%.1f, %.1f)" % (x, y)
             print_func(
@@ -613,8 +618,6 @@ class BedMeshCalibrate:
                 self.mesh_config, self.mesh_min, self.mesh_max,
                 self.radius, self.origin, probe_method
             )
-            gcmd.respond_info("Generating new points...")
-            self.print_generated_points(gcmd.respond_info)
             msg = "\n".join(["%s: %s" % (k, v)
                              for k, v in self.mesh_config.items()])
             logging.info("Updated Mesh Configuration:\n" + msg)
@@ -911,7 +914,7 @@ class ProbeManager:
         for i in range(y_cnt):
             for j in range(x_cnt):
                 if not i % 2:
-                    # move in positive directon
+                    # move in positive direction
                     pos_x = min_x + j * x_dist
                 else:
                     # move in negative direction
@@ -1161,7 +1164,7 @@ class ProbeManager:
 
     def _gen_arc(self, origin, radius, start, step, count):
         end = start + step * count
-        # create a segent for every 3 degress of travel
+        # create a segent for every 3 degrees of travel
         for angle in range(start, end, step):
             rad = math.radians(angle % 360)
             opp = math.sin(rad) * radius
@@ -1271,7 +1274,7 @@ class MoveSplitter:
         self.z_offset = self._calc_z_offset(prev_pos)
         self.traverse_complete = False
         self.distance_checked = 0.
-        axes_d = [self.next_pos[i] - self.prev_pos[i] for i in range(4)]
+        axes_d = [np - pp for np, pp in zip(self.next_pos, self.prev_pos)]
         self.total_move_length = math.sqrt(sum([d*d for d in axes_d[:3]]))
         self.axis_move = [not isclose(d, 0., abs_tol=1e-10) for d in axes_d]
     def _calc_z_offset(self, pos):
@@ -1284,7 +1287,7 @@ class MoveSplitter:
             raise self.gcode.error(
                 "bed_mesh: Slice distance is negative "
                 "or greater than entire move length")
-        for i in range(4):
+        for i in range(len(self.next_pos)):
             if self.axis_move[i]:
                 self.current_pos[i] = lerp(
                     t, self.prev_pos[i], self.next_pos[i])
@@ -1299,9 +1302,9 @@ class MoveSplitter:
                     next_z = self._calc_z_offset(self.current_pos)
                     if abs(next_z - self.z_offset) >= self.split_delta_z:
                         self.z_offset = next_z
-                        return self.current_pos[0], self.current_pos[1], \
-                            self.current_pos[2] + self.z_offset, \
-                            self.current_pos[3]
+                        newpos = list(self.current_pos)
+                        newpos[2] += self.z_offset
+                        return newpos
             # end of move reached
             self.current_pos[:] = self.next_pos
             self.z_offset = self._calc_z_offset(self.current_pos)

klippy/extras/bed_tilt.py

@@ -24,12 +24,14 @@ class BedTilt:
     def handle_connect(self):
         self.toolhead = self.printer.lookup_object('toolhead')
     def get_position(self):
-        x, y, z, e = self.toolhead.get_position()
-        return [x, y, z - x*self.x_adjust - y*self.y_adjust - self.z_adjust, e]
+        pos = self.toolhead.get_position()
+        x, y, z = pos[:3]
+        z -= x*self.x_adjust + y*self.y_adjust + self.z_adjust
+        return [x, y, z] + pos[3:]
     def move(self, newpos, speed):
-        x, y, z, e = newpos
-        self.toolhead.move([x, y, z + x*self.x_adjust + y*self.y_adjust
-                            + self.z_adjust, e], speed)
+        x, y, z = newpos[:3]
+        z += x*self.x_adjust + y*self.y_adjust + self.z_adjust
+        self.toolhead.move([x, y, z] + newpos[3:], speed)
     def update_adjust(self, x_adjust, y_adjust, z_adjust):
         self.x_adjust = x_adjust
         self.y_adjust = y_adjust

klippy/extras/bltouch.py

@@ -64,7 +64,11 @@ class BLTouchProbe:
         self.cmd_helper = probe.ProbeCommandHelper(
             config, self, self.mcu_endstop.query_endstop)
         self.probe_offsets = probe.ProbeOffsetsHelper(config)
-        self.probe_session = probe.ProbeSessionHelper(config, self)
+        self.param_helper = probe.ProbeParameterHelper(config)
+        self.homing_helper = probe.HomingViaProbeHelper(config, self,
+                                                        self.param_helper)
+        self.probe_session = probe.ProbeSessionHelper(
+            config, self.param_helper, self.homing_helper.start_probe_session)
         # Register BLTOUCH_DEBUG command
         self.gcode = self.printer.lookup_object('gcode')
         self.gcode.register_command("BLTOUCH_DEBUG", self.cmd_BLTOUCH_DEBUG,
@@ -75,7 +79,7 @@ class BLTouchProbe:
         self.printer.register_event_handler("klippy:connect",
                                             self.handle_connect)
     def get_probe_params(self, gcmd=None):
-        return self.probe_session.get_probe_params(gcmd)
+        return self.param_helper.get_probe_params(gcmd)
     def get_offsets(self):
         return self.probe_offsets.get_offsets()
     def get_status(self, eventtime):
@@ -191,9 +195,6 @@ class BLTouchProbe:
         self.verify_raise_probe()
         self.sync_print_time()
         self.multi = 'OFF'
-    def probing_move(self, pos, speed):
-        phoming = self.printer.lookup_object('homing')
-        return phoming.probing_move(self, pos, speed)
     def probe_prepare(self, hmove):
         if self.multi == 'OFF' or self.multi == 'FIRST':
             self.lower_probe()

klippy/extras/bme280.py

@@ -284,7 +284,7 @@ class BME280:
                 self.chip_type, self.i2c.i2c_address))
 
         # Reset chip
-        self.write_register('RESET', [RESET_CHIP_VALUE], wait=True)
+        self.write_register('RESET', [RESET_CHIP_VALUE])
         self.reactor.pause(self.reactor.monotonic() + .5)
 
         # Make sure non-volatile memory has been copied to registers
@@ -394,7 +394,7 @@ class BME280:
                 self.write_register('CTRL_HUM', self.os_hum)
             # Enter normal (periodic) mode
             meas = self.os_temp << 5 | self.os_pres << 2 | MODE_PERIODIC
-            self.write_register('CTRL_MEAS', meas, wait=True)
+            self.write_register('CTRL_MEAS', meas)
 
         if self.chip_type == 'BME680':
             self.write_register('CONFIG', self.iir_filter << 2)
@@ -528,7 +528,7 @@ class BME280:
 
         # Enter forced mode
         meas = self.os_temp << 5 | self.os_pres << 2 | MODE
-        self.write_register('CTRL_MEAS', meas, wait=True)
+        self.write_register('CTRL_MEAS', meas)
         max_sample_time = self.max_sample_time
         if run_gas:
             max_sample_time += self.gas_heat_duration / 1000
@@ -776,15 +776,12 @@ class BME280:
         params = self.i2c.i2c_read(regs, read_len)
         return bytearray(params['response'])
 
-    def write_register(self, reg_name, data, wait = False):
+    def write_register(self, reg_name, data):
         if type(data) is not list:
             data = [data]
         reg = self.chip_registers[reg_name]
         data.insert(0, reg)
-        if not wait:
         self.i2c.i2c_write(data)
-        else:
-            self.i2c.i2c_write_wait_ack(data)
 
     def get_status(self, eventtime):
         data = {

klippy/extras/bus.py

@@ -43,6 +43,7 @@ class MCU_SPI:
                  cs_active_high=False):
         self.mcu = mcu
         self.bus = bus
+        self.speed = speed
         # Config SPI object (set all CS pins high before spi_set_bus commands)
         self.oid = mcu.create_oid()
         if pin is None:
@@ -51,11 +52,17 @@ class MCU_SPI:
             mcu.add_config_cmd("config_spi oid=%d pin=%s cs_active_high=%d"
                                % (self.oid, pin, cs_active_high))
         # Generate SPI bus config message
+        self.config_fmt_ticks = None
         if sw_pins is not None:
             self.config_fmt = (
                 "spi_set_software_bus oid=%d"
                 " miso_pin=%s mosi_pin=%s sclk_pin=%s mode=%d rate=%d"
                 % (self.oid, sw_pins[0], sw_pins[1], sw_pins[2], mode, speed))
+            self.config_fmt_ticks = (
+                "spi_set_sw_bus oid=%d"
+                " miso_pin=%s mosi_pin=%s sclk_pin=%s mode=%d pulse_ticks=%%d"
+                % (self.oid, sw_pins[0], sw_pins[1],
+                    sw_pins[2], mode))
         else:
             self.config_fmt = (
                 "spi_set_bus oid=%d spi_bus=%%s mode=%d rate=%d"
@@ -78,6 +85,12 @@ class MCU_SPI:
         if '%' in self.config_fmt:
             bus = resolve_bus_name(self.mcu, "spi_bus", self.bus)
             self.config_fmt = self.config_fmt % (bus,)
+        if self.config_fmt_ticks:
+            if self.mcu.try_lookup_command("spi_set_sw_bus oid=%c miso_pin=%u "
+                                           "mosi_pin=%u sclk_pin=%u "
+                                           "mode=%u pulse_ticks=%u"):
+                pulse_ticks = self.mcu.seconds_to_clock(1./self.speed)
+                self.config_fmt = self.config_fmt_ticks % (pulse_ticks,)
         self.mcu.add_config_cmd(self.config_fmt)
         self.spi_send_cmd = self.mcu.lookup_command(
             "spi_send oid=%c data=%*s", cq=self.cmd_queue)
@@ -147,6 +160,8 @@ class MCU_I2C:
         self.bus = bus
         self.i2c_address = addr
         self.oid = self.mcu.create_oid()
+        self.speed = speed
+        self.config_fmt_ticks = None
         mcu.add_config_cmd("config_i2c oid=%d" % (self.oid,))
         # Generate I2C bus config message
         if sw_pins is not None:
@@ -154,6 +169,10 @@ class MCU_I2C:
                 "i2c_set_software_bus oid=%d"
                 " scl_pin=%s sda_pin=%s rate=%d address=%d"
                 % (self.oid, sw_pins[0], sw_pins[1], speed, addr))
+            self.config_fmt_ticks = (
+                "i2c_set_sw_bus oid=%d"
+                " scl_pin=%s sda_pin=%s pulse_ticks=%%d address=%d"
+                % (self.oid, sw_pins[0], sw_pins[1], addr))
         else:
             self.config_fmt = (
                 "i2c_set_bus oid=%d i2c_bus=%%s rate=%d address=%d"
@@ -161,6 +180,13 @@ class MCU_I2C:
         self.cmd_queue = self.mcu.alloc_command_queue()
         self.mcu.register_config_callback(self.build_config)
         self.i2c_write_cmd = self.i2c_read_cmd = None
+        printer = self.mcu.get_printer()
+        printer.register_event_handler("klippy:connect", self._handle_connect)
+        # backward support i2c_write inside the init section
+        self._to_write = []
+    def _handle_connect(self):
+        for data in self._to_write:
+            self.i2c_write(data)
     def get_oid(self):
         return self.oid
     def get_mcu(self):
@@ -173,6 +199,12 @@ class MCU_I2C:
         if '%' in self.config_fmt:
             bus = resolve_bus_name(self.mcu, "i2c_bus", self.bus)
             self.config_fmt = self.config_fmt % (bus,)
+        if self.config_fmt_ticks:
+            if self.mcu.try_lookup_command("i2c_set_sw_bus oid=%c"
+                                           " scl_pin=%u sda_pin=%u"
+                                           " pulse_ticks=%u address=%u"):
+                pulse_ticks = self.mcu.seconds_to_clock(1./self.speed/2)
+                self.config_fmt = self.config_fmt_ticks % (pulse_ticks,)
         self.mcu.add_config_cmd(self.config_fmt)
         self.i2c_write_cmd = self.mcu.lookup_command(
             "i2c_write oid=%c data=%*s", cq=self.cmd_queue)
@@ -182,18 +214,12 @@ class MCU_I2C:
             cq=self.cmd_queue)
     def i2c_write(self, data, minclock=0, reqclock=0):
         if self.i2c_write_cmd is None:
-            # Send setup message via mcu initialization
-            data_msg = "".join(["%02x" % (x,) for x in data])
-            self.mcu.add_config_cmd("i2c_write oid=%d data=%s" % (
-                self.oid, data_msg), is_init=True)
+            self._to_write.append(data)
             return
-        self.i2c_write_cmd.send([self.oid, data],
-                                minclock=minclock, reqclock=reqclock)
-    def i2c_write_wait_ack(self, data, minclock=0, reqclock=0):
         self.i2c_write_cmd.send_wait_ack([self.oid, data],
                                          minclock=minclock, reqclock=reqclock)
-    def i2c_read(self, write, read_len):
-        return self.i2c_read_cmd.send([self.oid, write, read_len])
+    def i2c_read(self, write, read_len, retry=True):
+        return self.i2c_read_cmd.send([self.oid, write, read_len], retry)
 
 def MCU_I2C_from_config(config, default_addr=None, default_speed=100000):
     # Load bus parameters

klippy/extras/buttons.py

@@ -244,6 +244,33 @@ class HalfStepRotaryEncoder(BaseRotaryEncoder):
          BaseRotaryEncoder.R_START | BaseRotaryEncoder.R_DIR_CCW),
     )
 
+class DebounceButton:
+    def __init__(self, config, button_action):
+        self.printer = config.get_printer()
+        self.reactor = self.printer.get_reactor()
+        self.button_action = button_action
+        self.debounce_delay = config.getfloat('debounce_delay', 0., minval=0.)
+        self.logical_state = None
+        self.physical_state = None
+        self.latest_eventtime = None
+    def button_handler(self, eventtime, state):
+        self.physical_state = state
+        self.latest_eventtime = eventtime
+        # if there would be no state transition, ignore the event:
+        if self.logical_state == self.physical_state:
+            return
+        trigger_time = eventtime + self.debounce_delay
+        self.reactor.register_callback(self._debounce_event, trigger_time)
+    def _debounce_event(self, eventtime):
+        # if there would be no state transition, ignore the event:
+        if self.logical_state == self.physical_state:
+            return
+        # if there were more recent events, they supersede this one:
+        if (eventtime - self.debounce_delay) < self.latest_eventtime:
+            return
+        # enact state transition and trigger action
+        self.logical_state = self.physical_state
+        self.button_action(self.latest_eventtime, self.logical_state)
 
 ######################################################################
 # Button registration code
@@ -261,6 +288,14 @@ class PrinterButtons:
             self.adc_buttons[pin] = adc_buttons = MCU_ADC_buttons(
                 self.printer, pin, pullup)
         adc_buttons.setup_button(min_val, max_val, callback)
+    def register_debounce_button(self, pin, callback, config):
+        debounce = DebounceButton(config, callback)
+        return self.register_buttons([pin], debounce.button_handler)
+    def register_debounce_adc_button(self, pin, min_val, max_val, pullup
+                                     , callback, config):
+        debounce = DebounceButton(config, callback)
+        return self.register_adc_button(pin, min_val, max_val, pullup
+                                        , debounce.button_handler)
     def register_adc_button_push(self, pin, min_val, max_val, pullup, callback):
         def helper(eventtime, state, callback=callback):
             if state:

klippy/extras/canbus_stats.py

@@ -0,0 +1,80 @@
+# Report canbus connection status
+#
+# Copyright (C) 2025  Kevin O'Connor <kevin@koconnor.net>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+import logging
+
+class PrinterCANBusStats:
+    def __init__(self, config):
+        self.printer = config.get_printer()
+        self.reactor = self.printer.get_reactor()
+        self.name = config.get_name().split()[-1]
+        self.mcu = None
+        self.get_canbus_status_cmd = None
+        self.status = {'rx_error': None, 'tx_error': None, 'tx_retries': None,
+                       'bus_state': None}
+        self.printer.register_event_handler("klippy:connect",
+                                            self.handle_connect)
+        self.printer.register_event_handler("klippy:shutdown",
+                                            self.handle_shutdown)
+    def handle_shutdown(self):
+        status = self.status.copy()
+        if status['bus_state'] is not None:
+            # Clear bus_state on shutdown to note that the values may be stale
+            status['bus_state'] = 'unknown'
+            self.status = status
+    def handle_connect(self):
+        # Lookup mcu
+        mcu_name = self.name
+        if mcu_name != 'mcu':
+            mcu_name = 'mcu ' + mcu_name
+        self.mcu = self.printer.lookup_object(mcu_name)
+        # Lookup status query command
+        if self.mcu.try_lookup_command("get_canbus_status") is None:
+            return
+        self.get_canbus_status_cmd = self.mcu.lookup_query_command(
+            "get_canbus_status",
+            "canbus_status rx_error=%u tx_error=%u tx_retries=%u"
+            " canbus_bus_state=%u")
+        # Register usb_canbus_state message handling (for usb to canbus bridge)
+        self.mcu.register_response(self.handle_usb_canbus_state,
+                                   "usb_canbus_state")
+        # Register periodic query timer
+        self.reactor.register_timer(self.query_event, self.reactor.NOW)
+    def handle_usb_canbus_state(self, params):
+        discard = params['discard']
+        if discard:
+            logging.warning("USB CANBUS bridge '%s' is discarding!"
+                            % (self.name,))
+        else:
+            logging.warning("USB CANBUS bridge '%s' is no longer discarding."
+                            % (self.name,))
+    def query_event(self, eventtime):
+        prev_rx = self.status['rx_error']
+        prev_tx = self.status['tx_error']
+        prev_retries = self.status['tx_retries']
+        if prev_rx is None:
+            prev_rx = prev_tx = prev_retries = 0
+        params = self.get_canbus_status_cmd.send()
+        rx = prev_rx + ((params['rx_error'] - prev_rx) & 0xffffffff)
+        tx = prev_tx + ((params['tx_error'] - prev_tx) & 0xffffffff)
+        retries = prev_retries + ((params['tx_retries'] - prev_retries)
+                                  & 0xffffffff)
+        state = params['canbus_bus_state']
+        self.status = {'rx_error': rx, 'tx_error': tx, 'tx_retries': retries,
+                       'bus_state': state}
+        return self.reactor.monotonic() + 1.
+    def stats(self, eventtime):
+        status = self.status
+        if status['rx_error'] is None:
+            return (False, '')
+        return (False, 'canstat_%s: bus_state=%s rx_error=%d'
+                ' tx_error=%d tx_retries=%d'
+                % (self.name, status['bus_state'], status['rx_error'],
+                   status['tx_error'], status['tx_retries']))
+    def get_status(self, eventtime):
+        return self.status
+
+def load_config_prefix(config):
+    return PrinterCANBusStats(config)

klippy/extras/display/__init__.py

@@ -12,7 +12,7 @@ def load_config_prefix(config):
     if not config.has_section('display'):
         raise config.error(
             "A primary [display] section must be defined in printer.cfg "
-            "to use auxilary displays")
+            "to use auxiliary displays")
     name = config.get_name().split()[-1]
     if name == "display":
         raise config.error(

klippy/extras/display/font8x14.py

@@ -13,7 +13,7 @@
 # ftp://ftp.simtel.net/pub/simtelnet/msdos/screen/fntcol16.zip
 # (c) Joseph Gil
 #
-# Indivdual fonts are public domain
+# Individual fonts are public domain
 ######################################################################
 
 VGA_FONT = [

klippy/extras/endstop_phase.py

@@ -52,7 +52,7 @@ class PhaseCalc:
 class EndstopPhase:
     def __init__(self, config):
         self.printer = config.get_printer()
-        self.name = config.get_name().split()[1]
+        self.name = " ".join(config.get_name().split()[1:])
         # Obtain step_distance and microsteps from stepper config section
         sconfig = config.getsection(self.name)
         rotation_dist, steps_per_rotation = stepper.parse_step_distance(sconfig)
@@ -118,7 +118,7 @@ class EndstopPhase:
         return delta * self.step_dist
     def handle_home_rails_end(self, homing_state, rails):
         for rail in rails:
-            stepper = rail.get_steppers()[0]
+            stepper = rail.get_endstops()[0][0].get_steppers()[0]
             if stepper.get_name() == self.name:
                 trig_mcu_pos = homing_state.get_trigger_position(self.name)
                 align = self.align_endstop(rail)

klippy/extras/exclude_object.py

@@ -82,24 +82,25 @@ class ExcludeObject:
         self._reset_state()
         self._unregister_transform()
 
-    def _get_extrusion_offsets(self):
-        offset = self.extrusion_offsets.get(
-            self.toolhead.get_extruder().get_name())
+    def _get_extrusion_offsets(self, num_coord):
+        ename = self.toolhead.get_extruder().get_name()
+        offset = self.extrusion_offsets.get(ename)
         if offset is None:
-            offset = [0., 0., 0., 0.]
-            self.extrusion_offsets[self.toolhead.get_extruder().get_name()] = \
-                offset
+            offset = [0.] * num_coord
+            self.extrusion_offsets[ename] = offset
+        if len(offset) < num_coord:
+            offset.extend([0.] * (len(num_coord) - len(offset)))
         return offset
 
     def get_position(self):
-        offset = self._get_extrusion_offsets()
         pos = self.next_transform.get_position()
-        for i in range(4):
+        offset = self._get_extrusion_offsets(len(pos))
+        for i in range(len(pos)):
             self.last_position[i] = pos[i] + offset[i]
         return list(self.last_position)
 
     def _normal_move(self, newpos, speed):
-        offset = self._get_extrusion_offsets()
+        offset = self._get_extrusion_offsets(len(newpos))
 
         if self.initial_extrusion_moves > 0 and \
             self.last_position[3] != newpos[3]:
@@ -122,9 +123,9 @@ class ExcludeObject:
         if (offset[0] != 0 or offset[1] != 0) and \
             (newpos[0] != self.last_position_excluded[0] or \
             newpos[1] != self.last_position_excluded[1]):
-            offset[0] = 0
-            offset[1] = 0
-            offset[2] = 0
+            for i in range(len(newpos)):
+                if i != 3:
+                    offset[i] = 0
             offset[3] += self.extruder_adj
             self.extruder_adj = 0
 
@@ -137,17 +138,18 @@ class ExcludeObject:
             self.extruder_adj = 0
 
         tx_pos = newpos[:]
-        for i in range(4):
+        for i in range(len(newpos)):
             tx_pos[i] = newpos[i] - offset[i]
         self.next_transform.move(tx_pos, speed)
 
     def _ignore_move(self, newpos, speed):
-        offset = self._get_extrusion_offsets()
-        for i in range(3):
+        offset = self._get_extrusion_offsets(len(newpos))
+        for i in range(len(newpos)):
+            if i != 3:
                 offset[i] = newpos[i] - self.last_position_extruded[i]
         offset[3] = offset[3] + newpos[3] - self.last_position[3]
         self.last_position[:] = newpos
-        self.last_position_excluded[:] =self.last_position
+        self.last_position_excluded[:] = self.last_position
         self.max_position_excluded = max(self.max_position_excluded, newpos[3])
 
     def _move_into_excluded_region(self, newpos, speed):

klippy/extras/fan_generic.py

@@ -29,6 +29,7 @@ class PrinterFanGeneric:
             value = float(text)
         except ValueError as e:
             logging.exception("fan_generic template render error")
+            value = 0.
         self.fan.set_speed(value)
     def cmd_SET_FAN_SPEED(self, gcmd):
         speed = gcmd.get_float('SPEED', None, 0.)

klippy/extras/filament_motion_sensor.py

@@ -63,7 +63,7 @@ class EncoderSensor:
     def _extruder_pos_update_event(self, eventtime):
         extruder_pos = self._get_extruder_pos(eventtime)
         # Check for filament runout
-        self.runout_helper.note_filament_present(
+        self.runout_helper.note_filament_present(eventtime,
                 extruder_pos < self.filament_runout_pos)
         return eventtime + CHECK_RUNOUT_TIMEOUT
     def encoder_event(self, eventtime, state):
@@ -71,7 +71,7 @@ class EncoderSensor:
             self._update_filament_runout_pos(eventtime)
             # Check for filament insertion
             # Filament is always assumed to be present on an encoder event
-            self.runout_helper.note_filament_present(True)
+            self.runout_helper.note_filament_present(eventtime, True)
 
 def load_config_prefix(config):
     return EncoderSensor(config)

klippy/extras/filament_switch_sensor.py

@@ -5,6 +5,7 @@
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
 
+
 class RunoutHelper:
     def __init__(self, config):
         self.name = config.get_name().split()[-1]
@@ -24,7 +25,7 @@ class RunoutHelper:
             self.insert_gcode = gcode_macro.load_template(
                 config, 'insert_gcode')
         self.pause_delay = config.getfloat('pause_delay', .5, above=.0)
-        self.event_delay = config.getfloat('event_delay', 3., above=0.)
+        self.event_delay = config.getfloat('event_delay', 3., minval=.0)
         # Internal state
         self.min_event_systime = self.reactor.NEVER
         self.filament_present = False
@@ -59,19 +60,20 @@ class RunoutHelper:
         except Exception:
             logging.exception("Script running error")
         self.min_event_systime = self.reactor.monotonic() + self.event_delay
-    def note_filament_present(self, is_filament_present):
+    def note_filament_present(self, eventtime, is_filament_present):
         if is_filament_present == self.filament_present:
             return
         self.filament_present = is_filament_present
-        eventtime = self.reactor.monotonic()
+
         if eventtime < self.min_event_systime or not self.sensor_enabled:
             # do not process during the initialization time, duplicates,
             # during the event delay time, while an event is running, or
             # when the sensor is disabled
             return
         # Determine "printing" status
+        now = self.reactor.monotonic()
         idle_timeout = self.printer.lookup_object("idle_timeout")
-        is_printing = idle_timeout.get_status(eventtime)["state"] == "Printing"
+        is_printing = idle_timeout.get_status(now)["state"] == "Printing"
         # Perform filament action associated with status change (if any)
         if is_filament_present:
             if not is_printing and self.insert_gcode is not None:
@@ -79,14 +81,14 @@ class RunoutHelper:
                 self.min_event_systime = self.reactor.NEVER
                 logging.info(
                     "Filament Sensor %s: insert event detected, Time %.2f" %
-                    (self.name, eventtime))
+                    (self.name, now))
                 self.reactor.register_callback(self._insert_event_handler)
         elif is_printing and self.runout_gcode is not None:
             # runout detected
             self.min_event_systime = self.reactor.NEVER
             logging.info(
                 "Filament Sensor %s: runout event detected, Time %.2f" %
-                (self.name, eventtime))
+                (self.name, now))
             self.reactor.register_callback(self._runout_event_handler)
     def get_status(self, eventtime):
         return {
@@ -108,11 +110,12 @@ class SwitchSensor:
         printer = config.get_printer()
         buttons = printer.load_object(config, 'buttons')
         switch_pin = config.get('switch_pin')
-        buttons.register_buttons([switch_pin], self._button_handler)
+        buttons.register_debounce_button(switch_pin, self._button_handler
+                                         , config)
         self.runout_helper = RunoutHelper(config)
         self.get_status = self.runout_helper.get_status
     def _button_handler(self, eventtime, state):
-        self.runout_helper.note_filament_present(state)
+        self.runout_helper.note_filament_present(eventtime, state)
 
 def load_config_prefix(config):
     return SwitchSensor(config)

klippy/extras/firmware_retraction.py

@@ -43,7 +43,7 @@ class FirmwareRetraction:
         self.unretract_length = (self.retract_length
                                  + self.unretract_extra_length)
         self.is_retracted = False
-    cmd_GET_RETRACTION_help = ("Report firmware retraction paramters")
+    cmd_GET_RETRACTION_help = ("Report firmware retraction parameters")
     def cmd_GET_RETRACTION(self, gcmd):
         gcmd.respond_info("RETRACT_LENGTH=%.5f RETRACT_SPEED=%.5f"
                           " UNRETRACT_EXTRA_LENGTH=%.5f UNRETRACT_SPEED=%.5f"

klippy/extras/force_move.py

@@ -33,10 +33,10 @@ class ForceMove:
         self.printer = config.get_printer()
         self.steppers = {}
         # Setup iterative solver
+        self.motion_queuing = self.printer.load_object(config, 'motion_queuing')
+        self.trapq = self.motion_queuing.allocate_trapq()
+        self.trapq_append = self.motion_queuing.lookup_trapq_append()
         ffi_main, ffi_lib = chelper.get_ffi()
-        self.trapq = ffi_main.gc(ffi_lib.trapq_alloc(), ffi_lib.trapq_free)
-        self.trapq_append = ffi_lib.trapq_append
-        self.trapq_finalize_moves = ffi_lib.trapq_finalize_moves
         self.stepper_kinematics = ffi_main.gc(
             ffi_lib.cartesian_stepper_alloc(b'x'), ffi_lib.free)
         # Register commands
@@ -85,14 +85,12 @@ class ForceMove:
         self.trapq_append(self.trapq, print_time, accel_t, cruise_t, accel_t,
                           0., 0., 0., axis_r, 0., 0., 0., cruise_v, accel)
         print_time = print_time + accel_t + cruise_t + accel_t
-        stepper.generate_steps(print_time)
-        self.trapq_finalize_moves(self.trapq, print_time + 99999.9,
-                                  print_time + 99999.9)
-        stepper.set_trapq(prev_trapq)
-        stepper.set_stepper_kinematics(prev_sk)
         toolhead.note_mcu_movequeue_activity(print_time)
         toolhead.dwell(accel_t + cruise_t + accel_t)
         toolhead.flush_step_generation()
+        stepper.set_trapq(prev_trapq)
+        stepper.set_stepper_kinematics(prev_sk)
+        self.motion_queuing.wipe_trapq(self.trapq)
     def _lookup_stepper(self, gcmd):
         name = gcmd.get('STEPPER')
         if name not in self.steppers:
@@ -131,12 +129,19 @@ class ForceMove:
         x = gcmd.get_float('X', curpos[0])
         y = gcmd.get_float('Y', curpos[1])
         z = gcmd.get_float('Z', curpos[2])
-        clear = gcmd.get('CLEAR', '').lower()
-        clear_axes = "".join([a for a in "xyz" if a in clear])
-        logging.info("SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f clear=%s",
-                     x, y, z, clear_axes)
-        toolhead.set_position([x, y, z, curpos[3]], homing_axes="xyz")
-        toolhead.get_kinematics().clear_homing_state(clear_axes)
+        set_homed = gcmd.get('SET_HOMED', 'xyz').lower()
+        set_homed_axes = "".join([a for a in "xyz" if a in set_homed])
+        if gcmd.get('CLEAR_HOMED', None) is None:
+            # "CLEAR" is an alias for "CLEAR_HOMED"; should deprecate
+            clear_homed = gcmd.get('CLEAR', '').lower()
+        else:
+            clear_homed = gcmd.get('CLEAR_HOMED', '').lower()
+        clear_homed_axes = "".join([a for a in "xyz" if a in clear_homed])
+        logging.info("SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f"
+                     " set_homed=%s clear_homed=%s",
+                     x, y, z, set_homed_axes, clear_homed_axes)
+        toolhead.set_position([x, y, z], homing_axes=set_homed_axes)
+        toolhead.get_kinematics().clear_homing_state(clear_homed_axes)
 
 def load_config(config):
     return ForceMove(config)

klippy/extras/garbage_collection.py

@@ -0,0 +1,31 @@
+# Garbage collection optimizations
+#
+# Copyright (C) 2025  Branden Cash <ammmze@gmail.com>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+import gc
+import logging
+
+class GarbageCollection:
+    def __init__(self, config):
+        self.printer = config.get_printer()
+        # feature check ... freeze/unfreeze is only available in python 3.7+
+        can_freeze = hasattr(gc, 'freeze') and hasattr(gc, 'unfreeze')
+        if can_freeze:
+            self.printer.register_event_handler("klippy:ready",
+                                                self._handle_ready)
+            self.printer.register_event_handler("klippy:disconnect",
+                                                self._handle_disconnect)
+
+    def _handle_ready(self):
+        logging.debug("Running full garbage collection and freezing")
+        for n in range(3):
+            gc.collect(n)
+        gc.freeze()
+
+    def _handle_disconnect(self):
+        logging.debug("Unfreezing garbage collection")
+        gc.unfreeze()
+
+def load_config(config):
+    return GarbageCollection(config)

klippy/extras/gcode_button.py

@@ -5,6 +5,7 @@
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
 
+
 class GCodeButton:
     def __init__(self, config):
         self.printer = config.get_printer()
@@ -13,12 +14,13 @@ class GCodeButton:
         self.last_state = 0
         buttons = self.printer.load_object(config, "buttons")
         if config.get('analog_range', None) is None:
-            buttons.register_buttons([self.pin], self.button_callback)
+            buttons.register_debounce_button(self.pin, self.button_callback
+                                             , config)
         else:
             amin, amax = config.getfloatlist('analog_range', count=2)
             pullup = config.getfloat('analog_pullup_resistor', 4700., above=0.)
-            buttons.register_adc_button(self.pin, amin, amax, pullup,
-                                        self.button_callback)
+            buttons.register_debounce_adc_button(self.pin, amin, amax, pullup,
+                                        self.button_callback, config)
         gcode_macro = self.printer.load_object(config, 'gcode_macro')
         self.press_template = gcode_macro.load_template(config, 'press_gcode')
         self.release_template = gcode_macro.load_template(config,

klippy/extras/gcode_macro.py

@@ -49,6 +49,12 @@ class TemplateWrapper:
         self.create_template_context = gcode_macro.create_template_context
         try:
             self.template = env.from_string(script)
+        except jinja2.exceptions.TemplateSyntaxError as e:
+            lines = script.splitlines()
+            msg = "Error loading template '%s'\nline %s: %s # %s" % (
+                name, e.lineno, lines[e.lineno-1], e.message)
+            logging.exception(msg)
+            raise self.gcode.error(msg)
         except Exception as e:
             msg = "Error loading template '%s': %s" % (
                  name, traceback.format_exception_only(type(e), e)[-1])
@@ -172,8 +178,8 @@ class GCodeMacro:
             literal = ast.literal_eval(value)
             json.dumps(literal, separators=(',', ':'))
         except (SyntaxError, TypeError, ValueError) as e:
-            raise gcmd.error("Unable to parse '%s' as a literal: %s" %
-                             (value, e))
+            raise gcmd.error("Unable to parse '%s' as a literal: %s in '%s'" %
+                             (value, e, gcmd.get_commandline()))
         v = dict(self.variables)
         v[variable] = literal
         self.variables = v

klippy/extras/gcode_move.py

@@ -1,6 +1,6 @@
 # G-Code G1 movement commands (and associated coordinate manipulation)
 #
-# Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2025  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
@@ -14,6 +14,8 @@ class GCodeMove:
                                        self.reset_last_position)
         printer.register_event_handler("toolhead:manual_move",
                                        self.reset_last_position)
+        printer.register_event_handler("toolhead:update_extra_axes",
+                                       self._update_extra_axes)
         printer.register_event_handler("gcode:command_error",
                                        self.reset_last_position)
         printer.register_event_handler("extruder:activate_extruder",
@@ -42,6 +44,7 @@ class GCodeMove:
         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.axis_map = {'X':0, 'Y': 1, 'Z': 2, 'E': 3}
         self.speed = 25.
         self.speed_factor = 1. / 60.
         self.extrude_factor = 1.
@@ -102,35 +105,46 @@ class GCodeMove:
             'extrude_factor': self.extrude_factor,
             'absolute_coordinates': self.absolute_coord,
             'absolute_extrude': self.absolute_extrude,
-            'homing_origin': self.Coord(*self.homing_position),
-            'position': self.Coord(*self.last_position),
-            'gcode_position': self.Coord(*move_position),
+            'homing_origin': self.Coord(*self.homing_position[:4]),
+            'position': self.Coord(*self.last_position[:4]),
+            'gcode_position': self.Coord(*move_position[:4]),
         }
     def reset_last_position(self):
         if self.is_printer_ready:
             self.last_position = self.position_with_transform()
+    def _update_extra_axes(self):
+        toolhead = self.printer.lookup_object('toolhead')
+        axis_map = {'X':0, 'Y': 1, 'Z': 2, 'E': 3}
+        extra_axes = toolhead.get_extra_axes()
+        for index, ea in enumerate(extra_axes):
+            if ea is None:
+                continue
+            gcode_id = ea.get_axis_gcode_id()
+            if gcode_id is None or gcode_id in axis_map or gcode_id in "FN":
+                continue
+            axis_map[gcode_id] = index
+        self.axis_map = axis_map
+        self.base_position[4:] = [0.] * (len(extra_axes) - 4)
+        self.reset_last_position()
     # G-Code movement commands
     def cmd_G1(self, gcmd):
         # Move
         params = gcmd.get_command_parameters()
         try:
-            for pos, axis in enumerate('XYZ'):
+            for axis, pos in self.axis_map.items():
                 if axis in params:
                     v = float(params[axis])
-                    if not self.absolute_coord:
+                    absolute_coord = self.absolute_coord
+                    if axis == 'E':
+                        v *= self.extrude_factor
+                        if not self.absolute_extrude:
+                            absolute_coord = False
+                    if not 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.:
@@ -169,7 +183,7 @@ class GCodeMove:
                     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)
+            self.base_position[:4] = self.last_position[:4]
     def cmd_M114(self, gcmd):
         # Get Current Position
         p = self._get_gcode_position()
@@ -227,7 +241,7 @@ class GCodeMove:
         # Restore state
         self.absolute_coord = state['absolute_coord']
         self.absolute_extrude = state['absolute_extrude']
-        self.base_position = list(state['base_position'])
+        self.base_position[:4] = state['base_position'][:4]
         self.homing_position = list(state['homing_position'])
         self.speed = state['speed']
         self.speed_factor = state['speed_factor']
@@ -255,7 +269,7 @@ class GCodeMove:
         kinfo = zip("XYZ", kin.calc_position(dict(cinfo)))
         kin_pos = " ".join(["%s:%.6f" % (a, v) for a, v in kinfo])
         toolhead_pos = " ".join(["%s:%.6f" % (a, v) for a, v in zip(
-            "XYZE", toolhead.get_position())])
+            "XYZE", toolhead.get_position()[:4])])
         gcode_pos = " ".join(["%s:%.6f"  % (a, v)
                               for a, v in zip("XYZE", self.last_position)])
         base_pos = " ".join(["%s:%.6f"  % (a, v)

klippy/extras/hall_filament_width_sensor.py

@@ -125,7 +125,7 @@ class HallFilamentWidthSensor:
         # Update filament array for lastFilamentWidthReading
         self.update_filament_array(last_epos)
         # Check runout
-        self.runout_helper.note_filament_present(
+        self.runout_helper.note_filament_present(eventtime,
             self.runout_dia_min <= self.diameter <= self.runout_dia_max)
         # Does filament exists
         if self.diameter > 0.5:
@@ -209,10 +209,12 @@ class HallFilamentWidthSensor:
                       +self.lastFilamentWidthReading2))
         gcmd.respond_info(response)
     def get_status(self, eventtime):
-        return {'Diameter': self.diameter,
+        status = self.runout_helper.get_status(eventtime)
+        status.update({'Diameter': self.diameter,
                 'Raw':(self.lastFilamentWidthReading+
                  self.lastFilamentWidthReading2),
-                'is_active':self.is_active}
+                'is_active':self.is_active})
+        return status
     def cmd_log_enable(self, gcmd):
         self.is_log = True
         gcmd.respond_info("Filament width logging Turned On")

klippy/extras/heaters.py

@@ -1,6 +1,6 @@
 # Tracking of PWM controlled heaters and their temperature control
 #
-# Copyright (C) 2016-2020  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2025  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import os, logging, threading
@@ -11,10 +11,11 @@ import os, logging, threading
 ######################################################################
 
 KELVIN_TO_CELSIUS = -273.15
-MAX_HEAT_TIME = 5.0
+MAX_HEAT_TIME = 3.0
 AMBIENT_TEMP = 25.
 PID_PARAM_BASE = 255.
 MAX_MAINTHREAD_TIME = 5.0
+QUELL_STALE_TIME = 7.0
 
 class Heater:
     def __init__(self, config, sensor):
@@ -74,7 +75,8 @@ class Heater:
             # No significant change in value - can suppress update
             return
         pwm_time = read_time + self.pwm_delay
-        self.next_pwm_time = pwm_time + 0.75 * MAX_HEAT_TIME
+        self.next_pwm_time = (pwm_time + MAX_HEAT_TIME
+                              - (3. * self.pwm_delay + 0.001))
         self.last_pwm_value = value
         self.mcu_pwm.set_pwm(pwm_time, value)
         #logging.debug("%s: pwm=%.3f@%.3f (from %.3f@%.3f [%.3f])",
@@ -110,9 +112,10 @@ class Heater:
         with self.lock:
             self.target_temp = degrees
     def get_temp(self, eventtime):
-        print_time = self.mcu_pwm.get_mcu().estimated_print_time(eventtime) - 5.
+        est_print_time = self.mcu_pwm.get_mcu().estimated_print_time(eventtime)
+        quell_time = est_print_time - QUELL_STALE_TIME
         with self.lock:
-            if self.last_temp_time < print_time:
+            if self.last_temp_time < quell_time:
                 return 0., self.target_temp
             return self.smoothed_temp, self.target_temp
     def check_busy(self, eventtime):

klippy/extras/homing.py

@@ -45,7 +45,7 @@ class StepperPosition:
 class HomingMove:
     def __init__(self, printer, endstops, toolhead=None):
         self.printer = printer
-        self.endstops = endstops
+        self.endstops = [es for es in endstops if es[0].get_steppers()]
         if toolhead is None:
             toolhead = printer.lookup_object('toolhead')
         self.toolhead = toolhead
@@ -71,7 +71,9 @@ class HomingMove:
             sname = stepper.get_name()
             kin_spos[sname] += offsets.get(sname, 0) * stepper.get_step_dist()
         thpos = self.toolhead.get_position()
-        return list(kin.calc_position(kin_spos))[:3] + thpos[3:]
+        cpos = kin.calc_position(kin_spos)
+        return [cp if cp is not None else tp
+                for cp, tp in zip(cpos, thpos[:3])] + thpos[3:]
     def homing_move(self, movepos, speed, probe_pos=False,
                     triggered=True, check_triggered=True):
         # Notify start of homing/probing move
@@ -233,6 +235,10 @@ class Homing:
                         for s in kin.get_steppers()}
             newpos = kin.calc_position(kin_spos)
             for axis in force_axes:
+                if newpos[axis] is None:
+                    raise self.printer.command_error(
+                            "Cannot determine position of toolhead on "
+                            "axis %s after homing" % "xyz"[axis])
                 homepos[axis] = newpos[axis]
             self.toolhead.set_position(homepos)
 

klippy/extras/htu21d.py

@@ -15,7 +15,7 @@ from . import bus
 #       Si7013 - Untested
 #       Si7020 - Untested
 #       Si7021 - Tested on Pico MCU
-#       SHT21  - Untested
+#       SHT21  - Tested on Linux MCU.
 #
 ######################################################################
 
@@ -34,7 +34,7 @@ HTU21D_COMMANDS = {
 
 }
 
-HTU21D_RESOLUTION_MASK = 0x7E;
+HTU21D_RESOLUTION_MASK = 0x7E
 HTU21D_RESOLUTIONS = {
     'TEMP14_HUM12':int('00000000',2),
     'TEMP13_HUM10':int('10000000',2),
@@ -42,31 +42,40 @@ HTU21D_RESOLUTIONS = {
     'TEMP11_HUM11':int('10000001',2)
 }
 
+ID_MAP = {
+    0x0D: 'SI7013',
+    0x14: 'SI7020',
+    0x15: 'SI7021',
+    0x31: 'SHT21',
+    0x01: 'SHT21',
+    0x32: 'HTU21D',
+}
+
 # Device with conversion time for tmp/resolution bit
 # The format is:
 #  <CHIPNAME>:{id:<ID>, ..<RESOlUTION>:[<temp time>,<humidity time>].. }
 HTU21D_DEVICES = {
-    'SI7013':{'id':0x0D,
+    'SI7013':{
         'TEMP14_HUM12':[.11,.12],
         'TEMP13_HUM10':[ .7, .5],
         'TEMP12_HUM08':[ .4, .4],
         'TEMP11_HUM11':[ .3, .7]},
-    'SI7020':{'id':0x14,
+    'SI7020':{
         'TEMP14_HUM12':[.11,.12],
         'TEMP13_HUM10':[ .7, .5],
         'TEMP12_HUM08':[ .4, .4],
         'TEMP11_HUM11':[ .3, .7]},
-    'SI7021':{'id':0x15,
+    'SI7021':{
         'TEMP14_HUM12':[.11,.12],
         'TEMP13_HUM10':[ .7, .5],
         'TEMP12_HUM08':[ .4, .4],
         'TEMP11_HUM11':[ .3, .7]},
-    'SHT21': {'id':0x31,
+    'SHT21': {
         'TEMP14_HUM12':[.85,.29],
         'TEMP13_HUM10':[.43, .9],
         'TEMP12_HUM08':[.22, .4],
         'TEMP11_HUM11':[.11,.15]},
-    'HTU21D':{'id':0x32,
+    'HTU21D':{
         'TEMP14_HUM12':[.50,.16],
         'TEMP13_HUM10':[.25, .5],
         'TEMP12_HUM08':[.13, .3],
@@ -128,19 +137,16 @@ class HTU21D:
         if self._chekCRC8(rdevId) != checksum:
             logging.warning("htu21d: Reading deviceId !Checksum error!")
         rdevId = rdevId >> 8
-        deviceId_list = list(
-            filter(
-              lambda elem: HTU21D_DEVICES[elem]['id'] == rdevId,HTU21D_DEVICES)
-            )
-        if len(deviceId_list) != 0:
-            logging.info("htu21d: Found Device Type %s" % deviceId_list[0])
+        guess_dev = ID_MAP.get(rdevId, "Unknown")
+        if guess_dev == self.deviceId:
+            logging.info("htu21d: Found Device Type %s" % guess_dev)
         else:
             logging.warning("htu21d: Unknown Device ID %#x " % rdevId)
 
-        if self.deviceId != deviceId_list[0]:
+        if self.deviceId != guess_dev:
             logging.warning(
-                "htu21d: Found device %s. Forcing to type %s as config.",
-                 deviceId_list[0],self.deviceId)
+                "htu21d: Found device %s. Forcing to type %s as config." %
+                 (guess_dev, self.deviceId))
 
         # Set Resolution
         params = self.i2c.i2c_read([HTU21D_COMMANDS['READ']], 1)
@@ -152,7 +158,7 @@ class HTU21D:
 
     def _sample_htu21d(self, eventtime):
         try:
-            # Read Temeprature
+            # Read Temperature
             if self.hold_master_mode:
                 params = self.i2c.i2c_write([HTU21D_COMMANDS['HTU21D_TEMP']])
             else:

klippy/extras/hx71x.py

@@ -51,12 +51,9 @@ class HX71xBase:
         self.batch_bulk = bulk_sensor.BatchBulkHelper(
             self.printer, self._process_batch, self._start_measurements,
             self._finish_measurements, UPDATE_INTERVAL)
-        # publish raw samples to the socket
-        dump_path = "%s/dump_%s" % (sensor_type, sensor_type)
-        hdr = {'header': ('time', 'counts', 'value')}
-        self.batch_bulk.add_mux_endpoint(dump_path, "sensor", self.name, hdr)
         # Command Configuration
         self.query_hx71x_cmd = None
+        self.attach_probe_cmd = None
         mcu.add_config_cmd(
             "config_hx71x oid=%d gain_channel=%d dout_pin=%s sclk_pin=%s"
             % (self.oid, self.gain_channel, self.dout_pin, self.sclk_pin))
@@ -68,10 +65,13 @@ class HX71xBase:
     def _build_config(self):
         self.query_hx71x_cmd = self.mcu.lookup_command(
             "query_hx71x oid=%c rest_ticks=%u")
+        self.attach_probe_cmd = self.mcu.lookup_command(
+            "hx71x_attach_load_cell_probe oid=%c load_cell_probe_oid=%c")
         self.ffreader.setup_query_command("query_hx71x_status oid=%c",
                                           oid=self.oid,
                                           cq=self.mcu.alloc_command_queue())
 
+
     def get_mcu(self):
         return self.mcu
 
@@ -87,6 +87,9 @@ class HX71xBase:
     def add_client(self, callback):
         self.batch_bulk.add_client(callback)
 
+    def attach_load_cell_probe(self, load_cell_probe_oid):
+        self.attach_probe_cmd.send([self.oid, load_cell_probe_oid])
+
     # Measurement decoding
     def _convert_samples(self, samples):
         adc_factor = 1. / (1 << 23)

klippy/extras/icm20948.py

@@ -0,0 +1,173 @@
+# Support for reading acceleration data from an icm20948 chip
+#
+# Copyright (C) 2024 Paul Hansel <github@paulhansel.com>
+# Copyright (C) 2022  Harry Beyel <harry3b9@gmail.com>
+# Copyright (C) 2020-2021 Kevin O'Connor <kevin@koconnor.net>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+
+# From https://invensense.tdk.com/wp-content/uploads/
+#               2016/06/DS-000189-ICM-20948-v1.3.pdf
+
+import logging
+from . import bus, adxl345, bulk_sensor
+
+ICM20948_ADDR =         0x68
+
+ICM_DEV_IDS = {
+    0xEA: "icm-20948",
+    #everything above are normal ICM IDs
+}
+
+# ICM20948 registers
+REG_DEVID =             0x00 # 0xEA
+REG_FIFO_EN =           0x67 # FIFO_EN_2
+REG_ACCEL_SMPLRT_DIV1 = 0x10 # MSB
+REG_ACCEL_SMPLRT_DIV2 = 0x11 # LSB
+REG_ACCEL_CONFIG =      0x14
+REG_USER_CTRL =         0x03
+REG_PWR_MGMT_1 =        0x06
+REG_PWR_MGMT_2 =        0x07
+REG_INT_STATUS =        0x19
+REG_BANK_SEL =          0x7F
+
+SAMPLE_RATE_DIVS = { 4500: 0x00 }
+
+SET_BANK_0 =            0x00
+SET_BANK_1 =            0x10
+SET_BANK_2 =            0x20
+SET_BANK_3 =            0x30
+SET_ACCEL_CONFIG =      0x06 # 16g full scale, 1209Hz BW, 4.5kHz samp rate
+SET_PWR_MGMT_1_WAKE =   0x01
+SET_PWR_MGMT_1_SLEEP =  0x41
+SET_PWR_MGMT_2_ACCEL_ON = 0x07
+SET_PWR_MGMT_2_OFF =    0x3F
+SET_USER_FIFO_RESET =   0x0E
+SET_USER_FIFO_EN =      0x40
+SET_ENABLE_FIFO  =      0x10
+SET_DISABLE_FIFO =      0x00
+
+FREEFALL_ACCEL = 9.80665 * 1000.
+# SCALE = 1/2048 g/LSB @16g scale * Earth gravity in mm/s**2
+SCALE = 0.00048828125 * FREEFALL_ACCEL
+
+FIFO_SIZE = 512
+
+BATCH_UPDATES = 0.100
+
+# Printer class that controls ICM20948 chip
+class ICM20948:
+    def __init__(self, config):
+        self.printer = config.get_printer()
+        adxl345.AccelCommandHelper(config, self)
+        self.axes_map = adxl345.read_axes_map(config, SCALE, SCALE, SCALE)
+        self.data_rate = config.getint('rate', 4500)
+        if self.data_rate not in SAMPLE_RATE_DIVS:
+            raise config.error("Invalid rate parameter: %d" % (self.data_rate,))
+        # Setup mcu sensor_icm20948 bulk query code
+        self.i2c = bus.MCU_I2C_from_config(config,
+                                           default_addr=ICM20948_ADDR,
+                                           default_speed=400000)
+        self.mcu = mcu = self.i2c.get_mcu()
+        self.oid = mcu.create_oid()
+        self.query_icm20948_cmd = None
+        mcu.register_config_callback(self._build_config)
+        # Bulk sample message reading
+        chip_smooth = self.data_rate * BATCH_UPDATES * 2
+        self.ffreader = bulk_sensor.FixedFreqReader(mcu, chip_smooth, ">hhh")
+        self.last_error_count = 0
+        # Process messages in batches
+        self.batch_bulk = bulk_sensor.BatchBulkHelper(
+            self.printer, self._process_batch,
+            self._start_measurements, self._finish_measurements, BATCH_UPDATES)
+        self.name = config.get_name().split()[-1]
+        hdr = ('time', 'x_acceleration', 'y_acceleration', 'z_acceleration')
+        self.batch_bulk.add_mux_endpoint("icm20948/dump_icm20948", "sensor",
+                                         self.name, {'header': hdr})
+    def _build_config(self):
+        cmdqueue = self.i2c.get_command_queue()
+        self.mcu.add_config_cmd("config_icm20948 oid=%d i2c_oid=%d"
+                           % (self.oid, self.i2c.get_oid()))
+        self.mcu.add_config_cmd("query_icm20948 oid=%d rest_ticks=0"
+                           % (self.oid,), on_restart=True)
+        self.query_icm20948_cmd = self.mcu.lookup_command(
+            "query_icm20948 oid=%c rest_ticks=%u", cq=cmdqueue)
+        self.ffreader.setup_query_command("query_icm20948_status oid=%c",
+                                          oid=self.oid, cq=cmdqueue)
+    def read_reg(self, reg):
+        params = self.i2c.i2c_read([reg], 1)
+        return bytearray(params['response'])[0]
+    def set_reg(self, reg, val, minclock=0):
+        self.i2c.i2c_write([reg, val & 0xFF], minclock=minclock)
+    def start_internal_client(self):
+        aqh = adxl345.AccelQueryHelper(self.printer)
+        self.batch_bulk.add_client(aqh.handle_batch)
+        return aqh
+    # Measurement decoding
+    def _convert_samples(self, samples):
+        (x_pos, x_scale), (y_pos, y_scale), (z_pos, z_scale) = self.axes_map
+        count = 0
+        for ptime, rx, ry, rz in samples:
+            raw_xyz = (rx, ry, rz)
+            x = round(raw_xyz[x_pos] * x_scale, 6)
+            y = round(raw_xyz[y_pos] * y_scale, 6)
+            z = round(raw_xyz[z_pos] * z_scale, 6)
+            samples[count] = (round(ptime, 6), x, y, z)
+            count += 1
+    # Start, stop, and process message batches
+    def _start_measurements(self):
+        # In case of miswiring, testing ICM20948 device ID prevents treating
+        # noise or wrong signal as a correctly initialized device
+        dev_id = self.read_reg(REG_DEVID)
+        if dev_id not in ICM_DEV_IDS.keys():
+            raise self.printer.command_error(
+                "Invalid mpu id (got %x).\n"
+                "This is generally indicative of connection problems\n"
+                "(e.g. faulty wiring) or a faulty chip."
+                % (dev_id))
+        else:
+            logging.info("Found %s with id %x"% (ICM_DEV_IDS[dev_id], dev_id))
+        # Setup chip in requested query rate
+        self.set_reg(REG_PWR_MGMT_1, SET_PWR_MGMT_1_WAKE)
+        self.set_reg(REG_PWR_MGMT_2, SET_PWR_MGMT_2_ACCEL_ON)
+        # Don't add 20ms pause for accelerometer chip wake up
+        self.read_reg(REG_DEVID) # Dummy read to ensure queues flushed
+        self.set_reg(REG_ACCEL_SMPLRT_DIV1, SAMPLE_RATE_DIVS[self.data_rate])
+        self.set_reg(REG_ACCEL_SMPLRT_DIV2, SAMPLE_RATE_DIVS[self.data_rate])
+        self.set_reg(REG_BANK_SEL, SET_BANK_2)
+        self.set_reg(REG_ACCEL_CONFIG, SET_ACCEL_CONFIG)
+        self.set_reg(REG_BANK_SEL, SET_BANK_0)
+        # Reset fifo
+        self.set_reg(REG_FIFO_EN, SET_DISABLE_FIFO)
+        self.set_reg(REG_USER_CTRL, SET_USER_FIFO_RESET)
+        self.set_reg(REG_USER_CTRL, SET_USER_FIFO_EN)
+        self.read_reg(REG_INT_STATUS) # clear FIFO overflow flag
+        # Start bulk reading
+        rest_ticks = self.mcu.seconds_to_clock(4. / self.data_rate)
+        self.query_icm20948_cmd.send([self.oid, rest_ticks])
+        self.set_reg(REG_FIFO_EN, SET_ENABLE_FIFO)
+        logging.info("ICM20948 starting '%s' measurements", self.name)
+        # Initialize clock tracking
+        self.ffreader.note_start()
+        self.last_error_count = 0
+    def _finish_measurements(self):
+        # Halt bulk reading
+        self.set_reg(REG_FIFO_EN, SET_DISABLE_FIFO)
+        self.query_icm20948_cmd.send_wait_ack([self.oid, 0])
+        self.ffreader.note_end()
+        logging.info("ICM20948 finished '%s' measurements", self.name)
+        self.set_reg(REG_PWR_MGMT_1, SET_PWR_MGMT_1_SLEEP)
+        self.set_reg(REG_PWR_MGMT_2, SET_PWR_MGMT_2_OFF)
+    def _process_batch(self, eventtime):
+        samples = self.ffreader.pull_samples()
+        self._convert_samples(samples)
+        if not samples:
+            return {}
+        return {'data': samples, 'errors': self.last_error_count,
+                'overflows': self.ffreader.get_last_overflows()}
+
+def load_config(config):
+    return ICM20948(config)
+
+def load_config_prefix(config):
+    return ICM20948(config)

klippy/extras/idle_timeout.py

@@ -35,7 +35,9 @@ class IdleTimeout:
         printing_time = 0.
         if self.state == "Printing":
             printing_time = eventtime - self.last_print_start_systime
-        return { "state": self.state, "printing_time": printing_time }
+        return {"state": self.state,
+                "printing_time": printing_time,
+                "idle_timeout": self.idle_timeout}
     def handle_ready(self):
         self.toolhead = self.printer.lookup_object('toolhead')
         self.timeout_timer = self.reactor.register_timer(self.timeout_handler)

klippy/extras/input_shaper.py

@@ -69,6 +69,8 @@ class AxisInputShaper:
             ffi_lib.input_shaper_set_shaper_params(
                     sk, self.axis.encode(), self.n, self.A, self.T)
         return success
+    def is_enabled(self):
+        return self.n > 0
     def disable_shaping(self):
         if self.saved is None and self.n:
             self.saved = (self.n, self.A, self.T)
@@ -89,6 +91,8 @@ class InputShaper:
     def __init__(self, config):
         self.printer = config.get_printer()
         self.printer.register_event_handler("klippy:connect", self.connect)
+        self.printer.register_event_handler("dual_carriage:update_kinematics",
+                                            self._update_kinematics)
         self.toolhead = None
         self.shapers = [AxisInputShaper('x', config),
                         AxisInputShaper('y', config)]
@@ -103,17 +107,23 @@ class InputShaper:
         return self.shapers
     def connect(self):
         self.toolhead = self.printer.lookup_object("toolhead")
+        dual_carriage = self.printer.lookup_object('dual_carriage', None)
+        if dual_carriage is not None:
+            for shaper in self.shapers:
+                if shaper.is_enabled():
+                    raise self.printer.config_error(
+                            'Input shaper parameters cannot be configured via'
+                            ' [input_shaper] section with dual_carriage(s) '
+                            ' enabled. Refer to Klipper documentation on how '
+                            ' to configure input shaper for dual_carriage(s).')
+            return
         # Configure initial values
         self._update_input_shaping(error=self.printer.config_error)
     def _get_input_shaper_stepper_kinematics(self, stepper):
         # Lookup stepper kinematics
         sk = stepper.get_stepper_kinematics()
-        if sk in self.orig_stepper_kinematics:
-            # Already processed this stepper kinematics unsuccessfully
-            return None
         if sk in self.input_shaper_stepper_kinematics:
             return sk
-        self.orig_stepper_kinematics.append(sk)
         ffi_main, ffi_lib = chelper.get_ffi()
         is_sk = ffi_main.gc(ffi_lib.input_shaper_alloc(), ffi_lib.free)
         stepper.set_stepper_kinematics(is_sk)
@@ -121,8 +131,27 @@ class InputShaper:
         if res < 0:
             stepper.set_stepper_kinematics(sk)
             return None
+        self.orig_stepper_kinematics.append(sk)
         self.input_shaper_stepper_kinematics.append(is_sk)
         return is_sk
+    def _update_kinematics(self):
+        if self.toolhead is None:
+            # Klipper initialization is not yet completed
+            return
+        ffi_main, ffi_lib = chelper.get_ffi()
+        kin = self.toolhead.get_kinematics()
+        for s in kin.get_steppers():
+            if s.get_trapq() is None:
+                continue
+            is_sk = self._get_input_shaper_stepper_kinematics(s)
+            if is_sk is None:
+                continue
+            old_delay = ffi_lib.input_shaper_get_step_generation_window(is_sk)
+            ffi_lib.input_shaper_update_sk(is_sk)
+            new_delay = ffi_lib.input_shaper_get_step_generation_window(is_sk)
+            if old_delay != new_delay:
+                self.toolhead.note_step_generation_scan_time(new_delay,
+                                                             old_delay)
     def _update_input_shaping(self, error=None):
         self.toolhead.flush_step_generation()
         ffi_main, ffi_lib = chelper.get_ffi()

klippy/extras/ldc1612.py

@@ -12,7 +12,7 @@ BATCH_UPDATES = 0.100
 
 LDC1612_ADDR = 0x2a
 
-LDC1612_FREQ = 12000000
+DEFAULT_LDC1612_FREQ = 12000000
 SETTLETIME = 0.005
 DRIVECUR = 15
 DEGLITCH = 0x05 # 10 Mhz
@@ -87,6 +87,8 @@ class LDC1612:
         self.oid = oid = mcu.create_oid()
         self.query_ldc1612_cmd = None
         self.ldc1612_setup_home_cmd = self.query_ldc1612_home_state_cmd = None
+        self.frequency = config.getint("frequency", DEFAULT_LDC1612_FREQ,
+                                       2000000, 40000000)
         if config.get('intb_pin', None) is not None:
             ppins = config.get_printer().lookup_object("pins")
             pin_params = ppins.lookup_pin(config.get('intb_pin'))
@@ -141,7 +143,7 @@ class LDC1612:
     def setup_home(self, print_time, trigger_freq,
                    trsync_oid, hit_reason, err_reason):
         clock = self.mcu.print_time_to_clock(print_time)
-        tfreq = int(trigger_freq * (1<<28) / float(LDC1612_FREQ) + 0.5)
+        tfreq = int(trigger_freq * (1<<28) / float(self.frequency) + 0.5)
         self.ldc1612_setup_home_cmd.send(
             [self.oid, clock, tfreq, trsync_oid, hit_reason, err_reason])
     def clear_home(self):
@@ -153,7 +155,7 @@ class LDC1612:
         return self.mcu.clock_to_print_time(tclock)
     # Measurement decoding
     def _convert_samples(self, samples):
-        freq_conv = float(LDC1612_FREQ) / (1<<28)
+        freq_conv = float(self.frequency) / (1<<28)
         count = 0
         for ptime, val in samples:
             mv = val & 0x0fffffff
@@ -174,10 +176,10 @@ class LDC1612:
                 "(e.g. faulty wiring) or a faulty ldc1612 chip."
                 % (manuf_id, dev_id, LDC1612_MANUF_ID, LDC1612_DEV_ID))
         # Setup chip in requested query rate
-        rcount0 = LDC1612_FREQ / (16. * (self.data_rate - 4))
+        rcount0 = self.frequency / (16. * (self.data_rate - 4))
         self.set_reg(REG_RCOUNT0, int(rcount0 + 0.5))
         self.set_reg(REG_OFFSET0, 0)
-        self.set_reg(REG_SETTLECOUNT0, int(SETTLETIME*LDC1612_FREQ/16. + .5))
+        self.set_reg(REG_SETTLECOUNT0, int(SETTLETIME*self.frequency/16. + .5))
         self.set_reg(REG_CLOCK_DIVIDERS0, (1 << 12) | 1)
         self.set_reg(REG_ERROR_CONFIG, (0x1f << 11) | 1)
         self.set_reg(REG_MUX_CONFIG, 0x0208 | DEGLITCH)

klippy/extras/led.py

@@ -1,6 +1,6 @@
 # Support for PWM driven LEDs
 #
-# Copyright (C) 2019-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2019-2025  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
@@ -21,7 +21,7 @@ class LEDHelper:
         self.led_state = [(red, green, blue, white)] * led_count
         # Support setting an led template
         self.template_eval = output_pin.lookup_template_eval(config)
-        self.tcallbacks = [(lambda text, s=self, index=i:
+        self.tcallbacks = [(lambda text, s=self, index=i+1:
                             s._template_update(index, text))
                            for i in range(led_count)]
         # Register commands
@@ -97,17 +97,15 @@ class LEDHelper:
             for i in range(self.led_count):
                 set_template(gcmd, self.tcallbacks[i], self._check_transmit)
 
-PIN_MIN_TIME = 0.100
-MAX_SCHEDULE_TIME = 5.0
-
 # Handler for PWM controlled LEDs
 class PrinterPWMLED:
     def __init__(self, config):
         self.printer = printer = config.get_printer()
         # Configure pwm pins
         ppins = printer.lookup_object('pins')
+        max_duration = printer.lookup_object('mcu').max_nominal_duration()
         cycle_time = config.getfloat('cycle_time', 0.010, above=0.,
-                                     maxval=MAX_SCHEDULE_TIME)
+                                     maxval=max_duration)
         hardware_pwm = config.getboolean('hardware_pwm', False)
         self.pins = []
         for i, name in enumerate(("red", "green", "blue", "white")):
@@ -128,11 +126,12 @@ class PrinterPWMLED:
         for idx, mcu_pin in self.pins:
             mcu_pin.setup_start_value(color[idx], 0.)
     def update_leds(self, led_state, print_time):
+        mcu = self.pins[0][1].get_mcu()
+        min_sched_time = mcu.min_schedule_time()
         if print_time is None:
             eventtime = self.printer.get_reactor().monotonic()
-            mcu = self.pins[0][1].get_mcu()
-            print_time = mcu.estimated_print_time(eventtime) + PIN_MIN_TIME
-        print_time = max(print_time, self.last_print_time + PIN_MIN_TIME)
+            print_time = mcu.estimated_print_time(eventtime) + min_sched_time
+        print_time = max(print_time, self.last_print_time + min_sched_time)
         color = led_state[0]
         for idx, mcu_pin in self.pins:
             if self.prev_color[idx] != color[idx]: