docs: Note the release of v0.13.0

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

.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@v3
+      uses: actions/upload-artifact@v4
       with:
         name: data-dict
         path: ci_build/dict

README.md

@@ -4,15 +4,14 @@ Welcome to the Klipper project!
 
 https://www.klipper3d.org/
 
-Klipper is a 3d-Printer firmware. It combines the power of a general
-purpose computer with one or more micro-controllers. See the
+The Klipper firmware controls 3d-Printers. It combines the power of a
+general purpose computer with one or more micro-controllers. See the
 [features document](https://www.klipper3d.org/Features.html) for more
-information on why you should use Klipper.
+information on why you should use the Klipper software.
 
-To begin using Klipper start by
-[installing](https://www.klipper3d.org/Installation.html) it.
+Start by [installing Klipper software](https://www.klipper3d.org/Installation.html).
 
-Klipper is Free Software. See the [license](COPYING) or read the
-[documentation](https://www.klipper3d.org/Overview.html). We depend on
-the generous support from our
+Klipper software is Free Software. See the [license](COPYING) or read
+the [documentation](https://www.klipper3d.org/Overview.html). We
+depend on the generous support from our
 [sponsors](https://www.klipper3d.org/Sponsors.html).

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

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

config/generic-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=PC6
+  PROBE_IN=PB0,PROBE_OUT=PB1,FIL_RUNOUT=PA4

config/generic-mellow-fly-e3-v2.cfg

@@ -0,0 +1,232 @@
+# 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

config/printer-geeetech-A10T-A20T-2021.cfg

@@ -0,0 +1,256 @@
+# 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

config/sample-duet3-1lc.cfg

@@ -77,5 +77,14 @@ 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

docs/API_Server.md

@@ -282,22 +282,6 @@ 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
@@ -380,35 +364,21 @@ and might later produce asynchronous messages such as:
 The "header" field in the initial query response is used to describe
 the fields found in later "data" responses.
 
-### hx71x/dump_hx71x
+### load_cell/dump_force
 
-This endpoint is used to subscribe to raw HX711 and HX717 ADC data.
-Obtaining these low-level ADC updates may be useful for diagnostic
-and debugging purposes. Using this endpoint may increase Klipper's
-system load.
+This endpoint is used to subscribe to force data produced by a load_cell.
+Using this endpoint may increase Klipper's system load.
 
 A request may look like:
-`{"id": 123, "method":"hx71x/dump_hx71x",
+`{"id": 123, "method":"load_cell/dump_force",
 "params": {"sensor": "load_cell", "response_template": {}}}`
 and might return:
-`{"id": 123,"result":{"header":["time","counts"]}}`
+`{"id": 123,"result":{"header":["time", "force (g)", "counts", "tare_counts"]}}`
 and might later produce asynchronous messages such as:
-`{"params":{"data":[[3292.432935, 562534], [3292.4394937, 5625322]]}}`
+`{"params":{"data":[[3292.432935, 40.65, 562534, -234467]]}}`
 
-### ads1220/dump_ads1220
-
-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]]}}`
+The "header" field in the initial query response is used to describe
+the fields found in later "data" responses.
 
 ### pause_resume/cancel
 

docs/Axis_Twist_Compensation.md

@@ -1,6 +1,6 @@
 # Axis Twist Compensation
 
-This document describes the [axis_twist_compensation] module.
+This document describes the `[axis_twist_compensation]` module.
 
 Some printers may have a small twist in their X rail which can skew the results
 of a probe attached to the X carriage.
@@ -24,27 +24,50 @@ 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.
 
-1. After setting up the [axis_twist_compensation] module,
-perform `AXIS_TWIST_COMPENSATION_CALIBRATE`
-* The calibration wizard will prompt you to measure the probe Z offset at a few
-points along the bed
-* The calibration defaults to 3 points but you can use the option
-`SAMPLE_COUNT=` to use a different number.
-2. [Adjust your Z offset](Probe_Calibrate.md#calibrating-probe-z-offset)
-3. Perform automatic/probe-based bed tramming operations, such as
-[Screws Tilt Adjust](G-Codes.md#screws_tilt_adjust),
-[Z Tilt Adjust](G-Codes.md#z_tilt_adjust) etc
-4. Home all axis, then perform a [Bed Mesh](Bed_Mesh.md) if required
-5. Perform a test print, followed by any
-[fine-tuning](Axis_Twist_Compensation.md#fine-tuning) as desired
+### Basic Usage: X-Axis Calibration
+1. After setting up the `[axis_twist_compensation]` module, run:
+```
+AXIS_TWIST_COMPENSATION_CALIBRATE
+```
+This command will calibrate the X-axis by default.
+  - The calibration wizard will prompt you to measure the probe Z offset at
+    several points along the bed.
+  - By default, the calibration uses 3 points, but you can specify a different
+    number with the option:
+``
+SAMPLE_COUNT=<value>
+``
+
+2. **Adjust Your Z Offset:**
+After completing the calibration, be sure to
+[adjust your Z offset](Probe_Calibrate.md#calibrating-probe-z-offset).
+
+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)

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#calibrating-a-z-endstop)
+[Z_ENDSTOP_CALIBRATE](./Manual_Level.md#calibrating-a-z-endstop)
 paper test is performed.  The bed_mesh module provides the
 `zero_reference_position` option for specifying this coordinate:
 

docs/Benchmarks.md

@@ -354,6 +354,26 @@ 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):
@@ -366,7 +386,7 @@ finalize_config crc=0
 
 ```
 
-The test was last run on commit `08d037c6` with gcc version
+The test was last run on commit `b7978d37` with gcc version
 `or1k-linux-musl-gcc (GCC) 9.2.0` on an Allwinner A64-H
 micro-controller.
 
@@ -375,9 +395,9 @@ micro-controller.
 | 1 stepper            | 85    |
 | 3 stepper            | 359   |
 
-### RP2040 step rate benchmark
+### RPxxxx step rate benchmark
 
-The following configuration sequence is used on the RP2040:
+The following configuration sequence is used on the RP2040 and RP2350:
 
 ```
 allocate_oids count=3
@@ -387,14 +407,25 @@ 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 `59314d99` with gcc version
-`arm-none-eabi-gcc (Fedora 10.2.0-4.fc34) 10.2.0` on a Raspberry Pi
-Pico board.
+The test was last run on commit `14c105b8` with gcc version
+`arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0` on Raspberry Pi
+Pico and Pico 2 boards.
 
-| rp2040               | ticks |
+| rp2040 (*)           | ticks |
 | -------------------- | ----- |
-| 1 stepper            | 5     |
-| 3 stepper            | 22    |
+| 1 stepper            | 3     |
+| 3 stepper            | 14    |
+
+| 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
 
@@ -456,7 +487,8 @@ 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)        | 873K | c5667193 | arm-none-eabi-gcc (Fedora 10.2.0-4.fc34) 10.2.0 |
+| rp2040 (USB)        | 885K | f6718291 | arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0 |
+| rp2350 (USB)        | 885K | f6718291 | arm-none-eabi-gcc (Fedora 14.1.0-1.fc40) 14.1.0 |
 
 ## Host Benchmarks
 

docs/CANBUS_Troubleshooting.md

@@ -37,20 +37,36 @@ hours or more frequently) then it is an indication of a severe
 problem.
 
 Incrementing `bytes_invalid` on a CAN bus connection is a symptom of
-reordered messages on the CAN bus. There are two known causes of
-reordered messages:
-1. Old versions of the popular candlight_firmware for USB CAN adapters
-   had a bug that could cause reordered messages. If using a USB CAN
-   adapter running this firmware then make sure to update to the
-   latest firmware if incrementing `bytes_invalid` is observed.
-2. Some Linux kernel builds for embedded devices have been known to
-   reorder CAN bus messages. It may be necessary to use an alternative
-   Linux kernel or to use alternative hardware that supports
-   mainstream Linux kernels that do not exhibit this problem.
+reordered messages on the CAN bus. If seen, make sure to:
+* Use a Linux kernel version 6.6.0 or later.
+* If using a USB-to-CANBUS adapter running candlelight firmware, use
+  v2.0 or later of candleLight_fw.
+* If using Klipper's USB-to-CANBUS bridge mode, make sure the bridge
+  node is flashed with Klipper v0.12.0 or later.
 
 Reordered messages is a severe problem that must be fixed. It will
 result in unstable behavior and can lead to confusing errors at any
-part of a print.
+part of a print. An incrementing `bytes_invalid` is not caused by
+wiring or similar hardware issues and can only be fixed by identifying
+and updating the faulty software.
+
+Older versions of the Linux kernel had a bug in the gs_usb canbus
+driver code that could cause reordered canbus packets.  The issue is
+thought to be fixed in
+[Linux commit 24bc41b4](https://github.com/torvalds/linux/commit/24bc41b4558347672a3db61009c339b1f5692169)
+which was released in v6.6.0. In some cases, older Linux versions may
+not show the problem (due to how hardware interrupts are configured),
+however if problems are seen the recommended solution is to upgrade to
+a newer kernel.
+
+Older versions of candlelight firmware could reorder canbus packets,
+and the issue is thought to be fixed in
+[candlelight_fw commit 8b3a7b45](https://github.com/candle-usb/candleLight_fw/commit/8b3a7b4565a3c9521b762b154c94c72c5acb2bcf).
+
+Older versions of Klipper's USB-to-CANBUS bridge code could
+incorrectly drop canbus messages. This is not as severe as reordering
+messages, but it should still be fixed. It is thought to be fixed with
+[Klipper PR #6175](https://github.com/Klipper3d/klipper/pull/6175).
 
 ## Use an appropriate txqueuelen setting
 

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()`, and `set_position()` methods. These
-   functions are typically used to provide kinematic specific checks.
-   However, at the start of development one can use boiler-plate code
-   here.
+   `get_steppers()`, `home()`, `clear_homing_state()`, and `set_position()`
+   methods. These functions are typically used to provide kinematic
+   specific checks. However, at the start of development one can use
+   boiler-plate code 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

docs/Config_Changes.md

@@ -8,6 +8,44 @@ 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

docs/Config_Reference.md

@@ -1669,14 +1669,34 @@ 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:
-#   The SPI enable pin for the sensor. This parameter must be provided.
+#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.
@@ -1686,6 +1706,46 @@ cs_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.
+```
+
+### [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.
 ```
@@ -1749,11 +1809,14 @@ 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: 75
+#accel_per_hz: 60
 #   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
@@ -1767,6 +1830,13 @@ 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
@@ -2014,6 +2084,9 @@ Support for eddy current inductive probes. One may define this section
 sensor_type: ldc1612
 #   The sensor chip used to perform eddy current measurements. This
 #   parameter must be provided and must be set to ldc1612.
+#frequency:
+#   The external crystal frequency (in Hz) of the LDC1612 chip.
+#   The default is 12000000.
 #intb_pin:
 #   MCU gpio pin connected to the ldc1612 sensor's INTB pin (if
 #   available). The default is to not use the INTB pin.
@@ -2042,9 +2115,9 @@ sensor_type: ldc1612
 
 ### [axis_twist_compensation]
 
-A tool to compensate for inaccurate probe readings due to twist in X gantry. See
-the [Axis Twist Compensation Guide](Axis_Twist_Compensation.md) for more
-detailed information regarding symptoms, configuration and setup.
+A tool to compensate for inaccurate probe readings due to twist in X or Y
+gantry. See the [Axis Twist Compensation Guide](Axis_Twist_Compensation.md)
+for more detailed information regarding symptoms, configuration and setup.
 
 ```
 [axis_twist_compensation]
@@ -2057,16 +2130,33 @@ 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. This parameter must be provided.
+#   calibration position.
 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. This parameter must be provided.
+#   calibration position.
 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 must be provided and is recommended to
+#   calibration process. This parameter 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
@@ -2458,6 +2548,10 @@ 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
@@ -3206,6 +3300,10 @@ pin:
 #   A list of G-Code commands to execute when the button is released.
 #   G-Code templates are supported. The default is to not run any
 #   commands on a button release.
+#debounce_delay:
+#   A period of time in seconds to debounce events prior to running the
+#   button gcode. If the button is pressed and released during this
+#   delay, the entire button press is ignored. Default is 0.
 ```
 
 ### [output_pin]
@@ -3384,8 +3482,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -3497,8 +3596,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #driver_MULTISTEP_FILT: True
 #driver_IHOLDDELAY: 8
 #driver_TPOWERDOWN: 20
@@ -3700,8 +3800,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -3774,6 +3875,7 @@ 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
@@ -3833,8 +3935,9 @@ run_current:
 #stealthchop_threshold: 0
 #   The velocity (in mm/s) to set the "stealthChop" threshold to. When
 #   set, "stealthChop" mode will be enabled if the stepper motor
-#   velocity is below this value. The default is 0, which disables
-#   "stealthChop" mode.
+#   velocity is below this value. Note that the "sensorless homing"
+#   code may temporarily override this setting during homing
+#   operations. The default is 0, which disables "stealthChop" mode.
 #coolstep_threshold:
 #   The velocity (in mm/s) to set the TMC driver internal "CoolStep"
 #   threshold to. If set, the coolstep feature will be enabled when
@@ -4077,15 +4180,16 @@ 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",
-#   "st7920", "emulated_st7920", "uc1701", "ssd1306", or "sh1106".
+#   "aip31068_spi", "st7920", "emulated_st7920", "uc1701", "ssd1306", or
+#   "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
-#   displays and _default_16x4 for other displays.
+#   for more information). The default is _default_20x4 for hd44780 or
+#   aip31068_spi 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
@@ -4211,6 +4315,31 @@ 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
@@ -4538,6 +4667,11 @@ more information.
 #   dispatch and execution of the runout_gcode. It may be useful to
 #   increase this delay if OctoPrint exhibits strange pause behavior.
 #   Default is 0.5 seconds.
+#debounce_delay:
+#   A period of time in seconds to debounce events prior to running the
+#   switch gcode. The switch must he held in a single state for at least
+#   this long to activate. If the switch is toggled on/off during this delay,
+#   the event is ignored. Default is 0.
 #switch_pin:
 #   The pin on which the switch is connected. This parameter must be
 #   provided.
@@ -4655,9 +4789,19 @@ 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.
 ```
 
-#### XH711
+#### HX711
 This is a 24 bit low sample rate chip using "bit-bang" communications. It is
 suitable for filament scales.
 ```
@@ -4725,13 +4869,30 @@ 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 chips c internal clock runs twice as fast and the SPI communication
+#   mode the chip's 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
@@ -4820,6 +4981,50 @@ 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
@@ -4901,7 +5106,7 @@ Octoprint as they will conflict, and 1 will fail to initialize
 properly likely aborting your print.
 
 If you use Octoprint and stream gcode over the serial port instead of
-printing from virtual_sd, then remo **M1** and **M0** from *Pausing commands*
+printing from virtual_sd, then remove **M1** and **M0** from *Pausing commands*
 in *Settings > Serial Connection > Firmware & protocol* will prevent
 the need to start print on the Palette 2 and unpausing in Octoprint
 for your print to begin.
@@ -4925,8 +5130,9 @@ serial:
 ### [angle]
 
 Magnetic hall angle sensor support for reading stepper motor angle
-shaft measurements using a1333, as5047d, or tle5012b SPI chips.  The
-measurements are available via the [API Server](API_Server.md) and
+shaft measurements using a1333, as5047d, mt6816, mt6826s,
+or tle5012b SPI chips.
+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.
 
@@ -4934,7 +5140,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", and "tle5012b". This parameter must be
+#   "a1333", "as5047d", "mt6816", "mt6826s", and "tle5012b". This parameter must be
 #   specified.
 #sample_period: 0.000400
 #   The query period (in seconds) to use during measurements. The
@@ -4997,8 +5203,9 @@ 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 support a rate of 400000
-via the `i2c_speed` parameter. All other Klipper micro-controllers use a
+"RP2040" micro-controller and ATmega AVR family and some STM32
+(F0, G0, G4, L4, F7, H7) support a rate of 400000 via the `i2c_speed` parameter.
+All other Klipper micro-controllers use a
 100000 rate and ignore the `i2c_speed` parameter.
 
 ```

docs/Contact.md

@@ -132,3 +132,10 @@ 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)

docs/Eddy_Probe.md

@@ -78,7 +78,9 @@ 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.
+steps outlined below.  If the printer to be calibrated is enclosed, it
+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]`

docs/Features.md

@@ -102,11 +102,13 @@ Klipper supports many standard 3d printer features:
   printers.
 
 * Automatic bed leveling support. Klipper can be configured for basic
-  bed tilt detection or full mesh bed leveling. If the bed uses
+  bed tilt detection or full mesh bed leveling. The bed mesh can be
+  customized to the print size (adaptive bed mesh). If the bed uses
   multiple Z steppers then Klipper can also level by independently
   manipulating the Z steppers. Most Z height probes are supported,
   including BL-Touch probes and servo activated probes. Probes may be
-  calibrated for axis twist compensation.
+  calibrated for axis twist compensation. If using an "eddy current
+  probe" then one can utilize fast bed mesh scanning,
 
 * Automatic delta calibration support. The calibration tool can
   perform basic height calibration as well as an enhanced X and Y
@@ -118,7 +120,7 @@ Klipper supports many standard 3d printer features:
 
 * Support for common temperature sensors (eg, common thermistors,
   AD595, AD597, AD849x, PT100, PT1000, MAX6675, MAX31855, MAX31856,
-  MAX31865, BME280, HTU21D, DS18B20, AHT10, and LM75). Custom
+  MAX31865, BME280, HTU21D, DS18B20, AHT10, SHT3x, and LM75). Custom
   thermistors and custom analog temperature sensors can also be
   configured. One can monitor the internal micro-controller
   temperature sensor and the internal temperature sensor of a
@@ -128,7 +130,8 @@ Klipper supports many standard 3d printer features:
 
 * Support for standard fans, nozzle fans, and temperature controlled
   fans. No need to keep fans running when the printer is idle. Fan
-  speed can be monitored on fans that have a tachometer.
+  speed can be monitored on fans that have a tachometer. One can
+  assign a "math formula" to a fan for automatic fan speed updating.
 
 * Support for run-time configuration of TMC2130, TMC2208/TMC2224,
   TMC2209, TMC2240, TMC2660, and TMC5160 stepper motor drivers. There
@@ -154,7 +157,7 @@ Klipper supports many standard 3d printer features:
   filament width sensors.
 
 * Support for measuring and recording acceleration using adxl345,
-  mpu9250, mpu6050, and lis2dw12 accelerometers.
+  mpu9250, mpu6050, lis2dw12, lis3dh, and icm20948 accelerometers.
 
 * Support for limiting the top speed of short "zigzag" moves to reduce
   printer vibration and noise. See the [kinematics](Kinematics.md)
@@ -184,12 +187,14 @@ 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

docs/G-Codes.md

@@ -127,6 +127,14 @@ 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
@@ -146,9 +154,13 @@ The following commands are available when the
 section](Config_Reference.md#axis_twist_compensation) is enabled.
 
 #### AXIS_TWIST_COMPENSATION_CALIBRATE
-`AXIS_TWIST_COMPENSATION_CALIBRATE [SAMPLE_COUNT=<value>]`: Initiates the X
-twist calibration wizard. `SAMPLE_COUNT` specifies the number of points along
-the X axis to calibrate at and defaults to 3.
+`AXIS_TWIST_COMPENSATION_CALIBRATE [AXIS=<X|Y>] [SAMPLE_COUNT=<value>]`
+
+Calibrates axis twist compensation by specifying the target axis or
+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]
 
@@ -476,6 +488,20 @@ 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
@@ -553,15 +579,51 @@ state; issue a G28 afterwards to reset the kinematics. This command is
 intended for low-level diagnostics and debugging.
 
 #### SET_KINEMATIC_POSITION
-`SET_KINEMATIC_POSITION [X=<value>] [Y=<value>] [Z=<value>]`: Force
-the low-level kinematic code to believe the toolhead is at the given
-cartesian position. This is a diagnostic and debugging command; use
-SET_GCODE_OFFSET and/or G92 for regular axis transformations. If an
-axis is not specified then it will default to the position that the
-head was last commanded to. Setting an incorrect or invalid position
-may lead to internal software errors. This command may invalidate
-future boundary checks; issue a G28 afterwards to reset the
-kinematics.
+
+`SET_KINEMATIC_POSITION [X=<value>] [Y=<value>] [Z=<value>]
+[SET_HOMED=<[X][Y][Z]>] [CLEAR_HOMED=<[X][Y][Z]>]`: Force the
+low-level kinematic code to believe the toolhead is at the given
+cartesian position and set/clear homed status. This is a diagnostic
+and debugging command; use SET_GCODE_OFFSET and/or G92 for regular
+axis transformations. Setting an incorrect or invalid position may
+lead to internal software errors.
+
+The `X`, `Y`, and `Z` parameters are used to alter the low-level
+kinematic position tracking. If any of these parameters are not set
+then the position is not changed - for example `SET_KINEMATIC_POSITION
+Z=10` would set all axes as homed, set the internal Z position to 10,
+and leave the X and Y positions unchanged. Changing the internal
+position tracking is not dependent on the internal homing state - one
+may alter the position for both homed and not homed axes, and
+similarly one may set or clear the homing state of an axis without
+altering its internal position.
+
+The `SET_HOMED` parameter defaults to `XYZ` which instructs the
+kinematics to consider all axes as homed. A bare
+`SET_KINEMATIC_POSITION` command will result in all axes being
+considered homed (and not change its current position). If it is not
+desired to change the state of homed axes then assign `SET_HOMED` to
+an empty string - for example:
+`SET_KINEMATIC_POSITION SET_HOMED= X=10`. It is also possible to
+request an individual axis be considered homed (eg, `SET_HOMED=X`),
+but note that non-cartesian style kinematics (such as delta
+kinematics) may not support setting an individual axis as homed.
+
+The `CLEAR_HOMED` parameter instructs the kinematics to consider the
+given axes as not homed. For example, `CLEAR_HOMED=XYZ` would request
+all axes to be considered not homed (and thus require homing prior to
+movement on those axes). The default is `SET_HOMED=XYZ` even if
+`CLEAR_HOMED` is present, so the command `SET_KINEMATIC_POSITION
+CLEAR_HOMED=Z` will set X and Y as homed and clear the homing state
+for Z.  Use `SET_KINEMATIC_POSITION SET_HOMED= CLEAR_HOMED=Z` if the
+goal is to clear only the Z homing state. If an axis is specified in
+neither `SET_HOMED` nor `CLEAR_HOMED` then its homing state is not
+changed and if it is specified in both then `CLEAR_HOMED` has
+precedence. It is possible to request clearing of an individual axis,
+but on non-cartesian style kinematics (such as delta kinematics) doing
+so may result in clearing the homing state of additional axes. Note
+the `CLEAR` parameter is currently an alias for the `CLEAR_HOMED`
+parameter, but this alias will be removed in the future.
 
 ### [gcode]
 
@@ -731,6 +793,82 @@ 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.
@@ -801,49 +939,6 @@ be between 0.0 and 1.0, unless a 'scale' is defined in the config.
 When 'scale' is defined, then this value should be  between 0.0 and
 'scale'.
 
-### [led]
-
-The following command is available when any of the
-[led config sections](Config_Reference.md#leds) are enabled.
-
-#### SET_LED
-`SET_LED LED=<config_name> RED=<value> GREEN=<value> BLUE=<value>
-WHITE=<value> [INDEX=<index>] [TRANSMIT=0] [SYNC=1]`: This sets the
-LED output. Each color `<value>` must be between 0.0 and 1.0. The
-WHITE option is only valid on RGBW LEDs. If the LED supports multiple
-chips in a daisy-chain then one may specify INDEX to alter the color
-of just the given chip (1 for the first chip, 2 for the second,
-etc.). If INDEX is not provided then all LEDs in the daisy-chain will
-be set to the provided color. If TRANSMIT=0 is specified then the
-color change will only be made on the next SET_LED command that does
-not specify TRANSMIT=0; this may be useful in combination with the
-INDEX parameter to batch multiple updates in a daisy-chain. By
-default, the SET_LED command will sync it's changes with other ongoing
-gcode commands.  This can lead to undesirable behavior if LEDs are
-being set while the printer is not printing as it will reset the idle
-timeout. If careful timing is not needed, the optional SYNC=0
-parameter can be specified to apply the changes without resetting the
-idle timeout.
-
-#### SET_LED_TEMPLATE
-`SET_LED_TEMPLATE LED=<led_name> TEMPLATE=<template_name>
-[<param_x>=<literal>] [INDEX=<index>]`: Assign a
-[display_template](Config_Reference.md#display_template) to a given
-[LED](Config_Reference.md#leds). For example, if one defined a
-`[display_template my_led_template]` config section then one could
-assign `TEMPLATE=my_led_template` here. The display_template should
-produce a comma separated string containing four floating point
-numbers corresponding to red, green, blue, and white color settings.
-The template will be continuously evaluated and the LED will be
-automatically set to the resulting colors. One may set
-display_template parameters to use during template evaluation
-(parameters will be parsed as Python literals). If INDEX is not
-specified then all chips in the LED's daisy-chain will be set to the
-template, otherwise only the chip with the given index will be
-updated. If TEMPLATE is an empty string then this command will clear
-any previous template assigned to the LED (one can then use `SET_LED`
-commands to manage the LED's color settings).
-
 ### [output_pin]
 
 The following command is available when an
@@ -857,6 +952,20 @@ 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
@@ -892,20 +1001,6 @@ Palette 2 once the loading has been completed. This command is the
 same as pressing **Smart Load** directly on the Palette 2 screen after
 the filament load is complete.
 
-### [pid_calibrate]
-
-The pid_calibrate module is automatically loaded if a heater is defined
-in the config file.
-
-#### PID_CALIBRATE
-`PID_CALIBRATE HEATER=<config_name> TARGET=<temperature>
-[WRITE_FILE=1]`: Perform a PID calibration test. The specified heater
-will be enabled until the specified target temperature is reached, and
-then the heater will be turned off and on for several cycles. If the
-WRITE_FILE parameter is enabled, then the file /tmp/heattest.txt will
-be created with a log of all temperature samples taken during the
-test.
-
 ### [pause_resume]
 
 The following commands are available when the
@@ -931,6 +1026,20 @@ the paused state is fresh for each print.
 #### CANCEL_PRINT
 `CANCEL_PRINT`: Cancels the current print.
 
+### [pid_calibrate]
+
+The pid_calibrate module is automatically loaded if a heater is defined
+in the config file.
+
+#### PID_CALIBRATE
+`PID_CALIBRATE HEATER=<config_name> TARGET=<temperature>
+[WRITE_FILE=1]`: Perform a PID calibration test. The specified heater
+will be enabled until the specified target temperature is reached, and
+then the heater will be turned off and on for several cycles. If the
+WRITE_FILE parameter is enabled, then the file /tmp/heattest.txt will
+be created with a log of all temperature samples taken during the
+test.
+
 ### [print_stats]
 
 The print_stats module is automatically loaded.
@@ -1021,6 +1130,21 @@ 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.
@@ -1056,20 +1180,19 @@ 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>]
-[HZ_PER_SEC=<hz_per_sec>] [CHIPS=<adxl345_chip_name>]
-[POINT=x,y,z] [INPUT_SHAPING=[<0:1>]]`: Runs the resonance
+[ACCEL_PER_HZ=<accel_per_hz>] [HZ_PER_SEC=<hz_per_sec>] [CHIPS=<chip_name>]
+[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. `adxl345_chip_name` can be one or
-more configured adxl345 chip,delimited with comma, for example
-`CHIPS="adxl345, adxl345 rpi"`. Note that `adxl345` can be omitted from
-named adxl345 chips. If POINT is specified it will override the point(s)
+and `AXIS=-dx,-dy` is equivalent. `chip_name` can be one or
+more configured accel chips, delimited with comma, for example
+`CHIPS="adxl345, adxl345 rpi"`. 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
@@ -1086,8 +1209,9 @@ 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>] [HZ_PER_SEC=<hz_per_sec>] [CHIPS=<adxl345_chip_name>]
-[MAX_SMOOTHING=<max_smoothing>]`: Similarly to `TEST_RESONANCES`, runs
+[FREQ_END=<max_freq>] [ACCEL_PER_HZ=<accel_per_hz>][HZ_PER_SEC=<hz_per_sec>]
+[CHIPS=<chip_name>] [MAX_SMOOTHING=<max_smoothing>] [INPUT_SHAPING=<0:1>]`:
+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
@@ -1137,8 +1261,9 @@ has been enabled.
 
 #### SAVE_VARIABLE
 `SAVE_VARIABLE VARIABLE=<name> VALUE=<value>`: Saves the variable to
-disk so that it can be used across restarts. All stored variables are
-loaded into the `printer.save_variables.variables` dict at startup and
+disk so that it can be used across restarts. The VARIABLE must be lowercase.
+All stored variables are loaded into the
+`printer.save_variables.variables` dict at startup and
 can be used in gcode macros. The provided VALUE is parsed as a Python
 literal.
 
@@ -1282,6 +1407,42 @@ temperature_fan. If a target is not supplied, it is set to the
 specified temperature in the config file. If speeds are not supplied,
 no change is applied.
 
+### [temperature_probe]
+
+The following commands are available when a
+[temperature_probe config section](Config_Reference.md#temperature_probe)
+is enabled.
+
+#### TEMPERATURE_PROBE_CALIBRATE
+`TEMPERATURE_PROBE_CALIBRATE [PROBE=<probe name>] [TARGET=<value>] [STEP=<value>]`:
+Initiates probe drift calibration for eddy current based probes.  The `TARGET`
+is a target temperature for the last sample.  When the temperature recorded
+during a sample exceeds the `TARGET` calibration will complete.  The `STEP`
+parameter sets temperature delta (in C) between samples. After a sample has
+been taken, this delta is used to schedule a call to `TEMPERATURE_PROBE_NEXT`.
+The default `STEP` is 2.
+
+#### TEMPERATURE_PROBE_NEXT
+`TEMPERATURE_PROBE_NEXT`: After calibration has started this command is run to
+take the next sample.  It is automatically scheduled to run when the delta
+specified by `STEP` has been reached, however its also possible to manually run
+this command to force a new sample.  This command is only available during
+calibration.
+
+#### TEMPERATURE_PROBE_COMPLETE:
+`TEMPERATURE_PROBE_COMPLETE`:  Can be used to end calibration and save the
+current result before the `TARGET` temperature is reached.  This command
+is only available during calibration.
+
+#### ABORT
+`ABORT`:  Aborts the calibration process, discarding the current results.
+This command is only available during drift calibration.
+
+### TEMPERATURE_PROBE_ENABLE
+`TEMPERATURE_PROBE_ENABLE ENABLE=[0|1]`: Sets temperature drift
+compensation on or off. If ENABLE is set to 0, drift compensation
+will be disabled, if set to 1 it is enabled.
+
 ### [tmcXXXX]
 
 The following commands are available when any of the
@@ -1410,44 +1571,10 @@ The following commands are available when the
 [z_tilt config section](Config_Reference.md#z_tilt) is enabled.
 
 #### Z_TILT_ADJUST
-`Z_TILT_ADJUST [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 `HORIZONTAL_MOVE_Z`
-value overrides the `horizontal_move_z` option 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.
+`Z_TILT_ADJUST [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.

docs/Installation.md

@@ -1,15 +1,20 @@
 # Installation
 
-These instructions assume the software will run on a Raspberry Pi
-computer in conjunction with OctoPrint. It is recommended that a
-Raspberry Pi 2 (or later) be used as the host machine (see the
+These instructions assume the software will run on a Linux-based host
+running a Klipper-compatible front end. It is recommended that a
+SBC(Small Board Computer) such as a Raspberry Pi or Debian-based Linux
+device be used as the host machine (see the
 [FAQ](FAQ.md#can-i-run-klipper-on-something-other-than-a-raspberry-pi-3)
-for other machines).
+for other options).
+
+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"
-that will be stored on the Raspberry Pi. An appropriate configuration
+printer.cfg, that will be stored on the host. 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
@@ -35,38 +40,51 @@ printer configuration file, then start with the closest example
 [config file](../config/) and use the Klipper
 [config reference](Config_Reference.md) for further information.
 
-## Prepping an OS image
+## Interacting with Klipper
 
-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 to v1.4.2 or later.
+Klipper is a 3d printer firmware, so it needs some way for the user to
+interact with it.
 
-After installing OctoPi and upgrading OctoPrint, it will be necessary
-to ssh into the target machine to run a handful of system commands. If
-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:
+Currently the best choices are front ends that retrieve information through
+the [Moonraker web API](https://moonraker.readthedocs.io/) and there is also
+the option to use [Octoprint](https://octoprint.org/) to control Klipper.
 
-```
-git clone https://github.com/Klipper3d/klipper
-./klipper/scripts/install-octopi.sh
-```
+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
+make an informed decision.
 
-The above will download Klipper, install some 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.
+## Obtaining an OS image for SBC's
+
+There are many ways to obtain an OS image for Klipper for SBC use, most depend on
+what front end you wish to use. Some manufacturers of these SBC boards also provide
+their own Klipper-centric images.
+
+The two main Moonraker-based front ends are [Fluidd](https://docs.fluidd.xyz/)
+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 the Raspberry Pi:
+on your host device:
 
 ```
 cd ~/klipper/
@@ -88,7 +106,7 @@ make
 If the comments at the top of the
 [printer configuration file](#obtain-a-klipper-configuration-file)
 describe custom steps for "flashing" the final image to the printer
-control board then follow those steps and then proceed to
+control board, then follow those steps and then proceed to
 [configuring OctoPrint](#configuring-octoprint-to-use-klipper).
 
 Otherwise, the following steps are often used to "flash" the printer
@@ -108,10 +126,21 @@ 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 (see the
+choose the line corresponding to the micro-controller. If many
+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, the code can be flashed with something
+For common micro-controllers with STM32 or clone chips, LPC chips and
+others, it is usual that these need an initial Klipper flash via SD card.
+
+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:
 
 ```
@@ -123,53 +152,38 @@ sudo service klipper start
 Be sure to update the FLASH_DEVICE with the printer's unique serial
 port name.
 
-When flashing for the first time, make sure that OctoPrint is not
-connected directly to the printer (from the OctoPrint web page, under
-the "Connection" section, click "Disconnect").
+For common micro-controllers using RP2040 chips, the code can be flashed
+with something similar to:
 
-## Configuring OctoPrint to use Klipper
+```
+sudo service klipper stop
+make flash FLASH_DEVICE=first
+sudo service klipper start
+```
 
-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:
+It is important to note that RP2040 chips may need to be put into Boot mode
+before this operation.
 
-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 Raspberry Pi.
+the host.
 
-Arguably the easiest way to set the Klipper configuration file is to
-use a desktop editor that supports editing files over the "scp" and/or
-"sftp" protocols. There are freely available tools 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`).
+Arguably the easiest way to set the Klipper configuration file is using the
+built-in editors in Mainsail or Fluidd. These will allow the user to open
+the configuration examples and save them to be printer.cfg.
+
+Another option is to use a desktop editor that supports editing files
+over the "scp" and/or "sftp" protocols. There are freely available tools
+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
-Raspberry Pi via ssh. That may look something like the following (be
+host via SSH. That may look something like the following (be
 sure to update the command to use the appropriate printer config
 filename):
 
@@ -200,9 +214,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
-"restart" command in the OctoPrint web terminal to load the config. A
-"status" command will report the printer is ready if the Klipper
+After creating and editing the file, it will be necessary to issue a
+"restart" command in the command console to load the config. A
+"status" command will report that the printer is ready if the Klipper
 config file is successfully read and the micro-controller is
 successfully found and configured.
 
@@ -211,10 +225,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 OctoPrint terminal tab. The
-"status" command can be used to re-report error messages. The default
-Klipper startup script also places a log in **/tmp/klippy.log** which
-provides more detailed information.
+Klipper reports error messages via the command console and pop-ups in
+Fluidd and Mainsail. The "status" command can be used to re-report error
+messages. A log is available and usually located at
+`~/printer_data/logs/klippy.log`.
 
 After Klipper reports that the printer is ready, proceed to the
 [config check document](Config_checks.md) to perform some basic checks

docs/Load_Cell.md

@@ -0,0 +1,122 @@
+# 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 %}
+```

docs/Measuring_Resonances.md

@@ -1,24 +1,26 @@
 # Measuring Resonances
 
-Klipper has built-in support for the ADXL345, MPU-9250 and LIS2DW compatible
+Klipper has built-in support for the ADXL345, MPU-9250, LIS2DW and LIS3DH 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/LIS2DW can be connected to the SPI interface
+soldering and crimping. The ADXL345 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.
+interface of an MCU board that supports 400kbit/s *fast mode* in Klipper. The
+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/LIS2DWs, make sure that the board supports SPI mode (a small number of
+For ADXL345s, make sure that the board supports SPI mode (a small number of
 boards appear to be hard-configured for I2C by pulling SDO to GND).
 
-For MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500s there are also a variety of
-board designs and clones with different I2C pull-up resistors which will need
-supplementing.
+For MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500/ICM20948s and LIS2DW/LIS3DH there
+are also a variety of board designs and clones with different I2C pull-up resistors
+which will need supplementing.
 
 ## MCUs with Klipper I2C *fast-mode* Support
 
@@ -27,6 +29,7 @@ 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
 
@@ -133,7 +136,7 @@ GND+SCL
 
 Note that unlike a cable shield, any GND(s) should be connected at both ends.
 
-#### MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500
+#### MPU-9250/MPU-9255/MPU-6515/MPU-6050/MPU-6500/ICM20948
 
 These accelerometers have been tested to work over I2C on the RPi, RP2040 (Pico)
 and AVR at 400kbit/s (*fast mode*). Some MPU accelerometer modules include
@@ -212,12 +215,20 @@ 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
+~/klippy-env/bin/pip install -v "numpy<1.26"
 ```
 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.
+the installation may fail and you will need to enable swap. Also note
+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
 
@@ -305,7 +316,7 @@ you'll also want to modify your `printer.cfg` file to include this:
 
 Restart Klipper via the `RESTART` command.
 
-#### Configure LIS2DW series
+#### Configure LIS2DW series over SPI
 
 ```
 [mcu lis]
@@ -344,6 +355,7 @@ accel_chip: mpu9250
 probe_points:
     100, 100, 20  # an example
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 #### Configure MPU-9520 Compatibles With Pico
 
@@ -366,6 +378,7 @@ probe_points:
 [static_digital_output pico_3V3pwm] # Improve power stability
 pins: pico:gpio23
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 #### Configure MPU-9520 Compatibles with AVR
 
@@ -384,6 +397,7 @@ accel_chip: mpu9250
 probe_points:
     100, 100, 20  # an example
 ```
+If you are using the ICM20948, replace instances of "mpu9250" with "icm20948".
 
 Restart Klipper via the `RESTART` command.
 
@@ -683,6 +697,24 @@ 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

docs/OctoPrint.md

@@ -0,0 +1,79 @@
+# 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

docs/Overview.md

@@ -17,6 +17,7 @@ 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
@@ -100,3 +101,4 @@ communication with the Klipper developers.
 - [TSL1401CL filament width sensor](TSL1401CL_Filament_Width_Sensor.md)
 - [Hall filament width sensor](Hall_Filament_Width_Sensor.md)
 - [Eddy Current Inductive probe](Eddy_Probe.md)
+- [Load Cells](Load_Cell.md)

docs/Pressure_Advance.md

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

docs/Releases.md

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

docs/Sponsors.md

@@ -17,7 +17,6 @@ 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
 

docs/Status_Reference.md

@@ -31,7 +31,7 @@ The following information is available in the
 ## bed_screws
 
 The following information is available in the
-`Config_Reference.md#bed_screws` object:
+[bed_screws](Config_Reference.md#bed_screws) object:
 - `is_active`: Returns True if the bed screws adjustment tool is currently
 active.
 - `state`: The bed screws adjustment tool state. It is one of
@@ -39,6 +39,27 @@ the following strings: "adjust", "fine".
 - `current_screw`: The index for the current screw being adjusted.
 - `accepted_screws`: The number of accepted screws.
 
+## canbus_stats
+
+The following information is available in the `canbus_stats
+some_mcu_name` object (this object is automatically available if an
+mcu is configured to use canbus):
+- `rx_error`: The number of receive errors detected by the
+  micro-controller canbus hardware.
+- `tx_error`: The number of transmit errors detected by the
+  micro-controller canbus hardware.
+- `tx_retries`: The number of transmit attempts that were retried due
+  to bus contention or errors.
+- `bus_state`: The status of the interface (typically "active" for a
+  bus in normal operation, "warn" for a bus with recent errors,
+  "passive" for a bus that will no longer transmit canbus error
+  frames, or "off" for a bus that will no longer transmit or receive
+  messages).
+
+Note that only the rp2XXX micro-controllers report a non-zero
+`tx_retries` field and the rp2XXX micro-controllers always report
+`tx_error` as zero and `bus_state` as "active".
+
 ## configfile
 
 The following information is available in the `configfile` object
@@ -256,11 +277,6 @@ 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
 
@@ -287,6 +303,17 @@ 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
@@ -431,6 +458,12 @@ The following information is available in
 - `printer["servo <config_name>"].value`: The last setting of the PWM
   pin (a value between 0.0 and 1.0) associated with the servo.
 
+## skew_correction.py
+
+The following information is available in the `skew_correction` object (this
+object is available if any skew_correction is defined):
+- `current_profile_name`: Returns the name of the currently loaded SKEW_PROFILE.
+
 ## stepper_enable
 
 The following information is available in the `stepper_enable` object (this

docs/TMC_Drivers.md

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

docs/_klipper3d/README

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

docs/_klipper3d/mkdocs-requirements.txt

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

docs/_klipper3d/mkdocs.yml

@@ -88,7 +88,9 @@ nav:
   - Config_Changes.md
   - Contact.md
   - Installation and Configuration:
-    - Installation.md
+    - Installation:
+      - Installation.md
+      - OctoPrint.md
     - Configuration Reference:
       - Config_Reference.md
       - Rotation_Distance.md
@@ -139,4 +141,5 @@ nav:
     - TSL1401CL_Filament_Width_Sensor.md
     - Hall_Filament_Width_Sensor.md
     - Eddy_Probe.md
+    - Load_Cell.md
   - Sponsors.md

docs/index.md

@@ -6,13 +6,16 @@ title: Welcome
 
 ![](img/klipper-logo.png){ .center-image }
 
-Klipper is a 3d-Printer firmware. It combines the power of a general
-purpose computer with one or more micro-controllers. See the
-[features](Features.md) document for more information on why you
-should use Klipper.
+The Klipper firmware controls 3d-Printers. It combines the power of a
+general purpose computer with one or more micro-controllers. See the
+[features document](https://www.klipper3d.org/Features.html) for more
+information on why you should use the Klipper software.
 
-To begin using Klipper start by [installing](Installation.md) it.
+Start by [installing Klipper software](https://www.klipper3d.org/Installation.html).
 
-Klipper is Free Software. Read the [documentation](Overview.md) or
-view [the Klipper code on github](https://github.com/Klipper3d/klipper).
-We depend on the generous support from our [sponsors](Sponsors.md).
+Klipper software is Free Software. Read the
+[documentation](https://www.klipper3d.org/Overview.html), see the
+[license](COPYING), or
+[download](https://github.com/Klipper3d/Klipper) the software. We
+depend on the generous support from our
+[sponsors](https://www.klipper3d.org/Sponsors.html).

klippy/chelper/kin_shaper.c

@@ -156,6 +156,16 @@ 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)
@@ -174,6 +184,9 @@ 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;
 }
 

klippy/configfile.py

@@ -1,12 +1,17 @@
 # Code for reading and writing the Klipper config file
 #
-# Copyright (C) 2016-2021  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 sys, os, glob, re, time, logging, configparser, io
 
 error = configparser.Error
 
+
+######################################################################
+# Config section parsing helper
+######################################################################
+
 class sentinel:
     pass
 
@@ -134,30 +139,13 @@ 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:
-    def __init__(self, printer):
-        self.printer = printer
-        self.autosave = None
-        self.deprecated = {}
-        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):
+######################################################################
+# Config file parsing (with include file support)
+######################################################################
+
+class ConfigFileReader:
+    def read_config_file(self, filename):
         try:
             f = open(filename, 'r')
             data = f.read()
@@ -167,6 +155,102 @@ class PrinterConfig:
             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 = ""
@@ -175,7 +259,7 @@ class PrinterConfig:
             regular_data = data[:pos]
             autosave_data = data[pos + len(AUTOSAVE_HEADER):].strip()
         # Check for errors and strip line prefixes
-        if "\n#*# " in regular_data:
+        if "\n#*# " in regular_data or autosave_data.find(AUTOSAVE_HEADER) >= 0:
             logging.warning("Can't read autosave from config file"
                             " - autosave state corrupted")
             return data, ""
@@ -192,7 +276,7 @@ class PrinterConfig:
         return regular_data, "\n".join(out)
     comment_r = re.compile('[#;].*$')
     value_r = re.compile('[^A-Za-z0-9_].*$')
-    def _strip_duplicates(self, data, config):
+    def _strip_duplicates(self, data, fileconfig):
         # Comment out fields in 'data' that are defined in 'config'
         lines = data.split('\n')
         section = None
@@ -210,152 +294,31 @@ class PrinterConfig:
                 section = pruned_line[1:-1].strip()
                 continue
             field = self.value_r.sub('', pruned_line)
-            if config.fileconfig.has_option(section, field):
+            if fileconfig.has_option(section, field):
                 is_dup_field = True
                 lines[lineno] = '#' + lines[lineno]
         return "\n".join(lines)
-    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):
+    def load_main_config(self):
         filename = self.printer.get_start_args()['config_file']
-        data = self._read_config_file(filename)
+        cfgrdr = ConfigFileReader()
+        data = cfgrdr.read_config_file(filename)
         regular_data, autosave_data = self._find_autosave_data(data)
-        regular_config = self._build_config_wrapper(regular_data, filename)
-        autosave_data = self._strip_duplicates(autosave_data, regular_config)
-        self.autosave = self._build_config_wrapper(autosave_data, filename)
-        cfg = self._build_config_wrapper(regular_data + autosave_data, filename)
-        return cfg
-    def check_unused_options(self, config):
-        fileconfig = config.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
+        regular_fileconfig = cfgrdr.build_fileconfig_with_includes(
+            regular_data, filename)
+        autosave_data = self._strip_duplicates(autosave_data,
+                                               regular_fileconfig)
+        self.fileconfig = cfgrdr.build_fileconfig(autosave_data, filename)
+        cfgrdr.append_fileconfig(regular_fileconfig,
+                                 autosave_data, '*AUTOSAVE*')
+        return regular_fileconfig, self.fileconfig
     def get_status(self, eventtime):
-        return {'config': self.status_raw_config,
-                'settings': self.status_settings,
-                'warnings': self.status_warnings,
-                'save_config_pending': self.save_config_pending,
+        return {'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.autosave.fileconfig.has_section(section):
-            self.autosave.fileconfig.add_section(section)
+        if not self.fileconfig.has_section(section):
+            self.fileconfig.add_section(section)
         svalue = str(value)
-        self.autosave.fileconfig.set(section, option, svalue)
+        self.fileconfig.set(section, option, svalue)
         pending = dict(self.status_save_pending)
         if not section in pending or pending[section] is None:
             pending[section] = {}
@@ -366,8 +329,8 @@ class PrinterConfig:
         self.save_config_pending = True
         logging.info("save_config: set [%s] %s = %s", section, option, svalue)
     def remove_section(self, section):
-        if self.autosave.fileconfig.has_section(section):
-            self.autosave.fileconfig.remove_section(section)
+        if self.fileconfig.has_section(section):
+            self.fileconfig.remove_section(section)
             pending = dict(self.status_save_pending)
             pending[section] = None
             self.status_save_pending = pending
@@ -378,21 +341,20 @@ class PrinterConfig:
             del pending[section]
             self.status_save_pending = pending
             self.save_config_pending = True
-    def _disallow_include_conflicts(self, regular_data, cfgname, gcode):
-        config = self._build_config_wrapper(regular_data, cfgname)
-        for section in self.autosave.fileconfig.sections():
-            for option in self.autosave.fileconfig.options(section):
-                if config.fileconfig.has_option(section, option):
+    def _disallow_include_conflicts(self, regular_fileconfig):
+        for section in self.fileconfig.sections():
+            for option in self.fileconfig.options(section):
+                if regular_fileconfig.has_option(section, option):
                     msg = ("SAVE_CONFIG section '%s' option '%s' conflicts "
                            "with included value" % (section, option))
-                    raise gcode.error(msg)
+                    raise self.printer.command_error(msg)
     cmd_SAVE_CONFIG_help = "Overwrite config file and restart"
     def cmd_SAVE_CONFIG(self, gcmd):
-        if not self.autosave.fileconfig.sections():
+        if not self.fileconfig.sections():
             return
-        gcode = self.printer.lookup_object('gcode')
         # Create string containing autosave data
-        autosave_data = self._build_config_string(self.autosave)
+        cfgrdr = ConfigFileReader()
+        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())
@@ -401,16 +363,27 @@ class PrinterConfig:
         # Read in and validate current config file
         cfgname = self.printer.get_start_args()['config_file']
         try:
-            data = self._read_config_file(cfgname)
-            regular_data, old_autosave_data = self._find_autosave_data(data)
-            config = self._build_config_wrapper(regular_data, cfgname)
+            data = cfgrdr.read_config_file(cfgname)
+        except error as e:
+            msg = "Unable to read existing config on SAVE_CONFIG"
+            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 gcode.error(msg)
-        regular_data = self._strip_duplicates(regular_data, self.autosave)
-        self._disallow_include_conflicts(regular_data, cfgname, gcode)
-        data = regular_data.rstrip() + autosave_data
+            raise gcmd.error(msg)
+        self._disallow_include_conflicts(regular_fileconfig)
         # Determine filenames
         datestr = time.strftime("-%Y%m%d_%H%M%S")
         backup_name = cfgname + datestr
@@ -430,6 +403,135 @@ class PrinterConfig:
         except:
             msg = "Unable to write config file during SAVE_CONFIG"
             logging.exception(msg)
-            raise gcode.error(msg)
+            raise gcmd.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)

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,8 +42,35 @@ 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('sps', self.sps_options, default='660')
+        self.sps = config.getchoice('sample_rate', self.sps_options,
+                                    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)
@@ -68,10 +95,6 @@ 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"
@@ -157,8 +180,10 @@ 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.gain << 1),
-                      (data_rate << 5) | (mode << 3) | (continuous << 2)]
+        reg_values = [(self.mux << 4) | (self.gain << 1) | int(self.pga_bypass),
+                      (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)
@@ -177,7 +202,7 @@ class ADS1220():
         write_command.extend(register_bytes)
         self.spi.spi_send(write_command)
         stored_val = self.read_reg(reg, len(register_bytes))
-        if register_bytes != stored_val:
+        if bytearray(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)" % (

klippy/extras/ads1x1x.py

@@ -0,0 +1,393 @@
+# 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)

klippy/extras/adxl345.py

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

klippy/extras/angle.py

@@ -411,6 +411,196 @@ 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
 
@@ -427,8 +617,11 @@ class Angle:
         self.start_clock = self.time_shift = self.sample_ticks = 0
         self.last_sequence = self.last_angle = 0
         # Sensor type
-        sensors = { "a1333": HelperA1333, "as5047d": HelperAS5047D,
-                    "tle5012b": HelperTLE5012B }
+        sensors = { "a1333": HelperA1333,
+                    "as5047d": HelperAS5047D,
+                    "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,

klippy/extras/axis_twist_compensation.py

@@ -23,18 +23,27 @@ 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_end_x = config.getfloat('calibrate_end_x')
-        self.calibrate_y = config.getfloat('calibrate_y')
+        self.calibrate_start_x = config.getfloat('calibrate_start_x',
+                                                default=None)
+        self.calibrate_end_x = config.getfloat('calibrate_end_x', default=None)
+        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_start_y',
+        self.compensation_end_x = config.getfloat('compensation_end_x',
                                                   default=None)
 
-        self.m = None
-        self.b = None
+        self.calibrate_start_y = config.getfloat('calibrate_start_y',
+                                                  default=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)
@@ -43,28 +52,46 @@ class AxisTwistCompensation:
                                             self._update_z_compensation_value)
 
     def _update_z_compensation_value(self, pos):
-        if not self.z_compensations:
-            return
+        if self.z_compensations:
+            pos[2] += self._get_interpolated_z_compensation(
+                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 = ((self.calibrate_end_x - self.calibrate_start_x)
+        spacing = ((comp_end - comp_start)
                    / (sample_count - 1))
-        interpolate_t = (x_coord - self.calibrate_start_x) / spacing
+        interpolate_t = (coord - comp_start) / 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])
-        pos[2] += interpolated_z_compensation
-
-    def clear_compensations(self):
-        self.z_compensations = []
-        self.m = None
-        self.b = None
+        return interpolated_z_compensation
 
+    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):
@@ -80,10 +107,14 @@ class Calibrater:
                                             self._handle_connect)
         self.speed = compensation.speed
         self.horizontal_move_z = compensation.horizontal_move_z
-        self.start_point = (compensation.calibrate_start_x,
+        self.x_start_point = (compensation.calibrate_start_x,
                             compensation.calibrate_y)
-        self.end_point = (compensation.calibrate_end_x,
+        self.x_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
@@ -94,9 +125,8 @@ class Calibrater:
 
     def _handle_connect(self):
         self.probe = self.printer.lookup_object('probe', None)
-        if (self.probe is None):
-            config = self.printer.lookup_object('configfile')
-            raise config.error(
+        if self.probe is None:
+            raise self.printer.config_error(
                 "AXIS_TWIST_COMPENSATION requires [probe] to be defined")
         self.lift_speed = self.probe.get_probe_params()['lift_speed']
         self.probe_x_offset, self.probe_y_offset, _ = \
@@ -119,20 +149,75 @@ 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 is None or sample_count < 2:
+        if sample_count < 2:
             raise self.gcmd.error(
                 "SAMPLE_COUNT to probe must be at least 2")
 
-        # clear the current config
-        self.compensation.clear_compensations()
+        # calculate the points to put the probe at, returned as a list of tuples
+        nozzle_points = []
+
+        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)
 
@@ -142,17 +227,9 @@ 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
@@ -238,14 +315,31 @@ 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)
-        configfile.set(self.configname, 'compensation_start_x',
-                       self.start_point[0])
-        configfile.set(self.configname, 'compensation_end_x',
-                       self.end_point[0])
-        self.compensation.z_compensations = self.results
-        self.compensation.compensation_start_x = self.start_point[0]
-        self.compensation.compensation_end_x = self.end_point[0]
+
+        if(self.current_axis == 'X'):
+
+            configfile.set(self.configname, 'z_compensations', values_as_str)
+            configfile.set(self.configname, 'compensation_start_x',
+                        self.x_start_point[0])
+            configfile.set(self.configname, 'compensation_end_x',
+                        self.x_end_point[0])
+
+            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 "

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)
+        self.bmc.print_generated_points(logging.info, truncate=True)
     def set_mesh(self, mesh):
         if mesh is not None and self.fade_end != self.FADE_DISABLE:
             self.log_fade_complete = True
@@ -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):
+    def print_generated_points(self, print_func, truncate=False):
         x_offset = y_offset = 0.
         probe = self.printer.lookup_object('probe', None)
         if probe is not None:
@@ -355,6 +355,10 @@ class BedMeshCalibrate:
                    " |  Tool Adjusted  |   Probe")
         points = self.probe_mgr.get_base_points()
         for i, (x, y) in enumerate(points):
+            if i >= 50 and truncate:
+                end = len(points) - 1
+                print_func("...points %d through %d truncated" % (i, end))
+                break
             adj_pt = "(%.1f, %.1f)" % (x - x_offset, y - y_offset)
             mesh_pt = "(%.1f, %.1f)" % (x, y)
             print_func(
@@ -613,8 +617,6 @@ class BedMeshCalibrate:
                 self.mesh_config, self.mesh_min, self.mesh_max,
                 self.radius, self.origin, probe_method
             )
-            gcmd.respond_info("Generating new points...")
-            self.print_generated_points(gcmd.respond_info)
             msg = "\n".join(["%s: %s" % (k, v)
                              for k, v in self.mesh_config.items()])
             logging.info("Updated Mesh Configuration:\n" + msg)

klippy/extras/bme280.py

@@ -83,6 +83,7 @@ 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
@@ -143,6 +144,7 @@ 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.
@@ -155,6 +157,7 @@ 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()
@@ -281,7 +284,7 @@ class BME280:
                 self.chip_type, self.i2c.i2c_address))
 
         # Reset chip
-        self.write_register('RESET', [RESET_CHIP_VALUE])
+        self.write_register('RESET', [RESET_CHIP_VALUE], wait=True)
         self.reactor.pause(self.reactor.monotonic() + .5)
 
         # Make sure non-volatile memory has been copied to registers
@@ -293,15 +296,15 @@ class BME280:
                 status = self.read_register('STATUS', 1)[0]
 
         if self.chip_type == 'BME680':
-            self.max_sample_time = 0.5
+            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_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",
@@ -318,15 +321,18 @@ class BME280:
             self.write_register("INT_CTRL", [BMP388_REG_VAL_DRDY_EN])
 
             self.sample_timer = self.reactor.register_timer(self._sample_bmp388)
-        else:
+        elif self.chip_type == 'BME280':
             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
-
-        if self.chip_type in ('BME680', 'BME280'):
-            self.write_register('CONFIG', (self.iir_filter & 0x07) << 2)
+        else:
+            self.max_sample_time = \
+                (1.25 + (2.3 * self.os_temp)
+                + ((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':
@@ -347,21 +353,64 @@ 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):
-        # Enter forced mode
-        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)
-
+        # In normal mode data shadowing is performed
+        # So reading can be done while measurements are in process
         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':
@@ -462,36 +511,40 @@ class BME280:
         return comp_press
 
     def _sample_bme680(self, eventtime):
-        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):
+        def data_ready(stat, run_gas):
             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 = meas | MODE
-        self.write_register('CTRL_MEAS', meas)
+        meas = self.os_temp << 5 | self.os_pres << 2 | MODE
+        self.write_register('CTRL_MEAS', meas, wait=True)
+        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):
+            while not data_ready(status, run_gas):
                 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 = self.read_register('GAS_R_MSB', 2)
+            gas_data = [0, 0]
+            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
@@ -515,6 +568,10 @@ 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(
@@ -643,7 +700,7 @@ class BME280:
                 gas_raw - 512. + var1)
         return gas
 
-    def _calculate_gas_heater_resistance(self, target_temp):
+    def _calc_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])
@@ -658,7 +715,7 @@ class BME280:
                             * (1. / (1. + (res_heat_val * 0.002)))) - 25))
         return int(res_heat)
 
-    def _calculate_gas_heater_duration(self, duration_ms):
+    def _calc_gas_heater_duration(self, duration_ms):
         if duration_ms >= 4032:
             duration_reg = 0xff
         else:
@@ -719,12 +776,15 @@ class BME280:
         params = self.i2c.i2c_read(regs, read_len)
         return bytearray(params['response'])
 
-    def write_register(self, reg_name, data):
+    def write_register(self, reg_name, data, wait = False):
         if type(data) is not list:
             data = [data]
         reg = self.chip_registers[reg_name]
         data.insert(0, reg)
-        self.i2c.i2c_write(data)
+        if not wait:
+            self.i2c.i2c_write(data)
+        else:
+            self.i2c.i2c_write_wait_ack(data)
 
     def get_status(self, eventtime):
         data = {

klippy/extras/bus.py

@@ -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 = self.i2c_modify_bits_cmd = None
+        self.i2c_write_cmd = self.i2c_read_cmd = None
     def get_oid(self):
         return self.oid
     def get_mcu(self):
@@ -180,9 +180,6 @@ 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
@@ -197,19 +194,6 @@ 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

klippy/extras/buttons.py

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

klippy/extras/canbus_stats.py

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

klippy/extras/controller_fan.py

@@ -62,9 +62,7 @@ class ControllerFan:
             self.last_on += 1
         if speed != self.last_speed:
             self.last_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)
+            self.fan.set_speed(speed)
         return eventtime + 1.
 
 def load_config_prefix(config):

klippy/extras/display/aip31068_spi.py

@@ -0,0 +1,209 @@
+# 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)

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 hd44780, hd44780_spi, st7920, uc1701, menu
+from . import aip31068_spi, hd44780, hd44780_spi, st7920, uc1701, menu
 
 # Normal time between each screen redraw
 REDRAW_TIME = 0.500
@@ -17,7 +17,8 @@ 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

klippy/extras/dotstar.py

@@ -1,9 +1,9 @@
 # Support for "dotstar" leds
 #
-# Copyright (C) 2019-2022  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2019-2024  Kevin O'Connor <kevin@koconnor.net>
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
-from . import bus
+from . import bus, led
 
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
 
@@ -22,9 +22,8 @@ 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)
-        pled = printer.load_object(config, "led")
-        self.led_helper = pled.setup_helper(config, self.update_leds,
-                                            self.chain_count)
+        self.led_helper = led.LEDHelper(config, self.update_leds,
+                                        self.chain_count)
         self.prev_data = None
         # Register commands
         printer.register_event_handler("klippy:connect", self.handle_connect)

klippy/extras/fan.py

@@ -1,17 +1,14 @@
 # Printer cooling fan
 #
-# 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.
-from . import pulse_counter
-
-FAN_MIN_TIME = 0.100
+from . import pulse_counter, output_pin
 
 class Fan:
     def __init__(self, config, default_shutdown_speed=0.):
         self.printer = config.get_printer()
-        self.last_fan_value = 0.
-        self.last_fan_time = 0.
+        self.last_fan_value = self.last_req_value = 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,
@@ -36,6 +33,10 @@ 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)
 
@@ -45,37 +46,37 @@ class Fan:
 
     def get_mcu(self):
         return self.mcu_fan.get_mcu()
-    def set_speed(self, print_time, value):
+    def _apply_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
-        print_time = max(self.last_fan_time + FAN_MIN_TIME, print_time)
+            return "discard", 0.
         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 value < self.max_power and self.kick_start_time
+        if (value 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)
-            print_time += self.kick_start_time
+            return "delay", self.kick_start_time
+        self.last_fan_value = self.last_req_value = value
         self.mcu_fan.set_pwm(print_time, value)
-        self.last_fan_time = print_time
-        self.last_fan_value = value
+    def set_speed(self, value, print_time=None):
+        self.gcrq.send_async_request(value, print_time)
     def set_speed_from_command(self, value):
-        toolhead = self.printer.lookup_object('toolhead')
-        toolhead.register_lookahead_callback((lambda pt:
-                                              self.set_speed(pt, value)))
+        self.gcrq.queue_gcode_request(value)
     def _handle_request_restart(self, print_time):
-        self.set_speed(print_time, 0.)
+        self.set_speed(0., print_time)
 
     def get_status(self, eventtime):
         tachometer_status = self.tachometer.get_status(eventtime)
         return {
-            'speed': self.last_fan_value,
+            'speed': self.last_req_value,
             'rpm': tachometer_status['rpm'],
         }
 

klippy/extras/fan_generic.py

@@ -1,9 +1,10 @@
 # Support fans that are controlled by gcode
 #
-# 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.
-from . import fan
+import logging
+from . import fan, output_pin
 
 class PrinterFanGeneric:
     cmd_SET_FAN_SPEED_help = "Sets the speed of a fan"
@@ -12,6 +13,9 @@ 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,
@@ -20,8 +24,22 @@ 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', 0.)
+        speed = gcmd.get_float('SPEED', None, 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):

klippy/extras/filament_motion_sensor.py

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

klippy/extras/filament_switch_sensor.py

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

klippy/extras/force_move.py

@@ -131,8 +131,19 @@ class ForceMove:
         x = gcmd.get_float('X', curpos[0])
         y = gcmd.get_float('Y', curpos[1])
         z = gcmd.get_float('Z', curpos[2])
-        logging.info("SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f", x, y, z)
-        toolhead.set_position([x, y, z, curpos[3]], homing_axes=(0, 1, 2))
+        set_homed = gcmd.get('SET_HOMED', 'xyz').lower()
+        set_homed_axes = "".join([a for a in "xyz" if a in set_homed])
+        if gcmd.get('CLEAR_HOMED', None) is None:
+            # "CLEAR" is an alias for "CLEAR_HOMED"; should deprecate
+            clear_homed = gcmd.get('CLEAR', '').lower()
+        else:
+            clear_homed = gcmd.get('CLEAR_HOMED', '').lower()
+        clear_homed_axes = "".join([a for a in "xyz" if a in clear_homed])
+        logging.info("SET_KINEMATIC_POSITION pos=%.3f,%.3f,%.3f"
+                     " set_homed=%s clear_homed=%s",
+                     x, y, z, set_homed_axes, clear_homed_axes)
+        toolhead.set_position([x, y, z, curpos[3]], homing_axes=set_homed_axes)
+        toolhead.get_kinematics().clear_homing_state(clear_homed_axes)
 
 def load_config(config):
     return ForceMove(config)

klippy/extras/garbage_collection.py

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

klippy/extras/gcode_arcs.py

@@ -39,8 +39,6 @@ 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
 
@@ -64,52 +62,36 @@ 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 = self.Coord(x=gcmd.get_float("X", currentPos[0]),
-                              y=gcmd.get_float("Y", currentPos[1]),
-                              z=gcmd.get_float("Z", currentPos[2]),
-                              e=None)
+        asTarget = [gcmd.get_float("X", currentPos[0]),
+                    gcmd.get_float("Y", currentPos[1]),
+                    gcmd.get_float("Z", currentPos[2])]
 
         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
-        asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('IJ') ]
+        I = gcmd.get_float('I', 0.)
+        J = gcmd.get_float('J', 0.)
+        asPlanar = (I, J)
         axes = (X_AXIS, Y_AXIS, Z_AXIS)
         if self.plane == ARC_PLANE_X_Z:
-            asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('IK') ]
+            K = gcmd.get_float('K', 0.)
+            asPlanar = (I, K)
             axes = (X_AXIS, Z_AXIS, Y_AXIS)
         elif self.plane == ARC_PLANE_Y_Z:
-            asPlanar = [ gcmd.get_float(a, 0.) for i,a in enumerate('JK') ]
+            K = gcmd.get_float('K', 0.)
+            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")
 
-        asE = gcmd.get_float("E", None)
-        asF = gcmd.get_float("F", None)
-
-        # 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)
+        # Build linear coordinates to move
+        self.planArc(currentPos, asTarget, asPlanar, clockwise,
+                     gcmd, absolut_extrude, *axes)
 
     # function planArc() originates from marlin plan_arc()
     # https://github.com/MarlinFirmware/Marlin
@@ -120,6 +102,7 @@ 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
 
@@ -159,23 +142,42 @@ class ArcSupport:
         # Generate coordinates
         theta_per_segment = angular_travel / segments
         linear_per_segment = linear_travel / segments
-        coords = []
-        for i in range(1, int(segments)):
+
+        asE = gcmd.get_float("E", None)
+        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
-            cos_Ti = math.cos(i * theta_per_segment)
-            sin_Ti = math.sin(i * theta_per_segment)
+            c_theta = i * theta_per_segment
+            cos_Ti = math.cos(c_theta)
+            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
 
-            # Coord doesn't support index assignment, create list
-            c = [None, None, None, None]
+            c = [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)
-        return coords
+
+            if i == segments:
+                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)

klippy/extras/gcode_button.py

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

klippy/extras/gcode_macro.py

@@ -49,6 +49,12 @@ class TemplateWrapper:
         self.create_template_context = gcode_macro.create_template_context
         try:
             self.template = env.from_string(script)
+        except jinja2.exceptions.TemplateSyntaxError as e:
+            lines = script.splitlines()
+            msg = "Error loading template '%s'\nline %s: %s # %s" % (
+                name, e.lineno, lines[e.lineno-1], e.message)
+            logging.exception(msg)
+            raise self.gcode.error(msg)
         except Exception as e:
             msg = "Error loading template '%s': %s" % (
                  name, traceback.format_exception_only(type(e), e)[-1])

klippy/extras/hall_filament_width_sensor.py

@@ -125,7 +125,7 @@ class HallFilamentWidthSensor:
         # Update filament array for lastFilamentWidthReading
         self.update_filament_array(last_epos)
         # Check runout
-        self.runout_helper.note_filament_present(
+        self.runout_helper.note_filament_present(eventtime,
             self.runout_dia_min <= self.diameter <= self.runout_dia_max)
         # Does filament exists
         if self.diameter > 0.5:

klippy/extras/heater_fan.py

@@ -33,9 +33,7 @@ class PrinterHeaterFan:
                 speed = self.fan_speed
         if speed != self.last_speed:
             self.last_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)
+            self.fan.set_speed(speed)
         return eventtime + 1.
 
 def load_config_prefix(config):

klippy/extras/heaters.py

@@ -1,6 +1,6 @@
 # Tracking of PWM controlled heaters and their temperature control
 #
-# 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 os, logging, threading
@@ -14,6 +14,7 @@ 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):
@@ -37,8 +38,7 @@ 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.is_shutdown = False
-        self.set_temp_count = 0
+        self.verify_mainthread_time = -999.
         self.lock = threading.Lock()
         self.last_temp = self.smoothed_temp = self.target_temp = 0.
         self.last_temp_time = 0.
@@ -64,13 +64,10 @@ 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 self.is_shutdown:
+        if self.target_temp <= 0. or read_time > self.verify_mainthread_time:
             value = 0.
         if ((read_time < self.next_pwm_time or not self.last_pwm_value)
             and abs(value - self.last_pwm_value) < 0.05):
@@ -95,7 +92,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.is_shutdown = True
+        self.verify_mainthread_time = -999.
     # External commands
     def get_name(self):
         return self.name
@@ -110,7 +107,6 @@ 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):
@@ -134,6 +130,9 @@ 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
@@ -148,17 +147,11 @@ 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)
 
 
 ######################################################################
@@ -250,7 +243,6 @@ 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",
@@ -271,7 +263,8 @@ class PrinterHeaters:
         try:
             dconfig = pconfig.read_config(filename)
         except Exception:
-            raise config.config_error("Cannot load config '%s'" % (filename,))
+            logging.exception("Unable to load temperature_sensors.cfg")
+            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):
@@ -317,8 +310,7 @@ class PrinterHeaters:
     def get_status(self, eventtime):
         return {'available_heaters': self.available_heaters,
                 'available_sensors': self.available_sensors,
-                'available_monitors': self.available_monitors,
-                'temperature_wait': self.in_temperature_wait}
+                'available_monitors': self.available_monitors}
     def turn_off_all_heaters(self, print_time=0.):
         for heater in self.heaters.values():
             heater.set_temp(0.)
@@ -349,23 +341,14 @@ 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))
@@ -384,12 +367,8 @@ 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")
@@ -398,18 +377,10 @@ class PrinterHeaters:
         while not self.printer.is_shutdown():
             temp, target = sensor.get_temp(eventtime)
             if temp >= min_temp and temp <= max_temp:
-                break
-            self.in_temperature_wait = full_name
+                return
             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)

klippy/extras/homing.py

@@ -1,6 +1,6 @@
 # Helper code for implementing homing operations
 #
-# Copyright (C) 2016-2021  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 logging, math
@@ -29,10 +29,17 @@ 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:
@@ -121,6 +128,9 @@ 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
@@ -130,7 +140,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)
@@ -177,7 +187,8 @@ 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
-        homing_axes = [axis for axis in range(3) if forcepos[axis] is not None]
+        force_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)
@@ -221,7 +232,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 homing_axes:
+            for axis in force_axes:
                 homepos[axis] = newpos[axis]
             self.toolhead.set_position(homepos)
 

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.append(axis)
+                homing_axes += "xyz"[axis]
         toolhead.set_position(pos, homing_axes=homing_axes)
         # Perform homing
         context = self.template.create_template_context()

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,10 +51,6 @@ 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(
@@ -145,23 +141,21 @@ class HX71xBase():
                 'overflows': self.ffreader.get_last_overflows()}
 
 
-class HX711(HX71xBase):
-    def __init__(self, config):
-        super(HX711, self).__init__(config, "hx711",
-                                    # HX711 sps options
-                                    {80: 80, 10: 10}, 80,
-                                    # HX711 gain/channel options
-                                    {'A-128': 1, 'B-32': 2, 'A-64': 3}, 'A-128')
+def HX711(config):
+    return HX71xBase(config, "hx711",
+                     # HX711 sps options
+                     {80: 80, 10: 10}, 80,
+                     # HX711 gain/channel options
+                     {'A-128': 1, 'B-32': 2, 'A-64': 3}, 'A-128')
 
 
-class HX717(HX71xBase):
-    def __init__(self, config):
-        super(HX717, self).__init__(config, "hx717",
-                                    # HX717 sps options
-                                    {320: 320, 80: 80, 20: 20, 10: 10}, 320,
-                                    # HX717 gain/channel options
-                                    {'A-128': 1, 'B-64': 2, 'A-64': 3,
-                                     'B-8': 4}, 'A-128')
+def HX717(config):
+    return HX71xBase(config, "hx717",
+                     # HX717 sps options
+                     {320: 320, 80: 80, 20: 20, 10: 10}, 320,
+                     # HX717 gain/channel options
+                     {'A-128': 1, 'B-64': 2, 'A-64': 3,
+                      'B-8': 4}, 'A-128')
 
 
 HX71X_SENSOR_TYPES = {

klippy/extras/icm20948.py

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

klippy/extras/ldc1612.py

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

klippy/extras/led.py

@@ -1,13 +1,10 @@
 # Support for PWM driven LEDs
 #
-# Copyright (C) 2019-2022  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2019-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
-
-# Time between each led template update
-RENDER_TIME = 0.500
+import logging
+from . import output_pin
 
 # Helper code for common LED initialization and control
 class LEDHelper:
@@ -22,14 +19,22 @@ 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)
-    def get_led_count(self):
-        return self.led_count
-    def set_color(self, index, color):
+        gcode.register_mux_command("SET_LED_TEMPLATE", "LED", name,
+                                   self.cmd_SET_LED_TEMPLATE,
+                                   desc=self.cmd_SET_LED_TEMPLATE_help)
+    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:
@@ -41,7 +46,17 @@ class LEDHelper:
             new_led_state[index - 1] = color
         self.led_state = new_led_state
         self.need_transmit = True
-    def check_transmit(self, print_time):
+    def _template_update(self, index, text):
+        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
@@ -62,9 +77,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')
@@ -72,112 +87,15 @@ 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):
-        led_name = gcmd.get("LED")
-        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,))
+        index = gcmd.get_int("INDEX", None, minval=1, maxval=self.led_count)
+        set_template = self.template_eval.set_template
         if index is not None:
-            self._activate_template(led_helper, index, template, lparams)
+            set_template(gcmd, self.tcallbacks[index-1], self._check_transmit)
         else:
-            for i in range(led_count):
-                self._activate_template(led_helper, i+1, template, lparams)
-        self._activate_timer()
+            for i in range(self.led_count):
+                set_template(gcmd, self.tcallbacks[i], self._check_transmit)
 
 PIN_MIN_TIME = 0.100
 MAX_SCHEDULE_TIME = 5.0
@@ -205,8 +123,7 @@ class PrinterPWMLED:
                                % (config.get_name(),))
         self.last_print_time = 0.
         # Initialize color data
-        pled = printer.load_object(config, "led")
-        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
+        self.led_helper = LEDHelper(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.)
@@ -225,8 +142,5 @@ 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)

klippy/extras/lis2dw.py

@@ -12,6 +12,8 @@ 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
@@ -23,29 +25,58 @@ 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
-SCALE = FREEFALL_ACCEL * 1.952 / 4
+LIS2DW_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):
+    def __init__(self, config, lis_type):
         self.printer = config.get_printer()
         adxl345.AccelCommandHelper(config, self)
-        self.axes_map = adxl345.read_axes_map(config, SCALE, SCALE, SCALE)
-        self.data_rate = 1600
+        self.lis_type = lis_type
+        if self.lis_type == LIS2DW_TYPE:
+            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
-        self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=5000000)
-        self.mcu = mcu = self.spi.get_mcu()
+        if self.bus_type == SPI_SERIAL_TYPE:
+            self.bus = bus.MCU_SPI_from_config(config,
+                            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 spi_oid=%d"
-                           % (oid, self.spi.get_oid()))
+        mcu.add_config_cmd("config_lis2dw oid=%d bus_oid=%d bus_oid_type=%s "
+                           "lis_chip_type=%s" % (oid, self.bus.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)
@@ -61,19 +92,24 @@ 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.spi.get_command_queue()
+        cmdqueue = self.bus.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):
-        params = self.spi.spi_transfer([reg | REG_MOD_READ, 0x00])
-        response = bytearray(params['response'])
-        return response[1]
+        if self.bus_type == SPI_SERIAL_TYPE:
+            params = self.bus.spi_transfer([reg | REG_MOD_READ, 0x00])
+            response = bytearray(params['response'])
+            return response[1]
+        params = self.bus.i2c_read([reg], 1)
+        return bytearray(params['response'])[0]
     def set_reg(self, reg, val, minclock=0):
-        self.spi.spi_send([reg, val & 0xFF], minclock=minclock)
+        if self.bus_type == SPI_SERIAL_TYPE:
+            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(
@@ -102,26 +138,48 @@ 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 dev_id != LIS2DW_DEV_ID:
-            raise self.printer.command_error(
-                "Invalid lis2dw id (got %x vs %x).\n"
-                "This is generally indicative of connection problems\n"
-                "(e.g. faulty wiring) or a faulty lis2dw chip."
-                % (dev_id, LIS2DW_DEV_ID))
-        # Setup chip in requested query rate
-        # ODR/2, +-16g, low-pass filter, Low-noise abled
-        self.set_reg(REG_LIS2DW_CTRL_REG6_ADDR, 0x34)
-        # Continuous mode: If the FIFO is full
-        # the new sample overwrites the older sample.
-        self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
-        # High-Performance / Low-Power mode 1600/200 Hz
-        # High-Performance Mode (14-bit resolution)
-        self.set_reg(REG_LIS2DW_CTRL_REG1_ADDR, 0x94)
-
+        if self.lis_type == LIS2DW_TYPE:
+            if dev_id != LIS2DW_DEV_ID:
+                raise self.printer.command_error(
+                    "Invalid lis2dw id (got %x vs %x).\n"
+                    "This is generally indicative of connection problems\n"
+                    "(e.g. faulty wiring) or a faulty lis2dw chip."
+                    % (dev_id, LIS2DW_DEV_ID))
+            # Setup chip in requested query rate
+            # ODR/2, +-16g, low-pass filter, Low-noise abled
+            self.set_reg(REG_LIS2DW_CTRL_REG6_ADDR, 0x34)
+            # Continuous mode: If the FIFO is full
+            # the new sample overwrites the older sample.
+            self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
+            # High-Performance / Low-Power mode 1600/200 Hz
+            # High-Performance Mode (14-bit resolution)
+            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])
-        self.set_reg(REG_LIS2DW_FIFO_CTRL, 0xC0)
+        if self.lis_type == LIS2DW_TYPE:
+            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()
@@ -142,7 +200,7 @@ class LIS2DW:
                 'overflows': self.ffreader.get_last_overflows()}
 
 def load_config(config):
-    return LIS2DW(config)
+    return LIS2DW(config, LIS2DW_TYPE)
 
 def load_config_prefix(config):
-    return LIS2DW(config)
+    return LIS2DW(config, LIS2DW_TYPE)

klippy/extras/lis3dh.py

@@ -0,0 +1,12 @@
+# 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)

klippy/extras/load_cell.py

@@ -3,21 +3,516 @@
 # 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
 
-# Printer class that controls a load cell
+# alternative to numpy's column selection:
+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.sensor = sensor   # must implement BulkAdcSensor
+        self.config_name = config.get_name()
+        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 _on_sample(self, msg):
+    def _handle_ready(self):
+        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 = {}

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()

klippy/extras/neopixel.py

@@ -4,6 +4,7 @@
 #
 # This file may be distributed under the terms of the GNU GPLv3 license.
 import logging
+from . import led
 
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
 
@@ -40,9 +41,7 @@ class PrinterNeoPixel:
         if len(self.color_map) > MAX_MCU_SIZE:
             raise config.error("neopixel chain too long")
         # Initialize color data
-        pled = printer.load_object(config, "led")
-        self.led_helper = pled.setup_helper(config, self.update_leds,
-                                            chain_count)
+        self.led_helper = led.LEDHelper(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])

klippy/extras/output_pin.py

@@ -3,9 +3,187 @@
 # 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:
@@ -24,30 +202,18 @@ class PrinterOutputPin:
         else:
             self.mcu_pin = ppins.setup_pin('digital_out', config.get('pin'))
             self.scale = 1.
-        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
+        self.mcu_pin.setup_max_duration(0.)
         # Determine start and shutdown values
-        static_value = config.getfloat('static_value', None,
-                                       minval=0., maxval=self.scale)
-        if static_value is not None:
-            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.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')
@@ -56,45 +222,37 @@ 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, is_resend=False):
-        if value == self.last_value and not is_resend:
-            return
-        print_time = max(print_time, self.last_print_time + PIN_MIN_TIME)
+    def _set_pin(self, print_time, value):
+        if value == self.last_value:
+            return "discard", 0.
+        self.last_value = value
         if self.is_pwm:
             self.mcu_pin.set_pwm(print_time, value)
         else:
             self.mcu_pin.set_digital(print_time, value)
-        self.last_value = value
-        self.last_print_time = print_time
-        if self.resend_interval and self.resend_timer is None:
-            self.resend_timer = self.reactor.register_timer(
-                self._resend_current_val, self.reactor.NOW)
+    def _template_update(self, text):
+        try:
+            value = float(text)
+        except ValueError as e:
+            logging.exception("output_pin template render error")
+            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")
-        # Obtain print_time and apply requested settings
-        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
+        # Queue requested value
+        self.gcrq.queue_gcode_request(value)
 
 def load_config_prefix(config):
     return PrinterOutputPin(config)

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
+from . import bus, led
 
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
 
@@ -16,8 +16,7 @@ class PCA9533:
     def __init__(self, config):
         self.printer = config.get_printer()
         self.i2c = bus.MCU_I2C_from_config(config, default_addr=98)
-        pled = self.printer.load_object(config, "led")
-        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
+        self.led_helper = led.LEDHelper(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)

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, mcp4018
+from . import bus, led, mcp4018
 
 BACKGROUND_PRIORITY_CLOCK = 0x7fffffff00000000
 
@@ -34,8 +34,7 @@ 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 = {}
-        pled = printer.load_object(config, "led")
-        self.led_helper = pled.setup_helper(config, self.update_leds, 1)
+        self.led_helper = led.LEDHelper(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:

klippy/extras/resonance_tester.py

@@ -45,40 +45,96 @@ def _parse_axis(gcmd, raw_axis):
                 "Unable to parse axis direction '%s'" % (raw_axis,))
     return TestAxis(vib_dir=(dir_x, dir_y))
 
-class VibrationPulseTest:
+class VibrationPulseTestGenerator:
     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.)
-        # Defaults are such that max_freq * accel_per_hz == 10000 (max_accel)
-        self.max_freq = config.getfloat('max_freq', 10000. / 75.,
+        self.max_freq = config.getfloat('max_freq', 135.,
                                         minval=self.min_freq, maxval=300.)
-        self.accel_per_hz = config.getfloat('accel_per_hz', 75., above=0.)
+        self.accel_per_hz = config.getfloat('accel_per_hz', 60., 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.hz_per_sec = gcmd.get_float("HZ_PER_SEC", self.hz_per_sec,
-                                         above=0., maxval=2.)
-    def run_test(self, axis, gcmd):
+        self.test_accel_per_hz = gcmd.get_float("ACCEL_PER_HZ",
+                                                self.accel_per_hz, above=0.)
+        self.test_hz_per_sec = gcmd.get_float("HZ_PER_SEC", self.hz_per_sec,
+                                              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 = self.printer.get_reactor().monotonic()
+        systime = 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 = self.freq_end * self.accel_per_hz
+        max_accel = max([abs(a) for _, a, _ in test_seq])
         self.gcode.run_script_from_command(
             "SET_VELOCITY_LIMIT ACCEL=%.3f MINIMUM_CRUISE_RATIO=0"
             % (max_accel,))
@@ -88,24 +144,46 @@ class VibrationPulseTest:
             gcmd.respond_info("Disabled [input_shaper] for resonance testing")
         else:
             input_shaper = None
-        gcmd.respond_info("Testing frequency %.0f Hz" % (freq,))
-        while freq <= self.freq_end + 0.000001:
-            t_seg = .25 / freq
-            accel = self.accel_per_hz * freq
-            max_v = accel * t_seg
+        last_v = last_t = last_accel = last_freq = 0.
+        for next_t, accel, freq in test_seq:
+            t_seg = next_t - last_t
             toolhead.cmd_M204(self.gcode.create_gcode_command(
-                "M204", "M204", {"S": accel}))
-            L = .5 * accel * t_seg**2
-            dX, dY = axis.get_point(L)
-            nX = X + sign * dX
-            nY = Y + sign * dY
-            toolhead.move([nX, nY, Z, E], max_v)
-            toolhead.move([X, Y, Z, E], max_v)
-            sign = -sign
-            old_freq = freq
-            freq += 2. * t_seg * self.hz_per_sec
-            if math.floor(freq) > math.floor(old_freq):
+                "M204", "M204", {"S": abs(accel)}))
+            v = last_v + accel * t_seg
+            abs_v = abs(v)
+            if abs_v < 0.000001:
+                v = abs_v = 0.
+            abs_last_v = abs(last_v)
+            v2 = v * v
+            last_v2 = last_v * last_v
+            half_inv_accel = .5 / accel
+            d = (v2 - last_v2) * half_inv_accel
+            dX, dY = axis.get_point(d)
+            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"
@@ -114,14 +192,13 @@ class VibrationPulseTest:
         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.test = VibrationPulseTest(config)
+        self.generator = SweepingVibrationsTestGenerator(config)
+        self.executor = ResonanceTestExecutor(config)
         if not config.get('accel_chip_x', None):
             self.accel_chip_names = [('xy', config.get('accel_chip').strip())]
         else:
@@ -131,6 +208,8 @@ 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",
@@ -154,12 +233,9 @@ class ResonanceTester:
         toolhead = self.printer.lookup_object('toolhead')
         calibration_data = {axis: None for axis in axes}
 
-        self.test.prepare_test(gcmd)
+        self.generator.prepare_test(gcmd)
 
-        if test_point is not None:
-            test_points = [test_point]
-        else:
-            test_points = self.test.get_start_test_points()
+        test_points = [test_point] if test_point else self.probe_points
 
         for point in test_points:
             toolhead.manual_move(point, self.move_speed)
@@ -184,7 +260,8 @@ class ResonanceTester:
                         raw_values.append((axis, aclient, chip.name))
 
                 # Generate moves
-                self.test.run_test(axis, gcmd)
+                test_seq = self.generator.gen_test()
+                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:
@@ -212,15 +289,11 @@ class ResonanceTester:
     def _parse_chips(self, accel_chips):
         parsed_chips = []
         for chip_name in accel_chips.split(','):
-            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)
+            chip = self.printer.lookup_object(chip_name.strip())
             parsed_chips.append(chip)
         return parsed_chips
     def _get_max_calibration_freq(self):
-        return 1.5 * self.test.get_max_freq()
+        return 1.5 * self.generator.get_max_freq()
     cmd_TEST_RESONANCES_help = ("Runs the resonance test for a specifed axis")
     def cmd_TEST_RESONANCES(self, gcmd):
         # Parse parameters

klippy/extras/safe_z_home.py

@@ -37,11 +37,10 @@ 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=[2])
+                toolhead.set_position(pos, homing_axes="z")
                 toolhead.manual_move([None, None, self.z_hop],
                                      self.z_hop_speed)
-                if hasattr(toolhead.get_kinematics(), "note_z_not_homed"):
-                    toolhead.get_kinematics().note_z_not_homed()
+                toolhead.get_kinematics().clear_homing_state("z")
             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],

klippy/extras/save_variables.py

@@ -36,6 +36,8 @@ 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)

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

klippy/extras/servo.py

@@ -1,11 +1,11 @@
 # Support for servos
 #
-# Copyright (C) 2017-2020  Kevin O'Connor <kevin@koconnor.net>
+# Copyright (C) 2017-2024  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 = self.last_value_time = 0.
+        self.last_value = 0.
         initial_pwm = 0.
         iangle = config.getfloat('initial_angle', None, minval=0., maxval=360.)
         if iangle is not None:
@@ -33,6 +33,9 @@ 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')
@@ -43,11 +46,9 @@ class PrinterServo:
         return {'value': self.last_value}
     def _set_pwm(self, print_time, value):
         if value == self.last_value:
-            return
-        print_time = max(print_time, self.last_value_time + PIN_MIN_TIME)
-        self.mcu_servo.set_pwm(print_time, value)
+            return "discard", 0.
         self.last_value = value
-        self.last_value_time = print_time
+        self.mcu_servo.set_pwm(print_time, value)
     def _get_pwm_from_angle(self, angle):
         angle = max(0., min(self.max_angle, angle))
         width = self.min_width + angle * self.angle_to_width
@@ -64,9 +65,7 @@ class PrinterServo:
         else:
             angle = gcmd.get_float('ANGLE')
             value = self._get_pwm_from_angle(angle)
-        toolhead = self.printer.lookup_object('toolhead')
-        toolhead.register_lookahead_callback((lambda pt:
-                                              self._set_pwm(pt, value)))
+        self.gcrq.queue_gcode_request(value)
 
 def load_config_prefix(config):
     return PrinterServo(config)

klippy/extras/shaper_calibrate.py

@@ -48,7 +48,9 @@ class CalibrationData:
             # Avoid division by zero errors
             psd /= self.freq_bins + .1
             # Remove low-frequency noise
-            psd[self.freq_bins < MIN_FREQ] = 0.
+            low_freqs = self.freq_bins < 2. * MIN_FREQ
+            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]
 

klippy/extras/skew_correction.py

@@ -20,6 +20,7 @@ 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.
@@ -117,6 +118,7 @@ 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(
@@ -156,7 +158,10 @@ 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)

klippy/extras/stepper_enable.py

@@ -94,6 +94,7 @@ 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):

klippy/extras/sx1509.py

@@ -38,19 +38,17 @@ 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
+        # Reset the chip, Default RegClock/RegMisc 0x0
         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_modify_bits oid=%d reg=%02x"
-                                 " clear_set_bits=%02x%02x" % (
-                                     self._oid, REG_CLOCK, 0, (1 << 6)))
+        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
+            self._oid, REG_CLOCK, (1 << 6)))
         # Setup Clock Divider
-        self._mcu.add_config_cmd("i2c_modify_bits oid=%d reg=%02x"
-                                 " clear_set_bits=%02x%02x" % (
-                                     self._oid, REG_MISC, 0, (1 << 4)))
+        self._mcu.add_config_cmd("i2c_write oid=%d data=%02x%02x" % (
+            self._oid, REG_MISC, (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" % (

klippy/extras/temperature_combined.py

@@ -41,19 +41,29 @@ class PrinterSensorCombined:
             sensor = self.printer.lookup_object(sensor_name)
             # check if sensor has get_status function and
             # get_status has a 'temperature' value
-            if (hasattr(sensor, 'get_status') and
-                    'temperature' in sensor.get_status(
-                            self.reactor.monotonic())):
-                self.sensors.append(sensor)
-            else:
+            if not hasattr(sensor, 'get_status'):
+                raise self.printer.config_error(
+                        "'%s' does not have a status."
+                        % (sensor_name,))
+            status = sensor.get_status(self.reactor.monotonic())
+            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.NOW)
+                                  self.reactor.monotonic() + 1.)
 
     def setup_minmax(self, min_temp, max_temp):
         self.min_temp = min_temp

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_speed(self, read_time, value):
+    def set_tf_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(speed_time, value)
+        self.fan.set_speed(value, speed_time)
     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_speed(read_time, 0.)
+            self.temperature_fan.set_tf_speed(read_time, 0.)
         else:
-            self.temperature_fan.set_speed(read_time,
-                                           self.temperature_fan.get_max_speed())
+            self.temperature_fan.set_tf_speed(
+                read_time, 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_speed(
+        self.temperature_fan.set_tf_speed(
             read_time, max(self.temperature_fan.get_min_speed(),
                            self.temperature_fan.get_max_speed() - bounded_co))
         # Store state for next measurement

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 = [
-            ('rp2040', self.config_rp2040),
+            ('rp2', 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),

klippy/extras/temperature_probe.py

@@ -490,6 +490,7 @@ 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
@@ -503,7 +504,8 @@ class EddyDriftCompensation:
                     )
             self.drift_calibration = [Polynomial2d(*coefs) for coefs in dc]
             cal = self.drift_calibration
-            self._check_calibration(cal, self.dc_min_temp, config.error)
+            start_temp, end_temp = self.dc_min_temp, self.max_valid_temp
+            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])
@@ -638,13 +640,15 @@ 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)))
-        self._check_calibration(polynomials, min_temp)
+        end_vld_temp = max(self.max_valid_temp, max_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)
@@ -656,10 +660,11 @@ class EddyDriftCompensation:
             % (self.name, len(polynomials))
         )
 
-    def _check_calibration(self, calibration, start_temp, error=None):
+    def _check_calibration(self, calibration, start_temp, end_temp, error=None):
         error = error or self.printer.command_error
         start = int(start_temp)
-        for temp in range(start, 121, 1):
+        end = int(end_temp) + 1
+        for temp in range(start, end, 1):
             last_freq = calibration[0](temp)
             for i, poly in enumerate(calibration[1:]):
                 next_freq = poly(temp)

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,
-                                                 3, TMC_FREQUENCY)
+                                                 7, TMC_FREQUENCY)
         else:
             # Use SPI bus for communication
             self.mcu_tmc = tmc2130.MCU_TMC_SPI(config, Registers, self.fields,
@@ -408,6 +408,8 @@ 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)

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
+            return "done"
         error = round(max(z_positions) - min(z_positions),6)
         self.gcode.respond_info(
             "Retries: %d/%d %s: %0.6f tolerance: %0.6f" % (

klippy/gcode.py

@@ -1,6 +1,6 @@
 # Parse gcode commands
 #
-# Copyright (C) 2016-2021  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, re, logging, collections, shlex
@@ -28,19 +28,18 @@ class GCodeCommand:
         return self._params
     def get_raw_command_parameters(self):
         command = self._command
-        if command.startswith("M117 ") or command.startswith("M118 "):
-            command = command[:4]
-        rawparams = self._commandline
-        urawparams = rawparams.upper()
-        if not urawparams.startswith(command):
-            rawparams = rawparams[urawparams.find(command):]
-            end = rawparams.rfind('*')
-            if end >= 0:
-                rawparams = rawparams[:end]
-        rawparams = rawparams[len(command):]
-        if rawparams.startswith(' '):
-            rawparams = rawparams[1:]
-        return rawparams
+        origline = self._commandline
+        param_start = len(command)
+        param_end = len(origline)
+        if origline[:param_start].upper() != command:
+            # Skip any gcode line-number and ignore any trailing checksum
+            param_start += origline.upper().find(command)
+            end = origline.rfind('*')
+            if end >= 0 and origline[end+1:].isdigit():
+                param_end = end
+        if origline[param_start:param_start+1].isspace():
+            param_start += 1
+        return origline[param_start:param_end]
     def ack(self, msg=None):
         if not self._need_ack:
             return False
@@ -133,6 +132,10 @@ 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
@@ -184,7 +187,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
@@ -194,16 +197,14 @@ class GCodeDispatch:
                 line = line[:cpos]
             # Break line into parts and determine command
             parts = self.args_r.split(line.upper())
-            numparts = len(parts)
-            cmd = ""
-            if numparts >= 3 and parts[1] != 'N':
-                cmd = parts[1] + parts[2].strip()
-            elif numparts >= 5 and parts[1] == 'N':
+            if ''.join(parts[:2]) == 'N':
                 # Skip line number at start of command
-                cmd = parts[3] + parts[4].strip()
+                cmd = ''.join(parts[3:5]).strip()
+            else:
+                cmd = ''.join(parts[:3]).strip()
             # Build gcode "params" dictionary
             params = { parts[i]: parts[i+1].strip()
-                       for i in range(1, numparts, 2) }
+                       for i in range(1, len(parts), 2) }
             gcmd = GCodeCommand(self, cmd, origline, params, need_ack)
             # Invoke handler for command
             handler = self.gcode_handlers.get(cmd, self.cmd_default)
@@ -251,26 +252,22 @@ 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):
-        m = self.extended_r.match(gcmd.get_commandline())
-        if m is None:
-            raise self.error("Malformed command '%s'"
-                             % (gcmd.get_commandline(),))
-        eargs = m.group('args')
+        rawparams = gcmd.get_raw_command_parameters()
+        # Extract args while allowing shell style quoting
+        s = shlex.shlex(rawparams, posix=True)
+        s.whitespace_split = True
+        s.commenters = '#;'
         try:
-            eparams = [earg.split('=', 1) for earg in shlex.split(eargs)]
+            eparams = [earg.split('=', 1) for earg in s]
             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()
@@ -289,12 +286,15 @@ class GCodeDispatch:
             if cmdline:
                 logging.debug(cmdline)
             return
-        if cmd.startswith("M117 ") or cmd.startswith("M118 "):
+        if ' ' in cmd:
             # Handle M117/M118 gcode with numeric and special characters
-            handler = self.gcode_handlers.get(cmd[:4], None)
-            if handler is not None:
-                handler(gcmd)
-                return
+            realcmd = cmd.split()[0]
+            if realcmd in ["M117", "M118", "M23"]:
+                handler = self.gcode_handlers.get(realcmd, None)
+                if handler is not None:
+                    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

klippy/kinematics/cartesian.py

@@ -40,8 +40,6 @@ 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,
@@ -67,15 +65,17 @@ class CartKinematics:
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-        for axis in homing_axes:
+        for axis_name 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 note_z_not_homed(self):
-        # Helper for Safe Z Home
-        self.limits[2] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                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,8 +96,6 @@ 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):

klippy/kinematics/corexy.py

@@ -21,8 +21,6 @@ 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(
@@ -41,11 +39,12 @@ class CoreXYKinematics:
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-            if i in homing_axes:
+            if "xyz"[i] in homing_axes:
                 self.limits[i] = rail.get_range()
-    def note_z_not_homed(self):
-        # Helper for Safe Z Home
-        self.limits[2] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                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():
@@ -62,8 +61,6 @@ 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):

klippy/kinematics/corexz.py

@@ -21,8 +21,6 @@ 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(
@@ -41,11 +39,12 @@ class CoreXZKinematics:
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-            if i in homing_axes:
+            if "xyz"[i] in homing_axes:
                 self.limits[i] = rail.get_range()
-    def note_z_not_homed(self):
-        # Helper for Safe Z Home
-        self.limits[2] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                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():
@@ -62,8 +61,6 @@ 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):

klippy/kinematics/delta.py

@@ -23,8 +23,6 @@ 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(
@@ -90,7 +88,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):
@@ -103,17 +101,19 @@ class DeltaKinematics:
         for rail in self.rails:
             rail.set_position(newpos)
         self.limit_xy2 = -1.
-        if tuple(homing_axes) == (0, 1, 2):
+        if homing_axes == "xyz":
             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

klippy/kinematics/deltesian.py

@@ -41,8 +41,6 @@ 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,
@@ -89,7 +87,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):
@@ -115,8 +113,13 @@ class DeltesianKinematics:
     def set_position(self, newpos, homing_axes):
         for rail in self.rails:
             rail.set_position(newpos)
-        for n in homing_axes:
-            self.homed_axis[n] = True
+        for axis_name in homing_axes:
+            axis = "xyz".index(axis_name)
+            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
@@ -142,8 +145,6 @@ 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

klippy/kinematics/hybrid_corexy.py

@@ -42,8 +42,6 @@ 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(
@@ -69,15 +67,17 @@ class HybridCoreXYKinematics:
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-        for axis in homing_axes:
+        for axis_name 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 note_z_not_homed(self):
-        # Helper for Safe Z Home
-        self.limits[2] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                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,8 +96,6 @@ 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):

klippy/kinematics/hybrid_corexz.py

@@ -42,8 +42,6 @@ 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(
@@ -69,15 +67,17 @@ class HybridCoreXZKinematics:
     def set_position(self, newpos, homing_axes):
         for i, rail in enumerate(self.rails):
             rail.set_position(newpos)
-        for axis in homing_axes:
+        for axis_name 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 note_z_not_homed(self):
-        # Helper for Safe Z Home
-        self.limits[2] = (1.0, -1.0)
+    def clear_homing_state(self, clear_axes):
+        for axis, axis_name in enumerate("xyz"):
+            if axis_name in clear_axes:
+                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,8 +96,6 @@ 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):

klippy/kinematics/none.py

@@ -13,6 +13,8 @@ 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):