def write(self, data):
        try:
            data = data.strip()
            if self.baudrate != self._baudrate:
                try:
                    self._baudrate = self.baudrate
                    self._logger.info("new baudrate = %d" % self.baudrate)
                    gpx.set_baudrate(self.baudrate)
                    self.baudrateError = False
                except ValueError:
                    self.baudrateError = True
                    self.outgoing.put("")
                    return

                    # look for a line number
                    # line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
                    # no line number means OctoPrint is generating the gcode (reprap flavor)
            match = self._regex_linenumber.match(data)
            if match is not None:
                lineno = int(match.group(1))
                if lineno == 1 and not "M112" in data:
                    self._bot_cancelled = False
                    currentJob = self._printer.get_current_job()
                    if (
                        currentJob is not None
                        and "file" in currentJob.keys()
                        and "name" in currentJob["file"]
                        and currentJob["file"]["name"] is not None
                    ):
                        build_name = os.path.splitext(os.path.basename(currentJob["file"]["name"]))[0]
                        gpx.write("(@build %s)" % build_name)
                        gpx.write("M136 (%s)" % build_name)
                    else:
                        gpx.write("M136")

                        # try to talk to the bot
            try:
                if match is None:
                    reprapSave = gpx.reprap_flavor(True)

                    # loop sending until the queue isn't full
                retries = 0
                while True:
                    try:
                        self._append(gpx.write("%s" % data))
                        break
                    except gpx.BufferOverflow:
                        time.sleep(0.1)
                    except gpx.Timeout:
                        time.sleep(1)
                        retries += 1
                        if retries >= 5:
                            raise

            finally:
                if match is None:
                    gpx.reprap_flavor(reprapSave)
        except gpx.CancelBuild:
            self._bot_reports_build_cancelled()
    def write(self, data):
        try:
            data = data.strip()
            if (self.baudrate != self._baudrate):
                try:
                    self._baudrate = self.baudrate
                    self._logger.info("new baudrate = %d" % self.baudrate)
                    gpx.set_baudrate(self.baudrate)
                    self.baudrateError = False
                except ValueError:
                    self.baudrateError = True
                    self.outgoing.put('')
                    return

            # look for a line number
            # line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
            # no line number means OctoPrint is generating the gcode (reprap flavor)
            match = self._regex_linenumber.match(data)
            if match is not None:
                lineno = int(match.group(1))
                if lineno == 1 and not "M112" in data:
                    self._bot_cancelled = False
                    currentJob = self._printer.get_current_job()
                    if currentJob is not None and "file" in currentJob.keys(
                    ) and "name" in currentJob["file"] and currentJob["file"][
                            "name"] is not None:
                        build_name = os.path.splitext(
                            os.path.basename(currentJob["file"]["name"]))[0]
                        gpx.write("(@build %s)" % build_name)
                        gpx.write("M136 (%s)" % build_name)
                    else:
                        gpx.write("M136")

            # try to talk to the bot
            try:
                if match is None:
                    reprapSave = gpx.reprap_flavor(True)

                # loop sending until the queue isn't full
                retries = 0
                while True:
                    try:
                        self._append(gpx.write("%s" % data))
                        break
                    except gpx.BufferOverflow:
                        time.sleep(0.1)
                    except gpx.Timeout:
                        time.sleep(1)
                        retries += 1
                        if (retries >= 5):
                            raise

            finally:
                if match is None:
                    gpx.reprap_flavor(reprapSave)
        except gpx.CancelBuild:
            self._bot_reports_build_cancelled()
Exemple #3
0
    def write(self, data):
        try:
            rval = len(data)
            data = data.strip()
            if (self.baudrate != self._baudrate):
                try:
                    self._baudrate = self.baudrate
                    self._logger.info("new baudrate = %d" % self.baudrate)
                    gpx.set_baudrate(self.baudrate)
                    self.baudrateError = False
                except ValueError:
                    self.baudrateError = True
                    self.outgoing.put('')
                    return 0

            # look for a line number
            # line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
            # no line number means OctoPrint is generating the gcode (reprap flavor)
            match = self._regex_linenumber.match(data)

            # try to talk to the bot
            try:
                if match is None:
                    reprapSave = gpx.reprap_flavor(True)

                # loop sending until the queue isn't full
                timeout_retries = 0
                bo_retries = 0
                while True:
                    try:
                        self._append(gpx.write("%s" % data))
                        break
                    except gpx.BufferOverflow:
                        bo_retries += 1
                        try:
                            if gpx.build_paused():
                                if bo_retries == 1:
                                    self._append(
                                        "// echo: print paused at bot")
                                time.sleep(1)  # 1 sec
                        except IOError:
                            pass
                        time.sleep(0.1)  # 100 ms
                    except gpx.Timeout:
                        time.sleep(1)
                        timeout_retries += 1
                        if (timeout_retries >= 5):
                            raise

            finally:
                if match is None:
                    gpx.reprap_flavor(reprapSave)
        except gpx.CancelBuild:
            self._bot_reports_build_cancelled()
        return rval
Exemple #4
0
	def write(self, data):
		data = data.strip()
		# strip checksum
		if "*" in data:
			data = data[:data.rfind("*")]
		if (self.baudrate != self._baudrate):
			try:
				self._baudrate = self.baudrate
				self._logger.info("new baudrate = %d" % self.baudrate)
				gpx.set_baudrate(self.baudrate)
				self.baudrateError = False
			except ValueError:
				self.baudrateError = True
				self.outgoing.put('')
				pass
				return

		# look for a line number
		# line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
		# no line number means OctoPrint is generating the gcode (reprap flavor)
		match = self._regex_linenumber.match(data)
		if match is not None:
			lineno = int(match.group(1))
			if lineno == 1:
				currentJob = self._printer.get_current_job()
				if currentJob is not None and "file" in currentJob.keys() and "name" in currentJob["file"]:
					gpx.write("M136 %s" % os.path.basename(currentJob["file"]["name"]))
				else:
					gpx.write("M136")

		# try to talk to the bot
		while True:
			try:
				if match is None:
					reprapSave = gpx.reprap_flavor(True)
				self._append(gpx.write("%s" % data))
				break
			except gpx.BufferOverflow:
				self._append("buffer overflow")
				time.sleep(1)
				pass
			finally:
				if match is None:
					gpx.reprap_flavor(reprapSave)
    def write(self, data):
        try:
            rval = len(data)
            data = data.strip()
            if (self.baudrate != self._baudrate):
                try:
                    self._baudrate = self.baudrate
                    self._logger.info("new baudrate = %d" % self.baudrate)
                    gpx.set_baudrate(self.baudrate)
                    self.baudrateError = False
                except ValueError:
                    self.baudrateError = True
                    self.outgoing.put('')
                    return 0

            # look for a line number
            # line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
            # no line number means OctoPrint is generating the gcode (reprap flavor)
            match = self._regex_linenumber.match(data)
            if match is not None:
                lineno = int(match.group(1))
                if lineno == 1 and not "M112" in data:
                    self._bot_cancelled = False
                    currentJob = self._printer.get_current_job()
                    try:
                        build_name = currentJob["file"]["name"]
                        build_name = os.path.splitext(
                            os.path.basename(build_name))[0]
                    except KeyError:
                        build_name = "OctoPrint"
                    gpx.write('(@build "%s")' % build_name)
                    gpx.write("M136 (%s)" % build_name)

            # try to talk to the bot
            try:
                if match is None:
                    reprapSave = gpx.reprap_flavor(True)

                # loop sending until the queue isn't full
                timeout_retries = 0
                bo_retries = 0
                while True:
                    try:
                        self._append(gpx.write("%s" % data))
                        break
                    except gpx.BufferOverflow:
                        bo_retries += 1
                        try:
                            if gpx.build_paused():
                                if bo_retries == 1:
                                    self._append(
                                        "// echo: print paused at bot")
                                time.sleep(1)  # 1 sec
                        except IOError:
                            pass
                        time.sleep(0.1)  # 100 ms
                    except gpx.Timeout:
                        time.sleep(1)
                        timeout_retries += 1
                        if (timeout_retries >= 5):
                            raise

            finally:
                if match is None:
                    gpx.reprap_flavor(reprapSave)
        except gpx.CancelBuild:
            self._bot_reports_build_cancelled()
        return rval
Exemple #6
0
	def write(self, data):
		try:
			rval = len(data)
			data = data.strip()
			if (self.baudrate != self._baudrate):
				try:
					self._baudrate = self.baudrate
					self._logger.info("new baudrate = %d" % self.baudrate)
					gpx.set_baudrate(self.baudrate)
					self.baudrateError = False
				except ValueError:
					self.baudrateError = True
					self.outgoing.put('')
					return 0

			# look for a line number
			# line number means OctoPrint is streaming gcode at us (gpx.ini flavor)
			# no line number means OctoPrint is generating the gcode (reprap flavor)
			match = self._regex_linenumber.match(data)
			if match is not None:
				lineno = int(match.group(1))
				if lineno == 1 and not "M112" in data:
					self._bot_cancelled = False
					currentJob = self._printer.get_current_job()
					try:
						build_name = currentJob["file"]["name"]
						build_name = os.path.splitext(os.path.basename(build_name))[0]
					except KeyError:
						build_name = "OctoPrint"
					gpx.write('(@build "%s")' % build_name)
					gpx.write("M136 (%s)" % build_name)

			# try to talk to the bot
			try:
				if match is None:
					reprapSave = gpx.reprap_flavor(True)

				# loop sending until the queue isn't full
				timeout_retries = 0
				bo_retries = 0
				while True:
					try:
						self._append(gpx.write("%s" % data))
						break
					except gpx.BufferOverflow:
						bo_retries += 1
						try:
							if gpx.build_paused():
								if bo_retries == 1:
									self._append("// echo: print paused at bot")
								time.sleep(1) # 1 sec
						except IOError:
							pass
						time.sleep(0.1) # 100 ms
					except gpx.Timeout:
						time.sleep(1)
						timeout_retries += 1
						if (timeout_retries >= 5):
							raise

			finally:
				if match is None:
					gpx.reprap_flavor(reprapSave)
		except gpx.CancelBuild:
			self._bot_reports_build_cancelled()
		return rval