def __init__(self, port = None, baudrate = None):
if port == None:
port = profile.getPreference('serial_port')
if baudrate == None:
baudrate = int(profile.getPreference('serial_baud'))
self.serial = None
if port == 'AUTO':
programmer = stk500v2.Stk500v2()
for port in serialList():
try:
print "Connecting to: %s %i" % (port, baudrate)
programmer.connect(port)
programmer.close()
time.sleep(1)
self.serial = Serial(port, baudrate, timeout=2)
break
except ispBase.IspError as (e):
print "Error while connecting to %s %i" % (port, baudrate)
print e
pass
except:
print "Unexpected error while connecting to serial port:" + port, sys.exc_info()[0]
programmer.close()
elif port == 'VIRTUAL':
self.serial = VirtualPrinter()
else:
try:
self.serial = Serial(port, baudrate, timeout=2)
except:
print "Unexpected error while connecting to serial port:" + port, sys.exc_info()[0]
print self.serial
def OnRun(self):
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 serialList():
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!")
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()
self._log("Serial port list: %s" % (str(serialList())))
for p in serialList():
try:
self._log("Connecting to: %s" % (p))
programmer.connect(p)
self._serial = programmer.leaveISP()
profile.putPreference('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()
elif self._port == 'VIRTUAL':
self._changeState(self.STATE_OPEN_SERIAL)
self._serial = VirtualPrinter()
else:
self._changeState(self.STATE_OPEN_SERIAL)
try:
self._log("Connecting to: %s" % (self._port))
if self._baudrate == 0:
self._serial = serial.Serial(self._port,
115200,
timeout=0.1,
writeTimeout=10000)
else:
self._serial = serial.Serial(self._port,
self._baudrate,
timeout=2,
writeTimeout=10000)
except:
self._log(
"Unexpected error while connecting to serial port: %s %s" %
(self._port, getExceptionString()))
if self._serial == None:
self._log("Failed to open serial port (%s)" % (self._port))
self._errorValue = 'Failed to autodetect serial port.'
self._changeState(self.STATE_ERROR)
return
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.
timeout = time.time() + 5
tempRequestTimeout = timeout
while True:
line = self._readline()
if line == None:
break
#No matter the state, if we see an error, goto the error state and store the error for reference.
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 'checksum mismatch' in line or 'Line Number is not Last Line Number' in line or 'No Line Number with checksum' in line:
pass
elif not self.isError():
self._errorValue = line[6:]
self._changeState(self.STATE_ERROR)
if ' T:' in line or line.startswith('T:'):
self._temp = float(
re.search("[0-9\.]*",
line.split('T:')[1]).group(0))
if ' B:' in line:
self._bedTemp = float(
re.search("[0-9\.]*",
line.split(' B:')[1]).group(0))
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 line != 'echo:Unknown command:""\n' and self.isOperational():
self._callback.mcMessage(line)
if self._state == self.STATE_DETECT_BAUDRATE:
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:
baudrate = self._baudrateDetectList.pop(0)
try:
self._serial.baudrate = 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 'ok' in line and '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.putPreference('serial_baud_auto',
self._serial.baudrate)
self._changeState(self.STATE_OPERATIONAL)
else:
self._testingBaudrate = False
elif self._state == self.STATE_CONNECTING:
if line == '':
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 == '':
self._sendCommand("M105")
tempRequestTimeout = time.time() + 5
elif self._state == self.STATE_PRINTING:
if line == '' and time.time() > timeout:
self._log(
"Communication timeout during printing, forcing a line"
)
line = 'ok'
#Even when printing request the temperture every 5 seconds.
if time.time() > tempRequestTimeout:
self._commandQueue.put("M105")
tempRequestTimeout = time.time() + 5
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._gcodePos = int(
line.replace("N:", " ").replace("N", " ").replace(
":", " ").split()[-1])
except:
if "rs" in line:
self._gcodePos = int(line.split()[1])
self._log("Connection closed, closing down monitor")
def __init__(self, port=None, baudrate=None, callbackObject=None):
if port == None:
port = profile.getPreference('serial_port')
if baudrate == None:
if profile.getPreference('serial_baud') == 'AUTO':
baudrate = 0
else:
baudrate = int(profile.getPreference('serial_baud'))
if callbackObject == None:
callbackObject = MachineComPrintCallback()
self._callback = callbackObject
self._state = self.STATE_NONE
self._serial = None
self._baudrateDetectList = baudrateList()
self._baudrateDetectRetry = 0
self._temp = 0
self._bedTemp = 0
self._gcodeList = None
self._gcodePos = 0
self._commandQueue = queue.Queue()
self._logQueue = queue.Queue(256)
self._feedRateModifier = {}
self._currentZ = -1
if port == 'AUTO':
programmer = stk500v2.Stk500v2()
self._log("Serial port list: %s" % (str(serialList())))
for p in serialList():
try:
self._log("Connecting to: %s" % (p))
programmer.connect(p)
self._serial = programmer.leaveISP()
profile.putPreference('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()
elif port == 'VIRTUAL':
self._serial = VirtualPrinter()
else:
try:
self._log("Connecting to: %s" % (port))
if baudrate == 0:
self._serial = Serial(port, 115200, timeout=0.1)
else:
self._serial = Serial(port, baudrate, timeout=2)
except:
self._log(
"Unexpected error while connecting to serial port: %s %s" %
(port, getExceptionString()))
if self._serial == None:
self._log("Failed to open serial port (%s)" % (port))
self._errorValue = 'Failed to autodetect serial port.'
self._changeState(self.STATE_ERROR)
return
self._log("Connected to: %s, starting monitor" % (self._serial))
if baudrate == 0:
self._changeState(self.STATE_DETECT_BAUDRATE)
else:
self._changeState(self.STATE_CONNECTING)
self.thread = threading.Thread(target=self._monitor)
self.thread.daemon = True
self.thread.start()