diff -r 51bf56ba3c10 -r 0bbb006204fc printrun-src/printrun/printcore.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/printrun-src/printrun/printcore.py Fri Jun 03 09:16:07 2016 +0200 @@ -0,0 +1,629 @@ +#!/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 . + +__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