def set_trigger_PV(self,value):
if value != self.__trigger_PV__:
from CA import camonitor,camonitor_clear
camonitor_clear(self.__trigger_PV__,callback=self.trigger_callback)
self.trigger_times = []
self.__trigger_PV__ = value
camonitor(self.__trigger_PV__,callback=self.trigger_callback)
def monitor(self,callback,new_thread=True):
"""Have the routine 'callback' be called every the time value
of the PV changes.
callback: function that takes three parameters:
PV_name, value, char_value
"""
from CA import camonitor
camonitor(self.prefix+".RBV",callback=callback,new_thread=new_thread)
def monitor(self,property_name,callback,*args,**kwargs):
from CA import camonitor
for PV_name in self.PV_names(property_name):
def monitor_callback(PV_name,value,formatted_value):
callback(*args,**kwargs)
monitor_callback.callback = callback
monitor_callback.args = args
monitor_callback.kwargs = kwargs
camonitor(PV_name,callback=monitor_callback,new_thread=True)
def caget_cached(PV_name):
"""Value of Channel Access (CA) Process Variable (PV)"""
from CA import caget, camonitor
camonitor(PV_name, callback=CA_cache_update)
value = caget(PV_name, timeout=0)
if value is None:
if cache.exists(PV_name): value = cache.get(PV_name)
if value is None: value = caget(PV_name)
if value is None: warn("Failed to get PV %r" % PV_name)
return value
def monitor(self,PVs):
"""Update list of monitored process variables"""
from CA import camonitor,camonitor_clear
for PV in self.monitored_PVs+[]:
if not PV in PVs:
camonitor_clear(PV,self.callback)
self.monitored_PVs.remove(PV)
for PV in PVs:
if not PV in self.monitored_PVs:
camonitor(PV,callback=self.callback)
self.monitored_PVs += [PV]
def query(self,string,terminator="",count=0):
"""Receive data, until either the terminator character was received,
the number of bytes given by 'count' have have received or
a timeout has occurred."""
# The first 'caget' after python statup always fails. As a work-around, use a
# dummy caget just in case.
if caget(self.port+".TMOD") != 0:
caput(self.port+".TMOD",0,wait=True) # 0 = write/read
if caget(self.port+".OEOS") != "":
caput(self.port+".OEOS","\0",wait=True) # not output terminator
if terminator:
if caget(self.port+".IEOS") != terminator:
caput(self.port+".IEOS",terminator,wait=True) # input terminator
else:
if caget(self.port+".IEOS") != "":
caput(self.port+".IEOS","\0",wait=True) # "\0" = none
if caget(self.port+".IFMT") != 1:
caput(self.port+".IFMT",1,wait=True) # 1 = hybrid
if caget(self.port+".SCAN") != 0:
caput(self.port+".SCAN",0,wait=True) # 0 = passive
if caget(self.port+".NRRD") != count:
caput(self.port+".NRRD",count,wait=True) # number of chars (0 = unlimited)
# If case string contains binary data, EpicsCA would strip away trailing
# null characters. Sending non-ASCII chacters as except codes
# makes sure that null characters are sent, too.
encoded_string = repr(string)[1:-1]
caput(self.port+".AOUT",encoded_string,wait=True)
# With EpicsCA it is (as of June 2009) not possible to reliably retreive
# special characters from the BINP (binary input) variable, because
# EpicsCA strips off trailing carriage return and null characters
# before passing back a string. Thus, I read the TINP (Text input)
# variable instead.
timeout = caget(self.port+".TMOT")
camonitor(self.port+".TINP",timeout=timeout)
reply = caget(self.port+".TINP")
if not reply: reply = ""
n = caget(self.port+".NORD")
if n == None: n = 0
if n == 0: return "" # nothing read
# Special characters in the TINP field are encoded as octal
# escape sequences. Decode them.
reply = eval("'"+reply+"'")
if caget(self.port+".EOMR") == 2: # 2 = EOS
return reply+terminator # terminator was stripped off, add it back
return reply
def write_read(self, command_dict):
"""Writes commands to multiple pumps with pump ids and commands
assembled in a dictionary. (with 1-based indices for the pumps)
Returns a dictionary of pump ids and their respective responses."""
from CA import caput, camonitor
from time import time, sleep
self.replies = {}
self.monitor_ids = command_dict.keys()
for i in command_dict:
camonitor(self.prefix + "%s.AINP" % i, callback=self.monitor)
if len(command_dict) > 1: caput(self.prefix + ".SPMG", 0) # halt queue
self.replies = {}
for i, command in command_dict.iteritems():
caput(self.prefix + "%s.AOUT" % i, command)
if len(command_dict) > 1:
caput(self.prefix + ".SPMG", 3) # resume queue
t0 = time()
while not all([i in self.replies for i in command_dict]):
if time() - t0 > self.timeout: break
sleep(0.010)
return self.replies
def CA_history(PV_name):
"""Value of Channel Access (CA) Process Variable (PV)"""
from CA import camonitor
camonitor(PV_name, callback=update)
history = PV_history.get(PV_name, ([], []))
return history
#!/usr/bin/env python
"""
Author: Friedrich Schotte
Date created: 2019-02-02
Date last modified: 2019-02-03
"""
from redirect import redirect
redirect("collect_monitor")
from CA import camonitor
camonitor("NIH:TIMING.registers.ch7_state.count")
camonitor("NIH:TIMING.registers.image_number.count")
camonitor("NIH:TIMING.registers.xdet_count.count")
camonitor("NIH:TIMING.registers.xdet_trig_count.count")
camonitor("NIH:TIMING.registers.xdet_acq_count.count")
camonitor("NIH:TIMING.registers.acquiring.count")
from time import sleep
while True: sleep(0.1)
def startup(self):
from CAServer import casput,casmonitor
from CA import caput,camonitor
from numpy import nan
#self.P_default , self.I_default , self.D_default = 1.0,0.316,0.562
#print('startup with prefix = %r' %self.prefix)
casput(self.prefix+".SCAN",self.SCAN)
casput(self.prefix+".DESC",value = "Temperature server IOC: a System Layer server that orchestrates setting on Lightwave IOC and Oasis IOC.", update = False)
casput(self.prefix+".EGU",value = "C")
# Set defaults
casput(self.prefix+".VAL",value = nan)
casput(self.prefix+".VAL_ADV",value = nan)
casput(self.prefix+".RBV",value = nan)
casput(self.prefix+".P",value = nan)
casput(self.prefix+".I",value = nan)
casput(self.prefix+".TIME_POINTS",self.time_points)
casput(self.prefix+".TEMP_POINTS",self.temp_points)
casput(self.prefix+".FAULTS"," ")
casput(self.prefix+".DMOV",value = nan)
casput(self.prefix+".KILL",value = 'write password to kill the process')
casput(self.prefix+".P_default",value = self.P_default)
casput(self.prefix+".I_default",value = self.I_default)
casput(self.prefix+".D_default",value = self.D_default)
casput(self.prefix+".oasis_slave",value = self.oasis_slave)
casput(self.prefix+".temperature_oasis_switch",value = self.temperature_oasis_switch)
casput(self.prefix+".idle_temperature_oasis",value = self.idle_temperature_oasis)
casput(self.prefix+".temperature_oasis_limit_high",value = self.temperature_oasis_limit_high)
casput(self.prefix+".oasis_headstart_time",value = self.oasis_headstart_time)
casput(self.prefix+".lightwave_prefix",value = self.lightwave_prefix)
casput(self.prefix+".oasis_prefix",value = self.oasis_prefix)
casput(self.prefix+".set_point_update_period",value = self.set_point_update_period)
casput(self.prefix+".oasis_RBV",value = nan)
casput(self.prefix+".oasis_VAL",value = nan)
#PV with a list of all process variable registered at the current Channel Access Server
casput(self.prefix+".LIST_ALL_PVS",value = self.get_pv_list())
# Monitor client-writable PVs.
casmonitor(self.prefix+".VAL",callback=self.monitor)
casmonitor(self.prefix+".VAL_ADV",callback=self.monitor)
casmonitor(self.prefix+".TIME_POINTS",callback=self.monitor)
casmonitor(self.prefix+".TEMP_POINTS",callback=self.monitor)
casmonitor(self.prefix+".KILL",callback=self.monitor)
casmonitor(self.prefix+".P_default",callback=self.monitor)
casmonitor(self.prefix+".I_default",callback=self.monitor)
casmonitor(self.prefix+".D_default",callback=self.monitor)
casmonitor(self.prefix+".oasis_slave",callback=self.monitor)
casmonitor(self.prefix+".temperature_oasis_switch",callback=self.monitor)
casmonitor(self.prefix+".idle_temperature_oasis",callback=self.monitor)
casmonitor(self.prefix+".temperature_oasis_limit_high",callback=self.monitor)
casmonitor(self.prefix+".oasis_headstart_time",callback=self.monitor)
casmonitor(self.prefix+".lightwave_prefix",callback=self.monitor)
casmonitor(self.prefix+".oasis_prefix",callback=self.monitor)
casmonitor(self.prefix+".set_point_update_period",callback=self.monitor)
#############################################################################
## Monitor server-writable PVs that come other servers
## Monitor Timing system IOC
from timing_system import timing_system
camonitor(timing_system.acquiring.PV_name,callback=self.on_acquire)
## Lightwave Temperature controller server
prefix = self.lightwave_prefix
camonitor(prefix+".VAL",callback=self.lightwave_monitor)
camonitor(prefix+".RBV",callback=self.lightwave_monitor)
camonitor(prefix+".P",callback=self.lightwave_monitor)
camonitor(prefix+".I",callback=self.lightwave_monitor)
camonitor(prefix+".DMOV",callback=self.lightwave_monitor)
## Oasis chiller server
prefix = self.oasis_prefix
camonitor(prefix+".VAL",callback=self.oasis_monitor)
camonitor(prefix+".RBV",callback=self.oasis_monitor)
## Create local circular buffers
from circular_buffer_LL import Server
self.buffers = {}
self.buffers['oasis_RBV'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['oasis_VAL'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['oasis_FAULTS'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['lightwave_RBV'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['lightwave_P'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['lightwave_I'] = Server(size = (2,1*3600*2) , var_type = 'float64')
self.buffers['lightwave_VAL'] = Server(size = (2,1*3600*2) , var_type = 'float64')
def set_monitoring_trigger(self,value):
from CA import camonitor,camonitor_clear
if value: camonitor(self.trigger_PV,callback=self.trigger_callback)
else: camonitor_clear(self.trigger_PV,callback=self.trigger_callback)
self.__monitoring_trigger__ = value
