Initial commit

.gitignore

@@ -0,0 +1 @@
+.DS_Store

bed-leveling.py

@@ -0,0 +1,707 @@
+#!/usr/bin/env python
+
+#
+# bed-leveling.py
+#
+# Written in June 2016 by:
+# Thomas Buck <xythobuz@xythobuz.de>
+#
+# Manual Mesh Bed Leveling GUI utility for 3D printers with Marlin Firmware.
+# At the time of me writing this program, Marlin had a bug that caused the
+# manual mesh bed leveling process to not work using the connected LCD display,
+# leaving G-Codes sent over the serial port as the only option. Because manually
+# inserting these in a terminal program proved to be very tedious, and none of the
+# G-Code senders I've tested had the features I wanted (mainly easily configurable
+# step sizes), I've wrote this simple little program.
+#
+# After starting the program, select the serial port connected to your printer,
+# the correct baudrate for communicating with it and press Connect.
+# The X, Y and Z value displayed are periodically polled from the printer and
+# are not very accurate. Zc is what is manipulated using the up- and down-arrow
+# buttons or keys. The value shown there will be more accurate.
+#
+# Before starting with the leveling procedure, the current Mesh info has to be
+# polled from the printer. This will happen automatically after connecting.
+# When ready, press Start, then adjust the Z-height for each measuring point
+# and press Next or the right-arrow key to move on. After you're finished,
+# you should store the new mesh data in the EEPROM using the Save button.
+#
+# Dependencies:
+#  - pySerial (>= v3.0)
+#  - wxPython
+#
+# This has been developed and tested on a Mac OS X 10.10.5 machine
+# with Python 2.7 and dependencies installed with MacPorts,
+# connected to a modified Fabrikator Mini V1.5 with Marlin 1.1.0-RC6.
+#
+
+import wx
+import serial
+import serial.threaded
+import serial.tools.list_ports
+import re
+
+POLL_SERIAL_PORTS_INTERVALL = 4000
+POLL_COORDINATES_INTERVALL = 2500
+POLL_TEMPERATURE_INTERVALL = 3000
+MESH_DATA_RETRY_TIMEOUT = 2000
+BUSY_PROCESSING_STEPS = 6;
+AVAILABLE_BAUD_RATES = ["2400", "9600", "19200", "38400", "57600", "115200", "250000"]
+DEFAULT_BAUD_RATE = "115200"
+DEFAULT_SERIAL_PORTS = ["/dev/cu.usbserial-AI02LQH7", "/dev/cu.SLAB_USBtoUART"]
+
+GCODE_EEPROM_SAVE = "M500"
+GCODE_STOP_IDLE_HOLD = "M84"
+GCODE_MOVE_TO_ORIGIN = "G28"
+GCODE_GET_CURRENT_POSITION = "M114"
+GCODE_MESH_INFO = "G29 S0"
+GCODE_MESH_START = "G29 S1"
+GCODE_MESH_NEXT = "G29 S2"
+GCODE_MOVE_Z = "G1 Z{}"
+GCODE_SET_BED_TEMP = "M140 S{}"
+GCODE_GET_TEMP = "M105"
+
+PRINTER_RESPONSE_OK = "ok"
+PRINTER_RESPONSE_BUSY = "echo:busy: processing"
+PRINTER_REGEX_COORDINATES = "^X:\d+\.\d+ Y:\d+\.\d+ Z:\d+\.\d+ E:\d+\.\d+ Count X:\s*\d+ Y:\s*\d+ Z:\s*\d+$"
+PRINTER_REGEX_MESH_POINTS = "^Num X,Y: \d,\d$"
+PRINTER_REGEX_MESH_Z = "^Z search height: \d\.*\d*$"
+PRINTER_REGEX_TEMP = "^ok T:\d\d*\.*\d* \/\d\d*\.*\d* B:\d\d*\.*\d* \/\d\d*\.*\d* B@:\d\d*\.*\d* @:\d\d*\.*\d*$"
+
+# Event for sending new XYZ coordinates from the serial thread to the GUI thread
+myEVT_COORDINATES = wx.NewEventType()
+EVT_COORDINATES = wx.PyEventBinder(myEVT_COORDINATES, 1)
+class CoordinatesEvent(wx.PyCommandEvent):
+    def __init__(self, etype, eid, value = None):
+        wx.PyCommandEvent.__init__(self, etype, eid)
+        self.value = value
+
+    def GetValue(self):
+        return self.value
+
+# Event for sending new mesh point info
+myEVT_MESH_POINTS = wx.NewEventType()
+EVT_MESH_POINTS = wx.PyEventBinder(myEVT_MESH_POINTS, 1)
+class MeshPointEvent(wx.PyCommandEvent):
+    def __init__(self, etype, eid, x = None, y = None):
+        wx.PyCommandEvent.__init__(self, etype, eid)
+        self.x = x
+        self.y = y
+
+    def GetX(self):
+        return self.x
+
+    def GetY(self):
+        return self.y
+
+# Event for sending new mesh point info
+myEVT_MESH_Z = wx.NewEventType()
+EVT_MESH_Z = wx.PyEventBinder(myEVT_MESH_Z, 1)
+class MeshZEvent(wx.PyCommandEvent):
+    def __init__(self, etype, eid, z = None):
+        wx.PyCommandEvent.__init__(self, etype, eid)
+        self.z = z
+
+    def GetZ(self):
+        return self.z
+
+# Event for sending temperature info
+myEVT_TEMPERATURE = wx.NewEventType()
+EVT_TEMPERATURE = wx.PyEventBinder(myEVT_TEMPERATURE, 1)
+class TemperatureEvent(wx.PyCommandEvent):
+    def __init__(self, etype, eid, bed = None):
+        wx.PyCommandEvent.__init__(self, etype, eid)
+        self.bed = bed
+
+    def GetBed(self):
+        return self.bed
+
+# Event for sending a new busy indicator status update
+myEVT_STATUS = wx.NewEventType()
+EVT_STATUS = wx.PyEventBinder(myEVT_STATUS, 1)
+class StatusEvent(wx.PyCommandEvent):
+    def __init__(self, etype, eid, value = None):
+        wx.PyCommandEvent.__init__(self, etype, eid)
+        self.value = value
+
+    def GetValue(self):
+        return self.value
+
+# Serial Thread reading from and writing to the printer, line-based
+class GCodeReader(serial.threaded.LineReader):
+
+    TERMINATOR = b'\n'
+
+    regexCoordinates = re.compile(PRINTER_REGEX_COORDINATES, re.M)
+    regexMeshPoints = re.compile(PRINTER_REGEX_MESH_POINTS, re.M)
+    regexMeshZ = re.compile(PRINTER_REGEX_MESH_Z, re.M)
+    regexTemp = re.compile(PRINTER_REGEX_TEMP, re.M)
+
+    def setParent(self, parent):
+        self.parent = parent
+
+    def handle_line(self, data):
+        if data == PRINTER_RESPONSE_OK:
+            event = StatusEvent(myEVT_STATUS, -1, 0)
+            wx.PostEvent(self.parent, event)
+            return
+
+        if data == PRINTER_RESPONSE_BUSY:
+            event = StatusEvent(myEVT_STATUS, -1, 1)
+            wx.PostEvent(self.parent, event)
+            return
+
+        if self.regexCoordinates.match(data):
+            afterX = data.split("X:")[1]
+            x = afterX.split(" ")[0]
+            afterY = data.split("Y:")[1]
+            y = afterY.split(" ")[0]
+            afterZ = data.split("Z:")[1]
+            z = afterZ.split(" ")[0]
+            str = "X: {} Y: {} Z: {}".format(x, y, z)
+            event = CoordinatesEvent(myEVT_COORDINATES, -1, str)
+            wx.PostEvent(self.parent, event)
+            return
+
+        if self.regexMeshPoints.match(data):
+            firstDigit = data.split("X,Y: ")[1]
+            x = firstDigit.split(",")[0]
+            y = firstDigit.split(",")[1]
+            event = MeshPointEvent(myEVT_MESH_POINTS, -1, x, y)
+            wx.PostEvent(self.parent, event)
+            return
+
+        if self.regexMeshZ.match(data):
+            num = data.split("Z search height: ")[1]
+            event = MeshZEvent(myEVT_MESH_Z, -1, float(num))
+            wx.PostEvent(self.parent, event)
+            return
+
+        if self.regexTemp.match(data):
+            bed = data.split(" B:")[1]
+            temp = bed.split(" /")[0]
+            event = TemperatureEvent(myEVT_TEMPERATURE, -1, float(temp))
+            wx.PostEvent(self.parent, event)
+            return
+
+# Main Window class
+class WizardFrame(wx.Frame):
+    def __init__(self, *args, **kwargs):
+        wx.Frame.__init__(self, *args, **kwargs)
+
+        self.hasQuit = False
+        self.isConnected = False
+        self.serial = serial.Serial()
+        self.thread = serial.threaded.ReaderThread(self.serial, GCodeReader)
+        self.isLeveling = False
+        self.currentPoint = 0
+        self.meshPoints = -1
+        self.step = 0.025
+        self.currentZ = 0.0
+        self.startZ = 0.0
+
+        self.Bind(EVT_COORDINATES, self.OnCoordinates)
+        self.Bind(EVT_STATUS, self.OnStatus)
+        self.Bind(EVT_MESH_POINTS, self.OnMeshPoints)
+        self.Bind(EVT_MESH_Z, self.OnMeshZ)
+        self.Bind(EVT_TEMPERATURE, self.OnTemperature)
+
+        # Menubar and Items
+        MenuBar = wx.MenuBar()
+        FileMenu = wx.Menu()
+        MenuBar.Append(FileMenu, "&File")
+        self.SetMenuBar(MenuBar)
+        item = FileMenu.Append(wx.ID_EXIT, text = "&Exit")
+        self.Bind(wx.EVT_MENU, self.OnQuit, item)
+        self.Bind(wx.EVT_CLOSE, self.OnQuit)
+        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        outerPanelSizer = wx.BoxSizer(wx.VERTICAL)
+
+        # Panel for serial control widgets
+        self.panelSerial = wx.Panel(self)
+        panelSerialSizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.panelSerial.SetSizer(panelSerialSizer)
+        outerPanelSizer.Add(self.panelSerial, 0, wx.TOP | wx.EXPAND, 4)
+        self.panelSerial.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # List all available serial ports
+        serialPortList = serial.tools.list_ports.comports()
+        serialPortNames = []
+        for port in serialPortList:
+            serialPortNames.append(port[0])
+
+        # Combobox for serial ports
+        self.comboBoxSerial = wx.ComboBox(parent = self.panelSerial, choices = serialPortNames, style = wx.CB_READONLY)
+        self.comboBoxSerial.SetMinSize((200, -1))
+        panelSerialSizer.Add(self.comboBoxSerial, 1, wx.LEFT, 5)
+        self.comboBoxSerial.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Select default serial port(s)
+        for port in serialPortList:
+            if port[0] in DEFAULT_SERIAL_PORTS:
+                self.comboBoxSerial.SetStringSelection(port[0])
+
+        # Regularly update serial port list
+        wx.FutureCall(POLL_SERIAL_PORTS_INTERVALL, self.EnumerateSerialPorts)
+
+        # Combobox for baudrates
+        self.comboBoxBaud = wx.ComboBox(parent = self.panelSerial, choices = AVAILABLE_BAUD_RATES, style = wx.CB_READONLY)
+        self.comboBoxBaud.SetMinSize((80, -1))
+        panelSerialSizer.Add(self.comboBoxBaud, 0)
+        self.comboBoxBaud.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        for baud in AVAILABLE_BAUD_RATES:
+            if baud == DEFAULT_BAUD_RATE:
+                self.comboBoxBaud.SetStringSelection(DEFAULT_BAUD_RATE)
+
+        # Button for connecting and disconnecting
+        self.buttonSerial = wx.Button(parent = self.panelSerial, label = "Connect")
+        self.buttonSerial.Bind(wx.EVT_BUTTON, self.OnConnectDisconnect)
+        panelSerialSizer.Add(self.buttonSerial, 0, wx.TOP, 2)
+        panelSerialSizer.AddSpacer(5)
+        self.buttonSerial.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Panel for status labels
+        self.panelStatus = wx.Panel(self)
+        panelStatusSizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.panelStatus.SetSizer(panelStatusSizer)
+        outerPanelSizer.Add(self.panelStatus, 0, wx.EXPAND | wx.TOP, 3)
+        self.panelStatus.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Labels for coordinates
+        self.labelX = wx.StaticText(parent = self.panelStatus, label = "X: ??.??")
+        panelStatusSizer.Add(self.labelX, 0, wx.LEFT, 5)
+        panelStatusSizer.AddStretchSpacer(1)
+        self.labelX.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        self.labelY = wx.StaticText(parent = self.panelStatus, label = "Y: ??.??")
+        panelStatusSizer.Add(self.labelY, 0)
+        panelStatusSizer.AddStretchSpacer(1)
+        self.labelY.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        self.labelZ = wx.StaticText(parent = self.panelStatus, label = "Z: ??.??")
+        panelStatusSizer.Add(self.labelZ, 0, wx.RIGHT, 5)
+        panelStatusSizer.AddStretchSpacer(1)
+        self.labelZ.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        self.labelZc = wx.StaticText(parent = self.panelStatus, label = "Zc: ??.???")
+        panelStatusSizer.Add(self.labelZc, 0, wx.RIGHT, 5)
+        self.labelZc.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Panel for general actions
+        self.panelAction = wx.Panel(self)
+        panelActionSizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.panelAction.SetSizer(panelActionSizer)
+        outerPanelSizer.Add(self.panelAction, 0, wx.EXPAND | wx.TOP, 5)
+        self.panelAction.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Button for homing
+        self.buttonHome = wx.Button(parent = self.panelAction, label = "Home")
+        self.buttonHome.Bind(wx.EVT_BUTTON, self.OnHome)
+        self.buttonHome.Enable(False)
+        panelActionSizer.AddSpacer(5)
+        panelActionSizer.Add(self.buttonHome, 0, wx.BOTTOM, 1)
+        self.buttonHome.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Button for steppers off
+        self.buttonOff = wx.Button(parent = self.panelAction, label = "Off")
+        self.buttonOff.Bind(wx.EVT_BUTTON, self.OnStepperOff)
+        self.buttonOff.Enable(False)
+        panelActionSizer.AddSpacer(5)
+        panelActionSizer.Add(self.buttonOff, 0, wx.BOTTOM, 1)
+        self.buttonOff.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Status Gauge
+        self.gauge = wx.Gauge(parent = self.panelAction)
+        self.gauge.SetRange(BUSY_PROCESSING_STEPS)
+        panelActionSizer.Add(self.gauge, 1, wx.LEFT | wx.RIGHT, 5)
+        self.gauge.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Bottom panel
+        self.panelBottom = wx.Panel(self)
+        panelBottomSizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.panelBottom.SetSizer(panelBottomSizer)
+        outerPanelSizer.Add(self.panelBottom, 0, wx.EXPAND | wx.TOP, 5)
+        self.panelBottom.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Config panel
+        self.panelConfig = wx.Panel(self.panelBottom)
+        panelConfigSizer = wx.BoxSizer(wx.VERTICAL)
+        self.panelConfig.SetSizer(panelConfigSizer)
+        panelBottomSizer.Add(self.panelConfig, 2, wx.EXPAND | wx.LEFT, 5)
+        self.panelConfig.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Step Size Label
+        stepSizeLabel = wx.StaticText(self.panelConfig, label="Step:")
+        panelConfigSizer.Add(stepSizeLabel, 0, wx.LEFT, 5)
+        stepSizeLabel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Step Size Text Input
+        self.stepSize = wx.TextCtrl(parent = self.panelConfig, value="0.025", style = wx.TE_DONTWRAP | wx.TE_PROCESS_ENTER)
+        self.stepSize.SetMinSize((65, -1))
+        self.stepSize.Enable(False)
+        self.stepSize.Bind(wx.EVT_TEXT_ENTER, self.OnNewStepSize)
+        panelConfigSizer.Add(self.stepSize, 0, wx.LEFT | wx.TOP, 5)
+
+        # Bed Temperature Label
+        self.bedTemperatureLabel = wx.StaticText(self.panelConfig, label="Bed: ??.?")
+        panelConfigSizer.Add(self.bedTemperatureLabel, 0, wx.LEFT | wx.TOP, 5)
+        self.bedTemperatureLabel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Bed Temperature Text Input
+        self.bedTemperature = wx.TextCtrl(parent = self.panelConfig, value="0", style = wx.TE_DONTWRAP | wx.TE_PROCESS_ENTER)
+        self.bedTemperature.SetMinSize((65, -1))
+        self.bedTemperature.Enable(False)
+        self.bedTemperature.Bind(wx.EVT_TEXT_ENTER, self.OnNewBedTemperature)
+        panelConfigSizer.Add(self.bedTemperature, 0, wx.LEFT | wx.TOP | wx.BOTTOM, 5)
+
+        # Control-Buttons Panel
+        self.panelControl = wx.Panel(self.panelBottom)
+        panelControlSizer = wx.BoxSizer(wx.VERTICAL)
+        self.panelControl.SetSizer(panelControlSizer)
+        panelBottomSizer.Add(self.panelControl, 2, wx.EXPAND | wx.LEFT, 5)
+        self.panelControl.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Up Button
+        self.buttonUp = wx.Button(parent = self.panelControl, label = "/\\")
+        self.buttonUp.Bind(wx.EVT_BUTTON, self.OnUp)
+        self.buttonUp.Enable(False)
+        panelControlSizer.AddStretchSpacer(1)
+        panelControlSizer.Add(self.buttonUp, 2, wx.ALIGN_CENTER_HORIZONTAL)
+        self.buttonUp.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Down Button
+        self.buttonDown = wx.Button(parent = self.panelControl, label = "\\/")
+        self.buttonDown.Bind(wx.EVT_BUTTON, self.OnDown)
+        self.buttonDown.Enable(False)
+        panelControlSizer.Add(self.buttonDown, 2, wx.ALIGN_CENTER_HORIZONTAL | wx.BOTTOM, 5)
+        panelControlSizer.AddStretchSpacer(1)
+        self.buttonDown.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Level Status Panel
+        self.panelLevelStatus = wx.Panel(self.panelBottom)
+        panelLevelStatusSizer = wx.BoxSizer(wx.VERTICAL)
+        self.panelLevelStatus.SetSizer(panelLevelStatusSizer)
+        panelBottomSizer.Add(self.panelLevelStatus, 1, wx.EXPAND)
+        self.panelLevelStatus.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Level Status Gauge
+        self.gaugeLevel = wx.Gauge(parent = self.panelLevelStatus, style = wx.GA_VERTICAL)
+        self.gaugeLevel.SetRange(1)
+        self.gaugeLevel.SetValue(1)
+        panelLevelStatusSizer.Add(self.gaugeLevel, 1, wx.ALIGN_CENTER_HORIZONTAL | wx.BOTTOM | wx.LEFT, 10)
+        self.gaugeLevel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Level Panel
+        self.panelLevel = wx.Panel(self.panelBottom)
+        panelLevelSizer = wx.BoxSizer(wx.VERTICAL)
+        self.panelLevel.SetSizer(panelLevelSizer)
+        panelBottomSizer.Add(self.panelLevel, 2, wx.EXPAND)
+        self.panelLevel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Start Button
+        self.buttonStart = wx.Button(parent = self.panelLevel, label = "Start")
+        self.buttonStart.Bind(wx.EVT_BUTTON, self.OnStart)
+        self.buttonStart.Enable(False)
+        panelLevelSizer.Add(self.buttonStart, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.TOP, 5)
+        self.buttonStart.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        # Next Button
+        self.buttonNext = wx.Button(parent = self.panelLevel, label = "Next")
+        self.buttonNext.Bind(wx.EVT_BUTTON, self.OnNext)
+        self.buttonNext.Enable(False)
+        panelLevelSizer.Add(self.buttonNext, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.TOP, 5)
+        self.buttonNext.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        self.buttonSave = wx.Button(parent = self.panelLevel, label = "Save")
+        self.buttonSave.Bind(wx.EVT_BUTTON, self.OnSave)
+        self.buttonSave.Enable(False)
+        panelLevelSizer.Add(self.buttonSave, 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.TOP | wx.BOTTOM, 5)
+        self.buttonSave.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+        self.SetSizerAndFit(outerPanelSizer)
+        #self.SetSizer(outerPanelSizer)
+
+    def EnumerateSerialPorts(self):
+        # List all available serial ports
+        serialPortList = serial.tools.list_ports.comports()
+
+        # Fill Combobox, remember selected value
+        selection = self.comboBoxSerial.GetValue()
+        self.comboBoxSerial.Clear()
+        for port in serialPortList:
+            self.comboBoxSerial.Append(port[0])
+            if port[0] == selection:
+                self.comboBoxSerial.SetStringSelection(selection)
+
+        # Select first port if nothing is selected
+        if not selection:
+            self.comboBoxSerial.SetStringSelection(serialPortList[0][0])
+
+        self.panelSerial.Layout()
+
+        # Check every 5 seconds for new available serial ports
+        wx.FutureCall(POLL_SERIAL_PORTS_INTERVALL, self.EnumerateSerialPorts)
+
+    def EnableDisableUI(self):
+        if not self.isConnected:
+            self.buttonSerial.SetLabel("Connect")
+            self.labelX.SetLabel("X: ??.??")
+            self.labelY.SetLabel("Y: ??.??")
+            self.labelZ.SetLabel("Z: ??.??")
+            self.labelZc.SetLabel("Zc: ??.???")
+        else:
+            self.buttonSerial.SetLabel("Disconnect")
+
+        self.panelStatus.Layout()
+        self.panelSerial.Layout()
+
+        self.comboBoxSerial.Enable(not self.isConnected)
+        self.comboBoxBaud.Enable(not self.isConnected)
+
+        self.buttonHome.Enable(self.isConnected)
+        self.buttonOff.Enable(self.isConnected)
+        self.buttonUp.Enable(self.isConnected)
+        self.buttonDown.Enable(self.isConnected)
+        self.stepSize.Enable(self.isConnected)
+        self.bedTemperature.Enable(self.isConnected)
+
+        self.buttonStart.Enable(False)
+        self.buttonNext.Enable(False)
+        self.buttonSave.Enable(False)
+        if self.isConnected:
+            if not self.isLeveling:
+                self.buttonSave.Enable(True)
+                if self.meshPoints > 0:
+                    self.buttonStart.Enable(True)
+
+            if self.isLeveling:
+                self.buttonNext.Enable(True)
+
+    def OnSave(self, event):
+        if self.isLeveling:
+            print "Leveling is already in progress!"
+            return
+
+        self.protocol.write_line(GCODE_EEPROM_SAVE)
+
+    def OnStart(self, event):
+        if self.isLeveling:
+            print "Leveling is already in progress!"
+            return
+
+        self.isLeveling = True
+        self.currentPoint = 0
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_MESH_START)
+        self.gaugeLevel.SetValue(0)
+        self.EnableDisableUI()
+
+    def OnNext(self, event):
+        if not self.isLeveling:
+            print "Start leveling before proceeding!"
+            return
+
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_MESH_NEXT)
+        self.currentPoint += 1
+        if self.currentPoint >= self.meshPoints:
+            self.isLeveling = False
+        self.gaugeLevel.SetValue(self.currentPoint)
+        self.EnableDisableUI()
+        self.currentZ = self.startZ
+        self.labelZc.SetLabel("Zc: {}".format(self.currentZ))
+        self.panelStatus.Layout()
+
+    def OnNewStepSize(self, event):
+        print "New Step Size: {}".format(self.stepSize.GetValue())
+        self.step = float(self.stepSize.GetValue())
+
+    def OnKeyDown(self, event):
+        key = event.GetKeyCode()
+
+        if self.isConnected:
+            if key == wx.WXK_DOWN:
+                self.OnDown(event)
+            elif key == wx.WXK_UP:
+                self.OnUp(event)
+            elif key == wx.WXK_RIGHT:
+                self.OnNext(event)
+
+    def OnUp(self, event):
+        self.currentZ += self.step
+        print "Moving up to {}".format(self.currentZ)
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_MOVE_Z.format(self.currentZ))
+        self.labelZc.SetLabel("Zc: {}".format(self.currentZ))
+        self.panelStatus.Layout()
+
+    def OnDown(self, event):
+        if self.currentZ <= 0.0:
+            print "Can't move further down!"
+            return
+
+        self.currentZ -= self.step
+        print "Moving down to {}".format(self.currentZ)
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_MOVE_Z.format(self.currentZ))
+        self.labelZc.SetLabel("Zc: {}".format(self.currentZ))
+        self.panelStatus.Layout()
+
+    def OnStepperOff(self, event):
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_STOP_IDLE_HOLD)
+
+    def OnHome(self, event):
+        self.gauge.SetValue(0)
+        self.protocol.write_line(GCODE_MOVE_TO_ORIGIN)
+
+    def OnStatus(self, event):
+        if event.GetValue() == 0:
+            self.OnDone(event)
+        else:
+            self.OnBusy(event)
+
+    def OnBusy(self, event):
+        val = self.gauge.GetValue()
+        if val < self.gauge.GetRange():
+            self.gauge.SetValue(val + 1)
+
+    def OnDone(self, event):
+        self.gauge.SetValue(self.gauge.GetRange())
+
+    def PollMeshData(self):
+        if self.isConnected:
+            self.protocol.write_line(GCODE_MESH_INFO)
+
+    def PollMeshDataRetry(self):
+        if self.meshPoints <= 0:
+            self.PollMeshData()
+            wx.FutureCall(MESH_DATA_RETRY_TIMEOUT, self.PollMeshDataRetry)
+
+    def OnMeshPoints(self, event):
+        x = int(event.GetX())
+        y = int(event.GetY())
+        self.meshPoints = x * y
+        print "Mesh Points: X: {} Y: {} --> {}".format(x, y, self.meshPoints)
+        self.gaugeLevel.SetRange(self.meshPoints)
+        self.gaugeLevel.SetValue(0)
+        self.EnableDisableUI()
+
+    def OnMeshZ(self, event):
+        self.startZ = float(event.GetZ())
+        self.currentZ = float(event.GetZ())
+        self.labelZc.SetLabel("Zc: {}".format(self.currentZ))
+        self.gauge.SetValue(BUSY_PROCESSING_STEPS)
+        print "Mesh starting height: {}".format(self.currentZ)
+
+    def PollPosition(self):
+        if self.isConnected:
+            #if not self.isLeveling:
+            self.protocol.write_line(GCODE_GET_CURRENT_POSITION)
+            wx.FutureCall(POLL_COORDINATES_INTERVALL, self.PollPosition)
+
+    def OnCoordinates(self, event):
+        data = event.GetValue()
+        print "New coordinates {}".format(data)
+        afterX = data.split("X: ")[1]
+        x = afterX.split(" ")[0]
+        afterY = data.split("Y: ")[1]
+        y = afterY.split(" ")[0]
+        afterZ = data.split("Z: ")[1]
+        z = afterZ.split(" ")[0]
+
+        self.labelX.SetLabel("X: {}".format(x))
+        self.labelY.SetLabel("Y: {}".format(y))
+        self.labelZ.SetLabel("Z: {}".format(z))
+
+        self.panelStatus.Layout()
+
+    def OnTemperature(self, event):
+        print "Current Bed Temperature: {}".format(event.GetBed())
+        self.bedTemperatureLabel.SetLabel("Bed: {}".format(event.GetBed()))
+
+    def OnNewBedTemperature(self, event):
+        self.protocol.write_line(GCODE_SET_BED_TEMP.format(float(self.bedTemperature.GetValue())))
+
+    def PollTemperature(self):
+        if self.isConnected:
+            self.protocol.write_line(GCODE_GET_TEMP)
+            wx.FutureCall(POLL_TEMPERATURE_INTERVALL, self.PollTemperature)
+
+    def OnConnectDisconnect(self, Event):
+        self.isLeveling = False
+        self.currentPoint = 0
+        if self.isConnected:
+            self.thread.close()
+            self.serial.close()
+            self.isConnected = False
+            self.gauge.SetValue(0)
+            self.gaugeLevel.SetRange(1)
+            self.gaugeLevel.SetValue(1)
+            self.EnableDisableUI()
+
+            # Recreate thread, so we can start it again next time
+            self.thread = serial.threaded.ReaderThread(self.serial, GCodeReader)
+        else:
+            self.serial.baudrate = self.comboBoxBaud.GetValue()
+            self.serial.port = self.comboBoxSerial.GetValue()
+            try:
+                self.serial.open()
+            except serial.SerialException as msg:
+                wx.MessageBox("SerialException: {}".format(msg), "Error", wx.OK | wx.ICON_ERROR)
+            except OSError as msg:
+                wx.MessageBox("OSError: {}".format(msg), "Error", wx.OK | wx.ICON_ERROR)
+            if self.serial.isOpen():
+                self.isConnected = True
+                self.thread.start()
+                self.transport, self.protocol = self.thread.connect()
+                self.protocol.setParent(self)
+                self.meshPoints = -1
+                self.EnableDisableUI()
+                self.PollPosition()
+                self.PollMeshData()
+                self.PollTemperature()
+                wx.FutureCall(MESH_DATA_RETRY_TIMEOUT, self.PollMeshDataRetry)
+
+    def OnQuit(self, Event):
+        if not self.hasQuit:
+            self.hasQuit = True
+            if self.isConnected:
+                print("Closing serial port...")
+                self.thread.close()
+                self.serial.close()
+                self.isConnected = False
+        self.Destroy()
+
+# App wrapper class
+class WizardApp(wx.App):
+    def __init__(self, *args, **kwargs):
+        wx.App.__init__(self, *args, **kwargs)
+        self.Bind(wx.EVT_ACTIVATE_APP, self.OnActivate)
+
+    def OnInit(self):
+        frame = WizardFrame(parent = None, title = "Bed Leveling Wizard", style = wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX | wx.CLIP_CHILDREN)
+        frame.Centre()
+        frame.Show()
+        return True
+
+    def BringWindowToFront(self):
+        self.GetTopWindow().Raise()
+
+    def OnActivate(self, event):
+        if event.GetActive():
+            self.BringWindowToFront()
+        event.Skip()
+
+    def MacReopenApp(self):
+        self.BringWindowToFront()
+
+def main():
+    app = WizardApp(False)
+    app.MainLoop()
+
+if __name__ == '__main__':
+    main()
+