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
   9 from Cura.avr_isp import stk500v2
  10 from Cura.avr_isp import ispBase
  11 from Cura.avr_isp import intelHex
  12
  13 from Cura.gui.util import taskbar
  14 from Cura.util import machineCom
  15 from Cura.util import profile
  16 from Cura.util import resources
  17
  18 def getDefaultFirmware(machineIndex = None):
  19         if profile.getMachineSetting('machine_type', machineIndex) == 'ultimaker':
  20                 name = 'MarlinUltimaker'
  21                 if profile.getMachineSettingFloat('extruder_amount', machineIndex) > 2:
  22                         return None
  23                 if profile.getMachineSetting('has_heated_bed', machineIndex) == 'True':
  24                         name += '-HBK'
  25                 if sys.platform.startswith('linux'):
  26                         name += '-115200'
  27                 else:
  28                         name += '-250000'
  29                 if profile.getMachineSettingFloat('extruder_amount', machineIndex) > 1:
  30                         name += '-dual'
  31                 return resources.getPathForFirmware(name + '.hex')
  32
  33         if profile.getMachineSetting('machine_type', machineIndex) == 'ultimaker_plus':
  34                 name = 'MarlinUltimaker-UMOP'
  35                 if profile.getMachineSettingFloat('extruder_amount', machineIndex) > 2:
  36                         return None
  37                 if sys.platform.startswith('linux'):
  38                         name += '-115200'
  39                 else:
  40                         name += '-250000'
  41                 if profile.getMachineSettingFloat('extruder_amount', machineIndex) > 1:
  42                         name += '-dual'
  43                 return resources.getPathForFirmware(name + '.hex')
  44
  45         if profile.getMachineSetting('machine_type', machineIndex) == 'ultimaker2':
  46                 return resources.getPathForFirmware("MarlinUltimaker2.hex")
  47         if profile.getMachineSetting('machine_type', machineIndex) == 'lulzbot_mini':
  48                 return resources.getPathForFirmware("marlin_mini_2014Q4.hex")
  49         if profile.getMachineSetting('machine_type', machineIndex) == 'Witbox':
  50                 return resources.getPathForFirmware("MarlinWitbox.hex")
  51         return None
  52
  53 class InstallFirmware(wx.Dialog):
  54         def __init__(self, parent = None, filename = None, port = None, machineIndex = None):
  55                 super(InstallFirmware, self).__init__(parent=parent, title="Firmware install for %s" % (profile.getMachineSetting('machine_name', machineIndex).title()), size=(250, 100))
  56                 if port is None:
  57                         port = profile.getMachineSetting('serial_port')
  58                 if filename is None:
  59                         filename = getDefaultFirmware(machineIndex)
  60                 if filename is None:
  61                         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)
  62                         self.Destroy()
  63                         return
  64                 self._machine_type = profile.getMachineSetting('machine_type', machineIndex)
  65                 if self._machine_type == 'reprap':
  66                         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)
  67
  68                 sizer = wx.BoxSizer(wx.VERTICAL)
  69
  70                 self.progressLabel = wx.StaticText(self, -1, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nX\nX')
  71                 sizer.Add(self.progressLabel, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
  72                 self.progressGauge = wx.Gauge(self, -1)
  73                 sizer.Add(self.progressGauge, 0, flag=wx.EXPAND)
  74                 self.okButton = wx.Button(self, -1, _("OK"))
  75                 self.okButton.Disable()
  76                 self.okButton.Bind(wx.EVT_BUTTON, self.OnOk)
  77                 sizer.Add(self.okButton, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
  78                 self.SetSizer(sizer)
  79
  80                 self.filename = filename
  81                 self.port = port
  82
  83                 self.Layout()
  84                 self.Fit()
  85
  86                 self.thread = threading.Thread(target=self.OnRun)
  87                 self.thread.daemon = True
  88                 self.thread.start()
  89
  90                 self.ShowModal()
  91                 self.Destroy()
  92                 return
  93
  94         def OnRun(self):
  95                 wx.CallAfter(self.updateLabel, _("Reading firmware..."))
  96                 hexFile = intelHex.readHex(self.filename)
  97                 wx.CallAfter(self.updateLabel, _("Connecting to machine..."))
  98                 programmer = stk500v2.Stk500v2()
  99                 programmer.progressCallback = self.OnProgress
 100                 if self.port == 'AUTO':
 101                         wx.CallAfter(self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable."))
 102                         while not programmer.isConnected():
 103                                 for self.port in machineCom.serialList(True):
 104                                         try:
 105                                                 programmer.connect(self.port)
 106                                                 break
 107                                         except ispBase.IspError:
 108                                                 pass
 109                                 time.sleep(1)
 110                                 if not self:
 111                                         #Window destroyed
 112                                         return
 113                 else:
 114                         try:
 115                                 programmer.connect(self.port)
 116                         except ispBase.IspError:
 117                                 pass
 118
 119                 if not programmer.isConnected():
 120                         wx.MessageBox(_("Failed to find machine for firmware upgrade\nIs your machine connected to the PC?"),
 121                                                   _("Firmware update"), wx.OK | wx.ICON_ERROR)
 122                         wx.CallAfter(self.Close)
 123                         return
 124
 125                 if self._machine_type == 'ultimaker':
 126                         if programmer.hasChecksumFunction():
 127                                 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+?"))
 128                                 programmer.close()
 129                                 wx.CallAfter(self.okButton.Enable)
 130                                 return
 131                 if self._machine_type == 'ultimaker_plus' or self._machine_type == 'ultimaker2':
 132                         if not programmer.hasChecksumFunction():
 133                                 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?"))
 134                                 programmer.close()
 135                                 wx.CallAfter(self.okButton.Enable)
 136                                 return
 137
 138                 wx.CallAfter(self.updateLabel, _("Uploading firmware..."))
 139                 try:
 140                         programmer.programChip(hexFile)
 141                         wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename)))
 142                 except ispBase.IspError as e:
 143                         wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e))
 144
 145                 programmer.close()
 146                 wx.CallAfter(self.okButton.Enable)
 147
 148         def updateLabel(self, text):
 149                 self.progressLabel.SetLabel(text)
 150                 #self.Layout()
 151
 152         def OnProgress(self, value, max):
 153                 wx.CallAfter(self.progressGauge.SetRange, max)
 154                 wx.CallAfter(self.progressGauge.SetValue, value)
 155                 taskbar.setProgress(self.GetParent(), value, max)
 156
 157         def OnOk(self, e):
 158                 self.Close()
 159                 taskbar.setBusy(self.GetParent(), False)
 160
 161         def OnClose(self, e):
 162                 self.Destroy()
 163
 164
 165 class AutoUpdateFirmware(wx.Dialog):
 166         def __init__(self, parent, filename = None, port = None, machineIndex = None):
 167                 super(AutoUpdateFirmware, self).__init__(parent=parent, title="Auto Firmware install", size=(250, 100))
 168                 if port is None:
 169                         port = profile.getMachineSetting('serial_port')
 170
 171                 sizer = wx.BoxSizer(wx.VERTICAL)
 172
 173                 self.progressLabel = wx.StaticText(self, -1, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nX\nX')
 174                 sizer.Add(self.progressLabel, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
 175                 self.progressGauge = wx.Gauge(self, -1)
 176                 sizer.Add(self.progressGauge, 0, flag=wx.EXPAND)
 177                 self.okButton = wx.Button(self, -1, _("OK"))
 178                 self.okButton.Bind(wx.EVT_BUTTON, self.OnOk)
 179                 sizer.Add(self.okButton, 0, flag=wx.ALIGN_CENTER|wx.ALL, border=5)
 180                 self.SetSizer(sizer)
 181
 182                 self.filename = filename
 183                 self.port = port
 184
 185                 self.Layout()
 186                 self.Fit()
 187
 188                 self.thread = threading.Thread(target=self.OnRun)
 189                 self.thread.daemon = True
 190                 self.thread.start()
 191
 192                 self.ShowModal()
 193                 self.Destroy()
 194                 return
 195
 196         def OnRun(self):
 197                 mtime = 0
 198                 while bool(self):
 199                         new_mtime = os.stat(self.filename).st_mtime
 200                         if mtime != new_mtime:
 201                                 mtime = new_mtime
 202                                 time.sleep(0.5)
 203                                 self.OnInstall()
 204                         time.sleep(0.5)
 205
 206         def OnInstall(self):
 207                 wx.CallAfter(self.okButton.Disable)
 208                 wx.CallAfter(self.updateLabel, _("Reading firmware..."))
 209                 hexFile = intelHex.readHex(self.filename)
 210                 wx.CallAfter(self.updateLabel, _("Connecting to machine..."))
 211                 programmer = stk500v2.Stk500v2()
 212                 programmer.progressCallback = self.OnProgress
 213                 if self.port == 'AUTO':
 214                         wx.CallAfter(self.updateLabel, _("Please connect the printer to\nyour computer with the USB cable."))
 215                         while not programmer.isConnected():
 216                                 for self.port in machineCom.serialList(True):
 217                                         try:
 218                                                 programmer.connect(self.port)
 219                                                 break
 220                                         except ispBase.IspError:
 221                                                 pass
 222                                 time.sleep(1)
 223                                 if not self:
 224                                         #Window destroyed
 225                                         return
 226                 else:
 227                         try:
 228                                 programmer.connect(self.port)
 229                         except ispBase.IspError:
 230                                 pass
 231
 232                 if not programmer.isConnected():
 233                         wx.CallAfter(self.updateLabel, _("Failed to connect to programmer.\n"))
 234                         return
 235
 236                 wx.CallAfter(self.updateLabel, _("Uploading firmware..."))
 237                 try:
 238                         programmer.programChip(hexFile)
 239                         wx.CallAfter(self.updateLabel, _("Done!\nInstalled firmware: %s") % (os.path.basename(self.filename)))
 240                 except ispBase.IspError as e:
 241                         wx.CallAfter(self.updateLabel, _("Failed to write firmware.\n") + str(e))
 242
 243                 programmer.close()
 244                 wx.CallAfter(self.okButton.Enable)
 245
 246         def updateLabel(self, text):
 247                 self.progressLabel.SetLabel(text)
 248                 #self.Layout()
 249
 250         def OnProgress(self, value, max):
 251                 wx.CallAfter(self.progressGauge.SetRange, max)
 252                 wx.CallAfter(self.progressGauge.SetValue, value)
 253                 taskbar.setProgress(self.GetParent(), value, max)
 254
 255         def OnOk(self, e):
 256                 self.Close()
 257                 taskbar.setBusy(self.GetParent(), False)
 258
 259         def OnClose(self, e):
 260                 self.Destroy()
 261