ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/epics/adcore/_core_io.py

@@ -1,33 +1,33 @@
 import asyncio
+from typing import Annotated as A
 
-from ophyd_async.core import Device, StrictEnum
-from ophyd_async.core._providers import DatasetDescriber
-from ophyd_async.epics.core import (
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_rw_rbv,
-)
+from ophyd_async.core import DatasetDescriber, SignalR, SignalRW, StrictEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
-from ._utils import ADBaseDataType, FileWriteMode, ImageMode, convert_ad_dtype_to_np
+from ._utils import ADBaseDataType, ADFileWriteMode, ADImageMode, convert_ad_dtype_to_np
 
 
-class Callback(StrictEnum):
+class ADCallbacks(StrictEnum):
     ENABLE = "Enable"
     DISABLE = "Disable"
 
 
-class NDArrayBaseIO(Device):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
-        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
-        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
-        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
-        self.data_type = epics_signal_r(ADBaseDataType, prefix + "DataType_RBV")
-        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
-        # There is no _RBV for this one
-        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
-        super().__init__(name=name)
+class NDArrayBaseIO(EpicsDevice):
+    """Class responsible for passing detector data from drivers to pluglins.
+
+    This mirrors the interface provided by ADCore/db/NDArrayBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDArray.html
+    """
+
+    unique_id: A[SignalR[int], PvSuffix("UniqueId_RBV")]
+    nd_attributes_file: A[SignalRW[str], PvSuffix("NDAttributesFile")]
+    acquire: A[SignalRW[bool], PvSuffix.rbv("Acquire")]
+    array_size_x: A[SignalR[int], PvSuffix("ArraySizeX_RBV")]
+    array_size_y: A[SignalR[int], PvSuffix("ArraySizeY_RBV")]
+    data_type: A[SignalR[ADBaseDataType], PvSuffix("DataType_RBV")]
+    array_counter: A[SignalRW[int], PvSuffix.rbv("ArrayCounter")]
+    # There is no _RBV for this one
+    wait_for_plugins: A[SignalRW[bool], PvSuffix("WaitForPlugins")]
 
 
 class ADBaseDatasetDescriber(DatasetDescriber):
@@ -46,49 +46,51 @@ class ADBaseDatasetDescriber(DatasetDescriber):
 
 
 class NDPluginBaseIO(NDArrayBaseIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
-        self.enable_callbacks = epics_signal_rw_rbv(
-            Callback, prefix + "EnableCallbacks"
-        )
-        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
-        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
-        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
-        self.queue_size = epics_signal_rw(int, prefix + "QueueSize")
-        super().__init__(prefix, name)
+    """Base class from which plugins are derived.
+
+    This mirrors the interface provided by ADCore/db/NDPluginBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginDriver.html
+    """
+
+    nd_array_port: A[SignalRW[str], PvSuffix.rbv("NDArrayPort")]
+    enable_callbacks: A[SignalRW[ADCallbacks], PvSuffix.rbv("EnableCallbacks")]
+    nd_array_address: A[SignalRW[int], PvSuffix.rbv("NDArrayAddress")]
+    array_size0: A[SignalR[int], PvSuffix("ArraySize0_RBV")]
+    array_size1: A[SignalR[int], PvSuffix("ArraySize1_RBV")]
+    queue_size: A[SignalRW[int], PvSuffix.rbv("QueueSize")]
 
 
 class NDPluginStatsIO(NDPluginBaseIO):
-    """
-    Plugin for computing statistics from an image or region of interest within an image.
-    """
+    """Plugin for computing statistics from an image or ROI within an image.
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # Basic statistics
-        self.compute_statistics = epics_signal_rw(bool, prefix + "ComputeStatistics")
-        self.bgd_width = epics_signal_rw(int, prefix + "BgdWidth")
-        self.total_array = epics_signal_rw(float, prefix + "TotalArray")
-        # Centroid statistics
-        self.compute_centroid = epics_signal_rw(bool, prefix + "ComputeCentroid")
-        self.centroid_threshold = epics_signal_rw(float, prefix + "CentroidThreshold")
-        # X and Y Profiles
-        self.compute_profiles = epics_signal_rw(bool, prefix + "ComputeProfiles")
-        self.profile_size_x = epics_signal_rw(int, prefix + "ProfileSizeX")
-        self.profile_size_y = epics_signal_rw(int, prefix + "ProfileSizeY")
-        self.cursor_x = epics_signal_rw(int, prefix + "CursorX")
-        self.cursor_y = epics_signal_rw(int, prefix + "CursorY")
-        # Array Histogram
-        self.compute_histogram = epics_signal_rw(bool, prefix + "ComputeHistogram")
-        self.hist_size = epics_signal_rw(int, prefix + "HistSize")
-        self.hist_min = epics_signal_rw(float, prefix + "HistMin")
-        self.hist_max = epics_signal_rw(float, prefix + "HistMax")
-        super().__init__(prefix, name)
-
-
-class DetectorState(StrictEnum):
+    This mirrors the interface provided by ADCore/db/NDStats.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginStats.html
     """
-    Default set of states of an AreaDetector driver.
-    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
+
+    # Basic statistics
+    compute_statistics: A[SignalRW[bool], PvSuffix.rbv("ComputeStatistics")]
+    bgd_width: A[SignalRW[int], PvSuffix.rbv("BgdWidth")]
+    total_array: A[SignalRW[float], PvSuffix.rbv("TotalArray")]
+    # Centroid statistics
+    compute_centroid: A[SignalRW[bool], PvSuffix.rbv("ComputeCentroid")]
+    centroid_threshold: A[SignalRW[float], PvSuffix.rbv("CentroidThreshold")]
+    # X and Y Profiles
+    compute_profiles: A[SignalRW[bool], PvSuffix.rbv("ComputeProfiles")]
+    profile_size_x: A[SignalRW[int], PvSuffix.rbv("ProfileSizeX")]
+    profile_size_y: A[SignalRW[int], PvSuffix.rbv("ProfileSizeY")]
+    cursor_x: A[SignalRW[int], PvSuffix.rbv("CursorX")]
+    cursor_y: A[SignalRW[int], PvSuffix.rbv("CursorY")]
+    # Array Histogram
+    compute_histogram: A[SignalRW[bool], PvSuffix.rbv("ComputeHistogram")]
+    hist_size: A[SignalRW[int], PvSuffix.rbv("HistSize")]
+    hist_min: A[SignalRW[float], PvSuffix.rbv("HistMin")]
+    hist_max: A[SignalRW[float], PvSuffix.rbv("HistMax")]
+
+
+class ADState(StrictEnum):
+    """Default set of states of an AreaDetector driver.
+
+    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore.
     """
 
     IDLE = "Idle"
@@ -105,19 +107,20 @@ class DetectorState(StrictEnum):
 
 
 class ADBaseIO(NDArrayBaseIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # Define some signals
-        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
-        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
-        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
-        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
-        self.detector_state = epics_signal_r(
-            DetectorState, prefix + "DetectorState_RBV"
-        )
-        super().__init__(prefix, name=name)
+    """Base class from which areaDetector drivers are derived.
+
+    This mirrors the interface provided by ADCore/db/ADBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/ADDriver.html
+    """
+
+    acquire_time: A[SignalRW[float], PvSuffix.rbv("AcquireTime")]
+    acquire_period: A[SignalRW[float], PvSuffix.rbv("AcquirePeriod")]
+    num_images: A[SignalRW[int], PvSuffix.rbv("NumImages")]
+    image_mode: A[SignalRW[ADImageMode], PvSuffix.rbv("ImageMode")]
+    detector_state: A[SignalR[ADState], PvSuffix("DetectorState_RBV")]
 
 
-class Compression(StrictEnum):
+class ADCompression(StrictEnum):
     NONE = "None"
     NBIT = "N-bit"
     SZIP = "szip"
@@ -129,35 +132,57 @@ class Compression(StrictEnum):
 
 
 class NDFileIO(NDPluginBaseIO):
-    def __init__(self, prefix: str, name="") -> None:
-        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
-        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
-        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
-        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
-        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
-        self.file_number = epics_signal_rw(int, prefix + "FileNumber")
-        self.auto_increment = epics_signal_rw(bool, prefix + "AutoIncrement")
-        self.file_write_mode = epics_signal_rw_rbv(
-            FileWriteMode, prefix + "FileWriteMode"
-        )
-        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
-        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
-        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
-        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")
-        super().__init__(prefix, name)
+    """Base class from which file plugins are derived.
+
+    This mirrors the interface provided by ADCore/db/NDFile.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginFile.html
+    """
+
+    file_path: A[SignalRW[str], PvSuffix.rbv("FilePath")]
+    file_name: A[SignalRW[str], PvSuffix.rbv("FileName")]
+    file_path_exists: A[SignalR[bool], PvSuffix("FilePathExists_RBV")]
+    file_template: A[SignalRW[str], PvSuffix.rbv("FileTemplate")]
+    full_file_name: A[SignalR[str], PvSuffix("FullFileName_RBV")]
+    file_number: A[SignalRW[int], PvSuffix("FileNumber")]
+    auto_increment: A[SignalRW[bool], PvSuffix("AutoIncrement")]
+    file_write_mode: A[SignalRW[ADFileWriteMode], PvSuffix.rbv("FileWriteMode")]
+    num_capture: A[SignalRW[int], PvSuffix.rbv("NumCapture")]
+    num_captured: A[SignalR[int], PvSuffix("NumCaptured_RBV")]
+    capture: A[SignalRW[bool], PvSuffix.rbv("Capture")]
+    array_size0: A[SignalR[int], PvSuffix("ArraySize0")]
+    array_size1: A[SignalR[int], PvSuffix("ArraySize1")]
+    create_directory: A[SignalRW[int], PvSuffix("CreateDirectory")]
 
 
 class NDFileHDFIO(NDFileIO):
-    def __init__(self, prefix: str, name="") -> None:
-        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
-        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
-        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
-        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
-        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
-        self.num_frames_chunks = epics_signal_r(int, prefix + "NumFramesChunks_RBV")
-        self.chunk_size_auto = epics_signal_rw_rbv(bool, prefix + "ChunkSizeAuto")
-        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
-        super().__init__(prefix, name)
+    """Plugin for storing data in HDF5 file format.
+
+    This mirrors the interface provided by ADCore/db/NDFileHDF5.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDFileHDF5.html
+    """
+
+    position_mode: A[SignalRW[bool], PvSuffix.rbv("PositionMode")]
+    compression: A[SignalRW[ADCompression], PvSuffix.rbv("Compression")]
+    num_extra_dims: A[SignalRW[int], PvSuffix.rbv("NumExtraDims")]
+    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")]
+    chunk_size_auto: A[SignalRW[bool], PvSuffix.rbv("ChunkSizeAuto")]
+    lazy_open: A[SignalRW[bool], PvSuffix.rbv("LazyOpen")]
+
+
+class NDCBFlushOnSoftTrgMode(StrictEnum):
+    ON_NEW_IMAGE = "OnNewImage"
+    IMMEDIATELY = "Immediately"
+
+
+class NDPluginCBIO(NDPluginBaseIO):
+    pre_count: A[SignalRW[int], PvSuffix.rbv("PreCount")]
+    post_count: A[SignalRW[int], PvSuffix.rbv("PostCount")]
+    preset_trigger_count: A[SignalRW[int], PvSuffix.rbv("PresetTriggerCount")]
+    trigger: A[SignalRW[bool], PvSuffix.rbv("Trigger")]
+    capture: A[SignalRW[bool], PvSuffix.rbv("Capture")]
+    flush_on_soft_trg: A[
+        SignalRW[NDCBFlushOnSoftTrgMode], PvSuffix.rbv("FlushOnSoftTrg")
+    ]

ophyd_async/epics/adcore/_core_logic.py

@@ -10,14 +10,18 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ._core_io import ADBaseIO, DetectorState
-from ._utils import ImageMode, stop_busy_record
+from ._core_io import (
+    ADBaseIO,
+    ADCallbacks,
+    ADState,
+    NDCBFlushOnSoftTrgMode,
+    NDPluginCBIO,
+)
+from ._utils import ADImageMode, stop_busy_record
 
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
-DEFAULT_GOOD_STATES: frozenset[DetectorState] = frozenset(
-    [DetectorState.IDLE, DetectorState.ABORTED]
-)
+DEFAULT_GOOD_STATES: frozenset[ADState] = frozenset([ADState.IDLE, ADState.ABORTED])
 
 ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
 ADBaseControllerT = TypeVar("ADBaseControllerT", bound="ADBaseController")
@@ -27,7 +31,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
     def __init__(
         self,
         driver: ADBaseIOT,
-        good_states: frozenset[DetectorState] = DEFAULT_GOOD_STATES,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -46,15 +50,16 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(ImageMode.MULTIPLE),
+            self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
     async def arm(self):
         self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 
     async def wait_for_idle(self):
-        if self._arm_status:
+        if self._arm_status and not self._arm_status.done:
             await self._arm_status
+        self._arm_status = None
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
@@ -66,17 +71,16 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         exposure: float | None = None,
         timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
-        """
-        Sets the exposure time if it is not None and the acquire period to the
-        exposure time plus the deadtime. This is expected behavior for most
-        AreaDetectors, but some may require more specialized handling.
-
-        Parameters
-        ----------
-        exposure:
-            Desired exposure time, this is a noop if it is None.
-        timeout:
-            How long to wait for the exposure time and acquire period to be set.
+        """Set the exposure time and acquire period.
+
+        If exposure is not None, this sets the acquire time to the exposure time
+        and sets the acquire period to the exposure time plus the deadtime. This
+        is expected behavior for most AreaDetectors, but some may require more
+        specialized handling.
+
+        :param exposure: Desired exposure time, this is a noop if it is None.
+        :type exposure: How long to wait for the exposure time and acquire
+            period to be set.
         """
         if exposure is not None:
             full_frame_time = exposure + self.get_deadtime(exposure)
@@ -86,20 +90,16 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
             )
 
     async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
-        """
-        Start acquiring driver, raising ValueError if the detector is in a bad state.
+        """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
         This sets driver.acquire to True, and waits for it to be True up to a timeout.
         Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
         and otherwise raises a ValueError.
 
-        Returns
-        -------
-        AsyncStatus:
+        :returns AsyncStatus:
             An AsyncStatus that can be awaited to set driver.acquire to True and perform
             subsequent raising (if applicable) due to detector state.
         """
-
         status = await set_and_wait_for_value(
             self.driver.acquire,
             True,
@@ -108,8 +108,8 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         )
 
         async def complete_acquisition() -> None:
-            """NOTE: possible race condition here between the callback from
-            set_and_wait_for_value and the detector state updating."""
+            # NOTE: possible race condition here between the callback from
+            # set_and_wait_for_value and the detector state updating.
             await status
             state = await self.driver.detector_state.get_value()
             if state not in self.good_states:
@@ -119,3 +119,82 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 )
 
         return AsyncStatus(complete_acquisition())
+
+
+class ADBaseContAcqController(ADBaseController[ADBaseIO]):
+    """Continuous acquisition interface for an AreaDetector."""
+
+    def __init__(self, driver: ADBaseIO, cb_plugin: NDPluginCBIO) -> None:
+        self.cb_plugin = cb_plugin
+        super().__init__(driver)
+
+    def get_deadtime(self, exposure):
+        # For now just set this to something until we can decide how to pass this in
+        return 0.001
+
+    async def ensure_acquisition_settings_valid(
+        self, trigger_info: TriggerInfo
+    ) -> None:
+        """Ensure the trigger mode is valid for the detector."""
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            # Note that not all detectors will use the `DetectorTrigger` enum
+            raise TypeError(
+                "The continuous acq interface only supports internal triggering."
+            )
+
+        # Not all detectors allow for changing exposure times during an acquisition,
+        # so in this least-common-denominator implementation check to see if
+        # exposure time matches the current exposure time.
+        exposure_time = await self.driver.acquire_time.get_value()
+        if trigger_info.livetime is not None and trigger_info.livetime != exposure_time:
+            raise ValueError(
+                f"Detector exposure time currently set to {exposure_time}, "
+                f"but requested exposure is {trigger_info.livetime}"
+            )
+
+    async def ensure_in_continuous_acquisition_mode(self) -> None:
+        """Ensure the detector is in continuous acquisition mode."""
+        image_mode = await self.driver.image_mode.get_value()
+        acquiring = await self.driver.acquire.get_value()
+
+        if image_mode != ADImageMode.CONTINUOUS or not acquiring:
+            raise RuntimeError(
+                "Driver must be acquiring in continuous mode to use the "
+                "cont acq interface"
+            )
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        # These are broken out into seperate functions to make it easier to
+        # override them in subclasses, for example if you want `prepare` to
+        # setup the detector in continuous mode if it isn't already (for now,
+        # we assume it already is). If your detector uses different enums
+        # for `ImageMode` or `DetectorTrigger`, you should also override these.
+        await self.ensure_acquisition_settings_valid(trigger_info)
+        await self.ensure_in_continuous_acquisition_mode()
+
+        # Configure the CB plugin to collect the correct number of triggers
+        await asyncio.gather(
+            self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
+            self.cb_plugin.pre_count.set(0),
+            self.cb_plugin.post_count.set(trigger_info.total_number_of_triggers),
+            self.cb_plugin.preset_trigger_count.set(1),
+            self.cb_plugin.flush_on_soft_trg.set(NDCBFlushOnSoftTrgMode.ON_NEW_IMAGE),
+        )
+
+    async def arm(self) -> None:
+        # Start the CB plugin's capture, and cache it in the arm status attr
+        self._arm_status = await set_and_wait_for_value(
+            self.cb_plugin.capture,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+            wait_for_set_completion=False,
+        )
+
+        # Send the trigger to begin acquisition
+        await self.cb_plugin.trigger.set(True, wait=False)
+
+    async def disarm(self) -> None:
+        await stop_busy_record(self.cb_plugin.capture, False, timeout=1)
+        if self._arm_status and not self._arm_status.done:
+            await self._arm_status
+        self._arm_status = None

ophyd_async/epics/adcore/_core_writer.py

@@ -24,18 +24,20 @@ from ophyd_async.core._utils import DEFAULT_TIMEOUT
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
     ADBaseDatasetDescriber,
-    Callback,
+    ADCallbacks,
     NDArrayBaseIO,
     NDFileIO,
     NDPluginBaseIO,
 )
-from ._utils import FileWriteMode
+from ._utils import ADFileWriteMode
 
 NDFileIOT = TypeVar("NDFileIOT", bound=NDFileIO)
 ADWriterT = TypeVar("ADWriterT", bound="ADWriter")
 
 
 class ADWriter(DetectorWriter, Generic[NDFileIOT]):
+    """Common behavior for all areaDetector writers."""
+
     default_suffix: str = "FILE1:"
 
     def __init__(
@@ -92,7 +94,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
     async def begin_capture(self) -> None:
         info = self._path_provider(device_name=self._name_provider())
 
-        await self.fileio.enable_callbacks.set(Callback.ENABLE)
+        await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.
@@ -102,7 +104,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
             # See https://github.com/bluesky/ophyd-async/issues/122
             self.fileio.file_path.set(str(info.directory_path)),
             self.fileio.file_name.set(info.filename),
-            self.fileio.file_write_mode.set(FileWriteMode.STREAM),
+            self.fileio.file_write_mode.set(ADFileWriteMode.STREAM),
             # For non-HDF file writers, use AD file templating mechanism
             # for generating multi-image datasets
             self.fileio.file_template.set(
@@ -134,7 +136,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
 
         describe = {
             self._name_provider(): DataKey(
-                source=self._name_provider(),
+                source=self.fileio.full_file_name.source,
                 shape=list(frame_shape),
                 dtype="array",
                 dtype_numpy=dtype_numpy,
@@ -144,9 +146,9 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         return describe
 
     async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
+        self, timeout: float
     ) -> AsyncGenerator[int, None]:
-        """Wait until a specific index is ready to be collected"""
+        """Wait until a specific index is ready to be collected."""
         async for num_captured in observe_value(self.fileio.num_captured, timeout):
             yield num_captured // self._multiplier
 
@@ -187,6 +189,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
                         "chunk_shape": (1, *frame_shape),
                         # Include file template for reconstruction in consolidator
                         "template": file_template,
+                        "multiplier": self._multiplier,
                     },
                     uid=None,
                     validate=True,
@@ -210,9 +213,10 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         # Already done a caput callback in _capture_status, so can't do one here
         await self.fileio.capture.set(False, wait=False)
         await wait_for_value(self.fileio.capture, False, DEFAULT_TIMEOUT)
-        if self._capture_status:
+        if self._capture_status and not self._capture_status.done:
             # We kicked off an open, so wait for it to return
             await self._capture_status
+        self._capture_status = None
 
     @property
     def hints(self) -> Hints: