def monitor(self, PV_name, value, char_value):
"""Handle client changes to PVs"""
with self.lock: # Allow only one thread at a time inside this function.
info("Received request %s=%r" % (PV_name, value))
# Delay execution of client requests storing them in a command queue.
from CAServer import casput
if PV_name == self.prefix + ".SCAN":
self.scan_time = value
casput(self.prefix + ".SCAN", self.scan_time)
for i in range(0, self.N):
if PV_name == self.prefix + "%d.AOUT" % (i + 1):
self.queue.commands[i] = value # queue for execution
elif PV_name == self.prefix + "%d:VOLUME.VAL" % (i + 1):
self.queue.volume_values[i] = value # queue for execution
elif PV_name == self.prefix + "%d:VOLUME.VELO" % (i + 1):
self.queue.volume_speeds[i] = value # queue for execution
elif PV_name == self.prefix + "%d:VOLUME.STOP" % (i + 1):
self.queue.volume_moving[
i] = not value # queue for execution
elif PV_name == self.prefix + "%d:PORT.VAL" % (i + 1):
self.queue.ports_values[i] = value # queue for execution
elif PV_name == self.prefix + "%d:PORT.STOP" % (i + 1):
self.queue.ports_values_moving[
i] = not value # queue for execution
info("Command count: %r" % len(self.queue.commands))
def lightwave_monitor(self,PV_name,value,char_value):
#print('time: %r, PV_name = %r,value= %r,char_value = %r' %(time(),PV_name,value,char_value) )
from CA import cainfo
from CAServer import casput
prefix = self.lightwave_prefix
if PV_name == prefix+".VAL":
arr = empty((2,1))
arr[0] = cainfo(prefix+".VAL","timestamp")
arr[1] = float(value)
self.buffers['lightwave_VAL'].append(arr)
casput(self.prefix +'.VAL',value = float(value))
if PV_name == prefix+".RBV":
arr = empty((2,1))
arr[0] = cainfo(prefix+".RBV","timestamp")
arr[1] = float(value)
self.buffers['lightwave_RBV'].append(arr)
casput(self.prefix +'.RBV',value = float(value))
if PV_name == prefix+".P":
arr = empty((2,1))
arr[0] = cainfo(prefix+".P","timestamp")
arr[1] = float(value)
self.buffers['lightwave_P'].append(arr)
casput(self.prefix +'.P',value = float(value))
if PV_name == prefix+".I":
arr = empty((2,1))
arr[0] = cainfo(prefix+".I","timestamp")
arr[1] = float(value)
self.buffers['lightwave_I'].append(arr)
casput(self.prefix +'.I',value = float(value))
#Done Move PV
if PV_name == prefix+".DMOV":
casput(self.prefix +'.DMOV',value = float(value))
def run(self):
from time import time,sleep
from CAServer import casget,casput
from SAXS_WAXS_control import SAXS_WAXS_control
from temperature_controller import temperature_controller
casput(self.CAS_prefix+'.ENABLED', self.intervention_enabled)
casput(self.CAS_prefix+'.RUNNING', self.deice_enabled)
try:
print('current temperature %r' % temperature_controller.value)
info('current temperature %r' % temperature_controller.value)
except:
warn('could not get temperature')
last_image_file = ""
while self.deice_enabled:
try:
self.intervention_enabled = casget(self.CAS_prefix+'.ENABLED')
except:
error('Failed to get CA %r' % (self.CAS_prefix+'.ENABLED'))
self.intervention_enabled = False
self.running_timestamp = time()
if self.current_image_file != last_image_file:
last_image_file = self.current_image_file
if self.sample_frozen(self.current_image_file) and not self.aux_deicing and self.intervention_enabled and (temperature_controller.value < -5.0) :
self.aux_deicing = True
elif self.sample_frozen(self.current_image_file) and SAXS_WAXS_control.inserted and self.retract_deicing and (temperature_controller.value < -5.0):
SAXS_WAXS_control.retracted = True
sleep(self.retracted_time)
SAXS_WAXS_control.inserted = True
else:
pass
else: sleep(0.25)
def run():
from time import sleep
casput("NIH:CHILLER.AUTOTUNE", 1)
while True:
autotune()
sleep(5)
def running(self):
info("Starting IOC...")
from CAServer import casget, casput, casdel, casmonitor
from time import time
from sleep import sleep
for name in self.PV_names:
PV_name = self.PV_name(name)
casmonitor(PV_name, callback=self.monitor)
while not self.running_cancelled:
t = time()
for name in self.PV_names:
if time() - self.last_updated(name) > self.update_period(name):
PV_name = self.PV_name(name)
value = getattr(self.object, name)
##info("%s=%r" % (PV_name,value))
casput(PV_name, self.transform(name, value), update=False)
self.set_update_time(name)
if not self.running_cancelled:
sleep(t + self.min_update_period - time())
for name in self.names:
PV_name = self.PV_name(name)
casdel(PV_name)
def monitor(self, PV_name, value, char_value):
"""Handle PV change requests"""
info("%s = %r" % (PV_name, value))
from CAServer import casput
for name in self.property_names:
if PV_name == self.prefix + name.upper():
setattr(self, name, value)
casput(PV_name, getattr(self, name))
def set_is_running(self,value):
from thread import start_new_thread
if value and not self.running:
self.init()
self.running = True
start_new_thread(self.run,())
else: self.running = False
casput(self.CAS_prefix+'.RUNNING', self.running)
def set_running(self,value):
from thread import start_new_thread
from CAServer import casput
if value and not self.running:
casput(self.CAS_prefix+'.RUNNING', value)
self.deice_enabled = True
start_new_thread(self.run,())
else: self.deice_enabled = False
def analyze_commands(self, command_dict):
"""Updaste state info base on serial commands snet directly to the
pump onctroller"""
from CAServer import casput
from parse import parse
for i, command in command_dict.iteritems():
values = parse("/{}A{value:g},1{}", command) # Absolute volume
if values:
casput(self.prefix + "%d:VOLUME.VAL" % (i + 1),
values["value"])
def sample_frozen(self,image_file):
from CAServer import casput
total_spots = self.diffraction_spots_of_image(image_file)
try:
casput(self.CAS_prefix+'.SPOTS',total_spots)
except:
pass
flag = total_spots >= self.threshold_N_spts
return flag
def monitor(self, PV_name, value, char_value):
"""Process PV change requests"""
from CAServer import casput
info("%s = %r" % (PV_name, value))
if PV_name == self.prefix + ".SCAN":
oasis_chiller_driver.wait_time = float(value)
casput(self.prefix + ".SCAN", oasis_chiller_driver.wait_time)
else:
attr = PV_name.replace(self.prefix + ".", "")
self.command_queue.append([attr, float(value)])
def monitor(self, PV_name, value, char_value):
"""Handle PV change requests"""
info("%s = %r" % (PV_name, value))
from CAServer import casput
for name in self.PV_names:
if PV_name == self.PV_name(name):
info("%s.%s=%r" % (self.object, name, value))
setattr(self.object, name, self.back_transform(name, value))
value = getattr(self.object, name)
casput(PV_name, self.transform(name, value))
def monitor(self, PV_name, value, char_value):
"""Process PV change requests"""
from CAServer import casput
info("%s = %r" % (PV_name, value))
if PV_name == self.prefix + ".SCAN":
self.SCAN = float(value)
casput(self.prefix + ".SCAN", self.SCAN)
if PV_name == self.prefix + ".VAL":
Ramsey_RF_driver.VAL = float(value)
casput(self.prefix + ".VAL", float(Ramsey_RF_driver.VAL))
def oasis_monitor(self,PV_name,value,char_value):
#print('oasis_monitor: time: %r, PV_name = %r,value= %r,char_value = %r' %(time(),PV_name,value,char_value) )
from CA import cainfo
prefix = self.oasis_prefix
if PV_name == prefix+".VAL":
arr = empty((2,1))
arr[0] = cainfo(prefix+".VAL","timestamp")
arr[1] = float(value)
self.buffers['oasis_VAL'].append(arr)
casput(self.prefix +'.oasis_VAL',value = float(value))
if PV_name == prefix+".RBV":
arr = empty((2,1))
arr[0] = cainfo(prefix+".RBV","timestamp")
arr[1] = float(value)
self.buffers['oasis_RBV'].append(arr)
casput(self.prefix +'.oasis_RBV',value = float(value))
def socketserver_init(self):
socket_port_lst = range(2030, 2050)
i = 0
flag = True
while flag:
try:
port = socket_port_lst[i]
self.sock = socket(AF_INET, SOCK_STREAM)
self.sock.bind(('', port))
self.sock.listen(5)
info('Trial %r, Connection to 127.0.0.1:%r is successful' %
(i, port))
self.socket_port = port
self.socket = [gethostbyname(gethostname()), self.socket_port]
casput(self.prefix + '.SOCKET', self.socket)
flag = False
info('flag in socketserver_init = %r' % flag)
except Exception as e:
i += 1
error(e)
self.server_command_dict = {}
self.server_command_dict[-2] = '-2:dev_info(in: None, out: dict)'
self.server_command_dict[-1] = '-1:type_def(in:None, out: dict)'
self.server_command_dict[0] = '0:init()'
self.server_command_dict[1] = '1:close()'
self.server_command_dict[
2] = '2:broadcast fixed rate(in: float, out: None)'
self.server_command_dict[
3] = '3:request average of N (in:N, out:float)'
self.server_command_dict[
4] = '4:request buffer all(in: None, out: nparray)'
self.server_command_dict[
5] = '5:request buffer update(in:pointer, out:nparray)'
self.server_command_dict[
6] = '6:perform calibration(in: None, out: nparray)'
self.server_command_dict[
7] = '7:get calibration(in: None, out: nparray)' #stores 1 oldest calibration record.
self.server_command_dict[8] = '8:save to a file(in: None, out: none)'
self.type_def = msgpack.packb(self.server_command_dict,
default=m.encode)
msg_in = [-1, -1, -1, -1]
self._run()
def startup(self):
from CAServer import casput,casmonitor
from CA import caput,camonitor
from numpy import nan
casput(self.prefix+".ENABLE",self.intervention_enabled)
casput(self.prefix+'.RUNNING', self.running)
casput(self.prefix+".KILL",value = 'write password to kill the process')
casput(self.prefix+".LIST_ALL_PVS",value = self.get_pv_list())
# Monitor client-writable PVs.
casmonitor(self.prefix+".KILL",callback=self.monitor)
def running(self):
info("Starting IOC: Prefix: %s ..." % self.prefix)
from CAServer import casget, casput, casdel
from time import time
from sleep import sleep
self.monitors_setup()
while not self.running_cancelled:
t = time()
for name in self.property_names:
if time() - self.last_updated(name) > self.update_period(name):
PV_name = self.prefix + name.upper()
value = getattr(self, name)
##info("Update: %s=%r" % (PV_name,value))
casput(PV_name, value, update=False)
self.set_update_time(name)
if not self.running_cancelled:
sleep(t + self.min_update_period - time())
casdel(self.prefix)
def monitor(self, PV_name, value, char_value):
"""Handle PV change requests"""
info("%s = %r" % (PV_name, value))
from configuration_driver import configuration
from CAServer import casput
for conf in configuration.configurations:
for prop in self.configuration_properties:
if PV_name == (self.prefix + "." + conf.name + "." +
prop).upper():
self.setattr(conf, prop, value)
value = self.getattr(conf, prop, expand=True)
if value is not None: casput(PV_name, value, update=False)
for motor_num in range(0, conf.n_motors):
for prop in self.motor_properties:
if PV_name == (self.prefix + "." + conf.name + ".MOTOR" +
str(motor_num + 1) + "." + prop).upper():
self.setitem(self.getattr(conf, prop), motor_num,
value)
value = self.getitem(self.getattr(conf, prop),
motor_num)
if value is not None:
casput(PV_name, value, update=False)
def monitor(self, PV_name, value, char_value):
"""Process PV change requests"""
from CAServer import casput
debug("%s = %r" % (PV_name, value))
if PV_name == self.prefix + ".SCAN":
self.SCAN = value
casput(self.prefix + ".SCAN", self.SCAN)
if PV_name == self.prefix + ".MFILTER":
thermocouple_driver.MFILTER = value
casput(self.prefix + ".MFILTER", thermocouple_driver.MFILTER)
if PV_name == self.prefix + ".IFILTER":
thermocouple_driver.IFILTER = value
casput(self.prefix + ".IFILTER", thermocouple_driver.IFILTER)
if PV_name == self.prefix + ".TCTYPE":
thermocouple_driver.TCTYPE = value
casput(self.prefix + ".TCTYPE", thermocouple_driver.TCTYPE)
def process_command_queue(self):
"""Handle client changes to PVs that where queued up by 'monitor'
in a synchronous ways."""
with self.lock: # Allow only one thread at a time inside this function.
if not self.queue_halted:
from CAServer import casput
if self.queue.commands:
info("Sending commands %r" % self.queue.commands)
replies = comm_ports.write_read(self.queue.commands)
self.analyze_commands(self.queue.commands)
info("Got replies %r" % replies)
for i in replies:
info("Updating %s=%r" % (self.prefix + "%d.AINP" %
(i + 1), replies[i]))
casput(self.prefix + "%d.AINP" % (i + 1),
replies[i],
update=True)
self.queue.commands = {}
if self.queue.volume_values:
volumes.set_values(self.queue.volume_values.keys(),
self.queue.volume_values.values())
V = self.queue.volume_values
for i in V:
casput(self.prefix + "%d:VOLUME.VAL" % (i + 1), V[i])
self.queue.volume_values = {}
if self.queue.volume_speeds:
volumes.set_speeds(self.queue.volume_speeds.keys(),
self.queue.volume_speeds.values())
indices = self.queue.volume_speeds.keys()
speeds = volumes.speeds(indices) # read back values
for i in indices:
casput(self.prefix + "%d:VOLUME.VELO" % (i + 1),
speeds[i])
self.queue.volume_speeds = {}
if self.queue.ports_values:
ports.set_values(self.queue.ports_values.keys(),
self.queue.ports_values.values())
p = self.queue.ports_values
for i in p:
casput(self.prefix + "%d:PORT.VAL" % (i + 1), p[i])
self.queue.ports_values = {}
if self.queue.volume_moving:
volumes.set_moving(self.queue.volume_moving.keys(),
self.queue.volume_moving.values())
self.queue.volume_moving = {}
def broadcast(self, method="on demand"):
dt = self.broadcast_period
number = int(dt * 50)
if method == "on demand":
#debug('Broadcasting on demand')
ch1 = mean(
((self.circular_buffer.get_last_N(N=number)[0] - 8192.) /
8192.) * float(self.gain_lst[0])) / self.calib[0]
casput(self.prefix + ".pressure_upstream", ch1)
ch2 = mean(
((self.circular_buffer.get_last_N(N=number)[1] - 8192.) /
8192.) * float(self.gain_lst[1])) / self.calib[1]
casput(self.prefix + ".pressure_downstream", ch2)
ch3 = mean(
((108.364 - 88.0461) / 2.0**13) *
(self.circular_buffer.get_last_N(N=number)[2] - 2.0**13) +
88.0461 + 0.2)
casput(self.prefix + ".pressure_barometric", ch3)
ch4 = mean(self.circular_buffer.get_last_N(N=number)[3] -
8192.) * 0.036621 + 100. + self.calib[3]
casput(self.prefix + ".temperature_hutch", ch4)
else:
debug("unknown method(%r) requested" % method)
def update(self):
from CAServer import casput, casmonitor
from configuration_driver import configuration
for prop in self.global_properties:
PV_name = (self.prefix + "." + prop).upper()
value = self.getattr(configuration, prop, expand=True)
if value is not None:
casput(PV_name, value, update=False)
casmonitor(PV_name, callback=self.monitor)
for conf in configuration.configurations:
for prop in self.configuration_properties:
PV_name = (self.prefix + "." + conf.name + "." + prop).upper()
value = self.getattr(conf, prop, expand=True)
if value is not None:
casput(PV_name, value, update=False)
casmonitor(PV_name, callback=self.monitor)
for prop in self.motor_properties:
for motor_num in range(0, conf.n_motors):
PV_name = (self.prefix + "." + conf.name + ".MOTOR" +
str(motor_num + 1) + "." + prop).upper()
value = self.getitem(self.getattr(conf, prop), motor_num)
if value is not None:
casput(PV_name, value, update=False)
casmonitor(PV_name, callback=self.monitor)
def run(self):
"""Run EPICS IOC"""
from CAServer import casput, casmonitor, casdel
from numpy import isfinite, isnan
from time import time
self.running = True
casput(self.prefix + ".SCAN", self.SCAN)
casput(self.prefix + ".DESC", "Temp")
casput(self.prefix + ".EGU", "C")
# Monitor client-writable PVs.
casmonitor(self.prefix + ".SCAN", callback=self.monitor)
casmonitor(self.prefix + ".MFILTER", callback=self.monitor)
casmonitor(self.prefix + ".IFILTER", callback=self.monitor)
casmonitor(self.prefix + ".TCTYPE", callback=self.monitor)
while self.running:
if self.SCAN > 0 and isfinite(self.SCAN):
if time() - self.last_valid_reply > 10:
if not isnan(thermocouple_driver.VAL):
info("Reading configuration")
casput(self.prefix + ".COMM", thermocouple_driver.COMM)
casput(self.prefix + ".MFILTER",
thermocouple_driver.MFILTER)
casput(self.prefix + ".IFILTER",
thermocouple_driver.IFILTER)
casput(self.prefix + ".TCTYPE",
thermocouple_driver.TCTYPE)
t = time()
VAL = thermocouple_driver.VAL
if not isnan(VAL): self.last_valid_reply = time()
casput(self.prefix + ".VAL", VAL)
sleep(t + 1.00 * self.SCAN - time())
casput(self.prefix + ".SCANT",
time() - t) # post actual scan time for diagnostics
else:
casput(self.prefix + ".SCANT", nan)
sleep(0.1)
casdel(self.prefix)
def set_queue_halted(self, value):
from CAServer import casput
return casput(self.prefix + ".SPMG", 0 if value else 3)
def run(self):
"""Run EPICS IOC"""
from CAServer import casput, casmonitor, casdel
from numpy import isfinite
from time import time
self.running = True
# Initialization
casput(self.prefix + ".SCAN", self.scan_time)
casput(self.prefix + ".SPMG", 3) # 0:Stop,1:Pause,2:Move,3:Go
for i in range(0, self.N):
casput(self.prefix + "%d.AOUT" % (i + 1),
"") # ASCII output string to device
casput(self.prefix + "%d.AINP" % (i + 1),
"") # ASCII input string from device
# Static PVs
for i in range(0, self.N):
casput(self.prefix + "%d:VOLUME.DESC" % (i + 1),
"Pump%d" % (i + 1))
casput(self.prefix + "%d:VOLUME.EGU" % (i + 1), "uL")
casput(self.prefix + "%d:PORT.DESC" % (i + 1), "Valve%d" % (i + 1))
casput(self.prefix + "%d:PORT.EGU" % (i + 1), "OIB")
casput(self.prefix + "%d:VOLUME.CNEN" % (i + 1), 1)
casput(self.prefix + "%d:PORT.CNEN" % (i + 1), 1)
# Monitor client-writable PVs
casmonitor(self.prefix + ".SCAN", callback=self.monitor)
casmonitor(self.prefix + ".SPMG", callback=self.monitor)
for i in range(0, self.N):
casmonitor(self.prefix + "%d.AOUT" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d.AINP" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d:VOLUME.VAL" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d:VOLUME.VELO" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d:PORT.VAL" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d:VOLUME.STOP" % (i + 1),
callback=self.monitor)
casmonitor(self.prefix + "%d:PORT.STOP" % (i + 1),
callback=self.monitor)
while self.running:
if self.scan_time > 0 and isfinite(self.scan_time):
for i in range(0, self.N):
if comm_ports.max_time_between_replies[i] > 10:
comm_ports.max_time_between_replies[i] = 0
debug("Reading pump %d configuration" % (i + 1))
casput(self.prefix + "%d:VOLUME.VAL" % (i + 1),
volumes.values([i])[0])
casput(self.prefix + "%d:VOLUME.LLM" % (i + 1),
volumes.low_limits([i])[0])
casput(self.prefix + "%d:VOLUME.HLM" % (i + 1),
volumes.high_limits([i])[0])
casput(self.prefix + "%d:PORT.VAL" % (i + 1),
ports.values([i])[0])
t = time()
values = volumes.values(range(0, self.N))
for i in range(0, self.N):
casput(self.prefix + "%d:VOLUME.RBV" % (i + 1), values[i])
self.process_command_queue()
values = ports.values(range(0, self.N))
for i in range(0, self.N):
casput(self.prefix + "%d:PORT.RBV" % (i + 1), values[i])
self.process_command_queue()
moving = volumes.moving(range(0, self.N))
for i in range(0, self.N):
casput(self.prefix + "%d:VOLUME.DMOV" % (i + 1),
not moving[i])
casput(self.prefix + "%d:PORT.DMOV" % (i + 1),
not moving[i])
self.process_command_queue()
speeds = volumes.speeds(range(0, self.N))
for i in range(0, self.N):
casput(self.prefix + "%d:VOLUME.VELO" % (i + 1), speeds[i])
self.process_command_queue()
sleep(t + 1 * self.scan_time - time())
casput(self.prefix + ".SCANT",
time() - t) # post actual scan time for diagnostics
else:
casput(self.prefix + ".SCANT", nan)
sleep(0.1)
casdel(self.prefix)
def init(self):
"""
define parameters for current operation
initializes image analyzer
"""
from optical_image_analyzer import image_analyzer
image_analyzer.init()
from CAServer import casput, casmonitor
from CA import caput, camonitor
from numpy import nan
info('initializing the %s server' % self.prefix)
casput(self.prefix + ".RBV", nan)
casput(self.prefix + ".VAL", nan)
casput(self.prefix + ".MEAN_TOP", nan)
casput(self.prefix + ".MEAN_BOTTOM", nan)
casput(self.prefix + ".MEAN_MIDDLE", nan)
casput(self.prefix + ".MEAN", nan)
casput(self.prefix + ".STDEV", nan)
casput(self.prefix + '.RUNNING', self.running)
#changable control parameters
casput(self.prefix + '.region_offset_x', self.region_offset_x)
casput(self.prefix + '.region_size_x', self.region_size_x)
casput(self.prefix + '.region_offset_y', self.region_offset_y)
casput(self.prefix + '.region_size_y', self.region_size_y)
casput(self.prefix + '.warning', self.warning)
casput(self.prefix + '.warning_threshold', self.warning_threshold)
casput(self.prefix + ".KILL",
value='write password to kill the process')
#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 + ".KILL", callback=self.monitor)
casmonitor(self.prefix + ".region_size_x", callback=self.monitor)
casmonitor(self.prefix + ".region_offset_x", callback=self.monitor)
casmonitor(self.prefix + ".region_size_y", callback=self.monitor)
casmonitor(self.prefix + ".region_offset_y", callback=self.monitor)
casmonitor(self.prefix + ".warning_threshold", callback=self.monitor)
def run_once(self):
from optical_image_analyzer import image_analyzer
from CAServer import casput, casget
from numpy import rot90
img = image_analyzer.get_image()
debug('image received: image counter %r, image dimensions %r' %
(image_analyzer.imageCounter, img.shape))
if self.orientation == 'horizontal2' or self.orientation == 'horizontal' or self.orientation == 'on-axis-h':
img = rot90(img, 3, axes=(1, 2))
res_dic = self.is_frozen(img)
debug('res_dic = %r' % res_dic)
is_frozen_flag = res_dic['flag']
casput(self.prefix + ".MEAN_TOP", round(res_dic['mean_top'], 2))
casput(self.prefix + ".MEAN_BOTTOM", round(res_dic['mean_bottom'], 2))
casput(self.prefix + ".MEAN_MIDDLE", round(res_dic['mean_middle'], 2))
casput(self.prefix + ".MEAN", round(res_dic['mean_value'], 2))
casput(self.prefix + ".RBV", round(res_dic['mean_value'], 2))
casput(self.prefix + ".warning",
res_dic['mean_value'] >= self.warning_threshold)
casput(self.prefix + ".STDEV", round(res_dic['stdev'], 2))
self.intervention_enabled = casget(self.prefix +
'.INTERVENTION_ENABLED')
casput(self.prefix + ".VAL", is_frozen_flag)
if is_frozen_flag and temperature.value < self.frozen_threshold_temperature:
print('freezing detected')
"""Intervention"""
if self.intervention_enabled:
self.retract_intervention()
else:
print('Intervention was disabled')
def CAserver_update(self):
from CAServer import casget, casput
casput(self.prefix + '.RUNNING', self.running)
casput(self.prefix + '.UPDATE_T', self.CA_update_t)
def CAserver_init(self):
from CAServer import casget, casput
self.running = False
self.CA_update_t = 0.3
casput(self.prefix + '.RUNNING', self.running)
casput(self.prefix + '.UPDATE_T', self.CA_update_t)
#controls
casput(self.prefix + ".broadcast_period", self.broadcast_period)
#indicators
casput(self.prefix + ".pressure_upstream", nan)
casput(self.prefix + ".pressure_downstream", nan)
casput(self.prefix + ".pressure_barometric", nan)
casput(self.prefix + ".temperature_hutch", nan)
#monitors
casmonitor(self.prefix + ".broadcast_period", callback=self.monitor)
try:
casput(self.prefix + '.SOCKET', self.socket)
except:
error(traceback.format_exc())
def server_init(self):
casput(self.prefix + '.SOCKET', ['', ''])
self.socketserver_init()
self.CAserver_init()
