ophyd-async 0.10.0a1__py3-none-any.whl → 0.10.0a3__py3-none-any.whl

ophyd_async/epics/adcore/_hdf_writer.py

@@ -5,12 +5,12 @@ from xml.etree import ElementTree as ET
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
+from pydantic import PositiveInt
 
 from ophyd_async.core import (
     DatasetDescriber,
     HDFDatasetDescription,
     HDFDocumentComposer,
-    NameProvider,
     PathProvider,
 )
 
@@ -31,14 +31,12 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         self,
         fileio: NDFileHDFIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".h5",
@@ -48,7 +46,9 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         self._composer: HDFDocumentComposer | None = None
         self._filename_template = "%s%s"
 
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         self._composer = None
 
         # Setting HDF writer specific signals
@@ -64,13 +64,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         )
 
         # Set common AD file plugin params, begin capturing
-        await self.begin_capture()
+        await self.begin_capture(name)
 
-        name = self._name_provider()
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()
-        self._multiplier = multiplier
-        outer_shape = (multiplier,) if multiplier > 1 else ()
+
+        # Used by the base class
+        self._exposures_per_event = exposures_per_event
 
         # Determine number of frames that will be saved per HDF chunk
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
@@ -80,9 +80,8 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             HDFDatasetDescription(
                 data_key=name,
                 dataset="/entry/data/data",
-                shape=detector_shape,
+                shape=(exposures_per_event, *detector_shape),
                 dtype_numpy=np_dtype,
-                multiplier=multiplier,
                 chunk_shape=(frames_per_chunk, *detector_shape),
             )
         ]
@@ -107,20 +106,23 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                         HDFDatasetDescription(
                             data_key=data_key,
                             dataset=f"/entry/instrument/NDAttributes/{data_key}",
-                            shape=(),
+                            shape=(exposures_per_event,)
+                            if exposures_per_event > 1
+                            else (),
                             dtype_numpy=np_datatype,
                             # NDAttributes appear to always be configured with
                             # this chunk size
                             chunk_shape=(16384,),
-                            multiplier=multiplier,
                         )
                     )
 
         describe = {
             ds.data_key: DataKey(
                 source=self.fileio.full_file_name.source,
-                shape=list(outer_shape + tuple(ds.shape)),
-                dtype="array" if ds.shape else "number",
+                shape=list(ds.shape),
+                dtype="array"
+                if exposures_per_event > 1 or len(ds.shape) > 1
+                else "number",
                 dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
             )
@@ -129,7 +131,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         return describe
 
     async def collect_stream_docs(
-        self, indices_written: int
+        self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
         await self.fileio.flush_now.set(True)

ophyd_async/epics/adcore/_jpeg_writer.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core import DatasetDescriber, PathProvider
 
 from ._core_io import NDFileIO, NDPluginBaseIO
 from ._core_writer import ADWriter
@@ -11,14 +11,12 @@ class ADJPEGWriter(ADWriter[NDFileIO]):
         self,
         fileio: NDFileIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".jpg",

ophyd_async/epics/adcore/_tiff_writer.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core import DatasetDescriber, PathProvider
 
 from ._core_io import NDFileIO, NDPluginBaseIO
 from ._core_writer import ADWriter
@@ -11,14 +11,12 @@ class ADTIFFWriter(ADWriter[NDFileIO]):
         self,
         fileio: NDFileIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".tiff",

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -34,7 +34,7 @@ class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
             self.driver.trigger_mode.set(
                 KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]
             ),
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -52,8 +52,8 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
             self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
             self.driver.num_images.set(
                 999_999
-                if trigger_info.total_number_of_triggers == 0
-                else trigger_info.total_number_of_triggers
+                if trigger_info.total_number_of_exposures == 0
+                else trigger_info.total_number_of_exposures
             ),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -21,4 +21,4 @@ class PilatusDriverIO(adcore.ADBaseIO):
     """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
     """See HTML docs at https://areadetector.github.io/areaDetector/ADPilatus/pilatusDoc.html"""
     trigger_mode: A[SignalRW[PilatusTriggerMode], PvSuffix.rbv("TriggerMode")]
-    armed: A[SignalR[bool], PvSuffix.rbv("Armed_RBV")]
+    armed: A[SignalR[bool], PvSuffix("Armed")]

ophyd_async/epics/advimba/_vimba_controller.py

@@ -40,7 +40,7 @@ class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
         await asyncio.gather(
             self.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
             self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/core/_p4p.py

@@ -383,7 +383,7 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
 
     async def put(self, value: SignalDatatypeT | None, wait: bool):
         if value is None:
-            write_value = self.initial_values[self.write_pv]
+            write_value = self.initial_values[self.write_pv]["value"]
         else:
             write_value = self.converter.write_value(value)
         await context().put(self.write_pv, {"value": write_value}, wait=wait)

ophyd_async/epics/core/_pvi_connector.py

@@ -43,10 +43,10 @@ FastCSPVIVector = dict[Literal["d"], Entry]
 
 def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
     match entry:
-        case {"r": read_pv}:
-            return SignalR, read_pv, read_pv
         case {"r": read_pv, "w": write_pv}:
             return SignalRW, read_pv, write_pv
+        case {"r": read_pv}:
+            return SignalR, read_pv, read_pv
         case {"w": write_pv}:
             return SignalW, write_pv, write_pv
         case {"rw": read_write_pv}:
@@ -77,6 +77,8 @@ class PviDeviceConnector(DeviceConnector):
         hinted Signals are not present.
     """
 
+    mock_device_vector_len: int = 2
+
     def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
@@ -110,7 +112,7 @@ class PviDeviceConnector(DeviceConnector):
             backend.write_pv = write_pv
 
     async def connect_mock(self, device: Device, mock: LazyMock):
-        self.filler.create_device_vector_entries_to_mock(2)
+        self.filler.create_device_vector_entries_to_mock(self.mock_device_vector_len)
         # Set the name of the device to name all children
         device.set_name(device.name)
         return await super().connect_mock(device, mock)

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,19 @@ 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,
     StrictEnum,
     observe_value,
+    set_and_wait_for_other_value,
     set_and_wait_for_value,
+    wait_for_value,
 )
 from ophyd_async.epics.core import (
     epics_signal_r,
@@ -22,44 +24,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}NumCapture_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.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}DatasetDataDatatype")
+        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DataType")
 
         super().__init__(name)
 
@@ -68,27 +79,37 @@ class OdinWriter(DetectorWriter):
     def __init__(
         self,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         odin_driver: Odin,
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
-        self._name_provider = name_provider
         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"
+                "UInt16"
             ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
             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 set_and_wait_for_other_value(
+            self._drv.capture,
+            Writing.CAPTURE,
+            self._drv.capture_rbv,
+            "Capturing",
+            set_timeout=None,
+            wait_for_set_completion=False,
+        )  # TODO: Investigate why we do not get a put callback when setting capture pv https://github.com/bluesky/ophyd-async/issues/866
+
+        await wait_for_value(self._drv.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT)
 
         return await self._describe()
 
@@ -100,7 +121,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 +133,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/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,10 @@
 from pydantic import Field
 
 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 +15,22 @@ 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),
             name=name,
         )
 

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

@@ -2,11 +2,9 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
-    set_and_wait_for_other_value,
 )
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
@@ -20,59 +18,47 @@ 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,
-        )
+        self._arm_status = self._drv.detector.arm.trigger(timeout=DEFAULT_TIMEOUT)
 
     async def wait_for_idle(self):
-        if self._arm_status and not self._arm_status.done:
+        if self._arm_status:
             await self._arm_status
-        self._arm_status = None
 
     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,53 @@
+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
+
+
+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__(