def run(self, target, bindings, *args, **kwargs):
server = SimpleServer()
server.createPV(prefix=kwargs['pv_prefix'], pvdb=bindings)
driver = PropertyExposingDriver(target=target, pv_dict=bindings)
delta = 0.0 # Delta between cycles
count = 0 # Cycles per second counter
timer = 0.0 # Second counter
while True:
start = datetime.now()
# pcaspy's process() is weird. Docs claim argument is "processing time" in seconds.
# But this is not at all consistent with the calculated delta.
# Having "watch caget" running has a huge effect too (runs faster when watching!)
# Additionally, if you don't call it every ~0.05s or less, PVs stop working. Annoying.
# Set it to 0.0 for maximum cycle speed.
server.process(0.1)
target.process(delta)
driver.process(delta)
delta = (datetime.now() - start).total_seconds()
count += 1
timer += delta
if timer >= 1.0:
print "Running at %d cycles per second (%.3f ms per cycle)" % (count, 1000.0 / count)
count = 0
timer = 0.0
def serve_forever(ioc_name: str, pv_prefix: str, macros: Dict[str, str]):
"""
Server the PVs for the remote ioc server
Args:
ioc_name: The name of the IOC to be run, including ioc number (e.g. LSICORR_01)
pv_prefix: prefix for the pvs
macros: Dictionary containing IOC macros
Returns:
"""
ioc_name_with_pv_prefix = "{pv_prefix}{ioc_name}:".format(pv_prefix=pv_prefix, ioc_name=ioc_name)
print_and_log(ioc_name_with_pv_prefix)
server = SimpleServer()
server.createPV(ioc_name_with_pv_prefix, STATIC_PV_DATABASE)
# Run heartbeat IOC, this is done with a different prefix
server.createPV(prefix="{pv_prefix}CS:IOC:{ioc_name}:DEVIOS:".format(pv_prefix=pv_prefix, ioc_name=ioc_name),
pvdb={"HEARTBEAT": {"type": "int", "value": 0}})
# Looks like it does nothing, but this creates *and automatically registers* the driver
# (via metaclasses in pcaspy). See declaration of DriverType in pcaspy/driver.py for details
# of how it achieves this.
LSiCorrelatorIOC(pv_prefix, macros)
register_ioc_start(ioc_name, STATIC_PV_DATABASE, ioc_name_with_pv_prefix)
try:
while True:
server.process(0.1)
except Exception:
print_and_log(traceback.format_exc())
raise
class FbServer(object):
"""
This class is a server that controls the FbDriver.
"""
def __init__(self):
"""
Constructor
"""
self.server = SimpleServer()
def init_driver(self, detector, feedback_pvs):
"""
This function initiates the driver.
It creates process variables for the requested lidt of pv names. For each data type combination with the
applicable quality check two pvs are created: one holding frame index, and one holding count of failed frames.
It creates FbDriver instance and returns it to the calling function.
Parameters
----------
detector : str
a pv name of the detector
feedback_pvs : list
a list of feedback process variables names, for each data type combination with the
applicable quality check
Returns
-------
driver : FbDriver
FbDriver instance
"""
prefix = detector + ':'
pvdb = {}
counters = {}
#add PV that follow index of failed farames and count of failed frames for each quality check
for pv in feedback_pvs:
pvdb[pv + '_res'] = {
'prec': 0,
}
pvdb[pv + '_ctr'] = {
'prec': 0,
}
counters[pv] = 0
self.server.createPV(prefix, pvdb)
driver = FbDriver(counters=counters)
return driver
def activate_pv(self):
"""
Infinite loop processing the pvs defined in server; exits when parent process exits.
"""
while True:
self.server.process(.1)
def run(self):
server = SimpleServer()
server.createPV("TU-", pvp.pvdb())
EpicsServer.driver = EpicsDriver()
recordAction("[%s] Action: EPICS server and driver started" %
getDateTime())
while True:
server.process(0.1)
class SimCAServer():
'''Defines basic PV server that continuously syncs the input model to the input (command) EPICS PV values
and publishes updated model data to output EPICS PVs. Assumes fast model execution, as the model executes
in the main CAS server thread. CAS for the input and ouput PVs is handled by the SimDriver object'''
def __init__(self, pv_file, model=None):
self.serve_data = False
inputs = parse_pv_file(pv_file)
assert 'name' in inputs
self.name = inputs['name']
assert 'input' in inputs, 'User supplied pv definitions must contain "input" pvs.'
if (model is None):
self.model = Model()
else:
self.model = model
self.pvdb = {**inputs['input'], **inputs['output']}
self.server = SimpleServer()
self.server.createPV(self.name + ':', self.pvdb)
self.driver = SimCADriver(inputs['input'], inputs['output'])
def start(self):
self.serve_data = True
current_sim_input_pv_state = self.driver.get_input_pv_state()
# Do initial simulation
vprint("Initializing sim...", True)
self.driver.set_output_pvs(
self.model.run(current_sim_input_pv_state, verbose=True))
vprint("...done.", True)
while self.serve_data:
# process CA transactions
self.server.process(0.1)
while (current_sim_input_pv_state !=
self.driver.get_input_pv_state()):
current_sim_input_pv_state = self.driver.get_input_pv_state()
vprint('Running model and updating pvs...', True)
t1 = time.time()
self.driver.set_output_pvs(
self.model.run(current_sim_input_pv_state, verbose=True))
t2 = time.time()
dt = ((t2 - t1) * unit_registry('s')).to_compact()
vprint('...done. Time ellapsed: {:.3E}'.format(dt), True)
def stop(self):
self.serve_data = False
class FbServer:
"""
This class is a server that controls the FbDriver.
"""
def __init__(self):
"""
Constructor
"""
self.server = SimpleServer()
def init_driver(self, detector, feedback_pvs):
"""
This function initiates the driver.
It creates process variables for the requested lidt of pv names. For each data type combination with the
applicable quality check two pvs are created: one holding frame index, and one holding count of failed frames.
It creates FbDriver instance and returns it to the calling function.
Parameters
----------
detector : str
a pv name of the detector
feedback_pvs : list
a list of feedback process variables names, for each data type combination with the
applicable quality check
Returns
-------
driver : FbDriver
FbDriver instance
"""
prefix = detector + ':'
pvdb = {}
counters = {}
for pv in feedback_pvs:
pvdb[pv+'_ind'] = { 'prec' : 0,}
pvdb[pv+'_ctr'] = { 'prec' : 0,
'hihi' : 1, }
counters[pv] = 0
self.server = SimpleServer()
self.server.createPV(prefix, pvdb)
driver = FbDriver(counters)
return driver
def activate_pv(self):
"""
Infinite loop processing the pvs defined in server; exits when parent process exits.
"""
while True:
self.server.process(.1)
def run(driver_class, prefix=None, pvdb=None):
prefix = driver_class.prefix if prefix is None else prefix
pvdb = driver_class.pvdb if pvdb is None else pvdb
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = driver_class()
# process CA transactions
while True:
server.process(0.1)
def run():
util.write_pid(pidfile)
server = SimpleServer()
server.createPV(prefix, pvdb)
context = zmq.Context()
driver = myDriver(context)
# process CA transactions
while forever:
server.process(0.1)
def run():
util.write_pid(pidfile)
server = SimpleServer()
server.createPV(prefix, pvdb)
context = zmq.Context()
driver = myDriver(context)
# process CA transactions
while forever:
server.process(0.1)
def epics_ca_ioc(pv_input):
if (isinstance(pv_input, str)):
pvdefs = yaml.safe_load(open(pv_input))
elif (isinstance(pv_input, dict)):
pvdefs = pv_input
prefix = pvdefs['prefix']
pvdb = pvdefs['pv']
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = ReadWriteDriver()
while True:
# process CA transactions
server.process(0.1)
def main(prefix, pvdb, port):
LOG.info('Starting ACQ ioc, abort with Ctrl-C')
server = SimpleServer()
server.createPV(_check_prefix(prefix), pvdb)
driver = AcqDriver(_check_prefix(prefix), pvdb, port)
myString = "pvdb = " + str(pvdb)
#print myString
LOG.debug('ACQ IOC is now started')
try:
# Run the driver process loop
while driver.run:
try:
# process CA transactions
server.process(0.1)
except KeyboardInterrupt:
LOG.info('ACQ IOC stopped by console interrupt!')
driver.run = False
finally:
pass
def main():
parser = ArgumentParser(description='Shimadzu HPLC CBM20 IOC')
parser.add_argument("ioc_prefix",
type=str,
help="Prefix of the IOC, include seperator.")
parser.add_argument("pump_host", type=str, help="Pump host.")
parser.add_argument("--polling_interval",
default=1,
type=float,
help="Pump polling interval.")
parser.add_argument(
"--log_level",
default="WARNING",
choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'],
help="Log level to use.")
arguments = parser.parse_args()
logging.basicConfig(stream=sys.stdout, level=arguments.log_level)
_logger = logging.getLogger(arguments.ioc_prefix)
_logger.info(
"Starting ioc with prefix '%s', pump polling interval '%s' seconds, and pump_host '%s'.",
arguments.ioc_prefix, arguments.polling_interval, arguments.pump_host)
server = SimpleServer()
server.createPV(prefix=arguments.ioc_prefix, pvdb=ioc.pvdb)
communication_driver = ShimadzuCbm20(host=arguments.pump_host)
driver = ioc.EpicsShimadzuPumpDriver(
communication_driver=communication_driver,
pump_polling_interval=arguments.polling_interval,
hostname=arguments.pump_host)
try:
while True:
server.process(0.1)
except KeyboardInterrupt:
_logger.info("User requested ioc termination. Exiting.")
def run_ioc(camera_type, ioc_name, prefix, platform, readout_grp, interface):
LOG.info('%s camera server, abort with Ctrl-C', camera_type)
ioc_prefix = "IOC:%s"%prefix
pvdb = db.init(camera_type)
if pvdb is None:
LOG.error('Unsupported camera type: %s', camera_type)
return 2
dtype = db.get_dtype(camera_type)
os.environ['EPICS_CA_MAX_ARRAY_BYTES'] = str(db.get_max_array_size(camera_type))
server = SimpleServer()
server.createPV(prefix, pvdb)
server.createPV(ioc_prefix, IocAdmin.ioc_pvdb)
driver = CameraDriver(pvdb, dtype, platform, readout_grp, interface, prefix, ioc_prefix, ioc_name)
LOG.debug('%s camera server is now started', camera_type)
try:
while driver.run:
try:
# process CA transactions
server.process(0.1)
except KeyboardInterrupt:
LOG.info('%s camera server stopped by console interrupt!', camera_type)
driver.run = False
finally:
# process CA transactions
server.process(0.1)
server.process(0.1)
# why 2? only psi knows...
driver.shutdown()
# do a final autosave
driver.ioc.shutdown()
# If we get here the server died in an unexpected way
if driver.run:
LOG.error('%s camera server exited unexpectedly!', camera_type)
return 1
else:
LOG.info('%s camera server exited normally', camera_type)
return 0
def main():
pid = int(sys.argv[1])
prefix = sys.argv[2]
print("pid = {0}".format(pid))
info = get_child_info(pid)
db = create_db(info)
server = SimpleServer()
server.createPV(prefix, db)
driver = RODriver()
while True:
next = time.time() + 0.25
server.process(0.25)
while time.time() < next:
time.sleep(0.01)
info = get_child_info(pid)
for thread_name in info:
if thread_name in db:
driver.setParam(thread_name, info[thread_name])
driver.updatePVs()
def start_test_ioc(ioc_prefix, polling_interval):
_logger.info(
"Starting test IOC with prefix '%s' and polling_interval '%s'.",
ioc_prefix, polling_interval)
server = SimpleServer()
server.createPV(prefix=ioc_prefix, pvdb=pvdb)
_logger.info("Available PVs:\n%s", [ioc_prefix + pv for pv in pvdb.keys()])
communication_driver = MockShimadzuCbm20()
driver = EpicsShimadzuPumpDriver(communication_driver=communication_driver,
pump_polling_interval=polling_interval)
try:
while True:
server.process(0.1)
except KeyboardInterrupt:
_logger.info("User terminated execution.")
def _execute(prefix, host, platform, ioc_name=None, ioc_prefix=None):
for descpv, valpv in pvlabels:
pvdb[descpv] = {'type': 'string'}
pvdb[valpv] = {'type': 'string'}
for descpv, valpv in pvcontrols:
pvdb[descpv] = {'type': 'string'}
pvdb[valpv] = {'type': 'float', 'prec': 3}
# If no IOC prefix is given just use the base prefix
if ioc_prefix is None:
ioc_prefix = prefix
LOG.info('Starting DAQ server, abort with Ctrl-C')
server = SimpleServer()
server.createPV(prefix, pvdb)
server.createPV(ioc_prefix, ioc_pvdb)
driver = DaqDriver(host, platform, prefix, ioc_prefix, ioc_name)
LOG.debug('DAQ server is now started')
try:
# Run the driver process loop
while driver.run:
try:
# process CA transactions
server.process(0.1)
except KeyboardInterrupt:
LOG.info('DAQ server stopped by console interrupt!')
driver.run = False
finally:
# do a final autosave
driver.ioc.shutdown()
# If we get here the server died in an unexpected way
if driver.run:
LOG.error('DAQ server exited unexpectedly!')
return 1
else:
LOG.info('DAQ server exited normally')
return 0
def to_subproc():
prefix = 'BSTEST:'
pvdb = {
'VAL': {
'prec': 3,
},
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
if __name__ == '__main__':
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
# process CA transactions
while True:
try:
server.process(0.1)
except KeyboardInterrupt:
break
#print('==================================================\n')
if len(else_gammaBuffer) > sample:
else_gammaBuffer = else_gammaBuffer[1:]
if len(else_neutronBuffer) > sample:
else_neutronBuffer = else_neutronBuffer[1:]
if len(else_dataBuffer) > sample:
else_dataBuffer = else_dataBuffer[1:]
if len(thermo_gammaBuffer) > sample:
thermo_gammaBuffer = thermo_gammaBuffer[1:]
if len(thermo_neutronBuffer) > sample:
thermo_neutronBuffer = thermo_neutronBuffer[1:]
if len(thermo_dataBuffer) > sample:
thermo_dataBuffer = thermo_dataBuffer[1:]
if len(berthold_gammaBuffer) > sample:
berthold_gammaBuffer = berthold_gammaBuffer[1:]
if len(berthold_neutronBuffer) > sample:
berthold_neutronBuffer = berthold_neutronBuffer[1:]
if len(berthold_dataBuffer) > sample:
berthold_dataBuffer = berthold_dataBuffer[1:]
if len(timeBuffer) > sample:
timeBuffer = timeBuffer[1:]
if len(deltatimeBuffer) > sample:
deltatimeBuffer = deltatimeBuffer[1:]
CAserver.process(0.1)
except Exception as e:
print(e)
pass
class SyncedSimPVServer():
'''Defines basic PV server that continuously syncs the input model to the input (command) EPICS PV values
and publishes updated model data to output EPICS PVs. Assumes fast model execution, as the model executes
in the main CAS server thread. CAS for the input and ouput PVs is handled by the SimDriver object'''
def __init__(self,
name,
input_pvdb,
output_pvdb,
noise_params,
model,
sim_params=None):
self.name = name
self.pvdb = {}
self.input_pv_state = {}
self.output_pv_state = {}
self.model = model
for pv in input_pvdb:
#print(pv)
self.pvdb[pv] = input_pvdb[pv]
self.input_pv_state[pv] = input_pvdb[pv]["value"]
output_pv_state = {}
for pv in output_pvdb:
self.pvdb[pv] = output_pvdb[pv]
output_pv_state[pv] = output_pvdb[pv]["value"]
for pv in output_pvdb:
if (pv in noise_params):
self.pvdb[pv + ':sigma'] = {
'type': 'float',
'value': noise_params[pv]['sigma']
}
self.pvdb[pv + ':dist'] = {
'type': 'char',
'count': 100,
'value': noise_params[pv]['dist']
}
prefix = self.name + ":"
self.server = SimpleServer()
self.server.createPV(prefix, self.pvdb)
self.driver = SimDriver(self.input_pv_state, output_pv_state,
noise_params)
self.serve_data = False
self.sim_params = sim_params
def set_sim_params(**params):
self.sim_params = params
def start_server(self):
self.serve_data = True
sim_pv_state = copy.deepcopy(self.input_pv_state)
# Do initial simulation
print("Initializing sim...")
output_pv_state = self.model.run(self.input_pv_state, verbose=True)
self.driver.set_output_pvs(output_pv_state)
print("...done.")
while self.serve_data:
# process CA transactions
self.server.process(0.1)
while (sim_pv_state != self.input_pv_state):
sim_pv_state = copy.deepcopy(self.input_pv_state)
output_pv_state = self.model.run(self.input_pv_state,
verbose=True)
self.driver.set_output_pvs(output_pv_state)
def stop_server(self):
self.serve_data = False
blocks_mon.initialise_block(b)
else:
pass
time.sleep(1)
def start_thread(self):
"""Starts the thread that monitors the block names for changes.
"""
t = threading.Thread(target=self._monitor_changes, args=(self,))
t.setDaemon(True)
t.start()
if __name__ == '__main__':
my_prefix = os.environ["MYPVPREFIX"]
print "Prefix is %s" % my_prefix
SERVER = SimpleServer()
SERVER.createPV(my_prefix, PVDB)
DRIVER = BlocksMonitor(my_prefix)
DRIVER.start_thread()
# Process CA transactions
while True:
try:
SERVER.process(0.1)
except Exception as err:
print_and_log(str(err), "MAJOR")
break
class EpicsAdapter(Adapter):
"""
Inheriting from this class provides an EPICS-interface to a device, powered by
the pcaspy-module. In the simplest case all that is required is to inherit
from this class and override the `pvs`-member. It should be a dictionary
that contains PV-names (without prefix) as keys and instances of PV as
values.
For a simple device with two properties, speed and position, the first of which
should be read-only, it's enough to define the following:
class SimpleDeviceEpicsAdapter(EpicsAdapter):
pvs = {
'VELO': PV('speed', read_only=True),
'POS': PV('position', lolo=0, hihi=100)
}
For more complex behavior, the adapter could contain properties that do not
exist in the device itself. If the device should also have a PV called STOP
that "stops the device", the adapter could look like this:
class SimpleDeviceEpicsAdapter(EpicsAdapter):
pvs = {
'VELO': PV('speed', read_only=True),
'POS': PV('position', lolo=0, hihi=100),
'STOP': PV('stop', type='int'),
}
@property
def stop(self):
return 0
@stop.setter
def stop(self, value):
if value == 1:
self._device.halt()
Even though the device does _not_ have a property called 'stop' (but a method called 'halt'),
issuing the command
caput STOP 1
will achieve the desired behavior, because EpicsAdapter merges the properties
of the device into SimpleDeviceEpicsAdapter itself, so that it is does not
matter whether the specified property in PV exists in the device or the adapter.
The intention of this design is to keep device classes small and free of
protocol specific stuff, such as in the case above where stopping a device
via EPICS might involve writing a value to a PV, whereas other protocols may
offer an RPC-way of achieving the same thing.
"""
protocol = 'epics'
pvs = None
def __init__(self, device, arguments=None):
super(EpicsAdapter, self).__init__(device, arguments)
if arguments is not None:
self._options = self._parseArguments(arguments)
self._create_properties(self.pvs.values())
self._server = None
self._driver = None
def start_server(self):
self._server = SimpleServer()
self._server.createPV(prefix=self._options.prefix,
pvdb={k: v.config
for k, v in self.pvs.items()})
self._driver = PropertyExposingDriver(target=self, pv_dict=self.pvs)
self._last_update = datetime.now()
def _create_properties(self, pvs):
for pv in pvs:
prop = pv.property
if not prop in dir(self):
if not prop in dir(self._device):
raise AttributeError('Can not find property \'' + prop +
'\' in device or interface.')
setattr(type(self), prop, ForwardProperty('_device', prop))
def _parseArguments(self, arguments):
parser = ArgumentParser(
description="Adapter to expose a device via EPICS")
parser.add_argument('-p',
'--prefix',
help='Prefix to use for all PVs',
default='')
return parser.parse_args(arguments)
def handle(self, cycle_delay=0.1):
# pcaspy's process() is weird. Docs claim argument is "processing time" in seconds.
# But this is not at all consistent with the calculated delta.
# Having "watch caget" running has a huge effect too (runs faster when watching!)
# Additionally, if you don't call it every ~0.05s or less, PVs stop working. Annoying.
# Set it to 0.0 for maximum cycle speed.
self._server.process(cycle_delay)
self._driver.process_pv_updates(seconds_since(self._last_update))
self._last_update = datetime.now()
nr_inits)
pnr_mode = BeamlineMode("pnr", PARAMS_FIELDS.keys(), pnr_inits)
disabled_mode = BeamlineMode("disabled", [])
modes = [nr_mode, pnr_mode, disabled_mode]
# init beamline
bl = Beamline(comps, params, [], modes)
bl.set_incoming_beam(beam_start)
bl.active_mode = nr_mode
return bl, modes
beamline, modes = create_beamline()
pv_db = PVManager(PARAMS_FIELDS, [mode.name for mode in modes])
SERVER = SimpleServer()
print("Prefix: {}".format(REFLECTOMETRY_PREFIX))
for pv_name in pv_db.PVDB.keys():
print("creating pv: {}".format(pv_name))
SERVER.createPV(REFLECTOMETRY_PREFIX, pv_db.PVDB)
DRIVER = ReflectometryDriver(SERVER, beamline, pv_db)
# Process CA transactions
while True:
try:
SERVER.process(0.1)
except Exception as err:
print(err)
break
action="store",
type="string",
dest="speed",
help="set Megamp serial port speed (e.g. 9600)")
(options, args) = parser.parse_args()
if (options.port):
port = options.port
else:
if (os.environ.get("MA_PORT")):
port = os.environ.get("MA_PORT")
if (options.speed):
speed = options.speed
else:
if (os.environ.get("MA_SPEED")):
speed = os.environ.get("MA_SPEED")
print("Megamp serial parameter: port = " + port + " speed = " + str(speed))
driver = iocDriver.myDriver(port, speed)
server = SimpleServer()
server.createPV(prefix, driver.getPVdb())
driver.start()
# print(driver.getPVdb())
while True:
server.process(1)
'LEBT_PS:SOL_01:IMon': {},
'ADS:G2:MC': {},
'ADS:G3:MC': {},
'LEBT_PS:DCH_01:IMon': {},
'LEBT_PS:DCH_02:IMon': {},
'LEBT_PS:DCV_01:IMon': {},
'LEBT_PS:DCV_02:IMon': {}
}
class myDriver(Driver):
def __init__(self):
Driver.__init__(self)
def write(self, reason, value):
status = True
# take proper actions
self.setParam(reason, value)
return status
if __name__ == '__main__':
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
while True:
# process CA transactions
server.process(0.01)
'value': [1.2, 5.6, 7.1]
},
'PUT_STRING_WAVEFORM': {
'type': 'string',
'count': 5,
'value': ['You', 'got', 'a', 'fast', 'car']
}
}
class testDriver(Driver):
def __init__(self):
super(testDriver, self).__init__()
def read(self, reason):
if reason is 'COUNTER':
value = self.getParam(reason) + 1
self.setParam(reason, value)
else:
value = self.getParam(reason)
return value
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = testDriver()
while True:
server.process(.1)
# Multimetro realiza 10 ciclos de integracao para cada leitura.
# Logo, cada leitura toma um tempo maior em relacao ao caso passado
self.scan_delay = 1
self.sendSerialCommand(":SYST:RWL; *CLS; :CONF:VOLT:DC 10,0.00001\x0D\x0A", 0.300)
elif item[1] == 100:
# 100 ciclos de integracao por leitura, equivalendo ao caso mais lento
self.scan_delay = 10
self.sendSerialCommand(":SYST:RWL; *CLS; :CONF:VOLT:DC 10, MIN\x0D\x0A", 0.300)
self.updatePVs()
# Envia um comando a interface serial e espera delay segundos.
def sendSerialCommand (self, command, delay):
self.serial.write(command)
time.sleep(delay)
if __name__ == '__main__':
CAserver = SimpleServer()
CAserver.createPV("Cnt:Measure:", PVs)
driver = PROSAC2HP232()
while (True):
CAserver.process(0.1)
# Main Thread
if (__name__ == "__main__"):
# PVs I/O
PV_input = sys.argv[1]
PV_output = sys.argv[2]
# PV config
PVs = {
PV_output: {
"type": "float",
"prec": 3,
"unit": "uSv",
"low": -0.1,
"high": 1.5,
"lolo": -0.1,
"hihi": 2
}
}
# Start Threads prl and CA
CA_server = SimpleServer()
CA_server.createPV("", PVs)
driver = IntegralDriver(PV_input, PV_output)
# Main loop
while (True):
CA_server.process(0.1)
'type': 'float',
'count': 3,
'value': [1.2, 5.6, 7.1]
},
'PUT_STRING_WAVEFORM' : {
'type': 'string',
'count': 5,
'value': ['You', 'got', 'a', 'fast', 'car']
}
}
class testDriver(Driver):
def __init__(self):
super(testDriver, self).__init__()
def read(self, reason):
if reason is 'COUNTER':
value = self.getParam(reason) + 1
self.setParam(reason, value)
else:
value = self.getParam(reason)
return value
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = testDriver()
while True:
server.process(.1)
class CAServer:
"""
Server object for channel access process variables that updates and reads process \\
values in a single thread.
Attributes
----------
model: online_model.model.surrogate_model.OnlineSurrogateModel
OnlineSurrogateModel instance used for getting predictions
pvdb: dict
Dictionary that maps the process variable string to type (str), prec \\
(precision), value (float), units (str), range (List[float])
input_pv_state: dict
Dictionary that maps the input process variables to their current values
output_pv_state:
Dictionary that maps the output process variables to their current values
server: pcaspy.driver.SimpleServer
Server class that interfaces between the channel access client and the driver. \\
Forwards the read/write requests to the driver
driver: online_model.server.ca.SimDriver
Class that reacts to process variable read/write requests
"""
def __init__(
self,
model_class,
model_kwargs: dict,
input_pvdb: Dict[str, dict],
output_pvdb: Dict[str, dict],
prefix: str,
) -> None:
"""
Create OnlineSurrogateModel instance and initialize output variables by running \\
with the input process variable state, set up the proces variable database and \\
input/output variable tracking, start the server, create the process variables, \\
and start the driver.
Parameters
----------
model_class
Model class to be instantiated
model_kwargs: dict
kwargs for initialization
in_pvdb: dict
Dictionary that maps the input process variable string to type (str), prec \\
(precision), value (float), units (str), range (List[float])
out_pvdb: dict
Dictionary that maps the output process variable string to type (str), prec \\
(precision), value (float), units (str), range (List[float])
"""
surrogate_model = model_class(**model_kwargs)
self.model = OnlineSurrogateModel([surrogate_model])
# set up db for initializing process variables
self.pvdb = {}
# set up input process variables
self.pvdb.update(input_pvdb)
self.input_pv_state = {pv: input_pvdb[pv]["value"] for pv in input_pvdb}
# get starting output from the model and set up output process variables
self.output_pv_state = self.model.run(self.input_pv_state)
self.pvdb.update(output_pvdb)
# initialize channel access server
self.server = SimpleServer()
# create all process variables using the process variables stored in self.pvdb
# with the given prefix
self.server.createPV(prefix + ":", self.pvdb)
# set up driver for handing read and write requests to process variables
self.driver = SimDriver(self.input_pv_state, self.output_pv_state)
def start_server(self) -> None:
"""
Start the channel access server and continually update.
"""
sim_pv_state = copy.deepcopy(self.input_pv_state)
# Initialize output variables
print("Initializing sim...")
output_pv_state = self.model.run(self.input_pv_state)
self.driver.set_output_pvs(output_pv_state)
print("...finished initializing.")
while True:
# process channel access transactions
self.server.process(0.1)
# check if the input process variable state has been updated as
# an indicator of new input values
while not all(
np.array_equal(sim_pv_state[key], self.input_pv_state[key])
for key in self.input_pv_state
):
sim_pv_state = copy.deepcopy(self.input_pv_state)
model_output = self.model.run(self.input_pv_state)
self.driver.set_output_pvs(model_output)
'hihi' : 140,
'high' : 100,
'low' : -100,
'lolo' : -140,
'lolim' : -180,
'unit' : 'deg'
},
'STATUS': {
'type': 'enum',
'enums': ['Off', 'On'],
'states': [Severity.MINOR_ALARM, Severity.NO_ALARM],
},
'WAVE': {
'count': 16,
'prec': 2,
'value': numpy.arange(16, dtype=float)
}
}
class myDriver(Driver):
def __init__(self):
super(myDriver, self).__init__()
if __name__ == '__main__':
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
print "Server is running... (ctrl+c to close)"
while True:
server.process(0.1)
return value
def write(self, reason, value):
lolim = pvdb[reason].get('lolim')
if lolim is not None and value < lolim:
return False
hilim = pvdb[reason].get('hilim')
if hilim is not None and value > hilim:
return False
self.setParam(reason, value)
return True
if __name__ == '__main__':
import os
os.environ['EPICS_CAS_INTF_ADDR_LIST'] = 'localhost'
ioc_server = SimpleServer()
ioc_server.createPV(prefix, pvdb)
driver = TestDriver()
print('Please note: you will need to set EPICS_CA_ADDR_LIST=localhost '
'to access PVs served by this IOC.')
while True:
ioc_server.process(.1)
if value == 1:
self.setParam('CMD', 1)
self.thread = thread.start_new_thread(self.run, ())
return True
return False
def run(self):
print("Running...")
self.updatePVs()
time.sleep(4.0)
self.setParam('RBV', self.getParam('RBV') + 1)
self.setParam('CMD', 0)
self.updatePVs()
print("Done.")
self.callbackPV('CMD')
self.thread = None
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = MyDriver()
print("Try camonitor Python:CMD Python:RBV")
print("then caput -c -w 10 Python:CMD 1")
while True:
server.process(0.1)
if reason == 'VAL': #if EPICS input VAL
print ('new speed is'); print (speedval) #print to Arduino current speed
x = str((speedval+0.2)*60) #calculation for rps with offset
ser.write (x) #send value for speed to Arduino
if status:
self.setParam(reason, speedval)
return status
def read(self, reason):
if reason == 'RBV': #if EPICS input RBV (in progress)
ser.write("speed")
time.sleep(0.01)
value=float(ser.readline())
self.setParam(reason, value)
print ('speed is '); print (value)
else:
value = self.getParam(reason)
return value
if __name__ == '__main__': #create PVs based on prefix and pvdb definition
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = myDriver()
while True:
server.process(0.1) # process CA transactions
