Writing a class to hold Arduino Properties for an Arduino I2C Debugger
Here is some feedback I have. I haven't had a chance to work with Arduino much, but there are some things that stand out to me:

 # Nothing to glaring in your constructor, but some tidbits:
 # I might add some defaults. 
 # I also noticed you have a lot of items in your constructor. 
 # Maybe **kwargs is warranted.

def __init__(self, tree_item, port=8080, identifier):

or

def __init__(self, **kwargs)

    # the number of arguments is borderline imho. I usually find if I
    # have too large a number (subjective), there is opportunity to 
    # break out the code into more classes. 
    self.__i2c = ArduinoI2C()
    self.__i2c.setPort(port)
    self.__i2c.connectPort()
    self.__id = None
    self.__i2c_version = None
    self.__switch_version = None
    self.__tree_item = tree_item
    self.__address_list = []
    self.__port = port
    self.__identifier = identifier


# Typically methods indicate some sort of action. i.e. get_id, show_id.
# specifying a noun is usually grounds for a class/instance variable.
# I would consider renaming your method to "def get_id(self):"
@property
def id(self):
    if self.__id is None:
        try:
            self.__id = self.__i2c.getID()
        except IOError: 
        # It may be good to add some logging. 
        # python logging module is great.
            self.__id = "NO CONNECTION"
    return self.__id

# ditto method name
@property
def i2c_version(self):
    if self.__i2c_version is None:
        try:
            self.__i2c_version = self.__i2c.i2cVersion()
        except IOError:
        # ditton on the logging.
            self.__i2c_version = "NO CONNECTION"
    return self.__i2c_version

# ditto method name
@property
def switch_version(self):
    if self.__switch_version is None:
        try:
            self.__switch_version = self.__i2c.switchVersion()
        except IOError:
            self.__switch_version = "NO CONNECTION"
    return self.__switch_version

# ditto method name
@property
def tree_item(self):
    return self.__tree_item

# ditto method name
@tree_item.setter
def tree_item(self, item):
    if type(item) is not wx.TreeItemId:
        return
    self.__tree_item = item

# ditto method name
@property
def address_list(self):
    return self.__address_list

# ditto method name
@address_list.setter
def address_list(self, addr_list):
    if type(addr_list) is not list:
        return
    self.__address_list = addr_list

# ditto method name
@property
def port(self):
    return self.__port

# ditto method name
@port.setter
def port(self, port):
    if port[:3] != "COM":
        return
    self.__port = port

# ditto method name
@property
def identifier(self):
    return self.__identifier

# ditto method name
@identifier.setter
def identifier(self, letter):
    if type(letter) is not str:
        return
    if letter[-1] != ':':
        letter += ':'
    self.__identifier = letter

# ditto, and its not idiomatic to use camelCase in a method name.
#   def run_serial_command(self, command)
def serialCommand(self, command):
    """
    Wrapper for ArduinoI2C serialCommand function
    """
    return self.__i2c.serialCommand(command)

# this method name is ok
def close(self):
    self.__i2c.close()

# this one two.. ditch the camelCase for snake_case connect_port
def connectPort(self):
    self.__i2c.connectPort()


It looks like there might be some opportunity for grouping your commands into separate classes, however not sure if you have enough per group yet. 

i.e.

class ArduinoVersions(ARCArduino):

# this might be to ambiguous, but just trying to give the general idea.
class ArduinoProperties(ArcaArduino): 


I have a feeling your command set will grow, so breaking this out may provide better organization in the future.