Starting Klippy...
Args: ['/home/pi/klipper/klippy/klippy.py', '/home/pi/printer_data/config/printer.cfg', '-I', '/home/pi/printer_data/comms/klippy.serial', '-l', '/home/pi/printer_data/logs/klippy.log', '-a', '/home/pi/printer_data/comms/klippy.sock']
Git version: 'v0.11.0-234-gd32a8334'
Branch: master
Remote: origin
Tracked URL: https://github.com/Klipper3d/klipper
CPU: 4 core ?
Python: '3.9.2 (default, Mar 12 2021, 04:06:34) \n[GCC 10.2.1 20210110]'
Building C code module c_helper.so
Start printer at Thu Jun 22 20:24:14 2023 (1687461854.5 469.4)
===== Config file =====
[virtual_sdcard]
path = /home/pi/printer_data/gcodes
on_error_gcode = CANCEL_PRINT

[pause_resume]

[display_status]

[gcode_macro CANCEL_PRINT]
description = Cancel the actual running print
rename_existing = CANCEL_PRINT_BASE
gcode = 
	TURN_OFF_HEATERS
	CANCEL_PRINT_BASE

[gcode_macro PAUSE]
description = Pause the actual running print
rename_existing = PAUSE_BASE
gcode = 
	
	{% set E = printer["gcode_macro PAUSE"].extrude|float %}
	
	
	{% set x_park = printer.toolhead.axis_maximum.x|float - 5.0 %}
	{% set y_park = printer.toolhead.axis_maximum.y|float - 5.0 %}
	
	{% set max_z = printer.toolhead.axis_maximum.z|float %}
	{% set act_z = printer.toolhead.position.z|float %}
	{% if act_z < (max_z - 2.0) %}
	{% set z_safe = 2.0 %}
	{% else %}
	{% set z_safe = max_z - act_z %}
	{% endif %}
	
	PAUSE_BASE
	G91
	{% if printer.extruder.can_extrude|lower == 'true' %}
	G1 E-{E} F2100
	{% else %}
	{action_respond_info("Extruder not hot enough")}
	{% endif %}
	{% if "xyz" in printer.toolhead.homed_axes %}
	G1 Z{z_safe} F900
	G90
	G1 X{x_park} Y{y_park} F6000
	{% else %}
	{action_respond_info("Printer not homed")}
	{% endif %}
variable_extrude = 1.0

[gcode_macro RESUME]
description = Resume the actual running print
rename_existing = RESUME_BASE
variable_last_extruder_temp = 0
gcode = 
	
	{% set E = printer["gcode_macro PAUSE"].extrude|float %}
	
	{% if 'VELOCITY' in params|upper %}
	{% set get_params = ('VELOCITY=' + params.VELOCITY)  %}
	{%else %}
	{% set get_params = "" %}
	{% endif %}
	
	{% if printer.extruder.can_extrude|lower == 'true' %}
	G91
	G1 E{E} F2100
	{% else %}
	{action_respond_info("Extruder not hot enough")}
	{% endif %}
	RESUME_BASE {get_params}

[gcode_macro SET_PAUSE_NEXT_LAYER]
description = Enable a pause if the next layer is reached
gcode = 
	{% set pause_next_layer = printer['gcode_macro SET_PRINT_STATS_INFO'].pause_next_layer %}
	{% set ENABLE = params.ENABLE | default(1) | int != 0 %}
	{% set MACRO = params.MACRO | default(pause_next_layer.call, True) %}
	SET_GCODE_VARIABLE MACRO=SET_PRINT_STATS_INFO VARIABLE=pause_next_layer VALUE="{{ 'enable': ENABLE, 'call': MACRO }}"

[gcode_macro SET_PAUSE_AT_LAYER]
description = Enable/disable a pause if a given layer number is reached
gcode = 
	{% set pause_at_layer = printer['gcode_macro SET_PRINT_STATS_INFO'].pause_at_layer %}
	{% set ENABLE = params.ENABLE | int != 0 if params.ENABLE is defined
	else params.LAYER is defined %}
	{% set LAYER = params.LAYER | default(pause_at_layer.layer) | int %}
	{% set MACRO = params.MACRO | default(pause_at_layer.call, True) %}
	SET_GCODE_VARIABLE MACRO=SET_PRINT_STATS_INFO VARIABLE=pause_at_layer VALUE="{{ 'enable': ENABLE, 'layer': LAYER, 'call': MACRO }}"

[gcode_macro SET_PRINT_STATS_INFO]
rename_existing = SET_PRINT_STATS_INFO_BASE
description = Overwrite, to get pause_next_layer and pause_at_layer feature
variable_pause_next_layer = { 'enable': False, 'call': "PAUSE" }
variable_pause_at_layer = { 'enable': False, 'layer': 0, 'call': "PAUSE" }
gcode = 
	{% if pause_next_layer.enable %}
	{action_respond_info("%s, forced by pause_next_layer" % pause_next_layer.call)}
	{pause_next_layer.call}
	SET_PAUSE_NEXT_LAYER ENABLE=0
	{% elif pause_at_layer.enable and params.CURRENT_LAYER is defined and params.CURRENT_LAYER|int == pause_at_layer.layer %}
	{action_respond_info("%s, forced by pause_at_layer [%d]" % (pause_at_layer.call, pause_at_layer.layer))}
	{pause_at_layer.call}
	SET_PAUSE_AT_LAYER ENABLE=0
	{% endif %}
	SET_PRINT_STATS_INFO_BASE {rawparams}

[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL]
description = Helper: park toolhead used in PAUSE and CANCEL_PRINT
gcode = 
	
	{% set macro_found = True if printer['gcode_macro _CLIENT_VARIABLE'] is defined else False %}
	{% set client = printer['gcode_macro _CLIENT_VARIABLE'] %}
	{% set velocity = printer.configfile.settings.pause_resume.recover_velocity %}
	{% set use_custom     = False if not macro_found
	else False if client.use_custom_pos is not defined
	else True  if client.use_custom_pos|lower == 'true'
	else False %}
	{% set custom_park_x  = 0.0 if not macro_found else client.custom_park_x|default(0.0) %}
	{% set custom_park_y  = 0.0 if not macro_found else client.custom_park_y|default(0.0) %}
	{% set park_dz        = 2.0 if not macro_found else client.custom_park_dz|default(2.0)|abs %}
	{% set sp_hop         = 900  if not macro_found else client.speed_hop|default(15) * 60 %}
	{% set sp_move        = velocity * 60 if not macro_found else client.speed_move|default(velocity) * 60 %}
	
	{% set origin    = printer.gcode_move.homing_origin %}
	{% set act       = printer.gcode_move.gcode_position %}
	{% set max       = printer.toolhead.axis_maximum %}
	{% set cone      = printer.toolhead.cone_start_z|default(max.z) %}
	{% set round_bed = True if printer.configfile.settings.printer.kinematics is in ['delta','polar','rotary_delta','winch']
	else False %}
	
	{% set z_min = params.Z_MIN|default(0)|float %}
	{% set z_park = [[(act.z + park_dz), z_min]|max, (max.z - origin.z)]|min %}
	{% set x_park = params.X       if params.X is defined
	else custom_park_x  if use_custom
	else 0.0            if round_bed
	else (max.x - 5.0) %}
	{% set y_park = params.Y       if params.Y is defined
	else custom_park_y  if use_custom
	else (max.y - 5.0)  if round_bed and z_park < cone
	else 0.0            if round_bed
	else (max.y - 5.0) %}
	
	_CLIENT_RETRACT
	{% if "xyz" in printer.toolhead.homed_axes %}
	G90
	G1 Z{z_park} F{sp_hop}
	G1 X{x_park} Y{y_park} F{sp_move}
	{% if not printer.gcode_move.absolute_coordinates %} G91 {% endif %}
	{% else %}
	{action_respond_info("Printer not homed")}
	{% endif %}

[gcode_macro _CLIENT_EXTRUDE]
description = Extrudes, if the extruder is hot enough
gcode = 
	{% set macro_found = True if printer['gcode_macro _CLIENT_VARIABLE'] is defined else False %}
	{% set client = printer['gcode_macro _CLIENT_VARIABLE'] %}
	{% set use_fw_retract = False if not macro_found
	else False if client.use_fw_retract is not defined
	else True  if client.use_fw_retract|lower == 'true' and printer.firmware_retraction is defined
	else False %}
	
	{% set length = (params.LENGTH|float) if params.LENGTH is defined
	else 1.0 if not macro_found
	else client.unretract|default(1.0) %}
	
	{% set speed = params.SPEED if params.SPEED is defined
	else 35 if not macro_found
	else client.speed_unretract|default(35) %}
	
	{% set absolute_extrude = printer.gcode_move.absolute_extrude %}
	
	{% if printer.extruder.can_extrude %}
	{% if use_fw_retract %}
	{% if length < 0 %}
	G10
	{% else %}
	G11
	{% endif %}
	{% else %}
	M83
	G1 E{length} F{(speed|float|abs) * 60}
	{% if absolute_extrude %}
	M82
	{% endif %}
	{% endif %}
	{% else %}
	{action_respond_info("Extruder not hot enough")}
	{% endif %}

[gcode_macro _CLIENT_RETRACT]
description = Retracts, if the extruder is hot enough
gcode = 
	{% set macro_found = True if printer['gcode_macro _CLIENT_VARIABLE'] is defined else False %}
	{% set client = printer['gcode_macro _CLIENT_VARIABLE'] %}
	
	{% set length = (params.LENGTH|float) if params.LENGTH is defined
	else 1.0 if not macro_found
	else client.retract|default(1.0) %}
	
	{% set speed = params.SPEED if params.SPEED is defined
	else 35 if not macro_found
	else client.speed_retract|default(35) %}
	
	_CLIENT_EXTRUDE LENGTH=-{length|float|abs} SPEED={speed|float|abs}

[gcode_macro GET_TIMELAPSE_SETUP]
description = Print the Timelapse setup
gcode = 
	{% set tl = printer['gcode_macro TIMELAPSE_TAKE_FRAME'] %}
	{% set output_txt = ["Timelapse Setup:"] %}
	{% set _dummy = output_txt.append("enable: %s" % tl.enable) %}
	{% set _dummy = output_txt.append("park: %s" % tl.park.enable) %}
	{% if tl.park.enable %}
	{% set _dummy = output_txt.append("park position: %s time: %s s" % (tl.park.pos, tl.park.time)) %}
	{% set _dummy = output_txt.append("park cord x:%s y:%s dz:%s" % (tl.park.coord.x, tl.park.coord.y, tl.park.coord.dz)) %}
	{% set _dummy = output_txt.append("travel speed: %s mm/s" % tl.speed.travel) %}
	{% endif %}
	{% set _dummy = output_txt.append("fw_retract: %s" % tl.extruder.fw_retract) %}
	{% if not tl.extruder.fw_retract %}
	{% set _dummy = output_txt.append("retract: %s mm speed: %s mm/s" % (tl.extruder.retract, tl.speed.retract)) %}
	{% set _dummy = output_txt.append("extrude: %s mm speed: %s mm/s" % (tl.extruder.extrude, tl.speed.extrude)) %}
	{% endif %}
	{% set _dummy = output_txt.append("verbose: %s" % tl.verbose) %}
	{action_respond_info(output_txt|join("\n"))}

[gcode_macro _SET_TIMELAPSE_SETUP]
description = Set user parameters for timelapse
gcode = 
	{% set tl = printer['gcode_macro TIMELAPSE_TAKE_FRAME'] %}
	
	{% set min = printer.toolhead.axis_minimum %}
	{% set max = printer.toolhead.axis_maximum %}
	{% set round_bed = True if printer.configfile.settings.printer.kinematics is in ['delta','polar','rotary_delta','winch']
	else False %}
	{% set park = {'min'   : {'x': (min.x / 1.42)|round(3) if round_bed else min.x|round(3),
	'y': (min.y / 1.42)|round(3) if round_bed else min.y|round(3)},
	'max'   : {'x': (max.x / 1.42)|round(3) if round_bed else max.x|round(3),
	'y': (max.y / 1.42)|round(3) if round_bed else max.y|round(3)},
	'center': {'x': (max.x-(max.x-min.x)/2)|round(3),
	'y': (max.y-(max.y-min.y)/2)|round(3)}} %}
	
	{% if params.ENABLE %}
	{% if params.ENABLE|lower is in ['true', 'false'] %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=enable VALUE={True if params.ENABLE|lower == 'true' else False}
	{% else %}
	{action_raise_error("ENABLE=%s not supported. Allowed values are [True, False]" % params.ENABLE|capitalize)}
	{% endif %}
	{% endif %}
	{% if params.VERBOSE %}
	{% if params.VERBOSE|lower is in ['true', 'false'] %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=verbose VALUE={True if params.VERBOSE|lower == 'true' else False}
	{% else %}
	{action_raise_error("VERBOSE=%s not supported. Allowed values are [True, False]" % params.VERBOSE|capitalize)}
	{% endif %}
	{% endif %}
	{% if params.CUSTOM_POS_X %}
	{% if params.CUSTOM_POS_X|float >= min.x and params.CUSTOM_POS_X|float <= max.x %}
	{% set _dummy = tl.park.custom.update({'x':params.CUSTOM_POS_X|float|round(3)}) %}
	{% else %}
	{action_raise_error("CUSTOM_POS_X=%s must be within [%s - %s]" % (params.CUSTOM_POS_X, min.x, max.x))}
	{% endif %}
	{% endif %}
	{% if params.CUSTOM_POS_Y %}
	{% if params.CUSTOM_POS_Y|float >= min.y and params.CUSTOM_POS_Y|float <= max.y %}
	{% set _dummy = tl.park.custom.update({'y':params.CUSTOM_POS_Y|float|round(3)}) %}
	{% else %}
	{action_raise_error("CUSTOM_POS_Y=%s must be within [%s - %s]" % (params.CUSTOM_POS_Y, min.y, max.y))}
	{% endif %}
	{% endif %}
	{% if params.CUSTOM_POS_DZ %}
	{% if params.CUSTOM_POS_DZ|float >= min.z and params.CUSTOM_POS_DZ|float <= max.z %}
	{% set _dummy = tl.park.custom.update({'dz':params.CUSTOM_POS_DZ|float|round(3)}) %}
	{% else %}
	{action_raise_error("CUSTOM_POS_DZ=%s must be within [%s - %s]" % (params.CUSTOM_POS_DZ, min.z, max.z))}
	{% endif %}
	{% endif %}
	{% if params.PARK_ENABLE %}
	{% if params.PARK_ENABLE|lower is in ['true', 'false'] %}
	{% set _dummy = tl.park.update({'enable':True if params.PARK_ENABLE|lower == 'true' else False}) %}
	{% else %}
	{action_raise_error("PARK_ENABLE=%s not supported. Allowed values are [True, False]" % params.PARK_ENABLE|capitalize)}
	{% endif %}
	{% endif %}
	{% if params.PARK_POS %}
	{% if params.PARK_POS|lower is in ['center','front_left','front_right','back_left','back_right','custom','x_only','y_only'] %}
	{% set dic = {'center'      : {'x': park.center.x   , 'y': park.center.y   , 'dz': 1                },
	'front_left'  : {'x': park.min.x      , 'y': park.min.y      , 'dz': 0                },
	'front_right' : {'x': park.max.x      , 'y': park.min.y      , 'dz': 0                },
	'back_left'   : {'x': park.min.x      , 'y': park.max.y      , 'dz': 0                },
	'back_right'  : {'x': park.max.x      , 'y': park.max.y      , 'dz': 0                },
	'custom'      : {'x': tl.park.custom.x, 'y': tl.park.custom.y, 'dz': tl.park.custom.dz},
	'x_only'      : {'x': tl.park.custom.x, 'y': 'none'          , 'dz': tl.park.custom.dz},
	'y_only'      : {'x': 'none'          , 'y': tl.park.custom.y, 'dz': tl.park.custom.dz}} %}
	{% set _dummy = tl.park.update({'pos':params.PARK_POS|lower}) %}
	{% set _dummy = tl.park.update({'coord':dic[tl.park.pos]}) %}
	{% else %}
	{action_raise_error("PARK_POS=%s not supported. Allowed values are [CENTER, FRONT_LEFT, FRONT_RIGHT, BACK_LEFT, BACK_RIGHT, CUSTOM, X_ONLY, Y_ONLY]"
	% params.PARK_POS|upper)}
	{% endif %}
	{% endif %}
	{% if params.PARK_TIME %}
	{% if params.PARK_TIME|float >= 0.0 %}
	{% set _dummy = tl.park.update({'time':params.PARK_TIME|float|round(3)}) %}
	{% else %}
	{action_raise_error("PARK_TIME=%s must be a positive number" % params.PARK_TIME)}
	{% endif %}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=park VALUE="{tl.park}"
	{% if params.TRAVEL_SPEED %}
	{% if params.TRAVEL_SPEED|float > 0.0 %}
	{% set _dummy = tl.speed.update({'travel':params.TRAVEL_SPEED|float|round(3)}) %}
	{% else %}
	{action_raise_error("TRAVEL_SPEED=%s must be larger than 0" % params.TRAVEL_SPEED)}
	{% endif %}
	{% endif %}
	{% if params.RETRACT_SPEED %}
	{% if params.RETRACT_SPEED|float > 0.0 %}
	{% set _dummy = tl.speed.update({'retract':params.RETRACT_SPEED|float|round(3)}) %}
	{% else %}
	{action_raise_error("RETRACT_SPEED=%s must be larger than 0" % params.RETRACT_SPEED)}
	{% endif %}
	{% endif %}
	{% if params.EXTRUDE_SPEED %}
	{% if params.EXTRUDE_SPEED|float > 0.0 %}
	{% set _dummy = tl.speed.update({'extrude':params.EXTRUDE_SPEED|float|round(3)}) %}
	{% else %}
	{action_raise_error("EXTRUDE_SPEED=%s must be larger than 0" % params.EXTRUDE_SPEED)}
	{% endif %}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=speed VALUE="{tl.speed}"
	{% if params.EXTRUDE_DISTANCE %}
	{% if params.EXTRUDE_DISTANCE|float >= 0.0 %}
	{% set _dummy = tl.extruder.update({'extrude':params.EXTRUDE_DISTANCE|float|round(3)}) %}
	{% else %}
	{action_raise_error("EXTRUDE_DISTANCE=%s must be specified as positiv number" % params.EXTRUDE_DISTANCE)}
	{% endif %}
	{% endif %}
	{% if params.RETRACT_DISTANCE %}
	{% if params.RETRACT_DISTANCE|float >= 0.0 %}
	{% set _dummy = tl.extruder.update({'retract':params.RETRACT_DISTANCE|float|round(3)}) %}
	{% else %}
	{action_raise_error("RETRACT_DISTANCE=%s must be specified as positiv number" % params.RETRACT_DISTANCE)}
	{% endif %}
	{% endif %}
	{% if params.FW_RETRACT %}
	{% if params.FW_RETRACT|lower is in ['true', 'false'] %}
	{% if 'firmware_retraction' in printer.configfile.settings %}
	{% set _dummy = tl.extruder.update({'fw_retract': True if params.FW_RETRACT|lower == 'true' else False}) %}
	{% else %}
	{% set _dummy = tl.extruder.update({'fw_retract':False}) %}
	{% if params.FW_RETRACT|capitalize == 'True' %}
	{action_raise_error("[firmware_retraction] not defined in printer.cfg. Can not enable fw_retract")}
	{% endif %}
	{% endif %}
	{% else %}
	{action_raise_error("FW_RETRACT=%s not supported. Allowed values are [True, False]" % params.FW_RETRACT|capitalize)}
	{% endif %}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=extruder VALUE="{tl.extruder}"
	{% if printer.configfile.settings['gcode_macro pause'] is defined %}
	{% set _dummy = tl.macro.update({'pause': printer.configfile.settings['gcode_macro pause'].rename_existing}) %}
	{% endif %}
	{% if printer.configfile.settings['gcode_macro resume'] is defined %}
	{% set _dummy = tl.macro.update({'resume': printer.configfile.settings['gcode_macro resume'].rename_existing}) %}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=macro VALUE="{tl.macro}"

[gcode_macro TIMELAPSE_TAKE_FRAME]
description = Take Timelapse shoot
variable_enable = False
variable_takingframe = False
variable_park = {'enable': False,
	'pos'   : 'center',
	'time'  : 0.1,
	'custom': {'x': 0, 'y': 0, 'dz': 0},
	'coord' : {'x': 0, 'y': 0, 'dz': 0}}
variable_extruder = {'fw_retract': False,
	'retract': 1.0,
	'extrude': 1.0}
variable_speed = {'travel': 100,
	'retract': 15,
	'extrude': 15}
variable_verbose = True
variable_restore = {'absolute': {'coordinates': True, 'extrude': True}, 'speed': 1500, 'e':0, 'factor': {'speed': 1.0, 'extrude': 1.0}}
variable_macro = {'pause': 'PAUSE', 'resume': 'RESUME'}
variable_is_paused = False
gcode = 
	{% set hyperlapse = True if params.HYPERLAPSE and params.HYPERLAPSE|lower =='true' else False %}
	{% if enable %}
	{% if (hyperlapse and printer['gcode_macro HYPERLAPSE'].run) or
	(not hyperlapse and not printer['gcode_macro HYPERLAPSE'].run) %}
	{% if park.enable %}
	{% set pos = {'x': 'X' + park.coord.x|string if park.pos != 'y_only' else '',
	'y': 'Y' + park.coord.y|string if park.pos != 'x_only' else '',
	'z': 'Z'+ [printer.gcode_move.gcode_position.z + park.coord.dz, printer.toolhead.axis_maximum.z]|min|string} %}
	{% set restore = {'absolute': {'coordinates': printer.gcode_move.absolute_coordinates,
	'extrude'    : printer.gcode_move.absolute_extrude},
	'speed'   : printer.gcode_move.speed,
	'e'       : printer.gcode_move.gcode_position.e,
	'factor'  : {'speed'  : printer.gcode_move.speed_factor,
	'extrude': printer.gcode_move.extrude_factor}} %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=restore VALUE="{restore}"
	{% if not printer[printer.toolhead.extruder].can_extrude %}
	{% if verbose %}{action_respond_info("Timelapse: Warning, minimum extruder temperature not reached!")}{% endif %}
	{% else %}
	{% if extruder.fw_retract %}
	G10
	{% else %}
	M83
	G0 E-{extruder.retract} F{speed.retract * 60}
	{% endif %}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=is_paused VALUE=True
	{macro.pause}
	SET_GCODE_OFFSET X=0 Y=0
	G90
	{% if "xyz" not in printer.toolhead.homed_axes %}
	{% if verbose %}{action_respond_info("Timelapse: Warning, axis not homed yet!")}{% endif %}
	{% else %}
	G0 {pos.x} {pos.y} {pos.z} F{speed.travel * 60}
	{% endif %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=takingframe VALUE=True
	UPDATE_DELAYED_GCODE ID=_WAIT_TIMELAPSE_TAKE_FRAME DURATION=0.5
	M400
	{% endif %}
	_TIMELAPSE_NEW_FRAME HYPERLAPSE={hyperlapse}
	{% endif %}
	{% else %}
	{% if verbose %}{action_respond_info("Timelapse: disabled, take frame ignored")}{% endif %}
	{% endif %}

[gcode_macro _TIMELAPSE_NEW_FRAME]
description = action call for timelapse shoot. must be a seperate macro
gcode = 
	{action_call_remote_method("timelapse_newframe",
	macropark=printer['gcode_macro TIMELAPSE_TAKE_FRAME'].park,
	hyperlapse=params.HYPERLAPSE)}

[delayed_gcode _WAIT_TIMELAPSE_TAKE_FRAME]
gcode = 
	{% set tl = printer['gcode_macro TIMELAPSE_TAKE_FRAME'] %}
	{% set factor = {'speed': printer.gcode_move.speed_factor, 'extrude': printer.gcode_move.extrude_factor} %}
	{% if tl.takingframe %}
	UPDATE_DELAYED_GCODE ID=_WAIT_TIMELAPSE_TAKE_FRAME DURATION=0.5
	{% else %}
	{tl.macro.resume} VELOCITY={tl.speed.travel}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=is_paused VALUE=False
	{% if not printer[printer.toolhead.extruder].can_extrude %}
	{action_respond_info("Timelapse: Warning minimum extruder temperature not reached!")}
	{% else %}
	{% if tl.extruder.fw_retract %}
	G11
	{% else %}
	G0 E{tl.extruder.extrude} F{tl.speed.extrude * 60}
	G0 F{tl.restore.speed}
	{% if tl.restore.absolute.extrude %}
	M82
	G92 E{tl.restore.e}
	{% endif %}
	{% endif %}
	{% endif %}
	{% if tl.restore.factor.speed   != factor.speed   %} M220 S{(factor.speed*100)|round(0)}   {% endif %}
	{% if tl.restore.factor.extrude != factor.extrude %} M221 S{(factor.extrude*100)|round(0)} {% endif %}
	{% if not tl.restore.absolute.coordinates %} G91 {% endif %}
	{% endif %}

[gcode_macro HYPERLAPSE]
description = Start/Stop a hyperlapse recording
variable_cycle = 0
variable_run = False
gcode = 
	{% set cycle = params.CYCLE|default(30)|int %}
	{% if params.ACTION and params.ACTION|lower == 'start' %}
	{action_respond_info("Hyperlapse: frames started (Cycle %d sec)" % cycle)}
	SET_GCODE_VARIABLE MACRO=HYPERLAPSE VARIABLE=run VALUE=True
	SET_GCODE_VARIABLE MACRO=HYPERLAPSE VARIABLE=cycle VALUE={cycle}
	UPDATE_DELAYED_GCODE ID=_HYPERLAPSE_LOOP DURATION={cycle}
	TIMELAPSE_TAKE_FRAME HYPERLAPSE=True
	{% elif params.ACTION and params.ACTION|lower == 'stop' %}
	{% if run %}{action_respond_info("Hyperlapse: frames stopped")}{% endif %}
	SET_GCODE_VARIABLE MACRO=HYPERLAPSE VARIABLE=run VALUE=False
	UPDATE_DELAYED_GCODE ID=_HYPERLAPSE_LOOP DURATION=0
	{% else %}
	{action_raise_error("Hyperlapse: No valid input parameter
	Use:
	- HYPERLAPSE ACTION=START [CYCLE=time]
	- HYPERLAPSE ACTION=STOP")}
	{% endif %}

[delayed_gcode _HYPERLAPSE_LOOP]
gcode = 
	UPDATE_DELAYED_GCODE ID=_HYPERLAPSE_LOOP DURATION={printer["gcode_macro HYPERLAPSE"].cycle}
	TIMELAPSE_TAKE_FRAME HYPERLAPSE=True

[gcode_macro TIMELAPSE_RENDER]
description = Render Timelapse video and wait for the result
variable_render = False
variable_run_identifier = 0
gcode = 
	{action_respond_info("Timelapse: Rendering started")}
	{action_call_remote_method("timelapse_render", byrendermacro="True")}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_RENDER VARIABLE=render VALUE=True
	{printer.configfile.settings['gcode_macro pause'].rename_existing}
	UPDATE_DELAYED_GCODE ID=_WAIT_TIMELAPSE_RENDER DURATION=0.5

[delayed_gcode _WAIT_TIMELAPSE_RENDER]
gcode = 
	{% set ri = printer['gcode_macro TIMELAPSE_RENDER'].run_identifier % 4 %}
	SET_GCODE_VARIABLE MACRO=TIMELAPSE_RENDER VARIABLE=run_identifier VALUE={ri + 1}
	{% if printer['gcode_macro TIMELAPSE_RENDER'].render %}
	M117 Rendering {['-','\\','|','/'][ri]}
	UPDATE_DELAYED_GCODE ID=_WAIT_TIMELAPSE_RENDER DURATION=0.5
	{% else %}
	{action_respond_info("Timelapse: Rendering finished")}
	M117
	{printer.configfile.settings['gcode_macro resume'].rename_existing}
	{% endif %}

[gcode_macro TEST_STREAM_DELAY]
description = Helper macro to find stream and park delay
gcode = 
	{% set min = printer.toolhead.axis_minimum %}
	{% set max = printer.toolhead.axis_maximum %}
	{% set act = printer.toolhead.position %}
	{% set tl = printer['gcode_macro TIMELAPSE_TAKE_FRAME'] %}
	{% if act.z > 5.0 %}
	G0 X{min.x + 5.0} F{tl.speed.travel|int * 60}
	G0 X{(max.x-min.x)/2}
	G4 P{tl.park.time|float * 1000}
	_TIMELAPSE_NEW_FRAME HYPERLAPSE=FALSE
	G0 X{max.x - 5.0}
	{% else %}
	{action_raise_error("Toolhead z %.3f to low. Please place head above z = 5.0" % act.z)}
	{% endif %}

[exclude_object]

[stepper_x]
step_pin = PC2
dir_pin = PB9
enable_pin = !PC3
microsteps = 16
rotation_distance = 40
endstop_pin = !PA5
position_endstop = -6
position_min = -6
position_max = 253
homing_speed = 50

[stepper_y]
step_pin = PB8
dir_pin = PB7
enable_pin = !PC3
microsteps = 16
rotation_distance = 40
endstop_pin = !PA6
position_endstop = -12
position_min = -12
position_max = 221
homing_speed = 50

[stepper_z]
step_pin = PB6
dir_pin = !PB5
enable_pin = !PC3
microsteps = 16
rotation_distance = 8
endstop_pin = probe:z_virtual_endstop
position_max = 256
position_min = -5

[extruder]
max_extrude_only_distance = 100.0
step_pin = PB4
dir_pin = PB3
enable_pin = !PC3
microsteps = 16
rotation_distance = 7.5749
nozzle_diameter = 0.400
filament_diameter = 1.750
heater_pin = PA1
sensor_type = EPCOS 100K B57560G104F
sensor_pin = PC5
control = pid
pid_kp = 22.865
pid_ki = 1.292
pid_kd = 101.178
min_temp = 0
max_temp = 300
pressure_advance = 0.0335

[input_shaper]
shaper_freq_x = 57.6
shaper_type_x = mzv
shaper_freq_y = 32
shaper_type_y = mzv

[mcu rpi]
serial = /tmp/klipper_host_mcu

[output_pin LIGHT]
pin = !rpi:gpio26

[gcode_macro SWITCH_LIGHTS]
gcode = 
	SET_PIN PIN=Light VALUE={(not printer['output_pin Light'].value)|int}

[output_pin RELAY2]
pin = !rpi:gpio20

[gcode_macro SWITCH_RELAY2]
gcode = 
	SET_PIN PIN=RELAY2 VALUE={(not printer['output_pin RELAY2'].value)|int}

[output_pin RELAY3]
pin = !rpi:gpio21

[gcode_macro SWITCH_RELAY3]
gcode = 
	SET_PIN PIN=RELAY3 VALUE={(not printer['output_pin RELAY3'].value)|int}

[gcode_macro QUERY_BME280]
gcode = 
	{% set sensor = printer["bme280 enclosure_temp"] %}
	{action_respond_info(
	"Temperature: %.2f C\n"
	"Humidity: %.2f%%"
	"Pressure: %.2f hPa\n"% (
	sensor.temperature,
	sensor.humidity,
	sensor.pressure))}```

[gcode_macro hx711]
gcode = 
	{% set res = printer["hx711 test"] %}
	{ action_respond_info(res.value) }
	{ action_respond_info(res.raw_value) }

[bed_screws]
screw1 = 74, 32
screw2 = 249, 32
screw3 = 249, 201
screw4 = 74, 2001

[screws_tilt_adjust]
screw1 = 74, 32
screw1_name = front left screw
screw2 = 249, 32
screw2_name = front right screw
screw3 = 249, 201
screw3_name = rear right screw
screw4 = 74,201
screw4_name = rear left screw
screw_thread = CW-M4

[filament_switch_sensor RunoutSensor]
pause_on_runout = False
runout_gcode = PAUSE
insert_gcode = RESUME
switch_pin = !PC15

[heater_bed]
heater_pin = PA7
sensor_type = EPCOS 100K B57560G104F
sensor_pin = PC4
control = pid
pid_kp = 69.139
pid_ki = 1.273
pid_kd = 938.565
min_temp = 0
max_temp = 130

[heater_fan hotend_fan]
pin = PC0
heater = extruder
heater_temp = 50.0
fan_speed = 0.6

[fan]
pin = PA0

[mcu]
serial = /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0
restart_method = command

[printer]
kinematics = cartesian
max_velocity = 500
max_accel = 3000
max_accel_to_decel = 3000
max_z_velocity = 5
square_corner_velocity = 5.0
max_z_accel = 100

[bltouch]
sensor_pin = ^PC14
control_pin = PC13
x_offset = -48
y_offset = 0
speed = 10
samples = 2
samples_result = average
probe_with_touch_mode = true
stow_on_each_sample = false
z_offset = 2.464

[safe_z_home]
home_xy_position = 165,128
speed = 100
z_hop = 10
z_hop_speed = 5

[bed_mesh]
speed = 100
mesh_min = 10, 10
mesh_max = 205, 220
algorithm = bicubic
probe_count = 8,8

[temperature_sensor Board_MCU]
sensor_type = temperature_mcu
min_temp = 0
max_temp = 100

[temperature_sensor Raspberry_Pi]
sensor_type = temperature_host
min_temp = 0
max_temp = 100

[bed_mesh default]
version = 1
points = 
	0.081250, 0.067500, 0.058750, 0.046250, 0.041250, 0.035000, 0.035000, 0.046250
	0.022500, 0.020000, 0.016250, 0.010000, 0.011250, 0.013750, -0.017500, -0.033750
	-0.031250, -0.052500, -0.043750, -0.053750, -0.055000, -0.051250, -0.075000, -0.081250
	-0.057500, -0.045000, -0.032500, -0.043750, -0.058750, -0.051250, -0.068750, -0.087500
	-0.043750, -0.047500, -0.053750, -0.042500, -0.061250, -0.046250, -0.060000, -0.067500
	-0.015000, -0.005000, 0.005000, -0.007500, -0.006250, -0.007500, -0.048750, -0.048750
	0.010000, -0.007500, 0.022500, -0.003750, 0.000000, -0.001250, 0.003750, -0.022500
	-0.020000, -0.051250, -0.010000, 0.010000, 0.008750, 0.030000, -0.005000, 0.012500
x_count = 8
y_count = 8
mesh_x_pps = 2
mesh_y_pps = 2
algo = bicubic
tension = 0.2
min_x = 10.0
max_x = 204.95
min_y = 10.0
max_y = 220.0
=======================
Extruder max_extrude_ratio=0.266081
mcu 'mcu': Starting serial connect
webhooks client 4127245168: New connection
webhooks client 4127245168: Client info {'program': 'Moonraker', 'version': 'v0.8.0-55-g0f4276d'}
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed
mcu 'mcu': Timeout on connect
mcu 'mcu': Wait for identify_response
Traceback (most recent call last):
  File "/home/pi/klipper/klippy/serialhdl.py", line 68, in _get_identify_data
    params = self.send_with_response(msg, 'identify_response')
  File "/home/pi/klipper/klippy/serialhdl.py", line 261, in send_with_response
    return src.get_response([cmd], self.default_cmd_queue)
  File "/home/pi/klipper/klippy/serialhdl.py", line 318, in get_response
    self.serial.raw_send_wait_ack(cmds[-1], minclock, reqclock,
  File "/home/pi/klipper/klippy/serialhdl.py", line 253, in raw_send_wait_ack
    self._error("Serial connection closed")
  File "/home/pi/klipper/klippy/serialhdl.py", line 61, in _error
    raise error(self.warn_prefix + (msg % params))
serialhdl.error: mcu 'mcu': Serial connection closed