def execute(self, g):
gcodes = self.printer.config.get("Macros", "G29").split("\n")
self.printer.path_planner.wait_until_done()
for gcode in gcodes:
# If 'S' (imulate) remove M561 and M500 codes
if g.has_letter("S"):
if "RFS" in gcode:
logging.debug("G29: Removing due to RFS: " + str(gcode))
else:
G = Gcode({"message": gcode, "prot": g.prot})
self.printer.processor.execute(G)
self.printer.path_planner.wait_until_done()
else: # Execute all
G = Gcode({"message": gcode, "prot": g.prot})
self.printer.processor.execute(G)
self.printer.path_planner.wait_until_done()
probe_data = copy.deepcopy(self.printer.probe_points)
bed_data = {
"probe_data": {
"x": [],
"y": [],
"z": []
},
"probe_type": "test" if g.has_letter("S") else "probe",
"replicape_key": self.printer.replicape_key
}
for k, v in enumerate(probe_data):
bed_data["probe_data"]["x"].append(probe_data[k]["X"])
bed_data["probe_data"]["y"].append(probe_data[k]["Y"])
bed_data["probe_data"]["z"].append(self.printer.probe_heights[k])
Alarm.action_command("bed_probe_data", json.dumps(bed_data))
def execute(self, g):
width = g.get_float_by_letter("W", 180.0) # Bed width
depth = g.get_float_by_letter("D", 180.0) # Bed depth
points = g.get_int_by_letter("P", 16) # Points in total
probe_start_height = g.get_float_by_letter(
"S", 6.0) # Probe starting point above bed
probe_speed = g.get_float_by_letter("K", 3000)
ppd = np.sqrt(points)
probes = []
for x in np.linspace(0, width, ppd):
for y in np.linspace(0, depth, ppd):
probes.append((x, y))
gcodes = "M561; (RFS) Reset bed matrix\n"
for i, p in enumerate(probes):
gcodes += "M557 P{0} X{1:+02.2f} Y{2:+02.2f} Z{3}\n".format(
i, p[0], p[1], probe_start_height)
gcodes += " G32 ; Undock probe\n"
gcodes += " G28 ; Home steppers\n"
for i in range(len(probes)):
gcodes += " G30 P{} S F{}; Probe point {}\n".format(
i, probe_speed, i)
gcodes += " G31 ; Dock probe\n"
gcodes += " M561 U; (RFS) Update the matrix based on probe data\n"
gcodes += " M561 S; Show the current matrix\n"
gcodes += " M500; (RFS) Save data\n"
self.printer.config.set("Macros", "G29", gcodes)
Alarm.action_command("new_g29", json.dumps(gcodes))
def execute(self, g):
bed_diameter_mm = g.get_float_by_letter("D", 140.0) # Bed diameter
circles = g.get_int_by_letter("C", 2) # Number of circles
points_pr_circle = g.get_int_by_letter("P", 8) # Points pr circle
probe_start_height = g.get_float_by_letter(
"S", 6.0) # Probe starting point above bed
add_zero = bool(g.get_int_by_letter("Z", 1)) # Add probe point in 0, 0
probe_speed = g.get_float_by_letter("K", 3000)
reverse = g.get_int_by_letter("R", 0)
reverse = -1 if bool(reverse) else 1
theta = np.linspace(0,
reverse * 2 * np.pi,
points_pr_circle,
endpoint=False)
probes = []
r = bed_diameter_mm / 2
for a in np.linspace(r, 0, circles, endpoint=False):
for t in theta:
x, y = a * np.cos(t), a * np.sin(t)
probes.append((x, y))
if add_zero:
probes.append((0, 0))
gcodes = "M561; (RFS) Reset bed matrix\n"
for i, p in enumerate(probes):
gcodes += "M557 P{0} X{1:+02.2f} Y{2:+02.2f} Z{3}\n".format(
i, p[0], p[1], probe_start_height)
gcodes += " G32 ; Undock probe\n"
gcodes += " G28 ; Home steppers\n"
for i in range(len(probes)):
gcodes += " G30 P{} S F{}; Probe point {}\n".format(
i, probe_speed, i)
gcodes += " G31 ; Dock probe\n"
gcodes += " M561 U; (RFS) Update the matrix based on probe data\n"
gcodes += " M561 S; Show the current matrix\n"
gcodes += " M500; (RFS) Save data\n"
# REset probe points
self.printer.probe_points = []
self.printer.config.set("Macros", "G29", gcodes)
Alarm.action_command("new_g29", json.dumps(gcodes))
def _loop(self):
''' Gather distance travelled from each of the sensors '''
while self.running:
self.current_pos = self.sensor.get_distance()
if self.printer and self.printer.path_planner:
self.ideal_pos = self.printer.path_planner.get_extruder_pos(self.ext_nr)
# Find the error in position, removing any previously reported error
self.error_pos = self.current_pos-self.ideal_pos-self.prev_alarm_pos
# Sound the alarm, if above level.
if abs(self.error_pos) >= self.alarm_level:
self.execute_alarm()
self.prev_alarm_pos = self.current_pos-self.ideal_pos
# Send filament data, if enabled
if self.send_action_command:
Alarm.action_command("filament_sensor", self.get_error())
time.sleep(1)
def _loop(self):
''' Gather distance travelled from each of the sensors '''
while self.running:
self.current_pos = self.sensor.get_distance()
if self.printer and self.printer.path_planner:
self.ideal_pos = self.printer.path_planner.get_extruder_pos(
self.ext_nr)
# Find the error in position, removing any previously reported error
self.error_pos = self.current_pos - self.ideal_pos - self.prev_alarm_pos
# Sound the alarm, if above level.
if abs(self.error_pos) >= self.alarm_level:
self.execute_alarm()
self.prev_alarm_pos = self.current_pos - self.ideal_pos
# Send filament data, if enabled
if self.send_action_command:
Alarm.action_command("filament_sensor", self.get_error())
time.sleep(1)
def execute(self, g):
heater_nr = g.get_int_by_letter("E", 0)
heater_name = ["HBP", "E", "H", "A", "B", "C"][heater_nr+1] # Map to name
if not heater_name in self.printer.heaters:
logging.warning("M303: Heater does not exist")
return
heater = self.printer.heaters[heater_name]
temp = g.get_float_by_letter("S", 200.0)
cycles = min(3, g.get_int_by_letter("C", 4))
pre_cal = bool(g.get_int_by_letter("P", 0))
tuning_algo_nr = g.get_int_by_letter("Q", 0)
if tuning_algo_nr not in [0, 1]:
logging.warning("Unknown uning algorithm '{}'. Use one of 0, 1. Choosing 0.".format(tuning_algo_nr))
tuning_algo_nr = 0
tuning_algo = ["TL","ZN"][tuning_algo_nr]
tuner = Autotune(heater, temp, cycles, g, self.printer, pre_cal, tuning_algo)
tuner.run()
logging.info("Max temp: {}, Min temp: {}, Ku: {}, Pu: {}".format(tuner.max_temp, tuner.min_temp, tuner.Ku, tuner.Pu))
logging.info("Kp: {}, Ti: {}, Td: {}".format(heater.Kp, heater.Ti, heater.Td))
self.printer.send_message(g.prot,"Max temp: {}, Min temp: {}, Ku: {}, Pu: {}".format(tuner.max_temp, tuner.min_temp, tuner.Ku, tuner.Pu))
self.printer.send_message(g.prot, "Kp: {}, Ti: {}, Td: {}".format(heater.Kp, heater.Ti, heater.Td))
self.printer.send_message(g.prot, "Settings by G-code: \n")
self.printer.send_message(g.prot, "M130 P{} S{:.4f}\n".format(heater_nr, heater.Kp))
self.printer.send_message(g.prot, "M131 P{} S{:.4f}\n".format(heater_nr, heater.Ti))
self.printer.send_message(g.prot, "M132 P{} S{:.4f}\n".format(heater_nr, heater.Td))
self.printer.send_message(g.prot, "Settings in local.cfg: \n")
self.printer.send_message(g.prot, "pid_{}_Kp = {:.4f}\n".format(heater_name.lower(), heater.Kp))
self.printer.send_message(g.prot, "pid_{}_Ti = {:.4f}\n".format(heater_name.lower(), heater.Ti))
self.printer.send_message(g.prot, "pid_{}_Td = {:.4f}".format(heater_name.lower(), heater.Td))
tune_data = {
"tune_data": tuner.plot_temps,
"tune_gcode": g.message,
"replicape_key": self.printer.replicape_key}
Alarm.action_command("pid_tune_data", json.dumps(tune_data))
def execute(self, g):
# This G-code can be used directly
text = g.message.strip("M117 ")
Alarm.action_command("display_message", text)
def execute(self, g):
if g.has_letter("P"): # Load point
index = int(g.get_value_by_letter("P"))
point = self.printer.probe_points[index]
else:
# If no probe point is specified, use current pos
# this value is in metres
# need to convert to millimetres as we are using
#this value for a G0 call
point = self.printer.path_planner.get_current_pos(mm=True,
ideal=True)
logging.debug("G30: current position (mm) : X{} Y{} Z{}".format(
point["X"], point["Y"], point["Z"]))
if g.has_letter("X"): # Override X
point["X"] = float(g.get_value_by_letter("X"))
if g.has_letter("Y"): # Override Y
point["Y"] = float(g.get_value_by_letter("Y"))
if g.has_letter("Z"): # Override Z
point["Z"] = float(g.get_value_by_letter("Z"))
# Get probe length, if present, else use 1 cm.
if g.has_letter("D"):
probe_length = float(g.get_value_by_letter("D")) / 1000.
else:
probe_length = self.printer.config.getfloat('Probe', 'length')
# Get probe speed. If not preset, use printers curent speed.
if g.has_letter("F"):
probe_speed = float(g.get_value_by_letter("F")) / 60000.0
else:
probe_speed = self.printer.config.getfloat('Probe', 'speed')
# Get acceleration. If not present, use value from config.
if g.has_letter("A"):
probe_accel = float(g.get_value_by_letter("A"))
else:
probe_accel = self.printer.config.getfloat('Probe', 'accel')
use_bed_matrix = bool(g.get_int_by_letter("B", 0))
# Find the Probe offset
# values in config file are in metres, need to convert to millimetres
offset_x = self.printer.config.getfloat('Probe', 'offset_x') * 1000
offset_y = self.printer.config.getfloat('Probe', 'offset_y') * 1000
logging.debug("G30: probing from point (mm) : X{} Y{} Z{}".format(
point["X"] + offset_x, point["Y"] + offset_y, point["Z"]))
# Move to the position
G0 = Gcode({
"message":
"G0 X{} Y{} Z{}".format(point["X"] + offset_x,
point["Y"] + offset_y, point["Z"]),
"prot":
g.prot
})
self.printer.processor.execute(G0)
self.printer.path_planner.wait_until_done()
bed_dist = self.printer.path_planner.probe(
probe_length, probe_speed, probe_accel) * 1000.0 # convert to mm
logging.debug("Bed dist: " + str(bed_dist) + " mm")
self.printer.send_message(
g.prot,
"Found Z probe distance {0:.2f} mm at (X, Y) = ({1:.2f}, {2:.2f})".
format(bed_dist, point["X"], point["Y"]))
Alarm.action_command("bed_probe_point",
json.dumps([point["X"], point["Y"], bed_dist]))
# Must have S to save the probe bed distance
# this is required for calculation of the bed compensation matrix
# NOTE: the use of S in G30 is different to that in G29, here "S" means "save"
if g.has_letter("S"):
if not g.has_letter("P"):
logging.warning(
"G30: S-parameter was set, but no index (P) was set.")
else:
self.printer.probe_heights[index] = bed_dist
def execute(self, g):
# This G-code can be used directly
text = g.message.strip("M117 ")
Alarm.action_command("display_message", text)
