def __init__(self, pvs, timeout=30.0, skip_first=True):
self.pvnames = pvs
self.values = dict()
self.timeout = timeout
self.first = [skip_first] * len(pvs)
self.pvs = [
epics.PV(pv, callback=self.channel_changed, auto_monitor=True)
for pv in pvs
]
def check_pv_online(pvname, timeout=1.0, use_prefix=True):
"""Return whether a PV is online."""
if use_prefix:
pvname = _envars.VACA_PREFIX + pvname
pvobj = _epics.PV(pvname=pvname, connection_timeout=timeout)
status = pvobj.wait_for_connection(timeout=timeout)
# invoke pv disconnect and explicitly signal to GC that PV object may be collected.
del pvobj
return status
def __init__(self, daq_host, daq_platform, laser_delay_pv_name,
tt_stage_position_pv_name, t0_pv_name, laser_lock_pv_name):
"""
Create a Timescaner instance, providing control over the timetool
and laser delay stages.
Parameters
----------
daq_host : str
daq_platform : int
laser_delay_pv_name : str
tt_stage_position_pv_name : str
t0_pv_name : str
laser_lock_pv_name : str
See Also
--------
Timescaner.from_rc() : function
Create a timescaner instance from a file.
"""
self._daq_host = daq_host
self._daq_platform = daq_platform
self.daq = pydaq.Control(daq_host, daq_platform)
self._laser_delay = epics.PV(laser_delay_pv_name)
self._tt_stage_position = epics.PV(tt_stage_position_pv_name)
self._t0 = epics.PV(t0_pv_name)
self._laser_lock = epics.PV(laser_lock_pv_name)
self.tt_travel_offset = 0.0
self.tt_fit_coeff = np.array([0.0, 1.0, 0.0])
self.calibrated = False
time.sleep(0.1) # time for PVs to connect
for pv in [
self._laser_delay, self._tt_stage_position, self._t0,
self._laser_lock
]:
if not pv.connected:
raise RuntimeError('Cannot connect to PV: %s' % pv.pvname)
return
def __init__(self, parent=None, args=None):
super(BetaScan, self).__init__(parent=parent, args=args)
self.ui.imageView.mousePressEvent = self.get_coord
self.ui.imageView.process_image = self.process_image
self.motorRead = self.ui.EmbeddedMotor.findChild(
PyDMLabel, "motorPosRead")
self.motorSet = self.ui.EmbeddedMotor.findChild(
PyDMLineEdit, "motorPosSet")
self.motorGo = self.ui.EmbeddedMotor.findChild(QPushButton,
"motorMove")
self.motorGo.mousePressEvent = self.move_motor
self.imageXSize = epics.PV('PelmeniNDSA:cam1:ArraySize0_RBV')
self.imageYSize = epics.PV('PelmeniNDSA:cam1:ArraySize1_RBV')
self.binYSize = epics.PV('PelmeniDet:ROI1:BinY_RBV')
self.zoomedSize = 1
self.imageHeight = 672.0
def connectPv(self, pvname):
if pvname is None:
raise RuntimeError("pvname must not be 'None'")
if len(pvname) == 0:
raise RuntimeError("pvname must not be ''")
self.pv = epics.PV(self.pvName)
self.startval = self.pv.get()
self.pv.add_callback(self.onChangePv)
self.myFig.addData(self.startval)
QCoreApplication.processEvents()
def emitter():
'return a random value with probability p, else 0'
dxpMca1PV = epics.PV('BL7D:dxpXMAP:mca1')
dxpAcqPV = epics.PV('BL7D:dxpXMAP:Acquiring')
mcas = 0.0
oldAcqStatus = 1
nowAcqStatus = 0
while True:
nowAcqStatus = dxpAcqPV.get()
if nowAcqStatus is 1 and oldAcqStatus is 0:
mcas = sum(dxpMca1PV.get())
oldAcqStatus = nowAcqStatus
yield mcas
else:
oldAcqStatus = nowAcqStatus
yield mcas
def __init__(self, busy_pv_name, motor_pv_name, calc_pv_name):
self.busy = epics.PV(busy_pv_name)
# motor: the independent variable
self.motor = epics.Motor(motor_pv_name)
# calc: the detector signal
self.calc = epics.PV(calc_pv_name)
self.calc_proc = epics.PV(calc_pv_name + ".PROC")
epics.caput(calc_pv_name + ".CALC", "RNDM") # report random numbers
self.calc_proc.put(1) # get a new value
self.cb_index = None
self.processing = False
# arbitrary choices for a demo program
self.num_steps = 5
self.step_size = 2.1
self.origin = 0
def pre_change(self):
puck_check = False
fill_check = False
fill_level = epics.PV('XF:17IDB-ES:AMX{CS8}Ln2Level-I').get()
user_name = getpass.getuser()
# Input file name to CSS
epics.PV('XF:17IDB-ES:AMX{Cam:14}JPEG1:FileName').put(user_name)
plates = (plate_check(1, 180), plate_check(2, 135), plate_check(3, 90),
plate_check(4, 45), plate_check(5, 0), plate_check(6, 315),
plate_check(7, 270), plate_check(8, 225))
holder = 0
##### Comment/Uncomment below to set directory by user and not date #####
for plate in plates:
if (epics.PV('XF:17IDB-ES:AMX{Dew:1-Ax:R}Mtr.VAL').get() +
135) == plate.degree or (
epics.PV('XF:17IDB-ES:AMX{Dew:1-Ax:R}Mtr.VAL').get() -
225) == plate.degree:
holder = plate.plate
if epics.PV('XF:17IDB-ES:AMX{Wago:1}Puck' + str(holder) +
'C-Sts').get() != 1:
print('There is no puck on position: {}. No image taken'.format(
holder))
else:
puck_check = True
epics.PV('XF:17IDB-ES:AMX{Cam:14}JPEG1:FilePath').put(image_path)
if fill_level >= 85:
fill_check = True
else:
print('Fill Violation, Fill Level Is: ' + str('%.2f' % fill_level))
print('Please Fill Dewar to Continue')
if puck_check and fill_check:
# A one minute buffer to allow the dewar to rotate
time.sleep(60)
print('Images are in: {}'.format(image_path))
epics.PV('XF:17IDB-ES:AMX{Cam:14}Proc1:EnableFilter').put(1)
for i in range(1, 4):
print('Taking image: ' + str(i) + ' of 3')
# Change the settings to take the picture and capture the image
acq.put(0)
img_mode.put(0)
data_type.put(0)
time.sleep(2)
acq.put(1)
time.sleep(2)
save_file.put(1)
# Put the camera back to the original settings
time.sleep(2)
img_mode.put(2)
data_type.put(1)
acq.put(1)
time.sleep(15)
self.post_change()
def __init__(self,
pv,
scaler_pv=None,
moving_pv=None,
moving_val=0,
precision=3,
limit_hi=9,
*args,
**kwargs):
super().__init__(*args, **kwargs)
if scaler_pv:
self.count_mode = epics.PV(scaler_pv + '.CONT')
self.count_time = epics.PV(scaler_pv + '.TP')
self.auto_count_time = epics.PV(scaler_pv + '.TP1')
self.setMinimumSize(qt.QSize(120, 30))
self.setMaximumSize(qt.QSize(120, 30))
self.precision = precision
self.setFrameShape(qt.QFrame.Panel)
self.setFrameShadow(qt.QFrame.Sunken)
self.setAlignment(qt.Qt.AlignCenter)
self.setText("not connected")
self.formatStr = "{:." + str(self.precision) + "f}"
self.moving_val = moving_val
self.pv = epics.PV(pv, auto_monitor=True)
self.pv.add_callback(self.update_value)
if moving_pv is not None:
self.moving_pv = epics.PV(moving_pv, auto_monitor=True)
self.moving_pv.add_callback(self.update_color)
self.limit_hi = limit_hi
self._dummyIndex = 0
self.notifyTimer = qt.QTimer()
self.notifyTimer.timeout.connect(self._notifyColor)
self.notifyTimer.start(1000)
def __init__(self):
""" Initialize parameters for the scanner class. """
self.secs_to_ave = 2 #time to integrate gas detector
self.getter = EpicsGet() #getter class for channel access
self.caput = epics.caput
self.state = lambda text: epics.PV(str(text), connection_timeout=0.1
).get()
self.inputNormParams = None #normalization parameters
self.norm_params_bool = False #normalization parameters
self.taperParams = None
def connect(self):
# Set is_ready to True when there is new data using a callback
print('Connecting ' + self.dev_type)
if(self._callback_pvname):
print('Connecting ' + self._callback_pvname)
pv = epics.PV(self._callback_pvname,
auto_monitor=True,
callback=lambda pvname=None, value=None, timestamp=None, **fw: self.set_ready(pvname, value, timestamp))
self.connected_pvs.append(pv)
return(self)
def monChan(chanNames):
chanList = []
cnameList = []
for cn in chanNames:
chan = epics.PV(cn)
chanStatus = chan.status
if not (chanStatus == None):
cnameList.append(cn)
chanList.append(chan)
return chanList, cnameList
class Test(unittest.TestCase):
lib = motor_lib()
motor = os.getenv("TESTEDMOTORAXIS")
pv_Err = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-Err")
pv_nErrorId = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-ErrId")
pv_nErrRst = epics.PV(os.getenv("TESTEDMOTORAXIS") + "-ErrRst")
saved_CNEN = epics.caget(motor + '.CNEN')
# Jog, wait for start, power off, check error, reset error
def test_TC_212(self):
motor = self.motor
tc_no = "TC-212-EnabledFailed"
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff",
AMPLIFIER_LOCKED_TO_BE_OFF_SILENT)
epics.caput(motor + '.CNEN', 1, wait=True)
mstaErr = int(epics.caget(motor + '.MSTA', use_monitor=False))
print '%s Error mstaErr=%s' % (tc_no, self.lib.getMSTAtext(mstaErr))
self.pv_nErrRst.put(1, wait=True)
setValueOnSimulator(self, motor, tc_no, "bAmplifierLockedToBeOff", 0)
mstaOKagain = int(epics.caget(motor + '.MSTA', use_monitor=False))
bError = self.pv_Err.get(use_monitor=False)
nErrorId = self.pv_nErrorId.get(use_monitor=False)
print '%s Clean self.lib.MSTA_BIT_PROBLEM=%x mstaOKagain=%s bError=%d nErrorId=%d' % (
tc_no, self.lib.MSTA_BIT_PROBLEM,
self.lib.getMSTAtext(mstaOKagain), bError, nErrorId)
epics.caput(motor + '.CNEN', self.saved_CNEN)
self.assertNotEqual(0, mstaErr & self.lib.MSTA_BIT_PROBLEM,
'Error MSTA.Problem should be set)')
self.assertEqual(0, mstaErr & self.lib.MSTA_BIT_SLIP_STALL,
'Error MSTA.Slip stall Error should not be set)')
self.assertEqual(0, mstaErr & self.lib.MSTA_BIT_MOVING,
'Error MSTA.Moving)')
self.assertEqual(0, mstaOKagain & self.lib.MSTA_BIT_MOVING,
'Clean MSTA.Moving)')
self.assertEqual(0, bError, 'bError')
self.assertEqual(0, nErrorId, 'nErrorId')
def build_getter_setter(self, beam_line, device, config, rbv):
for key, value in config.items():
if (rbv):
setattr(
self, '_{0}_rbv'.format(key),
epics.PV(
self.get_device_command_str(
beam_line, device, '{0}{1}'.format(value,
'_RBV'))))
setattr(
self, '_{0}'.format(key),
epics.PV(self.get_device_command_str(beam_line, device,
value)))
setattr(
self, 'get_{0}'.format(key),
getattr(self, '_{0}{1}'.format(key,
'_rbv' if rbv else '')).get)
setattr(self, 'set_{0}'.format(key),
getattr(self, '_{0}'.format(key)).put)
def connect_pv(self, pvname, wid=None):
"""try to connect newly added epics PVs"""
if pvname is None or len(pvname) < 1:
return
if pvname not in self.connecting_pvs:
if pvname not in self.epics_pvs:
self.epics_pvs[pvname] = epics.PV(pvname)
self.connecting_pvs[pvname] = (wid, time.time())
if not self.etimer.IsRunning():
self.etimer.Start(150)
def fautomated_repeated_scan_busy(trigger_busy='7bmb1:busy4',
action_name='7bmb1:busy5',
action_value='Busy',
shutter='A'):
'''Performs a repeated scan.
'''
repeated_scan_busy_PV = epics.PV(trigger_busy)
counter = 0
try:
while True:
if repeated_scan_busy_PV.value == 1:
num_repeats = int(epics.caget('7bmb1:var:int1'))
sec_between_pts = float(epics.caget('7bmb1:var:float6'))
for i in range(num_repeats):
if repeated_scan_busy_PV.value == 0:
break
print("In the repeat loop on scan #{:3d}".format(i))
#Monitor for good beam
while epics.caget(
"S:SRcurrentAI.VAL") < 30.0 or epics.caget(
'PA:07BM:STA_A_BEAMREADY_PL.VAL') < 0.5:
print("Waiting for beam to come back at time " +
time.strftime('%H:%M:%S', time.localtime()))
time.sleep(5.0)
if shutter == 'A':
fopen_A_shutter()
else:
fopen_shutters()
#Start the scan
epics.caput(action_name, action_value)
time.sleep(1.0)
for t in range(int(sec_between_pts), 0, -1):
#Check to make sure we haven't clicked "Done" on repeated_scan_busy to abort this.
print(
"Waiting for the next scan, {0:d} s left.".format(
t))
if repeated_scan_busy_PV.value == 0:
print("Scan aborted!")
break
time.sleep(1.0)
repeated_scan_busy_PV.value = 0
time.sleep(0.5)
if counter == 100:
print("Looking for repeated scan busy at time " +
time.strftime('%H:%M:%S', time.localtime()))
counter = 0
else:
counter += 1
time.sleep(0.01)
finally:
print("Problem in repeated scan loop.")
if shutter == 'A':
fclose_A_shutter()
else:
fclose_B_shutter()
def caget(self, update: Update, cont: CallbackContext) -> None:
answer = ""
for PV in cont.args:
pv = epics.PV(PV, connection_timeout=0.2)
if pv.value is not None and pv.units is not None:
answer += "\n{}: {} {}".format(PV, pv.value, pv.units)
else:
answer += "\n{} is not available".format(PV)
update.message.reply_text(answer)
def testLogDeadband(self):
'''DBE_LOG monitor on an ai with an ADEL - leaving the deadband generates events.'''
# gateway:passiveADEL has ADEL=10
ioc = epics.PV("ioc:passiveADEL", auto_monitor=epics.dbr.DBE_LOG)
gw = epics.PV("gateway:passiveADEL", auto_monitor=epics.dbr.DBE_LOG)
gw.add_callback(self.onChange)
ioc.get()
gw.get()
for val in range(35):
ioc.put(val, wait=True)
time.sleep(.1)
# We get 5 events: at connection, first put, then at 11 22 33
self.assertTrue(
self.eventsReceived == 5,
'events expected: 5; events received: ' + str(self.eventsReceived))
# Any updates inside deadband are an error
self.assertTrue(
self.diffInsideDeadband == 0,
str(self.diffInsideDeadband) +
' events with change <= deadband received')
def benchmark_psconnsofb_kick_setpoint_delay(delay_before, delay_after):
"""."""
trigger = _epics.PV('AS-RaMO:TI-EVG:OrbSIExtTrig-Cmd')
trigger.wait_for_connection()
pssofb = PSConnSOFB(EthBridgeClient)
pssofb.bsmp_slowrefsync()
exectimes = [0] * 150
pssofb.bsmp_update_sofb()
kick_refmon = pssofb.sofb_kick_refmon
for i, _ in enumerate(exectimes):
# calc new kick
kick_sp = kick_refmon + 1 * 0.01 * _np.random.randn(len(kick_refmon))
# start clock
time0 = _time.time()
# set kick values
curr_sp = pssofb.bsmp_sofb_kick_set(kick_sp)
# sleep for a while
_time.sleep(delay_before)
# send trigger
trigger.value = 1
# stop clock
time1 = _time.time()
exectimes[i] = 1000 * (time1 - time0)
# make sure trigger signal gets to power supplies.
_time.sleep(delay_after)
# read from power supplies
pssofb.bsmp_update_sofb()
curr_rb = pssofb.sofb_current_refmon
# comparison
issame = pssofb.sofb_vector_issame(curr_sp, curr_rb)
if not issame:
print('SP<>RB in event {}'.format(i))
# restore state
pssofb.bsmp_sofb_kick_set(kick_refmon)
for exectime in exectimes:
print(exectime)
pssofb.threads_shutdown()
def connect(self, pvname):
if pvname is None:
raise RuntimeError("pvname must not be 'None'")
if len(pvname) == 0:
raise RuntimeError("pvname must not be ''")
self.axisDiagPvName = pvname
self.axisDiagPv = epics.PV(self.axisDiagPvName)
self.axisDiagPv.add_callback(self.onChangeAxisDiagPv)
self.trend.setTitle(self.axisDiagPvName)
def reconnect(self):
# Clear Epics cache
epics.ca._cache.clear()
#epics.ca._put_done.clear()
# Reconnect PV
self.pv = epics.PV(self.pv_name, auto_monitor = self.auto_monitor)
self.pv_connected = self.pv.connect()
# Return the result of get()
return self.pv.get(as_string = self.read_as_str, timeout=0.2)
def _create_pvs(self, psnames, propty):
"""Create PVs."""
new_pvs = dict()
for psn in psnames:
pvname = self._get_pvname(psn, propty)
auto_monitor = '(from Array)' not in propty
if pvname in _PVHandler._pvs:
continue
new_pvs[pvname] = epics.PV(
pvname, auto_monitor=auto_monitor, connection_timeout=0.05)
_PVHandler._pvs.update(new_pvs)
def pv_error(pv_str, valid, msg_list=[]):
tmp = pv_str
pv_tmp = epics.PV(tmp)
msg = str(tmp) + ' ' + str(pv_tmp.value)
if round(pv_tmp.value) != valid:
msg = "ERROR " + msg
else:
msg = "INFO " + msg
msg_list.append(msg)
print(msg)
return pv_tmp.value
def _connect(self):
if self.pvname is not None:
self.pv = epics.PV(self.pvname)
self.pv.wait_for_connection(timeout=self.TIMEOUT)
if self.pv is None:
logging.warning("Failed to connect to PV.")
else:
self.pv.get(timeout=self.TIMEOUT)
self.size = self.pv.count
else:
self.pv = None
def __init__(self,
motor='7bmb1:aero:m1',
asynRec='7bmb1:PSOFly1:cmdWriteRead',
axis='Z',
PSOInput=3,
encoder_multiply=1e5):
self.motor = epics.Motor(motor)
self.asynRec = epics.PV(asynRec + '.BOUT')
self.axis = axis
self.PSOInput = PSOInput
self.encoder_multiply = encoder_multiply
def setPV(self, pvname, prec=5, type=float):
self.prec = prec
self.type = type
if self.pv is not None and self.cb_index is not None:
self.pvChanging.disconnect()
self.pv.remove_callback(self.cb_index)
self.pv = epics.PV(BYTES2STR(pvname))
self.setText(self.pv.get(as_string=True))
self.cb_index = self.pv.add_callback(self.onPVChange)
self.pvChanging.connect(self.updatePV)
def set_value(self, channel, val):
"""
Method to set value to a channel
:param channel: (str) String of the devices name used in doocs
:param val: value
:return: None
"""
# print("SETTING")
epics.PV(channel).put(val)
return
def pvs():
pvlist = ['test:ao', 'test:ao.DRVH', 'test:bo', 'test:ao2', 'test:permit']
pvs = dict()
for name in pvlist:
pv = epics.PV(name)
pv.wait_for_connection()
pvs[pv.pvname] = pv
yield pvs
for pv in pvs.values():
pv.disconnect()
def connectPvs(self):
if self.pvNameY is None:
raise RuntimeError("pvname y must not be 'None'")
if len(self.pvNameY)==0:
raise RuntimeError("pvname y must not be ''")
self.pvY = epics.PV(self.pvNameY)
#print('self.pvY: ' + self.pvY.info)
self.pvY.add_callback(self.onChangePvY)
QCoreApplication.processEvents()
def __init__(self, name):
self._name = name
self._data = {} # keep all infos arriving with change callback
self._conn = False # keeps all infos arriving with connection callback
self._attached = set() # set of finite state machines using this IO
self._pv = epics.PV(name,
callback=self.chgcb,
connection_callback=self.concb,
auto_monitor=True)
self._cond = threading.Condition()
