ophyd-async 0.10.0a2__py3-none-any.whl → 0.10.0a4__py3-none-any.whl

ophyd_async/epics/core/_util.py

@@ -1,16 +1,20 @@
-from collections.abc import Sequence
-from typing import Any, get_args, get_origin
+from collections.abc import Mapping, Sequence
+from typing import Any, TypeVar, get_args, get_origin
 
 import numpy as np
 
 from ophyd_async.core import (
     SignalBackend,
     SignalDatatypeT,
+    StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     get_dtype,
     get_enum_cls,
 )
 
+T = TypeVar("T")
+
 
 def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
     """Split PV into record name and field."""
@@ -23,26 +27,30 @@ def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
 
 def get_supported_values(
     pv: str,
-    datatype: type,
+    datatype: type[T],
     pv_choices: Sequence[str],
-) -> dict[str, str]:
+) -> Mapping[str, T | str]:
     enum_cls = get_enum_cls(datatype)
     if not enum_cls:
         raise TypeError(f"{datatype} is not an Enum")
     choices = [v.value for v in enum_cls]
     error_msg = f"{pv} has choices {pv_choices}, but {datatype} requested {choices} "
-    if issubclass(enum_cls, SubsetEnum):
+    if issubclass(enum_cls, StrictEnum):
+        if set(choices) != set(pv_choices):
+            raise TypeError(error_msg + "to be strictly equal to them.")
+    elif issubclass(enum_cls, SubsetEnum):
         if not set(choices).issubset(pv_choices):
             raise TypeError(error_msg + "to be a subset of them.")
+    elif issubclass(enum_cls, SupersetEnum):
+        if not set(pv_choices).issubset(choices):
+            raise TypeError(error_msg + "to be a superset of them.")
     else:
-        if set(choices) != set(pv_choices):
-            raise TypeError(error_msg + "to be strictly equal to them.")
-
-    # Take order from the pv choices
-    supported_values = {x: x for x in pv_choices}
-    # But override those that we specify via the datatype
-    for v in enum_cls:
-        supported_values[v.value] = v
+        raise TypeError(f"{datatype} is not a StrictEnum, SubsetEnum, or SupersetEnum")
+    # Create a map from the string value to the enum instance
+    # For StrictEnum and SupersetEnum, all values here will be enum values
+    # For SubsetEnum, only the values in choices will be enum values, the rest will be
+    # strings
+    supported_values = {x: enum_cls(x) for x in pv_choices}
     return supported_values
 
 

ophyd_async/epics/eiger/__init__.py

@@ -1,5 +1,3 @@
-from ._eiger import EigerDetector, EigerTriggerInfo
-from ._eiger_controller import EigerController
-from ._eiger_io import EigerDriverIO
+from ._odin_io import Odin, OdinWriter, Writing
 
-__all__ = ["EigerDetector", "EigerController", "EigerDriverIO", "EigerTriggerInfo"]
+__all__ = ["Odin", "OdinWriter", "Writing"]

ophyd_async/epics/eiger/_odin_io.py

@@ -2,17 +2,20 @@ import asyncio
 from collections.abc import AsyncGenerator, AsyncIterator
 
 from bluesky.protocols import StreamAsset
-from event_model import DataKey
+from event_model import DataKey  # type: ignore
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     DetectorWriter,
     Device,
     DeviceVector,
-    NameProvider,
     PathProvider,
+    Reference,
+    SignalR,
     StrictEnum,
     observe_value,
     set_and_wait_for_value,
+    wait_for_value,
 )
 from ophyd_async.epics.core import (
     epics_signal_r,
@@ -22,44 +25,53 @@ from ophyd_async.epics.core import (
 
 
 class Writing(StrictEnum):
-    ON = "ON"
-    OFF = "OFF"
+    CAPTURE = "Capture"
+    DONE = "Done"
 
 
 class OdinNode(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.writing = epics_signal_r(Writing, f"{prefix}HDF:Writing")
-        self.connected = epics_signal_r(bool, f"{prefix}Connected")
+        self.writing = epics_signal_r(str, f"{prefix}Writing_RBV")
+        self.frames_dropped = epics_signal_r(int, f"{prefix}FramesDropped_RBV")
+        self.frames_time_out = epics_signal_r(int, f"{prefix}FramesTimedOut_RBV")
+        self.error_status = epics_signal_r(str, f"{prefix}FPErrorState_RBV")
+        self.fp_initialised = epics_signal_r(int, f"{prefix}FPProcessConnected_RBV")
+        self.fr_initialised = epics_signal_r(int, f"{prefix}FRProcessConnected_RBV")
+        self.num_captured = epics_signal_r(int, f"{prefix}NumCaptured_RBV")
+        self.clear_errors = epics_signal_rw(int, f"{prefix}FPClearErrors")
+        self.error_message = epics_signal_rw(str, f"{prefix}FPErrorMessage_RBV")
 
         super().__init__(name)
 
 
 class Odin(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.nodes = DeviceVector({i: OdinNode(f"{prefix}FP{i}:") for i in range(4)})
-
-        self.capture = epics_signal_rw(
-            Writing, f"{prefix}Writing", f"{prefix}ConfigHdfWrite"
+        self.nodes = DeviceVector(
+            {i: OdinNode(f"{prefix[:-1]}{i + 1}:") for i in range(4)}
         )
-        self.num_captured = epics_signal_r(int, f"{prefix}FramesWritten")
-        self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}ConfigHdfFrames")
 
-        self.start_timeout = epics_signal_rw_rbv(int, f"{prefix}TimeoutTimerPeriod")
+        self.capture = epics_signal_rw(Writing, f"{prefix}Capture")
+        self.capture_rbv = epics_signal_r(str, prefix + "Capture_RBV")
+        self.num_captured = epics_signal_r(int, f"{prefix}NumCaptured_RBV")
+        self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}NumCapture")
 
-        self.image_height = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims0")
-        self.image_width = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims1")
+        self.start_timeout = epics_signal_rw(str, f"{prefix}StartTimeout")
+        self.timeout_active_rbv = epics_signal_r(str, f"{prefix}TimeoutActive_RBV")
 
-        self.num_row_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks1")
-        self.num_col_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks2")
+        self.image_height = epics_signal_rw_rbv(int, f"{prefix}ImageHeight")
+        self.image_width = epics_signal_rw_rbv(int, f"{prefix}ImageWidth")
 
-        self.file_path = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePath")
-        self.file_name = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePrefix")
+        self.num_row_chunks = epics_signal_rw_rbv(int, f"{prefix}NumRowChunks")
+        self.num_col_chunks = epics_signal_rw_rbv(int, f"{prefix}NumColChunks")
 
-        self.acquisition_id = epics_signal_rw_rbv(
-            str, f"{prefix}ConfigHdfAcquisitionId"
-        )
+        self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
+        self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
 
-        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DatasetDataDatatype")
+        self.num_frames_chunks = epics_signal_rw(int, prefix + "NumFramesChunks")
+        self.meta_active = epics_signal_r(str, prefix + "META:AcquisitionActive_RBV")
+        self.meta_writing = epics_signal_r(str, prefix + "META:Writing_RBV")
+
+        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DataType")
 
         super().__init__(name)
 
@@ -68,27 +80,35 @@ class OdinWriter(DetectorWriter):
     def __init__(
         self,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         odin_driver: Odin,
+        eiger_bit_depth: SignalR[int],
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
-        self._name_provider = name_provider
+        self._eiger_bit_depth = Reference(eiger_bit_depth)
         super().__init__()
 
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
-        info = self._path_provider(device_name=self._name_provider())
+    async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
+        info = self._path_provider(device_name=name)
+        self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
             self._drv.file_path.set(str(info.directory_path)),
             self._drv.file_name.set(info.filename),
-            self._drv.data_type.set(
-                "uint16"
-            ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
+            self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
             self._drv.num_to_capture.set(0),
         )
 
-        await self._drv.capture.set(Writing.ON)
+        await wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT)
+
+        await self._drv.capture.set(
+            Writing.CAPTURE, wait=False
+        )  # TODO: Investigate why we do not get a put callback when setting capture pv https://github.com/bluesky/ophyd-async/issues/866
+
+        await asyncio.gather(
+            wait_for_value(self._drv.capture_rbv, "Capturing", timeout=DEFAULT_TIMEOUT),
+            wait_for_value(self._drv.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT),
+        )
 
         return await self._describe()
 
@@ -100,7 +120,7 @@ class OdinWriter(DetectorWriter):
         return {
             "data": DataKey(
                 source=self._drv.file_name.source,
-                shape=list(data_shape),
+                shape=[self._exposures_per_event, *data_shape],
                 dtype="array",
                 # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
                 dtype_numpy="<u2",
@@ -112,14 +132,16 @@ class OdinWriter(DetectorWriter):
         self, timeout: float
     ) -> AsyncGenerator[int, None]:
         async for num_captured in observe_value(self._drv.num_captured, timeout):
-            yield num_captured
+            yield num_captured // self._exposures_per_event
 
     async def get_indices_written(self) -> int:
-        return await self._drv.num_captured.get_value()
+        return await self._drv.num_captured.get_value() // self._exposures_per_event
 
-    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+    def collect_stream_docs(
+        self, name: str, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
         # TODO: Correctly return stream https://github.com/bluesky/ophyd-async/issues/530
         raise NotImplementedError()
 
     async def close(self) -> None:
-        await set_and_wait_for_value(self._drv.capture, Writing.OFF)
+        await set_and_wait_for_value(self._drv.capture, Writing.DONE)

ophyd_async/epics/motor.py

@@ -260,10 +260,11 @@ class Motor(
             (await self.acceleration_time.get_value()) * fly_velocity * 0.5
         )
 
-        self._fly_completed_position = end_position + run_up_distance
+        direction = 1 if end_position > start_position else -1
+        self._fly_completed_position = end_position + (run_up_distance * direction)
 
         # Prepared position not used after prepare, so no need to store in self
-        fly_prepared_position = start_position - run_up_distance
+        fly_prepared_position = start_position - (run_up_distance * direction)
 
         motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
             self.low_limit_travel.get_value(),

ophyd_async/epics/testing/_example_ioc.py

@@ -48,6 +48,7 @@ class EpicsTestCaDevice(EpicsDevice):
     longstr: A[SignalRW[str], PvSuffix("longstr")]
     longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
     a_bool: A[SignalRW[bool], PvSuffix("bool")]
+    slowseq: A[SignalRW[int], PvSuffix("slowseq")]
     enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
     enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
     subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]

ophyd_async/epics/testing/test_records.db

@@ -112,6 +112,11 @@ record(mbbo, "$(device)enum_str_fallback") {
   field(PINI, "YES")
 }
 
+record(seq, "$(device)slowseq") {
+  field(DLY1, "0.5")
+  field(LNK1, "$(device)slowseq.DESC")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")

ophyd_async/fastcs/eiger/__init__.py

@@ -0,0 +1,13 @@
+from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDetectorIO, EigerDriverIO, EigerMonitorIO, EigerStreamIO
+
+__all__ = [
+    "EigerDetector",
+    "EigerController",
+    "EigerDriverIO",
+    "EigerTriggerInfo",
+    "EigerDetectorIO",
+    "EigerMonitorIO",
+    "EigerStreamIO",
+]

ophyd_async/{epics → fastcs}/eiger/_eiger.py

@@ -1,10 +1,15 @@
 from pydantic import Field
 
-from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector, TriggerInfo
+from ophyd_async.core import (
+    AsyncStatus,
+    PathProvider,
+    StandardDetector,
+    TriggerInfo,
+)
+from ophyd_async.epics.eiger import Odin, OdinWriter
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO
-from ._odin_io import Odin, OdinWriter
 
 
 class EigerTriggerInfo(TriggerInfo):
@@ -15,22 +20,26 @@ class EigerDetector(StandardDetector):
     """Ophyd-async implementation of an Eiger Detector."""
 
     _controller: EigerController
-    _writer: Odin
+    _writer: OdinWriter
 
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="-EA-EIGER-01:",
-        hdf_suffix="-EA-ODIN-01:",
+        hdf_suffix="-EA-EIGER-01:OD:",
         name="",
     ):
         self.drv = EigerDriverIO(prefix + drv_suffix)
-        self.odin = Odin(prefix + hdf_suffix + "FP:")
+        self.odin = Odin(prefix + hdf_suffix)
 
         super().__init__(
             EigerController(self.drv),
-            OdinWriter(path_provider, lambda: self.name, self.odin),
+            OdinWriter(
+                path_provider,
+                self.odin,
+                self.drv.detector.bit_depth_readout,
+            ),
             name=name,
         )
 

ophyd_async/{epics → fastcs}/eiger/_eiger_controller.py

@@ -2,11 +2,10 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
-    set_and_wait_for_other_value,
+    wait_for_value,
 )
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
@@ -20,59 +19,50 @@ EIGER_TRIGGER_MODE_MAP = {
 
 
 class EigerController(DetectorController):
-    """Controller for the Eiger detector."""
-
     def __init__(
         self,
         driver: EigerDriverIO,
     ) -> None:
         self._drv = driver
-        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
         return 0.0001
 
     async def set_energy(self, energy: float, tolerance: float = 0.1):
-        """Change photon energy if outside tolerance.
+        """Set photon energy."""
+        """Changing photon energy takes some time so only do so if the current energy is
+        outside the tolerance."""
 
-        It takes some time so don't do it unless it is outside tolerance.
-        """
-        current_energy = await self._drv.photon_energy.get_value()
+        current_energy = await self._drv.detector.photon_energy.get_value()
         if abs(current_energy - energy) > tolerance:
-            await self._drv.photon_energy.set(energy)
+            await self._drv.detector.photon_energy.set(energy)
 
     async def prepare(self, trigger_info: TriggerInfo):
         coros = [
-            self._drv.trigger_mode.set(
+            self._drv.detector.trigger_mode.set(
                 EIGER_TRIGGER_MODE_MAP[trigger_info.trigger].value
             ),
-            self._drv.num_images.set(trigger_info.total_number_of_triggers),
+            self._drv.detector.nimages.set(trigger_info.total_number_of_exposures),
         ]
         if trigger_info.livetime is not None:
             coros.extend(
                 [
-                    self._drv.acquire_time.set(trigger_info.livetime),
-                    self._drv.acquire_period.set(trigger_info.livetime),
+                    self._drv.detector.count_time.set(trigger_info.livetime),
+                    self._drv.detector.frame_time.set(trigger_info.livetime),
                 ]
             )
+
         await asyncio.gather(*coros)
 
     async def arm(self):
-        # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
-        self._arm_status = await set_and_wait_for_other_value(
-            self._drv.arm,
-            1,
-            self._drv.state,
-            "ready",
-            timeout=DEFAULT_TIMEOUT,
-            wait_for_set_completion=False,
-        )
+        # NOTE: This will return immedietly on FastCS 0.8.0,
+        # but will return after the Eiger has completed arming in 0.9.0.
+        # https://github.com/DiamondLightSource/FastCS/pull/141
+        await self._drv.detector.arm.trigger(timeout=DEFAULT_TIMEOUT)
 
     async def wait_for_idle(self):
-        if self._arm_status and not self._arm_status.done:
-            await self._arm_status
-        self._arm_status = None
+        await wait_for_value(self._drv.detector.state, "idle", timeout=DEFAULT_TIMEOUT)
 
     async def disarm(self):
-        await self._drv.disarm.set(1)
+        await self._drv.detector.disarm.trigger()

ophyd_async/fastcs/eiger/_eiger_io.py

@@ -0,0 +1,54 @@
+from ophyd_async.core import (
+    Device,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StrictEnum,
+)
+from ophyd_async.fastcs.core import fastcs_connector
+
+
+class EigerTriggerMode(StrictEnum):
+    INTERNAL = "ints"
+    EDGE = "exts"
+    GATE = "exte"
+
+
+class EigerMonitorIO(Device):
+    pass
+
+
+class EigerStreamIO(Device):
+    pass
+
+
+class EigerDetectorIO(Device):
+    bit_depth_readout: SignalR[int]
+    state: SignalR[str]
+    count_time: SignalRW[float]
+    frame_time: SignalRW[float]
+    nimages: SignalRW[int]
+    nexpi: SignalRW[int]
+    trigger_mode: SignalRW[str]
+    roi_mode: SignalRW[str]
+    photon_energy: SignalRW[float]
+    beam_center_x: SignalRW[float]
+    beam_center_y: SignalRW[float]
+    detector_distance: SignalRW[float]
+    omega_start: SignalRW[float]
+    omega_increment: SignalRW[float]
+    arm: SignalX
+    disarm: SignalX
+    trigger: SignalX
+
+
+class EigerDriverIO(Device):
+    """Contains signals for handling IO on the Eiger detector."""
+
+    stale_parameters: SignalR[bool]
+    monitor: EigerMonitorIO
+    stream: EigerStreamIO
+    detector: EigerDetectorIO
+
+    def __init__(self, uri: str, name: str = ""):
+        super().__init__(name=name, connector=fastcs_connector(self, uri))

ophyd_async/fastcs/panda/_block.py

@@ -38,6 +38,8 @@ class PulseBlock(Device):
     """Used for configuring pulses in the PandA."""
 
     delay: SignalRW[float]
+    pulses: SignalRW[int]
+    step: SignalRW[float]
     width: SignalRW[float]
 
 

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -30,7 +30,6 @@ class HDFPanda(
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
             path_provider=path_provider,
-            name_provider=lambda: name,
             panda_data_block=self.data,
         )
         super().__init__(

ophyd_async/fastcs/panda/_writer.py

@@ -10,7 +10,6 @@ from ophyd_async.core import (
     DetectorWriter,
     HDFDatasetDescription,
     HDFDocumentComposer,
-    NameProvider,
     PathProvider,
     observe_value,
     wait_for_value,
@@ -25,24 +24,22 @@ class PandaHDFWriter(DetectorWriter):
     def __init__(
         self,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         panda_data_block: DataBlock,
     ) -> None:
         self.panda_data_block = panda_data_block
         self._path_provider = path_provider
-        self._name_provider = name_provider
         self._datasets: list[HDFDatasetDescription] = []
         self._composer: HDFDocumentComposer | None = None
-        self._multiplier = 1
 
     # Triggered on PCAP arm
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
         """Retrieve and get descriptor of all PandA signals marked for capture."""
+        self._exposures_per_event = exposures_per_event
         # Ensure flushes are immediate
         await self.panda_data_block.flush_period.set(0)
 
         self._composer = None
-        info = self._path_provider(device_name=self._name_provider())
+        info = self._path_provider(device_name=name)
 
         # Set create dir depth first to guarantee that callback when setting
         # directory path has correct value
@@ -66,21 +63,19 @@ class PandaHDFWriter(DetectorWriter):
 
         # Wait for it to start, stashing the status that tells us when it finishes
         await self.panda_data_block.capture.set(True)
-        if multiplier > 1:
-            raise ValueError(
-                "All PandA datasets should be scalar, multiplier should be 1"
-            )
 
-        return await self._describe()
+        return await self._describe(name)
 
-    async def _describe(self) -> dict[str, DataKey]:
+    async def _describe(self, name: str) -> dict[str, DataKey]:
         """Return a describe based on the datasets PV."""
-        await self._update_datasets()
+        await self._update_datasets(name)
         describe = {
             ds.data_key: DataKey(
                 source=self.panda_data_block.hdf_directory.source,
                 shape=list(ds.shape),
-                dtype="number",
+                dtype="array"
+                if self._exposures_per_event > 1 or len(ds.shape) > 1
+                else "number",
                 # PandA data should always be written as Float64
                 dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
@@ -89,7 +84,7 @@ class PandaHDFWriter(DetectorWriter):
         }
         return describe
 
-    async def _update_datasets(self) -> None:
+    async def _update_datasets(self, name: str) -> None:
         # Load data from the datasets PV on the panda, update internal
         # representation of datasets that the panda will write.
         capture_table = await self.panda_data_block.datasets.get_value()
@@ -99,9 +94,10 @@ class PandaHDFWriter(DetectorWriter):
             HDFDatasetDescription(
                 data_key=dataset_name,
                 dataset="/" + dataset_name,
-                shape=(),
+                shape=(self._exposures_per_event,)
+                if self._exposures_per_event > 1
+                else (),
                 dtype_numpy="<f8",
-                multiplier=1,
                 chunk_shape=(1024,),
             )
             for dataset_name in capture_table.name
@@ -111,7 +107,7 @@ class PandaHDFWriter(DetectorWriter):
         # i.e. no stream resources will be generated
         if len(self._datasets) == 0:
             self.panda_data_block.log.warning(
-                f"PandA {self._name_provider()} DATASETS table is empty! "
+                f"PandA {name} DATASETS table is empty! "
                 "No stream resource docs will be generated. "
                 "Make sure captured positions have their corresponding "
                 "*:DATASET PV set to a scientifically relevant name."
@@ -121,7 +117,9 @@ class PandaHDFWriter(DetectorWriter):
     # StandardDetector behavior
     async def wait_for_index(self, index: int, timeout: float | None = DEFAULT_TIMEOUT):
         def matcher(value: int) -> bool:
-            return value >= index
+            # Index is already divided by exposures_per_event, so we need to also
+            # divide the value by exposures_per_event to get the correct index
+            return value // self._exposures_per_event >= index
 
         matcher.__name__ = f"index_at_least_{index}"
         await wait_for_value(
@@ -129,7 +127,10 @@ class PandaHDFWriter(DetectorWriter):
         )
 
     async def get_indices_written(self) -> int:
-        return await self.panda_data_block.num_captured.get_value()
+        return (
+            await self.panda_data_block.num_captured.get_value()
+            // self._exposures_per_event
+        )
 
     async def observe_indices_written(
         self, timeout: float
@@ -138,10 +139,10 @@ class PandaHDFWriter(DetectorWriter):
         async for num_captured in observe_value(
             self.panda_data_block.num_captured, timeout
         ):
-            yield num_captured // self._multiplier
+            yield num_captured // self._exposures_per_event
 
     async def collect_stream_docs(
-        self, indices_written: int
+        self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
         if indices_written:

ophyd_async/plan_stubs/_fly.py

@@ -60,11 +60,11 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     deadtime = max(det._controller.get_deadtime(exposure) for det in detectors)  # noqa: SLF001
 
     trigger_info = TriggerInfo(
-        number_of_triggers=number_of_frames * repeats,
+        number_of_events=number_of_frames * repeats,
         trigger=DetectorTrigger.CONSTANT_GATE,
         deadtime=deadtime,
         livetime=exposure,
-        frame_timeout=frame_timeout,
+        exposure_timeout=frame_timeout,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)

ophyd_async/sim/_blob_detector.py

@@ -26,7 +26,6 @@ class SimBlobDetector(StandardDetector):
             writer=BlobDetectorWriter(
                 pattern_generator=self.pattern_generator,
                 path_provider=path_provider,
-                name_provider=lambda: self.name,
             ),
             config_sigs=config_sigs,
             name=name,