Sat, 04 Jun 2016 13:07:59 +0200
Etikett BITMAP_FINISHED für den Änderungssatz e18b2a4ef561 ergänzt
#!/usr/bin/env python # This file is part of the Printrun suite. # # Printrun is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Printrun is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Printrun. If not, see <http://www.gnu.org/licenses/>. import cmd import glob import os import time import threading import sys import shutil import subprocess import codecs import argparse import locale import logging import traceback import re from serial import SerialException from . import printcore from .utils import install_locale, run_command, get_command_output, \ format_time, format_duration, RemainingTimeEstimator, \ get_home_pos, parse_build_dimensions, parse_temperature_report, \ setup_logging install_locale('pronterface') from .settings import Settings, BuildDimensionsSetting from .power import powerset_print_start, powerset_print_stop from printrun import gcoder from .rpc import ProntRPC if os.name == "nt": try: import _winreg except: pass READLINE = True try: import readline try: readline.rl.mode.show_all_if_ambiguous = "on" # config pyreadline on windows except: pass except: READLINE = False # neither readline module is available tempreading_exp = re.compile("(^T:| T:)") REPORT_NONE = 0 REPORT_POS = 1 REPORT_TEMP = 2 REPORT_MANUAL = 4 class Status(object): def __init__(self): self.extruder_temp = 0 self.extruder_temp_target = 0 self.bed_temp = 0 self.bed_temp_target = 0 self.print_job = None self.print_job_progress = 1.0 def update_tempreading(self, tempstr): temps = parse_temperature_report(tempstr) if "T0" in temps and temps["T0"][0]: hotend_temp = float(temps["T0"][0]) elif "T" in temps and temps["T"][0]: hotend_temp = float(temps["T"][0]) else: hotend_temp = None if "T0" in temps and temps["T0"][1]: hotend_setpoint = float(temps["T0"][1]) elif "T" in temps and temps["T"][1]: hotend_setpoint = float(temps["T"][1]) else: hotend_setpoint = None if hotend_temp is not None: self.extruder_temp = hotend_temp if hotend_setpoint is not None: self.extruder_temp_target = hotend_setpoint bed_temp = float(temps["B"][0]) if "B" in temps and temps["B"][0] else None if bed_temp is not None: self.bed_temp = bed_temp setpoint = temps["B"][1] if setpoint: self.bed_temp_target = float(setpoint) @property def bed_enabled(self): return self.bed_temp != 0 @property def extruder_enabled(self): return self.extruder_temp != 0 class pronsole(cmd.Cmd): def __init__(self): cmd.Cmd.__init__(self) if not READLINE: self.completekey = None self.status = Status() self.dynamic_temp = False self.compute_eta = None self.statuscheck = False self.status_thread = None self.monitor_interval = 3 self.p = printcore.printcore() self.p.recvcb = self.recvcb self.p.startcb = self.startcb self.p.endcb = self.endcb self.p.layerchangecb = self.layer_change_cb self.p.process_host_command = self.process_host_command self.recvlisteners = [] self.in_macro = False self.p.onlinecb = self.online self.p.errorcb = self.logError self.fgcode = None self.filename = None self.rpc_server = None self.curlayer = 0 self.sdlisting = 0 self.sdlisting_echo = 0 self.sdfiles = [] self.paused = False self.sdprinting = 0 self.uploading = 0 # Unused, just for pronterface generalization self.temps = {"pla": "185", "abs": "230", "off": "0"} self.bedtemps = {"pla": "60", "abs": "110", "off": "0"} self.percentdone = 0 self.posreport = "" self.tempreadings = "" self.userm114 = 0 self.userm105 = 0 self.m105_waitcycles = 0 self.macros = {} self.history_file = "~/.pronsole-history" self.rc_loaded = False self.processing_rc = False self.processing_args = False self.settings = Settings(self) self.settings._add(BuildDimensionsSetting("build_dimensions", "200x200x100+0+0+0+0+0+0", _("Build dimensions"), _("Dimensions of Build Platform\n & optional offset of origin\n & optional switch position\n\nExamples:\n XXXxYYY\n XXX,YYY,ZZZ\n XXXxYYYxZZZ+OffX+OffY+OffZ\nXXXxYYYxZZZ+OffX+OffY+OffZ+HomeX+HomeY+HomeZ"), "Printer"), self.update_build_dimensions) self.settings._port_list = self.scanserial self.settings._temperature_abs_cb = self.set_temp_preset self.settings._temperature_pla_cb = self.set_temp_preset self.settings._bedtemp_abs_cb = self.set_temp_preset self.settings._bedtemp_pla_cb = self.set_temp_preset self.update_build_dimensions(None, self.settings.build_dimensions) self.update_tcp_streaming_mode(None, self.settings.tcp_streaming_mode) self.monitoring = 0 self.starttime = 0 self.extra_print_time = 0 self.silent = False self.commandprefixes = 'MGT$' self.promptstrs = {"offline": "%(bold)soffline>%(normal)s ", "fallback": "%(bold)sPC>%(normal)s ", "macro": "%(bold)s..>%(normal)s ", "online": "%(bold)sT:%(extruder_temp_fancy)s%(progress_fancy)s>%(normal)s "} # -------------------------------------------------------------- # General console handling # -------------------------------------------------------------- def postloop(self): self.p.disconnect() cmd.Cmd.postloop(self) def preloop(self): self.log(_("Welcome to the printer console! Type \"help\" for a list of available commands.")) self.prompt = self.promptf() cmd.Cmd.preloop(self) # We replace this function, defined in cmd.py . # It's default behavior with regards to Ctr-C # and Ctr-D doesn't make much sense... def cmdloop(self, intro=None): """Repeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument. """ self.preloop() if self.use_rawinput and self.completekey: try: import readline self.old_completer = readline.get_completer() readline.set_completer(self.complete) readline.parse_and_bind(self.completekey + ": complete") history = os.path.expanduser(self.history_file) if os.path.exists(history): readline.read_history_file(history) except ImportError: pass try: if intro is not None: self.intro = intro if self.intro: self.stdout.write(str(self.intro) + "\n") stop = None while not stop: if self.cmdqueue: line = self.cmdqueue.pop(0) else: if self.use_rawinput: try: line = raw_input(self.prompt) except EOFError: self.log("") self.do_exit("") except KeyboardInterrupt: self.log("") line = "" else: self.stdout.write(self.prompt) self.stdout.flush() line = self.stdin.readline() if not len(line): line = "" else: line = line.rstrip('\r\n') line = self.precmd(line) stop = self.onecmd(line) stop = self.postcmd(stop, line) self.postloop() finally: if self.use_rawinput and self.completekey: try: import readline readline.set_completer(self.old_completer) readline.write_history_file(history) except ImportError: pass def confirm(self): y_or_n = raw_input("y/n: ") if y_or_n == "y": return True elif y_or_n != "n": return self.confirm() return False def log(self, *msg): msg = u"".join(unicode(i) for i in msg) logging.info(msg) def logError(self, *msg): msg = u"".join(unicode(i) for i in msg) logging.error(msg) if not self.settings.error_command: return output = get_command_output(self.settings.error_command, {"$m": msg}) if output: self.log("Error command output:") self.log(output.rstrip()) def promptf(self): """A function to generate prompts so that we can do dynamic prompts. """ if self.in_macro: promptstr = self.promptstrs["macro"] elif not self.p.online: promptstr = self.promptstrs["offline"] elif self.status.extruder_enabled: promptstr = self.promptstrs["online"] else: promptstr = self.promptstrs["fallback"] if "%" not in promptstr: return promptstr else: specials = {} specials["extruder_temp"] = str(int(self.status.extruder_temp)) specials["extruder_temp_target"] = str(int(self.status.extruder_temp_target)) if self.status.extruder_temp_target == 0: specials["extruder_temp_fancy"] = str(int(self.status.extruder_temp)) else: specials["extruder_temp_fancy"] = "%s/%s" % (str(int(self.status.extruder_temp)), str(int(self.status.extruder_temp_target))) if self.p.printing: progress = int(1000 * float(self.p.queueindex) / len(self.p.mainqueue)) / 10 elif self.sdprinting: progress = self.percentdone else: progress = 0.0 specials["progress"] = str(progress) if self.p.printing or self.sdprinting: specials["progress_fancy"] = " " + str(progress) + "%" else: specials["progress_fancy"] = "" specials["bold"] = "\033[01m" specials["normal"] = "\033[00m" return promptstr % specials def postcmd(self, stop, line): """ A hook we override to generate prompts after each command is executed, for the next prompt. We also use it to send M105 commands so that temp info gets updated for the prompt.""" if self.p.online and self.dynamic_temp: self.p.send_now("M105") self.prompt = self.promptf() return stop def kill(self): self.statuscheck = False if self.status_thread: self.status_thread.join() self.status_thread = None if self.rpc_server is not None: self.rpc_server.shutdown() def write_prompt(self): sys.stdout.write(self.promptf()) sys.stdout.flush() def help_help(self, l = ""): self.do_help("") def do_gcodes(self, l = ""): self.help_gcodes() def help_gcodes(self): self.log("Gcodes are passed through to the printer as they are") def precmd(self, line): if line.upper().startswith("M114"): self.userm114 += 1 elif line.upper().startswith("M105"): self.userm105 += 1 return line def help_shell(self): self.log("Executes a python command. Example:") self.log("! os.listdir('.')") def do_shell(self, l): exec(l) def emptyline(self): """Called when an empty line is entered - do not remove""" pass def default(self, l): if l[0].upper() in self.commandprefixes.upper(): if self.p and self.p.online: if not self.p.loud: self.log("SENDING:" + l.upper()) self.p.send_now(l.upper()) else: self.logError(_("Printer is not online.")) return elif l[0] == "@": if self.p and self.p.online: if not self.p.loud: self.log("SENDING:" + l[1:]) self.p.send_now(l[1:]) else: self.logError(_("Printer is not online.")) return else: cmd.Cmd.default(self, l) def do_exit(self, l): if self.status.extruder_temp_target != 0: self.log("Setting extruder temp to 0") self.p.send_now("M104 S0.0") if self.status.bed_enabled: if self.status.bed_temp_target != 0: self.log("Setting bed temp to 0") self.p.send_now("M140 S0.0") self.log("Disconnecting from printer...") if self.p.printing: self.log(_("Are you sure you want to exit while printing?\n\ (this will terminate the print).")) if not self.confirm(): return self.log(_("Exiting program. Goodbye!")) self.p.disconnect() self.kill() sys.exit() def help_exit(self): self.log(_("Disconnects from the printer and exits the program.")) # -------------------------------------------------------------- # Macro handling # -------------------------------------------------------------- def complete_macro(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in self.macros.keys() if i.startswith(text)] elif len(line.split()) == 3 or (len(line.split()) == 2 and line[-1] == " "): return [i for i in ["/D", "/S"] + self.completenames(text) if i.startswith(text)] else: return [] def hook_macro(self, l): l = l.rstrip() ls = l.lstrip() ws = l[:len(l) - len(ls)] # just leading whitespace if len(ws) == 0: self.end_macro() # pass the unprocessed line to regular command processor to not require empty line in .pronsolerc return self.onecmd(l) self.cur_macro_def += l + "\n" def end_macro(self): if "onecmd" in self.__dict__: del self.onecmd # remove override self.in_macro = False self.prompt = self.promptf() if self.cur_macro_def != "": self.macros[self.cur_macro_name] = self.cur_macro_def macro = self.compile_macro(self.cur_macro_name, self.cur_macro_def) setattr(self.__class__, "do_" + self.cur_macro_name, lambda self, largs, macro = macro: macro(self, *largs.split())) setattr(self.__class__, "help_" + self.cur_macro_name, lambda self, macro_name = self.cur_macro_name: self.subhelp_macro(macro_name)) if not self.processing_rc: self.log("Macro '" + self.cur_macro_name + "' defined") # save it if not self.processing_args: macro_key = "macro " + self.cur_macro_name macro_def = macro_key if "\n" in self.cur_macro_def: macro_def += "\n" else: macro_def += " " macro_def += self.cur_macro_def self.save_in_rc(macro_key, macro_def) else: self.logError("Empty macro - cancelled") del self.cur_macro_name, self.cur_macro_def def compile_macro_line(self, line): line = line.rstrip() ls = line.lstrip() ws = line[:len(line) - len(ls)] # just leading whitespace if ls == "" or ls.startswith('#'): return "" # no code if ls.startswith('!'): return ws + ls[1:] + "\n" # python mode else: ls = ls.replace('"', '\\"') # need to escape double quotes ret = ws + 'self.precmd("' + ls + '".format(*arg))\n' # parametric command mode return ret + ws + 'self.onecmd("' + ls + '".format(*arg))\n' def compile_macro(self, macro_name, macro_def): if macro_def.strip() == "": self.logError("Empty macro - cancelled") return macro = None pycode = "def macro(self,*arg):\n" if "\n" not in macro_def.strip(): pycode += self.compile_macro_line(" " + macro_def.strip()) else: lines = macro_def.split("\n") for l in lines: pycode += self.compile_macro_line(l) exec pycode return macro def start_macro(self, macro_name, prev_definition = "", suppress_instructions = False): if not self.processing_rc and not suppress_instructions: self.logError("Enter macro using indented lines, end with empty line") self.cur_macro_name = macro_name self.cur_macro_def = "" self.onecmd = self.hook_macro # override onecmd temporarily self.in_macro = False self.prompt = self.promptf() def delete_macro(self, macro_name): if macro_name in self.macros.keys(): delattr(self.__class__, "do_" + macro_name) del self.macros[macro_name] self.log("Macro '" + macro_name + "' removed") if not self.processing_rc and not self.processing_args: self.save_in_rc("macro " + macro_name, "") else: self.logError("Macro '" + macro_name + "' is not defined") def do_macro(self, args): if args.strip() == "": self.print_topics("User-defined macros", map(str, self.macros.keys()), 15, 80) return arglist = args.split(None, 1) macro_name = arglist[0] if macro_name not in self.macros and hasattr(self.__class__, "do_" + macro_name): self.logError("Name '" + macro_name + "' is being used by built-in command") return if len(arglist) == 2: macro_def = arglist[1] if macro_def.lower() == "/d": self.delete_macro(macro_name) return if macro_def.lower() == "/s": self.subhelp_macro(macro_name) return self.cur_macro_def = macro_def self.cur_macro_name = macro_name self.end_macro() return if macro_name in self.macros: self.start_macro(macro_name, self.macros[macro_name]) else: self.start_macro(macro_name) def help_macro(self): self.log("Define single-line macro: macro <name> <definition>") self.log("Define multi-line macro: macro <name>") self.log("Enter macro definition in indented lines. Use {0} .. {N} to substitute macro arguments") self.log("Enter python code, prefixed with ! Use arg[0] .. arg[N] to substitute macro arguments") self.log("Delete macro: macro <name> /d") self.log("Show macro definition: macro <name> /s") self.log("'macro' without arguments displays list of defined macros") def subhelp_macro(self, macro_name): if macro_name in self.macros.keys(): macro_def = self.macros[macro_name] if "\n" in macro_def: self.log("Macro '" + macro_name + "' defined as:") self.log(self.macros[macro_name] + "----------------") else: self.log("Macro '" + macro_name + "' defined as: '" + macro_def + "'") else: self.logError("Macro '" + macro_name + "' is not defined") # -------------------------------------------------------------- # Configuration handling # -------------------------------------------------------------- def set(self, var, str): try: t = type(getattr(self.settings, var)) value = self.settings._set(var, str) if not self.processing_rc and not self.processing_args: self.save_in_rc("set " + var, "set %s %s" % (var, value)) except AttributeError: logging.debug(_("Unknown variable '%s'") % var) except ValueError, ve: if hasattr(ve, "from_validator"): self.logError(_("Bad value %s for variable '%s': %s") % (str, var, ve.args[0])) else: self.logError(_("Bad value for variable '%s', expecting %s (%s)") % (var, repr(t)[1:-1], ve.args[0])) def do_set(self, argl): args = argl.split(None, 1) if len(args) < 1: for k in [kk for kk in dir(self.settings) if not kk.startswith("_")]: self.log("%s = %s" % (k, str(getattr(self.settings, k)))) return if len(args) < 2: # Try getting the default value of the setting to check whether it # actually exists try: getattr(self.settings, args[0]) except AttributeError: logging.warning("Unknown variable '%s'" % args[0]) return self.set(args[0], args[1]) def help_set(self): self.log("Set variable: set <variable> <value>") self.log("Show variable: set <variable>") self.log("'set' without arguments displays all variables") def complete_set(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in dir(self.settings) if not i.startswith("_") and i.startswith(text)] elif len(line.split()) == 3 or (len(line.split()) == 2 and line[-1] == " "): return [i for i in self.settings._tabcomplete(line.split()[1]) if i.startswith(text)] else: return [] def load_rc(self, rc_filename): self.processing_rc = True try: rc = codecs.open(rc_filename, "r", "utf-8") self.rc_filename = os.path.abspath(rc_filename) for rc_cmd in rc: if not rc_cmd.lstrip().startswith("#"): self.onecmd(rc_cmd) rc.close() if hasattr(self, "cur_macro_def"): self.end_macro() self.rc_loaded = True finally: self.processing_rc = False def load_default_rc(self, rc_filename = ".pronsolerc"): if rc_filename == ".pronsolerc" and hasattr(sys, "frozen") and sys.frozen in ["windows_exe", "console_exe"]: rc_filename = "printrunconf.ini" try: try: self.load_rc(os.path.join(os.path.expanduser("~"), rc_filename)) except IOError: self.load_rc(rc_filename) except IOError: # make sure the filename is initialized self.rc_filename = os.path.abspath(os.path.join(os.path.expanduser("~"), rc_filename)) def save_in_rc(self, key, definition): """ Saves or updates macro or other definitions in .pronsolerc key is prefix that determines what is being defined/updated (e.g. 'macro foo') definition is the full definition (that is written to file). (e.g. 'macro foo move x 10') Set key as empty string to just add (and not overwrite) Set definition as empty string to remove it from .pronsolerc To delete line from .pronsolerc, set key as the line contents, and definition as empty string Only first definition with given key is overwritten. Updates are made in the same file position. Additions are made to the end of the file. """ rci, rco = None, None if definition != "" and not definition.endswith("\n"): definition += "\n" try: written = False if os.path.exists(self.rc_filename): shutil.copy(self.rc_filename, self.rc_filename + "~bak") rci = codecs.open(self.rc_filename + "~bak", "r", "utf-8") rco = codecs.open(self.rc_filename + "~new", "w", "utf-8") if rci is not None: overwriting = False for rc_cmd in rci: l = rc_cmd.rstrip() ls = l.lstrip() ws = l[:len(l) - len(ls)] # just leading whitespace if overwriting and len(ws) == 0: overwriting = False if not written and key != "" and rc_cmd.startswith(key) and (rc_cmd + "\n")[len(key)].isspace(): overwriting = True written = True rco.write(definition) if not overwriting: rco.write(rc_cmd) if not rc_cmd.endswith("\n"): rco.write("\n") if not written: rco.write(definition) if rci is not None: rci.close() rco.close() shutil.move(self.rc_filename + "~new", self.rc_filename) # if definition != "": # self.log("Saved '"+key+"' to '"+self.rc_filename+"'") # else: # self.log("Removed '"+key+"' from '"+self.rc_filename+"'") except Exception, e: self.logError("Saving failed for ", key + ":", str(e)) finally: del rci, rco # -------------------------------------------------------------- # Configuration update callbacks # -------------------------------------------------------------- def update_build_dimensions(self, param, value): self.build_dimensions_list = parse_build_dimensions(value) self.p.analyzer.home_pos = get_home_pos(self.build_dimensions_list) def update_tcp_streaming_mode(self, param, value): self.p.tcp_streaming_mode = self.settings.tcp_streaming_mode def update_rpc_server(self, param, value): if value: if self.rpc_server is None: self.rpc_server = ProntRPC(self) else: if self.rpc_server is not None: self.rpc_server.shutdown() self.rpc_server = None # -------------------------------------------------------------- # Command line options handling # -------------------------------------------------------------- def add_cmdline_arguments(self, parser): parser.add_argument('-v', '--verbose', help = _("increase verbosity"), action = "store_true") parser.add_argument('-c', '--conf', '--config', help = _("load this file on startup instead of .pronsolerc ; you may chain config files, if so settings auto-save will use the last specified file"), action = "append", default = []) parser.add_argument('-e', '--execute', help = _("executes command after configuration/.pronsolerc is loaded ; macros/settings from these commands are not autosaved"), action = "append", default = []) parser.add_argument('filename', nargs='?', help = _("file to load")) def process_cmdline_arguments(self, args): if args.verbose: logger = logging.getLogger() logger.setLevel(logging.DEBUG) for config in args.conf: self.load_rc(config) if not self.rc_loaded: self.load_default_rc() self.processing_args = True for command in args.execute: self.onecmd(command) self.processing_args = False self.update_rpc_server(None, self.settings.rpc_server) if args.filename: filename = args.filename.decode(locale.getpreferredencoding()) self.cmdline_filename_callback(filename) def cmdline_filename_callback(self, filename): self.do_load(filename) def parse_cmdline(self, args): parser = argparse.ArgumentParser(description = 'Printrun 3D printer interface') self.add_cmdline_arguments(parser) args = [arg for arg in args if not arg.startswith("-psn")] args = parser.parse_args(args = args) self.process_cmdline_arguments(args) setup_logging(sys.stdout, self.settings.log_path, True) # -------------------------------------------------------------- # Printer connection handling # -------------------------------------------------------------- def connect_to_printer(self, port, baud, dtr): try: self.p.connect(port, baud, dtr) except SerialException as e: # Currently, there is no errno, but it should be there in the future if e.errno == 2: self.logError(_("Error: You are trying to connect to a non-existing port.")) elif e.errno == 8: self.logError(_("Error: You don't have permission to open %s.") % port) self.logError(_("You might need to add yourself to the dialout group.")) else: self.logError(traceback.format_exc()) # Kill the scope anyway return False except OSError as e: if e.errno == 2: self.logError(_("Error: You are trying to connect to a non-existing port.")) else: self.logError(traceback.format_exc()) return False self.statuscheck = True self.status_thread = threading.Thread(target = self.statuschecker) self.status_thread.start() return True def do_connect(self, l): a = l.split() p = self.scanserial() port = self.settings.port if (port == "" or port not in p) and len(p) > 0: port = p[0] baud = self.settings.baudrate or 115200 if len(a) > 0: port = a[0] if len(a) > 1: try: baud = int(a[1]) except: self.log("Bad baud value '" + a[1] + "' ignored") if len(p) == 0 and not port: self.log("No serial ports detected - please specify a port") return if len(a) == 0: self.log("No port specified - connecting to %s at %dbps" % (port, baud)) if port != self.settings.port: self.settings.port = port self.save_in_rc("set port", "set port %s" % port) if baud != self.settings.baudrate: self.settings.baudrate = baud self.save_in_rc("set baudrate", "set baudrate %d" % baud) self.connect_to_printer(port, baud, self.settings.dtr) def help_connect(self): self.log("Connect to printer") self.log("connect <port> <baudrate>") self.log("If port and baudrate are not specified, connects to first detected port at 115200bps") ports = self.scanserial() if ports: self.log("Available ports: ", " ".join(ports)) else: self.log("No serial ports were automatically found.") def complete_connect(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in self.scanserial() if i.startswith(text)] elif len(line.split()) == 3 or (len(line.split()) == 2 and line[-1] == " "): return [i for i in ["2400", "9600", "19200", "38400", "57600", "115200"] if i.startswith(text)] else: return [] def scanserial(self): """scan for available ports. return a list of device names.""" baselist = [] if os.name == "nt": try: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM") i = 0 while(1): baselist += [_winreg.EnumValue(key, i)[1]] i += 1 except: pass for g in ['/dev/ttyUSB*', '/dev/ttyACM*', "/dev/tty.*", "/dev/cu.*", "/dev/rfcomm*"]: baselist += glob.glob(g) return filter(self._bluetoothSerialFilter, baselist) def _bluetoothSerialFilter(self, serial): return not ("Bluetooth" in serial or "FireFly" in serial) def online(self): self.log("\rPrinter is now online") self.write_prompt() def do_disconnect(self, l): self.p.disconnect() def help_disconnect(self): self.log("Disconnects from the printer") def do_block_until_online(self, l): while not self.p.online: time.sleep(0.1) def help_block_until_online(self, l): self.log("Blocks until printer is online") self.log("Warning: if something goes wrong, this can block pronsole forever") # -------------------------------------------------------------- # Printer status monitoring # -------------------------------------------------------------- def statuschecker_inner(self, do_monitoring = True): if self.p.online: if self.p.writefailures >= 4: self.logError(_("Disconnecting after 4 failed writes.")) self.status_thread = None self.disconnect() return if do_monitoring: if self.sdprinting and not self.paused: self.p.send_now("M27") if self.m105_waitcycles % 10 == 0: self.p.send_now("M105") self.m105_waitcycles += 1 cur_time = time.time() wait_time = 0 while time.time() < cur_time + self.monitor_interval - 0.25: if not self.statuscheck: break time.sleep(0.25) # Safeguard: if system time changes and goes back in the past, # we could get stuck almost forever wait_time += 0.25 if wait_time > self.monitor_interval - 0.25: break # Always sleep at least a bit, if something goes wrong with the # system time we'll avoid freezing the whole app this way time.sleep(0.25) def statuschecker(self): while self.statuscheck: self.statuschecker_inner() # -------------------------------------------------------------- # File loading handling # -------------------------------------------------------------- def do_load(self, filename): self._do_load(filename) def _do_load(self, filename): if not filename: self.logError("No file name given.") return self.log(_("Loading file: %s") % filename) if not os.path.exists(filename): self.logError("File not found!") return self.load_gcode(filename) self.log(_("Loaded %s, %d lines.") % (filename, len(self.fgcode))) self.log(_("Estimated duration: %d layers, %s") % self.fgcode.estimate_duration()) def load_gcode(self, filename, layer_callback = None, gcode = None): if gcode is None: self.fgcode = gcoder.LightGCode(deferred = True) else: self.fgcode = gcode self.fgcode.prepare(open(filename, "rU"), get_home_pos(self.build_dimensions_list), layer_callback = layer_callback) self.fgcode.estimate_duration() self.filename = filename def complete_load(self, text, line, begidx, endidx): s = line.split() if len(s) > 2: return [] if (len(s) == 1 and line[-1] == " ") or (len(s) == 2 and line[-1] != " "): if len(s) > 1: return [i[len(s[1]) - len(text):] for i in glob.glob(s[1] + "*/") + glob.glob(s[1] + "*.g*")] else: return glob.glob("*/") + glob.glob("*.g*") def help_load(self): self.log("Loads a gcode file (with tab-completion)") def do_slice(self, l): l = l.split() if len(l) == 0: self.logError(_("No file name given.")) return settings = 0 if l[0] == "set": settings = 1 else: self.log(_("Slicing file: %s") % l[0]) if not(os.path.exists(l[0])): self.logError(_("File not found!")) return try: if settings: command = self.settings.sliceoptscommand self.log(_("Entering slicer settings: %s") % command) run_command(command, blocking = True) else: command = self.settings.slicecommand stl_name = l[0] gcode_name = stl_name.replace(".stl", "_export.gcode").replace(".STL", "_export.gcode") run_command(command, {"$s": stl_name, "$o": gcode_name}, blocking = True) self.log(_("Loading sliced file.")) self.do_load(l[0].replace(".stl", "_export.gcode")) except Exception, e: self.logError(_("Slicing failed: %s") % e) def complete_slice(self, text, line, begidx, endidx): s = line.split() if len(s) > 2: return [] if (len(s) == 1 and line[-1] == " ") or (len(s) == 2 and line[-1] != " "): if len(s) > 1: return [i[len(s[1]) - len(text):] for i in glob.glob(s[1] + "*/") + glob.glob(s[1] + "*.stl")] else: return glob.glob("*/") + glob.glob("*.stl") def help_slice(self): self.log(_("Creates a gcode file from an stl model using the slicer (with tab-completion)")) self.log(_("slice filename.stl - create gcode file")) self.log(_("slice filename.stl view - create gcode file and view using skeiniso (if using skeinforge)")) self.log(_("slice set - adjust slicer settings")) # -------------------------------------------------------------- # Print/upload handling # -------------------------------------------------------------- def do_upload(self, l): names = l.split() if len(names) == 2: filename = names[0] targetname = names[1] else: self.logError(_("Please enter target name in 8.3 format.")) return if not self.p.online: self.logError(_("Not connected to printer.")) return self._do_load(filename) self.log(_("Uploading as %s") % targetname) self.log(_("Uploading %s") % self.filename) self.p.send_now("M28 " + targetname) self.log(_("Press Ctrl-C to interrupt upload.")) self.p.startprint(self.fgcode) try: sys.stdout.write(_("Progress: ") + "00.0%") sys.stdout.flush() while self.p.printing: time.sleep(0.5) sys.stdout.write("\b\b\b\b\b%04.1f%%" % (100 * float(self.p.queueindex) / len(self.p.mainqueue),)) sys.stdout.flush() self.p.send_now("M29 " + targetname) time.sleep(0.2) self.p.clear = True self._do_ls(False) self.log("\b\b\b\b\b100%.") self.log(_("Upload completed. %s should now be on the card.") % targetname) return except (KeyboardInterrupt, Exception) as e: if isinstance(e, KeyboardInterrupt): self.logError(_("...interrupted!")) else: self.logError(_("Something wrong happened while uploading:") + "\n" + traceback.format_exc()) self.p.pause() self.p.send_now("M29 " + targetname) time.sleep(0.2) self.p.cancelprint() self.logError(_("A partial file named %s may have been written to the sd card.") % targetname) def complete_upload(self, text, line, begidx, endidx): s = line.split() if len(s) > 2: return [] if (len(s) == 1 and line[-1] == " ") or (len(s) == 2 and line[-1] != " "): if len(s) > 1: return [i[len(s[1]) - len(text):] for i in glob.glob(s[1] + "*/") + glob.glob(s[1] + "*.g*")] else: return glob.glob("*/") + glob.glob("*.g*") def help_upload(self): self.log("Uploads a gcode file to the sd card") def help_print(self): if not self.fgcode: self.log(_("Send a loaded gcode file to the printer. Load a file with the load command first.")) else: self.log(_("Send a loaded gcode file to the printer. You have %s loaded right now.") % self.filename) def do_print(self, l): if not self.fgcode: self.logError(_("No file loaded. Please use load first.")) return if not self.p.online: self.logError(_("Not connected to printer.")) return self.log(_("Printing %s") % self.filename) self.log(_("You can monitor the print with the monitor command.")) self.sdprinting = False self.p.startprint(self.fgcode) def do_pause(self, l): if self.sdprinting: self.p.send_now("M25") else: if not self.p.printing: self.logError(_("Not printing, cannot pause.")) return self.p.pause() self.paused = True def help_pause(self): self.log(_("Pauses a running print")) def pause(self, event = None): return self.do_pause(None) def do_resume(self, l): if not self.paused: self.logError(_("Not paused, unable to resume. Start a print first.")) return self.paused = False if self.sdprinting: self.p.send_now("M24") return else: self.p.resume() def help_resume(self): self.log(_("Resumes a paused print.")) def listfiles(self, line): if "Begin file list" in line: self.sdlisting = 1 elif "End file list" in line: self.sdlisting = 0 self.recvlisteners.remove(self.listfiles) if self.sdlisting_echo: self.log(_("Files on SD card:")) self.log("\n".join(self.sdfiles)) elif self.sdlisting: self.sdfiles.append(line.strip().lower()) def _do_ls(self, echo): # FIXME: this was 2, but I think it should rather be 0 as in do_upload self.sdlisting = 0 self.sdlisting_echo = echo self.sdfiles = [] self.recvlisteners.append(self.listfiles) self.p.send_now("M20") def do_ls(self, l): if not self.p.online: self.logError(_("Printer is not online. Please connect to it first.")) return self._do_ls(True) def help_ls(self): self.log(_("Lists files on the SD card")) def waitforsdresponse(self, l): if "file.open failed" in l: self.logError(_("Opening file failed.")) self.recvlisteners.remove(self.waitforsdresponse) return if "File opened" in l: self.log(l) if "File selected" in l: self.log(_("Starting print")) self.p.send_now("M24") self.sdprinting = True # self.recvlisteners.remove(self.waitforsdresponse) return if "Done printing file" in l: self.log(l) self.sdprinting = False self.recvlisteners.remove(self.waitforsdresponse) return if "SD printing byte" in l: # M27 handler try: resp = l.split() vals = resp[-1].split("/") self.percentdone = 100.0 * int(vals[0]) / int(vals[1]) except: pass def do_reset(self, l): self.p.reset() def help_reset(self): self.log(_("Resets the printer.")) def do_sdprint(self, l): if not self.p.online: self.log(_("Printer is not online. Please connect to it first.")) return self._do_ls(False) while self.listfiles in self.recvlisteners: time.sleep(0.1) if l.lower() not in self.sdfiles: self.log(_("File is not present on card. Please upload it first.")) return self.recvlisteners.append(self.waitforsdresponse) self.p.send_now("M23 " + l.lower()) self.log(_("Printing file: %s from SD card.") % l.lower()) self.log(_("Requesting SD print...")) time.sleep(1) def help_sdprint(self): self.log(_("Print a file from the SD card. Tab completes with available file names.")) self.log(_("sdprint filename.g")) def complete_sdprint(self, text, line, begidx, endidx): if not self.sdfiles and self.p.online: self._do_ls(False) while self.listfiles in self.recvlisteners: time.sleep(0.1) if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in self.sdfiles if i.startswith(text)] # -------------------------------------------------------------- # Printcore callbacks # -------------------------------------------------------------- def startcb(self, resuming = False): self.starttime = time.time() if resuming: self.log(_("Print resumed at: %s") % format_time(self.starttime)) else: self.log(_("Print started at: %s") % format_time(self.starttime)) if not self.sdprinting: self.compute_eta = RemainingTimeEstimator(self.fgcode) else: self.compute_eta = None if self.settings.start_command: output = get_command_output(self.settings.start_command, {"$s": str(self.filename), "$t": format_time(time.time())}) if output: self.log("Start command output:") self.log(output.rstrip()) try: powerset_print_start(reason = "Preventing sleep during print") except: self.logError(_("Failed to set power settings:") + "\n" + traceback.format_exc()) def endcb(self): try: powerset_print_stop() except: self.logError(_("Failed to set power settings:") + "\n" + traceback.format_exc()) if self.p.queueindex == 0: print_duration = int(time.time() - self.starttime + self.extra_print_time) self.log(_("Print ended at: %(end_time)s and took %(duration)s") % {"end_time": format_time(time.time()), "duration": format_duration(print_duration)}) # Update total filament length used if self.fgcode is not None: new_total = self.settings.total_filament_used + self.fgcode.filament_length self.set("total_filament_used", new_total) if not self.settings.final_command: return output = get_command_output(self.settings.final_command, {"$s": str(self.filename), "$t": format_duration(print_duration)}) if output: self.log("Final command output:") self.log(output.rstrip()) def recvcb_report(self, l): isreport = REPORT_NONE if "ok C:" in l or "Count" in l \ or ("X:" in l and len(gcoder.m114_exp.findall(l)) == 6): self.posreport = l isreport = REPORT_POS if self.userm114 > 0: self.userm114 -= 1 isreport |= REPORT_MANUAL if "ok T:" in l or tempreading_exp.findall(l): self.tempreadings = l isreport = REPORT_TEMP if self.userm105 > 0: self.userm105 -= 1 isreport |= REPORT_MANUAL else: self.m105_waitcycles = 0 return isreport def recvcb_actions(self, l): if l.startswith("!!"): self.do_pause(None) msg = l.split(" ", 1) if len(msg) > 1 and self.silent is False: self.logError(msg[1].ljust(15)) sys.stdout.write(self.promptf()) sys.stdout.flush() return True elif l.startswith("//"): command = l.split(" ", 1) if len(command) > 1: command = command[1] self.log(_("Received command %s") % command) command = command.split(":") if len(command) == 2 and command[0] == "action": command = command[1] if command == "pause": self.do_pause(None) sys.stdout.write(self.promptf()) sys.stdout.flush() return True elif command == "resume": self.do_resume(None) sys.stdout.write(self.promptf()) sys.stdout.flush() return True elif command == "disconnect": self.do_disconnect(None) sys.stdout.write(self.promptf()) sys.stdout.flush() return True return False def recvcb(self, l): l = l.rstrip() for listener in self.recvlisteners: listener(l) if not self.recvcb_actions(l): report_type = self.recvcb_report(l) if report_type & REPORT_TEMP: self.status.update_tempreading(l) if l != "ok" and not self.sdlisting \ and not self.monitoring and (report_type == REPORT_NONE or report_type & REPORT_MANUAL): if l[:5] == "echo:": l = l[5:].lstrip() if self.silent is False: self.log("\r" + l.ljust(15)) sys.stdout.write(self.promptf()) sys.stdout.flush() def layer_change_cb(self, newlayer): layerz = self.fgcode.all_layers[newlayer].z if layerz is not None: self.curlayer = layerz if self.compute_eta: secondselapsed = int(time.time() - self.starttime + self.extra_print_time) self.compute_eta.update_layer(newlayer, secondselapsed) def get_eta(self): if self.sdprinting or self.uploading: if self.uploading: fractioncomplete = float(self.p.queueindex) / len(self.p.mainqueue) else: fractioncomplete = float(self.percentdone / 100.0) secondselapsed = int(time.time() - self.starttime + self.extra_print_time) # Prevent division by zero secondsestimate = secondselapsed / max(fractioncomplete, 0.000001) secondsremain = secondsestimate - secondselapsed progress = fractioncomplete elif self.compute_eta is not None: secondselapsed = int(time.time() - self.starttime + self.extra_print_time) secondsremain, secondsestimate = self.compute_eta(self.p.queueindex, secondselapsed) progress = self.p.queueindex else: secondsremain, secondsestimate, progress = 1, 1, 0 return secondsremain, secondsestimate, progress def do_eta(self, l): if not self.p.printing: self.logError(_("Printer is not currently printing. No ETA available.")) else: secondsremain, secondsestimate, progress = self.get_eta() eta = _("Est: %s of %s remaining") % (format_duration(secondsremain), format_duration(secondsestimate)) self.log(eta.strip()) def help_eta(self): self.log(_("Displays estimated remaining print time.")) # -------------------------------------------------------------- # Temperature handling # -------------------------------------------------------------- def set_temp_preset(self, key, value): if not key.startswith("bed"): self.temps["pla"] = str(self.settings.temperature_pla) self.temps["abs"] = str(self.settings.temperature_abs) self.log("Hotend temperature presets updated, pla:%s, abs:%s" % (self.temps["pla"], self.temps["abs"])) else: self.bedtemps["pla"] = str(self.settings.bedtemp_pla) self.bedtemps["abs"] = str(self.settings.bedtemp_abs) self.log("Bed temperature presets updated, pla:%s, abs:%s" % (self.bedtemps["pla"], self.bedtemps["abs"])) def tempcb(self, l): if "T:" in l: self.log(l.strip().replace("T", "Hotend").replace("B", "Bed").replace("ok ", "")) def do_gettemp(self, l): if "dynamic" in l: self.dynamic_temp = True if self.p.online: self.p.send_now("M105") time.sleep(0.75) if not self.status.bed_enabled: self.log(_("Hotend: %s/%s") % (self.status.extruder_temp, self.status.extruder_temp_target)) else: self.log(_("Hotend: %s/%s") % (self.status.extruder_temp, self.status.extruder_temp_target)) self.log(_("Bed: %s/%s") % (self.status.bed_temp, self.status.bed_temp_target)) def help_gettemp(self): self.log(_("Read the extruder and bed temperature.")) def do_settemp(self, l): l = l.lower().replace(", ", ".") for i in self.temps.keys(): l = l.replace(i, self.temps[i]) try: f = float(l) except: self.logError(_("You must enter a temperature.")) return if f >= 0: if f > 250: self.log(_("%s is a high temperature to set your extruder to. Are you sure you want to do that?") % f) if not self.confirm(): return if self.p.online: self.p.send_now("M104 S" + l) self.log(_("Setting hotend temperature to %s degrees Celsius.") % f) else: self.logError(_("Printer is not online.")) else: self.logError(_("You cannot set negative temperatures. To turn the hotend off entirely, set its temperature to 0.")) def help_settemp(self): self.log(_("Sets the hotend temperature to the value entered.")) self.log(_("Enter either a temperature in celsius or one of the following keywords")) self.log(", ".join([i + "(" + self.temps[i] + ")" for i in self.temps.keys()])) def complete_settemp(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in self.temps.keys() if i.startswith(text)] def do_bedtemp(self, l): f = None try: l = l.lower().replace(", ", ".") for i in self.bedtemps.keys(): l = l.replace(i, self.bedtemps[i]) f = float(l) except: self.logError(_("You must enter a temperature.")) if f is not None and f >= 0: if self.p.online: self.p.send_now("M140 S" + l) self.log(_("Setting bed temperature to %s degrees Celsius.") % f) else: self.logError(_("Printer is not online.")) else: self.logError(_("You cannot set negative temperatures. To turn the bed off entirely, set its temperature to 0.")) def help_bedtemp(self): self.log(_("Sets the bed temperature to the value entered.")) self.log(_("Enter either a temperature in celsius or one of the following keywords")) self.log(", ".join([i + "(" + self.bedtemps[i] + ")" for i in self.bedtemps.keys()])) def complete_bedtemp(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in self.bedtemps.keys() if i.startswith(text)] def do_monitor(self, l): interval = 5 if not self.p.online: self.logError(_("Printer is not online. Please connect to it first.")) return if not (self.p.printing or self.sdprinting): self.logError(_("Printer is not printing. Please print something before monitoring.")) return self.log(_("Monitoring printer, use ^C to interrupt.")) if len(l): try: interval = float(l) except: self.logError(_("Invalid period given.")) self.log(_("Updating values every %f seconds.") % (interval,)) self.monitoring = 1 prev_msg_len = 0 try: while True: self.p.send_now("M105") if self.sdprinting: self.p.send_now("M27") time.sleep(interval) if self.p.printing: preface = _("Print progress: ") progress = 100 * float(self.p.queueindex) / len(self.p.mainqueue) elif self.sdprinting: preface = _("SD print progress: ") progress = self.percentdone prev_msg = preface + "%.1f%%" % progress if self.silent is False: sys.stdout.write("\r" + prev_msg.ljust(prev_msg_len)) sys.stdout.flush() prev_msg_len = len(prev_msg) except KeyboardInterrupt: if self.silent is False: self.log(_("Done monitoring.")) self.monitoring = 0 def help_monitor(self): self.log(_("Monitor a machine's temperatures and an SD print's status.")) self.log(_("monitor - Reports temperature and SD print status (if SD printing) every 5 seconds")) self.log(_("monitor 2 - Reports temperature and SD print status (if SD printing) every 2 seconds")) # -------------------------------------------------------------- # Manual printer controls # -------------------------------------------------------------- def do_tool(self, l): tool = None try: tool = int(l.lower().strip()) except: self.logError(_("You must specify the tool index as an integer.")) if tool is not None and tool >= 0: if self.p.online: self.p.send_now("T%d" % tool) self.log(_("Using tool %d.") % tool) else: self.logError(_("Printer is not online.")) else: self.logError(_("You cannot set negative tool numbers.")) def help_tool(self): self.log(_("Switches to the specified tool (e.g. doing tool 1 will emit a T1 G-Code).")) def do_move(self, l): if len(l.split()) < 2: self.logError(_("No move specified.")) return if self.p.printing: self.logError(_("Printer is currently printing. Please pause the print before you issue manual commands.")) return if not self.p.online: self.logError(_("Printer is not online. Unable to move.")) return l = l.split() if l[0].lower() == "x": feed = self.settings.xy_feedrate axis = "X" elif l[0].lower() == "y": feed = self.settings.xy_feedrate axis = "Y" elif l[0].lower() == "z": feed = self.settings.z_feedrate axis = "Z" elif l[0].lower() == "e": feed = self.settings.e_feedrate axis = "E" else: self.logError(_("Unknown axis.")) return try: float(l[1]) # check if distance can be a float except: self.logError(_("Invalid distance")) return try: feed = int(l[2]) except: pass self.p.send_now("G91") self.p.send_now("G0 " + axis + str(l[1]) + " F" + str(feed)) self.p.send_now("G90") def help_move(self): self.log(_("Move an axis. Specify the name of the axis and the amount. ")) self.log(_("move X 10 will move the X axis forward by 10mm at %s mm/min (default XY speed)") % self.settings.xy_feedrate) self.log(_("move Y 10 5000 will move the Y axis forward by 10mm at 5000mm/min")) self.log(_("move Z -1 will move the Z axis down by 1mm at %s mm/min (default Z speed)") % self.settings.z_feedrate) self.log(_("Common amounts are in the tabcomplete list.")) def complete_move(self, text, line, begidx, endidx): if (len(line.split()) == 2 and line[-1] != " ") or (len(line.split()) == 1 and line[-1] == " "): return [i for i in ["X ", "Y ", "Z ", "E "] if i.lower().startswith(text)] elif len(line.split()) == 3 or (len(line.split()) == 2 and line[-1] == " "): base = line.split()[-1] rlen = 0 if base.startswith("-"): rlen = 1 if line[-1] == " ": base = "" return [i[rlen:] for i in ["-100", "-10", "-1", "-0.1", "100", "10", "1", "0.1", "-50", "-5", "-0.5", "50", "5", "0.5", "-200", "-20", "-2", "-0.2", "200", "20", "2", "0.2"] if i.startswith(base)] else: return [] def do_extrude(self, l, override = None, overridefeed = 300): length = self.settings.default_extrusion # default extrusion length feed = self.settings.e_feedrate # default speed if not self.p.online: self.logError("Printer is not online. Unable to extrude.") return if self.p.printing: self.logError(_("Printer is currently printing. Please pause the print before you issue manual commands.")) return ls = l.split() if len(ls): try: length = float(ls[0]) except: self.logError(_("Invalid length given.")) if len(ls) > 1: try: feed = int(ls[1]) except: self.logError(_("Invalid speed given.")) if override is not None: length = override feed = overridefeed self.do_extrude_final(length, feed) def do_extrude_final(self, length, feed): if length > 0: self.log(_("Extruding %fmm of filament.") % (length,)) elif length < 0: self.log(_("Reversing %fmm of filament.") % (-length,)) else: self.log(_("Length is 0, not doing anything.")) self.p.send_now("G91") self.p.send_now("G1 E" + str(length) + " F" + str(feed)) self.p.send_now("G90") def help_extrude(self): self.log(_("Extrudes a length of filament, 5mm by default, or the number of mm given as a parameter")) self.log(_("extrude - extrudes 5mm of filament at 300mm/min (5mm/s)")) self.log(_("extrude 20 - extrudes 20mm of filament at 300mm/min (5mm/s)")) self.log(_("extrude -5 - REVERSES 5mm of filament at 300mm/min (5mm/s)")) self.log(_("extrude 10 210 - extrudes 10mm of filament at 210mm/min (3.5mm/s)")) def do_reverse(self, l): length = self.settings.default_extrusion # default extrusion length feed = self.settings.e_feedrate # default speed if not self.p.online: self.logError(_("Printer is not online. Unable to reverse.")) return if self.p.printing: self.logError(_("Printer is currently printing. Please pause the print before you issue manual commands.")) return ls = l.split() if len(ls): try: length = float(ls[0]) except: self.logError(_("Invalid length given.")) if len(ls) > 1: try: feed = int(ls[1]) except: self.logError(_("Invalid speed given.")) self.do_extrude("", -length, feed) def help_reverse(self): self.log(_("Reverses the extruder, 5mm by default, or the number of mm given as a parameter")) self.log(_("reverse - reverses 5mm of filament at 300mm/min (5mm/s)")) self.log(_("reverse 20 - reverses 20mm of filament at 300mm/min (5mm/s)")) self.log(_("reverse 10 210 - extrudes 10mm of filament at 210mm/min (3.5mm/s)")) self.log(_("reverse -5 - EXTRUDES 5mm of filament at 300mm/min (5mm/s)")) def do_home(self, l): if not self.p.online: self.logError(_("Printer is not online. Unable to move.")) return if self.p.printing: self.logError(_("Printer is currently printing. Please pause the print before you issue manual commands.")) return if "x" in l.lower(): self.p.send_now("G28 X0") if "y" in l.lower(): self.p.send_now("G28 Y0") if "z" in l.lower(): self.p.send_now("G28 Z0") if "e" in l.lower(): self.p.send_now("G92 E0") if not len(l): self.p.send_now("G28") self.p.send_now("G92 E0") def help_home(self): self.log(_("Homes the printer")) self.log(_("home - homes all axes and zeroes the extruder(Using G28 and G92)")) self.log(_("home xy - homes x and y axes (Using G28)")) self.log(_("home z - homes z axis only (Using G28)")) self.log(_("home e - set extruder position to zero (Using G92)")) self.log(_("home xyze - homes all axes and zeroes the extruder (Using G28 and G92)")) def do_off(self, l): self.off() def off(self, ignore = None): if self.p.online: if self.p.printing: self.pause(None) self.log(_("; Motors off")) self.onecmd("M84") self.log(_("; Extruder off")) self.onecmd("M104 S0") self.log(_("; Heatbed off")) self.onecmd("M140 S0") self.log(_("; Fan off")) self.onecmd("M107") self.log(_("; Power supply off")) self.onecmd("M81") else: self.logError(_("Printer is not online. Unable to turn it off.")) def help_off(self): self.log(_("Turns off everything on the printer")) # -------------------------------------------------------------- # Host commands handling # -------------------------------------------------------------- def process_host_command(self, command): """Override host command handling""" command = command.lstrip() if command.startswith(";@"): command = command[2:] self.log(_("G-Code calling host command \"%s\"") % command) self.onecmd(command) def do_run_script(self, l): p = run_command(l, {"$s": str(self.filename)}, stdout = subprocess.PIPE) for line in p.stdout.readlines(): self.log("<< " + line.strip()) def help_run_script(self): self.log(_("Runs a custom script. Current gcode filename can be given using $s token.")) def do_run_gcode_script(self, l): p = run_command(l, {"$s": str(self.filename)}, stdout = subprocess.PIPE) for line in p.stdout.readlines(): self.onecmd(line.strip()) def help_run_gcode_script(self): self.log(_("Runs a custom script which output gcode which will in turn be executed. Current gcode filename can be given using $s token."))