def __init__(self, espia_dev_nb, use_events=False, print_time=1,
sleep_time=0, all_frames=False):
self.m_edev = Espia.Dev(espia_dev_nb)
self.m_acq = Espia.Acq(self.m_edev)
self.m_buffer_cb_mgr = Espia.BufferMgr(self.m_acq)
self.m_eserline = Espia.SerialLine(self.m_edev)
self.m_cam = Frelon.Camera(self.m_eserline)
self.m_buffer_mgr = Core.BufferCtrlMgr(self.m_buffer_cb_mgr)
self.m_hw_inter = Frelon.Interface(self.m_acq,
self.m_buffer_mgr,
self.m_cam)
self.m_acq_state = Core.AcqState()
self.m_ct = Core.CtControl(self.m_hw_inter)
self.m_ct_acq = self.m_ct.acquisition()
self.m_ct_saving = self.m_ct.saving()
self.m_ct_image = self.m_ct.image()
self.m_ct_buffer = self.m_ct.buffer()
self.m_ct_display = self.m_ct.display()
self.m_use_events = use_events
self.m_print_time = print_time
self.m_sleep_time = sleep_time
if self.m_use_events:
cb = ImageStatusCallback(self.m_ct, self.m_acq_state, print_time,
sleep_time, all_frames)
self.m_img_status_cb = cb
self.m_ct.registerImageStatusCallback(self.m_img_status_cb)
self.m_ct_display.setNames('_ccd_ds_', 'frelon_live')
self.m_ct_display.setActive(True)
def __init__(self,
config_fname,
use_events=False,
print_time=1,
sleep_time=0,
all_frames=False):
self.m_cam = SlsDetector.Camera(config_fname)
self.m_hw_inter = SlsDetector.Interface(self.m_cam)
self.m_acq_state = Core.AcqState()
self.m_corr = None
if self.m_cam.getType() == SlsDetector.EigerDet:
self.m_eiger = SlsDetector.Eiger(self.m_cam)
self.m_corr = self.m_eiger.createCorrectionTask()
else:
deb.Warning("Non-supported type: %s" % self.m_cam.getType())
self.m_ct = Core.CtControl(self.m_hw_inter)
self.m_ct_acq = self.m_ct.acquisition()
self.m_ct_saving = self.m_ct.saving()
self.m_ct_image = self.m_ct.image()
self.m_ct_buffer = self.m_ct.buffer()
self.m_use_events = use_events
self.m_print_time = print_time
self.m_sleep_time = sleep_time
if self.m_corr:
self.m_ct.setReconstructionTask(self.m_corr)
if self.m_use_events:
cb = ImageStatusCallback(self.m_ct, self.m_acq_state, print_time,
sleep_time, all_frames)
self.m_img_status_cb = cb
self.m_ct.registerImageStatusCallback(self.m_img_status_cb)
def test_frelon_acc(enable_debug, espia_dev_nb, vert_bin, exp_time,
acc_max_exp_time, nb_frames, acc_time_mode):
if enable_debug:
Core.DebParams.enableModuleFlags(Core.DebParams.AllFlags)
Core.DebParams.enableTypeFlags(Core.DebParams.AllFlags)
else:
Core.DebParams.disableModuleFlags(Core.DebParams.AllFlags)
deb.Always("Creating FrelonAcq")
acq = Frelon.FrelonAcq(espia_dev_nb)
deb.Trace("Done!")
cam = acq.getFrelonCamera()
ct = acq.getGlobalControl()
ct_image = ct.image()
ct_acq = ct.acquisition()
acq_state = Core.AcqState()
status_cb = ImageStatusCallback(ct, acq_state)
ct.registerImageStatusCallback(status_cb)
deb.Always("Setting Full Frame Mode - Speed - Chan 3&4")
cam.setSPB2Config(Frelon.SPB2Speed)
cam.setFrameTransferMode(Frelon.FFM)
cam.setInputChan(Frelon.Chan34)
deb.Trace("Done!")
frame_dim = acq.getFrameDim(max_dim=True)
bin = Core.Bin(1, vert_bin)
deb.Always("Setting binning %s" % bin)
ct_image.setBin(bin)
deb.Trace("Done!")
image_size = frame_dim.getSize()
nb_cols = image_size.getWidth()
nb_lines = image_size.getHeight() / vert_bin
roi = Core.Roi(Core.Point(0, nb_lines - 2), Core.Size(nb_cols, 1))
deb.Always("Setting RoI %s" % roi)
ct_image.setRoi(roi)
deb.Trace("Done!")
deb.Always("Setting Kinetic RoI mode")
cam.setRoiMode(Frelon.Kinetic)
deb.Trace("Done!")
deb.Always("Setting Acc. mode")
ct_acq.setAcqMode(Core.Accumulation)
deb.Trace("Done!")
deb.Always("Setting %s Acc. Time mode" % acc_time_mode)
acc_mode = Core.CtAcquisition.Live \
if acc_time_mode == 'Live' \
else Core.CtAcquisition.Real
ct_acq.setAccTimeMode(acc_mode)
deb.Trace("Done!")
deb.Always("Setting Acc. max. exp. time %s" % acc_max_exp_time)
ct_acq.setAccMaxExpoTime(acc_max_exp_time)
deb.Trace("Done!")
deb.Always("Setting exp. time %s" % exp_time)
ct_acq.setAcqExpoTime(exp_time)
deb.Trace("Done!")
deb.Always("Setting nb. frames %s" % nb_frames)
ct_acq.setAcqNbFrames(nb_frames)
deb.Trace("Done!")
acc_nb_frames = ct_acq.getAccNbFrames()
acc_dead_time = ct_acq.getAccDeadTime()
acc_live_time = ct_acq.getAccLiveTime()
deb.Always("AccNbFrames: %d, AccDeadTime: %.6f, AccLiveTime: %.6f" %
(acc_nb_frames, acc_dead_time, acc_live_time))
deb.Always("Preparing acq.")
ct.prepareAcq()
deb.Trace("Done!")
deb.Always("Starting acq.")
status_cb.start()
ct.startAcq()
deb.Trace("Done!")
state_mask = Core.AcqState.Acquiring
acq_state.waitNot(state_mask)
deb.Always("Finished!")
dead_time = cam.getDeadTime()
read_time = cam.getReadoutTime()
xfer_time = cam.getTransferTime()
deb.Always("Dead Time: %.6f, Readout Time: %.6f, Transfer Time: %.6f" %
(dead_time, read_time, xfer_time))
def main(argv):
deb.Always("Creating Espia.Dev")
edev = Espia.Dev(0)
deb.Always("Creating Espia.Acq")
acq = Espia.Acq(edev)
acqstat = acq.getStatus()
deb.Always("Whether the Acquisition is running : %s" % acqstat.running)
deb.Always("Creating Espia.BufferMgr")
buffer_cb_mgr = Espia.BufferMgr(acq)
deb.Always("Creating BufferCtrlMgr")
buffer_mgr = Core.BufferCtrlMgr(buffer_cb_mgr)
deb.Always("Creating Espia.SerialLine")
eser_line = Espia.SerialLine(edev)
deb.Always("Creating Frelon.Camera")
cam = Frelon.Camera(eser_line)
deb.Always("Creating the Hw Interface ... ")
hw_inter = Frelon.Interface(acq, buffer_mgr, cam)
deb.Always("Creating HW BufferSave")
buffer_save = Core.HwBufferSave(Core.HwBufferSave.EDF, "img", 0, ".edf",
True, 1)
deb.Always("Getting HW detector info")
hw_det_info = hw_inter.getHwCtrlObj(Core.HwCap.DetInfo)
deb.Always("Getting HW buffer")
hw_buffer = hw_inter.getHwCtrlObj(Core.HwCap.Buffer)
deb.Always("Getting HW Sync")
hw_sync = hw_inter.getHwCtrlObj(Core.HwCap.Sync)
deb.Always("Getting HW Bin")
hw_bin = hw_inter.getHwCtrlObj(Core.HwCap.Bin)
deb.Always("Getting HW RoI")
hw_roi = hw_inter.getHwCtrlObj(Core.HwCap.Roi)
mis_cb = MaxImageSizeCallback()
hw_det_info.registerMaxImageSizeCallback(mis_cb)
deb.Always("Setting FTM")
cam.setFrameTransferMode(Frelon.FTM)
deb.Always("Setting FFM")
cam.setFrameTransferMode(Frelon.FFM)
soft_roi = Core.Roi()
acq_state = Core.AcqState()
deb.Always("Creating a TestFrameCallback")
cb = TestFrameCallback(hw_inter, soft_roi, buffer_save, acq_state)
do_reset = False
if do_reset:
deb.Always("Reseting hardware ...")
hw_inter.reset(HwInterface.HardReset)
deb.Always(" Done!")
size = hw_det_info.getMaxImageSize()
image_type = hw_det_info.getCurrImageType()
frame_dim = Core.FrameDim(size, image_type)
bin = Core.Bin(Core.Point(1))
hw_bin.setBin(bin)
#Roi set_roi, real_roi;
#set_hw_roi(hw_roi, set_roi, real_roi, soft_roi);
effect_frame_dim = Core.FrameDim(frame_dim) # was (frame_dim / bin)
hw_buffer.setFrameDim(effect_frame_dim)
hw_buffer.setNbBuffers(10)
hw_buffer.registerFrameCallback(cb)
hw_sync.setExpTime(2)
hw_sync.setNbFrames(3)
deb.Always("Starting Acquisition")
acq_state.set(Core.AcqState.Acquiring)
hw_inter.startAcq()
deb.Always("Waiting acq finished...")
acq_state.waitNot(Core.AcqState.Acquiring)
deb.Always("Acq finished!!")
deb.Always("Stopping Acquisition")
hw_inter.stopAcq()
deb.Always("This is the End...")
