ophyd-async 0.13.2__tar.gz → 0.13.4__tar.gz

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.2
+Version: 0.13.4
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -49,7 +49,7 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
-Requires-Dist: scanspec>=1.0a1
+Requires-Dist: scanspec>=0.8
 Requires-Dist: velocity-profile
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
@@ -88,6 +88,7 @@ Requires-Dist: pytest-forked; extra == "dev"
 Requires-Dist: pytest-rerunfailures; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: scanspec>=1.0a1; extra == "dev"
 Requires-Dist: sphinx-autobuild; extra == "dev"
 Requires-Dist: sphinx-autodoc2; extra == "dev"
 Requires-Dist: sphinxcontrib-mermaid; extra == "dev"

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
     "pydantic>=2.0",
     "pydantic-numpy",
     "stamina>=23.1.0",
-    "scanspec>=1.0a1",
+    "scanspec>=0.8",
     "velocity-profile",
 ]
 dynamic = ["version"]
@@ -60,6 +60,7 @@ dev = [
     "pytest-rerunfailures",
     "pytest-timeout",
     "ruff",
+    "scanspec>=1.0a1",
     "sphinx-autobuild",
     "sphinx-autodoc2",
     "sphinxcontrib-mermaid",

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.2'
-__version_tuple__ = version_tuple = (0, 13, 2)
+__version__ = version = '0.13.4'
+__version_tuple__ = version_tuple = (0, 13, 4)
 
-__commit_id__ = commit_id = 'gc5aa76fc4'
+__commit_id__ = commit_id = 'gb42c37bf9'

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/core/__init__.py

@@ -78,7 +78,7 @@ from ._signal_backend import (
 )
 from ._soft_signal_backend import SoftSignalBackend
 from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
-from ._table import Table
+from ._table import Table, TableSubclass
 from ._utils import (
     CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
@@ -221,4 +221,5 @@ __all__ = [
     "EnableDisable",
     "InOut",
     "OnOff",
+    "TableSubclass",
 ]

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/core/_table.py

@@ -13,6 +13,7 @@ TableSubclass = TypeVar("TableSubclass", bound="Table")
 
 
 def _concat(value1, value2):
+    """Concatenate two values, supports both NumPy arrays and generic types."""
     if isinstance(value1, np.ndarray):
         return np.concatenate((value1, value2))
     else:
@@ -20,6 +21,8 @@ def _concat(value1, value2):
 
 
 def _make_default_factory(dtype: np.dtype) -> Callable[[], np.ndarray]:
+    """Creates a default factory, returns an empty Numpy array of a specified dtype."""
+
     def numpy_array_default_factory() -> np.ndarray:
         return np.array([], dtype)
 
@@ -91,6 +94,11 @@ class Table(ConfinedModel):
                 raise TypeError(f"Cannot use annotation {anno} in a Table")
             cls.__annotations__[k] = new_anno
 
+    @classmethod
+    def empty(cls: type[TableSubclass]) -> TableSubclass:
+        """Makes an empty table with zero length columns."""
+        return cls()  # type: ignore
+
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
         cls = type(right)

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -34,9 +34,11 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         self,
         driver: ADBaseIOT,
         good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
+        image_mode: ADImageMode = ADImageMode.MULTIPLE,
     ) -> None:
         self.driver: ADBaseIOT = driver
         self.good_states = good_states
+        self.image_mode = image_mode
         self.frame_timeout = DEFAULT_TIMEOUT
         self._arm_status: AsyncStatus | None = None
 
@@ -52,7 +54,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_exposures),
-            self.driver.image_mode.set(ADImageMode.MULTIPLE),
+            self.driver.image_mode.set(self.image_mode),
         )
 
     async def arm(self):

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/epics/motor.py

@@ -107,18 +107,27 @@ class Motor(
         self.user_readback.set_name(name)
 
     async def check_motor_limit(self, abs_start_pos: float, abs_end_pos: float):
-        """Check the motor limit with the absolute positions."""
+        """Check the positions are within limits.
+
+        Will raise a MotorLimitsException if the given absolute positions will be
+        outside the motor soft limits.
+        """
         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(),
         )
+
+        # EPICS motor record treats limits of 0, 0 as no limit
+        if motor_lower_limit == 0 and motor_upper_limit == 0:
+            return
+
         if (
             not motor_upper_limit >= abs_start_pos >= motor_lower_limit
             or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
         ):
             raise MotorLimitsException(
-                f"Motor trajectory for requested fly/move is from "
+                f"{self.name} motor trajectory for requested fly/move is from "
                 f"{abs_start_pos}{egu} to "
                 f"{abs_end_pos}{egu} but motor limits are "
                 f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "

{ophyd_async-0.13.2 → ophyd_async-0.13.4}/src/ophyd_async/epics/pmac/_pmac_io.py

@@ -4,7 +4,7 @@ import numpy as np
 
 from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
 from ophyd_async.epics import motor
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 CS_LETTERS = "ABCUVWXYZ"
 
@@ -40,11 +40,15 @@ class PmacTrajectoryIO(StandardReadable):
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
+        self.total_points = epics_signal_r(int, f"{prefix}TotalPoints_RBV")
         self.points_to_build = epics_signal_rw(int, prefix + "ProfilePointsToBuild")
-        self.build_profile = epics_signal_rw(bool, prefix + "ProfileBuild")
+        self.build_profile = epics_signal_x(prefix + "ProfileBuild")
+        self.append_profile = epics_signal_x(prefix + "ProfileAppend")
+        # This should be a SignalX, but because it is a Busy record, must
+        # be a SignalRW to be waited on in PmacTrajectoryTriggerLogic.
+        # TODO: Change record type to bo from busy (https://github.com/DiamondLightSource/pmac/issues/154)
         self.execute_profile = epics_signal_rw(bool, prefix + "ProfileExecute")
-        self.scan_percent = epics_signal_r(float, prefix + "TscanPercent_RBV")
-        self.abort_profile = epics_signal_rw(bool, prefix + "ProfileAbort")
+        self.abort_profile = epics_signal_x(prefix + "ProfileAbort")
         self.profile_cs_name = epics_signal_rw(str, prefix + "ProfileCsName")
         self.calculate_velocities = epics_signal_rw(bool, prefix + "ProfileCalcVel")
 

ophyd_async-0.13.4/src/ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -0,0 +1,217 @@
+import asyncio
+from dataclasses import dataclass
+
+import numpy as np
+from scanspec.core import Path, Slice
+from scanspec.specs import Spec
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    FlyerController,
+    error_if_none,
+    observe_value,
+    set_and_wait_for_value,
+    wait_for_value,
+)
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.pmac import PmacIO
+from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
+from ophyd_async.epics.pmac._pmac_trajectory_generation import PVT, Trajectory
+from ophyd_async.epics.pmac._utils import (
+    _PmacMotorInfo,
+    calculate_ramp_position_and_duration,
+)
+
+# PMAC durations are in milliseconds
+# We must convert from scanspec durations (seconds) to milliseconds
+# PMAC motion program multiples durations by 0.001
+# (see https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmc/trajectory_scan_code_ppmac.pmc#L241)
+# Therefore, we must divide scanspec durations by 10e-6
+TICK_S = 0.000001
+SLICE_SIZE = 4000
+
+
+@dataclass
+class PmacPrepareContext:
+    path: Path
+    motor_info: _PmacMotorInfo
+    ramp_up_time: float
+
+
+class PmacTrajectoryTriggerLogic(FlyerController):
+    def __init__(self, pmac: PmacIO) -> None:
+        self.pmac = pmac
+        self._next_pvt: PVT | None
+        self._loaded: int = 0
+        self._trajectory_status: AsyncStatus | None = None
+        self._prepare_context: PmacPrepareContext | None = None
+
+    async def prepare(self, value: Spec[Motor]):
+        path = Path(value.calculate())
+        slice = path.consume(SLICE_SIZE)
+        path_length = len(path)
+        motors = slice.axes()
+        motor_info = await _PmacMotorInfo.from_motors(self.pmac, motors)
+        ramp_up_pos, ramp_up_time = calculate_ramp_position_and_duration(
+            slice, motor_info, True
+        )
+        self._prepare_context = PmacPrepareContext(
+            path=path, motor_info=motor_info, ramp_up_time=ramp_up_time
+        )
+        await asyncio.gather(
+            self._build_trajectory(motor_info, slice, path_length, ramp_up_time),
+            self._move_to_start(motor_info, ramp_up_pos),
+        )
+
+    async def kickoff(self):
+        prepare_context = error_if_none(
+            self._prepare_context, "Cannot kickoff. Must call prepare first."
+        )
+        self._prepare_context = None
+        self._trajectory_status = self._execute_trajectory(
+            prepare_context.path, prepare_context.motor_info
+        )
+        # Wait for the ramp up to happen
+        await wait_for_value(
+            self.pmac.trajectory.total_points,
+            lambda v: v >= 1,
+            prepare_context.ramp_up_time + DEFAULT_TIMEOUT,
+        )
+
+    async def complete(self):
+        trajectory_status = error_if_none(
+            self._trajectory_status, "Cannot complete. Must call kickoff first."
+        )
+        await trajectory_status
+        # Reset trajectory status and number of loaded points
+        self._trajectory_status = None
+        self._loaded = 0
+
+    async def stop(self):
+        await self.pmac.trajectory.abort_profile.trigger()
+
+    @AsyncStatus.wrap
+    async def _execute_trajectory(self, path: Path, motor_info: _PmacMotorInfo):
+        execute_status = self.pmac.trajectory.execute_profile.set(
+            True, wait=True, timeout=None
+        )
+        # We consume SLICE_SIZE from self.path and parse a trajectory
+        # containing at least 2 * SLICE_SIZE, as a gapless trajectory
+        # will contain 2 points per slice frame. If gaps are present,
+        # additional points are inserted, overfilling the buffer.
+        min_buffer_size = SLICE_SIZE * 2
+        async for current_point in observe_value(
+            self.pmac.trajectory.total_points,
+            done_status=execute_status,
+            timeout=DEFAULT_TIMEOUT,
+        ):
+            # Ensure we maintain a minimum buffer size, if we have more points to append
+            if len(path) != 0 and self._loaded - current_point < min_buffer_size:
+                # We have less than SLICE_SIZE * 2 points in the buffer, so refill
+                next_slice = path.consume(SLICE_SIZE)
+                path_length = len(path)
+                await self._append_trajectory(next_slice, path_length, motor_info)
+
+    async def _append_trajectory(
+        self, slice: Slice, path_length: int, motor_info: _PmacMotorInfo
+    ):
+        trajectory = await self._parse_trajectory(slice, path_length, motor_info)
+        await self._set_trajectory_arrays(trajectory, motor_info)
+        await self.pmac.trajectory.append_profile.trigger()
+
+    async def _build_trajectory(
+        self,
+        motor_info: _PmacMotorInfo,
+        slice: Slice,
+        path_length: int,
+        ramp_up_time: float,
+    ):
+        trajectory = await self._parse_trajectory(
+            slice, path_length, motor_info, ramp_up_time
+        )
+        use_axis = {
+            axis + 1: (axis in motor_info.motor_cs_index.values())
+            for axis in range(len(CS_LETTERS))
+        }
+
+        coros = [
+            self.pmac.trajectory.profile_cs_name.set(motor_info.cs_port),
+            self.pmac.trajectory.calculate_velocities.set(False),
+            self._set_trajectory_arrays(trajectory, motor_info),
+        ] + [
+            self.pmac.trajectory.use_axis[number].set(use)
+            for number, use in use_axis.items()
+        ]
+
+        await asyncio.gather(*coros)
+        await self.pmac.trajectory.build_profile.trigger()
+
+    async def _parse_trajectory(
+        self,
+        slice: Slice,
+        path_length: int,
+        motor_info: _PmacMotorInfo,
+        ramp_up_time: float | None = None,
+    ) -> Trajectory:
+        trajectory, exit_pvt = Trajectory.from_slice(
+            slice,
+            motor_info,
+            None if ramp_up_time else self._next_pvt,
+            ramp_up_time=ramp_up_time,
+        )
+
+        if path_length == 0:
+            ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
+                slice, motor_info, False
+            )
+            trajectory = trajectory.with_ramp_down(
+                exit_pvt, ramp_down_pos, ramp_down_time, 0
+            )
+        self._next_pvt = exit_pvt
+        self._loaded += len(trajectory)
+
+        return trajectory
+
+    async def _set_trajectory_arrays(
+        self, trajectory: Trajectory, motor_info: _PmacMotorInfo
+    ):
+        coros = []
+        for motor, number in motor_info.motor_cs_index.items():
+            coros.append(
+                self.pmac.trajectory.positions[number + 1].set(
+                    trajectory.positions[motor]
+                )
+            )
+            coros.append(
+                self.pmac.trajectory.velocities[number + 1].set(
+                    trajectory.velocities[motor]
+                )
+            )
+        coros.extend(
+            [
+                self.pmac.trajectory.time_array.set(trajectory.durations / TICK_S),
+                self.pmac.trajectory.user_array.set(trajectory.user_programs),
+                self.pmac.trajectory.points_to_build.set(len(trajectory.durations)),
+            ]
+        )
+        await asyncio.gather(*coros)
+
+    async def _move_to_start(
+        self, motor_info: _PmacMotorInfo, ramp_up_position: dict[Motor, np.float64]
+    ):
+        coord = self.pmac.coord[motor_info.cs_number]
+        coros = []
+        await coord.defer_moves.set(True)
+        for motor, position in ramp_up_position.items():
+            coros.append(
+                set_and_wait_for_value(
+                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor] + 1],
+                    position,
+                    set_timeout=10,
+                    wait_for_set_completion=False,
+                )
+            )
+        statuses = await asyncio.gather(*coros)
+        await coord.defer_moves.set(False)
+        await asyncio.gather(*statuses)