Use ADOdin with FastCS-Eiger (#863)

* Add fastcs eiger but use old odin

* Use ADOdin with fastcs-eiger

* Reorder signal type matching

* Get value from initial_values response

* Add test for order of signal sets and fix odin nodes

---------

Co-authored-by: Dominic Oram <[email protected]>

Author: shihab-dls

src/ophyd_async/epics/eiger/_odin_io.py

@@ -5,13 +5,16 @@
 from event_model import DataKey  # type: ignore
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     DetectorWriter,
     Device,
     DeviceVector,
     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,
@@ -21,44 +24,53 @@
 
 
 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)
 
@@ -81,12 +93,23 @@ async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataK
             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()
 
@@ -122,4 +145,4 @@ def collect_stream_docs(
         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)

src/ophyd_async/fastcs/eiger/_eiger.py

@@ -22,11 +22,11 @@ def __init__(
         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),

tests/epics/eiger/test_odin_io.py

@@ -1,9 +1,9 @@
 from pathlib import Path
-from unittest.mock import ANY, MagicMock
+from unittest.mock import ANY, AsyncMock, MagicMock, call, patch
 
 import pytest
 
-from ophyd_async.core import init_devices
+from ophyd_async.core import DEFAULT_TIMEOUT, init_devices
 from ophyd_async.epics.eiger import Odin, OdinWriter, Writing
 from ophyd_async.testing import get_mock_put, set_mock_value
 
@@ -17,6 +17,11 @@ def odin_driver_and_writer(RE) -> OdinDriverAndWriter:
     with init_devices(mock=True):
         driver = Odin("")
         writer = OdinWriter(MagicMock(), driver)
+
+    # Set meta and capturing pvs high
+    set_mock_value(driver.meta_active, "Active")
+    set_mock_value(driver.capture_rbv, "Capturing")
+    set_mock_value(driver.meta_writing, "Writing")
     return driver, writer
 
 
@@ -41,10 +46,10 @@ async def test_when_open_called_then_all_expected_signals_set(
     driver, writer = odin_driver_and_writer
     await writer.open(ODIN_DETECTOR_NAME)
 
-    get_mock_put(driver.data_type).assert_called_once_with("uint16", wait=ANY)
+    get_mock_put(driver.data_type).assert_called_once_with("UInt16", wait=ANY)
     get_mock_put(driver.num_to_capture).assert_called_once_with(0, wait=ANY)
 
-    get_mock_put(driver.capture).assert_called_once_with(Writing.ON, wait=ANY)
+    get_mock_put(driver.capture).assert_called_once_with(Writing.CAPTURE, wait=ANY)
 
 
 async def test_given_data_shape_set_when_open_called_then_describe_has_correct_shape(
@@ -62,4 +67,40 @@ async def test_when_closed_then_data_capture_turned_off(
 ):
     driver, writer = odin_driver_and_writer
     await writer.close()
-    get_mock_put(driver.capture).assert_called_once_with(Writing.OFF, wait=ANY)
+    get_mock_put(driver.capture).assert_called_once_with(Writing.DONE, wait=ANY)
+
+
+@pytest.mark.asyncio
+@patch("ophyd_async.epics.eiger._odin_io.wait_for_value")
+@patch("ophyd_async.epics.eiger._odin_io.set_and_wait_for_other_value")
+async def test_wait_for_active_before_capture_then_wait_for_writing(
+    mock_set_and_wait_for_other_value,
+    mock_wait_for_value,
+    odin_driver_and_writer,
+):
+    driver, writer = odin_driver_and_writer
+
+    mock_manager = AsyncMock()
+    mock_manager.attach_mock(mock_wait_for_value, "mock_wait_for_value")
+    mock_manager.attach_mock(
+        mock_set_and_wait_for_other_value, "mock_set_and_wait_for_other_value"
+    )
+
+    await writer.open(ODIN_DETECTOR_NAME)
+
+    expected_calls = [
+        call.mock_wait_for_value(driver.meta_active, "Active", timeout=DEFAULT_TIMEOUT),
+        call.mock_set_and_wait_for_other_value(
+            driver.capture,
+            Writing.CAPTURE,
+            driver.capture_rbv,
+            "Capturing",
+            set_timeout=None,
+            wait_for_set_completion=False,
+        ),
+        call.mock_wait_for_value(
+            driver.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT
+        ),
+    ]
+
+    assert mock_manager.mock_calls == expected_calls

tests/fastcs/eiger/test_eiger_detector.py

@@ -4,13 +4,16 @@
 
 from ophyd_async.core import DetectorTrigger, init_devices
 from ophyd_async.fastcs.eiger import EigerDetector, EigerTriggerInfo
-from ophyd_async.testing import get_mock_put
+from ophyd_async.testing import get_mock_put, set_mock_value
 
 
 @pytest.fixture
 def detector(RE):
     with init_devices(mock=True):
         detector = EigerDetector("BL03I", MagicMock())
+    set_mock_value(detector.odin.meta_active, "Active")
+    set_mock_value(detector.odin.capture_rbv, "Capturing")
+    set_mock_value(detector.odin.meta_writing, "Writing")
     return detector