from sys import version_info as _swig_python_version_info
if __package__ or "." in __name__:
from . import _HC_API_PythonPackage
else:
import _HC_API_PythonPackage
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 == "this":
set(self, name, value)
elif name == "thisown":
self.this.own(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__)
import weakref
[docs]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__ = _HC_API_PythonPackage.delete_SwigPyIterator
[docs] def value(self):
return _HC_API_PythonPackage.SwigPyIterator_value(self)
[docs] def incr(self, n=1):
return _HC_API_PythonPackage.SwigPyIterator_incr(self, n)
[docs] def decr(self, n=1):
return _HC_API_PythonPackage.SwigPyIterator_decr(self, n)
[docs] def distance(self, x):
return _HC_API_PythonPackage.SwigPyIterator_distance(self, x)
[docs] def equal(self, x):
return _HC_API_PythonPackage.SwigPyIterator_equal(self, x)
[docs] def copy(self):
return _HC_API_PythonPackage.SwigPyIterator_copy(self)
[docs] def next(self):
return _HC_API_PythonPackage.SwigPyIterator_next(self)
def __next__(self):
return _HC_API_PythonPackage.SwigPyIterator___next__(self)
[docs] def previous(self):
return _HC_API_PythonPackage.SwigPyIterator_previous(self)
[docs] def advance(self, n):
return _HC_API_PythonPackage.SwigPyIterator_advance(self, n)
def __eq__(self, x):
return _HC_API_PythonPackage.SwigPyIterator___eq__(self, x)
def __ne__(self, x):
return _HC_API_PythonPackage.SwigPyIterator___ne__(self, x)
def __iadd__(self, n):
return _HC_API_PythonPackage.SwigPyIterator___iadd__(self, n)
def __isub__(self, n):
return _HC_API_PythonPackage.SwigPyIterator___isub__(self, n)
def __add__(self, n):
return _HC_API_PythonPackage.SwigPyIterator___add__(self, n)
def __sub__(self, *args):
return _HC_API_PythonPackage.SwigPyIterator___sub__(self, *args)
def __iter__(self):
return self
_HC_API_PythonPackage.SwigPyIterator_swigregister(SwigPyIterator)
[docs]class IntVector(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def iterator(self):
return _HC_API_PythonPackage.IntVector_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
return _HC_API_PythonPackage.IntVector___nonzero__(self)
def __bool__(self):
return _HC_API_PythonPackage.IntVector___bool__(self)
def __len__(self):
return _HC_API_PythonPackage.IntVector___len__(self)
def __getslice__(self, i, j):
return _HC_API_PythonPackage.IntVector___getslice__(self, i, j)
def __setslice__(self, *args):
return _HC_API_PythonPackage.IntVector___setslice__(self, *args)
def __delslice__(self, i, j):
return _HC_API_PythonPackage.IntVector___delslice__(self, i, j)
def __delitem__(self, *args):
return _HC_API_PythonPackage.IntVector___delitem__(self, *args)
def __getitem__(self, *args):
return _HC_API_PythonPackage.IntVector___getitem__(self, *args)
def __setitem__(self, *args):
return _HC_API_PythonPackage.IntVector___setitem__(self, *args)
[docs] def pop(self):
return _HC_API_PythonPackage.IntVector_pop(self)
[docs] def append(self, x):
return _HC_API_PythonPackage.IntVector_append(self, x)
[docs] def empty(self):
return _HC_API_PythonPackage.IntVector_empty(self)
[docs] def size(self):
return _HC_API_PythonPackage.IntVector_size(self)
[docs] def swap(self, v):
return _HC_API_PythonPackage.IntVector_swap(self, v)
[docs] def begin(self):
return _HC_API_PythonPackage.IntVector_begin(self)
[docs] def end(self):
return _HC_API_PythonPackage.IntVector_end(self)
[docs] def rbegin(self):
return _HC_API_PythonPackage.IntVector_rbegin(self)
[docs] def rend(self):
return _HC_API_PythonPackage.IntVector_rend(self)
[docs] def clear(self):
return _HC_API_PythonPackage.IntVector_clear(self)
[docs] def get_allocator(self):
return _HC_API_PythonPackage.IntVector_get_allocator(self)
[docs] def pop_back(self):
return _HC_API_PythonPackage.IntVector_pop_back(self)
[docs] def erase(self, *args):
return _HC_API_PythonPackage.IntVector_erase(self, *args)
def __init__(self, *args):
_HC_API_PythonPackage.IntVector_swiginit(self, _HC_API_PythonPackage.new_IntVector(*args))
[docs] def push_back(self, x):
return _HC_API_PythonPackage.IntVector_push_back(self, x)
[docs] def front(self):
return _HC_API_PythonPackage.IntVector_front(self)
[docs] def back(self):
return _HC_API_PythonPackage.IntVector_back(self)
[docs] def assign(self, n, x):
return _HC_API_PythonPackage.IntVector_assign(self, n, x)
[docs] def resize(self, *args):
return _HC_API_PythonPackage.IntVector_resize(self, *args)
[docs] def insert(self, *args):
return _HC_API_PythonPackage.IntVector_insert(self, *args)
[docs] def reserve(self, n):
return _HC_API_PythonPackage.IntVector_reserve(self, n)
[docs] def capacity(self):
return _HC_API_PythonPackage.IntVector_capacity(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_IntVector
_HC_API_PythonPackage.IntVector_swigregister(IntVector)
[docs]class FloatVector(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def iterator(self):
return _HC_API_PythonPackage.FloatVector_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
return _HC_API_PythonPackage.FloatVector___nonzero__(self)
def __bool__(self):
return _HC_API_PythonPackage.FloatVector___bool__(self)
def __len__(self):
return _HC_API_PythonPackage.FloatVector___len__(self)
def __getslice__(self, i, j):
return _HC_API_PythonPackage.FloatVector___getslice__(self, i, j)
def __setslice__(self, *args):
return _HC_API_PythonPackage.FloatVector___setslice__(self, *args)
def __delslice__(self, i, j):
return _HC_API_PythonPackage.FloatVector___delslice__(self, i, j)
def __delitem__(self, *args):
return _HC_API_PythonPackage.FloatVector___delitem__(self, *args)
def __getitem__(self, *args):
return _HC_API_PythonPackage.FloatVector___getitem__(self, *args)
def __setitem__(self, *args):
return _HC_API_PythonPackage.FloatVector___setitem__(self, *args)
[docs] def pop(self):
return _HC_API_PythonPackage.FloatVector_pop(self)
[docs] def append(self, x):
return _HC_API_PythonPackage.FloatVector_append(self, x)
[docs] def empty(self):
return _HC_API_PythonPackage.FloatVector_empty(self)
[docs] def size(self):
return _HC_API_PythonPackage.FloatVector_size(self)
[docs] def swap(self, v):
return _HC_API_PythonPackage.FloatVector_swap(self, v)
[docs] def begin(self):
return _HC_API_PythonPackage.FloatVector_begin(self)
[docs] def end(self):
return _HC_API_PythonPackage.FloatVector_end(self)
[docs] def rbegin(self):
return _HC_API_PythonPackage.FloatVector_rbegin(self)
[docs] def rend(self):
return _HC_API_PythonPackage.FloatVector_rend(self)
[docs] def clear(self):
return _HC_API_PythonPackage.FloatVector_clear(self)
[docs] def get_allocator(self):
return _HC_API_PythonPackage.FloatVector_get_allocator(self)
[docs] def pop_back(self):
return _HC_API_PythonPackage.FloatVector_pop_back(self)
[docs] def erase(self, *args):
return _HC_API_PythonPackage.FloatVector_erase(self, *args)
def __init__(self, *args):
_HC_API_PythonPackage.FloatVector_swiginit(self, _HC_API_PythonPackage.new_FloatVector(*args))
[docs] def push_back(self, x):
return _HC_API_PythonPackage.FloatVector_push_back(self, x)
[docs] def front(self):
return _HC_API_PythonPackage.FloatVector_front(self)
[docs] def back(self):
return _HC_API_PythonPackage.FloatVector_back(self)
[docs] def assign(self, n, x):
return _HC_API_PythonPackage.FloatVector_assign(self, n, x)
[docs] def resize(self, *args):
return _HC_API_PythonPackage.FloatVector_resize(self, *args)
[docs] def insert(self, *args):
return _HC_API_PythonPackage.FloatVector_insert(self, *args)
[docs] def reserve(self, n):
return _HC_API_PythonPackage.FloatVector_reserve(self, n)
[docs] def capacity(self):
return _HC_API_PythonPackage.FloatVector_capacity(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_FloatVector
_HC_API_PythonPackage.FloatVector_swigregister(FloatVector)
[docs]def pythonPrintLogFunction():
print("Printing Log Location From Python: " + str(logLocation(0)))
HC_LOG_DEVICE_NAME_LEN = _HC_API_PythonPackage.HC_LOG_DEVICE_NAME_LEN
[docs]def throwTestException():
r"""
throw a test exception from the library
:rtype: int
:return:
"""
return _HC_API_PythonPackage.throwTestException()
[docs]def raiseTestSIGSEG():
r"""
raise a test SIGSEGV signal from the library
:rtype: int
:return:
"""
return _HC_API_PythonPackage.raiseTestSIGSEG()
[docs]def printTestMessage():
r""" print a test message from the library"""
return _HC_API_PythonPackage.printTestMessage()
[docs]def printTestErrorMessage():
r""" print a test error message from the library"""
return _HC_API_PythonPackage.printTestErrorMessage()
[docs]def printTestErrorThrowMessage():
r""" print a test error message from the library and throw an exception"""
return _HC_API_PythonPackage.printTestErrorThrowMessage()
[docs]def logLocation(index):
r"""
return the full path of the log location
:type index: int
:param index: the log location index (default 0)
:rtype: string
:return: the log location as a string.
"""
return _HC_API_PythonPackage.logLocation(index)
[docs]def addLogPath(logFilePath):
r"""
Add a new log path for log files to be created in.
:type logFilePath: string
:param logFilePath:
"""
return _HC_API_PythonPackage.addLogPath(logFilePath)
[docs]def getRuntimeLibraryPath():
return _HC_API_PythonPackage.getRuntimeLibraryPath()
[docs]def getRuntimeDependancyPath():
return _HC_API_PythonPackage.getRuntimeDependancyPath()
[docs]class HardwareInfo(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
apiDeviceId = property(_HC_API_PythonPackage.HardwareInfo_apiDeviceId_get, _HC_API_PythonPackage.HardwareInfo_apiDeviceId_set)
alias = property(_HC_API_PythonPackage.HardwareInfo_alias_get, _HC_API_PythonPackage.HardwareInfo_alias_set)
def __init__(self):
_HC_API_PythonPackage.HardwareInfo_swiginit(self, _HC_API_PythonPackage.new_HardwareInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_HardwareInfo
_HC_API_PythonPackage.HardwareInfo_swigregister(HardwareInfo)
[docs]class PhysicalAxisControlInfo(object):
r""" base class representing a physical axis (linear or rotational, with movement limits)"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
minPosLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minPosLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minPosLimit_set)
maxPosLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxPosLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxPosLimit_set)
minVelLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minVelLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minVelLimit_set)
maxVelLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxVelLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxVelLimit_set)
minAccLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minAccLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minAccLimit_set)
maxAccLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxAccLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxAccLimit_set)
isRadial = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_isRadial_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_isRadial_set)
submittedToApi = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_submittedToApi_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_submittedToApi_set)
def __init__(self):
_HC_API_PythonPackage.PhysicalAxisControlInfo_swiginit(self, _HC_API_PythonPackage.new_PhysicalAxisControlInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_PhysicalAxisControlInfo
_HC_API_PythonPackage.PhysicalAxisControlInfo_swigregister(PhysicalAxisControlInfo)
[docs]class CommandStateInfo(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CommandStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CommandStateInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CommandStateInfo
percentFinished = property(_HC_API_PythonPackage.CommandStateInfo_percentFinished_get, _HC_API_PythonPackage.CommandStateInfo_percentFinished_set, doc=r"""
<summary>
percentage to command completion.
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.CommandStateInfo_swiginit(self, _HC_API_PythonPackage.new_CommandStateInfo())
_HC_API_PythonPackage.CommandStateInfo_swigregister(CommandStateInfo)
[docs]class ApiCommandPackage(object):
r""" Base Class for command packages"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ApiCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ApiCommandPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ApiCommandPackage
alias = property(_HC_API_PythonPackage.ApiCommandPackage_alias_get, _HC_API_PythonPackage.ApiCommandPackage_alias_set, doc=r""" user definable unique alias for this command package""")
def __init__(self):
_HC_API_PythonPackage.ApiCommandPackage_swiginit(self, _HC_API_PythonPackage.new_ApiCommandPackage())
_HC_API_PythonPackage.ApiCommandPackage_swigregister(ApiCommandPackage)
[docs]class DeviceCommandPackage(ApiCommandPackage):
r"""
Base Class containing command parameters needed to run a command for a device.
The package is referenced during command updating. so parameters can be changed during command execution.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DeviceCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DeviceCommandPackage_className(self)
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DeviceCommandPackage_createSharedPtr(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DeviceCommandPackage
[docs] def cloneFrom(self, other):
r"""
clone from another device package - should be implemented for custom types.
:type other: :py:class:`DeviceCommandPackage`
:param other:
"""
return _HC_API_PythonPackage.DeviceCommandPackage_cloneFrom(self, other)
[docs] def prepareUpdatePackage(self):
r"""
Creates/Returns the DeviceCommandPackage to be used for updates to a running command. Update package will be a shallow copy of this package.
It is expected that markUpdatePackageReady() be called after update package is altered.
:rtype: :py:class:`DeviceCommandPackage`
:return: DeviceCommandPackage*
"""
return _HC_API_PythonPackage.DeviceCommandPackage_prepareUpdatePackage(self)
[docs] def markUpdatePackageReady(self):
r"""
signal the update package is ready to be used in running commands.
prepareUpdatePackage() should be called first.
"""
return _HC_API_PythonPackage.DeviceCommandPackage_markUpdatePackageReady(self)
continuous = property(_HC_API_PythonPackage.DeviceCommandPackage_continuous_get, _HC_API_PythonPackage.DeviceCommandPackage_continuous_set, doc=r"""
set to true if command is a continous (async/time consuming) command or if it is desired that the command run indefinitely. (tracking command etc)
set to false if the command should terminate once a target is reached.
""")
def __init__(self):
_HC_API_PythonPackage.DeviceCommandPackage_swiginit(self, _HC_API_PythonPackage.new_DeviceCommandPackage())
_HC_API_PythonPackage.DeviceCommandPackage_swigregister(DeviceCommandPackage)
[docs]class MovementCommandPackage(DeviceCommandPackage):
r""" Generic Movement Command Supported on moving devices"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.MovementCommandPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.MovementCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.MovementCommandPackage_className(self)
def __init__(self):
_HC_API_PythonPackage.MovementCommandPackage_swiginit(self, _HC_API_PythonPackage.new_MovementCommandPackage())
__swig_destroy__ = _HC_API_PythonPackage.delete_MovementCommandPackage
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.MovementCommandPackage_cloneFrom(self, other)
Units_Millimeters = _HC_API_PythonPackage.MovementCommandPackage_Units_Millimeters
Units_Degrees = _HC_API_PythonPackage.MovementCommandPackage_Units_Degrees
disp_target = property(_HC_API_PythonPackage.MovementCommandPackage_disp_target_get, _HC_API_PythonPackage.MovementCommandPackage_disp_target_set, doc=r""" Position Target ex: (Millimeters)""")
vel_target = property(_HC_API_PythonPackage.MovementCommandPackage_vel_target_get, _HC_API_PythonPackage.MovementCommandPackage_vel_target_set, doc=r""" Vel Target ex: (Millimeters/S)""")
acc_target = property(_HC_API_PythonPackage.MovementCommandPackage_acc_target_get, _HC_API_PythonPackage.MovementCommandPackage_acc_target_set, doc=r""" Acc Target ex: (Millimeters/S^2)""")
disp_absolute = property(_HC_API_PythonPackage.MovementCommandPackage_disp_absolute_get, _HC_API_PythonPackage.MovementCommandPackage_disp_absolute_set, doc=r""" whether position should be global to device or relative to starting position when command starts.""")
trackDisp = property(_HC_API_PythonPackage.MovementCommandPackage_trackDisp_get, _HC_API_PythonPackage.MovementCommandPackage_trackDisp_set, doc=r""" Enable Track Displacement Target""")
trackVel = property(_HC_API_PythonPackage.MovementCommandPackage_trackVel_get, _HC_API_PythonPackage.MovementCommandPackage_trackVel_set, doc=r""" Track Velocity Target (if vel_target is non-zero)""")
trackAcc = property(_HC_API_PythonPackage.MovementCommandPackage_trackAcc_get, _HC_API_PythonPackage.MovementCommandPackage_trackAcc_set, doc=r""" Track Acceleration Target (if acc_target is non-zero)""")
units = property(_HC_API_PythonPackage.MovementCommandPackage_units_get, _HC_API_PythonPackage.MovementCommandPackage_units_set, doc=r""" units""")
_HC_API_PythonPackage.MovementCommandPackage_swigregister(MovementCommandPackage)
[docs]class MonitorCommandPackage(DeviceCommandPackage):
r"""Base class command to get current state of device."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.MonitorCommandPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.MonitorCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.MonitorCommandPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_MonitorCommandPackage
def __init__(self):
_HC_API_PythonPackage.MonitorCommandPackage_swiginit(self, _HC_API_PythonPackage.new_MonitorCommandPackage())
_HC_API_PythonPackage.MonitorCommandPackage_swigregister(MonitorCommandPackage)
[docs]class TimeDelayDeviceCommand(DeviceCommandPackage):
r""" Command that adds a time delay."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.TimeDelayDeviceCommand_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.TimeDelayDeviceCommand_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_TimeDelayDeviceCommand
time_s = property(_HC_API_PythonPackage.TimeDelayDeviceCommand_time_s_get, _HC_API_PythonPackage.TimeDelayDeviceCommand_time_s_set, doc=r"""
<summary>
time in seconds to wait.
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.TimeDelayDeviceCommand_swiginit(self, _HC_API_PythonPackage.new_TimeDelayDeviceCommand())
_HC_API_PythonPackage.TimeDelayDeviceCommand_swigregister(TimeDelayDeviceCommand)
[docs]class SynchronizeDeviceCommand(DeviceCommandPackage):
r""" Command that synchronizes multiple commands to finish at a certain time"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SynchronizeDeviceCommand_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SynchronizeDeviceCommand_className(self)
def __init__(self):
_HC_API_PythonPackage.SynchronizeDeviceCommand_swiginit(self, _HC_API_PythonPackage.new_SynchronizeDeviceCommand())
__swig_destroy__ = _HC_API_PythonPackage.delete_SynchronizeDeviceCommand
_HC_API_PythonPackage.SynchronizeDeviceCommand_swigregister(SynchronizeDeviceCommand)
[docs]class MovementStateInfo(CommandStateInfo):
r""" base class for representing the movement state of a command at any time."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.MovementStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.MovementStateInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_MovementStateInfo
referencePos = property(_HC_API_PythonPackage.MovementStateInfo_referencePos_get, _HC_API_PythonPackage.MovementStateInfo_referencePos_set)
currentTargetPos = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetPos_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetPos_set)
currentPos = property(_HC_API_PythonPackage.MovementStateInfo_currentPos_get, _HC_API_PythonPackage.MovementStateInfo_currentPos_set)
currentTargetVel = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetVel_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetVel_set)
currentVel = property(_HC_API_PythonPackage.MovementStateInfo_currentVel_get, _HC_API_PythonPackage.MovementStateInfo_currentVel_set)
currentTargetAcc = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetAcc_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetAcc_set)
currentAcc = property(_HC_API_PythonPackage.MovementStateInfo_currentAcc_get, _HC_API_PythonPackage.MovementStateInfo_currentAcc_set)
signedDir = property(_HC_API_PythonPackage.MovementStateInfo_signedDir_get, _HC_API_PythonPackage.MovementStateInfo_signedDir_set)
homing = property(_HC_API_PythonPackage.MovementStateInfo_homing_get, _HC_API_PythonPackage.MovementStateInfo_homing_set)
isHomed = property(_HC_API_PythonPackage.MovementStateInfo_isHomed_get, _HC_API_PythonPackage.MovementStateInfo_isHomed_set)
def __init__(self):
_HC_API_PythonPackage.MovementStateInfo_swiginit(self, _HC_API_PythonPackage.new_MovementStateInfo())
_HC_API_PythonPackage.MovementStateInfo_swigregister(MovementStateInfo)
[docs]class CommandStatusControlMethods(object):
r""" Base class for implementing methods for CommandStatus objects."""
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
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CommandStatusControlMethods_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CommandStatusControlMethods_className(self)
[docs] def runFull(self):
r"""
<summary>
initializes, and runs the command until it stops (blocking)
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_runFull(self)
[docs] def runASync(self):
r"""
<summary>
initialize and start the command async.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_runASync(self)
[docs] def initialize(self):
r"""
<summary>
Start the command by internally initializing the thread, binding to the device, and ensuring it is ready to be updated.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_initialize(self)
[docs] def update(self, stepped=False):
r"""
<summary>
update the command by allowing it to begin. if stepped = true, will begin to perform 1 update. if stepped = false, will update until finished.
<summary>
<param name="stepped"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_update(self, stepped)
[docs] def waitUpdateReady(self):
r"""
<summary>
Wait until command is ready to begin a update step
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_waitUpdateReady(self)
[docs] def waitUpdateReadyOrFinished(self):
r"""
<summary>
Wait until command is ready to begin an update step or it is finished.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_waitUpdateReadyOrFinished(self)
[docs] def waitFinished(self):
r"""
<summary>
Wait for the command to finish.
<summary>
"""
return _HC_API_PythonPackage.CommandStatusControlMethods_waitFinished(self)
[docs] def stop(self):
r""" End the command (cancel)"""
return _HC_API_PythonPackage.CommandStatusControlMethods_stop(self)
[docs] def isBusy(self):
r""" returns true if the command is currently running"""
return _HC_API_PythonPackage.CommandStatusControlMethods_isBusy(self)
[docs] def isUpdateStepReady(self):
return _HC_API_PythonPackage.CommandStatusControlMethods_isUpdateStepReady(self)
[docs] def isFinished(self):
r""" returns true if the command has finished. (normally finished or cancelled)."""
return _HC_API_PythonPackage.CommandStatusControlMethods_isFinished(self)
[docs] def isCancelled(self):
r""" returns true if the command was cancelled."""
return _HC_API_PythonPackage.CommandStatusControlMethods_isCancelled(self)
[docs] def isSuccessful(self):
return _HC_API_PythonPackage.CommandStatusControlMethods_isSuccessful(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CommandStatusControlMethods
_HC_API_PythonPackage.CommandStatusControlMethods_swigregister(CommandStatusControlMethods)
[docs]class CommandStatus(CommandStatusControlMethods):
r""" Command Status Object for tracking the current state of a queued or executing command."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CommandStatus_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CommandStatus_className(self)
def __init__(self):
_HC_API_PythonPackage.CommandStatus_swiginit(self, _HC_API_PythonPackage.new_CommandStatus())
__swig_destroy__ = _HC_API_PythonPackage.delete_CommandStatus
[docs] def runFull(self):
return _HC_API_PythonPackage.CommandStatus_runFull(self)
[docs] def runASync(self):
return _HC_API_PythonPackage.CommandStatus_runASync(self)
[docs] def initialize(self):
return _HC_API_PythonPackage.CommandStatus_initialize(self)
[docs] def update(self, stepped=False):
return _HC_API_PythonPackage.CommandStatus_update(self, stepped)
[docs] def waitUpdateReady(self):
return _HC_API_PythonPackage.CommandStatus_waitUpdateReady(self)
[docs] def waitUpdateReadyOrFinished(self):
return _HC_API_PythonPackage.CommandStatus_waitUpdateReadyOrFinished(self)
[docs] def waitFinished(self):
return _HC_API_PythonPackage.CommandStatus_waitFinished(self)
[docs] def stop(self):
return _HC_API_PythonPackage.CommandStatus_stop(self)
[docs] def isBusy(self):
return _HC_API_PythonPackage.CommandStatus_isBusy(self)
[docs] def isUpdateStepReady(self):
return _HC_API_PythonPackage.CommandStatus_isUpdateStepReady(self)
[docs] def isFinished(self):
return _HC_API_PythonPackage.CommandStatus_isFinished(self)
[docs] def isCancelled(self):
return _HC_API_PythonPackage.CommandStatus_isCancelled(self)
[docs] def isSuccessful(self):
return _HC_API_PythonPackage.CommandStatus_isSuccessful(self)
[docs] def apiId(self):
return _HC_API_PythonPackage.CommandStatus_apiId(self)
[docs] def deviceApiId(self):
return _HC_API_PythonPackage.CommandStatus_deviceApiId(self)
[docs] def stateInfo(self):
r"""
<summary>
The command state information associated with the command.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatus_stateInfo(self)
[docs] def commandPackage(self):
r"""
<summary>
The command package associated with the command.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatus_commandPackage(self)
[docs] def controlSystem(self):
r"""
<summary>
The control system this command status belongs to.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatus_controlSystem(self)
[docs] def deviceInfo(self):
r"""
<summary>
The device this command status is associated with.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatus_deviceInfo(self)
[docs] def deviceController(self):
r"""
<summary>
The device controller this command status is associated with.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.CommandStatus_deviceController(self)
alias = property(_HC_API_PythonPackage.CommandStatus_alias_get, _HC_API_PythonPackage.CommandStatus_alias_set, doc=r""" The unique alias for this command.""")
_HC_API_PythonPackage.CommandStatus_swigregister(CommandStatus)
[docs]class DeviceInfo(HardwareInfo):
r""" Base Class for describing a device to be attached to a DeviceController"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DeviceInfo_className(self)
def __init__(self):
_HC_API_PythonPackage.DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DeviceInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_DeviceInfo
[docs] def preLoopCommandCheck(self, checkCancelled=True):
return _HC_API_PythonPackage.DeviceInfo_preLoopCommandCheck(self, checkCancelled)
[docs] def isConnected(self):
r""" Returns true is the device is currently connected."""
return _HC_API_PythonPackage.DeviceInfo_isConnected(self)
[docs] def setEnableCommandLogging(self, enable):
r"""
set the device to log messages to the console. (default true)
:type enable: boolean
:param enable:
"""
return _HC_API_PythonPackage.DeviceInfo_setEnableCommandLogging(self, enable)
[docs] def setCommandLoggingLevel(self, level):
r"""
Set the command logging level, 0 - regular, 1 - more detail, 2 - even more detail, etc.
:type level: int
:param level:
"""
return _HC_API_PythonPackage.DeviceInfo_setCommandLoggingLevel(self, level)
[docs] def commandLoggingEnabled(self):
return _HC_API_PythonPackage.DeviceInfo_commandLoggingEnabled(self)
[docs] def commandLoggingLevel(self):
return _HC_API_PythonPackage.DeviceInfo_commandLoggingLevel(self)
[docs] def initializeCommand(self, commandPackage):
return _HC_API_PythonPackage.DeviceInfo_initializeCommand(self, commandPackage)
[docs] def addCommandGeneric(self, package):
return _HC_API_PythonPackage.DeviceInfo_addCommandGeneric(self, package)
[docs] def deviceController(self):
r""" access to owning controller."""
return _HC_API_PythonPackage.DeviceInfo_deviceController(self)
[docs] def controlSystem(self):
r""" access to owning control system."""
return _HC_API_PythonPackage.DeviceInfo_controlSystem(self)
_HC_API_PythonPackage.DeviceInfo_swigregister(DeviceInfo)
[docs]class CommandCallbacks(object):
r""" DEPRECIATED Base Clase to be overridden by user exposing methods called on command state changes."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CommandCallbacks_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CommandCallbacks_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CommandCallbacks
[docs] def onCommandFinished(self, commandStatus, deviceInfo):
r""" Called when a Command Finishes."""
return _HC_API_PythonPackage.CommandCallbacks_onCommandFinished(self, commandStatus, deviceInfo)
[docs] def onCommandUpdate(self, commandStatus, deviceInfo):
r""" Called during command execution"""
return _HC_API_PythonPackage.CommandCallbacks_onCommandUpdate(self, commandStatus, deviceInfo)
def __init__(self):
_HC_API_PythonPackage.CommandCallbacks_swiginit(self, _HC_API_PythonPackage.new_CommandCallbacks())
_HC_API_PythonPackage.CommandCallbacks_swigregister(CommandCallbacks)
[docs]class LoggerFunctionality(object):
r""" base class implementing logger functionality for classes."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LoggerFunctionality_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LoggerFunctionality_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LoggerFunctionality
[docs] def getLogger(self):
return _HC_API_PythonPackage.LoggerFunctionality_getLogger(self)
[docs] def loggerName(self):
return _HC_API_PythonPackage.LoggerFunctionality_loggerName(self)
def __init__(self):
_HC_API_PythonPackage.LoggerFunctionality_swiginit(self, _HC_API_PythonPackage.new_LoggerFunctionality())
_HC_API_PythonPackage.LoggerFunctionality_swigregister(LoggerFunctionality)
[docs]class ControlSystem(LoggerFunctionality):
r"""
Primary class for managing upper-level control over a multi-axis system with different devices.
Supports addition of Devices, Controllers, and Control/Commands
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ControlSystem_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ControlSystem_className(self)
def __init__(self, *args):
_HC_API_PythonPackage.ControlSystem_swiginit(self, _HC_API_PythonPackage.new_ControlSystem(*args))
__swig_destroy__ = _HC_API_PythonPackage.delete_ControlSystem
[docs] def addDeviceController(self, controller):
r""" Add a device controller to the control system."""
return _HC_API_PythonPackage.ControlSystem_addDeviceController(self, controller)
[docs] def initializeDevices(self):
r""" initFriendlyNameBuffer (start initial communication and do checks) on all added controllers/devices"""
return _HC_API_PythonPackage.ControlSystem_initializeDevices(self)
[docs] def initializeController(self, controller):
r""" initFriendlyNameBuffer an added device controller."""
return _HC_API_PythonPackage.ControlSystem_initializeController(self, controller)
[docs] def unInitialize(self):
r"""
<summary>
De initialize the control system. disconnecting all controllers and devices. user created controllers and devices should remain allocated while this function
is called - then can be freed/released afterwards.
<summary>
"""
return _HC_API_PythonPackage.ControlSystem_unInitialize(self)
[docs] def muteConsole(self):
r""" Mute info messages on console."""
return _HC_API_PythonPackage.ControlSystem_muteConsole(self)
[docs] def unMuteConsole(self):
r""" UnMute info message on console."""
return _HC_API_PythonPackage.ControlSystem_unMuteConsole(self)
[docs] def delay(self, *args):
r"""
*Overload 1:*
Add a time delay command to a device
|
*Overload 2:*
Add a time delay command to a device
"""
return _HC_API_PythonPackage.ControlSystem_delay(self, *args)
[docs] def addDeviceCommand(self, device, package):
r""" Add a command to a device."""
return _HC_API_PythonPackage.ControlSystem_addDeviceCommand(self, device, package)
[docs] def addDeviceCommandAlias(self, deviceAlias, package):
r""" Add a command to a device using device alias string"""
return _HC_API_PythonPackage.ControlSystem_addDeviceCommandAlias(self, deviceAlias, package)
[docs] def addDeviceCommandDevId(self, deviceId, package):
r""" Add a command to a device using device id"""
return _HC_API_PythonPackage.ControlSystem_addDeviceCommandDevId(self, deviceId, package)
[docs] def getDeviceFromAlias(self, deviceAlias):
r""" Get a device from its alias string"""
return _HC_API_PythonPackage.ControlSystem_getDeviceFromAlias(self, deviceAlias)
[docs] def getControllerFromAlias(self, controllerAlias):
r""" Get a controller from its alias string"""
return _HC_API_PythonPackage.ControlSystem_getControllerFromAlias(self, controllerAlias)
[docs] def runFullCommandListSeq(self, commandList):
r"""
<summary>
Run Commands in order, one after another, fully
<summary>
<param name="commandList"><param>
"""
return _HC_API_PythonPackage.ControlSystem_runFullCommandListSeq(self, commandList)
[docs] def runFullCommandListParallel(self, commandList):
r"""
<summary>
Run Commands in parallel
<summary>
<param name="commandList"><param>
"""
return _HC_API_PythonPackage.ControlSystem_runFullCommandListParallel(self, commandList)
[docs] def runASyncCommandList(self, commandList):
r"""
<summary>
Start the list of commands running async, returns immediately.
<summary>
<param name="commandList"><param>
"""
return _HC_API_PythonPackage.ControlSystem_runASyncCommandList(self, commandList)
[docs] def waitFinishedCommandList(self, commandList):
r"""
<summary>
Wait for the list of commands to complete
<summary>
<param name="commandList"><param>
"""
return _HC_API_PythonPackage.ControlSystem_waitFinishedCommandList(self, commandList)
[docs] def setCommandCallback(self, callbackObj):
r""" Attach a CommandCallbacks object to the ControlSystem."""
return _HC_API_PythonPackage.ControlSystem_setCommandCallback(self, callbackObj)
_HC_API_PythonPackage.ControlSystem_swigregister(ControlSystem)
[docs]class DeviceController(LoggerFunctionality):
r""" Base Class For Controlling Devices"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DeviceController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DeviceController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DeviceController
[docs] def checkCommandPackage(self, deviceId, package):
r""" check validity of command package"""
return _HC_API_PythonPackage.DeviceController_checkCommandPackage(self, deviceId, package)
[docs] def addDeviceInfo(self, dev):
r"""
<summary>
Add a device to the controller.
<summary>
<param name="dev"><param>
"""
return _HC_API_PythonPackage.DeviceController_addDeviceInfo(self, dev)
[docs] def removeDeviceInfo(self, dev):
r""" Remove an already added device."""
return _HC_API_PythonPackage.DeviceController_removeDeviceInfo(self, dev)
[docs] def setDisconnectCallback(self, callback):
r""" set a disconnected callback function to be called when the controller is disconnected."""
return _HC_API_PythonPackage.DeviceController_setDisconnectCallback(self, callback)
alias = property(_HC_API_PythonPackage.DeviceController_alias_get, _HC_API_PythonPackage.DeviceController_alias_set, doc=r""" Alias of the controller""")
port = property(_HC_API_PythonPackage.DeviceController_port_get, _HC_API_PythonPackage.DeviceController_port_set, doc=r''' port for connecting, if the device is a serial device this can be "COM3" or "/dev/tty.***"''')
[docs] def disconnect(self, expected=False):
r"""
disconnect the controller, should handle both a manual disconnect and could be called from a comm error disconnect.
set expected to false if called from a timeout error or unknown disconnect event. - error messages are printed.
set expected to true if a manual disconnection is wanted.- info messages are printed.
"""
return _HC_API_PythonPackage.DeviceController_disconnect(self, expected)
[docs] def isConnected(self):
r""" returns true if the controller is currently connected."""
return _HC_API_PythonPackage.DeviceController_isConnected(self)
[docs] def apiId(self):
r""" the assigned Api Id of the controller"""
return _HC_API_PythonPackage.DeviceController_apiId(self)
[docs] def setSimulated(self, simulated):
r"""
set the simulated flag on the controller - simulated controllers can simulate interaction with attached devices.
can only be set before the controller is initialized.
:type simulated: boolean
:param simulated:
"""
return _HC_API_PythonPackage.DeviceController_setSimulated(self, simulated)
[docs] def isSimulated(self):
r"""
return if the controller is simulated.
:rtype: boolean
:return:
"""
return _HC_API_PythonPackage.DeviceController_isSimulated(self)
def __init__(self):
_HC_API_PythonPackage.DeviceController_swiginit(self, _HC_API_PythonPackage.new_DeviceController())
_HC_API_PythonPackage.DeviceController_swigregister(DeviceController)
[docs]def As_MovementStateInfo(obj):
r""" Dynamic Cast a CommandStateInfo pointer into a MovementStateInfo pointer"""
return _HC_API_PythonPackage.As_MovementStateInfo(obj)
[docs]def As_MovementCommandPackage(obj):
return _HC_API_PythonPackage.As_MovementCommandPackage(obj)
[docs]class Vector3D(object):
r""" primative 3D Vector"""
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):
_HC_API_PythonPackage.Vector3D_swiginit(self, _HC_API_PythonPackage.new_Vector3D(*args))
x = property(_HC_API_PythonPackage.Vector3D_x_get, _HC_API_PythonPackage.Vector3D_x_set)
y = property(_HC_API_PythonPackage.Vector3D_y_get, _HC_API_PythonPackage.Vector3D_y_set)
z = property(_HC_API_PythonPackage.Vector3D_z_get, _HC_API_PythonPackage.Vector3D_z_set)
[docs] def IsZero(self):
r"""
<summary>
return true if vector is unset (0,0,0) (no fuzzy compare)
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.Vector3D_IsZero(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_Vector3D
_HC_API_PythonPackage.Vector3D_swigregister(Vector3D)
[docs]class HardwareDeviceController(DeviceController):
r""" <summary> Base Class for hardware controllers."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.HardwareDeviceController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.HardwareDeviceController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_HardwareDeviceController
def __init__(self):
_HC_API_PythonPackage.HardwareDeviceController_swiginit(self, _HC_API_PythonPackage.new_HardwareDeviceController())
_HC_API_PythonPackage.HardwareDeviceController_swigregister(HardwareDeviceController)
[docs]class DMXDeviceInfo(DeviceInfo):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceInfo
DMXBaseAddress = property(_HC_API_PythonPackage.DMXDeviceInfo_DMXBaseAddress_get, _HC_API_PythonPackage.DMXDeviceInfo_DMXBaseAddress_set)
numChannels = property(_HC_API_PythonPackage.DMXDeviceInfo_numChannels_get, _HC_API_PythonPackage.DMXDeviceInfo_numChannels_set)
def __init__(self):
_HC_API_PythonPackage.DMXDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceInfo())
_HC_API_PythonPackage.DMXDeviceInfo_swigregister(DMXDeviceInfo)
[docs]class DMXDeviceCommandPackage(DeviceCommandPackage):
r"""
<summary>
base class for dmx command packages
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DMXDeviceCommandPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceCommandPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommandPackage
def __init__(self):
_HC_API_PythonPackage.DMXDeviceCommandPackage_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommandPackage())
_HC_API_PythonPackage.DMXDeviceCommandPackage_swigregister(DMXDeviceCommandPackage)
[docs]class DMXDeviceCommandLightingPackage(DMXDeviceCommandPackage):
r"""
<summary>
base class for dmx lighting command packages
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommandLightingPackage
def __init__(self):
_HC_API_PythonPackage.DMXDeviceCommandLightingPackage_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommandLightingPackage())
_HC_API_PythonPackage.DMXDeviceCommandLightingPackage_swigregister(DMXDeviceCommandLightingPackage)
[docs]class DMXDeviceCommand_HSLColor8Bit(DMXDeviceCommandLightingPackage):
r"""
<summary>
command to set the hsl color of a dmx lighting device
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_HSLColor8Bit
h = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_h_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_h_set, doc=r"""
<summary>
hue
<summary>
""")
s = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_s_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_s_set, doc=r"""
<summary>
saturation
<summary>
""")
l = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_l_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_l_set, doc=r"""
<summary>
lightness
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_HSLColor8Bit())
_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_swigregister(DMXDeviceCommand_HSLColor8Bit)
[docs]class DMXDeviceCommand_RGBColor8Bit(DMXDeviceCommandLightingPackage):
r"""
<summary>
command to set the rgb color of a dmx lighting device
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_RGBColor8Bit
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_cloneFrom(self, other)
red = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_red_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_red_set)
green = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_green_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_green_set)
blue = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_blue_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_blue_set)
def __init__(self):
_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_RGBColor8Bit())
_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_swigregister(DMXDeviceCommand_RGBColor8Bit)
[docs]class DMXDeviceCommand_SetPersonality(DMXDeviceCommandPackage):
r"""
<summary>
command to set the dmx personality of a dmx lighting device
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_SetPersonality
personalityIndex = property(_HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_personalityIndex_get, _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_personalityIndex_set)
def __init__(self):
_HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_SetPersonality())
_HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_swigregister(DMXDeviceCommand_SetPersonality)
[docs]class dmxController(HardwareDeviceController):
r"""
<summary>
controller base class for dmx devices
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.dmxController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.dmxController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_dmxController
def __init__(self):
_HC_API_PythonPackage.dmxController_swiginit(self, _HC_API_PythonPackage.new_dmxController())
_HC_API_PythonPackage.dmxController_swigregister(dmxController)
[docs]class EntTecController(dmxController):
r"""
<summary>
controller for EntTec DMX USB Pro
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.EntTecController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.EntTecController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_EntTecController
def __init__(self):
_HC_API_PythonPackage.EntTecController_swiginit(self, _HC_API_PythonPackage.new_EntTecController())
_HC_API_PythonPackage.EntTecController_swigregister(EntTecController)
KinoFlo_P1_CCT_8b_3 = _HC_API_PythonPackage.KinoFlo_P1_CCT_8b_3
KinoFlo_P2_GEL_8b_6 = _HC_API_PythonPackage.KinoFlo_P2_GEL_8b_6
KinoFlo_P3_RGB_8b_6 = _HC_API_PythonPackage.KinoFlo_P3_RGB_8b_6
KinoFlo_P4_FX_8b_8 = _HC_API_PythonPackage.KinoFlo_P4_FX_8b_8
KinoFlo_P5_xy_8b_3 = _HC_API_PythonPackage.KinoFlo_P5_xy_8b_3
KinoFlo_P6_CCT_16b_4 = _HC_API_PythonPackage.KinoFlo_P6_CCT_16b_4
KinoFlo_P7_GEL_16b_7 = _HC_API_PythonPackage.KinoFlo_P7_GEL_16b_7
KinoFlo_P8_RGB_16b_7 = _HC_API_PythonPackage.KinoFlo_P8_RGB_16b_7
KinoFlo_P9_FX_16b_9 = _HC_API_PythonPackage.KinoFlo_P9_FX_16b_9
KinoFlo_P10_xy_16b_4 = _HC_API_PythonPackage.KinoFlo_P10_xy_16b_4
KinoFlo_P11_CCT_8b_3 = _HC_API_PythonPackage.KinoFlo_P11_CCT_8b_3
KinoFlo_P12_CCT_16b_5 = _HC_API_PythonPackage.KinoFlo_P12_CCT_16b_5
KinoFlo_P13_Gel_8b_3 = _HC_API_PythonPackage.KinoFlo_P13_Gel_8b_3
KinoFlo_P14_Gel_16b_5 = _HC_API_PythonPackage.KinoFlo_P14_Gel_16b_5
KinoFlo_P15_HS_8b_4 = _HC_API_PythonPackage.KinoFlo_P15_HS_8b_4
KinoFlo_P16_HS_16b_8 = _HC_API_PythonPackage.KinoFlo_P16_HS_16b_8
KinoFlo_P17_RGB_8b_5 = _HC_API_PythonPackage.KinoFlo_P17_RGB_8b_5
KinoFlo_P18_RGB_16b_10 = _HC_API_PythonPackage.KinoFlo_P18_RGB_16b_10
KinoFlo_P19_CIE_xy_8b_3 = _HC_API_PythonPackage.KinoFlo_P19_CIE_xy_8b_3
KinoFlo_P20_CIE_xy_16b_6 = _HC_API_PythonPackage.KinoFlo_P20_CIE_xy_16b_6
KinoFlo_P21_FX_8b_8 = _HC_API_PythonPackage.KinoFlo_P21_FX_8b_8
KinoFlo_P22_FX_16b_10 = _HC_API_PythonPackage.KinoFlo_P22_FX_16b_10
KinoFlo_P23_CCT_AND_HS_8b_7 = _HC_API_PythonPackage.KinoFlo_P23_CCT_AND_HS_8b_7
KinoFlo_P24_CCT_AND_HS_16b_13 = _HC_API_PythonPackage.KinoFlo_P24_CCT_AND_HS_16b_13
KinoFlo_P25_CCT_AND_RGB_8b_8 = _HC_API_PythonPackage.KinoFlo_P25_CCT_AND_RGB_8b_8
KinoFlo_P26_CCT_AND_RGB_16b_15 = _HC_API_PythonPackage.KinoFlo_P26_CCT_AND_RGB_16b_15
KinoFlo_P27_xy1_AND_xy2_8b_6 = _HC_API_PythonPackage.KinoFlo_P27_xy1_AND_xy2_8b_6
KinoFlo_P28_xy1_AND_xy2_16b_12 = _HC_API_PythonPackage.KinoFlo_P28_xy1_AND_xy2_16b_12
KinoFlo_P29_CCT_AND_TDRGB_8b_9 = _HC_API_PythonPackage.KinoFlo_P29_CCT_AND_TDRGB_8b_9
KinoFlo_P30_CCT_AND_TDRGB_16b_15 = _HC_API_PythonPackage.KinoFlo_P30_CCT_AND_TDRGB_16b_15
[docs]class KinoFloDeviceCommand_RGBColor8Bit(DMXDeviceCommand_RGBColor8Bit):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_KinoFloDeviceCommand_RGBColor8Bit
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cloneFrom(self, other)
dimmer = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_dimmer_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_dimmer_set)
cct = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cct_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cct_set)
greenMagenta = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_greenMagenta_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_greenMagenta_set)
def __init__(self):
_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_swiginit(self, _HC_API_PythonPackage.new_KinoFloDeviceCommand_RGBColor8Bit())
_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_swigregister(KinoFloDeviceCommand_RGBColor8Bit)
cvar = _HC_API_PythonPackage.cvar
KinoFlo_NALPCODE = cvar.KinoFlo_NALPCODE
[docs]class KinoFloDeviceInfo(DMXDeviceInfo):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.KinoFloDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.KinoFloDeviceInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_KinoFloDeviceInfo
def __init__(self):
_HC_API_PythonPackage.KinoFloDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_KinoFloDeviceInfo())
_HC_API_PythonPackage.KinoFloDeviceInfo_swigregister(KinoFloDeviceInfo)
[docs]class LiftingColumnMovementStateInfo(MovementStateInfo):
r"""
<summary>
Lifting Column Movement State Info
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnMovementStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnMovementStateInfo_className(self)
isStalled = property(_HC_API_PythonPackage.LiftingColumnMovementStateInfo_isStalled_get, _HC_API_PythonPackage.LiftingColumnMovementStateInfo_isStalled_set, doc=r"""
<summary>
indicates if the column has stalled (normal cases: at lower limit or upper limit - or under high load)
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.LiftingColumnMovementStateInfo_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnMovementStateInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnMovementStateInfo
_HC_API_PythonPackage.LiftingColumnMovementStateInfo_swigregister(LiftingColumnMovementStateInfo)
[docs]class LiftingColumnCommandStatus(CommandStatus):
r"""
<summary>
Lifting Column Command Status
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnCommandStatus_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnCommandStatus_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandStatus
[docs] def stateInfo(self):
return _HC_API_PythonPackage.LiftingColumnCommandStatus_stateInfo(self)
def __init__(self):
_HC_API_PythonPackage.LiftingColumnCommandStatus_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandStatus())
_HC_API_PythonPackage.LiftingColumnCommandStatus_swigregister(LiftingColumnCommandStatus)
[docs]class LiftingColumnCommandMovementPackage(MovementCommandPackage):
r"""
<summary>
Movement command for roboclaw.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandMovementPackage
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_cloneFrom(self, other)
expectStall = property(_HC_API_PythonPackage.LiftingColumnCommandMovementPackage_expectStall_get, _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_expectStall_set, doc=r"""
<summary>
stall expected flag - set to true if expecting a stall. (useful to home against mechanical limit)
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.LiftingColumnCommandMovementPackage_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandMovementPackage())
_HC_API_PythonPackage.LiftingColumnCommandMovementPackage_swigregister(LiftingColumnCommandMovementPackage)
[docs]class LiftingColumnCommandSetEncoderPos(DeviceCommandPackage):
r"""
<summary>
Set the Internal Encoder Count of the RoboClaw
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandSetEncoderPos
counts = property(_HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_counts_get, _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_counts_set)
def __init__(self):
_HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandSetEncoderPos())
_HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_swigregister(LiftingColumnCommandSetEncoderPos)
[docs]class LiftingColumnCommandGetEncoderPos(DeviceCommandPackage):
r"""
<summary>
Get the Internal Encoder Count of the RoboClaw
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandGetEncoderPos
def __init__(self):
_HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandGetEncoderPos())
_HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_swigregister(LiftingColumnCommandGetEncoderPos)
[docs]class LiftingColumnDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the Lifting Column
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LiftingColumnDeviceInfo_addCommand(self, package)
def __init__(self):
_HC_API_PythonPackage.LiftingColumnDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnDeviceInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnDeviceInfo
roboClawAddress = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_roboClawAddress_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_roboClawAddress_set)
QPSS = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_QPSS_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_QPSS_set)
encoderDeadZone = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_encoderDeadZone_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_encoderDeadZone_set)
mm_s_p_duty = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_mm_s_p_duty_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_mm_s_p_duty_set, doc=r"""
<summary>
(millimeters/s)/(dutyCycle) ratio
<summary>
""")
maxDutyCycle = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_maxDutyCycle_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_maxDutyCycle_set, doc=r"""
<summary>
duty cycle (power factor) (0 - 100)
<summary>
""")
countsPerMM = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_countsPerMM_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_countsPerMM_set, doc=r"""
<summary>
Counts Per millimeter
<summary>
""")
_HC_API_PythonPackage.LiftingColumnDeviceInfo_swigregister(LiftingColumnDeviceInfo)
[docs]class LiftingColumnController(HardwareDeviceController):
r"""
<summary>
controller for Lifting Column
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LiftingColumnController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LiftingColumnController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnController
def __init__(self):
_HC_API_PythonPackage.LiftingColumnController_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnController())
_HC_API_PythonPackage.LiftingColumnController_swigregister(LiftingColumnController)
[docs]class PheonixMecanoActuator(LiftingColumnDeviceInfo):
r"""
<summary>
Device Info for the Pheonix Mecano Actuator (DEPRECATED)
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.PheonixMecanoActuator_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.PheonixMecanoActuator_className(self)
def __init__(self):
_HC_API_PythonPackage.PheonixMecanoActuator_swiginit(self, _HC_API_PythonPackage.new_PheonixMecanoActuator())
__swig_destroy__ = _HC_API_PythonPackage.delete_PheonixMecanoActuator
_HC_API_PythonPackage.PheonixMecanoActuator_swigregister(PheonixMecanoActuator)
ExoLightDriveMode_DC = _HC_API_PythonPackage.ExoLightDriveMode_DC
ExoLightDriveMode_Strobe = _HC_API_PythonPackage.ExoLightDriveMode_Strobe
ExoLightDriveMode_Voltage = _HC_API_PythonPackage.ExoLightDriveMode_Voltage
TriggerType_Internal = _HC_API_PythonPackage.TriggerType_Internal
TriggerType_External = _HC_API_PythonPackage.TriggerType_External
[docs]class ExoLightCommand_SetLighting(DeviceCommandPackage):
r"""
<summary>
Command to set the lighting of a ExoLight device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ExoLightCommand_SetLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ExoLightCommand_SetLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ExoLightCommand_SetLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetLighting
outputEnabled = property(_HC_API_PythonPackage.ExoLightCommand_SetLighting_outputEnabled_get, _HC_API_PythonPackage.ExoLightCommand_SetLighting_outputEnabled_set)
def __init__(self):
_HC_API_PythonPackage.ExoLightCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetLighting())
_HC_API_PythonPackage.ExoLightCommand_SetLighting_swigregister(ExoLightCommand_SetLighting)
[docs]class ExoLightCommand_SetDCLighting(ExoLightCommand_SetLighting):
r"""
<summary>
Command to set the lighting (DC current drive mode) of a ExoLight device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetDCLighting
intensityPercent = property(_HC_API_PythonPackage.ExoLightCommand_SetDCLighting_intensityPercent_get, _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_intensityPercent_set, doc=r"""
<summary>
percentage of range [20mA to maxMilliAmpsDCMode] to drive the light in DC mode
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ExoLightCommand_SetDCLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetDCLighting())
_HC_API_PythonPackage.ExoLightCommand_SetDCLighting_swigregister(ExoLightCommand_SetDCLighting)
[docs]class ExoLightCommand_SetStrobeLighting(ExoLightCommand_SetLighting):
r"""
<summary>
Command to set the lighting (strobe mode) of a ExoLight device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetStrobeLighting
strobeCurrentMilliAmps = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeCurrentMilliAmps_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeCurrentMilliAmps_set, doc=r"""
<summary>
DC Amperage to drive the led (milliamps)
<summary>
""")
strobePulseWidthMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobePulseWidthMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobePulseWidthMicroSec_set, doc=r"""
<summary>
pulse width micro seconds
<summary>
""")
strobeTriggerPeriodMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerPeriodMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerPeriodMicroSec_set, doc=r"""
<summary>
trigger period in micro seconds
<summary>
""")
strobeTriggerDelayMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerDelayMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerDelayMicroSec_set, doc=r"""
<summary>
strobe trigger delay in microsecs
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetStrobeLighting())
_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_swigregister(ExoLightCommand_SetStrobeLighting)
[docs]class ExoLightCommand_SetVoltageLighting(ExoLightCommand_SetLighting):
r"""
<summary>
Command to set the lighting (voltage mode) of a ExoLight device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetVoltageLighting
voltage = property(_HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_voltage_get, _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_voltage_set, doc=r"""
<summary>
output voltage
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetVoltageLighting())
_HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_swigregister(ExoLightCommand_SetVoltageLighting)
[docs]class ULC2_DC_Mode(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
maxMilliAmpsDCMode = property(_HC_API_PythonPackage.ULC2_DC_Mode_maxMilliAmpsDCMode_get, _HC_API_PythonPackage.ULC2_DC_Mode_maxMilliAmpsDCMode_set, doc=r"""
<summary>
mac milliamps allowed to drive in DC mode.
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ULC2_DC_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_DC_Mode())
__swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_DC_Mode
_HC_API_PythonPackage.ULC2_DC_Mode_swigregister(ULC2_DC_Mode)
[docs]class ULC2_STROBE_Mode(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
strobeMilliAmpsLimit = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobeMilliAmpsLimit_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobeMilliAmpsLimit_set, doc=r"""
<summary>
strobe mode
<summary>
""")
strobePulseWidthMaxLimitMicroSec = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobePulseWidthMaxLimitMicroSec_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobePulseWidthMaxLimitMicroSec_set, doc=r"""
<summary>
strobe mode
<summary>
""")
strobeTriggerPeriodLimitMicroSec = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobeTriggerPeriodLimitMicroSec_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobeTriggerPeriodLimitMicroSec_set, doc=r"""
<summary>
strobe mode
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ULC2_STROBE_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_STROBE_Mode())
__swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_STROBE_Mode
_HC_API_PythonPackage.ULC2_STROBE_Mode_swigregister(ULC2_STROBE_Mode)
[docs]class ULC2_VOLTAGE_Mode(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
voltagelimitVolts = property(_HC_API_PythonPackage.ULC2_VOLTAGE_Mode_voltagelimitVolts_get, _HC_API_PythonPackage.ULC2_VOLTAGE_Mode_voltagelimitVolts_set, doc=r"""
<summary>
strobe mode
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ULC2_VOLTAGE_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_VOLTAGE_Mode())
__swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_VOLTAGE_Mode
_HC_API_PythonPackage.ULC2_VOLTAGE_Mode_swigregister(ULC2_VOLTAGE_Mode)
[docs]class ExoLight2DeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the ExoLight2 device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ExoLight2DeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ExoLight2DeviceInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ExoLight2DeviceInfo
channel = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_channel_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_channel_set, doc=r"""
<summary>
Channel as attached to the Metaphase ULC2 controller (1 or 2)
<summary>
""")
driveMode = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_driveMode_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_driveMode_set, doc=r"""
<summary>
Drive Control Mode
<summary>
""")
triggerControlsDC = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerControlsDC_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerControlsDC_set, doc=r"""
<summary>
<summary>
""")
triggerPolarity = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerPolarity_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerPolarity_set, doc=r"""
<summary>
Rising Edge (true) or Falling Edge (false)
<summary>
""")
triggerType = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerType_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerType_set, doc=r"""
<summary>
Trigger type internal external.
<summary>
""")
outputEnabled = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_outputEnabled_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_outputEnabled_set, doc=r"""
<summary>
Enable output to LED
<summary>
""")
modeDCSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeDCSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeDCSettings_set)
modeStrobeSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeStrobeSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeStrobeSettings_set)
modeVoltageSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeVoltageSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeVoltageSettings_set)
def __init__(self):
_HC_API_PythonPackage.ExoLight2DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ExoLight2DeviceInfo())
_HC_API_PythonPackage.ExoLight2DeviceInfo_swigregister(ExoLight2DeviceInfo)
[docs]class ULC2Controller(HardwareDeviceController):
r"""
<summary>
base class controller for ULC2
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ULC2Controller_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ULC2Controller_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ULC2Controller
ipAddress = property(_HC_API_PythonPackage.ULC2Controller_ipAddress_get, _HC_API_PythonPackage.ULC2Controller_ipAddress_set)
localUdpPort = property(_HC_API_PythonPackage.ULC2Controller_localUdpPort_get, _HC_API_PythonPackage.ULC2Controller_localUdpPort_set)
def __init__(self):
_HC_API_PythonPackage.ULC2Controller_swiginit(self, _HC_API_PythonPackage.new_ULC2Controller())
_HC_API_PythonPackage.ULC2Controller_swigregister(ULC2Controller)
[docs]class LedLightBoxCommand_Lighting(DeviceCommandPackage):
r"""
<summary>
Command to set the lighting of a led light box.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxCommand_Lighting
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_cloneFrom(self, other)
dimmerIntensityPercent = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_dimmerIntensityPercent_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_dimmerIntensityPercent_set)
colorTemperaturePerc = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_colorTemperaturePerc_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_colorTemperaturePerc_set)
highLowSetting = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_highLowSetting_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_highLowSetting_set)
flickerFrequencyHz = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerFrequencyHz_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerFrequencyHz_set)
flickerDutyCyclePercent = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerDutyCyclePercent_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerDutyCyclePercent_set)
def __init__(self):
_HC_API_PythonPackage.LedLightBoxCommand_Lighting_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxCommand_Lighting())
_HC_API_PythonPackage.LedLightBoxCommand_Lighting_swigregister(LedLightBoxCommand_Lighting)
LedLightBox_NALPCODE = cvar.LedLightBox_NALPCODE
[docs]class LedLightPanelCommand_SetLighting(LedLightBoxCommand_Lighting):
r"""
<summary>
Command to set the lighting of a led light panel.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightPanelCommand_SetLighting
def __init__(self):
_HC_API_PythonPackage.LedLightPanelCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_LedLightPanelCommand_SetLighting())
_HC_API_PythonPackage.LedLightPanelCommand_SetLighting_swigregister(LedLightPanelCommand_SetLighting)
[docs]class LedLightBoxDeviceInfo(DeviceInfo):
r"""
<summary>
https://www.imatest.com/product/imatest-led-lightbox/
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDeviceInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDeviceInfo
maxDimmerIntegerHigh = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerHigh_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerHigh_set)
maxDimmerIntegerLow = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerLow_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerLow_set)
highLowCapable = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_highLowCapable_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_highLowCapable_set)
mixedCapable = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_mixedCapable_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_mixedCapable_set)
isPanel = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_isPanel_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_isPanel_set)
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDeviceInfo())
_HC_API_PythonPackage.LedLightBoxDeviceInfo_swigregister(LedLightBoxDeviceInfo)
[docs]class LedLightBoxDevice_Standard_LED_Box_Single_Info(LedLightBoxDeviceInfo):
r"""
<summary>
device info for Standard_LED_Box_Single
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Standard_LED_Box_Single_Info
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Standard_LED_Box_Single_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_friendlyName()
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_swigregister(LedLightBoxDevice_Standard_LED_Box_Single_Info)
[docs]class LedLightBoxDevice_Standard_LED_Box_Mixed_Info(LedLightBoxDeviceInfo):
r"""
<summary>
device info for Standard_LED_Box_Mixed
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Standard_LED_Box_Mixed_Info
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Standard_LED_Box_Mixed_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_friendlyName()
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_swigregister(LedLightBoxDevice_Standard_LED_Box_Mixed_Info)
[docs]class LedLightBoxDevice_High_LUX_LED_Box_Single_Info(LedLightBoxDeviceInfo):
r"""
<summary>
device info for High_LUX_LED_Box_Single
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_High_LUX_LED_Box_Single_Info
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_High_LUX_LED_Box_Single_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_friendlyName()
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_swigregister(LedLightBoxDevice_High_LUX_LED_Box_Single_Info)
[docs]class LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info(LedLightBoxDeviceInfo):
r"""
<summary>
device info for High_LUX_LED_Box_Mixed
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_friendlyName()
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_swigregister(LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info)
[docs]class LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info(LedLightBoxDeviceInfo):
r"""
<summary>
device info for Ultra_High_Illumination_Flickering
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info
def __init__(self):
_HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_friendlyName()
_HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_swigregister(LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info)
[docs]class LedLightBoxControllerBase(HardwareDeviceController):
r"""
<summary>
base class for led light box controllers
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxControllerBase_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxControllerBase_className(self)
def __init__(self):
_HC_API_PythonPackage.LedLightBoxControllerBase_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxControllerBase())
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxControllerBase
_HC_API_PythonPackage.LedLightBoxControllerBase_swigregister(LedLightBoxControllerBase)
[docs]class LedLightBoxController(LedLightBoxControllerBase):
r"""
<summary>
controller for LedLightBox
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightBoxController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightBoxController_className(self)
def __init__(self):
_HC_API_PythonPackage.LedLightBoxController_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxController())
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxController
_HC_API_PythonPackage.LedLightBoxController_swigregister(LedLightBoxController)
[docs]class LedLightPanel_Single_Info(LedLightBoxDeviceInfo):
r"""
<summary>
https://www.imatest.com/wp-content/uploads/2019/04/Imatest-LED-Light-Panel_Info-Sheet.pdf
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LedLightPanel_Single_Info_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LedLightPanel_Single_Info_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LedLightPanel_Single_Info_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LedLightPanel_Single_Info
def __init__(self):
_HC_API_PythonPackage.LedLightPanel_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightPanel_Single_Info())
[docs] @staticmethod
def friendlyName():
return _HC_API_PythonPackage.LedLightPanel_Single_Info_friendlyName()
_HC_API_PythonPackage.LedLightPanel_Single_Info_swigregister(LedLightPanel_Single_Info)
IsoLightPuck_LEDPatterns_Continuous_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Red
IsoLightPuck_LEDPatterns_Continuous_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Yellow
IsoLightPuck_LEDPatterns_Continuous_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Green
IsoLightPuck_LEDPatterns_Continuous_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Blue
IsoLightPuck_LEDPatterns_Continuous_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Magenta
IsoLightPuck_LEDPatterns_Flashing_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Red
IsoLightPuck_LEDPatterns_Flashing_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Yellow
IsoLightPuck_LEDPatterns_Flashing_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Green
IsoLightPuck_LEDPatterns_Flashing_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Blue
IsoLightPuck_LEDPatterns_Flashing_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Magenta
IsoLightPuck_LEDPatterns_Spin_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Red
IsoLightPuck_LEDPatterns_Spin_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Yellow
IsoLightPuck_LEDPatterns_Spin_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Green
IsoLightPuck_LEDPatterns_Spin_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Blue
IsoLightPuck_LEDPatterns_Spin_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Magenta
IsoLightPuck_LEDPatterns_RainbowCycle = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_RainbowCycle
[docs]class IsolightPuckCommand_Update(DeviceCommandPackage):
r"""
<summary>
Command to update the lighting and take light sensor reading from the isolight puck.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.IsolightPuckCommand_Update_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.IsolightPuckCommand_Update_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.IsolightPuckCommand_Update_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckCommand_Update
ledPattern = property(_HC_API_PythonPackage.IsolightPuckCommand_Update_ledPattern_get, _HC_API_PythonPackage.IsolightPuckCommand_Update_ledPattern_set, doc=r"""
<summary>
LED pattern
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.IsolightPuckCommand_Update_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckCommand_Update())
_HC_API_PythonPackage.IsolightPuckCommand_Update_swigregister(IsolightPuckCommand_Update)
[docs]class IsolightPuckUpdateStateInfo(CommandStateInfo):
r"""
<summary>
State Info providing readings from the isolight puck sensor.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_className(self)
sensor_GRXYZ_X = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_X_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_X_set, doc=r"""
<summary>
GRXYZ values
<summary>
""")
sensor_GRXYZ_Y = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Y_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Y_set)
sensor_GRXYZ_Z = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Z_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Z_set)
sensor_x_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_x_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_x_normalized_set, doc=r"""
<summary>
normalized x,y,z values
<summary>
""")
sensor_y_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_y_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_y_normalized_set)
sensor_z_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_z_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_z_normalized_set)
sensor_u_prime = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_u_prime_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_u_prime_set, doc=r"""
<summary>
Yu'v' color space
<summary>
""")
sensor_v_prime = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_v_prime_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_v_prime_set)
sensor_cct = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_cct_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_cct_set, doc=r"""
<summary>
correlated color temperature (K)
<summary>
""")
sensor_lightlevel = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_lightlevel_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_lightlevel_set, doc=r"""
<summary>
light level in lux
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckUpdateStateInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckUpdateStateInfo
_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_swigregister(IsolightPuckUpdateStateInfo)
[docs]class IsolightPuckCommandStatus(CommandStatus):
r"""
<summary>
Command status for the isolight puck.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.IsolightPuckCommandStatus_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.IsolightPuckCommandStatus_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckCommandStatus
[docs] def stateInfo(self):
return _HC_API_PythonPackage.IsolightPuckCommandStatus_stateInfo(self)
def __init__(self):
_HC_API_PythonPackage.IsolightPuckCommandStatus_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckCommandStatus())
_HC_API_PythonPackage.IsolightPuckCommandStatus_swigregister(IsolightPuckCommandStatus)
[docs]class IsolightPuckDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the isolight puck.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.IsolightPuckDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.IsolightPuckDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.IsolightPuckDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckDeviceInfo
port = property(_HC_API_PythonPackage.IsolightPuckDeviceInfo_port_get, _HC_API_PythonPackage.IsolightPuckDeviceInfo_port_set, doc=r""" Sereal Port Associated with the puck""")
updateRateMS = property(_HC_API_PythonPackage.IsolightPuckDeviceInfo_updateRateMS_get, _HC_API_PythonPackage.IsolightPuckDeviceInfo_updateRateMS_set, doc=r"""
<summary>
suggested update rate of the internal sensor in milliseconds, sensor may increase this in order to take accurate readings.
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.IsolightPuckDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckDeviceInfo())
_HC_API_PythonPackage.IsolightPuckDeviceInfo_swigregister(IsolightPuckDeviceInfo)
[docs]class IsolightPuckController(HardwareDeviceController):
r"""
<summary>
Controller for the isolight puck.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.IsolightPuckController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.IsolightPuckController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckController
def __init__(self):
_HC_API_PythonPackage.IsolightPuckController_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckController())
_HC_API_PythonPackage.IsolightPuckController_swigregister(IsolightPuckController)
[docs]class SpectralSensor_SpecDataInfo(object):
r"""
<summary>
Data Info for the Spectral Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
iType = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iType_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iType_set)
iVer = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iVer_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iVer_set)
Mark = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Mark_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Mark_set)
fLx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fLx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fLx_set)
fEfc = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fEfc_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fEfc_set)
cct = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_cct_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_cct_set)
duv = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_duv_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_duv_set)
x = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_x_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_x_set)
y = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_y_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_y_set)
u = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u_set)
v = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v_set)
u2 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u2_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u2_set)
v2 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v2_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v2_set)
Ra = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ra_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ra_set)
Ri = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ri_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ri_set)
fSP = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fSP_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fSP_set)
DominantWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_DominantWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_DominantWave_set)
Purity = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Purity_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Purity_set)
HlafWidth = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_HlafWidth_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_HlafWidth_set)
PeakWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_PeakWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_PeakWave_set)
CentreWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentreWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentreWave_set)
CentroidWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentroidWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentroidWave_set)
fRraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fRraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fRraito_set)
fGraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fGraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fGraito_set)
fBraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fBraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fBraito_set)
IntegTime0 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_IntegTime0_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_IntegTime0_set)
VPeak = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VPeak_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VPeak_set)
VDark = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDark_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDark_set)
VDarkDAC = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDarkDAC_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDarkDAC_set)
TestDate = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestDate_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestDate_set)
TestTime = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestTime_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestTime_set)
Spect1nmData = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Spect1nmData_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Spect1nmData_set)
StartTestWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWave_set)
EndTestWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWave_set)
StartTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWaveIdx_set)
EndTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWaveIdx_set)
def __init__(self):
_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensor_SpecDataInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensor_SpecDataInfo
_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_swigregister(SpectralSensor_SpecDataInfo)
SpectralSensor_NALPCODE = cvar.SpectralSensor_NALPCODE
[docs]class SpectralSensorCommand_Update(DeviceCommandPackage):
r"""
<summary>
Command to update the lighting and take light sensor reading from the isolight puck.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.SpectralSensorCommand_Update_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SpectralSensorCommand_Update_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SpectralSensorCommand_Update_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorCommand_Update
integralTime_US = property(_HC_API_PythonPackage.SpectralSensorCommand_Update_integralTime_US_get, _HC_API_PythonPackage.SpectralSensorCommand_Update_integralTime_US_set, doc=r"""
<summary>
Time in microseconds the device should integrate over for each end-result sample
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.SpectralSensorCommand_Update_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorCommand_Update())
_HC_API_PythonPackage.SpectralSensorCommand_Update_swigregister(SpectralSensorCommand_Update)
[docs]class SpectralSensorUpdateStateInfo(CommandStateInfo):
r"""
<summary>
State Info providing readings from the SpectralSensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_className(self)
iType = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iType_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iType_set, doc=r"""Spectrograph/lighting data""")
iVer = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iVer_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iVer_set)
Mark = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Mark_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Mark_set)
fLx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fLx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fLx_set)
fEfc = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fEfc_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fEfc_set)
cct = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_cct_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_cct_set)
duv = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_duv_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_duv_set)
x = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_x_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_x_set)
y = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_y_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_y_set)
u = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u_set)
v = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v_set)
u2 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u2_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u2_set)
v2 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v2_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v2_set)
Ra = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ra_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ra_set)
Ri = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ri_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ri_set)
fSP = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fSP_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fSP_set)
DominantWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_DominantWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_DominantWave_set)
Purity = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Purity_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Purity_set)
HlafWidth = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_HlafWidth_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_HlafWidth_set)
PeakWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_PeakWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_PeakWave_set)
CentreWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentreWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentreWave_set)
CentroidWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentroidWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentroidWave_set)
fRraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fRraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fRraito_set)
fGraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fGraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fGraito_set)
fBraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fBraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fBraito_set)
IntegTime0 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_IntegTime0_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_IntegTime0_set)
VPeak = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VPeak_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VPeak_set)
VDark = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDark_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDark_set)
VDarkDAC = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDarkDAC_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDarkDAC_set)
TestDate = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestDate_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestDate_set)
TestTime = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestTime_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestTime_set)
Spect1nmData = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Spect1nmData_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Spect1nmData_set)
StartTestWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWave_set)
EndTestWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWave_set)
StartTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWaveIdx_set)
EndTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWaveIdx_set)
def __init__(self):
_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorUpdateStateInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorUpdateStateInfo
_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_swigregister(SpectralSensorUpdateStateInfo)
[docs]class SpectralSensorCommandStatus(CommandStatus):
r"""
<summary>
Command Status for the Spectral Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SpectralSensorCommandStatus_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SpectralSensorCommandStatus_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorCommandStatus
[docs] def stateInfo(self):
return _HC_API_PythonPackage.SpectralSensorCommandStatus_stateInfo(self)
def __init__(self):
_HC_API_PythonPackage.SpectralSensorCommandStatus_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorCommandStatus())
_HC_API_PythonPackage.SpectralSensorCommandStatus_swigregister(SpectralSensorCommandStatus)
[docs]class SpectralSensorDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the Spectral Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SpectralSensorDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SpectralSensorDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.SpectralSensorDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorDeviceInfo
def __init__(self):
_HC_API_PythonPackage.SpectralSensorDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorDeviceInfo())
_HC_API_PythonPackage.SpectralSensorDeviceInfo_swigregister(SpectralSensorDeviceInfo)
[docs]class SpectralSensorController(HardwareDeviceController):
r"""
<summary>
Controller for the Spectral Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.SpectralSensorController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.SpectralSensorController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorController
def __init__(self):
_HC_API_PythonPackage.SpectralSensorController_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorController())
_HC_API_PythonPackage.SpectralSensorController_swigregister(SpectralSensorController)
[docs]class LowLightSensor_DataInfo(object):
r"""
<summary>
Data Info for the Low Light Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
fLx = property(_HC_API_PythonPackage.LowLightSensor_DataInfo_fLx_get, _HC_API_PythonPackage.LowLightSensor_DataInfo_fLx_set)
def __init__(self):
_HC_API_PythonPackage.LowLightSensor_DataInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensor_DataInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensor_DataInfo
_HC_API_PythonPackage.LowLightSensor_DataInfo_swigregister(LowLightSensor_DataInfo)
LowLightSensor_NALPCODE = cvar.LowLightSensor_NALPCODE
[docs]class LowLightSensorCommand_Update(DeviceCommandPackage):
r"""
<summary>
Command to update the lighting and take light sensor reading
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.LowLightSensorCommand_Update_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LowLightSensorCommand_Update_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LowLightSensorCommand_Update_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorCommand_Update
def __init__(self):
_HC_API_PythonPackage.LowLightSensorCommand_Update_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorCommand_Update())
_HC_API_PythonPackage.LowLightSensorCommand_Update_swigregister(LowLightSensorCommand_Update)
[docs]class LowLightSensorUpdateStateInfo(CommandStateInfo):
r"""
<summary>
State Info providing readings from the low light sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_className(self)
lx = property(_HC_API_PythonPackage.LowLightSensorUpdateStateInfo_lx_get, _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_lx_set)
def __init__(self):
_HC_API_PythonPackage.LowLightSensorUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorUpdateStateInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorUpdateStateInfo
_HC_API_PythonPackage.LowLightSensorUpdateStateInfo_swigregister(LowLightSensorUpdateStateInfo)
[docs]class LowLightSensorCommandStatus(CommandStatus):
r"""
<summary>
Command Status for the Low Light Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LowLightSensorCommandStatus_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LowLightSensorCommandStatus_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorCommandStatus
[docs] def stateInfo(self):
return _HC_API_PythonPackage.LowLightSensorCommandStatus_stateInfo(self)
def __init__(self):
_HC_API_PythonPackage.LowLightSensorCommandStatus_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorCommandStatus())
_HC_API_PythonPackage.LowLightSensorCommandStatus_swigregister(LowLightSensorCommandStatus)
[docs]class LowLightSensorDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the Low Light Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LowLightSensorDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LowLightSensorDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LowLightSensorDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorDeviceInfo
def __init__(self):
_HC_API_PythonPackage.LowLightSensorDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorDeviceInfo())
_HC_API_PythonPackage.LowLightSensorDeviceInfo_swigregister(LowLightSensorDeviceInfo)
[docs]class LowLightSensorController(HardwareDeviceController):
r"""
<summary>
Controller for the Low Light Sensor
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LowLightSensorController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LowLightSensorController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorController
def __init__(self):
_HC_API_PythonPackage.LowLightSensorController_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorController())
_HC_API_PythonPackage.LowLightSensorController_swigregister(LowLightSensorController)
[docs]class ZaberAxisInfo(PhysicalAxisControlInfo):
r"""
<summary>
Axis Info for attaching to a Zaber Device
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
alias = property(_HC_API_PythonPackage.ZaberAxisInfo_alias_get, _HC_API_PythonPackage.ZaberAxisInfo_alias_set)
apiAxisIdx = property(_HC_API_PythonPackage.ZaberAxisInfo_apiAxisIdx_get, _HC_API_PythonPackage.ZaberAxisInfo_apiAxisIdx_set)
def __init__(self):
_HC_API_PythonPackage.ZaberAxisInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberAxisInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberAxisInfo
_HC_API_PythonPackage.ZaberAxisInfo_swigregister(ZaberAxisInfo)
[docs]class ZaberDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for a single Zaber device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ZaberDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ZaberDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.ZaberDeviceInfo_addCommand(self, package)
def __init__(self):
_HC_API_PythonPackage.ZaberDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberDeviceInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberDeviceInfo
[docs] def AddAxisInfo(self, axis):
return _HC_API_PythonPackage.ZaberDeviceInfo_AddAxisInfo(self, axis)
[docs] def initializeCommand(self, commandPacakge):
return _HC_API_PythonPackage.ZaberDeviceInfo_initializeCommand(self, commandPacakge)
zaberDeviceAddress = property(_HC_API_PythonPackage.ZaberDeviceInfo_zaberDeviceAddress_get, _HC_API_PythonPackage.ZaberDeviceInfo_zaberDeviceAddress_set)
internals = property(_HC_API_PythonPackage.ZaberDeviceInfo_internals_get, _HC_API_PythonPackage.ZaberDeviceInfo_internals_set)
motionSim = property(_HC_API_PythonPackage.ZaberDeviceInfo_motionSim_get, _HC_API_PythonPackage.ZaberDeviceInfo_motionSim_set)
_HC_API_PythonPackage.ZaberDeviceInfo_swigregister(ZaberDeviceInfo)
[docs]class ZaberCommandSetAxisMovement(MovementCommandPackage):
r"""
<summary>
command to set axis movement on a zaber device
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandSetAxisMovement
doNativeHome = property(_HC_API_PythonPackage.ZaberCommandSetAxisMovement_doNativeHome_get, _HC_API_PythonPackage.ZaberCommandSetAxisMovement_doNativeHome_set, doc=r"""
<summary>
Ignores all other parameters and calls home() on the zaber device.
<summary>
""")
zaberAxisId = property(_HC_API_PythonPackage.ZaberCommandSetAxisMovement_zaberAxisId_get, _HC_API_PythonPackage.ZaberCommandSetAxisMovement_zaberAxisId_set)
def __init__(self):
_HC_API_PythonPackage.ZaberCommandSetAxisMovement_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandSetAxisMovement())
_HC_API_PythonPackage.ZaberCommandSetAxisMovement_swigregister(ZaberCommandSetAxisMovement)
[docs]def As_ZaberCommandSetAxisMovement(package):
return _HC_API_PythonPackage.As_ZaberCommandSetAxisMovement(package)
[docs]class ZaberCommandStorageKeyStateInfo(CommandStateInfo):
r"""
<summary>
state info for storage keystate of a zaber device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_className(self)
value = property(_HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_value_get, _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_value_set)
def __init__(self):
_HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandStorageKeyStateInfo())
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandStorageKeyStateInfo
_HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_swigregister(ZaberCommandStorageKeyStateInfo)
[docs]class ZaberCommandSetStorageKey(DeviceCommandPackage):
r"""
<summary>
command to set the storage key / value on a zaber device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ZaberCommandSetStorageKey_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ZaberCommandSetStorageKey_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ZaberCommandSetStorageKey_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandSetStorageKey
key = property(_HC_API_PythonPackage.ZaberCommandSetStorageKey_key_get, _HC_API_PythonPackage.ZaberCommandSetStorageKey_key_set, doc=r"""
<summary>
Zaber Storage Key
<summary>
""")
number = property(_HC_API_PythonPackage.ZaberCommandSetStorageKey_number_get, _HC_API_PythonPackage.ZaberCommandSetStorageKey_number_set)
def __init__(self):
_HC_API_PythonPackage.ZaberCommandSetStorageKey_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandSetStorageKey())
_HC_API_PythonPackage.ZaberCommandSetStorageKey_swigregister(ZaberCommandSetStorageKey)
[docs]def As_ZaberCommandSetStorageKey(package):
return _HC_API_PythonPackage.As_ZaberCommandSetStorageKey(package)
[docs]class ZaberCommandGetStorageKey(DeviceCommandPackage):
r"""
<summary>
command to get the storage key / value on a zaber device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ZaberCommandGetStorageKey_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ZaberCommandGetStorageKey_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ZaberCommandGetStorageKey_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandGetStorageKey
key = property(_HC_API_PythonPackage.ZaberCommandGetStorageKey_key_get, _HC_API_PythonPackage.ZaberCommandGetStorageKey_key_set, doc=r"""
<summary>
Zaber Storage Key
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ZaberCommandGetStorageKey_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandGetStorageKey())
_HC_API_PythonPackage.ZaberCommandGetStorageKey_swigregister(ZaberCommandGetStorageKey)
[docs]def As_ZaberCommandGetStorageKey(package):
return _HC_API_PythonPackage.As_ZaberCommandGetStorageKey(package)
[docs]class zaberController(HardwareDeviceController):
r"""
<summary>
controller for Zaber devices
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.zaberController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.zaberController_className(self)
def __init__(self):
_HC_API_PythonPackage.zaberController_swiginit(self, _HC_API_PythonPackage.new_zaberController())
__swig_destroy__ = _HC_API_PythonPackage.delete_zaberController
_HC_API_PythonPackage.zaberController_swigregister(zaberController)
[docs]def zaber_To_HomeSpace(zaber):
r"""
<summary>
convert zaber axis positions to homespace coordinates.
<summary>
<param name="zaber"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.zaber_To_HomeSpace(zaber)
[docs]def homeSpace_To_Zaber(home):
r"""
<summary>
<summary>
<param name="home"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.homeSpace_To_Zaber(home)
[docs]class CompositeCommandStatusSet(CommandStatusControlMethods):
r""" base class for giving access to composite command status sets. and functions to manage groups of commands etc."""
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
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CompositeCommandStatusSet_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_className(self)
[docs] def runFull(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_runFull(self)
[docs] def runASync(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_runASync(self)
[docs] def initialize(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_initialize(self)
[docs] def updateoverride(self, stepped=False):
return _HC_API_PythonPackage.CompositeCommandStatusSet_updateoverride(self, stepped)
[docs] def waitUpdateReady(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_waitUpdateReady(self)
[docs] def waitUpdateReadyOrFinished(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_waitUpdateReadyOrFinished(self)
[docs] def waitFinished(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_waitFinished(self)
[docs] def stop(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_stop(self)
[docs] def isBusy(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_isBusy(self)
[docs] def isFinished(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_isFinished(self)
[docs] def isCancelled(self):
return _HC_API_PythonPackage.CompositeCommandStatusSet_isCancelled(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CompositeCommandStatusSet
_HC_API_PythonPackage.CompositeCommandStatusSet_swigregister(CompositeCommandStatusSet)
[docs]class CompositeFrameBase(object):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CompositeFrameBase_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CompositeFrameBase_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CompositeFrameBase
def __init__(self):
_HC_API_PythonPackage.CompositeFrameBase_swiginit(self, _HC_API_PythonPackage.new_CompositeFrameBase())
system = property(_HC_API_PythonPackage.CompositeFrameBase_system_get, _HC_API_PythonPackage.CompositeFrameBase_system_set)
_HC_API_PythonPackage.CompositeFrameBase_swigregister(CompositeFrameBase)
[docs]class BTSFramingCommandStatusSet(CompositeCommandStatusSet):
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
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.BTSFramingCommandStatusSet_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.BTSFramingCommandStatusSet_className(self)
xAxis = property(_HC_API_PythonPackage.BTSFramingCommandStatusSet_xAxis_get, _HC_API_PythonPackage.BTSFramingCommandStatusSet_xAxis_set)
zAxis = property(_HC_API_PythonPackage.BTSFramingCommandStatusSet_zAxis_get, _HC_API_PythonPackage.BTSFramingCommandStatusSet_zAxis_set)
__swig_destroy__ = _HC_API_PythonPackage.delete_BTSFramingCommandStatusSet
_HC_API_PythonPackage.BTSFramingCommandStatusSet_swigregister(BTSFramingCommandStatusSet)
[docs]class BTSFraming(CompositeFrameBase):
r"""
<summary>
BTSFraming class, contains methods for control of BTS frames.
all dimension Units are in millimeters
https://drive.google.com/file/d/1pRtOPzCtmoEOHzolEsyHNhHvKwgjnRsm/view?usp=drive_link
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.BTSFraming_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.BTSFraming_className(self)
zaberPort = property(_HC_API_PythonPackage.BTSFraming_zaberPort_get, _HC_API_PythonPackage.BTSFraming_zaberPort_set, doc=r"""
<summary>
Serial Port for zaber (ex "COM4")
Set Before initialization.
<summary>
""")
ChartCenterHome_CameraCenterFrame = property(_HC_API_PythonPackage.BTSFraming_ChartCenterHome_CameraCenterFrame_get, _HC_API_PythonPackage.BTSFraming_ChartCenterHome_CameraCenterFrame_set, doc=r"""
<summary>
Chart center home position in the cameracenter frame.
Units: millimeters
<summary>
""")
calibrationOffset = property(_HC_API_PythonPackage.BTSFraming_calibrationOffset_get, _HC_API_PythonPackage.BTSFraming_calibrationOffset_set, doc=r"""
<summary>
Calibration offset (can be obtained by calling doCalibrationAndValidation)
<summary>
<param name="calibration"><param>
""")
chartCenterFrame_CameraCenterFrame = property(_HC_API_PythonPackage.BTSFraming_chartCenterFrame_CameraCenterFrame_get, _HC_API_PythonPackage.BTSFraming_chartCenterFrame_CameraCenterFrame_set, doc=r"""
<summary>
Current relative location of the chartCenter to the CameraCenter
<summary>
""")
[docs] def initialize(self, system):
r"""
initialize the frame using the given config.
:param config:
"""
return _HC_API_PythonPackage.BTSFraming_initialize(self, system)
[docs] def Home(self):
r"""
Command targetMountFrame to go to TargetMountHome position
use if axis' have been moved manually or without power to reset the BTSFrame.
"""
return _HC_API_PythonPackage.BTSFraming_Home(self)
[docs] def chartCenterFrame_Go_ChartCenterHomeFrame(self, homeSpace):
r"""
<summary>
Command the chartCenterFrame to go somewhere relative to the chartCenterHomeFrame
<summary>
<param name="homeSpace"><param>
"""
return _HC_API_PythonPackage.BTSFraming_chartCenterFrame_Go_ChartCenterHomeFrame(self, homeSpace)
[docs] def chartCenterFrame_Go_CameraCenterFrame(self, cameraSpace):
r"""
<summary>
Command the chartCenterFrame to move to a location relative to the CameraFrame
<summary>
"""
return _HC_API_PythonPackage.BTSFraming_chartCenterFrame_Go_CameraCenterFrame(self, cameraSpace)
[docs] def doCalibrationAndValidation(self):
r"""
<summary>
Do calibration and validation routine. prompts the user for micrometer reading. reports validation meaurements
returns calibration offset for use later.
<summary>
<returns><returns>
"""
return _HC_API_PythonPackage.BTSFraming_doCalibrationAndValidation(self)
[docs] def homeFrame_To_cameraCenterFrame(self, homeSpace):
r"""
<summary>
Transform vector in the homeFrame to cameraCenterFrame.
<summary>
<param name="homeSpace"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.BTSFraming_homeFrame_To_cameraCenterFrame(self, homeSpace)
[docs] def cameraCenterFrame_To_homeFrame(self, cameraSpace):
r"""
<summary>
Transform vector from cameraCenterFrame to homeFrame
<summary>
<param name="cameraSpace"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.BTSFraming_cameraCenterFrame_To_homeFrame(self, cameraSpace)
stageVelocity = property(_HC_API_PythonPackage.BTSFraming_stageVelocity_get, _HC_API_PythonPackage.BTSFraming_stageVelocity_set, doc=r"""
<summary>
Velocity to command the stages to use.
<summary>
""")
stageAcceleration = property(_HC_API_PythonPackage.BTSFraming_stageAcceleration_get, _HC_API_PythonPackage.BTSFraming_stageAcceleration_set, doc=r"""
<summary>
Acceleration to command the stages to use.
<summary>
""")
[docs] def zaberCont(self):
return _HC_API_PythonPackage.BTSFraming_zaberCont(self)
[docs] def zaberDevice1(self):
return _HC_API_PythonPackage.BTSFraming_zaberDevice1(self)
[docs] def zaberDevice2(self):
return _HC_API_PythonPackage.BTSFraming_zaberDevice2(self)
[docs] def zaberDevice1Axis(self):
return _HC_API_PythonPackage.BTSFraming_zaberDevice1Axis(self)
[docs] def zaberDevice2Axis(self):
return _HC_API_PythonPackage.BTSFraming_zaberDevice2Axis(self)
def __init__(self):
_HC_API_PythonPackage.BTSFraming_swiginit(self, _HC_API_PythonPackage.new_BTSFraming())
__swig_destroy__ = _HC_API_PythonPackage.delete_BTSFraming
_HC_API_PythonPackage.BTSFraming_swigregister(BTSFraming)
[docs]class VCXFraming(CompositeFrameBase):
r"""
<summary>
DEPRECIATED.
VCX Framing class, contains methods for control of VCX frames.
all dimension Units are in millimeters
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.VCXFraming_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.VCXFraming_className(self)
chartCenter__MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_chartCenter__MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_chartCenter__MechanicalOriginFrame_set, doc=r"""
<summary>
chart center position Relative to mechanical base point.
"Vector B"
Units: millimeters
<summary>
""")
home__MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_home__MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_home__MechanicalOriginFrame_set, doc=r"""
<summary>
Home position of table relative to mechanical base point.
"Vector A"
Units: millimeters
<summary>
""")
camera_MountBaseFrame = property(_HC_API_PythonPackage.VCXFraming_camera_MountBaseFrame_get, _HC_API_PythonPackage.VCXFraming_camera_MountBaseFrame_set, doc=r"""
<summary>
Camera position relative to the MountBaseFrame.
<summary>
""")
mountBase_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_mountBase_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_mountBase_MechanicalOriginFrame_set, doc=r""" current target mount position in the mechanical origin frame.""")
mountBase_Omega_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_mountBase_Omega_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_mountBase_Omega_MechanicalOriginFrame_set, doc=r""" current rotation of MountBase in the mechanicalOrigin frame.""")
camera_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_camera_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_camera_MechanicalOriginFrame_set, doc=r"""
<summary>
Current Camera position in mechanicalorigin Frame.
<summary>
""")
camera_ChartCenterFrame = property(_HC_API_PythonPackage.VCXFraming_camera_ChartCenterFrame_get, _HC_API_PythonPackage.VCXFraming_camera_ChartCenterFrame_set, doc=r"""
<summary>
Current Camera Position in ChartCenter Frame.
<summary>
""")
zaberPort = property(_HC_API_PythonPackage.VCXFraming_zaberPort_get, _HC_API_PythonPackage.VCXFraming_zaberPort_set, doc=r"""
<summary>
Serial Port for zaber (ex "COM4")
<summary>
""")
liftingColumnPort = property(_HC_API_PythonPackage.VCXFraming_liftingColumnPort_get, _HC_API_PythonPackage.VCXFraming_liftingColumnPort_set, doc=r"""
<summary>
Serial Port for Lifting Column. (ex "COM5")
<summary>
""")
[docs] def initialize(self, system):
return _HC_API_PythonPackage.VCXFraming_initialize(self, system)
[docs] def mountBase_GoTo_Home(self):
return _HC_API_PythonPackage.VCXFraming_mountBase_GoTo_Home(self)
[docs] def mountBase_Go_MechanicalOriginFrame(self, mechSpace, omega):
return _HC_API_PythonPackage.VCXFraming_mountBase_Go_MechanicalOriginFrame(self, mechSpace, omega)
[docs] def mountBase_Go_ChartCenterFrame(self, chartSpace, omega):
return _HC_API_PythonPackage.VCXFraming_mountBase_Go_ChartCenterFrame(self, chartSpace, omega)
[docs] def mountBase_Go_HomeFrame(self, displacement, omega):
return _HC_API_PythonPackage.VCXFraming_mountBase_Go_HomeFrame(self, displacement, omega)
[docs] def chartCenterFrame_To_MechanicalOriginFrame(self, chartCenterSpace):
r"""
transform vector in the chartcenter frame to the mechanical origin frame.
:type chartCenterSpace: :py:class:`Vector3D`
:param chartCenterSpace:
:rtype: :py:class:`Vector3D`
:return:
"""
return _HC_API_PythonPackage.VCXFraming_chartCenterFrame_To_MechanicalOriginFrame(self, chartCenterSpace)
[docs] def targetMountHomeFrame_To_MechanicaOriginFrame(self, homeSpace):
r"""
transform vector in the home frame to the mechanicalorigin frame. (offset)
:type homeSpace: :py:class:`Vector3D`
:param homeSpace:
:rtype: :py:class:`Vector3D`
:return:
"""
return _HC_API_PythonPackage.VCXFraming_targetMountHomeFrame_To_MechanicaOriginFrame(self, homeSpace)
[docs] def mechanicalOriginFrame_To_HomeFrame(self, mechanicalSpace):
r"""
transform vector in the mechanicalorigin frame to the home frame.
:type mechanicalSpace: :py:class:`Vector3D`
:param mechanicalSpace:
:rtype: :py:class:`Vector3D`
:return:
"""
return _HC_API_PythonPackage.VCXFraming_mechanicalOriginFrame_To_HomeFrame(self, mechanicalSpace)
[docs] def mountBaseFrame_To_MechanicalOriginFrame(self, mountbaseSpace):
r"""
<summary>
transform vector in mountbase space to mechanical origin frame space.
<summary>
<param name="mountbaseSpace"><param>
<returns><returns>
"""
return _HC_API_PythonPackage.VCXFraming_mountBaseFrame_To_MechanicalOriginFrame(self, mountbaseSpace)
def __init__(self):
_HC_API_PythonPackage.VCXFraming_swiginit(self, _HC_API_PythonPackage.new_VCXFraming())
__swig_destroy__ = _HC_API_PythonPackage.delete_VCXFraming
_HC_API_PythonPackage.VCXFraming_swigregister(VCXFraming)
[docs]class MOTYZ_Framing(CompositeFrameBase):
r"""
<summary>
The MOTYZ_Framing object can be calibrated to the coordinates of a target chart by calling frame.calibrate() and following the prompts to enter in distance values from the chart center using the range finder. MOTYZ_Frame.
state can be saved by saving/restoring the chartDisplacement_Ref, chartDisplacement, and liftingCol_refPos variables at any time if the frame is in the same position after calibration.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.MOTYZ_Framing_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.MOTYZ_Framing_className(self)
zaberPort = property(_HC_API_PythonPackage.MOTYZ_Framing_zaberPort_get, _HC_API_PythonPackage.MOTYZ_Framing_zaberPort_set, doc=r"""
<summary>
Serial Port for zaber (ex "COM4")
<summary>
""")
liftingColumnPort = property(_HC_API_PythonPackage.MOTYZ_Framing_liftingColumnPort_get, _HC_API_PythonPackage.MOTYZ_Framing_liftingColumnPort_set, doc=r"""
<summary>
Serial Port for Lifting Column. (ex "COM5")
<summary>
""")
[docs] def initialize(self, system):
r"""
<summary>
Initialize the frame (always required first)
<summary>
<param name="system"><param>
"""
return _HC_API_PythonPackage.MOTYZ_Framing_initialize(self, system)
[docs] def calibrate(self):
r"""
<summary>
prompt for distance measurement to calibrate the frame.
<summary>
"""
return _HC_API_PythonPackage.MOTYZ_Framing_calibrate(self)
chartDisplacement_Ref = property(_HC_API_PythonPackage.MOTYZ_Framing_chartDisplacement_Ref_get, _HC_API_PythonPackage.MOTYZ_Framing_chartDisplacement_Ref_set, doc=r""" homed chart displacement (set by calibration routine)""")
liftingCol_refPos = property(_HC_API_PythonPackage.MOTYZ_Framing_liftingCol_refPos_get, _HC_API_PythonPackage.MOTYZ_Framing_liftingCol_refPos_set, doc=r"""
<summary>
lifting col referance position (set by calibration routine)
<summary>
""")
currentChartDisplacement = property(_HC_API_PythonPackage.MOTYZ_Framing_currentChartDisplacement_get, _HC_API_PythonPackage.MOTYZ_Framing_currentChartDisplacement_set, doc=r"""
<summary>
current chart displacement - read only after calling go_Chart_YZ
<summary>
""")
stageVelocity = property(_HC_API_PythonPackage.MOTYZ_Framing_stageVelocity_get, _HC_API_PythonPackage.MOTYZ_Framing_stageVelocity_set, doc=r"""
<summary>
stage velocity to use when moving
<summary>
""")
stageAcceleration = property(_HC_API_PythonPackage.MOTYZ_Framing_stageAcceleration_get, _HC_API_PythonPackage.MOTYZ_Framing_stageAcceleration_set, doc=r"""
<summary>
stage acceleration to use when moving
<summary>
""")
[docs] def home(self):
r"""Home all Axis."""
return _HC_API_PythonPackage.MOTYZ_Framing_home(self)
[docs] def go_Chart_YZ(self, chartDisplacement):
r"""
<summary>
Go to liftingCol_refPos position chartDistance millimeters away from the chart.
<summary>
"""
return _HC_API_PythonPackage.MOTYZ_Framing_go_Chart_YZ(self, chartDisplacement)
def __init__(self):
_HC_API_PythonPackage.MOTYZ_Framing_swiginit(self, _HC_API_PythonPackage.new_MOTYZ_Framing())
__swig_destroy__ = _HC_API_PythonPackage.delete_MOTYZ_Framing
_HC_API_PythonPackage.MOTYZ_Framing_swigregister(MOTYZ_Framing)
[docs]class ThorLabsUPLED_SetLighting(DeviceCommandPackage):
r"""
<summary>
Command to set the lighting of a ThorLabs UPLED device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_SetLighting
intensityPercent = property(_HC_API_PythonPackage.ThorLabsUPLED_SetLighting_intensityPercent_get, _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_intensityPercent_set)
def __init__(self):
_HC_API_PythonPackage.ThorLabsUPLED_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_SetLighting())
_HC_API_PythonPackage.ThorLabsUPLED_SetLighting_swigregister(ThorLabsUPLED_SetLighting)
[docs]class ThorLabsUPLED_DeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the ThorLabs UPLED device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_DeviceInfo
def __init__(self):
_HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_DeviceInfo())
_HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_swigregister(ThorLabsUPLED_DeviceInfo)
[docs]class ThorLabsUPLED_Controller(HardwareDeviceController):
r"""
<summary>
controller for ThorLabs UPLED devices
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThorLabsUPLED_Controller_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThorLabsUPLED_Controller_className(self)
def __init__(self):
_HC_API_PythonPackage.ThorLabsUPLED_Controller_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_Controller())
__swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_Controller
[docs] def sendIntensityCommand(self, apiDeviceId, intensityPercent):
return _HC_API_PythonPackage.ThorLabsUPLED_Controller_sendIntensityCommand(self, apiDeviceId, intensityPercent)
_HC_API_PythonPackage.ThorLabsUPLED_Controller_swigregister(ThorLabsUPLED_Controller)
[docs]class ThousliteCommand_SetLighting(DeviceCommandPackage):
r"""
<summary>
Command to set the lighting of a Thouslite device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.ThousliteCommand_SetLighting_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThousliteCommand_SetLighting_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThousliteCommand_SetLighting_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteCommand_SetLighting
[docs] def cloneFrom(self, other):
return _HC_API_PythonPackage.ThousliteCommand_SetLighting_cloneFrom(self, other)
recipe = property(_HC_API_PythonPackage.ThousliteCommand_SetLighting_recipe_get, _HC_API_PythonPackage.ThousliteCommand_SetLighting_recipe_set, doc=r"""
light intensity for the 14 channels.
0 - 1023
all 0 will turn off LEDCube power.
% Channels:
1 -> White (Broad spectrum)
2 -> Orange (585nm)
3 -> Lt Orange (Broad spectrum)
4 -> Blue-Green (480nm)
5 -> Red (660nm)
6 -> Green-Blue (505nm)
7 -> Green (520nm)
8 -> Blue (445nm)
9 -> Lt Violet (420nm)
10 -> Red (635nm)
11 -> Yellow-Grn (545nm)
12 -> Dk Violet (405nm)
13 -> Red (670nm)
14 -> Red/IR (700/850nm)
""")
def __init__(self):
_HC_API_PythonPackage.ThousliteCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ThousliteCommand_SetLighting())
_HC_API_PythonPackage.ThousliteCommand_SetLighting_swigregister(ThousliteCommand_SetLighting)
Thouslite_NALPCODE = cvar.Thouslite_NALPCODE
ThousliteRecipeDescriptions = cvar.ThousliteRecipeDescriptions
[docs]class ThousliteDeviceInfo(DeviceInfo):
r"""
<summary>
Device Info for the Thouslite device.
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThousliteDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThousliteDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.ThousliteDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteDeviceInfo
cubeId = property(_HC_API_PythonPackage.ThousliteDeviceInfo_cubeId_get, _HC_API_PythonPackage.ThousliteDeviceInfo_cubeId_set, doc=r"""The unique ID of the LEDCube as shown on the side.""")
def __init__(self):
_HC_API_PythonPackage.ThousliteDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ThousliteDeviceInfo())
_HC_API_PythonPackage.ThousliteDeviceInfo_swigregister(ThousliteDeviceInfo)
[docs]class ThousliteController(HardwareDeviceController):
r"""
<summary>
controller for Thouslite devices
<summary>
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.ThousliteController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.ThousliteController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteController
baudrate = property(_HC_API_PythonPackage.ThousliteController_baudrate_get, _HC_API_PythonPackage.ThousliteController_baudrate_set, doc=r"""
<summary>
The baudrate to connect to the controller (9600 for older models, 115200 for newer touch screen controller)
only used with apiMajorVersion = 2
<summary>
""")
apiMajorVersion = property(_HC_API_PythonPackage.ThousliteController_apiMajorVersion_get, _HC_API_PythonPackage.ThousliteController_apiMajorVersion_set, doc=r"""
<summary>
The Api version (1 or 2) to use when communicating with the thouslite, default is 1 (older models)
<summary>
""")
def __init__(self):
_HC_API_PythonPackage.ThousliteController_swiginit(self, _HC_API_PythonPackage.new_ThousliteController())
_HC_API_PythonPackage.ThousliteController_swigregister(ThousliteController)
[docs]class DummyDeviceInfo(DeviceInfo):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DummyDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DummyDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.DummyDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_DummyDeviceInfo
updateDelayTime_S = property(_HC_API_PythonPackage.DummyDeviceInfo_updateDelayTime_S_get, _HC_API_PythonPackage.DummyDeviceInfo_updateDelayTime_S_set)
def __init__(self):
_HC_API_PythonPackage.DummyDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DummyDeviceInfo())
_HC_API_PythonPackage.DummyDeviceInfo_swigregister(DummyDeviceInfo)
[docs]class DummyController(DeviceController):
r""" <summary> Fully Virtual Controller Example used for controlling DummyDevices"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.DummyController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.DummyController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_DummyController
[docs] def BeginMotion(self, apiDeviceId):
return _HC_API_PythonPackage.DummyController_BeginMotion(self, apiDeviceId)
def __init__(self):
_HC_API_PythonPackage.DummyController_swiginit(self, _HC_API_PythonPackage.new_DummyController())
_HC_API_PythonPackage.DummyController_swigregister(DummyController)
[docs]class CommunicationCommandPackage(DeviceCommandPackage):
r""" Generic Command to communicate with a device."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] def createSharedPtr(self):
return _HC_API_PythonPackage.CommunicationCommandPackage_createSharedPtr(self)
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.CommunicationCommandPackage_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.CommunicationCommandPackage_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_CommunicationCommandPackage
outgoingBuffer = property(_HC_API_PythonPackage.CommunicationCommandPackage_outgoingBuffer_get, _HC_API_PythonPackage.CommunicationCommandPackage_outgoingBuffer_set)
def __init__(self):
_HC_API_PythonPackage.CommunicationCommandPackage_swiginit(self, _HC_API_PythonPackage.new_CommunicationCommandPackage())
_HC_API_PythonPackage.CommunicationCommandPackage_swigregister(CommunicationCommandPackage)
[docs]class LoopBackComDeviceInfo(DeviceInfo):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LoopBackComDeviceInfo_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LoopBackComDeviceInfo_className(self)
[docs] def addCommand(self, package):
return _HC_API_PythonPackage.LoopBackComDeviceInfo_addCommand(self, package)
__swig_destroy__ = _HC_API_PythonPackage.delete_LoopBackComDeviceInfo
def __init__(self):
_HC_API_PythonPackage.LoopBackComDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LoopBackComDeviceInfo())
_HC_API_PythonPackage.LoopBackComDeviceInfo_swigregister(LoopBackComDeviceInfo)
[docs]class LoopBackComController(DeviceController):
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
[docs] @staticmethod
def staticClassName():
return _HC_API_PythonPackage.LoopBackComController_staticClassName()
[docs] def className(self):
return _HC_API_PythonPackage.LoopBackComController_className(self)
__swig_destroy__ = _HC_API_PythonPackage.delete_LoopBackComController
port = property(_HC_API_PythonPackage.LoopBackComController_port_get, _HC_API_PythonPackage.LoopBackComController_port_set)
def __init__(self):
_HC_API_PythonPackage.LoopBackComController_swiginit(self, _HC_API_PythonPackage.new_LoopBackComController())
_HC_API_PythonPackage.LoopBackComController_swigregister(LoopBackComController)
[docs]def basicFunc(a, b):
return _HC_API_PythonPackage.basicFunc(a, b)
[docs]class controlGuiInterface(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):
_HC_API_PythonPackage.controlGuiInterface_swiginit(self, _HC_API_PythonPackage.new_controlGuiInterface())
__swig_destroy__ = _HC_API_PythonPackage.delete_controlGuiInterface
[docs] def open(self, argc, argv):
r""" open the control GUI in a seperate thread."""
return _HC_API_PythonPackage.controlGuiInterface_open(self, argc, argv)
[docs] def update(self):
return _HC_API_PythonPackage.controlGuiInterface_update(self)
noUserLoadMode = property(_HC_API_PythonPackage.controlGuiInterface_noUserLoadMode_get, _HC_API_PythonPackage.controlGuiInterface_noUserLoadMode_set, doc=r""" wait until the GUI is closed.""")
_HC_API_PythonPackage.controlGuiInterface_swigregister(controlGuiInterface)