Cura/gui/firmwareInstall.py

   1 __copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
   2
   3 import os
   4 import wx
   5 import threading
   6 import sys
   7 import time
   8 import serial
   9
  10 from Cura.avr_isp import stk500v2
  11 from Cura.avr_isp import ispBase
  12 from Cura.avr_isp import intelHex
  13
  14 from Cura.gui.util import taskbar
  15 from Cura.util import machineCom
  16 from Cura.util import profile
  17 from Cura.util import resources
  18
  19 def getDefaultFirmware(machineIndex = None):
  20         machine_type = profile.getMachineSetting('machine_type', machineIndex)
  21         extruders = profile.getMachineSettingFloat('extruder_amount', machineIndex)
  22         heated_bed = profile.getMachineSetting('has_heated_bed', machineIndex) == 'True'
  23         baudrate = 250000
  24         if sys.platform.startswith('linux'):
  25                 baudrate = 115200
  26         if machine_type == 'ultimaker':
  27                 name = 'MarlinUltimaker'
  28                 if extruders > 2:
  29                         return None
  30                 if heated_bed:
  31                         name += '-HBK'
  32                 name += '-%d' % (baudrate)
  33                 if extruders > 1:
  34                         name += '-dual'
  35                 return resources.getPathForFirmware(name + '.hex')
  36
  37         if machine_type == 'ultimaker_plus':
  38                 name = 'MarlinUltimaker-UMOP-%d' % (baudrate)
  39                 if extruders > 2:
  40                         return None
  41                 if extruders > 1:
  42                         name += '-dual'
  43                 return resources.getPathForFirmware(name + '.hex')
  44
  45         if machine_type == 'ultimaker2':
  46                 if extruders > 2:
  47                         return None
  48                 if extruders > 1:
  49                         return resources.getPathForFirmware("MarlinUltimaker2-dual.hex")
  50                 return resources.getPathForFirmware("MarlinUltimaker2.hex")
  51         if machine_type == 'ultimaker2go':
  52                 return resources.getPathForFirmware("MarlinUltimaker2go.hex")
  53         if machine_type == 'ultimaker2extended':
  54                 if extruders > 2:
  55                         return None
  56                 if extruders > 1:
  57                         return resources.getPathForFirmware("MarlinUltimaker2extended-dual.hex")
  58                 return resources.getPathForFirmware("MarlinUltimaker2extended.hex")
  59         if machine_type == 'Witbox':
  60                 return resources.getPathForFirmware("MarlinWitbox.hex")
  61         return None
  62
  63 class InstallFirmware(wx.Dialog):
  64         def __init__(self, parent = None, filename = None, port = None, machineIndex = None):
  65                 super(InstallFirmware, self).__init__(parent=parent, title="Firmware install for %s" % (profile.getMachineSetting('machine_name', machineIndex).title()), size=(250, 100))
  66                 if port is None:
  67                         port = profile.getMachineSetting('serial_port')
  68                 if filename is None:
  69                         filename = getDefaultFirmware(machineIndex)
  70                 if filename is None:
  71                         wx.MessageBox(_("I am sorry, but Cura does not ship with a default firmware for your machine configuration."), _("Firmware update"), wx.OK | wx.ICON_ERROR)
  72                         self.Destroy()
  73                         return
  74                 self._machine_type = profile.getMachineSetting('machine_type', machineIndex)
  75                 if self._machine_type == 'reprap':
  76                         wx.MessageBox(_("Cura only supports firmware updates for ATMega2560 based hardware.\nSo updating your RepRap with Cura might or might not work."), _("Firmware update"), wx.OK | wx.ICON_INFORMATION)
  77
  78                 sizer = wx.BoxSizer(wx.VERTICAL)
  79
  80                 self.progressLabel = wx.StaticText(self, -1, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nX\nX')
  81                 sizer.Add(self.progressLabel, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
  82                 self.progressGauge = wx.Gauge(self, -1)
  83                 sizer.Add(self.progressGauge, 0, flag=wx.EXPAND)
  84                 self.okButton = wx.Button(self, -1, _("OK"))
  85                 self.okButton.Disable()
  86                 self.okButton.Bind(wx.EVT_BUTTON, self.OnOk)
  87                 sizer.Add(self.okButton, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
  88                 self.SetSizer(sizer)
  89
  90                 self.filename = filename
  91                 self.port = port
  92
  93                 self.Layout()
  94                 self.Fit()
  95
  96                 self.thread = threading.Thread(target=self.OnRun)
  97                 self.thread.daemon = True
  98                 self.thread.start()
  99
 100                 self.ShowModal()
 101                 self.Destroy()
 102                 return
 103
 104         def OnRun(self):
 105                 wx.CallAfter(self.updateLabel, _("Reading firmware..."))
 106                 hexFile = intelHex.readHex(self.filename)
 107                 wx.CallAfter(self.updateLabel, _("Connecting to machine..."))
 108                 programmer = stk500v2.Stk500v2()
 109                 programmer.progressCallback = self.OnProgress
 110                 if self.port == 'AUTO':
 111                         wx.CallAfter(self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable."))
 112                         while not programmer.isConnected():
 113                                 for self.port in machineCom.serialList(True):
 114                                         try:
 115                                                 programmer.connect(self.port)
 116                                                 break
 117                                         except ispBase.IspError:
 118                                                 programmer.close()
 119                                 time.sleep(1)
 120                                 if not self:
 121                                         #Window destroyed
 122                                         return
 123                 else:
 124                         try:
 125                                 programmer.connect(self.port)
 126                         except ispBase.IspError:
 127                                 programmer.close()
 128
 129                 if not programmer.isConnected():
 130                         wx.MessageBox(_("Failed to find machine for firmware upgrade\nIs your machine connected to the PC?"),
 131                                                   _("Firmware update"), wx.OK | wx.ICON_ERROR)
 132                         wx.CallAfter(self.Close)
 133                         return
 134
 135                 if self._machine_type == 'ultimaker':
 136                         if programmer.hasChecksumFunction():
 137                                 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+?"))
 138                                 programmer.close()
 139                                 wx.CallAfter(self.okButton.Enable)
 140                                 return
 141                 if self._machine_type == 'ultimaker_plus' or self._machine_type == 'ultimaker2':
 142                         if not programmer.hasChecksumFunction():
 143                                 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?"))
 144                                 programmer.close()
 145                                 wx.CallAfter(self.okButton.Enable)
 146                                 return
 147
 148                 wx.CallAfter(self.updateLabel, _("Uploading firmware..."))
 149                 try:
 150                         programmer.programChip(hexFile)
 151                         wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename)))
 152                 except ispBase.IspError as e:
 153                         wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e))
 154
 155                 programmer.close()
 156                 wx.CallAfter(self.okButton.Enable)
 157
 158         def updateLabel(self, text):
 159                 self.progressLabel.SetLabel(text)
 160                 #self.Layout()
 161
 162         def OnProgress(self, value, max):
 163                 wx.CallAfter(self.progressGauge.SetRange, max)
 164                 wx.CallAfter(self.progressGauge.SetValue, value)
 165                 taskbar.setProgress(self.GetParent(), value, max)
 166
 167         def OnOk(self, e):
 168                 self.Close()
 169                 taskbar.setBusy(self.GetParent(), False)
 170
 171         def OnClose(self, e):
 172                 self.Destroy()
 173
 174
 175 class AutoUpdateFirmware(wx.Dialog):
 176         def __init__(self, parent, filename = None, port = None, machineIndex = None):
 177                 super(AutoUpdateFirmware, self).__init__(parent=parent, title="Auto Firmware install", size=(250, 500))
 178                 if port is None:
 179                         port = profile.getMachineSetting('serial_port')
 180                 self._serial = None
 181
 182                 sizer = wx.BoxSizer(wx.VERTICAL)
 183
 184                 self.progressLabel = wx.StaticText(self, -1, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nX\nX')
 185                 sizer.Add(self.progressLabel, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
 186                 self.progressGauge = wx.Gauge(self, -1)
 187                 sizer.Add(self.progressGauge, 0, flag=wx.EXPAND)
 188                 self.okButton = wx.Button(self, -1, _("OK"))
 189                 self.okButton.Bind(wx.EVT_BUTTON, self.OnOk)
 190                 sizer.Add(self.okButton, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
 191
 192                 f = wx.Font(8, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
 193                 self._termLog = wx.TextCtrl(self, style=wx.TE_MULTILINE | wx.TE_DONTWRAP)
 194                 self._termLog.SetFont(f)
 195                 self._termLog.SetEditable(0)
 196                 self._termLog.SetMinSize((1, 400))
 197                 self._termInput = wx.TextCtrl(self, style=wx.TE_PROCESS_ENTER)
 198                 self._termInput.SetFont(f)
 199                 sizer.Add(self._termLog, 0, flag=wx.ALIGN_CENTER|wx.ALL|wx.EXPAND)
 200                 sizer.Add(self._termInput, 0, flag=wx.ALIGN_CENTER|wx.ALL|wx.EXPAND)
 201
 202                 self.Bind(wx.EVT_TEXT_ENTER, self.OnTermEnterLine, self._termInput)
 203
 204                 self.SetSizer(sizer)
 205
 206                 self.filename = filename
 207                 self.port = port
 208
 209                 self.Layout()
 210                 self.Fit()
 211
 212                 self.thread = threading.Thread(target=self.OnRun)
 213                 self.thread.daemon = True
 214                 self.thread.start()
 215
 216                 self.read_thread = threading.Thread(target=self.OnSerialRead)
 217                 self.read_thread.daemon = True
 218                 self.read_thread.start()
 219
 220                 self.ShowModal()
 221                 self.Destroy()
 222                 return
 223
 224         def _addTermLog(self, line):
 225                 if self._termLog is not None:
 226                         if len(self._termLog.GetValue()) > 10000:
 227                                 self._termLog.SetValue(self._termLog.GetValue()[-10000:])
 228                         self._termLog.SetInsertionPointEnd()
 229                         if type(line) != unicode:
 230                                 line = unicode(line, 'utf-8', 'replace')
 231                         self._termLog.AppendText(line.encode('utf-8', 'replace'))
 232
 233         def OnTermEnterLine(self, e):
 234                 lines = self._termInput.GetValue().split(';')
 235                 for line in lines:
 236                         if line == '':
 237                                 continue
 238                         self._addTermLog('> %s\n' % (line))
 239                         if self._serial is not None:
 240                                 self._serial.write(line + '\n')
 241
 242         def OnRun(self):
 243                 mtime = 0
 244                 while bool(self):
 245                         new_mtime = os.stat(self.filename).st_mtime
 246                         if mtime != new_mtime:
 247                                 mtime = new_mtime
 248                                 if self._serial is not None:
 249                                         self._serial.close()
 250                                         self._serial = None
 251                                 time.sleep(0.5)
 252                                 self.OnInstall()
 253                                 try:
 254                                         self._serial = serial.Serial(self.port, 250000)
 255                                 except:
 256                                         pass
 257                         time.sleep(0.5)
 258
 259         def OnSerialRead(self):
 260                 while bool(self):
 261                         if self._serial is None:
 262                                 time.sleep(0.5)
 263                         else:
 264                                 try:
 265                                         line = self._serial.readline()
 266                                         wx.CallAfter(self._addTermLog, line)
 267                                 except:
 268                                         pass
 269
 270         def OnInstall(self):
 271                 wx.CallAfter(self.okButton.Disable)
 272                 wx.CallAfter(self.updateLabel, _("Reading firmware..."))
 273                 hexFile = intelHex.readHex(self.filename)
 274                 wx.CallAfter(self.updateLabel, _("Connecting to machine..."))
 275                 programmer = stk500v2.Stk500v2()
 276                 programmer.progressCallback = self.OnProgress
 277                 if self.port == 'AUTO':
 278                         wx.CallAfter(self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable."))
 279                         while not programmer.isConnected():
 280                                 for self.port in machineCom.serialList(True):
 281                                         try:
 282                                                 programmer.connect(self.port)
 283                                                 break
 284                                         except ispBase.IspError:
 285                                                 pass
 286                                 time.sleep(1)
 287                                 if not self:
 288                                         #Window destroyed
 289                                         return
 290                 else:
 291                         try:
 292                                 programmer.connect(self.port)
 293                         except ispBase.IspError:
 294                                 pass
 295
 296                 if not programmer.isConnected():
 297                         wx.CallAfter(self.updateLabel, _("Failed to connect to programmer.\n"))
 298                         return
 299
 300                 wx.CallAfter(self.updateLabel, _("Uploading firmware..."))
 301                 try:
 302                         programmer.programChip(hexFile)
 303                         wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename)))
 304                 except ispBase.IspError as e:
 305                         wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e))
 306
 307                 programmer.close()
 308                 wx.CallAfter(self.okButton.Enable)
 309
 310         def updateLabel(self, text):
 311                 self.progressLabel.SetLabel(text)
 312                 #self.Layout()
 313
 314         def OnProgress(self, value, max):
 315                 wx.CallAfter(self.progressGauge.SetRange, max)
 316                 wx.CallAfter(self.progressGauge.SetValue, value)
 317                 taskbar.setProgress(self.GetParent(), value, max)
 318
 319         def OnOk(self, e):
 320                 self.Close()
 321                 taskbar.setBusy(self.GetParent(), False)
 322
 323         def OnClose(self, e):
 324                 self.Destroy()
 325