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

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)

ophyd_async/core/__init__.py

@@ -1,5 +1,5 @@
 from ._detector import (
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     DetectorWriter,
     StandardDetector,
@@ -16,7 +16,7 @@ from ._device_save_loader import (
     set_signal_values,
     walk_rw_signals,
 )
-from ._flyer import StandardFlyer, TriggerLogic
+from ._flyer import FlyerController, StandardFlyer
 from ._hdf_dataset import HDFDataset, HDFFile
 from ._log import config_ophyd_async_logging
 from ._mock_signal_backend import MockSignalBackend
@@ -85,7 +85,7 @@ from ._utils import (
 )
 
 __all__ = [
-    "DetectorControl",
+    "DetectorController",
     "DetectorTrigger",
     "DetectorWriter",
     "StandardDetector",
@@ -102,7 +102,7 @@ __all__ = [
     "set_signal_values",
     "walk_rw_signals",
     "StandardFlyer",
-    "TriggerLogic",
+    "FlyerController",
     "HDFDataset",
     "HDFFile",
     "config_ophyd_async_logging",

ophyd_async/core/_detector.py

@@ -3,8 +3,9 @@
 import asyncio
 import time
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator, AsyncIterator, Callable, Sequence
+from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterator, Sequence
 from enum import Enum
+from functools import cached_property
 from typing import (
     Generic,
 )
@@ -20,7 +21,7 @@ from bluesky.protocols import (
     WritesStreamAssets,
 )
 from event_model import DataKey
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, NonNegativeInt, computed_field
 
 from ._device import Device
 from ._protocol import AsyncConfigurable, AsyncReadable
@@ -45,8 +46,16 @@ class DetectorTrigger(str, Enum):
 class TriggerInfo(BaseModel):
     """Minimal set of information required to setup triggering on a detector"""
 
-    #: Number of triggers that will be sent, 0 means infinite
-    number: int = Field(ge=0)
+    #: Number of triggers that will be sent, (0 means infinite) Can be:
+    #  - A single integer or
+    #  - A list of integers for multiple triggers
+    # Example for tomography: TriggerInfo(number=[2,3,100,3])
+    #:     This would trigger:
+    #:     - 2 times for dark field images
+    #:     - 3 times for initial flat field images
+    #:     - 100 times for projections
+    #:     - 3 times for final flat field images
+    number_of_triggers: NonNegativeInt | list[NonNegativeInt]
     #: Sort of triggers that will be sent
     trigger: DetectorTrigger = Field(default=DetectorTrigger.internal)
     #: What is the minimum deadtime between triggers
@@ -60,13 +69,18 @@ class TriggerInfo(BaseModel):
     #: e.g. if num=10 and multiplier=5 then the detector will take 10 frames,
     #: but publish 2 indices, and describe() will show a shape of (5, h, w)
     multiplier: int = 1
-    #: The number of times the detector can go through a complete cycle of kickoff and
-    #: complete without needing to re-arm. This is important for detectors where the
-    #: process of arming is expensive in terms of time
-    iteration: int = 1
+
+    @computed_field
+    @cached_property
+    def total_number_of_triggers(self) -> int:
+        return (
+            sum(self.number_of_triggers)
+            if isinstance(self.number_of_triggers, list)
+            else self.number_of_triggers
+        )
 
 
-class DetectorControl(ABC):
+class DetectorController(ABC):
     """
     Classes implementing this interface should hold the logic for
     arming and disarming a detector
@@ -167,7 +181,7 @@ class StandardDetector(
 
     def __init__(
         self,
-        controller: DetectorControl,
+        controller: DetectorController,
         writer: DetectorWriter,
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
@@ -192,14 +206,18 @@ class StandardDetector(
         # For kickoff
         self._watchers: list[Callable] = []
         self._fly_status: WatchableAsyncStatus | None = None
-        self._fly_start: float
-        self._iterations_completed: int = 0
-        self._intial_frame: int
-        self._last_frame: int
+        self._fly_start: float | None = None
+        self._frames_to_complete: int = 0
+        # Represents the total number of frames that will have been completed at the
+        # end of the next `complete`.
+        self._completable_frames: int = 0
+        self._number_of_triggers_iter: Iterator[int] | None = None
+        self._initial_frame: int = 0
+
         super().__init__(name)
 
     @property
-    def controller(self) -> DetectorControl:
+    def controller(self) -> DetectorController:
         return self._controller
 
     @property
@@ -208,7 +226,7 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        # Disarm the detector, stop filewriting.
+        # Disarm the detector, stop file writing.
         await self._check_config_sigs()
         await asyncio.gather(self.writer.close(), self.controller.disarm())
         self._trigger_info = None
@@ -251,7 +269,7 @@ class StandardDetector(
         if self._trigger_info is None:
             await self.prepare(
                 TriggerInfo(
-                    number=1,
+                    number_of_triggers=1,
                     trigger=DetectorTrigger.internal,
                     deadtime=None,
                     livetime=None,
@@ -301,8 +319,12 @@ class StandardDetector(
                 f"but trigger logic provides only {value.deadtime}s"
             )
         self._trigger_info = value
+        self._number_of_triggers_iter = iter(
+            self._trigger_info.number_of_triggers
+            if isinstance(self._trigger_info.number_of_triggers, list)
+            else [self._trigger_info.number_of_triggers]
+        )
         self._initial_frame = await self.writer.get_indices_written()
-        self._last_frame = self._initial_frame + self._trigger_info.number
         self._describe, _ = await asyncio.gather(
             self.writer.open(value.multiplier), self.controller.prepare(value)
         )
@@ -312,35 +334,50 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        assert self._trigger_info, "Prepare must be called before kickoff!"
-        if self._iterations_completed >= self._trigger_info.iteration:
-            raise Exception(f"Kickoff called more than {self._trigger_info.iteration}")
-        self._iterations_completed += 1
+        if self._trigger_info is None or self._number_of_triggers_iter is None:
+            raise RuntimeError("Prepare must be called before kickoff!")
+        try:
+            self._frames_to_complete = next(self._number_of_triggers_iter)
+            self._completable_frames += self._frames_to_complete
+        except StopIteration as err:
+            raise RuntimeError(
+                f"Kickoff called more than the configured number of "
+                f"{self._trigger_info.total_number_of_triggers} iteration(s)!"
+            ) from err
 
     @WatchableAsyncStatus.wrap
     async def complete(self):
         assert self._trigger_info
-        async for index in self.writer.observe_indices_written(
+        indices_written = self.writer.observe_indices_written(
             self._trigger_info.frame_timeout
             or (
                 DEFAULT_TIMEOUT
                 + (self._trigger_info.livetime or 0)
                 + (self._trigger_info.deadtime or 0)
             )
-        ):
-            yield WatcherUpdate(
-                name=self.name,
-                current=index,
-                initial=self._initial_frame,
-                target=self._trigger_info.number,
-                unit="",
-                precision=0,
-                time_elapsed=time.monotonic() - self._fly_start,
-            )
-            if index >= self._trigger_info.number:
-                break
-        if self._iterations_completed == self._trigger_info.iteration:
-            await self.controller.wait_for_idle()
+        )
+        try:
+            async for index in indices_written:
+                yield WatcherUpdate(
+                    name=self.name,
+                    current=index,
+                    initial=self._initial_frame,
+                    target=self._frames_to_complete,
+                    unit="",
+                    precision=0,
+                    time_elapsed=time.monotonic() - self._fly_start
+                    if self._fly_start
+                    else None,
+                )
+                if index >= self._frames_to_complete:
+                    break
+        finally:
+            await indices_written.aclose()
+            if self._completable_frames >= self._trigger_info.total_number_of_triggers:
+                self._completable_frames = 0
+                self._frames_to_complete = 0
+                self._number_of_triggers_iter = None
+                await self.controller.wait_for_idle()
 
     async def describe_collect(self) -> dict[str, DataKey]:
         return self._describe

ophyd_async/core/_device.py

@@ -12,7 +12,7 @@ from typing import (
 )
 
 from bluesky.protocols import HasName
-from bluesky.run_engine import call_in_bluesky_event_loop
+from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
 
 from ._utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
 
@@ -224,6 +224,11 @@ class DeviceCollector:
         await self._on_exit()
 
     def __exit__(self, type_, value, traceback):
+        if in_bluesky_event_loop():
+            raise RuntimeError(
+                "Cannot use DeviceConnector inside a plan, instead use "
+                "`yield from ophyd_async.plan_stubs.ensure_connected(device)`"
+            )
         self._objects_on_exit = self._caller_locals()
         try:
             fut = call_in_bluesky_event_loop(self._on_exit())

ophyd_async/core/_flyer.py

@@ -1,17 +1,14 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
 from typing import Generic
 
-from bluesky.protocols import Flyable, Preparable, Reading, Stageable
-from event_model import DataKey
+from bluesky.protocols import Flyable, Preparable, Stageable
 
 from ._device import Device
-from ._signal import SignalR
 from ._status import AsyncStatus
-from ._utils import T, merge_gathered_dicts
+from ._utils import T
 
 
-class TriggerLogic(ABC, Generic[T]):
+class FlyerController(ABC, Generic[T]):
     @abstractmethod
     async def prepare(self, value: T):
         """Move to the start of the flyscan"""
@@ -38,16 +35,14 @@ class StandardFlyer(
 ):
     def __init__(
         self,
-        trigger_logic: TriggerLogic[T],
-        configuration_signals: Sequence[SignalR] = (),
+        trigger_logic: FlyerController[T],
         name: str = "",
     ):
         self._trigger_logic = trigger_logic
-        self._configuration_signals = tuple(configuration_signals)
         super().__init__(name=name)
 
     @property
-    def trigger_logic(self) -> TriggerLogic[T]:
+    def trigger_logic(self) -> FlyerController[T]:
         return self._trigger_logic
 
     @AsyncStatus.wrap
@@ -73,13 +68,3 @@ class StandardFlyer(
     @AsyncStatus.wrap
     async def complete(self) -> None:
         await self._trigger_logic.complete()
-
-    async def describe_configuration(self) -> dict[str, DataKey]:
-        return await merge_gathered_dicts(
-            [sig.describe() for sig in self._configuration_signals]
-        )
-
-    async def read_configuration(self) -> dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read() for sig in self._configuration_signals]
-        )

ophyd_async/core/_table.py

@@ -1,4 +1,5 @@
-from typing import TypeVar
+from enum import Enum
+from typing import TypeVar, get_args, get_origin
 
 import numpy as np
 from pydantic import BaseModel, ConfigDict, model_validator
@@ -6,6 +7,13 @@ from pydantic import BaseModel, ConfigDict, model_validator
 TableSubclass = TypeVar("TableSubclass", bound="Table")
 
 
+def _concat(value1, value2):
+    if isinstance(value1, np.ndarray):
+        return np.concatenate((value1, value2))
+    else:
+        return value1 + value2
+
+
 class Table(BaseModel):
     """An abstraction of a Table of str to numpy array."""
 
@@ -13,34 +21,105 @@ class Table(BaseModel):
 
     @staticmethod
     def row(cls: type[TableSubclass], **kwargs) -> TableSubclass:  # type: ignore
-        arrayified_kwargs = {
-            field_name: np.concatenate(
-                (
-                    (default_arr := field_value.default_factory()),  # type: ignore
-                    np.array([kwargs[field_name]], dtype=default_arr.dtype),
+        arrayified_kwargs = {}
+        for field_name, field_value in cls.model_fields.items():
+            value = kwargs.pop(field_name)
+            if field_value.default_factory is None:
+                raise ValueError(
+                    "`Table` models should have default factories for their "
+                    "mutable empty columns."
+                )
+            default_array = field_value.default_factory()
+            if isinstance(default_array, np.ndarray):
+                arrayified_kwargs[field_name] = np.array(
+                    [value], dtype=default_array.dtype
+                )
+            elif issubclass(type(value), Enum) and isinstance(value, str):
+                arrayified_kwargs[field_name] = [value]
+            else:
+                raise TypeError(
+                    "Row column should be numpy arrays or sequence of string `Enum`."
                 )
+        if kwargs:
+            raise TypeError(
+                f"Unexpected keyword arguments {kwargs.keys()} for {cls.__name__}."
             )
-            for field_name, field_value in cls.model_fields.items()
-        }
         return cls(**arrayified_kwargs)
 
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
 
-        assert type(right) is type(self), (
-            f"{right} is not a `Table`, or is not the same "
-            f"type of `Table` as {self}."
-        )
+        if type(right) is not type(self):
+            raise RuntimeError(
+                f"{right} is not a `Table`, or is not the same "
+                f"type of `Table` as {self}."
+            )
 
         return type(right)(
             **{
-                field_name: np.concatenate(
-                    (getattr(self, field_name), getattr(right, field_name))
+                field_name: _concat(
+                    getattr(self, field_name), getattr(right, field_name)
                 )
                 for field_name in self.model_fields
             }
         )
 
+    def numpy_dtype(self) -> np.dtype:
+        dtype = []
+        for field_name, field_value in self.model_fields.items():
+            if np.ndarray in (
+                get_origin(field_value.annotation),
+                field_value.annotation,
+            ):
+                dtype.append((field_name, getattr(self, field_name).dtype))
+            else:
+                enum_type = get_args(field_value.annotation)[0]
+                assert issubclass(enum_type, Enum)
+                enum_values = [element.value for element in enum_type]
+                max_length_in_enum = max(len(value) for value in enum_values)
+                dtype.append((field_name, np.dtype(f"<U{max_length_in_enum}")))
+
+        return np.dtype(dtype)
+
+    def numpy_table(self):
+        # It would be nice to be able to use np.transpose for this,
+        # but it defaults to the largest dtype for everything.
+        dtype = self.numpy_dtype()
+        transposed_list = [
+            np.array(tuple(row), dtype=dtype)
+            for row in zip(*self.numpy_columns(), strict=False)
+        ]
+        transposed = np.array(transposed_list, dtype=dtype)
+        return transposed
+
+    def numpy_columns(self) -> list[np.ndarray]:
+        """Columns in the table can be lists of string enums or numpy arrays.
+
+        This method returns the columns, converting the string enums to numpy arrays.
+        """
+
+        columns = []
+        for field_name, field_value in self.model_fields.items():
+            if np.ndarray in (
+                get_origin(field_value.annotation),
+                field_value.annotation,
+            ):
+                columns.append(getattr(self, field_name))
+            else:
+                enum_type = get_args(field_value.annotation)[0]
+                assert issubclass(enum_type, Enum)
+                enum_values = [element.value for element in enum_type]
+                max_length_in_enum = max(len(value) for value in enum_values)
+                dtype = np.dtype(f"<U{max_length_in_enum}")
+
+                columns.append(
+                    np.array(
+                        [enum.value for enum in getattr(self, field_name)], dtype=dtype
+                    )
+                )
+
+        return columns
+
     @model_validator(mode="after")
     def validate_arrays(self) -> "Table":
         first_length = len(next(iter(self))[1])
@@ -49,11 +128,15 @@ class Table(BaseModel):
         ), "Rows should all be of equal size."
 
         if not all(
-            np.issubdtype(
-                self.model_fields[field_name].default_factory().dtype,  # type: ignore
-                field_value.dtype,
+            # Checks if the values are numpy subtypes if the array is a numpy array,
+            # or if the value is a string enum.
+            np.issubdtype(getattr(self, field_name).dtype, default_array.dtype)
+            if isinstance(
+                default_array := self.model_fields[field_name].default_factory(),  # type: ignore
+                np.ndarray,
             )
-            for field_name, field_value in self
+            else issubclass(get_args(field_value.annotation)[0], Enum)
+            for field_name, field_value in self.model_fields.items()
         ):
             raise ValueError(
                 f"Cannot construct a `{type(self).__name__}`, "

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -2,7 +2,7 @@ import asyncio
 from typing import Literal
 
 from ophyd_async.core import (
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     TriggerInfo,
     set_and_wait_for_value,
@@ -18,7 +18,7 @@ from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 
 
-class AravisController(DetectorControl):
+class AravisController(DetectorController):
     GPIO_NUMBER = Literal[1, 2, 3, 4]
 
     def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
@@ -30,7 +30,7 @@ class AravisController(DetectorControl):
         return _HIGHEST_POSSIBLE_DEADTIME
 
     async def prepare(self, trigger_info: TriggerInfo):
-        if (num := trigger_info.number) == 0:
+        if trigger_info.total_number_of_triggers == 0:
             image_mode = adcore.ImageMode.continuous
         else:
             image_mode = adcore.ImageMode.multiple
@@ -43,7 +43,7 @@ class AravisController(DetectorControl):
 
         await asyncio.gather(
             self._drv.trigger_source.set(trigger_source),
-            self._drv.num_images.set(num),
+            self._drv.num_images.set(trigger_info.total_number_of_triggers),
             self._drv.image_mode.set(image_mode),
         )
 

ophyd_async/epics/adcore/_core_logic.py

@@ -4,7 +4,7 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     DatasetDescriber,
-    DetectorControl,
+    DetectorController,
     set_and_wait_for_value,
 )
 from ophyd_async.epics.adcore._utils import convert_ad_dtype_to_np
@@ -34,7 +34,7 @@ class ADBaseDatasetDescriber(DatasetDescriber):
 
 
 async def set_exposure_time_and_acquire_period_if_supplied(
-    controller: DetectorControl,
+    controller: DetectorController,
     driver: ADBaseIO,
     exposure: float | None = None,
     timeout: float = DEFAULT_TIMEOUT,

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from ophyd_async.core import DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorController, DetectorTrigger
 from ophyd_async.core._detector import TriggerInfo
 from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
@@ -15,7 +15,7 @@ KINETIX_TRIGGER_MODE_MAP = {
 }
 
 
-class KinetixController(DetectorControl):
+class KinetixController(DetectorController):
     def __init__(
         self,
         driver: KinetixDriverIO,
@@ -29,7 +29,7 @@ class KinetixController(DetectorControl):
     async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
             self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]),
-            self._drv.num_images.set(trigger_info.number),
+            self._drv.num_images.set(trigger_info.total_number_of_triggers),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -2,7 +2,7 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     wait_for_value,
 )
@@ -13,7 +13,7 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-class PilatusController(DetectorControl):
+class PilatusController(DetectorController):
     _supported_trigger_types = {
         DetectorTrigger.internal: PilatusTriggerMode.internal,
         DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
@@ -40,7 +40,9 @@ class PilatusController(DetectorControl):
         await asyncio.gather(
             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
+                999_999
+                if trigger_info.total_number_of_triggers == 0
+                else trigger_info.total_number_of_triggers
             ),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )

ophyd_async/epics/adsimdetector/_sim.py

@@ -30,6 +30,6 @@ class SimDetector(StandardDetector):
                 lambda: self.name,
                 adcore.ADBaseDatasetDescriber(self.drv),
             ),
-            config_sigs=config_sigs,
+            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
             name=name,
         )

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -2,7 +2,7 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
 )
 from ophyd_async.core._detector import TriggerInfo
@@ -10,7 +10,7 @@ from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 
-class SimController(DetectorControl):
+class SimController(DetectorController):
     def __init__(
         self,
         driver: adcore.ADBaseIO,
@@ -32,7 +32,7 @@ class SimController(DetectorControl):
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.number),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
             self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
 

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from ophyd_async.core import DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorController, DetectorTrigger
 from ophyd_async.core._detector import TriggerInfo
 from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
@@ -22,7 +22,7 @@ EXPOSE_OUT_MODE = {
 }
 
 
-class VimbaController(DetectorControl):
+class VimbaController(DetectorController):
     def __init__(
         self,
         driver: VimbaDriverIO,
@@ -37,7 +37,7 @@ class VimbaController(DetectorControl):
         await asyncio.gather(
             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.num_images.set(trigger_info.total_number_of_triggers),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/eiger/_eiger_controller.py

@@ -2,7 +2,7 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     set_and_wait_for_other_value,
 )
@@ -18,7 +18,7 @@ EIGER_TRIGGER_MODE_MAP = {
 }
 
 
-class EigerController(DetectorControl):
+class EigerController(DetectorController):
     def __init__(
         self,
         driver: EigerDriverIO,
@@ -41,7 +41,7 @@ class EigerController(DetectorControl):
             self._drv.trigger_mode.set(
                 EIGER_TRIGGER_MODE_MAP[trigger_info.trigger].value
             ),
-            self._drv.num_images.set(trigger_info.number),
+            self._drv.num_images.set(trigger_info.total_number_of_triggers),
         ]
         if trigger_info.livetime is not None:
             coros.extend(