def test_enum_strs():
sig = EpicsSignal('connects')
sig.wait_for_connection()
enums = ['enum_strs']
# hack this onto the FakeEpicsPV
sig._read_pv.enum_strs = enums
assert sig.enum_strs == enums
def test_epicssignal_waveform():
def update_cb(value=None, **kwargs):
assert value in FakeEpicsWaveform.strings
signal = EpicsSignal('readpv', string=True)
signal.wait_for_connection()
signal.subscribe(update_cb, event_type=signal.SUB_VALUE)
assert signal.value in FakeEpicsWaveform.strings
def test_epicssignal_waveform(self):
epics.PV = FakeEpicsWaveform
def update_cb(value=None, **kwargs):
self.assertIn(value, FakeEpicsWaveform.strings)
signal = EpicsSignal('readpv', string=True)
signal.wait_for_connection()
signal.subscribe(update_cb)
self.assertIn(signal.value, FakeEpicsWaveform.strings)
def test_enum_strs(self):
epics.PV = FakeEpicsPV
sig = EpicsSignal('connects')
sig.wait_for_connection()
enums = ['enum_strs']
# hack this onto the FakeEpicsPV
sig._read_pv.enum_strs = enums
self.assertEquals(sig.enum_strs, enums)
def test_no_connection(cleanup, signal_test_ioc):
sig = EpicsSignal('does_not_connect')
cleanup.add(sig)
with pytest.raises(TimeoutError):
sig.wait_for_connection()
sig = EpicsSignal('does_not_connect')
cleanup.add(sig)
with pytest.raises(TimeoutError):
sig.put(0.0)
with pytest.raises(TimeoutError):
sig.get()
sig = EpicsSignal(signal_test_ioc.pvs['read_only'], write_pv='does_not_connect')
cleanup.add(sig)
with pytest.raises(TimeoutError):
sig.wait_for_connection()
def test_epicssignal_waveform(cleanup, signal_test_ioc):
def update_cb(value=None, **kwargs):
assert len(value) > 1
signal = EpicsSignal(signal_test_ioc.pvs['waveform'], string=True)
cleanup.add(signal)
signal.wait_for_connection()
sub = signal.subscribe(update_cb, event_type=signal.SUB_VALUE)
assert len(signal.value) > 1
signal.unsubscribe(sub)
def test_fakepv_signal():
sig = EpicsSignal(write_pv='XF:31IDA-OP{Tbl-Ax:X1}Mtr.VAL',
read_pv='XF:31IDA-OP{Tbl-Ax:X1}Mtr.RBV')
st = sig.set(1)
for j in range(10):
if st.done:
break
time.sleep(.1)
assert st.done
def test_epicssignal_pv_reuse(cleanup, pvname, count):
signals = [EpicsSignal(pvname, name='sig') for i in range(count)]
for sig in signals:
cleanup.add(sig)
sig.wait_for_connection()
assert sig.connected
assert sig.get() is not None
if get_cl().name == 'pyepics':
assert len(set(id(sig._read_pv) for sig in signals)) == 1
def test_panel_creation():
panel = SignalPanel("Test Signals", signals={
# Signal is its own write
'Standard': EpicsSignal('Tst:Pv'),
# Signal has separate write/read
'Read and Write': EpicsSignal('Tst:Read',
write_pv='Tst:Write'),
# Signal is read-only
'Read Only': EpicsSignalRO('Tst:Pv:RO'),
# Simulated Signal
'Simulated': SynSignal(name='simul'),
'SimulatedRO': SynSignalRO(name='simul_ro')})
assert len(panel.signals) == 5
# Check read-only channels do not have write widgets
panel.layout().itemAtPosition(2, 1).layout().count() == 1
panel.layout().itemAtPosition(4, 1).layout().count() == 1
# Check write widgets are present
panel.layout().itemAtPosition(0, 1).layout().count() == 2
panel.layout().itemAtPosition(1, 1).layout().count() == 2
panel.layout().itemAtPosition(3, 1).layout().count() == 2
return panel
def __init__(self, read_pv, write_pv=None, *, name, parent=None, **kwargs):
super().__init__(name=name, parent=parent)
self._epics_signal = EpicsSignal(read_pv=read_pv,
write_pv=write_pv,
parent=self,
name=self.name,
**kwargs)
self._epics_signal.subscribe(
self._epics_meta_update,
event_type=self._epics_signal.SUB_META,
)
self._saw_connection = False
def test_panel_add_enum():
panel = SignalPanel("Test Signals")
# Create an enum pv
sig = EpicsSignal("Tst:Enum")
sig._write_pv.enum_strs = ('A', 'B')
# Add our signal to the panel
loc = panel.add_signal(sig, "Enum PV")
# Check our signal was added a QCombobox
# Assume it is the last item in the button layout
but_layout = panel.layout().itemAtPosition(loc, 1)
assert isinstance(
but_layout.itemAt(but_layout.count() - 1).widget(), PyDMEnumComboBox)
return panel
def __init__(self):
#switch to trigger instead of full evr
self._sync_markers = {
0.5: 0,
1: 1,
5: 2,
10: 3,
30: 4,
60: 5,
120: 6,
360: 7
}
self.trigger_mag = Trigger('XCS:R42:EVR:01:TRIG4', name='trigger_mag')
self.trigger_pp = Trigger('XCS:USR:EVR:TRIG1', name='trigger_pp')
#self.nemptyshots = actions(0, name='nemptyshots')
#self.isfire = actions(False, name='isfire')
#self.emptyshotspacing = actions(0, name='emptyshotspacing')
#self.nshots = actions(0, name='nshots')
#self.shotspacing = actions(0, name='shotspacing')
#with safe_load('Pirani and Cold Cathode Gauges'):
# self.mag_pirani = BaseGauge('XCS:USR:GPI:01', name='mag_pirani')
# self.mag_cc = BaseGauge('XCS:USR:GCC:01', name='mag_cc')
self.sample_temp = LakeShoreChannel('XCS:USR:TCT:02', name='A')
self.mag_temp = LakeShoreChannel('XCS:USR:TCT:02', name='B')
self.ttl_high = 2.0
self.ttl_low = 0.8
self._ready_sig = EpicsSignal('XCS:USR:ai1:0',
name='User Analog Input channel 0',
kind='omitted')
self.i0_threshold = 4000 # default threshold is 0
self.i0_avg = AvgSignal(ipm4.wave8.isum, 30, name='ipm4_sum_avg')
self.i0_mag_retry = 10
self._gdet_threshold_pv = EpicsSignal('XCS:VARS:J78:GDET_THRES',
kind='normal')
#self.gdet_avg_count = 30
#self.gdet_mag_retry = 10
#self.gdet = GasDetector('GDET:FEE1', name='gas detector')
#self._bykik_pv = Cpt(EpicsSignal('IOC:IN20:EV01:BYKIK_ABTACT', kind = 'normal', string=True, doc='BYKIK: Abort Active')
self._req_burst_rate = 'Full'
self._test_burst_rate = EpicsSignal('PATT:SYS0:1:TESTBURSTRATE',
name='test_burst_rate',
kind='normal')
self._mps_burst_rate = EpicsSignal('PATT:SYS0:1:MPSBURSTRATE',
name='mps_burst_rate')
# number of seconds to pause between empty and magnet
self.pause_time = 2.
self._min_empty_delay = 4
self._beam_owner = EpicsSignal('ECS:SYS0:0:BEAM_OWNER_ID',
name='beam_owner',
kind='normal')
self._att = att
self.hutch = 'xcs'
self._hutch_id = EpicsSignal('ECS:SYS0:4:HUTCH_ID',
name='hutch_id',
kind='normal')
self.aliases = ['BEAM']
self.gainmodes = ''
def __init__(self,
*,
name,
move,
get_pos,
set_pos=None,
stop=None,
done=None,
check_value=None,
info=None,
egu='',
limits=None,
update_rate=1,
timeout=60,
notepad_pv=None,
parent=None,
kind=None,
**kwargs):
self._check_signature('move', move, 1)
self._move = move
self._check_signature('get_pos', get_pos, 0)
self._get_pos = get_pos
self._check_signature('set_pos', set_pos, 1)
self._set_pos = set_pos
self._check_signature('stop', stop, 0)
self._stop = stop
self._check_signature('done', done, 0)
self._done = done
self._check_signature('check_value', check_value, 1)
self._check = check_value
self._info = info
self._last_update = 0
self._goal = None
self.update_rate = 1
notepad_name = name + '_notepad'
if notepad_pv is None:
self.notepad_signal = Signal(name=notepad_name)
else:
self.notepad_signal = EpicsSignal(notepad_pv, name=notepad_name)
if parent is None and kind is None:
kind = 'hinted'
super().__init__(name=name,
egu=egu,
limits=limits,
source='func',
timeout=timeout,
parent=parent,
kind=kind,
**kwargs)
def test_epicssignal_readwrite_limits(cleanup, signal_test_ioc):
signal = EpicsSignal(read_pv=signal_test_ioc.pvs['read_only'],
write_pv=signal_test_ioc.pvs['read_write'],
limits=True)
cleanup.add(signal)
signal.wait_for_connection()
signal.check_value((signal.low_limit + signal.high_limit) / 2)
with pytest.raises(ValueError):
signal.check_value(None)
with pytest.raises(ValueError):
signal.check_value(signal.low_limit - 1)
with pytest.raises(ValueError):
signal.check_value(signal.high_limit + 1)
def tt_rough_FB(ttamp_th=0.02, ipm4_th=500, tt_window=0.05):
fbvalue = 0 # for drift record
while (1):
tenshots_tt = np.zeros([
1,
])
dlen = 0
while (dlen < 61):
#ttcomm = Popen("caget XPP:TIMETOOL:TTALL",shell = True, stdout=PIPE)
#ttdata = (ttcomm.communicate()[0]).decode()
ttall = EpicsSignal('XCS:TIMETOOL:TTALL')
ttdata = ttall.get()
current_tt = ttdata[1, ]
ttamp = ttdata[2, ]
ipm4val = ttdata[3, ]
ttfwhm = ttdata[5, ]
#current_tt = float((ttdata.split(" "))[3])
#ttamp = float((ttdata.split(" "))[4])
#ipm2val = float((ttdata.split(" "))[5])
#ttfwhm = float((ttdata.split(" "))[7])
if (dlen % 10 == 0):
#print("tt_value",current_tt,"ttamp",ttamp,"ipm4",ipm4val)
print("tt_value:%0.3f" % current_tt +
" ttamp:%0.3f " % ttamp +
" ipm4:%d" % ipm4val)
if (ttamp > ttamp_th) and (ipm4val > ipm4_th) and (
ttfwhm < 130
) and (ttfwhm > 30) and (
current_tt != tenshots_tt[-1, ]
): # for filtering the last one is for when DAQ is stopping
tenshots_tt = np.insert(tenshots_tt, dlen, current_tt)
dlen = np.shape(tenshots_tt)[0]
time.sleep(0.01)
tenshots_tt = np.delete(tenshots_tt, 0)
ave_tt = np.mean(tenshots_tt)
print("Moving average of timetool value:", ave_tt)
if np.abs(ave_tt) > tt_window:
ave_tt_second = -(ave_tt * 1e-12)
lxt.mvr(ave_tt_second)
print("feedback %f ps" % ave_tt)
fbvalue = ave_tt + fbvalue
#drift_log(str(fbvalue))
return
def test_epicssignal_waveform(cleanup, signal_test_ioc):
called = False
def update_cb(value=None, **kwargs):
nonlocal called
assert len(value) > 1
called = True
signal = EpicsSignal(signal_test_ioc.pvs['waveform'], string=True)
cleanup.add(signal)
signal.wait_for_connection()
sub = signal.subscribe(update_cb, event_type=signal.SUB_VALUE)
assert len(signal.get()) > 1
# force the current thread to allow other threads to run to service
# subscription
time.sleep(0.2)
assert called
signal.unsubscribe(sub)
def test_panel_add_enum():
panel = SignalPanel()
# Create an enum pv
epics_sig = EpicsSignal("Tst:Enum")
epics_sig._write_pv.enum_strs = ('A', 'B')
# Create an enum signal
syn_sig = RichSignal(name='Syn:Enum', value=1)
# Add our signals to the panel
loc1 = panel.add_signal(epics_sig, "EPICS Enum PV")
loc2 = panel.add_signal(syn_sig, "Sim Enum PV")
# Check our signal was added a QCombobox
# Assume it is the last item in the button layout
but_layout = panel.layout().itemAtPosition(loc1, 1)
assert isinstance(
but_layout.itemAt(but_layout.count() - 1).widget(), PyDMEnumComboBox)
# Check our signal was added a QCombobox
# Assume it is the last item in the button layout
but_layout = panel.layout().itemAtPosition(loc2, 1)
assert isinstance(
but_layout.itemAt(but_layout.count() - 1).widget(), PyDMEnumComboBox)
return panel
#raise ConnectionError
with safe_load('bluesky setup'):
from bluesky.callbacks.mpl_plotting import initialize_qt_teleporter
initialize_qt_teleporter()
with safe_load('ladm_det'):
xcsdet_y = IMS('XCS:LAM:MMS:07', name='xcsdet_y')
xcsdet_x = IMS('XCS:LAM:MMS:06', name='xcsdet_x')
with safe_load('LADM'):
from pcdsdevices.ladm import LADM, LADMMotors, Beamstops
from pcdsdevices.positioner import FuncPositioner
lm = LADMMotors('XCS:LAM', name='ladm_motors')
bs = Beamstops('XCS:LAM', name='ladm_beamstops')
theta_pv = EpicsSignal('XCS:VARS:LAM:Theta', name='LADM_theta')
gamma_pv = EpicsSignal('XCS:VARS:LAM:Gamma', name='LADM_gamma')
ladm = LADM(lm.x1_us, lm.y1_us, lm.x2_ds, lm.y2_ds, lm.z_us, theta_pv,
gamma_pv)
ladmTheta = FuncPositioner(name='ladmTheta',
move=ladm.moveTheta,
get_pos=ladm.wmTheta,
set_pos=ladm.setTheta)
ladm.theta = ladmTheta
ladmXT = FuncPositioner(name='ladmXT',
move=ladm.moveX,
get_pos=ladm.wmX,
set_pos=ladm._setX,
egu='mm',
limits=(ladm._get_lowlimX, ladm._get_hilimX))
ladm.XT = ladmXT
class User():
target_x = Motor('MEC:USR:MMS:17', name='target_x_motor')
YFEon = YFEon
YFEoff = YFEoff
HWPon = HWPon
SHG_opt = SHG_opt
save_scope_to_eLog = save_scope_to_eLog
def start_seq(self, rate=120, wLPLaser=False):
if rate==120:
sync_mark = 6#int(_sync_markers[120])
elif rate==60:
sync_mark = 5
elif rate==30:
sync_mark = 4
elif rate==10:
sync_mark = 3
elif rate==5:
sync_mark = 2
elif rate==1:
sync_mark = 1
elif rate==0.5:
sync_mark = 0
seq.sync_marker.put(sync_mark)
seq.play_mode.put(2) # Run sequence forever
ff_seq = [[169, 0, 0, 0]]
if wLPLaser:
ff_seq.append([182, 0, 0, 0])
seq.sequence.put_seq(ff_seq)
seq.start()
def start_seq_120Hz(self):
#self.start_seq_120Hz(120)
sync_mark = 6#int(_sync_markers[120])
seq.sync_marker.put(sync_mark)
seq.play_mode.put(2) # Run sequence forever
ff_seq = [[169, 0, 0, 0]]
seq.sequence.put_seq(ff_seq)
seq.start()
def start_seq_10Hz(self, wLPLaser=False):
sync_mark = 3#int(_sync_markers[10])
seq.sync_marker.put(sync_mark)
seq.play_mode.put(2) # Run sequence forever
ff_seq = [[169, 0, 0, 0]]
if wLPLaser:
ff_seq.append([182, 0, 0, 0])
seq.sequence.put_seq(ff_seq)
seq.start()
_seq = Sequence()
_sync_markers = {0.5:0, 1:1, 5:2, 10:3, 30:4, 60:5, 120:6, 360:7}
nsl = NanoSecondLaser()
fsl = FemtoSecondLaser()
shutters = [1,2,3,4,5,6]
_shutters = {1: shutter1,
2: shutter2,
3: shutter3,
4: shutter4,
5: shutter5,
6: shutter6}
seq_a_pvs = [EpicsSignal('MEC:ECS:IOC:01:EC_6:00'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:01'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:02'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:03'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:04'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:05'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:06'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:07'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:08'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:09')]
seq_b_pvs = [EpicsSignal('MEC:ECS:IOC:01:BD_6:00'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:01'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:02'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:03'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:04'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:05'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:06'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:07'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:08'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:09')]
def open_shutters(self):
print("Opening shutters...")
for shutter in self.shutters:
self._shutters[shutter].open()
time.sleep(5)
def close_shutters(self):
print("Closing shutters...")
for shutter in self.shutters:
self._shutters[shutter].close()
time.sleep(5)
def seq_wait(self):
time.sleep(0.5)
while seq.play_status.get() != 0:
time.sleep(0.5)
def scalar_sequence_write(self, s):
for i in range(len(s)):
self.seq_a_pvs[i].put(s[i][0])
for j in range(len(s)):
self.seq_b_pvs[j].put(s[j][1])
seq.sequence_length.put(len(s))
def uxi_shot(self, delta=0.3, record=True, lasps=True):
"""
Returns a BlueSky plan to run a scan for the LV08 experiment. Used for
the UXI camera which requires near continuous acquisition for stable
camera behavior. The following shots are combined in a single run.
Shot sequence:
--------------
1) 10 dark frames # Warm up camera
2) 10 X-ray frames
3) Sample moves in
4) 10 dark frames # Warm up camera
5) 1 X-ray + Optical laser frame
6) 10 dark frames
7) Sample moves out
8) 10 dark frames # Warm up camera
9) 10 X-ray frames
Parameters:
-----------
delta : float <default: 0.3>
The relative distance in mm to move the sample in and out.
record : bool <default: True>
Flag to record the data (or not).
lasps : bool <default: True>
Flag to perform pre-and post shot pulse shaping routines.
"""
logging.debug("Calling User.shot with parameters:")
logging.debug("delta: {}".format(delta))
logging.debug("record: {}".format(record))
logging.debug("lasps: {}".format(lasps))
print("Configuring DAQ...")
# yield from bps.configure(daq,events=0, record=record) # run infinitely, let sequencer
# control number of events
daq.begin_infinite(record=record)
long_seq = [[0, 240, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
print("Configuring sequencer...")
# Setup the pulse picker for single shots in flip flop mode
pp.flipflop(wait=True)
# Setup sequencer for requested rate
sync_mark = int(self._sync_markers[0.5])
seq.sync_marker.put(sync_mark)
seq.play_mode.put(1) # Run N times
seq.rep_count.put(10)
# Setup sequence
self._seq.rate = 0.5
# close the shutters specified by the user
for shutter in self.shutters:
self._shutters[shutter].close()
# Shutters are slow; give them time to close
time.sleep(5)
if lasps:
print("Running mecps.pspreshot()...")
pspreshot()
# Run 10 Pre-laser dark shots (step 1 above)
s = self._seq.darkSequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
print("Taking 10 dark shots...")
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
# Run 10 Pre-laser x-ray shots (step 2 above)
s = self._seq.darkXraySequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
print("Taking 10 x-ray shots...")
time.sleep(1)
seq.start()
self.seq_wait()
#yield from bps.trigger_and_read([daq, seq])
# Move sample in (step 3 above)
print("Moving sample in...")
yield from bps.mvr(self.target_x, delta) #TODO Check direction
# Run 10 Pre-laser dark shots (step 4 above)
print("Taking 10 dark shots...")
s = self._seq.darkSequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
# Run x-ray + optical sequence (step 5 above)
print("Taking optical laser shots...")
seq.rep_count.put(1)
s = self._seq.duringSequence(1, 'longpulse')
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
# Run 10 Post-laser dark shots (step 6 above)
print("Taking 10 dark shots...")
seq.rep_count.put(10)
s = self._seq.darkSequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
# Move sample out (step 7 above)
print("Moving sample out...")
yield from bps.mvr(self.target_x, -delta) #TODO Check direction
# Run 10 Pre-x-ray dark shots (step 8 above)
print("Taking 10 dark shots...")
seq.rep_count.put(10)
s = self._seq.darkSequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
# Run 10 Pre-laser x-ray shots (step 9 above)
print("Taking 10 x-ray shots...")
s = self._seq.darkXraySequence(1, preshot=False)
# seq.sequence.put_seq(long_seq)
# seq.sequence.put_seq(s)
self.scalar_sequence_write(s)
time.sleep(1)
seq.start()
self.seq_wait()
# yield from bps.trigger_and_read([daq, seq])
daq.end_run()
if lasps:
print("Running mecps.pspostshot()...")
pspostshot()
# open the shutters specified by the user
for shutter in self.shutters:
self._shutters[shutter].open()
def __init__(self, door_state, voltage_read, voltage_write):
self.door_state = EpicsSignalRO(door_state)
self.mesh_voltage = EpicsSignal(voltage_read, write_pv=voltage_write)
print('Using door pv {}'.format(door_state))
def test_setpoint():
sig = EpicsSignal('connects')
sig.wait_for_connection()
sig.get_setpoint()
sig.get_setpoint(as_string=True)
"""
from ophyd import EpicsMotor, set_and_wait
from ophyd.signal import (EpicsSignal, EpicsSignalRO)
from ophyd.utils.epics_pvs import (raise_if_disconnected, AlarmSeverity)
from ophyd.device import (Device, Component as Cpt)
from ophyd.status import wait as status_wait
import bluesky.plans as bp
import bluesky.plan_stubs as bps
import bluesky.preprocessors as bpp
class EpicsGapMotor(EpicsMotor):
def __init__(self, brakeDevice, *args, **kwargs):
super().__init__(*args, **kwargs)
self.brake = brakeDevice
def move(self, *args, **kwargs):
if self.brake.get() == 0:
set_and_wait(self.brake, 1)
return super().move(*args, **kwargs)
IVUgapBrake = EpicsSignal("SR:C16-ID:G1{IVU:1}BrakesDisengaged-Sts",
write_pv="SR:C16-ID:G1{IVU:1}BrakesDisengaged-SP")
IVUgap = EpicsGapMotor(IVUgapBrake,
"SR:C16-ID:G1{IVU:1-Ax:Gap}-Mtr",
name='IVUgap')
TIMEOUT = 60
if not EpicsSignalBase._EpicsSignalBase__any_instantiated:
EpicsSignalBase.set_defaults(
auto_monitor=True,
timeout=iconfig.get("PV_TIMEOUT", TIMEOUT),
write_timeout=iconfig.get("PV_WRITE_TIMEOUT", TIMEOUT),
connection_timeout=iconfig.get("PV_CONNECTION_TIMEOUT", TIMEOUT),
)
pvname = iconfig.get("RUN_ENGINE_SCAN_ID_PV")
if pvname is None:
logger.info("Using RunEngine metadata for scan_id")
scan_id_epics = None
else:
logger.info("Using EPICS PV %s for scan_id", pvname)
scan_id_epics = EpicsSignal(pvname, name="scan_id_epics")
def epics_scan_id_source(*args, **kwargs):
"""
Callback function for RunEngine. Returns *next* scan_id to be used.
* Get current scan_id from PV.
* Apply lower limit of zero.
* Increment.
* Set PV with new value.
* Return new value.
"""
if scan_id_epics is None:
raise RuntimeError("epics_scan_id_source() called when"
" 'RUN_ENGINE_SCAN_ID_PV' is"
def bool_enum_signal(cleanup, signal_test_ioc):
sig = EpicsSignal(signal_test_ioc.pvs['bool_enum'], name='bool_enum')
cleanup.add(sig)
sig.wait_for_connection()
return sig
class USBEncoder(Device):
tab_component_names = True
set_zero = Cpt(EpicsSignal, ':ZEROCNT')
pos = Cpt(EpicsSignal, ':POSITION')
scale = Cpt(EpicsSignal, ':SCALE')
offset = Cpt(EpicsSignal, ':OFFSET')
lxt_fast_enc = USBEncoder('XCS:USDUSB4:01:CH0', name='lxt_fast_enc')
with safe_load('Other Useful Actuators'):
from pcdsdevices.epics_motor import IMS
from ophyd.signal import EpicsSignal
tt_ty = IMS('XCS:SB2:MMS:46', name='tt_ty')
lib_y = IMS('XCS:USR:MMS:04', name='lib_y')
det_y = IMS('XCS:USR:MMS:40', name='det_y')
lp = EpicsSignal('XCS:USR:ao1:7', name='lp')
def lp_close():
lp.put(0)
def lp_open():
lp.put(4)
#with safe_load('User Opal'):
# from pcdsdevices.areadetector.detectors import PCDSDetector
# opal_1 = PCDSDetector('XCS:USR:O1000:01:', name='opal_1')
##these should mot be here with the exception of laser motors until we
## have a decent laser module
with safe_load('User Newports'):
def rw_signal(cleanup, signal_test_ioc):
sig = EpicsSignal(signal_test_ioc.pvs['read_write'], name='read_write')
cleanup.add(sig)
sig.wait_for_connection()
return sig
class User():
target_x = Motor('MEC:USR:MMS:17', name='target_x_motor')
YFEon = YFEon
YFEoff = YFEoff
HWPon = HWPon
SHG_opt = SHG_opt
save_scope_to_eLog = save_scope_to_eLog
def start_seq(self, rate=120, wLPLaser=False):
if rate == 120:
sync_mark = 6 #int(_sync_markers[120])
elif rate == 60:
sync_mark = 5
elif rate == 30:
sync_mark = 4
elif rate == 10:
sync_mark = 3
elif rate == 5:
sync_mark = 2
elif rate == 1:
sync_mark = 1
elif rate == 0.5:
sync_mark = 0
seq.sync_marker.put(sync_mark)
seq.play_mode.put(2) # Run sequence forever
ff_seq = [[169, 0, 0, 0]]
if wLPLaser:
ff_seq.append([182, 0, 0, 0])
seq.sequence.put_seq(ff_seq)
seq.start()
_seq = Sequence()
_sync_markers = {0.5: 0, 1: 1, 5: 2, 10: 3, 30: 4, 60: 5, 120: 6, 360: 7}
nsl = NanoSecondLaser()
fsl = FemtoSecondLaser()
shutters = [1, 2, 3, 4, 5, 6]
_shutters = {
1: shutter1,
2: shutter2,
3: shutter3,
4: shutter4,
5: shutter5,
6: shutter6
}
seq_a_pvs = [
EpicsSignal('MEC:ECS:IOC:01:EC_6:00'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:01'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:02'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:03'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:04'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:05'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:06'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:07'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:08'),
EpicsSignal('MEC:ECS:IOC:01:EC_6:09')
]
seq_b_pvs = [
EpicsSignal('MEC:ECS:IOC:01:BD_6:00'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:01'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:02'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:03'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:04'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:05'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:06'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:07'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:08'),
EpicsSignal('MEC:ECS:IOC:01:BD_6:09')
]
def open_shutters(self):
print("Opening shutters...")
for shutter in self.shutters:
self._shutters[shutter].open()
time.sleep(5)
def close_shutters(self):
print("Closing shutters...")
for shutter in self.shutters:
self._shutters[shutter].close()
time.sleep(5)
def seq_wait(self):
time.sleep(0.5)
while seq.play_status.get() != 0:
time.sleep(0.5)
def scalar_sequence_write(self, s):
for i in range(len(s)):
self.seq_a_pvs[i].put(s[i][0])
for j in range(len(s)):
self.seq_b_pvs[j].put(s[j][1])
seq.sequence_length.put(len(s))
def alarm_status_signal(cleanup, signal_test_ioc):
sig = EpicsSignal(signal_test_ioc.pvs['alarm_status'], name='alarm_status')
cleanup.add(sig)
sig.wait_for_connection()
return sig
def set_severity_signal(cleanup, signal_test_ioc):
sig = EpicsSignal(signal_test_ioc.pvs['set_severity'], name='set_severity')
cleanup.add(sig)
sig.wait_for_connection()
return sig
def motor_pair_signal(cleanup, motor):
sig = EpicsSignal(write_pv=motor.user_setpoint.pvname,
read_pv=motor.user_readback.pvname)
cleanup.add(sig)
sig.wait_for_connection()
return sig
