diff --git a/cfgs/CALIBRATION.cfg b/cfgs/CALIBRATION.cfg index 468c704..589b963 100644 --- a/cfgs/CALIBRATION.cfg +++ b/cfgs/CALIBRATION.cfg @@ -46,4 +46,4 @@ gcode: TEMPERATURE_WAIT SENSOR=heater_bed MINIMUM=60 TEMPERATURE_WAIT SENSOR=extruder MINIMUM=180 G28 - BED_MESH_CALIBRATE \ No newline at end of file + _BED_MESH_CALIBRATE \ No newline at end of file diff --git a/cfgs/kamp/Adaptive_Meshing.cfg b/cfgs/kamp/Adaptive_Meshing.cfg new file mode 100644 index 0000000..f1cb3a0 --- /dev/null +++ b/cfgs/kamp/Adaptive_Meshing.cfg @@ -0,0 +1,104 @@ +# # # Klipper Adaptive Meshing # # # + +# Heads up! If you have any other BED_MESH_CALIBRATE macros defined elsewhere in your config, you will need to comment out / remove them for this to work. (Klicky/Euclid Probe) +# You will also need to be sure that [exclude_object] is defined in printer.cfg, and your slicer is labeling objects. +# This macro will parse information from objects in your gcode to define a min and max mesh area to probe, creating an adaptive mesh! +# This macro will not increase probe_count values in your [bed_mesh] config. If you want richer meshes, be sure to increase probe_count. We recommend at least 5,5. + +[gcode_macro BED_MESH_CALIBRATE] +rename_existing: _BED_MESH_CALIBRATE +gcode: + + {% set all_points = printer.exclude_object.objects | map(attribute='polygon') | sum(start=[]) %} # Gather all object points + {% set bed_mesh_min = printer.configfile.settings.bed_mesh.mesh_min %} # Get bed mesh min from printer.cfg + {% set bed_mesh_max = printer.configfile.settings.bed_mesh.mesh_max %} # Get bed mesh max from printer.cfg + {% set probe_count = printer.configfile.settings.bed_mesh.probe_count %} # Get probe count from printer.cfg + {% set verbose_enable = printer["gcode_macro _KAMP_Settings"].verbose_enable | abs %} # Pull verbose setting from _KAMP_Settings + {% set mesh_margin = printer["gcode_macro _KAMP_Settings"].mesh_margin | float %} # Pull mesh margin setting from _KAMP_Settings + {% set fuzz_amount = printer["gcode_macro _KAMP_Settings"].fuzz_amount | float %} # Pull fuzz amount setting from _KAMP_Settings + {% set probe_count = probe_count if probe_count|length > 1 else probe_count * 2 %} # If probe count is only a single number, convert it to 2. E.g. probe_count:7 = 7,7 + {% set max_probe_point_distance_x = ( bed_mesh_max[0] - bed_mesh_min[0] ) / (probe_count[0] - 1) %} # Determine max probe point distance + {% set max_probe_point_distance_y = ( bed_mesh_max[1] - bed_mesh_min[1] ) / (probe_count[1] - 1) %} # Determine max probe point distance + {% set x_min = all_points | map(attribute=0) | min | default(bed_mesh_min[0]) %} # Set x_min from smallest object x point + {% set y_min = all_points | map(attribute=1) | min | default(bed_mesh_min[1]) %} # Set y_min from smallest object y point + {% set x_max = all_points | map(attribute=0) | max | default(bed_mesh_max[0]) %} # Set x_max from largest object x point + {% set y_max = all_points | map(attribute=1) | max | default(bed_mesh_max[1]) %} # Set y_max from largest object y point + + {% set fuzz_range = range((0) | int, (fuzz_amount * 100) | int + 1) %} # Set fuzz_range between 0 and fuzz_amount + {% set adapted_x_min = (bed_mesh_min[0] + fuzz_amount - mesh_margin, x_min) | max - (fuzz_range | random / 100.0) %} # Adapt x_min to margin and fuzz constraints + {% set adapted_y_min = (bed_mesh_min[1] + fuzz_amount - mesh_margin, y_min) | max - (fuzz_range | random / 100.0) %} # Adapt y_min to margin and fuzz constraints + {% set adapted_x_max = (bed_mesh_max[0] - fuzz_amount + mesh_margin, x_max) | min + (fuzz_range | random / 100.0) %} # Adapt x_max to margin and fuzz constraints + {% set adapted_y_max = (bed_mesh_max[1] - fuzz_amount + mesh_margin, y_max) | min + (fuzz_range | random / 100.0) %} # Adapt y_max to margin and fuzz constraints + + {% set points_x = (((adapted_x_max - adapted_x_min) / max_probe_point_distance_x) | round(method='ceil') | int) + 1 %} # Define probe_count's x point count and round up + {% set points_y = (((adapted_y_max - adapted_y_min) / max_probe_point_distance_y) | round(method='ceil') | int) + 1 %} # Define probe_count's y point count and round up + + {% if (([points_x, points_y]|max) > 6) %} # + {% set algorithm = "bicubic" %} # + {% set min_points = 4 %} # + {% else %} # Calculate if algorithm should be bicubic or lagrange + {% set algorithm = "lagrange" %} # + {% set min_points = 3 %} # + {% endif %} # + + {% set points_x = [points_x, min_points]|max %} # Set probe_count's x points to fit the calculated algorithm + {% set points_y = [points_y, min_points]|max %} # Set probe_count's y points to fit the calculated algorithm + {% set points_x = [points_x, probe_count[0]]|min %} + {% set points_y = [points_y, probe_count[1]]|min %} + + {% if verbose_enable == True %} # If verbose is enabled, print information about KAMP's calculations + + { action_respond_info( "Algorithm: {}.".format( + (algorithm), + )) } + + { action_respond_info("Default probe count: {},{}.".format( + (probe_count[0]), + (probe_count[1]), + )) } + + { action_respond_info("Adapted probe count: {},{}.".format( + (points_x), + (points_y), + )) } + + {action_respond_info("Default mesh bounds: {}, {}.".format( + (bed_mesh_min[0],bed_mesh_min[1]), + (bed_mesh_max[0],bed_mesh_max[1]), + )) } + + {% if mesh_margin > 0 %} + {action_respond_info("Mesh margin is {}, mesh bounds extended by {}mm.".format( + (mesh_margin), + (mesh_margin), + )) } + {% else %} + {action_respond_info("Mesh margin is 0, margin not increased.")} + {% endif %} + + {% if fuzz_amount > 0 %} + {action_respond_info("Mesh point fuzzing enabled, points fuzzed up to {}mm.".format( + (fuzz_amount), + )) } + {% else %} + {action_respond_info("Fuzz amount is 0, mesh points not fuzzed.")} + {% endif %} + + { action_respond_info("Adapted mesh bounds: {}, {}.".format( + (adapted_x_min, adapted_y_min), + (adapted_x_max, adapted_y_max), + )) } + + {action_respond_info("KAMP adjustments successful. Happy KAMPing!")} + + {% endif %} + + {% if probe_dock_enable == True %} + {attach_macro} # Attach/deploy a probe if the probe is stored somewhere outside of the print area + {% endif %} + + _BED_MESH_CALIBRATE mesh_min={adapted_x_min},{adapted_y_min} mesh_max={adapted_x_max},{adapted_y_max} ALGORITHM={algorithm} PROBE_COUNT={points_x},{points_y} + + {% if probe_dock_enable == True %} + {detach_macro} # Detach/stow a probe if the probe is stored somewhere outside of the print area + {% endif %} # End of verbose diff --git a/cfgs/kamp/KAMP_Settings.cfg b/cfgs/kamp/KAMP_Settings.cfg new file mode 100644 index 0000000..3164fba --- /dev/null +++ b/cfgs/kamp/KAMP_Settings.cfg @@ -0,0 +1,31 @@ +# Below you can include specific configuration files depending on what you want KAMP to do: + +[include ./Adaptive_Meshing.cfg] # Include to enable adaptive meshing configuration. +# [include ./KAMP/Line_Purge.cfg] # Include to enable adaptive line purging configuration. + +[gcode_macro _KAMP_Settings] +description: This macro contains all adjustable settings for KAMP + +# The following variables are settings for KAMP as a whole. +variable_verbose_enable: True # Set to True to enable KAMP information output when running. This is useful for debugging. + +# The following variables are for adjusting adaptive mesh settings for KAMP. +variable_mesh_margin: 0 # Expands the mesh size in millimeters if desired. Leave at 0 to disable. +variable_fuzz_amount: 0 # Slightly randomizes mesh points to spread out wear from nozzle-based probes. Leave at 0 to disable. + +# The following variables are for those with a dockable probe like Klicky, Euclid, etc. # ---------------- Attach Macro | Detach Macro +variable_probe_dock_enable: False # Set to True to enable the usage of a dockable probe. # --------------------------------------------- +variable_attach_macro: 'Attach_Probe' # The macro that is used to attach the probe. # Klicky Probe: 'Attach_Probe' | 'Dock_Probe' +variable_detach_macro: 'Dock_Probe' # The macro that is used to store the probe. # Euclid Probe: 'Deploy_Probe' | 'Stow_Probe' + # Legacy Gcode: 'M401' | 'M402' + +# The following variables are for adjusting adaptive purge settings for KAMP. +variable_purge_height: 0.8 # Z position of nozzle during purge, default is 0.8. +variable_tip_distance: 0 # Distance between tip of filament and nozzle before purge. Should be similar to PRINT_END final retract amount. +variable_purge_margin: 10 # Distance the purge will be in front of the print area, default is 10. +variable_purge_amount: 30 # Amount of filament to be purged prior to printing. +variable_flow_rate: 12 # Flow rate of purge in mm3/s. Default is 12. + +gcode: # Gcode section left intentionally blank. Do not disturb. + + {action_respond_info(" Running the KAMP_Settings macro does nothing, it is only used for storing KAMP settings. ")} \ No newline at end of file diff --git a/cfgs/kamp/Line_Purge.cfg b/cfgs/kamp/Line_Purge.cfg new file mode 100644 index 0000000..f6e77ac --- /dev/null +++ b/cfgs/kamp/Line_Purge.cfg @@ -0,0 +1,113 @@ +[gcode_macro LINE_PURGE] +description: A purge macro that adapts to be near your actual printed objects +gcode: + # Get relevant printer params + {% set travel_speed = (printer.toolhead.max_velocity) * 60 | float %} + {% set cross_section = printer.configfile.settings.extruder.max_extrude_cross_section | float %} + + # Use firmware retraction if it is defined + {% if printer.firmware_retraction is defined %} + {% set RETRACT = G10 | string %} + {% set UNRETRACT = G11 | string %} + {% else %} + {% set RETRACT = 'G1 E-.5 F2100' | string %} + {% set UNRETRACT = 'G1 E.5 F2100' | string %} + {% endif %} + + # Get purge settings from _Kamp_Settings + {% set verbose_enable = printer["gcode_macro _KAMP_Settings"].verbose_enable | abs %} + {% set purge_height = printer["gcode_macro _KAMP_Settings"].purge_height | float %} + {% set tip_distance = printer["gcode_macro _KAMP_Settings"].tip_distance | float %} + {% set purge_margin = printer["gcode_macro _KAMP_Settings"].purge_margin | float %} + {% set purge_amount = printer["gcode_macro _KAMP_Settings"].purge_amount | float %} + {% set flow_rate = printer["gcode_macro _KAMP_Settings"].flow_rate | float %} + + + # Calculate purge origins and centers from objects + {% set all_points = printer.exclude_object.objects | map(attribute='polygon') | sum(start=[]) %} # Get all object points + {% set purge_x_min = (all_points | map(attribute=0) | min | default(0)) %} # Object x min + {% set purge_x_max = (all_points | map(attribute=0) | max | default(0)) %} # Object x max + {% set purge_y_min = (all_points | map(attribute=1) | min | default(0)) %} # Object y min + {% set purge_y_max = (all_points | map(attribute=1) | max | default(0)) %} # Object y max + + {% set purge_x_center = ([((purge_x_max + purge_x_min) / 2) - (purge_amount / 2), 0] | max) %} # Create center point of purge line relative to print on X axis + {% set purge_y_center = ([((purge_y_max + purge_y_min) / 2) - (purge_amount / 2), 0] | max) %} # Create center point of purge line relative to print on Y axis + + {% set purge_x_origin = ([purge_x_min - purge_margin, 0] | max) %} # Add margin to x min, compare to 0, and choose the larger + {% set purge_y_origin = ([purge_y_min - purge_margin, 0] | max) %} # Add margin to y min, compare to 0, and choose the larger + + # Calculate purge speed + {% set purge_move_speed = (flow_rate / cross_section) * 60 | float %} + + {% if cross_section != 5 %} + + {action_respond_info("[Extruder] max_extrude_cross_section is not configured correctly, please set it to 5. Purge skipped.")} + + {% else %} + + {% if verbose_enable == True %} + + {action_respond_info("Moving filament tip {}mms".format( + (tip_distance), + )) } + {% endif %} + + {% if printer.firmware_retraction is defined %} + {action_respond_info("KAMP purge is using firmware retraction.")} + {% else %} + {action_respond_info("KAMP purge is not using firmware retraction, it is recommended to configure it.")} + {% endif %} + + {% if purge_y_origin > 0 %} + + {action_respond_info("KAMP purge starting at {}, {} and purging {}mm of filament, requested flow rate is {}mm/s3.".format( + (purge_x_center), + (purge_y_origin), + (purge_amount), + (flow_rate), + )) } + + {% else %} + + {action_respond_info("KAMP purge starting at {}, {} and purging {}mm of filament, requested flow rate is {}mm/s3.".format( + (purge_x_origin), + (purge_y_center), + (purge_amount), + (flow_rate), + )) } + + {% endif %} + + {% if purge_y_origin > 0 %} # If there's room on Y, purge along X axis in front of print area + + G92 E0 # Reset extruder + G0 F{travel_speed} # Set travel speed + G90 # Absolute positioning + G0 X{purge_x_center} Y{purge_y_origin} # Move to purge position + G0 Z{purge_height} # Move to purge Z height + M83 # Relative extrusion mode + G1 E{tip_distance} F{purge_move_speed} # Move filament tip + G1 X{purge_x_center + purge_amount} E{purge_amount} F{purge_move_speed} # Purge line + {RETRACT} # Retract + G92 E0 # Reset extruder distance + M82 # Absolute extrusion mode + G0 Z{purge_height * 2} F{travel_speed} # Z hop + + {% else %} # If there's room on X, purge along Y axis to the left of print area + + G92 E0 # Reset extruder + G0 F{travel_speed} # Set travel speed + G90 # Absolute positioning + G0 X{purge_x_origin} Y{purge_y_center} # Move to purge position + G0 Z{purge_height} # Move to purge Z height + M83 # Relative extrusion mode + G1 E{tip_distance} F{purge_move_speed} # Move filament tip + G1 Y{purge_y_center + purge_amount} E{purge_amount} F{purge_move_speed} # Purge line + {RETRACT} # Retract + G92 E0 # Reset extruder distance + M82 # Absolute extrusion mode + G0 Z{purge_height * 2} F{travel_speed} # Z hop + + {% endif %} + + {% endif %} \ No newline at end of file diff --git a/cfgs/misc-macros.cfg b/cfgs/misc-macros.cfg index 6872835..7d3af82 100644 --- a/cfgs/misc-macros.cfg +++ b/cfgs/misc-macros.cfg @@ -29,13 +29,10 @@ gcode: variable_filament_sensor_enabled: 0 # NOTE Enable(1) or disable(0) the filament sensor, if one is connected variable_beeping_enabled: 1 # NOTE Enable(1) or disable(0) beeping everywhere except during gantry calibration variable_bed_temp_over: 10 # NOTE Start print if bed temperature is over by this amount, otherwise wait for temperature drop +variable_kamp_enable: 0 # NOTE Enable(1) or disable(0) KAMP (adaptive mesh) variable_pre_purge_prime_length: 1.40 gcode: - # DELETEME This section is unnecessary - SET_GCODE_VARIABLE MACRO=_globals VARIABLE=pre_purge_prime_length VALUE={ variable_pre_purge_prime_length } - SET_GCODE_VARIABLE MACRO=_globals VARIABLE=filament_sensor_enabled VALUE={ variable_filament_sensor_enabled } - SET_GCODE_VARIABLE MACRO=_globals VARIABLE=beeping_enabled VALUE={ variable_beeping_enabled } - SET_GCODE_VARIABLE MACRO=_globals VARIABLE=bed_temp_over VALUE={ variable_bed_temp_over } + # Don't delete this section [gcode_macro CONDITIONAL_BEEP] gcode: @@ -122,6 +119,7 @@ gcode: [gcode_macro PRINT_START] gcode: + ADJUST_FILAMENT_SENSOR_STATUS ENABLE=1 # Parameters {% set bedtemp = params.BED|int %} {% set hotendtemp = params.HOTEND|int %} @@ -132,6 +130,7 @@ gcode: {% set bedtempOver = printer["gcode_macro _globals"].bed_temp_over|default(0)|int %} {% set maxVelocity = printer.configfile.settings.printer.max_velocity|default(200)|int %} {% set maxVelocityAdjusted = (0.90 * maxVelocity * 60)|int %} + {% set kampEnabled=printer["gcode_macro _globals"].kamp_enable|default(0)|int %} {% if printer.configfile.settings.safe_z_home %} {% set startX = printer.configfile.settings.safe_z_home.home_xy_position[0]|float %} @@ -149,9 +148,6 @@ gcode: {% endif %} {% endif %} - BED_MESH_PROFILE LOAD=default ; NOTE if not using a mesh, comment out this line - ADJUST_FILAMENT_SENSOR_STATUS ENABLE=1 - G90 ; absolute positioning M140 S{bedtempAlmost} ; set & don't wait for bed temp M104 S{hotendtempStepOne} ; set & don't wait for hotend temp @@ -161,12 +157,21 @@ gcode: {% endif %} M190 S{bedtempAlmost} ; set & wait for bed temp - M104 S{hotendtempStepTwo} ; set & don't wait for hotend temp + {% if kampEnabled == 0 %} + M104 S{hotendtempStepTwo} ; set & don't wait for hotend temp + {% endif %} M190 S{bedtemp} ; set & wait for bed temp M140 S{bedtempSlicer} ; set & don't wait for bed temp ; set temp to sliced setting regardless - M104 S{hotendtemp} ; set & don't wait for hotend temp - G28 Z ; final z homing + {% if kampEnabled == 0 %} + BED_MESH_PROFILE LOAD=default ; NOTE if not using a mesh, comment out this line + M104 S{hotendtemp} ; set & don't wait for hotend temp + G28 Z ; final z homing + {% else %} + G28 Z ; final z homing + BED_MESH_CALIBRATE ; KAMP mesh + M104 S{hotendtemp} ; set & don't wait for hotend temp + {% endif %} G1 X0 Y0 F{maxVelocityAdjusted} M109 S{hotendtemp} ; set & wait for hotend temp diff --git a/osskc.cfg b/osskc.cfg new file mode 100644 index 0000000..f05dfa7 --- /dev/null +++ b/osskc.cfg @@ -0,0 +1,10 @@ +[include ./cfgs/misc-macros.cfg] +[include ./cfgs/PARKING.cfg] +[include ./cfgs/MECHANICAL_GANTRY_CALIBRATION.cfg] +[include ./cfgs/CALIBRATION.cfg] +[include ./cfgs/kamp/KAMP_Settings.cfg] + +# NOTE Uncomment the ONE of the following lines if you're using an adxl345 +# [include ./cfgs/adxl-rp2040.cfg] +# [include ./cfgs/adxl-rpi-pico-2x.cfg] +# [include ./cfgs/adxl-direct.cfg] \ No newline at end of file diff --git a/printer.cfg b/printer.cfg index 8f1e965..06f67be 100644 --- a/printer.cfg +++ b/printer.cfg @@ -4,15 +4,7 @@ # # See https://www.klipper3d.org/Config_Reference.html for configuration reference. -[include ./cfgs/misc-macros.cfg] -[include ./cfgs/PARKING.cfg] -[include ./cfgs/MECHANICAL_GANTRY_CALIBRATION.cfg] -[include ./cfgs/CALIBRATION.cfg] - -# NOTE Uncomment the ONE of the following lines if you're using an adxl345 -# [include ./cfgs/adxl-rp2040.cfg] -# [include ./cfgs/adxl-rpi-pico-2x.cfg] -# [include ./cfgs/adxl-direct.cfg] +[include ./osskc.cfg] [mcu] # NOTE Obtain definition by "ls -l /dev/serial/by-path/" or "ls -l /dev/serial/by-id/"