class Adsc(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self,cl, name): PyTango.Device_4Impl.__init__(self,cl,name) self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #------------------------------------------------------------------ # LoadConfiguration command #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def takeDarks(self,Texp): _AdscInterface.takeDarks(Texp)
class Prosilica(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self,*args) : PyTango.Device_4Impl.__init__(self,*args) self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return AttrHelper.get_attr_string_value_list(self, attr_name) def __getattr__(self,name) : return AttrHelper.get_attr_4u(self, name, ProsilicaAcq)
class Xpad(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): valueList = [] dict_name = '_' + self.__class__.__name__ + '__' + ''.join( [x.title() for x in attr_name.split('_')]) d = getattr(self, dict_name, None) if d: valueList = d.keys() return valueList def __getattr__(self, name): if name.startswith('read_') or name.startswith('write_'): split_name = name.split('_')[1:] attr_name = ''.join([x.title() for x in split_name]) dict_name = '_' + self.__class__.__name__ + '__' + attr_name d = getattr(self, dict_name, None) attr_name = self.__Attribute2FunctionBase.get( '_'.join(split_name), attr_name) if d: if name.startswith('read_'): functionName = 'get' + attr_name function2Call = getattr(_XpadAcq, functionName) callable_obj = CallableReadEnum(d, function2Call) else: functionName = 'set' + attr_name function2Call = getattr(_XpadAcq, function2Call) callable_obj = CallableWriteEnum(d, function2Call) self.__dict__[name] = callable_obj return callable_obj raise AttributeError('Xpad has no attribute %s' % name)
class _PushingThread(threading.Thread): Core.DEB_CLASS(Core.DebModApplication, "_PushingThread") def __init__(self, task): threading.Thread.__init__(self) self._task = task self.timestamp = time.time() def run(self): task = self._task while task._stop is False: with task._lock: while (task._new_frame_ready is False and task._stop is False): task._lock.wait() if task._stop: break task._new_frame_ready = False dt = time.time() - self.timestamp if dt > 0.04: bvdata, bvdata_format = construct_bvdata( self._task._bpm_device) self._task._bpm_device.push_change_event( "bvdata", bvdata_format, bvdata) self.timestamp = time.time()
class Eiger(PyTango.Device_4Impl): #--------- Add you global variables here -------------------------- Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, cl, name): PyTango.Device_4Impl.__init__(self, cl, name) self.init_device() self.__CountrateCorrection = {'ON': True, 'OFF': False} self.__FlatfieldCorrection = {'ON': True, 'OFF': False} self.__AutoSummation = {'ON': True, 'OFF': False} self.__EfficiencyCorrection = {'ON': True, 'OFF': False} self.__VirtualPixelCorrection = {'ON': True, 'OFF': False} self.__PixelMask = {'ON': True, 'OFF': False} #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #------------------------------------------------------------------ # getAttrStringValueList command: # # Description: return a list of authorized values if any # argout: DevVarStringArray #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return AttrHelper.get_attr_string_value_list(self, attr_name) #---------------------------------------------------------------------------- # delete all memory files #---------------------------------------------------------------------------- @Core.DEB_MEMBER_FUNCT def deleteMemoryFiles(self): _EigerCamera.deleteMemoryFiles() #================================================================== # # Eiger read/write attribute methods # #================================================================== def __getattr__(self, name): return AttrHelper.get_attr_4u(self, name, _EigerCamera)
class HDF5SavingDeviceServer(BasePostProcess): HDF5_TASK_NAME = 'HDF5SavingTask' Core.DEB_CLASS(Core.DebModApplication, 'HDF5Saving') def __init__(self, cl, name): self.__HDF5SavingTask = None self.__HDF5Sink = None self.__HDF5Writer = None self.get_device_properties(self.get_device_class()) self.__extension = "" self.__subdir = None BasePostProcess.__init__(self, cl, name) HDF5SavingDeviceServer.init_device(self) def set_state(self, state): if (state == PyTango.DevState.OFF): if (self.__HDF5SavingTask): self.__HDF5Writer.close() self.__callback = None self.__HDF5Writer = None self.__HDF5SavingTask = None ctControl = _control_ref() extOpt = ctControl.externalOperation() extOpt.delOp(self.HDF5_TASK_NAME) elif (state == PyTango.DevState.ON): if not self.__HDF5SavingTask: try: ctControl = _control_ref() extOpt = ctControl.externalOperation() self.__HDF5SavingTask = extOpt.addOp( Core.USER_SINK_TASK, self.HDF5_TASK_NAME, self._runLevel) if not self.__HDF5Sink: self.__HDF5Writer = HDF5Writer() self.__HDF5Sink = HDF5Sink(self.__HDF5Writer) self.__HDF5SavingTask.setSinkTask(self.__HDF5Sink) self.__callback = PrepareAcqCallback( ctControl, self.__HDF5Sink) self.__HDF5SavingTask.registerCallback(self.__callback) except: import traceback traceback.print_exc() return PyTango.Device_4Impl.set_state(self, state) def Reset(self): if (self.__HDF5Sink): self.__HDF5Sink.reset() def read_Parameters(self, the_att): """ Called when reading the "Parameters" attribute """ if self.__HDF5Sink: the_att.set_value(self.__HDF5Sink.__repr__()) else: the_att.set_value("No HDF5 Sink processlib active for the moment")
class Basler(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self,*args) : PyTango.Device_4Impl.__init__(self,*args) self.__TestImageSelector = {'TESTIMAGE_OFF': BaslerAcq.Camera.TestImage_Off, 'TESTIMAGE_1': BaslerAcq.Camera.TestImage_1, 'TESTIMAGE_2': BaslerAcq.Camera.TestImage_2, 'TESTIMAGE_3': BaslerAcq.Camera.TestImage_3, 'TESTIMAGE_4': BaslerAcq.Camera.TestImage_4, 'TESTIMAGE_5': BaslerAcq.Camera.TestImage_5, 'TESTIMAGE_6': BaslerAcq.Camera.TestImage_6, 'TESTIMAGE_7': BaslerAcq.Camera.TestImage_7, } self.__Attribute2FunctionBase = { } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #------------------------------------------------------------------ # getAttrStringValueList command: # # Description: return a list of authorized values if any # argout: DevVarStringArray #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): #use AttrHelper return AttrHelper.get_attr_string_value_list(self, attr_name) #================================================================== # # Basler read/write attribute methods # #================================================================== def __getattr__(self,name) : #use AttrHelper return AttrHelper.get_attr_4u(self,name,_BaslerCam)
class Dexela(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) self.init_device() self.__Attribute2FunctionBase = {} #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #Full well mode self.__FullWellMode = { 'HIGH': _DexelaInterface.High, 'LOW': _DexelaInterface.Low } self.__SkipFirstFrame = {'YES': True, 'NO': False} #------------------------------------------------------------------ # getAttrStringValueList command: # # Description: return a list of authorized values if any # argout: DevVarStringArray #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): #use AttrHelper return get_attr_string_value_list(self, attr_name) #================================================================== # # Dexela read/write attribute methods # #================================================================== def __getattr__(self, name): #use AttrHelper return get_attr_4u(self, name, _DexelaInterface)
class XPad(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self,cl, name): PyTango.Device_4Impl.__init__(self,cl,name) self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #------------------------------------------------------------------ # LoadConfiguration command #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def loadConfiguration(self,filearr): _XPadInterface.loadConfig(filearr[0],filearr[1]) #------------------------------------------------------------------ # Attrubute read/write methods #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def read_config_id(self, attr): Id = _XPadInterface.getConfigId() attr.set_value(Id) @Core.DEB_MEMBER_FUNCT def write_config_id(self, attr): data = [] attr.get_write_value(data) Id = data[0] _XPadInterface.setConfigId(Id) @Core.DEB_MEMBER_FUNCT def read_ITHLoffset(self, attr): th = _XPadInterface.getITHLoffset() attr.set_value(th) @Core.DEB_MEMBER_FUNCT def write_ITHLoffset(self, attr): data = [] attr.get_write_value(data) th = data[0] _XPadInterface.getITHLoffset(th)
class _ExampleThreshold(Core.CtAccumulation.ThresholdCallback): Core.DEB_CLASS(Core.DebModApplication, '_ExampleThreshold') def __init__(self): Core.CtAccumulation.ThresholdCallback.__init__(self) ##@brief the effective callback methode @Core.DEB_MEMBER_FUNCT def aboveMax(self, data, value): deb.Trace('aboveMax: data=%s, value=%s' % (data, value))
class MaxImageSizeCallback(Core.HwMaxImageSizeCallback): Core.DEB_CLASS(Core.DebModTest, "MaxImageSizeCallback") @Core.DEB_MEMBER_FUNCT def maxImageSizeChanged(self, size, image_type): fdim = Core.FrameDim(size, image_type) msg = "size=%sx%s, image_type=%s, depth=%d" % \ (size.getWidth(), size.getHeight(), image_type, \ fdim.getDepth()) deb.Always("MaxImageSizeChanged: %s" % msg)
class ImageStatusCallback(Core.CtControl.ImageStatusCallback): Core.DEB_CLASS(Core.DebModTest, "ImageStatusCallback") @Core.DEB_MEMBER_FUNCT def __init__(self, ct, acq_state): Core.CtControl.ImageStatusCallback.__init__(self) self.m_ct = ct self.m_acq_state = acq_state self.m_nb_frames = 0 @Core.DEB_MEMBER_FUNCT def start(self): self.m_acq_state.set(Core.AcqState.Acquiring) self.m_start_time = time.time() self.m_stat_acc = [0.0] * 4 ct_acq = self.m_ct.acquisition() self.m_nb_frames = ct_acq.getAcqNbFrames() @Core.DEB_MEMBER_FUNCT def imageStatusChanged(self, cb_img_status): t = time.time() global_status = self.m_ct.getStatus() acq_status = global_status.AcquisitionStatus img_status = global_status.ImageCounters last_acq_frame_nb = img_status.LastImageAcquired last_base_frame_nb = img_status.LastBaseImageReady last_ready_frame_nb = img_status.LastImageReady dt = t - self.m_start_time n = last_acq_frame_nb + 1 acc = self.m_stat_acc acc[0] += n acc[1] += n**2 acc[2] += dt acc[3] += n * dt acq_state_changed = False if last_ready_frame_nb == self.m_nb_frames - 1: self.m_acq_state.set(Core.AcqState.Finished) acq_state_changed = True pt = t0 = 0 if n > 1: pt = (acc[0] * acc[2] - n * acc[3]) / (acc[0]**2 - n * acc[1]) t0 = (acc[2] - pt * acc[0]) / n if True: deb.Always("Last Acquired: %8d, Last Base: %8d, " \ "Last Ready: %8d, Status: %s, PT: %.6f, T0: %.6f" % (last_acq_frame_nb, last_base_frame_nb, last_ready_frame_nb, acq_status, pt, t0))
class BackgroundSubstractionDeviceServer(BasePostProcess): BACKGROUND_TASK_NAME = 'BackGroundTask' Core.DEB_CLASS(Core.DebModApplication, 'BackgroundSubstraction') def __init__(self, cl, name): self.__backGroundTask = None self.__backGroundImage = Core.Processlib.Data() self.get_device_properties(self.get_device_class()) self.__deleteDarkAfterRead = False BasePostProcess.__init__(self, cl, name) BackgroundSubstractionDeviceServer.init_device(self) def set_state(self, state): if (state == PyTango.DevState.OFF): if (self.__backGroundTask): self.__backGroundTask = None ctControl = _control_ref() extOpt = ctControl.externalOperation() extOpt.delOp(self.BACKGROUND_TASK_NAME) elif (state == PyTango.DevState.ON): if not self.__backGroundTask: try: ctControl = _control_ref() extOpt = ctControl.externalOperation() self.__backGroundTask = extOpt.addOp( Core.BACKGROUNDSUBSTRACTION, self.BACKGROUND_TASK_NAME, self._runLevel) self.__backGroundTask.setBackgroundImage( self.__backGroundImage) except: import traceback traceback.print_exc() return PyTango.Device_4Impl.set_state(self, state) def read_delete_dark_after_read(self, attr): attr.set_value(self.__deleteDarkAfterRead) def write_delete_dark_after_read(self, attr): data = [] attr.get_write_value(data) self.__deleteDarkAfterRead = data[0] @Core.DEB_MEMBER_FUNCT def setBackgroundImage(self, filepath): deb.Param('filepath=%s' % filepath) self.__backGroundImage = getDataFromFile(filepath) if self.__deleteDarkAfterRead: os.unlink(filepath) if (self.__backGroundTask): self.__backGroundTask.setBackgroundImage(self.__backGroundImage)
class BVDataTask(Core.Processlib.SinkTaskBase): Core.DEB_CLASS(Core.DebModApplication, "BVDataTask") class _PushingThread(threading.Thread): Core.DEB_CLASS(Core.DebModApplication, "_PushingThread") def __init__(self, task): threading.Thread.__init__(self) self._task = task self.timestamp = time.time() def run(self): task = self._task while task._stop is False: with task._lock: while (task._new_frame_ready is False and task._stop is False): task._lock.wait() if task._stop: break task._new_frame_ready = False dt = time.time() - self.timestamp if dt > 0.04: bvdata, bvdata_format = construct_bvdata( self._task._bpm_device) self._task._bpm_device.push_change_event( "bvdata", bvdata_format, bvdata) self.timestamp = time.time() def __init__(self, bpm_manager, bpm_device): Core.Processlib.SinkTaskBase.__init__(self) self._bpm_device = bpm_device self._bpm_manager = bpm_manager self._lock = threading.Condition() self._new_frame_ready = False self._stop = False self._pushing_event_thread = self._PushingThread(self) self._pushing_event_thread.start() def __del__(self): self._stop = True self._pushing_event_thread.join() def process(self, data): with self._lock: # just inform pushing_thread of a new image self._new_frame_ready = True self._lock.notify()
class DeadTimeChangedCallback(Frelon.Camera.DeadTimeChangedCallback): Core.DEB_CLASS(Core.DebModTest, "DeadTimeChangedCallback") @Core.DEB_MEMBER_FUNCT def __init__(self, cam): Frelon.Camera.DeadTimeChangedCallback.__init__(self) self.m_cam = cam @Core.DEB_MEMBER_FUNCT def deadTimeChanged(self, dead_time): cam = self.m_cam deb.Always("dead_time=%.6f, readout_time=%.6f, xfer_time=%.6f" % (dead_time, cam.getReadoutTime(), cam.getTransferTime()))
class Ueye(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) self.init_device() self.__Attribute2FunctionBase = {} #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #------------------------------------------------------------------ # getAttrStringValueList command: # # Description: return a list of authorized values if any # argout: DevVarStringArray #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): #use AttrHelper return AttrHelper.get_attr_string_value_list(self, attr_name) #================================================================== # # Ueye read/write attribute methods # #================================================================== def __getattr__(self, name): #use AttrHelper return AttrHelper.get_attr_4u(self, name, _UeyeInterface)
class RoperScientific(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) self.__AdcRate = { 'MHZ1': 0, 'KHZ100': 1, } self.__InternalAcqMode = { 'FOCUS': 'FOCUS', 'STANDARD': 'STANDARD', } self.__Attribute2FunctionBase = { 'adc_rate': 'SpeedTableIndex', } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name) def __getattr__(self, name): return get_attr_4u(self, name, _RoperScientificCam) def read_InternalAcqMode(self, attr): int_acq_mode = _RoperScientificCam.getInternalAcqMode() attr.set_value(int_acq_mode)
class SoftRoiCallback(Core.Processlib.TaskEventCallback): Core.DEB_CLASS(Core.DebModTest, "SoftRoiCallback") DataType2ImageType = { N.int8: Core.Bpp8, N.uint8: Core.Bpp8, N.int16: Core.Bpp16, N.uint16: Core.Bpp16, N.int32: Core.Bpp32, N.uint32: Core.Bpp32 } @Core.DEB_MEMBER_FUNCT def __init__(self, hw_inter, buffer_save, acq_state): Core.Processlib.TaskEventCallback.__init__(self) self.m_hw_inter = hw_inter self.m_buffer_save = buffer_save self.m_acq_state = acq_state @Core.DEB_MEMBER_FUNCT def finished(self, data): finfo, fdim = self.data2FrameInfo(data) self.m_buffer_save.writeFrame(finfo) hw_sync = self.m_hw_inter.getHwCtrlObj(Core.HwCap.Sync) nb_frames = hw_sync.getNbFrames() if finfo.acq_frame_nb == nb_frames - 1: self.m_acq_state.set(Core.AcqState.Finished) @Core.DEB_MEMBER_FUNCT def data2FrameInfo(self, data): arr = data.buffer arr_type = arr.dtype.type arr_height, arr_width = arr.shape image_type = self.DataType2ImageType[arr_type] buffer_ctrl = self.m_hw_inter.getHwCtrlObj(Core.HwCap.Buffer) start_ts = buffer_ctrl.getStartTimestamp() fdim = Core.FrameDim(arr_width, arr_height, image_type) timestamp = Core.Timestamp(data.timestamp) valid_pixels = Core.Point(fdim.getSize()).getArea() ownership = Core.HwFrameInfoType.Managed finfo = Core.HwFrameInfoType(data.frameNumber, arr, timestamp, valid_pixels, ownership) return finfo, fdim
class TestFrameCallback(Core.HwFrameCallback): Core.DEB_CLASS(Core.DebModTest, "TestFrameCallback") ImageType2DataType = { Core.Bpp8: Data_UINT8, Core.Bpp16: Data_UINT16, Core.Bpp32: Data_UINT32 } @Core.DEB_MEMBER_FUNCT def __init__(self, hw_inter, soft_roi, buffer_save, acq_state): Core.HwFrameCallback.__init__(self) self.m_hw_inter = hw_inter self.m_soft_roi = soft_roi self.m_acq_state = acq_state self.m_roi_task = Core.Processlib.Tasks.SoftRoi() self.m_roi_cb = SoftRoiCallback(hw_inter, buffer_save, acq_state) @Core.DEB_MEMBER_FUNCT def newFrameReady(self, frame_info): msg = 'acq_frame_nb=%d, ' % frame_info.acq_frame_nb data = self.frameInfo2Data(frame_info) buffer = data.buffer msg += 'frame_dim=%dx%dx%d, ' % \ (buffer.shape[1], buffer.shape[0], buffer.dtype.itemsize) msg += 'frame_timestamp=%.6f, ' % frame_info.frame_timestamp msg += 'valid_pixels=%d' % frame_info.valid_pixels deb.Always("newFrameReady: %s" % msg) if self.m_soft_roi.isActive(): pass else: self.m_roi_cb.finished(data) return True @Core.DEB_MEMBER_FUNCT def frameInfo2Data(self, frame_info): data = Core.Processlib.Data() data.buffer = frame_info.frame_data data.frameNumber = frame_info.acq_frame_nb data.timestamp = frame_info.frame_timestamp return data
class TestControlAutoSync: Core.DEB_CLASS(Core.DebModTest, 'TestControlAutoSync') def __init__(self): self.test_control = TestControl() self.traceRefCount(1) def __del__(self): self.traceRefCount(2) self.test_control.sync() self.traceRefCount(3) @Core.DEB_MEMBER_FUNCT def traceRefCount(self, point): deb.Trace("%s* refcount(test_control): %s" % (point, sys.getrefcount(self.test_control))) def __getattr__(self, name): return getattr(self.test_control, name)
class imXPAD(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self,*args) : PyTango.Device_4Impl.__init__(self,*args) self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) @Core.DEB_MEMBER_FUNCT def loadConfig(self,config_prefix) : config_path = self.config_path _imXPADCam.loadConfigGFromFile(os.path.join(config_path,'%s.cfg' % config_prefix)) _imXPADCam.loadConfigLFromFileToSRAM(os.path.join(config_path,'%s.cfl' % config_prefix)) _imXPADCam.loadConfigLSRAMToDetector() @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name) def __getattr__(self,name) : return get_attr_4u(self, name, XpadAcq)
class Lambda(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) #self.__Attribute2FunctionBase = {'distortion_correction': 'DistortionCorrection', # } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name) def __getattr__(self, name): return get_attr_4u(self, name, _LambdaCam)
class AzimuthalIntegrationDeviceServer(BasePostProcess): AZIMUTHAL_TASK_NAME = 'AzimuthalIntegrationTask' Core.DEB_CLASS(Core.DebModApplication, 'AzimuthalIntegration') def __init__(self, cl, name): self.__azimuthalIntegratorTask = None self.__jsonConfig = None self.__pyFAISink = None self.get_device_properties(self.get_device_class()) self.__extension = "" self.__subdir = None BasePostProcess.__init__(self, cl, name) AzimuthalIntegrationDeviceServer.init_device(self) def set_state(self, state): if (state == PyTango.DevState.OFF): if (self.__azimuthalIntegratorTask): self.__azimuthalIntegratorTask = None ctControl = _control_ref() extOpt = ctControl.externalOperation() extOpt.delOp(self.AZIMUTHAL_TASK_NAME) elif (state == PyTango.DevState.ON): if not self.__azimuthalIntegratorTask: try: ctControl = _control_ref() extOpt = ctControl.externalOperation() self.__azimuthalIntegratorTask = extOpt.addOp( Core.USER_SINK_TASK, self.AZIMUTHAL_TASK_NAME, self._runLevel) if not self.__pyFAISink: self.__pyFAISink = SinkPyFAI() if self.__jsonConfig: self.__pyFAISink.setJsonConfig(self.__jsonConfig) if self.__extension: self.__pyFAISink.setExtension(self.__extension) if self.__subdir: self.__pyFAISink.setSubdir(self.__subdir) self.__azimuthalIntegratorTask.setSinkTask( self.__pyFAISink) except: import traceback traceback.print_exc() return PyTango.Device_4Impl.set_state(self, state) def setBackgroundImage(self, filepath): if (self.__pyFAISink): self.__pyFAISink.setBackgroundFile(filepath) def setFlatfieldImage(self, filepath): if (self.__pyFAISink): self.__pyFAISink.setFlatfieldFile(filepath) def setJsonConfig(self, filepath): self.__jsonConfig = filepath if (self.__pyFAISink): self.__pyFAISink.setJsonConfig(filepath) def setProcessedSubdir(self, filepath): """ Directory (relative or absolute) for processed data """ self.__subdir = filepath if self.__pyFAISink: self.__pyFAISink.setSubdir(self.__subdir) def setProcessedExt(self, ext): """ Extension for prcessed data files """ self.__extension = ext if self.__pyFAISink: self.__pyFAISink.setExtension(self.__extension) def Reset(self): if (self.__pyFAISink): self.__pyFAISink.reset() def Reconfig(self, shape): if (self.__pyFAISink): self.__pyFAISink.reconfig(shape) def read_Parameters(self, the_att): """ Called when reading the "Parameters" attribute """ if self.__pyFAISink: the_att.set_value(self.__pyFAISink.__repr__()) else: the_att.set_value("No pyFAI Sink processlib active for the moment")
class Interface(Core.HwInterface) : Core.DEB_CLASS(Core.DebModCamera, "Interface") def __init__(self) : Core.HwInterface.__init__(self) self.__comm = Communication() self.__comm.start() self.__detInfo = DetInfoCtrlObj() self.__detInfo.init() self.__buffer = BufferCtrlObj(self.__comm,self.__detInfo) self.__syncObj = SyncCtrlObj(self.__comm,self.__detInfo) def __del__(self) : self.__comm.quit() def quit(self) : self.__comm.quit() @Core.DEB_MEMBER_FUNCT def getCapList(self) : return [Core.HwCap(x) for x in [self.__detInfo,self.__syncObj,self.__buffer]] @Core.DEB_MEMBER_FUNCT def reset(self,reset_level): pass @Core.DEB_MEMBER_FUNCT def prepareAcq(self): self.__syncObj.prepareAcq() # while self.__comm.getCurrentCommand() != Communication.COM_NONE: # time.sleep(0.1) @Core.DEB_MEMBER_FUNCT def loadConfig(self,file1,file2): self.__comm.setCalFiles(file1,file2) self.__comm.Configure() @Core.DEB_MEMBER_FUNCT def setITHLoffset(self,th) : self.__comm.setITHLoffset(th) @Core.DEB_MEMBER_FUNCT def getITHLoffset(self) : return self.__comm.getITHLoffset() @Core.DEB_MEMBER_FUNCT def setConfigId(self,Id): self.__comm.setConfigId(Id) @Core.DEB_MEMBER_FUNCT def getConfigId(self): return self.__comm.getConfigId() @Core.DEB_MEMBER_FUNCT def startAcq(self) : self.__comm.startAcquisition() @Core.DEB_MEMBER_FUNCT def stopAcq(self) : pass @Core.DEB_MEMBER_FUNCT def getStatus(self) : CommOk = self.__comm.isAlive() and self.__comm.isRunning() CommState = self.__comm.getCurrentCommand() status = Core.HwInterface.StatusType() if not CommOk: status.det = Core.DetFault status.acq = Core.AcqFault deb.Error("Detector communication is not running") elif CommState == Communication.COM_NONE: status.det = Core.DetIdle status.acq = Core.AcqReady elif not self.__comm.isConfigured() : status.det = Core.DetFault status.acq = Core.AcqConfig else: if CommState == Communication.COM_START or \ CommState == Communication.COM_TEST: status.det = Core.DetExposure else: status.det = Core.DetFault if self.__syncObj.getNbFrames() == self.__comm.getNbFramesReady(): status.acq = Core.AcqReady else: status.acq = Core.AcqRunning status.det_mask = (Core.DetExposure|Core.DetFault) return status @Core.DEB_MEMBER_FUNCT def getNbAcquiredFrames(self) : return self.__comm.getNbFramesReady() @Core.DEB_MEMBER_FUNCT def getNbHwAcquiredFrames(self): return self.getNbAcquiredFrames()
class Pco(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) #self._Pco__Rollingshutter = { "only for EDGE": "-1", "GLOBAL": "0", "ROLLING":"1" } self.__Attribute2FunctionBase = { 'acqTimeoutRetry': 'AcqTimeoutRetry', 'adc': 'Adc', 'adcMax': 'AdcMax', 'binInfo': 'BinningInfo', 'bitAlignment': 'BitAlignment', 'bytesPerPixel': 'BytesPerPixel', 'camInfo': 'CamInfo', 'camName': 'CameraName', 'camNameBase': 'CameraNameBase', 'camNameEx': 'CameraNameEx', 'camType': 'CamType', 'cdiMode': 'CDIMode', 'clXferPar': 'ClTransferParam', 'cocRunTime': 'CocRunTime', 'coolingTemperature': 'CoolingTemperature', 'doubleImageMode': 'DoubleImageMode', 'firmwareInfo': 'FirmwareInfo', 'frameRate': 'FrameRate', 'info': 'CamInfo', 'lastError': 'LastError', 'lastImgAcquired': 'LastImgAcquired', 'lastImgRecorded': 'LastImgRecorded', 'logMsg': 'MsgLog', 'logPcoEnabled': 'PcoLogsEnabled', 'maxNbImages': 'MaxNbImages', 'pixelRate': 'PixelRate', 'pixelRateInfo': 'PixelRateInfo', 'pixelRateValidValues': 'PixelRateValidValues', 'roiInfo': 'RoiInfo', 'roiLastFixed': 'LastFixedRoi', 'rollingShutter': 'RollingShutter', 'rollingShutterInfo': 'RollingShutterInfo', 'temperatureInfo': 'TemperatureInfo', 'traceAcq': 'TraceAcq', 'version': 'Version', 'versionSdk': 'SdkRelease', 'camerasFound': 'CamerasFound', 'debugInt': 'DebugInt', 'debugIntTypes': 'DebugIntTypes', 'test': 'Test', 'timestampMode': 'TimestampMode', } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) #================================================================== # # Pco read/write attribute methods # #================================================================== def __getattr__(self, name): return get_attr_4u(self, name, _PcoCam) def read_versionAtt(self, attr): attr.set_value(VERSION_ATT) #================================================================== # # Pco command methods # #================================================================== @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name) @Core.DEB_MEMBER_FUNCT def talk(self, argin): val = _PcoCam.talk(argin) return val
class Frelon(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaFrelon') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ def __init__(self, *args): PyTango.Device_4Impl.__init__(self, *args) self.__ImageMode = { 'FRAME TRANSFER': FrelonAcq.FTM, 'FULL FRAME': FrelonAcq.FFM } self.__RoiMode = { 'NONE': FrelonAcq.None, 'SLOW': FrelonAcq.Slow, 'FAST': FrelonAcq.Fast, 'KINETIC': FrelonAcq.Kinetic } self.__InputChannel = { '1': 0x1, '2': 0x2, '3': 0x4, '4': 0x8, '1-2': 0x3, '3-4': 0xc, '1-3': 0x5, '2-4': 0xA, '1-2-3-4': 0xf } self.__E2VCorrection = {'ON': True, 'OFF': False} self.__Spb2Config = {'PRECISION': 0, 'SPEED': 1} self.__Attribute2FunctionBase = { 'image_mode': 'FrameTransferMode', 'input_channel': 'InputChan', 'e2v_correction': 'E2VCorrectionActive', 'spb2_config': 'SPB2Config' } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) self.get_device_properties(self.get_device_class()) self.ResetLinkWaitTime = 5 @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name) def __getattr__(self, name): return get_attr_4u(self, name, _FrelonAcq) @Core.DEB_MEMBER_FUNCT def execSerialCommand(self, command_string): return _FrelonAcq.execFrelonSerialCmd(command_string) @Core.DEB_MEMBER_FUNCT def resetLink(self): _FrelonAcq.getEspiaDev().resetLink() time.sleep(self.ResetLinkWaitTime) ## @brief read the espia board id # def read_espia_dev_nb(self, attr): espia_dev_nb = 0 if self.espia_dev_nb: espia_dev_nb = self.espia_dev_nb attr.set_value(espia_dev_nb) def read_roi_bin_offset(self, attr): roi_bin_offset = _FrelonAcq.getRoiBinOffset() attr.set_value(roi_bin_offset.y) def write_roi_bin_offset(self, attr): roi_bin_offset = Core.Point(0, attr.get_write_value()) _FrelonAcq.setRoiBinOffset(roi_bin_offset)
class FrelonTacoProxy: Core.DEB_CLASS(Core.DebModApplication, 'FrelonTacoProxy') @Core.DEB_MEMBER_FUNCT def DevCcdGetType(self): model = _FrelonAcq.getCameraModel() type_nb = ((model.getAdcBits() == 16) and 2016) or 2014 deb.Return('Getting type: %s' % type_nb) return type_nb @Core.DEB_MEMBER_FUNCT def DevCcdGetLstErrMsg(self): err_msg = '' deb.Return('Getting last err. msg: %s' % err_msg) return err_msg @Core.DEB_MEMBER_FUNCT def DevCcdSetChannel(self, input_chan): _FrelonAcq.setInputChan(input_chan) @Core.DEB_MEMBER_FUNCT def DevCcdGetChannel(self): return _FrelonAcq.getInputChan() @Core.DEB_MEMBER_FUNCT def DevCcdSetHwPar(self, hw_par_str): hw_par = map(int, string.split(hw_par_str)) deb.Param('Setting hw par: %s' % hw_par) kin_win_size, kin_line_beg, kin_stripes = self.getKinPars() flip_mode, kin_line_beg, kin_stripes, d0, roi_mode_int = hw_par flip = Core.Flip(flip_mode >> 1, flip_mode & 1) _FrelonAcq.setFlip(flip) roi_mode = FrelonAcq.RoiMode(roi_mode_int) _FrelonAcq.setRoiMode(roi_mode) if roi_mode == FrelonAcq.Kinetic: max_frame_dim = _FrelonAcq.getFrameDim(max_dim=True) frame_height = max_frame_dim.getSize().getHeight() if kin_line_beg + kin_win_size > frame_height: kin_win_size = frame_height - kin_line_beg bin_y = _FrelonAcq.getBin().getY() kin_win_size = (kin_win_size / bin_y) * bin_y deb.Trace('Re-adjusting kin_win_size to %d to fit chip' % kin_win_size) self.setKinPars(kin_win_size, kin_line_beg, kin_stripes) else: deb.Warning('Ingoring Kinetic parameters') @Core.DEB_MEMBER_FUNCT def DevCcdGetHwPar(self): flip = _FrelonAcq.getFlip() flip_mode = flip.x << 1 | flip.y roi_mode = _FrelonAcq.getRoiMode() kin_win_size, kin_line_beg, kin_stripes = self.getKinPars() hw_par = [flip_mode, kin_line_beg, kin_stripes, 0, roi_mode] deb.Return('Getting hw par: %s' % hw_par) hw_par_str = string.join(map(str, hw_par)) return hw_par_str @Core.DEB_MEMBER_FUNCT def DevCcdSetKinetics(self, kinetics): deb.Param('Setting the profile: %s' % kinetics) if kinetics == 0: ftm = FrelonAcq.FFM elif kinetics == 3: ftm = FrelonAcq.FTM else: raise Core.Exception, 'Invalid profile value: %s' % kinetics _FrelonAcq.setFrameTransferMode(ftm) @Core.DEB_MEMBER_FUNCT def DevCcdGetKinetics(self): ftm = _FrelonAcq.getFrameTransferMode() if ftm == FrelonAcq.FTM: kinetics = 3 else: kinetics = 0 deb.Return('Getting the profile: %s' % kinetics) return kinetics @Core.DEB_MEMBER_FUNCT def DevCcdSetKinWinSize(self, kin_win_size): deb.Param('Setting the kinetics window size: %s' % kin_win_size) prev_win_size, kin_line_beg, kin_stripes = self.getKinPars() self.setKinPars(kin_win_size, kin_line_beg, kin_stripes) @Core.DEB_MEMBER_FUNCT def DevCcdGetKinWinSize(self): kin_win_size, kin_line_beg, kin_stripes = self.getKinPars() deb.Return('Getting the kinetics window size: %s' % kin_win_size) return kin_win_size @Core.DEB_MEMBER_FUNCT def setKinPars(self, kin_win_size, kin_line_beg, kin_stripes): deb.Param('Setting kin pars: ' + 'kin_win_size=%s, kin_line_beg=%s, kin_stripes=%s' % \ (kin_win_size, kin_line_beg, kin_stripes)) if kin_stripes > 1: deb.Warning('Ignoring kin_stripes=%d' % kin_stripes) bin = _FrelonAcq.getBin() if kin_win_size % bin.getY() != 0: msg = 'Invalid kinetics window size (%d): ' % kin_win_size + \ 'must be multiple of vert. bin (%d)' % bin.getY() raise Core.Exception, msg roi = _FrelonAcq.getRoi() roi = roi.getUnbinned(bin) tl = Core.Point(roi.getTopLeft().x, kin_line_beg) size = Core.Size(roi.getSize().getWidth(), kin_win_size) roi = Core.Roi(tl, size) roi = roi.getBinned(bin) _FrelonAcq.setRoi(roi) _FrelonAcq.setRoiLineBegin(kin_line_beg) @Core.DEB_MEMBER_FUNCT def getKinPars(self): bin = _FrelonAcq.getBin() roi = _FrelonAcq.getRoi() roi = roi.getUnbinned(bin) kin_win_size = roi.getSize().getHeight() kin_line_beg = _FrelonAcq.getRoiLineBegin() kin_stripes = 1 deb.Return('Getting kin pars: ' + 'kin_win_size=%s, kin_line_beg=%s, kin_stripes=%s' % \ (kin_win_size, kin_line_beg, kin_stripes)) return kin_win_size, kin_line_beg, kin_stripes @Core.DEB_MEMBER_FUNCT def DevCcdCommand(self, cmd): return _FrelonAcq.execFrelonSerialCmd(cmd) @Core.DEB_MEMBER_FUNCT def DevCcdGetChanges(self): changes = 0 deb.Trace('Getting changes: %s' % changes) return changes @Core.DEB_MEMBER_FUNCT def getAutoResetCtStatus(self): return True
class TestControl: Core.DEB_CLASS(Core.DebModTest, 'TestControl') class ImageStatusCallback(Core.CtControl.ImageStatusCallback): def __init__(self, test_control, cb_end): Core.CtControl.ImageStatusCallback.__init__(self) self.test_control = weakref.ref(test_control) self.cb_end = cb_end def imageStatusChanged(self, image_status): test_control = self.test_control() if not test_control: return self.cb_end.clear() test_control.imageStatusChanged(image_status) del test_control self.cb_end.set() @Core.DEB_MEMBER_FUNCT def __init__(self): self.simu = Simulator.Camera() self.simu_hw = Simulator.Interface(self.simu) self.ct_control = Core.CtControl(self.simu_hw) self.cb_end = threading.Event() self.cb = self.ImageStatusCallback(self, self.cb_end) self.ct_control.registerImageStatusCallback(self.cb) @Core.DEB_MEMBER_FUNCT def __del__(self): del self.ct_control del self.simu_hw @Core.DEB_MEMBER_FUNCT def start(self, exp_time, nb_frames, prepare_timeout, sleep_time): ct_acq = self.ct_control.acquisition() ct_acq.setAcqExpoTime(exp_time) ct_acq.setAcqNbFrames(nb_frames) self.sleep_time = sleep_time if hasattr(self.ct_control, 'setPrepareTimeout'): self.ct_control.setPrepareTimeout(prepare_timeout) self.ct_control.prepareAcq() deb.Always('prepareAcq finished') self.ct_control.startAcq() @Core.DEB_MEMBER_FUNCT def waitAcq(self): def acq_status(): return self.ct_control.getStatus().AcquisitionStatus while acq_status() == Core.AcqRunning: time.sleep(10e-3) deb.Always('Acq. is ready') @Core.DEB_MEMBER_FUNCT def sync(self): self.waitAcq() self.cb_end.wait() @Core.DEB_MEMBER_FUNCT def imageStatusChanged(self, img_status): last_img_ready = img_status.LastImageReady if last_img_ready < 0: return image = self.ct_control.ReadImage(last_img_ready) time.sleep(self.sleep_time) deb.Always('Forcing read frame %d memory' % last_img_ready) data = b' ' + image.buffer.tostring()
class Andor3(PyTango.Device_4Impl): #--------- Add you global variables here -------------------------- Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs') #------------------------------------------------------------------ # Device constructor #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def __init__(self,cl, name): PyTango.Device_4Impl.__init__(self,cl,name) # dictionnaries to be used with AttrHelper.get_attr_4u self.__AdcGain = {'b11_hi_gain': _Andor3Camera.b11_hi_gain, 'b11_low_gain': _Andor3Camera.b11_low_gain, 'b16_lh_gain': _Andor3Camera.b16_lh_gain, } self.__AdcRate = {'MHZ10': _Andor3Camera.MHz10, 'MHZ100': _Andor3Camera.MHz100, 'MHZ200': _Andor3Camera.MHz200, 'MHZ280': _Andor3Camera.MHz280, } self.__Cooler = {'ON': True, 'OFF': False} self.__FanSpeed = {'OFF': _Andor3Camera.Off, 'LOW': _Andor3Camera.Low, 'HIGH': _Andor3Camera.On, } self.__ElectronicShutterMode = {'ROLLING': _Andor3Camera.Rolling, 'GLOBAL': _Andor3Camera.Global, } self.__DestrideActive = {'YES': True, 'NO': False} self.__Attribute2FunctionBase = {'adc_gain': 'SimpleGain', 'adc_rate': 'AdcRate', 'temperature': 'Temperature', 'temperature_sp': 'TemperatureSP', 'cooler': 'Cooler', 'cooling_status': 'CoolingStatus', 'fan_speed': 'FanSpeed', 'electronic_shutter_mode': 'ElectronicShutterMode', 'destride_active': 'DestrideActive', 'frame_rate': 'FrameRate', 'max_frame_rate_transfer': 'MaxFrameRateTransfer', 'readout_time': 'ReadoutTime', } self.init_device() #------------------------------------------------------------------ # Device destructor #------------------------------------------------------------------ def delete_device(self): pass #------------------------------------------------------------------ # Device initialization #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def init_device(self): self.set_state(PyTango.DevState.ON) # Load the properties self.get_device_properties(self.get_device_class()) # Apply properties if any if self.adc_gain: _Andor3Interface.setAdcGain(self.__AdcGain[self.adc_gain]) if self.adc_rate: _Andor3Interface.setAdcRate(self.__AdcRate[self.adc_rate]) if self.temperature_sp: _Andor3Camera.setTemperatureSP(self.temperature_sp) if self.cooler: _Andor3Camera.setCooler(self.__Cooler[self.cooler]) #================================================================== # # Andor3 read/write attribute methods # #================================================================== def __getattr__(self,name) : try: return get_attr_4u(self, name, _Andor3Interface) except: return get_attr_4u(self, name, _Andor3Camera) #================================================================== # # Andor3 command methods # #================================================================== #------------------------------------------------------------------ # getAttrStringValueList command: # # Description: return a list of authorized values if any # argout: DevVarStringArray #------------------------------------------------------------------ @Core.DEB_MEMBER_FUNCT def getAttrStringValueList(self, attr_name): return get_attr_string_value_list(self, attr_name)
class Andor3(PyTango.Device_4Impl): Core.DEB_CLASS(Core.DebModApplication, 'LimaCCDs')