def get_time_stamped_data(): sample_time = 0.50 num_to_show = 5 gdet = Pv('GDET:FEE1:241:ENRC') gmd = Pv('SXR:GMD:BLD:milliJoulesPerPulse') ebeam = Pv('BLD:SYS0:500:PHOTONENERGY') pv_list = [gdet, gmd, ebeam] for pv in pv_list: pv.monitor_start(True) time.sleep(sample_time) for pv in pv_list: pv.monitor_stop() my_dict = {} for pv in pv_list: for my_timestamps, my_vals in zip(pv.timestamps, pv.values): if ts_to_fid(my_timestamps) in my_dict: my_dict[ts_to_fid(my_timestamps)][pv.name] = my_vals else: my_dict[ts_to_fid(my_timestamps)] = {pv.name: my_vals} my_array = np.array([ np.array([my_dict[i][j] for j in my_dict[i]]) for i in my_dict if len(my_dict[i]) == 3 ]).transpose() return my_array
def __init__(self, name): pycaPv.__init__(self, name) self.connect(time_out_connect) self.monitor_cb = self.monitor_handler self.values = [] self.ismonitored = False self.last_update = "Never"
def connect(self): Pv.connect(self, timeout=1.0) self.connected = True # self.monitor_cb = self.changed evtmask = pyca.DBE_VALUE | pyca.DBE_LOG | pyca.DBE_ALARM self.monitor(evtmask) pyca.flush_io()
def __init__(self, name, adata=None): Pv.__init__(self, name) self.connected = False self._name = name self.evt = threading.Event() if adata != None: self.set_processor(adata) self.connect()
def __init__(self, pv_camera, pv_x, pv_z, detector=Detector()): self.pv_obj_camera = Pv(pv_camera) self.pv_obj_x = Pv(pv_x) self.pv_obj_z = Pv(pv_z) self.detector = detector self.image = None self.centroid = None self.bounding_box = None
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 setup_pv(pvname, con_cb=None, mon_cb=None, rwaccess_cb=None, signal=None, mon_cb_once=False): """ Initialize an EPICS PV using psp with proper callbacks. :param pvname: EPICS PV name :type pvname: str :param con_cb: Connection callback. If left as None and provided with signal, emit our value from signal as the callback. :type con_cb: function(isconnected=None) :param mon_cb: Monitor callback. If left as None and provided with signal, emit our value from signal as the callback. :type mon_cb: function(errors=None) :param rwaccess_cb: Read/write access state callback. :type rwaccess_cb: function(access_state) :param signal: Signal to emit our value on as the default callback when con_cb or mon_cb are left as None. Check the base :class:`PyDMConnection` class for available signals. :type signal: Signal :param mon_cb_once: True if we only want the monitor callback to run once. :type mon_cb_once: bool :rtype: Pv """ pv = Pv(pvname, use_numpy=True) if signal is None: default_mon_cb = lambda e: None else: default_mon_cb = generic_mon_cb(pv, signal) pv.add_connection_callback(con_cb or generic_con_cb(pv)) pv.add_monitor_callback(mon_cb or default_mon_cb, once=mon_cb_once) if rwaccess_cb: pv.add_rwaccess_callback(rwaccess_cb) pv.connect(None) return pv
def connectPv(name, timeout=-1.0): try: pv = Pv(name) if timeout < 0: pv.save_connect_cb = pv.connect_cb pv.connect_cb = lambda isconn: __connect_callback(pv, isconn) pv.connect(timeout) else: pv.connect(timeout) pv.get(ctrl=False, timeout=timeout) return pv except: return None
def dopv(self, name, gui, format): pv = Pv(name, initialize=True) if pv != None: gui.setText("") pv.gui = gui pv.format = format self.pvlist.append(pv) pv.add_monitor_callback(lambda e: self.displayPV(pv, e)) try: pv.wait_ready(0.5) pv.monitor() except: pass
def setup_pv(pvname, con_cb=None, mon_cb=None, signal=None, mon_cb_once=False): """ Initialize an EPICS PV using psp with proper callbacks. :param pvname: EPICS PV name :type pvname: str :param con_cb: Connection callback. If left as None and provided with signal, emit our value from signal as the callback. :type con_cb: function(isconnected=None) :param mon_cb: Monitor callback. If left as None and provided with signal, emit our value from signal as the callback. :type mon_cb: function(errors=None) :param signal: Signal to emit our value on as the default callback when con_cb or mon_cb are left as None. Check the base :class:`PyDMConnection` class for available signals. :type signal: pyqtSignal :param mon_cb_once: True if we only want the monitor callback to run once. :type mon_cb_once: bool :rtype: Pv """ pv = Pv(pvname, use_numpy=True) if signal is None: default_mon_cb = lambda e: None else: default_mon_cb = generic_mon_cb(pv, signal) pv.add_connection_callback(con_cb or generic_con_cb(pv)) pv.add_monitor_callback(mon_cb or default_mon_cb, once=mon_cb_once) pv.connect(None) return pv
def get(self, handle_no_ioc=True): """ returns current value for the Pv """ if (is_debug_on()): logprint("caget %s: " % self.name) try: pycaPv.get(self, False, time_out_get) self.last_update = self.timestr() if (is_debug_on()): logprint("got %s\n" % self.value.__str__()) return self.value except pyca.pyexc: logprint("caget %s: " % self.name, newline=False) logprint("failed (PV timed out) !!, returning nan") return numpy.nan
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 __init__(self, name): pycaPv.__init__(self, name) try: self.connect(time_out_connect) except pyca.pyexc: print "## WARNING ## connecting to %s timeout, will try once more" % name logprint( "## WARNING ## connecting to %s timeout, will try once more" % name) time.sleep(0.1) self.connect(time_out_connect) self.monitor_cb = self.monitor_handler self.values = [] self.ismonitored = False self.monitor_append = False self.last_update = "Never"
def caget(pvname, timeout=1.0): try: pv = Pv(pvname) pv.connect(timeout) pv.get(ctrl=False, timeout=timeout) v = pv.value pv.disconnect() return v except pyca.pyexc, e: print 'pyca exception: %s' % (e) return None
def caget(pvname, timeout=1.0, **kw): try: pv = Pv(pvname) pv.connect(timeout) try: if kw['enum']: pv.set_string_enum(True) except: pass pv.get(ctrl=False, timeout=timeout) v = pv.value pv.disconnect() return v except pyca.pyexc as e: print('pyca exception: %s' % (e)) return None except pyca.caexc as e: print('channel access exception: %s' % (e)) return None
class Imager(object): """ Imager object that will encapsulate the various yag screens along the beamline. """ def __init__(self, pv_camera, pv_x, pv_z, detector=Detector()): self.pv_obj_camera = Pv(pv_camera) self.pv_obj_x = Pv(pv_x) self.pv_obj_z = Pv(pv_z) self.detector = detector self.image = None self.centroid = None self.bounding_box = None def get(self): """Get an image from the imager.""" self.image = Pv.get() return self.image def get_centroid(self): """Return the centroid of the image.""" self.centroid, self.bounding_box = self.detector.find(Pv.get()) return self.centroid @property def x(self): return self.pv_obj_x.get() @x.setter def x(self, val): put_val(self.pv_obj_x, val) @property def z(self): return self.pv_obj_z.get() @z.setter def z(self, val): put_val(self.pv_obj_z, val) @property def pos(self): return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
class Source(object): def __init__(self, pv_x, pv_xp, pv_y, pv_yp, pv_z): self.pv_obj_x = Pv(pv_x) self.pv_obj_xp = Pv(pv_xp) self.pv_obj_y = Pv(pv_y) self.pv_obj_yp = Pv(pv_yp) self.pv_obj_z = Pv(pv_z) def put_val(self, pv, val): try: pv.put(float(val)) except ValueError: print("Invalid input type. Must be castable to float.") @property def x(self): return self.pv_obj_x.get() @x.setter def x(self, val): put_val(self.pv_obj_x, val) @property def xp(self): return self.pv_obj_xp.get() @xp.setter def xp(self, val): put_val(self.pv_obj_xp, val) @property def y(self): return self.pv_obj_y.get() @y.setter def y(self, val): put_val(self.pv_obj_y, val) @property def yp(self): return self.pv_obj_yp.get() @yp.setter def yp(self, val): put_val(self.pv_obj_yp, val) @property def z(self): return self.pv_obj_z.get() @z.setter def z(self, val): put_val(self.pv_obj_z, val) @property def pos(self): return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
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 caPutArray(pvName, value, timeout=-1.0): try: tmo = float(timeout) # See if this PV exists pv = Pv(pvName) pv.connect(1.0) # Convert value to the appropriate type for this PV # Assumption is that PV is a waveform record if isinstance(value, str): # Convert string values to a tuple value = stringToTuple(value) if not isinstance(value, tuple): raise TypeError, "Pv.put Error: value not a tuple for waveform PV" if len(value) != len(pv.value): raise TypeError, "Pv.put Error: Element count mismatch" pv.put_data(value, tmo) except Exception, msg: if verbose: print "Unable to connect to PV:", pvName if showCAErrors: print >> sys.stderr, "failed: pyca exception: ", msg return
def caget(pvname,timeout=30.0): try: pv = Pv(pvname) pv.connect(timeout) pv.get(ctrl=False, timeout=timeout) v = pv.value pv.disconnect() return v except pyca.pyexc as e: print('pyca exception: %s' %(e)) return None except pyca.caexc as e: print('channel access exception: %s' %(e)) return None
def caget_async(pvname): try: pv = Pv(pvname) pv.get_done = threading.Event() pv.connect_cb = lambda isconn: __connect_callback(pv, isconn) pv.getevt_cb = lambda e=None: __get_callback(pv, e) pv.connect(-1) return pv except pyca.pyexc, e: print 'pyca exception: %s' % (e) return None
class Mirror(object): """ Mirror class to encapsulate the two HOMS (or any) mirrors. """ def __init__(self, pv_x, pv_alpha, pv_z): self.pv_obj_x = Pv(pv_x) self.pv_obj_xp = Pv(pv_xp) self.pv_obj_z = Pv(pv_z) @property def x(self): return self.pv_obj_x.get() @x.setter def x(self, val): put_val(self.pv_obj_x, val) @property def alpha(self): return self.pv_obj_alpha.get() @alpha.setter def alpha(self, val): put_val(self.pv_obj_alpha, val) @property def z(self): return self.pv_obj_z.get() @z.setter def z(self, val): put_val(self.pv_obj_z, val) @property def pos(self): return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
def reconfigStream(cameraPvName, streamName, verbose=False): streamPvName = cameraPvName + ":" + streamName try: streamTypePv = Pv(streamPvName + ":StreamType") streamTypePv.connect(0.5) streamTypePv.get(timeout=1.0) except Exception, msg: if verbose: print "Stream %s not found." % streamName return
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 printPvNameValue(pvName): try: pv = Pv(pvName) pv.connect(0.1) pv.get() if isinstance(pv.value, str): print "%s \"%-.30s\"" % (pv.name, pv.value) else: print "%s %-.30s" % (pv.name, pv.value) except pyca.pyexc, msg: if showCAErrors: print >> sys.stderr, "failed: pyca exception: ", msg pass
def caGetValue(pvName, verbose=True, timeout=0.1): try: # See if this PV exists pv = Pv(pvName) pv.connect(timeout) pv.get() return pv.value except Exception, msg: if verbose: print "Unable to connect to PV: %s" % pvName if showCAErrors: print >> sys.stderr, "failed: pyca exception: ", msg return None
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
def __init__(self, pv_x, pv_alpha, pv_z): self.pv_obj_x = Pv(pv_x) self.pv_obj_xp = Pv(pv_xp) self.pv_obj_z = Pv(pv_z)
def get_centroid(self): """Return the centroid of the image.""" self.centroid, self.bounding_box = self.detector.find(Pv.get()) return self.centroid
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
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))
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()