配置文件_功能注释

## moonraker.conf
```bash
[server]
host: 0.0.0.0  # 服务器监听的IP地址，0.0.0.0表示监听所有IP地址
port: 7125  # 服务器监听的端口号
klippy_uds_address: /home/wj/printer_data/comms/klippy.sock  # Klipper UDS（Unix域套接字）的地址

[authorization]
trusted_clients:  # 受信任的客户端IP范围，这些范围内的客户端可以访问服务器
    10.0.0.0/8
    127.0.0.0/8
    169.254.0.0/16
    172.16.0.0/12
    192.168.0.0/16
    FE80::/10
    ::1/128
cors_domains:  # CORS（跨域资源共享）允许的域名列表
    *.lan
    *.local
    *://localhost
    *://localhost:*
    *://my.mainsail.xyz
    *://app.fluidd.xyz

[octoprint_compat]  # OctoPrint兼容性配置，这里没有具体配置项

[history]  # 历史记录配置，这里没有具体配置项

[update_manager]
channel: dev  # 更新管理器的频道，用于获取更新信息
refresh_interval: 168  # 刷新间隔，单位为小时

[update_manager mainsail]
type: web  # 更新管理器类型为Web
channel: stable  # 频道名称
repo: mainsail-crew/mainsail  # Git仓库名称
path: ~/mainsail  # 配置文件的本地路径

[update_manager mainsail-config]
type: git_repo  # 更新管理器类型为Git仓库
primary_branch: master  # 主分支名称
path: ~/mainsail-config  # 配置文件的本地路径
origin: https://git.918178.xyz/https://github.com/mainsail-crew/mainsail-config.git  # 远程Git仓库地址(增加加速)
managed_services: klipper  # 管理的服务，这里是Klipper

[update_manager crowsnest]
type: git_repo  # 更新管理器类型为Git仓库
path: ~/crowsnest  # 配置文件的本地路径
origin: https://git.918178.xyz/https://github.com/mainsail-crew/crowsnest.git  # 远程Git仓库地址(增加加速)
managed_services: crowsnest  # 管理的服务，这里是Crowsnest
install_script: tools/pkglist.sh  # 安装脚本路径

[update_manager timelapse]
type: git_repo  # 更新管理器类型为Git仓库
primary_branch: main  # 主分支名称
path: ~/moonraker-timelapse  # 配置文件的本地路径
origin: https://git.918178.xyz/https://github.com/mainsail-crew/moonraker-timelapse.git  # 远程Git仓库地址(增加加速)
managed_services: klipper moonraker  # 管理的服务，这里是Klipper和Moonraker

# 延迟拍摄，https://github.com/mainsail-crew/moonraker-timelapse
[timelapse]
output_path: ~/timelapse/
# 生成视频的保存目录
frame_path: /tmp/timelapse/
# 临时帧保存的目录
ffmpeg_binary_path: /usr/bin/ffmpeg
# 安装ffmpeg的目录
enabled: True
# 功能开关
mode: layermacro
# 目前有两种模式可用'layermacro'(换层模式)和'hyperlapse'(超时模式)
    # layermacro(换层)：此模式使用宏触发帧抓取，但需要设置切片器以在图层更改时添加换层指令 "TIMELAPSE_TAKE_FRAME"
    # hyperlapse(超时)：此模式每 x 秒拍摄一帧，由 hyperlapse_cycle 设置配置
# hyperlapse_cycle: 30                       # hyperlapse(超时)模式下抓拍间隔，单位s
# snapshoturl: http://localhost:8080/?action=snapshot  # 这个好像无效
snapshoturl: http://localhost:/webcam/?action=snapshot  # 使用这个
# 照片流地址
constant_rate_factor: 23
# 影片质量(0(无损)~51(最差))
output_framerate: 30
# 延时摄影输出帧数，如果启用了“variable_fps”，这个会被忽略
pixelformat: yuv420p
# 合成影片编码
time_format_code: %Y%m%d_%H%M
# 照片命名规则，详情：https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
# autorender: True                           # 自动生成延时摄影，或者可以在最终 gcode 中使用 "TIMELAPSE_RENDER"（可以集成到前端）来触发渲染过程。
# duplicatelastframe: 0                      # 将最后一帧复制到输出视频的末尾
previewimage: True
# 最后一帧预览图复制到输出目录，方便预览
# saveframes: False                          # 将帧打包到 zip 文件以供外部使用或渲染
# gcode_verbose: True                        # 宏的详细程度
# parkhead: False                            # 拍摄前停放打印头
# parkpos: back_left                         # 拍摄帧之前停放打印头的位置。可能的配置是 [center, front_left, front_right, back_left, back_right, custom]
# park_custom_pos_x: 0.0                     # 自定义停放位置的绝对 X 坐标（单位 mm）
# park_custom_pos_y: 0.0                     # 自定义停放位置的绝对 Y 坐标（单位 mm）
# park_custom_pos_dz: 0.0                    # 自定义停放位置的相对 Z 坐标（单位 mm）
# park_travel_speed: 100                     # 停车时打印头移动的速度（单位 mm/s）
# park_retract_speed: 15                     # 驻车后退速度（单位 mm/s）
# park_extrude_speed: 15                     # 驻车后退速度（单位 mm/s）
# park_retract_distance: 1.0                 # 缩回灯丝以防止渗出的距离（单位 mm）
# park_extrude_distance: 1.0                 # 恢复打印前挤出以填充喷嘴的距离（单位 mm）
# fw_retract: False                          # 启用此功能将禁用收回相关设置！
# park_time: 0.1                             # 停车时增加额外的空闲时间（单位秒，默认0.1）
# stream_delay_compensation: 0.05            # 延迟帧捕获（单位秒，默认0.05）
# extraoutputparams:                         # 额外输出参数，此处指定任何内容可能会禁用其他功能，参考：https://ffmpeg.org/ffmpeg.html
# variable_fps: False                        # 输出帧率的变量计算，使用拍摄帧的计数和“targetlength”，但受“variable_fps_min”和“variable_fps_max”设置的限制
# targetlength: 10                           # 视频目标长度
# variable_fps_min: 5                        # 最小FPS
# variable_fps_max: 60                       # 最大FPS
```

## timelapse.cfg
```bash
# Timelapse klipper 宏定义
#
# 版权所有 (C) 2021 Christoph Frei <fryakatkop@gmail.com>
# 版权所有 (C) 2021 Alex Zellner <alexander.zellner@googlemail.com>
#
# 本文件可能依据GNU GPLv3许可条款进行分发
#
# 宏版本 1.15
#

##### 请勿修改任何宏定义！！#####

##########################################################################
#                                                                        #
# GET_TIMELAPSE_SETUP: 将延时摄影设置打印到控制台                          #
#                                                                        #
##########################################################################

[gcode_macro GET_TIMELAPSE_SETUP]# 定义名为GET_TIMELAPSE_SETUP的G-code宏
description: 打印延时摄影设置  # 宏功能描述
gcode:                               # G-code指令开始
  {% set tl = printer['gcode_macro TIMELAPSE_TAKE_FRAME'] %}  # 获取TIMELAPSE_TAKE_FRAME宏的配置信息
  {% set output_txt = ["Timelapse 设置:"] %}  # 初始化输出信息数组
  {% set _dummy = output_txt.append("启用状态: %s" % tl.enable) %}  # 添加启用状态信息
  {% set _dummy = output_txt.append("暂停功能: %s" % tl.park.enable) %}  # 添加暂停功能状态
  {% if tl.park.enable %}  # 如果启用暂停功能
    {% set _dummy = output_txt.append("暂停位置: %s 时间: %s 秒" % (tl.park.pos, tl.park.time)) %}  # 暂停位置和时间
    {% set _dummy = output_txt.append("移动到位置 x:%s y:%s z增加:%s" % (tl.park.coord.x, tl.park.coord.y, tl.park.coord.dz)) %}
    {% set _dummy = output_txt.append("移动速度: %s 毫米/秒" % tl.speed.travel) %}
  {% endif %}
  {% set _dummy = output_txt.append("喷嘴前进缩回: %s" % tl.extruder.fw_retract) %}
  {% if not tl.extruder.fw_retract %}  # 如果不使用前进缩回
    {% set _dummy = output_txt.append("缩回距离: %s 毫米 速度: %s 毫米/秒" % (tl.extruder.retract, tl.speed.retract)) %}
    {% set _dummy = output_txt.append("挤出距离: %s 毫米 速度: %s 毫米/秒" % (tl.extruder.extrude, tl.speed.extrude)) %}
  {% endif %}
  {% set _dummy = output_txt.append("详细模式: %s" % tl.verbose) %}
  {action_respond_info(output_txt|join("\n"))}  # 将所有设置信息拼接并以信息形式响应

################################################################################################
#                                                                                              #
# 使用 _SET_TIMELAPSE_SETUP 宏设置各项参数，例如：                                               #
# _SET_TIMELAPSE_SETUP ENABLE=value VERBOSE=value PARK_ENABLE=value PARK_POS=value ...         #
# 其中value应替换为实际数值或布尔值，例如ENABLE=true，更多参数请参考宏内注释。                      #
#                                                                                              #
################################################################################################

[gcode_macro _SET_TIMELAPSE_SETUP]# 设置延时拍摄设置
description: 设置延时拍摄的用户参数
gcode:
  # 初始化变量，获取当前Timelapse拍摄宏的配置信息
  {% 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)}} %}
  ##### 设置新值 #####
  # 根据提供的参数更新Timelapse设置
  # 对每个参数进行逻辑判断，确保输入有效并更新相应配置
  {% 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 不支持.允许的值为 [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 不支持.允许的值为 [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 必须在 [%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 必须在 [%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 必须在 [%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 不支持.允许的值为 [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 不支持.允许的值为 [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 必须是正数" % 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 必须大于 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 必须大于 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 必须大于 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 必须指定为正数" % 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 必须指定为正数" % 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] 未在 Printer.cfg 中定义.无法启用 fw_retract")}
        {% endif %}
      {% endif %}
    {% else %}
      {action_raise_error("FW_RETRACT=%s 不支持.允许的值为 [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}"

##########################################################################
#                                                                       #
# TIMELapse_TAKE_FRAME: 拍摄下一帧照片                                   #
#                                                                       #
##########################################################################

######################### 定义 #########################
## enable: 启用或禁用拍摄下一帧照片的功能。有效输入值：[True, False]
## takingframe: 内部变量，指示是否正在拍摄帧。有效输入值：[True, False]
##
## park.enable: 选择在拍照时是否使喷头归位。有效输入值：[True, False]
## park.pos   : 指定拍照时喷头归位的位置。有效选项：[center, front_left, front_right, back_left, back_right, custom, x_only, y_only]
## park.time  : 用于调试宏中的等待时间，单位为秒(s)。
## park.custom.x, park.custom.y: 自定义归位点的X、Y坐标。单位[毫米(mm)]
## park.custom.dz              : 拍照时自定义的Z轴上升距离。单位[毫米(mm)]
## park.coord : 内部使用，存储归位坐标信息
##
## extruder.fw_retract: 是否使用固件级的退料功能。有效输入值：[True, False]
## extruder.extrude   : 拍摄完毕后，向前挤出的耗材长度。单位[毫米(mm)]
## extruder.retract   : 开始拍照前，耗材的回抽长度。单位[毫米(mm)]
##
## speed.travel : 移动到和从归位点移动时的旅行速度。单位：[毫米/分钟(mm/min)]
## speed.retract: 回抽速度。单位[毫米/分钟(mm/min)]
## speed.extrude: 挤出速度。单位[毫米/分钟(mm/min)]
##
## verbose: 是否开启本宏(TIMELapse_TAKE_FRAME)的详细消息输出。
##
## check_time: 检查照片是否成功拍摄的时间间隔，默认为0.5秒。
##
## restore.absolute.coordinates: 内部使用，存储绝对坐标信息以备恢复
## restore.absolute.extrude    : 内部使用，保存挤出量的绝对值
## restore.speed               : 内部使用，保存移动速度信息
## restore.e                   : 内部使用，与挤出量相关
## restore.factor.speed        : 内部使用，速度调整因子
## restore.factor.extrude      : 内部使用，挤出调整因子
##
## macro.pause  : 内部使用，与暂停宏相关
## macro.resume : 内部使用，与恢复宏相关
##
## is_paused: 内部标记，表示当前是否处于暂停状态
###############################################################
[gcode_macro TIMELAPSE_TAKE_FRAME]# 延时拍摄
description: 延时拍摄
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_check_time: 0.5            # 检查拍摄状态的时间间隔，默认0.5秒
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:                               # G-code指令部分
  # 判断是否启用超时拍摄模式
  {% 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("提示：延时摄影警告，挤出机未达到最低工作温度！")}{% 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}            ; 执行 klipper 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={check_time}
        # 确保所有移动完成
        M400
      {% endif %}
      # 触发新帧拍摄
      _TIMELAPSE_NEW_FRAME HYPERLAPSE={hyperlapse}
    {% endif %}     {% else %}
    {% if verbose %}{action_respond_info("提示：延时摄影已禁用,忽略拍摄帧请求")}{% endif %}
  {% endif %}

[gcode_macro _TIMELAPSE_NEW_FRAME]# 延时拍摄新帧
description: 动作要求延时拍摄,必须是单独的宏
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={tl.check_time}
  {% else %}
    # 恢复打印
    {tl.macro.resume} VELOCITY={tl.speed.travel} ; 执行 klipper RESUME 命令
    # 标记未暂停
    SET_GCODE_VARIABLE MACRO=TIMELAPSE_TAKE_FRAME VARIABLE=is_paused VALUE=False
    # 检查挤出机温度并执行挤出
    {% if not printer[printer.toolhead.extruder].can_extrude %}
        {action_respond_info("延时拍摄：警告,挤出机温度未达到最低！")}
    {% 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 %}

####################################################################################################
#                                                                                                  #
# 延时拍摄：开始或停止延时拍摄视频                                                                    #
# 用法：HYPERLAPSE ACTION=START [CYCLE=time] 开始循环时间的延时摄影（默认 30 秒）                     #
#        HYPERLAPSE ACTION=STOP 停止延时拍摄                                                        ##                                                                                                  #
####################################################################################################

######################### 定义 #########################
## cycle：循环时间（以秒为单位）
## run: 内部使用 [True/False]
###############################################################
[gcode_macro HYPERLAPSE]# 延时摄影
description: 开始/停止延时拍摄  # 开始/停止延时拍摄
variable_cycle: 0         # 循环周期，默认0秒
variable_run: False       # 运行状态，默认关闭
gcode:
  # 设置循环周期，若未提供则默认为30秒
  {% set cycle = params.CYCLE|default(30)|int %}
  # 根据ACTION参数启动或停止延时摄影
  {% 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

##########################################################################
#                                                                        #
# TIMELAPSE_RENDER: 打印结束时渲染视频                                     #
#                                                                        #
##########################################################################

######################### 定义 #########################
## render: 内部使用，指示渲染状态。有效输入：[True, False]
## run_identifier: 内部使用，运行标识符，用于动画显示。有效输入：[0..3]
###############################################################
[gcode_macro TIMELAPSE_RENDER]# 渲染延时摄影视频宏
description: 渲染延时视频并等待渲染完成
variable_render: False         # 渲染状态，默认未渲染
variable_run_identifier: 0     # 运行标识符，默认0
gcode:
  {action_respond_info("延时拍摄：渲染已开始")}
  {action_call_remote_method("timelapse_render", byrendermacro="True")}
  SET_GCODE_VARIABLE MACRO=TIMELAPSE_RENDER VARIABLE=render VALUE=True
## run_identifier: internal use. Valid input [0 .. 3]
  {printer.configfile.settings['gcode_macro pause'].rename_existing} ; execute the klipper PAUSE command
  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("延时拍摄：渲染完成")}
    M117
    {printer.configfile.settings['gcode_macro resume'].rename_existing} ; execute the klipper RESUME command
  {% endif %}

##########################################################################
#                                                                        #
# TEST_STREAM_DELAY: 辅助宏用于查找流和停放延迟                            #
#                                                                        #
##########################################################################

[gcode_macro TEST_STREAM_DELAY]# 辅助宏用于查找流和停放延迟
description: 辅助宏用于查找流和停放延迟
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("工具头 z %.3f 太低,请将头部置于 z = 5.0 以上" % act.z)}
  {% endif %}
```

## mainsail.cfg
```bash
## 客户端klipper宏定义
##
## 版权所有 (C) 2022 Alex Zellner <alexander.zellner@googlemail.com>
##
## 本文件可能遵循GNU通用公共许可证第三版的规定
##
## !!! 这个文件是只读的。也许使用的编辑器会显示这一点。！!!
##
## 自定义：
##   1) 复制gcode_macro _CLIENT_VARIABLE（见下面）到你的printer.cfg
##   2) 删除注释标记（#）从所有行
##   3) 更改任何值以满足您的需求
##
## 使用PAUSE宏直接在你的M600中：
##   例如，使用不同的停车位置和最小高度为50
##     M600: 换料暂停
##     gcode: PAUSE X=10 Y=10 Z_MIN=50
##   Z_MIN将工具头在最低处至少保持50毫米，以便更容易地更换耗材。
##
## 客户端变量宏为您的printer.cfg
## #variable_use_custom_parking   : False ; 使用自定义停车坐标x,y [True/False]
## #variable_custom_parking_x     : 0.0   ; 自定义停车位置x；必须在您定义的最小和最大范围内
## #variable_custom_parking_y     : 0.0   ; 自定义停车位置y；必须在您定义的最小和最大范围内
## #variable_custom_parking_dz    : 2.0   ; 当移动到停车位置时，z轴上升的距离（单位：mm）
## #variable_retract              : 1.0   ; 打印暂停时的回抽量
## #variable_cancel_retract       : 5.0   ; 打印取消时的回抽量
## #variable_speed_retract        : 35.0  ; 回抽速度（单位：mm/s）
## #variable_unretract            : 1.0   ; 打印恢复时的回抽量
## #variable_speed_unretract      : 35.0  ; 解除回抽速度（单位：mm/s）
## #variable_speed_hop            : 15.0  ; z轴移动速度（单位：mm/s）
## #variable_speed_move           : 100.0 ; 移动速度（单位：mm/s）
## #variable_park_at_cancel       : False ; 允许在执行CANCEL_PRINT时移动工具头到停车位置 [True/False]
## #variable_park_at_cancel_x     : None  ; 不同停车位置的CANCEL_PRINT [None/Position as Float]; park_at_cancel必须为True
## #variable_park_at_cancel_y     : None  ; 不同停车位置的CANCEL_PRINT [None/Position as Float]; park_at_cancel必须为True
## !!! 如果设置了[firmware_retraction]，则必须在printer.cfg中定义[firmware_retraction]。设置为True以使用固件回抽代替手动版本 [True/False]
## #variable_use_fw_retract       : False ;
## #variable_idle_timeout         : 0     ; idle_timeout达到后触发的时间（单位：秒）。值为0表示不会设置或恢复
## #variable_runout_sensor        : ""    ; 如果定义了传感器，它将用于取消执行RESUME，如果没有检测到耗材。指定运行传感器的配置名称，例如"filament_switch_sensor runout"。提示：与printer.cfg中的相同
## !!! 自定义宏，请谨慎使用并检查相应宏的部分。这些宏用于简单操作状态LED等。请确保您的宏不会干扰基本宏功能。仅支持单行命令，如需多个命令，请创建宏。
## #variable_user_pause_macro     : ""    ; 在klipper基础暂停（PAUSE_BASE）函数之后执行的所有内容
## #variable_user_resume_macro    : ""    ; 在klipper基础恢复（RESUME_BASE）函数之前执行的所有内容
## #variable_user_cancel_macro    : ""    ; 在klipper基础取消（CANCEL_PRINT_BASE）函数之前执行的所有内容
gcode:

[virtual_sdcard]
path: ~/printer_data/gcodes
on_error: CANCEL_PRINT

[pause_resume]
#recover_velocity: 50.
# 当捕获/恢复启用时，返回到捕获位置的速度（单位：mm/s）。默认为50.0 mm/s。

[display_status]

[respond]

[gcode_macro CANCEL_PRINT]# 取消打印
description: 取消实际运行的打印
rename_existing: CANCEL_PRINT_BASE
gcode:
  ##### 获取用户参数或使用默认参数 #####
  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set allow_park = client.park_at_cancel|default(false)|lower == 'true' %}
  {% set retract = client.cancel_retract|default(5.0)|abs %}
  ##### 确定停车位置 #####
  {% set park_x = "" if (client.park_at_cancel_x|default(none) is none)
            else "X=" ~ client.park_at_cancel_x %}
  {% set park_y = "" if (client.park_at_cancel_y|default(none) is none)
            else "Y=" ~ client.park_at_cancel_y %}
  {% set custom_park = park_x|length > 0 or park_y|length > 0 %}
  ##### 定义结束 #####
  # 如果需要，恢复空闲超时时间
  {% if printer['gcode_macro RESUME'].restore_idle_timeout > 0 %}
    SET_IDLE_TIMEOUT TIMEOUT={printer['gcode_macro RESUME'].restore_idle_timeout}
  {% endif %}
  {% if (custom_park or not printer.pause_resume.is_paused) and allow_park %} _TOOLHEAD_PARK_PAUSE_CANCEL {park_x} {park_y} {% endif %}
  _CLIENT_RETRACT LENGTH={retract}
  TURN_OFF_HEATERS
  M106 S0
  {client.user_cancel_macro|default("")}
  SET_GCODE_VARIABLE MACRO=RESUME VARIABLE=idle_state VALUE=False
  # 清除 pause_next_layer 和 pause_at_layer 为下一次打印做准备
  SET_PAUSE_NEXT_LAYER ENABLE=0
  SET_PAUSE_AT_LAYER ENABLE=0 LAYER=0
  CANCEL_PRINT_BASE

[gcode_macro PAUSE]# 暂停打印
description: 暂停实际运行的打印
rename_existing: PAUSE_BASE
gcode:
  ##### 获取用户参数或使用默认值 #####  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set idle_timeout = client.idle_timeout|default(0) %}
  {% set temp = printer[printer.toolhead.extruder].target if printer.toolhead.extruder != '' else 0 %}
  {% set restore = False if printer.toolhead.extruder == ''
              else True  if params.RESTORE|default(1)|int == 1 else False %}
  ##### 定义结束 #####
  SET_GCODE_VARIABLE MACRO=RESUME VARIABLE=last_extruder_temp VALUE="{{'restore': restore, 'temp': temp}}"
  # 设置新的idle_timeout值
  {% if idle_timeout > 0 %}
    SET_GCODE_VARIABLE MACRO=RESUME VARIABLE=restore_idle_timeout VALUE={printer.configfile.settings.idle_timeout.timeout}
    SET_IDLE_TIMEOUT TIMEOUT={idle_timeout}
  {% endif %}
  PAUSE_BASE
  {client.user_pause_macro|default("")}
  _TOOLHEAD_PARK_PAUSE_CANCEL {rawparams}

[gcode_macro RESUME]# 恢复打印
description: 恢复实际运行打印
rename_existing: RESUME_BASE
variable_last_extruder_temp: {'restore': False, 'temp': 0}
variable_restore_idle_timeout: 0
variable_idle_state: False
gcode:
  ##### 获取用户参数或使用默认值 #####
  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set velocity = printer.configfile.settings.pause_resume.recover_velocity %}
  {% set sp_move = client.speed_move|default(velocity) %}
  {% set runout_resume = True if client.runout_sensor|default("") == ""     # 无跳动
                    else True if not printer[client.runout_sensor].enabled  # 传感器已禁用
                    else printer[client.runout_sensor].filament_detected %} # 传感器状态
  {% set can_extrude = True if printer.toolhead.extruder == ''           # 配置中未定义挤出机
                  else printer[printer.toolhead.extruder].can_extrude %} # 活动挤出机的状态
  {% set do_resume = False %}
  {% set prompt_txt = [] %}
  ##### 定义结束 #####
  #### 打印机处于超时空闲状态 ####
  {% if printer.idle_timeout.state|upper == "IDLE" or idle_state %}
    SET_GCODE_VARIABLE MACRO=RESUME VARIABLE=idle_state VALUE=False
    {% if last_extruder_temp.restore %}
      # 我们需要将 unicode(\u00B0)用于 °，否则 py2 环境会抛出错误
      RESPOND TYPE=echo MSG='{"Restoring \"%s\" temperature to %3.1f\u00B0C, this may take some time" % (printer.toolhead.extruder, last_extruder_temp.temp) }'
      M109 S{last_extruder_temp.temp}
      {% set do_resume = True %}
    {% elif can_extrude %}
      {% set do_resume = True %}
    {% else %}      RESPOND TYPE=error MSG='{"Resume aborted !!! \"%s\" not hot enough, please heat up again and press RESUME" % printer.toolhead.extruder}'
      {% set _d = prompt_txt.append("\"%s\" not hot enough, please heat up again and press RESUME" % printer.toolhead.extruder) %}
    {% endif %}
  #### 打印机退出常规暂停状态 ####
  {% elif can_extrude %}
    {% set do_resume = True %}
  {% else %}
    RESPOND TYPE=error MSG='{"Resume aborted !!! \"%s\" not hot enough, please heat up again and press RESUME" % printer.toolhead.extruder}'
    {% set _d = prompt_txt.append("\"%s\" not hot enough, please heat up again and press RESUME" % printer.toolhead.extruder) %}
  {% endif %}
  {% if runout_resume %}
    {% if do_resume %}
      {% if restore_idle_timeout > 0 %} SET_IDLE_TIMEOUT TIMEOUT={restore_idle_timeout} {% endif %} # 恢复idle_timeout(空闲超时)时间
      {client.user_resume_macro|default("")}
      _CLIENT_EXTRUDE
      RESUME_BASE VELOCITY={params.VELOCITY|default(sp_move)}
    {% endif %}
  {% else %}
    RESPOND TYPE=error MSG='{"Resume aborted !!! \"%s\" detects no filament, please load filament and press RESUME" % (client.runout_sensor.split(" "))[1]}'
    {% set _d = prompt_txt.append("\"%s\" detects no filament, please load filament and press RESUME" % (client.runout_sensor.split(" "))[1]) %}
  {% endif %}
  ##### 中止时生成用户信息框 #####
  {% if not (runout_resume and do_resume) %}    RESPOND TYPE=command MSG="action:prompt_begin RESUME aborted !!!"
    {% for element in prompt_txt %}
      RESPOND TYPE=command MSG='{"action:prompt_text %s" % element}'    {% endfor %}
    RESPOND TYPE=command MSG="action:prompt_footer_button Ok|RESPOND TYPE=command MSG=action:prompt_end|info"
    RESPOND TYPE=command MSG="action:prompt_show"
  {% endif %}
 # 用法: SET_PAUSE_NEXT_LAYER [ENABLE=[0|1]] [MACRO=<name>]
[gcode_macro SET_PAUSE_NEXT_LAYER]# 设置暂停下一层
description: 如果到达下一层，则启用暂停
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 }}"

# 用法: SET_PAUSE_AT_LAYER [ENABLE=[0|1]] [LAYER=<number>] [MACRO=<name>]
[gcode_macro SET_PAUSE_AT_LAYER]# 设置暂停层
description: 如果达到给定的层数，则启用/禁用暂停
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 }}"

# 用法: SET_PRINT_STATS_INFO [TOTAL_LAYER=<total_layer_count>] [CURRENT_LAYER= <current_layer>]
[gcode_macro SET_PRINT_STATS_INFO]# 设置打印统计信息
rename_existing: 设置打印统计信息库
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 %}
    RESPOND TYPE=echo MSG='{"%s, forced by pause_next_layer" % pause_next_layer.call}'
    {pause_next_layer.call} ; 执行给定的 gcode 来暂停，应该是 M600 或 PAUSE
    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 %}
    RESPOND TYPE=echo MSG='{"%s, forced by pause_at_layer [%d]" % (pause_at_layer.call, pause_at_layer.layer)}'
    {pause_at_layer.call} ; 执行给定的 gcode 来暂停，应该是 M600 或 PAUSE
    SET_PAUSE_AT_LAYER ENABLE=0
  {% endif %}
  SET_PRINT_STATS_INFO_BASE {rawparams}
 ##### 内部使用 #####
[gcode_macro _TOOLHEAD_PARK_PAUSE_CANCEL]# 工具头停放暂停取消
description: Helper: 在 PAUSE 和 CANCEL_PRINT 中使用的停放工具头
gcode:
  ##### 获取用户参数或使用默认值 #####
  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set velocity = printer.configfile.settings.pause_resume.recover_velocity %}
  {% set use_custom     = client.use_custom_pos|default(false)|lower == 'true' %}
  {% set custom_park_x  = client.custom_park_x|default(0.0) %}
  {% set custom_park_y  = client.custom_park_y|default(0.0) %}
  {% set park_dz        = client.custom_park_dz|default(2.0)|abs %}
  {% set sp_hop         = client.speed_hop|default(15) * 60 %}
  {% set sp_move        = 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 %}
    RESPOND TYPE=echo MSG='Printer not homed'
  {% endif %}
 [gcode_macro _CLIENT_EXTRUDE]# 挤出
description: 挤出，如果挤出机足够热
gcode:
  ##### 获取用户参数或使用默认值 #####
  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set use_fw_retract = (client.use_fw_retract|default(false)|lower == 'true') and (printer.firmware_retraction is defined) %}
  {% set length = params.LENGTH|default(client.unretract)|default(1.0)|float %}
  {% set speed = params.SPEED|default(client.speed_unretract)|default(35) %}
  {% set absolute_extrude = printer.gcode_move.absolute_extrude %}
  ##### 定义结束 #####
  {% if printer.toolhead.extruder != '' %}
    {% if printer[printer.toolhead.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 %}
      RESPOND TYPE=echo MSG='{"\"%s\" not hot enough" % printer.toolhead.extruder}'
    {% endif %}
  {% endif %}

[gcode_macro _CLIENT_RETRACT]# 回抽
description: 回抽，如果挤出机足够热
gcode:
  {% set client = printer['gcode_macro _CLIENT_VARIABLE']|default({}) %}
  {% set length = params.LENGTH|default(client.retract)|default(1.0)|float %}
  {% set speed = params.SPEED|default(client.speed_retract)|default(35) %}

_CLIENT_EXTRUDE LENGTH=-{length|float|abs} SPEED={speed|float|abs}
```

## Klipper 控制台命令
- ACTIVATE_EXTRUDER：更改激活的挤出器
- CANCEL_PRINT：取消当前运行的打印
- CANCEL_PRINT_BASE：CANCEL_PRINT的内置别名
- CLEAR_PAUSE：清除当前的暂停状态，不恢复打印
- DUMP_TMC：读取并显示TMC步进电机驱动器寄存器
- FIRMWARE_RESTART：重启固件、主机并重新加载配置
- GET_POSITION：返回当前工具头的位置信息
- HELP：报告可用的扩展G-Code命令列表
- INIT_TMC：初始化TMC步进电机驱动器寄存器
- MANUAL_PROBE：启动手动探针辅助脚本
- PAUSE：暂停当前运行的打印
- PAUSE_BASE：PAUSE的内置别名
- PID_CALIBRATE：运行PID校准测试
- PRINT_END：G-Code宏
- PRINT_START：G-Code宏
- PROBE：在当前XY位置探测Z高度
- PROBE_ACCURACY：在当前XY位置探测Z高度的精度
- PROBE_CALIBRATE：校准探针的z_offset
- QUERY_ADC：报告模拟引脚的最后值
- QUERY_ENDSTOPS：报告每个限位开关的状态
- QUERY_FILAMENT_SENSOR：查询丝材传感器的状态
- QUERY_PROBE：返回z探针的状态
- RESPOND：回显消息，消息前缀为指定内容
- RESTART：重新加载配置文件并重启
- RESTORE_GCODE_STATE：恢复之前保存的G-Code状态
- RESUME：恢复当前运行的打印
- RESUME_BASE：RESUME的内置别名
- SAVE_CONFIG：覆盖配置文件并重启
- SAVE_GCODE_STATE：保存G-Code坐标状态
- SDCARD_PRINT_FILE：加载SD卡文件并开始打印，可能包括子目录中的文件
- SDCARD_RESET_FILE：清除已加载的SD文件，如有必要，停止打印
- SET_DISPLAY_GROUP：设置活动显示组
- SET_DISPLAY_TEXT：设置或清除显示消息
- SET_EXTRUDER_ROTATION_DISTANCE：设置挤出器旋转距离
- SET_FILAMENT_SENSOR：设置丝材传感器开关
- SET_GCODE_OFFSET：设置G-Code位置的虚拟偏移
- SET_GCODE_VARIABLE：设置G-Code宏变量的值
- SET_HEATER_TEMPERATURE：设置加热器温度
- SET_IDLE_TIMEOUT：设置空闲超时（秒）
- SET_PAUSE_AT_LAYER：达到给定层数时启用/禁用暂停
- SET_PAUSE_NEXT_LAYER：下一层达到时启用暂停
- SET_PIN：设置输出引脚的值
- SET_PRESSURE_ADVANCE：设置压力前进参数
- SET_PRINT_STATS_INFO：覆盖打印统计信息，以获得pause_next_layer和pause_at_layer功能
- SET_PRINT_STATS_INFO_BASE：SET_PRINT_STATS_INFO的内置别名
- SET_STEPPER_ENABLE：通过名称启用/禁用个别步进电机
- SET_TMC_CURRENT：设置TMC驱动器的电流
- SET_TMC_FIELD：设置TMC驱动器寄存器的字段
- SET_VELOCITY_LIMIT：设置打印机速度限制
- STATUS：报告打印机状态
- STEPPER_BUZZ：使给定步进电机振荡以帮助识别它
- SYNC_EXTRUDER_MOTION：设置挤出器步进电机运动队列
- TEMPERATURE_WAIT：等待传感器达到一定温度
- TUNING_TOWER：在每个Z高度调整参数的工具
- TURN_OFF_HEATERS：关闭所有加热器
- XWCF：G-Code宏
- Z_ENDSTOP_CALIBRATE：校准Z限位开关
- Z_OFFSET_APPLY_ENDSTOP：调整z限位位置
- Z_OFFSET_APPLY_PROBE：调整探针的z_offset
- _CLIENT_EXTRUDE：如果挤出器足够热，则挤出
- _CLIENT_RETRACT：如果挤出器足够热，则回抽
- _TOOLHEAD_PARK_PAUSE_CANCEL：辅助：在PAUSE和CANCEL_PRINT中使用的停放工具头