def test_pvpos(self):
motor_record = self.sim_pv
mrec = EpicsMotor(motor_record, name='pvpos_mrec')
print('mrec', mrec.describe())
mrec.wait_for_connection()
class MyPositioner(PVPositioner):
'''Setpoint, readback, done, stop. No put completion'''
setpoint = C(EpicsSignal, '.VAL')
readback = C(EpicsSignalRO, '.RBV')
done = C(EpicsSignalRO, '.MOVN')
stop_signal = C(EpicsSignal, '.STOP')
stop_value = 1
done_value = 0
m = MyPositioner(motor_record, name='pos_no_put_compl')
m.wait_for_connection()
m.read()
mrec.move(0.1, wait=True)
time.sleep(0.1)
self.assertEqual(m.position, 0.1)
m.stop()
m.limits
repr(m)
str(m)
mc = copy(m)
self.assertEqual(mc.describe(), m.describe())
m.read()
def setUpModule():
global mtr
setup_ophyd()
mtr = EpicsMotor(motor_recs[0])
mtr.wait_for_connection()
def test_pvpos(self):
motor_record = self.sim_pv
mrec = EpicsMotor(motor_record, name='pvpos_mrec')
print('mrec', mrec.describe())
mrec.wait_for_connection()
class MyPositioner(PVPositioner):
'''Setpoint, readback, done, stop. No put completion'''
setpoint = C(EpicsSignal, '.VAL')
readback = C(EpicsSignalRO, '.RBV')
done = C(EpicsSignalRO, '.MOVN')
stop_signal = C(EpicsSignal, '.STOP')
stop_value = 1
done_value = 0
m = MyPositioner(motor_record, name='pos_no_put_compl')
m.wait_for_connection()
m.read()
mrec.move(0.1, wait=True)
time.sleep(0.1)
self.assertEqual(m.position, 0.1)
m.stop()
m.limits
repr(m)
str(m)
mc = copy(m)
self.assertEqual(mc.describe(), m.describe())
m.read()
def setUpModule():
global mtr
setup_ophyd()
mtr = EpicsMotor(motor_recs[0])
mtr.wait_for_connection()
def motor_pv_scan(detectors, pvname, start, stop, num, events=None):
"""
Scan over a motor record as a UI test utility
"""
mot = EpicsMotor(pvname, name=pvname)
config_in_scan(detectors, [mot], events)
mot.wait_for_connection()
return (yield from scan(detectors, mot, start, stop, num))
def test_write_pv_timestamp_no_monitor(self):
mtr = EpicsMotor(config.motor_recs[0], name='test')
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname, name='test')
sp_value0 = sp.get()
ts0 = sp.timestamp
sp.put(sp_value0 + 0.1, wait=True)
time.sleep(0.1)
sp_value1 = sp.get()
ts1 = sp.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(sp_value0 + 0.1, sp_value1)
sp.put(sp.value - 0.1, wait=True)
def test_write_pv_timestamp_monitor(self):
mtr = EpicsMotor(config.motor_recs[0])
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname, auto_monitor=True)
sp_value0 = sp.get()
ts0 = sp.timestamp
sp.put(sp_value0 + 0.1, wait=True)
time.sleep(0.1)
sp_value1 = sp.get()
ts1 = sp.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(sp_value0 + 0.1, sp_value1)
sp.put(sp.value - 0.1, wait=True)
def test_read_pv_timestamp_monitor(self):
mtr = EpicsMotor(config.motor_recs[0])
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname, auto_monitor=True)
rbv = EpicsSignalRO(mtr.user_readback.pvname, auto_monitor=True)
rbv_value0 = rbv.get()
ts0 = rbv.timestamp
sp.put(sp.value + 0.1, wait=True)
time.sleep(0.1)
rbv_value1 = rbv.get()
ts1 = rbv.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(rbv_value0 + 0.1, rbv_value1)
sp.put(sp.value - 0.1, wait=True)
def test_read_pv_timestamp_no_monitor(self):
mtr = EpicsMotor(config.motor_recs[0])
mtr.wait_for_connection()
sp = EpicsSignal(mtr.user_setpoint.pvname)
rbv = EpicsSignalRO(mtr.user_readback.pvname)
rbv_value0 = rbv.get()
ts0 = rbv.timestamp
sp.put(sp.value + 0.1, wait=True)
time.sleep(0.1)
rbv_value1 = rbv.get()
ts1 = rbv.timestamp
self.assertGreater(ts1, ts0)
self.assertAlmostEqual(rbv_value0 + 0.1, rbv_value1)
sp.put(sp.value - 0.1, wait=True)
"""
lesson 2 : create the motor and scaler
"""
__all__ = [
'm1',
'scaler',
]
from ...session_logs import logger
logger.info(__file__)
from apstools.devices import use_EPICS_scaler_channels
from ophyd import EpicsMotor
from ophyd.scaler import ScalerCH
m1 = EpicsMotor("sky:m1", name="m1")
scaler = ScalerCH("sky:scaler1", name="scaler")
m1.wait_for_connection()
scaler.wait_for_connection()
scaler.match_names()
use_EPICS_scaler_channels(scaler)
'''A simple test for :class:`EpicsMotor`'''
import config
from ophyd import EpicsMotor
def callback(sub_type=None, timestamp=None, value=None, **kwargs):
logger.info('[callback] [%s] (type=%s) value=%s', timestamp, sub_type,
value)
def done_moving(**kwargs):
logger.info('Done moving %s', kwargs)
logger = config.logger
motor_record = config.motor_recs[0]
m1 = EpicsMotor(motor_record)
m1.wait_for_connection()
m1.subscribe(callback, event_type=m1.SUB_DONE)
m1.subscribe(callback, event_type=m1.SUB_READBACK)
logger.info('---- test #1 ----')
logger.info('--> move to 1')
m1.move(1)
logger.info('--> move to 0')
m1.move(0)
import functools
import sys
from bluesky import RunEngine
from bluesky.plan_stubs import mvr, read, sleep
from ophyd import EpicsMotor, EpicsSignal
# from bluesky.log import config_bluesky_logging
print = functools.partial(print, file=sys.stderr)
# Create ophyd devices
pm = EpicsMotor("XF:08BMA-OP{Mono:1-Ax:Pico}Mtr", name="pm")
inb = EpicsSignal("XF:08BMES-BI{PSh:1-BPM:1}V-I", name="inb")
outb = EpicsSignal("XF:08BMES-BI{PSh:1-BPM:2}V-I", name="outb")
pm.wait_for_connection()
inb.wait_for_connection()
outb.wait_for_connection()
print(f"pico starting position {pm.position:.6}")
inb_initial = inb.get()
outb_initial = outb.get()
print(f"inboard signal {inb_initial:.6}")
print(f"outboard signal {outb_initial:.6}")
BPMpos = (outb_initial - inb_initial) / (outb_initial + inb_initial) * 1000000
print(f"position {BPMpos:.4}")
source_pos = EpicsSignal("SR:APHLA:SOFB{BUMP:C08-BMB}offset:X-I",
name="source_pos")
print(f"source position {source_pos.get():.6}")
print(datetime.now().isoformat())
