class Part:
def __init__(self, part):
# Let errors propagate
self._name = part.get('name')
self._vset = part.get('vset')
self._base = part.get('base')
self._scale = part.get('scale')
self._ramping = EpicsSignalRO(f'{self._base}{RAMPING}')
self._set_voltage = EpicsSignal(f'{self._base}{VSET}')
@property
def name(self):
return self._name
@property
def vset(self):
return self._vset
@property
def base(self):
return self._base
def set_voltage(self, zero=False):
if zero:
self._set_voltage.put(0)
else:
self._set_voltage.put(self.vset)
@property
def ramping(self):
return self._ramping.get()
def fug_fil_degas(I_target,
pressure_pv,
max_pressure,
max_voltage,
current=fug_current,
voltage=fug_voltage,
enable=fug_enable):
"""
fug_fil_degas(1 (in A), prep_pressure, 1*10**-8, 10 (in Volts))
"""
# pressure_pv_dict = {
# ['Load_Lock_1']= 'XF:21IDD-VA{LOCK1:4A-CCG:EA4_1}P-I',
# ['Load_Lock_2']= 'XF:21IDD-VA{LOCK2:3A-CCG:EA3_1}P-I',
# ['Preparation']= 'XF:21IDD-VA{PREP:2A-CCG:EA5_1}P-I',
# ['Low_Temp']= 'XF:21IDD-VA{LOWT:5A-CCG:EA5_1}P-I',
# ['Analysis']= 'XF:21IDD-VA{ANAL:1A-CCG:EA1_1}P-I' }
pressure_pv = EpicsSignal(pressure_pv_dict[pressure_pv])
voltage.put(max_voltage)
current.put(0)
enable.put(1)
while I_target > current.get():
incr = .1
print("Current value: " + str(round(current.get(), 2)) +
". Going to " + str(round(current.get() + incr, 2)))
while (pressure_pv.get() >= max_pressure):
time.sleep(10)
current.put(current.get() + incr)
time.sleep(10)
current.put(0)
voltage.put(0)
enable.put(0)
class MMC_Axis:
def __init__(self, base_pv, name=None):
self.base_pv = base_pv
self.rbv = EpicsSignalRO(self.base_pv+'.RBV', auto_monitor=True)
self.val = EpicsSignal(self.base_pv+'.VAL')
self.dmov = EpicsSignalRO(self.base_pv+'.DMOV', auto_monitor=True)
self.name = name
def mv(self, target, wait=False):
self.set(target)
if wait:
time.sleep(0.2)
while self.dmov.value==0:
time.sleep(0.2)
def mvr(self, adjustment, wait=False):
target = self.get() + adjustment
self.mv(target, wait=wait)
def set(self, target):
self.val.set(target)
def get(self):
return self.rbv.value
def wm(self):
return self.get()
class HxnScanStatus:
'''Broadcast if a scan is in progress via PV
Processed on every start/end document
'''
def __init__(self, running_pv):
self._last_start = None
self.running_signal = EpicsSignal(running_pv)
self._running = False
@property
def running(self):
return self._running
@running.setter
def running(self, running):
self._running = running
if running is None:
running = 0
try:
self.running_signal.put(running)
except DisconnectedError:
logger.error('ScanRunning PV disconnected. Is the hxntools IOC running?')
def __call__(self, name, doc):
'''Bluesky callback with document info'''
if name == 'start':
self._last_start = doc
if self._last_start and name in ('start', 'stop'):
self.running = (name == 'start')
def move_to_target(frame_cfg=[1, 'F1', 1, 'F2', 1, 'F3'],
frame=1,
target='A1'):
'''
Description: script to move to a predefined target in the target holder. Assuming
for now that columns are letters, and raws are numbers. Columns start from A and
finish at I from left to right and raws start from 1 to 7 from top to bottom. All
these while looking at the target holder from the back (opposite view from questar 1).
Since everytarget frame is position a few 100um differt due to screw slop, there are two
epics user pv that can be set as a correction for each target. These correctionis should be
small (<1mm), and are best reset when going to a different frame. They are the user PVs
57 and 58.
IN:
frame_cfg : the configuration of the frames on the target holder as viewed from
the back, meaning the opposite view of Q1. TO DO: need to confirm size
of the half-U frame.
frame : the number of the frame where the targets are located. Can be full size
or half size U frame. TO DO: need to confirm size of the half-U frame.
target : the number of the target to go to within this frame.
OUT:
move to target
'''
xcorr = EpicsSignal('MEC:NOTE:DOUBLE:57').get()
ycorr = EpicsSignal('MEC:NOTE:DOUBLE:58').get()
# 1U is 40mm large, 0.5U is 20mm, starting from just after the calibration cartridge
global msg_log_target
frame_pos = x_start_pos
if (frame > 1):
# -1 to not account for the first frame, and count for the other position in the array
for idx in np.arange(0, 2 * (frame - 1), 2):
if (frame_cfg[idx] == 1):
frame_pos = frame_pos + one_u
else:
frame_pos = frame_pos + half_u
# starting position from where the target value will be evaluated
# +1 because the array start
target_col = letter_arr.index(target[0]) + 1
target_raw = int(target[1])
# initialisation of x and y target positions
y_target_pos = y_start_pos
x_target_pos = 0.0
# calculating the y position of the target
if (target_raw > 1):
y_target_pos = y_target_pos + ((target_raw - 1) * y_step)
# calculatinf the x position of the target
if (target_col > 1):
x_target_pos = x_target_pos + ((target_col - 1) * x_step)
# execute the motion
tgx(pin_pos - (x_target_pos + frame_pos) + xcorr)
hexy.put(y_target_pos + ycorr)
print('Moving to Frame {}, target {}.'.format(frame, target))
print('Tweak position as appropriate.')
print('The frame configuration is {}.'.format(frame_cfg))
# print in the eLog only the naming used by the users to avoid confusion
msg_log_target = 'on frame {}, target {}'.format(
frame_cfg[(2 * frame) - 1], target)
def test_local_without_defaults_no_string(testdir):
from ophyd import EpicsSignal
signal = EpicsSignal(f"{pv_base}.SCAN", name="signal")
signal.wait_for_connection()
desc = signal.describe()
assert not signal.as_string
assert desc["signal"]["dtype"] == "integer"
class HDCMPIEZOPITCH(PVPositionerPC):
setpoint = Cpt(EpicsSignal, '')
readback = Cpt(EpicsSignalRO, '')
pid_enabled = EpicsSignal('XF:05IDD-CT{FbPid:02}PID:on')
pid_I = EpicsSignal('XF:05IDD-CT{FbPid:02}PID.I')
def reset_pid(self):
yield from bps.mov(self.pid_I, 0.0)
def __init__(self, part):
# Let errors propagate
self._name = part.get('name')
self._vset = part.get('vset')
self._base = part.get('base')
self._scale = part.get('scale')
self._ramping = EpicsSignalRO(f'{self._base}{RAMPING}')
self._set_voltage = EpicsSignal(f'{self._base}{VSET}')
def pv_scan(detectors, pvname, start, stop, num, events=None):
"""
Scan over a PV as a UI test utility
"""
sig = EpicsSignal(pvname, name=pvname)
mot = PhonyMotor(sig)
config_in_scan(detectors, [mot], events)
sig.wait_for_connection()
return (yield from scan(detectors, sig, start, stop, num))
def live_data_stream(self):
self.PVs = GetPVs()
gatt = self.PVs.get('gatt', None)
self.signal_gatt = EpicsSignal(gatt)
#wave8 = self.PVs.get('wave8', None)
#self.signal_wave8 = EpicsSignal(wave8)
diff = self.PVs.get('diff', None)
self.signal_diff = EpicsSignal(diff)
self.gatt = self.signal_gatt.get()
self.diff = self.signal_diff.get()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._num_images = 1
self._acquisition_signal = self.cam.acquire
self._counter_signal = self.cam.array_counter
#self._trigger_signal = EpicsSignal('XF:16ID-TS{EVR:C1-Out:FP3}Src:Scale-SP')
self._trigger_signal = EpicsSignal('XF:16IDC-ES{Zeb:1}:SOFT_IN:B0')
self._status = None
self.first = True
self.acq_t = 0
def __init__(self,
open=None,
open_status=None,
close=None,
close_status=None):
super(Shutter, self).__init__()
signals = [
EpicsSignal(open_status, write_pv=open, alias='_open'),
EpicsSignal(close_status, write_pv=close, alias='_close'),
]
for sig in signals:
self.add_signal(sig)
class ValueReader(metaclass=Singleton):
def __init__(self, signals):
self.signals = signals
self.PVs = dict()
self.PV_signals = list()
self.live_data = True
self.signals.run_live.connect(self.run_live_data)
def run_live_data(self, live):
self.live_data = live
def live_data_stream(self):
self.PVs = GetPVs()
gatt = self.PVs.get('gatt', None)
self.signal_gatt = EpicsSignal(gatt)
#wave8 = self.PVs.get('wave8', None)
#self.signal_wave8 = EpicsSignal(wave8)
diff = self.PVs.get('diff', None)
self.signal_diff = EpicsSignal(diff)
self.gatt = self.signal_gatt.get()
self.diff = self.signal_diff.get()
def sim_data_stream(self):
"""
context_data = zmq.Context()
socket_data = context_data.socket(zmq.SUB)
socket_data.connect(".join(['tcp://localhost:', '8123'])")
socket_data.subscribe("")
while True:
md = socket_data.rev_json(flags=0)
msg = socket.recv(flags=0,copy=false, track=false)
buf = memoryview(msg)
data = np.frombuffer(buf, dtype=md['dtype'])
data = np.ndarray.tolist(data.reshape(md['shape']))
self.gatt = data[0]
self.diff = data[1]
"""
x = 0.8
y = 0.4
self.gatt = sinwv(x)
self.diff = sinwv(y)
def read_value(self): # needs to initialize first maybe using a decorator?
if self.live_data:
self.live_data_stream()
return({'gatt': self.gatt, 'diff': self.diff})
else:
self.sim_data_stream()
return({'gatt': self.gatt, 'diff': self.diff})
def calibrate():
for i in range(4):
EpicsSignal(pv + 'CurrentScale' + str(i + 1)).put(1)
EpicsSignal(pv + 'CurrentOffset' + str(i + 1)).put(0)
EpicsSignal(pv + 'Range').put(0)
time.sleep(1)
EpicsSignal(pv + 'CalibrationMode').put(1)
time.sleep(1)
EpicsSignal(pv + 'CopyADCOffsets.PROC').put(0)
time.sleep(1)
EpicsSignal(pv + 'CalibrationMode').put(0)
time.sleep(1)
try:
with open(path + "/offsets.csv", "r") as f:
print('Offset file already exists.')
i = 0
for line in f:
if i <= 3:
EpicsSignal(pv + 'ADCOffset' + str(i + 1)).put(
line.strip())
print('Setting ADCOffset ' + str(i + 1) + ' to ' +
line.strip() + '.')
i += 1
except Exception as e:
print(e)
print('Offset file does not exist. Calibrating.')
f = open(path + "/offsets.csv", "w")
for i in range(4):
offset = EpicsSignal(pv + 'ADCOffset' + str(i + 1)).get()
f.write(str(offset) + '\n')
print('offset ' + str(i) + ': ' + str(offset))
f.close()
print('Finished')
def stop_turbo():
turbo_onoff = EpicsSignal('XF:12IDC-VA:2{Det:300KW-TMP:1}OnOff',
name='turbo_onoff')
turbo_onoff.put(0)
iv1 = EpicsSignal('XF:12IDC-VA:2{Det:300KW-IV:1}Cmd:Cls-Cmd', name='iv1')
iv1.put(1)
async def pid_output_name(self, instance, async_lib):
while (self.pid_output_name.value == ''):
await async_lib.sleep(1)
self.pid_output = EpicsSignal(self.pid_output_name.value,
name='pid_output')
def subscription(value, **kwargs):
if value != 0:
if self.pid_enable is not None:
if self.pid_enable.get() == 0:
self.pid_output.put(0)
self.pid_output.subscribe(subscription)
class Ring(Device):
current = EpicsSignalRO('SR:C03-BI{DCCT:1}I:Real-I', name='ring_current')
lifetime = EpicsSignalRO('SR:OPS-BI{DCCT:1}Lifetime-I',
name='ring_lifetime')
energy = EpicsSignalRO('SR{}Energy_SRBend', name='ring_energy')
mode = EpicsSignal('SR-OPS{}Mode-Sts', name='ring_ops', string=True)
filltarget = EpicsSignalRO('SR-HLA{}FillPattern:DesireImA',
name='ring_filltarget')
def bias():
#BIAS
f = open(path+"/bias.csv","w")
out='bias,rbv,measured'
f.write(out+'\n')
biases=np.arange(-10,11) #array from -10 to 10
for bias in biases:
for i in range(3):
EpicsSignal(pv+'BiasVoltage').put(bias)
time.sleep(0.1)
pro.write("meas:volt:dc?",27)
value_measured=pro.readline()
value_RBV=EpicsSignal(pv+'BiasVoltage_RBV').get()
out=str(bias)+', '+str(value_RBV)+', '+value_measured.split(',')[0].split('N')[0]
print(out)
f.write(out+'\n')
f.close()
print('Finished')
def test_read_pv_timestamp_monitor(self):
mtr = EpicsMotor(config.motor_recs[0])
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname, auto_monitor=True)
rbv = EpicsSignalRO(mtr.user_readback.pvname, auto_monitor=True)
rbv_value0 = rbv.get()
ts0 = rbv.timestamp
sp.put(sp.value + 0.1, wait=True)
time.sleep(0.1)
rbv_value1 = rbv.get()
ts1 = rbv.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(rbv_value0 + 0.1, rbv_value1)
sp.put(sp.value - 0.1, wait=True)
def collect(id):
while time.time() < start_time+span:
if id==0:
pro.write("meas:volt:dc?",13)
value_measured_orig=pro.readline()
value_measured=value_measured_orig.split(',')[0].split('N')[0]
try:
volts.append(float(value_measured))
except:
print(value_measured_orig+'.split(\',\')[0].split(\'N\')[0] cannot be converted into a float')
if id==1:
isAquiring = EpicsSignal(pv+'TS:TSAcquiring').get()
if isAquiring == 0: #if it's done acquiring
for channel in range(1): #collect data for each channel
curr_str=EpicsSignal(pv+'TS:Current'+str(channel+1)+':TimeSeries').value
#print(str(channel)+' '+str(curr_str))
currentArr[channel].append(curr_str[0])
EpicsSignal(pv+'TS:TSAcquire').put(1) #acquire new data
class BYKIKS_BURST(Display):
_abort_req = EpicsSignal(ABORT_REQ_PV)
_last_shots = EpicsSignalRO(LAST_SHOTS_PV)
_last_enable = EpicsSignalRO(LAST_EN_PV)
_cur_shots = EpicsSignal(CUR_SHOTS_PV)
_cur_enable = EpicsSignal(CUR_EN_PV)
def __init__(self, parent=None, args=None, macros=None):
super(BYKIKS_BURST, self).__init__(parent=parent,
args=args,
macros=macros)
self._abort_req.subscribe(self.abort_clbk)
self.ui.clear_abort_btn.clicked.connect(self.clear_abort)
def ui_filename(self):
"""Boiler plate pydm"""
return 'bykiks_burst.ui'
def ui_filepath(self):
"""Boiler plate pydm"""
return os.path.join(os.path.dirname(os.path.realpath(__file__)),
self.ui_filename())
def _set_emer_vis(self, val):
"""Hide or Show label if abort is active"""
if int(val) is 1:
#self.ui.abort_en_cb.setDisabled(True)
#self.ui.num_shots_le.setDisabled(True)
self.ui.emer_label.show()
self.ui.clear_abort_btn.show()
else:
#self.ui.abort_en_cb.setDisabled(False)
#self.ui.num_shots_le.setDisabled(False)
self.ui.emer_label.hide()
self.ui.clear_abort_btn.hide()
def abort_clbk(self, value, **kwargs):
self._set_emer_vis(value)
def clear_abort(self):
# Get the previous values and restore
self._cur_shots.put(self._last_shots.get())
self._cur_enable.put(self._last_enable.get())
self._abort_req.put(0)
def test_write_pv_timestamp_no_monitor(motor):
motor.set(0, wait=True)
sp = EpicsSignal(motor.user_setpoint.pvname, name='test')
sp_value0 = sp.get()
ts0 = sp.timestamp
sp.put(sp_value0 + 0.1, wait=True)
time.sleep(0.1)
sp_value1 = sp.get()
ts1 = sp.timestamp
assert ts1 > ts0
assert_almost_equal(sp_value0 + 0.1, sp_value1)
sp.put(sp.get() - 0.1, wait=True)
def __init__(self):
self._sync_markers = {
0.5: 0,
1: 1,
5: 2,
10: 3,
30: 4,
60: 5,
120: 6,
360: 7
}
with safe_load('Spare Event Sequencer'):
self.seq2 = EventSequencer('ECS:SYS0:11', name='seq_11')
with safe_load('PP trigger'):
self.evr_pp = Trigger('XCS:USR:EVR:TRIG1', name='evr_pp')
with safe_load('SmarAct'):
self.las1 = SmarActTipTilt(prefix='XCS:MCS2:01',
tip_pv=':m1',
tilt_pv=':m2',
name='las1')
self.las2 = SmarActTipTilt(prefix='XCS:MCS2:01',
tip_pv=':m4',
tilt_pv=':m5',
name='las2')
self.las3 = SmarActTipTilt(prefix='XCS:MCS2:01',
tip_pv=':m7',
tilt_pv=':m8',
name='las3')
# with safe_load('elog'):
# kwargs = dict()
# self.elog = HutchELog.from_conf('XCS', **kwargs)
#
with safe_load('lw68_motors'):
self.iStar_focus = Newport('XCS:USR:MMN:06', name='iStar_focus')
self.bbo_wp = Newport('XCS:USR:MMN:07', name='bbo_wp')
self.huber_x = IMS('XCS:USR:MMS:40', name='huber_x')
self.huber_y = IMS('XCS:USR:MMS:37', name='huber_y')
self.ldx = IMS('XCS:LAM:MMS:06', name='ldx')
self.ldy = IMS('XCS:LAM:MMS:07', name='ldy')
self.bs6x = IMS('XCS:LAM:MMS:11', name='bs6x')
self.bs6y = IMS('XCS:LAM:MMS:12', name='bs6y')
self.att = IMS('XCS:SB2:MMS:15', name='att')
# need to chose one ATT motor that does the desired attenuation and identify the two positions to go just in/out. Motor 15 is the 320um filter which does about a factor of 10.
with safe_load('Triggers'):
self.gateEVR = Trigger('XCS:R42:EVR:01:TRIG4', name='evr_trig4')
self.gateEVR_ticks = EpicsSignal('XCS:R42:EVR:01:CTRL.DG4D',
name='evr_trig4_ticks')
self.GD = self.gateEVR.ns_delay
self.tx = self.huber_y
self.ty = gon_sy
self.tn = self.huber_x
#self.ty = xcs_gon.ver
self.lp = LaserShutter('XCS:USR:ao1:7', name='lp')
def test_read_pv_timestamp_no_monitor(motor):
motor.set(0, wait=True)
sp = EpicsSignal(motor.user_setpoint.pvname, name='test')
rbv = EpicsSignalRO(motor.user_readback.pvname, name='test')
assert rbv.get() == sp.get()
rbv_value0 = rbv.get()
ts0 = rbv.timestamp
sp.put(sp.get() + 0.1)
time.sleep(.5)
rbv_value1 = rbv.get()
ts1 = rbv.timestamp
assert ts1 > ts0
assert_almost_equal(rbv_value0 + 0.1, rbv_value1)
sp.put(sp.get() - 0.1)
def scan():
pv_EM1 = 'quadEMTest:NSLS_EM:'
pv_motor = 'RGD:'
pv_EM2 = 'XF:12IDA-BI:2{EM:BPM1}'
home_position = [25.05,-10,38.808]
#home_position = [0,0,0]
step_size=0.005 #in mm
radius=1 #in mm
init_pos = np.add(home_position,[-radius,0,-radius])
positions = []
for i in range(int(radius*2/step_size + 1)):
for j in range(int(radius*2/step_size + 1)):
delta=[step_size*j,0,step_size*i]
positions.append(np.add(init_pos,delta))
#print(positions)
f = open(path+"/scan_"+str(step_size)+"mm.csv","w")
#out='x,y,z,photodiode (micro amp), current A, current B, current C, current D'
#f.write(out+'\n')
for i in range(len(positions)):
EpicsSignal(pv_motor+'X.VAL').put(positions[i][0])
EpicsSignal(pv_motor+'Z.VAL').put(positions[i][2])
if(i%int(radius*2/step_size + 1)==0):
time.sleep(2)
else:
time.sleep(0.3)
currA=EpicsSignal(pv_EM2+'Current1:MeanValue_RBV').get()
currB=EpicsSignal(pv_EM2+'Current2:MeanValue_RBV').get()
currC=EpicsSignal(pv_EM2+'Current3:MeanValue_RBV').get()
currD=EpicsSignal(pv_EM2+'Current4:MeanValue_RBV').get()
currPhoto=EpicsSignal(pv_EM1+'Current1:MeanValue_RBV').get()
print('moved to '+str(positions[i][0]-home_position[0])+', '+str(positions[i][2]-home_position[2]))
out=str(positions[i][0])+', '+str(positions[i][1])+', '+str(positions[i][2])+', '+str(currPhoto)+', '+str(currA)+', '+str(currB)+', '+str(currC)+', '+str(currD)
print(out)
f.write(out+'\n')
f.close()
EpicsSignal(pv_motor+'X.VAL').put(home_position[0])
EpicsSignal(pv_motor+'Y.VAL').put(home_position[1])
EpicsSignal(pv_motor+'Z.VAL').put(home_position[2])
print("Finished")
class Ramper(Device):
pv_sp = Cpt(EpicsSignal, 'pv_sp', name='pv_sp')
pv_sp_rate = Cpt(EpicsSignal, 'pv_sp_rate', name='pv_sp_rate') # pv setpoint change rate in pv units per minute
go = Cpt(EpicsSignal, 'go', name='go')
pv_pause = EpicsSignal('XF:08IDB-Ramping:pause', name='pv_pause')
tprog = Cpt(EpicsSignal, 'tprog', name='tprog')
pvprog = Cpt(EpicsSignal, 'pvprog', name='pvprog')
dwell = Cpt(EpicsSignal, 'dwell', name='dwell')
safety_thresh = Cpt(EpicsSignal, 'safety_thresh', name='safety_thresh')
safety_timer = Cpt(EpicsSignal, 'safety_timer', name='safety_timer')
pid_enable_name = Cpt(EpicsSignal, 'pid_enable_name', name='pid_enable_name')
pid_output_name = Cpt(EpicsSignal, 'pid_output_name', name='pid_output_name')
def __init__(self, aux_pv_sp=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.aux_pv_sp = aux_pv_sp
self._subscribe_aux_pv_sp()
self.subscribe_safety_timer_upd()
def _subscribe_aux_pv_sp(self):
if self.aux_pv_sp is not None:
def subscription(value, **kwargs):
setpoint = value
self.aux_pv_sp.put(setpoint)
return
self.pv_sp.subscribe(subscription)
def subscribe_safety_timer_upd(self):
def subscription(value, **kwargs):
if value>5:
self.safety_timer.put(0)
self.safety_timer.subscribe(subscription)
def enable(self):
self.pv_pause.put(0)
self.go.put(1)
def pause(self):
self.pv_pause.put(1)
def depause(self):
self.pv_pause.put(0)
def disable(self, pv_sp_value=25):
self.go.put(0)
self.pv_pause.put(0)
ttime.sleep(0.3)
if pv_sp_value is not None:
self.pv_sp.put(pv_sp_value)
def collect(id):
while time.time() < start_time+span:
if id==0: #Temperature collection
#pro.write("meas:volt:dc?",13)
#value_measured_orig=pro.readline()
#value_measured=value_measured_orig.split(',')[0].split('N')[0]
if id==1: #Drift collection
isAquiring = EpicsSignal(pv_EM6+'TS:TSAcquiring').get()
if isAquiring == 0: #if it's done acquiring
channel=1 #1-4
curr_str=EpicsSignal(pv_EM6+'TS:Current'+channel+':TimeSeries').value
drift_curr_6.append(curr_str[0])
EpicsSignal(pv_EM6+'TS:TSAcquire').put(1) #acquire new data
temp_thread = threading.Thread(target=collect, args=(0,))
drift_thread = threading.Thread(target=collect, args=(1,))
EpicsSignal(pv_EM6+'TS:TSAcquire').put(1) #acquire new data
start_time=time.time()
# starting thread 1
drift_thread.start()
# starting thread 2
temp_thread.start()
# wait until thread 1 is completely executed
drift_thread.join()
# wait until thread 2 is completely executed
temp_thread.join()
end_time=time.time()
temp_curr_mean = np.average(temp_curr_102)
temp_curr_std = np.std(temp_curr_102,ddof=1)
temp_curr_num = len(temp_curr_102)
drift_curr_mean = np.average(drift_curr_6)
drift_curr_std = np.std(drift_curr_6,ddof=1)
drift_curr_num=len(drift_curr_6)
out=str(start_time)+','+str(end_time)+','+str(voltage_mean)+','+str(voltage_std)+','+str(voltage_num)+','+str(current_mean)+','+str(current_std)+','+str(current_num)
print(out)
f.write(out+'\n')
f.flush()
def test_add_signal(sim_signal):
# Create Signals
epics_sig = EpicsSignal('Tst:This')
# Create empty plot
ttp = TyphonTimePlot()
# Add to list of available signals
ttp.add_available_signal(epics_sig, 'Epics Signal')
assert ttp.ui.signal_combo.itemText(0) == 'Epics Signal'
assert ttp.ui.signal_combo.itemData(0) == 'ca://Tst:This'
ttp.add_available_signal(sim_signal, 'Simulated Signal')
assert ttp.ui.signal_combo.itemText(1) == 'Simulated Signal'
assert ttp.ui.signal_combo.itemData(1) == 'sig://tst_this_2'
def dark_current():
shb = user_ns['shb']
reopen = shb.state.get() == shb.openval
if reopen:
print('\nClosing photon shutter')
yield from shb.close_plan()
print('Measuring current offsets, this will take several seconds')
EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset1.PROC",
name='').put(1)
EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset2.PROC",
name='').put(1)
EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset3.PROC",
name='').put(1)
EpicsSignal("XF:06BM-BI{EM:1}EM180:ComputeCurrentOffset4.PROC",
name='').put(1)
yield from sleep(3)
BMM_log_info('Measured dark current on quadem1')
if reopen:
print('Opening photon shutter')
yield from shb.open_plan()
print('You are ready to measure!\n')
class MaxiGauge:
def __init__(self, devName):
self.pres_sig = EpicsSignal(devName + 'P:Raw-I')
def pressure(self):
msg = self.pres_sig.get()
if msg == "UNDER":
return 1.0e-3
elif msg == "OVER":
return 1.1e3
else:
return float(msg)
def gv_temp_open(sysdev, duration):
"""
gv_temp_open("XF:21IDB-VA{BT:10-GV:10_D_1}", 1.5 (seconds))
"""
open_pv_str = sysdev + "Cmd:Opn-Cmd"
close_pv_str = sysdev + "Cmd:Cls-Cmd"
open_cmd = EpicsSignal(name="open_cmd",
read_pv=open_pv_str,
write_pv=open_pv_str)
close_cmd = EpicsSignal(name="close_cmd",
read_pv=close_pv_str,
write_pv=close_pv_str)
open_cmd.put(1)
time.sleep(duration)
close_cmd.put(1)
def cryofill(wait_time_after_v19_claose=60 * 10):
cryo_v19_possp = EpicsSignal('XF:05IDA-UT{Cryo:1-IV:19}Pos-SP',
name='cryov19_possp')
cryo_v19_possp.set(100)
while abs(cryo_v19.get() - 1) > 0.05:
cryo_v19_possp.set(100)
time.sleep(2)
time.sleep(5)
while (cryo_v19.get() - 0) > 0.05:
print('cryo cooler still refilling')
time.sleep(5)
cryo_v19_possp.set(0)
print('waiting for', wait_time_after_v19_claose, 's',
'before taking data...')
time.sleep(wait_time_after_v19_claose)
def __init__(self, *args, gain_0, gain_1, gain_2, hspeed_bit, bw_10mhz_bit, bw_1mhz_bit, lnoise, hspeed, bwidth, par = None, **kwargs):
super().__init__(*args, **kwargs)
self.gain_0 = EpicsSignal(self.prefix + gain_0, name=self.name + '_gain_0')
self.gain_1 = EpicsSignal(self.prefix + gain_1, name=self.name + '_gain_1')
self.gain_2 = EpicsSignal(self.prefix + gain_2, name=self.name + '_gain_2')
self.hspeed_bit = EpicsSignal(self.prefix + hspeed_bit, name=self.name + '_hspeed_bit')
self.bw_10mhz_bit = EpicsSignal(self.prefix + bw_10mhz_bit, name=self.name + '_bw_10mhz_bit')
self.bw_1mhz_bit = EpicsSignal(self.prefix + bw_1mhz_bit, name=self.name + '_bw_1mhz_bit')
self.low_noise_gain = EpicsSignal(self.prefix + lnoise, name=self.name + '_lnoise')
self.high_speed_gain = EpicsSignal(self.prefix + hspeed, name=self.name + '_hspeed')
self.band_width = EpicsSignal(self.prefix + bwidth, name=self.name + '_bwidth')
self.par = par
def test_write_pv_timestamp_no_monitor(self):
mtr = EpicsMotor(config.motor_recs[0])
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname)
sp_value0 = sp.get()
ts0 = sp.timestamp
sp.put(sp_value0 + 0.1, wait=True)
time.sleep(0.1)
sp_value1 = sp.get()
ts1 = sp.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(sp_value0 + 0.1, sp_value1)
sp.put(sp.value - 0.1, wait=True)
from ophyd import (EpicsSignal, Signal)
from ophyd.utils.epics_pvs import record_field
def callback(sub_type=None, timestamp=None, value=None, **kwargs):
logger.info('[callback] [%s] (type=%s) value=%s', timestamp, sub_type,
value)
# Test that the monitor dispatcher works (you cannot use channel access in
# callbacks without it)
logger.info('[callback] caget=%s', rw_signal.get())
logger = config.logger
motor_record = config.motor_recs[0]
val = record_field(motor_record, 'VAL')
rbv = record_field(motor_record, 'RBV')
rw_signal = EpicsSignal(rbv, write_pv=val)
rw_signal.subscribe(callback, event_type=rw_signal.SUB_VALUE)
rw_signal.subscribe(callback, event_type=rw_signal.SUB_SETPOINT)
rw_signal.value = 2
time.sleep(1.)
rw_signal.value = 1
time.sleep(1.)
# You can also create a Python Signal:
sig = Signal(name='testing', value=10)
logger.info('Python signal: %s', sig)
def __init__(self, running_pv):
self._last_start = None
self.running_signal = EpicsSignal(running_pv)
self._running = False
class ICAmplifier(Device):
#low_noise_gain = Cpt(EpicsSignal, 'LN}I0')
def __init__(self, *args, gain_0, gain_1, gain_2, hspeed_bit, bw_10mhz_bit, bw_1mhz_bit, lnoise, hspeed, bwidth, par = None, **kwargs):
super().__init__(*args, **kwargs)
self.gain_0 = EpicsSignal(self.prefix + gain_0, name=self.name + '_gain_0')
self.gain_1 = EpicsSignal(self.prefix + gain_1, name=self.name + '_gain_1')
self.gain_2 = EpicsSignal(self.prefix + gain_2, name=self.name + '_gain_2')
self.hspeed_bit = EpicsSignal(self.prefix + hspeed_bit, name=self.name + '_hspeed_bit')
self.bw_10mhz_bit = EpicsSignal(self.prefix + bw_10mhz_bit, name=self.name + '_bw_10mhz_bit')
self.bw_1mhz_bit = EpicsSignal(self.prefix + bw_1mhz_bit, name=self.name + '_bw_1mhz_bit')
self.low_noise_gain = EpicsSignal(self.prefix + lnoise, name=self.name + '_lnoise')
self.high_speed_gain = EpicsSignal(self.prefix + hspeed, name=self.name + '_hspeed')
self.band_width = EpicsSignal(self.prefix + bwidth, name=self.name + '_bwidth')
self.par = par
def set_gain(self, value: int, high_speed: bool):
val = int(value) - 2
if not ((high_speed and (1 <= val < 7)) or (not high_speed and (0 <= val < 6))):
print('{} invalid value. Ignored...'.format(self.name))
return 'Aborted'
if high_speed:
val -= 1
self.low_noise_gain.put(0)
self.high_speed_gain.put(val + 1)
self.hspeed_bit.put(1)
else:
self.low_noise_gain.put(val + 1)
self.high_speed_gain.put(0)
self.hspeed_bit.put(0)
self.gain_0.put((val >> 0) & 1)
self.gain_1.put((val >> 1) & 1)
self.gain_2.put((val >> 2) & 1)
def set_gain_plan(self, value: int, high_speed: bool):
val = int(value) - 2
if not ((high_speed and (1 <= val < 7)) or (not high_speed and (0 <= val < 6))):
print('{} invalid value. Ignored...'.format(self.name))
return 'Aborted'
if high_speed:
val -= 1
yield from bps.abs_set(self.low_noise_gain, 0)
yield from bps.abs_set(self.high_speed_gain, val + 1)
yield from bps.abs_set(self.hspeed_bit, 1)
else:
yield from bps.abs_set(self.low_noise_gain, val + 1)
yield from bps.abs_set(self.high_speed_gain, 0)
yield from bps.abs_set(self.hspeed_bit, 0)
yield from bps.abs_set(self.gain_0, (val >> 0) & 1)
yield from bps.abs_set(self.gain_1, (val >> 1) & 1)
yield from bps.abs_set(self.gain_2, (val >> 2) & 1)
def get_gain(self):
if self.low_noise_gain.value == 0:
return [self.high_speed_gain.enum_strs[self.high_speed_gain.value], 1]
elif self.high_speed_gain.value == 0:
return [self.low_noise_gain.enum_strs[self.low_noise_gain.value], 0]
else:
return ['0', 0]
