ophyd-async 0.13.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

ophyd_async/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.0'
-__version_tuple__ = version_tuple = (0, 13, 0)
+__version__ = version = '0.13.2'
+__version_tuple__ = version_tuple = (0, 13, 2)
+
+__commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -6,7 +6,7 @@ from ._derived_signal import (
     derived_signal_rw,
     derived_signal_w,
 )
-from ._derived_signal_backend import Transform
+from ._derived_signal_backend import Transform, merge_gathered_dicts
 from ._detector import (
     DetectorController,
     DetectorTrigger,
@@ -212,6 +212,7 @@ __all__ = [
     "derived_signal_w",
     "Transform",
     "DerivedSignalFactory",
+    "merge_gathered_dicts",
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",

ophyd_async/core/_detector.py

@@ -84,7 +84,7 @@ class TriggerInfo(ConfinedModel):
     A exposures_per_event > 1 can be useful to have exposures from a faster detector
     able to be zipped with a single exposure from a slower detector. E.g. if
     number_of_events=10 and exposures_per_event=5 then the detector will take
-    10 exposures, but publish 2 StreamDatum indices, and describe() will show a
+    50 exposures, but publish 10 StreamDatum indices, and describe() will show a
     shape of (5, h, w) for each.
     Default is 1.
     """

ophyd_async/core/_signal.py

@@ -39,8 +39,8 @@ from ._utils import (
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
     try:
         return await asyncio.wait_for(coro, timeout)
-    except asyncio.TimeoutError as e:
-        raise asyncio.TimeoutError(source) from e
+    except TimeoutError as e:
+        raise TimeoutError(source) from e
 
 
 def _add_timeout(func):
@@ -121,6 +121,13 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self._valid = asyncio.Event()
         self._reading: Reading[SignalDatatypeT] | None = None
         self.backend: SignalBackend[SignalDatatypeT] = backend
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError as e:
+            raise RuntimeError(
+                "Need a running event loop to subscribe to a signal, "
+                "are you trying to run subscribe outside a plan?"
+            ) from e
         signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 
@@ -492,7 +499,7 @@ async def observe_signals_value(
         last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
-                raise asyncio.TimeoutError(
+                raise TimeoutError(
                     f"observe_value was still observing signals "
                     f"{[signal.source for signal in signals]} after "
                     f"timeout {done_timeout}s"
@@ -500,8 +507,8 @@ async def observe_signals_value(
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
             try:
                 item = await asyncio.wait_for(q.get(), iteration_timeout)
-            except asyncio.TimeoutError as exc:
-                raise asyncio.TimeoutError(
+            except TimeoutError as exc:
+                raise TimeoutError(
                     f"Timeout Error while waiting {iteration_timeout}s to update "
                     f"{[signal.source for signal in signals]}. "
                     f"Last observed signal and value were {last_item}"
@@ -536,8 +543,8 @@ class _ValueChecker(Generic[SignalDatatypeT]):
     ):
         try:
             await asyncio.wait_for(self._wait_for_value(signal), timeout)
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{signal.name} didn't match {self._matcher_name} in {timeout}s, "
                 f"last value {self._last_value!r}"
             ) from e
@@ -635,8 +642,8 @@ async def set_and_wait_for_other_value(
             await asyncio.wait_for(_wait_for_value(), timeout)
             if wait_for_set_completion:
                 await status
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
                 f" {matcher.__name__}() in {timeout}s"
             ) from e

ophyd_async/core/_utils.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
-from enum import Enum, EnumMeta
+from enum import Enum, EnumMeta, StrEnum
 from typing import (
     Any,
     Generic,
@@ -59,15 +59,15 @@ class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class StrictEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """All members should exist in the Backend, and there will be no extras."""
 
 
-class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
+class SubsetEnum(StrEnum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
-class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class SupersetEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """Some members should exist in the Backend, and there should be no extras."""
 
 
@@ -243,6 +243,7 @@ def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
+    datatype = get_origin_class(datatype)
     if datatype and issubclass(datatype, Enum):
         if not issubclass(datatype, EnumTypes):
             raise TypeError(

ophyd_async/epics/adandor/_andor.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._andor_controller import Andor2Controller

ophyd_async/epics/adcore/_core_detector.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import SignalR, StandardDetector
-from ophyd_async.core._providers import PathProvider
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
 
 from ._core_io import ADBaseIO, NDPluginBaseIO, NDPluginCBIO
 from ._core_logic import ADBaseContAcqController, ADBaseControllerT

ophyd_async/epics/adcore/_core_io.py

@@ -229,7 +229,7 @@ class NDFileHDFIO(NDFilePluginIO):
     swmr_mode: A[SignalRW[bool], PvSuffix.rbv("SWMRMode")]
     flush_now: A[SignalRW[bool], PvSuffix("FlushNow")]
     xml_file_name: A[SignalRW[str], PvSuffix.rbv("XMLFileName")]
-    num_frames_chunks: A[SignalR[int], PvSuffix("NumFramesChunks_RBV")]
+    num_frames_chunks: A[SignalRW[int], PvSuffix.rbv("NumFramesChunks")]
     chunk_size_auto: A[SignalRW[bool], PvSuffix.rbv("ChunkSizeAuto")]
     lazy_open: A[SignalRW[bool], PvSuffix.rbv("LazyOpen")]
 

ophyd_async/epics/adcore/_core_logic.py

@@ -130,7 +130,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 ):
                     if state in self.good_states:
                         return
-            except asyncio.TimeoutError as exc:
+            except TimeoutError as exc:
                 if state is not None:
                     raise ValueError(
                         f"Final detector state {state.value} not in valid end "
@@ -138,7 +138,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                     ) from exc
                 else:
                     # No updates from the detector, something else is wrong
-                    raise asyncio.TimeoutError(
+                    raise TimeoutError(
                         "Could not monitor detector state: "
                         + self.driver.detector_state.source
                     ) from exc

ophyd_async/epics/adcore/_core_writer.py

@@ -11,15 +11,18 @@ from event_model import (  # type: ignore
 )
 from pydantic import PositiveInt
 
-from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._enums import EnableDisable
-from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
-from ophyd_async.core._signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DatasetDescriber,
+    DetectorWriter,
+    EnableDisable,
+    PathInfo,
+    PathProvider,
+    error_if_none,
     observe_value,
     set_and_wait_for_value,
 )
-from ophyd_async.core._status import AsyncStatus
-from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
 from ophyd_async.epics.core import stop_busy_record
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber

ophyd_async/epics/adcore/_hdf_writer.py

@@ -75,8 +75,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Used by the base class
         self._exposures_per_event = exposures_per_event
 
-        # Determine number of frames that will be saved per HDF chunk
+        # Determine number of frames that will be saved per HDF chunk.
+        # On a fresh IOC startup, this is set to zero until the first capture,
+        # so if it is zero, set it to 1.
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
+        if frames_per_chunk == 0:
+            frames_per_chunk = 1
+            await self.fileio.num_frames_chunks.set(frames_per_chunk)
 
         if not _is_fully_described(detector_shape):
             # Questions:

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -16,10 +16,10 @@ class KinetixTriggerMode(StrictEnum):
 class KinetixReadoutMode(StrictEnum):
     """Readout mode for ADKinetix detector."""
 
-    SENSITIVITY = 1
-    SPEED = 2
-    DYNAMIC_RANGE = 3
-    SUB_ELECTRON = 4
+    SENSITIVITY = "1"
+    SPEED = "2"
+    DYNAMIC_RANGE = "3"
+    SUB_ELECTRON = "4"
 
 
 class KinetixDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,11 +1,7 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
-from ophyd_async.epics.adcore._core_detector import AreaDetector
-from ophyd_async.epics.adcore._core_io import NDPluginBaseIO
-from ophyd_async.epics.adcore._core_writer import ADWriter
-from ophyd_async.epics.adcore._hdf_writer import ADHDFWriter
+from ophyd_async.core import PathProvider, SignalR
+from ophyd_async.epics.adcore import ADHDFWriter, ADWriter, AreaDetector, NDPluginBaseIO
 
 from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO

ophyd_async/epics/advimba/_vimba_io.py

@@ -30,7 +30,7 @@ class VimbaTriggerSource(StrictEnum):
 class VimbaOverlap(StrictEnum):
     """Overlap modes for the Vimba detector."""
 
-    OFF = OnOff.OFF
+    OFF = OnOff.OFF.value
     PREV_FRAME = "PreviousFrame"
 
 

ophyd_async/epics/core/_epics_connector.py

@@ -10,7 +10,20 @@ from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol
 
 @dataclass
 class PvSuffix:
-    """Define the PV suffix to be appended to the device prefix."""
+    """Define the PV suffix to be appended to the device prefix.
+
+    For a SignalRW:
+    - If you use the same "Suffix" for the read and write PV then use PvSuffix("Suffix")
+    - If you have "Suffix" for the write PV and "Suffix_RBV" for the read PV then use
+      PvSuffix.rbv("Suffix")
+    - If you have "WriteSuffix" for the write PV and "ReadSuffix" for the read PV then
+      you use PvSuffix(read_suffix="ReadSuffix", write_suffix="WriteSuffix")
+
+    For a SignalR:
+    - If you have "Suffix" for the read PV then use PvSuffix("Suffix")
+    - If you have "Suffix_RBV" for the read PV then use PvSuffix("Suffix_RBV"), do not
+      use PvSuffix.rbv as that will try to connect to multiple PVs
+    """
 
     read_suffix: str
     write_suffix: str | None = None

ophyd_async/epics/core/_p4p.py

@@ -22,7 +22,6 @@ from ophyd_async.core import (
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
-    StrictEnum,
     Table,
     get_enum_cls,
     get_unique,
@@ -82,7 +81,7 @@ def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMe
     if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
-    if datatype is str or issubclass(datatype, StrictEnum):
+    if datatype is str or get_enum_cls(datatype) is not None:
         if hasattr(display_data, "choices"):
             metadata["choices"] = display_data.choices
         elif hasattr(value_data, "choices"):
@@ -327,7 +326,7 @@ def context() -> Context:
 async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
-    except asyncio.TimeoutError as exc:
+    except TimeoutError as exc:
         logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 

ophyd_async/epics/core/_pvi_connector.py

@@ -6,13 +6,13 @@ from ophyd_async.core import (
     Device,
     DeviceConnector,
     DeviceFiller,
+    LazyMock,
     Signal,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
 )
-from ophyd_async.core._utils import LazyMock
 
 from ._epics_connector import fill_backend_with_prefix
 from ._signal import PvaSignalBackend, pvget_with_timeout

ophyd_async/epics/motor.py

@@ -106,6 +106,24 @@ class Motor(
         # Readback should be named the same as its parent in read()
         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."""
+        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 >= 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"{abs_start_pos}{egu} to "
+                f"{abs_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
         """Move to the beginning of a suitable run-up distance ready for a fly scan."""
@@ -126,22 +144,7 @@ class Motor(
         ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
         ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        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 >= ramp_up_start_pos >= motor_lower_limit
-            or not motor_upper_limit >= ramp_down_end_pos >= motor_lower_limit
-        ):
-            raise MotorLimitsException(
-                f"Motor trajectory for requested fly is from "
-                f"{ramp_up_start_pos}{egu} to "
-                f"{ramp_down_end_pos}{egu} but motor limits are "
-                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
-            )
+        await self.check_motor_limit(ramp_up_start_pos, ramp_down_end_pos)
 
         # move to prepare position at maximum velocity
         await self.velocity.set(abs(max_speed))
@@ -199,6 +202,8 @@ class Motor(
                 msg = "Mover has zero velocity"
                 raise ValueError(msg) from error
 
+        await self.check_motor_limit(old_position, new_position)
+
         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

ophyd_async/epics/{eiger → odin}/_odin_io.py

@@ -90,11 +90,11 @@ class OdinWriter(DetectorWriter):
         self,
         path_provider: PathProvider,
         odin_driver: Odin,
-        eiger_bit_depth: SignalR[int],
+        detector_bit_depth: SignalR[int],
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
-        self._eiger_bit_depth = Reference(eiger_bit_depth)
+        self._detector_bit_depth = Reference(detector_bit_depth)
         self._capture_status: AsyncStatus | None = None
         super().__init__()
 
@@ -103,7 +103,9 @@ class OdinWriter(DetectorWriter):
         self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
-            self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
+            self._drv.data_type.set(
+                f"UInt{await self._detector_bit_depth().get_value()}"
+            ),
             self._drv.num_to_capture.set(0),
             self._drv.file_path.set(str(info.directory_path)),
             self._drv.file_name.set(info.filename),

ophyd_async/epics/pmac/__init__.py

@@ -1,8 +1,10 @@
 from ._pmac_io import PmacAxisAssignmentIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+from ._pmac_trajectory import PmacTrajectoryTriggerLogic
 
 __all__ = [
     "PmacAxisAssignmentIO",
     "PmacCoordIO",
     "PmacIO",
     "PmacTrajectoryIO",
+    "PmacTrajectoryTriggerLogic",
 ]

ophyd_async/epics/pmac/_pmac_io.py

@@ -72,7 +72,7 @@ class PmacCoordIO(Device):
         self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")
+                i + 1: epics_signal_rw(float, f"{prefix}M{i + 1}:DirectDemand")
                 for i in range(len(CS_LETTERS))
             }
         )
@@ -93,7 +93,7 @@ class PmacIO(Device):
 
         self.assignment = DeviceVector(
             {
-                i: PmacAxisAssignmentIO(motor_prefix)
+                i: PmacAxisAssignmentIO(motor_prefix + ":")
                 for i, motor_prefix in enumerate(motor_prefixes)
             }
         )

ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -0,0 +1,116 @@
+import asyncio
+
+import numpy as np
+from scanspec.core import Path
+from scanspec.specs import Spec
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    FlyerController,
+    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._utils import (
+    _PmacMotorInfo,
+    _Trajectory,
+    calculate_ramp_position_and_duration,
+)
+
+
+class PmacTrajectoryTriggerLogic(FlyerController):
+    def __init__(self, pmac: PmacIO) -> None:
+        self.pmac = pmac
+        self.scantime: float | None = None
+
+    async def prepare(self, value: Spec[Motor]):
+        slice = Path(value.calculate()).consume()
+        motor_info = await _PmacMotorInfo.from_motors(self.pmac, slice.axes())
+        ramp_up_pos, ramp_up_time = calculate_ramp_position_and_duration(
+            slice, motor_info, True
+        )
+        ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
+            slice, motor_info, False
+        )
+        trajectory = _Trajectory.from_slice(slice, ramp_up_time, motor_info)
+        await asyncio.gather(
+            self._build_trajectory(
+                trajectory, motor_info, ramp_down_pos, ramp_down_time
+            ),
+            self._move_to_start(motor_info, ramp_up_pos),
+        )
+
+    async def kickoff(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot kickoff. Must call prepare first.")
+        self.status = await self.pmac.trajectory.execute_profile.set(
+            True, timeout=self.scantime + 1
+        )
+
+    async def complete(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot complete. Must call prepare first.")
+        await wait_for_value(
+            self.pmac.trajectory.execute_profile,
+            False,
+            timeout=self.scantime + DEFAULT_TIMEOUT,
+        )
+
+    async def stop(self):
+        await self.pmac.trajectory.abort_profile.set(True)
+
+    async def _build_trajectory(
+        self,
+        trajectory: _Trajectory,
+        motor_info: _PmacMotorInfo,
+        ramp_down_pos: dict[Motor, np.float64],
+        ramp_down_time: float,
+    ):
+        trajectory = trajectory.append_ramp_down(ramp_down_pos, ramp_down_time, 0)
+        self.scantime = np.sum(trajectory.durations)
+        use_axis = {axis + 1: False for axis in range(len(CS_LETTERS))}
+
+        size = 0
+        for motor, number in motor_info.motor_cs_index.items():
+            use_axis[number + 1] = True
+            await self.pmac.trajectory.positions[number + 1].set(
+                trajectory.positions[motor]
+            )
+            await self.pmac.trajectory.velocities[number + 1].set(
+                trajectory.velocities[motor]
+            )
+            size += len(trajectory.positions[motor])
+
+        coros = [
+            self.pmac.trajectory.profile_cs_name.set(motor_info.cs_port),
+            self.pmac.trajectory.time_array.set(trajectory.durations),
+            self.pmac.trajectory.user_array.set(trajectory.user_programs),
+            self.pmac.trajectory.points_to_build.set(size),
+            self.pmac.trajectory.calculate_velocities.set(False),
+        ] + [
+            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.set(True)
+
+    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)