Fri, 22 Sep 2017 17:38:36 +0200
ModuleWatcher code embed, doesnt work on windows os
#!/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/>. __version__ = "2015.03.10" from serialWrapper import Serial, SerialException, PARITY_ODD, PARITY_NONE from select import error as SelectError import threading from Queue import Queue, Empty as QueueEmpty import time import platform import os import sys stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr reload(sys).setdefaultencoding('utf8') sys.stdin, sys.stdout, sys.stderr = stdin, stdout, stderr import logging import traceback import errno import socket import re from functools import wraps from collections import deque from printrun import gcoder from .utils import install_locale, decode_utf8 install_locale('pronterface') def locked(f): @wraps(f) def inner(*args, **kw): with inner.lock: return f(*args, **kw) inner.lock = threading.Lock() return inner def control_ttyhup(port, disable_hup): """Controls the HUPCL""" if platform.system() == "Linux": if disable_hup: os.system("stty -F %s -hup" % port) else: os.system("stty -F %s hup" % port) def enable_hup(port): control_ttyhup(port, False) def disable_hup(port): control_ttyhup(port, True) class printcore(): def __init__(self, port = None, baud = None, dtr=None): """Initializes a printcore instance. Pass the port and baud rate to connect immediately""" self.baud = None self.dtr = None self.port = None self.analyzer = gcoder.GCode() # Serial instance connected to the printer, should be None when # disconnected self.printer = None # clear to send, enabled after responses # FIXME: should probably be changed to a sliding window approach self.clear = 0 # The printer has responded to the initial command and is active self.online = False # is a print currently running, true if printing, false if paused self.printing = False self.mainqueue = None self.priqueue = Queue(0) self.queueindex = 0 self.lineno = 0 self.resendfrom = -1 self.paused = False self.sentlines = {} self.log = deque(maxlen = 10000) self.sent = [] self.writefailures = 0 self.tempcb = None # impl (wholeline) self.recvcb = None # impl (wholeline) self.sendcb = None # impl (wholeline) self.preprintsendcb = None # impl (wholeline) self.printsendcb = None # impl (wholeline) self.layerchangecb = None # impl (wholeline) self.errorcb = None # impl (wholeline) self.startcb = None # impl () self.endcb = None # impl () self.onlinecb = None # impl () self.loud = False # emit sent and received lines to terminal self.tcp_streaming_mode = False self.greetings = ['start', 'Grbl '] self.wait = 0 # default wait period for send(), send_now() self.read_thread = None self.stop_read_thread = False self.send_thread = None self.stop_send_thread = False self.print_thread = None if port is not None and baud is not None: self.connect(port, baud) self.xy_feedrate = None self.z_feedrate = None def logError(self, error): if self.errorcb: try: self.errorcb(error) except: logging.error(traceback.format_exc()) else: logging.error(error) @locked def disconnect(self): """Disconnects from printer and pauses the print """ if self.printer: if self.read_thread: self.stop_read_thread = True if threading.current_thread() != self.read_thread: self.read_thread.join() self.read_thread = None if self.print_thread: self.printing = False self.print_thread.join() self._stop_sender() try: self.printer.close() except socket.error: pass except OSError: pass self.printer = None self.online = False self.printing = False @locked def connect(self, port = None, baud = None, dtr=None): """Set port and baudrate if given, then connect to printer """ if self.printer: self.disconnect() if port is not None: self.port = port if baud is not None: self.baud = baud if dtr is not None: self.dtr = dtr if self.port is not None and self.baud is not None: # Connect to socket if "port" is an IP, device if not host_regexp = re.compile("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$|^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$") is_serial = True if ":" in port: bits = port.split(":") if len(bits) == 2: hostname = bits[0] try: port = int(bits[1]) if host_regexp.match(hostname) and 1 <= port <= 65535: is_serial = False except: pass self.writefailures = 0 if not is_serial: self.printer_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.printer_tcp.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self.timeout = 0.25 self.printer_tcp.settimeout(1.0) try: self.printer_tcp.connect((hostname, port)) self.printer_tcp.settimeout(self.timeout) self.printer = self.printer_tcp.makefile() except socket.error as e: if(e.strerror is None): e.strerror="" self.logError(_("Could not connect to %s:%s:") % (hostname, port) + "\n" + _("Socket error %s:") % e.errno + "\n" + e.strerror) self.printer = None self.printer_tcp = None return else: disable_hup(self.port) self.printer_tcp = None try: self.printer = Serial(port = self.port, baudrate = self.baud, timeout = 0.25, parity = PARITY_ODD) self.printer.close() self.printer.parity = PARITY_NONE try: #this appears not to work on many platforms, so we're going to call it but not care if it fails self.printer.setDTR(dtr); except: #self.logError(_("Could not set DTR on this platform")) #not sure whether to output an error message pass self.printer.open() except SerialException as e: self.logError(_("Could not connect to %s at baudrate %s:") % (self.port, self.baud) + "\n" + _("Serial error: %s") % e) self.printer = None return except IOError as e: self.logError(_("Could not connect to %s at baudrate %s:") % (self.port, self.baud) + "\n" + _("IO error: %s") % e) self.printer = None return self.stop_read_thread = False self.read_thread = threading.Thread(target = self._listen) self.read_thread.start() self._start_sender() def reset(self): """Reset the printer """ if self.printer and not self.printer_tcp: self.printer.setDTR(1) time.sleep(0.2) self.printer.setDTR(0) def _readline(self): try: try: line = self.printer.readline() if self.printer_tcp and not line: raise OSError(-1, "Read EOF from socket") except socket.timeout: return "" if len(line) > 1: self.log.append(line) if self.recvcb: try: self.recvcb(line) except: self.logError(traceback.format_exc()) if self.loud: logging.info("RECV: %s" % line.rstrip()) return line except SelectError as e: if 'Bad file descriptor' in e.args[1]: self.logError(_(u"Can't read from printer (disconnected?) (SelectError {0}): {1}").format(e.errno, decode_utf8(e.strerror))) return None else: self.logError(_(u"SelectError ({0}): {1}").format(e.errno, decode_utf8(e.strerror))) raise except SerialException as e: self.logError(_(u"Can't read from printer (disconnected?) (SerialException): {0}").format(decode_utf8(str(e)))) return None except socket.error as e: self.logError(_(u"Can't read from printer (disconnected?) (Socket error {0}): {1}").format(e.errno, decode_utf8(e.strerror))) return None except OSError as e: if e.errno == errno.EAGAIN: # Not a real error, no data was available return "" self.logError(_(u"Can't read from printer (disconnected?) (OS Error {0}): {1}").format(e.errno, e.strerror)) return None def _listen_can_continue(self): if self.printer_tcp: return not self.stop_read_thread and self.printer return (not self.stop_read_thread and self.printer and self.printer.isOpen()) def _listen_until_online(self): while not self.online and self._listen_can_continue(): self._send("M105") if self.writefailures >= 4: logging.error(_("Aborting connection attempt after 4 failed writes.")) return empty_lines = 0 while self._listen_can_continue(): line = self._readline() if line is None: break # connection problem # workaround cases where M105 was sent before printer Serial # was online an empty line means read timeout was reached, # meaning no data was received thus we count those empty lines, # and once we have seen 15 in a row, we just break and send a # new M105 # 15 was chosen based on the fact that it gives enough time for # Gen7 bootloader to time out, and that the non received M105 # issues should be quite rare so we can wait for a long time # before resending if not line: empty_lines += 1 if empty_lines == 15: break else: empty_lines = 0 if line.startswith(tuple(self.greetings)) \ or line.startswith('ok') or "T:" in line: self.online = True if self.onlinecb: try: self.onlinecb() except: self.logError(traceback.format_exc()) return def _listen(self): """This function acts on messages from the firmware """ self.clear = True if not self.printing: self._listen_until_online() while self._listen_can_continue(): line = self._readline() if line is None: break if line.startswith('DEBUG_'): continue if line.startswith(tuple(self.greetings)) or line.startswith('ok'): self.clear = True if line.startswith('ok') and "T:" in line and self.tempcb: # callback for temp, status, whatever try: self.tempcb(line) except: self.logError(traceback.format_exc()) elif line.startswith('Error'): self.logError(line) # Teststrings for resend parsing # Firmware exp. result # line="rs N2 Expected checksum 67" # Teacup 2 if line.lower().startswith("resend") or line.startswith("rs"): for haystack in ["N:", "N", ":"]: line = line.replace(haystack, " ") linewords = line.split() while len(linewords) != 0: try: toresend = int(linewords.pop(0)) self.resendfrom = toresend break except: pass self.clear = True self.clear = True def _start_sender(self): self.stop_send_thread = False self.send_thread = threading.Thread(target = self._sender) self.send_thread.start() def _stop_sender(self): if self.send_thread: self.stop_send_thread = True self.send_thread.join() self.send_thread = None def _sender(self): while not self.stop_send_thread: try: command = self.priqueue.get(True, 0.1) except QueueEmpty: continue while self.printer and self.printing and not self.clear: time.sleep(0.001) self._send(command) while self.printer and self.printing and not self.clear: time.sleep(0.001) def _checksum(self, command): return reduce(lambda x, y: x ^ y, map(ord, command)) def startprint(self, gcode, startindex = 0): """Start a print, gcode is an array of gcode commands. returns True on success, False if already printing. The print queue will be replaced with the contents of the data array, the next line will be set to 0 and the firmware notified. Printing will then start in a parallel thread. """ if self.printing or not self.online or not self.printer: return False self.queueindex = startindex self.mainqueue = gcode self.printing = True self.lineno = 0 self.resendfrom = -1 self._send("M110", -1, True) if not gcode or not gcode.lines: return True self.clear = False resuming = (startindex != 0) self.print_thread = threading.Thread(target = self._print, kwargs = {"resuming": resuming}) self.print_thread.start() return True def cancelprint(self): self.pause() self.paused = False self.mainqueue = None self.clear = True # run a simple script if it exists, no multithreading def runSmallScript(self, filename): if filename is None: return f = None try: with open(filename) as f: for i in f: l = i.replace("\n", "") l = l[:l.find(";")] # remove comments self.send_now(l) except: pass def pause(self): """Pauses the print, saving the current position. """ if not self.printing: return False self.paused = True self.printing = False # try joining the print thread: enclose it in try/except because we # might be calling it from the thread itself try: self.print_thread.join() except RuntimeError, e: if e.message == "cannot join current thread": pass else: self.logError(traceback.format_exc()) except: self.logError(traceback.format_exc()) self.print_thread = None # saves the status self.pauseX = self.analyzer.abs_x self.pauseY = self.analyzer.abs_y self.pauseZ = self.analyzer.abs_z self.pauseE = self.analyzer.abs_e self.pauseF = self.analyzer.current_f self.pauseRelative = self.analyzer.relative def resume(self): """Resumes a paused print. """ if not self.paused: return False if self.paused: # restores the status self.send_now("G90") # go to absolute coordinates xyFeedString = "" zFeedString = "" if self.xy_feedrate is not None: xyFeedString = " F" + str(self.xy_feedrate) if self.z_feedrate is not None: zFeedString = " F" + str(self.z_feedrate) self.send_now("G1 X%s Y%s%s" % (self.pauseX, self.pauseY, xyFeedString)) self.send_now("G1 Z" + str(self.pauseZ) + zFeedString) self.send_now("G92 E" + str(self.pauseE)) # go back to relative if needed if self.pauseRelative: self.send_now("G91") # reset old feed rate self.send_now("G1 F" + str(self.pauseF)) self.paused = False self.printing = True self.print_thread = threading.Thread(target = self._print, kwargs = {"resuming": True}) self.print_thread.start() def send(self, command, wait = 0): """Adds a command to the checksummed main command queue if printing, or sends the command immediately if not printing""" if self.online: if self.printing: self.mainqueue.append(command) else: self.priqueue.put_nowait(command) else: self.logError(_("Not connected to printer.")) def send_now(self, command, wait = 0): """Sends a command to the printer ahead of the command queue, without a checksum""" if self.online: self.priqueue.put_nowait(command) else: self.logError(_("Not connected to printer.")) def _print(self, resuming = False): self._stop_sender() try: if self.startcb: # callback for printing started try: self.startcb(resuming) except: self.logError(_("Print start callback failed with:") + "\n" + traceback.format_exc()) while self.printing and self.printer and self.online: self._sendnext() self.sentlines = {} self.log.clear() self.sent = [] if self.endcb: # callback for printing done try: self.endcb() except: self.logError(_("Print end callback failed with:") + "\n" + traceback.format_exc()) except: self.logError(_("Print thread died due to the following error:") + "\n" + traceback.format_exc()) finally: self.print_thread = None self._start_sender() def process_host_command(self, command): """only ;@pause command is implemented as a host command in printcore, but hosts are free to reimplement this method""" command = command.lstrip() if command.startswith(";@pause"): self.pause() def _sendnext(self): if not self.printer: return while self.printer and self.printing and not self.clear: time.sleep(0.001) # Only wait for oks when using serial connections or when not using tcp # in streaming mode if not self.printer_tcp or not self.tcp_streaming_mode: self.clear = False if not (self.printing and self.printer and self.online): self.clear = True return if self.resendfrom < self.lineno and self.resendfrom > -1: self._send(self.sentlines[self.resendfrom], self.resendfrom, False) self.resendfrom += 1 return self.resendfrom = -1 if not self.priqueue.empty(): self._send(self.priqueue.get_nowait()) self.priqueue.task_done() return if self.printing and self.queueindex < len(self.mainqueue): (layer, line) = self.mainqueue.idxs(self.queueindex) gline = self.mainqueue.all_layers[layer][line] if self.layerchangecb and self.queueindex > 0: (prev_layer, prev_line) = self.mainqueue.idxs(self.queueindex - 1) if prev_layer != layer: try: self.layerchangecb(layer) except: self.logError(traceback.format_exc()) if self.preprintsendcb: if self.queueindex + 1 < len(self.mainqueue): (next_layer, next_line) = self.mainqueue.idxs(self.queueindex + 1) next_gline = self.mainqueue.all_layers[next_layer][next_line] else: next_gline = None gline = self.preprintsendcb(gline, next_gline) if gline is None: self.queueindex += 1 self.clear = True return tline = gline.raw if tline.lstrip().startswith(";@"): # check for host command self.process_host_command(tline) self.queueindex += 1 self.clear = True return # Strip comments tline = gcoder.gcode_strip_comment_exp.sub("", tline).strip() if tline: self._send(tline, self.lineno, True) self.lineno += 1 if self.printsendcb: try: self.printsendcb(gline) except: self.logError(traceback.format_exc()) else: self.clear = True self.queueindex += 1 else: self.printing = False self.clear = True if not self.paused: self.queueindex = 0 self.lineno = 0 self._send("M110", -1, True) def _send(self, command, lineno = 0, calcchecksum = False): # Only add checksums if over serial (tcp does the flow control itself) if calcchecksum and not self.printer_tcp: prefix = "N" + str(lineno) + " " + command command = prefix + "*" + str(self._checksum(prefix)) if "M110" not in command: self.sentlines[lineno] = command if self.printer: self.sent.append(command) # run the command through the analyzer gline = None try: gline = self.analyzer.append(command, store = False) except: logging.warning(_("Could not analyze command %s:") % command + "\n" + traceback.format_exc()) if self.loud: logging.info("SENT: %s" % command) if self.sendcb: try: self.sendcb(command, gline) except: self.logError(traceback.format_exc()) try: self.printer.write(str(command + "\n")) if self.printer_tcp: try: self.printer.flush() except socket.timeout: pass self.writefailures = 0 except socket.error as e: if e.errno is None: self.logError(_(u"Can't write to printer (disconnected ?):") + "\n" + traceback.format_exc()) else: self.logError(_(u"Can't write to printer (disconnected?) (Socket error {0}): {1}").format(e.errno, decode_utf8(e.strerror))) self.writefailures += 1 except SerialException as e: self.logError(_(u"Can't write to printer (disconnected?) (SerialException): {0}").format(decode_utf8(str(e)))) self.writefailures += 1 except RuntimeError as e: self.logError(_(u"Socket connection broken, disconnected. ({0}): {1}").format(e.errno, decode_utf8(e.strerror))) self.writefailures += 1