ophyd-async 0.3rc2__tar.gz → 0.3.1a1__tar.gz

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3rc2
+Version: 0.3.1a1
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -96,7 +96,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/README.md

@@ -5,7 +5,7 @@
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3rc2'
-__version_tuple__ = version_tuple = (0, 3)
+__version__ = version = '0.3.1a1'
+__version_tuple__ = version_tuple = (0, 3, 1)

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/core/detector.py

@@ -63,6 +63,8 @@ class TriggerInfo:
     deadtime: float
     #: What is the maximum high time of the triggers
     livetime: float
+    #: What is the maximum timeout on waiting for a frame
+    frame_timeout: float | None = None
 
 
 class DetectorControl(ABC):
@@ -162,7 +164,6 @@ class StandardDetector(
         writer: DetectorWriter,
         config_sigs: Sequence[AsyncReadable] = (),
         name: str = "",
-        writer_timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
         """
         Constructor
@@ -173,16 +174,11 @@ class StandardDetector(
             config_sigs: Signals to read when describe and read
             configuration are called. Defaults to ().
             name: Device name. Defaults to "".
-            writer_timeout: Timeout for frame writing to start, if the
-            timeout is reached, ophyd-async assumes the detector
-            has a problem and raises an error.
-            Defaults to DEFAULT_TIMEOUT.
         """
         self._controller = controller
         self._writer = writer
         self._describe: Dict[str, DataKey] = {}
         self._config_sigs = list(config_sigs)
-        self._frame_writing_timeout = writer_timeout
         # For prepare
         self._arm_status: Optional[AsyncStatus] = None
         self._trigger_info: Optional[TriggerInfo] = None
@@ -245,17 +241,21 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
+        # set default trigger_info
+        self._trigger_info = TriggerInfo(
+            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+        )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=1,
-            trigger=DetectorTrigger.internal,
+            num=self._trigger_info.num,
+            trigger=self._trigger_info.trigger,
         )
         await written_status
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
         ):
             if index >= end_observation:
                 break
@@ -309,7 +309,12 @@ class StandardDetector(
         assert self._arm_status, "Prepare not run"
         assert self._trigger_info
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            self._trigger_info.frame_timeout
+            or (
+                DEFAULT_TIMEOUT
+                + self._trigger_info.livetime
+                + self._trigger_info.deadtime
+            )
         ):
             yield WatcherUpdate(
                 name=self.name,

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/core/mock_signal_utils.py

@@ -79,8 +79,22 @@ class _SetValuesIterator:
         return next_value
 
     def __del__(self):
-        if self.require_all_consumed and self.index != len(list(self.values)):
-            raise AssertionError("Not all values have been consumed.")
+        if self.require_all_consumed:
+            # Values is cast to a list here because the user has supplied
+            # require_all_consumed=True, we can therefore assume they
+            # supplied a finite list.
+            # In the case of require_all_consumed=False, an infinite
+            # iterble is permitted
+            values = list(self.values)
+            if self.index != len(values):
+                # Report the values consumed and the values yet to be
+                # consumed
+                consumed = values[0 : self.index]
+                to_be_consumed = values[self.index :]
+                raise AssertionError(
+                    f"{self.signal.name}: {consumed} were consumed "
+                    f"but {to_be_consumed} were not consumed"
+                )
 
 
 def set_mock_values(

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/core/standard_readable.py

@@ -254,6 +254,8 @@ class HintedSignal(HasHints, AsyncReadable):
 
     @property
     def hints(self) -> Hints:
+        if self.signal.name == "":
+            return {"fields": []}
         return {"fields": [self.signal.name]}
 
     @classmethod

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Optional
 
+from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.core.detector import DetectorControl, DetectorTrigger
 from ophyd_async.epics.areadetector.drivers.ad_base import (
@@ -23,14 +24,13 @@ class PilatusController(DetectorControl):
     def __init__(
         self,
         driver: PilatusDriver,
+        readout_time: float,
     ) -> None:
         self._drv = driver
+        self._readout_time = readout_time
 
     def get_deadtime(self, exposure: float) -> float:
-        # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-        """The required minimum time difference between ExpPeriod and ExpTime
-        (readout time) is 2.28 ms"""
-        return 2.28e-3
+        return self._readout_time
 
     async def arm(
         self,
@@ -45,7 +45,20 @@ class PilatusController(DetectorControl):
             self._drv.num_images.set(999_999 if num == 0 else num),
             self._drv.image_mode.set(ImageMode.multiple),
         )
-        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+        # Standard arm the detector and wait for the acquire PV to be True
+        idle_status = await 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
+        await wait_for_value(
+            self._drv.armed_for_triggers,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+        return idle_status
 
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -1,7 +1,6 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
+from ...signal import epics_signal_r, epics_signal_rw_rbv
 from .ad_base import ADBase
 
 
@@ -18,4 +17,5 @@ class PilatusDriver(ADBase):
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
+        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/pilatus.py

@@ -1,3 +1,5 @@
+from enum import Enum
+
 from bluesky.protocols import Hints
 
 from ophyd_async.core import DirectoryProvider
@@ -11,6 +13,20 @@ from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
 from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
 
 
+#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+#: The required minimum time difference between ExpPeriod and ExpTime
+#: (readout time) is 2.28 ms
+#: We provide an option to override for newer Pilatus models
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms"""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    pilatus2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    pilatus3 = 0.95e-3
+
+
 class PilatusDetector(StandardDetector):
     """A Pilatus StandardDetector writing HDF files"""
 
@@ -21,15 +37,16 @@ class PilatusDetector(StandardDetector):
         self,
         prefix: str,
         directory_provider: DirectoryProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        drv_suffix: str = "cam1:",
+        hdf_suffix: str = "HDF1:",
+        name: str = "",
     ):
         self.drv = PilatusDriver(prefix + drv_suffix)
         self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
-            PilatusController(self.drv),
+            PilatusController(self.drv, readout_time=readout_time.value),
             HDFWriter(
                 self.hdf,
                 directory_provider,

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/panda/_hdf_panda.py

@@ -38,7 +38,6 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=DEFAULT_TIMEOUT,
         )
 
     async def connect(

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/plan_stubs/fly.py

@@ -18,6 +18,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -39,6 +40,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
+        frame_timeout=frame_timeout,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
@@ -120,6 +122,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Run a scan wth a flyer and multiple detectors.
 
@@ -144,6 +147,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
         shutter_time=shutter_time,
         repeats=repeats,
         period=period,
+        frame_timeout=frame_timeout,
     )
     # Run the fly scan
     yield from fly_and_collect(stream_name, flyer, detectors)

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async/sim/sim_pattern_generator.py

@@ -16,7 +16,6 @@ class SimPatternDetector(StandardDetector):
         path: Path,
         config_sigs: Sequence[AsyncReadable] = [],
         name: str = "sim_pattern_detector",
-        writer_timeout: float = 1,
     ) -> None:
         self.directory_provider: DirectoryProvider = StaticDirectoryProvider(path)
         self.pattern_generator = PatternGenerator()
@@ -33,5 +32,4 @@ class SimPatternDetector(StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=writer_timeout,
         )

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3rc2
+Version: 0.3.1a1
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -96,7 +96,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/core/test_flyer.py

@@ -124,13 +124,11 @@ async def detectors(RE: RunEngine) -> tuple[StandardDetector, StandardDetector]:
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_1),
         writers[0],
         name="detector_1",
-        writer_timeout=3,
     )
     detector_2: StandardDetector[Any] = StandardDetector(
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_2),
         writers[1],
         name="detector_2",
-        writer_timeout=3,
     )
 
     return (detector_1, detector_2)

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/core/test_standard_readable.py

@@ -8,7 +8,7 @@ from bluesky.protocols import HasHints
 from ophyd_async.core import ConfigSignal, HintedSignal, StandardReadable
 from ophyd_async.core.device import Device, DeviceVector
 from ophyd_async.core.mock_signal_backend import MockSignalBackend
-from ophyd_async.core.signal import SignalR
+from ophyd_async.core.signal import SignalR, soft_signal_r_and_setter
 from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
 
 
@@ -219,3 +219,14 @@ def test_standard_readable_set_readable_signals():
     assert all(isinstance(x, ConfigSignal) for x in sr._configurables)
     assert len(sr._stageables) == 1
     assert all(isinstance(x, HintedSignal) for x in sr._stageables)
+
+
+def test_standard_readable_add_children_multi_nested():
+    inner = StandardReadable()
+    outer = StandardReadable()
+    with inner.add_children_as_readables(HintedSignal):
+        inner.a, _ = soft_signal_r_and_setter(float, initial_value=5.0)
+        inner.b, _ = soft_signal_r_and_setter(float, initial_value=6.0)
+    with outer.add_children_as_readables():
+        outer.inner = inner
+    assert outer

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/epics/areadetector/test_controllers.py

@@ -2,7 +2,7 @@ from unittest.mock import patch
 
 import pytest
 
-from ophyd_async.core import DetectorTrigger, DeviceCollector
+from ophyd_async.core import DetectorTrigger, DeviceCollector, set_mock_value
 from ophyd_async.epics.areadetector.controllers import (
     ADSimController,
     PilatusController,
@@ -13,10 +13,17 @@ from ophyd_async.epics.areadetector.utils import ImageMode
 
 
 @pytest.fixture
-async def pilatus(RE) -> PilatusController:
+async def pilatus_driver(RE) -> PilatusDriver:
     async with DeviceCollector(mock=True):
         drv = PilatusDriver("DRIVER:")
-        controller = PilatusController(drv)
+
+    return drv
+
+
+@pytest.fixture
+async def pilatus(RE, pilatus_driver: PilatusDriver) -> PilatusController:
+    async with DeviceCollector(mock=True):
+        controller = PilatusController(pilatus_driver, readout_time=2.28)
 
     return controller
 
@@ -47,19 +54,22 @@ async def test_ad_controller(RE, ad: ADSimController):
     assert await driver.acquire.get_value() is False
 
 
-async def test_pilatus_controller(RE, pilatus: PilatusController):
-    with patch("ophyd_async.core.signal.wait_for_value", return_value=None):
-        await pilatus.arm(num=1, trigger=DetectorTrigger.constant_gate)
+async def test_pilatus_controller(
+    RE,
+    pilatus: PilatusController,
+    pilatus_driver: PilatusDriver,
+):
+    set_mock_value(pilatus_driver.armed_for_triggers, True)
+    status = await pilatus.arm(num=1, trigger=DetectorTrigger.constant_gate)
+    await status
 
-    driver = pilatus._drv
-    assert await driver.num_images.get_value() == 1
-    assert await driver.image_mode.get_value() == ImageMode.multiple
-    assert await driver.trigger_mode.get_value() == PilatusTriggerMode.ext_enable
-    assert await driver.acquire.get_value() is True
+    assert await pilatus_driver.num_images.get_value() == 1
+    assert await pilatus_driver.image_mode.get_value() == ImageMode.multiple
+    assert (
+        await pilatus_driver.trigger_mode.get_value() == PilatusTriggerMode.ext_enable
+    )
+    assert await pilatus_driver.acquire.get_value() is True
 
-    with patch(
-        "ophyd_async.epics.areadetector.utils.wait_for_value", return_value=None
-    ):
-        await pilatus.disarm()
+    await pilatus.disarm()
 
-    assert await driver.acquire.get_value() is False
+    assert await pilatus_driver.acquire.get_value() is False

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/epics/areadetector/test_pilatus.py

@@ -1,3 +1,6 @@
+from typing import Awaitable, Callable
+from unittest.mock import patch
+
 import pytest
 from bluesky.run_engine import RunEngine
 
@@ -9,7 +12,7 @@ from ophyd_async.core import (
     set_mock_value,
 )
 from ophyd_async.epics.areadetector.drivers.pilatus_driver import PilatusTriggerMode
-from ophyd_async.epics.areadetector.pilatus import PilatusDetector
+from ophyd_async.epics.areadetector.pilatus import PilatusDetector, PilatusReadoutTime
 
 
 @pytest.fixture
@@ -23,13 +26,25 @@ async def pilatus(
     return adpilatus
 
 
+async def test_deadtime_overridable(static_directory_provider: DirectoryProvider):
+    async with DeviceCollector(mock=True):
+        pilatus = PilatusDetector(
+            "PILATUS:",
+            static_directory_provider,
+            readout_time=PilatusReadoutTime.pilatus2,
+        )
+    pilatus_controller = pilatus.controller
+    # deadtime invariant with exposure time
+    assert pilatus_controller.get_deadtime(0) == 2.28e-3
+
+
 async def test_deadtime_invariant(
     pilatus: PilatusDetector,
 ):
     pilatus_controller = pilatus.controller
     # deadtime invariant with exposure time
-    assert pilatus_controller.get_deadtime(0) == 2.28e-3
-    assert pilatus_controller.get_deadtime(500) == 2.28e-3
+    assert pilatus_controller.get_deadtime(0) == 0.95e-3
+    assert pilatus_controller.get_deadtime(500) == 0.95e-3
 
 
 @pytest.mark.parametrize(
@@ -46,10 +61,37 @@ async def test_trigger_mode_set(
     expected_trigger_mode: PilatusTriggerMode,
 ):
     async def trigger_and_complete():
-        await pilatus.controller.arm(num=1, trigger=detector_trigger)
-        # Prevent timeouts
-        set_mock_value(pilatus.controller._drv.acquire, True)
+        set_mock_value(pilatus.drv.armed_for_triggers, True)
+        status = await pilatus.controller.arm(
+            num=1,
+            trigger=detector_trigger,
+        )
+        await status
+
+    await _trigger(pilatus, expected_trigger_mode, trigger_and_complete)
+
+
+async def test_trigger_mode_set_without_armed_pv(pilatus: PilatusDetector):
+    async def trigger_and_complete():
+        status = await pilatus.controller.arm(
+            num=1,
+            trigger=DetectorTrigger.internal,
+        )
+        await status
+
+    with patch(
+        "ophyd_async.epics.areadetector.controllers.pilatus_controller.DEFAULT_TIMEOUT",
+        0.1,
+    ):
+        with pytest.raises(TimeoutError):
+            await _trigger(pilatus, PilatusTriggerMode.internal, trigger_and_complete)
 
+
+async def _trigger(
+    pilatus: PilatusDetector,
+    expected_trigger_mode: PilatusTriggerMode,
+    trigger_and_complete: Callable[[], Awaitable],
+):
     # Default TriggerMode
     assert (await pilatus.drv.trigger_mode.get_value()) == PilatusTriggerMode.internal
 

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/epics/areadetector/test_scans.py

@@ -1,7 +1,7 @@
 import asyncio
 from pathlib import Path
 from typing import Any, Optional
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, patch
 
 import bluesky.plan_stubs as bps
 import bluesky.plans as bp
@@ -76,6 +76,7 @@ def writer(RE, tmp_path: Path) -> HDFWriter:
     )
 
 
+@patch("ophyd_async.core.detector.DEFAULT_TIMEOUT", 0.1)
 async def test_hdf_writer_fails_on_timeout_with_stepscan(
     RE: RunEngine,
     writer: HDFWriter,
@@ -83,7 +84,7 @@ async def test_hdf_writer_fails_on_timeout_with_stepscan(
 ):
     set_mock_value(writer.hdf.file_path_exists, True)
     detector: StandardDetector[Any] = StandardDetector(
-        controller, writer, name="detector", writer_timeout=0.01
+        controller, writer, name="detector"
     )
 
     with pytest.raises(Exception) as exc:
@@ -92,12 +93,13 @@ async def test_hdf_writer_fails_on_timeout_with_stepscan(
     assert isinstance(exc.value.__cause__, asyncio.TimeoutError)
 
 
+@patch("ophyd_async.core.detector.DEFAULT_TIMEOUT", 0.1)
 def test_hdf_writer_fails_on_timeout_with_flyscan(RE: RunEngine, writer: HDFWriter):
     controller = DummyController()
     set_mock_value(writer.hdf.file_path_exists, True)
 
     detector: StandardDetector[Optional[TriggerInfo]] = StandardDetector(
-        controller, writer, writer_timeout=0.01
+        controller, writer
     )
     trigger_logic = DummyTriggerLogic()
 

{ophyd_async-0.3rc2 → ophyd_async-0.3.1a1}/tests/plan_stubs/test_fly.py

@@ -40,6 +40,7 @@ class DummyWriter(DetectorWriter):
         self._file: Optional[ComposeStreamResourceBundle] = None
         self._last_emitted = 0
         self.index = 0
+        self.observe_indices_written_timeout_log = []
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         return {
@@ -54,6 +55,7 @@ class DummyWriter(DetectorWriter):
     async def observe_indices_written(
         self, timeout=DEFAULT_TIMEOUT
     ) -> AsyncGenerator[int, None]:
+        self.observe_indices_written_timeout_log.append(timeout)
         num_captured: int
         async for num_captured in observe_value(self.dummy_signal, timeout):
             yield num_captured
@@ -102,9 +104,8 @@ class MockDetector(StandardDetector):
         writer: DetectorWriter,
         config_sigs: Sequence[AsyncReadable] = [],
         name: str = "",
-        writer_timeout: float = 1,
     ) -> None:
-        super().__init__(controller, writer, config_sigs, name, writer_timeout)
+        super().__init__(controller, writer, config_sigs, name)
 
     @WatchableAsyncStatus.wrap
     async def complete(self):
@@ -112,7 +113,12 @@ class MockDetector(StandardDetector):
         assert self._trigger_info
         self.writer.increment_index()
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            self._trigger_info.frame_timeout
+            or (
+                DEFAULT_TIMEOUT
+                + self._trigger_info.livetime
+                + self._trigger_info.deadtime
+            )
         ):
             yield WatcherUpdate(
                 name=self.name,
@@ -143,13 +149,11 @@ async def detectors(RE: RunEngine) -> tuple[MockDetector, MockDetector]:
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_1),
         writers[0],
         name="detector_1",
-        writer_timeout=3,
     )
     detector_2 = MockDetector(
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_2),
         writers[1],
         name="detector_2",
-        writer_timeout=3,
     )
     return (detector_1, detector_2)
 
@@ -374,3 +378,39 @@ async def test_at_least_one_detector_in_fly_plan(
     with pytest.raises(ValueError) as exc:
         RE(fly())
         assert str(exc) == "No detectors provided. There must be at least one."
+
+
+@pytest.mark.parametrize("timeout_setting,expected_timeout", [(None, 12), (5.0, 5.0)])
+async def test_trigger_sets_or_defaults_timeout(
+    RE: RunEngine,
+    flyer: HardwareTriggeredFlyable,
+    detectors: tuple[StandardDetector, ...],
+    timeout_setting: float | None,
+    expected_timeout: float,
+):
+    detector_list = list(detectors)
+
+    # Trigger parameters
+    number_of_frames = 1
+    exposure = 1
+    shutter_time = 0.004
+
+    def fly():
+        yield from bps.stage_all(*detector_list, flyer)
+        yield from bps.open_run()
+        yield from time_resolved_fly_and_collect_with_static_seq_table(
+            stream_name="stream1",
+            flyer=flyer,
+            detectors=detector_list,
+            number_of_frames=number_of_frames,
+            exposure=exposure,
+            shutter_time=shutter_time,
+            frame_timeout=timeout_setting,
+        )
+        yield from bps.close_run()
+        yield from bps.unstage_all(flyer, *detector_list)
+
+    RE(fly())
+
+    for detector in detectors:
+        assert detector.writer.observe_indices_written_timeout_log == [expected_timeout]