def buffering_low(self):
status = PV('status')
if not util.check_device('C1', self.proc) and status.get() in range(0,3):
print "device not connected"
return False
count3 = PV('in_counts_3')
low_3 = PV('low_limit_3')
low_4 = PV('low_limit_4')
trig_buffer = PV('trig_buffer')
init = PV('initiate')
poll(evt=1.e-5, iot=0.01)
data3 = []
def getCount3(pvname, value, **kw):
data3.append(value)
if util.put_check(low_3, 0.0) and util.put_check(low_4, 0.0) and util.put_check(trig_buffer, 1000) and util.put_fuzzy('analog_out_period', 10e-5, 0.05):
pass
else:
print "setting not taking place"
return False, False
count3.add_callback(getCount3)
init.put(1)
t0 = time.time()
while time.time() - t0 < 3:
poll(evt=1.e-5, iot=0.01)
time.sleep(2)
return len(data3)
class Motor(object):
def __init__(self, name='SOL1B_M1'):
if name not in mtc.MOTORS.keys():
raise ValueError('You have not specified a valid motor')
motor_dict = mtc.MOTORS[name]
self._name = name
self._set = PV(motor_dict['set'])
self._rbv = PV(motor_dict['rbv'])
self._status = PV(motor_dict['status'])
self._status_vars = self._status.get_ctrlvars()
self._logger = logger.custom_logger(__name__)
@property
def name(self):
return self._name
@property
def pos_set(self):
return self._set.get()
@pos_set.setter
def pos_set(self, val):
if not isinstance(val, int) or isinstance(val, float):
self._logger('position must be int or float')
return
self._set.put(val)
@property
def pos_rbv(self):
return self._rbv.get()
@property
def status_vars(self):
return self._status_vars
def fault_codes(self):
connect = self.proc.expect(
[pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5)
if connect != 2:
return -1
cmux_0, cmux_1, cmux_2, cmux_3 = PV('c_mux_0'), PV('c_mux_1'), PV('c_mux_2'), PV('c_mux_3')
fault_message = PV('r_psu_fault_message')
faults = []
perms = itertools.product([0,1], repeat=4)
for i,j,k,c in list(perms):
#print i,j,k,c
cmux_0.put(i)
poll(evt=0.1, iot=0.1)
cmux_1.put(j)
poll(evt=0.1, iot=0.1)
cmux_2.put(k)
poll(evt=0.1, iot=0.1)
cmux_3.put(c)
poll(evt=0.1, iot=0.1)
faults.append(fault_message.get())
#print cmux_1.get(), cmux_2.get(), cmux_3.get(), cmux_4.get()
return faults
def setupBlComm():
# global message_string_pv
thread.start_new_thread(process_commands,(.05,))
# message_string_pv = PV(beamlineName + "_comm:message_string")
comm_pv = PV(beamlineName + "_comm:command_s")
comm_pv.put("\n",wait=True)
comm_pv.add_callback(comm_cb)
def move(self, val, wait=True, delta=0.005, timeout=360.0):
"""Put value and press Go button."""
PV.put(self, val)
sleep(0.2)
self.go.put(1)
if wait:
Motor.motorWait(self, val, delta, timeout)
class BeckhoffMotor(Motor):
"""Beckhoff Motor class which inherits from pvScan Motor class."""
def __init__(self, pvname, pvnumber=0):
if 'ESB' in pvname:
rbv = pvname.split(':')[0] + ':CALC:' + ':'.join(pvname.split(':')[3:5]) + ':POS:MM'
go = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[3:5]) + ':GO:POS'
abort = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[3:5]) + ':STOP'
elif 'UEDM' in pvname:
rbv = pvname.split(':')[0] + ':UEDM:' + 'AI:' + pvname.split(':')[-2] + ':POS'
go = pvname.split(':')[0] + ':UEDM:' + 'BO:' + pvname.split(':')[-2] + ':GOPOS'
abort = pvname.split(':')[0] + ':UEDM:' + pvname.split(':')[-2] + ':STOP'
else:
rbv = pvname.split(':')[0] + ':CALC:' + ':'.join(pvname.split(':')[2:3]) + ':POS:MM'
go = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[2:3]) + ':GO:POS:ABS'
abort = pvname.split(':')[0] + ':BO:' + ':'.join(pvname.split(':')[2:3]) + ':STOP'
BasePv.__init__(self, pvname, pvnumber, rbv)
self.go = PV(go)
self.abort = PV(abort)
def move(self, val, wait=True, delta=0.005, timeout=360.0):
"""Put value and press Go button."""
PV.put(self, val)
sleep(0.2)
self.go.put(1)
if wait:
Motor.motorWait(self, val, delta, timeout)
def testEnumPut(self):
pv = PV(pvnames.enum_pv)
self.assertIsNot(pv, None)
pv.put('Stop')
time.sleep(0.1)
val = pv.get()
self.assertEqual(val, 0)
def acquisition_modes(self):
if not self.connected:
print "Device not connected"
return False
data = []
acquisition_mode = PV('acquisition_mode')
burst_count = PV('burst_count')
poll(evt=0.1, iot=0.1)
print acquisition_mode.get()
for i in range(0, 6):
#acquisition_mode.put(i)
util.put_check(acquisition_mode, i)
if i == 5:
util.put_check(burst_count, 0)
#util.put_check(acquisition_mode, i)
poll(evt=0.1, iot=0.1)
print acquisition_mode.get()
if acquisition_mode.get() == i:
data.append(True)
else:
data.append(False)
print data
#teardown
#acquisition_mode.put(0)
#util.put_check(acquisition_mode, 1)
acquisition_mode.put(1)
print acquisition_mode.get()
util.put_check(acquisition_mode, 0)
#acquisition_mode.put(0)
print acquisition_mode.get()
poll(evt=1.0, iot=1.0)
return data
def move(self, val, wait=True, delta=0.005, timeout=360.0):
"""Put value and press Go button."""
PV.put(self, val)
sleep(1)
self.go.put(1)
if wait:
self.pvWait(val, delta, timeout)
class SyncedPV():
def __init__(self,
linked_pvname,
synced_pvname,
operation,
auto_sync=False):
self.operation_fun = self.get_operation(operation)
self.auto_sync = auto_sync
self.linked_pv = PV(linked_pvname)
self.synced_pv = PV(synced_pvname,
auto_monitor=True,
callback=self.synced_pv_callback)
self.sync_value = self.synced_pv.value
def synced_pv_callback(self, pvname, value, **kwargs):
if (self.auto_sync):
self.linked_pv.put(self.operation_fun(self.linked_pv.value, value))
self.sync_value = value
def sync(self):
self.linked_pv.put(
self.operation_fun(self.linked_pv.value, self.synced_pv.value))
def get_operation(self, operation):
if (operation == '*'):
return multiply
elif (operation == '='):
return equals
def acquire_image_spectrum():
print("push acquisition of the N image + average image")
push_acq_image = PV('CAM1:det1:Acquire')
push_acq_image.put(1)
# push the spectrum acquisition +
push_acq_spectr = PV('CCS1:det1:Acquire')
push_acq_spectr.put(1)
#
sleep(10)
print("acquire image")
im_pv = PV('CAM1:image1:ArrayData')
im = im_pv.get()
sizex = PV('CAM1:det1:ArraySizeX_RBV')
sizey = PV('CAM1:det1:ArraySizeY_RBV')
nx = sizex.get()
ny = sizey.get()
#print('size image :', nx, ny)
#print('size im' , im.shape)
im0 = im.reshape(nx, ny)
#print('size im' , im.shape)
#print(im)
return im.ravel(), nx, ny
def test_emptyish_char_waveform_no_monitor(self):
'''a test of a char waveform of length 1 (NORD=1): value "\0"
without using auto_monitor
'''
with no_simulator_updates():
zerostr = PV(pvnames.char_arr_pv, auto_monitor=False)
zerostr.wait_for_connection()
# elem_count = 128, requested count = None, libca returns count = 1
zerostr.put([0], wait=True)
time.sleep(0.2)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0])
# elem_count = 128, requested count = None, libca returns count = 2
zerostr.put([0, 0], wait=True)
time.sleep(0.2)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0, 0])
def discriminator_limits(self):
if not self.connected:
print "Device not connected"
return False
polarity3, polarity4, trig_buffer, int_time, init = PV(
'digital_out_polarity_3'), PV('digital_out_polarity_4'), PV(
'trig_buffer'), PV('analog_out_period'), PV('initiate')
util.put_check(trig_buffer, 1000)
int_time.put(10e-4)
poll(evt=1.e-5, iot=0.01)
count3 = PV('in_counts_3')
count4 = PV('in_counts_4')
low_limit3 = PV('low_limit_3')
low_limit4 = PV('low_limit_4')
high_limit3 = PV('high_limit_3')
high_limit4 = PV('high_limit_4')
util.put_check(low_limit3, 1.0)
util.put_check(low_limit4, 1.0)
util.put_check(polarity3, 1)
util.put_check(polarity4, 1)
util.put_check(high_limit3, 5.0)
util.put_check(high_limit4, 5.0)
poll(evt=1.e-5, iot=0.01)
setting = self.proc.expect([pexpect.TIMEOUT, 'Error setting C400'],
timeout=1)
if setting == 1:
polarity3.put(1)
polarity4.put(1)
data = []
data2 = []
def getCount(pvname, value, **kw):
data.append(value)
def getCount2(pvname, value, **kw):
data2.append(value)
count3.add_callback(getCount)
count4.add_callback(getCount2)
poll(evt=1.e-5, iot=0.01)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 3:
poll(evt=1.e-5, iot=0.01)
util.put_check(low_limit3, 0.0)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 3:
poll(evt=1.e-5, iot=0.01)
return sum(data), sum(data2)
def buffering(self, value):
check = util.expect(self.proc, ["C1"])
count3 = PV('in_counts_3')
low3 = PV('low_limit_3')
trig_buffer = PV('trig_buffer', auto_monitor=False)
int_time = PV('analog_out_period')
init = PV('initiate')
poll(evt=1.e-5, iot=0.01)
data = []
#camonitor('trig_buffer')
def getCount1(pvname, value, **kw):
data.append(value)
util.put_check(low3, 0.0)
util.put_check(trig_buffer, value)
util.put_fuzzy('analog_out_period', 10e-5, 0.05)
print "set value " + str(value)
print "buffer value " + str(trig_buffer.get())
#time.sleep(5)
#print "buffer value " + str(trig_buffer.get())
count3.add_callback(getCount1)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 5:
poll(evt=1.e-5, iot=0.01)
run1 = len(data)
return run1
def initialize_devices(self, devices):
"""
Initialize the devices if they are not already initialized. If the
IOC is not running skip all tests
"""
# set single image mode, else will continuously acquire
self.detector, self.plugin, self.image_channel = devices
self.status = PV(self.detector.errormsgpv)
if not self.status.connected:
pytest.skip('PVs not connected')
image_mode = PV('13SIM1:cam1:ImageMode')
image_mode.put('Single')
self.PVtime = PV('13SIM1:cam1:AcquireTime')
self.PVtime.put(0.01)
self.detector.stop()
self.PVbroker = PV(self.plugin.brokerpv[:-4])
self.PVtopic = PV(self.plugin.topicpv[:-4])
pv = PV(self.plugin.msgpv[:-4])
pv.get()
if pv.connected:
self.PVmessage = pv
pv = PV(self.plugin.statuspv[:-4])
pv.get()
if pv.connected:
self.PVstatus = pv
self.log = self.detector.log
def get_current_readback(self):
connect = self.proc.expect(
[pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5)
if connect == 2:
#enable = PV('c_psu_enable')
resistance = PV('c_psu_resistance')
readback_current = PV('r_psu_current')
readback_voltage = PV('r_psu_voltage')
# setpoint_current = PV('analog_in_current_setpoint')
# setpoint_voltage = PV('analog_in_voltage_setpoint')
command_v = PV('c_psu_control_voltage')
poll(evt=1.0, iot=1.0)
command_v.put(400)
poll(evt=1.0, iot=1.0)
change = self.proc.expect([pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5)
r_curr = readback_current.get()
r_volt = readback_voltage.get()
target = 400/resistance.get()
# set_curr = setpoint_current.get()
# set_volt = setpoint_voltage.get()
return r_curr, target
else:
return -1
def abort(self):
if not self.connected:
print "Device not conncted"
return False
init = PV('initiate')
data = []
a_in_1 = PV('analogIn1')
poll(evt=1.e-5, iot=0.01)
def getData1(pvname, value, **kw):
if value != 0:
data.append(value)
a_in_1.add_callback(getData1)
poll(evt=1.e-5, iot=0.01)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 10:
poll(evt=1.e-5, iot=0.01)
if len(data) >= 50:
init.put(0)
time.sleep(2)
return len(data)
def set_command_voltage(self):
connect = self.proc.expect(
[pexpect.TIMEOUT, pexpect.EOF, 'success'], timeout=5)
print self.proc.after
print self.proc.before
if connect == 2:
command_v = PV('c_psu_control_voltage')
value = random.random()*1000
command_v.put(value)
poll(evt=1.0, iot=1.0)
command = command_v.get()
print command_v.info
print command
print command_v.get()
#teardown
#command_v.disconnect()
#util.blowout_pvs()
# epics.ca.clear_channel(command_v.chid)
# ctx = epics.ca.current_context()
# pvs = []
# for x in epics.ca._cache[ctx]:
# pvs.append(x)
# for pv in pvs:
# import itertools
# for element in itertools.product(*somelists):
# print(element) epics.ca._cache[ctx].pop(pv)
#print epics.ca._cache[ctx]
#epics.ca._cache[ctx].pop('c_psu_control_voltage')
return command, value
else:
return -1
def stopcount_value(self, value):
initial_check = util.expect(self.proc, ["A1"])
data1 = []
def getData1(pvname, value, **kw):
if value != 0:
data1.append(value)
analog1 = PV('analogIn1')
stop_count = PV('outStopCount')
init = PV('initiate')
analog2 = PV('analogIn2')
poll(evt=1.e-5, iot=0.01)
analog1.wait_for_connection()
analog2.wait_for_connection()
init.wait_for_connection()
stop_count.wait_for_connection()
util.put_check(stop_count, value)
analog1.add_callback(getData1)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 10:
poll(evt=1.e-5, iot=0.01)
run = len(data1)
return run
def abort(self):
initial_check = util.expect(self.proc, ["A1"])
init = PV('initiate')
data = []
a_in_1 = PV('analogIn1')
poll(evt=1.e-5, iot=0.01)
def getData1(pvname, value, **kw):
if value != 0:
data.append(value)
a_in_1.add_callback(getData1)
poll(evt=1.e-5, iot=0.01)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 10:
poll(evt=1.e-5, iot=0.01)
if len(data) >= 50:
init.put(0)
time.sleep(2)
return len(data)
def findBestDacTrim(pixel):
wf = PV('vipic:Waveform1')
caput('vipic:PixelToScan1', pixel)
configCntWord = 1984
configCntWordReg = PV('vipic:configPixelCnt1')
configCntWordReg.put(configCntWord, wait=True)
peak = findAvgPeak(wf)
bestDelta = 100
bestConfig = 1984
delta = delta1 = delta2 = 0
print 'configCntWord = ', configCntWord, ' Peak = ', peak
while (abs(100 - peak) > 1):
if (peak > 100):
if ((abs(100 - peak) > 40) and (abs(delta) != 1)):
delta = -5
else:
delta = -1
else:
if ((abs(100 - peak) > 40) and (abs(delta) != 1)):
delta = 5
else:
delta = 1
configCntWord += delta
configCntWordReg.put(configCntWord, wait=True)
peak = findAvgPeak(wf)
print 'configCntWord = ', configCntWord, ' Peak = ', peak, ' Delta = ', delta, delta1, delta2
if (abs(100 - peak) <= bestDelta):
bestDelta = abs(100 - peak)
bestConfig = configCntWord
if (((delta == -1) and (delta1 == 1) and (delta2 == -1))
or ((delta == 1) and (delta1 == -1) and (delta2 == 1))):
break
delta2 = delta1
delta1 = delta
return bestConfig
def test_abortch_timestamp_after_6sec(softioc, caclient, fieldset, abt_ch):
pv = PV(PVNAME)
pv_sec = PV(PVNAME + ':TIME_SEC')
pv_nsec = PV(PVNAME + ':TIME_NANO')
pv.put(0, timeout=1)
time.sleep(0.1)
t = time.time()
t_sec, t_nano = ('%.9f' % t).split('.')
pv_sec.put(int(t_sec), timeout=1)
pv_nsec.put(int(t_nano), timeout=1)
time.sleep(6)
pv.put(1, timeout=1)
time.sleep(0.1)
dt = datetime.fromtimestamp(int(t_sec))
d = dt.isoformat(' ')
tstr = d + '.' + str(int(t_nano)).zfill(9)
act = abt_ch.get_timestamp()
err_msg = 'abt_ch:{} dt:{}'.format(act, tstr)
assert act == '1970-01-01 09:00:00.000000000', err_msg
pv.put(0, timeout=1)
time.sleep(0.1)
class EnumWrapper:
def __init__(self, pvname, elog=None):
self._elog = elog
self._pv = PV(pvname)
self.names = self._pv.enum_strs
# print(self.names)
# if self.names:
self.setters = Positioner([(nam, lambda: self.set(nam))
for nam in self.names])
def set(self, target):
if type(target) is str:
assert target in self.names, ("set value need to be one of \n %s" %
self.names)
self._pv.put(self.names.index(target))
elif type(target) is int:
assert target >= 0, "set integer needs to be positive"
assert target < len(self.names)
self._pv.put(target)
def get(self):
return self._pv.get()
def get_name(self):
return self.names[self.get()]
def __repr__(self):
return self.get_name()
def channel_scaling(self):
status = PV('status')
if not util.check_device('A1', self.proc) and status.get() in range(0,3):
print "device not connected"
print status.get()
print util.check_device('A1', self.proc)
return False
normal = PV('cleanIn1')
linear = PV('linearIn1')
log = PV('logIn1')
both_scaled = PV('bothScaled')
init = PV('initiate')
poll(evt=1.e-5, iot=0.01)
init.put(1)
poll(evt=1.e-5, iot=0.01)
time.sleep(2)
base = normal.get()
lin = linear.get()
logged = log.get()
both = both_scaled.get()
print base, lin, logged, both
return (self.check( lin, base*2 + 10, 0.01) and self.check( logged, 10**base, 0.01) and self.check(both, 10 ** (base*2 +10), 0.01))
def test_emptyish_char_waveform_monitor(self):
'''a test of a char waveform of length 1 (NORD=1): value "\0"
with using auto_monitor
'''
with no_simulator_updates():
zerostr = PV(pvnames.char_arr_pv, auto_monitor=True)
zerostr.wait_for_connection()
zerostr.put([0], wait=True)
time.sleep(0.2)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(
zerostr.get(as_string=False, as_numpy=False), [0])
zerostr.put([0, 0], wait=True)
time.sleep(0.2)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False),
[0, 0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(
zerostr.get(as_string=False, as_numpy=False), [0, 0])
def test_emptyish_char_waveform_no_monitor(self):
'''a test of a char waveform of length 1 (NORD=1): value "\0"
without using auto_monitor
'''
with no_simulator_updates():
zerostr = PV(pvnames.char_arr_pv, auto_monitor=False)
zerostr.wait_for_connection()
# elem_count = 128, requested count = None, libca returns count = 1
zerostr.put([0], wait=True)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(
zerostr.get(as_string=False, as_numpy=False), [0])
# elem_count = 128, requested count = None, libca returns count = 2
zerostr.put([0, 0], wait=True)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False),
[0, 0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(
zerostr.get(as_string=False, as_numpy=False), [0, 0])
zerostr.disconnect()
class PolluxMotor(Motor):
"""Pollux Motor class which inherits from pvScan Motor class."""
def __init__(self, pvname, pvnumber=0):
if pvname.endswith('ACTPOS'):
rbv = pvname
velo = ':'.join(pvname.split(':')[0:2]) + ':AO:VELO'
go = ':'.join(pvname.split(':')[0:2]) + ':BO:GOABS'
abort = ':'.join(pvname.split(':')[0:2]) + ':BO:ABORT'
pvname = ':'.join(pvname.split(':')[0:2]) + ':AO:ABSMOV'
else:
rbv = ':'.join(pvname.split(':')[0:2]) + ':AI:ACTPOS'
velo = ':'.join(pvname.split(':')[0:2]) + ':AO:VELO'
go = ':'.join(pvname.split(':')[0:2]) + ':BO:GOABS'
abort = ':'.join(pvname.split(':')[0:2]) + ':BO:ABORT'
BasePv.__init__(self, pvname, pvnumber, rbv)
self.velo = PV(velo)
self.go = PV(go)
self.abort = PV(abort)
def move(self, val, wait=True, delta=0.005, timeout=360.0):
"""Put value and press Go button."""
PV.put(self, val)
sleep(0.2)
self.go.put(1)
if wait:
Motor.motorWait(self, val, delta, timeout)
class EcolEnergy:
def __init__(self,
ID,
val="SARCL02-MBND100:P-SET",
rb="SARCL02-MBND100:P-READ",
dmov="SFB_BEAM_ENERGY_ECOL:SUM-ERROR-OK"):
self.ID = ID
self.setter = PV(val)
self.readback = PV(rb)
self.dmov = PV(dmov)
self.done = False
def get_current_value(self):
return self.readback.get()
def move_and_wait(self, value, checktime=0.01, precision=2):
curr = self.setter.get()
while abs(curr - value) > 0.1:
curr = self.setter.get()
self.setter.put(curr + np.sign(value - curr) * 0.1)
sleep(0.3)
self.setter.put(value)
while abs(self.get_current_value() - value) > precision:
sleep(checktime)
while not self.dmov.get():
#print(self.dmov.get())
sleep(checktime)
def set_target_value(self, value, hold=False):
changer = lambda: self.move_and_wait(value)
return Task(changer, hold=hold)
def test(self):
pv_w = PV(iocname + pv_write)
pv_r = PV(iocname + pv_read)
if type == "PUTGET":
pv_w.put(value)
time.sleep(DELAY)
got = pv_r.get(as_string=True)
fail_string = 'The PV values do not match, sent %s got %s but expected %s' % (value, got, expected)
self.assertEqual(expected, got, fail_string)
elif type == "PUTERROR":
self.assertRaises(ValueError, pv_w.put, value)
elif type == "GET":
as_str=False
dbl = 0
try:
dbl = float(expected)
except:
as_str=True
dbl = expected
got = pv_r.get(as_string=as_str)
fail_string = 'The value read was not as expected, got %s but expected %s' % (got, dbl)
self.assertEqual(dbl, got, fail_string)
elif type == "EQUAL":
got1 = pv_r.get(as_string=True)
got2 = pv_w.get(as_string=True)
fail_string = 'The PV values do not match, got %s and %s' % (got1, got2)
self.assertEqual(got1, got2, fail_string)
def channel_scaling(self):
status = PV('status')
start_time = time.time()
while status.get() not in (0, 3):
print str(status.get()) + "not connected yet"
connected = status.get() in (0, 3)
poll(evt=1.0, iot=0.51)
if time.time() - start_time >= 60:
connected = False
print "timed out"
break
check = util.expect(self.proc, ["A1"])
normal = PV('cleanIn1')
linear = PV('linearIn1')
log = PV('logIn1')
both_scaled = PV('bothScaled')
init = PV('initiate')
poll(evt=1.e-5, iot=0.01)
init.put(1)
poll(evt=1.e-5, iot=0.01)
time.sleep(2)
base = normal.get()
lin = linear.get()
logged = log.get()
both = both_scaled.get()
print base, lin, logged, both
return (self.check(lin, base * 2 + 10, 0.01)
and self.check(logged, 10**base, 0.01)
and self.check(both, 10**(base * 2 + 10), 0.01))
def testEnumPut(self):
pv = PV(pvnames.enum_pv)
self.assertIsNot(pv, None)
pv.put('Stop')
time.sleep(0.1)
val = pv.get()
self.assertEqual(val, 0)
def trigger_start(self):
if not self.connected:
print "Device not connected"
return False
status = PV('status')
print status.get()
if status.get() not in range(0,3):
print "status"
return False
data = []
start_trig = PV('start_trigger_source')
acquisition_mode = PV('acquisition_mode')
poll(evt=1.e-5, iot=0.01)
print "starting setup is, acquisition: " + str(acquisition_mode.get()) + " stoptrig: " + str(start_trig.get())
acquisition_mode.put(0)
poll(evt=1.e-5, iot=0.01)
#start_trig.put(1)
util.put_check(start_trig, 1)
print "trig1: " + str(start_trig.get())
poll(evt=1.0, iot=1.01)
print "trig2: " + str(start_trig.get())
data.append(start_trig.get() == 1)
time.sleep(3)
print "trig3: " + str(start_trig.get())
#start_trig.put(0)
util.put_check(start_trig, 0)
poll(evt=1.0, iot=1.01)
data.append(start_trig.get() == 0)
time.sleep(3)
print "trig4: " + str(start_trig.get())
return data
def trigger_pause(self):
if not self.connected:
print "Device not connected"
return False
data = []
pause_trig = PV('pause_trigger_source')
acquisition_mode = PV('acquisition_mode')
poll(evt=1.e-5, iot=0.01)
print "starting setup is, acquisition: " + str(
acquisition_mode.get()) + " stoptrig: " + str(pause_trig.get())
acquisition_mode.put(0)
poll(evt=1.e-5, iot=0.01)
#pause_trig.put(1)
util.put_check(pause_trig, 1)
print "trig1: " + str(pause_trig.get())
poll(evt=1.0, iot=1.01)
print "trig2: " + str(pause_trig.get())
data.append(pause_trig.get() == 1)
time.sleep(3)
print "trig3: " + str(pause_trig.get())
#pause_trig.put(0)
util.put_check(pause_trig, 0)
poll(evt=1.0, iot=1.01)
data.append(pause_trig.get() == 0)
time.sleep(3)
print "trig4: " + str(pause_trig.get())
return data
class PVObject(QObject):
newValue = pyqtSignal(float, float)
def __init__(self, pv, readback=None, parent=None):
super(PVObject, self).__init__()
self.name = pv
self.pv = PV(self.name, callback=self.callback)
self.dict = OrderedDict()
self._value = [time.time(), self.pv.get()]
self.writeAccess = False
self.readBackName = readback
if not self.readBackName is None:
self.readBackPV = PV(self.readBackName)
def callback(self, **kwargs):
self.dict = OrderedDict(kwargs)
if 'status' in kwargs and 'value' in kwargs and self.dict['status'] is 0:
if not 'timestamp' in kwargs:
timestamp = time.time()
self._value = [self.dict['timestamp'], self.dict['value']]
self.newValue.emit(*self._value)
def setValue(self, value):
self.value = value
@property
def value(self):
if self._value[1] is None:
return self.pv.get() if self.pv.get() is not None else 0
else:
return self._value[1]
@value.setter
def value(self, val):
self.put(val)
@property
def time(self):
return self._value[0]
def get(self):
return self._value
def getTime(self):
return self._value[0]
def getValue(self):
return self._value[1] if self._value[1] is not None else 0
def put(self, value):
ntries = 0
if self.writeAccess:
self.pv.put(value)
if not self.readBackName is None:
rbkValue = self.readBackPV.get()
while abs(rbkValue - self.value) > 0.01 and ntries < 10:
time.sleep(0.05)
rbkValue = self.readBackPV.get()
ntries += 1
class DDGrabber(Experiment):
"""UED Direct Detector grabber."""
def __init__(self, cameraPvPrefix):
Experiment.__init__(self)
self.cameraPvPrefix = cameraPvPrefix
self.grabFlag = PV(pvPrefix + ':GRABIMAGES:ENABLE').get()
self.grabSeq2Flag = PV(pvPrefix + ':GRABIMAGES:SEQ2ENABLE').get() # Grab second image sequence after first
self.grabSeq2Delay = PV(pvPrefix + ':GRABIMAGES:SEQ2DELAY').get() # Delay between 1st and 2nd sequence
self.stepFlag = PV(pvPrefix + ':GRABIMAGES:STEPNUMBER').get() # Write step number into filename
self.dataTime = PV(pvPrefix + ':GRABIMAGES:DATATIME').get() # Data capture time for DirectD
self.dataStartStopPv = PV('UED:TST:FILEWRITER:CMD') # DataWriter start/stop PV
self.dataStatusPv = PV('UED:TST:FILEWRITER:STATUS') # DataWriter status PV
self.dataFilenamePv = PV('UED:TST:FILEWRITER:PATH') # DataWriter filename template PV
self.nImages2 = None
self.filenameExtras = ''
self.timestampRBVPv = None
self.captureRBVPv = None
def dataWriterStatus(self):
"""Return status of dataWriter."""
status = self.dataStatusPv.get()
if status:
printMsg('DataWriter status is: ON')
else:
printMsg('DataWriter status is: OFF')
return status
def grabImages(self, nImages=0):
"""Set filepath PV, turn on/off dataWriter."""
#filenameTemplate='%s/%s%s_%s' %(timestamp('today'), self.expname, self.filenameExtras, timestamp(1))
if self.filenameExtras.startswith('_'):
self.filenameExtras = self.filenameExtras.replace('_', '')
filenameTemplate = ('%s/%s/%s_%s' %(timestamp('today'), self.expname,
self.filenameExtras, timestamp(1)))
self.dataFilenamePv.put(filenameTemplate + '\0')
printMsg('Writing %s data for %d seconds...' % (self.cameraPvPrefix, self.dataTime))
print 'DirectD filepath: ', filenameTemplate
#print self.dataStatusPv.get()
#print caget('UED:TST:FILEWRITER:STATUS')
self.dataStartStopPv.put(1)
#caput('UED:TST:FILEWRITER:CMD',1)
sleep(0.25)
self.dataStartStopPv.put(1)
#caput('UED:TST:FILEWRITER:CMD',1)
sleep(0.25)
self.dataWriterStatus()
#print self.dataStatusPv.get()
#print caget('UED:TST:FILEWRITER:STATUS')
sleep(self.dataTime)
self.dataStartStopPv.put(0)
#caput('UED:TST:FILEWRITER:CMD',0)
sleep(0.25)
self.dataStartStopPv.put(0)
#caput('UED:TST:FILEWRITER:CMD',0)
sleep(0.25)
self.dataWriterStatus()
#print caget('UED:TST:FILEWRITER:STATUS')
#print self.dataStatusPv.get()
printMsg('Done Writing %s data.' % (self.cameraPvPrefix))
def test_stopcount():
proc = pexpect.spawn(
"/home/steve/workspace/ig2_medical/ig2-2.6.7 /home/steve/workspace/ig2_medical/m10_stopcount.xml"
)
proc.expect([pexpect.TIMEOUT, pexpect.EOF, 'Announce\(\) success'],
timeout=10)
print proc.after
#util.pv_check('status', 0)
stop = 1001
data1 = []
data2 = []
def getData1(pvname, value, **kw):
if value != 0:
data1.append(value)
def getData2(pvname, value, **kw):
if value != 0:
data2.append(value)
analog1 = PV('analogIn1')
stop_count = PV('outStopCount')
init = PV('initiate')
analog2 = PV('analogIn2')
analog1.wait_for_connection()
analog2.wait_for_connection()
init.wait_for_connection()
stop_count.wait_for_connection()
analog1.add_callback(getData1)
if util.put_check('outStopCount', stop):
init.put(1)
t0 = time.time()
while time.time() - t0 < 30:
poll(evt=1.e-5, iot=0.01)
else:
print "Stopcount not set"
return False
buffered_run = len(data1)
analog2.add_callback(getData2)
time.sleep(2)
if util.put_check('outStopCount', -1):
init.put(1)
t0 = time.time()
while time.time() - t0 < 30:
poll(evt=1.e-5, iot=0.01)
else:
print "Stopcount not set 2nd time"
return False
unbuffered_run = len(data2)
return buffered_run, unbuffered_run
def test_put_string_waveform(self):
write('String Array: \n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = ['a', 'b', 'c']
pv.put(put_value)
get_value = pv.get(use_monitor=False, count=len(put_value))
numpy.testing.assert_array_equal(get_value, put_value)
def test_put_string_waveform(self):
write('String Array: put\n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = ['a', 'b', 'c']
pv.put(put_value, wait=True)
get_value = pv.get(use_monitor=False, as_numpy=False)
numpy.testing.assert_array_equal(get_value, put_value)
def move(self, val, wait=False, delta=0.005, timeout=300.0):
"""Put with optional wait."""
PV.put(self,val)
if wait or self.rbv:
if not self.delta:
delta = delta
else:
delta = self.delta
self.pvWait(val, delta, timeout)
def init_var_channels(beamlineComm):
global var_channel_list,beamlineStateChannel
beamlineStateChannel = PV(beamlineComm + "beamlineState")
beamlineStateChannel.put(0)
for varname in list(stateVars.keys()):
var_channel_list[varname] = PV(beamlineComm + varname)
# beamline_support.pvPut(var_channel_list[varname],stateVars[varname])
var_channel_list[varname].add_callback(var_list_item_changeCb,varname=varname)
class Shutter(object):
def __init__(self, pvname):
self.out_pv = PV(pvname)
def open(self):
self.out_pv.put(str(1))
def close(self):
self.out_pv.put(str(0))
class Shutter(object):
def __init__(self):
self.out_pv = PV('34idc:softGlue:OR-1_IN2_Signal')
def open(self):
self.out_pv.put(str(1))
def close(self):
self.out_pv.put(str(0))
def test_put_string_waveform_single_element(self):
write('String Array: put single element\n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = ['a']
pv.put(put_value, wait=True)
time.sleep(0.05)
get_value = pv.get(use_monitor=False, as_numpy=False)
self.failUnless(put_value[0] == get_value)
def test_put_string_waveform_mixed_types(self):
write('String Array: put mixed types\n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = ['a', 2, 'b']
pv.put(put_value, wait=True)
time.sleep(0.05)
get_value = pv.get(use_monitor=False, as_numpy=False)
numpy.testing.assert_array_equal(get_value, ['a', '2', 'b'])
def test_put_string_waveform_zero_length_strings(self):
write('String Array: put zero length strings\n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = ['', '', '']
pv.put(put_value, wait=True)
time.sleep(0.05)
get_value = pv.get(use_monitor=False, as_numpy=False)
numpy.testing.assert_array_equal(get_value, put_value)
def test_put_string_waveform_empty_list(self):
write('String Array: put empty list\n')
with no_simulator_updates():
pv = PV(pvnames.string_arr_pv)
put_value = []
pv.put(put_value, wait=True)
time.sleep(0.05)
get_value = pv.get(use_monitor=False, as_numpy=False)
self.failUnless('' == ''.join(get_value))
class Shutter(StandardDevice):
#CALLBACK FUNCTION FOR THE SHUTTER STATUS PV
#def onStatusChange(self, **kw):
#self._open = not self._open
#CONSTRUCTOR OF SHUTTER CLASS
def __init__(self, pvStatusName="", pvControlName="", pvHutchName="", mnemonic="", invert=False):
StandardDevice.__init__(self, mnemonic)
self.delay = 0.01
self.invert = invert
self.pvStatus = PV(pvStatusName)
self.pvControl = PV(pvControlName)
self.pvHutch = PV(pvHutchName)
#IF POSSIBLE, OPEN THE SHUTTER AND WAIT UNTIL THE SHUTTER IS REALLY OPEN
def open(self):
if not self.isHutchReady():
raise Exception('Error: ','Hutch Not Ready')
try:
if not self.isOpen():
self.pvControl.put(1, wait=True)
while not self.isOpen():
sleep(self.delay)
else:
print('Warning: ','Shutter already open')
except Exception as e:
print(e.args[0],e.args[1])
#IF POSSIBLE, CLOSE THE SHUTTER AND WAIT UNTIL THE SHUTTER IS REALLY CLOSE
def close(self):
try:
if self.isOpen():
self.pvControl.put(1, wait=True)
while self.isOpen():
sleep(self.delay)
else:
print('Warning: ','Shutter already closed')
except Exception as e:
print(e.args[0],e.args[1])
def isHutchReady(self):
if(self.invert):
return 1 - self.pvHutch.get()
else:
return self.pvHutch.get()
def isOpen(self):
if(self.invert):
return 1 - self.pvStatus.get()
else:
return self.pvStatus.get()
def test_putcomplete(self):
write('Put with wait and put_complete (using real motor!) \n')
vals = (1.35, 1.50, 1.44, 1.445, 1.45, 1.453, 1.446, 1.447, 1.450, 1.450, 1.490, 1.5, 1.500)
p = PV(pvnames.motor1)
see_complete = []
for v in vals:
t0 = time.time()
p.put(v, use_complete=True)
count = 0
for i in range(100000):
time.sleep(0.001)
count = count + 1
if p.put_complete:
see_complete.append(True)
break
# print( 'made it to value= %.3f, elapsed time= %.4f sec (count=%i)' % (v, time.time()-t0, count))
self.failUnless(len(see_complete) > (len(vals) - 5))
def test_emptyish_char_waveform_monitor(self):
'''a test of a char waveform of length 1 (NORD=1): value "\0"
with using auto_monitor
'''
with no_simulator_updates():
zerostr = PV(pvnames.char_arr_pv, auto_monitor=True)
zerostr.wait_for_connection()
zerostr.put([0], wait=True)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0])
zerostr.put([0, 0], wait=True)
self.assertEquals(zerostr.get(as_string=True), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False), [0, 0])
self.assertEquals(zerostr.get(as_string=True, as_numpy=False), '')
numpy.testing.assert_array_equal(zerostr.get(as_string=False, as_numpy=False), [0, 0])
def test_positions(self):
PVPREFIX = os.environ['MYPVPREFIX'] + 'LKUP:'
filter = PV(PVPREFIX + 'SAMPX:FILTER1')
filter.put('Rack1_Rct')
posns = PV(PVPREFIX + 'SAMPX:POSITIONS')
positions = posns.get()
self.assertEqual(positions[0], 'Rack1_Rct_1')
self.assertEqual(positions[2], 'Rack1_Rct_3')
self.assertEqual(positions[10], 'END')
posns = PV(PVPREFIX + 'MON3:POSITIONS')
positions = posns.get()
self.assertEqual(positions[0], 'In')
self.assertEqual(positions[1], 'Out')
self.assertEqual(positions[2], 'END')
posns = PV(PVPREFIX + 'SAMPY:POSITIONS')
positions = posns.get()
self.assertEqual(positions[0], 'Top')
self.assertEqual(positions[1], 'Bottom')
self.assertEqual(positions[2], 'END')
class SimpleShutter(StandardDevice):
SHUTTER_OPEN = 0
SHUTTER_CLOSE = 1
def __init__(self, mnemonic, shutter):
super().__init__(mnemonic)
self.shutter = PV(shutter)
def isOpen(self):
return self.shutter.get() == self.SHUTTER_OPEN
def wait(self, timeout=3):
pass
def open(self, wait=False):
self.shutter.put(self.SHUTTER_OPEN, wait=wait)
def close(self, wait=False):
self.shutter.put(self.SHUTTER_CLOSE, wait=wait)
def test_putcomplete(self):
write('Put with wait and put_complete (using real motor!) \n')
vals = (1.35, 1.50, 1.44, 1.445, 1.45, 1.453, 1.446, 1.447, 1.450, 1.450, 1.490, 1.5, 1.500)
p = PV(pvnames.motor1)
# this works with a real motor, fail if it doesn't connect quickly
if not p.wait_for_connection(timeout=0.2):
self.skipTest('Unable to connect to real motor record')
see_complete = []
for v in vals:
t0 = time.time()
p.put(v, use_complete=True)
count = 0
for i in range(100000):
time.sleep(0.001)
count = count + 1
if p.put_complete:
see_complete.append(True)
break
# print( 'made it to value= %.3f, elapsed time= %.4f sec (count=%i)' % (v, time.time()-t0, count))
self.failUnless(len(see_complete) > (len(vals) - 5))
class ToggleShutter(StandardDevice):
def __init__(self, mnemonic, shutter, shutterReadback):
super().__init__(mnemonic)
self.read = PV(shutterReadback)
self.toggle = PV(shutter)
self._open = self.read.get()
self.changed = Event()
self.read.add_callback(self.onReadChange)
def isOpen(self):
return self._open
def onReadChange(self, value, **kwargs):
self._open = value
self.changed.set()
def wait(self, timeout=3):
ca.flush_io()
self.changed.wait(timeout)
def change(self, open, wait=False):
if self.isOpen() == open:
self.changed.set()
return
self.changed.clear()
self.toggle.put(1)
ca.flush_io()
if wait:
self.wait()
def open(self, wait=False):
self.change(open=True, wait=wait)
def close(self, wait=False):
self.change(open=False, wait=wait)
def test_lookps(self):
PVPREFIX = os.environ['MYPVPREFIX'] + 'LKUP:'
posn3 = PV(PVPREFIX + 'MON3:POSN')
posn4 = PV(PVPREFIX + 'MON4:POSN')
posnX = PV(PVPREFIX + 'SAMPX:POSN')
posnY = PV(PVPREFIX + 'SAMPY:POSN')
posn3sp = PV(PVPREFIX + 'MON3:POSN:SP')
posn4sp = PV(PVPREFIX + 'MON4:POSN:SP')
posnXsp = PV(PVPREFIX + 'SAMPX:POSN:SP')
posnYsp = PV(PVPREFIX + 'SAMPY:POSN:SP')
print(PVPREFIX + 'MON3:POSN')
posn3sp.put('Out')
posn4sp.put('In')
posnXsp.put('Rack1_Rct_3')
posnYsp.put('Bottom')
time.sleep(self.DELAY)
rbv3 = PV(PVPREFIX + 'MON3:COORD1:RBV')
rbv4 = PV(PVPREFIX + 'MON4:COORD1:RBV')
rbvX = PV(PVPREFIX + 'SAMPX:COORD1:RBV')
rbvY = PV(PVPREFIX + 'SAMPY:COORD1:RBV')
pvStationary = PV(PVPREFIX + 'SAMPX:STATIONARY')
for i in range(20):
stationary = pvStationary.get()
if stationary==1:
break
print('Moving')
print('3=' + str(rbv3.get()) + ' 4=' + str(rbv4.get()) + ' X=' + str(rbvX.get()) + ' Y=' + str(rbvY.get()))
time.sleep(self.DELAY)
time.sleep(self.DELAY)
self.assertEqual(posn3.get(), 'Out')
self.assertEqual(posn4.get(), 'In')
self.assertEqual(posnX.get(), 'Rack1_Rct_3')
self.assertEqual(posnY.get(), 'Bottom')
coord3 = PV(PVPREFIX + 'MON3:COORD1')
coord4 = PV(PVPREFIX + 'MON4:COORD1')
coordX = PV(PVPREFIX + 'SAMPX:COORD1')
coordY = PV(PVPREFIX + 'SAMPY:COORD1')
self.assertAlmostEqual(coord3.get(), 10)
self.assertAlmostEqual(coord4.get(), 5)
self.assertAlmostEqual(coordX.get(), 30)
self.assertAlmostEqual(coordY.get(), 12)
self.assertAlmostEqual(rbv3.get(), 10)
self.assertAlmostEqual(rbv4.get(), 5)
self.assertAlmostEqual(rbvX.get(), 30)
self.assertAlmostEqual(rbvY.get(), 12)
def move_to_sample_pos(x, y, z, wait=True, callbacks=[]):
logger.info('Moving Sample to x: {}, y: {}, z: {}'.format(x, y, z))
motor_x = PV(epics_config['sample_position_x'])
motor_y = PV(epics_config['sample_position_y'])
motor_z = PV(epics_config['sample_position_z'])
motor_x.put(x, use_complete=True)
motor_y.put(y, use_complete=True)
motor_z.put(z, use_complete=True)
if wait:
while not motor_x.put_complete and \
not motor_y.put_complete and \
not motor_z.put_complete:
time.sleep(0.1)
for callback in callbacks:
callback()
time.sleep(0.5)
logger.info('Moving Sample to x: {}, y: {}, z: {} finished.\n'.format(x, y, z))
return
def test_subarrays(self):
write("Subarray test: dynamic length arrays\n")
driver = PV(pvnames.subarr_driver)
subarr1 = PV(pvnames.subarr1)
subarr1.connect()
len_full = 64
len_sub1 = 16
full_data = numpy.arange(len_full)/1.0
caput("%s.NELM" % pvnames.subarr1, len_sub1)
caput("%s.INDX" % pvnames.subarr1, 0)
driver.put(full_data) ;
time.sleep(0.1)
subval = subarr1.get()
self.assertEqual(len(subval), len_sub1)
self.failUnless(numpy.all(subval == full_data[:len_sub1]))
write("Subarray test: C\n")
caput("%s.NELM" % pvnames.subarr2, 19)
caput("%s.INDX" % pvnames.subarr2, 3)
subarr2 = PV(pvnames.subarr2)
subarr2.get()
driver.put(full_data) ; time.sleep(0.1)
subval = subarr2.get()
self.assertEqual(len(subval), 19)
self.failUnless(numpy.all(subval == full_data[3:3+19]))
caput("%s.NELM" % pvnames.subarr2, 5)
caput("%s.INDX" % pvnames.subarr2, 13)
driver.put(full_data) ; time.sleep(0.1)
subval = subarr2.get()
self.assertEqual(len(subval), 5)
self.failUnless(numpy.all(subval == full_data[13:5+13]))
# mdunning 1/7/16
from epics import PV
from time import sleep
import datetime, os, sys
from threading import Thread
import subprocess
# PV prefix for pvScan IOC; should be passed as an argument to this script.
pvPrefix = sys.argv[1]
# Set an environment variable for so pvScan module can use it
os.environ["PVSCAN_PVPREFIX"] = pvPrefix
# For printing status messages to PV
msgPv = PV(pvPrefix + ":MSG")
msgPv.put("Initializing...")
print "Initializing..."
# Import pvScan module
sys.path.append("/afs/slac/g/testfac/extras/scripts/pvScan/prod/modules/")
import pvscan
# --- Experiment ---------------------------------------
# Create Experiment object. Sets default filepath and gets experiment name from PV.
# First argument (optional) is an experiment name, leave blank to get from pvScan IOC.
# Second arg (optional) is a filepath, leave blank to get from pvScan IOC.
# Third arg (optional) is a scan name, leave blank to get from pvScan IOC.
exp1 = pvscan.Experiment()
exp1.targetname = PV(pvPrefix + ":SCAN:TARGETNAME").get()
if " " in exp1.targetname:
exp1.targetname = exp1.targetname.replace(" ", "_")
class RotaryMagnet(StandardDevice, IScannable):
"""
Class to add ICountable support for rotary magnet.
Examples
--------
>>> from py4syn.epics.RotaryMagnetClass import RotaryMagnet
>>>
>>> myMagnet = RotaryMagnet('myMagnet')
>>> myMagnet.setValue(0)
>>>
"""
# Callback function for the RotaryMagnet's PV value change
def onValChange(self, value, **kw):
self._active = (value == 1)
# Constructor of RotaryMagnet
def __init__(self, pvRotaryMagnetName="", mnemonic=""):
StandardDevice.__init__(self, mnemonic)
self._active = False
self._done = self.isDone()
self.pvRotaryMagnetDESC = PV(pvRotaryMagnetName+".DESC")
self.pvRotaryMagnetVAL = PV(pvRotaryMagnetName+".VAL", self.onValChange)
def getDescription(self):
"""
Obtain the current description of rotary magnet device or its identification.
Returns
-------
`String`
A detail about the device or its identification.
"""
return self.pvRotaryMagnetDESC.get()
def setDescription(self, magnetDescription):
"""
Method to set a description to the rotary magnet device.
Parameters
----------
`String`
A detail about the device or its identification.
Returns
-------
`None`
"""
self.pvRotaryMagnetDESC.put(magnetDescription)
def getValue(self):
"""
Obtain the current value of rotary magnet device or its identification.
Returns
-------
`integer`
.. note::
- **1** -- Active rotary magnet;
- **0** -- Inactive rotary magnet.
"""
return self.pvRotaryMagnetVAL.get()
def setValue(self, v):
"""
Method to set a value to the rotary magnet device.
Parameters
----------
`integer`
.. note::
- **1** -- Active rotary magnet;
- **0** -- Inactive rotary magnet.
"""
self.pvRotaryMagnetVAL.put(v)
def isActive(self):
"""
Return whether Rotary Magnet is currently active (set to 1).
Returns
-------
`boolean`
.. note::
- **True** -- Rotary magnet is active (1);
- **False** -- Rotary magnet is inactive (0).
"""
return self._active
def isDone(self):
return True
def wait(self):
while(not self._done):
sleep(0.001)
def getLowLimitValue(self):
"""
Obtain low limit value of rotary magnet.
Parameters
----------
None
Returns
-------
`double`
"""
return -1
def getHighLimitValue(self):
"""
Obtain high limit value of rotary magnet.
Parameters
----------
None
Returns
-------
`double`
"""
return 2
class PhotonicCCD(StandardDevice):
#CALLBACK FUNCTION FOR THE CCD ACQUIRE STATUS PV
def onAcquireChange(self, value, **kw):
#print datetime.datetime.now(), " - Acquisition Done = ", (value == 0)
self._done = (value == 0)
#CONSTRUCTOR OF CCD CLASS
def __init__(self, pvName, mnemonic, scalerObject=""):
StandardDevice.__init__(self, mnemonic)
self.pvAcquire = PV(pvName+":cam1:Acquire", callback=self.onAcquireChange)
self.pvNumImages = PV(pvName+":cam1:NumImages")
self.pvFileName = PV(pvName+":cam1:FileName")
self.pvFilePath = PV(pvName+":cam1:FilePath")
self.pvAcquireTime = PV(pvName+":cam1:AcquireTime")
self.pvFileNumber = PV(pvName+":cam1:FileNumber")
self.pvArrayCounter = PV(pvName+":cam1:ArrayCounter")
self.pvArrayCounterRBV = PV(pvName+":cam1:ArrayCounter_RBV")
self.scaler = scalerObject
self._done = self.isDone()
self.time = self.pvAcquireTime.get()
def isDone(self):
return (self.pvAcquire.get() == 0)
def getAcquireTime(self):
return self.pvAcquireTime.get()
def getFileName(self):
#name = ''.join([chr(c) for c in self.pvFileName.get()])
#name = name[0:-1]
name = self.pvFileName.get(as_string=True)
return name
def getFilePath(self):
#path = ''.join([chr(c) for c in self.pvFilePath.get()])
#path = path[0:-1]
path = self.pvFilePath.get(as_string=True)
return path
def getFileNumber(self):
return self.pvArrayCounterRBV.get()
def getCompletePreviousFileName(self):
return self.getFileName()+str(self.getFileNumber()-1).zfill(3)
def getCompleteFileName(self):
return self.getFileName()+str(self.getFileNumber()).zfill(3)
def acquire(self, waitComplete=False):
self.scaler.setCountTime(self.time)
self.scaler.setCountStart()
self.pvAcquire.put(1)
self._done = False
if(waitComplete):
self.wait()
self.scaler.setCountStop()
def getIntensity(self):
return self.scaler.getIntensity()
def setFileNumber(self, number):
self.pvArrayCounter.put(number-1, wait=True)
self.pvFileNumber.put(number, wait=True)
def setAcquireTime(self, time):
self.time = time
self.pvAcquireTime.put(time, wait=True)
def setFileName(self, name):
self.pvFileName.put(name+"\0", wait=True)
def setNumImages(self, number):
self.pvNumImages.put(number, wait=True)
def wait(self):
while(not self._done):
sleep(0.001)
