diff --git a/Code/Pyborg_Robot_Scripts/UltraBorg.py b/Code/Pyborg_Robot_Scripts/UltraBorg.py
deleted file mode 100644
index b259db6f87b04c610eee63571070f7e8c78011db..0000000000000000000000000000000000000000
--- a/Code/Pyborg_Robot_Scripts/UltraBorg.py
+++ /dev/null
@@ -1,1840 +0,0 @@
-#!/usr/bin/env python
-# coding: latin-1
-"""
-This module is designed to communicate with the UltraBorg
-
-Use by creating an instance of the class, call the Init function, then command as desired, e.g.
-import UltraBorg
-UB = UltraBorg.UltraBorg()
-UB.Init()
-# User code here, use UB to control the board
-
-Multiple boards can be used when configured with different I²C addresses by creating multiple instances, e.g.
-import UltraBorg
-UB1 = UltraBorg.UltraBorg()
-UB2 = UltraBorg.UltraBorg()
-UB1.i2cAddress = 0x44
-UB2.i2cAddress = 0x45
-UB1.Init()
-UB2.Init()
-# User code here, use UB1 and UB2 to control each board separately
-
-For explanations of the functions available call the Help function, e.g.
-import UltraBorg
-UB = UltraBorg.UltraBorg()
-UB.Help()
-See the website at www.piborg.org/ultraborg for more details
-"""
-
-# Import the libraries we need
-import io
-import fcntl
-import types
-import time
-
-# Constant values
-I2C_SLAVE                   = 0x0703
-I2C_MAX_LEN             = 4
-USM_US_TO_MM            = 0.171500
-PWM_MIN                 = 2000  # Should be a 1 ms burst, typical servo minimum
-PWM_MAX                 = 4000  # Should be a 2 ms burst, typical servo maximum
-DELAY_AFTER_EEPROM      = 0.01  # Time to wait after updating an EEPROM value before reading
-PWM_UNSET               = 0xFFFF
-
-I2C_ID_SERVO_USM        = 0x36
-
-COMMAND_GET_TIME_USM1   = 1     # Get the time measured by ultrasonic #1 in us (0 for no detection)
-COMMAND_GET_TIME_USM2   = 2     # Get the time measured by ultrasonic #2 in us (0 for no detection)
-COMMAND_GET_TIME_USM3   = 3     # Get the time measured by ultrasonic #3 in us (0 for no detection)
-COMMAND_GET_TIME_USM4   = 4     # Get the time measured by ultrasonic #4 in us (0 for no detection)
-COMMAND_SET_PWM1        = 5     # Set the PWM duty cycle for drive #1 (16 bit)
-COMMAND_GET_PWM1        = 6     # Get the PWM duty cycle for drive #1 (16 bit)
-COMMAND_SET_PWM2        = 7     # Set the PWM duty cycle for drive #2 (16 bit)
-COMMAND_GET_PWM2        = 8     # Get the PWM duty cycle for drive #2 (16 bit)
-COMMAND_SET_PWM3        = 9     # Set the PWM duty cycle for drive #3 (16 bit)
-COMMAND_GET_PWM3        = 10    # Get the PWM duty cycle for drive #3 (16 bit)
-COMMAND_SET_PWM4        = 11    # Set the PWM duty cycle for drive #4 (16 bit)
-COMMAND_GET_PWM4        = 12    # Get the PWM duty cycle for drive #4 (16 bit)
-COMMAND_CALIBRATE_PWM1  = 13    # Set the PWM duty cycle for drive #1 (16 bit, ignores limit checks)
-COMMAND_CALIBRATE_PWM2  = 14    # Set the PWM duty cycle for drive #2 (16 bit, ignores limit checks)
-COMMAND_CALIBRATE_PWM3  = 15    # Set the PWM duty cycle for drive #3 (16 bit, ignores limit checks)
-COMMAND_CALIBRATE_PWM4  = 16    # Set the PWM duty cycle for drive #4 (16 bit, ignores limit checks)
-COMMAND_GET_PWM_MIN_1   = 17    # Get the minimum allowed PWM duty cycle for drive #1
-COMMAND_GET_PWM_MAX_1   = 18    # Get the maximum allowed PWM duty cycle for drive #1
-COMMAND_GET_PWM_BOOT_1  = 19    # Get the startup PWM duty cycle for drive #1
-COMMAND_GET_PWM_MIN_2   = 20    # Get the minimum allowed PWM duty cycle for drive #2
-COMMAND_GET_PWM_MAX_2   = 21    # Get the maximum allowed PWM duty cycle for drive #2
-COMMAND_GET_PWM_BOOT_2  = 22    # Get the startup PWM duty cycle for drive #2
-COMMAND_GET_PWM_MIN_3   = 23    # Get the minimum allowed PWM duty cycle for drive #3
-COMMAND_GET_PWM_MAX_3   = 24    # Get the maximum allowed PWM duty cycle for drive #3
-COMMAND_GET_PWM_BOOT_3  = 25    # Get the startup PWM duty cycle for drive #3
-COMMAND_GET_PWM_MIN_4   = 26    # Get the minimum allowed PWM duty cycle for drive #4
-COMMAND_GET_PWM_MAX_4   = 27    # Get the maximum allowed PWM duty cycle for drive #4
-COMMAND_GET_PWM_BOOT_4  = 28    # Get the startup PWM duty cycle for drive #4
-COMMAND_SET_PWM_MIN_1   = 29    # Set the minimum allowed PWM duty cycle for drive #1
-COMMAND_SET_PWM_MAX_1   = 30    # Set the maximum allowed PWM duty cycle for drive #1
-COMMAND_SET_PWM_BOOT_1  = 31    # Set the startup PWM duty cycle for drive #1
-COMMAND_SET_PWM_MIN_2   = 32    # Set the minimum allowed PWM duty cycle for drive #2
-COMMAND_SET_PWM_MAX_2   = 33    # Set the maximum allowed PWM duty cycle for drive #2
-COMMAND_SET_PWM_BOOT_2  = 34    # Set the startup PWM duty cycle for drive #2
-COMMAND_SET_PWM_MIN_3   = 35    # Set the minimum allowed PWM duty cycle for drive #3
-COMMAND_SET_PWM_MAX_3   = 36    # Set the maximum allowed PWM duty cycle for drive #3
-COMMAND_SET_PWM_BOOT_3  = 37    # Set the startup PWM duty cycle for drive #3
-COMMAND_SET_PWM_MIN_4   = 38    # Set the minimum allowed PWM duty cycle for drive #4
-COMMAND_SET_PWM_MAX_4   = 39    # Set the maximum allowed PWM duty cycle for drive #4
-COMMAND_SET_PWM_BOOT_4  = 40    # Set the startup PWM duty cycle for drive #4
-COMMAND_GET_FILTER_USM1 = 41    # Get the filtered time measured by ultrasonic #1 in us (0 for no detection)
-COMMAND_GET_FILTER_USM2 = 42    # Get the filtered time measured by ultrasonic #2 in us (0 for no detection)
-COMMAND_GET_FILTER_USM3 = 43    # Get the filtered time measured by ultrasonic #3 in us (0 for no detection)
-COMMAND_GET_FILTER_USM4 = 44    # Get the filtered time measured by ultrasonic #4 in us (0 for no detection)
-COMMAND_GET_ID          = 0x99  # Get the board identifier
-COMMAND_SET_I2C_ADD     = 0xAA  # Set a new I2C address
-
-COMMAND_VALUE_FWD       = 1     # I2C value representing forward
-COMMAND_VALUE_REV       = 2     # I2C value representing reverse
-
-COMMAND_VALUE_ON        = 1     # I2C value representing on
-COMMAND_VALUE_OFF       = 0     # I2C value representing off
-
-
-def ScanForUltraBorg(busNumber = 1):
-    """
-ScanForUltraBorg([busNumber])
-
-Scans the I²C bus for a UltraBorg boards and returns a list of all usable addresses
-The busNumber if supplied is which I²C bus to scan, 0 for Rev 1 boards, 1 for Rev 2 boards, if not supplied the default is 1
-    """
-    found = []
-    print 'Scanning I²C bus #%d' % (busNumber)
-    bus = UltraBorg()
-    for address in range(0x03, 0x78, 1):
-        try:
-            bus.InitBusOnly(busNumber, address)
-            i2cRecv = bus.RawRead(COMMAND_GET_ID, I2C_MAX_LEN)
-            if len(i2cRecv) == I2C_MAX_LEN:
-                if i2cRecv[1] == I2C_ID_SERVO_USM:
-                    print 'Found UltraBorg at %02X' % (address)
-                    found.append(address)
-                else:
-                    pass
-            else:
-                pass
-        except KeyboardInterrupt:
-            raise
-        except:
-            pass
-    if len(found) == 0:
-        print 'No UltraBorg boards found, is bus #%d correct (should be 0 for Rev 1, 1 for Rev 2)' % (busNumber)
-    elif len(found) == 1:
-        print '1 UltraBorg board found'
-    else:
-        print '%d UltraBorg boards found' % (len(found))
-    return found
-
-
-def SetNewAddress(newAddress, oldAddress = -1, busNumber = 1):
-    """
-SetNewAddress(newAddress, [oldAddress], [busNumber])
-
-Scans the I²C bus for the first UltraBorg and sets it to a new I2C address
-If oldAddress is supplied it will change the address of the board at that address rather than scanning the bus
-The busNumber if supplied is which I²C bus to scan, 0 for Rev 1 boards, 1 for Rev 2 boards, if not supplied the default is 1
-Warning, this new I²C address will still be used after resetting the power on the device
-    """
-    if newAddress < 0x03:
-        print 'Error, I²C addresses below 3 (0x03) are reserved, use an address between 3 (0x03) and 119 (0x77)'
-        return
-    elif newAddress > 0x77:
-        print 'Error, I²C addresses above 119 (0x77) are reserved, use an address between 3 (0x03) and 119 (0x77)'
-        return
-    if oldAddress < 0x0:
-        found = ScanForUltraBorg(busNumber)
-        if len(found) < 1:
-            print 'No UltraBorg boards found, cannot set a new I²C address!'
-            return
-        else:
-            oldAddress = found[0]
-    print 'Changing I²C address from %02X to %02X (bus #%d)' % (oldAddress, newAddress, busNumber)
-    bus = UltraBorg()
-    bus.InitBusOnly(busNumber, oldAddress)
-    try:
-        i2cRecv = bus.RawRead(COMMAND_GET_ID, I2C_MAX_LEN)
-        if len(i2cRecv) == I2C_MAX_LEN:
-            if i2cRecv[1] == I2C_ID_SERVO_USM:
-                foundChip = True
-                print 'Found UltraBorg at %02X' % (oldAddress)
-            else:
-                foundChip = False
-                print 'Found a device at %02X, but it is not a UltraBorg (ID %02X instead of %02X)' % (oldAddress, i2cRecv[1], I2C_ID_SERVO_USM)
-        else:
-            foundChip = False
-            print 'Missing UltraBorg at %02X' % (oldAddress)
-    except KeyboardInterrupt:
-        raise
-    except:
-        foundChip = False
-        print 'Missing UltraBorg at %02X' % (oldAddress)
-    if foundChip:
-        bus.RawWrite(COMMAND_SET_I2C_ADD, [newAddress])
-        time.sleep(0.1)
-        print 'Address changed to %02X, attempting to talk with the new address' % (newAddress)
-        try:
-            bus.InitBusOnly(busNumber, newAddress)
-            i2cRecv = bus.RawRead(COMMAND_GET_ID, I2C_MAX_LEN)
-            if len(i2cRecv) == I2C_MAX_LEN:
-                if i2cRecv[1] == I2C_ID_SERVO_USM:
-                    foundChip = True
-                    print 'Found UltraBorg at %02X' % (newAddress)
-                else:
-                    foundChip = False
-                    print 'Found a device at %02X, but it is not a UltraBorg (ID %02X instead of %02X)' % (newAddress, i2cRecv[1], I2C_ID_SERVO_USM)
-            else:
-                foundChip = False
-                print 'Missing UltraBorg at %02X' % (newAddress)
-        except KeyboardInterrupt:
-            raise
-        except:
-            foundChip = False
-            print 'Missing UltraBorg at %02X' % (newAddress)
-    if foundChip:
-        print 'New I²C address of %02X set successfully' % (newAddress)
-    else:
-        print 'Failed to set new I²C address...'
-
-
-# Class used to control UltraBorg
-class UltraBorg:
-    """
-This module is designed to communicate with the UltraBorg
-
-busNumber               I²C bus on which the UltraBorg is attached (Rev 1 is bus 0, Rev 2 is bus 1)
-bus                     the smbus object used to talk to the I²C bus
-i2cAddress              The I²C address of the UltraBorg chip to control
-foundChip               True if the UltraBorg chip can be seen, False otherwise
-printFunction           Function reference to call when printing text, if None "print" is used
-    """
-
-    # Shared values used by this class
-    busNumber               = 1                 # Check here for Rev 1 vs Rev 2 and select the correct bus
-    i2cAddress              = I2C_ID_SERVO_USM  # I²C address, override for a different address
-    foundChip               = False
-    printFunction           = None
-    i2cWrite                = None
-    i2cRead                 = None
-
-    # Default calibration adjustments to standard values
-    PWM_MIN_1               = PWM_MIN
-    PWM_MAX_1               = PWM_MAX
-    PWM_MIN_2               = PWM_MIN
-    PWM_MAX_2               = PWM_MAX
-    PWM_MIN_3               = PWM_MIN
-    PWM_MAX_3               = PWM_MAX
-    PWM_MIN_4               = PWM_MIN
-    PWM_MAX_4               = PWM_MAX
-
-    def RawWrite(self, command, data):
-        """
-RawWrite(command, data)
-
-Sends a raw command on the I2C bus to the UltraBorg
-Command codes can be found at the top of UltraBorg.py, data is a list of 0 or more byte values
-
-Under most circumstances you should use the appropriate function instead of RawWrite
-        """
-        rawOutput = chr(command)
-        for singleByte in data:
-            rawOutput += chr(singleByte)
-        self.i2cWrite.write(rawOutput)
-
-
-    def RawRead(self, command, length, retryCount = 3):
-        """
-RawRead(command, length, [retryCount])
-
-Reads data back from the UltraBorg after sending a GET command
-Command codes can be found at the top of UltraBorg.py, length is the number of bytes to read back
-
-The function checks that the first byte read back matches the requested command
-If it does not it will retry the request until retryCount is exhausted (default is 3 times)
-
-Under most circumstances you should use the appropriate function instead of RawRead
-        """
-        while retryCount > 0:
-            self.RawWrite(command, [])
-            time.sleep(0.000001)
-            rawReply = self.i2cRead.read(length)
-            reply = []
-            for singleByte in rawReply:
-                reply.append(ord(singleByte))
-            if command == reply[0]:
-                break
-            else:
-                retryCount -= 1
-        if retryCount > 0:
-            return reply
-        else:
-            raise IOError('I2C read for command %d failed' % (command))
-
-
-    def InitBusOnly(self, busNumber, address):
-        """
-InitBusOnly(busNumber, address)
-
-Prepare the I2C driver for talking to a UltraBorg on the specified bus and I2C address
-This call does not check the board is present or working, under most circumstances use Init() instead
-        """
-        self.busNumber = busNumber
-        self.i2cAddress = address
-        self.i2cRead = io.open("/dev/i2c-" + str(self.busNumber), "rb", buffering = 0)
-        fcntl.ioctl(self.i2cRead, I2C_SLAVE, self.i2cAddress)
-        self.i2cWrite = io.open("/dev/i2c-" + str(self.busNumber), "wb", buffering = 0)
-        fcntl.ioctl(self.i2cWrite, I2C_SLAVE, self.i2cAddress)
-
-
-    def Print(self, message):
-        """
-Print(message)
-
-Wrapper used by the UltraBorg instance to print messages, will call printFunction if set, print otherwise
-        """
-        if self.printFunction == None:
-            print message
-        else:
-            self.printFunction(message)
-
-
-    def NoPrint(self, message):
-        """
-NoPrint(message)
-
-Does nothing, intended for disabling diagnostic printout by using:
-UB = UltraBorg.UltraBorg()
-UB.printFunction = UB.NoPrint
-        """
-        pass
-
-
-    def Init(self, tryOtherBus = False):
-        """
-Init([tryOtherBus])
-
-Prepare the I2C driver for talking to the UltraBorg
-
-If tryOtherBus is True, this function will attempt to use the other bus if the ThunderBorg devices can not be found on the current busNumber
-    This is only really useful for early Raspberry Pi models!
-        """
-        self.Print('Loading UltraBorg on bus %d, address %02X' % (self.busNumber, self.i2cAddress))
-
-        # Open the bus
-        self.i2cRead = io.open("/dev/i2c-" + str(self.busNumber), "rb", buffering = 0)
-        fcntl.ioctl(self.i2cRead, I2C_SLAVE, self.i2cAddress)
-        self.i2cWrite = io.open("/dev/i2c-" + str(self.busNumber), "wb", buffering = 0)
-        fcntl.ioctl(self.i2cWrite, I2C_SLAVE, self.i2cAddress)
-
-        # Check for UltraBorg
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_ID, I2C_MAX_LEN)
-            if len(i2cRecv) == I2C_MAX_LEN:
-                if i2cRecv[1] == I2C_ID_SERVO_USM:
-                    self.foundChip = True
-                    self.Print('Found UltraBorg at %02X' % (self.i2cAddress))
-                else:
-                    self.foundChip = False
-                    self.Print('Found a device at %02X, but it is not a UltraBorg (ID %02X instead of %02X)' % (self.i2cAddress, i2cRecv[1], I2C_ID_SERVO_USM))
-            else:
-                self.foundChip = False
-                self.Print('Missing UltraBorg at %02X' % (self.i2cAddress))
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.foundChip = False
-            self.Print('Missing UltraBorg at %02X' % (self.i2cAddress))
-
-        # See if we are missing chips
-        if not self.foundChip:
-            self.Print('UltraBorg was not found')
-            if tryOtherBus:
-                if self.busNumber == 1:
-                    self.busNumber = 0
-                else:
-                    self.busNumber = 1
-                self.Print('Trying bus %d instead' % (self.busNumber))
-                self.Init(False)
-            else:
-                self.Print('Are you sure your UltraBorg is properly attached, the correct address is used, and the I2C drivers are running?')
-                self.bus = None
-        else:
-            self.Print('UltraBorg loaded on bus %d' % (self.busNumber))
-
-        # Read the calibration settings from the UltraBorg
-        self.PWM_MIN_1 = self.GetWithRetry(self.GetServoMinimum1, 5)
-        self.PWM_MAX_1 = self.GetWithRetry(self.GetServoMaximum1, 5)
-        self.PWM_MIN_2 = self.GetWithRetry(self.GetServoMinimum2, 5)
-        self.PWM_MAX_2 = self.GetWithRetry(self.GetServoMaximum2, 5)
-        self.PWM_MIN_3 = self.GetWithRetry(self.GetServoMinimum3, 5)
-        self.PWM_MAX_3 = self.GetWithRetry(self.GetServoMaximum3, 5)
-        self.PWM_MIN_4 = self.GetWithRetry(self.GetServoMinimum4, 5)
-        self.PWM_MAX_4 = self.GetWithRetry(self.GetServoMaximum4, 5)
-
-
-    def GetWithRetry(self, function, count):
-        """
-value = GetWithRetry(function, count)
-
-Attempts to read a value multiple times before giving up
-Pass a get function with no parameters
-e.g.
-distance = GetWithRetry(UB.GetDistance1, 5)
-Will try UB.GetDistance1() upto 5 times, returning when it gets a value
-Useful for ensuring a read is successful
-        """
-        value = None
-        for i in range(count):
-            okay = True
-            try:
-                value = function()
-            except KeyboardInterrupt:
-                raise
-            except:
-                okay = False
-            if okay:
-                break
-        return value
-
-
-    def SetWithRetry(self, setFunction, getFunction, value, count):
-        """
-worked = SetWithRetry(setFunction, getFunction, value, count)
-
-Attempts to write a value multiple times before giving up
-Pass a set function with one parameter, and a get function no parameters
-The get function will be used to check if the set worked, if not it will be repeated
-e.g.
-worked = SetWithRetry(UB.SetServoMinimum1, UB.GetServoMinimum1, 2000, 5)
-Will try UB.SetServoMinimum1(2000) upto 5 times, returning when UB.GetServoMinimum1 returns 2000.
-Useful for ensuring a write is successful
-        """
-        for i in range(count):
-            okay = True
-            try:
-                setFunction(value)
-                readValue = getFunction()
-            except KeyboardInterrupt:
-                raise
-            except:
-                okay = False
-            if okay:
-                if readValue == value:
-                    break
-                else:
-                    okay = False
-        return okay
-
-
-    def GetDistance1(self):
-        """
-distance = GetDistance1()
-
-Gets the filtered distance for ultrasonic module #1 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-If you need a faster response try GetRawDistance1 instead (no filtering)
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_FILTER_USM1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #1 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetDistance2(self):
-        """
-distance = GetDistance2()
-
-Gets the filtered distance for ultrasonic module #2 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-If you need a faster response try GetRawDistance2 instead (no filtering)
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_FILTER_USM2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #2 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetDistance3(self):
-        """
-distance = GetDistance3()
-
-Gets the filtered distance for ultrasonic module #3 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-If you need a faster response try GetRawDistance3 instead (no filtering)
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_FILTER_USM3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #3 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetDistance4(self):
-        """
-distance = GetDistance4()
-
-Gets the filtered distance for ultrasonic module #4 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-If you need a faster response try GetRawDistance4 instead (no filtering)
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_FILTER_USM4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #4 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-
-    def GetRawDistance1(self):
-        """
-distance = GetRawDistance1()
-
-Gets the raw distance for ultrasonic module #1 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-For a filtered (less jumpy) reading use GetDistance1
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_TIME_USM1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #1 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetRawDistance2(self):
-        """
-distance = GetRawDistance2()
-
-Gets the raw distance for ultrasonic module #2 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-For a filtered (less jumpy) reading use GetDistance2
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_TIME_USM2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #2 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetRawDistance3(self):
-        """
-distance = GetRawDistance3()
-
-Gets the raw distance for ultrasonic module #3 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-For a filtered (less jumpy) reading use GetDistance3
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_TIME_USM3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #3 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetRawDistance4(self):
-        """
-distance = GetRawDistance4()
-
-Gets the distance for ultrasonic module #4 in millimeters
-Returns 0 for no object detected or no ultrasonic module attached
-For a filtered (less jumpy) reading use GetDistance4
-e.g.
-0     -> No object in range
-25    -> Object 25 mm away
-1000  -> Object 1000 mm (1 m) away
-3500  -> Object 3500 mm (3.5 m) away
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_TIME_USM4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading ultrasonic #4 distance!')
-            return
-
-        time_us = (i2cRecv[1] << 8) + i2cRecv[2]
-        if time_us == 65535:
-            time_us = 0
-        return time_us * USM_US_TO_MM
-
-
-    def GetServoPosition1(self):
-        """
-position = GetServoPosition1()
-
-Gets the drive position for servo output #1
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo output #1!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        powerOut = (float(pwmDuty) - self.PWM_MIN_1) / (self.PWM_MAX_1 - self.PWM_MIN_1)
-        return (2.0 * powerOut) - 1.0
-
-
-    def GetServoPosition2(self):
-        """
-position = GetServoPosition2()
-
-Gets the drive position for servo output #2
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo output #2!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        powerOut = (float(pwmDuty) - self.PWM_MIN_2) / (self.PWM_MAX_2 - self.PWM_MIN_2)
-        return (2.0 * powerOut) - 1.0
-
-
-    def GetServoPosition3(self):
-        """
-position = GetServoPosition3()
-
-Gets the drive position for servo output #3
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo output #3!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        powerOut = (float(pwmDuty) - self.PWM_MIN_3) / (self.PWM_MAX_3 - self.PWM_MIN_3)
-        return (2.0 * powerOut) - 1.0
-
-
-    def GetServoPosition4(self):
-        """
-position = GetServoPosition4()
-
-Gets the drive position for servo output #4
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo output #4!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        powerOut = (float(pwmDuty) - self.PWM_MIN_4) / (self.PWM_MAX_4 - self.PWM_MIN_4)
-        return (2.0 * powerOut) - 1.0
-
-
-    def SetServoPosition1(self, position):
-        """
-SetServoPosition1(position)
-
-Sets the drive position for servo output #1
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        powerOut = (position + 1.0) / 2.0
-        pwmDuty = int((powerOut * (self.PWM_MAX_1 - self.PWM_MIN_1)) + self.PWM_MIN_1)
-        pwmDutyLow = pwmDuty & 0xFF
-        pwmDutyHigh = (pwmDuty >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM1, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo output #1!')
-
-
-    def SetServoPosition2(self, position):
-        """
-SetServoPosition2(position)
-
-Sets the drive position for servo output #2
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        powerOut = (position + 1.0) / 2.0
-        pwmDuty = int((powerOut * (self.PWM_MAX_2 - self.PWM_MIN_2)) + self.PWM_MIN_2)
-        pwmDutyLow = pwmDuty & 0xFF
-        pwmDutyHigh = (pwmDuty >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM2, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo output #2!')
-
-
-    def SetServoPosition3(self, position):
-        """
-SetServoPosition3(position)
-
-Sets the drive position for servo output #3
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        powerOut = (position + 1.0) / 2.0
-        pwmDuty = int((powerOut * (self.PWM_MAX_3 - self.PWM_MIN_3)) + self.PWM_MIN_3)
-        pwmDutyLow = pwmDuty & 0xFF
-        pwmDutyHigh = (pwmDuty >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM3, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo output #3!')
-
-
-    def SetServoPosition4(self, position):
-        """
-SetServoPosition4(position)
-
-Sets the drive position for servo output #4
-0 is central, -1 is maximum left, +1 is maximum right
-e.g.
-0     -> Central
-0.5   -> 50% to the right
-1     -> 100% to the right
--0.75 -> 75% to the left
-        """
-        powerOut = (position + 1.0) / 2.0
-        pwmDuty = int((powerOut * (self.PWM_MAX_4 - self.PWM_MIN_4)) + self.PWM_MIN_4)
-        pwmDutyLow = pwmDuty & 0xFF
-        pwmDutyHigh = (pwmDuty >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM4, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo output #1!')
-
-
-    def GetServoMinimum1(self):
-        """
-pwmLevel = GetServoMinimum1()
-
-Gets the minimum PWM level for servo output #1
-This corresponds to position -1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MIN_1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #1 minimum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMinimum2(self):
-        """
-pwmLevel = GetServoMinimum2()
-
-Gets the minimum PWM level for servo output #2
-This corresponds to position -1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MIN_2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #2 minimum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMinimum3(self):
-        """
-pwmLevel = GetServoMinimum3()
-
-Gets the minimum PWM level for servo output #3
-This corresponds to position -1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MIN_3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #3 minimum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMinimum4(self):
-        """
-pwmLevel = GetServoMinimum4()
-
-Gets the minimum PWM level for servo output #4
-This corresponds to position -1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MIN_4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #4 minimum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMaximum1(self):
-        """
-pwmLevel = GetServoMaximum1()
-
-Gets the maximum PWM level for servo output #1
-This corresponds to position +1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MAX_1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #1 maximum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMaximum2(self):
-        """
-pwmLevel = GetServoMaximum2()
-
-Gets the maximum PWM level for servo output #2
-This corresponds to position +1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MAX_2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #2 maximum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMaximum3(self):
-        """
-pwmLevel = GetServoMaximum3()
-
-Gets the maximum PWM level for servo output #3
-This corresponds to position +1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MAX_3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #3 maximum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoMaximum4(self):
-        """
-pwmLevel = GetServoMaximum4()
-
-Gets the maximum PWM level for servo output #4
-This corresponds to position +1
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_MAX_4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #4 maximum burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoStartup1(self):
-        """
-pwmLevel = GetServoStartup1()
-
-Gets the startup PWM level for servo output #1
-This can be anywhere in the minimum to maximum range
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_BOOT_1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #1 startup burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoStartup2(self):
-        """
-pwmLevel = GetServoStartup2()
-
-Gets the startup PWM level for servo output #2
-This can be anywhere in the minimum to maximum range
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_BOOT_2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #2 startup burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoStartup3(self):
-        """
-pwmLevel = GetServoStartup3()
-
-Gets the startup PWM level for servo output #3
-This can be anywhere in the minimum to maximum range
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_BOOT_3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #3 startup burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def GetServoStartup4(self):
-        """
-pwmLevel = GetServoStartup4()
-
-Gets the startup PWM level for servo output #4
-This can be anywhere in the minimum to maximum range
-The value is an integer where 2000 represents a 1 ms servo burst
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst
-4000  -> 2 ms servo burst, typical longest burst
-3000  -> 1.5 ms servo burst, typical centre, 
-5000  -> 2.5 ms servo burst, higher than typical longest burst 
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM_BOOT_4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading servo #4 startup burst!')
-            return
-
-        return (i2cRecv[1] << 8) + i2cRecv[2]
-
-
-    def CalibrateServoPosition1(self, pwmLevel):
-        """
-CalibrateServoPosition1(pwmLevel)
-
-Sets the raw PWM level for servo output #1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-NO LIMIT CHECKING IS PERFORMED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition1 / GetServoPosition1
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_CALIBRATE_PWM1, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending calibration servo output #1!')
-
-
-    def CalibrateServoPosition2(self, pwmLevel):
-        """
-CalibrateServoPosition2(pwmLevel)
-
-Sets the raw PWM level for servo output #2
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-NO LIMIT CHECKING IS PERFORMED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition2 / GetServoPosition2
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_CALIBRATE_PWM2, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending calibration servo output #2!')
-
-
-    def CalibrateServoPosition3(self, pwmLevel):
-        """
-CalibrateServoPosition3(pwmLevel)
-
-Sets the raw PWM level for servo output #3
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-NO LIMIT CHECKING IS PERFORMED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition3 / GetServoPosition3
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_CALIBRATE_PWM3, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending calibration servo output #3!')
-
-
-    def CalibrateServoPosition4(self, pwmLevel):
-        """
-CalibrateServoPosition4(pwmLevel)
-
-Sets the raw PWM level for servo output #4
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-NO LIMIT CHECKING IS PERFORMED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition4 / GetServoPosition4
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_CALIBRATE_PWM4, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending calibration servo output #4!')
-
-
-    def GetRawServoPosition1(self):
-        """
-pwmLevel = GetRawServoPosition1()
-
-Gets the raw PWM level for servo output #1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-This value requires interpreting into an actual servo position, this is already done by GetServoPosition1
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition1 / GetServoPosition1
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM1, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading raw servo output #1!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        return pwmDuty
-
-
-    def GetRawServoPosition2(self):
-        """
-pwmLevel = GetRawServoPosition2()
-
-Gets the raw PWM level for servo output #2
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-This value requires interpreting into an actual servo position, this is already done by GetServoPosition2
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition2 / GetServoPosition2
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM2, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading raw servo output #2!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        return pwmDuty
-
-
-    def GetRawServoPosition3(self):
-        """
-pwmLevel = GetRawServoPosition3()
-
-Gets the raw PWM level for servo output #3
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-This value requires interpreting into an actual servo position, this is already done by GetServoPosition3
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition3 / GetServoPosition3
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM3, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading raw servo output #3!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        return pwmDuty
-
-
-    def GetRawServoPosition4(self):
-        """
-pwmLevel = GetRawServoPosition4()
-
-Gets the raw PWM level for servo output #4
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-This value requires interpreting into an actual servo position, this is already done by GetServoPosition4
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition4 / GetServoPosition4
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        try:
-            i2cRecv = self.RawRead(COMMAND_GET_PWM4, I2C_MAX_LEN)
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed reading raw servo output #4!')
-            return
-
-        pwmDuty = (i2cRecv[1] << 8) + i2cRecv[2]
-        return pwmDuty
-
-
-    def SetServoMinimum1(self, pwmLevel):
-        """
-SetServoMinimum1(pwmLevel)
-
-Sets the minimum PWM level for servo output #1
-This corresponds to position -1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition1 / GetServoPosition1
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MIN_1, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo minimum limit #1!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MIN_1 = self.GetServoMinimum1()
-
-
-    def SetServoMinimum2(self, pwmLevel):
-        """
-SetServoMinimum2(pwmLevel)
-
-Sets the minimum PWM level for servo output #2
-This corresponds to position -1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition2 / GetServoPosition2
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MIN_2, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo minimum limit #2!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MIN_2 = self.GetServoMinimum2()
-
-
-    def SetServoMinimum3(self, pwmLevel):
-        """
-SetServoMinimum3(pwmLevel)
-
-Sets the minimum PWM level for servo output #3
-This corresponds to position -1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition3 / GetServoPosition3
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MIN_3, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo minimum limit #3!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MIN_3 = self.GetServoMinimum3()
-
-
-    def SetServoMinimum4(self, pwmLevel):
-        """
-SetServoMinimum4(pwmLevel)
-
-Sets the minimum PWM level for servo output #4
-This corresponds to position -1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition4 / GetServoPosition4
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MIN_4, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo minimum limit #4!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MIN_4 = self.GetServoMinimum4()
-
-
-    def SetServoMaximum1(self, pwmLevel):
-        """
-SetServoMaximum1(pwmLevel)
-
-Sets the maximum PWM level for servo output #1
-This corresponds to position +1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition1 / GetServoPosition1
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MAX_1, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo maximum limit #1!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MAX_1 = self.GetServoMaximum1()
-
-
-    def SetServoMaximum2(self, pwmLevel):
-        """
-SetServoMaximum2(pwmLevel)
-
-Sets the maximum PWM level for servo output #2
-This corresponds to position +1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition2 / GetServoPosition2
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MAX_2, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo maximum limit #2!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MAX_2 = self.GetServoMaximum2()
-
-
-    def SetServoMaximum3(self, pwmLevel):
-        """
-SetServoMaximum3(pwmLevel)
-
-Sets the maximum PWM level for servo output #3
-This corresponds to position +1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition3 / GetServoPosition3
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MAX_3, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo maximum limit #3!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MAX_3 = self.GetServoMaximum3()
-
-
-    def SetServoMaximum4(self, pwmLevel):
-        """
-SetServoMaximum4(pwmLevel)
-
-Sets the maximum PWM level for servo output #4
-This corresponds to position +1
-This value can be set anywhere from 0 for a 0% duty cycle to 65535 for a 100% duty cycle
-
-Setting values outside the range of the servo for extended periods of time can damage the servo
-LIMIT CHECKING IS ALTERED BY THIS COMMAND!
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition4 / GetServoPosition4
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_MAX_4, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo maximum limit #4!')
-        time.sleep(DELAY_AFTER_EEPROM)
-        self.PWM_MAX_4 = self.GetServoMaximum4()
-
-
-    def SetServoStartup1(self, pwmLevel):
-        """
-SetServoStartup1(pwmLevel)
-
-Sets the startup PWM level for servo output #1
-This can be anywhere in the minimum to maximum range
-
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition1 / GetServoPosition1
-This value is checked against the current servo limits before setting
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-        inRange = True
-
-        if self.PWM_MIN_1 < self.PWM_MAX_1:
-            # Normal direction
-            if pwmLevel < self.PWM_MIN_1:
-                inRange = False
-            elif pwmLevel > self.PWM_MAX_1:
-                inRange = False
-        else:
-            # Inverted direction
-            if pwmLevel > self.PWM_MIN_1:
-                inRange = False
-            elif pwmLevel < self.PWM_MAX_1:
-                inRange = False
-        if pwmLevel == PWM_UNSET:
-            # Force to unset behaviour (central)
-            inRange = True
-
-        if not inRange:
-            print 'Servo #1 startup position %d is outside the limits of %d to %d' % (pwmLevel, self.PWM_MIN_1, self.PWM_MAX_1)
-            return
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_BOOT_1, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo startup position #1!')
-        time.sleep(DELAY_AFTER_EEPROM)
-
-
-    def SetServoStartup2(self, pwmLevel):
-        """
-SetServoStartup2(pwmLevel)
-
-Sets the startup PWM level for servo output #2
-This can be anywhere in the minimum to maximum range
-
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition2 / GetServoPosition2
-This value is checked against the current servo limits before setting
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-        inRange = True
-
-        if self.PWM_MIN_2 < self.PWM_MAX_2:
-            # Normal direction
-            if pwmLevel < self.PWM_MIN_2:
-                inRange = False
-            elif pwmLevel > self.PWM_MAX_2:
-                inRange = False
-        else:
-            # Inverted direction
-            if pwmLevel > self.PWM_MIN_2:
-                inRange = False
-            elif pwmLevel < self.PWM_MAX_2:
-                inRange = False
-        if pwmLevel == PWM_UNSET:
-            # Force to unset behaviour (central)
-            inRange = True
-
-        if not inRange:
-            print 'Servo #2 startup position %d is outside the limits of %d to %d' % (pwmLevel, self.PWM_MIN_2, self.PWM_MAX_2)
-            return
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_BOOT_2, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo startup position #2!')
-        time.sleep(DELAY_AFTER_EEPROM)
-
-
-    def SetServoStartup3(self, pwmLevel):
-        """
-SetServoStartup3(pwmLevel)
-
-Sets the startup PWM level for servo output #3
-This can be anywhere in the minimum to maximum range
-
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition3 / GetServoPosition3
-This value is checked against the current servo limits before setting
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-        inRange = True
-
-        if self.PWM_MIN_3 < self.PWM_MAX_3:
-            # Normal direction
-            if pwmLevel < self.PWM_MIN_3:
-                inRange = False
-            elif pwmLevel > self.PWM_MAX_3:
-                inRange = False
-        else:
-            # Inverted direction
-            if pwmLevel > self.PWM_MIN_3:
-                inRange = False
-            elif pwmLevel < self.PWM_MAX_3:
-                inRange = False
-        if pwmLevel == PWM_UNSET:
-            # Force to unset behaviour (central)
-            inRange = True
-
-        if not inRange:
-            print 'Servo #3 startup position %d is outside the limits of %d to %d' % (pwmLevel, self.PWM_MIN_3, self.PWM_MAX_3)
-            return
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_BOOT_3, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo startup position #3!')
-        time.sleep(DELAY_AFTER_EEPROM)
-
-
-    def SetServoStartup4(self, pwmLevel):
-        """
-SetServoStartup4(pwmLevel)
-
-Sets the startup PWM level for servo output #4
-This can be anywhere in the minimum to maximum range
-
-We recommend using the tuning GUI for setting the servo limits for SetServoPosition4 / GetServoPosition4
-This value is checked against the current servo limits before setting
-
-The value is an integer where 2000 represents a 1ms servo burst, approximately 3% duty cycle
-e.g.
-2000  -> 1 ms servo burst, typical shortest burst, ~3% duty cycle
-4000  -> 2 ms servo burst, typical longest burst, ~ 6.1% duty cycle
-3000  -> 1.5 ms servo burst, typical centre, ~4.6% duty cycle
-5000  -> 2.5 ms servo burst, higher than typical longest burst, ~ 7.6% duty cycle
-        """
-        pwmDutyLow = pwmLevel & 0xFF
-        pwmDutyHigh = (pwmLevel >> 8) & 0xFF
-        inRange = True
-
-        if self.PWM_MIN_4 < self.PWM_MAX_4:
-            # Normal direction
-            if pwmLevel < self.PWM_MIN_4:
-                inRange = False
-            elif pwmLevel > self.PWM_MAX_4:
-                inRange = False
-        else:
-            # Inverted direction
-            if pwmLevel > self.PWM_MIN_4:
-                inRange = False
-            elif pwmLevel < self.PWM_MAX_4:
-                inRange = False
-        if pwmLevel == PWM_UNSET:
-            # Force to unset behaviour (central)
-            inRange = True
-
-        if not inRange:
-            print 'Servo #4 startup position %d is outside the limits of %d to %d' % (pwmLevel, self.PWM_MIN_4, self.PWM_MAX_4)
-            return
-
-        try:
-            self.RawWrite(COMMAND_SET_PWM_BOOT_4, [pwmDutyHigh, pwmDutyLow])
-        except KeyboardInterrupt:
-            raise
-        except:
-            self.Print('Failed sending servo startup position #4!')
-        time.sleep(DELAY_AFTER_EEPROM)
-
-
-    def Help(self):
-        """
-Help()
-
-Displays the names and descriptions of the various functions and settings provided
-        """
-        funcList = [UltraBorg.__dict__.get(a) for a in dir(UltraBorg) if isinstance(UltraBorg.__dict__.get(a), types.FunctionType)]
-        funcListSorted = sorted(funcList, key = lambda x: x.func_code.co_firstlineno)
-
-        print self.__doc__
-        print
-        for func in funcListSorted:
-            print '=== %s === %s' % (func.func_name, func.func_doc)
-
diff --git a/Code/Pyborg_Robot_Scripts/lefigure.png b/Code/Pyborg_Robot_Scripts/lefigure.png
deleted file mode 100644
index 4a5138bf962debe501b19e52759dcf1f25470099..0000000000000000000000000000000000000000
Binary files a/Code/Pyborg_Robot_Scripts/lefigure.png and /dev/null differ
diff --git a/Code/Pyborg_Robot_Scripts/losfiguros.png b/Code/Pyborg_Robot_Scripts/losfiguros.png
deleted file mode 100644
index 52f4332e7365cfdb7ac02096cd37e9648618c9b7..0000000000000000000000000000000000000000
Binary files a/Code/Pyborg_Robot_Scripts/losfiguros.png and /dev/null differ