def connect_instr(self):
""" Create the instrument class and connect to the instrument. """
instr = self.instr
device = instr.device_cls(instr.address)
if device.connection_error:
rsp = daq.Rsp('connection_error')
self.r_queue.put(rsp)
return
device.type = instr.device_type
self.device = device
info = self.connect_info()
rsp = daq.Rsp('connected', info=info)
self.r_queue.put(rsp)
def close(self):
"""" Close the device and send an exit code to the response queue. """
self.device.close()
del self.device # Need to ensure all references to a camera are removed
rsp = daq.Rsp('exit')
self.r_queue.put(rsp)
def is_free_running(self):
""" Check if the TC is free running. """
if self.FR:
meta = self.create_meta()
response = 'output'
rsp = daq.Rsp(response, info=raw, meta=meta)
self.r_queue.put(rsp)
def set_settings(self, settings, save=False):
""" Set the delay settings for a one or more channels.
Parameters
----------
settings : dict
The dictionary containing the settings.
save : bool, optional
Specify if the new settings should be saved to file.
"""
sdg = self.device
for key in settings:
delay = settings[key]['delay']
output = settings[key]['output']
ref = settings[key]['ref']
polarity = settings[key]['polarity']
sdg.set_delay([ref, key, delay])
if key == 'T0':
sdg.set_output(['T0', output], pol=polarity)
elif key == 'A':
sdg.set_output(['AB', output], pol=polarity)
elif key == 'C':
sdg.set_output(['CD', output], pol=polarity)
elif key == 'E':
sdg.set_output(['EF', output], pol=polarity)
elif key == 'G':
sdg.set_output(['GH', output], pol=polarity)
if save:
meta = self.create_meta()
rsp = daq.Rsp('save', settings, meta)
self.r_queue.put(rsp)
def capture_thread(self, r_queue):
""" Continually quieres the turbo molecular pump for power.
Parameters
----------
r_queue : mp.Queue
The response queue to place the pressure in.
"""
while self.streaming:
raw = {}
raw['status'] = self.device.get_status()
raw['power'] = self.device.get_power()
raw['frequency'] = self.device.get_driving_frequency()
raw['temperature'] = self.device.get_temperature()
raw['error'] = self.device.get_error()
meta = self.create_meta()
if self.save: response = 'save'
else: response = 'output'
rsp = daq.Rsp(response, info=raw, meta=meta)
self.r_queue.put(rsp)
self.shot += 1
if self.shot == self.numShots:
self.save = False
time.sleep(self.sampleDelay)
def update_vel(self):
nf = self.device
axes = self.axes
slave = self.slave
raw_velocity = nf.get_velocity(axes[0], slave)
split_velocity = raw_velocity.split(">")
velocity_readback = split_velocity[-1]
rsp = daq.Rsp('driver', info={'velocity_readback': velocity_readback})
self.r_queue.put(rsp)
def update_accel(self):
nf = self.device
axes = self.axes
slave = self.slave
raw_accel = nf.get_acceleration(axes[0], slave)
split_accel = raw_accel.split(">")
acceleration_readback = split_accel[-1]
rsp = daq.Rsp('driver',
info={'acceleration_readback': acceleration_readback})
self.r_queue.put(rsp)
def save_waveform(self, chan=None):
""" Save the current waveform to disk. """
t, y, pre = self.device.retrieve_current_waveform()
meta = self.create_meta()
if chan != None:
meta['Channel'] = chan
for name in pre:
meta[name] = pre[name]
data = {'meta': meta, 't': t, 'y': y}
rsp = daq.Rsp('save', data, meta)
self.shot += 1
self.r_queue.put(rsp)
def set_record_voltage(self, v):
""" Set the voltage and save the value.
Parameters
----------
v : float
The voltage to set the power supply to.
"""
self.device.set_voltage(v)
meta = self.create_meta()
rsp = daq.Rsp('save', {'voltage': v}, meta)
self.r_queue.put(rsp)
self.shot += 1
def capture_thread(self, r_queue):
""" Continually quieres the controller for motor positions.
Parameters
----------
r_queue : mp.Queue
The response queue to place the pressure in.
"""
while self.streaming:
raw = self.get_settings()
response = 'driver'
rsp = daq.Rsp(response, info=raw)
self.r_queue.put(rsp)
time.sleep(self.sampleDelay)
def get_settings(self):
"""Place the current settings on the SDG into the response queue."""
settings = {}
sdg = self.device
for i in range(10):
# Output is only defined for T0, AB, BC, CD, EF, so set it the same for both
ref, delay = sdg.get_delay(i)
settings[self.channels[i]] = {
'delay': delay,
'output': sdg.get_output(int(i / 2)),
'ref': self.channels[ref],
'polarity': sdg.get_polarity(int(i / 2))
}
meta = self.create_meta()
if self.save: response = 'save'
else: response = 'output'
rsp = daq.Rsp(response, info=settings, meta=meta)
self.r_queue.put(rsp)
def capture_thread(self, r_queue):
""" Continually queries the camera for images.
Parameters
----------
r_queue : mp.Queue
The response queue to place the pressure in.
"""
while self.streaming:
# This call blocks and does not release the GIL, no commands will
# make it through until a buffer is retrieved
# This is a problem with an external trigger, the save command
# wont make it through until after the first shot
#start = time.clock()
meta = self.create_meta()
image = self.device.retrieve_buffer()
if image is None:
print('Image dropped, shot %d' % self.shot)
raw = None
else:
# This conversion reduces the image to 8bit
#converted = image.Convert(PySpin.PixelFormat_Mono16)
# Changed everything to just run in 8bit instead
converted = image
raw = converted.GetNDArray()
if self.save:
response = 'save'
else:
response = 'output'
#raw = np.random.randint(0, 256, size=(2000, 2000), dtype=np.uint16)
rsp = daq.Rsp(response, raw, meta=meta)
self.r_queue.put(rsp)
#end = time.clock()
#print("Start:", start, "End:", end, "Duration:", end-start)
if image is not None:
image.Release()
#print('Camera', self.shot)
self.shot += 1
if self.shot == self.numShots:
self.save = False
self.stop_stream() # For releasing the GIL
time.sleep(0.01) # Guarantee the GIL is released
def get_motor_settings(self, slave):
nf = self.device
data = {
'vel1': nf.get_velocity(1, slave),
'acc1': nf.get_acceleration(1, slave),
'typ1': nf.get_motor(1, slave),
'vel2': nf.get_velocity(2, slave),
'acc2': nf.get_acceleration(2, slave),
'typ2': nf.get_motor(2, slave),
'vel3': nf.get_velocity(3, slave),
'acc3': nf.get_acceleration(3, slave),
'typ3': nf.get_motor(3, slave),
'vel4': nf.get_velocity(4, slave),
'acc4': nf.get_acceleration(4, slave),
'typ4': nf.get_motor(4, slave),
}
response = 'settings'
rsp = daq.Rsp(response, info=data)
self.r_queue.put(rsp)
def capture_thread(self, r_queue):
""" Continually quieres the XPS controller for updated data.
Parameters
----------
r_queue : mp.Queue
The response queue to place the data.
"""
while self.streaming:
raw = self.get_settings()
if self.save: response = 'save'
else: response = 'driver'
rsp = daq.Rsp(response, info=raw)
self.r_queue.put(rsp)
self.shot += 1
if self.shot == self.numShots:
self.save = False
time.sleep(self.sampleDelay)
def capture_thread(self, r_queue):
""" Continually quieres the pressure gauge for the pressure.
Parameters
----------
r_queue : mp.Queue
The response queue to place the pressure in.
"""
while self.streaming:
raw = self.device.get_voltage()
meta = self.create_meta()
serial = meta['Serial number'] # This serial number has '/dev/' in front, which causes an error when saving the data.
serial_sliced = serial[5:] # Remove /dev/ from serial number
meta['Serial number'] = serial_sliced # Redefine the serial number in meta
if self.save: response = 'save'
else: response = 'output'
rsp = daq.Rsp(response, info=raw, meta=meta)
self.r_queue.put(rsp)
self.shot += 1
if self.shot == self.numShots:
self.save = False
time.sleep(self.sampleDelay)
def capture_thread(self, r_queue):
""" Continually quieres the timing controller for the shot number.
Parameters
----------
r_queue : mp.Queue
The response queue to place the shot number in.
"""
while self.streaming:
raw = self.device.get_shot()
if raw is None:
continue
meta = self.create_meta()
response = 'output'
rsp = daq.Rsp(response, info=raw, meta=meta)
self.r_queue.put(rsp)
#print('TC', self.shot)
self.shot += 1
if self.shot == self.numShots and raw == self.numShots:
self.save = False
self.stop_stream()
time.sleep(self.sampleDelay)
def capture_thread(self, r_queue):
""" Continually quieres the spectrometer for new spectra.
Parameters
----------
r_queue : mp.Queue
The response queue to place spectrums in.
"""
while self.streaming:
raw = self.device.get_spectrum()
meta = self.create_meta()
data = {'lambda' : raw[0, :],
'I' : raw[1, :]}
if self.save:
response = 'save'
else:
response = 'output'
rsp = daq.Rsp(response, info=data, meta=meta)
self.r_queue.put(rsp)
self.shot += 1
if self.shot == self.numShots:
self.save = False
def update_position2(self):
xps = self.device
pos_readback2 = xps.get_stage2_position()
rsp = daq.Rsp('driver', info={'pos_readback2': pos_readback2})
self.r_queue.put(rsp)
def update_status2(self):
xps = self.device
status2 = xps.get_group2_status()
rsp = daq.Rsp('driver', info={'status2': status2})
self.r_queue.put(rsp)
def reboot_status(self):
rsp = daq.Rsp('driver', info={'reboot': 'Rebooting...'})
self.r_queue.put(rsp)
def homing_status2(self):
rsp = daq.Rsp('driver', info={'homing2': 'Homing...'})
self.r_queue.put(rsp)
