ophyd-async 0.3.4a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/epics/motor.py

@@ -0,0 +1,228 @@
+import asyncio
+from typing import Optional
+
+from bluesky.protocols import Flyable, Movable, Preparable, Stoppable
+from pydantic import BaseModel, Field
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    CalculateTimeout,
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+
+
+class MotorLimitsException(Exception):
+    pass
+
+
+class InvalidFlyMotorException(Exception):
+    pass
+
+
+DEFAULT_MOTOR_FLY_TIMEOUT = 60
+DEFAULT_WATCHER_UPDATE_FREQUENCY = 0.2
+
+
+class FlyMotorInfo(BaseModel):
+    """Minimal set of information required to fly a motor:"""
+
+    #: Absolute position of the motor once it finishes accelerating to desired
+    #: velocity, in motor EGUs
+    start_position: float = Field(frozen=True)
+
+    #: Absolute position of the motor once it begins decelerating from desired
+    #: velocity, in EGUs
+    end_position: float = Field(frozen=True)
+
+    #: Time taken for the motor to get from start_position to end_position, excluding
+    #: run-up and run-down, in seconds.
+    time_for_move: float = Field(frozen=True, gt=0)
+
+    #: Maximum time for the complete motor move, including run up and run down.
+    #: Defaults to `time_for_move` + run up and run down times + 10s.
+    timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
+
+
+class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
+    """Device that moves a motor record"""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some signals
+        with self.add_children_as_readables(ConfigSignal):
+            self.motor_egu = epics_signal_r(str, prefix + ".EGU")
+            self.velocity = epics_signal_rw(float, prefix + ".VELO")
+
+        with self.add_children_as_readables(HintedSignal):
+            self.user_readback = epics_signal_r(float, prefix + ".RBV")
+
+        self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")
+        self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
+        self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
+        self.precision = epics_signal_r(int, prefix + ".PREC")
+        self.deadband = epics_signal_r(float, prefix + ".RDBD")
+        self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
+        self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
+        self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+
+        self.motor_stop = epics_signal_x(prefix + ".STOP")
+        # Whether set() should complete successfully or not
+        self._set_success = True
+
+        # end_position of a fly move, with run_up_distance added on.
+        self._fly_completed_position: Optional[float] = None
+
+        # Set on kickoff(), complete when motor reaches self._fly_completed_position
+        self._fly_status: Optional[WatchableAsyncStatus] = None
+
+        # Set during prepare
+        self._fly_timeout: Optional[CalculatableTimeout] = CalculateTimeout
+
+        super().__init__(name=name)
+
+    def set_name(self, name: str):
+        super().set_name(name)
+        # Readback should be named the same as its parent in read()
+        self.user_readback.set_name(name)
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: FlyMotorInfo):
+        """Calculate required velocity and run-up distance, then if motor limits aren't
+        breached, move to start position minus run-up distance"""
+
+        self._fly_timeout = value.timeout
+
+        # Velocity, at which motor travels from start_position to end_position, in motor
+        # egu/s.
+        fly_velocity = await self._prepare_velocity(
+            value.start_position,
+            value.end_position,
+            value.time_for_move,
+        )
+
+        # start_position with run_up_distance added on.
+        fly_prepared_position = await self._prepare_motor_path(
+            abs(fly_velocity), value.start_position, value.end_position
+        )
+
+        await self.set(fly_prepared_position)
+        await self.velocity.set(fly_velocity)
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        """Begin moving motor from prepared position to final position."""
+        assert (
+            self._fly_completed_position
+        ), "Motor must be prepared before attempting to kickoff"
+
+        self._fly_status = self.set(
+            self._fly_completed_position, timeout=self._fly_timeout
+        )
+
+    def complete(self) -> WatchableAsyncStatus:
+        """Mark as complete once motor reaches completed position."""
+        assert self._fly_status, "kickoff not called"
+        return self._fly_status
+
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
+        self._set_success = True
+        (
+            old_position,
+            units,
+            precision,
+            velocity,
+            acceleration_time,
+        ) = await asyncio.gather(
+            self.user_setpoint.get_value(),
+            self.motor_egu.get_value(),
+            self.precision.get_value(),
+            self.velocity.get_value(),
+            self.acceleration_time.get_value(),
+        )
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Motor has zero velocity"
+            timeout = (
+                abs(new_position - old_position) / velocity
+                + 2 * acceleration_time
+                + DEFAULT_TIMEOUT
+            )
+        move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=False):
+        self._set_success = success
+        # Put with completion will never complete as we are waiting for completion on
+        # the move above, so need to pass wait=False
+        await self.motor_stop.trigger(wait=False)
+
+    async def _prepare_velocity(
+        self, start_position: float, end_position: float, time_for_move: float
+    ) -> float:
+        fly_velocity = (end_position - start_position) / time_for_move
+        max_speed, egu = await asyncio.gather(
+            self.max_velocity.get_value(), self.motor_egu.get_value()
+        )
+        if abs(fly_velocity) > max_speed:
+            raise MotorLimitsException(
+                f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
+                f" with max speed of {max_speed} {egu}/s"
+            )
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
+        return fly_velocity
+
+    async def _prepare_motor_path(
+        self, fly_velocity: float, start_position: float, end_position: float
+    ) -> float:
+        # Distance required for motor to accelerate from stationary to fly_velocity, and
+        # distance required for motor to decelerate from fly_velocity to stationary
+        run_up_distance = (
+            (await self.acceleration_time.get_value()) * fly_velocity * 0.5
+        )
+
+        self._fly_completed_position = end_position + run_up_distance
+
+        # Prepared position not used after prepare, so no need to store in self
+        fly_prepared_position = start_position - run_up_distance
+
+        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+            self.low_limit_travel.get_value(),
+            self.high_limit_travel.get_value(),
+            self.motor_egu.get_value(),
+        )
+
+        if (
+            not motor_upper_limit >= fly_prepared_position >= motor_lower_limit
+            or not motor_upper_limit
+            >= self._fly_completed_position
+            >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly is from "
+                f"{fly_prepared_position}{egu} to "
+                f"{self._fly_completed_position}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+        return fly_prepared_position

ophyd_async/epics/pvi/__init__.py

@@ -1,3 +1,3 @@
-from .pvi import PVIEntry, create_children_from_annotations, fill_pvi_entries
+from ._pvi import create_children_from_annotations, fill_pvi_entries
 
-__all__ = ["PVIEntry", "fill_pvi_entries", "create_children_from_annotations"]
+__all__ = ["fill_pvi_entries", "create_children_from_annotations"]

ophyd_async/epics/pvi/{pvi.py → _pvi.py}

@@ -10,25 +10,28 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    TypeVar,
     Union,
     get_args,
     get_origin,
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
-from ophyd_async.core.signal import Signal
-from ophyd_async.core.utils import DEFAULT_TIMEOUT
-from ophyd_async.epics._backend._p4p import PvaSignalBackend
-from ophyd_async.epics.signal.signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Device,
+    DeviceVector,
+    Signal,
+    SoftSignalBackend,
+    T,
+)
+from ophyd_async.epics.signal import (
+    PvaSignalBackend,
     epics_signal_r,
     epics_signal_rw,
     epics_signal_w,
     epics_signal_x,
 )
 
-T = TypeVar("T")
 Access = FrozenSet[
     Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
 ]
@@ -74,19 +77,19 @@ def _strip_device_vector(field: Union[Type[Device]]) -> Tuple[bool, Type[Device]
 
 
 @dataclass
-class PVIEntry:
+class _PVIEntry:
     """
     A dataclass to represent a single entry in the PVI table.
     This could either be a signal or a sub-table.
     """
 
-    sub_entries: Dict[str, Union[Dict[int, "PVIEntry"], "PVIEntry"]]
+    sub_entries: Dict[str, Union[Dict[int, "_PVIEntry"], "_PVIEntry"]]
     pvi_pv: Optional[str] = None
     device: Optional[Device] = None
     common_device_type: Optional[Type[Device]] = None
 
 
-def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
+def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
     if not entry.sub_entries:
         return
     common_sub_devices = get_type_hints(common_device)
@@ -205,7 +208,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
         sub_device.parent = device
 
 
-async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
+async def _get_pvi_entries(entry: _PVIEntry, timeout=DEFAULT_TIMEOUT):
     if not entry.pvi_pv or not entry.pvi_pv.endswith(":PVI"):
         raise RuntimeError("Top level entry must be a pvi table")
 
@@ -235,7 +238,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         else:
             device = getattr(entry.device, sub_name, device_type())
 
-        sub_entry = PVIEntry(
+        sub_entry = _PVIEntry(
             device=device, common_device_type=device_type, sub_entries={}
         )
 
@@ -257,7 +260,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         _verify_common_blocks(entry, entry.common_device_type)
 
 
-def _set_device_attributes(entry: PVIEntry):
+def _set_device_attributes(entry: _PVIEntry):
     for sub_name, sub_entry in entry.sub_entries.items():
         if isinstance(sub_entry, dict):
             sub_device = DeviceVector()  # type: ignore
@@ -289,7 +292,7 @@ async def fill_pvi_entries(
         _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
-        root_entry = PVIEntry(
+        root_entry = _PVIEntry(
             pvi_pv=root_pv,
             device=device,
             common_device_type=type(device),

ophyd_async/epics/signal/__init__.py

@@ -1,4 +1,6 @@
-from .signal import (
+from ._common import LimitPair, Limits, get_supported_values
+from ._p4p import PvaSignalBackend
+from ._signal import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
@@ -7,6 +9,10 @@ from .signal import (
 )
 
 __all__ = [
+    "get_supported_values",
+    "LimitPair",
+    "Limits",
+    "PvaSignalBackend",
     "epics_signal_r",
     "epics_signal_rw",
     "epics_signal_rw_rbv",

ophyd_async/epics/{_backend → signal}/_aioca.py

@@ -21,6 +21,8 @@ from bluesky.protocols import DataKey, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -28,9 +30,8 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -66,9 +67,12 @@ def _data_key_from_augmented_value(
     scalar = value.element_count == 1
     dtype = dtype or dbr_to_dtype[value.datatype]
 
+    dtype_numpy = np.dtype(dbr.DbrCodeToType[value.datatype].dtype).descr[0][1]
+
     d = DataKey(
         source=source,
         dtype=dtype if scalar else "array",
+        dtype_numpy=dtype_numpy,
         # strictly value.element_count >= len(value)
         shape=[] if scalar else [len(value)],
     )

ophyd_async/epics/{_backend/common.py → signal/_common.py}

@@ -1,8 +1,10 @@
 import inspect
 from enum import Enum
-from typing import Dict, Optional, Tuple, Type, TypedDict
+from typing import Dict, Optional, Tuple, Type
 
-from ophyd_async.core.signal_backend import RuntimeSubsetEnum
+from typing_extensions import TypedDict
+
+from ophyd_async.core import RuntimeSubsetEnum
 
 common_meta = {
     "units",

ophyd_async/epics/signal/_epics_transport.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from enum import Enum
 
 try:
-    from .._backend._aioca import CaSignalBackend
+    from ._aioca import CaSignalBackend
 except ImportError as ca_error:
 
     class CaSignalBackend:  # type: ignore
@@ -14,7 +14,7 @@ except ImportError as ca_error:
 
 
 try:
-    from .._backend._p4p import PvaSignalBackend
+    from ._p4p import PvaSignalBackend
 except ImportError as pva_error:
 
     class PvaSignalBackend:  # type: ignore
@@ -22,7 +22,7 @@ except ImportError as pva_error:
             raise NotImplementedError("PVA support not available") from pva_error
 
 
-class EpicsTransport(Enum):
+class _EpicsTransport(Enum):
     """The sorts of transport EPICS support"""
 
     #: Use Channel Access (using aioca library)

ophyd_async/epics/{_backend → signal}/_p4p.py

@@ -1,5 +1,6 @@
 import asyncio
 import atexit
+import inspect
 import logging
 import time
 from dataclasses import dataclass
@@ -12,16 +13,18 @@ from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
+    RuntimeSubsetEnum,
     SignalBackend,
     T,
     get_dtype,
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -39,6 +42,21 @@ specifier_to_dtype: Dict[str, Dtype] = {
     "s": "string",
 }
 
+specifier_to_np_dtype: Dict[str, str] = {
+    "?": "<i2",  # bool
+    "b": "|i1",  # int8
+    "B": "|u1",  # uint8
+    "h": "<i2",  # int16
+    "H": "<u2",  # uint16
+    "i": "<i4",  # int32
+    "I": "<u4",  # uint32
+    "l": "<i8",  # int64
+    "L": "<u8",  # uint64
+    "f": "<f4",  # float32
+    "d": "<f8",  # float64
+    "s": "|S40",
+}
+
 
 def _data_key_from_value(
     source: str,
@@ -59,12 +77,35 @@ def _data_key_from_value(
         DataKey: A rich DataKey describing the DB record
     """
     shape = shape or []
-    dtype = dtype or specifier_to_dtype[value.type().aspy("value")]
+    type_code = value.type().aspy("value")
+
+    dtype = dtype or specifier_to_dtype[type_code]
+
+    try:
+        if isinstance(type_code, tuple):
+            dtype_numpy = ""
+            if type_code[1] == "enum_t":
+                if dtype == "bool":
+                    dtype_numpy = "<i2"
+                else:
+                    for item in type_code[2]:
+                        if item[0] == "choices":
+                            dtype_numpy = specifier_to_np_dtype[item[1][1]]
+        elif not type_code.startswith("a"):
+            dtype_numpy = specifier_to_np_dtype[type_code]
+        else:
+            # Array type, use typecode of internal element
+            dtype_numpy = specifier_to_np_dtype[type_code[1]]
+    except KeyError:
+        # Case where we can't determine dtype string from value
+        dtype_numpy = ""
+
     display_data = getattr(value, "display", None)
 
     d = DataKey(
         source=source,
         dtype=dtype,
+        dtype_numpy=dtype_numpy,
         shape=shape,
     )
     if display_data is not None:
@@ -249,7 +290,7 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
     typ = get_unique(
         {k: type(v.get("value")) for k, v in values.items()}, "value types"
     )
-    if "NTScalarArray" in typeid and typ == list:
+    if "NTScalarArray" in typeid and typ is list:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
             raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
@@ -287,6 +328,14 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
         if (
+            typ is str
+            and inspect.isclass(datatype)
+            and issubclass(datatype, RuntimeSubsetEnum)
+        ):
+            return PvaEnumConverter(
+                get_supported_values(pv, datatype, datatype.choices)
+            )
+        elif (
             datatype
             and not issubclass(typ, datatype)
             and not (

ophyd_async/epics/signal/{signal.py → _signal.py}

@@ -14,26 +14,27 @@ from ophyd_async.core import (
     get_unique,
 )
 
-from ._epics_transport import EpicsTransport
+from ._epics_transport import _EpicsTransport
 
-_default_epics_transport = EpicsTransport.ca
+_default_epics_transport = _EpicsTransport.ca
 
 
-def _transport_pv(pv: str) -> Tuple[EpicsTransport, str]:
+def _transport_pv(pv: str) -> Tuple[_EpicsTransport, str]:
     split = pv.split("://", 1)
     if len(split) > 1:
         # We got something like pva://mydevice, so use specified comms mode
         transport_str, pv = split
-        transport = EpicsTransport[transport_str]
+        transport = _EpicsTransport[transport_str]
     else:
         # No comms mode specified, use the default
         transport = _default_epics_transport
     return transport, pv
 
 
-def _make_backend(
+def _epics_signal_backend(
     datatype: Optional[Type[T]], read_pv: str, write_pv: str
 ) -> SignalBackend[T]:
+    """Create an epics signal backend."""
     r_transport, r_pv = _transport_pv(read_pv)
     w_transport, w_pv = _transport_pv(write_pv)
     transport = get_unique({read_pv: r_transport, write_pv: w_transport}, "transports")
@@ -54,7 +55,7 @@ def epics_signal_rw(
     write_pv:
         If given, use this PV to write to, otherwise use read_pv
     """
-    backend = _make_backend(datatype, read_pv, write_pv or read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
     return SignalRW(backend, name=name)
 
 
@@ -85,7 +86,7 @@ def epics_signal_r(datatype: Type[T], read_pv: str, name: str = "") -> SignalR[T
     read_pv:
         The PV to read and monitor
     """
-    backend = _make_backend(datatype, read_pv, read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, read_pv)
     return SignalR(backend, name=name)
 
 
@@ -99,7 +100,7 @@ def epics_signal_w(datatype: Type[T], write_pv: str, name: str = "") -> SignalW[
     write_pv:
         The PV to write to
     """
-    backend = _make_backend(datatype, write_pv, write_pv)
+    backend = _epics_signal_backend(datatype, write_pv, write_pv)
     return SignalW(backend, name=name)
 
 
@@ -111,5 +112,5 @@ def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
     write_pv:
         The PV to write its initial value to on trigger
     """
-    backend: SignalBackend = _make_backend(None, write_pv, write_pv)
+    backend: SignalBackend = _epics_signal_backend(None, write_pv, write_pv)
     return SignalX(backend, name=name)

ophyd_async/{panda → fastcs/panda}/__init__.py

@@ -1,38 +1,57 @@
 from ._common_blocks import (
     CommonPandaBlocks,
     DataBlock,
+    EnableDisableOptions,
     PcapBlock,
+    PcompBlock,
+    PcompDirectionOptions,
     PulseBlock,
     SeqBlock,
     TimeUnits,
 )
 from ._hdf_panda import HDFPanda
+from ._hdf_writer import PandaHDFWriter
 from ._panda_controller import PandaPcapController
 from ._table import (
+    DatasetTable,
+    PandaHdf5DatasetType,
     SeqTable,
     SeqTableRow,
     SeqTrigger,
     seq_table_from_arrays,
     seq_table_from_rows,
 )
-from ._trigger import StaticSeqTableTriggerLogic
+from ._trigger import (
+    PcompInfo,
+    SeqTableInfo,
+    StaticPcompTriggerLogic,
+    StaticSeqTableTriggerLogic,
+)
 from ._utils import phase_sorter
 
 __all__ = [
     "CommonPandaBlocks",
-    "HDFPanda",
+    "DataBlock",
+    "EnableDisableOptions",
     "PcapBlock",
+    "PcompBlock",
+    "PcompDirectionOptions",
     "PulseBlock",
-    "seq_table_from_arrays",
-    "seq_table_from_rows",
     "SeqBlock",
+    "TimeUnits",
+    "HDFPanda",
+    "PandaHDFWriter",
+    "PandaPcapController",
+    "DatasetTable",
+    "PandaHdf5DatasetType",
     "SeqTable",
     "SeqTableRow",
     "SeqTrigger",
-    "phase_sorter",
-    "PandaPcapController",
-    "TimeUnits",
-    "DataBlock",
-    "CommonPandABlocks",
+    "seq_table_from_arrays",
+    "seq_table_from_rows",
+    "PcompInfo",
+    "SeqTableInfo",
+    "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
+    "phase_sorter",
 ]