def caput(pvname, value, timeout=1.0):
try:
pv = Pv(pvname)
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
pv.put(value, timeout)
pv.disconnect()
except pyca.pyexc, e:
print 'pyca exception: %s' % (e)
def caPutValue(pvName, value, verbose=True):
try:
# See if this PV exists
pv = Pv(pvName)
pv.connect(1.0)
pv.put(value, timeout=1.0)
except Exception, msg:
if verbose:
print "Unable to connect to PV:", pvName
if showCAErrors:
print >> sys.stderr, "failed: pyca exception: ", msg
return
def caput(pvname, value, timeout=1.0, **kw):
try:
pv = Pv(pvname)
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
try:
if kw['enum']:
pv.set_string_enum(True)
except:
pass
pv.put(value, timeout=timeout)
pv.disconnect()
except pyca.pyexc, e:
print 'pyca exception: %s' % (e)
class Magnet(object):
kick_delta = 0.0002 #in kG
def __init__(self, device_name, z_pos):
self.device_name = device_name
self.z = z_pos
self.bctrl_pv = Pv("{}:BCTRL".format(device_name))
self.bact_pv = Pv("{}:BACT".format(device_name))
@classmethod
def pv_count(cls):
return 2
@property
def name(self):
return self.device_name
def connect(self):
self.bctrl_pv.connect()
self.bact_pv.connect()
def connected(self):
if self.bctrl_pv.state() == 2 and self.bact_pv.state() == 2:
return True
else:
return False
def monitor(self):
self.bctrl_pv.monitor(pyca.DBE_VALUE)
self.bact_pv.monitor(pyca.DBE_VALUE)
@property
def kick_setpoint(self):
return self.bctrl_pv.data["value"]
@kick_setpoint.setter
def kick_setpoint(self, new_setpoint):
return self.bctrl_pv.put(new_setpoint)
@property
def kick_readback(self):
return self.bact_pv.data["value"]
def increase_kick(self):
before_val = self.kick_setpoint
new_val = before_val + (self.kick_delta)
self.kick_setpoint = new_val
def decrease_kick(self):
before_val = self.kick_setpoint
new_val = before_val - (self.kick_delta)
self.kick_setpoint = new_val
class LclsEvent(object):
"""
Contains methods to view and change parameters from the lcls
event/timing system screen.
"""
def __init__(self):
self._bykik_abort_pv = Pv(ioc_base + "BYKIK_ABTACT")
self._bykik_period_pv = Pv(ioc_base + "BYKIK_ABTPRD")
def edm_screen(self):
"""
Open up the lcls event/timing screen.
"""
subprocess.Popen([
"sh",
"/reg/g/pcds/package/epics/3.14-dev/screens/edm/common/current/lcls/lclsSystemArea.sh"
])
def bykik_status(self):
"""
Return status of bykik abort (Disable or Enable)
"""
val = self._bykik_abort_pv.get()
if val == 0:
return "Disable"
else:
return "Enable"
def bykik_disable(self):
"""
Disable bykik abort
"""
self._bykik_abort_pv.put(0)
def bykik_enable(self):
"""
Enable bykik abort
"""
self._bykik_abort_pv.put(1)
def bykik_get_period(self):
"""
Get number of events between bykik aborts
"""
return self._bykik_period_pv.get()
def bykik_set_period(self, period):
"""
Set number of events between bykik aborts
"""
self._bykik_period_pv.put(period)
def put(self, value):
""" put value to the Pv, returns the value itself """
if (is_debug_on()):
logprint("caput %s in %s\n" % (value, self.name))
pycaPv.put(self, value, time_out_get)
return value
class SmartMotor:
def __init__(self,
motor_channel,
motor_name=None,
active_monitoring=False):
self.motor_channel = motor_channel
self.motor_name = motor_name
self.active_monitoring = active_monitoring
self.__move_pv = Pv(motor_channel)
self.__move_pv.connect(1.0)
# self.__pos_pv = Pv(self.__get_pv_name('.RBV'))
# self.__pos_pv.connect(1.0)
self.__dmovpv = Pv(self.__get_pv_name('.DMOV'))
self.update()
pass
def update(self):
self.egu = self.__get('.EGU')
self.ulim_lo = self.__get('.LLM')
self.ulim_hi = self.__get('.HLM')
self.base_speed = self.__get('.SBAS')
self.speed = self.__get('.S')
self.accel = self.__get('.ACCL')
self.base_speed_egu = self.__get('.VELO')
self.speed_egu = self.__get('.VELO')
self.backlash_speed = self.__get('.SBAK')
self.backlash_accel = self.__get('.BACC')
self.backlash_dist = self.__get('.BDST')
if (self.motor_name is None):
self.motor_name = self.__get('.DESC')
pass
pass
# TODO: Add logic to consider backlash:
def is_in_range(self, pos):
return not (pos < self.ulim_lo or pos > self.ulim_hi)
pass
# TODO: Add logic to consider backlash:
def why_outside_range(self, pos):
if (pos < self.ulim_lo):
return "Position (%f%s) exceeds user low-limit (%f%s) for '%s.'" % (
pos, self.egu, self.ulim_lo, self.egu, self.motor_name)
elif (pos > self.ulim_hi):
return "Position (%f%s) exceeds user high-limit (%f%s) for '%s.'" % (
pos, self.egu, self.ulim_hi, self.egu, self.motor_name)
else:
return "Position (%f%s) is within user limits [%f,%f]%s for '%s.'" % (
pos, self.egu, self.ulim_lo, self.ulim_hi, self.egu,
self.motor_name)
def is_in_range_relative(self, offset):
return is_in_range(self.get_position() + offset)
def get_position(self):
return caget(self.__get_pv_name('.RBV'))
# self.__pos_pv.get(False, 5.0)
# return self.__pos_pv.value
def move(self, pos):
self.__move_pv.put(pos)
pyca.pend_io(.5)
pass
def wait(self, timeout=DEFAULT_TIMEOUT):
self.__dmovpv.wait_for_value(1, timeout)
def move_wait(self, pos, timeout=None):
if timeout == None:
timeout = self.get_move_time(pos)
self.move(pos)
self.wait(timeout)
# self.__dmovpv.wait_for_value(1, timeout)
pass
def move_relative(self, offset):
self.move(self.get_position() + offset)
pass
def move_relative_wait(self, offset, timeout=None):
pos = self.get_position() + offset
if timeout == None:
timeout = self.get_move_time(pos)
self.move_wait(pos, timeout)
pass
def __get_pv_name(self, pv_field):
return self.motor_channel + pv_field
def __get(self, pv_field):
return caget(self.__get_pv_name(pv_field))
def __put(self, pv_field, value):
caput(self.__get_pv_name(pv_field), value)
pass
def get_dist_to(self, pos):
return fabs(pos - self.get_position())
# TODO: Add logic to consider backlash
def get_move_time(self, pos):
return fabs(self.get_dist_to(pos) /
self.speed_egu) + 2 * self.accel + EPICS_OVERHEAD
# def get_move_time2(self, pos):
# return fabs(self.get_dist_to(pos) / self.speed_egu) + 2*self.accel + EPICS_OVERHEAD
# todo: add backlash checks
def checkLimits(self):
lim_lo = self.__get('.LLS')
if (lim_lo == 1):
return -1
else:
lim_hi = self.__get('.HLS')
if (lim_hi == 1):
return 1
else:
return 0
pass
pass
# TODO: This should pickle the important motor parameters to file
def saveMotor(self, file, name):
parms = {}
parms['DESC'] = self.name
pass
# TODO: Maybe make this a global which returns a motor instance?
# TODO: This should load a pickled record from a file
def loadMotor(self, file, name):
pass
# TODO: This should install the important motor parameters to a user motor channel
def installTo(self, channel, restict=True):
if restrict and channel.split(':')[1] != 'USR':
raise Exception(
"Request refused. Destination channel is not a user motor.")
else:
pass
pass
pass
def caput(PVName, val): """Same definition of caput but with a connect timeout of 10.0""" pv = Pv(PVName) pv.connect(timeout=10.0) pv.put(value=val, timeout=10.0) pv.disconnect()
for key, val in post.items():
if key in pvNames: # override pv value
if "cfg_id" in key:
pvdb[key] = val + 1
else:
pvdb[key] = pvNames[key]
print("Found match: ", key, val)
else:
pvdb[key] = val
for key, val in pvdb.items():
if "cfg_id" not in key:
_pv = Pv(prefix + ':' + key)
_pv.connect(1.0)
if type(val['value']) == list:
_pv.put(tuple(val['value']))
else:
_pv.put(val['value'])
pyca.flush_io()
# TODO: avoid creating Pv multiple times and avoid multiple connects
for key, val in pvdb.items():
if "cfg_id" not in key:
_pv = Pv(prefix + ':' + key)
_pv.connect(1.0)
_pv.get(False, 1.0)
# config keys for pvNames are the strings after the last colon
xtcDict = {}
for key, val in pvNames.items():
def caput(pvname, value):
pv = Pv(pvname)
pv.connect(1.)
pv.put(value, timeout=1.)
pv.disconnect()
try:
options.parse()
except Exception, msg:
options.usage(str(msg))
sys.exit()
motorpvname = options.motorpvname
position = float(options.start)
end = float(options.end)
delta = float(options.delta)
try:
motorpv = Pv(motorpvname)
motorpv.connect(1.0)
dmovpv = donemoving(motorpvname + '.DMOV')
steps = int((end-position)/delta)
for step in range(0, steps+1):
starttime = time.time()
motorpv.put(position)
pyca.pend_io(.1)
dmovpv.wait_for_done(10)
elapsed = time.time() - starttime
print 'pos %f time %.4f elapsed %f' %(position, starttime, elapsed)
position += delta
except pyca.pyexc, e:
print 'pyca exception: %s' %(e)
except pyca.caexc, e:
print 'channel access exception: %s' %(e)
except Exception, e:
print e
