heaters: Add "heaters/set_target_temperature" API endpoint

Add a mechanism for api clients to asynchronously set a target temperature. That is, a mechanism to set the temperature without needing to wait for G-Code commands to complete. Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
heaters: Add 'temperature_wait' status to heaters object
2024-08-05 01:12:19 -04:00 · 2024-08-05 00:43:41 -04:00
459 changed files with 10357 additions and 153325 deletions
--- a/.github/workflows/build-test.yaml
+++ b/.github/workflows/build-test.yaml
@@ -21,7 +21,7 @@ jobs:
      run: ./scripts/ci-build.sh 2>&1
    - name: Upload micro-controller data dictionaries
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      with:
        name: data-dict
        path: ci_build/dict
--- a/README.md
+++ b/README.md
@@ -4,14 +4,15 @@ Welcome to the Klipper project!
 https://www.klipper3d.org/
-The Klipper firmware controls 3d-Printers. It combines the power of a
+Klipper is a 3d-Printer firmware. It combines the power of a general
-general purpose computer with one or more micro-controllers. See the
+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.
+information on why you should use Klipper.
-Start by [installing Klipper software](https://www.klipper3d.org/Installation.html).
+To begin using Klipper start by
 [installing](https://www.klipper3d.org/Installation.html) it.
-Klipper software is Free Software. See the [license](COPYING) or read
+Klipper is Free Software. See the [license](COPYING) or read the
-the [documentation](https://www.klipper3d.org/Overview.html). We
+[documentation](https://www.klipper3d.org/Overview.html). We depend on
-depend on the generous support from our
+the generous support from our
 [sponsors](https://www.klipper3d.org/Sponsors.html).
--- a/config/generic-bigtreetech-skr-mini-mz.cfg
+++ b/config/generic-bigtreetech-skr-mini-mz.cfg
@@ -122,12 +122,6 @@ 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
--- a/config/generic-creality-v4.2.7.cfg
+++ b/config/generic-creality-v4.2.7.cfg
@@ -95,4 +95,4 @@ max_z_accel: 100
 aliases:
  EXP1_1=PC6,EXP1_3=PB10,EXP1_5=PB14,EXP1_7=PB12,EXP1_9=<GND>,
  EXP1_2=PB2,EXP1_4=PB11,EXP1_6=PB13,EXP1_8=PB15,EXP1_10=<5V>,
-  PROBE_IN=PB0,PROBE_OUT=PB1,FIL_RUNOUT=PA4
+  PROBE_IN=PB0,PROBE_OUT=PB1,FIL_RUNOUT=PC6
--- a/config/generic-mellow-fly-e3-v2.cfg
+++ b/config/generic-mellow-fly-e3-v2.cfg
@@ -1,232 +0,0 @@
 # This file contains common pin mappings for the Mellow Fly-E3-v2.
 # To use this config, the firmware should be compiled for the
 # STM32F407 with a "32KiB bootloader".
 # The "make flash" command does not work on the Fly-E3-v2. Instead,
 # after running "make", copy the generated "out/klipper.bin" file to a
 # file named "firmware.bin" or "klipper.bin" on an SD card and then restart the Fly-E3-v2
 # with that SD card.
 # See docs/Config_Reference.md for a description of parameters.
 [mcu]
 serial: /dev/serial/by-id/usb-Klipper_stm32f407xx_27004A001851323333353137-if00
 [stepper_x]
 step_pin: PE5
 dir_pin: PC0
 enable_pin: !PC1
 microsteps: 16
 rotation_distance: 30
 full_steps_per_rotation: 200
 endstop_pin: PE7 #X-STOP
 position_endstop: 0
 position_max: 200
 homing_speed: 50
 second_homing_speed: 10
 homing_retract_dist: 5.0
 homing_positive_dir: false
 step_pulse_duration: 0.000004
 [stepper_y]
 step_pin: PE4
 dir_pin: !PC13
 enable_pin: !PC14
 microsteps: 16
 rotation_distance: 30
 full_steps_per_rotation: 200
 endstop_pin: PE8 #Y-STOP
 position_endstop: 0
 position_max: 200
 homing_speed: 50
 second_homing_speed: 10
 homing_retract_dist: 5.0
 homing_positive_dir: false
 step_pulse_duration: 0.000004
 [stepper_z]
 step_pin: PE1
 dir_pin: !PB7
 enable_pin: !PE3
 microsteps: 16
 rotation_distance: 30
 full_steps_per_rotation: 200
 endstop_pin: PE9 #Z-STOP
 position_min: 0
 position_endstop: 0
 position_max: 200
 homing_speed: 5
 second_homing_speed: 3
 homing_retract_dist: 5.0
 homing_positive_dir: false
 step_pulse_duration: 0.000004
 [extruder]
 step_pin: PE2
 dir_pin: PD5
 enable_pin: !PD6
 microsteps: 16
 rotation_distance: 33.500
 nozzle_diameter: 0.400
 filament_diameter: 1.750
 heater_pin: PC6 #E0
 ########################################
 # Extruder 100K thermistor configuration
 ########################################
 sensor_type: ATC Semitec 104GT-2
 sensor_pin: PC4 #T0 TEMP
 control: pid
 pid_Kp: 22.2
 pid_Ki: 1.08
 pid_Kd: 114
 min_temp: 0
 max_temp: 275
 ########################################
 # Extruder MAX31865 PT100 2 wire config
 ########################################
 # sensor_type: MAX31865
 # sensor_pin: PD15 #PT-100
 # spi_speed: 4000000
 # spi_software_sclk_pin: PD12
 # spi_software_mosi_pin: PD11
 # spi_software_miso_pin: PD13
 # rtd_nominal_r: 100
 # rtd_reference_r: 430
 # rtd_num_of_wires: 2
 # rtd_use_50Hz_filter: True
 min_temp: 0
 max_temp: 300
 #[extruder1]
 #step_pin: PE0
 #dir_pin: PD1
 #enable_pin: !PD3
 #microsteps: 16
 #heater_pin: PC7 #E1
 #sensor_pin: PC5 #T1 TEMP
 ########################################
 # TMC2209 configuration
 ########################################
 [tmc2209 stepper_x]
 uart_pin: PC15
 interpolate: False
 run_current: 0.3
 sense_resistor: 0.110
 stealthchop_threshold: 999999
 [tmc2209 stepper_y]
 uart_pin: PB6
 interpolate: False
 run_current: 0.3
 sense_resistor: 0.110
 stealthchop_threshold: 999999
 [tmc2209 stepper_z]
 uart_pin: PD7
 interpolate: False
 run_current: 0.4
 sense_resistor: 0.110
 stealthchop_threshold: 999999
 [tmc2209 extruder]
 uart_pin: PD4
 interpolate: False
 run_current: 0.27
 sense_resistor: 0.075
 stealthchop_threshold: 999999
 #[tmc2209 extruder1]
 #uart_pin: PD0
 #interpolate: False
 #run_current: 0.27
 #sense_resistor: 0.075
 #stealthchop_threshold: 999999
 #######################################
 # Heated Bed
 #######################################
 [heater_bed]
 heater_pin: PB0 #BED
 sensor_type: Generic 3950
 sensor_pin: PB1 #B-TEMP
 max_power: 1.0
 min_temp: 0
 max_temp: 120
 control: pid
 pid_kp: 58.437
 pid_ki: 2.347
 pid_kd: 363.769
 #######################################
 # LIGHTING
 #######################################
 #[led Toolhead]
 #white_pin: PA2 #FAN2
 #cycle_time: 0.010
 #initial_white: 0
 #######################################
 # COOLING
 #######################################
 [heater_fan hotend_fan]
 pin: PA1 #FAN1
 max_power: 1.0
 kick_start_time: 0.5
 heater: extruder
 heater_temp: 50
 fan_speed: 1.0
 [controller_fan controller_fan]
 pin: PA0 #FAN0
 max_power: 1.0
 kick_start_time: 0.5
 heater: extruder
 stepper: stepper_x, stepper_y, stepper_z
 fan_speed: 1.0
 idle_timeout: 60
 [fan]
 pin: PA3 #FAN3
 max_power: 1.0
 off_below: 0.2
 [temperature_sensor Mellow_Fly_E3_V2]
 sensor_type: temperature_mcu
 min_temp: 5
 max_temp: 80
 [printer]
 kinematics: cartesian
 max_velocity: 300
 max_accel: 3000
 max_z_velocity: 50
 max_z_accel: 100
 ########################################
 # EXP1 / EXP2 (display) pins
 ########################################
 [board_pins]
 aliases:
    EXP1_1=PD10, EXP1_3=PA8,   EXP1_5=PE15,   EXP1_7=PA14,  EXP1_9=<GND>,
    EXP1_2=PA9,  EXP1_4=PA10,  EXP1_6=PE14,   EXP1_8=PA13,  EXP1_10=<5V>,
    # EXP2 header
    EXP2_1=PA6, EXP2_3=PB11,  EXP2_5=PB10,  EXP2_7=PE13,   EXP2_9=<GND>,
    EXP2_2=PA5, EXP2_4=PA4,   EXP2_6=PA7,   EXP2_8=<RST>, EXP2_10=<NC>,
 # See the sample-lcd.cfg file for definitions of common LCD displays.
 #######################################
 # BL-Touch
 #######################################
 #[bltouch]
 #sensor_pin: PC2
 #control_pin: PE6
 #z_offset: 0
--- a/config/printer-geeetech-A10T-A20T-2021.cfg
+++ b/config/printer-geeetech-A10T-A20T-2021.cfg
@@ -1,256 +0,0 @@
 # This file contains common pin mappings for the Geeetech GT2560 v4.0 and v4.1b
 # boards. These boards use a firmware compiled for the AVR atmega2560.
 # For default Geeetech A10/A20  (1 extruder),
 #                      A10M/A20M (mixing 2 in 1 out),
 #                      A10T/A20T (mixing 3 in 1 out) printers
 # Installation: https://www.klipper3d.org/Installation.html
 # Always read for first start: https://www.klipper3d.org/Config_checks.html
 [mcu]
 # Might need to be changed: https://www.klipper3d.org/Installation.html
 serial: /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0
 [printer]
 kinematics: cartesian
 max_velocity: 200
 max_accel: 1500
 max_z_velocity: 20
 max_z_accel: 500
 # # uncomment for BLTouch/3DTouch
 # [bltouch]
 # sensor_pin: PC7 # there is an external pull up so no need in ^
 # control_pin: PB5
 # speed: 3.0
 # samples: 2
 # x_offset: -42.0
 # y_offset: -1.0
 #                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      z_offset: 1.0 # during calibration this line is commented out and new record added at the end of file
 [safe_z_home]
 home_xy_position: 100, 100  # Change coordinates to the center of your print bed
 speed: 50
 z_hop: 10  # Move up 10mm
 z_hop_speed: 5
 [stepper_x]
 enable_pin: !PC2
 dir_pin: !PG2
 step_pin: PC0
 microsteps: 16
 rotation_distance: 40
 endstop_pin: !PA2 # there are external pull ups
 position_endstop: 0
 position_max: 220 # for A10/M/T / change to 250 for A20/M/T
 homing_speed: 40
 [stepper_y]
 enable_pin: !PA7
 dir_pin: !PC4
 step_pin: PC6
 microsteps: 16
 rotation_distance: 40
 endstop_pin: !PA6 # there are external pull ups
 position_endstop: 0
 position_max: 220 # for A10/M/T / change to 250 for A20/M/T
 homing_speed: 40
 [stepper_z]
 enable_pin: !PA5
 dir_pin: PA1
 step_pin: PA3
 microsteps: 16
 rotation_distance: 8
 #endstop_pin: probe:z_virtual_endstop # uncomment for BLTouch/3DTouch
 endstop_pin: !PC7 # comment for BLTouch/3DTouch
 position_endstop: 0 # comment for BLTouch/3DTouch
 position_max: 230 # for A10/M/T / change to 250 for A20/M/T
 position_min: -5
 homing_speed: 20
 [extruder]
 enable_pin: !PB6
 dir_pin: PL5
 step_pin: PL3
 microsteps: 16
 rotation_distance: 8 # Needs to be optimized: https://www.klipper3d.org/Rotation_Distance.html#calibrating-rotation_distance-on-extruders
 nozzle_diameter: 0.4
 filament_diameter: 1.750
 heater_pin: PB4
 sensor_type: EPCOS 100K B57560G104F
 sensor_pin: PK3
 min_temp: 0
 max_temp: 250
 max_extrude_only_distance: 200.0
 # Parameters for stock hotend on A10M
 # Please recalibrate according to https://www.klipper3d.org/Config_checks.html#calibrate-pid-settings
 control: pid
 pid_kp: 54.722
 pid_ki: 4.800
 pid_kd: 155.958
 [extruder_stepper extruder_1]
 extruder:
 enable_pin: !PL1
 dir_pin: PL2
 step_pin: PL0
 microsteps: 16
 rotation_distance: 8 # Needs to be optimized: https://www.klipper3d.org/Rotation_Distance.html#calibrating-rotation_distance-on-extruders
 [extruder_stepper extruder_2]
 extruder:
 enable_pin: !PG0
 dir_pin: PL4
 step_pin: PL6
 microsteps: 16
 rotation_distance: 8 # Needs to be optimized: https://www.klipper3d.org/Rotation_Distance.html#calibrating-rotation_distance-on-extruders
 [heater_bed]
 heater_pin: PG5
 sensor_type: EPCOS 100K B57560G104F
 sensor_pin: PK2
 min_temp: 0
 max_temp: 120
 # Parameters for `SuperPlate` on A10M
 # Please recalibrate according to https://www.klipper3d.org/Config_checks.html#calibrate-pid-settings
 control: pid
 pid_kp: 70.936
 pid_ki: 1.785
 pid_kd: 704.924
 [fan]
 pin: PH6
 cycle_time: 0.150
 kick_start_time: 0.300
 # # for GT2560V4.0 with 20pin flat cable toward the display
 # [display]
 # lcd_type: hd44780
 # hd44780_protocol_init: True
 # rs_pin: PD1
 # e_pin: PH0
 # d4_pin: PH1
 # d5_pin: PD0
 # d6_pin: PE3
 # d7_pin: PC1
 # encoder_pins: ^PG1, ^PL7
 # click_pin: ^!PD2
 # for GT2560V4.1B with 12pin flat cable toward the display YHCB2004-06 ver3.0
 # the aip31068_spi driver was added to Klipper on 2024-12-02, commit aecb29d2
 [display]
 lcd_type: aip31068_spi
 latch_pin: PE3
 spi_software_sclk_pin: PD0
 spi_software_mosi_pin: PC1
 spi_software_miso_pin: PH7 # any unused pin
 encoder_pins: ^PH0, ^PH1
 click_pin: ^!PD2
 [filament_switch_sensor sensor_e0]
 switch_pin: !PK4
 [filament_switch_sensor sensor_e1]
 switch_pin: !PK5
 [filament_switch_sensor sensor_e2]
 # switch_pin: !PE2 # for GT2560V4.0
 switch_pin: !PF0 # for GT2560V4.1B
 # to enable M118 echo command
 [respond]
 # Specific macros for mixing colors.
 # Add in slicer new filament color and in filament start G-Code add desired mixing factor:
 #     M163 S0 P50 ; set extruder 0 to 50%
 #     M163 S1 P40 ; set extruder 1 to 40%
 #     M163 S2 P10 ; set extruder 2 to 10%
 #     M164 ; commit the mix factors
 [gcode_macro M163]
 description:  M163 [P<factor>] [S<index>] Set a single mix factor (in proportion to the sum total of all mix factors). The mix must be committed to a virtual tool by M164 before it takes effect.
 gcode:
    {% if 'P' in params %}
            {% set s = params.S|default(0)| int %}
            {% if s == 0 %}
                SET_GCODE_VARIABLE MACRO=M164 VARIABLE=e0_parts VALUE={params.P|default(0)|float}
                M118 Set Mixing factor for extruder 0 to {params.P|default(0)|float}
            {% elif s == 1 %}
                SET_GCODE_VARIABLE MACRO=M164 VARIABLE=e1_parts VALUE={params.P|default(0)|float}
                M118 Set Mixing factor for extruder 1 to {params.P|default(0)|float}
            {% elif s == 2 %}
                SET_GCODE_VARIABLE MACRO=M164 VARIABLE=e2_parts VALUE={params.P|default(0)|float}
                M118 Set Mixing factor for extruder 2 to {params.P|default(0)|float}
            {% endif %}
    {% else %}
        M118 No Mixing factor set, missing value for P
    {% endif %}
    M118 {e0_parts} {e1_parts} {e2_parts}
 [gcode_macro M164]
 description: Applies the set mixing factors to the extruders
 # default values:
 variable_e0_parts : 100
 variable_e1_parts : 0
 variable_e2_parts : 0
 gcode:
    # normalize the parts to sum of 1
    {% set e0 = e0_parts / (e0_parts + e1_parts + e2_parts) | float %}
    {% set e1 = e1_parts / (e0_parts + e1_parts + e2_parts) | float %}
    {% set e2 = e2_parts / (e0_parts + e1_parts + e2_parts) | float %}
    M118 scaled rot-dist_e0 { printer.configfile.settings.extruder.rotation_distance / (e0 + 0.000001) | float }
    M118 scaled rot-dist_e1 { printer.configfile.settings['extruder_stepper extruder_1'].rotation_distance / (e1 + 0.000001) | float }
    M118 scaled rot-dist_e2 { printer.configfile.settings['extruder_stepper extruder_2'].rotation_distance / (e2 + 0.000001) |float }
    # activate stepper percentages
    SYNC_EXTRUDER_MOTION EXTRUDER=extruder MOTION_QUEUE=extruder
    SYNC_EXTRUDER_MOTION EXTRUDER=extruder_1 MOTION_QUEUE=extruder
    SYNC_EXTRUDER_MOTION EXTRUDER=extruder_2 MOTION_QUEUE=extruder
    SET_EXTRUDER_ROTATION_DISTANCE EXTRUDER=extruder DISTANCE={ printer.configfile.settings.extruder.rotation_distance / (e0+0.000001)|float }
    SET_EXTRUDER_ROTATION_DISTANCE EXTRUDER=extruder_1 DISTANCE={ printer.configfile.settings['extruder_stepper extruder_1'].rotation_distance / (e1+0.000001)|float }
    SET_EXTRUDER_ROTATION_DISTANCE EXTRUDER=extruder_2 DISTANCE={ printer.configfile.settings['extruder_stepper extruder_2'].rotation_distance / (e2+0.000001)|float }
    M118 Mixing factors {e0} {e1} {e2} are activated
 # In PrusaSlicer:
 #    - you can add as many extruders as mixing ratios you want
 #    - in Printer Settings -> Custom G-code -> Tool change G-code add:
 #        TOOL_CHANGE EXTRUDER={next_extruder}
 #    - in this config file add:
 #           [gcode_macro TOOL_CHANGE]
 #           description: Tool change macro with mix ratio setup for 11 extruders
 #           variable_extruder: 0
 #           gcode:
 #               {% set extruder = params.EXTRUDER|default(0)| int %}
 #               {% if extruder == 0 %}
 #                   M163 S0 P100
 #                   M163 S1 P0
 #                   M163 S2 P0
 #                   M164
 #                   M118 Switching to Extruder 0
 #               {% elif extruder == 1 %}
 #                   M163 S0 P90
 #                   M163 S1 P10
 #                   M163 S2P0
 #                   M164
 #                   M118 Switching to Extruder 1
 #               {% elif extruder == 2 %}
 #                   # and so on ...
 #               {% else %}
 #                   M118 Unknown extruder number: {extruder}
 #               {% endif %}
 # In OrcaSlicer:
 # you can add as many filaments as mixing ratios you want
 # in Material settings -> Advanced -> Filament start G-code add desired mixing ratio:
 #    ; filament start gcode
 #    M163 S0 P100 ; set extruder 0
 #    M163 S1 P0 ; set extruder 1
 #    M163 S2 P0 ; set extruder 2
 #    M164 ; commit the mix factors
 # For gradient over Z axis:
 # In `Printer -> Custom G-code -> After layer change G-code` add:
 #     M163 S0 P{ layer_num * 100 / total_layer_count } ; Gradient 0-100
 #     M163 S1 P{(total_layer_count-layer_num) * 100 / total_layer_count} ; Gradient 100-0
 #     M164 ; commit the mix factors
--- a/config/sample-duet3-1lc.cfg
+++ b/config/sample-duet3-1lc.cfg
@@ -77,14 +77,5 @@ heater_temp: 50.0
 pin: toolboard:PA9
 z_offset: 20
 [samd_sercom sercom_i2c]
 sercom: sercom1
 tx_pin: toolboard:PA16
 clk_pin: toolboard:PA17
 [lis3dh]
 i2c_mcu: toolboard
 i2c_bus: sercom1
 [mcu toolboard]
 canbus_uuid: 4b194673554e
--- a/docs/API_Server.md
+++ b/docs/API_Server.md
@@ -282,6 +282,22 @@ window" interface. Parsing content from the G-Code terminal output is
 discouraged. Use the "objects/subscribe" endpoint to obtain updates on
 Klipper's state.
 ### heaters/set_target_temperature
 This endpoint is used to asynchronously set the target temperature for
 a heater. For example:
 `{"id": 123, "method": "heaters/set_target_temperature", "params":
 {"heater":"heater_generic my_heater", "target": 100.3}}`
 This endpoint is similar to the `SET_HEATER_TEMPERATURE` G-Code
 command, but the target temperature takes effect immediately.  It does
 not wait for pending G-Code commands to complete.
 If this endpoint is issued for a heater while a `WAIT_TEMPERATURE`
 command (or `M109`, `M190`) is pending for that heater, then the
 requested target temperature will be set and the `WAIT_TEMPERATURE`
 command will exit with an error.
 ### motion_report/dump_stepper
 This endpoint is used to subscribe to Klipper's internal stepper
@@ -364,21 +380,35 @@ 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.
-### load_cell/dump_force
+### hx71x/dump_hx71x
-This endpoint is used to subscribe to force data produced by a load_cell.
+This endpoint is used to subscribe to raw HX711 and HX717 ADC data.
-Using this endpoint may increase Klipper's system load.
+Obtaining these low-level ADC updates may be useful for diagnostic
 and debugging purposes. Using this endpoint may increase Klipper's
 system load.
 A request may look like:
-`{"id": 123, "method":"load_cell/dump_force",
+`{"id": 123, "method":"hx71x/dump_hx71x",
 "params": {"sensor": "load_cell", "response_template": {}}}`
 and might return:
-`{"id": 123,"result":{"header":["time", "force (g)", "counts", "tare_counts"]}}`
+`{"id": 123,"result":{"header":["time","counts"]}}`
 and might later produce asynchronous messages such as:
-`{"params":{"data":[[3292.432935, 40.65, 562534, -234467]]}}`
+`{"params":{"data":[[3292.432935, 562534], [3292.4394937, 5625322]]}}`
-The "header" field in the initial query response is used to describe
+### ads1220/dump_ads1220
-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.
 A request may look like:
 `{"id": 123, "method":"ads1220/dump_ads1220",
 "params": {"sensor": "load_cell", "response_template": {}}}`
 and might return:
 `{"id": 123,"result":{"header":["time","counts"]}}`
 and might later produce asynchronous messages such as:
 `{"params":{"data":[[3292.432935, 562534], [3292.4394937, 5625322]]}}`
 ### pause_resume/cancel
--- a/docs/Axis_Twist_Compensation.md
+++ b/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.
@@ -24,50 +24,27 @@ try to probe the bed without attaching the probe if you use it.
 > **Tip:** Make sure the [probe X and Y offsets](Config_Reference.md#probe) are
 > correctly set as they greatly influence calibration.
-### Basic Usage: X-Axis Calibration
+1. After setting up the [axis_twist_compensation] module,
-1. After setting up the `[axis_twist_compensation]` module, run:
+perform `AXIS_TWIST_COMPENSATION_CALIBRATE`
-```
+* The calibration wizard will prompt you to measure the probe Z offset at a few
-AXIS_TWIST_COMPENSATION_CALIBRATE
+points along the bed
-```
+* The calibration defaults to 3 points but you can use the option
-This command will calibrate the X-axis by default.
+`SAMPLE_COUNT=` to use a different number.
-  - The calibration wizard will prompt you to measure the probe Z offset at
+2. [Adjust your Z offset](Probe_Calibrate.md#calibrating-probe-z-offset)
-    several points along the bed.
+3. Perform automatic/probe-based bed tramming operations, such as
-  - By default, the calibration uses 3 points, but you can specify a different
+[Screws Tilt Adjust](G-Codes.md#screws_tilt_adjust),
-    number with the option:
+[Z Tilt Adjust](G-Codes.md#z_tilt_adjust) etc
-``
+4. Home all axis, then perform a [Bed Mesh](Bed_Mesh.md) if required
-SAMPLE_COUNT=<value>
+5. Perform a test print, followed by any
-``
+[fine-tuning](Axis_Twist_Compensation.md#fine-tuning) as desired
 2. **Adjust Your 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:
  - [Screws Tilt Adjust](G-Codes.md#screws_tilt_adjust)
  - [Z Tilt Adjust](G-Codes.md#z_tilt_adjust)
 4. **Finalize the Setup:**
  - Home all axes, and perform a [Bed Mesh](Bed_Mesh.md) if necessary.
  - Run a test print, followed by any
    [fine-tuning](Axis_Twist_Compensation.md#fine-tuning)
    if needed.
 ### For Y-Axis Calibration
 The calibration process for the Y-axis is similar to the X-axis. To calibrate
 the Y-axis, use:
 ```
 AXIS_TWIST_COMPENSATION_CALIBRATE AXIS=Y
 ```
 This will guide you through the same measuring process as for the X-axis.
 > **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)
--- a/docs/Bed_Mesh.md
+++ b/docs/Bed_Mesh.md
@@ -269,7 +269,7 @@ 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
 be the location on the bed where a
-[Z_ENDSTOP_CALIBRATE](./Manual_Level.md#calibrating-a-z-endstop)
+[Z_ENDSTOP_CALIBRATE](./Manual_Level#calibrating-a-z-endstop)
 paper test is performed.  The bed_mesh module provides the
 `zero_reference_position` option for specifying this coordinate:
--- a/docs/Benchmarks.md
+++ b/docs/Benchmarks.md
@@ -354,26 +354,6 @@ micro-controller.
 | 1 stepper (200Mhz)   | 39    |
 | 3 stepper (200Mhz)   | 181   |
 ### SAME70 step rate benchmark
 The following configuration sequence is used on the SAME70:
 ```
 allocate_oids count=3
 config_stepper oid=0 step_pin=PC18 dir_pin=PB5 invert_step=-1 step_pulse_ticks=0
 config_stepper oid=1 step_pin=PC16 dir_pin=PD10 invert_step=-1 step_pulse_ticks=0
 config_stepper oid=2 step_pin=PC28 dir_pin=PA4 invert_step=-1 step_pulse_ticks=0
 finalize_config crc=0
 ```
 The test was last run on commit `34e9ea55` with gcc version
 `arm-none-eabi-gcc (NixOS 10.3-2021.10) 10.3.1` on a SAME70Q20B
 micro-controller.
 | same70               | ticks |
 | -------------------- | ----- |
 | 1 stepper            | 45    |
 | 3 stepper            | 190   |
 ### AR100 step rate benchmark ###
 The following configuration sequence is used on AR100 CPU (Allwinner A64):
@@ -386,7 +366,7 @@ finalize_config crc=0
 ```
-The test was last run on commit `b7978d37` with gcc version
+The test was last run on commit `08d037c6` with gcc version
 `or1k-linux-musl-gcc (GCC) 9.2.0` on an Allwinner A64-H
 micro-controller.
@@ -395,9 +375,9 @@ micro-controller.
 | 1 stepper            | 85    |
 | 3 stepper            | 359   |
-### RPxxxx step rate benchmark
+### RP2040 step rate benchmark
-The following configuration sequence is used on the RP2040 and RP2350:
+The following configuration sequence is used on the RP2040:
 ```
 allocate_oids count=3
@@ -407,25 +387,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 `14c105b8` with gcc version
+The test was last run on commit `59314d99` with gcc version
-`arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0` on Raspberry Pi
+`arm-none-eabi-gcc (Fedora 10.2.0-4.fc34) 10.2.0` on a Raspberry Pi
-Pico and Pico 2 boards.
+Pico board.
-| rp2040 (*)           | ticks |
+| rp2040               | ticks |
 | -------------------- | ----- |
-| 1 stepper            | 3     |
+| 1 stepper            | 5     |
-| 3 stepper            | 14    |
+| 3 stepper            | 22    |
 | rp2350               | ticks |
 | -------------------- | ----- |
 | 1 stepper            | 36    |
 | 3 stepper            | 169   |
 (*) Note that the reported rp2040 ticks are relative to a 12Mhz
 scheduling timer and do not correspond to its 200Mhz internal ARM
 processing rate. It is expected that 5 scheduling ticks corresponds to
 ~42 ARM core cycles and 14 scheduling ticks corresponds to ~225 ARM
 core cycles.
 ### Linux MCU step rate benchmark
@@ -487,8 +456,7 @@ hub.
 | sam4s8c (USB)       | 650K | 8d4a5c16 | arm-none-eabi-gcc (Fedora 7.4.0-1.fc30) 7.4.0 |
 | samd51 (USB)        | 864K | 01d2183f | arm-none-eabi-gcc (Fedora 7.4.0-1.fc30) 7.4.0 |
 | stm32f446 (USB)     | 870K | 01d2183f | arm-none-eabi-gcc (Fedora 7.4.0-1.fc30) 7.4.0 |
-| rp2040 (USB)        | 885K | f6718291 | arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0 |
+| rp2040 (USB)        | 873K | c5667193 | arm-none-eabi-gcc (Fedora 10.2.0-4.fc34) 10.2.0 |
 | rp2350 (USB)        | 885K | f6718291 | arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0 |
 ## Host Benchmarks
--- a/docs/CANBUS_Troubleshooting.md
+++ b/docs/CANBUS_Troubleshooting.md
@@ -37,36 +37,20 @@ 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. If seen, make sure to:
+reordered messages on the CAN bus. There are two known causes of
-* Use a Linux kernel version 6.6.0 or later.
+reordered messages:
-* If using a USB-to-CANBUS adapter running candlelight firmware, use
+1. Old versions of the popular candlight_firmware for USB CAN adapters
-  v2.0 or later of candleLight_fw.
+   had a bug that could cause reordered messages. If using a USB CAN
-* If using Klipper's USB-to-CANBUS bridge mode, make sure the bridge
+   adapter running this firmware then make sure to update to the
-  node is flashed with Klipper v0.12.0 or later.
+   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 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. An incrementing `bytes_invalid` is not caused by
+part of a print.
 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
--- a/docs/Code_Overview.md
+++ b/docs/Code_Overview.md
@@ -359,10 +359,10 @@ Useful steps:
   be efficient as it is typically only called during homing and
   probing operations.
 5. Other methods. Implement the `check_move()`, `get_status()`,
-   `get_steppers()`, `home()`, `clear_homing_state()`, and `set_position()`
+   `get_steppers()`, `home()`, and `set_position()` methods. These
-   methods. These functions are typically used to provide kinematic
+   functions are typically used to provide kinematic specific checks.
-   specific checks. However, at the start of development one can use
+   However, at the start of development one can use boiler-plate code
-   boiler-plate code here.
+   here.
 6. Implement test cases. Create a g-code file with a series of moves
   that can test important cases for the given kinematics. Follow the
   [debugging documentation](Debugging.md) to convert this g-code file
--- a/docs/Config_Changes.md
+++ b/docs/Config_Changes.md
@@ -8,44 +8,6 @@ All dates in this document are approximate.
 ## Changes
 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
 the default settings). The new test should generally produce more
 accurate and reliable test results. However, if required, the previous
 test behavior can be restored by adding options `sweeping_period: 0` and
 `accel_per_hz: 75` to the `[resonance_tester]` config section.
 20241201: In some cases Klipper may have ignored leading characters or
 spaces in a traditional G-Code command. For example, "99M123" may have
 been interpreted as "M123" and "M 321" may have been interpreted as
 "M321". Klipper will now report these cases with an "Unknown command"
 warning.
 20241112: Option `CHIPS=<chip_name>` in `TEST_RESONANCES` and
 `SHAPER_CALIBRATE` requires specifying the full name(s) of the accel
 chip(s). For example, `adxl345 rpi` instead of short name - `rpi`.
 20240912: `SET_PIN`, `SET_SERVO`, `SET_FAN_SPEED`, `M106`, and `M107`
 commands are now collated. Previously, if many updates to the same
 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
 updates.
 20240912: Support for `maximum_mcu_duration` and `static_value`
 parameters in `[output_pin]` config sections have been removed. These
 options have been deprecated since 20240123.
 20240415: The `on_error_gcode` parameter in the `[virtual_sdcard]`
 config section now has a default. If this parameter is not specified
 it now defaults to `TURN_OFF_HEATERS`. If the previous behavior is
--- a/docs/Config_Reference.md
+++ b/docs/Config_Reference.md
@@ -1669,34 +1669,14 @@ 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.
 ```
 [lis2dw]
-#cs_pin:
+cs_pin:
-#   The SPI enable pin for the sensor. This parameter must be provided
+#   The SPI enable pin for the sensor. This parameter must be provided.
 #   if using SPI.
 #spi_speed: 5000000
 #   The SPI speed (in hz) to use when communicating with the chip.
 #   The default is 5000000.
@@ -1706,46 +1686,6 @@ Support for LIS2DW accelerometers.
 #spi_software_miso_pin:
 #   See the "common SPI settings" section for a description of the
 #   above parameters.
 #i2c_address:
 #   Default is 25 (0x19). If SA0 is high, it would be 24 (0x18) 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.
 ```
 ### [lis3dh]
 Support for LIS3DH accelerometers.
 ```
 [lis3dh]
 #cs_pin:
 #   The SPI enable pin for the sensor. This parameter must be provided
 #   if using SPI.
 #spi_speed: 5000000
 #   The SPI speed (in hz) to use when communicating with the chip.
 #   The default is 5000000.
 #spi_bus:
 #spi_software_sclk_pin:
 #spi_software_mosi_pin:
 #spi_software_miso_pin:
 #   See the "common SPI settings" section for a description of the
 #   above parameters.
 #i2c_address:
 #   Default is 25 (0x19). If SA0 is high, it would be 24 (0x18) 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.
 ```
@@ -1809,14 +1749,11 @@ section of the measuring resonances guide for more information on
 #   auto-calibration (with 'SHAPER_CALIBRATE' command). By default no
 #   maximum smoothing is specified. Refer to Measuring_Resonances guide
 #   for more details on using this feature.
 #move_speed: 50
 #   The speed (in mm/s) to move the toolhead to and between test points
 #   during the calibration. The default is 50.
 #min_freq: 5
 #   Minimum frequency to test for resonances. The default is 5 Hz.
 #max_freq: 133.33
 #   Maximum frequency to test for resonances. The default is 133.33 Hz.
-#accel_per_hz: 60
+#accel_per_hz: 75
 #   This parameter is used to determine which acceleration to use to
 #   test a specific frequency: accel = accel_per_hz * freq. Higher the
 #   value, the higher is the energy of the oscillations. Can be set to
@@ -1830,13 +1767,6 @@ section of the measuring resonances guide for more information on
 #   hz_per_sec. Small values make the test slow, and the large values
 #   will decrease the precision of the test. The default value is 1.0
 #   (Hz/sec == sec^-2).
 #sweeping_accel: 400
 #   An acceleration of slow sweeping moves. The default is 400 mm/sec^2.
 #sweeping_period: 1.2
 #   A period of slow sweeping moves. Setting this parameter to 0
 #   disables slow sweeping moves. Avoid setting it to a too small
 #   non-zero value in order to not poison the measurements.
 #   The default is 1.2 sec which is a good all-round choice.
 ```
 ## Config file helpers
@@ -2084,9 +2014,6 @@ 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.
@@ -2115,9 +2042,9 @@ sensor_type: ldc1612
 ### [axis_twist_compensation]
-A tool to compensate for inaccurate probe readings due to twist in X or Y
+A tool to compensate for inaccurate probe readings due to twist in X gantry. See
-gantry. See the [Axis Twist Compensation Guide](Axis_Twist_Compensation.md)
+the [Axis Twist Compensation Guide](Axis_Twist_Compensation.md) for more
-for more detailed information regarding symptoms, configuration and setup.
+detailed information regarding symptoms, configuration and setup.
 ```
 [axis_twist_compensation]
@@ -2130,33 +2057,16 @@ for more detailed information regarding symptoms, configuration and setup.
 calibrate_start_x: 20
 #   Defines the minimum X coordinate of the calibration
 #   This should be the X coordinate that positions the nozzle at the starting
-#   calibration position.
+#   calibration position. This parameter must be provided.
 calibrate_end_x: 200
 #   Defines the maximum X coordinate of the calibration
 #   This should be the X coordinate that positions the nozzle at the ending
-#   calibration position.
+#   calibration position. This parameter must be provided.
 calibrate_y: 112.5
 #   Defines the Y coordinate of the calibration
 #   This should be the Y coordinate that positions the nozzle during the
-#   calibration process. This parameter is recommended to
+#   calibration process. This parameter must be provided and is recommended to
 #   be near the center of the bed
 # For Y-axis twist compensation, specify the following parameters:
 calibrate_start_y: ...
 #   Defines the minimum Y coordinate of the calibration
 #   This should be the Y coordinate that positions the nozzle at the starting
 #   calibration position for the Y axis. This parameter must be provided if
 #   compensating for Y axis twist.
 calibrate_end_y: ...
 #   Defines the maximum Y coordinate of the calibration
 #   This should be the Y coordinate that positions the nozzle at the ending
 #   calibration position for the Y axis. This parameter must be provided if
 #   compensating for Y axis twist.
 calibrate_x: ...
 #   Defines the X coordinate of the calibration for Y axis twist compensation
 #   This should be the X coordinate that positions the nozzle during the
 #   calibration process for Y axis twist compensation. This parameter must be
 #   provided and is recommended to be near the center of the bed.
 ```
 ## Additional stepper motors and extruders
@@ -2548,10 +2458,6 @@ postfix for both sections.
 #   "calibration_extruder_temp" option is set.  Its recommended to heat
 #   the extruder some distance from the bed to minimize its impact on
 #   the probe coil temperature.  The default is 50.
 #max_validation_temp: 60.
 #   The maximum temperature used to validate the calibration.  It is
 #   recommended to set this to a value between 100 and 120 for enclosed
 #   printers.  The default is 60.
 ```
 ## Temperature sensors
@@ -3300,10 +3206,6 @@ 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]
@@ -3482,9 +3384,8 @@ 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. Note that the "sensorless homing"
+#   velocity is below this value. The default is 0, which disables
-#   code may temporarily override this setting during homing
+#   "stealthChop" mode.
 #   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
@@ -3596,9 +3497,8 @@ 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. Note that the "sensorless homing"
+#   velocity is below this value. The default is 0, which disables
-#   code may temporarily override this setting during homing
+#   "stealthChop" mode.
 #   operations. The default is 0, which disables "stealthChop" mode.
 #driver_MULTISTEP_FILT: True
 #driver_IHOLDDELAY: 8
 #driver_TPOWERDOWN: 20
@@ -3800,9 +3700,8 @@ 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. Note that the "sensorless homing"
+#   velocity is below this value. The default is 0, which disables
-#   code may temporarily override this setting during homing
+#   "stealthChop" mode.
 #   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
@@ -3875,7 +3774,6 @@ run_current:
 #driver_SEIMIN: 0
 #driver_SFILT: 0
 #driver_SG4_ANGLE_OFFSET: 1
 #driver_SLOPE_CONTROL: 0
 #   Set the given register during the configuration of the TMC2240
 #   chip. This may be used to set custom motor parameters. The
 #   defaults for each parameter are next to the parameter name in the
@@ -3935,9 +3833,8 @@ 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. Note that the "sensorless homing"
+#   velocity is below this value. The default is 0, which disables
-#   code may temporarily override this setting during homing
+#   "stealthChop" mode.
 #   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
@@ -4180,16 +4077,15 @@ Support for a display attached to the micro-controller.
 [display]
 lcd_type:
 #   The type of LCD chip in use. This may be "hd44780", "hd44780_spi",
-#   "aip31068_spi", "st7920", "emulated_st7920", "uc1701", "ssd1306", or
+#   "st7920", "emulated_st7920", "uc1701", "ssd1306", or "sh1106".
 #   "sh1106".
 #   See the display sections below for information on each type and
 #   additional parameters they provide. This parameter must be
 #   provided.
 #display_group:
 #   The name of the display_data group to show on the display. This
 #   controls the content of the screen (see the "display_data" section
-#   for more information). The default is _default_20x4 for hd44780 or
+#   for more information). The default is _default_20x4 for hd44780
-#   aip31068_spi displays and _default_16x4 for other displays.
+#   displays and _default_16x4 for other displays.
 #menu_timeout:
 #   Timeout for menu. Being inactive this amount of seconds will
 #   trigger menu exit or return to root menu when having autorun
@@ -4315,31 +4211,6 @@ spi_software_miso_pin:
 ...
 ```
 #### aip31068_spi display
 Information on configuring an aip31068_spi display - a very similar to hd44780_spi
 a 20x04 (20 symbols by 4 lines) display with slightly different internal
 protocol.
 ```
 [display]
 lcd_type: aip31068_spi
 latch_pin:
 spi_software_sclk_pin:
 spi_software_mosi_pin:
 spi_software_miso_pin:
 #   The pins connected to the shift register controlling the display.
 #   The spi_software_miso_pin needs to be set to an unused pin of the
 #   printer mainboard as the shift register does not have a MISO pin,
 #   but the software spi implementation requires this pin to be
 #   configured.
 #line_length:
 #   Set the number of characters per line for an hd44780 type lcd.
 #   Possible values are 20 (default) and 16. The number of lines is
 #   fixed to 4.
 ...
 ```
 #### st7920 display
 Information on configuring st7920 displays (which is used in
@@ -4667,11 +4538,6 @@ 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.
@@ -4789,19 +4655,9 @@ 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
+#### XH711
 This is a 24 bit low sample rate chip using "bit-bang" communications. It is
 suitable for filament scales.
 ```
@@ -4869,30 +4725,13 @@ data_ready_pin:
 #gain: 128
 #   Valid gain values are 128, 64, 32, 16, 8, 4, 2, 1
 #   The default is 128
 #pga_bypass: False
 #   Disable the internal Programmable Gain Amplifier. If
 #   True the PGA will be disabled for gains 1, 2, and 4. The PGA is always
 #   enabled for gain settings 8 to 128, regardless of the pga_bypass setting.
 #   If AVSS is used as an input pga_bypass is forced to True.
 #   The default is False.
 #sample_rate: 660
 #   This chip supports two ranges of sample rates, Normal and Turbo. In turbo
-#   mode the chip's internal clock runs twice as fast and the SPI communication
+#   mode the chips c internal clock runs twice as fast and the SPI communication
 #   speed is also doubled.
 #   Normal sample rates: 20, 45, 90, 175, 330, 600, 1000
 #   Turbo sample rates: 40, 90, 180, 350, 660, 1200, 2000
 #   The default is 660
 #input_mux:
 #   Input multiplexer configuration, select a pair of pins to use. The first pin
 #   is the positive, AINP, and the second pin is the negative, AINN. Valid
 #   values are: 'AIN0_AIN1', 'AIN0_AIN2', 'AIN0_AIN3', 'AIN1_AIN2', 'AIN1_AIN3',
 #   'AIN2_AIN3', 'AIN1_AIN0', 'AIN3_AIN2', 'AIN0_AVSS', 'AIN1_AVSS', 'AIN2_AVSS'
 #   and 'AIN3_AVSS'. If AVSS is used the PGA is bypassed and the pga_bypass
 #   setting will be forced to True.
 #   The default is AIN0_AIN1.
 #vref:
 #   The selected voltage reference. Valid values are: 'internal', 'REF0', 'REF1'
 #   and 'analog_supply'. Default is 'internal'.
 ```
 ## Board specific hardware support
@@ -4981,50 +4820,6 @@ vssa_pin:
 #   noise. The default is 2 seconds.
 ```
 ### [ads1x1x]
 ADS1013, ADS1014, ADS1015, ADS1113, ADS1114 and ADS1115 are I2C based Analog to
 Digital Converters that can be used for temperature sensors. They provide 4
 analog input pins either as single line or as differential input.
 Note: Use caution if using this sensor to control heaters. The heater min_temp
 and max_temp are only verified in the host and only if the host is running and
 operating normally. (ADC inputs directly connected to the micro-controller
 verify min_temp and max_temp within the micro-controller and do not require a
 working connection to the host.)
 ```
 [ads1x1x my_ads1x1x]
 chip: ADS1115
 #pga: 4.096V
 #   Default value is 4.096V. The maximum voltage range used for the input. This
 #   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
 #   for all values read from the ADC.
 i2c_mcu: host
 i2c_bus: i2c.1
 #address_pin: GND
 #   Default value is GND.  There can be up to four addressed devices depending
 #   upon wiring of the device. Check the datasheet for details. The i2c_address
 #   can be specified directly instead of using the address_pin.
 ```
 The chip provides pins that can be used on other sensors.
 ```
 sensor_type: ...
 #   Can be any thermistor or adc_temperature.
 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
 #   DIFF03 measures the differential between line 0 and 3. Only specific
 #   combinations for the differentials are allowed.
 ```
 ### [replicape]
 Replicape support - see the [beaglebone guide](Beaglebone.md) and the
@@ -5106,7 +4901,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 remove **M1** and **M0** from *Pausing commands*
+printing from virtual_sd, then remo **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.
@@ -5130,9 +4925,8 @@ serial:
 ### [angle]
 Magnetic hall angle sensor support for reading stepper motor angle
-shaft measurements using a1333, as5047d, mt6816, mt6826s,
+shaft measurements using a1333, as5047d, or tle5012b SPI chips.  The
-or tle5012b SPI chips.
+measurements are available via the [API Server](API_Server.md) and
 The measurements are available via the [API Server](API_Server.md) and
 [motion analysis tool](Debugging.md#motion-analysis-and-data-logging).
 See the [G-Code reference](G-Codes.md#angle) for available commands.
@@ -5140,7 +4934,7 @@ See the [G-Code reference](G-Codes.md#angle) for available commands.
 [angle my_angle_sensor]
 sensor_type:
 #   The type of the magnetic hall sensor chip. Available choices are
-#   "a1333", "as5047d", "mt6816", "mt6826s", and "tle5012b". This parameter must be
+#   "a1333", "as5047d", and "tle5012b". This parameter must be
 #   specified.
 #sample_period: 0.000400
 #   The query period (in seconds) to use during measurements. The
@@ -5203,9 +4997,8 @@ Most Klipper micro-controller implementations only support an
 micro-controller supports a 400000 speed (*fast mode*, 400kbit/s), but it must be
 [set in the operating system](RPi_microcontroller.md#optional-enabling-i2c)
 and the `i2c_speed` parameter is otherwise ignored. The Klipper
-"RP2040" micro-controller and ATmega AVR family and some STM32
+"RP2040" micro-controller and ATmega AVR family support a rate of 400000
-(F0, G0, G4, L4, F7, H7) support a rate of 400000 via the `i2c_speed` parameter.
+via the `i2c_speed` parameter. All other Klipper micro-controllers use a
 All other Klipper micro-controllers use a
 100000 rate and ignore the `i2c_speed` parameter.
 ```
--- a/docs/Contact.md
+++ b/docs/Contact.md
@@ -132,10 +132,3 @@ There are several
 you have questions on the code then you can also ask in the
 [Klipper Discourse Forum](#discourse-forum) or on the
 [Klipper Discord Chat](#discord-chat).
 ## Professional Services
 ![](img/klipper-logo-small.png)
 Custom software development, software support, and solutions:
 [https://ko-fi.com/koconnor](https://ko-fi.com/koconnor)
--- a/docs/Eddy_Probe.md
+++ b/docs/Eddy_Probe.md
@@ -78,9 +78,7 @@ for further details on how to configure a `temperature_probe`.  It is
 advised to configure the `calibration_position`,
 `calibration_extruder_temp`, `extruder_heating_z`, and
 `calibration_bed_temp` options, as doing so will automate some of the
-steps outlined below.  If the printer to be calibrated is enclosed, it
+steps outlined below.
 is strongly recommended to set the `max_validation_temp` option to a value
 between 100 and 120.
 Eddy probe manufacturers may offer a stock drift calibration that can be
 manually added to `drift_calibration` option of the `[probe_eddy_current]`
--- a/docs/Features.md
+++ b/docs/Features.md
@@ -102,13 +102,11 @@ 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. The bed mesh can be
+  bed tilt detection or full mesh bed leveling. If the bed uses
  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. If using an "eddy current
+  calibrated for axis twist compensation.
  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
@@ -120,7 +118,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, SHT3x, and LM75). Custom
+  MAX31865, BME280, HTU21D, DS18B20, AHT10, 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
@@ -130,8 +128,7 @@ 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. One can
+  speed can be monitored on fans that have a tachometer.
  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
@@ -157,7 +154,7 @@ Klipper supports many standard 3d printer features:
  filament width sensors.
 * Support for measuring and recording acceleration using adxl345,
-  mpu9250, mpu6050, lis2dw12, lis3dh, and icm20948 accelerometers.
+  mpu9250, mpu6050, and lis2dw12 accelerometers.
 * Support for limiting the top speed of short "zigzag" moves to reduce
  printer vibration and noise. See the [kinematics](Kinematics.md)
@@ -187,14 +184,12 @@ 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             |
 | STM32F407                       | 3652K             | 2459K             |
 | STM32F446                       | 3913K             | 2634K             |
 | RP2040                          | 4000K             | 2571K             |
 | RP2350                          | 4167K             | 2663K             |
 | SAME70                          | 6667K             | 4737K             |
 | STM32H743                       | 9091K             | 6061K             |
 If unsure of the micro-controller on a particular board, find the
--- a/docs/G-Codes.md
+++ b/docs/G-Codes.md
@@ -127,14 +127,6 @@ use this tool the Python "numpy" package must be installed (see the
 [measuring resonance document](Measuring_Resonances.md#software-installation)
 for more information).
 #### ANGLE_CHIP_CALIBRATE
 `ANGLE_CHIP_CALIBRATE CHIP=<chip_name>`: Perform internal sensor calibration,
 if implemented (MT6826S/MT6835).
 - **MT68XX**: The motor should be disconnected
 from any printer carriage before performing calibration.
 After calibration, the sensor should be reset by disconnecting the power.
 #### ANGLE_DEBUG_READ
 `ANGLE_DEBUG_READ CHIP=<config_name> REG=<register>`: Queries sensor
 register "register" (e.g. 44 or 0x2C). Can be useful for debugging
@@ -154,13 +146,9 @@ 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>] [SAMPLE_COUNT=<value>]`
+`AXIS_TWIST_COMPENSATION_CALIBRATE [SAMPLE_COUNT=<value>]`: Initiates the X
-
+twist calibration wizard. `SAMPLE_COUNT` specifies the number of points along
-Calibrates axis twist compensation by specifying the target axis or
+the X axis to calibrate at and defaults to 3.
 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'`.
 ### [bed_mesh]
@@ -488,20 +476,6 @@ enabled.
 `SET_FAN_SPEED FAN=config_name SPEED=<speed>` This command sets the
 speed of a fan. "speed" must be between 0.0 and 1.0.
 `SET_FAN_SPEED PIN=config_name TEMPLATE=<template_name>
 [<param_x>=<literal>]`: If `TEMPLATE` is specified then it assigns a
 [display_template](Config_Reference.md#display_template) to the given
 fan. For example, if one defined a `[display_template
 my_fan_template]` config section then one could assign
 `TEMPLATE=my_fan_template` here. The display_template should produce a
 string containing a floating point number with the desired value. The
 template will be continuously evaluated and the fan will be
 automatically set to the resulting speed. One may set display_template
 parameters to use during template evaluation (parameters will be
 parsed as Python literals). If TEMPLATE is an empty string then this
 command will clear any previous template assigned to the pin (one can
 then use `SET_FAN_SPEED` commands to manage the values directly).
 ### [filament_switch_sensor]
 The following command is available when a
@@ -579,51 +553,15 @@ 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>]`: Force
-`SET_KINEMATIC_POSITION [X=<value>] [Y=<value>] [Z=<value>]
+the low-level kinematic code to believe the toolhead is at the given
-[SET_HOMED=<[X][Y][Z]>] [CLEAR_HOMED=<[X][Y][Z]>]`: Force the
+cartesian position. This is a diagnostic and debugging command; use
-low-level kinematic code to believe the toolhead is at the given
+SET_GCODE_OFFSET and/or G92 for regular axis transformations. If an
-cartesian position and set/clear homed status. This is a diagnostic
+axis is not specified then it will default to the position that the
-and debugging command; use SET_GCODE_OFFSET and/or G92 for regular
+head was last commanded to. Setting an incorrect or invalid position
-axis transformations. Setting an incorrect or invalid position may
+may lead to internal software errors. This command may invalidate
-lead to internal software errors.
+future boundary checks; issue a G28 afterwards to reset the
-
+kinematics.
 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]
@@ -793,82 +731,6 @@ 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
 1. Next you apply a known load to the load cell and run the
 `CALIBRATE GRAMS=nnn` command
 1. 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.
 ### 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.
 ### [manual_probe]
 The manual_probe module is automatically loaded.
@@ -939,6 +801,49 @@ 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
@@ -952,20 +857,6 @@ output `VALUE`. VALUE should be 0 or 1 for "digital" output pins. For
 PWM pins, set to a value between 0.0 and 1.0, or between 0.0 and
 `scale` if a scale is configured in the output_pin config section.
 `SET_PIN PIN=config_name TEMPLATE=<template_name> [<param_x>=<literal>]`:
 If `TEMPLATE` is specified then it assigns a
 [display_template](Config_Reference.md#display_template) to the given
 pin. For example, if one defined a `[display_template
 my_pin_template]` config section then one could assign
 `TEMPLATE=my_pin_template` here. The display_template should produce a
 string containing a floating point number with the desired value. The
 template will be continuously evaluated and the pin will be
 automatically set to the resulting value. One may set display_template
 parameters to use during template evaluation (parameters will be
 parsed as Python literals). If TEMPLATE is an empty string then this
 command will clear any previous template assigned to the pin (one can
 then use `SET_PIN` commands to manage the values directly).
 ### [palette2]
 The following commands are available when the
@@ -1001,6 +892,20 @@ 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
@@ -1026,20 +931,6 @@ 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.
@@ -1130,21 +1021,6 @@ CYCLE_TIME parameter is not stored between SET_PIN commands (any
 SET_PIN command without an explicit CYCLE_TIME parameter will use the
 `cycle_time` specified in the pwm_cycle_time config section).
 ### [quad_gantry_level]
 The following commands are available when the
 [quad_gantry_level config section](Config_Reference.md#quad_gantry_level)
 is enabled.
 #### QUAD_GANTRY_LEVEL
 `QUAD_GANTRY_LEVEL [RETRIES=<value>] [RETRY_TOLERANCE=<value>]
 [HORIZONTAL_MOVE_Z=<value>] [<probe_parameter>=<value>]`: This command
 will probe the points specified in the config and then make
 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.
 ### [query_adc]
 The query_adc module is automatically loaded.
@@ -1180,19 +1056,20 @@ is enabled (also see the
 all enabled accelerometer chips.
 #### TEST_RESONANCES
-`TEST_RESONANCES AXIS=<axis> [OUTPUT=<resonances,raw_data>]
+`TEST_RESONANCES AXIS=<axis> OUTPUT=<resonances,raw_data>
 [NAME=<name>] [FREQ_START=<min_freq>] [FREQ_END=<max_freq>]
-[ACCEL_PER_HZ=<accel_per_hz>] [HZ_PER_SEC=<hz_per_sec>] [CHIPS=<chip_name>]
+[HZ_PER_SEC=<hz_per_sec>] [CHIPS=<adxl345_chip_name>]
-[POINT=x,y,z] [INPUT_SHAPING=<0:1>]`: Runs the resonance
+[POINT=x,y,z] [INPUT_SHAPING=[<0:1>]]`: Runs the resonance
 test in all configured probe points for the requested "axis" and
 measures the acceleration using the accelerometer chips configured for
 the respective axis. "axis" can either be X or Y, or specify an
 arbitrary direction as `AXIS=dx,dy`, where dx and dy are floating
 point numbers defining a direction vector (e.g. `AXIS=X`, `AXIS=Y`, or
 `AXIS=1,-1` to define a diagonal direction). Note that `AXIS=dx,dy`
-and `AXIS=-dx,-dy` is equivalent. `chip_name` can be one or
+and `AXIS=-dx,-dy` is equivalent. `adxl345_chip_name` can be one or
-more configured accel chips, delimited with comma, for example
+more configured adxl345 chip,delimited with comma, for example
-`CHIPS="adxl345, adxl345 rpi"`. If POINT is specified it will override the point(s)
+`CHIPS="adxl345, adxl345 rpi"`. Note that `adxl345` can be omitted from
 named adxl345 chips. If POINT is specified it will override the point(s)
 configured in `[resonance_tester]`. If `INPUT_SHAPING=0` or not set(default),
 disables input shaping for the resonance testing, because
 it is not valid to run the resonance testing with the input shaper
@@ -1209,9 +1086,8 @@ frequency response is calculated (across all probe points) and written into
 #### SHAPER_CALIBRATE
 `SHAPER_CALIBRATE [AXIS=<axis>] [NAME=<name>] [FREQ_START=<min_freq>]
-[FREQ_END=<max_freq>] [ACCEL_PER_HZ=<accel_per_hz>][HZ_PER_SEC=<hz_per_sec>]
+[FREQ_END=<max_freq>] [HZ_PER_SEC=<hz_per_sec>] [CHIPS=<adxl345_chip_name>]
-[CHIPS=<chip_name>] [MAX_SMOOTHING=<max_smoothing>] [INPUT_SHAPING=<0:1>]`:
+[MAX_SMOOTHING=<max_smoothing>]`: Similarly to `TEST_RESONANCES`, runs
 Similarly to `TEST_RESONANCES`, runs
 the resonance test as configured, and tries to find the optimal
 parameters for the input shaper for the requested axis (or both X and
 Y axes if `AXIS` parameter is unset). If `MAX_SMOOTHING` is unset, its
@@ -1261,9 +1137,8 @@ has been enabled.
 #### SAVE_VARIABLE
 `SAVE_VARIABLE VARIABLE=<name> VALUE=<value>`: Saves the variable to
-disk so that it can be used across restarts. The VARIABLE must be lowercase.
+disk so that it can be used across restarts. All stored variables are
-All stored variables are loaded into the
+loaded into the `printer.save_variables.variables` dict at startup and
 `printer.save_variables.variables` dict at startup and
 can be used in gcode macros. The provided VALUE is parsed as a Python
 literal.
@@ -1407,42 +1282,6 @@ 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
@@ -1571,10 +1410,44 @@ The following commands are available when the
 [z_tilt config section](Config_Reference.md#z_tilt) is enabled.
 #### Z_TILT_ADJUST
-`Z_TILT_ADJUST [RETRIES=<value>] [RETRY_TOLERANCE=<value>]
+`Z_TILT_ADJUST [HORIZONTAL_MOVE_Z=<value>] [<probe_parameter>=<value>]`: This
-[HORIZONTAL_MOVE_Z=<value>] [<probe_parameter>=<value>]`: This command
+command will probe the points specified in the config and then make independent
-will probe the points specified in the config and then make
+adjustments to each Z stepper to compensate for tilt. See the PROBE command for
-independent adjustments to each Z stepper to compensate for tilt. See
+details on the optional probe parameters. The optional `HORIZONTAL_MOVE_Z`
-the PROBE command for details on the optional probe parameters. The
+value overrides the `horizontal_move_z` option specified in the config file.
-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.
--- a/docs/Installation.md
+++ b/docs/Installation.md
@@ -1,20 +1,15 @@
 # Installation
-These instructions assume the software will run on a Linux-based host
+These instructions assume the software will run on a Raspberry Pi
-running a Klipper-compatible front end. It is recommended that a
+computer in conjunction with OctoPrint. It is recommended that a
-SBC(Small Board Computer) such as a Raspberry Pi or Debian-based Linux
+Raspberry Pi 2 (or later) be used as the host machine (see the
 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 other machines).
 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
 Most Klipper settings are determined by a "printer configuration file"
-printer.cfg, that will be stored on the host. An appropriate configuration
+that will be stored on the Raspberry Pi. An appropriate configuration
 file can often be found by looking in the Klipper
 [config directory](../config/) for a file starting with a "printer-"
 prefix that corresponds to the target printer. The Klipper
@@ -40,51 +35,38 @@ printer configuration file, then start with the closest example
 [config file](../config/) and use the Klipper
 [config reference](Config_Reference.md) for further information.
-## Interacting with Klipper
+## Prepping an OS image
-Klipper is a 3d printer firmware, so it needs some way for the user to
+Start by installing [OctoPi](https://github.com/guysoft/OctoPi) on the
-interact with it.
+Raspberry Pi computer. Use OctoPi v0.17.0 or later - see the
 [OctoPi releases](https://github.com/guysoft/OctoPi/releases) for
 release information. One should verify that OctoPi boots and that the
 OctoPrint web server works. After connecting to the OctoPrint web
 page, follow the prompt to upgrade OctoPrint to v1.4.2 or later.
-Currently the best choices are front ends that retrieve information through
+After installing OctoPi and upgrading OctoPrint, it will be necessary
-the [Moonraker web API](https://moonraker.readthedocs.io/) and there is also
+to ssh into the target machine to run a handful of system commands. If
-the option to use [Octoprint](https://octoprint.org/) to control Klipper.
+using a Linux or MacOS desktop, then the "ssh" software should already
 be installed on the desktop. There are free ssh clients available for
 other desktops (eg,
 [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/)). Use the
 ssh utility to connect to the Raspberry Pi (`ssh pi@octopi` -- password
 is "raspberry") and run the following commands:
-The choice is up to the user on what to use, but the underlying Klipper is the
+```
-same in all cases. We encourage users to research the options available and
+git clone https://github.com/Klipper3d/klipper
-make an informed decision.
+./klipper/scripts/install-octopi.sh
 ```
-## Obtaining an OS image for SBC's
+The above will download Klipper, install some system dependencies,
-
+setup Klipper to run at system startup, and start the Klipper host
-There are many ways to obtain an OS image for Klipper for SBC use, most depend on
+software. It will require an internet connection and it may take a few
-what front end you wish to use. Some manufacturers of these SBC boards also provide
+minutes to complete.
 their own Klipper-centric images.
 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"](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.
 OctoPrint can be installed via the popular OctoPi image or via KIAUH, this
 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 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 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
 at https://github.com/dw-0/kiauh
 ## Building and flashing the micro-controller
 To compile the micro-controller code, start by running these commands
-on your host device:
+on the Raspberry Pi:
 ```
 cd ~/klipper/
@@ -106,7 +88,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
@@ -126,21 +108,10 @@ It should report something similar to the following:
 It's common for each printer to have its own unique serial port name.
 This unique name will be used when flashing the micro-controller. It's
 possible there may be multiple lines in the above output - if so,
-choose the line corresponding to the micro-controller. If many
+choose the line corresponding to the micro-controller (see the
 items are listed and the choice is ambiguous, unplug the board and
 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
+For common micro-controllers, the code can be flashed with something
 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
 occurring.
 For common micro-controllers using Atmega chips, for example the 2560,
 the code can be flashed with something
 similar to:
 ```
@@ -152,38 +123,53 @@ sudo service klipper start
 Be sure to update the FLASH_DEVICE with the printer's unique serial
 port name.
-For common micro-controllers using RP2040 chips, the code can be flashed
+When flashing for the first time, make sure that OctoPrint is not
-with something similar to:
+connected directly to the printer (from the OctoPrint web page, under
 the "Connection" section, click "Disconnect").
-```
+## Configuring OctoPrint to use Klipper
 sudo service klipper stop
 make flash FLASH_DEVICE=first
 sudo service klipper start
 ```
-It is important to note that RP2040 chips may need to be put into Boot mode
+The OctoPrint web server needs to be configured to communicate with
-before this operation.
+the Klipper host software. Using a web browser, login to the OctoPrint
 web page and then configure the following items:
 Navigate to the Settings tab (the wrench icon at the top of the
 page). Under "Serial Connection" in "Additional serial ports" add
 `/tmp/printer`. Then click "Save".
 Enter the Settings tab again and under "Serial Connection" change the
 "Serial Port" setting to `/tmp/printer`.
 In the Settings tab, navigate to the "Behavior" sub-tab and select the
 "Cancel any ongoing prints but stay connected to the printer"
 option. Click "Save".
 From the main page, under the "Connection" section (at the top left of
 the page) make sure the "Serial Port" is set to `/tmp/printer` and
 click "Connect". (If `/tmp/printer` is not an available selection then
 try reloading the page.)
 Once connected, navigate to the "Terminal" tab and type "status"
 (without the quotes) into the command entry box and click "Send". The
 terminal window will likely report there is an error opening the
 config file - that means OctoPrint is successfully communicating with
 Klipper. Proceed to the next section.
 ## Configuring Klipper
 The next step is to copy the
 [printer configuration file](#obtain-a-klipper-configuration-file) to
-the host.
+the Raspberry Pi.
-Arguably the easiest way to set the Klipper configuration file is using the
+Arguably the easiest way to set the Klipper configuration file is to
-built-in editors in Mainsail or Fluidd. These will allow the user to open
+use a desktop editor that supports editing files over the "scp" and/or
-the configuration examples and save them to be printer.cfg.
+"sftp" protocols. There are freely available tools that support this
-
+(eg, Notepad++, WinSCP, and Cyberduck). Load the printer config file
-Another option is to use a desktop editor that supports editing files
+in the editor and then save it as a file named `printer.cfg` in the
-over the "scp" and/or "sftp" protocols. There are freely available tools
+home directory of the pi user (ie, `/home/pi/printer.cfg`).
 that support this (eg, Notepad++, WinSCP, and Cyberduck).
 Load the printer config file in the editor and then save it as a file
 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
+Raspberry Pi via ssh. That may look something like the following (be
 sure to update the command to use the appropriate printer config
 filename):
@@ -214,9 +200,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
+"restart" command in the OctoPrint web terminal to load the config. A
-"status" command will report that the printer is ready if the Klipper
+"status" command will report the printer is ready if the Klipper
 config file is successfully read and the micro-controller is
 successfully found and configured.
@@ -225,10 +211,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 pop-ups in
+Klipper reports error messages via the OctoPrint terminal tab. The
-Fluidd and Mainsail. The "status" command can be used to re-report error
+"status" command can be used to re-report error messages. The default
-messages. A log is available and usually located at
+Klipper startup script also places a log in **/tmp/klippy.log** which
-`~/printer_data/logs/klippy.log`.
+provides more detailed information.
 After Klipper reports that the printer is ready, proceed to the
 [config check document](Config_checks.md) to perform some basic checks
--- a/docs/Load_Cell.md
+++ b/docs/Load_Cell.md
@@ -1,122 +0,0 @@
 # 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 ths 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 %}
 ```
--- a/docs/Measuring_Resonances.md
+++ b/docs/Measuring_Resonances.md
@@ -1,26 +1,24 @@
 # Measuring Resonances
-Klipper has built-in support for the ADXL345, MPU-9250, LIS2DW and LIS3DH compatible
+Klipper has built-in support for the ADXL345, MPU-9250 and LIS2DW compatible
 accelerometers which can be used to measure resonance frequencies of the printer
 for different axes, and auto-tune [input shapers](Resonance_Compensation.md) to
 compensate for resonances. Note that using accelerometers requires some
-soldering and crimping. The ADXL345 can be connected to the SPI interface
+soldering and crimping. The ADXL345/LIS2DW can be connected to the SPI interface
 of a Raspberry Pi or MCU board (it needs to be reasonably fast). The MPU family can
 be connected to the I2C interface of a Raspberry Pi directly, or to an I2C
-interface of an MCU board that supports 400kbit/s *fast mode* in Klipper. The
+interface of an MCU board that supports 400kbit/s *fast mode* in Klipper.
 LIS2DW and LIS3DH can be connected to either SPI or I2C with the same considerations
 as above.
 When sourcing accelerometers, be aware that there are a variety of different PCB
 board designs and different clones of them. If it is going to be connected to a
 5V printer MCU ensure it has a voltage regulator and level shifters.
-For ADXL345s, make sure that the board supports SPI mode (a small number of
+For ADXL345s/LIS2DWs, 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-6500/ICM20948s and LIS2DW/LIS3DH there
+For MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500s there are also a variety of
-are also a variety of board designs and clones with different I2C pull-up resistors
+board designs and clones with different I2C pull-up resistors which will need
-which will need supplementing.
+supplementing.
 ## MCUs with Klipper I2C *fast-mode* Support
@@ -29,7 +27,6 @@ which will need supplementing.
 | Raspberry Pi | 3B+, Pico | 3A, 3A+, 3B, 4 |
 | AVR ATmega | ATmega328p | ATmega32u4, ATmega128, ATmega168, ATmega328, ATmega644p, ATmega1280, ATmega1284, ATmega2560 |
 | AVR AT90 | - | AT90usb646, AT90usb1286 |
 | SAMD | SAMC21G18 | SAMC21G18, SAMD21G18, SAMD21E18, SAMD21J18, SAMD21E15, SAMD51G19, SAMD51J19, SAMD51N19, SAMD51P20, SAME51J19, SAME51N19, SAME54P20 |
 ## Installation instructions
@@ -136,7 +133,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/ICM20948
+#### MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500
 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
@@ -215,20 +212,12 @@ sudo apt install python3-numpy python3-matplotlib libatlas-base-dev libopenblas-
 Next, in order to install NumPy in the Klipper environment, run the command:
 ```
-~/klippy-env/bin/pip install -v "numpy<1.26"
+~/klippy-env/bin/pip install -v numpy
 ```
 Note that, depending on the performance of the CPU, it may take *a lot*
 of time, up to 10-20 minutes. Be patient and wait for the completion of
 the installation. On some occasions, if the board has too little RAM
-the installation may fail and you will need to enable swap. Also note
+the installation may fail and you will need to enable swap.
 the forced version, due to newer versions of NumPY having requirements
 that may not be satisfied in some klipper python environments.
 Once installed please check that no errors show from the command:
 ```
 ~/klippy-env/bin/python -c 'import numpy;'
 ```
 The correct output should simply be a new line.
 #### Configure ADXL345 With RPi
@@ -316,7 +305,7 @@ you'll also want to modify your `printer.cfg` file to include this:
 Restart Klipper via the `RESTART` command.
-#### Configure LIS2DW series over SPI
+#### Configure LIS2DW series
 ```
 [mcu lis]
@@ -355,7 +344,6 @@ 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
@@ -378,7 +366,6 @@ 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
@@ -397,7 +384,6 @@ 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.
@@ -697,24 +683,6 @@ If you are doing a shaper re-calibration and the reported smoothing for the
 suggested shaper configuration is almost the same as what you got during the
 previous calibration, this step can be skipped.
 ### Unreliable measurements of resonance frequencies
 Sometimes the resonance measurements can produce bogus results, leading to
 the incorrect suggestions for the input shapers. This can be caused by a
 variety of reasons, including running fans on the toolhead, incorrect
 position or non-rigid mounting of the accelerometer, or mechanical problems
 such as loose belts or binding or bumpy axis. Keep in mind that all fans
 should be disabled for resonance testing, especially the noisy ones, and
 that the accelerometer should be rigidly mounted on the corresponding
 moving part (e.g. on the bed itself for the bed slinger, or on the extruder
 of the printer itself and not the carriage, and some people get better
 results by mounting the accelerometer on the nozzle itself). As for
 mechanical problems, the user should inspect if there is any fault that
 can be fixed with a moving axis (e.g. linear guide rails cleaned up and
 lubricated and V-slot wheels tension adjusted correctly). If none of that
 helps, a user may try the other shapers from the produced list besides the
 one recommended by default.
 ### Testing custom axes
 `TEST_RESONANCES` command supports custom axes. While this is not really
--- a/docs/OctoPrint.md
+++ b/docs/OctoPrint.md
@@ -1,79 +0,0 @@
 # OctoPrint for Klipper
 Klipper has a few options for its front ends, Octoprint was the first
 and original front end for Klipper. This document will give
 a brief overview of installing with this option.
 ## Install with OctoPi
 Start by installing [OctoPi](https://github.com/guysoft/OctoPi) on the
 Raspberry Pi computer. Use OctoPi v0.17.0 or later - see the
 [OctoPi releases](https://github.com/guysoft/OctoPi/releases) for
 release information.
 One should verify that OctoPi boots and that the
 OctoPrint web server works. After connecting to the OctoPrint web
 page, follow the prompt to upgrade OctoPrint if needed.
 After installing OctoPi and upgrading OctoPrint, it will be necessary
 to ssh into the target machine to run a handful of system commands.
 Start by running these commands on your host device:
 __If you do not have git installed, please do so with:__
 ```
 sudo apt install git
 ```
 then proceed:
 ```
 cd ~
 git clone https://github.com/Klipper3d/klipper
 ./klipper/scripts/install-octopi.sh
 ```
 The above will download Klipper, install the needed system dependencies,
 setup Klipper to run at system startup, and start the Klipper host
 software. It will require an internet connection and it may take a few
 minutes to complete.
 ## Installing with KIAUH
 KIAUH can be used to install OctoPrint on a variety of Linux based systems
 that run a form of Debian. More information can be found
 at https://github.com/dw-0/kiauh
 ## Configuring OctoPrint to use Klipper
 The OctoPrint web server needs to be configured to communicate with the Klipper
 host software. Using a web browser, login to the OctoPrint web page and then
 configure the following items:
 Navigate to the Settings tab (the wrench icon at the top of the page).
 Under "Serial Connection" in "Additional serial ports" add:
 ```
 ~/printer_data/comms/klippy.serial
 ```
 Then click "Save".
 _In some older setups this address may be `/tmp/printer`_
 Enter the Settings tab again and under "Serial Connection" change the "Serial Port"
 setting to the one added above.
 In the Settings tab, navigate to the "Behavior" sub-tab and select the
 "Cancel any ongoing prints but stay connected to the printer" option. Click "Save".
 From the main page, under the "Connection" section (at the top left of the page)
 make sure the "Serial Port" is set to the new additional one added
 and click "Connect". (If it is not in the available selection then
 try reloading the page.)
 Once connected, navigate to the "Terminal" tab and type "status" (without the quotes)
 into the command entry box and click "Send". The terminal window will likely report
 there is an error opening the config file - that means OctoPrint is successfully
 communicating with Klipper.
 Please proceed to [Installation.md](Installation.md) and the
 _Building and flashing the micro-controller_ section
--- a/docs/Overview.md
+++ b/docs/Overview.md
@@ -17,7 +17,6 @@ communication with the Klipper developers.
 ## Installation and Configuration
 - [Installation](Installation.md): Guide to installing Klipper.
  - [Octoprint](OctoPrint.md): Guide to installing Octoprint with Klipper.
 - [Config Reference](Config_Reference.md): Description of config
  parameters.
  - [Rotation Distance](Rotation_Distance.md): Calculating the
@@ -101,4 +100,3 @@ 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)
--- a/docs/Pressure_Advance.md
+++ b/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" and "scarf joint" seams are disabled in the slicer.
+"dynamic acceleration control" is disabled in the slicer.
 Prepare for the test by issuing the following G-Code command:
 ```
--- a/docs/Releases.md
+++ b/docs/Releases.md
@@ -3,35 +3,6 @@
 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:
--- a/docs/Sponsors.md
+++ b/docs/Sponsors.md
@@ -17,6 +17,7 @@ serve the 3D printing community better. Follow them on
 ## Sponsors
 [<img src="./img/sponsors/obico-light-horizontal.png" width="200" style="margin:25px" />](https://obico.io/klipper.html?source=klipper_sponsor)
 [<img src="./img/sponsors/peopoly-logo.png" width="200" style="margin:25px" />](https://peopoly.net)
 ## Klipper Developers
--- a/docs/Status_Reference.md
+++ b/docs/Status_Reference.md
@@ -31,7 +31,7 @@ The following information is available in the
 ## bed_screws
 The following information is available in the
-[bed_screws](Config_Reference.md#bed_screws) object:
+`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,27 +39,6 @@ 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
@@ -277,6 +256,11 @@ object is available if any heater is defined):
  e.g. `["tmc2240 stepper_x"]`.  While a temperature sensor is always
  available to read, a temperature monitor may not be available and
  will return null in such case.
 - `temperature_wait`: Indicates if G-Code processing is stalled
  waiting for a requested temperature (typically via
  `TEMPERATURE_WAIT`, `M109`, or `M190` commands). The value will
  contain the name of the sensor that is causing the stall or `None`
  if no wait is in progress.
 ## idle_timeout
@@ -303,17 +287,6 @@ The following information is available for each `[led led_name]`,
  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.
 ## manual_probe
 The following information is available in the
@@ -458,12 +431,6 @@ 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
--- a/docs/TMC_Drivers.md
+++ b/docs/TMC_Drivers.md
@@ -83,10 +83,6 @@ 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
--- a/docs/_klipper3d/README
+++ b/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 && ~/mkdocs-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
+virtualenv ~/mkdocs-env && ~/python-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 && ~/mkdocs-env/bin/pip install -r ~/klipper/docs/_klipper3d/mkdocs-requirements.txt
+virtualenv ~/mkdocs-env && ~/python-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
--- a/docs/_klipper3d/mkdocs-requirements.txt
+++ b/docs/_klipper3d/mkdocs-requirements.txt
@@ -1,5 +1,5 @@
 # Python virtualenv module requirements for mkdocs
-jinja2==3.1.6
+jinja2==3.1.4
 mkdocs==1.2.4
 mkdocs-material==8.1.3
 mkdocs-simple-hooks==0.1.3
--- a/docs/_klipper3d/mkdocs.yml
+++ b/docs/_klipper3d/mkdocs.yml
@@ -88,9 +88,7 @@ nav:
  - Config_Changes.md
  - Contact.md
  - Installation and Configuration:
-    - Installation:
+    - Installation.md
      - Installation.md
      - OctoPrint.md
    - Configuration Reference:
      - Config_Reference.md
      - Rotation_Distance.md
@@ -141,5 +139,4 @@ nav:
    - TSL1401CL_Filament_Width_Sensor.md
    - Hall_Filament_Width_Sensor.md
    - Eddy_Probe.md
    - Load_Cell.md
  - Sponsors.md
--- a/docs/img/klipper_pico_menuconfig.png
+++ b/docs/img/klipper_pico_menuconfig.png
--- a/docs/index.md
+++ b/docs/index.md
@@ -6,16 +6,13 @@ title: Welcome
 ![](img/klipper-logo.png){ .center-image }
-The Klipper firmware controls 3d-Printers. It combines the power of a
+Klipper is a 3d-Printer firmware. It combines the power of a general
-general purpose computer with one or more micro-controllers. See the
+purpose computer with one or more micro-controllers. See the
-[features document](https://www.klipper3d.org/Features.html) for more
+[features](Features.md) document for more information on why you
-information on why you should use the Klipper software.
+should use Klipper.
-Start by [installing Klipper software](https://www.klipper3d.org/Installation.html).
+To begin using Klipper start by [installing](Installation.md) it.
-Klipper software is Free Software. Read the
+Klipper is Free Software. Read the [documentation](Overview.md) or
-[documentation](https://www.klipper3d.org/Overview.html), see the
+view [the Klipper code on github](https://github.com/Klipper3d/klipper).
-[license](COPYING), or
+We depend on the generous support from our [sponsors](Sponsors.md).
 [download](https://github.com/Klipper3d/Klipper) the software. We
 depend on the generous support from our
 [sponsors](https://www.klipper3d.org/Sponsors.html).
--- a/klippy/chelper/kin_shaper.c
+++ b/klippy/chelper/kin_shaper.c
@@ -156,16 +156,6 @@ 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);
 }
 // 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);
    is->orig_sk->commanded_pos = sk->commanded_pos;
    is->orig_sk->post_cb(is->orig_sk);
    sk->commanded_pos = is->orig_sk->commanded_pos;
 }
 int __visible
 input_shaper_set_sk(struct stepper_kinematics *sk
                    , struct stepper_kinematics *orig_sk)
@@ -184,9 +174,6 @@ input_shaper_set_sk(struct stepper_kinematics *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;
 }
--- a/klippy/configfile.py
+++ b/klippy/configfile.py
@@ -1,17 +1,12 @@
 # Code for reading and writing the Klipper config file
 #
-# Copyright (C) 2016-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import sys, os, glob, re, time, logging, configparser, io
 error = configparser.Error
 ######################################################################
 # Config section parsing helper
 ######################################################################
 class sentinel:
    pass
@@ -139,13 +134,30 @@ class ConfigWrapper:
        pconfig = self.printer.lookup_object("configfile")
        pconfig.deprecate(self.section, option, value, msg)
 AUTOSAVE_HEADER = """
 #*# <---------------------- SAVE_CONFIG ---------------------->
 #*# DO NOT EDIT THIS BLOCK OR BELOW. The contents are auto-generated.
 #*#
 """
-######################################################################
+class PrinterConfig:
-# Config file parsing (with include file support)
+    def __init__(self, printer):
-######################################################################
+        self.printer = printer
-
+        self.autosave = None
-class ConfigFileReader:
+        self.deprecated = {}
-    def read_config_file(self, filename):
+        self.runtime_warnings = []
        self.deprecate_warnings = []
        self.status_raw_config = {}
        self.status_save_pending = {}
        self.status_settings = {}
        self.status_warnings = []
        self.save_config_pending = False
        gcode = self.printer.lookup_object('gcode')
        gcode.register_command("SAVE_CONFIG", self.cmd_SAVE_CONFIG,
                               desc=self.cmd_SAVE_CONFIG_help)
    def get_printer(self):
        return self.printer
    def _read_config_file(self, filename):
        try:
            f = open(filename, 'r')
            data = f.read()
@@ -155,102 +167,6 @@ class ConfigFileReader:
            logging.exception(msg)
            raise error(msg)
        return data.replace('\r\n', '\n')
    def build_config_string(self, fileconfig):
        sfile = io.StringIO()
        fileconfig.write(sfile)
        return sfile.getvalue().strip()
    def append_fileconfig(self, fileconfig, data, filename):
        if not data:
            return
        # Strip trailing comments
        lines = data.split('\n')
        for i, line in enumerate(lines):
            pos = line.find('#')
            if pos >= 0:
                lines[i] = line[:pos]
        sbuffer = io.StringIO('\n'.join(lines))
        if sys.version_info.major >= 3:
            fileconfig.read_file(sbuffer, filename)
        else:
            fileconfig.readfp(sbuffer, filename)
    def _create_fileconfig(self):
        if sys.version_info.major >= 3:
            fileconfig = configparser.RawConfigParser(
                strict=False, inline_comment_prefixes=(';', '#'))
        else:
            fileconfig = configparser.RawConfigParser()
        return fileconfig
    def build_fileconfig(self, data, filename):
        fileconfig = self._create_fileconfig()
        self.append_fileconfig(fileconfig, data, filename)
        return fileconfig
    def _resolve_include(self, source_filename, include_spec, fileconfig,
                         visited):
        dirname = os.path.dirname(source_filename)
        include_spec = include_spec.strip()
        include_glob = os.path.join(dirname, include_spec)
        include_filenames = glob.glob(include_glob)
        if not include_filenames and not glob.has_magic(include_glob):
            # Empty set is OK if wildcard but not for direct file reference
            raise error("Include file '%s' does not exist" % (include_glob,))
        include_filenames.sort()
        for include_filename in include_filenames:
            include_data = self.read_config_file(include_filename)
            self._parse_config(include_data, include_filename, fileconfig,
                               visited)
        return include_filenames
    def _parse_config(self, data, filename, fileconfig, visited):
        path = os.path.abspath(filename)
        if path in visited:
            raise error("Recursive include of config file '%s'" % (filename))
        visited.add(path)
        lines = data.split('\n')
        # Buffer lines between includes and parse as a unit so that overrides
        # in includes apply linearly as they do within a single file
        buf = []
        for line in lines:
            # Strip trailing comment
            pos = line.find('#')
            if pos >= 0:
                line = line[:pos]
            # Process include or buffer line
            mo = configparser.RawConfigParser.SECTCRE.match(line)
            header = mo and mo.group('header')
            if header and header.startswith('include '):
                self.append_fileconfig(fileconfig, '\n'.join(buf), filename)
                del buf[:]
                include_spec = header[8:].strip()
                self._resolve_include(filename, include_spec, fileconfig,
                                      visited)
            else:
                buf.append(line)
        self.append_fileconfig(fileconfig, '\n'.join(buf), filename)
        visited.remove(path)
    def build_fileconfig_with_includes(self, data, filename):
        fileconfig = self._create_fileconfig()
        self._parse_config(data, filename, fileconfig, set())
        return fileconfig
 ######################################################################
 # Config auto save helper
 ######################################################################
 AUTOSAVE_HEADER = """
 #*# <---------------------- SAVE_CONFIG ---------------------->
 #*# DO NOT EDIT THIS BLOCK OR BELOW. The contents are auto-generated.
 #*#
 """
 class ConfigAutoSave:
    def __init__(self, printer):
        self.printer = printer
        self.fileconfig = None
        self.status_save_pending = {}
        self.save_config_pending = False
        gcode = self.printer.lookup_object('gcode')
        gcode.register_command("SAVE_CONFIG", self.cmd_SAVE_CONFIG,
                               desc=self.cmd_SAVE_CONFIG_help)
    def _find_autosave_data(self, data):
        regular_data = data
        autosave_data = ""
@@ -259,7 +175,7 @@ class ConfigAutoSave:
            regular_data = data[:pos]
            autosave_data = data[pos + len(AUTOSAVE_HEADER):].strip()
        # Check for errors and strip line prefixes
-        if "\n#*# " in regular_data or autosave_data.find(AUTOSAVE_HEADER) >= 0:
+        if "\n#*# " in regular_data:
            logging.warning("Can't read autosave from config file"
                            " - autosave state corrupted")
            return data, ""
@@ -276,7 +192,7 @@ class ConfigAutoSave:
        return regular_data, "\n".join(out)
    comment_r = re.compile('[#;].*$')
    value_r = re.compile('[^A-Za-z0-9_].*$')
-    def _strip_duplicates(self, data, fileconfig):
+    def _strip_duplicates(self, data, config):
        # Comment out fields in 'data' that are defined in 'config'
        lines = data.split('\n')
        section = None
@@ -294,31 +210,152 @@ class ConfigAutoSave:
                section = pruned_line[1:-1].strip()
                continue
            field = self.value_r.sub('', pruned_line)
-            if fileconfig.has_option(section, field):
+            if config.fileconfig.has_option(section, field):
                is_dup_field = True
                lines[lineno] = '#' + lines[lineno]
        return "\n".join(lines)
-    def load_main_config(self):
+    def _parse_config_buffer(self, buffer, filename, fileconfig):
        if not buffer:
            return
        data = '\n'.join(buffer)
        del buffer[:]
        sbuffer = io.StringIO(data)
        if sys.version_info.major >= 3:
            fileconfig.read_file(sbuffer, filename)
        else:
            fileconfig.readfp(sbuffer, filename)
    def _resolve_include(self, source_filename, include_spec, fileconfig,
                         visited):
        dirname = os.path.dirname(source_filename)
        include_spec = include_spec.strip()
        include_glob = os.path.join(dirname, include_spec)
        include_filenames = glob.glob(include_glob)
        if not include_filenames and not glob.has_magic(include_glob):
            # Empty set is OK if wildcard but not for direct file reference
            raise error("Include file '%s' does not exist" % (include_glob,))
        include_filenames.sort()
        for include_filename in include_filenames:
            include_data = self._read_config_file(include_filename)
            self._parse_config(include_data, include_filename, fileconfig,
                               visited)
        return include_filenames
    def _parse_config(self, data, filename, fileconfig, visited):
        path = os.path.abspath(filename)
        if path in visited:
            raise error("Recursive include of config file '%s'" % (filename))
        visited.add(path)
        lines = data.split('\n')
        # Buffer lines between includes and parse as a unit so that overrides
        # in includes apply linearly as they do within a single file
        buffer = []
        for line in lines:
            # Strip trailing comment
            pos = line.find('#')
            if pos >= 0:
                line = line[:pos]
            # Process include or buffer line
            mo = configparser.RawConfigParser.SECTCRE.match(line)
            header = mo and mo.group('header')
            if header and header.startswith('include '):
                self._parse_config_buffer(buffer, filename, fileconfig)
                include_spec = header[8:].strip()
                self._resolve_include(filename, include_spec, fileconfig,
                                      visited)
            else:
                buffer.append(line)
        self._parse_config_buffer(buffer, filename, fileconfig)
        visited.remove(path)
    def _build_config_wrapper(self, data, filename):
        if sys.version_info.major >= 3:
            fileconfig = configparser.RawConfigParser(
                strict=False, inline_comment_prefixes=(';', '#'))
        else:
            fileconfig = configparser.RawConfigParser()
        self._parse_config(data, filename, fileconfig, set())
        return ConfigWrapper(self.printer, fileconfig, {}, 'printer')
    def _build_config_string(self, config):
        sfile = io.StringIO()
        config.fileconfig.write(sfile)
        return sfile.getvalue().strip()
    def read_config(self, filename):
        return self._build_config_wrapper(self._read_config_file(filename),
                                          filename)
    def read_main_config(self):
        filename = self.printer.get_start_args()['config_file']
-        cfgrdr = ConfigFileReader()
+        data = self._read_config_file(filename)
        data = cfgrdr.read_config_file(filename)
        regular_data, autosave_data = self._find_autosave_data(data)
-        regular_fileconfig = cfgrdr.build_fileconfig_with_includes(
+        regular_config = self._build_config_wrapper(regular_data, filename)
-            regular_data, filename)
+        autosave_data = self._strip_duplicates(autosave_data, regular_config)
-        autosave_data = self._strip_duplicates(autosave_data,
+        self.autosave = self._build_config_wrapper(autosave_data, filename)
-                                               regular_fileconfig)
+        cfg = self._build_config_wrapper(regular_data + autosave_data, filename)
-        self.fileconfig = cfgrdr.build_fileconfig(autosave_data, filename)
+        return cfg
-        cfgrdr.append_fileconfig(regular_fileconfig,
+    def check_unused_options(self, config):
-                                 autosave_data, '*AUTOSAVE*')
+        fileconfig = config.fileconfig
-        return regular_fileconfig, self.fileconfig
+        objects = dict(self.printer.lookup_objects())
        # Determine all the fields that have been accessed
        access_tracking = dict(config.access_tracking)
        for section in self.autosave.fileconfig.sections():
            for option in self.autosave.fileconfig.options(section):
                access_tracking[(section.lower(), option.lower())] = 1
        # Validate that there are no undefined parameters in the config file
        valid_sections = { s: 1 for s, o in access_tracking }
        for section_name in fileconfig.sections():
            section = section_name.lower()
            if section not in valid_sections and section not in objects:
                raise error("Section '%s' is not a valid config section"
                            % (section,))
            for option in fileconfig.options(section_name):
                option = option.lower()
                if (section, option) not in access_tracking:
                    raise error("Option '%s' is not valid in section '%s'"
                                % (option, section))
        # Setup get_status()
        self._build_status(config)
    def log_config(self, config):
        lines = ["===== Config file =====",
                 self._build_config_string(config),
                 "======================="]
        self.printer.set_rollover_info("config", "\n".join(lines))
    # Status reporting
    def runtime_warning(self, msg):
        logging.warning(msg)
        res = {'type': 'runtime_warning', 'message': msg}
        self.runtime_warnings.append(res)
        self.status_warnings = self.runtime_warnings + self.deprecate_warnings
    def deprecate(self, section, option, value=None, msg=None):
        self.deprecated[(section, option, value)] = msg
    def _build_status(self, config):
        self.status_raw_config.clear()
        for section in config.get_prefix_sections(''):
            self.status_raw_config[section.get_name()] = section_status = {}
            for option in section.get_prefix_options(''):
                section_status[option] = section.get(option, note_valid=False)
        self.status_settings = {}
        for (section, option), value in config.access_tracking.items():
            self.status_settings.setdefault(section, {})[option] = value
        self.deprecate_warnings = []
        for (section, option, value), msg in self.deprecated.items():
            if value is None:
                res = {'type': 'deprecated_option'}
            else:
                res = {'type': 'deprecated_value', 'value': value}
            res['message'] = msg
            res['section'] = section
            res['option'] = option
            self.deprecate_warnings.append(res)
        self.status_warnings = self.runtime_warnings + self.deprecate_warnings
    def get_status(self, eventtime):
-        return {'save_config_pending': self.save_config_pending,
+        return {'config': self.status_raw_config,
                'settings': self.status_settings,
                'warnings': self.status_warnings,
                'save_config_pending': self.save_config_pending,
                'save_config_pending_items': self.status_save_pending}
    # Autosave functions
    def set(self, section, option, value):
-        if not self.fileconfig.has_section(section):
+        if not self.autosave.fileconfig.has_section(section):
-            self.fileconfig.add_section(section)
+            self.autosave.fileconfig.add_section(section)
        svalue = str(value)
-        self.fileconfig.set(section, option, svalue)
+        self.autosave.fileconfig.set(section, option, svalue)
        pending = dict(self.status_save_pending)
        if not section in pending or pending[section] is None:
            pending[section] = {}
@@ -329,8 +366,8 @@ class ConfigAutoSave:
        self.save_config_pending = True
        logging.info("save_config: set [%s] %s = %s", section, option, svalue)
    def remove_section(self, section):
-        if self.fileconfig.has_section(section):
+        if self.autosave.fileconfig.has_section(section):
-            self.fileconfig.remove_section(section)
+            self.autosave.fileconfig.remove_section(section)
            pending = dict(self.status_save_pending)
            pending[section] = None
            self.status_save_pending = pending
@@ -341,20 +378,21 @@ class ConfigAutoSave:
            del pending[section]
            self.status_save_pending = pending
            self.save_config_pending = True
-    def _disallow_include_conflicts(self, regular_fileconfig):
+    def _disallow_include_conflicts(self, regular_data, cfgname, gcode):
-        for section in self.fileconfig.sections():
+        config = self._build_config_wrapper(regular_data, cfgname)
-            for option in self.fileconfig.options(section):
+        for section in self.autosave.fileconfig.sections():
-                if regular_fileconfig.has_option(section, option):
+            for option in self.autosave.fileconfig.options(section):
                if config.fileconfig.has_option(section, option):
                    msg = ("SAVE_CONFIG section '%s' option '%s' conflicts "
                           "with included value" % (section, option))
-                    raise self.printer.command_error(msg)
+                    raise gcode.error(msg)
    cmd_SAVE_CONFIG_help = "Overwrite config file and restart"
    def cmd_SAVE_CONFIG(self, gcmd):
-        if not self.fileconfig.sections():
+        if not self.autosave.fileconfig.sections():
            return
        gcode = self.printer.lookup_object('gcode')
        # Create string containing autosave data
-        cfgrdr = ConfigFileReader()
+        autosave_data = self._build_config_string(self.autosave)
        autosave_data = cfgrdr.build_config_string(self.fileconfig)
        lines = [('#*# ' + l).strip()
                 for l in autosave_data.split('\n')]
        lines.insert(0, "\n" + AUTOSAVE_HEADER.rstrip())
@@ -363,27 +401,16 @@ class ConfigAutoSave:
        # Read in and validate current config file
        cfgname = self.printer.get_start_args()['config_file']
        try:
-            data = cfgrdr.read_config_file(cfgname)
+            data = self._read_config_file(cfgname)
-        except error as e:
+            regular_data, old_autosave_data = self._find_autosave_data(data)
-            msg = "Unable to read existing config on SAVE_CONFIG"
+            config = self._build_config_wrapper(regular_data, cfgname)
            logging.exception(msg)
            raise gcmd.error(msg)
        regular_data, old_autosave_data = self._find_autosave_data(data)
        regular_data = self._strip_duplicates(regular_data, self.fileconfig)
        data = regular_data.rstrip() + autosave_data
        new_regular_data, new_autosave_data = self._find_autosave_data(data)
        if not new_autosave_data:
            raise gcmd.error(
                "Existing config autosave is corrupted."
                " Can't complete SAVE_CONFIG")
        try:
            regular_fileconfig = cfgrdr.build_fileconfig_with_includes(
                new_regular_data, cfgname)
        except error as e:
            msg = "Unable to parse existing config on SAVE_CONFIG"
            logging.exception(msg)
-            raise gcmd.error(msg)
+            raise gcode.error(msg)
-        self._disallow_include_conflicts(regular_fileconfig)
+        regular_data = self._strip_duplicates(regular_data, self.autosave)
        self._disallow_include_conflicts(regular_data, cfgname, gcode)
        data = regular_data.rstrip() + autosave_data
        # Determine filenames
        datestr = time.strftime("-%Y%m%d_%H%M%S")
        backup_name = cfgname + datestr
@@ -403,135 +430,6 @@ class ConfigAutoSave:
        except:
            msg = "Unable to write config file during SAVE_CONFIG"
            logging.exception(msg)
-            raise gcmd.error(msg)
+            raise gcode.error(msg)
        # Request a restart
        gcode = self.printer.lookup_object('gcode')
        gcode.request_restart('restart')
 ######################################################################
 # Config validation (check for undefined options)
 ######################################################################
 class ConfigValidate:
    def __init__(self, printer):
        self.printer = printer
        self.status_settings = {}
        self.access_tracking = {}
        self.autosave_options = {}
    def start_access_tracking(self, autosave_fileconfig):
        # Note autosave options for use during undefined options check
        self.autosave_options = {}
        for section in autosave_fileconfig.sections():
            for option in autosave_fileconfig.options(section):
                self.autosave_options[(section.lower(), option.lower())] = 1
        self.access_tracking = {}
        return self.access_tracking
    def check_unused(self, fileconfig):
        # Don't warn on fields set in autosave segment
        access_tracking = dict(self.access_tracking)
        access_tracking.update(self.autosave_options)
        # Note locally used sections
        valid_sections = { s: 1 for s, o in self.printer.lookup_objects() }
        valid_sections.update({ s: 1 for s, o in access_tracking })
        # Validate that there are no undefined parameters in the config file
        for section_name in fileconfig.sections():
            section = section_name.lower()
            if section not in valid_sections:
                raise error("Section '%s' is not a valid config section"
                            % (section,))
            for option in fileconfig.options(section_name):
                option = option.lower()
                if (section, option) not in access_tracking:
                    raise error("Option '%s' is not valid in section '%s'"
                                % (option, section))
        # Setup get_status()
        self._build_status_settings()
        # Clear tracking state
        self.access_tracking.clear()
        self.autosave_options.clear()
    def _build_status_settings(self):
        self.status_settings = {}
        for (section, option), value in self.access_tracking.items():
            self.status_settings.setdefault(section, {})[option] = value
    def get_status(self, eventtime):
        return {'settings': self.status_settings}
 ######################################################################
 # Main printer config tracking
 ######################################################################
 class PrinterConfig:
    def __init__(self, printer):
        self.printer = printer
        self.autosave = ConfigAutoSave(printer)
        self.validate = ConfigValidate(printer)
        self.deprecated = {}
        self.runtime_warnings = []
        self.deprecate_warnings = []
        self.status_raw_config = {}
        self.status_warnings = []
    def get_printer(self):
        return self.printer
    def read_config(self, filename):
        cfgrdr = ConfigFileReader()
        data = cfgrdr.read_config_file(filename)
        fileconfig = cfgrdr.build_fileconfig(data, filename)
        return ConfigWrapper(self.printer, fileconfig, {}, 'printer')
    def read_main_config(self):
        fileconfig, autosave_fileconfig = self.autosave.load_main_config()
        access_tracking = self.validate.start_access_tracking(
            autosave_fileconfig)
        config = ConfigWrapper(self.printer, fileconfig,
                               access_tracking, 'printer')
        self._build_status_config(config)
        return config
    def log_config(self, config):
        cfgrdr = ConfigFileReader()
        lines = ["===== Config file =====",
                 cfgrdr.build_config_string(config.fileconfig),
                 "======================="]
        self.printer.set_rollover_info("config", "\n".join(lines))
    def check_unused_options(self, config):
        self.validate.check_unused(config.fileconfig)
    # Deprecation warnings
    def runtime_warning(self, msg):
        logging.warning(msg)
        res = {'type': 'runtime_warning', 'message': msg}
        self.runtime_warnings.append(res)
        self.status_warnings = self.runtime_warnings + self.deprecate_warnings
    def deprecate(self, section, option, value=None, msg=None):
        key = (section, option, value)
        if key in self.deprecated and self.deprecated[key] == msg:
            return
        self.deprecated[key] = msg
        self.deprecate_warnings = []
        for (section, option, value), msg in self.deprecated.items():
            if value is None:
                res = {'type': 'deprecated_option'}
            else:
                res = {'type': 'deprecated_value', 'value': value}
            res['message'] = msg
            res['section'] = section
            res['option'] = option
            self.deprecate_warnings.append(res)
        self.status_warnings = self.runtime_warnings + self.deprecate_warnings
    # Status reporting
    def _build_status_config(self, config):
        self.status_raw_config = {}
        for section in config.get_prefix_sections(''):
            self.status_raw_config[section.get_name()] = section_status = {}
            for option in section.get_prefix_options(''):
                section_status[option] = section.get(option, note_valid=False)
    def get_status(self, eventtime):
        status = {'config': self.status_raw_config,
                  'warnings': self.status_warnings}
        status.update(self.autosave.get_status(eventtime))
        status.update(self.validate.get_status(eventtime))
        return status
    # Autosave functions
    def set(self, section, option, value):
        self.autosave.set(section, option, value)
    def remove_section(self, section):
        self.autosave.remove_section(section)
--- a/klippy/extras/ads1220.py
+++ b/klippy/extras/ads1220.py
@@ -24,7 +24,7 @@ def hexify(byte_array):
    return "[%s]" % (", ".join([hex(b) for b in byte_array]))
-class ADS1220:
+class ADS1220():
    def __init__(self, config):
        self.printer = printer = config.get_printer()
        self.name = config.get_name().split()[-1]
@@ -42,35 +42,8 @@ class ADS1220:
                          '660': 660, '1200': 1200, '2000': 2000}
        self.sps_options = self.sps_normal.copy()
        self.sps_options.update(self.sps_turbo)
-        self.sps = config.getchoice('sample_rate', self.sps_options,
+        self.sps = config.getchoice('sps', self.sps_options, default='660')
                                    default='660')
        self.is_turbo = str(self.sps) in self.sps_turbo
        # Input multiplexer: AINP and AINN
        mux_options = {'AIN0_AIN1': 0b0000, 'AIN0_AIN2': 0b0001,
                       'AIN0_AIN3': 0b0010, 'AIN1_AIN2': 0b0011,
                       'AIN1_AIN3': 0b0100, 'AIN2_AIN3': 0b0101,
                       'AIN1_AIN0': 0b0110, 'AIN3_AIN2': 0b0111,
                       'AIN0_AVSS': 0b1000, 'AIN1_AVSS': 0b1001,
                       'AIN2_AVSS': 0b1010, 'AIN3_AVSS': 0b1011}
        self.mux = config.getchoice('input_mux', mux_options,
                                    default='AIN0_AIN1')
        # PGA Bypass
        self.pga_bypass = config.getboolean('pga_bypass', default=False)
        # bypass PGA when AVSS is the negative input
        force_pga_bypass = self.mux >= 0b1000
        self.pga_bypass = force_pga_bypass or self.pga_bypass
        # Voltage Reference
        self.vref_options = {'internal': 0b0, 'REF0': 0b01, 'REF1': 0b10,
                             'analog_supply': 0b11}
        self.vref = config.getchoice('vref', self.vref_options,
                                     default='internal')
        # check for conflict between REF1 and AIN0/AIN3
        mux_conflict = [0b0000, 0b0001, 0b0010, 0b0100, 0b0101, 0b0110, 0b0111,
                        0b1000, 0b1011]
        if self.vref == 0b10 and self.mux in mux_conflict:
            raise config.error("ADS1220 config error: AIN0/REFP1 and AIN3/REFN1"
                               " cant be used as a voltage reference and"
                               " an input at the same time")
        # SPI Setup
        spi_speed = 512000 if self.is_turbo else 256000
        self.spi = bus.MCU_SPI_from_config(config, 1, default_speed=spi_speed)
@@ -95,6 +68,10 @@ 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
        self.batch_bulk.add_mux_endpoint("ads1220/dump_ads1220", "sensor",
                                         self.name,
                                         {'header': ('time', 'counts')})
        # Command Configuration
        mcu.add_config_cmd(
            "config_ads1220 oid=%d spi_oid=%d data_ready_pin=%s"
@@ -180,10 +157,8 @@ class ADS1220:
        mode = 0x2 if self.is_turbo else 0x0  # turbo mode
        sps_list = self.sps_turbo if self.is_turbo else self.sps_normal
        data_rate = list(sps_list.keys()).index(str(self.sps))
-        reg_values = [(self.mux << 4) | (self.gain << 1) | int(self.pga_bypass),
+        reg_values = [(self.gain << 1),
-                      (data_rate << 5) | (mode << 3) | (continuous << 2),
+                      (data_rate << 5) | (mode << 3) | (continuous << 2)]
                      (self.vref << 6),
                      0x0]
        self.write_reg(0x0, reg_values)
        # start measurements immediately
        self.send_command(START_SYNC_CMD)
@@ -202,7 +177,7 @@ class ADS1220:
        write_command.extend(register_bytes)
        self.spi.spi_send(write_command)
        stored_val = self.read_reg(reg, len(register_bytes))
-        if bytearray(register_bytes) != stored_val:
+        if register_bytes != stored_val:
            raise self.printer.command_error(
                "Failed to set ADS1220 register [0x%x] to %s: got %s. "
                "This may be a connection problem (e.g. faulty wiring)" % (
--- a/klippy/extras/ads1x1x.py
+++ b/klippy/extras/ads1x1x.py
@@ -1,393 +0,0 @@
 # Support for I2C based ADS1013, ADS1014, ADS1015, ADS1113, ADS1114 and ADS1115
 #
 # Copyright (C) 2024 Konstantin Koch <korsarnek@gmail.com>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
 import pins
 from . import bus
 # Supported chip types
 ADS1X1X_CHIP_TYPE = {
    'ADS1013': 3,
    'ADS1014': 4,
    'ADS1015': 5,
    'ADS1113': 13,
    'ADS1114': 14,
    'ADS1115': 15
 }
 def isADS101X(chip):
    return (chip == ADS1X1X_CHIP_TYPE['ADS1013'] \
        or chip == ADS1X1X_CHIP_TYPE['ADS1014'] \
        or chip == ADS1X1X_CHIP_TYPE['ADS1015'])
 def isADS111X(chip):
    return (chip == ADS1X1X_CHIP_TYPE['ADS1113'] \
        or chip == ADS1X1X_CHIP_TYPE['ADS1114'] \
        or chip == ADS1X1X_CHIP_TYPE['ADS1115'])
 # Address is defined by how the address pin is wired
 ADS1X1X_CHIP_ADDR = {
    'GND': 0x48,
    'VCC': 0x49,
    'SDA': 0x4a,
    'SCL': 0x4b
 }
 # Chip "pointer" registers
 ADS1X1X_REG_POINTER_MASK = 0x03
 ADS1X1X_REG_POINTER = {
    'CONVERSION': 0x00,
    'CONFIG': 0x01,
    'LO_THRESH': 0x02,
    'HI_THRESH': 0x03
 }
 # Config register masks
 ADS1X1X_REG_CONFIG = {
    'OS_MASK': 0x8000,
    'MULTIPLEXER_MASK': 0x7000,
    'PGA_MASK': 0x0E00,
    'MODE_MASK': 0x0100,
    'DATA_RATE_MASK': 0x00E0,
    'COMPARATOR_MODE_MASK': 0x0010,
    'COMPARATOR_POLARITY_MASK': 0x0008,
    # Determines if ALERT/RDY pin latches once asserted
    'COMPARATOR_LATCHING_MASK': 0x0004,
    'COMPARATOR_QUEUE_MASK': 0x0003
 }
 #
 # The following enums are to be used with the configuration functions.
 #
 ADS1X1X_OS = {
    'OS_IDLE': 0x8000,  # Device is not performing a conversion
    'OS_SINGLE': 0x8000 # Single-conversion
 }
 ADS1X1X_MUX = {
    'DIFF01': 0x0000,  # Differential P = AIN0, N = AIN1 0
    'DIFF03': 0x1000,  # Differential P = AIN0, N = AIN3 4096
    'DIFF13': 0x2000,  # Differential P = AIN1, N = AIN3 8192
    'DIFF23': 0x3000,  # Differential P = AIN2, N = AIN3 12288
    'AIN0': 0x4000,  # Single-ended (ADS1015: AIN0 16384)
    'AIN1': 0x5000,  # Single-ended (ADS1015: AIN1 20480)
    'AIN2': 0x6000,  # Single-ended (ADS1015: AIN2 24576)
    'AIN3': 0x7000   # Single-ended (ADS1015: AIN3 28672)
 }
 ADS1X1X_PGA = {
    '6.144V': 0x0000,  # +/-6.144V range = Gain 2/3
    '4.096V': 0x0200,  # +/-4.096V range = Gain 1
    '2.048V': 0x0400,  # +/-2.048V range = Gain 2
    '1.024V': 0x0600,  # +/-1.024V range = Gain 4
    '0.512V': 0x0800,  # +/-0.512V range = Gain 8
    '0.256V': 0x0A00  # +/-0.256V range = Gain 16
 }
 ADS1X1X_PGA_VALUE = {
    0x0000: 6.144,
    0x0200: 4.096,
    0x0400: 2.048,
    0x0600: 1.024,
    0x0800: 0.512,
    0x0A00: 0.256,
 }
 ADS111X_RESOLUTION = 32767.0
 ADS111X_PGA_SCALAR = {
    0x0000: 6.144 / ADS111X_RESOLUTION,  # +/-6.144V range = Gain 2/3
    0x0200: 4.096 / ADS111X_RESOLUTION,  # +/-4.096V range = Gain 1
    0x0400: 2.048 / ADS111X_RESOLUTION,  # +/-2.048V range = Gain 2
    0x0600: 1.024 / ADS111X_RESOLUTION,  # +/-1.024V range = Gain 4
    0x0800: 0.512 / ADS111X_RESOLUTION,  # +/-0.512V range = Gain 8
    0x0A00: 0.256 / ADS111X_RESOLUTION  # +/-0.256V range = Gain 16
 }
 ADS101X_RESOLUTION = 2047.0
 ADS101X_PGA_SCALAR = {
    0x0000: 6.144 / ADS101X_RESOLUTION,  # +/-6.144V range = Gain 2/3
    0x0200: 4.096 / ADS101X_RESOLUTION,  # +/-4.096V range = Gain 1
    0x0400: 2.048 / ADS101X_RESOLUTION,  # +/-2.048V range = Gain 2
    0x0600: 1.024 / ADS101X_RESOLUTION,  # +/-1.024V range = Gain 4
    0x0800: 0.512 / ADS101X_RESOLUTION,  # +/-0.512V range = Gain 8
    0x0A00: 0.256 / ADS101X_RESOLUTION  # +/-0.256V range = Gain 16
 }
 ADS1X1X_MODE = {
    'continuous': 0x0000,  # Continuous conversion mode
    'single': 0x0100  # Power-down single-shot mode
 }
 # Lesser samples per second means it takes and averages more samples before
 # returning a result.
 ADS101X_SAMPLES_PER_SECOND = {
    '128': 0x0000,  # 128 samples per second
    '250': 0x0020,  # 250 samples per second
    '490': 0x0040,  # 490 samples per second
    '920': 0x0060,  # 920 samples per second
    '1600': 0x0080,  # 1600 samples per second
    '2400': 0x00a0,  # 2400 samples per second
    '3300': 0x00c0,  # 3300 samples per second
 }
 ADS111X_SAMPLES_PER_SECOND = {
    '8': 0x0000,  # 8 samples per second
    '16': 0x0020,  # 16 samples per second
    '32': 0x0040,  # 32 samples per second
    '64': 0x0060,  # 64 samples per second
    '128': 0x0080,  # 128 samples per second
    '250': 0x00a0,  # 250 samples per second
    '475': 0x00c0,  # 475 samples per second
    '860': 0x00e0  # 860 samples per second
 }
 ADS1X1X_COMPARATOR_MODE = {
    'TRADITIONAL': 0x0000,  # Traditional comparator with hysteresis
    'WINDOW': 0x0010  # Window comparator
 }
 ADS1X1X_COMPARATOR_POLARITY = {
    'ACTIVE_LO': 0x0000,  # ALERT/RDY pin is low when active
    'ACTIVE_HI': 0x0008  # ALERT/RDY pin is high when active
 }
 ADS1X1X_COMPARATOR_LATCHING = {
    'NON_LATCHING': 0x0000,  # Non-latching comparator
    'LATCHING': 0x0004  # Latching comparator
 }
 ADS1X1X_COMPARATOR_QUEUE = {
    'QUEUE_1': 0x0000,  # Assert ALERT/RDY after one conversions
    'QUEUE_2': 0x0001,  # Assert ALERT/RDY after two conversions
    'QUEUE_4': 0x0002,  # Assert ALERT/RDY after four conversions
    'QUEUE_NONE': 0x0003  # Disable the comparator and put ALERT/RDY
                        # in high state
 }
 ADS1X1_OPERATIONS = {
    'SET_MUX': 0,
    'READ_CONVERSION': 1
 }
 class ADS1X1X_chip:
    def __init__(self, config):
        self._printer = config.get_printer()
        self._reactor = self._printer.get_reactor()
        self.name = config.get_name().split()[-1]
        self.chip = config.getchoice('chip', ADS1X1X_CHIP_TYPE)
        address = ADS1X1X_CHIP_ADDR['GND']
        # If none is specified, i2c_address can be used for a specific address
        if config.get('address_pin', None) is not None:
            address = config.getchoice('address_pin', ADS1X1X_CHIP_ADDR)
        self._ppins = self._printer.lookup_object("pins")
        self._ppins.register_chip(self.name, self)
        self.pga = config.getchoice('pga', ADS1X1X_PGA, '4.096V')
        self.adc_voltage = config.getfloat('adc_voltage', above=0., default=3.3)
        # Comparators are not implemented, they would only be useful if the
        # alert pin is used, which we haven't made configurable.
        # But that wouldn't be useful for a normal temperature sensor anyway.
        self.comp_mode = ADS1X1X_COMPARATOR_MODE['TRADITIONAL']
        self.comp_polarity = ADS1X1X_COMPARATOR_POLARITY['ACTIVE_LO']
        self.comp_latching = ADS1X1X_COMPARATOR_LATCHING['NON_LATCHING']
        self.comp_queue = ADS1X1X_COMPARATOR_QUEUE['QUEUE_NONE']
        self._i2c = bus.MCU_I2C_from_config(config, address)
        self.mcu = self._i2c.get_mcu()
        self._printer.add_object("ads1x1x " + self.name, self)
        self._printer.register_event_handler("klippy:connect", \
                                            self._handle_connect)
        self._pins = {}
        self._mutex = self._reactor.mutex()
    def setup_pin(self, pin_type, pin_params):
        pin = pin_params['pin']
        if pin_type == 'adc':
            if (pin not in ADS1X1X_MUX):
                raise pins.error('ADS1x1x pin %s is not valid' % \
                                 pin_params['pin'])
            config = 0
            config |= (ADS1X1X_OS['OS_SINGLE'] & \
                       ADS1X1X_REG_CONFIG['OS_MASK'])
            config |= (ADS1X1X_MUX[pin_params['pin']] & \
                       ADS1X1X_REG_CONFIG['MULTIPLEXER_MASK'])
            config |= (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'] & \
                       ADS1X1X_REG_CONFIG['MODE_MASK'])
            # lowest sample rate per default, until report time has been set in
            # setup_adc_sample
            config |= (self.comp_mode \
                & ADS1X1X_REG_CONFIG['COMPARATOR_MODE_MASK'])
            config |= (self.comp_polarity \
                & ADS1X1X_REG_CONFIG['COMPARATOR_POLARITY_MASK'])
            config |= (self.comp_latching \
                & ADS1X1X_REG_CONFIG['COMPARATOR_LATCHING_MASK'])
            config |= (self.comp_queue \
                & ADS1X1X_REG_CONFIG['COMPARATOR_QUEUE_MASK'])
            pin_obj = ADS1X1X_pin(self, config)
            if pin in self._pins:
                raise pins.error(
                    'pin %s for chip %s is used multiple times' \
                        % (pin, self.name))
            self._pins[pin] = pin_obj
            return pin_obj
        raise pins.error('Wrong pin or incompatible type: %s with type %s! ' % (
            pin, pin_type))
    def _handle_connect(self):
        try:
            # Init all devices on bus for this kind of device
            self._i2c.i2c_write([0x06, 0x00, 0x00])
        except Exception:
            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']) == \
                    ADS1X1X_OS['OS_IDLE'])
    def calculate_sample_rate(self):
        pin_count = len(self._pins)
        lowest_report_time = 1
        for pin in self._pins.values():
            lowest_report_time = min(lowest_report_time, pin.report_time)
        sample_rate = 1 / lowest_report_time * pin_count
        samples_per_second = ADS111X_SAMPLES_PER_SECOND
        if isADS101X(self.chip):
            samples_per_second = ADS101X_SAMPLES_PER_SECOND
        # make sure the samples list is sorted correctly by number.
        samples_per_second = sorted(samples_per_second.items(), \
                                    key=lambda t: int(t[0]))
        for rate, bits in samples_per_second:
            rate_number = int(rate)
            if sample_rate <= rate_number:
                return (rate_number, bits)
        logging.warning(
            "ADS1X1X: requested sample rate %s is higher than supported by %s."\
                % (sample_rate, self.name))
        return (rate_number, bits)
    def handle_report_time_update(self):
        (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']) \
                | (sample_rate_bits & ADS1X1X_REG_CONFIG['DATA_RATE_MASK'])
        self.delay = 1 / float(sample_rate)
    def sample(self, pin):
        with self._mutex:
            try:
                self._write_register(ADS1X1X_REG_POINTER['CONFIG'], pin.config)
                self._reactor.pause(self._reactor.monotonic() + self.delay)
                start_time = self._reactor.monotonic()
                while not self.is_ready():
                    self._reactor.pause(self._reactor.monotonic() + 0.001)
                    # if we waited twice the expected time, mark this an error
                    if start_time + self.delay < self._reactor.monotonic():
                        logging.warning("ADS1X1X: timeout during sampling")
                        return None
                return self._read_register(ADS1X1X_REG_POINTER['CONVERSION'])
            except Exception as e:
                logging.exception("ADS1X1X: error while sampling: %s" % str(e))
                return None
    def _read_register(self, reg):
        # read a single register
        params = self._i2c.i2c_read([reg], 2)
        buff = bytearray(params['response'])
        return (buff[0]<<8 | buff[1])
    def _write_register(self, reg, data):
        data = [
            (reg & 0xFF), # Control register
            ((data>>8) & 0xFF), # High byte
            (data & 0xFF), # Lo byte
        ]
        self._i2c.i2c_write(data)
 class ADS1X1X_pin:
    def __init__(self, chip, config):
        self.mcu = chip.mcu
        self.chip = chip
        self.config = config
        self.invalid_count = 0
        self.chip._printer.register_event_handler("klippy:connect", \
                                                  self._handle_connect)
    def _handle_connect(self):
        self._reactor = self.chip._printer.get_reactor()
        self._sample_timer = \
            self._reactor.register_timer(self._process_sample, \
                                         self._reactor.NOW)
    def _process_sample(self, eventtime):
        sample = self.chip.sample(self)
        if sample is not None:
            # The sample is encoded in the top 12 or full 16 bits
            # Value's meaning is defined by ADS1X1X_REG_CONFIG['PGA_MASK']
            if isADS101X(self.chip.chip):
                sample >>= 4
                target_value = sample / ADS101X_RESOLUTION
            else:
                target_value = sample / ADS111X_RESOLUTION
            # Thermistors expect a value between 0 and 1 to work. If we use a
            # PGA with 4.096V but supply only 3.3V, the reference voltage for
            # voltage divider is only 3.3V, not 4.096V. So we remap the range
            # from what the PGA allows as range to end up between 0 and 1 for
            # the thermistor logic to work as expected.
            target_value = target_value * (ADS1X1X_PGA_VALUE[self.chip.pga] / \
                                           self.chip.adc_voltage)
            if target_value > self.maxval or target_value < self.minval:
                self.invalid_count = self.invalid_count + 1
                logging.warning("ADS1X1X: temperature outside range")
                self.check_invalid()
            else:
                self.invalid_count = 0
            # Publish result
            measured_time = self._reactor.monotonic()
            self.callback(self.chip.mcu.estimated_print_time(measured_time),
                        target_value)
        else:
            self.invalid_count = self.invalid_count + 1
            self.check_invalid()
        return eventtime + self.report_time
    def check_invalid(self):
        if self.invalid_count > self.range_check_count:
            self.chip._printer.invoke_shutdown(
                "ADS1X1X temperature check failed")
    def get_mcu(self):
        return self.mcu
    def setup_adc_callback(self, report_time, callback):
        self.report_time = report_time
        self.callback = callback
        self.chip.handle_report_time_update()
    def setup_adc_sample(self, sample_time, sample_count,
                         minval=0., maxval=1., range_check_count=0):
        self.minval = minval
        self.maxval = maxval
        self.range_check_count = range_check_count
 def load_config_prefix(config):
    return ADS1X1X_chip(config)
--- a/klippy/extras/adxl345.py
+++ b/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=127, parser=lambda x: int(x, 0))
+        reg = gcmd.get("REG", minval=0, maxval=126, 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=127, parser=lambda x: int(x, 0))
+        reg = gcmd.get("REG", minval=0, maxval=126, 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)
--- a/klippy/extras/angle.py
+++ b/klippy/extras/angle.py
@@ -411,196 +411,6 @@ class HelperTLE5012B:
                       parser=lambda x: int(x, 0))
        self._write_reg(reg, val)
 class HelperMT6816:
    SPI_MODE = 3
    SPI_SPEED = 10000000
    def __init__(self, config, spi, oid):
        self.printer = config.get_printer()
        self.spi = spi
        self.oid = oid
        self.mcu = spi.get_mcu()
        self.mcu.register_config_callback(self._build_config)
        self.spi_angle_transfer_cmd = None
        self.is_tcode_absolute = False
        self.last_temperature = None
        name = config.get_name().split()[-1]
        gcode = self.printer.lookup_object("gcode")
        gcode.register_mux_command("ANGLE_DEBUG_READ", "CHIP", name,
                                   self.cmd_ANGLE_DEBUG_READ,
                                   desc=self.cmd_ANGLE_DEBUG_READ_help)
    def _build_config(self):
        cmdqueue = self.spi.get_command_queue()
        self.spi_angle_transfer_cmd = self.mcu.lookup_query_command(
            "spi_angle_transfer oid=%c data=%*s",
            "spi_angle_transfer_response oid=%c clock=%u response=%*s",
            oid=self.oid, cq=cmdqueue)
    def _send_spi(self, msg):
        return self.spi.spi_transfer(msg)
    def get_static_delay(self):
        return .000001
    def _read_reg(self, reg):
        msg = [reg, 0, 0]
        params = self._send_spi(msg)
        resp = bytearray(params['response'])
        val =  (resp[1] << 8) | resp[2]
        return val
    def start(self):
        pass
    cmd_ANGLE_DEBUG_READ_help = "Query low-level angle sensor register"
    def cmd_ANGLE_DEBUG_READ(self, gcmd):
        reg = 0x83
        val = self._read_reg(reg)
        gcmd.respond_info("ANGLE REG[0x%02x] = 0x%04x" % (reg, val))
        angle = val >> 2
        parity = bin(val >> 1).count("1") % 2
        gcmd.respond_info("Angle %i ~ %.2f" % (angle, angle * 360 / (1 << 14)))
        gcmd.respond_info("No Mag: %i" % (val >> 1 & 0x1))
        gcmd.respond_info("Parity: %i == %i" % (parity, val & 0x1))
 class HelperMT6826S:
    SPI_MODE = 3
    SPI_SPEED = 10000000
    def __init__(self, config, spi, oid):
        self.printer = config.get_printer()
        self.stepper_name = config.get('stepper', None)
        self.spi = spi
        self.oid = oid
        self.mcu = spi.get_mcu()
        self.mcu.register_config_callback(self._build_config)
        self.spi_angle_transfer_cmd = None
        self.is_tcode_absolute = False
        self.last_temperature = None
        name = config.get_name().split()[-1]
        gcode = self.printer.lookup_object("gcode")
        gcode.register_mux_command("ANGLE_DEBUG_READ", "CHIP", name,
                                   self.cmd_ANGLE_DEBUG_READ,
                                   desc=self.cmd_ANGLE_DEBUG_READ_help)
        gcode.register_mux_command("ANGLE_CHIP_CALIBRATE", "CHIP", name,
                                   self.cmd_ANGLE_CHIP_CALIBRATE,
                                   desc=self.cmd_ANGLE_CHIP_CALIBRATE_help)
        self.status_map = {
            0: "No Calibration",
            1: "Running Calibration",
            2: "Calibration Failed",
            3: "Calibration Successful"
        }
    def _build_config(self):
        cmdqueue = self.spi.get_command_queue()
        self.spi_angle_transfer_cmd = self.mcu.lookup_query_command(
            "spi_angle_transfer oid=%c data=%*s",
            "spi_angle_transfer_response oid=%c clock=%u response=%*s",
            oid=self.oid, cq=cmdqueue)
    def _send_spi(self, msg):
        params = self.spi.spi_transfer(msg)
        return params
    def get_static_delay(self):
        return .00001
    def _read_reg(self, reg):
        reg = 0x3000 | reg
        msg = [reg >> 8, reg & 0xff, 0]
        params = self._send_spi(msg)
        resp = bytearray(params['response'])
        return resp[2]
    def _write_reg(self, reg, data):
        reg = 0x6000 | reg
        msg = [reg >> 8, reg & 0xff, data]
        self._send_spi(msg)
    def crc8(self, data):
        polynomial = 0x07
        crc = 0x00
        for byte in data:
            crc ^= byte
            for _ in range(8):
                if crc & 0x80:
                    crc = (crc << 1) ^ polynomial
                else:
                    crc <<= 1
                crc &= 0xFF
        return crc
    def _read_angle(self, reg):
        reg = 0x3000 | reg
        msg = [reg >> 8, reg & 0xff, 0, 0, 0, 0]
        params = self._send_spi(msg)
        resp = bytearray(params['response'])
        angle = (resp[2] << 7) | (resp[3] >> 1)
        status = resp[4]
        crc_computed = self.crc8([resp[2], resp[3], resp[4]])
        crc = resp[5]
        return angle, status, crc, crc_computed
    def start(self):
        val = self._read_reg(0x00d)
        # Set histeresis to 0.003 degree
        self._write_reg(0x00d, (val & 0xf8) | 0x5)
    def get_microsteps(self):
        configfile = self.printer.lookup_object('configfile')
        sconfig = configfile.get_status(None)['settings']
        stconfig = sconfig.get(self.stepper_name, {})
        microsteps = stconfig['microsteps']
        full_steps = stconfig['full_steps_per_rotation']
        return microsteps, full_steps
    cmd_ANGLE_CHIP_CALIBRATE_help = "Run MT6826s calibration sequence"
    def cmd_ANGLE_CHIP_CALIBRATE(self, gcmd):
        fmove = self.printer.lookup_object('force_move')
        mcu_stepper = fmove.lookup_stepper(self.stepper_name)
        if self.stepper_name is None:
            gcmd.respond_info("stepper not defined")
            return
        gcmd.respond_info("MT6826S Run calibration sequence")
        gcmd.respond_info("Motor will do 18+ rotations -" +
                          " ensure pulley is disconnected")
        req_freq = self._read_reg(0x00e) >> 4 & 0x7
        # Minimal calibration speed
        rpm = (3200 >> req_freq) + 1
        rps = rpm / 60
        move = fmove.manual_move
        # Move stepper several turns (to allow internal sensor calibration)
        microsteps, full_steps = self.get_microsteps()
        step_dist = mcu_stepper.get_step_dist()
        full_step_dist = step_dist * microsteps
        rotation_dist = full_steps * full_step_dist
        move(mcu_stepper, 2 * rotation_dist, rps * rotation_dist)
        self._write_reg(0x155, 0x5e)
        move(mcu_stepper, 20 * rotation_dist, rps * rotation_dist)
        val = self._read_reg(0x113)
        code = val >> 6
        gcmd.respond_info("Status: %s" % (self.status_map[code]))
        while code == 1:
            move(mcu_stepper, 5 * rotation_dist, rps * rotation_dist)
            val = self._read_reg(0x113)
            code = val >> 6
            gcmd.respond_info("Status: %s" % (self.status_map[code]))
        if code == 2:
            gcmd.respond_info("Calibration failed")
        if code == 3:
            gcmd.respond_info("Calibration success, please poweroff sensor")
    cmd_ANGLE_DEBUG_READ_help = "Query low-level angle sensor register"
    def cmd_ANGLE_DEBUG_READ(self, gcmd):
        reg = gcmd.get("REG", minval=0, maxval=0x155,
                       parser=lambda x: int(x, 0))
        if reg == 0x003:
            angle, status, crc1, crc2 = self._read_angle(reg)
            gcmd.respond_info("ANGLE REG[0x003] = 0x%02x" %
                              (angle >> 7))
            gcmd.respond_info("ANGLE REG[0x004] = 0x%02x" %
                              ((angle << 1) & 0xff))
            gcmd.respond_info("Angle %i ~ %.2f" % (angle,
                                                   angle * 360 / (1 << 15)))
            gcmd.respond_info("Weak Mag: %i" % (status >> 1 & 0x1))
            gcmd.respond_info("Under Voltage: %i" % (status >> 2 & 0x1))
            gcmd.respond_info("CRC: 0x%02x == 0x%02x" % (crc1, crc2))
        elif reg == 0x00e:
            val = self._read_reg(reg)
            gcmd.respond_info("GPIO_DS = %i" % (val >> 7))
            gcmd.respond_info("AUTOCAL_FREQ = %i" % (val >> 4 & 0x7))
        elif reg == 0x113:
            val = self._read_reg(reg)
            gcmd.respond_info("Status: %s" % (self.cal_status[val >> 6]))
        else:
            val = self._read_reg(reg)
            gcmd.respond_info("REG[0x%04x] = 0x%02x" % (reg, val))
 BYTES_PER_SAMPLE = 3
 SAMPLES_PER_BLOCK = bulk_sensor.MAX_BULK_MSG_SIZE // BYTES_PER_SAMPLE
@@ -617,11 +427,8 @@ class Angle:
        self.start_clock = self.time_shift = self.sample_ticks = 0
        self.last_sequence = self.last_angle = 0
        # Sensor type
-        sensors = { "a1333": HelperA1333,
+        sensors = { "a1333": HelperA1333, "as5047d": HelperAS5047D,
-                    "as5047d": HelperAS5047D,
+                    "tle5012b": HelperTLE5012B }
                    "tle5012b": HelperTLE5012B,
                    "mt6816": HelperMT6816,
                    "mt6826s": HelperMT6826S }
        sensor_type = config.getchoice('sensor_type', {s: s for s in sensors})
        sensor_class = sensors[sensor_type]
        self.spi = bus.MCU_SPI_from_config(config, sensor_class.SPI_MODE,
--- a/klippy/extras/axis_twist_compensation.py
+++ b/klippy/extras/axis_twist_compensation.py
@@ -23,27 +23,18 @@ class AxisTwistCompensation:
        self.horizontal_move_z = config.getfloat('horizontal_move_z',
                                                 DEFAULT_HORIZONTAL_MOVE_Z)
        self.speed = config.getfloat('speed', DEFAULT_SPEED)
-        self.calibrate_start_x = config.getfloat('calibrate_start_x',
+        self.calibrate_start_x = config.getfloat('calibrate_start_x')
-                                                default=None)
+        self.calibrate_end_x = config.getfloat('calibrate_end_x')
-        self.calibrate_end_x = config.getfloat('calibrate_end_x', default=None)
+        self.calibrate_y = config.getfloat('calibrate_y')
        self.calibrate_y = config.getfloat('calibrate_y', default=None)
        self.z_compensations = config.getlists('z_compensations',
                                               default=[], parser=float)
        self.compensation_start_x = config.getfloat('compensation_start_x',
                                                    default=None)
-        self.compensation_end_x = config.getfloat('compensation_end_x',
+        self.compensation_end_x = config.getfloat('compensation_start_y',
                                                  default=None)
-        self.calibrate_start_y = config.getfloat('calibrate_start_y',
+        self.m = None
-                                                  default=None)
+        self.b = None
        self.calibrate_end_y = config.getfloat('calibrate_end_y', default=None)
        self.calibrate_x = config.getfloat('calibrate_x', default=None)
        self.compensation_start_y = config.getfloat('compensation_start_y',
                                                    default=None)
        self.compensation_end_y = config.getfloat('compensation_end_y',
                                                  default=None)
        self.zy_compensations = config.getlists('zy_compensations',
                                                default=[], parser=float)
        # setup calibrater
        self.calibrater = Calibrater(self, config)
@@ -52,46 +43,28 @@ class AxisTwistCompensation:
                                            self._update_z_compensation_value)
    def _update_z_compensation_value(self, pos):
-        if self.z_compensations:
+        if not self.z_compensations:
-            pos[2] += self._get_interpolated_z_compensation(
+            return
                pos[0], self.z_compensations,
                self.compensation_start_x,
                self.compensation_end_x
                )
        if self.zy_compensations:
            pos[2] += self._get_interpolated_z_compensation(
                pos[1], self.zy_compensations,
                self.compensation_start_y,
                self.compensation_end_y
                )
    def _get_interpolated_z_compensation(
            self, coord, z_compensations,
            comp_start,
            comp_end
            ):
        x_coord = pos[0]
        z_compensations = self.z_compensations
        sample_count = len(z_compensations)
-        spacing = ((comp_end - comp_start)
+        spacing = ((self.calibrate_end_x - self.calibrate_start_x)
                   / (sample_count - 1))
-        interpolate_t = (coord - comp_start) / spacing
+        interpolate_t = (x_coord - self.calibrate_start_x) / spacing
        interpolate_i = int(math.floor(interpolate_t))
        interpolate_i = bed_mesh.constrain(interpolate_i, 0, sample_count - 2)
        interpolate_t -= interpolate_i
        interpolated_z_compensation = bed_mesh.lerp(
            interpolate_t, z_compensations[interpolate_i],
            z_compensations[interpolate_i + 1])
-        return interpolated_z_compensation
+        pos[2] += interpolated_z_compensation
    def clear_compensations(self):
        self.z_compensations = []
        self.m = None
        self.b = None
    def clear_compensations(self, axis=None):
        if axis is None:
            self.z_compensations = []
            self.zy_compensations = []
        elif axis == 'X':
            self.z_compensations = []
        elif axis == 'Y':
            self.zy_compensations = []
 class Calibrater:
    def __init__(self, compensation, config):
@@ -107,14 +80,10 @@ class Calibrater:
                                            self._handle_connect)
        self.speed = compensation.speed
        self.horizontal_move_z = compensation.horizontal_move_z
-        self.x_start_point = (compensation.calibrate_start_x,
+        self.start_point = (compensation.calibrate_start_x,
                            compensation.calibrate_y)
-        self.x_end_point = (compensation.calibrate_end_x,
+        self.end_point = (compensation.calibrate_end_x,
                          compensation.calibrate_y)
        self.y_start_point = (compensation.calibrate_x,
                            compensation.calibrate_start_y)
        self.y_end_point = (compensation.calibrate_x,
                            compensation.calibrate_end_y)
        self.results = None
        self.current_point_index = None
        self.gcmd = None
@@ -125,8 +94,9 @@ class Calibrater:
    def _handle_connect(self):
        self.probe = self.printer.lookup_object('probe', None)
-        if self.probe is None:
+        if (self.probe is None):
-            raise self.printer.config_error(
+            config = self.printer.lookup_object('configfile')
            raise 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, _ = \
@@ -149,75 +119,20 @@ 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', 'X')
        # check for valid sample_count
-        if sample_count < 2:
+        if sample_count is None or sample_count < 2:
            raise self.gcmd.error(
                "SAMPLE_COUNT to probe must be at least 2")
-        # calculate the points to put the probe at, returned as a list of tuples
+        # clear the current config
-        nozzle_points = []
+        self.compensation.clear_compensations()
        if axis == 'X':
            self.compensation.clear_compensations('X')
            if not all([
                self.x_start_point[0],
                self.x_end_point[0],
                self.x_start_point[1]
                ]):
                raise self.gcmd.error(
                    """AXIS_TWIST_COMPENSATION for X axis requires
                    calibrate_start_x, calibrate_end_x and calibrate_y
                    to be defined
                    """
                    )
            start_point = self.x_start_point
            end_point = self.x_end_point
            x_axis_range = end_point[0] - start_point[0]
            interval_dist = x_axis_range / (sample_count - 1)
            for i in range(sample_count):
                x = start_point[0] + i * interval_dist
                y = start_point[1]
                nozzle_points.append((x, y))
        elif axis == 'Y':
            self.compensation.clear_compensations('Y')
            if not all([
                self.y_start_point[0],
                self.y_end_point[0],
                self.y_start_point[1]
                ]):
                raise self.gcmd.error(
                    """AXIS_TWIST_COMPENSATION for Y axis requires
                    calibrate_start_y, calibrate_end_y and calibrate_x
                    to be defined
                    """
                    )
            start_point = self.y_start_point
            end_point = self.y_end_point
            y_axis_range = end_point[1] - start_point[1]
            interval_dist = y_axis_range / (sample_count - 1)
            for i in range(sample_count):
                x = start_point[0]
                y = start_point[1] + i * interval_dist
                nozzle_points.append((x, y))
        else:
            raise self.gcmd.error(
                "AXIS_TWIST_COMPENSATION_CALIBRATE: "
                "Invalid axis.")
        # calculate some values
        x_range = self.end_point[0] - self.start_point[0]
        interval_dist = x_range / (sample_count - 1)
        nozzle_points = self._calculate_nozzle_points(sample_count,
                                                      interval_dist)
        probe_points = self._calculate_probe_points(
            nozzle_points, self.probe_x_offset, self.probe_y_offset)
@@ -227,9 +142,17 @@ class Calibrater:
        # begin calibration
        self.current_point_index = 0
        self.results = []
        self.current_axis = axis
        self._calibration(probe_points, nozzle_points, interval_dist)
    def _calculate_nozzle_points(self, sample_count, interval_dist):
        # calculate the points to put the probe at, returned as a list of tuples
        nozzle_points = []
        for i in range(sample_count):
            x = self.start_point[0] + i * interval_dist
            y = self.start_point[1]
            nozzle_points.append((x, y))
        return nozzle_points
    def _calculate_probe_points(self, nozzle_points,
        probe_x_offset, probe_y_offset):
        # calculate the points to put the nozzle at
@@ -315,31 +238,14 @@ class Calibrater:
        configfile = self.printer.lookup_object('configfile')
        values_as_str = ', '.join(["{:.6f}".format(x)
                                   for x in self.results])
-
+        configfile.set(self.configname, 'z_compensations', values_as_str)
-        if(self.current_axis == 'X'):
+        configfile.set(self.configname, 'compensation_start_x',
-
+                       self.start_point[0])
-            configfile.set(self.configname, 'z_compensations', values_as_str)
+        configfile.set(self.configname, 'compensation_end_x',
-            configfile.set(self.configname, 'compensation_start_x',
+                       self.end_point[0])
-                        self.x_start_point[0])
+        self.compensation.z_compensations = self.results
-            configfile.set(self.configname, 'compensation_end_x',
+        self.compensation.compensation_start_x = self.start_point[0]
-                        self.x_end_point[0])
+        self.compensation.compensation_end_x = self.end_point[0]
            self.compensation.z_compensations = self.results
            self.compensation.compensation_start_x = self.x_start_point[0]
            self.compensation.compensation_end_x = self.x_end_point[0]
        elif(self.current_axis == 'Y'):
            configfile.set(self.configname, 'zy_compensations', values_as_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.compensation.zy_compensations = self.results
            self.compensation.compensation_start_y = self.y_start_point[1]
            self.compensation.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 "
--- a/klippy/extras/bed_mesh.py
+++ b/klippy/extras/bed_mesh.py
@@ -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, truncate=True)
+        self.bmc.print_generated_points(logging.info)
    def set_mesh(self, mesh):
        if mesh is not None and self.fade_end != self.FADE_DISABLE:
            self.log_fade_complete = True
@@ -346,7 +346,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, truncate=False):
+    def print_generated_points(self, print_func):
        x_offset = y_offset = 0.
        probe = self.printer.lookup_object('probe', None)
        if probe is not None:
@@ -355,10 +355,6 @@ 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(
@@ -617,6 +613,8 @@ 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)
--- a/klippy/extras/bme280.py
+++ b/klippy/extras/bme280.py
@@ -83,7 +83,6 @@ BMP180_REGS = {
 STATUS_MEASURING = 1 << 3
 STATUS_IM_UPDATE = 1
 MODE = 1
 MODE_PERIODIC = 3
 RUN_GAS = 1 << 4
 NB_CONV_0 = 0
 EAS_NEW_DATA = 1 << 7
@@ -144,7 +143,6 @@ class BME280:
            pow(2, self.os_temp - 1), pow(2, self.os_hum - 1),
            pow(2, self.os_pres - 1)))
        logging.info("BMxx80: IIR: %dx" % (pow(2, self.iir_filter) - 1))
        self.iir_filter = self.iir_filter & 0x07
        self.temp = self.pressure = self.humidity = self.gas = self.t_fine = 0.
        self.min_temp = self.max_temp = self.range_switching_error = 0.
@@ -157,7 +155,6 @@ class BME280:
            return
        self.printer.register_event_handler("klippy:connect",
                                            self.handle_connect)
        self.last_gas_time = 0
    def handle_connect(self):
        self._init_bmxx80()
@@ -284,7 +281,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
@@ -296,15 +293,15 @@ class BME280:
                status = self.read_register('STATUS', 1)[0]
        if self.chip_type == 'BME680':
-            self.max_sample_time = \
+            self.max_sample_time = 0.5
                    (1.25 + (2.3 * self.os_temp) + ((2.3 * self.os_pres) + .575)
                     + ((2.3 * self.os_hum) + .575)) / 1000
            self.sample_timer = self.reactor.register_timer(self._sample_bme680)
            self.chip_registers = BME680_REGS
        elif self.chip_type == 'BMP180':
            self.max_sample_time = (1.25 + ((2.3 * self.os_pres) + .575)) / 1000
            self.sample_timer = self.reactor.register_timer(self._sample_bmp180)
            self.chip_registers = BMP180_REGS
        elif self.chip_type == 'BMP388':
            self.max_sample_time = 0.5
            self.chip_registers = BMP388_REGS
            self.write_register(
                "PWR_CTRL",
@@ -321,18 +318,15 @@ class BME280:
            self.write_register("INT_CTRL", [BMP388_REG_VAL_DRDY_EN])
            self.sample_timer = self.reactor.register_timer(self._sample_bmp388)
-        elif self.chip_type == 'BME280':
+        else:
            self.max_sample_time = \
                (1.25 + (2.3 * self.os_temp) + ((2.3 * self.os_pres) + .575)
                 + ((2.3 * self.os_hum) + .575)) / 1000
            self.sample_timer = self.reactor.register_timer(self._sample_bme280)
            self.chip_registers = BME280_REGS
-        else:
+
-            self.max_sample_time = \
+        if self.chip_type in ('BME680', 'BME280'):
-                (1.25 + (2.3 * self.os_temp)
+            self.write_register('CONFIG', (self.iir_filter & 0x07) << 2)
                + ((2.3 * self.os_pres) + .575)) / 1000
            self.sample_timer = self.reactor.register_timer(self._sample_bme280)
            self.chip_registers = BME280_REGS
        # Read out and calculate the trimming parameters
        if self.chip_type == 'BMP180':
@@ -353,64 +347,21 @@ class BME280:
        elif self.chip_type == 'BMP388':
            self.dig = read_calibration_data_bmp388(cal_1)
        if self.chip_type in ('BME280', 'BMP280'):
            max_standby_time = REPORT_TIME - self.max_sample_time
            # 0.5 ms
            t_sb = 0
            if self.chip_type == 'BME280':
                if max_standby_time > 1:
                    t_sb = 5
                elif max_standby_time > 0.5:
                    t_sb = 4
                elif max_standby_time > 0.25:
                    t_sb = 3
                elif max_standby_time > 0.125:
                    t_sb = 2
                elif max_standby_time > 0.0625:
                    t_sb = 1
                elif max_standby_time > 0.020:
                    t_sb = 7
                elif max_standby_time > 0.010:
                    t_sb = 6
            else:
                if max_standby_time > 4:
                    t_sb = 7
                elif max_standby_time > 2:
                    t_sb = 6
                elif max_standby_time > 1:
                    t_sb = 5
                elif max_standby_time > 0.5:
                    t_sb = 4
                elif max_standby_time > 0.25:
                    t_sb = 3
                elif max_standby_time > 0.125:
                    t_sb = 2
                elif max_standby_time > 0.0625:
                    t_sb = 1
            cfg = t_sb << 5 | self.iir_filter << 2
            self.write_register('CONFIG', cfg)
            if self.chip_type == '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)
        if self.chip_type == 'BME680':
            self.write_register('CONFIG', self.iir_filter << 2)
            # Should be set once and reused on every mode register write
            self.write_register('CTRL_HUM', self.os_hum & 0x07)
            gas_wait_0 = self._calc_gas_heater_duration(self.gas_heat_duration)
            self.write_register('GAS_WAIT_0', [gas_wait_0])
            res_heat_0 = self._calc_gas_heater_resistance(self.gas_heat_temp)
            self.write_register('RES_HEAT_0', [res_heat_0])
            # Set initial heater current to reach Gas heater target on start
            self.write_register('IDAC_HEAT_0', 96)
    def _sample_bme280(self, eventtime):
-        # In normal mode data shadowing is performed
+        # Enter forced mode
-        # So reading can be done while measurements are in process
+        if self.chip_type == 'BME280':
            self.write_register('CTRL_HUM', self.os_hum)
        meas = self.os_temp << 5 | self.os_pres << 2 | MODE
        self.write_register('CTRL_MEAS', meas)
        try:
            # wait until results are ready
            status = self.read_register('STATUS', 1)[0]
            while status & STATUS_MEASURING:
                self.reactor.pause(
                    self.reactor.monotonic() + self.max_sample_time)
                status = self.read_register('STATUS', 1)[0]
            if self.chip_type == 'BME280':
                data = self.read_register('PRESSURE_MSB', 8)
            elif self.chip_type == 'BMP280':
@@ -511,40 +462,36 @@ class BME280:
        return comp_press
    def _sample_bme680(self, eventtime):
-        def data_ready(stat, run_gas):
+        self.write_register('CTRL_HUM', self.os_hum & 0x07)
        meas = self.os_temp << 5 | self.os_pres << 2
        self.write_register('CTRL_MEAS', [meas])
        gas_wait_0 = self._calculate_gas_heater_duration(self.gas_heat_duration)
        self.write_register('GAS_WAIT_0', [gas_wait_0])
        res_heat_0 = self._calculate_gas_heater_resistance(self.gas_heat_temp)
        self.write_register('RES_HEAT_0', [res_heat_0])
        gas_config = RUN_GAS | NB_CONV_0
        self.write_register('CTRL_GAS_1', [gas_config])
        def data_ready(stat):
            new_data = (stat & EAS_NEW_DATA)
            gas_done = not (stat & GAS_DONE)
            meas_done = not (stat & MEASURE_DONE)
            if not run_gas:
                gas_done = True
            return new_data and gas_done and meas_done
        run_gas = False
        # Check VOC once a while
        if self.reactor.monotonic() - self.last_gas_time > 3:
            gas_config = RUN_GAS | NB_CONV_0
            self.write_register('CTRL_GAS_1', [gas_config])
            run_gas = True
        # Enter forced mode
-        meas = self.os_temp << 5 | self.os_pres << 2 | MODE
+        meas = meas | 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
        self.reactor.pause(self.reactor.monotonic() + max_sample_time)
        try:
            # wait until results are ready
            status = self.read_register('EAS_STATUS_0', 1)[0]
-            while not data_ready(status, run_gas):
+            while not data_ready(status):
                self.reactor.pause(
                    self.reactor.monotonic() + self.max_sample_time)
                status = self.read_register('EAS_STATUS_0', 1)[0]
            data = self.read_register('PRESSURE_MSB', 8)
-            gas_data = [0, 0]
+            gas_data = self.read_register('GAS_R_MSB', 2)
            if run_gas:
                gas_data = self.read_register('GAS_R_MSB', 2)
        except Exception:
            logging.exception("BME680: Error reading data")
            self.temp = self.pressure = self.humidity = self.gas = .0
@@ -568,10 +515,6 @@ class BME280:
            gas_raw = (gas_data[0] << 2) | ((gas_data[1] & 0xC0) >> 6)
            gas_range = (gas_data[1] & 0x0F)
            self.gas = self._compensate_gas(gas_raw, gas_range)
            # Disable gas measurement on success
            gas_config = NB_CONV_0
            self.write_register('CTRL_GAS_1', [gas_config])
            self.last_gas_time = self.reactor.monotonic()
        if self.temp < self.min_temp or self.temp > self.max_temp:
            self.printer.invoke_shutdown(
@@ -700,7 +643,7 @@ class BME280:
                gas_raw - 512. + var1)
        return gas
-    def _calc_gas_heater_resistance(self, target_temp):
+    def _calculate_gas_heater_resistance(self, target_temp):
        amb_temp = self.temp
        heater_data = self.read_register('RES_HEAT_VAL', 3)
        res_heat_val = get_signed_byte(heater_data[0])
@@ -715,7 +658,7 @@ class BME280:
                            * (1. / (1. + (res_heat_val * 0.002)))) - 25))
        return int(res_heat)
-    def _calc_gas_heater_duration(self, duration_ms):
+    def _calculate_gas_heater_duration(self, duration_ms):
        if duration_ms >= 4032:
            duration_reg = 0xff
        else:
@@ -776,15 +719,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)
            self.i2c.i2c_write(data)
        else:
            self.i2c.i2c_write_wait_ack(data)
    def get_status(self, eventtime):
        data = {
--- a/klippy/extras/bus.py
+++ b/klippy/extras/bus.py
@@ -160,7 +160,7 @@ class MCU_I2C:
                % (self.oid, speed, addr))
        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
+        self.i2c_write_cmd = self.i2c_read_cmd = self.i2c_modify_bits_cmd = None
    def get_oid(self):
        return self.oid
    def get_mcu(self):
@@ -180,6 +180,9 @@ class MCU_I2C:
            "i2c_read oid=%c reg=%*s read_len=%u",
            "i2c_read_response oid=%c response=%*s", oid=self.oid,
            cq=self.cmd_queue)
        self.i2c_modify_bits_cmd = self.mcu.lookup_command(
            "i2c_modify_bits oid=%c reg=%*s clear_set_bits=%*s",
            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
@@ -194,6 +197,19 @@ class MCU_I2C:
                                minclock=minclock, reqclock=reqclock)
    def i2c_read(self, write, read_len):
        return self.i2c_read_cmd.send([self.oid, write, read_len])
    def i2c_modify_bits(self, reg, clear_bits, set_bits,
                        minclock=0, reqclock=0):
        clearset = clear_bits + set_bits
        if self.i2c_modify_bits_cmd is None:
            # Send setup message via mcu initialization
            reg_msg = "".join(["%02x" % (x,) for x in reg])
            clearset_msg = "".join(["%02x" % (x,) for x in clearset])
            self.mcu.add_config_cmd(
                "i2c_modify_bits oid=%d reg=%s clear_set_bits=%s" % (
                    self.oid, reg_msg, clearset_msg), is_init=True)
            return
        self.i2c_modify_bits_cmd.send([self.oid, reg, clearset],
                                      minclock=minclock, reqclock=reqclock)
 def MCU_I2C_from_config(config, default_addr=None, default_speed=100000):
    # Load bus parameters
--- a/klippy/extras/buttons.py
+++ b/klippy/extras/buttons.py
@@ -244,33 +244,6 @@ 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
@@ -288,14 +261,6 @@ 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:
--- a/klippy/extras/canbus_stats.py
+++ b/klippy/extras/canbus_stats.py
@@ -1,80 +0,0 @@
 # 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)
--- a/klippy/extras/controller_fan.py
+++ b/klippy/extras/controller_fan.py
@@ -62,7 +62,9 @@ class ControllerFan:
            self.last_on += 1
        if speed != self.last_speed:
            self.last_speed = speed
-            self.fan.set_speed(speed)
+            curtime = self.printer.get_reactor().monotonic()
            print_time = self.fan.get_mcu().estimated_print_time(curtime)
            self.fan.set_speed(print_time + PIN_MIN_TIME, speed)
        return eventtime + 1.
 def load_config_prefix(config):
--- a/klippy/extras/display/aip31068_spi.py
+++ b/klippy/extras/display/aip31068_spi.py
@@ -1,209 +0,0 @@
 # Support for YHCB2004 (20x4 text) LCD displays based on AiP31068 controller
 #
 # Copyright (C) 2018  Kevin O'Connor <kevin@koconnor.net>
 # Copyright (C) 2018  Eric Callahan <arksine.code@gmail.com>
 # Copyright (C) 2021  Marc-Andre Denis <marcadenis@msn.com>
 # Copyright (C) 2024  Alexander Bazarov <oss@bazarov.dev>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 # This file is a modified version of hd44780_spi.py, introducing slightly
 # different protocol as implemented in Marlin FW (based on
 # https://github.com/red-scorp/LiquidCrystal_AIP31068 ).
 # In addition, a hack is used to send 8 commands, each 9 bits, at once,
 # allowing the transmission of a full 9 bytes.
 # This helps avoid modifying the SW_SPI driver to handle non-8-bit data.
 from .. import bus
 LINE_LENGTH_DEFAULT=20
 LINE_LENGTH_OPTIONS={16:16, 20:20}
 TextGlyphs = { 'right_arrow': b'\x7e' }
 # Each command is 9 bits long:
 #     1 bit for RS (Register Select) - 0 for command, 1 for data
 #     8 bits for the command/data
 # Command is a bitwise OR of CMND(=opcode) and flg_CMND(=parameters) multiplied
 # by 1 or 0 as En/Dis flag.
 #     cmd = CMND | flg_CMND.param0*0 | flg_CMND.param1*1
 # or just by OR with enabled flags:
 #     cmd = CMND | flg_CMND.param1
 class CMND:
    CLR = 1             # Clear display
    HOME = 2            # Return home
    ENTERY_MODE = 2**2  # Entry mode set
    DISPLAY = 2**3      # Display on/off control
    SHIFT = 2**4        # Cursor or display shift
    FUNCTION = 2**5     # Function set
    CGRAM = 2**6        # Character Generator RAM
    DDRAM = 2**7        # Display Data RAM
    WRITE_RAM = 2**8    # Write to RAM
 # Define flags for all commands:
 class flg_ENTERY_MODE:
    INC = 2**1      # Increment
    SHIFT = 2**0    # Shift display
 class flg_DISPLAY:
    ON = 2**2       # Display ON
    CURSOR = 2**1   # Cursor ON
    BLINK = 2**0    # Blink ON
 class flg_SHIFT:
    WHOLE_DISPLAY = 2**3    # Shift whole display
    RIGHT = 2**2            # Shift right
 class flg_FUNCTION:
    TWO_LINES = 2**3        # 2-line display mode
    FIVE_BY_ELEVEN = 2**2   # 5x11 dot character font
 class flg_CGRAM:
    MASK = 0b00111111   # CGRAM address mask
 class flg_DDRAM:
    MASK = 0b01111111   # DDRAM address mask
 class flg_WRITE_RAM:
    MASK = 0b11111111   # Write RAM mask
 DISPLAY_INIT_CMNDS= [
    # CMND.CLR - no need as framebuffer will rewrite all
    CMND.HOME, # move cursor to home (0x00)
    CMND.ENTERY_MODE | flg_ENTERY_MODE.INC, # increment cursor and no shift
    CMND.DISPLAY | flg_DISPLAY.ON, # keep cursor and blinking off
    CMND.SHIFT | flg_SHIFT.RIGHT, # shift right cursor only
    CMND.FUNCTION | flg_FUNCTION.TWO_LINES, # 2-line display mode, 5x8 dots
 ]
 class aip31068_spi:
    def __init__(self, config):
        self.printer = config.get_printer()
        # spi config
        self.spi = bus.MCU_SPI_from_config(
            config, 0x00, pin_option="latch_pin") # (config, mode, cs_name)
        self.mcu = self.spi.get_mcu()
        self.icons = {}
        self.line_length = config.getchoice('line_length', LINE_LENGTH_OPTIONS,
                                            LINE_LENGTH_DEFAULT)
        # each controller's line is 2 lines on the display and hence twice
        # line length
        self.text_framebuffers = [bytearray(b' '*2*self.line_length),
                                  bytearray(b' '*2*self.line_length)]
        self.glyph_framebuffer = bytearray(64)
        # all_framebuffers - list of tuples per buffer type.
        # Each tuple contains:
        #   1. the updated framebuffer
        #   2. a copy of the old framebuffer == data on the display
        #   3. the command to send to write to this buffer
        # Then flush() will compare new data with data on the display
        # and send only the differences to the display controller
        # and update the old framebuffer with the new data
        # (immutable tuple is allowed to store mutable bytearray)
        self.all_framebuffers = [
            # Text framebuffers
            (self.text_framebuffers[0], bytearray(b'~'*2*self.line_length),
                CMND.DDRAM | (flg_DDRAM.MASK & 0x00) ),
            (self.text_framebuffers[1], bytearray(b'~'*2*self.line_length),
                CMND.DDRAM | (flg_DDRAM.MASK & 0x40) ),
            # Glyph framebuffer
            (self.glyph_framebuffer, bytearray(b'~'*64),
                CMND.CGRAM | (flg_CGRAM.MASK & 0x00) ) ]
    @staticmethod
    def encode(data, width = 9):
        encoded_bytes = []
        accumulator = 0  # To accumulate bits
        acc_bits = 0  # Count of bits in the accumulator
        for num in data:
            # check that num will fit in width bits
            if num >= (1 << width):
                raise ValueError("Number {} does not fit in {} bits".
                                 format(num, width))
            # Shift the current number into the accumulator from the right
            accumulator = (accumulator << width) | num
            acc_bits += width  # Update the count of bits in the accumulator
            # While we have at least 8 bits, form a byte and append it
            while acc_bits >= 8:
                acc_bits -= 8  # Decrease bit count by 8
                # Extract the 8 most significant bits to form a byte
                byte = (accumulator >> acc_bits) & 0xFF
                # Remove msb 8 bits from the accumulator
                accumulator &= (1 << acc_bits) - 1
                encoded_bytes.append(byte)
        # Handle any remaining bits by padding them on the right to byte
        if acc_bits > 0:
            last_byte = accumulator << (8 - acc_bits)
            encoded_bytes.append(last_byte)
        return encoded_bytes
    def send(self, data, minclock=0):
        # different commands have different processing time
        # to avoid timing violation pad with some fast command, e.g. ENTRY_MODE
        # that has execution time of 39us (for comparison CLR is 1.53ms)
        pad = CMND.ENTERY_MODE | flg_ENTERY_MODE.INC
        for i in range(0, len(data), 8):
            # Take a slice of 8 numbers
            group = data[i:i+8]
            # Pad the group if it has fewer than 8 elements
            if len(group) < 8:
                group.extend([pad] * (8 - len(group)))
            self.spi.spi_send(self.encode(group), minclock)
    def flush(self):
        # Find all differences in the framebuffers and send them to the chip
        for new_data, old_data, fb_cmnd in self.all_framebuffers:
            if new_data == old_data:
                continue
            # Find the position of all changed bytes in this framebuffer
            diffs = [[i, 1] for i, (n, o) in enumerate(zip(new_data, old_data))
                     if n != o]
            # Batch together changes that are close to each other
            for i in range(len(diffs)-2, -1, -1):
                pos, count = diffs[i]
                nextpos, nextcount = diffs[i+1]
                if pos + 4 >= nextpos and nextcount < 16:
                    diffs[i][1] = nextcount + (nextpos - pos)
                    del diffs[i+1]
            # Transmit changes
            for pos, count in diffs:
                chip_pos = pos
                self.send([fb_cmnd + chip_pos])
                self.send([CMND.WRITE_RAM | byte for byte in
                           new_data[pos:pos+count]])
            old_data[:] = new_data
    def init(self):
        curtime = self.printer.get_reactor().monotonic()
        print_time = self.mcu.estimated_print_time(curtime)
        for i, cmds in enumerate(DISPLAY_INIT_CMNDS):
            minclock = self.mcu.print_time_to_clock(print_time + i * .100)
            self.send([cmds], minclock=minclock)
        self.flush()
    def write_text(self, x, y, data):
        if x + len(data) > self.line_length:
            data = data[:self.line_length - min(x, self.line_length)]
        pos = x + ((y & 0x02) >> 1) * self.line_length
        self.text_framebuffers[y & 1][pos:pos+len(data)] = data
    def set_glyphs(self, glyphs):
        for glyph_name, glyph_data in glyphs.items():
            data = glyph_data.get('icon5x8')
            if data is not None:
                self.icons[glyph_name] = data
    def write_glyph(self, x, y, glyph_name):
        data = self.icons.get(glyph_name)
        if data is not None:
            slot, bits = data
            self.write_text(x, y, [slot])
            self.glyph_framebuffer[slot * 8:(slot + 1) * 8] = bits
            return 1
        char = TextGlyphs.get(glyph_name)
        if char is not None:
            # Draw character
            self.write_text(x, y, char)
            return 1
        return 0
    def write_graphics(self, x, y, data):
        pass # this display supports only hardcoded or 8 user defined glyphs
    def clear(self):
        spaces = b' ' * 2*self.line_length
        self.text_framebuffers[0][:] = spaces
        self.text_framebuffers[1][:] = spaces
    def get_dimensions(self):
        return (self.line_length, 4)
--- a/klippy/extras/display/display.py
+++ b/klippy/extras/display/display.py
@@ -6,7 +6,7 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging, os, ast
-from . import aip31068_spi, hd44780, hd44780_spi, st7920, uc1701, menu
+from . import hd44780, hd44780_spi, st7920, uc1701, menu
 # Normal time between each screen redraw
 REDRAW_TIME = 0.500
@@ -17,8 +17,7 @@ LCD_chips = {
    'st7920': st7920.ST7920, 'emulated_st7920': st7920.EmulatedST7920,
    'hd44780': hd44780.HD44780, 'uc1701': uc1701.UC1701,
    'ssd1306': uc1701.SSD1306, 'sh1106': uc1701.SH1106,
-    'hd44780_spi': hd44780_spi.hd44780_spi,
+    'hd44780_spi': hd44780_spi.hd44780_spi
    'aip31068_spi':aip31068_spi.aip31068_spi
 }
 # Storage of [display_template my_template] config sections
--- a/klippy/extras/dotstar.py
+++ b/klippy/extras/dotstar.py
@@ -1,9 +1,9 @@
 # Support for "dotstar" leds
 #
-# Copyright (C) 2019-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2019-2022  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-from . import bus, led
+from . import bus
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
@@ -22,8 +22,9 @@ class PrinterDotstar:
        self.spi = bus.MCU_SPI(mcu, None, None, 0, 500000, sw_spi_pins)
        # Initialize color data
        self.chain_count = config.getint('chain_count', 1, minval=1)
-        self.led_helper = led.LEDHelper(config, self.update_leds,
+        pled = printer.load_object(config, "led")
-                                        self.chain_count)
+        self.led_helper = pled.setup_helper(config, self.update_leds,
                                            self.chain_count)
        self.prev_data = None
        # Register commands
        printer.register_event_handler("klippy:connect", self.handle_connect)
--- a/klippy/extras/fan.py
+++ b/klippy/extras/fan.py
@@ -1,14 +1,17 @@
 # Printer cooling fan
 #
-# Copyright (C) 2016-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2020  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-from . import pulse_counter, output_pin
+from . import pulse_counter
 FAN_MIN_TIME = 0.100
 class Fan:
    def __init__(self, config, default_shutdown_speed=0.):
        self.printer = config.get_printer()
-        self.last_fan_value = self.last_req_value = 0.
+        self.last_fan_value = 0.
        self.last_fan_time = 0.
        # Read config
        self.max_power = config.getfloat('max_power', 1., above=0., maxval=1.)
        self.kick_start_time = config.getfloat('kick_start_time', 0.1,
@@ -33,10 +36,6 @@ class Fan:
            self.enable_pin = ppins.setup_pin('digital_out', enable_pin)
            self.enable_pin.setup_max_duration(0.)
        # Create gcode request queue
        self.gcrq = output_pin.GCodeRequestQueue(config, self.mcu_fan.get_mcu(),
                                                 self._apply_speed)
        # Setup tachometer
        self.tachometer = FanTachometer(config)
@@ -46,37 +45,37 @@ class Fan:
    def get_mcu(self):
        return self.mcu_fan.get_mcu()
-    def _apply_speed(self, print_time, value):
+    def set_speed(self, print_time, value):
        if value < self.off_below:
            value = 0.
        value = max(0., min(self.max_power, value * self.max_power))
        if value == self.last_fan_value:
-            return "discard", 0.
+            return
        print_time = max(self.last_fan_time + FAN_MIN_TIME, print_time)
        if self.enable_pin:
            if value > 0 and self.last_fan_value == 0:
                self.enable_pin.set_digital(print_time, 1)
            elif value == 0 and self.last_fan_value > 0:
                self.enable_pin.set_digital(print_time, 0)
-        if (value and self.kick_start_time
+        if (value and value < self.max_power and self.kick_start_time
            and (not self.last_fan_value or value - self.last_fan_value > .5)):
            # Run fan at full speed for specified kick_start_time
            self.last_req_value = value
            self.last_fan_value = self.max_power
            self.mcu_fan.set_pwm(print_time, self.max_power)
-            return "delay", self.kick_start_time
+            print_time += self.kick_start_time
        self.last_fan_value = self.last_req_value = value
        self.mcu_fan.set_pwm(print_time, value)
-    def set_speed(self, value, print_time=None):
+        self.last_fan_time = print_time
-        self.gcrq.send_async_request(value, print_time)
+        self.last_fan_value = value
    def set_speed_from_command(self, value):
-        self.gcrq.queue_gcode_request(value)
+        toolhead = self.printer.lookup_object('toolhead')
        toolhead.register_lookahead_callback((lambda pt:
                                              self.set_speed(pt, value)))
    def _handle_request_restart(self, print_time):
-        self.set_speed(0., print_time)
+        self.set_speed(print_time, 0.)
    def get_status(self, eventtime):
        tachometer_status = self.tachometer.get_status(eventtime)
        return {
-            'speed': self.last_req_value,
+            'speed': self.last_fan_value,
            'rpm': tachometer_status['rpm'],
        }
--- a/klippy/extras/fan_generic.py
+++ b/klippy/extras/fan_generic.py
@@ -1,10 +1,9 @@
 # Support fans that are controlled by gcode
 #
-# Copyright (C) 2016-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2020  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-import logging
+from . import fan
 from . import fan, output_pin
 class PrinterFanGeneric:
    cmd_SET_FAN_SPEED_help = "Sets the speed of a fan"
@@ -13,9 +12,6 @@ class PrinterFanGeneric:
        self.fan = fan.Fan(config, default_shutdown_speed=0.)
        self.fan_name = config.get_name().split()[-1]
        # Template handling
        self.template_eval = output_pin.lookup_template_eval(config)
        gcode = self.printer.lookup_object("gcode")
        gcode.register_mux_command("SET_FAN_SPEED", "FAN",
                                   self.fan_name,
@@ -24,22 +20,8 @@ class PrinterFanGeneric:
    def get_status(self, eventtime):
        return self.fan.get_status(eventtime)
    def _template_update(self, text):
        try:
            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.)
+        speed = gcmd.get_float('SPEED', 0.)
        template = gcmd.get('TEMPLATE', None)
        if (speed is None) == (template is None):
            raise gcmd.error("SET_FAN_SPEED must specify SPEED or TEMPLATE")
        # Check for template setting
        if template is not None:
            self.template_eval.set_template(gcmd, self._template_update)
            return
        self.fan.set_speed_from_command(speed)
 def load_config_prefix(config):
--- a/klippy/extras/filament_motion_sensor.py
+++ b/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(eventtime,
+        self.runout_helper.note_filament_present(
                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(eventtime, True)
+            self.runout_helper.note_filament_present(True)
 def load_config_prefix(config):
    return EncoderSensor(config)
--- a/klippy/extras/filament_switch_sensor.py
+++ b/klippy/extras/filament_switch_sensor.py
@@ -5,7 +5,6 @@
 # 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]
@@ -25,7 +24,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., minval=.0)
+        self.event_delay = config.getfloat('event_delay', 3., above=0.)
        # Internal state
        self.min_event_systime = self.reactor.NEVER
        self.filament_present = False
@@ -60,20 +59,19 @@ class RunoutHelper:
        except Exception:
            logging.exception("Script running error")
        self.min_event_systime = self.reactor.monotonic() + self.event_delay
-    def note_filament_present(self, eventtime, is_filament_present):
+    def note_filament_present(self, 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(now)["state"] == "Printing"
+        is_printing = idle_timeout.get_status(eventtime)["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:
@@ -81,14 +79,14 @@ class RunoutHelper:
                self.min_event_systime = self.reactor.NEVER
                logging.info(
                    "Filament Sensor %s: insert event detected, Time %.2f" %
-                    (self.name, now))
+                    (self.name, eventtime))
                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, now))
+                (self.name, eventtime))
            self.reactor.register_callback(self._runout_event_handler)
    def get_status(self, eventtime):
        return {
@@ -110,12 +108,11 @@ class SwitchSensor:
        printer = config.get_printer()
        buttons = printer.load_object(config, 'buttons')
        switch_pin = config.get('switch_pin')
-        buttons.register_debounce_button(switch_pin, self._button_handler
+        buttons.register_buttons([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(eventtime, state)
+        self.runout_helper.note_filament_present(state)
 def load_config_prefix(config):
    return SwitchSensor(config)
--- a/klippy/extras/force_move.py
+++ b/klippy/extras/force_move.py
@@ -131,19 +131,8 @@ class ForceMove:
        x = gcmd.get_float('X', curpos[0])
        y = gcmd.get_float('Y', curpos[1])
        z = gcmd.get_float('Z', curpos[2])
-        set_homed = gcmd.get('SET_HOMED', 'xyz').lower()
+        logging.info("SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f", x, y, z)
-        set_homed_axes = "".join([a for a in "xyz" if a in set_homed])
+        toolhead.set_position([x, y, z, curpos[3]], homing_axes=(0, 1, 2))
        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, curpos[3]], homing_axes=set_homed_axes)
        toolhead.get_kinematics().clear_homing_state(clear_homed_axes)
 def load_config(config):
    return ForceMove(config)
--- a/klippy/extras/garbage_collection.py
+++ b/klippy/extras/garbage_collection.py
@@ -1,31 +0,0 @@
 # 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)
--- a/klippy/extras/gcode_arcs.py
+++ b/klippy/extras/gcode_arcs.py
@@ -39,6 +39,8 @@ class ArcSupport:
        self.gcode.register_command("G18", self.cmd_G18)
        self.gcode.register_command("G19", self.cmd_G19)
        self.Coord = self.gcode.Coord
        # backwards compatibility, prior implementation only supported XY
        self.plane = ARC_PLANE_X_Y
@@ -62,36 +64,52 @@ class ArcSupport:
        if not gcodestatus['absolute_coordinates']:
            raise gcmd.error("G2/G3 does not support relative move mode")
        currentPos = gcodestatus['gcode_position']
        absolut_extrude = gcodestatus['absolute_extrude']
        # Parse parameters
-        asTarget = [gcmd.get_float("X", currentPos[0]),
+        asTarget = self.Coord(x=gcmd.get_float("X", currentPos[0]),
-                    gcmd.get_float("Y", currentPos[1]),
+                              y=gcmd.get_float("Y", currentPos[1]),
-                    gcmd.get_float("Z", currentPos[2])]
+                              z=gcmd.get_float("Z", currentPos[2]),
                              e=None)
        if gcmd.get_float("R", None) is not None:
            raise gcmd.error("G2/G3 does not support R moves")
        # determine the plane coordinates and the helical axis
-        I = gcmd.get_float('I', 0.)
+        asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('IJ') ]
        J = gcmd.get_float('J', 0.)
        asPlanar = (I, J)
        axes = (X_AXIS, Y_AXIS, Z_AXIS)
        if self.plane == ARC_PLANE_X_Z:
-            K = gcmd.get_float('K', 0.)
+            asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('IK') ]
            asPlanar = (I, K)
            axes = (X_AXIS, Z_AXIS, Y_AXIS)
        elif self.plane == ARC_PLANE_Y_Z:
-            K = gcmd.get_float('K', 0.)
+            asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('JK') ]
            asPlanar = (J, K)
            axes = (Y_AXIS, Z_AXIS, X_AXIS)
        if not (asPlanar[0] or asPlanar[1]):
            raise gcmd.error("G2/G3 requires IJ, IK or JK parameters")
-        # Build linear coordinates to move
+        asE = gcmd.get_float("E", None)
-        self.planArc(currentPos, asTarget, asPlanar, clockwise,
+        asF = gcmd.get_float("F", None)
-                     gcmd, absolut_extrude, *axes)
+
        # Build list of linear coordinates to move
        coords = self.planArc(currentPos, asTarget, asPlanar,
                              clockwise, *axes)
        e_per_move = e_base = 0.
        if asE is not None:
            if gcodestatus['absolute_extrude']:
                e_base = currentPos[3]
            e_per_move = (asE - e_base) / len(coords)
        # Convert coords into G1 commands
        for coord in coords:
            g1_params = {'X': coord[0], 'Y': coord[1], 'Z': coord[2]}
            if e_per_move:
                g1_params['E'] = e_base + e_per_move
                if gcodestatus['absolute_extrude']:
                    e_base += e_per_move
            if asF is not None:
                g1_params['F'] = asF
            g1_gcmd = self.gcode.create_gcode_command("G1", "G1", g1_params)
            self.gcode_move.cmd_G1(g1_gcmd)
    # function planArc() originates from marlin plan_arc()
    # https://github.com/MarlinFirmware/Marlin
@@ -102,7 +120,6 @@ class ArcSupport:
    #
    # alpha and beta axes are the current plane, helical axis is linear travel
    def planArc(self, currentPos, targetPos, offset, clockwise,
                gcmd, absolut_extrude,
                alpha_axis, beta_axis, helical_axis):
        # todo: sometimes produces full circles
@@ -142,42 +159,23 @@ class ArcSupport:
        # Generate coordinates
        theta_per_segment = angular_travel / segments
        linear_per_segment = linear_travel / segments
-
+        coords = []
-        asE = gcmd.get_float("E", None)
+        for i in range(1, int(segments)):
        asF = gcmd.get_float("F", None)
        e_per_move = e_base = 0.
        if asE is not None:
            if absolut_extrude:
                e_base = currentPos[3]
            e_per_move = (asE - e_base) / segments
        for i in range(1, int(segments) + 1):
            dist_Helical = i * linear_per_segment
-            c_theta = i * theta_per_segment
+            cos_Ti = math.cos(i * theta_per_segment)
-            cos_Ti = math.cos(c_theta)
+            sin_Ti = math.sin(i * theta_per_segment)
            sin_Ti = math.sin(c_theta)
            r_P = -offset[0] * cos_Ti + offset[1] * sin_Ti
            r_Q = -offset[0] * sin_Ti - offset[1] * cos_Ti
-            c = [None, None, None]
+            # Coord doesn't support index assignment, create list
            c = [None, None, None, None]
            c[alpha_axis] = center_P + r_P
            c[beta_axis] = center_Q + r_Q
            c[helical_axis] = currentPos[helical_axis] + dist_Helical
            coords.append(self.Coord(*c))
-
+        coords.append(targetPos)
-            if i == segments:
+        return coords
                c = targetPos
            # Convert coords into G1 commands
            g1_params = {'X': c[0], 'Y': c[1], 'Z': c[2]}
            if e_per_move:
                g1_params['E'] = e_base + e_per_move
                if absolut_extrude:
                    e_base += e_per_move
            if asF is not None:
                g1_params['F'] = asF
            g1_gcmd = self.gcode.create_gcode_command("G1", "G1", g1_params)
            self.gcode_move.cmd_G1(g1_gcmd)
 def load_config(config):
    return ArcSupport(config)
--- a/klippy/extras/gcode_button.py
+++ b/klippy/extras/gcode_button.py
@@ -5,7 +5,6 @@
 # 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()
@@ -14,13 +13,12 @@ class GCodeButton:
        self.last_state = 0
        buttons = self.printer.load_object(config, "buttons")
        if config.get('analog_range', None) is None:
-            buttons.register_debounce_button(self.pin, self.button_callback
+            buttons.register_buttons([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_debounce_adc_button(self.pin, amin, amax, pullup,
+            buttons.register_adc_button(self.pin, amin, amax, pullup,
-                                        self.button_callback, config)
+                                        self.button_callback)
        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,
--- a/klippy/extras/gcode_macro.py
+++ b/klippy/extras/gcode_macro.py
@@ -49,12 +49,6 @@ 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])
--- a/klippy/extras/hall_filament_width_sensor.py
+++ b/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(eventtime,
+        self.runout_helper.note_filament_present(
            self.runout_dia_min <= self.diameter <= self.runout_dia_max)
        # Does filament exists
        if self.diameter > 0.5:
--- a/klippy/extras/heater_fan.py
+++ b/klippy/extras/heater_fan.py
@@ -33,7 +33,9 @@ class PrinterHeaterFan:
                speed = self.fan_speed
        if speed != self.last_speed:
            self.last_speed = speed
-            self.fan.set_speed(speed)
+            curtime = self.printer.get_reactor().monotonic()
            print_time = self.fan.get_mcu().estimated_print_time(curtime)
            self.fan.set_speed(print_time + PIN_MIN_TIME, speed)
        return eventtime + 1.
 def load_config_prefix(config):
--- a/klippy/extras/heaters.py
+++ b/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-2024  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import os, logging, threading
@@ -14,7 +14,6 @@ KELVIN_TO_CELSIUS = -273.15
 MAX_HEAT_TIME = 5.0
 AMBIENT_TEMP = 25.
 PID_PARAM_BASE = 255.
 MAX_MAINTHREAD_TIME = 5.0
 class Heater:
    def __init__(self, config, sensor):
@@ -38,7 +37,8 @@ class Heater:
        self.max_power = config.getfloat('max_power', 1., above=0., maxval=1.)
        self.smooth_time = config.getfloat('smooth_time', 1., above=0.)
        self.inv_smooth_time = 1. / self.smooth_time
-        self.verify_mainthread_time = -999.
+        self.is_shutdown = False
        self.set_temp_count = 0
        self.lock = threading.Lock()
        self.last_temp = self.smoothed_temp = self.target_temp = 0.
        self.last_temp_time = 0.
@@ -64,10 +64,13 @@ class Heater:
        gcode.register_mux_command("SET_HEATER_TEMPERATURE", "HEATER",
                                   short_name, self.cmd_SET_HEATER_TEMPERATURE,
                                   desc=self.cmd_SET_HEATER_TEMPERATURE_help)
        wh = self.printer.lookup_object('webhooks')
        wh.register_mux_endpoint("heaters/set_target_temperature", "heater",
                                 self.name, self._api_set_target_temperature)
        self.printer.register_event_handler("klippy:shutdown",
                                            self._handle_shutdown)
    def set_pwm(self, read_time, value):
-        if self.target_temp <= 0. or read_time > self.verify_mainthread_time:
+        if self.target_temp <= 0. or self.is_shutdown:
            value = 0.
        if ((read_time < self.next_pwm_time or not self.last_pwm_value)
            and abs(value - self.last_pwm_value) < 0.05):
@@ -92,7 +95,7 @@ class Heater:
            self.can_extrude = (self.smoothed_temp >= self.min_extrude_temp)
        #logging.debug("temp: %.3f %f = %f", read_time, temp)
    def _handle_shutdown(self):
-        self.verify_mainthread_time = -999.
+        self.is_shutdown = True
    # External commands
    def get_name(self):
        return self.name
@@ -107,6 +110,7 @@ class Heater:
            raise self.printer.command_error(
                "Requested temperature (%.1f) out of range (%.1f:%.1f)"
                % (degrees, self.min_temp, self.max_temp))
        self.set_temp_count += 1
        with self.lock:
            self.target_temp = degrees
    def get_temp(self, eventtime):
@@ -130,9 +134,6 @@ class Heater:
            target_temp = max(self.min_temp, min(self.max_temp, target_temp))
        self.target_temp = target_temp
    def stats(self, eventtime):
        est_print_time = self.mcu_pwm.get_mcu().estimated_print_time(eventtime)
        if not self.printer.is_shutdown():
            self.verify_mainthread_time = est_print_time + MAX_MAINTHREAD_TIME
        with self.lock:
            target_temp = self.target_temp
            last_temp = self.last_temp
@@ -147,11 +148,17 @@ class Heater:
            last_pwm_value = self.last_pwm_value
        return {'temperature': round(smoothed_temp, 2), 'target': target_temp,
                'power': last_pwm_value}
    def get_set_temp_count(self):
        return self.set_temp_count
    cmd_SET_HEATER_TEMPERATURE_help = "Sets a heater temperature"
    def cmd_SET_HEATER_TEMPERATURE(self, gcmd):
        temp = gcmd.get_float('TARGET', 0.)
        pheaters = self.printer.lookup_object('heaters')
        pheaters.set_temperature(self, temp)
    def _api_set_target_temperature(self, web_request):
        temp = web_request.get_float('target')
        pheaters = self.printer.lookup_object('heaters')
        pheaters.set_temperature(self, temp)
 ######################################################################
@@ -243,6 +250,7 @@ class PrinterHeaters:
        self.available_heaters = []
        self.available_sensors = []
        self.available_monitors = []
        self.in_temperature_wait = None
        self.has_started = self.have_load_sensors = False
        self.printer.register_event_handler("klippy:ready", self._handle_ready)
        self.printer.register_event_handler("gcode:request_restart",
@@ -263,8 +271,7 @@ class PrinterHeaters:
        try:
            dconfig = pconfig.read_config(filename)
        except Exception:
-            logging.exception("Unable to load temperature_sensors.cfg")
+            raise config.config_error("Cannot load config '%s'" % (filename,))
            raise config.error("Cannot load config '%s'" % (filename,))
        for c in dconfig.get_prefix_sections(''):
            self.printer.load_object(dconfig, c.get_name())
    def add_sensor_factory(self, sensor_type, sensor_factory):
@@ -310,7 +317,8 @@ class PrinterHeaters:
    def get_status(self, eventtime):
        return {'available_heaters': self.available_heaters,
                'available_sensors': self.available_sensors,
-                'available_monitors': self.available_monitors}
+                'available_monitors': self.available_monitors,
                'temperature_wait': self.in_temperature_wait}
    def turn_off_all_heaters(self, print_time=0.):
        for heater in self.heaters.values():
            heater.set_temp(0.)
@@ -341,14 +349,23 @@ class PrinterHeaters:
        # Helper to wait on heater.check_busy() and report M105 temperatures
        if self.printer.get_start_args().get('debugoutput') is not None:
            return
        full_name = heater.get_name()
        set_temp_count = heater.get_set_temp_count()
        toolhead = self.printer.lookup_object("toolhead")
        gcode = self.printer.lookup_object("gcode")
        reactor = self.printer.get_reactor()
        eventtime = reactor.monotonic()
        while not self.printer.is_shutdown() and heater.check_busy(eventtime):
            self.in_temperature_wait = full_name
            print_time = toolhead.get_last_move_time()
            gcode.respond_raw(self._get_temp(eventtime))
            eventtime = reactor.pause(eventtime + 1.)
            if heater.get_set_temp_count() != set_temp_count:
                self.in_temperature_wait = None
                raise self.printer.command_error(
                    "Heater '%s' target temperature changed during wait"
                    % (full_name,))
        self.in_temperature_wait = None
    def set_temperature(self, heater, temp, wait=False):
        toolhead = self.printer.lookup_object('toolhead')
        toolhead.register_lookahead_callback((lambda pt: None))
@@ -367,8 +384,12 @@ class PrinterHeaters:
                "Error on 'TEMPERATURE_WAIT': missing MINIMUM or MAXIMUM.")
        if self.printer.get_start_args().get('debugoutput') is not None:
            return
        full_name = sensor_name
        set_temp_count = None
        if sensor_name in self.heaters:
            sensor = self.heaters[sensor_name]
            full_name = sensor.get_name()
            set_temp_count = sensor.get_set_temp_count()
        else:
            sensor = self.printer.lookup_object(sensor_name)
        toolhead = self.printer.lookup_object("toolhead")
@@ -377,10 +398,18 @@ class PrinterHeaters:
        while not self.printer.is_shutdown():
            temp, target = sensor.get_temp(eventtime)
            if temp >= min_temp and temp <= max_temp:
-                return
+                break
            self.in_temperature_wait = full_name
            print_time = toolhead.get_last_move_time()
            gcmd.respond_raw(self._get_temp(eventtime))
            eventtime = reactor.pause(eventtime + 1.)
            if (set_temp_count is not None
                and sensor.get_set_temp_count() != set_temp_count):
                self.in_temperature_wait = None
                raise self.printer.command_error(
                    "Heater '%s' target temperature changed during wait"
                    % (full_name,))
        self.in_temperature_wait = None
 def load_config(config):
    return PrinterHeaters(config)
--- a/klippy/extras/homing.py
+++ b/klippy/extras/homing.py
@@ -1,6 +1,6 @@
 # Helper code for implementing homing operations
 #
-# Copyright (C) 2016-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging, math
@@ -29,17 +29,10 @@ class StepperPosition:
        self.endstop_name = endstop_name
        self.stepper_name = stepper.get_name()
        self.start_pos = stepper.get_mcu_position()
        self.start_cmd_pos = stepper.mcu_to_commanded_position(self.start_pos)
        self.halt_pos = self.trig_pos = None
    def note_home_end(self, trigger_time):
        self.halt_pos = self.stepper.get_mcu_position()
        self.trig_pos = self.stepper.get_past_mcu_position(trigger_time)
    def verify_no_probe_skew(self, haltpos):
        new_start_pos = self.stepper.get_mcu_position(self.start_cmd_pos)
        if new_start_pos != self.start_pos:
            logging.warning(
                "Stepper '%s' position skew after probe: pos %d now %d",
                self.stepper.get_name(), self.start_pos, new_start_pos)
 # Implementation of homing/probing moves
 class HomingMove:
@@ -128,9 +121,6 @@ class HomingMove:
            haltpos = trigpos = self.calc_toolhead_pos(kin_spos, trig_steps)
            if trig_steps != halt_steps:
                haltpos = self.calc_toolhead_pos(kin_spos, halt_steps)
            self.toolhead.set_position(haltpos)
            for sp in self.stepper_positions:
                sp.verify_no_probe_skew(haltpos)
        else:
            haltpos = trigpos = movepos
            over_steps = {sp.stepper_name: sp.halt_pos - sp.trig_pos
@@ -140,7 +130,7 @@ class HomingMove:
                halt_kin_spos = {s.get_name(): s.get_commanded_position()
                                 for s in kin.get_steppers()}
                haltpos = self.calc_toolhead_pos(halt_kin_spos, over_steps)
-            self.toolhead.set_position(haltpos)
+        self.toolhead.set_position(haltpos)
        # Signal homing/probing move complete
        try:
            self.printer.send_event("homing:homing_move_end", self)
@@ -187,8 +177,7 @@ class Homing:
        # Notify of upcoming homing operation
        self.printer.send_event("homing:home_rails_begin", self, rails)
        # Alter kinematics class to think printer is at forcepos
-        force_axes = [axis for axis in range(3) if forcepos[axis] is not None]
+        homing_axes = [axis for axis in range(3) if forcepos[axis] is not None]
        homing_axes = "".join(["xyz"[i] for i in force_axes])
        startpos = self._fill_coord(forcepos)
        homepos = self._fill_coord(movepos)
        self.toolhead.set_position(startpos, homing_axes=homing_axes)
@@ -232,7 +221,7 @@ class Homing:
                                       + self.adjust_pos.get(s.get_name(), 0.))
                        for s in kin.get_steppers()}
            newpos = kin.calc_position(kin_spos)
-            for axis in force_axes:
+            for axis in homing_axes:
                homepos[axis] = newpos[axis]
            self.toolhead.set_position(homepos)
--- a/klippy/extras/homing_override.py
+++ b/klippy/extras/homing_override.py
@@ -46,11 +46,11 @@ class HomingOverride:
        # Calculate forced position (if configured)
        toolhead = self.printer.lookup_object('toolhead')
        pos = toolhead.get_position()
-        homing_axes = ""
+        homing_axes = []
        for axis, loc in enumerate(self.start_pos):
            if loc is not None:
                pos[axis] = loc
-                homing_axes += "xyz"[axis]
+                homing_axes.append(axis)
        toolhead.set_position(pos, homing_axes=homing_axes)
        # Perform homing
        context = self.template.create_template_context()
--- a/klippy/extras/hx71x.py
+++ b/klippy/extras/hx71x.py
@@ -14,7 +14,7 @@ SAMPLE_ERROR_DESYNC = -0x80000000
 SAMPLE_ERROR_LONG_READ = 0x40000000
 # Implementation of HX711 and HX717
-class HX71xBase:
+class HX71xBase():
    def __init__(self, config, sensor_type,
                 sample_rate_options, default_sample_rate,
                 gain_options, default_gain):
@@ -51,6 +51,10 @@ 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)
        self.batch_bulk.add_mux_endpoint(dump_path, "sensor", self.name,
                                         {'header': ('time', 'counts')})
        # Command Configuration
        self.query_hx71x_cmd = None
        mcu.add_config_cmd(
@@ -141,21 +145,23 @@ class HX71xBase:
                'overflows': self.ffreader.get_last_overflows()}
-def HX711(config):
+class HX711(HX71xBase):
-    return HX71xBase(config, "hx711",
+    def __init__(self, config):
-                     # HX711 sps options
+        super(HX711, self).__init__(config, "hx711",
-                     {80: 80, 10: 10}, 80,
+                                    # HX711 sps options
-                     # HX711 gain/channel options
+                                    {80: 80, 10: 10}, 80,
-                     {'A-128': 1, 'B-32': 2, 'A-64': 3}, 'A-128')
+                                    # HX711 gain/channel options
                                    {'A-128': 1, 'B-32': 2, 'A-64': 3}, 'A-128')
-def HX717(config):
+class HX717(HX71xBase):
-    return HX71xBase(config, "hx717",
+    def __init__(self, config):
-                     # HX717 sps options
+        super(HX717, self).__init__(config, "hx717",
-                     {320: 320, 80: 80, 20: 20, 10: 10}, 320,
+                                    # HX717 sps options
-                     # HX717 gain/channel options
+                                    {320: 320, 80: 80, 20: 20, 10: 10}, 320,
-                     {'A-128': 1, 'B-64': 2, 'A-64': 3,
+                                    # HX717 gain/channel options
-                      'B-8': 4}, 'A-128')
+                                    {'A-128': 1, 'B-64': 2, 'A-64': 3,
                                     'B-8': 4}, 'A-128')
 HX71X_SENSOR_TYPES = {
--- a/klippy/extras/icm20948.py
+++ b/klippy/extras/icm20948.py
@@ -1,173 +0,0 @@
 # 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)
--- a/klippy/extras/ldc1612.py
+++ b/klippy/extras/ldc1612.py
@@ -12,7 +12,7 @@ BATCH_UPDATES = 0.100
 LDC1612_ADDR = 0x2a
-DEFAULT_LDC1612_FREQ = 12000000
+LDC1612_FREQ = 12000000
 SETTLETIME = 0.005
 DRIVECUR = 15
 DEGLITCH = 0x05 # 10 Mhz
@@ -87,8 +87,6 @@ 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'))
@@ -143,7 +141,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(self.frequency) + 0.5)
+        tfreq = int(trigger_freq * (1<<28) / float(LDC1612_FREQ) + 0.5)
        self.ldc1612_setup_home_cmd.send(
            [self.oid, clock, tfreq, trsync_oid, hit_reason, err_reason])
    def clear_home(self):
@@ -155,7 +153,7 @@ class LDC1612:
        return self.mcu.clock_to_print_time(tclock)
    # Measurement decoding
    def _convert_samples(self, samples):
-        freq_conv = float(self.frequency) / (1<<28)
+        freq_conv = float(LDC1612_FREQ) / (1<<28)
        count = 0
        for ptime, val in samples:
            mv = val & 0x0fffffff
@@ -176,10 +174,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 = self.frequency / (16. * (self.data_rate - 4))
+        rcount0 = LDC1612_FREQ / (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*self.frequency/16. + .5))
+        self.set_reg(REG_SETTLECOUNT0, int(SETTLETIME*LDC1612_FREQ/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)
--- a/klippy/extras/led.py
+++ b/klippy/extras/led.py
@@ -1,10 +1,13 @@
 # Support for PWM driven LEDs
 #
-# Copyright (C) 2019-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2019-2022  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-import logging
+import logging, ast
-from . import output_pin
+from .display import display
 # Time between each led template update
 RENDER_TIME = 0.500
 # Helper code for common LED initialization and control
 class LEDHelper:
@@ -19,22 +22,14 @@ class LEDHelper:
        blue = config.getfloat('initial_BLUE', 0., minval=0., maxval=1.)
        white = config.getfloat('initial_WHITE', 0., minval=0., maxval=1.)
        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+1:
                            s._template_update(index, text))
                           for i in range(led_count)]
        # Register commands
        name = config.get_name().split()[-1]
        gcode = self.printer.lookup_object('gcode')
        gcode.register_mux_command("SET_LED", "LED", name, self.cmd_SET_LED,
                                   desc=self.cmd_SET_LED_help)
-        gcode.register_mux_command("SET_LED_TEMPLATE", "LED", name,
+    def get_led_count(self):
-                                   self.cmd_SET_LED_TEMPLATE,
+        return self.led_count
-                                   desc=self.cmd_SET_LED_TEMPLATE_help)
+    def set_color(self, index, color):
    def get_status(self, eventtime=None):
        return {'color_data': self.led_state}
    def _set_color(self, index, color):
        if index is None:
            new_led_state = [color] * self.led_count
            if self.led_state == new_led_state:
@@ -46,17 +41,7 @@ class LEDHelper:
            new_led_state[index - 1] = color
        self.led_state = new_led_state
        self.need_transmit = True
-    def _template_update(self, index, text):
+    def check_transmit(self, print_time):
        try:
            parts = [max(0., min(1., float(f)))
                     for f in text.split(',', 4)]
        except ValueError as e:
            logging.exception("led template render error")
            parts = []
        if len(parts) < 4:
            parts += [0.] * (4 - len(parts))
        self._set_color(index, tuple(parts))
    def _check_transmit(self, print_time=None):
        if not self.need_transmit:
            return
        self.need_transmit = False
@@ -77,9 +62,9 @@ class LEDHelper:
        color = (red, green, blue, white)
        # Update and transmit data
        def lookahead_bgfunc(print_time):
-            self._set_color(index, color)
+            self.set_color(index, color)
            if transmit:
-                self._check_transmit(print_time)
+                self.check_transmit(print_time)
        if sync:
            #Sync LED Update with print time and send
            toolhead = self.printer.lookup_object('toolhead')
@@ -87,15 +72,112 @@ class LEDHelper:
        else:
            #Send update now (so as not to wake toolhead and reset idle_timeout)
            lookahead_bgfunc(None)
    def get_status(self, eventtime=None):
        return {'color_data': self.led_state}
 # Main LED tracking code
 class PrinterLED:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.led_helpers = {}
        self.active_templates = {}
        self.render_timer = None
        # Load templates
        dtemplates = display.lookup_display_templates(config)
        self.templates = dtemplates.get_display_templates()
        gcode_macro = self.printer.lookup_object("gcode_macro")
        self.create_template_context = gcode_macro.create_template_context
        # Register handlers
        gcode = self.printer.lookup_object('gcode')
        gcode.register_command("SET_LED_TEMPLATE", self.cmd_SET_LED_TEMPLATE,
                               desc=self.cmd_SET_LED_TEMPLATE_help)
    def setup_helper(self, config, update_func, led_count=1):
        led_helper = LEDHelper(config, update_func, led_count)
        name = config.get_name().split()[-1]
        self.led_helpers[name] = led_helper
        return led_helper
    def _activate_timer(self):
        if self.render_timer is not None or not self.active_templates:
            return
        reactor = self.printer.get_reactor()
        self.render_timer = reactor.register_timer(self._render, reactor.NOW)
    def _activate_template(self, led_helper, index, template, lparams):
        key = (led_helper, index)
        if template is not None:
            uid = (template,) + tuple(sorted(lparams.items()))
            self.active_templates[key] = (uid, template, lparams)
            return
        if key in self.active_templates:
            del self.active_templates[key]
    def _render(self, eventtime):
        if not self.active_templates:
            # Nothing to do - unregister timer
            reactor = self.printer.get_reactor()
            reactor.register_timer(self.render_timer)
            self.render_timer = None
            return reactor.NEVER
        # Setup gcode_macro template context
        context = self.create_template_context(eventtime)
        def render(name, **kwargs):
            return self.templates[name].render(context, **kwargs)
        context['render'] = render
        # Render all templates
        need_transmit = {}
        rendered = {}
        template_info = self.active_templates.items()
        for (led_helper, index), (uid, template, lparams) in template_info:
            color = rendered.get(uid)
            if color is None:
                try:
                    text = template.render(context, **lparams)
                    parts = [max(0., min(1., float(f)))
                             for f in text.split(',', 4)]
                except Exception as e:
                    logging.exception("led template render error")
                    parts = []
                if len(parts) < 4:
                    parts += [0.] * (4 - len(parts))
                rendered[uid] = color = tuple(parts)
            need_transmit[led_helper] = 1
            led_helper.set_color(index, color)
        context.clear() # Remove circular references for better gc
        # Transmit pending changes
        for led_helper in need_transmit.keys():
            led_helper.check_transmit(None)
        return eventtime + RENDER_TIME
    cmd_SET_LED_TEMPLATE_help = "Assign a display_template to an LED"
    def cmd_SET_LED_TEMPLATE(self, gcmd):
-        index = gcmd.get_int("INDEX", None, minval=1, maxval=self.led_count)
+        led_name = gcmd.get("LED")
-        set_template = self.template_eval.set_template
+        led_helper = self.led_helpers.get(led_name)
        if led_helper is None:
            raise gcmd.error("Unknown LED '%s'" % (led_name,))
        led_count = led_helper.get_led_count()
        index = gcmd.get_int("INDEX", None, minval=1, maxval=led_count)
        template = None
        lparams = {}
        tpl_name = gcmd.get("TEMPLATE")
        if tpl_name:
            template = self.templates.get(tpl_name)
            if template is None:
                raise gcmd.error("Unknown display_template '%s'" % (tpl_name,))
            tparams = template.get_params()
            for p, v in gcmd.get_command_parameters().items():
                if not p.startswith("PARAM_"):
                    continue
                p = p.lower()
                if p not in tparams:
                    raise gcmd.error("Invalid display_template parameter: %s"
                                     % (p,))
                try:
                    lparams[p] = ast.literal_eval(v)
                except ValueError as e:
                    raise gcmd.error("Unable to parse '%s' as a literal" % (v,))
        if index is not None:
-            set_template(gcmd, self.tcallbacks[index-1], self._check_transmit)
+            self._activate_template(led_helper, index, template, lparams)
        else:
-            for i in range(self.led_count):
+            for i in range(led_count):
-                set_template(gcmd, self.tcallbacks[i], self._check_transmit)
+                self._activate_template(led_helper, i+1, template, lparams)
        self._activate_timer()
 PIN_MIN_TIME = 0.100
 MAX_SCHEDULE_TIME = 5.0
@@ -123,7 +205,8 @@ class PrinterPWMLED:
                               % (config.get_name(),))
        self.last_print_time = 0.
        # Initialize color data
-        self.led_helper = LEDHelper(config, self.update_leds, 1)
+        pled = printer.load_object(config, "led")
        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
        self.prev_color = color = self.led_helper.get_status()['color_data'][0]
        for idx, mcu_pin in self.pins:
            mcu_pin.setup_start_value(color[idx], 0.)
@@ -142,5 +225,8 @@ class PrinterPWMLED:
    def get_status(self, eventtime=None):
        return self.led_helper.get_status(eventtime)
 def load_config(config):
    return PrinterLED(config)
 def load_config_prefix(config):
    return PrinterPWMLED(config)
--- a/klippy/extras/lis2dw.py
+++ b/klippy/extras/lis2dw.py
@@ -12,8 +12,6 @@ REG_LIS2DW_WHO_AM_I_ADDR = 0x0F
 REG_LIS2DW_CTRL_REG1_ADDR = 0x20
 REG_LIS2DW_CTRL_REG2_ADDR = 0x21
 REG_LIS2DW_CTRL_REG3_ADDR = 0x22
 REG_LIS2DW_CTRL_REG4_ADDR = 0x23
 REG_LIS2DW_CTRL_REG5_ADDR = 0x24
 REG_LIS2DW_CTRL_REG6_ADDR = 0x25
 REG_LIS2DW_STATUS_REG_ADDR = 0x27
 REG_LIS2DW_OUT_XL_ADDR = 0x28
@@ -25,58 +23,29 @@ REG_LIS2DW_OUT_ZH_ADDR = 0x2D
 REG_LIS2DW_FIFO_CTRL   = 0x2E
 REG_LIS2DW_FIFO_SAMPLES = 0x2F
 REG_MOD_READ = 0x80
 # REG_MOD_MULTI = 0x40
 LIS2DW_DEV_ID = 0x44
 LIS3DH_DEV_ID = 0x33
 LIS_I2C_ADDR = 0x19
 # Right shift for left justified registers.
 FREEFALL_ACCEL = 9.80665
-LIS2DW_SCALE = FREEFALL_ACCEL * 1.952 / 4
+SCALE = FREEFALL_ACCEL * 1.952 / 4
 LIS3DH_SCALE = FREEFALL_ACCEL * 3.906 / 16
 BATCH_UPDATES = 0.100
 # "Enums" that should be compatible with all python versions
 LIS2DW_TYPE = 'LIS2DW'
 LIS3DH_TYPE = 'LIS3DH'
 SPI_SERIAL_TYPE = 'spi'
 I2C_SERIAL_TYPE = 'i2c'
 # Printer class that controls LIS2DW chip
 class LIS2DW:
-    def __init__(self, config, lis_type):
+    def __init__(self, config):
        self.printer = config.get_printer()
        adxl345.AccelCommandHelper(config, self)
-        self.lis_type = lis_type
+        self.axes_map = adxl345.read_axes_map(config, SCALE, SCALE, SCALE)
-        if self.lis_type == LIS2DW_TYPE:
+        self.data_rate = 1600
            self.axes_map = adxl345.read_axes_map(config, LIS2DW_SCALE,
                            LIS2DW_SCALE, LIS2DW_SCALE)
            self.data_rate = 1600
        else:
            self.axes_map = adxl345.read_axes_map(config, LIS3DH_SCALE,
                            LIS3DH_SCALE, LIS3DH_SCALE)
            self.data_rate = 1344
        # Check for spi or i2c
        if config.get('cs_pin', None) is not None:
            self.bus_type = SPI_SERIAL_TYPE
        else:
            self.bus_type = I2C_SERIAL_TYPE
        # Setup mcu sensor_lis2dw bulk query code
-        if self.bus_type == SPI_SERIAL_TYPE:
+        self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=5000000)
-            self.bus = bus.MCU_SPI_from_config(config,
+        self.mcu = mcu = self.spi.get_mcu()
                            3, default_speed=5000000)
        else:
            self.bus = bus.MCU_I2C_from_config(config,
                            default_addr=LIS_I2C_ADDR, default_speed=400000)
        self.mcu = mcu = self.bus.get_mcu()
        self.oid = oid = mcu.create_oid()
        self.query_lis2dw_cmd = None
-        mcu.add_config_cmd("config_lis2dw oid=%d bus_oid=%d bus_oid_type=%s "
+        mcu.add_config_cmd("config_lis2dw oid=%d spi_oid=%d"
-                           "lis_chip_type=%s" % (oid, self.bus.get_oid(),
+                           % (oid, self.spi.get_oid()))
                            self.bus_type, self.lis_type))
        mcu.add_config_cmd("query_lis2dw oid=%d rest_ticks=0"
                           % (oid,), on_restart=True)
        mcu.register_config_callback(self._build_config)
@@ -92,24 +61,19 @@ class LIS2DW:
        hdr = ('time', 'x_acceleration', 'y_acceleration', 'z_acceleration')
        self.batch_bulk.add_mux_endpoint("lis2dw/dump_lis2dw", "sensor",
                                         self.name, {'header': hdr})
    def _build_config(self):
-        cmdqueue = self.bus.get_command_queue()
+        cmdqueue = self.spi.get_command_queue()
        self.query_lis2dw_cmd = self.mcu.lookup_command(
            "query_lis2dw oid=%c rest_ticks=%u", cq=cmdqueue)
        self.ffreader.setup_query_command("query_lis2dw_status oid=%c",
                                          oid=self.oid, cq=cmdqueue)
    def read_reg(self, reg):
-        if self.bus_type == SPI_SERIAL_TYPE:
+        params = self.spi.spi_transfer([reg | REG_MOD_READ, 0x00])
-            params = self.bus.spi_transfer([reg | REG_MOD_READ, 0x00])
+        response = bytearray(params['response'])
-            response = bytearray(params['response'])
+        return response[1]
            return response[1]
        params = self.bus.i2c_read([reg], 1)
        return bytearray(params['response'])[0]
    def set_reg(self, reg, val, minclock=0):
-        if self.bus_type == SPI_SERIAL_TYPE:
+        self.spi.spi_send([reg, val & 0xFF], minclock=minclock)
            self.bus.spi_send([reg, val & 0xFF], minclock=minclock)
        else:
            self.bus.i2c_write([reg, val & 0xFF], minclock=minclock)
        stored_val = self.read_reg(reg)
        if stored_val != val:
            raise self.printer.command_error(
@@ -138,48 +102,26 @@ class LIS2DW:
        # noise or wrong signal as a correctly initialized device
        dev_id = self.read_reg(REG_LIS2DW_WHO_AM_I_ADDR)
        logging.info("lis2dw_dev_id: %x", dev_id)
-        if self.lis_type == LIS2DW_TYPE:
+        if dev_id != LIS2DW_DEV_ID:
-            if dev_id != LIS2DW_DEV_ID:
+            raise self.printer.command_error(
-                raise self.printer.command_error(
+                "Invalid lis2dw id (got %x vs %x).\n"
-                    "Invalid lis2dw id (got %x vs %x).\n"
+                "This is generally indicative of connection problems\n"
-                    "This is generally indicative of connection problems\n"
+                "(e.g. faulty wiring) or a faulty lis2dw chip."
-                    "(e.g. faulty wiring) or a faulty lis2dw chip."
+                % (dev_id, LIS2DW_DEV_ID))
-                    % (dev_id, LIS2DW_DEV_ID))
+        # Setup chip in requested query rate
-            # Setup chip in requested query rate
+        # ODR/2, +-16g, low-pass filter, Low-noise abled
-            # ODR/2, +-16g, low-pass filter, Low-noise abled
+        self.set_reg(REG_LIS2DW_CTRL_REG6_ADDR, 0x34)
-            self.set_reg(REG_LIS2DW_CTRL_REG6_ADDR, 0x34)
+        # Continuous mode: If the FIFO is full
-            # Continuous mode: If the FIFO is full
+        # the new sample overwrites the older sample.
-            # the new sample overwrites the older sample.
+        self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
-            self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
+        # High-Performance / Low-Power mode 1600/200 Hz
-            # High-Performance / Low-Power mode 1600/200 Hz
+        # High-Performance Mode (14-bit resolution)
-            # High-Performance Mode (14-bit resolution)
+        self.set_reg(REG_LIS2DW_CTRL_REG1_ADDR, 0x94)
-            self.set_reg(REG_LIS2DW_CTRL_REG1_ADDR, 0x94)
+
        else:
            if dev_id != LIS3DH_DEV_ID:
                raise self.printer.command_error(
                    "Invalid lis3dh id (got %x vs %x).\n"
                    "This is generally indicative of connection problems\n"
                    "(e.g. faulty wiring) or a faulty lis3dh chip."
                    % (dev_id, LIS3DH_DEV_ID))
            # High Resolution / Low Power mode 1344/5376 Hz
            # High Resolution mode (12-bit resolution)
            # Enable X Y Z axes
            self.set_reg(REG_LIS2DW_CTRL_REG1_ADDR, 0x97)
            # Disable all filtering
            self.set_reg(REG_LIS2DW_CTRL_REG2_ADDR, 0)
            # Set +-8g, High Resolution mode
            self.set_reg(REG_LIS2DW_CTRL_REG4_ADDR, 0x28)
            # Enable FIFO
            self.set_reg(REG_LIS2DW_CTRL_REG5_ADDR, 0x40)
            # Stream mode
            self.set_reg(REG_LIS2DW_FIFO_CTRL, 0x80)
        # Start bulk reading
        rest_ticks = self.mcu.seconds_to_clock(4. / self.data_rate)
        self.query_lis2dw_cmd.send([self.oid, rest_ticks])
-        if self.lis_type == LIS2DW_TYPE:
+        self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
            self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
        else:
            self.set_reg(REG_LIS2DW_FIFO_CTRL, 0x80)
        logging.info("LIS2DW starting '%s' measurements", self.name)
        # Initialize clock tracking
        self.ffreader.note_start()
@@ -200,7 +142,7 @@ class LIS2DW:
                'overflows': self.ffreader.get_last_overflows()}
 def load_config(config):
-    return LIS2DW(config, LIS2DW_TYPE)
+    return LIS2DW(config)
 def load_config_prefix(config):
-    return LIS2DW(config, LIS2DW_TYPE)
+    return LIS2DW(config)
--- a/klippy/extras/lis3dh.py
+++ b/klippy/extras/lis3dh.py
@@ -1,12 +0,0 @@
 # Support for reading acceleration data from an LIS3DH chip
 #
 # Copyright (C) 2024 Luke Vuksta <wulfstawulfsta@gmail.com>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 from . import lis2dw
 def load_config(config):
    return lis2dw.LIS2DW(config, lis2dw.LIS3DH_TYPE)
 def load_config_prefix(config):
    return lis2dw.LIS2DW(config, lis2dw.LIS3DH_TYPE)
--- a/klippy/extras/load_cell.py
+++ b/klippy/extras/load_cell.py
@@ -3,516 +3,21 @@
 # Copyright (C) 2024 Gareth Farrington <gareth@waves.ky>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 from . import hx71x
 from . import ads1220
 from .bulk_sensor import BatchWebhooksClient
 import collections, itertools
 # We want either Python 3's zip() or Python 2's izip() but NOT 2's zip():
 zip_impl = zip
 try:
    from itertools import izip as zip_impl # python 2.x izip
 except ImportError: # will be Python 3.x
    pass
-# alternative to numpy's column selection:
+# Printer class that controls a load cell
 def select_column(data, column_idx):
    return list(zip_impl(*data))[column_idx]
 def avg(data):
    return sum(data) / len(data)
 # Helper for event driven webhooks and subscription based API clients
 class ApiClientHelper(object):
    def __init__(self, printer):
        self.printer = printer
        self.client_cbs = []
        self.webhooks_start_resp = {}
    # send data to clients
    def send(self, msg):
        for client_cb in list(self.client_cbs):
            res = client_cb(msg)
            if not res:
                # This client no longer needs updates - unregister it
                self.client_cbs.remove(client_cb)
    # Add a client that gets data callbacks
    def add_client(self, client_cb):
        self.client_cbs.append(client_cb)
    # Add Webhooks client and send header
    def _add_webhooks_client(self, web_request):
        whbatch = BatchWebhooksClient(web_request)
        self.add_client(whbatch.handle_batch)
        web_request.send(self.webhooks_start_resp)
    # Set up a webhooks endpoint with a static header
    def add_mux_endpoint(self, path, key, value, webhooks_start_resp):
        self.webhooks_start_resp = webhooks_start_resp
        wh = self.printer.lookup_object('webhooks')
        wh.register_mux_endpoint(path, key, value, self._add_webhooks_client)
 # Class for handling commands related ot load cells
 class LoadCellCommandHelper:
    def __init__(self, config, load_cell):
        self.printer = config.get_printer()
        self.load_cell = load_cell
        name_parts = config.get_name().split()
        self.name = name_parts[-1]
        self.register_commands(self.name)
        if len(name_parts) == 1:
            self.register_commands(None)
    def register_commands(self, name):
        # Register commands
        gcode = self.printer.lookup_object('gcode')
        gcode.register_mux_command("LOAD_CELL_TARE", "LOAD_CELL", name,
                                   self.cmd_LOAD_CELL_TARE,
                                   desc=self.cmd_LOAD_CELL_TARE_help)
        gcode.register_mux_command("LOAD_CELL_CALIBRATE", "LOAD_CELL", name,
                                   self.cmd_LOAD_CELL_CALIBRATE,
                                   desc=self.cmd_CALIBRATE_LOAD_CELL_help)
        gcode.register_mux_command("LOAD_CELL_READ", "LOAD_CELL", name,
                                   self.cmd_LOAD_CELL_READ,
                                   desc=self.cmd_LOAD_CELL_READ_help)
        gcode.register_mux_command("LOAD_CELL_DIAGNOSTIC", "LOAD_CELL", name,
                                   self.cmd_LOAD_CELL_DIAGNOSTIC,
                                   desc=self.cmd_LOAD_CELL_DIAGNOSTIC_help)
    cmd_LOAD_CELL_TARE_help = "Set the Zero point of the load cell"
    def cmd_LOAD_CELL_TARE(self, gcmd):
        tare_counts = self.load_cell.avg_counts()
        self.load_cell.tare(tare_counts)
        tare_percent = self.load_cell.counts_to_percent(tare_counts)
        gcmd.respond_info("Load cell tare value: %.2f%% (%i)"
                          % (tare_percent, tare_counts))
    cmd_CALIBRATE_LOAD_CELL_help = "Start interactive calibration tool"
    def cmd_LOAD_CELL_CALIBRATE(self, gcmd):
        LoadCellGuidedCalibrationHelper(self.printer, self.load_cell)
    cmd_LOAD_CELL_READ_help = "Take a reading from the load cell"
    def cmd_LOAD_CELL_READ(self, gcmd):
        counts = self.load_cell.avg_counts()
        percent = self.load_cell.counts_to_percent(counts)
        force = self.load_cell.counts_to_grams(counts)
        if percent >= 100 or percent <= -100:
            gcmd.respond_info("Err (%.2f%%)" % (percent,))
        if force is None:
            gcmd.respond_info("---.-g (%.2f%%)" % (percent,))
        else:
            gcmd.respond_info("%.1fg (%.2f%%)" % (force, percent))
    cmd_LOAD_CELL_DIAGNOSTIC_help = "Check the health of the load cell"
    def cmd_LOAD_CELL_DIAGNOSTIC(self, gcmd):
        gcmd.respond_info("Collecting load cell data for 10 seconds...")
        collector = self.load_cell.get_collector()
        reactor = self.printer.get_reactor()
        collector.start_collecting()
        reactor.pause(reactor.monotonic() + 10.)
        samples, errors = collector.stop_collecting()
        if errors:
            gcmd.respond_info("Sensor reported errors: %i errors,"
                              " %i overflows" % (errors[0], errors[1]))
        else:
            gcmd.respond_info("Sensor reported no errors")
        if not samples:
            raise gcmd.error("No samples returned from sensor!")
        counts = select_column(samples, 2)
        range_min, range_max = self.load_cell.saturation_range()
        good_count = 0
        saturation_count = 0
        for sample in counts:
            if sample >= range_max or sample <= range_min:
                saturation_count += 1
            else:
                good_count += 1
        gcmd.respond_info("Samples Collected: %i" % (len(samples)))
        if len(samples) > 2:
            sensor_sps = self.load_cell.sensor.get_samples_per_second()
            sps = float(len(samples)) / (samples[-1][0] - samples[0][0])
            gcmd.respond_info("Measured samples per second: %.1f, "
                              "configured: %.1f" % (sps, sensor_sps))
        gcmd.respond_info("Good samples: %i, Saturated samples: %i, Unique"
                          " values: %i" % (good_count, saturation_count,
                          len(set(counts))))
        max_pct = self.load_cell.counts_to_percent(max(counts))
        min_pct = self.load_cell.counts_to_percent(min(counts))
        gcmd.respond_info("Sample range: [%.2f%% to %.2f%%]"
                          % (min_pct, max_pct))
        gcmd.respond_info("Sample range / sensor capacity: %.5f%%"
                          % ((max_pct - min_pct) / 2.))
 # Class to guide the user through calibrating a load cell
 class LoadCellGuidedCalibrationHelper:
    def __init__(self, printer, load_cell):
        self.printer = printer
        self.gcode = printer.lookup_object('gcode')
        self.load_cell = load_cell
        self._tare_counts = self._counts_per_gram = None
        self.tare_percent = 0.
        self.register_commands()
        self.gcode.respond_info(
            "Starting load cell calibration. \n"
            "1.) Remove all load and run TARE. \n"
            "2.) Apply a known load, run CALIBRATE GRAMS=nnn. \n"
            "Complete calibration with the ACCEPT command.\n"
            "Use the ABORT command to quit.")
    def verify_no_active_calibration(self,):
        try:
            self.gcode.register_command('TARE', 'dummy')
        except self.printer.config_error as e:
            raise self.gcode.error(
                "Already Calibrating a Load Cell. Use ABORT to quit.")
        self.gcode.register_command('TARE', None)
    def register_commands(self):
        self.verify_no_active_calibration()
        register_command = self.gcode.register_command
        register_command("ABORT", self.cmd_ABORT, desc=self.cmd_ABORT_help)
        register_command("ACCEPT", self.cmd_ACCEPT, desc=self.cmd_ACCEPT_help)
        register_command("TARE", self.cmd_TARE, desc=self.cmd_TARE_help)
        register_command("CALIBRATE", self.cmd_CALIBRATE,
                         desc=self.cmd_CALIBRATE_help)
    # convert the delta of counts to a counts/gram metric
    def counts_per_gram(self, grams, cal_counts):
        return float(abs(int(self._tare_counts - cal_counts))) / grams
    # calculate max force that the load cell can register
    # given tare bias, at saturation in kilograms
    def capacity_kg(self, counts_per_gram):
        range_min, range_max = self.load_cell.saturation_range()
        return (int((range_max - abs(self._tare_counts)) / counts_per_gram)
                / 1000.)
    def finalize(self, save_results=False):
        for name in ['ABORT', 'ACCEPT', 'TARE', 'CALIBRATE']:
            self.gcode.register_command(name, None)
        if not save_results:
            self.gcode.respond_info("Load cell calibration aborted")
            return
        if self._counts_per_gram is None or self._tare_counts is None:
            self.gcode.respond_info("Calibration process is incomplete, "
                                    "aborting")
        self.load_cell.set_calibration(self._counts_per_gram, self._tare_counts)
        self.gcode.respond_info("Load cell calibration settings:\n\n"
            "counts_per_gram: %.6f\n"
            "reference_tare_counts: %i\n\n"
            "The SAVE_CONFIG command will update the printer config file"
            " with the above and restart the printer."
            % (self._counts_per_gram, self._tare_counts))
        self.load_cell.tare(self._tare_counts)
    cmd_ABORT_help = "Abort load cell calibration tool"
    def cmd_ABORT(self, gcmd):
        self.finalize(False)
    cmd_ACCEPT_help = "Accept calibration results and apply to load cell"
    def cmd_ACCEPT(self, gcmd):
        self.finalize(True)
    cmd_TARE_help = "Tare the load cell"
    def cmd_TARE(self, gcmd):
        self._tare_counts = self.load_cell.avg_counts()
        self._counts_per_gram = None  # require re-calibration on tare
        self.tare_percent = self.load_cell.counts_to_percent(self._tare_counts)
        gcmd.respond_info("Load cell tare value: %.2f%% (%i)"
                          % (self.tare_percent, self._tare_counts))
        if self.tare_percent > 2.:
            gcmd.respond_info(
                "WARNING: tare value is more than 2% away from 0!\n"
                "The load cell's range will be impacted.\n"
                "Check for external force on the load cell.")
        gcmd.respond_info("Now apply a known force to the load cell and enter \
                         the force value with:\n CALIBRATE GRAMS=nnn")
    cmd_CALIBRATE_help = "Enter the load cell value in grams"
    def cmd_CALIBRATE(self, gcmd):
        if self._tare_counts is None:
            gcmd.respond_info("You must use TARE first.")
            return
        grams = gcmd.get_float("GRAMS", minval=50., maxval=25000.)
        cal_counts = self.load_cell.avg_counts()
        cal_percent = self.load_cell.counts_to_percent(cal_counts)
        c_per_g = self.counts_per_gram(grams, cal_counts)
        cap_kg = self.capacity_kg(c_per_g)
        gcmd.respond_info("Calibration value: %.2f%% (%i), Counts/gram: %.5f, \
            Total capacity: +/- %0.2fKg"
                % (cal_percent, cal_counts, c_per_g, cap_kg))
        range_min, range_max = self.load_cell.saturation_range()
        if cal_counts >= range_max or cal_counts <= range_min:
            raise self.printer.command_error(
                "ERROR: Sensor is saturated with too much load!\n"
                "Use less force to calibrate the load cell.")
        if cal_counts == self._tare_counts:
            raise self.printer.command_error(
                "ERROR: Tare and Calibration readings are the same!\n"
                "Check wiring and validate sensor with READ_LOAD_CELL command.")
        if (abs(cal_percent - self.tare_percent)) < 1.:
            raise self.printer.command_error(
                "ERROR: Tare and Calibration readings are less than 1% "
                "different!\n"
                "Use more force when calibrating or a higher sensor gain.")
        # only set _counts_per_gram after all errors are raised
        self._counts_per_gram = c_per_g
        if cap_kg < 1.:
            gcmd.respond_info("WARNING: Load cell capacity is less than 1kg!\n"
                "Check wiring and consider using a lower sensor gain.")
        if cap_kg > 25.:
            gcmd.respond_info("WARNING: Load cell capacity is more than 25Kg!\n"
                "Check wiring and consider using a higher sensor gain.")
        gcmd.respond_info("Accept calibration with the ACCEPT command.")
 # Utility to collect some samples from the LoadCell for later analysis
 # Optionally blocks execution while collecting with reactor.pause()
 # can collect a minimum n samples or collect until a specific print_time
 # samples returned in [[time],[force],[counts]] arrays for easy processing
 RETRY_DELAY = 0.05  # 20Hz
 class LoadCellSampleCollector:
    def __init__(self, printer, load_cell):
        self._printer = printer
        self._load_cell = load_cell
        self._reactor = printer.get_reactor()
        self._mcu = load_cell.sensor.get_mcu()
        self.min_time = 0.
        self.max_time = float("inf")
        self.min_count = float("inf")  # In Python 3.5 math.inf is better
        self.is_started = False
        self._samples = []
        self._errors = 0
        self._overflows = 0
    def _on_samples(self, msg):
        if not self.is_started:
            return False  # already stopped, ignore
        self._errors += msg['errors']
        self._overflows += msg['overflows']
        samples = msg['data']
        for sample in samples:
            time = sample[0]
            if self.min_time <= time <= self.max_time:
                self._samples.append(sample)
            if time > self.max_time:
                self.is_started = False
        if len(self._samples) >= self.min_count:
            self.is_started = False
        return self.is_started
    def _finish_collecting(self):
        self.is_started = False
        self.min_time = 0.
        self.max_time = float("inf")
        self.min_count = float("inf")  # In Python 3.5 math.inf is better
        samples = self._samples
        self._samples = []
        errors = self._errors
        self._errors = 0
        overflows = self._overflows
        self._overflows = 0
        return samples, (errors, overflows) if errors or overflows else 0
    def _collect_until(self, timeout):
        self.start_collecting()
        while self.is_started:
            now = self._reactor.monotonic()
            if self._mcu.estimated_print_time(now) > timeout:
                self._finish_collecting()
                raise self._printer.command_error(
                    "LoadCellSampleCollector timed out! Errors: %i,"
                    " Overflows: %i" % (self._errors, self._overflows))
            self._reactor.pause(now + RETRY_DELAY)
        return self._finish_collecting()
    # start collecting with no automatic end to collection
    def start_collecting(self, min_time=None):
        if self.is_started:
            return
        self.min_time = min_time if min_time is not None else self.min_time
        self.is_started = True
        self._load_cell.add_client(self._on_samples)
    # stop collecting immediately and return results
    def stop_collecting(self):
        return self._finish_collecting()
    # block execution until at least min_count samples are collected
    # will return all samples collected, not just up to min_count
    def collect_min(self, min_count=1):
        self.min_count = min_count
        if len(self._samples) >= min_count:
            return self._finish_collecting()
        print_time = self._mcu.estimated_print_time(self._reactor.monotonic())
        start_time = max(print_time, self.min_time)
        sps = self._load_cell.sensor.get_samples_per_second()
        return self._collect_until(start_time + 1. + (min_count / sps))
    # returns when a sample is collected with a timestamp after print_time
    def collect_until(self, print_time=None):
        self.max_time = print_time
        if len(self._samples) and self._samples[-1][0] >= print_time:
            return self._finish_collecting()
        return self._collect_until(self.max_time + 1.)
 # Printer class that controls the load cell
 MIN_COUNTS_PER_GRAM = 1.
 class LoadCell:
    def __init__(self, config, sensor):
        self.printer = printer = config.get_printer()
-        self.config_name = config.get_name()
+        self.sensor = sensor   # must implement BulkAdcSensor
        self.name = config.get_name().split()[-1]
        self.sensor = sensor   # must implement BulkSensorAdc
        buffer_size = sensor.get_samples_per_second() // 2
        self._force_buffer = collections.deque(maxlen=buffer_size)
        self.reference_tare_counts = config.getint('reference_tare_counts',
                                                   default=None)
        self.tare_counts = self.reference_tare_counts
        self.counts_per_gram = config.getfloat('counts_per_gram',
                                   minval=MIN_COUNTS_PER_GRAM, default=None)
        self.invert = config.getchoice('sensor_orientation',
                        {'normal': 1., 'inverted': -1.}, default="normal")
        LoadCellCommandHelper(config, self)
        # Client support:
        self.clients = ApiClientHelper(printer)
        header = {"header": ["time", "force (g)", "counts", "tare_counts"]}
        self.clients.add_mux_endpoint("load_cell/dump_force",
                                      "load_cell", self.name, header)
        # startup, when klippy is ready, start capturing data
        printer.register_event_handler("klippy:ready", self._handle_ready)
-    def _handle_ready(self):
+    def _on_sample(self, msg):
        self.sensor.add_client(self._sensor_data_event)
        self.add_client(self._track_force)
        # announce calibration status on ready
        if self.is_calibrated():
            self.printer.send_event("load_cell:calibrate", self)
        if self.is_tared():
            self.printer.send_event("load_cell:tare", self)
    # convert raw counts to grams and broadcast to clients
    def _sensor_data_event(self, msg):
        data = msg.get("data")
        errors = msg.get("errors")
        overflows = msg.get("overflows")
        if data is None:
            return None
        samples = []
        for row in data:
            # [time, grams, counts, tare_counts]
            samples.append([row[0], self.counts_to_grams(row[1]), row[1],
                            self.tare_counts])
        msg = {'data': samples, 'errors': errors, 'overflows': overflows}
        self.clients.send(msg)
        return True
    # get internal events of force data
    def add_client(self, callback):
        self.clients.add_client(callback)
    def tare(self, tare_counts):
        self.tare_counts = int(tare_counts)
        self.printer.send_event("load_cell:tare", self)
    def set_calibration(self, counts_per_gram, tare_counts):
        if (counts_per_gram is None
                or abs(counts_per_gram) < MIN_COUNTS_PER_GRAM):
            raise self.printer.command_error("Invalid counts per gram value")
        if tare_counts is None:
            raise self.printer.command_error("Missing tare counts")
        self.counts_per_gram = counts_per_gram
        self.reference_tare_counts = int(tare_counts)
        configfile = self.printer.lookup_object('configfile')
        configfile.set(self.config_name, 'counts_per_gram',
                       "%.5f" % (self.counts_per_gram,))
        configfile.set(self.config_name, 'reference_tare_counts',
                       "%i" % (self.reference_tare_counts,))
        self.printer.send_event("load_cell:calibrate", self)
    def counts_to_grams(self, sample):
        if not self.is_calibrated() or not self.is_tared():
            return None
        sample_delta = float(sample - self.tare_counts)
        return self.invert * (sample_delta / self.counts_per_gram)
    # The maximum range of the sensor based on its bit width
    def saturation_range(self):
        return self.sensor.get_range()
    # convert raw counts to a +/- percentage of the sensors range
    def counts_to_percent(self, counts):
        range_min, range_max = self.saturation_range()
        return (float(counts) / float(range_max)) * 100.
    # read 1 second of load cell data and average it
    # performs safety checks for saturation
    def avg_counts(self, num_samples=None):
        if num_samples is None:
            num_samples = self.sensor.get_samples_per_second()
        samples, errors = self.get_collector().collect_min(num_samples)
        if errors:
            raise self.printer.command_error(
                "Sensor reported %i errors while sampling"
                    % (errors[0] + errors[1]))
        # check samples for saturated readings
        range_min, range_max = self.saturation_range()
        for sample in samples:
            if sample[2] >= range_max or sample[2] <= range_min:
                raise self.printer.command_error(
                    "Some samples are saturated (+/-100%)")
        return avg(select_column(samples, 2))
    # Provide ongoing force tracking/averaging for status updates
    def _track_force(self, msg):
        if not (self.is_calibrated() and self.is_tared()):
            return True
        samples = msg['data']
        # selectColumn unusable here because Python 2 lacks deque.extend
        for sample in samples:
            self._force_buffer.append(sample[1])
        return True
    def _force_g(self):
        if (self.is_calibrated() and self.is_tared()
                and len(self._force_buffer) > 0):
            return {"force_g": round(avg(self._force_buffer), 1),
                    "min_force_g": round(min(self._force_buffer), 1),
                    "max_force_g": round(max(self._force_buffer), 1)}
        return {}
    def is_tared(self):
        return self.tare_counts is not None
    def is_calibrated(self):
        return (self.counts_per_gram is not None
                and self.reference_tare_counts is not None)
    def get_sensor(self):
        return self.sensor
    def get_reference_tare_counts(self):
        return self.reference_tare_counts
    def get_tare_counts(self):
        return self.tare_counts
    def get_counts_per_gram(self):
        return self.counts_per_gram
    def get_collector(self):
        return LoadCellSampleCollector(self.printer, self)
    def get_status(self, eventtime):
        status = self._force_g()
        status.update({'is_calibrated': self.is_calibrated(),
                       'counts_per_gram': self.counts_per_gram,
                       'reference_tare_counts': self.reference_tare_counts,
                       'tare_counts': self.tare_counts})
        return status
 def load_config(config):
    # Sensor types
    sensors = {}
--- a/klippy/extras/manual_stepper.py
+++ b/klippy/extras/manual_stepper.py
@@ -109,7 +109,7 @@ class ManualStepper:
        self.sync_print_time()
    def get_position(self):
        return [self.rail.get_commanded_position(), 0., 0., 0.]
-    def set_position(self, newpos, homing_axes=""):
+    def set_position(self, newpos, homing_axes=()):
        self.do_set_position(newpos[0])
    def get_last_move_time(self):
        self.sync_print_time()
--- a/klippy/extras/neopixel.py
+++ b/klippy/extras/neopixel.py
@@ -4,7 +4,6 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
 from . import led
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
@@ -41,7 +40,9 @@ class PrinterNeoPixel:
        if len(self.color_map) > MAX_MCU_SIZE:
            raise config.error("neopixel chain too long")
        # Initialize color data
-        self.led_helper = led.LEDHelper(config, self.update_leds, chain_count)
+        pled = printer.load_object(config, "led")
        self.led_helper = pled.setup_helper(config, self.update_leds,
                                            chain_count)
        self.color_data = bytearray(len(self.color_map))
        self.update_color_data(self.led_helper.get_status()['color_data'])
        self.old_color_data = bytearray([d ^ 1 for d in self.color_data])
--- a/klippy/extras/output_pin.py
+++ b/klippy/extras/output_pin.py
@@ -3,187 +3,9 @@
 # Copyright (C) 2017-2024  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging, ast
 from .display import display
 ######################################################################
 # G-Code request queuing helper
 ######################################################################
 PIN_MIN_TIME = 0.100
-
+RESEND_HOST_TIME = 0.300 + PIN_MIN_TIME
 # Helper code to queue g-code requests
 class GCodeRequestQueue:
    def __init__(self, config, mcu, callback):
        self.printer = printer = config.get_printer()
        self.mcu = mcu
        self.callback = callback
        self.rqueue = []
        self.next_min_flush_time = 0.
        self.toolhead = None
        mcu.register_flush_callback(self._flush_notification)
        printer.register_event_handler("klippy:connect", self._handle_connect)
    def _handle_connect(self):
        self.toolhead = self.printer.lookup_object('toolhead')
    def _flush_notification(self, print_time, clock):
        rqueue = self.rqueue
        while rqueue:
            next_time = max(rqueue[0][0], self.next_min_flush_time)
            if next_time > print_time:
                return
            # Skip requests that have been overridden with a following request
            pos = 0
            while pos + 1 < len(rqueue) and rqueue[pos + 1][0] <= next_time:
                pos += 1
            req_pt, req_val = rqueue[pos]
            # Invoke callback for the request
            min_wait = 0.
            ret = self.callback(next_time, req_val)
            if ret is not None:
                # Handle special cases
                action, min_wait = ret
                if action == "discard":
                    del rqueue[:pos+1]
                    continue
                if action == "delay":
                    pos -= 1
            del rqueue[:pos+1]
            self.next_min_flush_time = next_time + max(min_wait, PIN_MIN_TIME)
            # Ensure following queue items are flushed
            self.toolhead.note_mcu_movequeue_activity(self.next_min_flush_time)
    def _queue_request(self, print_time, value):
        self.rqueue.append((print_time, value))
        self.toolhead.note_mcu_movequeue_activity(print_time)
    def queue_gcode_request(self, value):
        self.toolhead.register_lookahead_callback(
            (lambda pt: self._queue_request(pt, value)))
    def send_async_request(self, value, print_time=None):
        if print_time is None:
            systime = self.printer.get_reactor().monotonic()
            print_time = self.mcu.estimated_print_time(systime + PIN_MIN_TIME)
        while 1:
            next_time = max(print_time, self.next_min_flush_time)
            # Invoke callback for the request
            action, min_wait = "normal", 0.
            ret = self.callback(next_time, value)
            if ret is not None:
                # Handle special cases
                action, min_wait = ret
                if action == "discard":
                    break
            self.next_min_flush_time = next_time + max(min_wait, PIN_MIN_TIME)
            if action != "delay":
                break
 ######################################################################
 # Template evaluation helper
 ######################################################################
 # Time between each template update
 RENDER_TIME = 0.500
 # Main template evaluation code
 class PrinterTemplateEvaluator:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.active_templates = {}
        self.render_timer = None
        # Load templates
        dtemplates = display.lookup_display_templates(config)
        self.templates = dtemplates.get_display_templates()
        gcode_macro = self.printer.load_object(config, "gcode_macro")
        self.create_template_context = gcode_macro.create_template_context
    def _activate_timer(self):
        if self.render_timer is not None or not self.active_templates:
            return
        reactor = self.printer.get_reactor()
        self.render_timer = reactor.register_timer(self._render, reactor.NOW)
    def _activate_template(self, callback, template, lparams, flush_callback):
        if template is not None:
            # Build a unique id to make it possible to cache duplicate rendering
            uid = (template,) + tuple(sorted(lparams.items()))
            try:
                {}.get(uid)
            except TypeError as e:
                # lparams is not static, so disable caching
                uid = None
            self.active_templates[callback] = (
                uid, template, lparams, flush_callback)
            return
        if callback in self.active_templates:
            del self.active_templates[callback]
    def _render(self, eventtime):
        if not self.active_templates:
            # Nothing to do - unregister timer
            reactor = self.printer.get_reactor()
            reactor.unregister_timer(self.render_timer)
            self.render_timer = None
            return reactor.NEVER
        # Setup gcode_macro template context
        context = self.create_template_context(eventtime)
        def render(name, **kwargs):
            return self.templates[name].render(context, **kwargs)
        context['render'] = render
        # Render all templates
        flush_callbacks = {}
        render_cache = {}
        template_info = self.active_templates.items()
        for callback, (uid, template, lparams, flush_callback) in template_info:
            text = render_cache.get(uid)
            if text is None:
                try:
                    text = template.render(context, **lparams)
                except Exception as e:
                    logging.exception("display template render error")
                    text = ""
                if uid is not None:
                    render_cache[uid] = text
            if flush_callback is not None:
                flush_callbacks[flush_callback] = 1
            callback(text)
        context.clear() # Remove circular references for better gc
        # Invoke optional flush callbacks
        for flush_callback in flush_callbacks.keys():
            flush_callback()
        return eventtime + RENDER_TIME
    def set_template(self, gcmd, callback, flush_callback=None):
        template = None
        lparams = {}
        tpl_name = gcmd.get("TEMPLATE")
        if tpl_name:
            template = self.templates.get(tpl_name)
            if template is None:
                raise gcmd.error("Unknown display_template '%s'" % (tpl_name,))
            tparams = template.get_params()
            for p, v in gcmd.get_command_parameters().items():
                if not p.startswith("PARAM_"):
                    continue
                p = p.lower()
                if p not in tparams:
                    raise gcmd.error("Invalid display_template parameter: %s"
                                     % (p,))
                try:
                    lparams[p] = ast.literal_eval(v)
                except ValueError as e:
                    raise gcmd.error("Unable to parse '%s' as a literal" % (v,))
        self._activate_template(callback, template, lparams, flush_callback)
        self._activate_timer()
 def lookup_template_eval(config):
    printer = config.get_printer()
    te = printer.lookup_object("template_evaluator", None)
    if te is None:
        te = PrinterTemplateEvaluator(config)
        printer.add_object("template_evaluator", te)
    return te
 ######################################################################
 # Main output pin handling
 ######################################################################
 MAX_SCHEDULE_TIME = 5.0
 class PrinterOutputPin:
@@ -202,18 +24,30 @@ class PrinterOutputPin:
        else:
            self.mcu_pin = ppins.setup_pin('digital_out', config.get('pin'))
            self.scale = 1.
-        self.mcu_pin.setup_max_duration(0.)
+        self.last_print_time = 0.
        # Support mcu checking for maximum duration
        self.reactor = self.printer.get_reactor()
        self.resend_timer = None
        self.resend_interval = 0.
        max_mcu_duration = config.getfloat('maximum_mcu_duration', 0.,
                                           minval=0.500,
                                           maxval=MAX_SCHEDULE_TIME)
        self.mcu_pin.setup_max_duration(max_mcu_duration)
        if max_mcu_duration:
            config.deprecate('maximum_mcu_duration')
            self.resend_interval = max_mcu_duration - RESEND_HOST_TIME
        # Determine start and shutdown values
-        self.last_value = config.getfloat(
+        static_value = config.getfloat('static_value', None,
-            'value', 0., minval=0., maxval=self.scale) / self.scale
+                                       minval=0., maxval=self.scale)
-        self.shutdown_value = config.getfloat(
+        if static_value is not None:
-            'shutdown_value', 0., minval=0., maxval=self.scale) / self.scale
+            config.deprecate('static_value')
            self.last_value = self.shutdown_value = static_value / self.scale
        else:
            self.last_value = config.getfloat(
                'value', 0., minval=0., maxval=self.scale) / self.scale
            self.shutdown_value = config.getfloat(
                'shutdown_value', 0., minval=0., maxval=self.scale) / self.scale
        self.mcu_pin.setup_start_value(self.last_value, self.shutdown_value)
        # Create gcode request queue
        self.gcrq = GCodeRequestQueue(config, self.mcu_pin.get_mcu(),
                                      self._set_pin)
        # Template handling
        self.template_eval = lookup_template_eval(config)
        # Register commands
        pin_name = config.get_name().split()[1]
        gcode = self.printer.lookup_object('gcode')
@@ -222,37 +56,45 @@ class PrinterOutputPin:
                                   desc=self.cmd_SET_PIN_help)
    def get_status(self, eventtime):
        return {'value': self.last_value}
-    def _set_pin(self, print_time, value):
+    def _set_pin(self, print_time, value, is_resend=False):
-        if value == self.last_value:
+        if value == self.last_value and not is_resend:
-            return "discard", 0.
+            return
-        self.last_value = value
+        print_time = max(print_time, self.last_print_time + PIN_MIN_TIME)
        if self.is_pwm:
            self.mcu_pin.set_pwm(print_time, value)
        else:
            self.mcu_pin.set_digital(print_time, value)
-    def _template_update(self, text):
+        self.last_value = value
-        try:
+        self.last_print_time = print_time
-            value = float(text)
+        if self.resend_interval and self.resend_timer is None:
-        except ValueError as e:
+            self.resend_timer = self.reactor.register_timer(
-            logging.exception("output_pin template render error")
+                self._resend_current_val, self.reactor.NOW)
            value = 0.
        self.gcrq.send_async_request(value)
    cmd_SET_PIN_help = "Set the value of an output pin"
    def cmd_SET_PIN(self, gcmd):
        value = gcmd.get_float('VALUE', None, minval=0., maxval=self.scale)
        template = gcmd.get('TEMPLATE', None)
        if (value is None) == (template is None):
            raise gcmd.error("SET_PIN command must specify VALUE or TEMPLATE")
        # Check for template setting
        if template is not None:
            self.template_eval.set_template(gcmd, self._template_update)
            return
        # Read requested value
        value = gcmd.get_float('VALUE', minval=0., maxval=self.scale)
        value /= self.scale
        if not self.is_pwm and value not in [0., 1.]:
            raise gcmd.error("Invalid pin value")
-        # Queue requested value
+        # Obtain print_time and apply requested settings
-        self.gcrq.queue_gcode_request(value)
+        toolhead = self.printer.lookup_object('toolhead')
        toolhead.register_lookahead_callback(
            lambda print_time: self._set_pin(print_time, value))
    def _resend_current_val(self, eventtime):
        if self.last_value == self.shutdown_value:
            self.reactor.unregister_timer(self.resend_timer)
            self.resend_timer = None
            return self.reactor.NEVER
        systime = self.reactor.monotonic()
        print_time = self.mcu_pin.get_mcu().estimated_print_time(systime)
        time_diff = (self.last_print_time + self.resend_interval) - print_time
        if time_diff > 0.:
            # Reschedule for resend time
            return systime + time_diff
        self._set_pin(print_time + PIN_MIN_TIME, self.last_value, True)
        return systime + self.resend_interval
 def load_config_prefix(config):
    return PrinterOutputPin(config)
--- a/klippy/extras/pca9533.py
+++ b/klippy/extras/pca9533.py
@@ -4,7 +4,7 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
-from . import bus, led
+from . import bus
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
@@ -16,7 +16,8 @@ class PCA9533:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.i2c = bus.MCU_I2C_from_config(config, default_addr=98)
-        self.led_helper = led.LEDHelper(config, self.update_leds, 1)
+        pled = self.printer.load_object(config, "led")
        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
        self.i2c.i2c_write([PCA9533_PWM0, 85])
        self.i2c.i2c_write([PCA9533_PWM1, 170])
        self.update_leds(self.led_helper.get_status()['color_data'], None)
--- a/klippy/extras/pca9632.py
+++ b/klippy/extras/pca9632.py
@@ -3,7 +3,7 @@
 # Copyright (C) 2022  Ricardo Alcantara <ricardo@vulcanolabs.com>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-from . import bus, led, mcp4018
+from . import bus, mcp4018
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
@@ -34,7 +34,8 @@ class PCA9632:
            raise config.error("Invalid color_order '%s'" % (color_order,))
        self.color_map = ["RGBW".index(c) for c in color_order]
        self.prev_regs = {}
-        self.led_helper = led.LEDHelper(config, self.update_leds, 1)
+        pled = printer.load_object(config, "led")
        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
        printer.register_event_handler("klippy:connect", self.handle_connect)
    def reg_write(self, reg, val, minclock=0):
        if self.prev_regs.get(reg) == val:
--- a/klippy/extras/resonance_tester.py
+++ b/klippy/extras/resonance_tester.py
@@ -45,96 +45,40 @@ def _parse_axis(gcmd, raw_axis):
                "Unable to parse axis direction '%s'" % (raw_axis,))
    return TestAxis(vib_dir=(dir_x, dir_y))
-class VibrationPulseTestGenerator:
+class VibrationPulseTest:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.gcode = self.printer.lookup_object('gcode')
        self.min_freq = config.getfloat('min_freq', 5., minval=1.)
-        self.max_freq = config.getfloat('max_freq', 135.,
+        # Defaults are such that max_freq * accel_per_hz == 10000 (max_accel)
        self.max_freq = config.getfloat('max_freq', 10000. / 75.,
                                        minval=self.min_freq, maxval=300.)
-        self.accel_per_hz = config.getfloat('accel_per_hz', 60., above=0.)
+        self.accel_per_hz = config.getfloat('accel_per_hz', 75., above=0.)
        self.hz_per_sec = config.getfloat('hz_per_sec', 1.,
                                          minval=0.1, maxval=2.)
        self.probe_points = config.getlists('probe_points', seps=(',', '\n'),
                                            parser=float, count=3)
    def get_start_test_points(self):
        return self.probe_points
    def prepare_test(self, gcmd):
        self.freq_start = gcmd.get_float("FREQ_START", self.min_freq, minval=1.)
        self.freq_end = gcmd.get_float("FREQ_END", self.max_freq,
                                       minval=self.freq_start, maxval=300.)
-        self.test_accel_per_hz = gcmd.get_float("ACCEL_PER_HZ",
+        self.hz_per_sec = gcmd.get_float("HZ_PER_SEC", self.hz_per_sec,
-                                                self.accel_per_hz, above=0.)
+                                         above=0., maxval=2.)
-        self.test_hz_per_sec = gcmd.get_float("HZ_PER_SEC", self.hz_per_sec,
+    def run_test(self, axis, gcmd):
                                              above=0., maxval=2.)
    def gen_test(self):
        freq = self.freq_start
        res = []
        sign = 1.
        time = 0.
        while freq <= self.freq_end + 0.000001:
            t_seg = .25 / freq
            accel = self.test_accel_per_hz * freq
            time += t_seg
            res.append((time, sign * accel, freq))
            time += t_seg
            res.append((time, -sign * accel, freq))
            freq += 2. * t_seg * self.test_hz_per_sec
            sign = -sign
        return res
    def get_max_freq(self):
        return self.freq_end
 class SweepingVibrationsTestGenerator:
    def __init__(self, config):
        self.vibration_generator = VibrationPulseTestGenerator(config)
        self.sweeping_accel = config.getfloat('sweeping_accel', 400., above=0.)
        self.sweeping_period = config.getfloat('sweeping_period', 1.2,
                                               minval=0.)
    def prepare_test(self, gcmd):
        self.vibration_generator.prepare_test(gcmd)
        self.test_sweeping_accel = gcmd.get_float(
                "SWEEPING_ACCEL", self.sweeping_accel, above=0.)
        self.test_sweeping_period = gcmd.get_float(
                "SWEEPING_PERIOD", self.sweeping_period, minval=0.)
    def gen_test(self):
        test_seq = self.vibration_generator.gen_test()
        accel_fraction = math.sqrt(2.0) * 0.125
        if self.test_sweeping_period:
            t_rem = self.test_sweeping_period * accel_fraction
            sweeping_accel = self.test_sweeping_accel
        else:
            t_rem = float('inf')
            sweeping_accel = 0.
        res = []
        last_t = 0.
        sig = 1.
        accel_fraction += 0.25
        for next_t, accel, freq in test_seq:
            t_seg = next_t - last_t
            while t_rem <= t_seg:
                last_t += t_rem
                res.append((last_t, accel + sweeping_accel * sig, freq))
                t_seg -= t_rem
                t_rem = self.test_sweeping_period * accel_fraction
                accel_fraction = 0.5
                sig = -sig
            t_rem -= t_seg
            res.append((next_t, accel + sweeping_accel * sig, freq))
            last_t = next_t
        return res
    def get_max_freq(self):
        return self.vibration_generator.get_max_freq()
 class ResonanceTestExecutor:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.gcode = self.printer.lookup_object('gcode')
    def run_test(self, test_seq, axis, gcmd):
        reactor = self.printer.get_reactor()
        toolhead = self.printer.lookup_object('toolhead')
        X, Y, Z, E = toolhead.get_position()
        sign = 1.
        freq = self.freq_start
        # Override maximum acceleration and acceleration to
        # deceleration based on the maximum test frequency
-        systime = reactor.monotonic()
+        systime = self.printer.get_reactor().monotonic()
        toolhead_info = toolhead.get_status(systime)
        old_max_accel = toolhead_info['max_accel']
        old_minimum_cruise_ratio = toolhead_info['minimum_cruise_ratio']
-        max_accel = max([abs(a) for _, a, _ in test_seq])
+        max_accel = self.freq_end * self.accel_per_hz
        self.gcode.run_script_from_command(
            "SET_VELOCITY_LIMIT ACCEL=%.3f MINIMUM_CRUISE_RATIO=0"
            % (max_accel,))
@@ -144,46 +88,24 @@ class ResonanceTestExecutor:
            gcmd.respond_info("Disabled [input_shaper] for resonance testing")
        else:
            input_shaper = None
-        last_v = last_t = last_accel = last_freq = 0.
+        gcmd.respond_info("Testing frequency %.0f Hz" % (freq,))
-        for next_t, accel, freq in test_seq:
+        while freq <= self.freq_end + 0.000001:
-            t_seg = next_t - last_t
+            t_seg = .25 / freq
            accel = self.accel_per_hz * freq
            max_v = accel * t_seg
            toolhead.cmd_M204(self.gcode.create_gcode_command(
-                "M204", "M204", {"S": abs(accel)}))
+                "M204", "M204", {"S": accel}))
-            v = last_v + accel * t_seg
+            L = .5 * accel * t_seg**2
-            abs_v = abs(v)
+            dX, dY = axis.get_point(L)
-            if abs_v < 0.000001:
+            nX = X + sign * dX
-                v = abs_v = 0.
+            nY = Y + sign * dY
-            abs_last_v = abs(last_v)
+            toolhead.move([nX, nY, Z, E], max_v)
-            v2 = v * v
+            toolhead.move([X, Y, Z, E], max_v)
-            last_v2 = last_v * last_v
+            sign = -sign
-            half_inv_accel = .5 / accel
+            old_freq = freq
-            d = (v2 - last_v2) * half_inv_accel
+            freq += 2. * t_seg * self.hz_per_sec
-            dX, dY = axis.get_point(d)
+            if math.floor(freq) > math.floor(old_freq):
            nX = X + dX
            nY = Y + dY
            toolhead.limit_next_junction_speed(abs_last_v)
            if v * last_v < 0:
                # The move first goes to a complete stop, then changes direction
                d_decel = -last_v2 * half_inv_accel
                decel_X, decel_Y = axis.get_point(d_decel)
                toolhead.move([X + decel_X, Y + decel_Y, Z, E], abs_last_v)
                toolhead.move([nX, nY, Z, E], abs_v)
            else:
                toolhead.move([nX, nY, Z, E], max(abs_v, abs_last_v))
            if math.floor(freq) > math.floor(last_freq):
                gcmd.respond_info("Testing frequency %.0f Hz" % (freq,))
                reactor.pause(reactor.monotonic() + 0.01)
            X, Y = nX, nY
            last_t = next_t
            last_v = v
            last_accel = accel
            last_freq = freq
        if last_v:
            d_decel = -.5 * last_v2 / old_max_accel
            decel_X, decel_Y = axis.get_point(d_decel)
            toolhead.cmd_M204(self.gcode.create_gcode_command(
                "M204", "M204", {"S": old_max_accel}))
            toolhead.move([X + decel_X, Y + decel_Y, Z, E], abs(last_v))
        # Restore the original acceleration values
        self.gcode.run_script_from_command(
            "SET_VELOCITY_LIMIT ACCEL=%.3f MINIMUM_CRUISE_RATIO=%.3f"
@@ -192,13 +114,14 @@ class ResonanceTestExecutor:
        if input_shaper is not None:
            input_shaper.enable_shaping()
            gcmd.respond_info("Re-enabled [input_shaper]")
    def get_max_freq(self):
        return self.freq_end
 class ResonanceTester:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.move_speed = config.getfloat('move_speed', 50., above=0.)
-        self.generator = SweepingVibrationsTestGenerator(config)
+        self.test = VibrationPulseTest(config)
        self.executor = ResonanceTestExecutor(config)
        if not config.get('accel_chip_x', None):
            self.accel_chip_names = [('xy', config.get('accel_chip').strip())]
        else:
@@ -208,8 +131,6 @@ class ResonanceTester:
            if self.accel_chip_names[0][1] == self.accel_chip_names[1][1]:
                self.accel_chip_names = [('xy', self.accel_chip_names[0][1])]
        self.max_smoothing = config.getfloat('max_smoothing', None, minval=0.05)
        self.probe_points = config.getlists('probe_points', seps=(',', '\n'),
                                            parser=float, count=3)
        self.gcode = self.printer.lookup_object('gcode')
        self.gcode.register_command("MEASURE_AXES_NOISE",
@@ -233,9 +154,12 @@ class ResonanceTester:
        toolhead = self.printer.lookup_object('toolhead')
        calibration_data = {axis: None for axis in axes}
-        self.generator.prepare_test(gcmd)
+        self.test.prepare_test(gcmd)
-        test_points = [test_point] if test_point else self.probe_points
+        if test_point is not None:
            test_points = [test_point]
        else:
            test_points = self.test.get_start_test_points()
        for point in test_points:
            toolhead.manual_move(point, self.move_speed)
@@ -260,8 +184,7 @@ class ResonanceTester:
                        raw_values.append((axis, aclient, chip.name))
                # Generate moves
-                test_seq = self.generator.gen_test()
+                self.test.run_test(axis, gcmd)
                self.executor.run_test(test_seq, axis, gcmd)
                for chip_axis, aclient, chip_name in raw_values:
                    aclient.finish_measurements()
                    if raw_name_suffix is not None:
@@ -289,11 +212,15 @@ class ResonanceTester:
    def _parse_chips(self, accel_chips):
        parsed_chips = []
        for chip_name in accel_chips.split(','):
-            chip = self.printer.lookup_object(chip_name.strip())
+            if "adxl345" in chip_name:
                chip_lookup_name = chip_name.strip()
            else:
                chip_lookup_name = "adxl345 " + chip_name.strip();
            chip = self.printer.lookup_object(chip_lookup_name)
            parsed_chips.append(chip)
        return parsed_chips
    def _get_max_calibration_freq(self):
-        return 1.5 * self.generator.get_max_freq()
+        return 1.5 * self.test.get_max_freq()
    cmd_TEST_RESONANCES_help = ("Runs the resonance test for a specifed axis")
    def cmd_TEST_RESONANCES(self, gcmd):
        # Parse parameters
--- a/klippy/extras/safe_z_home.py
+++ b/klippy/extras/safe_z_home.py
@@ -37,10 +37,11 @@ class SafeZHoming:
            if 'z' not in kin_status['homed_axes']:
                # Always perform the z_hop if the Z axis is not homed
                pos[2] = 0
-                toolhead.set_position(pos, homing_axes="z")
+                toolhead.set_position(pos, homing_axes=[2])
                toolhead.manual_move([None, None, self.z_hop],
                                     self.z_hop_speed)
-                toolhead.get_kinematics().clear_homing_state("z")
+                if hasattr(toolhead.get_kinematics(), "note_z_not_homed"):
                    toolhead.get_kinematics().note_z_not_homed()
            elif pos[2] < self.z_hop:
                # If the Z axis is homed, and below z_hop, lift it to z_hop
                toolhead.manual_move([None, None, self.z_hop],
--- a/klippy/extras/save_variables.py
+++ b/klippy/extras/save_variables.py
@@ -36,8 +36,6 @@ class SaveVariables:
    cmd_SAVE_VARIABLE_help = "Save arbitrary variables to disk"
    def cmd_SAVE_VARIABLE(self, gcmd):
        varname = gcmd.get('VARIABLE')
        if (varname.lower() != varname):
            raise gcmd.error("VARIABLE must not contain upper case")
        value = gcmd.get('VALUE')
        try:
            value = ast.literal_eval(value)
--- a/klippy/extras/screws_tilt_adjust.py
+++ b/klippy/extras/screws_tilt_adjust.py
@@ -12,7 +12,7 @@ class ScrewsTiltAdjust:
        self.config = config
        self.printer = config.get_printer()
        self.screws = []
-        self.results = {}
+        self.results = []
        self.max_diff = None
        self.max_diff_error = False
        # Read config
--- a/klippy/extras/servo.py
+++ b/klippy/extras/servo.py
@@ -1,11 +1,11 @@
 # Support for servos
 #
-# Copyright (C) 2017-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2017-2020  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 from . import output_pin
 SERVO_SIGNAL_PERIOD = 0.020
 PIN_MIN_TIME = 0.100
 class PrinterServo:
    def __init__(self, config):
@@ -18,7 +18,7 @@ class PrinterServo:
        self.max_angle = config.getfloat('maximum_servo_angle', 180.)
        self.angle_to_width = (self.max_width - self.min_width) / self.max_angle
        self.width_to_value = 1. / SERVO_SIGNAL_PERIOD
-        self.last_value = 0.
+        self.last_value = self.last_value_time = 0.
        initial_pwm = 0.
        iangle = config.getfloat('initial_angle', None, minval=0., maxval=360.)
        if iangle is not None:
@@ -33,9 +33,6 @@ class PrinterServo:
        self.mcu_servo.setup_max_duration(0.)
        self.mcu_servo.setup_cycle_time(SERVO_SIGNAL_PERIOD)
        self.mcu_servo.setup_start_value(initial_pwm, 0.)
        # Create gcode request queue
        self.gcrq = output_pin.GCodeRequestQueue(
            config, self.mcu_servo.get_mcu(), self._set_pwm)
        # Register commands
        servo_name = config.get_name().split()[1]
        gcode = self.printer.lookup_object('gcode')
@@ -46,9 +43,11 @@ class PrinterServo:
        return {'value': self.last_value}
    def _set_pwm(self, print_time, value):
        if value == self.last_value:
-            return "discard", 0.
+            return
-        self.last_value = value
+        print_time = max(print_time, self.last_value_time + PIN_MIN_TIME)
        self.mcu_servo.set_pwm(print_time, value)
        self.last_value = value
        self.last_value_time = print_time
    def _get_pwm_from_angle(self, angle):
        angle = max(0., min(self.max_angle, angle))
        width = self.min_width + angle * self.angle_to_width
@@ -65,7 +64,9 @@ class PrinterServo:
        else:
            angle = gcmd.get_float('ANGLE')
            value = self._get_pwm_from_angle(angle)
-        self.gcrq.queue_gcode_request(value)
+        toolhead = self.printer.lookup_object('toolhead')
        toolhead.register_lookahead_callback((lambda pt:
                                              self._set_pwm(pt, value)))
 def load_config_prefix(config):
    return PrinterServo(config)
--- a/klippy/extras/shaper_calibrate.py
+++ b/klippy/extras/shaper_calibrate.py
@@ -48,9 +48,7 @@ class CalibrationData:
            # Avoid division by zero errors
            psd /= self.freq_bins + .1
            # Remove low-frequency noise
-            low_freqs = self.freq_bins < 2. * MIN_FREQ
+            psd[self.freq_bins < MIN_FREQ] = 0.
            psd[low_freqs] *= self.numpy.exp(
                    -(2. * MIN_FREQ / (self.freq_bins[low_freqs] + .1))**2 + 1.)
    def get_psd(self, axis='all'):
        return self._psd_map[axis]
--- a/klippy/extras/skew_correction.py
+++ b/klippy/extras/skew_correction.py
@@ -20,7 +20,6 @@ class PrinterSkew:
    def __init__(self, config):
        self.printer = config.get_printer()
        self.name = config.get_name()
        self.current_profile_name = ""
        self.toolhead = None
        self.xy_factor = 0.
        self.xz_factor = 0.
@@ -118,7 +117,6 @@ class PrinterSkew:
    def cmd_SKEW_PROFILE(self, gcmd):
        if gcmd.get('LOAD', None) is not None:
            name = gcmd.get('LOAD')
            self.current_profile_name = name
            prof = self.skew_profiles.get(name)
            if prof is None:
                gcmd.respond_info(
@@ -158,10 +156,7 @@ class PrinterSkew:
                gcmd.respond_info(
                    "skew_correction: No profile named [%s] to remove"
                    % (name))
-    def get_status(self, eventtime):
+
        return {
            'current_profile_name': self.current_profile_name
        }
 def load_config(config):
    return PrinterSkew(config)
--- a/klippy/extras/stepper_enable.py
+++ b/klippy/extras/stepper_enable.py
@@ -94,7 +94,6 @@ class PrinterStepperEnable:
        print_time = toolhead.get_last_move_time()
        for el in self.enable_lines.values():
            el.motor_disable(print_time)
        toolhead.get_kinematics().clear_homing_state("xyz")
        self.printer.send_event("stepper_enable:motor_off", print_time)
        toolhead.dwell(DISABLE_STALL_TIME)
    def motor_debug_enable(self, stepper, enable):
--- a/klippy/extras/sx1509.py
+++ b/klippy/extras/sx1509.py
@@ -38,17 +38,19 @@ class SX1509(object):
                         REG_INPUT_DISABLE : 0, REG_ANALOG_DRIVER_ENABLE : 0}
        self.reg_i_on_dict = {reg : 0 for reg in REG_I_ON}
    def _build_config(self):
-        # Reset the chip, Default RegClock/RegMisc 0x0
+        # Reset the chip
        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
            self._oid, REG_RESET, 0x12))
        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
            self._oid, REG_RESET, 0x34))
        # Enable Oscillator
-        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
+        self._mcu.add_config_cmd("i2c_modify_bits oid=%d reg=%02x"
-            self._oid, REG_CLOCK, (1 << 6)))
+                                 " clear_set_bits=%02x%02x" % (
                                     self._oid, REG_CLOCK, 0, (1 << 6)))
        # Setup Clock Divider
-        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
+        self._mcu.add_config_cmd("i2c_modify_bits oid=%d reg=%02x"
-            self._oid, REG_MISC, (1 << 4)))
+                                 " clear_set_bits=%02x%02x" % (
                                     self._oid, REG_MISC, 0, (1 << 4)))
        # Transfer all regs with their initial cached state
        for _reg, _data in self.reg_dict.items():
            self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%04x" % (
--- a/klippy/extras/temperature_combined.py
+++ b/klippy/extras/temperature_combined.py
@@ -41,29 +41,19 @@ class PrinterSensorCombined:
            sensor = self.printer.lookup_object(sensor_name)
            # check if sensor has get_status function and
            # get_status has a 'temperature' value
-            if not hasattr(sensor, 'get_status'):
+            if (hasattr(sensor, 'get_status') and
-                raise self.printer.config_error(
+                    'temperature' in sensor.get_status(
-                        "'%s' does not have a status."
+                            self.reactor.monotonic())):
-                        % (sensor_name,))
+                self.sensors.append(sensor)
-            status = sensor.get_status(self.reactor.monotonic())
+            else:
            if 'temperature' not in status:
                raise self.printer.config_error(
                        "'%s' does not report a temperature."
                        % (sensor_name,))
            # Handle temperature monitors
            if status["temperature"] is None:
                raise self.printer.config_error(
                        "Temperature monitor '%s' is not supported"
                        % (sensor_name,))
            self.sensors.append(sensor)
    def _handle_ready(self):
        # Start temperature update timer
        # There is a race condition with sensors where they can be not ready,
        # and return 0 or None - initialize a little bit later.
        self.reactor.update_timer(self.temperature_update_timer,
-                                  self.reactor.monotonic() + 1.)
+                                  self.reactor.NOW)
    def setup_minmax(self, min_temp, max_temp):
        self.min_temp = min_temp
--- a/klippy/extras/temperature_fan.py
+++ b/klippy/extras/temperature_fan.py
@@ -46,7 +46,7 @@ class TemperatureFan:
            self.cmd_SET_TEMPERATURE_FAN_TARGET,
            desc=self.cmd_SET_TEMPERATURE_FAN_TARGET_help)
-    def set_tf_speed(self, read_time, value):
+    def set_speed(self, read_time, value):
        if value <= 0.:
            value = 0.
        elif value < self.min_speed:
@@ -60,7 +60,7 @@ class TemperatureFan:
        speed_time = read_time + self.speed_delay
        self.next_speed_time = speed_time + 0.75 * MAX_FAN_TIME
        self.last_speed_value = value
-        self.fan.set_speed(value, speed_time)
+        self.fan.set_speed(speed_time, value)
    def temperature_callback(self, read_time, temp):
        self.last_temp = temp
        self.control.temperature_callback(read_time, temp)
@@ -128,10 +128,10 @@ class ControlBangBang:
              and temp <= target_temp-self.max_delta):
            self.heating = True
        if self.heating:
-            self.temperature_fan.set_tf_speed(read_time, 0.)
+            self.temperature_fan.set_speed(read_time, 0.)
        else:
-            self.temperature_fan.set_tf_speed(
+            self.temperature_fan.set_speed(read_time,
-                read_time, self.temperature_fan.get_max_speed())
+                                           self.temperature_fan.get_max_speed())
 ######################################################################
 # Proportional Integral Derivative (PID) control algo
@@ -171,7 +171,7 @@ class ControlPID:
        # Calculate output
        co = self.Kp*temp_err + self.Ki*temp_integ - self.Kd*temp_deriv
        bounded_co = max(0., min(self.temperature_fan.get_max_speed(), co))
-        self.temperature_fan.set_tf_speed(
+        self.temperature_fan.set_speed(
            read_time, max(self.temperature_fan.get_min_speed(),
                           self.temperature_fan.get_max_speed() - bounded_co))
        # Store state for next measurement
--- a/klippy/extras/temperature_mcu.py
+++ b/klippy/extras/temperature_mcu.py
@@ -66,7 +66,7 @@ class PrinterTemperatureMCU:
        self.mcu_type = mcu.get_constants().get("MCU", "")
        # Run MCU specific configuration
        cfg_funcs = [
-            ('rp2', self.config_rp2040),
+            ('rp2040', self.config_rp2040),
            ('sam3', self.config_sam3), ('sam4', self.config_sam4),
            ('same70', self.config_same70), ('samd21', self.config_samd21),
            ('samd51', self.config_samd51), ('same5', self.config_samd51),
--- a/klippy/extras/temperature_probe.py
+++ b/klippy/extras/temperature_probe.py
@@ -490,7 +490,6 @@ class EddyDriftCompensation:
        self.cal_temp = config.getfloat("calibration_temp", 0.)
        self.drift_calibration = None
        self.calibration_samples = None
        self.max_valid_temp = config.getfloat("max_validation_temp", 60.)
        self.dc_min_temp = config.getfloat("drift_calibration_min_temp", 0.)
        dc = config.getlists(
            "drift_calibration", None, seps=(',', '\n'), parser=float
@@ -504,8 +503,7 @@ class EddyDriftCompensation:
                    )
            self.drift_calibration = [Polynomial2d(*coefs) for coefs in dc]
            cal = self.drift_calibration
-            start_temp, end_temp = self.dc_min_temp, self.max_valid_temp
+            self._check_calibration(cal, self.dc_min_temp, config.error)
            self._check_calibration(cal, start_temp, end_temp, config.error)
            low_poly = self.drift_calibration[-1]
            self.min_freq = min([low_poly(temp) for temp in range(121)])
            cal_str = "\n".join([repr(p) for p in cal])
@@ -640,15 +638,13 @@ class EddyDriftCompensation:
                "calbration error, not enough samples"
            )
        min_temp, _ = cal_samples[0][0]
        max_temp, _ = cal_samples[-1][0]
        polynomials = []
        for i, coords in enumerate(cal_samples):
            height = .05 + i * .5
            poly = Polynomial2d.fit(coords)
            polynomials.append(poly)
            logging.info("Polynomial at Z=%.2f: %s" % (height, repr(poly)))
-        end_vld_temp = max(self.max_valid_temp, max_temp)
+        self._check_calibration(polynomials, min_temp)
        self._check_calibration(polynomials, min_temp, end_vld_temp)
        coef_cfg = "\n" + "\n".join([str(p) for p in polynomials])
        configfile = self.printer.lookup_object('configfile')
        configfile.set(self.name, "drift_calibration", coef_cfg)
@@ -660,11 +656,10 @@ class EddyDriftCompensation:
            % (self.name, len(polynomials))
        )
-    def _check_calibration(self, calibration, start_temp, end_temp, error=None):
+    def _check_calibration(self, calibration, start_temp, error=None):
        error = error or self.printer.command_error
        start = int(start_temp)
-        end = int(end_temp) + 1
+        for temp in range(start, 121, 1):
        for temp in range(start, end, 1):
            last_freq = calibration[0](temp)
            for i, poly in enumerate(calibration[1:]):
                next_freq = poly(temp)
--- a/klippy/extras/tmc2240.py
+++ b/klippy/extras/tmc2240.py
@@ -348,7 +348,7 @@ class TMC2240:
        if config.get("uart_pin", None) is not None:
            # use UART for communication
            self.mcu_tmc = tmc_uart.MCU_TMC_uart(config, Registers, self.fields,
-                                                 7, TMC_FREQUENCY)
+                                                 3, TMC_FREQUENCY)
        else:
            # Use SPI bus for communication
            self.mcu_tmc = tmc2130.MCU_TMC_SPI(config, Registers, self.fields,
@@ -408,8 +408,6 @@ class TMC2240:
        set_config_field(config, "tpowerdown", 10)
        #   SG4_THRS
        set_config_field(config, "sg4_angle_offset", 1)
        #   DRV_CONF
        set_config_field(config, "slope_control", 0)
 def load_config_prefix(config):
    return TMC2240(config)
--- a/klippy/extras/z_tilt.py
+++ b/klippy/extras/z_tilt.py
@@ -108,7 +108,7 @@ class RetryHelper:
        return self.increasing > 1
    def check_retry(self, z_positions):
        if self.max_retries == 0:
-            return "done"
+            return
        error = round(max(z_positions) - min(z_positions),6)
        self.gcode.respond_info(
            "Retries: %d/%d %s: %0.6f tolerance: %0.6f" % (
--- a/klippy/gcode.py
+++ b/klippy/gcode.py
@@ -1,6 +1,6 @@
 # Parse gcode commands
 #
-# Copyright (C) 2016-2024  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import os, re, logging, collections, shlex
@@ -28,18 +28,19 @@ class GCodeCommand:
        return self._params
    def get_raw_command_parameters(self):
        command = self._command
-        origline = self._commandline
+        if command.startswith("M117 ") or command.startswith("M118 "):
-        param_start = len(command)
+            command = command[:4]
-        param_end = len(origline)
+        rawparams = self._commandline
-        if origline[:param_start].upper() != command:
+        urawparams = rawparams.upper()
-            # Skip any gcode line-number and ignore any trailing checksum
+        if not urawparams.startswith(command):
-            param_start += origline.upper().find(command)
+            rawparams = rawparams[urawparams.find(command):]
-            end = origline.rfind('*')
+            end = rawparams.rfind('*')
-            if end >= 0 and origline[end+1:].isdigit():
+            if end >= 0:
-                param_end = end
+                rawparams = rawparams[:end]
-        if origline[param_start:param_start+1].isspace():
+        rawparams = rawparams[len(command):]
-            param_start += 1
+        if rawparams.startswith(' '):
-        return origline[param_start:param_end]
+            rawparams = rawparams[1:]
        return rawparams
    def ack(self, msg=None):
        if not self._need_ack:
            return False
@@ -132,10 +133,6 @@ class GCodeDispatch:
            raise self.printer.config_error(
                "gcode command %s already registered" % (cmd,))
        if not self.is_traditional_gcode(cmd):
            if (cmd.upper() != cmd or not cmd.replace('_', 'A').isalnum()
                or cmd[0].isdigit() or cmd[1:2].isdigit()):
                raise self.printer.config_error(
                    "Can't register '%s' as it is an invalid name" % (cmd,))
            origfunc = func
            func = lambda params: origfunc(self._get_extended_params(params))
        self.ready_gcode_handlers[cmd] = func
@@ -187,7 +184,7 @@ class GCodeDispatch:
        self._build_status_commands()
        self._respond_state("Ready")
    # Parse input into commands
-    args_r = re.compile('([A-Z_]+|[A-Z*])')
+    args_r = re.compile('([A-Z_]+|[A-Z*/])')
    def _process_commands(self, commands, need_ack=True):
        for line in commands:
            # Ignore comments and leading/trailing spaces
@@ -197,14 +194,16 @@ class GCodeDispatch:
                line = line[:cpos]
            # Break line into parts and determine command
            parts = self.args_r.split(line.upper())
-            if ''.join(parts[:2]) == 'N':
+            numparts = len(parts)
            cmd = ""
            if numparts >= 3 and parts[1] != 'N':
                cmd = parts[1] + parts[2].strip()
            elif numparts >= 5 and parts[1] == 'N':
                # Skip line number at start of command
-                cmd = ''.join(parts[3:5]).strip()
+                cmd = parts[3] + parts[4].strip()
            else:
                cmd = ''.join(parts[:3]).strip()
            # Build gcode "params" dictionary
            params = { parts[i]: parts[i+1].strip()
-                       for i in range(1, len(parts), 2) }
+                       for i in range(1, numparts, 2) }
            gcmd = GCodeCommand(self, cmd, origline, params, need_ack)
            # Invoke handler for command
            handler = self.gcode_handlers.get(cmd, self.cmd_default)
@@ -252,22 +251,26 @@ class GCodeDispatch:
    def _respond_state(self, state):
        self.respond_info("Klipper state: %s" % (state,), log=False)
    # Parameter parsing helpers
    extended_r = re.compile(
        r'^\s*(?:N[0-9]+\s*)?'
        r'(?P<cmd>[a-zA-Z_][a-zA-Z0-9_]+)(?:\s+|$)'
        r'(?P<args>[^#*;]*?)'
        r'\s*(?:[#*;].*)?$')
    def _get_extended_params(self, gcmd):
-        rawparams = gcmd.get_raw_command_parameters()
+        m = self.extended_r.match(gcmd.get_commandline())
-        # Extract args while allowing shell style quoting
+        if m is None:
-        s = shlex.shlex(rawparams, posix=True)
+            raise self.error("Malformed command '%s'"
-        s.whitespace_split = True
+                             % (gcmd.get_commandline(),))
-        s.commenters = '#;'
+        eargs = m.group('args')
        try:
-            eparams = [earg.split('=', 1) for earg in s]
+            eparams = [earg.split('=', 1) for earg in shlex.split(eargs)]
            eparams = { k.upper(): v for k, v in eparams }
            gcmd._params.clear()
            gcmd._params.update(eparams)
            return gcmd
        except ValueError as e:
            raise self.error("Malformed command '%s'"
                             % (gcmd.get_commandline(),))
        # Update gcmd with new parameters
        gcmd._params.clear()
        gcmd._params.update(eparams)
        return gcmd
    # G-Code special command handlers
    def cmd_default(self, gcmd):
        cmd = gcmd.get_command()
@@ -286,15 +289,12 @@ class GCodeDispatch:
            if cmdline:
                logging.debug(cmdline)
            return
-        if ' ' in cmd:
+        if cmd.startswith("M117 ") or cmd.startswith("M118 "):
            # Handle M117/M118 gcode with numeric and special characters
-            realcmd = cmd.split()[0]
+            handler = self.gcode_handlers.get(cmd[:4], None)
-            if realcmd in ["M117", "M118", "M23"]:
+            if handler is not None:
-                handler = self.gcode_handlers.get(realcmd, None)
+                handler(gcmd)
-                if handler is not None:
+                return
                    gcmd._command = realcmd
                    handler(gcmd)
                    return
        elif cmd in ['M140', 'M104'] and not gcmd.get_float('S', 0.):
            # Don't warn about requests to turn off heaters when not present
            return
--- a/klippy/kinematics/cartesian.py
+++ b/klippy/kinematics/cartesian.py
@@ -40,6 +40,8 @@ class CartKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        self.printer.register_event_handler("stepper_enable:motor_off",
                                            self._motor_off)
        # Setup boundary checks
        max_velocity, max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat('max_z_velocity', max_velocity,
@@ -65,17 +67,15 @@ class CartKinematics:
    def set_position(self, newpos, homing_axes):
        for i, rail in enumerate(self.rails):
            rail.set_position(newpos)
-        for axis_name in homing_axes:
+        for axis in homing_axes:
            axis = "xyz".index(axis_name)
            if self.dc_module and axis == self.dc_module.axis:
                rail = self.dc_module.get_primary_rail().get_rail()
            else:
                rail = self.rails[axis]
            self.limits[axis] = rail.get_range()
-    def clear_homing_state(self, clear_axes):
+    def note_z_not_homed(self):
-        for axis, axis_name in enumerate("xyz"):
+        # Helper for Safe Z Home
-            if axis_name in clear_axes:
+        self.limits[2] = (1.0, -1.0)
                self.limits[axis] = (1.0, -1.0)
    def home_axis(self, homing_state, axis, rail):
        # Determine movement
        position_min, position_max = rail.get_range()
@@ -96,6 +96,8 @@ class CartKinematics:
                self.dc_module.home(homing_state)
            else:
                self.home_axis(homing_state, axis, self.rails[axis])
    def _motor_off(self, print_time):
        self.limits = [(1.0, -1.0)] * 3
    def _check_endstops(self, move):
        end_pos = move.end_pos
        for i in (0, 1, 2):
--- a/klippy/kinematics/corexy.py
+++ b/klippy/kinematics/corexy.py
@@ -21,6 +21,8 @@ class CoreXYKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        config.get_printer().register_event_handler("stepper_enable:motor_off",
                                                    self._motor_off)
        # Setup boundary checks
        max_velocity, max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat(
@@ -39,12 +41,11 @@ class CoreXYKinematics:
    def set_position(self, newpos, homing_axes):
        for i, rail in enumerate(self.rails):
            rail.set_position(newpos)
-            if "xyz"[i] in homing_axes:
+            if i in homing_axes:
                self.limits[i] = rail.get_range()
-    def clear_homing_state(self, clear_axes):
+    def note_z_not_homed(self):
-        for axis, axis_name in enumerate("xyz"):
+        # Helper for Safe Z Home
-            if axis_name in clear_axes:
+        self.limits[2] = (1.0, -1.0)
                self.limits[axis] = (1.0, -1.0)
    def home(self, homing_state):
        # Each axis is homed independently and in order
        for axis in homing_state.get_axes():
@@ -61,6 +62,8 @@ class CoreXYKinematics:
                forcepos[axis] += 1.5 * (position_max - hi.position_endstop)
            # Perform homing
            homing_state.home_rails([rail], forcepos, homepos)
    def _motor_off(self, print_time):
        self.limits = [(1.0, -1.0)] * 3
    def _check_endstops(self, move):
        end_pos = move.end_pos
        for i in (0, 1, 2):
--- a/klippy/kinematics/corexz.py
+++ b/klippy/kinematics/corexz.py
@@ -21,6 +21,8 @@ class CoreXZKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        config.get_printer().register_event_handler("stepper_enable:motor_off",
                                                    self._motor_off)
        # Setup boundary checks
        max_velocity, max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat(
@@ -39,12 +41,11 @@ class CoreXZKinematics:
    def set_position(self, newpos, homing_axes):
        for i, rail in enumerate(self.rails):
            rail.set_position(newpos)
-            if "xyz"[i] in homing_axes:
+            if i in homing_axes:
                self.limits[i] = rail.get_range()
-    def clear_homing_state(self, clear_axes):
+    def note_z_not_homed(self):
-        for axis, axis_name in enumerate("xyz"):
+        # Helper for Safe Z Home
-            if axis_name in clear_axes:
+        self.limits[2] = (1.0, -1.0)
                self.limits[axis] = (1.0, -1.0)
    def home(self, homing_state):
        # Each axis is homed independently and in order
        for axis in homing_state.get_axes():
@@ -61,6 +62,8 @@ class CoreXZKinematics:
                forcepos[axis] += 1.5 * (position_max - hi.position_endstop)
            # Perform homing
            homing_state.home_rails([rail], forcepos, homepos)
    def _motor_off(self, print_time):
        self.limits = [(1.0, -1.0)] * 3
    def _check_endstops(self, move):
        end_pos = move.end_pos
        for i in (0, 1, 2):
--- a/klippy/kinematics/delta.py
+++ b/klippy/kinematics/delta.py
@@ -23,6 +23,8 @@ class DeltaKinematics:
            stepper_configs[2], need_position_minmax = False,
            default_position_endstop=a_endstop)
        self.rails = [rail_a, rail_b, rail_c]
        config.get_printer().register_event_handler("stepper_enable:motor_off",
                                                    self._motor_off)
        # Setup max velocity
        self.max_velocity, self.max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat(
@@ -88,7 +90,7 @@ class DeltaKinematics:
                        math.sqrt(self.very_slow_xy2)))
        self.axes_min = toolhead.Coord(-max_xy, -max_xy, self.min_z, 0.)
        self.axes_max = toolhead.Coord(max_xy, max_xy, self.max_z, 0.)
-        self.set_position([0., 0., 0.], "")
+        self.set_position([0., 0., 0.], ())
    def get_steppers(self):
        return [s for rail in self.rails for s in rail.get_steppers()]
    def _actuator_to_cartesian(self, spos):
@@ -101,19 +103,17 @@ class DeltaKinematics:
        for rail in self.rails:
            rail.set_position(newpos)
        self.limit_xy2 = -1.
-        if homing_axes == "xyz":
+        if tuple(homing_axes) == (0, 1, 2):
            self.need_home = False
    def clear_homing_state(self, clear_axes):
        # Clearing homing state for each axis individually is not implemented
        if clear_axes:
            self.limit_xy2 = -1
            self.need_home = True
    def home(self, homing_state):
        # All axes are homed simultaneously
        homing_state.set_axes([0, 1, 2])
        forcepos = list(self.home_position)
        forcepos[2] = -1.5 * math.sqrt(max(self.arm2)-self.max_xy2)
        homing_state.home_rails(self.rails, forcepos, self.home_position)
    def _motor_off(self, print_time):
        self.limit_xy2 = -1.
        self.need_home = True
    def check_move(self, move):
        end_pos = move.end_pos
        end_xy2 = end_pos[0]**2 + end_pos[1]**2
--- a/klippy/kinematics/deltesian.py
+++ b/klippy/kinematics/deltesian.py
@@ -41,6 +41,8 @@ class DeltesianKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        config.get_printer().register_event_handler(
            "stepper_enable:motor_off", self._motor_off)
        self.limits = [(1.0, -1.0)] * 3
        # X axis limits
        min_angle = config.getfloat('min_angle', MIN_ANGLE,
@@ -87,7 +89,7 @@ class DeltesianKinematics:
        self.axes_min = toolhead.Coord(*[l[0] for l in self.limits], e=0.)
        self.axes_max = toolhead.Coord(*[l[1] for l in self.limits], e=0.)
        self.homed_axis = [False] * 3
-        self.set_position([0., 0., 0.], "")
+        self.set_position([0., 0., 0.], ())
    def get_steppers(self):
        return [s for rail in self.rails for s in rail.get_steppers()]
    def _actuator_to_cartesian(self, sp):
@@ -113,13 +115,8 @@ class DeltesianKinematics:
    def set_position(self, newpos, homing_axes):
        for rail in self.rails:
            rail.set_position(newpos)
-        for axis_name in homing_axes:
+        for n in homing_axes:
-            axis = "xyz".index(axis_name)
+            self.homed_axis[n] = True
            self.homed_axis[axis] = True
    def clear_homing_state(self, clear_axes):
        for axis, axis_name in enumerate("xyz"):
            if axis_name in clear_axes:
                self.homed_axis[axis] = False
    def home(self, homing_state):
        homing_axes = homing_state.get_axes()
        home_xz = 0 in homing_axes or 2 in homing_axes
@@ -145,6 +142,8 @@ class DeltesianKinematics:
            else:
                forcepos[1] += 1.5 * (position_max - hi.position_endstop)
            homing_state.home_rails([self.rails[2]], forcepos, homepos)
    def _motor_off(self, print_time):
        self.homed_axis = [False] * 3
    def check_move(self, move):
        limits = list(map(list, self.limits))
        spos, epos = move.start_pos, move.end_pos
--- a/klippy/kinematics/hybrid_corexy.py
+++ b/klippy/kinematics/hybrid_corexy.py
@@ -42,6 +42,8 @@ class HybridCoreXYKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        self.printer.register_event_handler("stepper_enable:motor_off",
                                                    self._motor_off)
        # Setup boundary checks
        max_velocity, max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat(
@@ -67,17 +69,15 @@ class HybridCoreXYKinematics:
    def set_position(self, newpos, homing_axes):
        for i, rail in enumerate(self.rails):
            rail.set_position(newpos)
-        for axis_name in homing_axes:
+        for axis in homing_axes:
            axis = "xyz".index(axis_name)
            if self.dc_module and axis == self.dc_module.axis:
                rail = self.dc_module.get_primary_rail().get_rail()
            else:
                rail = self.rails[axis]
            self.limits[axis] = rail.get_range()
-    def clear_homing_state(self, clear_axes):
+    def note_z_not_homed(self):
-        for axis, axis_name in enumerate("xyz"):
+        # Helper for Safe Z Home
-            if axis_name in clear_axes:
+        self.limits[2] = (1.0, -1.0)
                self.limits[axis] = (1.0, -1.0)
    def home_axis(self, homing_state, axis, rail):
        position_min, position_max = rail.get_range()
        hi = rail.get_homing_info()
@@ -96,6 +96,8 @@ class HybridCoreXYKinematics:
                self.dc_module.home(homing_state)
            else:
                self.home_axis(homing_state, axis, self.rails[axis])
    def _motor_off(self, print_time):
        self.limits = [(1.0, -1.0)] * 3
    def _check_endstops(self, move):
        end_pos = move.end_pos
        for i in (0, 1, 2):
--- a/klippy/kinematics/hybrid_corexz.py
+++ b/klippy/kinematics/hybrid_corexz.py
@@ -42,6 +42,8 @@ class HybridCoreXZKinematics:
        for s in self.get_steppers():
            s.set_trapq(toolhead.get_trapq())
            toolhead.register_step_generator(s.generate_steps)
        self.printer.register_event_handler("stepper_enable:motor_off",
                                                    self._motor_off)
        # Setup boundary checks
        max_velocity, max_accel = toolhead.get_max_velocity()
        self.max_z_velocity = config.getfloat(
@@ -67,17 +69,15 @@ class HybridCoreXZKinematics:
    def set_position(self, newpos, homing_axes):
        for i, rail in enumerate(self.rails):
            rail.set_position(newpos)
-        for axis_name in homing_axes:
+        for axis in homing_axes:
            axis = "xyz".index(axis_name)
            if self.dc_module and axis == self.dc_module.axis:
                rail = self.dc_module.get_primary_rail().get_rail()
            else:
                rail = self.rails[axis]
            self.limits[axis] = rail.get_range()
-    def clear_homing_state(self, clear_axes):
+    def note_z_not_homed(self):
-        for axis, axis_name in enumerate("xyz"):
+        # Helper for Safe Z Home
-            if axis_name in clear_axes:
+        self.limits[2] = (1.0, -1.0)
                self.limits[axis] = (1.0, -1.0)
    def home_axis(self, homing_state, axis, rail):
        position_min, position_max = rail.get_range()
        hi = rail.get_homing_info()
@@ -96,6 +96,8 @@ class HybridCoreXZKinematics:
                self.dc_module.home(homing_state)
            else:
                self.home_axis(homing_state, axis, self.rails[axis])
    def _motor_off(self, print_time):
        self.limits = [(1.0, -1.0)] * 3
    def _check_endstops(self, move):
        end_pos = move.end_pos
        for i in (0, 1, 2):
--- a/klippy/kinematics/none.py
+++ b/klippy/kinematics/none.py
@@ -13,8 +13,6 @@ class NoneKinematics:
        return [0, 0, 0]
    def set_position(self, newpos, homing_axes):
        pass
    def clear_homing_state(self, clear_axes):
        pass
    def home(self, homing_state):
        pass
    def check_move(self, move):
--- a/Show More
+++ b/Show More