# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _toolbit
else:
    import _toolbit

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _toolbit.delete_SwigPyIterator

    def value(self):
        return _toolbit.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _toolbit.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _toolbit.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _toolbit.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _toolbit.SwigPyIterator_equal(self, x)

    def copy(self):
        return _toolbit.SwigPyIterator_copy(self)

    def next(self):
        return _toolbit.SwigPyIterator_next(self)

    def __next__(self):
        return _toolbit.SwigPyIterator___next__(self)

    def previous(self):
        return _toolbit.SwigPyIterator_previous(self)

    def advance(self, n):
        return _toolbit.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _toolbit.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _toolbit.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _toolbit.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _toolbit.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _toolbit.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _toolbit.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _toolbit:
_toolbit.SwigPyIterator_swigregister(SwigPyIterator)

class StringVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _toolbit.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _toolbit.StringVector___nonzero__(self)

    def __bool__(self):
        return _toolbit.StringVector___bool__(self)

    def __len__(self):
        return _toolbit.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _toolbit.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _toolbit.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _toolbit.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _toolbit.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _toolbit.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _toolbit.StringVector___setitem__(self, *args)

    def pop(self):
        return _toolbit.StringVector_pop(self)

    def append(self, x):
        return _toolbit.StringVector_append(self, x)

    def empty(self):
        return _toolbit.StringVector_empty(self)

    def size(self):
        return _toolbit.StringVector_size(self)

    def swap(self, v):
        return _toolbit.StringVector_swap(self, v)

    def begin(self):
        return _toolbit.StringVector_begin(self)

    def end(self):
        return _toolbit.StringVector_end(self)

    def rbegin(self):
        return _toolbit.StringVector_rbegin(self)

    def rend(self):
        return _toolbit.StringVector_rend(self)

    def clear(self):
        return _toolbit.StringVector_clear(self)

    def get_allocator(self):
        return _toolbit.StringVector_get_allocator(self)

    def pop_back(self):
        return _toolbit.StringVector_pop_back(self)

    def erase(self, *args):
        return _toolbit.StringVector_erase(self, *args)

    def __init__(self, *args):
        _toolbit.StringVector_swiginit(self, _toolbit.new_StringVector(*args))

    def push_back(self, x):
        return _toolbit.StringVector_push_back(self, x)

    def front(self):
        return _toolbit.StringVector_front(self)

    def back(self):
        return _toolbit.StringVector_back(self)

    def assign(self, n, x):
        return _toolbit.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _toolbit.StringVector_resize(self, *args)

    def insert(self, *args):
        return _toolbit.StringVector_insert(self, *args)

    def reserve(self, n):
        return _toolbit.StringVector_reserve(self, n)

    def capacity(self):
        return _toolbit.StringVector_capacity(self)
    __swig_destroy__ = _toolbit.delete_StringVector

# Register StringVector in _toolbit:
_toolbit.StringVector_swigregister(StringVector)

class TbiCore(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.TbiCore_swiginit(self, _toolbit.new_TbiCore())
    __swig_destroy__ = _toolbit.delete_TbiCore

    def openPath(self, path):
        return _toolbit.TbiCore_openPath(self, path)

    def close(self):
        return _toolbit.TbiCore_close(self)

    def isConnected(self):
        return _toolbit.TbiCore_isConnected(self)

    def getVendorName(self):
        return _toolbit.TbiCore_getVendorName(self)

    def getProductName(self):
        return _toolbit.TbiCore_getProductName(self)

    def getProductRevision(self):
        return _toolbit.TbiCore_getProductRevision(self)

    def getProductSerial(self):
        return _toolbit.TbiCore_getProductSerial(self)

    def getFirmVersion(self):
        return _toolbit.TbiCore_getFirmVersion(self)

# Register TbiCore in _toolbit:
_toolbit.TbiCore_swigregister(TbiCore)


def convertWcharToString(p):
    return _toolbit.convertWcharToString(p)
BUF_LEN = _toolbit.BUF_LEN
MAX_STR = _toolbit.MAX_STR
DEFAULT_DEALY = _toolbit.DEFAULT_DEALY
class TbiDevice(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.TbiDevice_swiginit(self, _toolbit.new_TbiDevice())
    __swig_destroy__ = _toolbit.delete_TbiDevice

    def open(self, *args):
        return _toolbit.TbiDevice_open(self, *args)

    def isOpen(self):
        return _toolbit.TbiDevice_isOpen(self)

    def close(self):
        return _toolbit.TbiDevice_close(self)

    def write(self, sndbuf, num):
        return _toolbit.TbiDevice_write(self, sndbuf, num)

    def read(self, rcvbuf):
        return _toolbit.TbiDevice_read(self, rcvbuf)

# Register TbiDevice in _toolbit:
_toolbit.TbiDevice_swigregister(TbiDevice)

USB_VID_PIC = _toolbit.USB_VID_PIC
USB_PID_PIC = _toolbit.USB_PID_PIC
USB_VID_ARDUINO = _toolbit.USB_VID_ARDUINO
USB_PID_ARDUINO = _toolbit.USB_PID_ARDUINO
USB_VID_NUM_MAX = _toolbit.USB_VID_NUM_MAX
class TbiDeviceManager(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.TbiDeviceManager_swiginit(self, _toolbit.new_TbiDeviceManager())
    __swig_destroy__ = _toolbit.delete_TbiDeviceManager

    def updateDeviceList(self):
        return _toolbit.TbiDeviceManager_updateDeviceList(self)

    def getDeviceNum(self, *args):
        return _toolbit.TbiDeviceManager_getDeviceNum(self, *args)

    def getDeviceList(self):
        return _toolbit.TbiDeviceManager_getDeviceList(self)

    def getSerialList(self, name):
        return _toolbit.TbiDeviceManager_getSerialList(self, name)

    def getPathByName(self, name):
        return _toolbit.TbiDeviceManager_getPathByName(self, name)

    def getPathByNameAndSerial(self, name, serial):
        return _toolbit.TbiDeviceManager_getPathByNameAndSerial(self, name, serial)

# Register TbiDeviceManager in _toolbit:
_toolbit.TbiDeviceManager_swigregister(TbiDeviceManager)

PROTOCOL_VERSION = _toolbit.PROTOCOL_VERSION
class tbiPacket(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dat = property(_toolbit.tbiPacket_dat_get, _toolbit.tbiPacket_dat_set)

    def __init__(self):
        _toolbit.tbiPacket_swiginit(self, _toolbit.new_tbiPacket())
    __swig_destroy__ = _toolbit.delete_tbiPacket

# Register tbiPacket in _toolbit:
_toolbit.tbiPacket_swigregister(tbiPacket)

OP_METADATA_GET = _toolbit.OP_METADATA_GET
OP_CONFIG_SET = _toolbit.OP_CONFIG_SET
OP_ATT_VALUE_SET = _toolbit.OP_ATT_VALUE_SET
OP_ATT_VALUE_GET = _toolbit.OP_ATT_VALUE_GET
EVT_NOTIFY = _toolbit.EVT_NOTIFY
RC_FAIL = _toolbit.RC_FAIL
RC_OK = _toolbit.RC_OK
class TbiService(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p):
        _toolbit.TbiService_swiginit(self, _toolbit.new_TbiService(p))
    __swig_destroy__ = _toolbit.delete_TbiService

    def readAttribute(self, att):
        return _toolbit.TbiService_readAttribute(self, att)

    def writeAttribute(self, att):
        return _toolbit.TbiService_writeAttribute(self, att)

# Register TbiService in _toolbit:
_toolbit.TbiService_swigregister(TbiService)

VALUE_LEN = _toolbit.VALUE_LEN
ATT_VENDOR_NAME = _toolbit.ATT_VENDOR_NAME
ATT_PRODUCT_NAME = _toolbit.ATT_PRODUCT_NAME
ATT_PRODUCT_REVISION = _toolbit.ATT_PRODUCT_REVISION
ATT_PRODUCT_SERIAL = _toolbit.ATT_PRODUCT_SERIAL
ATT_FIRM_VERSION = _toolbit.ATT_FIRM_VERSION
PERMISSION_NONE = _toolbit.PERMISSION_NONE
PERMISSION_READABLE = _toolbit.PERMISSION_READABLE
PERMISSION_WRITABLE = _toolbit.PERMISSION_WRITABLE
PERMISSION_READABLE_WRITABLE = _toolbit.PERMISSION_READABLE_WRITABLE
PROPERTY_READ = _toolbit.PROPERTY_READ
PROPERTY_WRITE = _toolbit.PROPERTY_WRITE
PROPERTY_NOTIFY = _toolbit.PROPERTY_NOTIFY
class Attvalue(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.Attvalue_swiginit(self, _toolbit.new_Attvalue())
    __swig_destroy__ = _toolbit.delete_Attvalue

    def setValue(self, *args):
        return _toolbit.Attvalue_setValue(self, *args)

    def getValueUint8(self):
        return _toolbit.Attvalue_getValueUint8(self)

    def getValueInt8(self):
        return _toolbit.Attvalue_getValueInt8(self)

    def getValueUint16(self):
        return _toolbit.Attvalue_getValueUint16(self)

    def getValueInt16(self):
        return _toolbit.Attvalue_getValueInt16(self)

    def getValueUint32(self):
        return _toolbit.Attvalue_getValueUint32(self)

    def getValueInt32(self):
        return _toolbit.Attvalue_getValueInt32(self)

    def getValueUint64(self):
        return _toolbit.Attvalue_getValueUint64(self)

    def getValueInt64(self):
        return _toolbit.Attvalue_getValueInt64(self)

    def getValueStr(self):
        return _toolbit.Attvalue_getValueStr(self)

    def getValueU8str(self):
        return _toolbit.Attvalue_getValueU8str(self)

    def getValueFloat(self):
        return _toolbit.Attvalue_getValueFloat(self)

    def getValueDouble(self):
        return _toolbit.Attvalue_getValueDouble(self)

    def getValueLength(self):
        return _toolbit.Attvalue_getValueLength(self)

# Register Attvalue in _toolbit:
_toolbit.Attvalue_swigregister(Attvalue)

class Attribute(Attvalue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, id, prop, perm):
        _toolbit.Attribute_swiginit(self, _toolbit.new_Attribute(id, prop, perm))
    __swig_destroy__ = _toolbit.delete_Attribute

    def getAttid(self):
        return _toolbit.Attribute_getAttid(self)

# Register Attribute in _toolbit:
_toolbit.Attribute_swigregister(Attribute)

ATT_GPIO0_BASE = _toolbit.ATT_GPIO0_BASE
ATT_ADC_BASE = _toolbit.ATT_ADC_BASE
ATT_IC20_BASE = _toolbit.ATT_IC20_BASE
class Tbit(TbiCore):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.Tbit_swiginit(self, _toolbit.new_Tbit())
    __swig_destroy__ = _toolbit.delete_Tbit

    def open(self, *args):
        return _toolbit.Tbit_open(self, *args)
    gpiohw = property(_toolbit.Tbit_gpiohw_get, _toolbit.Tbit_gpiohw_set)
    adchw = property(_toolbit.Tbit_adchw_get, _toolbit.Tbit_adchw_set)
    i2chw = property(_toolbit.Tbit_i2chw_get, _toolbit.Tbit_i2chw_set)

# Register Tbit in _toolbit:
_toolbit.Tbit_swigregister(Tbit)

class hid_device_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    path = property(_toolbit.hid_device_info_path_get, _toolbit.hid_device_info_path_set)
    vendor_id = property(_toolbit.hid_device_info_vendor_id_get, _toolbit.hid_device_info_vendor_id_set)
    product_id = property(_toolbit.hid_device_info_product_id_get, _toolbit.hid_device_info_product_id_set)
    serial_number = property(_toolbit.hid_device_info_serial_number_get, _toolbit.hid_device_info_serial_number_set)
    release_number = property(_toolbit.hid_device_info_release_number_get, _toolbit.hid_device_info_release_number_set)
    manufacturer_string = property(_toolbit.hid_device_info_manufacturer_string_get, _toolbit.hid_device_info_manufacturer_string_set)
    product_string = property(_toolbit.hid_device_info_product_string_get, _toolbit.hid_device_info_product_string_set)
    usage_page = property(_toolbit.hid_device_info_usage_page_get, _toolbit.hid_device_info_usage_page_set)
    usage = property(_toolbit.hid_device_info_usage_get, _toolbit.hid_device_info_usage_set)
    interface_number = property(_toolbit.hid_device_info_interface_number_get, _toolbit.hid_device_info_interface_number_set)
    next = property(_toolbit.hid_device_info_next_get, _toolbit.hid_device_info_next_set)

    def __init__(self):
        _toolbit.hid_device_info_swiginit(self, _toolbit.new_hid_device_info())
    __swig_destroy__ = _toolbit.delete_hid_device_info

# Register hid_device_info in _toolbit:
_toolbit.hid_device_info_swigregister(hid_device_info)


def hid_init():
    return _toolbit.hid_init()

def hid_exit():
    return _toolbit.hid_exit()

def hid_enumerate(vendor_id, product_id):
    return _toolbit.hid_enumerate(vendor_id, product_id)

def hid_free_enumeration(devs):
    return _toolbit.hid_free_enumeration(devs)

def hid_open(vendor_id, product_id, serial_number):
    return _toolbit.hid_open(vendor_id, product_id, serial_number)

def hid_open_path(path):
    return _toolbit.hid_open_path(path)

def hid_write(device, data, length):
    return _toolbit.hid_write(device, data, length)

def hid_read_timeout(dev, data, length, milliseconds):
    return _toolbit.hid_read_timeout(dev, data, length, milliseconds)

def hid_read(device, data, length):
    return _toolbit.hid_read(device, data, length)

def hid_set_nonblocking(device, nonblock):
    return _toolbit.hid_set_nonblocking(device, nonblock)

def hid_send_feature_report(device, data, length):
    return _toolbit.hid_send_feature_report(device, data, length)

def hid_get_feature_report(device, data, length):
    return _toolbit.hid_get_feature_report(device, data, length)

def hid_close(device):
    return _toolbit.hid_close(device)

def hid_get_manufacturer_string(device, string, maxlen):
    return _toolbit.hid_get_manufacturer_string(device, string, maxlen)

def hid_get_product_string(device, string, maxlen):
    return _toolbit.hid_get_product_string(device, string, maxlen)

def hid_get_serial_number_string(device, string, maxlen):
    return _toolbit.hid_get_serial_number_string(device, string, maxlen)

def hid_get_indexed_string(device, string_index, string, maxlen):
    return _toolbit.hid_get_indexed_string(device, string_index, string, maxlen)

def hid_error(device):
    return _toolbit.hid_error(device)
ATT_USB_PORT_CTRL = _toolbit.ATT_USB_PORT_CTRL
class Chopper(TbiCore):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.Chopper_swiginit(self, _toolbit.new_Chopper())
    __swig_destroy__ = _toolbit.delete_Chopper

    def open(self, *args):
        return _toolbit.Chopper_open(self, *args)

    def enableAllUsbPort(self):
        return _toolbit.Chopper_enableAllUsbPort(self)

    def enableUsbPort(self, p):
        return _toolbit.Chopper_enableUsbPort(self, p)

    def disableAllUsbPort(self):
        return _toolbit.Chopper_disableAllUsbPort(self)

    def disableUsbPort(self, p):
        return _toolbit.Chopper_disableUsbPort(self, p)

    def getUsbPortStatus(self):
        return _toolbit.Chopper_getUsbPortStatus(self)
    gpiohw = property(_toolbit.Chopper_gpiohw_get, _toolbit.Chopper_gpiohw_set)

# Register Chopper in _toolbit:
_toolbit.Chopper_swigregister(Chopper)

ATT_CALIBRATION = _toolbit.ATT_CALIBRATION
ATT_VOLTAGE = _toolbit.ATT_VOLTAGE
ATT_CURRENT = _toolbit.ATT_CURRENT
class Dmm(TbiCore):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _toolbit.Dmm_swiginit(self, _toolbit.new_Dmm())
    __swig_destroy__ = _toolbit.delete_Dmm
    i2chw = property(_toolbit.Dmm_i2chw_get, _toolbit.Dmm_i2chw_set)

    def open(self, *args):
        return _toolbit.Dmm_open(self, *args)

    def calibration(self):
        return _toolbit.Dmm_calibration(self)

    def getCalibrationData(self):
        return _toolbit.Dmm_getCalibrationData(self)

    def getVoltage(self):
        return _toolbit.Dmm_getVoltage(self)

    def getCurrent(self):
        return _toolbit.Dmm_getCurrent(self)

    def showReg(self):
        return _toolbit.Dmm_showReg(self)

    def getDieID(self):
        return _toolbit.Dmm_getDieID(self)

# Register Dmm in _toolbit:
_toolbit.Dmm_swigregister(Dmm)

class Adc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p, pinnum):
        _toolbit.Adc_swiginit(self, _toolbit.new_Adc(p, pinnum))
    __swig_destroy__ = _toolbit.delete_Adc

    def value(self):
        return _toolbit.Adc_value(self)

# Register Adc in _toolbit:
_toolbit.Adc_swigregister(Adc)

class AdcHw(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tbisrv, base):
        _toolbit.AdcHw_swiginit(self, _toolbit.new_AdcHw(tbisrv, base))
    __swig_destroy__ = _toolbit.delete_AdcHw

    def analogRead(self, pin):
        return _toolbit.AdcHw_analogRead(self, pin)

# Register AdcHw in _toolbit:
_toolbit.AdcHw_swigregister(AdcHw)

ATT_GPIO_INOUT_MODE = _toolbit.ATT_GPIO_INOUT_MODE
ATT_GPIO_PULL_UP = _toolbit.ATT_GPIO_PULL_UP
ATT_GPIO_PULL_DOWN = _toolbit.ATT_GPIO_PULL_DOWN
ATT_GPIO_RW = _toolbit.ATT_GPIO_RW
OUTPUT_PIN = _toolbit.OUTPUT_PIN
INPUT_PIN = _toolbit.INPUT_PIN
INPUT_PULLUP_PIN = _toolbit.INPUT_PULLUP_PIN
INPUT_PULLDOWN_PIN = _toolbit.INPUT_PULLDOWN_PIN
HIGH = _toolbit.HIGH
LOW = _toolbit.LOW
class GpioHw(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tbisrv, base):
        _toolbit.GpioHw_swiginit(self, _toolbit.new_GpioHw(tbisrv, base))
    __swig_destroy__ = _toolbit.delete_GpioHw

    def pinMode(self, pin, mode):
        return _toolbit.GpioHw_pinMode(self, pin, mode)

    def write(self, dat):
        return _toolbit.GpioHw_write(self, dat)

    def read(self):
        return _toolbit.GpioHw_read(self)

    def digitalWrite(self, pin, val):
        return _toolbit.GpioHw_digitalWrite(self, pin, val)

    def digitalRead(self, pin):
        return _toolbit.GpioHw_digitalRead(self, pin)

# Register GpioHw in _toolbit:
_toolbit.GpioHw_swigregister(GpioHw)

ATT_I2C_DEVICE_ADDR = _toolbit.ATT_I2C_DEVICE_ADDR
ATT_I2C_REG_ADDR = _toolbit.ATT_I2C_REG_ADDR
ATT_I2C_RW_1BYTE = _toolbit.ATT_I2C_RW_1BYTE
ATT_I2C_RW_2BYTE = _toolbit.ATT_I2C_RW_2BYTE
ATT_I2C_RW_3BYTE = _toolbit.ATT_I2C_RW_3BYTE
ATT_I2C_RW_4BYTE = _toolbit.ATT_I2C_RW_4BYTE
class I2cHw(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tbisrv, base):
        _toolbit.I2cHw_swiginit(self, _toolbit.new_I2cHw(tbisrv, base))
    __swig_destroy__ = _toolbit.delete_I2cHw

    def setI2cDeviceAddr(self, dev_addr):
        return _toolbit.I2cHw_setI2cDeviceAddr(self, dev_addr)

    def write2byte(self, addr, val):
        return _toolbit.I2cHw_write2byte(self, addr, val)

    def read2byte(self, addr):
        return _toolbit.I2cHw_read2byte(self, addr)

# Register I2cHw in _toolbit:
_toolbit.I2cHw_swigregister(I2cHw)

class Pin(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _toolbit.Pin_swiginit(self, _toolbit.new_Pin(*args))
    __swig_destroy__ = _toolbit.delete_Pin

    def mode(self, m):
        return _toolbit.Pin_mode(self, m)

    def value(self, *args):
        return _toolbit.Pin_value(self, *args)

    def on(self):
        return _toolbit.Pin_on(self)

    def off(self):
        return _toolbit.Pin_off(self)

# Register Pin in _toolbit:
_toolbit.Pin_swigregister(Pin)



