# pylint: disable=spelling from . import atmcd32d_defs from .atmcd32d_defs import DRV_STATUS, drDRV_STATUS from .atmcd32d_defs import define_functions from .atmcd32d_defs import AT_STEPMODE, AT_GATEMODE # pylint: disable=unused-import from .atmcd32d_defs import AC_ACQMODE, AC_READMODE, AC_TRIGGERMODE, AC_EMGAIN, AC_FEATURES # pylint: disable=unused-import from .atmcd32d_defs import AC_CAMERATYPE, drAC_CAMERATYPE, AC_PIXELMODE # pylint: disable=unused-import from .atmcd32d_defs import AC_SETFUNC, AC_GETFUNC # pylint: disable=unused-import from .base import AndorError from ...core.utils import ctypes_wrap, py3 from ..utils import load_lib import numpy as np import platform import ctypes import collections class AndorSDK2LibError(AndorError): """Generic Andor SDK2 library error""" def __init__(self, func, code): self.func=func self.code=code self.name=drDRV_STATUS.get(self.code,"UNKNOWN") msg="function '{}' raised error {}({})".format(func,code,self.name) AndorError.__init__(self,msg) def errcheck(passing=None): """ Build an error checking function. Return a function which checks return codes of Andor SDK3 library functions. `passing` is a list specifying which return codes are acceptable (by default only 0, which is success code, is acceptable). """ passing=set(passing) if passing is not None else set() passing.add(DRV_STATUS.DRV_SUCCESS) # always allow success def errchecker(result, func, arguments): # pylint: disable=unused-argument if result not in passing: raise AndorSDK2LibError(func.__name__,result) return result return errchecker class CAndorCapabilities(atmcd32d_defs.CAndorCapabilities): def prep(self, struct): struct.ulSize=ctypes.sizeof(struct) return struct TAmpModeSimple=collections.namedtuple("TAmpModeSimple",["channel","oamp","hsspeed","preamp"]) TAmpModeFull=collections.namedtuple("TAmpModeFull",["channel","channel_bitdepth","oamp","oamp_kind","hsspeed","hsspeed_MHz","preamp","preamp_gain"]) class AndorSDK2Lib: def __init__(self): self._initialized=False def initlib(self): if self._initialized: return solis_path=load_lib.get_program_files_folder("Andor SOLIS") sdk2_path=load_lib.get_program_files_folder("Andor SDK") archbit=platform.architecture()[0][:2] error_message="The library is automatically supplied with Andor Solis software or Andor SDK2 software\n"+load_lib.par_error_message.format("andor_sdk2") lib_names=["atmcd{}d_legacy.dll".format(archbit),"atmcd{}d.dll".format(archbit)] self.lib=load_lib.load_lib(lib_names,locations=("parameter/andor_sdk2",solis_path,sdk2_path,"global"),error_message=error_message,call_conv="stdcall") lib=self.lib define_functions(lib) wrapper=ctypes_wrap.CFunctionWrapper(errcheck=errcheck(),default_rvals="pointer") default_strlen=256 strprep=ctypes_wrap.strprep(default_strlen) # ctypes.c_uint Initialize(ctypes.c_char_p dir) self.Initialize=wrapper(lib.Initialize) # ctypes.c_uint ShutDown() self.ShutDown=wrapper(lib.ShutDown) # ctypes.c_uint GetVersionInfo(ctypes.c_int arr, ctypes.c_char_p szVersionInfo, ctypes.c_ulong ui32BufferLen) self.GetVersionInfo=wrapper(lib.GetVersionInfo, args=["arr"], rvals=["szVersionInfo"], argprep={"szVersionInfo":strprep,"ui32BufferLen":default_strlen}, byref=[]) # ctypes.c_uint GetAvailableCameras(ctypes.POINTER(ctypes.c_long) totalCameras) self.GetAvailableCameras=wrapper(lib.GetAvailableCameras) # ctypes.c_uint GetCameraHandle(ctypes.c_long cameraIndex, ctypes.POINTER(ctypes.c_long) cameraHandle) self.GetCameraHandle=wrapper(lib.GetCameraHandle) # ctypes.c_uint GetCurrentCamera(ctypes.POINTER(ctypes.c_long) cameraHandle) self.GetCurrentCamera=wrapper(lib.GetCurrentCamera) # ctypes.c_uint SetCurrentCamera(ctypes.c_long cameraHandle) self.SetCurrentCamera=wrapper(lib.SetCurrentCamera) # # ctypes.c_uint GetCapabilities(ctypes.POINTER(AndorCapabilities) caps) self.GetCapabilities=wrapper(lib.GetCapabilities, rvals=["caps"], argprep={"caps":CAndorCapabilities.prep_struct}, rconv={"caps":CAndorCapabilities.tup_struct}) # # ctypes.c_uint GetControllerCardModel(ctypes.c_char_p controllerCardModel) self.GetControllerCardModel=wrapper(lib.GetControllerCardModel, rvals=["controllerCardModel"], argprep={"controllerCardModel":strprep}, byref=[]) # # ctypes.c_uint GetHeadModel(ctypes.c_char_p name) self.GetHeadModel=wrapper(lib.GetHeadModel, rvals=["name"], argprep={"name":strprep}, byref=[]) # ctypes.c_uint GetHardwareVersion(ctypes.POINTER(ctypes.c_uint) PCB, ctypes.POINTER(ctypes.c_uint) Decode, ctypes.POINTER(ctypes.c_uint) dummy1, ctypes.POINTER(ctypes.c_uint) dummy2, ctypes.POINTER(ctypes.c_uint) CameraFirmwareVersion, ctypes.POINTER(ctypes.c_uint) CameraFirmwareBuild) self.GetHardwareVersion=wrapper(lib.GetHardwareVersion) # ctypes.c_uint GetSoftwareVersion(ctypes.POINTER(ctypes.c_uint) eprom, ctypes.POINTER(ctypes.c_uint) coffile, ctypes.POINTER(ctypes.c_uint) vxdrev, ctypes.POINTER(ctypes.c_uint) vxdver, ctypes.POINTER(ctypes.c_uint) dllrev, ctypes.POINTER(ctypes.c_uint) dllver) self.GetSoftwareVersion=wrapper(lib.GetSoftwareVersion) # ctypes.c_uint GetCameraSerialNumber(ctypes.POINTER(ctypes.c_int) number) self.GetCameraSerialNumber=wrapper(lib.GetCameraSerialNumber) # only iDus, set index=0 # # ctypes.c_uint GetPixelSize(ctypes.POINTER(ctypes.c_float) xSize, ctypes.POINTER(ctypes.c_float) ySize) self.GetPixelSize=wrapper(lib.GetPixelSize) # ctypes.c_uint GetQE(ctypes.c_char_p sensor, ctypes.c_float wavelength, ctypes.c_uint mode, ctypes.POINTER(ctypes.c_float) QE) self.GetQE=wrapper(lib.GetQE) # ctypes.c_uint InAuxPort(ctypes.c_int port, ctypes.POINTER(ctypes.c_int) state) self.InAuxPort=wrapper(lib.InAuxPort) # ctypes.c_uint OutAuxPort(ctypes.c_int port, ctypes.c_int state) self.OutAuxPort=wrapper(lib.OutAuxPort) # ctypes.c_uint GetNumberIO(ctypes.POINTER(ctypes.c_int) iNumber) self.GetNumberIO=wrapper(lib.GetNumberIO) # ctypes.c_uint GetIODirection(ctypes.c_int index, ctypes.POINTER(ctypes.c_int) iDirection) self.GetIODirection=wrapper(lib.GetIODirection) # ctypes.c_uint GetIOLevel(ctypes.c_int index, ctypes.POINTER(ctypes.c_int) iLevel) self.SetIODirection=wrapper(lib.SetIODirection) # ctypes.c_uint SetIOLevel(ctypes.c_int index, ctypes.c_int iLevel) self.GetIOLevel=wrapper(lib.GetIOLevel) # ctypes.c_uint SetIODirection(ctypes.c_int index, ctypes.c_int iDirection) self.SetIOLevel=wrapper(lib.SetIOLevel) # ctypes.c_uint SetDACOutput(ctypes.c_int iOption, ctypes.c_int iResolution, ctypes.c_int iValue) self.SetDACOutput=wrapper(lib.SetDACOutput) # ctypes.c_uint SetDACOutputScale(ctypes.c_int iScale) self.SetDACOutputScale=wrapper(lib.SetDACOutputScale) # ctypes.c_uint GPIBReceive(ctypes.c_int id, ctypes.c_short address, ctypes.c_char_p text, ctypes.c_int size) self.GPIBReceive=wrapper(lib.GPIBReceive, rvals=["text"], argprep={"text": lambda size: strprep(size)()}, byref=[]) # ctypes.c_uint GPIBSend(ctypes.c_int id, ctypes.c_short address, ctypes.c_char_p text) self.GPIBSend=wrapper(lib.GPIBSend) # ctypes.c_uint SetDelayGenerator(ctypes.c_int board, ctypes.c_short address, ctypes.c_int typ) self.SetDelayGenerator=wrapper(lib.SetDelayGenerator) # # ctypes.c_uint I2CBurstRead(BYTE i2cAddress, ctypes.c_long nBytes, ctypes.POINTER(BYTE) data) # lib.I2CBurstRead.restype=ctypes.c_uint # lib.I2CBurstRead.argtypes=[BYTE, ctypes.c_long, ctypes.POINTER(BYTE)] # lib.I2CBurstRead.argnames=["i2cAddress", "nBytes", "data"] # # ctypes.c_uint I2CBurstWrite(BYTE i2cAddress, ctypes.c_long nBytes, ctypes.POINTER(BYTE) data) # lib.I2CBurstWrite.restype=ctypes.c_uint # lib.I2CBurstWrite.argtypes=[BYTE, ctypes.c_long, ctypes.POINTER(BYTE)] # lib.I2CBurstWrite.argnames=["i2cAddress", "nBytes", "data"] # # ctypes.c_uint I2CRead(BYTE deviceID, BYTE intAddress, ctypes.POINTER(BYTE) pdata) # lib.I2CRead.restype=ctypes.c_uint # lib.I2CRead.argtypes=[BYTE, BYTE, ctypes.POINTER(BYTE)] # lib.I2CRead.argnames=["deviceID", "intAddress", "pdata"] # # ctypes.c_uint I2CReset() # lib.I2CReset.restype=ctypes.c_uint # lib.I2CReset.argtypes=[] # lib.I2CReset.argnames=[] # # ctypes.c_uint I2CWrite(BYTE deviceID, BYTE intAddress, BYTE data) # lib.I2CWrite.restype=ctypes.c_uint # lib.I2CWrite.argtypes=[BYTE, BYTE, BYTE] # lib.I2CWrite.argnames=["deviceID", "intAddress", "data"] # ctypes.c_uint SetTriggerMode(ctypes.c_int mode) self.SetTriggerMode=wrapper(lib.SetTriggerMode) # ctypes.c_uint GetExternalTriggerTermination(ctypes.POINTER(ctypes.c_ulong) puiTermination) self.GetExternalTriggerTermination=wrapper(lib.GetExternalTriggerTermination) # ctypes.c_uint SetExternalTriggerTermination(ctypes.c_ulong uiTermination) self.SetExternalTriggerTermination=wrapper(lib.SetExternalTriggerTermination) # ctypes.c_uint GetTriggerLevelRange(ctypes.POINTER(ctypes.c_float) minimum, ctypes.POINTER(ctypes.c_float) maximum) self.GetTriggerLevelRange=wrapper(lib.GetTriggerLevelRange) # ctypes.c_uint SetTriggerLevel(ctypes.c_float f_level) self.SetTriggerLevel=wrapper(lib.SetTriggerLevel) # ctypes.c_uint SetTriggerInvert(ctypes.c_int mode) self.SetTriggerInvert=wrapper(lib.SetTriggerInvert) # ctypes.c_uint IsTriggerModeAvailable(ctypes.c_int iTriggerMode) self.IsTriggerModeAvailable=wrapper(lib.IsTriggerModeAvailable) # ctypes.c_uint SendSoftwareTrigger() self.SendSoftwareTrigger=wrapper(lib.SendSoftwareTrigger) # ctypes.c_uint SetAdvancedTriggerModeState(ctypes.c_int iState) self.SetAdvancedTriggerModeState=wrapper(lib.SetAdvancedTriggerModeState) # ctypes.c_uint SetFastExtTrigger(ctypes.c_int mode) self.SetFastExtTrigger=wrapper(lib.SetFastExtTrigger) # ctypes.c_uint SetChargeShifting(ctypes.c_uint NumberRows, ctypes.c_uint NumberRepeats) self.SetChargeShifting=wrapper(lib.SetChargeShifting) errcheck_temp=errcheck(passing={20034,20035,20036,20037,20040}) # ctypes.c_uint GetTemperature(ctypes.POINTER(ctypes.c_int) temperature) self.GetTemperature=wrapper(lib.GetTemperature, rvals=[None,"temperature"], errcheck=errcheck_temp) # ctypes.c_uint GetTemperatureF(ctypes.POINTER(ctypes.c_float) temperature) self.GetTemperatureF=wrapper(lib.GetTemperatureF, rvals=[None,"temperature"], errcheck=errcheck_temp) # ctypes.c_uint SetTemperature(ctypes.c_int temperature) self.SetTemperature=wrapper(lib.SetTemperature) # ctypes.c_uint GetTemperatureRange(ctypes.POINTER(ctypes.c_int) mintemp, ctypes.POINTER(ctypes.c_int) maxtemp) self.GetTemperatureRange=wrapper(lib.GetTemperatureRange) # ctypes.c_uint CoolerON() self.CoolerON=wrapper(lib.CoolerON) # ctypes.c_uint CoolerOFF() self.CoolerOFF=wrapper(lib.CoolerOFF) # ctypes.c_uint IsCoolerOn(ctypes.POINTER(ctypes.c_int) iCoolerStatus) self.IsCoolerOn=wrapper(lib.IsCoolerOn) # ctypes.c_uint SetCoolerMode(ctypes.c_int mode) self.SetCoolerMode=wrapper(lib.SetCoolerMode) # ctypes.c_uint SetFanMode(ctypes.c_int mode) self.SetFanMode=wrapper(lib.SetFanMode) # ctypes.c_uint GetTECStatus(ctypes.POINTER(ctypes.c_int) piFlag) self.GetTECStatus=wrapper(lib.GetTECStatus) # ctypes.c_uint GetNumberADChannels(ctypes.POINTER(ctypes.c_int) channels) self.GetNumberADChannels=wrapper(lib.GetNumberADChannels) # ctypes.c_uint SetADChannel(ctypes.c_int channel) self.SetADChannel=wrapper(lib.SetADChannel) # ctypes.c_uint GetBitDepth(ctypes.c_int channel, ctypes.POINTER(ctypes.c_int) depth) self.GetBitDepth=wrapper(lib.GetBitDepth) # ctypes.c_uint GetNumberAmp(ctypes.POINTER(ctypes.c_int) amp) self.GetNumberAmp=wrapper(lib.GetNumberAmp) # ctypes.c_uint SetOutputAmplifier(ctypes.c_int typ) self.SetOutputAmplifier=wrapper(lib.SetOutputAmplifier) # ctypes.c_uint IsAmplifierAvailable(ctypes.c_int iamp) self.IsAmplifierAvailable=wrapper(lib.IsAmplifierAvailable) # ctypes.c_uint GetNumberPreAmpGains(ctypes.POINTER(ctypes.c_int) noGains) self.GetNumberPreAmpGains=wrapper(lib.GetNumberPreAmpGains) # ctypes.c_uint GetPreAmpGain(ctypes.c_int index, ctypes.POINTER(ctypes.c_float) gain) self.GetPreAmpGain=wrapper(lib.GetPreAmpGain) # ctypes.c_uint SetPreAmpGain(ctypes.c_int index) self.SetPreAmpGain=wrapper(lib.SetPreAmpGain) # ctypes.c_uint IsPreAmpGainAvailable(ctypes.c_int channel, ctypes.c_int amplifier, ctypes.c_int index, ctypes.c_int pa, ctypes.POINTER(ctypes.c_int) status) self.IsPreAmpGainAvailable=wrapper(lib.IsPreAmpGainAvailable) # ctypes.c_uint GetPreAmpGainText(ctypes.c_int index, ctypes.c_char_p name, ctypes.c_int length) self.GetPreAmpGainText=wrapper(lib.GetPreAmpGainText, args=["index"], rvals=["name"], argprep={"name":strprep,"length":default_strlen}, byref=[]) # ctypes.c_uint GetAmpDesc(ctypes.c_int index, ctypes.c_char_p name, ctypes.c_int length) self.GetAmpDesc=wrapper(lib.GetAmpDesc, args=["index"], rvals=["name"], argprep={"name":strprep,"length":default_strlen}, byref=[]) # ctypes.c_uint GetAmpMaxSpeed(ctypes.c_int index, ctypes.POINTER(ctypes.c_float) speed) self.GetAmpMaxSpeed=wrapper(lib.GetAmpMaxSpeed) # ctypes.c_uint GetSensitivity(ctypes.c_int channel, ctypes.c_int horzShift, ctypes.c_int amplifier, ctypes.c_int pa, ctypes.POINTER(ctypes.c_float) sensitivity) self.GetSensitivity=wrapper(lib.GetSensitivity) # ctypes.c_uint GetNumberHSSpeeds(ctypes.c_int channel, ctypes.c_int typ, ctypes.POINTER(ctypes.c_int) speeds) self.GetNumberHSSpeeds=wrapper(lib.GetNumberHSSpeeds) # ctypes.c_uint GetHSSpeed(ctypes.c_int channel, ctypes.c_int typ, ctypes.c_int index, ctypes.POINTER(ctypes.c_float) speed) self.GetHSSpeed=wrapper(lib.GetHSSpeed) # ctypes.c_uint SetHSSpeed(ctypes.c_int typ, ctypes.c_int index) self.SetHSSpeed=wrapper(lib.SetHSSpeed) # ctypes.c_uint GetNumberVSSpeeds(ctypes.POINTER(ctypes.c_int) speeds) self.GetNumberVSSpeeds=wrapper(lib.GetNumberVSSpeeds) # ctypes.c_uint GetVSSpeed(ctypes.c_int index, ctypes.POINTER(ctypes.c_float) speed) self.GetVSSpeed=wrapper(lib.GetVSSpeed) # ctypes.c_uint SetVSSpeed(ctypes.c_int index) self.SetVSSpeed=wrapper(lib.SetVSSpeed) # ctypes.c_uint GetFastestRecommendedVSSpeed(ctypes.POINTER(ctypes.c_int) index, ctypes.POINTER(ctypes.c_float) speed) self.GetFastestRecommendedVSSpeed=wrapper(lib.GetFastestRecommendedVSSpeed) # ctypes.c_uint GetNumberVSAmplitudes(ctypes.POINTER(ctypes.c_int) number) self.GetNumberVSAmplitudes=wrapper(lib.GetNumberVSAmplitudes) # ctypes.c_uint GetVSAmplitudeValue(ctypes.c_int index, ctypes.POINTER(ctypes.c_int) value) self.GetVSAmplitudeValue=wrapper(lib.GetVSAmplitudeValue) # ctypes.c_uint SetVSAmplitude(ctypes.c_int index) self.SetVSAmplitude=wrapper(lib.SetVSAmplitude) # ctypes.c_uint GetVSAmplitudeString(ctypes.c_int index, ctypes.c_char_p text) self.GetVSAmplitudeString=wrapper(lib.GetVSAmplitudeString, rvals=["text"], argprep={"text":strprep}, byref=[]) # ctypes.c_uint GetVSAmplitudeFromString(ctypes.c_char_p text, ctypes.POINTER(ctypes.c_int) index) self.GetVSAmplitudeFromString=wrapper(lib.GetVSAmplitudeFromString) # ctypes.c_uint SetHighCapacity(ctypes.c_int state) self.SetHighCapacity=wrapper(lib.SetHighCapacity) # ctypes.c_uint SetEMGainMode(ctypes.c_int mode) self.SetEMGainMode=wrapper(lib.SetEMGainMode) # ctypes.c_uint GetEMGainRange(ctypes.POINTER(ctypes.c_int) low, ctypes.POINTER(ctypes.c_int) high) self.GetEMGainRange=wrapper(lib.GetEMGainRange) # ctypes.c_uint GetEMCCDGain(ctypes.POINTER(ctypes.c_int) gain) self.GetEMCCDGain=wrapper(lib.GetEMCCDGain) # ctypes.c_uint SetEMCCDGain(ctypes.c_int gain) self.SetEMCCDGain=wrapper(lib.SetEMCCDGain) # ctypes.c_uint GetEMAdvanced(ctypes.POINTER(ctypes.c_int) state) self.GetEMAdvanced=wrapper(lib.GetEMAdvanced) # ctypes.c_uint SetEMAdvanced(ctypes.c_int state) self.SetEMAdvanced=wrapper(lib.SetEMAdvanced) # ctypes.c_uint GetShutterMinTimes(ctypes.POINTER(ctypes.c_int) minclosingtime, ctypes.POINTER(ctypes.c_int) minopeningtime) self.GetShutterMinTimes=wrapper(lib.GetShutterMinTimes) # ctypes.c_uint SetShutter(ctypes.c_int typ, ctypes.c_int mode, ctypes.c_int closingtime, ctypes.c_int openingtime) self.SetShutter=wrapper(lib.SetShutter) # ctypes.c_uint SetShutterEx(ctypes.c_int typ, ctypes.c_int mode, ctypes.c_int closingtime, ctypes.c_int openingtime, ctypes.c_int extmode) self.SetShutterEx=wrapper(lib.SetShutterEx) # ctypes.c_uint IsInternalMechanicalShutter(ctypes.POINTER(ctypes.c_int) InternalShutter) self.IsInternalMechanicalShutter=wrapper(lib.IsInternalMechanicalShutter) # ctypes.c_uint GetCountConvertWavelengthRange(ctypes.POINTER(ctypes.c_float) minval, ctypes.POINTER(ctypes.c_float) maxval) self.GetCountConvertWavelengthRange=wrapper(lib.GetCountConvertWavelengthRange) # ctypes.c_uint IsCountConvertModeAvailable(ctypes.c_int mode) self.IsCountConvertModeAvailable=wrapper(lib.IsCountConvertModeAvailable) # ctypes.c_uint SetCountConvertMode(ctypes.c_int Mode) self.SetCountConvertMode=wrapper(lib.SetCountConvertMode) # ctypes.c_uint SetCountConvertWavelength(ctypes.c_float wavelength) self.SetCountConvertWavelength=wrapper(lib.SetCountConvertWavelength) # ctypes.c_uint SetPhotonCounting(ctypes.c_int state) self.SetPhotonCounting=wrapper(lib.SetPhotonCounting) # ctypes.c_uint SetPhotonCountingThreshold(ctypes.c_long min, ctypes.c_long max) self.SetPhotonCountingThreshold=wrapper(lib.SetPhotonCountingThreshold) # ctypes.c_uint GetNumberPhotonCountingDivisions(ctypes.POINTER(ctypes.c_ulong) noOfDivisions) self.GetNumberPhotonCountingDivisions=wrapper(lib.GetNumberPhotonCountingDivisions) # ctypes.c_uint SetPhotonCountingDivisions(ctypes.c_ulong noOfDivisions, ctypes.POINTER(ctypes.c_long) divisions) self.SetPhotonCountingDivisions=wrapper(lib.SetPhotonCountingDivisions, rvals=[]) # ctypes.c_uint SetGate(ctypes.c_float delay, ctypes.c_float width, ctypes.c_float stepRenamed) self.SetGate=wrapper(lib.SetGate) # ctypes.c_uint GetGateMode(ctypes.POINTER(ctypes.c_int) piGatemode) self.GetGateMode=wrapper(lib.GetGateMode) # ctypes.c_uint SetGateMode(ctypes.c_int gatemode) self.SetGateMode=wrapper(lib.SetGateMode) # ctypes.c_uint GetAcquisitionTimings(ctypes.POINTER(ctypes.c_float) exposure, ctypes.POINTER(ctypes.c_float) accumulate, ctypes.POINTER(ctypes.c_float) kinetic) self.GetAcquisitionTimings=wrapper(lib.GetAcquisitionTimings) # ctypes.c_uint SetExposureTime(ctypes.c_float time) self.SetExposureTime=wrapper(lib.SetExposureTime) # ctypes.c_uint GetMaximumExposure(ctypes.POINTER(ctypes.c_float) MaxExp) self.GetMaximumExposure=wrapper(lib.GetMaximumExposure) # ctypes.c_uint SetDualExposureTimes(ctypes.c_float expTime1, ctypes.c_float expTime2) self.SetDualExposureTimes=wrapper(lib.SetDualExposureTimes) # ctypes.c_uint SetDualExposureMode(ctypes.c_int mode) self.SetDualExposureMode=wrapper(lib.SetDualExposureMode) # ctypes.c_uint GetDualExposureTimes(ctypes.POINTER(ctypes.c_float) exposure1, ctypes.POINTER(ctypes.c_float) exposure2) self.GetDualExposureTimes=wrapper(lib.GetDualExposureTimes) # ctypes.c_uint GetMaximumNumberRingExposureTimes(ctypes.POINTER(ctypes.c_int) number) self.GetMaximumNumberRingExposureTimes=wrapper(lib.GetMaximumNumberRingExposureTimes) # ctypes.c_uint GetRingExposureRange(ctypes.POINTER(ctypes.c_float) fpMin, ctypes.POINTER(ctypes.c_float) fpMax) self.GetRingExposureRange=wrapper(lib.GetRingExposureRange) # ctypes.c_uint GetNumberRingExposureTimes(ctypes.POINTER(ctypes.c_int) ipnumTimes) self.GetNumberRingExposureTimes=wrapper(lib.GetNumberRingExposureTimes) # ctypes.c_uint SetRingExposureTimes(ctypes.c_int numTimes, ctypes.POINTER(ctypes.c_float) times) self.SetRingExposureTimes=wrapper(lib.SetRingExposureTimes, rvals=["times"], byref=[], argprep={"times":lambda numTimes: (ctypes.c_float*numTimes)()}, rconv={"times": lambda v,_,kwargs: np.ctypeslib.as_array(v,(kwargs["numTimes"],)).copy()}) # ctypes.c_uint GetAdjustedRingExposureTimes(ctypes.c_int inumTimes, ctypes.POINTER(ctypes.c_float) fptimes) self.GetAdjustedRingExposureTimes=wrapper(lib.GetAdjustedRingExposureTimes, rvals=["fptimes"], byref=[], argprep={"fptimes":lambda inumTimes: (ctypes.c_float*inumTimes)()}, rconv={"fptimes": lambda v,_,kwargs: np.ctypeslib.as_array(v,(kwargs["inumTimes"],)).copy()}) # ctypes.c_uint SetAcquisitionMode(ctypes.c_int mode) self.SetAcquisitionMode=wrapper(lib.SetAcquisitionMode) # ctypes.c_uint SetNumberAccumulations(ctypes.c_int number) self.SetNumberAccumulations=wrapper(lib.SetNumberAccumulations) # ctypes.c_uint SetNumberKinetics(ctypes.c_int number) self.SetNumberKinetics=wrapper(lib.SetNumberKinetics) # ctypes.c_uint SetNumberPrescans(ctypes.c_int iNumber) self.SetNumberPrescans=wrapper(lib.SetNumberPrescans) # ctypes.c_uint SetKineticCycleTime(ctypes.c_float time) self.SetKineticCycleTime=wrapper(lib.SetKineticCycleTime) # ctypes.c_uint SetAccumulationCycleTime(ctypes.c_float time) self.SetAccumulationCycleTime=wrapper(lib.SetAccumulationCycleTime) # ctypes.c_uint SetFrameTransferMode(ctypes.c_int mode) self.SetFrameTransferMode=wrapper(lib.SetFrameTransferMode) # ctypes.c_uint GetReadOutTime(ctypes.POINTER(ctypes.c_float) ReadOutTime) self.GetReadOutTime=wrapper(lib.GetReadOutTime) # ctypes.c_uint GetKeepCleanTime(ctypes.POINTER(ctypes.c_float) KeepCleanTime) self.GetKeepCleanTime=wrapper(lib.GetKeepCleanTime) # ctypes.c_uint EnableKeepCleans(ctypes.c_int iMode) self.EnableKeepCleans=wrapper(lib.EnableKeepCleans) # ctypes.c_uint SetOverlapMode(ctypes.c_int mode) self.SetOverlapMode=wrapper(lib.SetOverlapMode) # ctypes.c_uint SetFastKinetics(ctypes.c_int exposedRows, ctypes.c_int seriesLength, ctypes.c_float time, ctypes.c_int mode, ctypes.c_int hbin, ctypes.c_int vbin) self.SetFastKinetics=wrapper(lib.SetFastKinetics) # ctypes.c_uint SetFastKineticsEx(ctypes.c_int exposedRows, ctypes.c_int seriesLength, ctypes.c_float time, ctypes.c_int mode, ctypes.c_int hbin, ctypes.c_int vbin, ctypes.c_int offset) self.SetFastKineticsEx=wrapper(lib.SetFastKineticsEx) # ctypes.c_uint GetFKExposureTime(ctypes.POINTER(ctypes.c_float) time) self.GetFKExposureTime=wrapper(lib.GetFKExposureTime) # ctypes.c_uint GetFKVShiftSpeedF(ctypes.c_int index, ctypes.POINTER(ctypes.c_float) speed) self.GetFKVShiftSpeedF=wrapper(lib.GetFKVShiftSpeedF) # ctypes.c_uint SetFKVShiftSpeed(ctypes.c_int index) self.SetFKVShiftSpeed=wrapper(lib.SetFKVShiftSpeed) # ctypes.c_uint GetNumberFKVShiftSpeeds(ctypes.POINTER(ctypes.c_int) number) self.GetNumberFKVShiftSpeeds=wrapper(lib.GetNumberFKVShiftSpeeds) # ctypes.c_uint GetMCPGain(ctypes.POINTER(ctypes.c_int) piGain) self.GetMCPGain=wrapper(lib.GetMCPGain) # ctypes.c_uint GetMCPGainRange(ctypes.POINTER(ctypes.c_int) iLow, ctypes.POINTER(ctypes.c_int) iHigh) self.GetMCPGainRange=wrapper(lib.GetMCPGainRange) # ctypes.c_uint GetMCPVoltage(ctypes.POINTER(ctypes.c_int) iVoltage) self.GetMCPVoltage=wrapper(lib.GetMCPVoltage) # ctypes.c_uint SetMCPGain(ctypes.c_int gain) self.SetMCPGain=wrapper(lib.SetMCPGain) # ctypes.c_uint SetMCPGating(ctypes.c_int gating) self.SetMCPGating=wrapper(lib.SetMCPGating) # ctypes.c_uint PrepareAcquisition() self.PrepareAcquisition=wrapper(lib.PrepareAcquisition) # ctypes.c_uint StartAcquisition() self.StartAcquisition=wrapper(lib.StartAcquisition) # ctypes.c_uint AbortAcquisition() self.AbortAcquisition=wrapper(lib.AbortAcquisition) # ctypes.c_uint GetAcquisitionProgress(ctypes.POINTER(ctypes.c_long) acc, ctypes.POINTER(ctypes.c_long) series) self.GetAcquisitionProgress=wrapper(lib.GetAcquisitionProgress) # ctypes.c_uint GetStatus(ctypes.POINTER(ctypes.c_int) status) self.GetStatus=wrapper(lib.GetStatus) # ctypes.c_uint GetCameraEventStatus(ctypes.POINTER(DWORD) camStatus) self.GetCameraEventStatus=wrapper(lib.GetCameraEventStatus) # ctypes.c_uint GetFrontEndStatus(ctypes.POINTER(ctypes.c_int) piFlag) self.GetFrontEndStatus=wrapper(lib.GetFrontEndStatus) # ctypes.c_uint WaitForAcquisition() self.WaitForAcquisition=wrapper(lib.WaitForAcquisition) # ctypes.c_uint WaitForAcquisitionTimeOut(ctypes.c_int iTimeOutMs) self.WaitForAcquisitionTimeOut=wrapper(lib.WaitForAcquisitionTimeOut) # ctypes.c_uint WaitForAcquisitionByHandle(ctypes.c_long cameraHandle) self.WaitForAcquisitionByHandle=wrapper(lib.WaitForAcquisitionByHandle) # ctypes.c_uint WaitForAcquisitionByHandleTimeOut(ctypes.c_long cameraHandle, ctypes.c_int iTimeOutMs) self.WaitForAcquisitionByHandleTimeOut=wrapper(lib.WaitForAcquisitionByHandleTimeOut) # ctypes.c_uint CancelWait() self.CancelWait=wrapper(lib.CancelWait) # ctypes.c_uint SetReadMode(ctypes.c_int mode) self.SetReadMode=wrapper(lib.SetReadMode) # ctypes.c_uint GetMaximumBinning(ctypes.c_int ReadMode, ctypes.c_int HorzVert, ctypes.POINTER(ctypes.c_int) MaxBinning) self.GetMaximumBinning=wrapper(lib.GetMaximumBinning) # ctypes.c_uint GetMinimumImageLength(ctypes.POINTER(ctypes.c_int) MinImageLength) self.GetMinimumImageLength=wrapper(lib.GetMinimumImageLength) # ctypes.c_uint SetSingleTrack(ctypes.c_int centre, ctypes.c_int height) self.SetSingleTrack=wrapper(lib.SetSingleTrack) # ctypes.c_uint SetMultiTrack(ctypes.c_int number, ctypes.c_int height, ctypes.c_int offset, ctypes.POINTER(ctypes.c_int) bottom, ctypes.POINTER(ctypes.c_int) gap) self.SetMultiTrack=wrapper(lib.SetMultiTrack) # ctypes.c_uint SetRa\ndomTracks(ctypes.c_int numTracks, ctypes.POINTER(ctypes.c_int) areas) self.SetRandomTracks_lib=wrapper(lib.SetRandomTracks, args="all", byref=[]) # ctypes.c_uint SetImage(ctypes.c_int hbin, ctypes.c_int vbin, ctypes.c_int hstart, ctypes.c_int hend, ctypes.c_int vstart, ctypes.c_int vend) self.SetImage=wrapper(lib.SetImage) # ctypes.c_uint SetFVBHBin(ctypes.c_int bin) self.SetFVBHBin=wrapper(lib.SetFVBHBin) # ctypes.c_uint GetImageFlip(ctypes.POINTER(ctypes.c_int) iHFlip, ctypes.POINTER(ctypes.c_int) iVFlip) self.GetImageFlip=wrapper(lib.GetImageFlip) # ctypes.c_uint GetImageRotate(ctypes.POINTER(ctypes.c_int) iRotate) self.SetImageFlip=wrapper(lib.SetImageFlip) # ctypes.c_uint SetImageRotate(ctypes.c_int iRotate) self.GetImageRotate=wrapper(lib.GetImageRotate) # ctypes.c_uint SetImageFlip(ctypes.c_int iHFlip, ctypes.c_int iVFlip) self.SetImageRotate=wrapper(lib.SetImageRotate) # ctypes.c_uint GetDetector(ctypes.POINTER(ctypes.c_int) xpixels, ctypes.POINTER(ctypes.c_int) ypixels) self.GetDetector=wrapper(lib.GetDetector) # ctypes.c_uint GetBaselineClamp(ctypes.POINTER(ctypes.c_int) state) self.GetBaselineClamp=wrapper(lib.GetBaselineClamp) # ctypes.c_uint SetBaselineClamp(ctypes.c_int state) self.SetBaselineClamp=wrapper(lib.SetBaselineClamp) # ctypes.c_uint SetBaselineOffset(ctypes.c_int offset) self.SetBaselineOffset=wrapper(lib.SetBaselineOffset) # ctypes.c_uint GetFilterMode(ctypes.POINTER(ctypes.c_int) mode) self.GetFilterMode=wrapper(lib.GetFilterMode) # ctypes.c_uint SetFilterMode(ctypes.c_int mode) self.SetFilterMode=wrapper(lib.SetFilterMode) # ctypes.c_uint Filter_SetMode(ctypes.c_uint mode) self.Filter_SetMode=wrapper(lib.Filter_SetMode) # ctypes.c_uint Filter_GetMode(ctypes.POINTER(ctypes.c_uint) mode) self.Filter_GetMode=wrapper(lib.Filter_GetMode) # ctypes.c_uint Filter_SetThreshold(ctypes.c_float threshold) self.Filter_SetThreshold=wrapper(lib.Filter_SetThreshold) # ctypes.c_uint Filter_GetThreshold(ctypes.POINTER(ctypes.c_float) threshold) self.Filter_GetThreshold=wrapper(lib.Filter_GetThreshold) # ctypes.c_uint Filter_SetDataAveragingMode(ctypes.c_int mode) self.Filter_SetDataAveragingMode=wrapper(lib.Filter_SetDataAveragingMode) # ctypes.c_uint Filter_GetDataAveragingMode(ctypes.POINTER(ctypes.c_int) mode) self.Filter_GetDataAveragingMode=wrapper(lib.Filter_GetDataAveragingMode) # ctypes.c_uint Filter_SetAveragingFrameCount(ctypes.c_int frames) self.Filter_SetAveragingFrameCount=wrapper(lib.Filter_SetAveragingFrameCount) # ctypes.c_uint Filter_GetAveragingFrameCount(ctypes.POINTER(ctypes.c_int) frames) self.Filter_GetAveragingFrameCount=wrapper(lib.Filter_GetAveragingFrameCount) # ctypes.c_uint Filter_SetAveragingFactor(ctypes.c_int averagingFactor) self.Filter_SetAveragingFactor=wrapper(lib.Filter_SetAveragingFactor) # ctypes.c_uint Filter_GetAveragingFactor(ctypes.POINTER(ctypes.c_int) averagingFactor) self.Filter_GetAveragingFactor=wrapper(lib.Filter_GetAveragingFactor) # ctypes.c_uint GetSizeOfCircularBuffer(ctypes.POINTER(ctypes.c_long) index) self.GetSizeOfCircularBuffer=wrapper(lib.GetSizeOfCircularBuffer) # ctypes.c_uint FreeInternalMemory() self.FreeInternalMemory=wrapper(lib.FreeInternalMemory) # ctypes.c_uint GetImagesPerDMA(ctypes.POINTER(ctypes.c_ulong) images) self.GetImagesPerDMA=wrapper(lib.GetImagesPerDMA) # ctypes.c_uint SetDMAParameters(ctypes.c_int MaxImagesPerDMA, ctypes.c_float SecondsPerDMA) self.SetDMAParameters=wrapper(lib.SetDMAParameters) buffer16_prep=ctypes_wrap.buffprep(0,"