def initServer(self):
self.listeners = set()
self.camera = AndorCamera()
self.camera.set_shutter(0, 1) #turn on shutter
self.camera.set_ADchannel(0)
self.camera.set_HSspeed()
self.camera.set_VSspeed()
self.camera.set_preamp(2) #set pre amp gain to 2
self.camera.set_emccd_gain(1)
print self.camera.get_preamp()
self.lock = DeferredLock()
self.gui = AndorVideo(self)
def initServer(self):
self.listeners = set()
self.camera = AndorCamera()
self.lock = DeferredLock()
self.gui = AndorVideo(self)
class AndorServer(LabradServer):
""" Contains methods that interact with the Andor CCD Cameras"""
name = "Andor Server"
def initServer(self):
self.listeners = set()
self.camera = AndorCamera()
self.lock = DeferredLock()
self.gui = AndorVideo(self)
def initContext(self, c):
"""Initialize a new context object."""
self.listeners.add(c.ID)
def expireContext(self, c):
self.listeners.remove(c.ID)
def getOtherListeners(self,c):
notified = self.listeners.copy()
notified.remove(c.ID)
return notified
'''
Temperature Related Settings
'''
@setting(0, "Get Temperature", returns = 'v[degC]')
def get_temperature(self, c):
"""Gets Current Device Temperature"""
temperature = None
print 'acquiring: {}'.format(self.get_temperature.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.get_temperature.__name__)
temperature = yield deferToThread(self.camera.get_temperature)
finally:
print 'releasing: {}'.format(self.get_temperature.__name__)
self.lock.release()
if temperature is not None:
temperature = WithUnit(temperature, 'degC')
returnValue(temperature)
@setting(1, "Get Cooler State", returns = 'b')
def get_cooler_state(self, c):
"""Returns Current Cooler State"""
cooler_state = None
print 'acquiring: {}'.format(self.get_cooler_state.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.get_cooler_state.__name__)
cooler_state = yield deferToThread(self.camera.get_cooler_state)
finally:
print 'releasing: {}'.format(self.get_cooler_state.__name__)
self.lock.release()
if cooler_state is not None:
returnValue(cooler_state)
@setting(3, "Set Temperature", setTemp = 'v[degC]', returns = '')
def set_temperature(self, c, setTemp):
"""Sets The Target Temperature"""
print 'acquiring: {}'.format(self.set_temperature.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.set_temperature.__name__)
yield deferToThread(self.camera.set_temperature, setTemp['degC'])
finally:
print 'releasing: {}'.format(self.set_temperature.__name__)
self.lock.release()
@setting(4, "Set Cooler On", returns = '')
def set_cooler_on(self, c):
"""Turns Cooler On"""
print 'acquiring: {}'.format(self.set_cooler_on.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.set_cooler_on.__name__)
yield deferToThread(self.camera.set_cooler_on)
finally:
print 'releasing: {}'.format(self.set_cooler_on.__name__)
self.lock.release()
@setting(5, "Set Cooler Off", returns = '')
def set_cooler_off(self, c):
"""Turns Cooler On"""
print 'acquiring: {}'.format(self.set_cooler_off.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.set_cooler_off.__name__)
yield deferToThread(self.camera.set_cooler_off)
finally:
print 'releasing: {}'.format(self.set_cooler_off.__name__)
self.lock.release()
'''
EMCCD Gain Settings
'''
@setting(6, "Get EMCCD Gain", returns = 'i')
def getEMCCDGain(self, c):
"""Gets Current EMCCD Gain"""
gain = None
print 'acquiring: {}'.format(self.getEMCCDGain.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.getEMCCDGain.__name__)
gain = yield deferToThread(self.camera.get_emccd_gain)
finally:
print 'releasing: {}'.format(self.getEMCCDGain.__name__)
self.lock.release()
if gain is not None:
returnValue(gain)
@setting(7, "Set EMCCD Gain", gain = 'i', returns = '')
def setEMCCDGain(self, c, gain):
"""Sets Current EMCCD Gain"""
print 'acquiring: {}'.format(self.setEMCCDGain.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setEMCCDGain.__name__)
yield deferToThread(self.camera.set_emccd_gain, gain)
finally:
print 'releasing: {}'.format(self.setEMCCDGain.__name__)
self.lock.release()
if c is not None:
self.gui.set_gain(gain)
'''
Read mode
'''
@setting(8, "Get Read Mode", returns = 's')
def getReadMode(self, c):
return self.camera.get_read_mode()
@setting(9, "Set Read Mode", readMode = 's', returns = '')
def setReadMode(self, c, readMode):
"""Sets Current Read Mode"""
mode = None
print 'acquiring: {}'.format(self.setReadMode.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setReadMode.__name__)
yield deferToThread(self.camera.set_read_mode, readMode)
finally:
print 'releasing: {}'.format(self.setReadMode.__name__)
self.lock.release()
if mode is not None:
returnValue(mode)
'''
Shutter Mode
'''
@setting(100, "get_shutter_mode", returns = 's')
def get_shutter_mode(self, c):
return self.camera.get_shutter_mode()
@setting(101, "set_shutter_mode", shutterMode = 's', returns = '')
def set_shutter_mode(self, c, shutterMode):
"""Sets Current Shutter Mode"""
mode = None
print 'acquiring: {}'.format(self.set_shutter_mode.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.set_shutter_mode.__name__)
yield deferToThread(self.camera.set_shutter_mode, shutterMode)
finally:
print 'releasing: {}'.format(self.set_shutter_mode.__name__)
self.lock.release()
if mode is not None:
returnValue(mode)
'''
Acquisition Mode
'''
@setting(10, "Get Acquisition Mode", returns = 's')
def getAcquisitionMode(self, c):
"""Gets Current Acquisition Mode"""
return self.camera.get_acquisition_mode()
@setting(11, "Set Acquisition Mode", mode = 's', returns = '')
def setAcquisitionMode(self, c, mode):
"""Sets Current Acquisition Mode"""
print 'acquiring: {}'.format(self.setAcquisitionMode.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setAcquisitionMode.__name__)
yield deferToThread(self.camera.set_acquisition_mode, mode)
finally:
print 'releasing: {}'.format(self.setAcquisitionMode.__name__)
self.lock.release()
self.gui.set_acquisition_mode(mode)
'''
Trigger Mode
'''
@setting(12, "Get Trigger Mode", returns = 's')
def getTriggerMode(self, c):
"""Gets Current Trigger Mode"""
return self.camera.get_trigger_mode()
@setting(13, "Set Trigger Mode", mode = 's', returns = '')
def setTriggerMode(self, c, mode):
"""Sets Current Trigger Mode"""
print 'acquiring: {}'.format(self.setTriggerMode.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setTriggerMode.__name__)
yield deferToThread(self.camera.set_trigger_mode, mode)
finally:
print 'releasing: {}'.format(self.setTriggerMode.__name__)
self.lock.release()
self.gui.set_trigger_mode(mode)
'''
Exposure Time
'''
@setting(14, "Get Exposure Time", returns = 'v[s]')
def getExposureTime(self, c):
"""Gets Current Exposure Time"""
time = self.camera.get_exposure_time()
return WithUnit(time, 's')
@setting(15, "Set Exposure Time", expTime = 'v[s]', returns = 'v[s]')
def setExposureTime(self, c, expTime):
"""Sets Current Exposure Time"""
print 'acquiring: {}'.format(self.setExposureTime.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setExposureTime.__name__)
yield deferToThread(self.camera.set_exposure_time, expTime['s'])
finally:
print 'releasing: {}'.format(self.setExposureTime.__name__)
self.lock.release()
#need to request the actual set value because it may differ from the request when the request is not possible
time = self.camera.get_exposure_time()
if c is not None:
self.gui.set_exposure(time)
returnValue(WithUnit(time, 's'))
'''
Image Region
'''
@setting(16, "Get Image Region", returns = '*i')
def getImageRegion(self, c):
"""Gets Current Image Region"""
return self.camera.get_image()
@setting(17, "Set Image Region", horizontalBinning = 'i', verticalBinning = 'i', horizontalStart = 'i', horizontalEnd = 'i', verticalStart = 'i', verticalEnd = 'i', returns = '')
def setImageRegion(self, c, horizontalBinning, verticalBinning, horizontalStart, horizontalEnd, verticalStart, verticalEnd):
"""Sets Current Image Region"""
print 'acquiring: {}'.format(self.setImageRegion.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setImageRegion.__name__)
yield deferToThread(self.camera.set_image, horizontalBinning, verticalBinning, horizontalStart, horizontalEnd, verticalStart, verticalEnd)
finally:
print 'releasing: {}'.format(self.setImageRegion.__name__)
self.lock.release()
'''
Acquisition
'''
@setting(18, "Start Acquisition", returns = '')
def startAcquisition(self, c):
print 'acquiring: {}'.format(self.startAcquisition.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.startAcquisition.__name__)
#speeds up the call to start_acquisition
yield deferToThread(self.camera.prepare_acqusition)
yield deferToThread(self.camera.start_acquisition)
#necessary so that start_acquisition call completes even for long kinetic series
#yield self.wait(0.050)
yield self.wait(0.1)
finally:
print 'releasing: {}'.format(self.startAcquisition.__name__)
self.lock.release()
@setting(19, "Wait For Acquisition", returns = '')
def waitForAcquisition(self, c):
print 'acquiring: {}'.format(self.waitForAcquisition.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.waitForAcquisition.__name__)
yield deferToThread(self.camera.wait_for_acquisition)
finally:
print 'releasing: {}'.format(self.waitForAcquisition.__name__)
self.lock.release()
@setting(20, "Abort Acquisition", returns = '')
def abortAcquisition(self, c):
if c is not None and self.gui.live_update_running:
yield self.gui.stop_live_display()
print 'acquiring: {}'.format(self.abortAcquisition.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.abortAcquisition.__name__)
yield deferToThread(self.camera.abort_acquisition)
finally:
print 'releasing: {}'.format(self.abortAcquisition.__name__)
self.lock.release()
@setting(21, "Get Acquired Data", num_images = 'i',returns = '*i')
def getAcquiredData(self, c, num_images = 1):
"""Get the acquired images"""
print 'acquiring: {}'.format(self.getAcquiredData.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.getAcquiredData.__name__)
image = yield deferToThread(self.camera.get_acquired_data, num_images)
finally:
print 'releasing: {}'.format(self.getAcquiredData.__name__)
self.lock.release()
returnValue(image)
@setting(33, "Get Summed Data", num_images = 'i', returns = '*i')
def getSummedData(self, c, num_images = 1):
''' Get the counts with the vertical axis summed over. '''
print 'acquiring: {}'.format(self.getAcquiredData.__name__)
yield self.lock.acquire()
try:
print 'acquired: {}'.format(self.getAcquiredData.__name__)
images = yield deferToThread(self.camera.get_acquired_data, num_images)
hbin, vbin, hstart, hend, vstart, vend = self.camera.get_image()
x_pixels = int( (hend - hstart + 1.) / (hbin) )
y_pixels = int(vend - vstart + 1.) / (vbin)
images = np.reshape(images, (num_images, y_pixels, x_pixels))
images = images.sum(axis=1)
images = np.ravel(images, order='C')
images = images.tolist()
finally:
print 'releasing: {}'.format(self.getAcquiredData.__name__)
self.lock.release()
returnValue(images)
'''
General
'''
@setting(22, "Get Camera Serial Number", returns = 'i')
def getCameraSerialNumber(self, c):
"""Gets Camera Serial Number"""
return self.camera.get_camera_serial_number()
@setting(23, "Get Most Recent Image", returns = '*i')
def getMostRecentImage(self, c):
"""Get all Data"""
# print 'acquiring: {}'.format(self.getMostRecentImage.__name__)
yield self.lock.acquire()
try:
# print 'acquired : {}'.format(self.getMostRecentImage.__name__)
image = yield deferToThread(self.camera.get_most_recent_image)
finally:
# print 'releasing: {}'.format(self.getMostRecentImage.__name__)
self.lock.release()
returnValue(image)
@setting(24, "Start Live Display", returns = '')
def startLiveDisplay(self, c):
"""Starts live display of the images on the GUI"""
yield self.gui.start_live_display()
@setting(25, "Is Live Display Running", returns = 'b')
def isLiveDisplayRunning(self, c):
return self.gui.live_update_running
@setting(26, "Get Number Kinetics", returns = 'i')
def getNumberKinetics(self, c):
"""Gets Number Of Scans In A Kinetic Cycle"""
return self.camera.get_number_kinetics()
@setting(27, "Set Number Kinetics", numKin = 'i', returns = '')
def setNumberKinetics(self, c, numKin):
"""Sets Number Of Scans In A Kinetic Cycle"""
print 'acquiring: {}'.format(self.setNumberKinetics.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.setNumberKinetics.__name__)
yield deferToThread(self.camera.set_number_kinetics, numKin)
finally:
print 'releasing: {}'.format(self.setNumberKinetics.__name__)
self.lock.release()
# UPDATED THE TIMEOUT. FIX IT LATER
@setting(28, "Wait For Kinetic", timeout = 'v[s]',returns = 'b')
def waitForKinetic(self, c, timeout = WithUnit(1,'s')):
'''Waits until the given number of kinetic images are completed'''
requestCalls = int(timeout['s'] / 0.050 ) #number of request calls
for i in range(requestCalls):
print 'acquiring: {}'.format(self.waitForKinetic.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.waitForKinetic.__name__)
status = yield deferToThread(self.camera.get_status)
#useful for debugging of how many iterations have been completed in case of missed trigger pulses
a,b = yield deferToThread(self.camera.get_series_progress)
print a,b
print status
finally:
print 'releasing: {}'.format(self.waitForKinetic.__name__)
self.lock.release()
if status == 'DRV_IDLE':
returnValue(True)
yield self.wait(0.050)
returnValue(False)
@setting(31, "Get Detector Dimensions", returns = 'ww')
def get_detector_dimensions(self, c):
print 'acquiring: {}'.format(self.get_detector_dimensions.__name__)
yield self.lock.acquire()
try:
print 'acquired : {}'.format(self.get_detector_dimensions.__name__)
dimensions = yield deferToThread(self.camera.get_detector_dimensions)
finally:
print 'releasing: {}'.format(self.get_detector_dimensions.__name__)
self.lock.release()
returnValue(dimensions)
@setting(32, "getemrange", returns = '(ii)')
def getemrange(self, c):
#emrange = yield self.camera.get_camera_em_gain_range()
#returnValue(emrange)
return self.camera.get_camera_em_gain_range()
def wait(self, seconds, result=None):
"""Returns a deferred that will be fired later"""
d = Deferred()
reactor.callLater(seconds, d.callback, result)
return d
def stop(self):
self._stopServer()
@inlineCallbacks
def stopServer(self):
"""Shuts down camera before closing"""
try:
if self.gui.live_update_running:
yield self.gui.stop_live_display()
print 'acquiring: {}'.format(self.stopServer.__name__)
yield self.lock.acquire()
print 'acquired : {}'.format(self.stopServer.__name__)
self.camera.shut_down()
print 'releasing: {}'.format(self.stopServer.__name__)
self.lock.release()
except Exception:
#not yet created
pass
