aoclw_wrapper.py

 
 
 
# This Python file uses the following encoding: utf-8
 
from ctypes import CDLL, create_string_buffer, c_uint, c_int, \
                   byref, py_object, CFUNCTYPE, c_void_p, \
                   POINTER, c_ushort, c_char_p
import platform, os
 
# derived exception class to be caught and handled in calling application
class AxErr(Exception):
    pass
 
 
# types of devices
device_t = {0: "unknown",
            40: "laser  ",
            41: "CLDAQ  ",
            42: "EDAQ   "
            }
 
# types of connection interfaces
connection_t = {0: "none",
                1: "USB",
                2: "RS232_PASSTHRU",
                3: "RS232",
                4: "ETHERNET"
                }
 
 
class AOCLW_wrapper_class:
 
    def __init__(self, interfaces = 0):
        # load the AxsunOCTControl_LW shared library into 'AOCLW' (adjust path to dll as needed)
        if platform.system() == "Windows":
            self.AOCLW = CDLL("../x64/Release/AxsunOCTControl_LW.dll")
        if platform.system() == "Darwin" or platform.system() == "Linux":
            lib_path = os.path.join(os.getcwd(), "build/lib/libaxsunoctcontrol_lw.dylib")
            self.AOCLW = CDLL(lib_path)
        retval = self.AOCLW.axOpenAxsunOCTControl(c_uint(interfaces))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def __del__(self):
        self.AOCLW.axCloseAxsunOCTControl()
 
    # get an error string from AxsunOCTControl_LW API
    def GetAPIErrorString(self, errorno):
        the_string = create_string_buffer(512)
        self.AOCLW.axGetErrorExplained(errorno, the_string)
        return ("*** AxErr " + str(errorno) + ":  "
                + the_string.value.decode() + " ***")
 
    # get the AxsunOCTControl_LW library version (numeric tuple version)
    def LibraryVersion(self):
        # to be used as pointer args to AxsunOCTControl_LW calls:
        major = c_uint(0)
        minor = c_uint(0)
        build = c_uint(0)
        patch = c_uint(0)
        self.AOCLW.axLibraryVersion(byref(major), byref(minor),
                                             byref(build), byref(patch))
        return (major.value, minor.value, build.value, patch.value)
 
    # get the AxsunOCTControl_LW library version (string version)
    def LWLibVersion(self):
        ReadStr = self.AOCLW.axLWLibVersion
        ReadStr.restype = c_char_p
        return str(ReadStr(), 'UTF-8')
 
    # get the AxsunOCTControl_LW library build date and time (string version)
    def axLWBuildDateTime(self):
        ReadStr = self.AOCLW.axLWBuildDateTime
        ReadStr.restype = c_char_p
        return ReadStr().decode()
 
    # get device type
    def GetDeviceType(self, which_dev):
        this_device = c_int(0)
        retval = self.AOCLW.axDeviceType(byref(this_device), c_uint(which_dev))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
        return device_t[this_device.value]
 
    # get device serial number
    def GetSerialNum(self, which_dev):
        serialnum = create_string_buffer(40)
        retval = self.AOCLW.axSerialNumber(serialnum, c_uint(which_dev))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
        return serialnum.value.decode()
 
    # get device firmware version
    def GetFirmwareVersion(self, which_dev):
        # to be used as pointer args to AxsunOCTControl_LW calls:
        major = c_uint(0)
        minor = c_uint(0)
        patch = c_uint(0)
 
        # get the library version
        retval = self.AOCLW.axFirmwareVersion(byref(major), byref(minor),
                                              byref(patch), c_uint(which_dev))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
        return (str(major.value) + "."
                + str(minor.value) + "."
                + str(patch.value))
 
    # get device connection type
    def GetConnectionType(self, which_dev):
        this_device = c_int(0)
        retval = self.AOCLW.axConnectionType(byref(this_device), c_uint(which_dev))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
        return connection_t[this_device.value]
 
    # count connected Axsun devices
    def CountDevices(self):
        return self.AOCLW.axCountConnectedDevices()
 
    def RegisterCallback(self, func, obj):
        # define the callback function C type
        CALLBACK_TYPE = CFUNCTYPE(None, c_void_p)
 
        # create C-callable instance of the python callback function
        obj.callback_fn = CALLBACK_TYPE(func)
 
        # 'load' axRegisterConnectCallback function
        RegisterConnectCallback = self.AOCLW.axRegisterConnectCallback
 
        # define its argument types and result type
        RegisterConnectCallback.argtypes = [CALLBACK_TYPE, c_void_p]
        RegisterConnectCallback.restype = c_int
 
        # obj is the userdata argument, 'cast' to a c_void_p type
        retval = RegisterConnectCallback(obj.callback_fn, c_void_p.from_buffer(py_object(obj)))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def OpenUSBInterface(self, open):
        retval = self.AOCLW.axUSBInterfaceOpen(c_uint(open))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def OpenNetworkInterface(self, open):
        retval = self.AOCLW.axNetworkInterfaceOpen(c_uint(open))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def LaserEmission(self, state, which_laser = 0):
        retval = self.AOCLW.axSetLaserEmission(c_uint(state), c_uint(which_laser))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def GetFPGARegisterRange(self, start_reg, end_reg, which_daq = 0):
        allocatedwords = end_reg - start_reg + 1
        regvals_t = c_ushort * allocatedwords
        regvals = regvals_t()
        ReadRegs = self.AOCLW.axGetFPGARegisterRange
        ReadRegs.argtypes = [c_uint, c_uint, POINTER(c_ushort), c_uint, c_uint]
        ReadRegs.restype = c_int
        retval = ReadRegs(start_reg,
                          end_reg,
                          regvals,
                          allocatedwords * 2,
                          which_daq)
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
        # create dictionary
        this_reg = start_reg
        regnums_vals = {}
        for x in regvals:
            regnums_vals[this_reg] = x
            this_reg += 1
 
        # return register num/value pairs
        return regnums_vals
 
    def SetFPGARegister(self, reg, value, which_daq = 0):
        retval = self.AOCLW.axSetFPGARegister(c_uint(reg), c_ushort(value), c_uint(which_daq))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
 
    def GetFPGARegister(self, reg, which_daq = 0):
        regvalue = c_ushort(0)
        retval = self.AOCLW.axGetFPGARegister(reg, byref(regvalue), c_uint(which_daq))
        if retval:
            raise AxErr(self.GetAPIErrorString(retval))
        return regvalue.value