ophyd-async 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

ophyd_async/core/_utils.py

@@ -2,23 +2,13 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import dataclass
-from typing import (
-    Awaitable,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    List,
-    Optional,
-    ParamSpec,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Generic, Literal, ParamSpec, TypeVar, get_origin
 
 import numpy as np
 from bluesky.protocols import Reading
+from pydantic import BaseModel
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -28,18 +18,18 @@ Callback = Callable[[T], None]
 #: monitor updates
 ReadingValueCallback = Callable[[Reading, T], None]
 DEFAULT_TIMEOUT = 10.0
-ErrorText = Union[str, Dict[str, Exception]]
+ErrorText = str | dict[str, Exception]
 
 
-class CalculateTimeout:
-    """Sentinel class used to implement ``myfunc(timeout=CalculateTimeout)``
+CALCULATE_TIMEOUT = "CALCULATE_TIMEOUT"
+"""Sentinel used to implement ``myfunc(timeout=CalculateTimeout)``
 
-    This signifies that the function should calculate a suitable non-zero
-    timeout itself
-    """
+This signifies that the function should calculate a suitable non-zero
+timeout itself
+"""
 
 
-CalculatableTimeout = float | None | Type[CalculateTimeout]
+CalculatableTimeout = float | None | Literal["CALCULATE_TIMEOUT"]
 
 
 class NotConnected(Exception):
@@ -115,7 +105,7 @@ async def wait_for_connection(**coros: Awaitable[None]):
     results = await asyncio.gather(*coros.values(), return_exceptions=True)
     exceptions = {}
 
-    for name, result in zip(coros, results):
+    for name, result in zip(coros, results, strict=False):
         if isinstance(result, Exception):
             exceptions[name] = result
             if not isinstance(result, NotConnected):
@@ -129,7 +119,7 @@ async def wait_for_connection(**coros: Awaitable[None]):
         raise NotConnected(exceptions)
 
 
-def get_dtype(typ: Type) -> Optional[np.dtype]:
+def get_dtype(typ: type) -> np.dtype | None:
     """Get the runtime dtype from a numpy ndarray type annotation
 
     >>> import numpy.typing as npt
@@ -144,8 +134,8 @@ def get_dtype(typ: Type) -> Optional[np.dtype]:
     return None
 
 
-def get_unique(values: Dict[str, T], types: str) -> T:
-    """If all values are the same, return that value, otherwise return TypeError
+def get_unique(values: dict[str, T], types: str) -> T:
+    """If all values are the same, return that value, otherwise raise TypeError
 
     >>> get_unique({"a": 1, "b": 1}, "integers")
     1
@@ -162,21 +152,21 @@ def get_unique(values: Dict[str, T], types: str) -> T:
 
 
 async def merge_gathered_dicts(
-    coros: Iterable[Awaitable[Dict[str, T]]],
-) -> Dict[str, T]:
+    coros: Iterable[Awaitable[dict[str, T]]],
+) -> dict[str, T]:
     """Merge dictionaries produced by a sequence of coroutines.
 
     Can be used for merging ``read()`` or ``describe``. For instance::
 
         combined_read = await merge_gathered_dicts(s.read() for s in signals)
     """
-    ret: Dict[str, T] = {}
+    ret: dict[str, T] = {}
     for result in await asyncio.gather(*coros):
         ret.update(result)
     return ret
 
 
-async def gather_list(coros: Iterable[Awaitable[T]]) -> List[T]:
+async def gather_list(coros: Iterable[Awaitable[T]]) -> list[T]:
     return await asyncio.gather(*coros)
 
 
@@ -195,3 +185,9 @@ def in_micros(t: float) -> int:
     if t < 0:
         raise ValueError(f"Expected a positive time in seconds, got {t!r}")
     return int(np.ceil(t * 1e6))
+
+
+def is_pydantic_model(datatype) -> bool:
+    while origin := get_origin(datatype):
+        datatype = origin
+    return datatype and issubclass(datatype, BaseModel)

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,12 +1,13 @@
 import asyncio
-from typing import Literal, Optional, Tuple
+from typing import Literal
 
 from ophyd_async.core import (
-    AsyncStatus,
     DetectorControl,
     DetectorTrigger,
+    TriggerInfo,
     set_and_wait_for_value,
 )
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
@@ -23,24 +24,20 @@ class AravisController(DetectorControl):
     def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
         self._drv = driver
         self.gpio_number = gpio_number
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return _HIGHEST_POSSIBLE_DEADTIME
 
-    async def arm(
-        self,
-        num: int = 0,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
-        if num == 0:
+    async def prepare(self, trigger_info: TriggerInfo):
+        if (num := trigger_info.number) == 0:
             image_mode = adcore.ImageMode.continuous
         else:
             image_mode = adcore.ImageMode.multiple
-        if exposure is not None:
+        if (exposure := trigger_info.livetime) is not None:
             await self._drv.acquire_time.set(exposure)
 
-        trigger_mode, trigger_source = self._get_trigger_info(trigger)
+        trigger_mode, trigger_source = self._get_trigger_info(trigger_info.trigger)
         # trigger mode must be set first and on it's own!
         await self._drv.trigger_mode.set(trigger_mode)
 
@@ -50,12 +47,16 @@ class AravisController(DetectorControl):
             self._drv.image_mode.set(image_mode),
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, True)
-        return status
+    async def arm(self):
+        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     def _get_trigger_info(
         self, trigger: DetectorTrigger
-    ) -> Tuple[AravisTriggerMode, AravisTriggerSource]:
+    ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
         supported_trigger_types = (
             DetectorTrigger.constant_gate,
             DetectorTrigger.edge_trigger,
@@ -70,7 +71,7 @@ class AravisController(DetectorControl):
         if trigger == DetectorTrigger.internal:
             return AravisTriggerMode.off, "Freerun"
         else:
-            return (AravisTriggerMode.on, f"Line{self.gpio_number}")
+            return (AravisTriggerMode.on, f"Line{self.gpio_number}")  # type: ignore
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adaravis/_aravis_io.py

@@ -38,6 +38,7 @@ class AravisDriverIO(adcore.ADBaseIO):
             AravisTriggerMode, prefix + "TriggerMode"
         )
         self.trigger_source = epics_signal_rw_rbv(
-            AravisTriggerSource, prefix + "TriggerSource"
+            AravisTriggerSource,  # type: ignore
+            prefix + "TriggerSource",
         )
         super().__init__(prefix, name=name)

ophyd_async/epics/adcore/_core_io.py

@@ -135,4 +135,6 @@ class NDFileHDFIO(NDPluginBaseIO):
         self.array_size0 = epics_signal_r(int, prefix + "ArraySize0")
         self.array_size1 = epics_signal_r(int, prefix + "ArraySize1")
         self.create_directory = epics_signal_rw(int, prefix + "CreateDirectory")
+        self.num_frames_chunks = epics_signal_r(int, prefix + "NumFramesChunks_RBV")
+        self.chunk_size_auto = epics_signal_rw_rbv(bool, prefix + "ChunkSizeAuto")
         super().__init__(prefix, name)

ophyd_async/epics/adcore/_core_logic.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import FrozenSet, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -14,7 +13,7 @@ from ._core_io import ADBaseIO, DetectorState
 
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
-DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
+DEFAULT_GOOD_STATES: frozenset[DetectorState] = frozenset(
     [DetectorState.Idle, DetectorState.Aborted]
 )
 
@@ -66,7 +65,7 @@ async def set_exposure_time_and_acquire_period_if_supplied(
 
 async def start_acquiring_driver_and_ensure_status(
     driver: ADBaseIO,
-    good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
+    good_states: frozenset[DetectorState] = frozenset(DEFAULT_GOOD_STATES),
     timeout: float = DEFAULT_TIMEOUT,
 ) -> AsyncStatus:
     """

ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,9 +1,10 @@
 import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
 from pathlib import Path
-from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 from xml.etree import ElementTree as ET
 
-from bluesky.protocols import DataKey, Hints, StreamAsset
+from bluesky.protocols import Hints, StreamAsset
+from event_model import DataKey
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -42,19 +43,22 @@ class ADHDFWriter(DetectorWriter):
         self._dataset_describer = dataset_describer
 
         self._plugins = plugins
-        self._capture_status: Optional[AsyncStatus] = None
-        self._datasets: List[HDFDataset] = []
-        self._file: Optional[HDFFile] = None
+        self._capture_status: AsyncStatus | None = None
+        self._datasets: list[HDFDataset] = []
+        self._file: HDFFile | None = None
         self._multiplier = 1
 
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         self._file = None
-        info = self._path_provider(device_name=self.hdf.name)
+        info = self._path_provider(device_name=self._name_provider())
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.
         await self.hdf.create_directory.set(info.create_dir_depth)
 
+        # Make sure we are using chunk auto-sizing
+        await asyncio.gather(self.hdf.chunk_size_auto.set(True))
+
         await asyncio.gather(
             self.hdf.num_extra_dims.set(0),
             self.hdf.lazy_open.set(True),
@@ -83,6 +87,9 @@ class ADHDFWriter(DetectorWriter):
         self._multiplier = multiplier
         outer_shape = (multiplier,) if multiplier > 1 else ()
 
+        # Determine number of frames that will be saved per HDF chunk
+        frames_per_chunk = await self.hdf.num_frames_chunks.get_value()
+
         # Add the main data
         self._datasets = [
             HDFDataset(
@@ -91,6 +98,7 @@ class ADHDFWriter(DetectorWriter):
                 shape=detector_shape,
                 dtype_numpy=np_dtype,
                 multiplier=multiplier,
+                chunk_shape=(frames_per_chunk, *detector_shape),
             )
         ]
         # And all the scalar datasets
@@ -117,6 +125,9 @@ class ADHDFWriter(DetectorWriter):
                             (),
                             np_datatype,
                             multiplier,
+                            # NDAttributes appear to always be configured with
+                            # this chunk size
+                            chunk_shape=(16384,),
                         )
                     )
 
@@ -125,7 +136,7 @@ class ADHDFWriter(DetectorWriter):
                 source=self.hdf.full_file_name.source,
                 shape=outer_shape + tuple(ds.shape),
                 dtype="array" if ds.shape else "number",
-                dtype_numpy=ds.dtype_numpy,
+                dtype_numpy=ds.dtype_numpy,  # type: ignore
                 external="STREAM:",
             )
             for ds in self._datasets

ophyd_async/epics/adcore/_single_trigger.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Sequence
+from collections.abc import Sequence
 
 from bluesky.protocols import Triggerable
 

ophyd_async/epics/adcore/_utils.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
 
 from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
 from ophyd_async.core._signal import SignalR
@@ -51,8 +50,8 @@ def convert_pv_dtype_to_np(datatype: str) -> str:
     else:
         try:
             np_datatype = convert_ad_dtype_to_np(_pvattribute_to_ad_datatype[datatype])
-        except KeyError:
-            raise ValueError(f"Invalid dbr type {datatype}")
+        except KeyError as e:
+            raise ValueError(f"Invalid dbr type {datatype}") from e
     return np_datatype
 
 
@@ -69,8 +68,8 @@ def convert_param_dtype_to_np(datatype: str) -> str:
             np_datatype = convert_ad_dtype_to_np(
                 _paramattribute_to_ad_datatype[datatype]
             )
-        except KeyError:
-            raise ValueError(f"Invalid datatype {datatype}")
+        except KeyError as e:
+            raise ValueError(f"Invalid datatype {datatype}") from e
     return np_datatype
 
 
@@ -126,7 +125,7 @@ async def stop_busy_record(
     signal: SignalRW[T],
     value: T,
     timeout: float = DEFAULT_TIMEOUT,
-    status_timeout: Optional[float] = None,
+    status_timeout: float | None = None,
 ) -> None:
     await signal.set(value, wait=False, timeout=status_timeout)
     await wait_for_value(signal, value, timeout=timeout)

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -1,7 +1,8 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorControl, DetectorTrigger
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
@@ -20,27 +21,31 @@ class KinetixController(DetectorControl):
         driver: KinetixDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger]),
-            self._drv.num_images.set(num),
+            self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]),
+            self._drv.num_images.set(trigger_info.number),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
-        if exposure is not None and trigger not in [
+        if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.variable_gate,
             DetectorTrigger.constant_gate,
         ]:
-            await self._drv.acquire_time.set(exposure)
-        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
+            await self._drv.acquire_time.set(trigger_info.livetime)
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self._drv
+        )
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,13 +1,13 @@
 import asyncio
-from typing import Optional
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorControl,
     DetectorTrigger,
     wait_for_value,
 )
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
@@ -27,29 +27,29 @@ class PilatusController(DetectorControl):
     ) -> None:
         self._drv = driver
         self._readout_time = readout_time
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return self._readout_time
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
-        if exposure is not None:
+    async def prepare(self, trigger_info: TriggerInfo):
+        if trigger_info.livetime is not None:
             await adcore.set_exposure_time_and_acquire_period_if_supplied(
-                self, self._drv, exposure
+                self, self._drv, trigger_info.livetime
             )
         await asyncio.gather(
-            self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
-            self._drv.num_images.set(999_999 if num == 0 else num),
+            self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self._drv.num_images.set(
+                999_999 if trigger_info.number == 0 else trigger_info.number
+            ),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
 
+    async def arm(self):
         # Standard arm the detector and wait for the acquire PV to be True
-        idle_status = await adcore.start_acquiring_driver_and_ensure_status(self._drv)
-
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self._drv
+        )
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
@@ -59,7 +59,9 @@ class PilatusController(DetectorControl):
             timeout=DEFAULT_TIMEOUT,
         )
 
-        return idle_status
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from ophyd_async.core import PathProvider, SignalR, StandardDetector
 from ophyd_async.epics import adcore
@@ -12,14 +12,15 @@ class SimDetector(StandardDetector):
 
     def __init__(
         self,
-        drv: adcore.ADBaseIO,
-        hdf: adcore.NDFileHDFIO,
+        prefix: str,
         path_provider: PathProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = drv
-        self.hdf = hdf
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             SimController(self.drv),

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -1,12 +1,12 @@
 import asyncio
-from typing import Optional, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorControl,
     DetectorTrigger,
 )
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 
@@ -14,32 +14,37 @@ class SimController(DetectorControl):
     def __init__(
         self,
         driver: adcore.ADBaseIO,
-        good_states: Set[adcore.DetectorState] = set(adcore.DEFAULT_GOOD_STATES),
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
+        self.frame_timeout: float
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.002
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         assert (
-            trigger == DetectorTrigger.internal
+            trigger_info.trigger == DetectorTrigger.internal
         ), "fly scanning (i.e. external triggering) is not supported for this device"
-        frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        self.frame_timeout = (
+            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        )
         await asyncio.gather(
-            self.driver.num_images.set(num),
+            self.driver.num_images.set(trigger_info.number),
             self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
-        return await adcore.start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states, timeout=frame_timeout
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=self.frame_timeout
         )
 
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,7 +1,8 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorControl, DetectorTrigger
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
@@ -27,32 +28,36 @@ class VimbaController(DetectorControl):
         driver: VimbaDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
-            self._drv.num_images.set(num),
+            self._drv.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
+            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
+            self._drv.num_images.set(trigger_info.number),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
-        if exposure is not None and trigger not in [
+        if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.variable_gate,
             DetectorTrigger.constant_gate,
         ]:
-            await self._drv.acquire_time.set(exposure)
-        if trigger != DetectorTrigger.internal:
+            await self._drv.acquire_time.set(trigger_info.livetime)
+        if trigger_info.trigger != DetectorTrigger.internal:
             self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
             self._drv.trigger_source.set(VimbaTriggerSource.freerun)
-        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self._drv
+        )
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/demo/_mover.py

@@ -4,10 +4,10 @@ import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     Device,
     HintedSignal,
@@ -44,9 +44,8 @@ class Mover(StandardReadable, Movable, Stoppable):
         self.readback.set_name(name)
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         old_position, units, precision, velocity = await asyncio.gather(
             self.setpoint.get_value(),
@@ -54,7 +53,7 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout == CALCULATE_TIMEOUT:
             assert velocity > 0, "Mover has zero velocity"
             timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
         # Make an Event that will be set on completion, and a Status that will

ophyd_async/epics/demo/sensor.db

@@ -17,4 +17,3 @@ record(calc, "$(P)Value") {
     field(EGU,  "$(EGU=cts/s)")
     field(PREC, "$(PREC=3)")
 }
-