def Init(self):
self.cam = pco.Camera(debuglevel=self._debuglevel)
self.SetDescription()
self._mode = self.MODE_CONTINUOUS
self.SetHotPixelCorrectionMode('off')
self.buffer_size = 0
self.n_read = 0
self.initalized = True
self._roi = None
self.SetROI(1, 1, self.GetCCDWidth(), self.GetCCDHeight())
self._ccd_temp = 0 # Store the sensor temperature
self._cycle_time = 0
self.recording = False
def Init(self):
self.cam = pco.Camera(debuglevel=self._debuglevel)
self.SetDescription()
self._mode = self.MODE_CONTINUOUS
self.SetHotPixelCorrectionMode('off')
self.buffer_size = 0
self.n_read = 0
self.initalized = True
self._roi = None
self.SetROI(1, 1, self.GetCCDWidth(), self.GetCCDHeight())
self._ccd_temp = 0
self._ccd_temp_set_point = 0
self._electr_temp = 0
self._cycle_time = 0
self._integ_time = 0
self._binning_x = 0
self._binning_y = 0
self.recording = False
def open_camera(self):
import pco
self.cam = pco.Camera() # no logging
# self.cam = pco.Camera(debuglevel='verbose', timestamp='on')
self.cam.sdk.set_cmos_line_timing(
'on', self.cfg.camera_parameters['line_interval']) # 75 us delay
self.cam.set_exposure_time(self.cfg.camera_parameters['exp_time'])
# self.cam.sdk.set_cmos_line_exposure_delay(80, 0) # 266 lines = 20 ms / 75 us
self.cam.configuration = {
'trigger': self.cfg.camera_parameters['trigger']
}
line_time = self.cam.sdk.get_cmos_line_timing()['line time']
lines_exposure = self.cam.sdk.get_cmos_line_exposure_delay(
)['lines exposure']
t = self.cam.get_exposure_time()
#print('Exposure Time: {:9.6f} s'.format(t))
#print('Line Time: {:9.6f} s'.format(line_time))
#print('Number of Lines: {:d}'.format(lines_exposure))
self.cam.record(number_of_images=4, mode='fifo')
def pco_camera_child_process(
data_buffers,
buffer_shape,
input_queue,
output_queue,
commands,
):
"""For use with image_data_pipeline.py
https://github.com/AndrewGYork/tools/blob/master/image_data_pipeline.py
Debugged for the edge 4.2, less so for the edge 5.5, pixelfly and panda 4.2.
"""
from image_data_pipeline import info, Q, sleep, clock
try:
import pco
except ImportError:
info("Failed to import pco.py; go get it from github:")
info("https://github.com/AndrewGYork/tools/blob/master/pco.py")
raise
buffer_size = np.prod(buffer_shape)
info("Initializing...")
camera = pco.Camera(verbose=False)
camera.apply_settings(trigger='auto_trigger')
camera.arm(num_buffers=3)
info("Done initializing")
preframes = 3
first_trigger_timeout_seconds = 0
status = 'Normal'
while True:
if commands.poll():
cmd, args = commands.recv()
info("Command received: " + cmd)
if cmd == 'apply_settings':
result = camera.apply_settings(**args)
camera.arm(num_buffers=3)
commands.send(result)
elif cmd == 'get_setting':
setting = getattr(
camera, args['setting'], 'unrecognized_setting')
commands.send(setting)
elif cmd == 'set_buffer_shape':
buffer_shape = args['shape']
buffer_size = np.prod(buffer_shape)
commands.send(buffer_shape)
elif cmd == 'get_status':
commands.send(status)
elif cmd == 'reset_status':
status = 'Normal'
commands.send(status)
elif cmd == 'get_preframes':
commands.send(preframes)
elif cmd == 'set_preframes':
preframes = args['preframes']
commands.send(preframes)
elif cmd == 'get_first_trigger_timeout_seconds':
commands.send(first_trigger_timeout_seconds)
elif cmd == 'set_first_trigger_timeout_seconds':
first_trigger_timeout_seconds = args[
'first_trigger_timeout_seconds']
commands.send(first_trigger_timeout_seconds)
elif cmd == 'force_trigger':
result = camera._force_trigger()
commands.send(result)
else:
info("Unrecognized command: " + cmd)
commands.send("unrecognized_command")
continue
try:
permission_slip = input_queue.get_nowait()
except Q.Empty:
sleep(0.001) #Non-deterministic sleep time :(
continue
if permission_slip is None: #This is how we signal "shut down"
output_queue.put(permission_slip)
break #We're done
else:
# Fill the data buffer with images from the camera
time_received = clock()
process_me = permission_slip['which_buffer']
## Trust IDP to request a legal num_slices
num_slices = permission_slip.get('num_slices', buffer_shape[0])
info("start buffer %i, acquiring %i frames and %i preframes"%(
process_me, num_slices, preframes))
with data_buffers[process_me].get_lock():
a = np.frombuffer(
data_buffers[process_me].get_obj(),
dtype=np.uint16)[:buffer_size].reshape(buffer_shape
)[:num_slices, :, :]
try:
camera.record_to_memory(
num_images=a.shape[0] + preframes,
preframes=preframes,
out=a,
first_trigger_timeout_seconds=(
first_trigger_timeout_seconds))
except pco.TimeoutError as e:
info('TimeoutError: %s'%(e.value))
status = 'TimeoutError'
#FIXME: we can do better, probably. Keep trying?
#Should we zero the remainder of 'a'?
except pco.DMAError:
info('DMAError')
status = 'DMAError'
else:
status = 'Normal'
info("end buffer %i, %06f seconds elapsed"%(
process_me, clock() - time_received))
output_queue.put(permission_slip)
camera.close()
return None
import pco
from pco import sdk
import matplotlib.pyplot as plt
with pco.Camera() as cam:
shutter_mode = cam.sdk.get_camera_setup()
print('shutter_mode:')
print(shutter_mode)
cam.record(number_of_images=5, mode='ring buffer')
images, metadatas = cam.images()
for image in images:
plt.imshow(image, cmap='gray')
plt.show()
cam.stop(
) #automatically called if record mode is 'sequence' or 'sequence non blocking'
cam.close(
) #automatically called with statement 'with pco.Camera() as cam:'
def __init__(self, parent=None):
super(scope, self).__init__()
self.delay = 0.02 # delay in loops (StackExt)
self.handleA = None
self.handleB = None
self.QUIT = False
self.stackparams = {
'Date/Time': 0,
'X': 0,
'Y': 0,
'Z1': 0,
'Z2': 0,
'Zstep': 0,
'Exposure(s)': 0,
'CCD Temperature': 0,
'Pixel Size(nm)': 89,
'CCD setting': '',
'User': ''
}
# camera
self.ccd = pyAndor_P35_a.ccd()
self.ccd.CoolerON()
self.ccd.SetCoolerMode(COOLER_MODE)
self.ccd.SetTemperature(TEMPERATURE_SETPOINT)
self.data = N.zeros(self.ccd.image_size, dtype=N.uint16)
# pco camera
self.cam = pco.Camera()
self.number_of_images = 4
self.cam.sdk.set_trigger_mode('external exposure control')
# piezo
self.zst = zstage.zstage()
self.zst.setPositionf(50)
self.zpos = 0
# Filter wheel
# self.fw = filterWheel.filter_wheel()
# motorized polarizer
print('Initializing Polarizer')
self.pol = mp2.A8MRU()
self.pol.MotorOn()
self.pol.setSpeed(5000, 1)
# self.pol_array = N.array([0.,0.,0.,60.,60.,60.,30.,30.,30.]) #2D
self.pol_array = N.array([52., 102., 0.]) #3D
print(self.pol.getState())
# priorxy
self.prior = priorxyP35.prior()
self.xpos = 0
self.ypos = 0
self.prior.limits = [-10000, 10000, -10000, 10000]
#DM
self.serialName = 'BAX228'
self.dm = DM(self.serialName)
# qxga
qx.initiate()
# qx.open_usb_port()
self.l = 0
self.k = 0
# Coherent laser
try:
self.ll647 = Coherent_P33.obis('COM6')
self.ll647.SetDigitalModMode()
self.ll647.SetLaserOn()
self.laser647 = True
except:
self.ll647 = None
self.laser647 = False
print('647nm Laser not on') #raise Exception('647nm Laser not on')
try:
self.ll561 = Coherent_P33.obis('COM8')
self.ll561.SetDigitalModMode()
self.ll561.SetLaserOn()
self.laser561 = True
except:
self.ll561 = None
self.laser561 = False
print('561nm Laser not on') #raise Exception('647nm Laser not on')
try:
self.ll405 = Coherent_P33.obis('COM7')
self.ll405.SetLaserOn()
self.ll405.SetDigitalModMode()
self.laser405 = True
except:
self.ll405 = None
self.laser405 = False
print('405nm Laser not on') #raise Exception('405nm Laser not on')
#Attenuator
self.att = attu.attenuate()
#set save path
t = time.localtime()
self.is_videomode = False
dpth = str(int(t[0] * 1e4 + t[1] * 1e2 + t[2])) + '_' + getuser()
self.path = os.path.join(datapath, dpth)
try:
os.mkdir(self.path)
except:
print('Directory already exists')
# defaults
self.coord = (200, 400, 200, 400)
self.Name = 'default'
###
self.Name = 'default'
self.coordVal = self.ccd.GetImageCoordinates()
self.old_Cval = self.ccd.GetImageCoordinates()
