def DevReadValues(self):
control = _control_ref()
img_data = control.ReadImage(-1)
self.__bpm_task.process(img_data)
release = getattr(img_data, 'releaseBuffer', None)
if release:
release()
bpm_pars = self.__bpm_mgr.getResult(1)
if bpm_pars.errorCode != self.__bpm_mgr.OK:
raise Core.Exception('Error calculating beam params: %d' %
bpm_pars.errorCode)
nr_spots = 1
auto_cal = -1
exp_time = self.DevCcdGetExposure()
if exp_time > 0:
norm_intensity = bpm_pars.beam_intensity / exp_time
else:
norm_intensity = 0
return [
nr_spots, bpm_pars.beam_intensity, bpm_pars.beam_center_x,
bpm_pars.beam_center_y, bpm_pars.beam_fwhm_x, bpm_pars.beam_fwhm_y,
bpm_pars.AOI_max_x - bpm_pars.AOI_min_x,
bpm_pars.AOI_max_y - bpm_pars.AOI_min_y, bpm_pars.max_pixel_value,
bpm_pars.max_pixel_x, bpm_pars.max_pixel_y, bpm_pars.AOI_min_x,
bpm_pars.AOI_min_y, bpm_pars.AOI_max_x, bpm_pars.AOI_max_y,
bpm_pars.beam_center_x - bpm_pars.beam_fwhm_x / 2,
bpm_pars.beam_center_y - bpm_pars.beam_fwhm_y / 2,
bpm_pars.beam_center_x + bpm_pars.beam_fwhm_x / 2,
bpm_pars.beam_center_y + bpm_pars.beam_fwhm_y / 2, norm_intensity,
auto_cal
]
def setTmpfsSize(self, new_size):
det_info = self.__det_info()
imageFormat = det_info.getMaxImageSize()
imageSize = imageFormat.getWidth() * imageFormat.getHeight(
) * 2 # 2 == image 16bits
if new_size * 0.8 < imageSize: # 80% occupancy
raise Core.Exception(Core.Hardware, Core.InvalidValue)
self.__tmpfs_size = new_size
def DevCcdSetKinetics(self, kinetics):
deb.Param('Setting the profile: %s' % kinetics)
if kinetics == 0:
ftm = FrelonHw.FFM
elif kinetics == 3:
ftm = FrelonHw.FTM
else:
raise Core.Exception('Invalid profile value: %s' % kinetics)
_FrelonAcq.getFrelonCamera().setFrameTransferMode(ftm)
def DevCcdRead(self, frame_data):
frame_nb, frame_size = frame_data
deb.Param('frame_nb=%s, frame_size=%s' % (frame_nb, frame_size))
control = _control_ref()
data = control.ReadImage(int(frame_nb))
self._data_cache = numpy.array(data.buffer.ravel())
self._data_cache.dtype = numpy.uint8
release = getattr(data, 'releaseBuffer', None)
if release:
release()
if self._data_cache.shape[0] != frame_size:
raise Core.Exception(('Client expects %d bytes, frame has %d' %
(frame_size, self._data_cache.shape[0])))
return self._data_cache
def setAcqMode(self, stripe_concat, frame_accum):
deb.Param('Setting acq. mode: stripe_concat=%s, frame_accum=%s' %
(stripe_concat, frame_accum))
if not stripe_concat and not frame_accum:
acq_mode = Core.Single
elif stripe_concat and not frame_accum:
acq_mode = Core.Concatenation
elif not stripe_concat and frame_accum:
acq_mode = Core.Accumulation
else:
err_msg = ('Invalid acq. mode: stripe_concat=%s, frame_accum=%s' %
(stripe_concat, frame_accum))
raise Core.Exception(err_msg)
control = _control_ref()
acq = control.acquisition()
acq.setAcqMode(acq_mode)
def DevCcdGetTrigger(self):
control = _control_ref()
acquisition = control.acquisition()
triggerMode = acquisition.getTriggerMode()
if triggerMode == Core.IntTrig:
returnValue = 0
elif triggerMode == Core.ExtTrigSingle or triggerMode == Core.ExtGate:
returnValue = 1
elif triggerMode == Core.ExtTrigMult:
returnValue = 2
elif triggerMode == Core.ExtStartStop:
returnValue = 3
elif triggerMode == Core.ExtTrigReadout:
returnValue = 4
else:
raise Core.Exception('Invalid trigger mode: %s' % triggerMode)
return returnValue
def TacoState(self):
state = self.State()
if state == PyTango.DevState.OFF:
taco_state = DevCcdReady
elif state == PyTango.DevState.ON:
taco_state = DevCcdAcquiring
else:
control = _control_ref()
ct_status = control.getStatus()
msg = 'Acquisition error: %s' % ct_status
end = msg.index(', ImageCounters')
msg = msg[:end] + '>'
if self.AutoResetCtStatus:
control.resetStatus(True)
raise Core.Exception(msg)
deb.Return('TACO state: 0x%08x (%d)' % (taco_state, taco_state))
return taco_state
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 = self.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)
def DevCcdSetTrigger(self, argin):
control = _control_ref()
acquisition = control.acquisition()
triggerMode = None
if argin == 0:
triggerMode = Core.IntTrig
elif argin == 1:
triggerMode = Core.ExtTrigSingle
if self.__last_exp_time is not None:
if self.__last_exp_time == 0:
triggerMode = Core.ExtGate
elif argin == 2:
triggerMode = Core.ExtTrigMult
elif argin == 3:
triggerMode = Core.ExtStartStop
elif argin == 4:
triggerMode = Core.ExtTrigReadout
else:
raise Core.Exception('Invalid ext. trig: %s' % argin)
acquisition.setTriggerMode(triggerMode)
def getDefImageType(self) :
"""Default data type of image"""
if self.__bpp == 16:
return Core.Bpp16
else:
raise Core.Exception(Core.Hardware,Core.NotSupported)
def DevCcdReadAll(self, frame_size):
deb.Param('frame_size=%s' % frame_size)
frame_dim = self.__getFrameDim()
nb_frames = frame_size / frame_dim.getMemSize()
control = _control_ref()
image = control.image()
image_type = image.getImageType()
da_type = self.ImageType2DataArrayType.get(image_type, "?")
image_size = frame_dim.getSize()
da_size = [image_size.getWidth(), image_size.getHeight() * nb_frames]
# The DATA_ARRAY definition
#struct {
#unsigned int Magic= 0x44544159;
#unsigned short Version;
#unsigned short HeaderLength;
#DataArrayCategory Category;
#DataArrayType DataType;
#unsigned short DataEndianness;
#unsigned short NbDim;
#unsigned short Dim[8]
#unsigned int DimStep[8]
#} DataArrayHeaderStruct;
#enum DataArrayCategory {
#ScalarStack = 0;
#Spectrum;
#Image;
#SpectrumStack;
#ImageStack;
#};
#enum DataArrayType{
#DARRAY_UINT8 = 0;
#DARRAY_UINT16;
#DARRAY_UINT32;
#DARRAY_UINT64;
#DARRAY_INT8;
#DARRAY_INT16;
#DARRAY_INT32;
#DARRAY_INT64;
#DARRAY_FLOAT32;
#DARRAY_FLOAT64;
#};
#prepare the structure
# '>IHHHHHHHHHHHHHHIIIIIIII',
header_len = 64
data_header = struct.pack(
'IHHIIHHHHHHHHHHHHHHHHHHIII',
0x44544159, # 4bytes I - magic number
1, # 2bytes H - version
header_len, # 2 bytes H - this header size
2, # 4 bytes I - category (enum)
da_type, # 4 bytes I - data type (enum)
0, # 2 bytes H - endianness
2, # 2 bytes H - nb of dims
da_size[0],
da_size[1],
0,
0,
0,
0,
0,
0, # 16 bytes Hx8 - dims
1,
da_size[1],
0,
0,
0,
0,
0,
0, # 16 bytes H x 8 - dimsteps
0,
0,
0) # padding 3 x 4 bytes
if len(data_header) != header_len:
msg = ('Invalid DevEncoded DATA_ARRAY len: %d (expected %d)' %
(len(data_header), header_len))
raise Core.Exception(msg)
concat_frames = control.ReadImage(0, nb_frames)
self._concat_data_cache = data_header + concat_frames.buffer.tostring()
da_len = len(self._concat_data_cache) - header_len
release = getattr(concat_frames, 'releaseBuffer', None)
if release:
release()
if da_len != frame_size:
raise Core.Exception(('Client expects %d bytes, frame has %d' %
(frame_size, da_len)))
return ('DATA_ARRAY', self._concat_data_cache)
def dummy(self, *args):
raise Core.Exception('Taco command not supported for this camera')
def setNbConcatFrames(self, nb_concat_frames):
if nb_concat_frames != 1:
raise Core.Exception(Core.Hardware, Core.NotSupported)
def DevCcdSetMultTrigNbFrames(self, nb_frames):
deb.Param('Setting mult-trig nb_frames: %d' % nb_frames)
if nb_frames < 1:
raise Core.Exception('Invalid nb_frames=%d' % nb_frames)
self.__mult_trig_data = dict(nb_frames=nb_frames, state='Ready',
last_frame=-1)
def setCurrImageType(self, ImgType):
if ImgType == Core.Bpp16 or ImgType == Core.Bpp32:
self.__ImgType = ImgType
else:
raise Core.Exception(Core.Hardware, Core.NotSupported)
