def main():
pvdb = {}
with open("xcor_list.json") as f:
mags = json.load(f)
pvs = [MagnetPV(mag["devname"], "XCOR{}".format(mag["devname"].split(":")[-1]), prefix=mag["devname"]) for mag in mags]
for pv in pvs:
pvdb.update(**pv.pvdb)
_, run_options = ioc_arg_parser(
default_prefix='',
desc="Simulated Corrector Magnet IOC")
run(pvdb, **run_options)
async def random(self, instance):
logger.debug('read random from %s', type(self).__name__)
return random.randint(1, 100)
# PV: {prefix}group4:subgroup4:random
# (TODO BUG) {prefix}subgroup4:random
@SubGroup
class group4(PVGroup):
@SubGroup
class subgroup4(PVGroup):
@pvproperty
async def random(self, instance):
logger.debug('read random from %s', type(self).__name__)
return random.randint(1, 100)
if __name__ == '__main__':
ioc_options, run_options = ioc_arg_parser(
default_prefix='subgroups:',
desc='Run an IOC with groups of groups of PVs.')
ioc = MyPVGroup(**ioc_options)
# here's what accessing a pvproperty descriptor looks like:
print('random using the descriptor getter is:', ioc.random)
# and for subgroups:
print('subgroup4 is:', ioc.group4.subgroup4)
print('subgroup4.random is:', ioc.group4.subgroup4.random)
run(ioc.pvdb, **run_options)
def main():
service = CavityService()
asyncio.get_event_loop()
_, run_options = ioc_arg_parser(default_prefix='',
desc="Simulated CM Cavity Service")
run(service, **run_options)
def main():
service = KlystronService()
loop = asyncio.get_event_loop()
_, run_options = ioc_arg_parser(default_prefix='',
desc="Simulated Klystron Service")
run(service, **run_options)
name="b",
value=2.0,
record='ai',
doc='A float',
put=put_handler,
)
pv_c = PVSpec(
name="c",
value=[1, 2, 3],
record='waveform',
doc='An array of integers',
put=put_handler,
)
pvdb = {
pvspec.name: pvspec.create(group=None)
for pvspec in [pv_a, pv_b, pv_c]
}
if __name__ == '__main__':
print("pvdb contents:", pvdb)
ioc_options, run_options = ioc_arg_parser(
default_prefix='pvspec:',
desc="A simple IOC without using the PVGroup-style class syntax.")
# It's up to you to add on the prefix and support any other ioc_options:
pvdb = {ioc_options['prefix'] + name: data for name, data in pvdb.items()}
run(pvdb, **run_options)
input_count_rate = pvproperty(
name='InputCountRate', dtype=unknown, read_only=True)
output_count_rate = pvproperty(
name='OutputCountRate', dtype=unknown, read_only=True)
mca_bin_width = pvproperty(
name='MCABinWidth_RBV', dtype=unknown, read_only=True)
calibration_energy = pvproperty(
name='CalibrationEnergy_RBV', dtype=unknown, read_only=True)
current_pixel = pvproperty(name='CurrentPixel', dtype=unknown)
dynamic_range = pvproperty(
name='DynamicRange_RBV', dtype=unknown, read_only=True)
preset_events = pvproperty_with_rbv(name='PresetEvents', dtype=unknown)
preset_triggers = pvproperty_with_rbv(name='PresetTriggers', dtype=unknown)
trace_data = pvproperty(name='TraceData', dtype=unknown)
trace_mode = pvproperty_with_rbv(value='Mode', name='TraceMode', dtype=str)
trace_time_array = pvproperty(name='TraceTimeArray', dtype=unknown)
trace_time = pvproperty_with_rbv(name='TraceTime', dtype=unknown)
class McaDxpIOC(PVGroup):
mca = SubGroup(EpicsMCAGroup, prefix='mca')
dxp = SubGroup(EpicsDXPGroup, prefix='dxp:')
if __name__ == '__main__':
ioc_options, run_options = ioc_arg_parser(
default_prefix='test_mca:',
desc="ophyd.tests.test_mca test IOC")
ioc = McaDxpIOC(**ioc_options)
run(ioc.pvdb, **run_options)
# Loop and grab items from the queue one at a time
async for event, context, data in ctx.monitor(self.pv_to_mirror):
if event == 'subscription':
print('* Client pushed a new value in the queue')
print(f'\tValue={data.data} {data.metadata}')
# Mirror the value, status, severity, and timestamp:
await self.mirrored.write(data.data,
timestamp=data.metadata.timestamp,
status=data.metadata.status,
severity=data.metadata.severity)
elif event == 'connection':
print(f'* Client connection state changed: {data}')
if data == 'disconnected':
# Raise an alarm - our client PV is disconnected.
await self.mirrored.write(
self.mirrored.value,
status=ca.AlarmStatus.LINK,
severity=ca.AlarmSeverity.MAJOR_ALARM)
if __name__ == '__main__':
ioc_options, run_options = ioc_arg_parser(
default_prefix='mirror:',
desc=dedent(MirrorClientIOC.__doc__),
supported_async_libs=('asyncio', ),
)
ioc = MirrorClientIOC('simple:A', **ioc_options)
run(ioc.pvdb, startup_hook=ioc.__ainit__, **run_options)
def run_server():
import asyncio
asyncio.set_event_loop(asyncio.new_event_loop())
run(ioc.pvdb, module_name='caproto.asyncio.server')
async def motor(fields, instance, value):
""" tweak_motor_forward motor.TWF """
slf = fields.parent.group
pos = slf.motor.value
move_by = slf.motor.field_inst.tweak_step_size.value
logger.info(f"TWF: TWV={move_by}, passing {pos+move_by} to VAL")
await slf.motor.write(pos + move_by)
@motor.fields.tweak_motor_reverse.putter
async def motor(fields, instance, value):
""" tweak_motor_reverse motor.TWR"""
slf = fields.parent.group
pos = slf.motor.value
move_by = slf.motor.field_inst.tweak_step_size.value
logger.info(f"TWR: TWV={move_by}, passing {pos-move_by} to VAL")
await slf.motor.write(slf.motor.value - move_by)
if __name__ == "__main__":
ioc_options, run_options = ioc_arg_parser(default_prefix=PV_prefix,
desc="demo IOC using caproto")
print("ioc_options" + str(ioc_options))
ioc = DemoIOC(**ioc_options)
run_options["log_pv_names"] = True
print("run_options:" + str(run_options))
run(ioc.pvdb, **run_options) # blocking
print("end")
def main():
service = GenericPVService()
_, run_options = ioc_arg_parser(default_prefix='',
desc="Generic PV Service")
run(service, **run_options)
"""
called when the a new value is written into "jog" PV
"""
print(f"Server: {'bit'} Got 'put' request from outside: new value is {value} and type {type(value)}")
if self.device is not None:
self.device.set_bit_client(value)
else:
print('device is None')
@set_bit.putter
async def set_bit(self, instance, value):
"""
called when the a new value is written into "jog" PV
"""
print(f"Server: {'set_bit'} Got 'put' request from outside: new value is {value} and type {type(value)}")
if self.device is not None:
self.device.set_bit_server(value)
else:
print('device is None')
if __name__ == '__main__':
device = Device()
ioc_options, run_options = ioc_arg_parser(
default_prefix='TEST:PUTTER.',
desc='description')
server = Server(**ioc_options)
server.device = device
#start async caproto server IO
run(server.pvdb, **run_options)
def main():
ioc_options, run_options = ioc_arg_parser(default_prefix=prefix,
desc=IOCMain.__doc__)
ioc = create_ioc(eV_pv=eV_name, pmps_run_pv=pmps_run_name, **ioc_options)
run(ioc.pvdb, **run_options)
image_mean = pvproperty(value=0.0, precision=3)
@image.startup #this fubction will be executed on instantiaton
async def image(self, instance, async_lib):
while True:
new_arr = random.randint(256, size=(3, 100, 100)).flatten()
await self.image.write(value=new_arr)
await self.image_mean.write(value=new_arr.mean())
# Let the async library wait for the next iteration
await async_lib.library.sleep(1)
if __name__ == '__main__':
# The Record Name is specified by prefix
prefix = 'TEST.'
from pdb import pm
from tempfile import gettempdir
import logging
print(gettempdir() + '/{}.log'.format(prefix))
logging.basicConfig(filename=gettempdir() + '/{}.log'.format(prefix),
level=logging.DEBUG,
format="%(asctime)s %(levelname)s: %(message)s")
ioc_options, run_options = ioc_arg_parser(default_prefix=prefix,
desc='description')
io_server = Server(**ioc_options)
#start async caproto server IO
run(io_server.pvdb, **run_options)
