def __init__(self, parent): super(decideToUpdateSigma, self).__init__(parent, _('Firmware Updater')) self._port = 'AUTO' self._baudrate = 250000 if self._port == 'AUTO': print 'entramos en port auto despues de baudrate' programmer = stk500v2.Stk500v2() print 'antes', self._port if not programmer.isConnected(): print 'not connected' for self._port in machineCom.serialList(False): try: print 'despues', self._port programmer.connect(self._port) print 'lo que devuelve', programmer.isConnected() print self._baudrate profile.putMachineSetting('serial_port_auto', self._port) print 'hemos llegado despues del port' print self._port #wx.MessageBox('esto es lo que tenemoss',self._port) programmer.close() self._serial = serial.Serial(str(self._port), self._baudrate, timeout=1) print self._serial profile.putMachineSetting('self_serial', self._serial) self._state = 'Online' print 'bueno', self._state break except ispBase.IspError as (e): self._state = 'Offline' pass programmer.close() if self._port not in machineCom.serialList(False): self._state = 'Offline' print 'malo', self._state if self._state == 'Offline': self.AddText( _('Please connect your printer to the computer.\n\n' 'In case you already had it connected and it was not detected,\n' 'please disconnect and connect again.\n\n' 'Once you have done this, you may press Connect && Upgrade to\n' 'continue with the process.\n\n' '(Note: this may take a minute)\n')) connectButton = self.AddButton('Connect && Upgrade') connectButton.Bind(wx.EVT_BUTTON, self.OnWantToConnect) self.AddSeperator() if self._state == 'Online': self.AddText( _('We have detected a printer, please press Upgrade to continue\n' 'with the process.\n\n' '(Note: this may take a minute)\n')) upgradeButton = self.AddButton('Upgrade') upgradeButton.Bind(wx.EVT_BUTTON, self.OnWantToUpgrade) self.AddSeperator()
def OnRun(self): wx.CallAfter(self.updateLabel, _("Reading firmware...")) hexFile = intelHex.readHex(self.filename) wx.CallAfter(self.updateLabel, _("Connecting to machine...")) programmer = stk500v2.Stk500v2() programmer.progressCallback = self.OnProgress if self.port == 'AUTO': wx.CallAfter(self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable.")) while not programmer.isConnected(): for self.port in machineCom.serialList(True): try: programmer.connect(self.port) break except ispBase.IspError: programmer.close() time.sleep(1) if not self: #Window destroyed return else: try: programmer.connect(self.port) except ispBase.IspError: programmer.close() if not programmer.isConnected(): wx.MessageBox(_("Failed to find machine for firmware upgrade\nIs your machine connected to the PC?"), _("Firmware update"), wx.OK | wx.ICON_ERROR) wx.CallAfter(self.Close) return if self._machine_type == 'ultimaker': if programmer.hasChecksumFunction(): wx.CallAfter(self.updateLabel, _("Failed to install firmware:\nThis firmware is not compatible with this machine.\nTrying to install UMO firmware on an UM2 or UMO+?")) programmer.close() wx.CallAfter(self.okButton.Enable) return if self._machine_type == 'ultimaker_plus' or self._machine_type == 'ultimaker2': if not programmer.hasChecksumFunction(): wx.CallAfter(self.updateLabel, _("Failed to install firmware:\nThis firmware is not compatible with this machine.\nTrying to install UM2 or UMO+ firmware on an UMO?")) programmer.close() wx.CallAfter(self.okButton.Enable) return wx.CallAfter(self.updateLabel, _("Uploading firmware...")) try: programmer.programChip(hexFile) self.success = True wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename))) except ispBase.IspError as e: wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e)) programmer.close() wx.CallAfter(self.okButton.Enable)
def OnInstall(self): wx.CallAfter(self.okButton.Disable) wx.CallAfter(self.updateLabel, _("Reading firmware...")) hexFile = intelHex.readHex(self.filename) wx.CallAfter(self.updateLabel, _("Connecting to machine...")) programmer = stk500v2.Stk500v2() programmer.progressCallback = self.OnProgress if self.port == 'AUTO': wx.CallAfter( self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable." )) while not programmer.isConnected(): for self.port in machineCom.serialList(True): try: programmer.connect(self.port) break except ispBase.IspError: pass time.sleep(1) if not self: #Window destroyed return else: try: programmer.connect(self.port) except ispBase.IspError: pass if not programmer.isConnected(): wx.CallAfter(self.updateLabel, _("Failed to connect to programmer.\n")) return wx.CallAfter(self.updateLabel, _("Uploading firmware...")) try: programmer.programChip(hexFile) wx.CallAfter( self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename))) except ispBase.IspError as e: wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e)) programmer.close() wx.CallAfter(self.okButton.Enable)
def _monitor(self): programmer = stk500v2.Stk500v2() if self._port == 'AUTO': while not programmer.isConnected(): for self._port in machineCom.serialList(False): try: programmer.connect(self._port) if programmer.isConnected(): return self._serial except ispBase.IspError: programmer.close() time.sleep(1) if not self: #Window destroyed return else: try: programmer.connect(self._port) except ispBase.IspError: programmer.close()
def OnRun(self): programmer = stk500v2.Stk500v2() programmer.progressCallback = self.OnProgress if self.port == 'AUTO': wx.CallAfter( self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable." )) while not programmer.isConnected(): for self.port in machineCom.serialList(False): try: programmer.connect(self.port) break except ispBase.IspError: programmer.close() time.sleep(1) if not self: #Window destroyed return else: try: programmer.connect(self.port) except ispBase.IspError: programmer.close() if not programmer.isConnected(): wx.MessageBox( _("Failed to find machine for firmware upgrade\nIs your machine connected to the PC?" ), _("Firmware update"), wx.OK | wx.ICON_ERROR) wx.CallAfter(self.Close) return #wx.CallAfter(self.updateLabel, _("Uploading firmware...")) #try: # programmer.programChip(hexFile) # wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename))) #except ispBase.IspError as e: # wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e)) programmer.close() wx.CallAfter(self.okButton.Enable)
def OnWantToConnect(self, e): self._port = 'AUTO' self._baudrate = 250000 if self._port == 'AUTO': print 'entramos en port auto despues de baudrate' programmer = stk500v2.Stk500v2() print 'antes', self._port if not programmer.isConnected(): print 'not connected' for self._port in machineCom.serialList(False): try: print 'despues', self._port programmer.connect(self._port) print 'lo que devuelve', programmer.isConnected() print self._baudrate profile.putMachineSetting('serial_port_auto', self._port) print 'hemos llegado despues del port' print self._port programmer.close() self._serial = serial.Serial(str(self._port), self._baudrate, timeout=1) print self._serial profile.putMachineSetting('self_serial', self._serial) self._state = 'Online' print 'bueno', self._state break except ispBase.IspError as (e): self._state = 'Offline' pass programmer.close() if self._port not in machineCom.serialList(False): self._state = 'Offline' print 'malo', self._state if self._state == 'Online': self._serial.close() self.readFirstLine() self.getFirmwareHardware()
def OnRun(self): wx.CallAfter(self.updateLabel, "Reading firmware...") hexFile = intelHex.readHex(self.filename) wx.CallAfter(self.updateLabel, "Connecting to machine...") programmer = stk500v2.Stk500v2() programmer.progressCallback = self.OnProgress if self.port == 'AUTO': for self.port in machineCom.serialList(True): try: programmer.connect(self.port) break except ispBase.IspError: pass else: try: programmer.connect(self.port) except ispBase.IspError: pass if programmer.isConnected(): wx.CallAfter(self.updateLabel, "Uploading firmware...") try: programmer.programChip(hexFile) wx.CallAfter( self.updateLabel, "Done!\nInstalled firmware: %s" % (os.path.basename(self.filename))) except ispBase.IspError as e: wx.CallAfter(self.updateLabel, "Failed to write firmware.\n" + str(e)) programmer.close() wx.CallAfter(self.okButton.Enable) return wx.MessageBox( 'Failed to find machine for firmware upgrade\nIs your machine connected to the PC?', 'Firmware update', wx.OK | wx.ICON_ERROR) wx.CallAfter(self.Close)
def _monitor(self): #Open the serial port. if self._port == 'AUTO': self._changeState(self.STATE_DETECT_SERIAL) programmer = stk500v2.Stk500v2() for p in serialList(True): try: self._log("Connecting to: %s (programmer)" % (p)) programmer.connect(p) self._serial = programmer.leaveISP() profile.putMachineSetting('serial_port_auto', p) break except ispBase.IspError as (e): self._log("Error while connecting to %s: %s" % (p, str(e))) pass except: self._log( "Unexpected error while connecting to serial port: %s %s" % (p, getExceptionString())) programmer.close() if self._serial is None: self._log("Serial port list: %s" % (str(serialList(True)))) self._serialDetectList = serialList(True) elif self._port == 'VIRTUAL': self._changeState(self.STATE_OPEN_SERIAL) self._serial = VirtualPrinter() else: self._changeState(self.STATE_OPEN_SERIAL) try: if self._baudrate == 0: self._log( "Connecting to: %s with baudrate: 115200 (fallback)" % (self._port)) self._serial = serial.Serial(str(self._port), 115200, timeout=3, writeTimeout=10000) else: self._log( "Connecting to: %s with baudrate: %s (configured)" % (self._port, self._baudrate)) self._serial = serial.Serial(str(self._port), self._baudrate, timeout=5, writeTimeout=10000) except: self._log( "Unexpected error while connecting to serial port: %s %s" % (self._port, getExceptionString())) if self._serial is None: baudrate = self._baudrate if baudrate == 0: baudrate = self._baudrateDetectList.pop(0) if len(self._serialDetectList) < 1: self._log("Found no ports to try for auto detection") self._errorValue = 'Failed to autodetect serial port.' self._changeState(self.STATE_ERROR) return port = self._serialDetectList.pop(0) self._log("Connecting to: %s with baudrate: %s (auto)" % (port, baudrate)) try: self._serial = serial.Serial(port, baudrate, timeout=3, writeTimeout=10000) except: pass else: self._log("Connected to: %s, starting monitor" % (self._serial)) if self._baudrate == 0: self._changeState(self.STATE_DETECT_BAUDRATE) else: self._changeState(self.STATE_CONNECTING) #Start monitoring the serial port. if self._state == self.STATE_CONNECTING: timeout = time.time() + 15 else: timeout = time.time() + 5 tempRequestTimeout = timeout while True: line = self._readline() if line is None: break #No matter the state, if we see an fatal error, goto the error state and store the error for reference. # Only goto error on known fatal errors. if line.startswith('Error:'): #Oh YEAH, consistency. # Marlin reports an MIN/MAX temp error as "Error:x\n: Extruder switched off. MAXTEMP triggered !\n" # But a bed temp error is reported as "Error: Temperature heated bed switched off. MAXTEMP triggered !!" # So we can have an extra newline in the most common case. Awesome work people. if re.match('Error:[0-9]\n', line): line = line.rstrip() + self._readline() #Skip the communication errors, as those get corrected. if 'Extruder switched off' in line or 'Temperature heated bed switched off' in line or 'Something is wrong, please turn off the printer.' in line: if not self.isError(): self._errorValue = line[6:] self._changeState(self.STATE_ERROR) if ' T:' in line or line.startswith('T:'): try: self._temp[self._temperatureRequestExtruder] = float( re.search("T: *([0-9\.]*)", line).group(1)) except: pass if 'B:' in line: try: self._bedTemp = float( re.search("B: *([0-9\.]*)", line).group(1)) except: pass self._callback.mcTempUpdate(self._temp, self._bedTemp, self._targetTemp, self._bedTargetTemp) #If we are waiting for an M109 or M190 then measure the time we lost during heatup, so we can remove that time from our printing time estimate. if not 'ok' in line and self._heatupWaitStartTime != 0: t = time.time() self._heatupWaitTimeLost = t - self._heatupWaitStartTime self._heatupWaitStartTime = t elif line.strip() != '' and line.strip( ) != 'ok' and not line.startswith( 'Resend:' ) and not line.startswith( 'Error:checksum mismatch' ) and not line.startswith( 'Error:Line Number is not Last Line Number+1' ) and line != 'echo:Unknown command:""\n' and self.isOperational(): self._callback.mcMessage(line) if self._state == self.STATE_DETECT_BAUDRATE or self._state == self.STATE_DETECT_SERIAL: if line == '' or time.time() > timeout: if len(self._baudrateDetectList) < 1: self.close() self._errorValue = "No more baudrates to test, and no suitable baudrate found." self._changeState(self.STATE_ERROR) elif self._baudrateDetectRetry > 0: self._baudrateDetectRetry -= 1 self._serial.write('\n') self._log("Baudrate test retry: %d" % (self._baudrateDetectRetry)) self._sendCommand("M105") self._testingBaudrate = True else: if self._state == self.STATE_DETECT_SERIAL: if len(self._serialDetectList) == 0: if len(self._baudrateDetectList) == 0: self._log( "Tried all serial ports and baudrates, but still not printer found that responds to M105." ) self._errorValue = 'Failed to autodetect serial port.' self._changeState(self.STATE_ERROR) return else: self._serialDetectList = serialList(True) baudrate = self._baudrateDetectList.pop(0) self._serial.close() self._serial = serial.Serial( self._serialDetectList.pop(0), baudrate, timeout=2.5, writeTimeout=10000) else: baudrate = self._baudrateDetectList.pop(0) try: self._setBaudrate(baudrate) self._serial.timeout = 0.5 self._log("Trying baudrate: %d" % (baudrate)) self._baudrateDetectRetry = 5 self._baudrateDetectTestOk = 0 timeout = time.time() + 5 self._serial.write('\n') self._sendCommand("M105") self._testingBaudrate = True except: self._log( "Unexpected error while setting baudrate: %d %s" % (baudrate, getExceptionString())) elif 'T:' in line: self._baudrateDetectTestOk += 1 if self._baudrateDetectTestOk < 10: self._log("Baudrate test ok: %d" % (self._baudrateDetectTestOk)) self._sendCommand("M105") else: self._sendCommand("M999") self._serial.timeout = 2 profile.putMachineSetting('serial_baud_auto', self._serial.baudrate) self._changeState(self.STATE_OPERATIONAL) else: self._testingBaudrate = False elif self._state == self.STATE_CONNECTING: if line == '' or 'wait' in line: # 'wait' needed for Repetier (kind of watchdog) self._sendCommand("M105") elif 'ok' in line: self._changeState(self.STATE_OPERATIONAL) if time.time() > timeout: self.close() elif self._state == self.STATE_OPERATIONAL: #Request the temperature on comm timeout (every 2 seconds) when we are not printing. if line == '': if self._extruderCount > 0: self._temperatureRequestExtruder = ( self._temperatureRequestExtruder + 1) % self._extruderCount self.sendCommand("M105 T%d" % (self._temperatureRequestExtruder)) else: self.sendCommand("M105") tempRequestTimeout = time.time() + 5 elif self._state == self.STATE_PRINTING: #Even when printing request the temperature every 5 seconds. if time.time() > tempRequestTimeout: if self._extruderCount > 0: self._temperatureRequestExtruder = ( self._temperatureRequestExtruder + 1) % self._extruderCount self.sendCommand("M105 T%d" % (self._temperatureRequestExtruder)) else: self.sendCommand("M105") tempRequestTimeout = time.time() + 5 if line == '' and time.time() > timeout: self._log( "Communication timeout during printing, forcing a line" ) line = 'ok' if 'ok' in line: timeout = time.time() + 5 if not self._commandQueue.empty(): self._sendCommand(self._commandQueue.get()) else: self._sendNext() elif "resend" in line.lower() or "rs" in line: try: self._gcodePosition = int( line.replace("N:", " ").replace("N", " ").replace( ":", " ").split()[-1]) except: if "rs" in line: self._gcodePosition = int(line.split()[1]) self._log("Connection closed, closing down monitor")
def OnRun(self): wx.CallAfter(self.updateLabel, _("Reading firmware...")) hexFile = intelHex.readHex(self.filename) wx.CallAfter(self.updateLabel, _("Connecting to machine...")) programmer = stk500v2.Stk500v2() programmer.progressCallback = self.OnProgress if self.port == 'AUTO': wx.CallAfter( self.updateLabel, _("Please connect the printer to your\ncomputer with a USB cable and power it on." )) while not programmer.isConnected(): for self.port in machineCom.serialList(True): try: programmer.connect(self.port) break except ispBase.IspError: programmer.close() time.sleep(1) if not self: #Window destroyed return else: try: programmer.connect(self.port) except ispBase.IspError: programmer.close() if not self: #Window destroyed return self.cancelButton.Disable() self.okButton.SetLabel(_('Ok')) if not programmer.isConnected(): self.show_connect_dialog = True wx.CallAfter(self.Close) return if self._machine_type == 'ultimaker': if programmer.hasChecksumFunction(): wx.CallAfter( self.updateLabel, _("Failed to install firmware:\nThis firmware is not compatible with this machine.\nTrying to install UMO firmware on an UM2 or UMO+?" )) programmer.close() wx.CallAfter(self.okButton.Enable) return if self._machine_type == 'ultimaker_plus' or self._machine_type == 'ultimaker2': if not programmer.hasChecksumFunction(): wx.CallAfter( self.updateLabel, _("Failed to install firmware:\nThis firmware is not compatible with this machine.\nTrying to install UM2 or UMO+ firmware on an UMO?" )) programmer.close() wx.CallAfter(self.okButton.Enable) return wx.CallAfter(self.updateLabel, _("Uploading firmware...")) try: programmer.programChip(hexFile) self.success = True wx.CallAfter(self.updateLabel, _("Done!")) except ispBase.IspError as e: wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e)) programmer.close() wx.CallAfter(self.okButton.Enable)
def _monitor(self): #Open the serial port. if self._port == 'AUTO': self._changeState(self.STATE_DETECT_SERIAL) programmer = stk500v2.Stk500v2() for p in serialList(True): try: self._log("Connecting to: %s (programmer)" % (p)) programmer.connect(p) self._serial = programmer.leaveISP() profile.putMachineSetting('serial_port_auto', p) break except ispBase.IspError as (e): self._log("Error while connecting to %s: %s" % (p, str(e))) pass except: self._log( "Unexpected error while connecting to serial port: %s %s" % (p, getExceptionString())) programmer.close() if self._serial is None: self._log("Serial port list: %s" % (str(serialList(True)))) self._serialDetectList = serialList(True) elif self._port == 'VIRTUAL': self._changeState(self.STATE_OPEN_SERIAL) self._serial = VirtualPrinter() else: self._changeState(self.STATE_OPEN_SERIAL) try: if self._baudrate == 0: self._log( "Connecting to: %s with baudrate: 115200 (fallback)" % (self._port)) self._serial = serial.Serial(str(self._port), 115200, timeout=3) # Need to set writeTimeout separately in order to be compatible with pyserial 3.0 self._serial.writeTimeout = 10000 else: self._log( "Connecting to: %s with baudrate: %s (configured)" % (self._port, self._baudrate)) self._serial = serial.Serial(str(self._port), self._baudrate, timeout=5) # Need to set writeTimeout separately in order to be compatible with pyserial 3.0 self._serial.writeTimeout = 10000 except: self._log( "Unexpected error while connecting to serial port: %s %s" % (self._port, getExceptionString())) if self._serial is None: baudrate = self._baudrate if baudrate == 0: baudrate = self._baudrateDetectList.pop(0) if len(self._serialDetectList) < 1: self._log("Found no ports to try for auto detection") self._errorValue = 'Failed to autodetect serial port.' self._changeState(self.STATE_ERROR) return port = self._serialDetectList.pop(0) self._log("Connecting to: %s with baudrate: %s (auto)" % (port, baudrate)) try: self._serial = serial.Serial(port, baudrate, timeout=3) # Need to set writeTimeout separately in order to be compatible with pyserial 3.0 self._serial.writeTimeout = 10000 except: pass else: self._log("Connected to: %s, starting monitor" % (self._serial)) if self._baudrate == 0: self._changeState(self.STATE_DETECT_BAUDRATE) else: self._changeState(self.STATE_CONNECTING) #Start monitoring the serial port. if self._state == self.STATE_CONNECTING: timeout = time.time() + 15 else: timeout = time.time() + 5 tempRequestTimeout = timeout while True: line = self._readline() if line is None: break #No matter the state, if we see an fatal error, goto the error state and store the error for reference. # Only goto error on known fatal errors. if line.startswith('Error:'): #Oh YEAH, consistency. # Marlin reports an MIN/MAX temp error as "Error:x\n: Extruder switched off. MAXTEMP triggered !\n" # But a bed temp error is reported as "Error: Temperature heated bed switched off. MAXTEMP triggered !!" # So we can have an extra newline in the most common case. Awesome work people. if re.match('Error:[0-9]\n', line): line = line.rstrip() + self._readline() #Skip the communication errors, as those get corrected. if 'Extruder switched off' in line or 'Temperature heated bed switched off' in line or 'Something is wrong, please turn off the printer.' in line or 'PROBE FAIL' in line: if not self.isError(): self._errorValue = line[6:] self._changeState(self.STATE_ERROR) if ' T:' in line or line.startswith('T:'): tempRequestTimeout = time.time() + 5 try: self._temp[self._temperatureRequestExtruder] = float( re.search("T: *([0-9\.]*)", line).group(1)) except: pass if 'B:' in line: try: self._bedTemp = float( re.search("B: *([0-9\.]*)", line).group(1)) except: pass self._callback.mcTempUpdate(self._temp, self._bedTemp, self._targetTemp, self._bedTargetTemp) #If we are waiting for an M109 or M190 then measure the time we lost during heatup, so we can remove that time from our printing time estimate. if not 'ok' in line and self._heatupWaitStartTime != 0: t = time.time() self._heatupWaitTimeLost = t - self._heatupWaitStartTime self._heatupWaitStartTime = t elif line.strip() != '' and line.strip() != 'ok' and not line.startswith('Resend:') and \ not line.startswith('Error:checksum mismatch') and not line.startswith('Error:Line Number is not Last Line Number+1') and \ not line.startswith('Error:No Checksum with line number') and not line.startswith('Error:No Line Number with checksum') and \ line != 'echo:Unknown command:""\n' and self.isOperational(): self._callback.mcMessage(line) if self._state == self.STATE_DETECT_BAUDRATE or self._state == self.STATE_DETECT_SERIAL: if line == '' or time.time() > timeout: if len(self._baudrateDetectList) < 1: self.close() self._errorValue = "No more baudrates to test, and no suitable baudrate found." self._changeState(self.STATE_ERROR) elif self._baudrateDetectRetry > 0: self._baudrateDetectRetry -= 1 self._serial.write('\n') self._log("Baudrate test retry: %d" % (self._baudrateDetectRetry)) self._sendCommand("M105") self._testingBaudrate = True else: if self._state == self.STATE_DETECT_SERIAL: if len(self._serialDetectList) == 0: if len(self._baudrateDetectList) == 0: self._log( "Tried all serial ports and baudrates, but still not printer found that responds to M105." ) self._errorValue = 'Failed to autodetect serial port.' self._changeState(self.STATE_ERROR) return else: self._serialDetectList = serialList(True) baudrate = self._baudrateDetectList.pop(0) self._serial.close() self._serial = serial.Serial( self._serialDetectList.pop(0), baudrate, timeout=2.5) # Need to set writeTimeout separately in order to be compatible with pyserial 3.0 self._serial.writeTimeout = 10000 else: baudrate = self._baudrateDetectList.pop(0) try: self._setBaudrate(baudrate) self._serial.timeout = 0.5 self._log("Trying baudrate: %d" % (baudrate)) self._baudrateDetectRetry = 5 self._baudrateDetectTestOk = 0 timeout = time.time() + 5 self._serial.write('\n') self._sendCommand("M105") self._testingBaudrate = True except: self._log( "Unexpected error while setting baudrate: %d %s" % (baudrate, getExceptionString())) elif 'T:' in line: self._baudrateDetectTestOk += 1 if self._baudrateDetectTestOk < 10: self._log("Baudrate test ok: %d" % (self._baudrateDetectTestOk)) self._sendCommand("M105") else: self._sendCommand("M999") self._serial.timeout = 2 profile.putMachineSetting('serial_baud_auto', self._serial.baudrate) self._changeState(self.STATE_OPERATIONAL) else: self._testingBaudrate = False elif self._state == self.STATE_CONNECTING: if line == '' or 'wait' in line or 'start' in line: # 'wait' needed for Repetier (kind of watchdog) self._sendCommand("M105") elif 'ok' in line: self._changeState(self.STATE_OPERATIONAL) if time.time() > timeout: self.close() elif self._state == self.STATE_OPERATIONAL: # Request the temperature on comm timeout (every 2 seconds) when we are not printing. # unless we had a temperature feedback (from M109 or M190 for example) if line == '' and time.time() > tempRequestTimeout: if self._heatupWaiting and len(self._currentCommands) == 1: self._log( "Canceling heatup due to missing T: line in the past 5 seconds. cmdbuffer desync?" ) self._heatupWaiting = False # Force a timeout now if necessary timeout = time.time() - 1 if self._extruderCount > 0: self._temperatureRequestExtruder = ( self._temperatureRequestExtruder + 1) % self._extruderCount self.sendCommand("M105 T%d" % (self._temperatureRequestExtruder)) else: self.sendCommand("M105") # set timeout to less than 2 seconds to make sure it always triggers when comm times out tempRequestTimeout = time.time() + 1.5 if line == '' and time.time() > timeout: line = 'ok' if 'ok' in line: self.receivedOK() timeout = time.time() + 30 if not self._heatupWaiting and not self._commandQueue.empty( ): self._sendCommand(self._commandQueue.get()) if len(self._currentCommands) > 0 and \ ("G28" in self._currentCommands[0] or "G29" in self._currentCommands[0] or \ "M109" in self._currentCommands[0] or "M190" in self._currentCommands[0]): # Long command detected. Timeout is now set to 10 minutes to avoid forcing 'ok' # every 30 seconds while it's not needed timeout = time.time() + 600 elif 'start' in line: self._currentCommands = [] timeout = time.time() + 30 elif self._state == self.STATE_PRINTING: #Even when printing request the temperature every 5 seconds. if time.time() > tempRequestTimeout: if self._heatupWaiting and len(self._currentCommands) == 1: self._log( "Canceling heatup due to missing T: line in the past 5 seconds. cmdbuffer desync?" ) self._heatupWaiting = False # Force a timeout now if necessary timeout = time.time() - 1 if self._extruderCount > 0: self._temperatureRequestExtruder = ( self._temperatureRequestExtruder + 1) % self._extruderCount self.sendCommand("M105 T%d" % (self._temperatureRequestExtruder)) else: self.sendCommand("M105") tempRequestTimeout = time.time() + 5 if line == '' and time.time() > timeout: self._log( "Communication timeout during printing, forcing a line" ) line = 'ok' if 'ok' in line: self.receivedOK() timeout = time.time() + 30 # If we are heating up with M109 or M190, then we can't send any new # commands until the command buffer queue in firmware is empty (M109/M190 done) # otherwise, we will fill up the buffer queue (2 more commands will be accepted after M109/M190) # and anything else we send will just end up in the serial ringbuffer and will not be read until # the M109/M190 is done. # So if we want to cancel the heatup, we need to send M108 which needs to be able to be read from # the ringbuffer, which means the command queue needs to be empty. # So we stop sending any commands after M109/M190 unless it's M108 (or until heating done) if we want # M108 to get handled. # the small delay that is caused by the firmware buffer getting empty is not important because # this happens during a heat&wait, not during a move command. # If M108 is received, it gets sent directly from the receiving thread, not from here # because the _commandQueue is not iterable if not self._heatupWaiting: # We iterate in case we just came out of a heat&wait for i in xrange(len(self._currentCommands), CMDBUFFER_SIZE): # One of the next 4 could enable the heatupWaiting mode if not self._heatupWaiting: if not self._commandQueue.empty(): self._sendCommand(self._commandQueue.get()) else: self._sendNext() if len(self._currentCommands) > 0 and \ ("G28" in self._currentCommands[0] or "G29" in self._currentCommands[0] or \ "M109" in self._currentCommands[0] or "M190" in self._currentCommands[0]): # Long command detected. Timeout is now set to 10 minutes to avoid forcing 'ok' # every 30 seconds while it's not needed timeout = time.time() + 600 elif 'start' in line: self._currentCommands = [] timeout = time.time() + 30 elif "resend" in line.lower() or "rs" in line: newPos = self._gcodePos try: newPos = int( line.replace("N:", " ").replace("N", " ").replace( ":", " ").split()[-1]) except: if "rs" in line: newPos = int(line.split()[1]) # If we need to resend more than 10 lines, we can assume that the machine # was shut down and turned back on or something else that's weird just happened. # In that case, it can be dangerous to restart the print, so we'd better kill it if newPos == 1 or self._gcodePos > newPos + 100: self._callback.mcMessage( "Print canceled due to loss of communication to printer (USB unplugged or power lost)" ) self.cancelPrint() else: self._gcodePos = newPos elif self._state == self.STATE_PAUSED: #Even when printing request the temperature every 5 seconds. if time.time() > tempRequestTimeout: if self._heatupWaiting and len(self._currentCommands) == 1: self._log( "Canceling heatup due to missing T: line in the past 5 seconds. cmdbuffer desync?" ) self._heatupWaiting = False # Force a timeout now if necessary timeout = time.time() - 1 if self._extruderCount > 0: self._temperatureRequestExtruder = ( self._temperatureRequestExtruder + 1) % self._extruderCount self.sendCommand("M105 T%d" % (self._temperatureRequestExtruder)) else: self.sendCommand("M105") tempRequestTimeout = time.time() + 5 if line == '' and time.time() > timeout: line = 'ok' if 'ok' in line: self.receivedOK() timeout = time.time() + 30 if not self._heatupWaiting and not self._commandQueue.empty( ): self._sendCommand(self._commandQueue.get()) if len(self._currentCommands) > 0 and \ ("G28" in self._currentCommands[0] or "G29" in self._currentCommands[0] or \ "M109" in self._currentCommands[0] or "M190" in self._currentCommands[0]): # Long command detected. Timeout is now set to 10 minutes to avoid forcing 'ok' # every 30 seconds while it's not needed timeout = time.time() + 600 elif 'start' in line: self._currentCommands = [] timeout = time.time() + 30 self._log("Connection closed, closing down monitor")