266 lines
14 KiB
INI
266 lines
14 KiB
INI
#########################################
|
|
###### FLOW MULTIPLIER CALIBRATION ######
|
|
#########################################
|
|
# Written by Frix_x#0161 #
|
|
# @version: 1.6
|
|
|
|
# CHANGELOG:
|
|
# v1.6: directly added the [gcode_arcs] definition in this file to simplify installation
|
|
# v1.5: moved the install notes into a proper markdown file in: docs > features > flow_calibration.md
|
|
# v1.4: fix issue when extrude_factor is != 1
|
|
# v1.3: fix the logging
|
|
# v1.2: fix for those using absolute extrusion that leads to an error
|
|
# v1.1: added part cooling fan control and some speed optimizations
|
|
# v1.0: first flow calibration macro
|
|
|
|
# -------------------------------------------------------------------------------------------------------------------------
|
|
# If you want to use it into your own config, please install it as a standalone macro as described in the
|
|
# installation section of this file: docs > features > flow_calibration.md
|
|
# -------------------------------------------------------------------------------------------------------------------------
|
|
|
|
### What is it ? ###
|
|
# The main reason for this set of macros is to get a filament and slicer agnostic way to calibrate the flow extrusion multiplier.
|
|
# The goal is to make it easy to set, share and use it.
|
|
|
|
# This macro is parametric and most of the values can be adjusted with their respective input parameters.
|
|
# It can be called without any parameters - in which case the default values would be used - or with any combination of parameters as desired.
|
|
|
|
# Feel free to ping me on Discord (Frix_x#0161) if you need help or have any comments to improve it :)
|
|
|
|
|
|
# ===========================================================================================================
|
|
# DO NOT MODIFY THOSE VARIABLES (they are used internaly by the flow calibration macro)
|
|
[gcode_macro _FLOW_CALIB_VARIABLES]
|
|
variable_last_shell_thickness: 0.0
|
|
variable_last_evalue: 0.0
|
|
gcode:
|
|
|
|
[gcode_arcs]
|
|
resolution: 0.1
|
|
|
|
[gcode_macro FLOW_MULTIPLIER_CALIBRATION]
|
|
description: Print a small tower to calibrate the extrusion flow multiplier by measuring the shell
|
|
gcode:
|
|
#
|
|
# PARAMETERS
|
|
#
|
|
{% set do_raft = params.DO_RAFT|default(1)|int %} # whether to print a raft or not
|
|
{% set do_retract = params.DO_RECTRACT|default(0)|int %} # whether to enable retract/unrectract on travel moves
|
|
{% set print_size = params.PRINT_SIZE|default(40)|int %} # size of the printed object on the build plate
|
|
{% set print_height = params.HEIGHT|default(15)|int %} # height of the printed object
|
|
{% set corner_radius = params.CORNER_RADIUS|default(8)|int %} # radius of the corners to smooth the shell and toolpath
|
|
{% set number_of_perimeters = params.PERIMETERS|default(2)|int %} # number of perimeters to print the shell
|
|
{% set fan_speed = params.FAN_SPEED|default(20)|int %} # part cooling fan speed in percent (0-100)
|
|
|
|
{% set e_multiplier = params.EXTRUSION_MULTIPLIER|default(1.00)|float %} # extrusion multiplier for the shell
|
|
{% set filament_diameter = params.FILAMENT_DIAMETER|default(1.75)|float %} # filament diameter
|
|
{% set extrusion_width = params.EXTRUSION_WIDTH|default(0.4)|float %} # extrusion width goal for one line
|
|
{% set layer_height = params.LAYER_HEIGHT|default(0.2)|float %} # layer height for the print
|
|
|
|
{% set retract_length = params.RETRACT_LENGTH|default(0.5)|float %} # how much to retract when traveling between print moves
|
|
{% set initial_purge = params.PURGE_MM|default(1)|int %} # mm of filament to purge before printing. set to 0 to disable
|
|
{% set z_hop_height = 2 * layer_height %}
|
|
|
|
{% set feedrate_print = params.CONTROL_SPEED|default(100)|int * 60 %} # print feedrate
|
|
{% set feedrate_travel = params.TRAVEL_SPEED|default(200)|int * 60 %} # travel feedrate between print moves
|
|
{% set feedrate_raft = params.RAFT_SPEED|default(60)|int * 60 %} # print feedrate for printing raft
|
|
{% set feedrate_z = params.Z_LIFT_SPEED|default(20)|int * 60 %} # z axis travel feedrate
|
|
{% set feedrate_retract = params.RETRACT_SPEED|default(50)|int * 60 %} # retract and deretract feedrate
|
|
|
|
#
|
|
# COMPUTED VALUES
|
|
#
|
|
{% set e_per_mm = ((extrusion_width - layer_height) * layer_height + 3.14159 * (layer_height / 2)**2) / (3.14159 * (filament_diameter / 2)**2) %} # computed E factor (similar to Slic3r/PrusaSlicer/SuperSlicer)
|
|
{% set spacing = extrusion_width - layer_height * (1 - 3.14159 / 4) %} # line spacing during the print
|
|
{% set shell_thickness = extrusion_width + (number_of_perimeters|float - 1) * spacing %} # theoric shell thickness
|
|
|
|
{% set max_x = printer.toolhead.axis_maximum.x|float %}
|
|
{% set max_y = printer.toolhead.axis_maximum.y|float %}
|
|
{% set x_start = max_x / 2 - print_size / 2 %}
|
|
{% set y_start = max_y / 2 - print_size / 2 %}
|
|
{% set x_end = x_start + print_size %}
|
|
{% set y_end = y_start + print_size %}
|
|
|
|
{% set num_raft_lines = ([print_size, max_x]|min / spacing)|round(0, 'floor')|int %}
|
|
{% set raft_size = num_raft_lines * spacing %}
|
|
|
|
#
|
|
# STARTING...
|
|
#
|
|
{action_respond_info("")}
|
|
{action_respond_info("Starting extrusion flow calibration print")}
|
|
{action_respond_info("This operation can not be interrupted by normal means. Hit the \"emergency stop\" button to stop it if needed")}
|
|
{action_respond_info("")}
|
|
{action_respond_info("Exrusion multiplier used: %.4f" % e_multiplier)}
|
|
{action_respond_info("Number of perimeters to print: %d" % number_of_perimeters)}
|
|
{action_respond_info("THEORIC SHELL THICKNESS: %.4f" % shell_thickness)}
|
|
{action_respond_info("")}
|
|
{action_respond_info("Measure the shell thickness using a caliper or micrometer. Then call the computation macro with the measured value:")}
|
|
{action_respond_info("COMPUTE_FLOW_MULTIPLIER MEASURED_THICKNESS=xxx.xxx")}
|
|
{action_respond_info("")}
|
|
|
|
SAVE_GCODE_STATE NAME=STATE_FLOW_MULTIPLIER_CALIBRATION
|
|
|
|
#
|
|
# set variables for later computation
|
|
#
|
|
SET_GCODE_VARIABLE MACRO=_FLOW_CALIB_VARIABLES VARIABLE=last_shell_thickness VALUE={shell_thickness}
|
|
SET_GCODE_VARIABLE MACRO=_FLOW_CALIB_VARIABLES VARIABLE=last_evalue VALUE={e_multiplier}
|
|
|
|
#
|
|
# purging before raft
|
|
#
|
|
G90
|
|
M83
|
|
G92 E0.0
|
|
G0 X{x_start} Y{y_start - 5} Z{layer_height} F{feedrate_travel} # move at the start position to do a purge line
|
|
|
|
G91 # use relative coordinates for the prime line
|
|
G1 E{initial_purge} F{5 * 60}
|
|
G1 X{raft_size} E{raft_size * e_per_mm * 1.5} F{feedrate_raft / 2} # print prime line
|
|
G1 Y-{extrusion_width} E{extrusion_width * e_per_mm} F{feedrate_raft / 2} # move to next line
|
|
G1 X-{raft_size} E{raft_size * e_per_mm} F{feedrate_raft / 2} # print second prime line
|
|
|
|
G1 E-{retract_length} F{feedrate_retract} # retract
|
|
G0 Z{z_hop_height} F{feedrate_z} # z-hop
|
|
|
|
G90 # back to absolute coordinates
|
|
G0 X{x_start} Y{y_start} F{feedrate_travel} # move to start position
|
|
G1 Z{layer_height} F{feedrate_z} # move to print height
|
|
G1 E{retract_length} F{feedrate_retract} # unretract
|
|
|
|
# set extrude_factor
|
|
M221 S{e_multiplier * 100}
|
|
|
|
#
|
|
# print the raft
|
|
#
|
|
{% if do_raft == 1 %}
|
|
G91 # use relative coordinates for the raft
|
|
{% for curr_raft_line in range(1, num_raft_lines + 2) %}
|
|
# print a raft line with alternating direction
|
|
G1 Y{loop.cycle(1.0, -1.0) * raft_size} E{raft_size * e_per_mm} F{feedrate_raft}
|
|
|
|
# spacing move
|
|
{% if not loop.last %}
|
|
G1 X{spacing} E{spacing * e_per_mm} F{feedrate_raft}
|
|
{% endif %}
|
|
{% endfor %}
|
|
|
|
G1 E-{retract_length} F{feedrate_retract} # retract
|
|
G0 Z{z_hop_height} F{feedrate_z} # z-hop
|
|
G90 # back to absolute coordinates
|
|
{% endif %}
|
|
|
|
#
|
|
# print the shell
|
|
#
|
|
G90
|
|
M106 S{fan_speed * 255 / 100}
|
|
|
|
# for each layer
|
|
{% for curr_layer in range(1, (print_height / layer_height)|round|int) %}
|
|
G0 X{x_start + corner_radius} Y{y_start} F{feedrate_travel} # move to XY start position
|
|
G1 Z{(curr_layer * layer_height) + (layer_height if do_raft == 1 else 0)} F{feedrate_z} # move to Z start position
|
|
|
|
# print one layer of the shell (in a for loop to do all the perimeters of one layer)
|
|
{% for perim_num in range(number_of_perimeters) %}
|
|
# compute values for the current perimeter (offset and radius)
|
|
{% set perim_offset = perim_num * spacing %}
|
|
{% set perim_radius = corner_radius - (perim_num * spacing) %}
|
|
|
|
# start position of the current perimeter
|
|
G1 X{x_start + corner_radius} Y{y_start + perim_offset} F{feedrate_travel}
|
|
{% if do_retract == 1 %}
|
|
G1 E{retract_length} F{feedrate_retract} # unretract
|
|
{% endif %}
|
|
|
|
# print the perimeter using the offset and radius computed
|
|
G1 X{x_end - corner_radius} Y{y_start + perim_offset} E{(print_size - (2 * corner_radius)) * e_per_mm} F{feedrate_print}
|
|
G3 X{x_end - perim_offset} Y{y_start + corner_radius} J{perim_radius} E{(3.14159 / 2) * perim_radius * e_per_mm} F{feedrate_print}
|
|
G1 X{x_end - perim_offset} Y{y_end - corner_radius} E{(print_size - (2 * corner_radius)) * e_per_mm} F{feedrate_print}
|
|
G3 X{x_end - corner_radius} Y{y_end - perim_offset} I-{perim_radius} E{(3.14159 / 2) * perim_radius * e_per_mm} F{feedrate_print}
|
|
G1 X{x_start + corner_radius} Y{y_end - perim_offset} E{(print_size - (2 * corner_radius)) * e_per_mm} F{feedrate_print}
|
|
G3 X{x_start + perim_offset} Y{y_end - corner_radius} J-{perim_radius} E{(3.14159 / 2) * perim_radius * e_per_mm} F{feedrate_print}
|
|
G1 X{x_start + perim_offset} Y{y_start + corner_radius} E{(print_size - (2 * corner_radius)) * e_per_mm} F{feedrate_print}
|
|
G3 X{x_start + corner_radius} Y{y_start + perim_offset} I{perim_radius} E{(3.14159 / 2) * perim_radius * e_per_mm} F{feedrate_print}
|
|
|
|
{% if do_retract == 1 %}
|
|
G1 E-{retract_length} F{feedrate_retract} # retract
|
|
{% endif %}
|
|
{% endfor %}
|
|
|
|
{% if do_retract == 1 %}
|
|
G91
|
|
G0 Z{z_hop_height} F{feedrate_z}
|
|
G90
|
|
{% endif %}
|
|
{% endfor %}
|
|
|
|
#
|
|
# retract and move away
|
|
#
|
|
G1 E-{retract_length} F{feedrate_retract}
|
|
G91
|
|
G0 Z20 F{feedrate_travel}
|
|
|
|
RESTORE_GCODE_STATE NAME=STATE_FLOW_MULTIPLIER_CALIBRATION
|
|
|
|
|
|
[gcode_macro COMPUTE_FLOW_MULTIPLIER]
|
|
description: Compute a new flow multiplier by using the measured shell thickness on the calibration print
|
|
gcode:
|
|
{% set evalue = params.OLD_EXTRUSION_MULTIPLIER|default(0.0)|float %} # extrusion multiplier used for the calibration print
|
|
{% set theorical_thickness = params.THEORICAL_THICKNESS|default(0.0)|float %} # theorical shell thickness
|
|
{% set measured_thickness = params.MEASURED_THICKNESS|default(0.0)|float %} # measured shell thickness on the calibration print
|
|
|
|
# if there is no OLD_EXTRUSION_MULTIPLIER passed as param, get the one from the last print calib run
|
|
{% if evalue == 0.0 %}
|
|
{% set last_evalue = printer["gcode_macro _FLOW_CALIB_VARIABLES"].last_evalue %}
|
|
|
|
# then, if there is also no evalue saved from the last run, alert user
|
|
{% if last_evalue == 0.0 %}
|
|
{action_respond_info("It seems that no calibration print was run prior to this (or a restart of Klipper occured).")}
|
|
{action_respond_info("You can still manually use it by calling again this macro like that:")}
|
|
{action_respond_info("COMPUTE_FLOW_MULTIPLIER OLD_EXTRUSION_MULTIPLIER=xxx.xxx THEORICAL_THICKNESS=xxx.xxx MEASURED_THICKNESS=xxx.xxx")}
|
|
{action_raise_error("not enough data to perform the computation of the new flow !")}
|
|
{% else %}
|
|
{% set final_evalue = last_evalue %}
|
|
{action_respond_info("Using OLD_EXTRUSION_MULTIPLIER: %.3f" % final_evalue)}
|
|
{% endif %}
|
|
{% else %}
|
|
{% set final_evalue = evalue %}
|
|
{action_respond_info("Using OLD_EXTRUSION_MULTIPLIER: %.3f" % final_evalue)}
|
|
{% endif %}
|
|
|
|
# similarly, if there is no THEORICAL_THICKNESS passed as param, get the one from the last print calib run
|
|
{% if theorical_thickness == 0.0 %}
|
|
{% set last_shell_thickness = printer["gcode_macro _FLOW_CALIB_VARIABLES"].last_shell_thickness %}
|
|
|
|
# then, if there is also no evalue saved from the last run, alert user
|
|
{% if last_shell_thickness == 0.0 %}
|
|
{action_respond_info("It seems that no calibration print was run prior to this (or a restart of Klipper occured).")}
|
|
{action_respond_info("You can still manually use it by calling again this macro like that:")}
|
|
{action_respond_info("COMPUTE_FLOW_MULTIPLIER OLD_EXTRUSION_MULTIPLIER=xxx.xxx THEORICAL_THICKNESS=xxx.xxx MEASURED_THICKNESS=xxx.xxx")}
|
|
{action_raise_error("not enough data to perform the computation of the new flow !")}
|
|
{% else %}
|
|
{% set final_theorical_thickness = last_shell_thickness %}
|
|
{action_respond_info("Using THEORICAL_THICKNESS: %.3f" % final_theorical_thickness)}
|
|
{% endif %}
|
|
{% else %}
|
|
{% set final_theorical_thickness = theorical_thickness %}
|
|
{action_respond_info("Using THEORICAL_THICKNESS: %.3f" % final_theorical_thickness)}
|
|
{% endif %}
|
|
|
|
# use the measured thickness from the user to compute a new flow value
|
|
{% if measured_thickness == 0.0 %}
|
|
{action_respond_info("You must use a caliper or micrometer to measure the calibration print shell thickness and call this macro with the measured value !!!")}
|
|
{action_respond_info("COMPUTE_FLOW_MULTIPLIER MEASURED_THICKNESS=xxx.xxx")}
|
|
{action_raise_error("not enough data to perform the computation of the new flow !")}
|
|
{% else %}
|
|
{% set new_evalue = final_theorical_thickness * final_evalue / measured_thickness %}
|
|
{action_respond_info("NEW COMPUTED FLOW VALUE: %.3f" % new_evalue)}
|
|
{action_respond_info("Use this new value as extrusion multiplier in your slicer of choice")}
|
|
{action_respond_info("")}
|
|
{% endif %}
|