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