__copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
-import threading
-import re
-import subprocess
-import sys
+import wx
+from wx.lib.intctrl import IntCtrl
+import power
import time
-import platform
+import sys
import os
-import power
-import datetime
-
-import wx
-from wx.lib import buttons
-
-from Cura.gui.util import webcam
-from Cura.gui.util import taskbar
-from Cura.util import machineCom
-from Cura.util import gcodeInterpreter
+import ctypes
+import subprocess
from Cura.util import resources
-from Cura.util import profile
-
-#The printProcessMonitor is used from the main GUI python process. This monitors the printing python process.
-# This class also handles starting of the 2nd process for printing and all communications with it.
-class printProcessMonitor():
- def __init__(self, callback = None):
- self.handle = None
- self._state = 'CLOSED'
- self._z = 0.0
- self._callback = callback
- self._id = -1
-
- def loadFile(self, filename, id):
- if self.handle is None:
- if platform.system() == "Darwin" and hasattr(sys, 'frozen'):
- cmdList = [os.path.join(os.path.dirname(sys.executable), 'Cura')]
- else:
- cmdList = [sys.executable, '-m', 'Cura.cura']
- cmdList.append('-r')
- cmdList.append(filename)
- if platform.system() == "Darwin":
- if platform.machine() == 'i386':
- cmdList.insert(0, 'arch')
- cmdList.insert(1, '-i386')
- #Save the preferences before starting the print window so we use the proper machine settings.
- profile.savePreferences(profile.getPreferencePath())
- self.handle = subprocess.Popen(cmdList, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- self.thread = threading.Thread(target=self.Monitor)
- self.thread.start()
+
+#TODO: This does not belong here!
+if sys.platform.startswith('win'):
+ def preventComputerFromSleeping(frame, prevent):
+ """
+ Function used to prevent the computer from going into sleep mode.
+ :param prevent: True = Prevent the system from going to sleep from this point on.
+ :param prevent: False = No longer prevent the system from going to sleep.
+ """
+ ES_CONTINUOUS = 0x80000000
+ ES_SYSTEM_REQUIRED = 0x00000001
+ ES_AWAYMODE_REQUIRED = 0x00000040
+ #SetThreadExecutionState returns 0 when failed, which is ignored. The function should be supported from windows XP and up.
+ if prevent:
+ # For Vista and up we use ES_AWAYMODE_REQUIRED to prevent a print from failing if the PC does go to sleep
+ # As it's not supported on XP, we catch the error and fallback to using ES_SYSTEM_REQUIRED only
+ if ctypes.windll.kernel32.SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED) == 0:
+ ctypes.windll.kernel32.SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED)
+ else:
+ ctypes.windll.kernel32.SetThreadExecutionState(ES_CONTINUOUS)
+
+elif sys.platform.startswith('darwin'):
+ import objc
+ bundle = objc.initFrameworkWrapper("IOKit",
+ frameworkIdentifier="com.apple.iokit",
+ frameworkPath=objc.pathForFramework("/System/Library/Frameworks/IOKit.framework"),
+ globals=globals())
+ objc.loadBundleFunctions(bundle, globals(), [("IOPMAssertionCreateWithName", b"i@I@o^I")])
+ objc.loadBundleFunctions(bundle, globals(), [("IOPMAssertionRelease", b"iI")])
+ def preventComputerFromSleeping(frame, prevent):
+ if prevent:
+ success, preventComputerFromSleeping.assertionID = IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn, "Cura is printing", None)
+ if success != kIOReturnSuccess:
+ preventComputerFromSleeping.assertionID = None
else:
- self.handle.stdin.write('LOAD:%s\n' % filename)
- self._id = id
-
- def Monitor(self):
- p = self.handle
- line = p.stdout.readline()
- while len(line) > 0:
- line = line.rstrip()
+ if hasattr(preventComputerFromSleeping, "assertionID"):
+ if preventComputerFromSleeping.assertionID is not None:
+ IOPMAssertionRelease(preventComputerFromSleeping.assertionID)
+ preventComputerFromSleeping.assertionID = None
+else:
+ def preventComputerFromSleeping(frame, prevent):
+ if os.path.isfile("/usr/bin/xdg-screensaver"):
try:
- if line.startswith('Z:'):
- self._z = float(line[2:])
- self._callCallback()
- elif line.startswith('STATE:'):
- self._state = line[6:]
- self._callCallback()
- else:
- print '>' + line.rstrip()
+ cmd = ['xdg-screensaver', 'suspend' if prevent else 'resume', str(frame.GetHandle())]
+ subprocess.call(cmd)
except:
- print sys.exc_info()
- line = p.stdout.readline()
- line = p.stderr.readline()
- while len(line) > 0:
- print '>>' + line.rstrip()
- line = p.stderr.readline()
- p.communicate()
- self.handle = None
- self.thread = None
-
- def getID(self):
- return self._id
-
- def getZ(self):
- return self._z
-
- def getState(self):
- return self._state
-
- def _callCallback(self):
- if self._callback is not None:
- self._callback()
-
-def startPrintInterface(filename):
- #startPrintInterface is called from the main script when we want the printer interface to run in a separate process.
- # It needs to run in a separate process, as any running python code blocks the GCode sender python code (http://wiki.python.org/moin/GlobalInterpreterLock).
-
- sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
-
- app = wx.App(False)
- resources.setupLocalization(profile.getPreference('language'))
- printWindowHandle = printWindow()
- printWindowHandle.Show(True)
- printWindowHandle.Raise()
- printWindowHandle.OnConnect(None)
- t = threading.Thread(target=printWindowHandle.LoadGCodeFile, args=(filename,))
- t.daemon = True
- t.start()
- app.MainLoop()
-
-class PrintCommandButton(buttons.GenBitmapButton):
- def __init__(self, parent, commandList, bitmapFilename, size=(20, 20)):
- self.bitmap = wx.Bitmap(resources.getPathForImage(bitmapFilename))
- super(PrintCommandButton, self).__init__(parent.directControlPanel, -1, self.bitmap, size=size)
-
- self.commandList = commandList
- self.parent = parent
-
- self.SetBezelWidth(1)
- self.SetUseFocusIndicator(False)
-
- self.Bind(wx.EVT_BUTTON, self.OnClick)
-
- def OnClick(self, e):
- if self.parent.machineCom is None or self.parent.machineCom.isPrinting():
- return;
- for cmd in self.commandList:
- self.parent.machineCom.sendCommand(cmd)
- e.Skip()
+ pass
+
+class printWindowPlugin(wx.Frame):
+ def __init__(self, parent, printerConnection, filename):
+ super(printWindowPlugin, self).__init__(parent, -1, style=wx.CLOSE_BOX|wx.CLIP_CHILDREN|wx.CAPTION|wx.SYSTEM_MENU|wx.FRAME_FLOAT_ON_PARENT|wx.MINIMIZE_BOX, title=_("Printing on %s") % (printerConnection.getName()))
+ self._printerConnection = printerConnection
+ self._basePath = os.path.dirname(filename)
+ self._backgroundImage = None
+ self._colorCommandMap = {}
+ self._buttonList = []
+ self._termLog = None
+ self._termInput = None
+ self._termHistory = []
+ self._termHistoryIdx = 0
+ self._progressBar = None
+ self._tempGraph = None
+ self._infoText = None
+ self._lastUpdateTime = time.time()
+ self._isPrinting = False
+
+ variables = {
+ 'setImage': self.script_setImage,
+ 'addColorCommand': self.script_addColorCommand,
+ 'addTerminal': self.script_addTerminal,
+ 'addTemperatureGraph': self.script_addTemperatureGraph,
+ 'addProgressbar': self.script_addProgressbar,
+ 'addButton': self.script_addButton,
+ 'addSpinner': self.script_addSpinner,
+ 'addTextButton': self.script_addTextButton,
+
+ 'sendGCode': self.script_sendGCode,
+ 'sendMovementGCode': self.script_sendMovementGCode,
+ 'connect': self.script_connect,
+ 'startPrint': self.script_startPrint,
+ 'pausePrint': self.script_pausePrint,
+ 'cancelPrint': self.script_cancelPrint,
+ 'showErrorLog': self.script_showErrorLog,
+ }
+ execfile(filename, variables, variables)
+
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_PAINT, self.OnDraw)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftClick)
+ self.Bind(wx.EVT_CLOSE, self.OnClose)
+
+ self._updateButtonStates()
+
+ self._printerConnection.addCallback(self._doPrinterConnectionUpdate)
+
+ if self._printerConnection.hasActiveConnection() and not self._printerConnection.isActiveConnectionOpen():
+ self._printerConnection.openActiveConnection()
+
+ def script_setImage(self, guiImage, mapImage):
+ self._backgroundImage = wx.BitmapFromImage(wx.Image(os.path.join(self._basePath, guiImage)))
+ self._mapImage = wx.Image(os.path.join(self._basePath, mapImage))
+ self.SetClientSize(self._mapImage.GetSize())
+
+ def script_addColorCommand(self, r, g, b, command, data = None):
+ self._colorCommandMap[(r, g, b)] = (command, data)
+
+ def script_addTerminal(self, r, g, b):
+ x, y, w, h = self._getColoredRect(r, g, b)
+ if x < 0 or self._termLog is not None:
+ return
+ f = wx.Font(8, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
+ self._termLog = wx.TextCtrl(self, style=wx.TE_MULTILINE | wx.TE_DONTWRAP)
+ self._termLog.SetFont(f)
+ self._termLog.SetEditable(0)
+ self._termInput = wx.TextCtrl(self, style=wx.TE_PROCESS_ENTER)
+ self._termInput.SetFont(f)
+
+ self._termLog.SetPosition((x, y))
+ self._termLog.SetSize((w, h - self._termInput.GetSize().GetHeight()))
+ self._termInput.SetPosition((x, y + h - self._termInput.GetSize().GetHeight()))
+ self._termInput.SetSize((w, self._termInput.GetSize().GetHeight()))
+ self.Bind(wx.EVT_TEXT_ENTER, self.OnTermEnterLine, self._termInput)
+ self._termInput.Bind(wx.EVT_CHAR, self.OnTermKey)
+
+ def script_addTemperatureGraph(self, r, g, b):
+ x, y, w, h = self._getColoredRect(r, g, b)
+ if x < 0 or self._tempGraph is not None:
+ return
+ self._tempGraph = TemperatureGraph(self)
+
+ self._tempGraph.SetPosition((x, y))
+ self._tempGraph.SetSize((w, h))
+
+ def script_addProgressbar(self, r, g, b):
+ x, y, w, h = self._getColoredRect(r, g, b)
+ if x < 0:
+ return
+ self._progressBar = wx.Gauge(self, -1, range=1000)
+
+ self._progressBar.SetPosition((x, y))
+ self._progressBar.SetSize((w, h))
+
+ def script_addButton(self, r, g, b, text, command, data = None):
+ x, y, w, h = self._getColoredRect(r, g, b)
+ if x < 0:
+ return
+ button = wx.Button(self, -1, _(text))
+ button.SetPosition((x, y))
+ button.SetSize((w, h))
+ button.command = command
+ button.data = data
+ self._buttonList.append(button)
+ self.Bind(wx.EVT_BUTTON, lambda e: command(data), button)
+
+ def script_addSpinner(self, r, g, b, command, data):
+ x, y, w, h = self._getColoredRect(r, g, b)
+ if x < 0:
+ return
+
+ def run_command(spinner):
+ value = spinner.GetValue()
+ print "Value (%s) and (%s)" % (spinner.last_value, value)
+ if spinner.last_value != '' and value != 0:
+ spinner.command(spinner.data % value)
+ spinner.last_value = value
+
+ spinner = wx.SpinCtrl(self, -1, style=wx.TE_PROCESS_ENTER)
+ spinner.SetRange(0, 300)
+ spinner.SetPosition((x, y))
+ spinner.SetSize((w, h))
+ spinner.SetValue(0)
+ spinner.command = command
+ spinner.data = data
+ spinner.last_value = ''
+ self._buttonList.append(spinner)
+ self.Bind(wx.EVT_SPINCTRL, lambda e: run_command(spinner), spinner)
+
+ def script_addTextButton(self, r_text, g_text, b_text, r_button, g_button, b_button, button_text, command, data):
+ x_text, y_text, w_text, h_text = self._getColoredRect(r_text, g_text, b_text)
+ if x_text < 0:
+ return
+ x_button, y_button, w_button, h_button = self._getColoredRect(r_button, g_button, b_button)
+ if x_button < 0:
+ return
+ from wx.lib.intctrl import IntCtrl
+ text = IntCtrl(self, -1)
+ text.SetBounds(0, 300)
+ text.SetPosition((x_text, y_text))
+ text.SetSize((w_text, h_text))
+
+ button = wx.Button(self, -1, _(button_text))
+ button.SetPosition((x_button, y_button))
+ button.SetSize((w_button, h_button))
+ button.command = command
+ button.data = data
+ self._buttonList.append(button)
+ self.Bind(wx.EVT_BUTTON, lambda e: command(data % text.GetValue()), button)
+
+ def _getColoredRect(self, r, g, b):
+ for x in xrange(0, self._mapImage.GetWidth()):
+ for y in xrange(0, self._mapImage.GetHeight()):
+ if self._mapImage.GetRed(x, y) == r and self._mapImage.GetGreen(x, y) == g and self._mapImage.GetBlue(x, y) == b:
+ w = 0
+ while x+w < self._mapImage.GetWidth() and self._mapImage.GetRed(x + w, y) == r and self._mapImage.GetGreen(x + w, y) == g and self._mapImage.GetBlue(x + w, y) == b:
+ w += 1
+ h = 0
+ while y+h < self._mapImage.GetHeight() and self._mapImage.GetRed(x, y + h) == r and self._mapImage.GetGreen(x, y + h) == g and self._mapImage.GetBlue(x, y + h) == b:
+ h += 1
+ return x, y, w, h
+ print "Failed to find color: ", r, g, b
+ return -1, -1, 1, 1
+
+ def script_sendGCode(self, data = None):
+ for line in data.split(';'):
+ line = line.strip()
+ if len(line) > 0:
+ self._printerConnection.sendCommand(line)
+
+ def script_sendMovementGCode(self, data = None):
+ if not self._printerConnection.isPaused() and not self._printerConnection.isPrinting():
+ self.script_sendGCode(data)
+
+ def script_connect(self, data = None):
+ self._printerConnection.openActiveConnection()
+
+ def script_startPrint(self, data = None):
+ if self._printerConnection.isPrinting() or self._printerConnection.isPaused():
+ self._printerConnection.pause(not self._printerConnection.isPaused())
+ else:
+ self._printerConnection.startPrint()
+
+ def script_cancelPrint(self, e):
+ self._printerConnection.cancelPrint()
+
+ def script_pausePrint(self, e):
+ self._printerConnection.pause(not self._printerConnection.isPaused())
+
+ def script_showErrorLog(self, e):
+ LogWindow(self._printerConnection.getErrorLog())
+
+ def OnEraseBackground(self, e):
+ pass
+
+ def OnDraw(self, e):
+ dc = wx.BufferedPaintDC(self, self._backgroundImage)
+ def OnLeftClick(self, e):
+ r = self._mapImage.GetRed(e.GetX(), e.GetY())
+ g = self._mapImage.GetGreen(e.GetX(), e.GetY())
+ b = self._mapImage.GetBlue(e.GetX(), e.GetY())
+ if (r, g, b) in self._colorCommandMap:
+ command = self._colorCommandMap[(r, g, b)]
+ command[0](command[1])
-class printWindow(wx.Frame):
- "Main user interface window"
+ def OnClose(self, e):
+ if self._printerConnection.hasActiveConnection():
+ if self._printerConnection.isPrinting() or self._printerConnection.isPaused():
+ pass #TODO: Give warning that the close will kill the print.
+ self._printerConnection.closeActiveConnection()
+ self._printerConnection.removeCallback(self._doPrinterConnectionUpdate)
+ #TODO: When multiple printer windows are open, closing one will enable sleeping again.
+ preventComputerFromSleeping(self, False)
+ self._printerConnection.cancelPrint()
+ self.Destroy()
+
+ def OnTermEnterLine(self, e):
+ if not self._printerConnection.isAbleToSendDirectCommand():
+ return
+ line = self._termInput.GetValue()
+ if line == '':
+ return
+ self._addTermLog('> %s\n' % (line))
+ self._printerConnection.sendCommand(line)
+ self._termHistory.append(line)
+ self._termHistoryIdx = len(self._termHistory)
+ self._termInput.SetValue('')
+
+ def OnTermKey(self, e):
+ if len(self._termHistory) > 0:
+ if e.GetKeyCode() == wx.WXK_UP:
+ self._termHistoryIdx -= 1
+ if self._termHistoryIdx < 0:
+ self._termHistoryIdx = len(self._termHistory) - 1
+ self._termInput.SetValue(self._termHistory[self._termHistoryIdx])
+ if e.GetKeyCode() == wx.WXK_DOWN:
+ self._termHistoryIdx -= 1
+ if self._termHistoryIdx >= len(self._termHistory):
+ self._termHistoryIdx = 0
+ self._termInput.SetValue(self._termHistory[self._termHistoryIdx])
+ e.Skip()
+
+ def _addTermLog(self, line):
+ if self._termLog is not None:
+ if len(self._termLog.GetValue()) > 10000:
+ self._termLog.SetValue(self._termLog.GetValue()[-10000:])
+ self._termLog.SetInsertionPointEnd()
+ if type(line) != unicode:
+ line = unicode(line, 'utf-8', 'replace')
+ self._termLog.AppendText(line.encode('utf-8', 'replace'))
+
+ def _updateButtonStates(self):
+ hasPauseButton = False
+ for button in self._buttonList:
+ if button.command == self.script_pausePrint:
+ hasPauseButton = True
+ break
+
+ for button in self._buttonList:
+ if button.command == self.script_connect:
+ button.Show(self._printerConnection.hasActiveConnection())
+ button.Enable(not self._printerConnection.isActiveConnectionOpen() and \
+ not self._printerConnection.isActiveConnectionOpening())
+ elif button.command == self.script_pausePrint:
+ button.Show(self._printerConnection.hasPause())
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ button.Enable(self._printerConnection.isPrinting() or \
+ self._printerConnection.isPaused())
+ if self._printerConnection.isPaused():
+ button.SetLabel(_("Resume"))
+ else:
+ button.SetLabel(_("Pause"))
+ else:
+ button.Enable(False)
+ elif button.command == self.script_startPrint:
+ if hasPauseButton or not self._printerConnection.hasPause():
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ button.Enable(not self._printerConnection.isPrinting() and \
+ not self._printerConnection.isPaused())
+ else:
+ button.Enable(False)
+ else:
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ if self._printerConnection.isPrinting():
+ button.SetLabel(_("Pause"))
+ else:
+ if self._printerConnection.isPaused():
+ button.SetLabel(_("Resume"))
+ else:
+ button.SetLabel(_("Print"))
+ button.Enable(True)
+ else:
+ button.Enable(False)
+ elif button.command == self.script_cancelPrint:
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ button.Enable(self._printerConnection.isPrinting() or \
+ self._printerConnection.isPaused())
+ else:
+ button.Enable(False)
+ elif button.command == self.script_showErrorLog:
+ button.Show(self._printerConnection.isInErrorState())
+ if self._termInput is not None:
+ self._termInput.Enable(self._printerConnection.isAbleToSendDirectCommand())
+
+ def _doPrinterConnectionUpdate(self, connection, extraInfo = None):
+ wx.CallAfter(self.__doPrinterConnectionUpdate, connection, extraInfo)
+ if self._tempGraph is not None:
+ temp = []
+ for n in xrange(0, 4):
+ t = connection.getTemperature(0)
+ if t is not None:
+ temp.append(t)
+ else:
+ break
+ self._tempGraph.addPoint(temp, [0] * len(temp), connection.getBedTemperature(), 0)
- def __init__(self):
- super(printWindow, self).__init__(None, -1, title=_("Printing"))
+ def __doPrinterConnectionUpdate(self, connection, extraInfo):
t = time.time()
- self.machineCom = None
- self.gcode = None
- self.gcodeList = None
- self.sendList = []
- self.temp = None
- self.bedTemp = None
- self.bufferLineCount = 4
- self.sendCnt = 0
- self.feedrateRatioOuterWall = 1.0
- self.feedrateRatioInnerWall = 1.0
- self.feedrateRatioFill = 1.0
- self.feedrateRatioSupport = 1.0
- self.pause = False
- self.termHistory = []
- self.termHistoryIdx = 0
-
- self.cam = None
+ if self._lastUpdateTime + 0.5 > t and extraInfo is None:
+ return
+ self._lastUpdateTime = t
+
+ if extraInfo is not None and len(extraInfo) > 0:
+ self._addTermLog('< %s\n' % (extraInfo))
+
+ self._updateButtonStates()
+ isPrinting = connection.isPrinting() or connection.isPaused()
+ if self._progressBar is not None:
+ if isPrinting:
+ self._progressBar.SetValue(connection.getPrintProgress() * 1000)
+ else:
+ self._progressBar.SetValue(0)
+ info = connection.getStatusString()
+ info += '\n'
+ if self._printerConnection.getTemperature(0) is not None:
+ info += 'Temperature: %d' % (self._printerConnection.getTemperature(0))
+ if self._printerConnection.getBedTemperature() > 0:
+ info += ' Bed: %d' % (self._printerConnection.getBedTemperature())
+ if self._infoText is not None:
+ self._infoText.SetLabel(info)
+ else:
+ self.SetTitle(info.replace('\n', ', ').strip().strip(','))
+ if isPrinting != self._isPrinting:
+ self._isPrinting = isPrinting
+ preventComputerFromSleeping(self, self._isPrinting)
+
+class printWindowBasic(wx.Frame):
+ """
+ Printing window for USB printing, network printing, and any other type of printer connection we can think off.
+ This is only a basic window with minimal information.
+ """
+ def __init__(self, parent, printerConnection):
+ super(printWindowBasic, self).__init__(parent, -1, style=wx.CLOSE_BOX|wx.CLIP_CHILDREN|wx.CAPTION|wx.SYSTEM_MENU|wx.FRAME_TOOL_WINDOW|wx.FRAME_FLOAT_ON_PARENT, title=_("Printing on %s") % (printerConnection.getName()))
+ self._printerConnection = printerConnection
+ self._lastUpdateTime = 0
+ self._isPrinting = False
self.SetSizer(wx.BoxSizer())
self.panel = wx.Panel(self)
self.sizer = wx.GridBagSizer(2, 2)
self.panel.SetSizer(self.sizer)
- sb = wx.StaticBox(self.panel, label=_("Statistics"))
- boxsizer = wx.StaticBoxSizer(sb, wx.VERTICAL)
-
self.powerWarningText = wx.StaticText(parent=self.panel,
id=-1,
label=_("Your computer is running on battery power.\nConnect your computer to AC power or your print might not finish."),
style=wx.ALIGN_CENTER)
self.powerWarningText.SetBackgroundColour('red')
self.powerWarningText.SetForegroundColour('white')
- boxsizer.AddF(self.powerWarningText, flags=wx.SizerFlags().Expand().Border(wx.BOTTOM, 10))
self.powerManagement = power.PowerManagement()
self.powerWarningTimer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.OnPowerWarningChange, self.powerWarningTimer)
self.OnPowerWarningChange(None)
self.powerWarningTimer.Start(10000)
- self.statsText = wx.StaticText(self.panel, -1, _("Filament: ####.##m #.##g\nEstimated print time: #####:##\nMachine state:\nDetecting baudrateXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
- boxsizer.Add(self.statsText, flag=wx.LEFT, border=5)
-
- self.sizer.Add(boxsizer, pos=(0, 0), span=(7, 1), flag=wx.EXPAND)
+ self.statsText = wx.StaticText(self.panel, -1, _("InfoLine from printer connection\nInfoLine from dialog\nExtra line\nMore lines for layout\nMore lines for layout\nMore lines for layout"))
self.connectButton = wx.Button(self.panel, -1, _("Connect"))
#self.loadButton = wx.Button(self.panel, -1, 'Load')
self.printButton = wx.Button(self.panel, -1, _("Print"))
self.pauseButton = wx.Button(self.panel, -1, _("Pause"))
self.cancelButton = wx.Button(self.panel, -1, _("Cancel print"))
- self.machineLogButton = wx.Button(self.panel, -1, _("Error log"))
- self.progress = wx.Gauge(self.panel, -1)
-
- self.sizer.Add(self.connectButton, pos=(1, 1), flag=wx.EXPAND)
- #self.sizer.Add(self.loadButton, pos=(1,1), flag=wx.EXPAND)
- self.sizer.Add(self.printButton, pos=(2, 1), flag=wx.EXPAND)
- self.sizer.Add(self.pauseButton, pos=(3, 1), flag=wx.EXPAND)
- self.sizer.Add(self.cancelButton, pos=(4, 1), flag=wx.EXPAND)
- self.sizer.Add(self.machineLogButton, pos=(5, 1), flag=wx.EXPAND)
- self.sizer.Add(self.progress, pos=(7, 0), span=(1, 7), flag=wx.EXPAND)
-
- nb = wx.Notebook(self.panel)
- self.tabs = nb
- self.sizer.Add(nb, pos=(0, 2), span=(7, 4), flag=wx.EXPAND)
-
- self.temperaturePanel = wx.Panel(nb)
- sizer = wx.GridBagSizer(2, 2)
- self.temperaturePanel.SetSizer(sizer)
-
- self.temperatureSelect = wx.SpinCtrl(self.temperaturePanel, -1, '0', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.temperatureSelect.SetRange(0, 400)
- self.temperatureHeatUp = wx.Button(self.temperaturePanel, -1, str(int(profile.getProfileSettingFloat('print_temperature'))) + 'C')
- self.bedTemperatureLabel = wx.StaticText(self.temperaturePanel, -1, _("BedTemp:"))
- self.bedTemperatureSelect = wx.SpinCtrl(self.temperaturePanel, -1, '0', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.bedTemperatureSelect.SetRange(0, 400)
- self.bedTemperatureLabel.Show(False)
- self.bedTemperatureSelect.Show(False)
-
- self.temperatureGraph = temperatureGraph(self.temperaturePanel)
-
- sizer.Add(wx.StaticText(self.temperaturePanel, -1, _("Temp:")), pos=(0, 0))
- sizer.Add(self.temperatureSelect, pos=(0, 1))
- sizer.Add(self.temperatureHeatUp, pos=(0, 2))
- sizer.Add(self.bedTemperatureLabel, pos=(1, 0))
- sizer.Add(self.bedTemperatureSelect, pos=(1, 1))
- sizer.Add(self.temperatureGraph, pos=(2, 0), span=(1, 3), flag=wx.EXPAND)
- sizer.AddGrowableRow(2)
- sizer.AddGrowableCol(2)
-
- nb.AddPage(self.temperaturePanel, 'Temp')
-
- self.directControlPanel = wx.Panel(nb)
-
- sizer = wx.GridBagSizer(2, 2)
- self.directControlPanel.SetSizer(sizer)
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y100 F6000', 'G90'], 'print-move-y100.png'), pos=(0, 3))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y10 F6000', 'G90'], 'print-move-y10.png'), pos=(1, 3))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y1 F6000', 'G90'], 'print-move-y1.png'), pos=(2, 3))
-
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y-1 F6000', 'G90'], 'print-move-y-1.png'), pos=(4, 3))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y-10 F6000', 'G90'], 'print-move-y-10.png'), pos=(5, 3))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Y-100 F6000', 'G90'], 'print-move-y-100.png'), pos=(6, 3))
-
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X-100 F6000', 'G90'], 'print-move-x-100.png'), pos=(3, 0))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X-10 F6000', 'G90'], 'print-move-x-10.png'), pos=(3, 1))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X-1 F6000', 'G90'], 'print-move-x-1.png'), pos=(3, 2))
-
- sizer.Add(PrintCommandButton(self, ['G28 X0 Y0'], 'print-move-home.png'), pos=(3, 3))
-
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X1 F6000', 'G90'], 'print-move-x1.png'), pos=(3, 4))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X10 F6000', 'G90'], 'print-move-x10.png'), pos=(3, 5))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 X100 F6000', 'G90'], 'print-move-x100.png'), pos=(3, 6))
-
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z10 F200', 'G90'], 'print-move-z10.png'), pos=(0, 8))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z1 F200', 'G90'], 'print-move-z1.png'), pos=(1, 8))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z0.1 F200', 'G90'], 'print-move-z0.1.png'), pos=(2, 8))
-
- sizer.Add(PrintCommandButton(self, ['G28 Z0'], 'print-move-home.png'), pos=(3, 8))
-
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z-0.1 F200', 'G90'], 'print-move-z-0.1.png'), pos=(4, 8))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z-1 F200', 'G90'], 'print-move-z-1.png'), pos=(5, 8))
- sizer.Add(PrintCommandButton(self, ['G91', 'G1 Z-10 F200', 'G90'], 'print-move-z-10.png'), pos=(6, 8))
-
- sizer.Add(PrintCommandButton(self, ['G92 E0', 'G1 E2 F120'], 'extrude.png', size=(60, 20)), pos=(1, 10),
- span=(1, 3), flag=wx.EXPAND)
- sizer.Add(PrintCommandButton(self, ['G92 E0', 'G1 E-2 F120'], 'retract.png', size=(60, 20)), pos=(2, 10),
- span=(1, 3), flag=wx.EXPAND)
-
- nb.AddPage(self.directControlPanel, _("Jog"))
-
- self.speedPanel = wx.Panel(nb)
- sizer = wx.GridBagSizer(2, 2)
- self.speedPanel.SetSizer(sizer)
-
- self.outerWallSpeedSelect = wx.SpinCtrl(self.speedPanel, -1, '100', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.outerWallSpeedSelect.SetRange(5, 1000)
- self.innerWallSpeedSelect = wx.SpinCtrl(self.speedPanel, -1, '100', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.innerWallSpeedSelect.SetRange(5, 1000)
- self.fillSpeedSelect = wx.SpinCtrl(self.speedPanel, -1, '100', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.fillSpeedSelect.SetRange(5, 1000)
- self.supportSpeedSelect = wx.SpinCtrl(self.speedPanel, -1, '100', size=(21 * 3, 21), style=wx.SP_ARROW_KEYS)
- self.supportSpeedSelect.SetRange(5, 1000)
-
- sizer.Add(wx.StaticText(self.speedPanel, -1, _("Outer wall:")), pos=(0, 0))
- sizer.Add(self.outerWallSpeedSelect, pos=(0, 1))
- sizer.Add(wx.StaticText(self.speedPanel, -1, "%"), pos=(0, 2))
- sizer.Add(wx.StaticText(self.speedPanel, -1, _("Inner wall:")), pos=(1, 0))
- sizer.Add(self.innerWallSpeedSelect, pos=(1, 1))
- sizer.Add(wx.StaticText(self.speedPanel, -1, "%"), pos=(1, 2))
- sizer.Add(wx.StaticText(self.speedPanel, -1, _("Fill:")), pos=(2, 0))
- sizer.Add(self.fillSpeedSelect, pos=(2, 1))
- sizer.Add(wx.StaticText(self.speedPanel, -1, "%"), pos=(2, 2))
- sizer.Add(wx.StaticText(self.speedPanel, -1, _("Support:")), pos=(3, 0))
- sizer.Add(self.supportSpeedSelect, pos=(3, 1))
- sizer.Add(wx.StaticText(self.speedPanel, -1, "%"), pos=(3, 2))
-
- nb.AddPage(self.speedPanel, _("Speed"))
-
- self.termPanel = wx.Panel(nb)
- sizer = wx.GridBagSizer(2, 2)
- self.termPanel.SetSizer(sizer)
-
- f = wx.Font(8, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
- self.termLog = wx.TextCtrl(self.termPanel, style=wx.TE_MULTILINE | wx.TE_DONTWRAP)
- self.termLog.SetFont(f)
- self.termLog.SetEditable(0)
- self.termInput = wx.TextCtrl(self.termPanel, style=wx.TE_PROCESS_ENTER)
- self.termInput.SetFont(f)
-
- sizer.Add(self.termLog, pos=(0, 0), flag=wx.EXPAND)
- sizer.Add(self.termInput, pos=(1, 0), flag=wx.EXPAND)
- sizer.AddGrowableCol(0)
- sizer.AddGrowableRow(0)
-
- nb.AddPage(self.termPanel, _("Term"))
-
- self.sizer.AddGrowableRow(6)
- self.sizer.AddGrowableCol(3)
+ self.errorLogButton = wx.Button(self.panel, -1, _("Error log"))
+ self.progress = wx.Gauge(self.panel, -1, range=1000)
+
+ self.sizer.Add(self.powerWarningText, pos=(0, 0), span=(1, 5), flag=wx.EXPAND|wx.BOTTOM, border=5)
+ self.sizer.Add(self.statsText, pos=(1, 0), span=(1, 5), flag=wx.LEFT, border=5)
+ self.sizer.Add(self.connectButton, pos=(2, 0))
+ #self.sizer.Add(self.loadButton, pos=(2,1))
+ self.sizer.Add(self.printButton, pos=(2, 1))
+ self.sizer.Add(self.pauseButton, pos=(2, 2))
+ self.sizer.Add(self.cancelButton, pos=(2, 3))
+ self.sizer.Add(self.errorLogButton, pos=(2, 4))
+ self.sizer.Add(self.progress, pos=(3, 0), span=(1, 5), flag=wx.EXPAND)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.connectButton.Bind(wx.EVT_BUTTON, self.OnConnect)
self.printButton.Bind(wx.EVT_BUTTON, self.OnPrint)
self.pauseButton.Bind(wx.EVT_BUTTON, self.OnPause)
self.cancelButton.Bind(wx.EVT_BUTTON, self.OnCancel)
- self.machineLogButton.Bind(wx.EVT_BUTTON, self.OnMachineLog)
-
- self.Bind(wx.EVT_BUTTON, lambda e: (self.temperatureSelect.SetValue(int(profile.getProfileSettingFloat('print_temperature'))), self.machineCom.sendCommand("M104 S%d" % (int(profile.getProfileSettingFloat('print_temperature'))))), self.temperatureHeatUp)
- self.Bind(wx.EVT_SPINCTRL, self.OnTempChange, self.temperatureSelect)
- self.Bind(wx.EVT_SPINCTRL, self.OnBedTempChange, self.bedTemperatureSelect)
-
- self.Bind(wx.EVT_SPINCTRL, self.OnSpeedChange, self.outerWallSpeedSelect)
- self.Bind(wx.EVT_SPINCTRL, self.OnSpeedChange, self.innerWallSpeedSelect)
- self.Bind(wx.EVT_SPINCTRL, self.OnSpeedChange, self.fillSpeedSelect)
- self.Bind(wx.EVT_SPINCTRL, self.OnSpeedChange, self.supportSpeedSelect)
- self.Bind(wx.EVT_TEXT_ENTER, self.OnTermEnterLine, self.termInput)
- self.termInput.Bind(wx.EVT_CHAR, self.OnTermKey)
+ self.errorLogButton.Bind(wx.EVT_BUTTON, self.OnErrorLog)
self.Layout()
self.Fit()
self.Centre()
- self.statsText.SetMinSize(self.statsText.GetSize())
-
- self.UpdateButtonStates()
-
- #self.UpdateProgress()
- self._thread = threading.Thread(target=self._stdinMonitor)
- self._thread.daemon = True
- self._thread.start()
-
- if webcam.hasWebcamSupport():
- #Need to call the camera class on the GUI thread, or else it won't work. Shame as it hangs the GUI for about 2 seconds.
- wx.CallAfter(self._webcamCheck)
-
- def _stdinMonitor(self):
- while True:
- line = sys.stdin.readline().rstrip()
- if line.startswith('LOAD:'):
- if not self.LoadGCodeFile(line[5:]):
- print 'LOADFAILED\n'
-
- def _webcamCheck(self):
- self.cam = webcam.webcam()
- if self.cam.hasCamera():
- self.camPage = wx.Panel(self.tabs)
- sizer = wx.GridBagSizer(2, 2)
- self.camPage.SetSizer(sizer)
-
- self.timelapsEnable = wx.CheckBox(self.camPage, -1, _("Enable timelapse movie recording"))
- self.timelapsSavePath = wx.TextCtrl(self.camPage, -1, os.path.expanduser('~/timelaps_' + datetime.datetime.now().strftime('%Y-%m-%d_%H-%M') + '.mpg'))
- sizer.Add(self.timelapsEnable, pos=(0, 0), span=(1, 2), flag=wx.EXPAND)
- sizer.Add(self.timelapsSavePath, pos=(1, 0), span=(1, 2), flag=wx.EXPAND)
-
- pages = self.cam.propertyPages()
- self.cam.buttons = [self.timelapsEnable, self.timelapsSavePath]
- for page in pages:
- button = wx.Button(self.camPage, -1, page)
- button.index = pages.index(page)
- sizer.Add(button, pos=(2, pages.index(page)))
- button.Bind(wx.EVT_BUTTON, self.OnPropertyPageButton)
- self.cam.buttons.append(button)
-
- self.campreviewEnable = wx.CheckBox(self.camPage, -1, _("Show preview"))
- sizer.Add(self.campreviewEnable, pos=(3, 0), span=(1, 2), flag=wx.EXPAND)
-
- self.camPreview = wx.Panel(self.camPage)
- sizer.Add(self.camPreview, pos=(4, 0), span=(1, 2), flag=wx.EXPAND)
-
- self.tabs.AddPage(self.camPage, _("Camera"))
- self.camPreview.timer = wx.Timer(self)
- self.Bind(wx.EVT_TIMER, self.OnCameraTimer, self.camPreview.timer)
- self.camPreview.timer.Start(500)
- self.camPreview.Bind(wx.EVT_ERASE_BACKGROUND, self.OnCameraEraseBackground)
- else:
- self.cam = None
+ self.progress.SetMinSize(self.progress.GetSize())
+ self.statsText.SetLabel('\n\n\n\n\n\n')
+ self._updateButtonStates()
- def OnCameraTimer(self, e):
- if not self.campreviewEnable.GetValue():
- return
- if self.machineCom is not None and self.machineCom.isPrinting():
- return
- self.cam.takeNewImage()
- self.camPreview.Refresh()
-
- def OnCameraEraseBackground(self, e):
- dc = e.GetDC()
- if not dc:
- dc = wx.ClientDC(self)
- rect = self.GetUpdateRegion().GetBox()
- dc.SetClippingRect(rect)
- dc.SetBackground(wx.Brush(self.camPreview.GetBackgroundColour(), wx.SOLID))
- if self.cam.getLastImage() is not None:
- self.camPreview.SetMinSize((self.cam.getLastImage().GetWidth(), self.cam.getLastImage().GetHeight()))
- self.camPage.Fit()
- dc.DrawBitmap(self.cam.getLastImage(), 0, 0)
- else:
- dc.Clear()
-
- def OnPropertyPageButton(self, e):
- self.cam.openPropertyPage(e.GetEventObject().index)
-
- def UpdateButtonStates(self):
- self.connectButton.Enable(self.machineCom is None or self.machineCom.isClosedOrError())
- #self.loadButton.Enable(self.machineCom == None or not (self.machineCom.isPrinting() or self.machineCom.isPaused()))
- self.printButton.Enable(self.machineCom is not None and self.machineCom.isOperational() and not (
- self.machineCom.isPrinting() or self.machineCom.isPaused()))
- self.temperatureHeatUp.Enable(self.machineCom is not None and self.machineCom.isOperational() and not (
- self.machineCom.isPrinting() or self.machineCom.isPaused()))
- self.pauseButton.Enable(
- self.machineCom is not None and (self.machineCom.isPrinting() or self.machineCom.isPaused()))
- if self.machineCom is not None and self.machineCom.isPaused():
- self.pauseButton.SetLabel(_("Resume"))
- else:
- self.pauseButton.SetLabel(_("Pause"))
- self.cancelButton.Enable(
- self.machineCom is not None and (self.machineCom.isPrinting() or self.machineCom.isPaused()))
- self.temperatureSelect.Enable(self.machineCom is not None and self.machineCom.isOperational())
- self.bedTemperatureSelect.Enable(self.machineCom is not None and self.machineCom.isOperational())
- self.directControlPanel.Enable(
- self.machineCom is not None and self.machineCom.isOperational() and not self.machineCom.isPrinting())
- self.machineLogButton.Show(self.machineCom is not None and self.machineCom.isClosedOrError())
- if self.cam is not None:
- for button in self.cam.buttons:
- button.Enable(self.machineCom is None or not self.machineCom.isPrinting())
-
- def UpdateProgress(self):
- status = ""
- if self.gcode is None:
- status += _("Loading gcode...\n")
- else:
- status += _("Filament: %(amount).2fm %(weight).2fg\n") % {'amount': self.gcode.extrusionAmount / 1000, 'weight': self.gcode.calculateWeight() * 1000}
- cost = self.gcode.calculateCost()
- if cost is not None:
- status += _("Filament cost: %s\n") % (cost)
- #status += "Estimated print time: %02d:%02d\n" % (int(self.gcode.totalMoveTimeMinute / 60), int(self.gcode.totalMoveTimeMinute % 60))
- if self.machineCom is None or not self.machineCom.isPrinting():
- self.progress.SetValue(0)
- if self.gcodeList is not None:
- status += 'Line: -/%d\n' % (len(self.gcodeList))
- else:
- printTime = self.machineCom.getPrintTime() / 60
- printTimeLeft = self.machineCom.getPrintTimeRemainingEstimate()
- status += 'Line: %d/%d %d%%\n' % (self.machineCom.getPrintPos(), len(self.gcodeList),
- self.machineCom.getPrintPos() * 100 / len(self.gcodeList))
- if self.currentZ > 0:
- status += 'Height: %0.1f\n' % (self.currentZ)
- status += 'Print time: %02d:%02d\n' % (int(printTime / 60), int(printTime % 60))
- if printTimeLeft is None:
- status += 'Print time left: Unknown\n'
- else:
- status += 'Print time left: %02d:%02d\n' % (int(printTimeLeft / 60), int(printTimeLeft % 60))
- self.progress.SetValue(self.machineCom.getPrintPos())
- taskbar.setProgress(self, self.machineCom.getPrintPos(), len(self.gcodeList))
- if self.machineCom is not None:
- if self.machineCom.getTemp() > 0:
- status += 'Temp: %s\n' % (' ,'.join(map(str, self.machineCom.getTemp())))
- if self.machineCom.getBedTemp() > 0:
- status += 'Bed Temp: %d\n' % (self.machineCom.getBedTemp())
- self.bedTemperatureLabel.Show(True)
- self.bedTemperatureSelect.Show(True)
- self.temperaturePanel.Layout()
- status += 'Machine state:%s\n' % (self.machineCom.getStateString())
-
- self.statsText.SetLabel(status.strip())
+ self._printerConnection.addCallback(self._doPrinterConnectionUpdate)
+
+ if self._printerConnection.hasActiveConnection() and not self._printerConnection.isActiveConnectionOpen():
+ self._printerConnection.openActiveConnection()
+
+ def OnPowerWarningChange(self, e):
+ type = self.powerManagement.get_providing_power_source_type()
+ if type == power.POWER_TYPE_AC and self.powerWarningText.IsShown():
+ self.powerWarningText.Hide()
+ self.panel.Layout()
+ self.Layout()
+ self.Fit()
+ self.Refresh()
+ elif type != power.POWER_TYPE_AC and not self.powerWarningText.IsShown():
+ self.powerWarningText.Show()
+ self.panel.Layout()
+ self.Layout()
+ self.Fit()
+ self.Refresh()
+
+ def OnClose(self, e):
+ if self._printerConnection.hasActiveConnection():
+ if self._printerConnection.isPrinting() or self._printerConnection.isPaused():
+ pass #TODO: Give warning that the close will kill the print.
+ self._printerConnection.closeActiveConnection()
+ self._printerConnection.removeCallback(self._doPrinterConnectionUpdate)
+ #TODO: When multiple printer windows are open, closing one will enable sleeping again.
+ preventComputerFromSleeping(self, False)
+ self.Destroy()
def OnConnect(self, e):
- if self.machineCom is not None:
- self.machineCom.close()
- self.machineCom = machineCom.MachineCom(callbackObject=self)
- self.UpdateButtonStates()
- taskbar.setBusy(self, True)
+ self._printerConnection.openActiveConnection()
def OnLoad(self, e):
pass
def OnPrint(self, e):
- if self.machineCom is None or not self.machineCom.isOperational():
- return
- if self.gcodeList is None:
- return
- if self.machineCom.isPrinting():
- return
- self.currentZ = -1
- if self.cam is not None and self.timelapsEnable.GetValue():
- self.cam.startTimelapse(self.timelapsSavePath.GetValue())
- self.machineCom.printGCode(self.gcodeList)
- self.UpdateButtonStates()
+ self._printerConnection.startPrint()
def OnCancel(self, e):
- self.pauseButton.SetLabel('Pause')
- self.machineCom.cancelPrint()
- self.machineCom.sendCommand("M84")
- self.machineCom.sendCommand("M104 S0")
- self.UpdateButtonStates()
+ self._printerConnection.cancelPrint()
def OnPause(self, e):
- if self.machineCom.isPaused():
- self.machineCom.setPause(False)
+ self._printerConnection.pause(not self._printerConnection.isPaused())
+
+ def OnErrorLog(self, e):
+ LogWindow(self._printerConnection.getErrorLog())
+
+ def _doPrinterConnectionUpdate(self, connection, extraInfo = None):
+ wx.CallAfter(self.__doPrinterConnectionUpdate, connection, extraInfo)
+ #temp = [connection.getTemperature(0)]
+ #self.temperatureGraph.addPoint(temp, [0], connection.getBedTemperature(), 0)
+
+ def __doPrinterConnectionUpdate(self, connection, extraInfo):
+ now = time.time()
+ if self._lastUpdateTime + 0.5 > now and extraInfo is None:
+ return
+ self._lastUpdateTime = now
+
+ if extraInfo is not None and len(extraInfo) > 0:
+ self._addTermLog('< %s\n' % (extraInfo))
+
+ self._updateButtonStates()
+ onGoingPrint = connection.isPrinting() or connection.isPaused()
+ if onGoingPrint:
+ self.progress.SetValue(connection.getPrintProgress() * 1000)
else:
- self.machineCom.setPause(True)
+ self.progress.SetValue(0)
+ info = connection.getStatusString()
+ info += '\n'
+ if self._printerConnection.getTemperature(0) is not None:
+ info += 'Temperature: %d' % (self._printerConnection.getTemperature(0))
+ if self._printerConnection.getBedTemperature() > 0:
+ info += ' Bed: %d' % (self._printerConnection.getBedTemperature())
+ info += '\n\n'
+ self.statsText.SetLabel(info)
+ if onGoingPrint != self._isPrinting:
+ self._isPrinting = onGoingPrint
+ preventComputerFromSleeping(self, self._isPrinting)
+
+ def _addTermLog(self, msg):
+ pass
- def OnMachineLog(self, e):
- LogWindow('\n'.join(self.machineCom.getLog()))
+ def _updateButtonStates(self):
+ self.connectButton.Show(self._printerConnection.hasActiveConnection())
+ self.connectButton.Enable(not self._printerConnection.isActiveConnectionOpen() and not self._printerConnection.isActiveConnectionOpening())
+ self.pauseButton.Show(self._printerConnection.hasPause())
+ if not self._printerConnection.hasActiveConnection() or self._printerConnection.isActiveConnectionOpen():
+ self.printButton.Enable(not self._printerConnection.isPrinting() and \
+ not self._printerConnection.isPaused())
+ self.pauseButton.Enable(self._printerConnection.isPrinting())
+ self.cancelButton.Enable(self._printerConnection.isPrinting())
+ else:
+ self.printButton.Enable(False)
+ self.pauseButton.Enable(False)
+ self.cancelButton.Enable(False)
+ self.errorLogButton.Show(self._printerConnection.isInErrorState())
+
+class printWindowAdvanced(wx.Frame):
+ def __init__(self, parent, printerConnection):
+ super(printWindowAdvanced, self).__init__(parent, -1, style=wx.CLOSE_BOX|wx.CLIP_CHILDREN|wx.CAPTION|wx.SYSTEM_MENU|wx.FRAME_FLOAT_ON_PARENT|wx.MINIMIZE_BOX, title=_("Printing on %s") % (printerConnection.getName()))
+ self._printerConnection = printerConnection
+ self._lastUpdateTime = time.time()
+ self._isPrinting = False
+
+ self.SetSizer(wx.BoxSizer(wx.VERTICAL))
+ self.toppanel = wx.Panel(self)
+ self.topsizer = wx.GridBagSizer(2, 2)
+ self.toppanel.SetSizer(self.topsizer)
+ self.toppanel.SetBackgroundColour(wx.WHITE)
+ self.topsizer.SetEmptyCellSize((125, 1))
+ self.panel = wx.Panel(self)
+ self.sizer = wx.GridBagSizer(2, 2)
+ self.sizer.SetEmptyCellSize((125, 1))
+ self.panel.SetSizer(self.sizer)
+ self.panel.SetBackgroundColour(wx.WHITE)
+ self.GetSizer().Add(self.toppanel, 0, flag=wx.EXPAND)
+ self.GetSizer().Add(self.panel, 1, flag=wx.EXPAND)
- def OnClose(self, e):
- global printWindowHandle
- printWindowHandle = None
- if self.machineCom is not None:
- self.machineCom.close()
- self.Destroy()
+ self._fullscreenTemperature = None
+ self._termHistory = []
+ self._termHistoryIdx = 0
+
+ self._mapImage = wx.Image(resources.getPathForImage('print-window-map.png'))
+ self._colorCommandMap = {}
+
+ # Move X
+ self._addMovementCommand(0, 0, 255, self._moveX, 100)
+ self._addMovementCommand(0, 0, 240, self._moveX, 10)
+ self._addMovementCommand(0, 0, 220, self._moveX, 1)
+ self._addMovementCommand(0, 0, 200, self._moveX, 0.1)
+ self._addMovementCommand(0, 0, 180, self._moveX, -0.1)
+ self._addMovementCommand(0, 0, 160, self._moveX, -1)
+ self._addMovementCommand(0, 0, 140, self._moveX, -10)
+ self._addMovementCommand(0, 0, 120, self._moveX, -100)
+
+ # Move Y
+ self._addMovementCommand(0, 255, 0, self._moveY, -100)
+ self._addMovementCommand(0, 240, 0, self._moveY, -10)
+ self._addMovementCommand(0, 220, 0, self._moveY, -1)
+ self._addMovementCommand(0, 200, 0, self._moveY, -0.1)
+ self._addMovementCommand(0, 180, 0, self._moveY, 0.1)
+ self._addMovementCommand(0, 160, 0, self._moveY, 1)
+ self._addMovementCommand(0, 140, 0, self._moveY, 10)
+ self._addMovementCommand(0, 120, 0, self._moveY, 100)
+
+ # Move Z
+ self._addMovementCommand(255, 0, 0, self._moveZ, 10)
+ self._addMovementCommand(220, 0, 0, self._moveZ, 1)
+ self._addMovementCommand(200, 0, 0, self._moveZ, 0.1)
+ self._addMovementCommand(180, 0, 0, self._moveZ, -0.1)
+ self._addMovementCommand(160, 0, 0, self._moveZ, -1)
+ self._addMovementCommand(140, 0, 0, self._moveZ, -10)
+
+ # Extrude/Retract
+ self._addMovementCommand(255, 80, 0, self._moveE, 10)
+ self._addMovementCommand(255, 180, 0, self._moveE, -10)
+
+ # Home
+ self._addMovementCommand(255, 255, 0, self._homeXYZ, None)
+ self._addMovementCommand(240, 255, 0, self._homeXYZ, "X")
+ self._addMovementCommand(220, 255, 0, self._homeXYZ, "Y")
+ self._addMovementCommand(200, 255, 0, self._homeXYZ, "Z")
+
+ self.powerWarningText = wx.StaticText(parent=self.toppanel,
+ id=-1,
+ label=_("Your computer is running on battery power.\nConnect your computer to AC power or your print might not finish."),
+ style=wx.ALIGN_CENTER)
+ self.powerWarningText.SetBackgroundColour('red')
+ self.powerWarningText.SetForegroundColour('white')
+ self.powerManagement = power.PowerManagement()
+ self.powerWarningTimer = wx.Timer(self)
+ self.Bind(wx.EVT_TIMER, self.OnPowerWarningChange, self.powerWarningTimer)
+ self.OnPowerWarningChange(None)
+ self.powerWarningTimer.Start(10000)
- def OnTempChange(self, e):
- self.machineCom.sendCommand("M104 S%d" % (self.temperatureSelect.GetValue()))
+ self.connectButton = wx.Button(self.toppanel, -1, _("Connect"), size=(125, 30))
+ self.printButton = wx.Button(self.toppanel, -1, _("Print"), size=(125, 30))
+ self.cancelButton = wx.Button(self.toppanel, -1, _("Cancel"), size=(125, 30))
+ self.errorLogButton = wx.Button(self.toppanel, -1, _("Error log"), size=(125, 30))
+ self.motorsOffButton = wx.Button(self.toppanel, -1, _("Motors off"), size=(125, 30))
+ self.movementBitmap = wx.StaticBitmap(self.panel, -1, wx.BitmapFromImage(wx.Image(
+ resources.getPathForImage('print-window.png'))), (0, 0))
+ self.temperatureBitmap = wx.StaticBitmap(self.panel, -1, wx.BitmapFromImage(wx.Image(
+ resources.getPathForImage('print-window-temperature.png'))), (0, 0))
+ self.temperatureField = TemperatureField(self.panel, self._setHotendTemperature)
+ self.temperatureBedBitmap = wx.StaticBitmap(self.panel, -1, wx.BitmapFromImage(wx.Image(
+ resources.getPathForImage('print-window-temperature-bed.png'))), (0, 0))
+ self.temperatureBedField = TemperatureField(self.panel, self._setBedTemperature)
+ self.temperatureGraph = TemperatureGraph(self.panel)
+ self.temperatureGraph.SetMinSize((250, 100))
+ self.progress = wx.Gauge(self.panel, -1, range=1000)
- def OnBedTempChange(self, e):
- self.machineCom.sendCommand("M140 S%d" % (self.bedTemperatureSelect.GetValue()))
+ f = wx.Font(8, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
+ self._termLog = wx.TextCtrl(self.panel, style=wx.TE_MULTILINE)
+ self._termLog.SetFont(f)
+ self._termLog.SetEditable(0)
+ self._termLog.SetMinSize((385, -1))
+ self._termInput = wx.TextCtrl(self.panel, style=wx.TE_PROCESS_ENTER)
+ self._termInput.SetFont(f)
+
+ self.Bind(wx.EVT_TEXT_ENTER, self.OnTermEnterLine, self._termInput)
+ self._termInput.Bind(wx.EVT_CHAR, self.OnTermKey)
+
+ self.topsizer.Add(self.powerWarningText, pos=(0, 0), span=(1, 6), flag=wx.EXPAND|wx.BOTTOM, border=5)
+ self.topsizer.Add(self.connectButton, pos=(1, 0), flag=wx.LEFT, border=2)
+ self.topsizer.Add(self.printButton, pos=(1, 1), flag=wx.LEFT, border=2)
+ self.topsizer.Add(self.cancelButton, pos=(1, 2), flag=wx.LEFT, border=2)
+ self.topsizer.Add(self.errorLogButton, pos=(1, 4), flag=wx.LEFT, border=2)
+ self.topsizer.Add(self.motorsOffButton, pos=(1, 5), flag=wx.LEFT|wx.RIGHT, border=2)
+ self.sizer.Add(self.movementBitmap, pos=(0, 0), span=(2, 3))
+ self.sizer.Add(self.temperatureGraph, pos=(2, 0), span=(4, 2), flag=wx.EXPAND)
+ self.sizer.Add(self.temperatureBitmap, pos=(2, 2))
+ self.sizer.Add(self.temperatureField, pos=(3, 2))
+ self.sizer.Add(self.temperatureBedBitmap, pos=(4, 2))
+ self.sizer.Add(self.temperatureBedField, pos=(5, 2))
+ self.sizer.Add(self._termLog, pos=(0, 3), span=(5, 3), flag=wx.EXPAND|wx.RIGHT, border=5)
+ self.sizer.Add(self._termInput, pos=(5, 3), span=(1, 3), flag=wx.EXPAND|wx.RIGHT, border=5)
+ self.sizer.Add(self.progress, pos=(6, 0), span=(1, 6), flag=wx.EXPAND|wx.BOTTOM)
- def OnSpeedChange(self, e):
- if self.machineCom is None:
- return
- self.machineCom.setFeedrateModifier('WALL-OUTER', self.outerWallSpeedSelect.GetValue() / 100.0)
- self.machineCom.setFeedrateModifier('WALL-INNER', self.innerWallSpeedSelect.GetValue() / 100.0)
- self.machineCom.setFeedrateModifier('FILL', self.fillSpeedSelect.GetValue() / 100.0)
- self.machineCom.setFeedrateModifier('SUPPORT', self.supportSpeedSelect.GetValue() / 100.0)
-
- def AddTermLog(self, line):
- if len(self.termLog.GetValue()) > 10000:
- self.termLog.SetValue(self.termLog.GetValue()[-10000:])
- self.termLog.SetInsertionPointEnd()
- self.termLog.AppendText(unicode(line, 'utf-8', 'replace'))
- #l = self.termLog.GetLastPosition() # if needed (windows? mac?)
- #self.termLog.ShowPosition(l)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_CLOSE, self.OnClose)
+ self.movementBitmap.Bind(wx.EVT_LEFT_DOWN, self.OnMovementClick)
+ self.temperatureGraph.Bind(wx.EVT_LEFT_UP, self.OnTemperatureClick)
+ self.connectButton.Bind(wx.EVT_BUTTON, self.OnConnect)
+ self.printButton.Bind(wx.EVT_BUTTON, self.OnPrint)
+ self.cancelButton.Bind(wx.EVT_BUTTON, self.OnCancel)
+ self.errorLogButton.Bind(wx.EVT_BUTTON, self.OnErrorLog)
+ self.motorsOffButton.Bind(wx.EVT_BUTTON, self.OnMotorsOff)
- def OnTermEnterLine(self, e):
- line = self.termInput.GetValue()
- if line == '':
- return
- self.termLog.AppendText('>%s\n' % (line))
- self.machineCom.sendCommand(line)
- self.termHistory.append(line)
- self.termHistoryIdx = len(self.termHistory)
- self.termInput.SetValue('')
+ self.Layout()
+ self.Fit()
+ self.Refresh()
+ self.progress.SetMinSize(self.progress.GetSize())
+ self._updateButtonStates()
- def OnTermKey(self, e):
- if len(self.termHistory) > 0:
- if e.GetKeyCode() == wx.WXK_UP:
- self.termHistoryIdx -= 1
- if self.termHistoryIdx < 0:
- self.termHistoryIdx = len(self.termHistory) - 1
- self.termInput.SetValue(self.termHistory[self.termHistoryIdx])
- if e.GetKeyCode() == wx.WXK_DOWN:
- self.termHistoryIdx -= 1
- if self.termHistoryIdx >= len(self.termHistory):
- self.termHistoryIdx = 0
- self.termInput.SetValue(self.termHistory[self.termHistoryIdx])
+ self._printerConnection.addCallback(self._doPrinterConnectionUpdate)
+
+ if self._printerConnection.hasActiveConnection() and \
+ not self._printerConnection.isActiveConnectionOpen():
+ self._printerConnection.openActiveConnection()
+
+ def OnSize(self, e):
+ # HACK ALERT: This is needed for some reason otherwise the window
+ # will be bigger than it should be until a power warning change
+ self.Layout()
+ self.Fit()
e.Skip()
+ def OnClose(self, e):
+ if self._printerConnection.hasActiveConnection():
+ if self._printerConnection.isPrinting() or self._printerConnection.isPaused():
+ pass #TODO: Give warning that the close will kill the print.
+ self._printerConnection.closeActiveConnection()
+ self._printerConnection.removeCallback(self._doPrinterConnectionUpdate)
+ #TODO: When multiple printer windows are open, closing one will enable sleeping again.
+ preventComputerFromSleeping(self, False)
+ self._printerConnection.cancelPrint()
+ self.Destroy()
+
def OnPowerWarningChange(self, e):
type = self.powerManagement.get_providing_power_source_type()
if type == power.POWER_TYPE_AC and self.powerWarningText.IsShown():
self.powerWarningText.Hide()
- self.panel.Layout()
+ self.toppanel.Layout()
self.Layout()
+ self.Fit()
+ self.Refresh()
elif type != power.POWER_TYPE_AC and not self.powerWarningText.IsShown():
self.powerWarningText.Show()
- self.panel.Layout()
+ self.toppanel.Layout()
self.Layout()
+ self.Fit()
+ self.Refresh()
- def LoadGCodeFile(self, filename):
- if self.machineCom is not None and self.machineCom.isPrinting():
- return False
- #Send an initial M110 to reset the line counter to zero.
- prevLineType = lineType = 'CUSTOM'
- gcodeList = ["M110"]
- for line in open(filename, 'r'):
- if line.startswith(';TYPE:'):
- lineType = line[6:].strip()
- if ';' in line:
- line = line[0:line.find(';')]
- line = line.strip()
- if len(line) > 0:
- if prevLineType != lineType:
- gcodeList.append((line, lineType, ))
+ def OnConnect(self, e):
+ self._printerConnection.openActiveConnection()
+
+ def OnPrint(self, e):
+ if self._printerConnection.isPrinting() or self._printerConnection.isPaused():
+ self._printerConnection.pause(not self._printerConnection.isPaused())
+ else:
+ self._printerConnection.startPrint()
+
+ def OnCancel(self, e):
+ self._printerConnection.cancelPrint()
+
+ def OnErrorLog(self, e):
+ LogWindow(self._printerConnection.getErrorLog())
+
+ def OnMotorsOff(self, e):
+ self._printerConnection.sendCommand("M18")
+
+ def GetMapRGB(self, x, y):
+ r = self._mapImage.GetRed(x, y)
+ g = self._mapImage.GetGreen(x, y)
+ b = self._mapImage.GetBlue(x, y)
+ return (r, g, b)
+
+ def OnMovementClick(self, e):
+ (r, g, b) = self.GetMapRGB(e.GetX(), e.GetY())
+ if (r, g, b) in self._colorCommandMap:
+ command = self._colorCommandMap[(r, g, b)]
+ command[0](command[1])
+
+ def _addMovementCommand(self, r, g, b, command, step):
+ self._colorCommandMap[(r, g, b)] = (command, step)
+
+ def _moveXYZE(self, motor, step, feedrate):
+ # Prevent Z movement when paused and all moves when printing
+ if (not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen()) and \
+ (not (self._printerConnection.isPaused() and motor == 'Z') and \
+ not self._printerConnection.isPrinting()):
+ self._printerConnection.sendCommand("G91")
+ self._printerConnection.sendCommand("G1 %s%.1f F%d" % (motor, step, feedrate))
+ self._printerConnection.sendCommand("G90")
+
+ def _moveX(self, step):
+ self._moveXYZE("X", step, 2000)
+
+ def _moveY(self, step):
+ self._moveXYZE("Y", step, 2000)
+
+ def _moveZ(self, step):
+ self._moveXYZE("Z", step, 200)
+
+ def _moveE(self, step):
+ self._moveXYZE("E", step, 120)
+
+ def _homeXYZ(self, direction):
+ if not self._printerConnection.isPaused() and not self._printerConnection.isPrinting():
+ if direction is None:
+ self._printerConnection.sendCommand("G28")
+ else:
+ self._printerConnection.sendCommand("G28 %s0" % direction)
+
+ def _setHotendTemperature(self, value):
+ self._printerConnection.sendCommand("M104 S%d" % value)
+
+ def _setBedTemperature(self, value):
+ self._printerConnection.sendCommand("M140 S%d" % value)
+
+ def OnTemperatureClick(self, e):
+ wx.CallAfter(self.ToggleFullScreenTemperature)
+
+ def ToggleFullScreenTemperature(self):
+ sizer = self.GetSizer()
+ if self._fullscreenTemperature:
+ self._fullscreenTemperature.Show(False)
+ sizer.Detach(self._fullscreenTemperature)
+ self._fullscreenTemperature.Destroy()
+ self._fullscreenTemperature = None
+ self.panel.Show(True)
+ else:
+ self._fullscreenTemperature = self.temperatureGraph.Clone(self)
+ self._fullscreenTemperature.Bind(wx.EVT_LEFT_UP, self.OnTemperatureClick)
+ self._fullscreenTemperature.SetMinSize(self.panel.GetSize())
+ sizer.Add(self._fullscreenTemperature, 1, flag=wx.EXPAND)
+ self.panel.Show(False)
+ self.Layout()
+ self.Refresh()
+
+ def OnTermEnterLine(self, e):
+ if not self._printerConnection.isAbleToSendDirectCommand():
+ return
+ line = self._termInput.GetValue()
+ if line == '':
+ return
+ self._addTermLog('> %s\n' % (line))
+ self._printerConnection.sendCommand(line)
+ self._termHistory.append(line)
+ self._termHistoryIdx = len(self._termHistory)
+ self._termInput.SetValue('')
+
+ def OnTermKey(self, e):
+ if len(self._termHistory) > 0:
+ if e.GetKeyCode() == wx.WXK_UP:
+ self._termHistoryIdx -= 1
+ if self._termHistoryIdx < 0:
+ self._termHistoryIdx = len(self._termHistory) - 1
+ self._termInput.SetValue(self._termHistory[self._termHistoryIdx])
+ if e.GetKeyCode() == wx.WXK_DOWN:
+ self._termHistoryIdx -= 1
+ if self._termHistoryIdx >= len(self._termHistory):
+ self._termHistoryIdx = 0
+ self._termInput.SetValue(self._termHistory[self._termHistoryIdx])
+ e.Skip()
+
+ def _addTermLog(self, line):
+ if self._termLog is not None:
+ if len(self._termLog.GetValue()) > 10000:
+ self._termLog.SetValue(self._termLog.GetValue()[-10000:])
+ self._termLog.SetInsertionPointEnd()
+ if type(line) != unicode:
+ line = unicode(line, 'utf-8', 'replace')
+ self._termLog.AppendText(line.encode('utf-8', 'replace'))
+
+ def _updateButtonStates(self):
+ self.connectButton.Show(self._printerConnection.hasActiveConnection())
+ self.connectButton.Enable(not self._printerConnection.isActiveConnectionOpen() and \
+ not self._printerConnection.isActiveConnectionOpening())
+ if not self._printerConnection.hasPause():
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ self.printButton.Enable(not self._printerConnection.isPrinting() and \
+ not self._printerConnection.isPaused())
+ else:
+ self.printButton.Enable(False)
+ else:
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ if self._printerConnection.isPrinting():
+ self.printButton.SetLabel(_("Pause"))
else:
- gcodeList.append(line)
- prevLineType = lineType
- gcode = gcodeInterpreter.gcode()
- gcode.load(gcodeList)
- #print "Loaded: %s (%d)" % (filename, len(gcodeList))
- self.filename = filename
- self.gcode = gcode
- self.gcodeList = gcodeList
-
- wx.CallAfter(self.progress.SetRange, len(gcodeList))
- wx.CallAfter(self.UpdateButtonStates)
- wx.CallAfter(self.UpdateProgress)
- return True
-
- def sendLine(self, lineNr):
- if lineNr >= len(self.gcodeList):
- return False
- line = self.gcodeList[lineNr]
- try:
- if ('M104' in line or 'M109' in line) and 'S' in line:
- n = int(re.search('S([0-9]*)', line).group(1))
- wx.CallAfter(self.temperatureSelect.SetValue, n)
- if ('M140' in line or 'M190' in line) and 'S' in line:
- n = int(re.search('S([0-9]*)', line).group(1))
- wx.CallAfter(self.bedTemperatureSelect.SetValue, n)
- except:
- print "Unexpected error:", sys.exc_info()
- checksum = reduce(lambda x, y: x ^ y, map(ord, "N%d%s" % (lineNr, line)))
- self.machineCom.sendCommand("N%d%s*%d" % (lineNr, line, checksum))
- return True
-
- def mcLog(self, message):
- #print message
- pass
+ if self._printerConnection.isPaused():
+ self.printButton.SetLabel(_("Resume"))
+ else:
+ self.printButton.SetLabel(_("Print"))
+ self.printButton.Enable(True)
+ else:
+ self.printButton.Enable(False)
+ if not self._printerConnection.hasActiveConnection() or \
+ self._printerConnection.isActiveConnectionOpen():
+ self.cancelButton.Enable(self._printerConnection.isPrinting() or \
+ self._printerConnection.isPaused())
+ else:
+ self.cancelButton.Enable(False)
+ self.errorLogButton.Show(self._printerConnection.isInErrorState())
+ self._termInput.Enable(self._printerConnection.isAbleToSendDirectCommand())
+ self.Layout()
- def mcTempUpdate(self, temp, bedTemp, targetTemp, bedTargetTemp):
- self.temperatureGraph.addPoint(temp, targetTemp, bedTemp, bedTargetTemp)
- wx.CallAfter(self._mcTempUpdate, temp, bedTemp, targetTemp, bedTargetTemp)
-
- def _mcTempUpdate(self, temp, bedTemp, targetTemp, bedTargetTemp):
- if self.temperatureSelect.GetValue() != targetTemp[0] and wx.Window.FindFocus() != self.temperatureSelect:
- self.temperatureSelect.SetValue(targetTemp[0])
- if self.bedTemperatureSelect.GetValue() != bedTargetTemp and wx.Window.FindFocus() != self.bedTemperatureSelect:
- self.bedTemperatureSelect.SetValue(bedTargetTemp)
-
- def mcStateChange(self, state):
- if self.machineCom is not None:
- if state == self.machineCom.STATE_OPERATIONAL and self.cam is not None:
- self.cam.endTimelapse()
- if state == self.machineCom.STATE_OPERATIONAL:
- taskbar.setBusy(self, False)
- if self.machineCom.isClosedOrError():
- taskbar.setBusy(self, False)
- if self.machineCom.isPaused():
- taskbar.setPause(self, True)
- if self.machineCom.isClosedOrError():
- print 'STATE:CLOSED'
- elif self.machineCom.isPrinting():
- print 'STATE:PRINTING'
+ def _doPrinterConnectionUpdate(self, connection, extraInfo = None):
+ wx.CallAfter(self.__doPrinterConnectionUpdate, connection, extraInfo)
+ temp = []
+ for n in xrange(0, 4):
+ t = connection.getTemperature(0)
+ if t is not None:
+ temp.append(t)
else:
- print 'STATE:IDLE'
- wx.CallAfter(self.UpdateButtonStates)
- wx.CallAfter(self.UpdateProgress)
+ break
+ self.temperatureGraph.addPoint(temp, [0] * len(temp), connection.getBedTemperature(), 0)
+ if self._fullscreenTemperature is not None:
+ self._fullscreenTemperature.addPoint(temp, [0] * len(temp), connection.getBedTemperature(), 0)
- def mcMessage(self, message):
- wx.CallAfter(self.AddTermLog, message)
+ def __doPrinterConnectionUpdate(self, connection, extraInfo):
+ t = time.time()
+ if self._lastUpdateTime + 0.5 > t and extraInfo is None:
+ return
+ self._lastUpdateTime = t
- def mcProgress(self, lineNr):
- wx.CallAfter(self.UpdateProgress)
+ if extraInfo is not None and len(extraInfo) > 0:
+ self._addTermLog('< %s\n' % (extraInfo))
- def mcZChange(self, newZ):
- self.currentZ = newZ
- print 'Z:%f' % newZ
- if self.cam is not None:
- wx.CallAfter(self.cam.takeNewImage)
- wx.CallAfter(self.camPreview.Refresh)
+ self._updateButtonStates()
+ isPrinting = connection.isPrinting() or connection.isPaused()
+ if isPrinting:
+ self.progress.SetValue(connection.getPrintProgress() * 1000)
+ else:
+ self.progress.SetValue(0)
+ info = connection.getStatusString()
+ info += '\n'
+ if self._printerConnection.getTemperature(0) is not None:
+ info += 'Temperature: %d' % (self._printerConnection.getTemperature(0))
+ if self._printerConnection.getBedTemperature() > 0:
+ info += ' Bed: %d' % (self._printerConnection.getBedTemperature())
+ self.SetTitle(info.replace('\n', ', ').strip().strip(','))
+ if isPrinting != self._isPrinting:
+ self._isPrinting = isPrinting
+ preventComputerFromSleeping(self, self._isPrinting)
+
+class TemperatureField(wx.Panel):
+ def __init__(self, parent, callback):
+ super(TemperatureField, self).__init__(parent)
+ self.callback = callback
+
+ self.SetBackgroundColour(wx.WHITE)
+
+ self.text = IntCtrl(self, -1)
+ self.text.SetBounds(0, 300)
+ self.text.SetSize((60, 28))
+
+ self.unit = wx.StaticBitmap(self, -1, wx.BitmapFromImage(wx.Image(
+ resources.getPathForImage('print-window-temperature-unit.png'))), (0, 0))
+ self.button = wx.Button(self, -1, _("Set"))
+ self.button.SetSize((35, 25))
+ self.Bind(wx.EVT_BUTTON, lambda e: self.callback(self.text.GetValue()), self.button)
-class temperatureGraph(wx.Panel):
+ self.text.SetPosition((0, 0))
+ self.unit.SetPosition((60, 0))
+ self.button.SetPosition((90, 0))
+
+
+class TemperatureGraph(wx.Panel):
def __init__(self, parent):
- super(temperatureGraph, self).__init__(parent)
+ super(TemperatureGraph, self).__init__(parent)
self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_PAINT, self.OnDraw)
- self.lastDraw = time.time() - 1.0
- self.points = []
- self.backBuffer = None
+ self._lastDraw = time.time() - 1.0
+ self._points = []
+ self._backBuffer = None
self.addPoint([0]*16, [0]*16, 0, 0)
- self.SetMinSize((320, 200))
+
+ def Clone(self, parent):
+ clone = TemperatureGraph(parent)
+ clone._points = list(self._points)
+ return clone
def OnEraseBackground(self, e):
pass
def OnSize(self, e):
- if self.backBuffer is None or self.GetSize() != self.backBuffer.GetSize():
- self.backBuffer = wx.EmptyBitmap(*self.GetSizeTuple())
+ if self._backBuffer is None or self.GetSize() != self._backBuffer.GetSize():
+ self._backBuffer = wx.EmptyBitmap(*self.GetSizeTuple())
self.UpdateDrawing(True)
def OnDraw(self, e):
- dc = wx.BufferedPaintDC(self, self.backBuffer)
+ dc = wx.BufferedPaintDC(self, self._backBuffer)
def UpdateDrawing(self, force=False):
now = time.time()
- if not force and now - self.lastDraw < 1.0:
+ if (not force and now - self._lastDraw < 1.0) or self._backBuffer is None:
return
- self.lastDraw = now
+ self._lastDraw = now
dc = wx.MemoryDC()
- dc.SelectObject(self.backBuffer)
+ dc.SelectObject(self._backBuffer)
+ dc.SetBackground(wx.Brush(wx.WHITE))
dc.Clear()
dc.SetFont(wx.SystemSettings.GetFont(wx.SYS_SYSTEM_FONT))
w, h = self.GetSizeTuple()
#Draw the background up to the current temperatures.
x0 = 0
- t0 = [0] * len(self.points[0][0])
+ t0 = []
bt0 = 0
tSP0 = 0
btSP0 = 0
- for temp, tempSP, bedTemp, bedTempSP, t in self.points:
+ for temp, tempSP, bedTemp, bedTempSP, t in self._points:
x1 = int(w - (now - t))
for x in xrange(x0, x1 + 1):
- for n in xrange(0, len(temp)):
+ for n in xrange(0, min(len(t0), len(temp))):
t = float(x - x0) / float(x1 - x0 + 1) * (temp[n] - t0[n]) + t0[n]
dc.SetPen(tempPenBG)
- dc.DrawLine(x, h, x, h - (t * h / 300))
+ dc.DrawLine(x, h, x, h - (t * h / 350))
bt = float(x - x0) / float(x1 - x0 + 1) * (bedTemp - bt0) + bt0
dc.SetPen(bedTempPenBG)
- dc.DrawLine(x, h, x, h - (bt * h / 300))
+ dc.DrawLine(x, h, x, h - (bt * h / 350))
t0 = temp
bt0 = bedTemp
tSP0 = tempSP
dc.SetPen(bgLinePen)
dc.DrawLine(x, 0, x, h)
tmpNr = 0
- for y in xrange(h - 1, 0, -h * 50 / 300):
+ for y in xrange(h - 1, 0, -h * 50 / 350):
dc.SetPen(bgLinePen)
dc.DrawLine(0, y, w, y)
dc.DrawText(str(tmpNr), 0, y - dc.GetFont().GetPixelSize().GetHeight())
#Draw the main lines
x0 = 0
- t0 = [0] * len(self.points[0][0])
+ t0 = []
bt0 = 0
- tSP0 = [0] * len(self.points[0][0])
+ tSP0 = []
btSP0 = 0
- for temp, tempSP, bedTemp, bedTempSP, t in self.points:
+ for temp, tempSP, bedTemp, bedTempSP, t in self._points:
x1 = int(w - (now - t))
for x in xrange(x0, x1 + 1):
- for n in xrange(0, len(temp)):
+ for n in xrange(0, min(len(t0), len(temp))):
t = float(x - x0) / float(x1 - x0 + 1) * (temp[n] - t0[n]) + t0[n]
tSP = float(x - x0) / float(x1 - x0 + 1) * (tempSP[n] - tSP0[n]) + tSP0[n]
dc.SetPen(tempSPPen)
- dc.DrawPoint(x, h - (tSP * h / 300))
+ dc.DrawPoint(x, h - (tSP * h / 350))
dc.SetPen(tempPen)
- dc.DrawPoint(x, h - (t * h / 300))
+ dc.DrawPoint(x, h - (t * h / 350))
bt = float(x - x0) / float(x1 - x0 + 1) * (bedTemp - bt0) + bt0
btSP = float(x - x0) / float(x1 - x0 + 1) * (bedTempSP - btSP0) + btSP0
dc.SetPen(bedTempSPPen)
- dc.DrawPoint(x, h - (btSP * h / 300))
+ dc.DrawPoint(x, h - (btSP * h / 350))
dc.SetPen(bedTempPen)
- dc.DrawPoint(x, h - (bt * h / 300))
+ dc.DrawPoint(x, h - (bt * h / 350))
t0 = temp
bt0 = bedTemp
tSP0 = tempSP
self.Refresh(eraseBackground=False)
self.Update()
- if len(self.points) > 0 and (time.time() - self.points[0][4]) > w + 20:
- self.points.pop(0)
+ if len(self._points) > 0 and (time.time() - self._points[0][4]) > w + 20:
+ self._points.pop(0)
def addPoint(self, temp, tempSP, bedTemp, bedTempSP):
+ if len(self._points) > 0 and time.time() - self._points[-1][4] < 0.5:
+ return
+ for n in xrange(0, len(temp)):
+ if temp[n] is None:
+ temp[n] = 0
+ for n in xrange(0, len(tempSP)):
+ if tempSP[n] is None:
+ tempSP[n] = 0
if bedTemp is None:
bedTemp = 0
if bedTempSP is None:
bedTempSP = 0
- self.points.append((temp[:], tempSP[:], bedTemp, bedTempSP, time.time()))
+ self._points.append((temp[:], tempSP[:], bedTemp, bedTempSP, time.time()))
wx.CallAfter(self.UpdateDrawing)
-
class LogWindow(wx.Frame):
def __init__(self, logText):
- super(LogWindow, self).__init__(None, title="Machine log")
+ super(LogWindow, self).__init__(None, title=_("Error log"))
self.textBox = wx.TextCtrl(self, -1, logText, style=wx.TE_MULTILINE | wx.TE_DONTWRAP | wx.TE_READONLY)
self.SetSize((500, 400))
- self.Centre()
self.Show(True)
~ianmdlvl / cura.git / blobdiff