424 lines
16 KiB
Python
424 lines
16 KiB
Python
import logging
|
|
import gi
|
|
|
|
gi.require_version("Gtk", "3.0")
|
|
from gi.repository import Gtk, GLib
|
|
from contextlib import suppress
|
|
from ks_includes.screen_panel import ScreenPanel
|
|
from ks_includes.widgets.heatergraph import HeaterGraph
|
|
from ks_includes.widgets.keypad import Keypad
|
|
from ks_includes.KlippyGtk import find_widget
|
|
|
|
|
|
class Panel(ScreenPanel):
|
|
graph_update = None
|
|
active_heater = None
|
|
|
|
def __init__(self, screen, title, extra=None):
|
|
title = title or _("Temperature")
|
|
super().__init__(screen, title)
|
|
self.left_panel = None
|
|
self.devices = {}
|
|
self.popover = Gtk.Popover(position=Gtk.PositionType.BOTTOM)
|
|
self.popover_buttons = {}
|
|
self.long_press = {}
|
|
self.popover_device = None
|
|
self.h = self.f = 0
|
|
self.tempdeltas = ["1", "5", "10", "25"]
|
|
self.tempdelta = self.tempdeltas[-2]
|
|
self.show_preheat = self._printer.state not in ("printing", "paused")
|
|
self.preheat_options = self._screen._config.get_preheat_options()
|
|
self.grid = Gtk.Grid(row_homogeneous=True, column_homogeneous=True)
|
|
self._gtk.reset_temp_color()
|
|
|
|
right_panel = self.create_right_panel()
|
|
right_panel.set_halign(Gtk.Align.CENTER)
|
|
right_panel.set_valign(Gtk.Align.CENTER)
|
|
right_panel.set_size_request(self._screen.width / 5 * 3, self._screen.height / 5 * 4)
|
|
dev = self.create_left_panel()
|
|
if self._screen.vertical_mode:
|
|
self.grid.attach(right_panel, 0, 0, 1, 1)
|
|
else:
|
|
self.grid.attach(right_panel, 0, 0, 1, 1)
|
|
|
|
# When printing start only select tools
|
|
selection = []
|
|
if self._printer.state not in ("printing", "paused"):
|
|
selection.extend(self._printer.get_temp_devices())
|
|
elif extra:
|
|
selection.append(extra)
|
|
|
|
# Select heaters
|
|
for h in selection:
|
|
if h.startswith("temperature_sensor "):
|
|
continue
|
|
name = h.split()[1] if len(h.split()) > 1 else h
|
|
# Support for hiding devices by name
|
|
if name.startswith("_"):
|
|
continue
|
|
if h not in self.active_heaters:
|
|
self.select_heater(None, h)
|
|
|
|
self.content.add(self.grid)
|
|
|
|
def create_right_panel(self):
|
|
cooldown = self._gtk.Button(
|
|
"cool-down", _("Cooldown"), "color4", self.bts, Gtk.PositionType.LEFT, 1
|
|
)
|
|
cooldown.connect("clicked", self.set_temperature, "cooldown")
|
|
|
|
right = Gtk.Grid(row_homogeneous=True, column_homogeneous=True)
|
|
right.attach(cooldown, 0, 0, 3, 1)
|
|
right.attach(self.preheat(), 0, 1, 3, 2)
|
|
return right
|
|
|
|
|
|
def preheat(self):
|
|
self.labels["preheat_grid"] = Gtk.Grid(
|
|
row_homogeneous=True, column_homogeneous=True
|
|
)
|
|
i = 0
|
|
for option in self.preheat_options:
|
|
if option != "cooldown":
|
|
self.labels[option] = self._gtk.Button(
|
|
label=option, style=f"color{(i % 4) + 1}"
|
|
)
|
|
self.labels[option].connect("clicked", self.set_temperature, option)
|
|
self.labels["preheat_grid"].attach(
|
|
self.labels[option], (i % 2), int(i / 2), 1, 1
|
|
)
|
|
i += 1
|
|
scroll = self._gtk.ScrolledWindow()
|
|
scroll.add(self.labels["preheat_grid"])
|
|
return scroll
|
|
|
|
# Create buttons for increase and decrease
|
|
|
|
# Create buttons for temperature deltas
|
|
|
|
# Create grid for temperature deltas
|
|
|
|
# Create grid for decrease button, increase button, temperature labels, and grid
|
|
|
|
def change_temp_delta(self, widget, tempdelta):
|
|
logging.info(f"### tempdelta {tempdelta}")
|
|
self.labels[f"deg{self.tempdelta}"].get_style_context().remove_class(
|
|
"horizontal_togglebuttons_active"
|
|
)
|
|
self.labels[f"deg{tempdelta}"].get_style_context().add_class(
|
|
"horizontal_togglebuttons_active"
|
|
)
|
|
self.tempdelta = tempdelta
|
|
|
|
def change_target_temp_incremental(self, widget, direction):
|
|
|
|
if len(self.active_heaters) == 0:
|
|
self._screen.show_popup_message(_("Nothing selected"))
|
|
else:
|
|
for heater in self.active_heaters:
|
|
target = self._printer.get_stat(heater, "target")
|
|
name = heater.split()[1] if len(heater.split()) > 1 else heater
|
|
if direction == "+":
|
|
target += int(self.tempdelta)
|
|
max_temp = int(
|
|
float(self._printer.get_config_section(heater)["max_temp"])
|
|
)
|
|
if target > max_temp:
|
|
target = max_temp
|
|
self._screen.show_popup_message(
|
|
_("Can't set above the maximum:") + f" {target}"
|
|
)
|
|
|
|
else:
|
|
target -= int(self.tempdelta)
|
|
target = max(target, 0)
|
|
if heater.startswith("extruder"):
|
|
self._screen._ws.klippy.set_tool_temp(
|
|
self._printer.get_tool_number(heater), target
|
|
)
|
|
elif heater.startswith("heater_bed"):
|
|
self._screen._ws.klippy.set_bed_temp(target)
|
|
elif heater.startswith("heater_generic "):
|
|
self._screen._ws.klippy.set_heater_temp(name, target)
|
|
elif heater.startswith("temperature_fan "):
|
|
self._screen._ws.klippy.set_temp_fan_temp(name, target)
|
|
else:
|
|
logging.info(f"Unknown heater: {heater}")
|
|
self._screen.show_popup_message(_("Unknown Heater") + " " + heater)
|
|
logging.info(f"Setting {heater} to {target}")
|
|
|
|
# This has a high impact on load
|
|
|
|
def activate(self):
|
|
if not self._printer.tempstore:
|
|
self._screen.init_tempstore()
|
|
|
|
|
|
def select_heater(self, widget, device):
|
|
if (
|
|
self.active_heater is None
|
|
and device in self.devices
|
|
and self._printer.device_has_target(device)
|
|
):
|
|
if device in self.active_heaters:
|
|
self.active_heaters.pop(self.active_heaters.index(device))
|
|
self.devices[device]["name_button"].get_style_context().remove_class(
|
|
"button_active"
|
|
)
|
|
logging.info(f"Deselecting {device}")
|
|
return
|
|
self.active_heaters.append(device)
|
|
self.devices[device]["name_button"].get_style_context().add_class(
|
|
"button_active"
|
|
)
|
|
logging.info(f"Selecting {device}")
|
|
return
|
|
|
|
def set_temperature(self, widget, setting):
|
|
if len(self.active_heaters) == 0:
|
|
self._screen.show_popup_message(_("Nothing selected"))
|
|
else:
|
|
for heater in self.active_heaters:
|
|
target = None
|
|
max_temp = float(self._printer.get_config_section(heater)["max_temp"])
|
|
name = heater.split()[1] if len(heater.split()) > 1 else heater
|
|
with suppress(KeyError):
|
|
for i in self.preheat_options[setting]:
|
|
logging.info(f"{self.preheat_options[setting]}")
|
|
if i == name:
|
|
# Assign the specific target if available
|
|
target = self.preheat_options[setting][name]
|
|
logging.info(f"name match {name}")
|
|
elif i == heater:
|
|
target = self.preheat_options[setting][heater]
|
|
logging.info(f"heater match {heater}")
|
|
if (
|
|
target is None
|
|
and setting == "cooldown"
|
|
and not heater.startswith("temperature_fan ")
|
|
):
|
|
target = 0
|
|
if heater.startswith("extruder"):
|
|
if self.validate(heater, target, max_temp):
|
|
self._screen._ws.klippy.set_tool_temp(
|
|
self._printer.get_tool_number(heater), target
|
|
)
|
|
elif heater.startswith("heater_bed"):
|
|
if target is None:
|
|
with suppress(KeyError):
|
|
target = self.preheat_options[setting]["bed"]
|
|
if self.validate(heater, target, max_temp):
|
|
self._screen._ws.klippy.set_bed_temp(target)
|
|
elif heater.startswith("heater_generic "):
|
|
if target is None:
|
|
with suppress(KeyError):
|
|
target = self.preheat_options[setting]["heater_generic"]
|
|
if self.validate(heater, target, max_temp):
|
|
self._screen._ws.klippy.set_heater_temp(name, target)
|
|
elif heater.startswith("temperature_fan "):
|
|
if target is None:
|
|
with suppress(KeyError):
|
|
target = self.preheat_options[setting]["temperature_fan"]
|
|
if self.validate(heater, target, max_temp):
|
|
self._screen._ws.klippy.set_temp_fan_temp(name, target)
|
|
# This small delay is needed to properly update the target if the user configured something above
|
|
# and then changed the target again using preheat gcode
|
|
GLib.timeout_add(250, self.preheat_gcode, widget, setting)
|
|
self._screen._menu_go_back()
|
|
|
|
def validate(self, heater, target=None, max_temp=None):
|
|
if target is not None and max_temp is not None:
|
|
if 0 <= target <= max_temp:
|
|
return True
|
|
elif target > max_temp:
|
|
self._screen.show_popup_message(
|
|
_("Can't set above the maximum:") + f" {max_temp}"
|
|
)
|
|
return False
|
|
logging.debug(f"Invalid {heater} Target:{target}/{max_temp}")
|
|
return False
|
|
|
|
def preheat_gcode(self, widget, setting):
|
|
with suppress(KeyError):
|
|
script = {"script": self.preheat_options[setting]["gcode"]}
|
|
self._screen._send_action(widget, "printer.gcode.script", script)
|
|
return False
|
|
|
|
def add_device(self, device):
|
|
|
|
logging.info(f"Adding device: {device}")
|
|
|
|
temperature = self._printer.get_stat(device, "temperature")
|
|
if temperature is None:
|
|
return False
|
|
|
|
devname = device.split()[1] if len(device.split()) > 1 else device
|
|
# Support for hiding devices by name
|
|
if devname.startswith("_"):
|
|
return False
|
|
|
|
if device.startswith("extruder"):
|
|
if self._printer.extrudercount > 1:
|
|
image = f"extruder-{device[8:]}" if device[8:] else "extruder-0"
|
|
else:
|
|
image = "extruder"
|
|
class_name = f"graph_label_{device}"
|
|
dev_type = "extruder"
|
|
elif device == "heater_bed":
|
|
image = "bed"
|
|
devname = "Heater Bed"
|
|
class_name = "graph_label_heater_bed"
|
|
dev_type = "bed"
|
|
elif device.startswith("heater_generic"):
|
|
self.h += 1
|
|
image = "heater"
|
|
class_name = f"graph_label_sensor_{self.h}"
|
|
dev_type = "sensor"
|
|
elif device.startswith("temperature_fan"):
|
|
self.f += 1
|
|
image = "fan"
|
|
class_name = f"graph_label_fan_{self.f}"
|
|
dev_type = "fan"
|
|
elif self._config.get_main_config().getboolean("only_heaters", False):
|
|
return False
|
|
else:
|
|
self.h += 1
|
|
image = "heat-up"
|
|
class_name = f"graph_label_sensor_{self.h}"
|
|
dev_type = "sensor"
|
|
|
|
|
|
name = self._gtk.Button(
|
|
image, self.prettify(devname), None, self.bts, Gtk.PositionType.LEFT, 1
|
|
)
|
|
name.set_alignment(0, 0.5)
|
|
name.get_style_context().add_class(class_name)
|
|
|
|
|
|
|
|
self.devices[device] = {
|
|
"class": class_name,
|
|
"name_button": name,
|
|
}
|
|
|
|
|
|
return True
|
|
|
|
def name_pressed(self, widget, event, device):
|
|
self.popover_device = device
|
|
if event.button == 3:
|
|
self.popover_popup(widget, device)
|
|
|
|
def name_long_press_cancelled(self, gesture_long_press, widget, device):
|
|
if self.active_heater:
|
|
self.show_numpad(widget, device)
|
|
else:
|
|
self.select_heater(widget, device)
|
|
|
|
def name_long_press(self, gesture_long_press, x, y, widget, device):
|
|
self.popover_device = device
|
|
self.popover_popup(widget, device)
|
|
|
|
def toggle_visibility(self, widget, device=None):
|
|
if device is None:
|
|
device = self.popover_device
|
|
self.devices[device]["visible"] ^= True
|
|
logging.info(f"Graph show {self.devices[device]['visible']}: {device}")
|
|
|
|
section = f"graph {self._screen.connected_printer}"
|
|
if section not in self._config.get_config().sections():
|
|
self._config.get_config().add_section(section)
|
|
self._config.set(section, f"{device}", f"{self.devices[device]['visible']}")
|
|
self._config.save_user_config_options()
|
|
|
|
if self._printer.device_has_target(device):
|
|
self.popover_populate_menu()
|
|
self.popover.show_all()
|
|
|
|
def change_target_temp(self, temp):
|
|
name = (
|
|
self.active_heater.split()[1]
|
|
if len(self.active_heater.split()) > 1
|
|
else self.active_heater
|
|
)
|
|
temp = self.verify_max_temp(temp)
|
|
if temp is False:
|
|
return
|
|
|
|
if self.active_heater.startswith("extruder"):
|
|
self._screen._ws.klippy.set_tool_temp(
|
|
self._printer.get_tool_number(self.active_heater), temp
|
|
)
|
|
elif self.active_heater == "heater_bed":
|
|
self._screen._ws.klippy.set_bed_temp(temp)
|
|
elif self.active_heater.startswith("heater_generic "):
|
|
self._screen._ws.klippy.set_heater_temp(name, temp)
|
|
elif self.active_heater.startswith("temperature_fan "):
|
|
self._screen._ws.klippy.set_temp_fan_temp(name, temp)
|
|
else:
|
|
logging.info(f"Unknown heater: {self.active_heater}")
|
|
self._screen.show_popup_message(
|
|
_("Unknown Heater") + " " + self.active_heater
|
|
)
|
|
|
|
def verify_max_temp(self, temp):
|
|
temp = int(temp)
|
|
max_temp = int(
|
|
float(self._printer.get_config_section(self.active_heater)["max_temp"])
|
|
)
|
|
logging.debug(f"{temp}/{max_temp}")
|
|
if temp > max_temp:
|
|
self._screen.show_popup_message(
|
|
_("Can't set above the maximum:") + f" {max_temp}"
|
|
)
|
|
return False
|
|
return max(temp, 0)
|
|
|
|
def pid_calibrate(self, temp):
|
|
heater = self.active_heater.split(' ', maxsplit=1)[-1]
|
|
if self.verify_max_temp(temp):
|
|
script = {"script": f"PID_CALIBRATE HEATER={heater} TARGET={temp}"}
|
|
self._screen._confirm_send_action(
|
|
None,
|
|
_("Initiate a PID calibration for:")
|
|
+ f" {heater} @ {temp} ºC"
|
|
+ "\n\n"
|
|
+ _("It may take more than 5 minutes depending on the heater power."),
|
|
"printer.gcode.script",
|
|
script,
|
|
)
|
|
|
|
def create_left_panel(self):
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for d in self._printer.get_temp_devices():
|
|
self.add_device(d)
|
|
|
|
return self.left_panel
|
|
|
|
|
|
|
|
|
|
def popover_closed(self, widget):
|
|
self.popover_device = None
|
|
|
|
def popover_popup(self, widget, device):
|
|
self.popover_device = device
|
|
self.popover.set_relative_to(widget)
|
|
self.popover_populate_menu()
|
|
self.popover.show_all()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|