mirror of
https://git.mirrors.martin98.com/https://github.com/Ultimaker/Cura
synced 2025-04-16 18:59:39 +08:00
ba9e10cfd8
These are long lines for some screens. It'll save a bit of space. No PID controller can really control down to fractional degrees. Fan speed and flow rates are already integer settings. For speeds and retraction lenghts the fractions can be important. Done for #8967.
1433 lines
54 KiB
Python
1433 lines
54 KiB
Python
# ChangeAtZ script - Change printing parameters at a given height
|
|
# This script is the successor of the TweakAtZ plugin for legacy Cura.
|
|
# It contains code from the TweakAtZ plugin V1.0-V4.x and from the ExampleScript by Jaime van Kessel, Ultimaker B.V.
|
|
# It runs with the PostProcessingPlugin which is released under the terms of the AGPLv3 or higher.
|
|
# This script is licensed under the Creative Commons - Attribution - Share Alike (CC BY-SA) terms
|
|
|
|
# Authors of the ChangeAtZ plugin / script:
|
|
# Written by Steven Morlock, smorloc@gmail.com
|
|
# Modified by Ricardo Gomez, ricardoga@otulook.com, to add Bed Temperature and make it work with Cura_13.06.04+
|
|
# Modified by Stefan Heule, Dim3nsioneer@gmx.ch since V3.0 (see changelog below)
|
|
# Modified by Jaime van Kessel (Ultimaker), j.vankessel@ultimaker.com to make it work for 15.10 / 2.x
|
|
# Modified by Ruben Dulek (Ultimaker), r.dulek@ultimaker.com, to debug.
|
|
# Modified by Wes Hanney, https://github.com/novamxd, Retract Length + Speed, Clean up
|
|
|
|
# history / changelog:
|
|
# V3.0.1: TweakAtZ-state default 1 (i.e. the plugin works without any TweakAtZ comment)
|
|
# V3.1: Recognizes UltiGCode and deactivates value reset, fan speed added, alternatively layer no. to tweak at,
|
|
# extruder three temperature disabled by "#Ex3"
|
|
# V3.1.1: Bugfix reset flow rate
|
|
# V3.1.2: Bugfix disable TweakAtZ on Cool Head Lift
|
|
# V3.2: Flow rate for specific extruder added (only for 2 extruders), bugfix parser,
|
|
# added speed reset at the end of the print
|
|
# V4.0: Progress bar, tweaking over multiple layers, M605&M606 implemented, reset after one layer option,
|
|
# extruder three code removed, tweaking print speed, save call of Publisher class,
|
|
# uses previous value from other plugins also on UltiGCode
|
|
# V4.0.1: Bugfix for doubled G1 commands
|
|
# V4.0.2: Uses Cura progress bar instead of its own
|
|
# V4.0.3: Bugfix for cool head lift (contributed by luisonoff)
|
|
# V4.9.91: First version for Cura 15.06.x and PostProcessingPlugin
|
|
# V4.9.92: Modifications for Cura 15.10
|
|
# V4.9.93: Minor bugfixes (input settings) / documentation
|
|
# V4.9.94: Bugfix Combobox-selection; remove logger
|
|
# V5.0: Bugfix for fall back after one layer and doubled G0 commands when using print speed tweak, Initial version for Cura 2.x
|
|
# V5.0.1: Bugfix for calling unknown property 'bedTemp' of previous settings storage and unkown variable 'speed'
|
|
# V5.1: API Changes included for use with Cura 2.2
|
|
# V5.2.0: Wes Hanney. Added support for changing Retract Length and Speed. Removed layer spread option. Fixed issue of cumulative ChangeZ
|
|
# mods so they can now properly be stacked on top of each other. Applied code refactoring to clean up various coding styles. Added comments.
|
|
# Broke up functions for clarity. Split up class so it can be debugged outside of Cura.
|
|
# V5.2.1: Wes Hanney. Added support for firmware based retractions. Fixed issue of properly restoring previous values in single layer option.
|
|
# Added support for outputting changes to LCD (untested). Added type hints to most functions and variables. Added more comments. Created GCodeCommand
|
|
# class for better detection of G1 vs G10 or G11 commands, and accessing arguments. Moved most GCode methods to GCodeCommand class. Improved wording
|
|
# of Single Layer vs Keep Layer to better reflect what was happening.
|
|
|
|
# Uses -
|
|
# M220 S<factor in percent> - set speed factor override percentage
|
|
# M221 S<factor in percent> - set flow factor override percentage
|
|
# M221 S<factor in percent> T<0-#toolheads> - set flow factor override percentage for single extruder
|
|
# M104 S<temp> T<0-#toolheads> - set extruder <T> to target temperature <S>
|
|
# M140 S<temp> - set bed target temperature
|
|
# M106 S<PWM> - set fan speed to target speed <S>
|
|
# M207 S<mm> F<mm/m> - set the retract length <S> or feed rate <F>
|
|
# M117 - output the current changes
|
|
|
|
from typing import List, Dict
|
|
from ..Script import Script
|
|
import re
|
|
|
|
|
|
# this was broken up into a separate class so the main ChangeZ script could be debugged outside of Cura
|
|
class ChangeAtZ(Script):
|
|
version = "5.2.1"
|
|
|
|
def getSettingDataString(self):
|
|
return """{
|
|
"name": "ChangeAtZ """ + self.version + """(Experimental)",
|
|
"key": "ChangeAtZ",
|
|
"metadata": {},
|
|
"version": 2,
|
|
"settings": {
|
|
"caz_enabled": {
|
|
"label": "Enabled",
|
|
"description": "Allows adding multiple ChangeZ mods and disabling them as needed.",
|
|
"type": "bool",
|
|
"default_value": true
|
|
},
|
|
"a_trigger": {
|
|
"label": "Trigger",
|
|
"description": "Trigger at height or at layer no.",
|
|
"type": "enum",
|
|
"options": {
|
|
"height": "Height",
|
|
"layer_no": "Layer No."
|
|
},
|
|
"default_value": "height"
|
|
},
|
|
"b_targetZ": {
|
|
"label": "Change Height",
|
|
"description": "Z height to change at",
|
|
"unit": "mm",
|
|
"type": "float",
|
|
"default_value": 5.0,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "0.1",
|
|
"maximum_value_warning": "230",
|
|
"enabled": "a_trigger == 'height'"
|
|
},
|
|
"b_targetL": {
|
|
"label": "Change Layer",
|
|
"description": "Layer no. to change at",
|
|
"unit": "",
|
|
"type": "int",
|
|
"default_value": 1,
|
|
"minimum_value": "-100",
|
|
"minimum_value_warning": "-1",
|
|
"enabled": "a_trigger == 'layer_no'"
|
|
},
|
|
"c_behavior": {
|
|
"label": "Apply To",
|
|
"description": "Target Layer + Subsequent Layers is good for testing changes between ranges of layers, ex: Layer 0 to 10 or 0mm to 5mm. Single layer is good for testing changes at a single layer, ex: at Layer 10 or 5mm only.",
|
|
"type": "enum",
|
|
"options": {
|
|
"keep_value": "Target Layer + Subsequent Layers",
|
|
"single_layer": "Target Layer Only"
|
|
},
|
|
"default_value": "keep_value"
|
|
},
|
|
"caz_output_to_display": {
|
|
"label": "Output to Display",
|
|
"description": "Displays the current changes to the LCD",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"e1_Change_speed": {
|
|
"label": "Change Speed",
|
|
"description": "Select if total speed (print and travel) has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"e2_speed": {
|
|
"label": "Speed",
|
|
"description": "New total speed (print and travel)",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "1",
|
|
"minimum_value_warning": "10",
|
|
"maximum_value_warning": "200",
|
|
"enabled": "e1_Change_speed"
|
|
},
|
|
"f1_Change_printspeed": {
|
|
"label": "Change Print Speed",
|
|
"description": "Select if print speed has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"f2_printspeed": {
|
|
"label": "Print Speed",
|
|
"description": "New print speed",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "1",
|
|
"minimum_value_warning": "10",
|
|
"maximum_value_warning": "200",
|
|
"enabled": "f1_Change_printspeed"
|
|
},
|
|
"g1_Change_flowrate": {
|
|
"label": "Change Flow Rate",
|
|
"description": "Select if flow rate has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"g2_flowrate": {
|
|
"label": "Flow Rate",
|
|
"description": "New Flow rate",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "1",
|
|
"minimum_value_warning": "10",
|
|
"maximum_value_warning": "200",
|
|
"enabled": "g1_Change_flowrate"
|
|
},
|
|
"g3_Change_flowrateOne": {
|
|
"label": "Change Flow Rate 1",
|
|
"description": "Select if first extruder flow rate has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"g4_flowrateOne": {
|
|
"label": "Flow Rate One",
|
|
"description": "New Flow rate Extruder 1",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "1",
|
|
"minimum_value_warning": "10",
|
|
"maximum_value_warning": "200",
|
|
"enabled": "g3_Change_flowrateOne"
|
|
},
|
|
"g5_Change_flowrateTwo": {
|
|
"label": "Change Flow Rate 2",
|
|
"description": "Select if second extruder flow rate has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"g6_flowrateTwo": {
|
|
"label": "Flow Rate two",
|
|
"description": "New Flow rate Extruder 2",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "1",
|
|
"minimum_value_warning": "10",
|
|
"maximum_value_warning": "200",
|
|
"enabled": "g5_Change_flowrateTwo"
|
|
},
|
|
"h1_Change_bedTemp": {
|
|
"label": "Change Bed Temp",
|
|
"description": "Select if Bed Temperature has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"h2_bedTemp": {
|
|
"label": "Bed Temp",
|
|
"description": "New Bed Temperature",
|
|
"unit": "C",
|
|
"type": "float",
|
|
"default_value": 60,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "30",
|
|
"maximum_value_warning": "120",
|
|
"enabled": "h1_Change_bedTemp"
|
|
},
|
|
"i1_Change_extruderOne": {
|
|
"label": "Change Extruder 1 Temp",
|
|
"description": "Select if First Extruder Temperature has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"i2_extruderOne": {
|
|
"label": "Extruder 1 Temp",
|
|
"description": "New First Extruder Temperature",
|
|
"unit": "C",
|
|
"type": "float",
|
|
"default_value": 190,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "160",
|
|
"maximum_value_warning": "250",
|
|
"enabled": "i1_Change_extruderOne"
|
|
},
|
|
"i3_Change_extruderTwo": {
|
|
"label": "Change Extruder 2 Temp",
|
|
"description": "Select if Second Extruder Temperature has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"i4_extruderTwo": {
|
|
"label": "Extruder 2 Temp",
|
|
"description": "New Second Extruder Temperature",
|
|
"unit": "C",
|
|
"type": "float",
|
|
"default_value": 190,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "160",
|
|
"maximum_value_warning": "250",
|
|
"enabled": "i3_Change_extruderTwo"
|
|
},
|
|
"j1_Change_fanSpeed": {
|
|
"label": "Change Fan Speed",
|
|
"description": "Select if Fan Speed has to be changed",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"j2_fanSpeed": {
|
|
"label": "Fan Speed",
|
|
"description": "New Fan Speed (0-100)",
|
|
"unit": "%",
|
|
"type": "int",
|
|
"default_value": 100,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "0",
|
|
"maximum_value_warning": "100",
|
|
"enabled": "j1_Change_fanSpeed"
|
|
},
|
|
"caz_change_retract": {
|
|
"label": "Change Retraction",
|
|
"description": "Indicates you would like to modify retraction properties.",
|
|
"type": "bool",
|
|
"default_value": false
|
|
},
|
|
"caz_retractstyle": {
|
|
"label": "Retract Style",
|
|
"description": "Specify if you're using firmware retraction or linear move based retractions. Check your printer settings to see which you're using.",
|
|
"type": "enum",
|
|
"options": {
|
|
"linear": "Linear Move",
|
|
"firmware": "Firmware"
|
|
},
|
|
"default_value": "linear",
|
|
"enabled": "caz_change_retract"
|
|
},
|
|
"caz_change_retractfeedrate": {
|
|
"label": "Change Retract Feed Rate",
|
|
"description": "Changes the retraction feed rate during print",
|
|
"type": "bool",
|
|
"default_value": false,
|
|
"enabled": "caz_change_retract"
|
|
},
|
|
"caz_retractfeedrate": {
|
|
"label": "Retract Feed Rate",
|
|
"description": "New Retract Feed Rate (mm/s)",
|
|
"unit": "mm/s",
|
|
"type": "float",
|
|
"default_value": 40,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "0",
|
|
"maximum_value_warning": "100",
|
|
"enabled": "caz_change_retractfeedrate"
|
|
},
|
|
"caz_change_retractlength": {
|
|
"label": "Change Retract Length",
|
|
"description": "Changes the retraction length during print",
|
|
"type": "bool",
|
|
"default_value": false,
|
|
"enabled": "caz_change_retract"
|
|
},
|
|
"caz_retractlength": {
|
|
"label": "Retract Length",
|
|
"description": "New Retract Length (mm)",
|
|
"unit": "mm",
|
|
"type": "float",
|
|
"default_value": 6,
|
|
"minimum_value": "0",
|
|
"minimum_value_warning": "0",
|
|
"maximum_value_warning": "20",
|
|
"enabled": "caz_change_retractlength"
|
|
}
|
|
}
|
|
}"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
def execute(self, data):
|
|
|
|
caz_instance = ChangeAtZProcessor()
|
|
|
|
caz_instance.targetValues = {}
|
|
|
|
# copy over our settings to our change z class
|
|
self.setIntSettingIfEnabled(caz_instance, "e1_Change_speed", "speed", "e2_speed")
|
|
self.setIntSettingIfEnabled(caz_instance, "f1_Change_printspeed", "printspeed", "f2_printspeed")
|
|
self.setIntSettingIfEnabled(caz_instance, "g1_Change_flowrate", "flowrate", "g2_flowrate")
|
|
self.setIntSettingIfEnabled(caz_instance, "g3_Change_flowrateOne", "flowrateOne", "g4_flowrateOne")
|
|
self.setIntSettingIfEnabled(caz_instance, "g5_Change_flowrateTwo", "flowrateTwo", "g6_flowrateTwo")
|
|
self.setFloatSettingIfEnabled(caz_instance, "h1_Change_bedTemp", "bedTemp", "h2_bedTemp")
|
|
self.setFloatSettingIfEnabled(caz_instance, "i1_Change_extruderOne", "extruderOne", "i2_extruderOne")
|
|
self.setFloatSettingIfEnabled(caz_instance, "i3_Change_extruderTwo", "extruderTwo", "i4_extruderTwo")
|
|
self.setIntSettingIfEnabled(caz_instance, "j1_Change_fanSpeed", "fanSpeed", "j2_fanSpeed")
|
|
self.setFloatSettingIfEnabled(caz_instance, "caz_change_retractfeedrate", "retractfeedrate", "caz_retractfeedrate")
|
|
self.setFloatSettingIfEnabled(caz_instance, "caz_change_retractlength", "retractlength", "caz_retractlength")
|
|
|
|
# is this mod enabled?
|
|
caz_instance.enabled = self.getSettingValueByKey("caz_enabled")
|
|
|
|
# are we emitting data to the LCD?
|
|
caz_instance.displayChangesToLcd = self.getSettingValueByKey("caz_output_to_display")
|
|
|
|
# are we doing linear move retractions?
|
|
caz_instance.linearRetraction = self.getSettingValueByKey("caz_retractstyle") == "linear"
|
|
|
|
# see if we're applying to a single layer or to all layers hence forth
|
|
caz_instance.applyToSingleLayer = self.getSettingValueByKey("c_behavior") == "single_layer"
|
|
|
|
# used for easy reference of layer or height targeting
|
|
caz_instance.targetByLayer = self.getSettingValueByKey("a_trigger") == "layer_no"
|
|
|
|
# change our target based on what we're targeting
|
|
caz_instance.targetLayer = self.getIntSettingByKey("b_targetL", None)
|
|
caz_instance.targetZ = self.getFloatSettingByKey("b_targetZ", None)
|
|
|
|
# run our script
|
|
return caz_instance.execute(data)
|
|
|
|
# Sets the given TargetValue in the ChangeAtZ instance if the trigger is specified
|
|
def setIntSettingIfEnabled(self, caz_instance, trigger, target, setting):
|
|
|
|
# stop here if our trigger isn't enabled
|
|
if not self.getSettingValueByKey(trigger):
|
|
return
|
|
|
|
# get our value from the settings
|
|
value = self.getIntSettingByKey(setting, None)
|
|
|
|
# skip if there's no value or we can't interpret it
|
|
if value is None:
|
|
return
|
|
|
|
# set our value in the target settings
|
|
caz_instance.targetValues[target] = value
|
|
|
|
# Sets the given TargetValue in the ChangeAtZ instance if the trigger is specified
|
|
def setFloatSettingIfEnabled(self, caz_instance, trigger, target, setting):
|
|
|
|
# stop here if our trigger isn't enabled
|
|
if not self.getSettingValueByKey(trigger):
|
|
return
|
|
|
|
# get our value from the settings
|
|
value = self.getFloatSettingByKey(setting, None)
|
|
|
|
# skip if there's no value or we can't interpret it
|
|
if value is None:
|
|
return
|
|
|
|
# set our value in the target settings
|
|
caz_instance.targetValues[target] = value
|
|
|
|
# Returns the given settings value as an integer or the default if it cannot parse it
|
|
def getIntSettingByKey(self, key, default):
|
|
|
|
# change our target based on what we're targeting
|
|
try:
|
|
return int(self.getSettingValueByKey(key))
|
|
except:
|
|
return default
|
|
|
|
# Returns the given settings value as an integer or the default if it cannot parse it
|
|
def getFloatSettingByKey(self, key, default):
|
|
|
|
# change our target based on what we're targeting
|
|
try:
|
|
return float(self.getSettingValueByKey(key))
|
|
except:
|
|
return default
|
|
|
|
|
|
# This is a utility class for getting details of gcodes from a given line
|
|
class GCodeCommand:
|
|
|
|
# The GCode command itself (ex: G10)
|
|
command = None,
|
|
|
|
# Contains any arguments passed to the command. The key is the argument name, the value is the value of the argument.
|
|
arguments = {}
|
|
|
|
# Contains the components of the command broken into pieces
|
|
components = []
|
|
|
|
# Constructor. Sets up defaults
|
|
def __init__(self):
|
|
self.reset()
|
|
|
|
# Gets a GCode Command from the given single line of GCode
|
|
@staticmethod
|
|
def getFromLine(line: str):
|
|
|
|
# obviously if we don't have a command, we can't return anything
|
|
if line is None or len(line) == 0:
|
|
return None
|
|
|
|
# we only support G or M commands
|
|
if line[0] != "G" and line[0] != "M":
|
|
return None
|
|
|
|
# remove any comments
|
|
line = re.sub(r";.*$", "", line)
|
|
|
|
# break into the individual components
|
|
command_pieces = line.strip().split(" ")
|
|
|
|
# our return command details
|
|
command = GCodeCommand()
|
|
|
|
# stop here if we don't even have something to interpret
|
|
if len(command_pieces) == 0:
|
|
return None
|
|
|
|
# stores all the components of the command within the class for later
|
|
command.components = command_pieces
|
|
|
|
# set the actual command
|
|
command.command = command_pieces[0]
|
|
|
|
# stop here if we don't have any parameters
|
|
if len(command_pieces) == 1:
|
|
return None
|
|
|
|
# return our indexed command
|
|
return command
|
|
|
|
# Handy function for reading a linear move command
|
|
@staticmethod
|
|
def getLinearMoveCommand(line: str):
|
|
|
|
# get our command from the line
|
|
linear_command = GCodeCommand.getFromLine(line)
|
|
|
|
# if it's not a linear move, we don't care
|
|
if linear_command is None or (linear_command.command != "G0" and linear_command.command != "G1"):
|
|
return None
|
|
|
|
# convert our values to floats (or defaults)
|
|
linear_command.arguments["F"] = linear_command.getArgumentAsFloat("F", None)
|
|
linear_command.arguments["X"] = linear_command.getArgumentAsFloat("X", None)
|
|
linear_command.arguments["Y"] = linear_command.getArgumentAsFloat("Y", None)
|
|
linear_command.arguments["Z"] = linear_command.getArgumentAsFloat("Z", None)
|
|
linear_command.arguments["E"] = linear_command.getArgumentAsFloat("E", None)
|
|
|
|
# return our new command
|
|
return linear_command
|
|
|
|
# Gets the value of a parameter or returns the default if there is none
|
|
def getArgument(self, name: str, default: str = None) -> str:
|
|
|
|
# parse our arguments (only happens once)
|
|
self.parseArguments()
|
|
|
|
# if we don't have the parameter, return the default
|
|
if name not in self.arguments:
|
|
return default
|
|
|
|
# otherwise return the value
|
|
return self.arguments[name]
|
|
|
|
# Gets the value of a parameter as a float or returns the default
|
|
def getArgumentAsFloat(self, name: str, default: float = None) -> float:
|
|
|
|
# try to parse as a float, otherwise return the default
|
|
try:
|
|
return float(self.getArgument(name, default))
|
|
except:
|
|
return default
|
|
|
|
# Gets the value of a parameter as an integer or returns the default
|
|
def getArgumentAsInt(self, name: str, default: int = None) -> int:
|
|
|
|
# try to parse as a integer, otherwise return the default
|
|
try:
|
|
return int(self.getArgument(name, default))
|
|
except:
|
|
return default
|
|
|
|
# Allows retrieving values from the given GCODE line
|
|
@staticmethod
|
|
def getDirectArgument(line: str, key: str, default: str = None) -> str:
|
|
|
|
if key not in line or (";" in line and line.find(key) > line.find(";") and ";ChangeAtZ" not in key and ";LAYER:" not in key):
|
|
return default
|
|
|
|
# allows for string lengths larger than 1
|
|
sub_part = line[line.find(key) + len(key):]
|
|
|
|
if ";ChangeAtZ" in key:
|
|
m = re.search("^[0-4]", sub_part)
|
|
elif ";LAYER:" in key:
|
|
m = re.search("^[+-]?[0-9]*", sub_part)
|
|
else:
|
|
# the minus at the beginning allows for negative values, e.g. for delta printers
|
|
m = re.search(r"^[-]?[0-9]*\.?[0-9]*", sub_part)
|
|
if m is None:
|
|
return default
|
|
|
|
try:
|
|
return m.group(0)
|
|
except:
|
|
return default
|
|
|
|
# Converts the command parameter to a int or returns the default
|
|
@staticmethod
|
|
def getDirectArgumentAsFloat(line: str, key: str, default: float = None) -> float:
|
|
|
|
# get the value from the command
|
|
value = GCodeCommand.getDirectArgument(line, key, default)
|
|
|
|
# stop here if it's the default
|
|
if value == default:
|
|
return value
|
|
|
|
try:
|
|
return float(value)
|
|
except:
|
|
return default
|
|
|
|
# Converts the command parameter to a int or returns the default
|
|
@staticmethod
|
|
def getDirectArgumentAsInt(line: str, key: str, default: int = None) -> int:
|
|
|
|
# get the value from the command
|
|
value = GCodeCommand.getDirectArgument(line, key, default)
|
|
|
|
# stop here if it's the default
|
|
if value == default:
|
|
return value
|
|
|
|
try:
|
|
return int(value)
|
|
except:
|
|
return default
|
|
|
|
# Parses the arguments of the command on demand, only once
|
|
def parseArguments(self):
|
|
|
|
# stop here if we don't have any remaining components
|
|
if len(self.components) <= 1:
|
|
return None
|
|
|
|
# iterate and index all of our parameters, skip the first component as it's the command
|
|
for i in range(1, len(self.components)):
|
|
|
|
# get our component
|
|
component = self.components[i]
|
|
|
|
# get the first character of the parameter, which is the name
|
|
component_name = component[0]
|
|
|
|
# get the value of the parameter (the rest of the string
|
|
component_value = None
|
|
|
|
# get our value if we have one
|
|
if len(component) > 1:
|
|
component_value = component[1:]
|
|
|
|
# index the argument
|
|
self.arguments[component_name] = component_value
|
|
|
|
# clear the components to we don't process again
|
|
self.components = []
|
|
|
|
# Easy function for replacing any GCODE parameter variable in a given GCODE command
|
|
@staticmethod
|
|
def replaceDirectArgument(line: str, key: str, value: str) -> str:
|
|
return re.sub(r"(^|\s)" + key + r"[\d\.]+(\s|$)", r"\1" + key + str(value) + r"\2", line)
|
|
|
|
# Resets the model back to defaults
|
|
def reset(self):
|
|
self.command = None
|
|
self.arguments = {}
|
|
|
|
|
|
# The primary ChangeAtZ class that does all the gcode editing. This was broken out into an
|
|
# independent class so it could be debugged using a standard IDE
|
|
class ChangeAtZProcessor:
|
|
|
|
# Holds our current height
|
|
currentZ = None
|
|
|
|
# Holds our current layer number
|
|
currentLayer = None
|
|
|
|
# Indicates if we're only supposed to apply our settings to a single layer or multiple layers
|
|
applyToSingleLayer = False
|
|
|
|
# Indicates if this should emit the changes as they happen to the LCD
|
|
displayChangesToLcd = False
|
|
|
|
# Indicates that this mod is still enabled (or not)
|
|
enabled = True
|
|
|
|
# Indicates if we're processing inside the target layer or not
|
|
insideTargetLayer = False
|
|
|
|
# Indicates if we have restored the previous values from before we started our pass
|
|
lastValuesRestored = False
|
|
|
|
# Indicates if the user has opted for linear move retractions or firmware retractions
|
|
linearRetraction = True
|
|
|
|
# Indicates if we're targetting by layer or height value
|
|
targetByLayer = True
|
|
|
|
# Indicates if we have injected our changed values for the given layer yet
|
|
targetValuesInjected = False
|
|
|
|
# Holds the last extrusion value, used with detecting when a retraction is made
|
|
lastE = None
|
|
|
|
# An index of our gcodes which we're monitoring
|
|
lastValues = {}
|
|
|
|
# The detected layer height from the gcode
|
|
layerHeight = None
|
|
|
|
# The target layer
|
|
targetLayer = None
|
|
|
|
# Holds the values the user has requested to change
|
|
targetValues = {}
|
|
|
|
# The target height in mm
|
|
targetZ = None
|
|
|
|
# Used to track if we've been inside our target layer yet
|
|
wasInsideTargetLayer = False
|
|
|
|
# boots up the class with defaults
|
|
def __init__(self):
|
|
self.reset()
|
|
|
|
# Modifies the given GCODE and injects the commands at the various targets
|
|
def execute(self, data):
|
|
|
|
# short cut the whole thing if we're not enabled
|
|
if not self.enabled:
|
|
return data
|
|
|
|
# our layer cursor
|
|
index = 0
|
|
|
|
for active_layer in data:
|
|
|
|
# will hold our updated gcode
|
|
modified_gcode = ""
|
|
|
|
# mark all the defaults for deletion
|
|
active_layer = self.markChangesForDeletion(active_layer)
|
|
|
|
# break apart the layer into commands
|
|
lines = active_layer.split("\n")
|
|
|
|
# evaluate each command individually
|
|
for line in lines:
|
|
|
|
# trim or command
|
|
line = line.strip()
|
|
|
|
# skip empty lines
|
|
if len(line) == 0:
|
|
continue
|
|
|
|
# update our layer number if applicable
|
|
self.processLayerNumber(line)
|
|
|
|
# update our layer height if applicable
|
|
self.processLayerHeight(line)
|
|
|
|
# check if we're at the target layer or not
|
|
self.processTargetLayer()
|
|
|
|
# process any changes to the gcode
|
|
modified_gcode += self.processLine(line)
|
|
|
|
# remove any marked defaults
|
|
modified_gcode = self.removeMarkedChanges(modified_gcode)
|
|
|
|
# append our modified line
|
|
data[index] = modified_gcode
|
|
|
|
index += 1
|
|
|
|
# return our modified gcode
|
|
return data
|
|
|
|
# Builds the restored layer settings based on the previous settings and returns the relevant GCODE lines
|
|
def getChangedLastValues(self) -> Dict[str, any]:
|
|
|
|
# capture the values that we've changed
|
|
changed = {}
|
|
|
|
# for each of our target values, get the value to restore
|
|
# no point in restoring values we haven't changed
|
|
for key in self.targetValues:
|
|
|
|
# skip target values we can't restore
|
|
if key not in self.lastValues:
|
|
continue
|
|
|
|
# save into our changed
|
|
changed[key] = self.lastValues[key]
|
|
|
|
# return our collection of changed values
|
|
return changed
|
|
|
|
# Builds the relevant display feedback for each of the values
|
|
def getDisplayChangesFromValues(self, values: Dict[str, any]) -> str:
|
|
|
|
# stop here if we're not outputting data
|
|
if not self.displayChangesToLcd:
|
|
return ""
|
|
|
|
# will hold all the default settings for the target layer
|
|
codes = []
|
|
|
|
# looking for wait for bed temp
|
|
if "bedTemp" in values:
|
|
codes.append("BedTemp: " + str(round(values["bedTemp"])))
|
|
|
|
# set our extruder one temp (if specified)
|
|
if "extruderOne" in values:
|
|
codes.append("Extruder 1 Temp: " + str(round(values["extruderOne"])))
|
|
|
|
# set our extruder two temp (if specified)
|
|
if "extruderTwo" in values:
|
|
codes.append("Extruder 2 Temp: " + str(round(values["extruderTwo"])))
|
|
|
|
# set global flow rate
|
|
if "flowrate" in values:
|
|
codes.append("Extruder A Flow Rate: " + str(values["flowrate"]))
|
|
|
|
# set extruder 0 flow rate
|
|
if "flowrateOne" in values:
|
|
codes.append("Extruder 1 Flow Rate: " + str(values["flowrateOne"]))
|
|
|
|
# set second extruder flow rate
|
|
if "flowrateTwo" in values:
|
|
codes.append("Extruder 2 Flow Rate: " + str(values["flowrateTwo"]))
|
|
|
|
# set our fan speed
|
|
if "fanSpeed" in values:
|
|
codes.append("Fan Speed: " + str(values["fanSpeed"]))
|
|
|
|
# set feedrate percentage
|
|
if "speed" in values:
|
|
codes.append("Print Speed: " + str(values["speed"]))
|
|
|
|
# set print rate percentage
|
|
if "printspeed" in values:
|
|
codes.append("Linear Print Speed: " + str(values["printspeed"]))
|
|
|
|
# set retract rate
|
|
if "retractfeedrate" in values:
|
|
codes.append("Retract Feed Rate: " + str(values["retractfeedrate"]))
|
|
|
|
# set retract length
|
|
if "retractlength" in values:
|
|
codes.append("Retract Length: " + str(values["retractlength"]))
|
|
|
|
# stop here if there's nothing to output
|
|
if len(codes) == 0:
|
|
return ""
|
|
|
|
# output our command to display the data
|
|
return "M117 " + ", ".join(codes) + "\n"
|
|
|
|
# Converts the last values to something that can be output on the LCD
|
|
def getLastDisplayValues(self) -> str:
|
|
|
|
# convert our last values to something we can output
|
|
return self.getDisplayChangesFromValues(self.getChangedLastValues())
|
|
|
|
# Converts the target values to something that can be output on the LCD
|
|
def getTargetDisplayValues(self) -> str:
|
|
|
|
# convert our target values to something we can output
|
|
return self.getDisplayChangesFromValues(self.targetValues)
|
|
|
|
# Builds the the relevant GCODE lines from the given collection of values
|
|
def getCodeFromValues(self, values: Dict[str, any]) -> str:
|
|
|
|
# will hold all the desired settings for the target layer
|
|
codes = self.getCodeLinesFromValues(values)
|
|
|
|
# stop here if there are no values that require changing
|
|
if len(codes) == 0:
|
|
return ""
|
|
|
|
# return our default block for this layer
|
|
return ";[CAZD:\n" + "\n".join(codes) + "\n;:CAZD]"
|
|
|
|
# Builds the relevant GCODE lines from the given collection of values
|
|
def getCodeLinesFromValues(self, values: Dict[str, any]) -> List[str]:
|
|
|
|
# will hold all the default settings for the target layer
|
|
codes = []
|
|
|
|
# looking for wait for bed temp
|
|
if "bedTemp" in values:
|
|
codes.append("M140 S" + str(values["bedTemp"]))
|
|
|
|
# set our extruder one temp (if specified)
|
|
if "extruderOne" in values:
|
|
codes.append("M104 S" + str(values["extruderOne"]) + " T0")
|
|
|
|
# set our extruder two temp (if specified)
|
|
if "extruderTwo" in values:
|
|
codes.append("M104 S" + str(values["extruderTwo"]) + " T1")
|
|
|
|
# set our fan speed
|
|
if "fanSpeed" in values:
|
|
|
|
# convert our fan speed percentage to PWM
|
|
fan_speed = int((float(values["fanSpeed"]) / 100.0) * 255)
|
|
|
|
# add our fan speed to the defaults
|
|
codes.append("M106 S" + str(fan_speed))
|
|
|
|
# set global flow rate
|
|
if "flowrate" in values:
|
|
codes.append("M221 S" + str(values["flowrate"]))
|
|
|
|
# set extruder 0 flow rate
|
|
if "flowrateOne" in values:
|
|
codes.append("M221 S" + str(values["flowrateOne"]) + " T0")
|
|
|
|
# set second extruder flow rate
|
|
if "flowrateTwo" in values:
|
|
codes.append("M221 S" + str(values["flowrateTwo"]) + " T1")
|
|
|
|
# set feedrate percentage
|
|
if "speed" in values:
|
|
codes.append("M220 S" + str(values["speed"]) + "")
|
|
|
|
# set print rate percentage
|
|
if "printspeed" in values:
|
|
codes.append(";PRINTSPEED " + str(values["printspeed"]) + "")
|
|
|
|
# set retract rate
|
|
if "retractfeedrate" in values:
|
|
|
|
if self.linearRetraction:
|
|
codes.append(";RETRACTFEEDRATE " + str(values["retractfeedrate"] * 60) + "")
|
|
else:
|
|
codes.append("M207 F" + str(values["retractfeedrate"] * 60) + "")
|
|
|
|
# set retract length
|
|
if "retractlength" in values:
|
|
|
|
if self.linearRetraction:
|
|
codes.append(";RETRACTLENGTH " + str(values["retractlength"]) + "")
|
|
else:
|
|
codes.append("M207 S" + str(values["retractlength"]) + "")
|
|
|
|
return codes
|
|
|
|
# Builds the restored layer settings based on the previous settings and returns the relevant GCODE lines
|
|
def getLastValues(self) -> str:
|
|
|
|
# build the gcode to restore our last values
|
|
return self.getCodeFromValues(self.getChangedLastValues())
|
|
|
|
# Builds the gcode to inject either the changed values we want or restore the previous values
|
|
def getInjectCode(self) -> str:
|
|
|
|
# if we're now outside of our target layer and haven't restored our last values, do so now
|
|
if not self.insideTargetLayer and self.wasInsideTargetLayer and not self.lastValuesRestored:
|
|
|
|
# mark that we've injected the last values
|
|
self.lastValuesRestored = True
|
|
|
|
# inject the defaults
|
|
return self.getLastValues() + "\n" + self.getLastDisplayValues()
|
|
|
|
# if we're inside our target layer but haven't added our values yet, do so now
|
|
if self.insideTargetLayer and not self.targetValuesInjected:
|
|
|
|
# mark that we've injected the target values
|
|
self.targetValuesInjected = True
|
|
|
|
# inject the defaults
|
|
return self.getTargetValues() + "\n" + self.getTargetDisplayValues()
|
|
|
|
# nothing to do
|
|
return ""
|
|
|
|
# Returns the unmodified GCODE line from previous ChangeZ edits
|
|
@staticmethod
|
|
def getOriginalLine(line: str) -> str:
|
|
|
|
# get the change at z original (cazo) details
|
|
original_line = re.search(r"\[CAZO:(.*?):CAZO\]", line)
|
|
|
|
# if we didn't get a hit, this is the original line
|
|
if original_line is None:
|
|
return line
|
|
|
|
return original_line.group(1)
|
|
|
|
# Builds the target layer settings based on the specified values and returns the relevant GCODE lines
|
|
def getTargetValues(self) -> str:
|
|
|
|
# build the gcode to change our current values
|
|
return self.getCodeFromValues(self.targetValues)
|
|
|
|
# Determines if the current line is at or below the target required to start modifying
|
|
def isTargetLayerOrHeight(self) -> bool:
|
|
|
|
# target selected by layer no.
|
|
if self.targetByLayer:
|
|
|
|
# if we don't have a current layer, we're not there yet
|
|
if self.currentLayer is None:
|
|
return False
|
|
|
|
# if we're applying to a single layer, stop if our layer is not identical
|
|
if self.applyToSingleLayer:
|
|
return self.currentLayer == self.targetLayer
|
|
else:
|
|
return self.currentLayer >= self.targetLayer
|
|
|
|
else:
|
|
|
|
# if we don't have a current Z, we're not there yet
|
|
if self.currentZ is None:
|
|
return False
|
|
|
|
# if we're applying to a single layer, stop if our Z is not identical
|
|
if self.applyToSingleLayer:
|
|
return self.currentZ == self.targetZ
|
|
else:
|
|
return self.currentZ >= self.targetZ
|
|
|
|
# Marks any current ChangeZ layer defaults in the layer for deletion
|
|
@staticmethod
|
|
def markChangesForDeletion(layer: str):
|
|
return re.sub(r";\[CAZD:", ";[CAZD:DELETE:", layer)
|
|
|
|
# Grabs the current height
|
|
def processLayerHeight(self, line: str):
|
|
|
|
# stop here if we haven't entered a layer yet
|
|
if self.currentLayer is None:
|
|
return
|
|
|
|
# get our gcode command
|
|
command = GCodeCommand.getFromLine(line)
|
|
|
|
# skip if it's not a command we're interested in
|
|
if command is None:
|
|
return
|
|
|
|
# stop here if this isn't a linear move command
|
|
if command.command != "G0" and command.command != "G1":
|
|
return
|
|
|
|
# get our value from the command
|
|
current_z = command.getArgumentAsFloat("Z", None)
|
|
|
|
# stop here if we don't have a Z value defined, we can't get the height from this command
|
|
if current_z is None:
|
|
return
|
|
|
|
# stop if there's no change
|
|
if current_z == self.currentZ:
|
|
return
|
|
|
|
# set our current Z value
|
|
self.currentZ = current_z
|
|
|
|
# if we don't have a layer height yet, set it based on the current Z value
|
|
if self.layerHeight is None:
|
|
self.layerHeight = self.currentZ
|
|
|
|
# Grabs the current layer number
|
|
def processLayerNumber(self, line: str):
|
|
|
|
# if this isn't a layer comment, stop here, nothing to update
|
|
if ";LAYER:" not in line:
|
|
return
|
|
|
|
# get our current layer number
|
|
current_layer = GCodeCommand.getDirectArgumentAsInt(line, ";LAYER:", None)
|
|
|
|
# this should never happen, but if our layer number hasn't changed, stop here
|
|
if current_layer == self.currentLayer:
|
|
return
|
|
|
|
# update our current layer
|
|
self.currentLayer = current_layer
|
|
|
|
# Makes any linear move changes and also injects either target or restored values depending on the plugin state
|
|
def processLine(self, line: str) -> str:
|
|
|
|
# used to change the given line of code
|
|
modified_gcode = ""
|
|
|
|
# track any values that we may be interested in
|
|
self.trackChangeableValues(line)
|
|
|
|
# if we're not inside the target layer, simply read the any
|
|
# settings we can and revert any ChangeAtZ deletions
|
|
if not self.insideTargetLayer:
|
|
|
|
# read any settings if we haven't hit our target layer yet
|
|
if not self.wasInsideTargetLayer:
|
|
self.processSetting(line)
|
|
|
|
# if we haven't hit our target yet, leave the defaults as is (unmark them for deletion)
|
|
if "[CAZD:DELETE:" in line:
|
|
line = line.replace("[CAZD:DELETE:", "[CAZD:")
|
|
|
|
# if we're targeting by Z, we want to add our values before the first linear move
|
|
if "G1 " in line or "G0 " in line:
|
|
modified_gcode += self.getInjectCode()
|
|
|
|
# modify our command if we're still inside our target layer, otherwise pass unmodified
|
|
if self.insideTargetLayer:
|
|
modified_gcode += self.processLinearMove(line) + "\n"
|
|
else:
|
|
modified_gcode += line + "\n"
|
|
|
|
# if we're targetting by layer we want to add our values just after the layer label
|
|
if ";LAYER:" in line:
|
|
modified_gcode += self.getInjectCode()
|
|
|
|
# return our changed code
|
|
return modified_gcode
|
|
|
|
# Handles any linear moves in the current line
|
|
def processLinearMove(self, line: str) -> str:
|
|
|
|
# if it's not a linear motion command we're not interested
|
|
if not ("G1 " in line or "G0 " in line):
|
|
return line
|
|
|
|
# always get our original line, otherwise the effect will be cumulative
|
|
line = self.getOriginalLine(line)
|
|
|
|
# get our command from the line
|
|
linear_command = GCodeCommand.getLinearMoveCommand(line)
|
|
|
|
# if it's not a linear move, we don't care
|
|
if linear_command is None:
|
|
return line
|
|
|
|
# get our linear move parameters
|
|
feed_rate = linear_command.arguments["F"]
|
|
x_coord = linear_command.arguments["X"]
|
|
y_coord = linear_command.arguments["Y"]
|
|
z_coord = linear_command.arguments["Z"]
|
|
extrude_length = linear_command.arguments["E"]
|
|
|
|
# set our new line to our old line
|
|
new_line = line
|
|
|
|
# handle retract length
|
|
new_line = self.processRetractLength(extrude_length, feed_rate, new_line, x_coord, y_coord, z_coord)
|
|
|
|
# handle retract feed rate
|
|
new_line = self.processRetractFeedRate(extrude_length, feed_rate, new_line, x_coord, y_coord, z_coord)
|
|
|
|
# handle print speed adjustments
|
|
if extrude_length is not None: # Only for extrusion moves.
|
|
new_line = self.processPrintSpeed(feed_rate, new_line)
|
|
|
|
# set our current extrude position
|
|
self.lastE = extrude_length if extrude_length is not None else self.lastE
|
|
|
|
# if no changes have been made, stop here
|
|
if new_line == line:
|
|
return line
|
|
|
|
# return our updated command
|
|
return self.setOriginalLine(new_line, line)
|
|
|
|
# Handles any changes to print speed for the given linear motion command
|
|
def processPrintSpeed(self, feed_rate: float, new_line: str) -> str:
|
|
|
|
# if we're not setting print speed or we don't have a feed rate, stop here
|
|
if "printspeed" not in self.targetValues or feed_rate is None:
|
|
return new_line
|
|
|
|
# get our requested print speed
|
|
print_speed = int(self.targetValues["printspeed"])
|
|
|
|
# if they requested no change to print speed (ie: 100%), stop here
|
|
if print_speed == 100:
|
|
return new_line
|
|
|
|
# get our feed rate from the command
|
|
feed_rate = GCodeCommand.getDirectArgumentAsFloat(new_line, "F") * (float(print_speed) / 100.0)
|
|
|
|
# change our feed rate
|
|
return GCodeCommand.replaceDirectArgument(new_line, "F", feed_rate)
|
|
|
|
# Handles any changes to retraction length for the given linear motion command
|
|
def processRetractLength(self, extrude_length: float, feed_rate: float, new_line: str, x_coord: float, y_coord: float, z_coord: float) -> str:
|
|
|
|
# if we don't have a retract length in the file we can't add one
|
|
if "retractlength" not in self.lastValues or self.lastValues["retractlength"] == 0:
|
|
return new_line
|
|
|
|
# if we're not changing retraction length, stop here
|
|
if "retractlength" not in self.targetValues:
|
|
return new_line
|
|
|
|
# retractions are only F (feed rate) and E (extrude), at least in cura
|
|
if x_coord is not None or y_coord is not None or z_coord is not None:
|
|
return new_line
|
|
|
|
# since retractions require both F and E, and we don't have either, we can't process
|
|
if feed_rate is None or extrude_length is None:
|
|
return new_line
|
|
|
|
# stop here if we don't know our last extrude value
|
|
if self.lastE is None:
|
|
return new_line
|
|
|
|
# if there's no change in extrude we have nothing to change
|
|
if self.lastE == extrude_length:
|
|
return new_line
|
|
|
|
# if our last extrude was lower than our current, we're restoring, so skip
|
|
if self.lastE < extrude_length:
|
|
return new_line
|
|
|
|
# get our desired retract length
|
|
retract_length = float(self.targetValues["retractlength"])
|
|
|
|
# subtract the difference between the default and the desired
|
|
extrude_length -= (retract_length - self.lastValues["retractlength"])
|
|
|
|
# replace our extrude amount
|
|
return GCodeCommand.replaceDirectArgument(new_line, "E", extrude_length)
|
|
|
|
# Used for picking out the retract length set by Cura
|
|
def processRetractLengthSetting(self, line: str):
|
|
|
|
# skip if we're not doing linear retractions
|
|
if not self.linearRetraction:
|
|
return
|
|
|
|
# get our command from the line
|
|
linear_command = GCodeCommand.getLinearMoveCommand(line)
|
|
|
|
# if it's not a linear move, we don't care
|
|
if linear_command is None:
|
|
return
|
|
|
|
# get our linear move parameters
|
|
feed_rate = linear_command.arguments["F"]
|
|
x_coord = linear_command.arguments["X"]
|
|
y_coord = linear_command.arguments["Y"]
|
|
z_coord = linear_command.arguments["Z"]
|
|
extrude_length = linear_command.arguments["E"]
|
|
|
|
# the command we're looking for only has extrude and feed rate
|
|
if x_coord is not None or y_coord is not None or z_coord is not None:
|
|
return
|
|
|
|
# if either extrude or feed is missing we're likely looking at the wrong command
|
|
if extrude_length is None or feed_rate is None:
|
|
return
|
|
|
|
# cura stores the retract length as a negative E just before it starts printing
|
|
extrude_length = extrude_length * -1
|
|
|
|
# if it's a negative extrude after being inverted, it's not our retract length
|
|
if extrude_length < 0:
|
|
return
|
|
|
|
# what ever the last negative retract length is it wins
|
|
self.lastValues["retractlength"] = extrude_length
|
|
|
|
# Handles any changes to retraction feed rate for the given linear motion command
|
|
def processRetractFeedRate(self, extrude_length: float, feed_rate: float, new_line: str, x_coord: float, y_coord: float, z_coord: float) -> str:
|
|
|
|
# skip if we're not doing linear retractions
|
|
if not self.linearRetraction:
|
|
return new_line
|
|
|
|
# if we're not changing retraction length, stop here
|
|
if "retractfeedrate" not in self.targetValues:
|
|
return new_line
|
|
|
|
# retractions are only F (feed rate) and E (extrude), at least in cura
|
|
if x_coord is not None or y_coord is not None or z_coord is not None:
|
|
return new_line
|
|
|
|
# since retractions require both F and E, and we don't have either, we can't process
|
|
if feed_rate is None or extrude_length is None:
|
|
return new_line
|
|
|
|
# get our desired retract feed rate
|
|
retract_feed_rate = float(self.targetValues["retractfeedrate"])
|
|
|
|
# convert to units/min
|
|
retract_feed_rate *= 60
|
|
|
|
# replace our feed rate
|
|
return GCodeCommand.replaceDirectArgument(new_line, "F", retract_feed_rate)
|
|
|
|
# Used for finding settings in the print file before we process anything else
|
|
def processSetting(self, line: str):
|
|
|
|
# if we're in layers already we're out of settings
|
|
if self.currentLayer is not None:
|
|
return
|
|
|
|
# check our retract length
|
|
self.processRetractLengthSetting(line)
|
|
|
|
# Sets the flags if we're at the target layer or not
|
|
def processTargetLayer(self):
|
|
|
|
# skip this line if we're not there yet
|
|
if not self.isTargetLayerOrHeight():
|
|
|
|
# flag that we're outside our target layer
|
|
self.insideTargetLayer = False
|
|
|
|
# skip to the next line
|
|
return
|
|
|
|
# flip if we hit our target layer
|
|
self.wasInsideTargetLayer = True
|
|
|
|
# flag that we're inside our target layer
|
|
self.insideTargetLayer = True
|
|
|
|
# Removes all the ChangeZ layer defaults from the given layer
|
|
@staticmethod
|
|
def removeMarkedChanges(layer: str) -> str:
|
|
return re.sub(r";\[CAZD:DELETE:[\s\S]+?:CAZD\](\n|$)", "", layer)
|
|
|
|
# Resets the class contents to defaults
|
|
def reset(self):
|
|
|
|
self.targetValues = {}
|
|
self.applyToSingleLayer = False
|
|
self.lastE = None
|
|
self.currentZ = None
|
|
self.currentLayer = None
|
|
self.targetByLayer = True
|
|
self.targetLayer = None
|
|
self.targetZ = None
|
|
self.layerHeight = None
|
|
self.lastValues = {"speed": 100}
|
|
self.linearRetraction = True
|
|
self.insideTargetLayer = False
|
|
self.targetValuesInjected = False
|
|
self.lastValuesRestored = False
|
|
self.wasInsideTargetLayer = False
|
|
self.enabled = True
|
|
|
|
# Sets the original GCODE line in a given GCODE command
|
|
@staticmethod
|
|
def setOriginalLine(line, original) -> str:
|
|
return line + ";[CAZO:" + original + ":CAZO]"
|
|
|
|
# Tracks the change in gcode values we're interested in
|
|
def trackChangeableValues(self, line: str):
|
|
|
|
# simulate a print speed command
|
|
if ";PRINTSPEED" in line:
|
|
line = line.replace(";PRINTSPEED ", "M220 S")
|
|
|
|
# simulate a retract feedrate command
|
|
if ";RETRACTFEEDRATE" in line:
|
|
line = line.replace(";RETRACTFEEDRATE ", "M207 F")
|
|
|
|
# simulate a retract length command
|
|
if ";RETRACTLENGTH" in line:
|
|
line = line.replace(";RETRACTLENGTH ", "M207 S")
|
|
|
|
# get our gcode command
|
|
command = GCodeCommand.getFromLine(line)
|
|
|
|
# stop here if it isn't a G or M command
|
|
if command is None:
|
|
return
|
|
|
|
# handle retract length changes
|
|
if command.command == "M207":
|
|
|
|
# get our retract length if provided
|
|
if "S" in command.arguments:
|
|
self.lastValues["retractlength"] = command.getArgumentAsFloat("S")
|
|
|
|
# get our retract feedrate if provided, convert from mm/m to mm/s
|
|
if "F" in command.arguments:
|
|
self.lastValues["retractfeedrate"] = command.getArgumentAsFloat("F") / 60.0
|
|
|
|
# move to the next command
|
|
return
|
|
|
|
# handle bed temp changes
|
|
if command.command == "M140" or command.command == "M190":
|
|
|
|
# get our bed temp if provided
|
|
if "S" in command.arguments:
|
|
self.lastValues["bedTemp"] = command.getArgumentAsFloat("S")
|
|
|
|
# move to the next command
|
|
return
|
|
|
|
# handle extruder temp changes
|
|
if command.command == "M104" or command.command == "M109":
|
|
|
|
# get our tempurature
|
|
tempurature = command.getArgumentAsFloat("S")
|
|
|
|
# don't bother if we don't have a tempurature
|
|
if tempurature is None:
|
|
return
|
|
|
|
# get our extruder, default to extruder one
|
|
extruder = command.getArgumentAsInt("T", None)
|
|
|
|
# set our extruder temp based on the extruder
|
|
if extruder is None or extruder == 0:
|
|
self.lastValues["extruderOne"] = tempurature
|
|
|
|
if extruder is None or extruder == 1:
|
|
self.lastValues["extruderTwo"] = tempurature
|
|
|
|
# move to the next command
|
|
return
|
|
|
|
# handle fan speed changes
|
|
if command.command == "M106":
|
|
|
|
# get our bed temp if provided
|
|
if "S" in command.arguments:
|
|
self.lastValues["fanSpeed"] = (command.getArgumentAsInt("S") / 255.0) * 100
|
|
|
|
# move to the next command
|
|
return
|
|
|
|
# handle flow rate changes
|
|
if command.command == "M221":
|
|
|
|
# get our flow rate
|
|
tempurature = command.getArgumentAsFloat("S")
|
|
|
|
# don't bother if we don't have a flow rate (for some reason)
|
|
if tempurature is None:
|
|
return
|
|
|
|
# get our extruder, default to global
|
|
extruder = command.getArgumentAsInt("T", None)
|
|
|
|
# set our extruder temp based on the extruder
|
|
if extruder is None:
|
|
self.lastValues["flowrate"] = tempurature
|
|
elif extruder == 1:
|
|
self.lastValues["flowrateOne"] = tempurature
|
|
elif extruder == 1:
|
|
self.lastValues["flowrateTwo"] = tempurature
|
|
|
|
# move to the next command
|
|
return
|
|
|
|
# handle print speed changes
|
|
if command.command == "M220":
|
|
|
|
# get our speed if provided
|
|
if "S" in command.arguments:
|
|
self.lastValues["speed"] = command.getArgumentAsInt("S")
|
|
|
|
# move to the next command
|
|
return
|