dls-dodal 1.34.1__py3-none-any.whl → 1.36.0__py3-none-any.whl

dodal/devices/apple2_undulator.py

@@ -1,26 +1,26 @@
 import abc
 import asyncio
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any
 
 import numpy as np
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
+    Reference,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     soft_signal_r_and_setter,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
 
 
-class UndulatorGateStatus(str, Enum):
+class UndulatorGateStatus(StrictEnum):
     open = "Open"
     close = "Closed"
 
@@ -128,12 +128,12 @@ class UndulatorGap(StandardReadable, Movable):
         )
         # This is calculated acceleration from speed
         self.acceleration_time = epics_signal_r(float, prefix + "IDGSETACC")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Unit
             self.motor_egu = epics_signal_r(str, prefix + "BLGAPMTR.EGU")
             # Gap velocity
             self.velocity = epics_signal_rw(float, prefix + "BLGSETVEL")
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Gap readback value
             self.user_readback = epics_signal_r(float, prefix + "CURRGAPD")
         super().__init__(name)
@@ -187,10 +187,10 @@ class UndulatorPhaseMotor(StandardReadable):
         self.user_setpoint_demand_readback = epics_signal_r(float, fullPV + "DMD")
 
         fullPV = fullPV + "MTR"
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.user_setpoint_readback = epics_signal_r(float, fullPV + ".RBV")
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, fullPV + ".EGU")
             self.velocity = epics_signal_rw(float, fullPV + ".VELO")
 
@@ -388,10 +388,10 @@ class Apple2(StandardReadable, Movable):
 
         # Attributes are set after super call so they are not renamed to
         # <name>-undulator, etc.
-        with self.add_children_as_readables():
-            self.gap = id_gap
-            self.phase = id_phase
-        with self.add_children_as_readables(HintedSignal):
+        self.gap = Reference(id_gap)
+        self.phase = Reference(id_phase)
+
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Store the polarisation for readback.
             self.polarisation, self._polarisation_set = soft_signal_r_and_setter(
                 str, initial_value=None
@@ -437,16 +437,16 @@ class Apple2(StandardReadable, Movable):
         """
 
         # Only need to check gap as the phase motors share both fault and gate with gap.
-        await self.gap.check_id_status()
+        await self.gap().check_id_status()
         await asyncio.gather(
-            self.phase.top_outer.user_setpoint.set(value=value.top_outer),
-            self.phase.top_inner.user_setpoint.set(value=value.top_inner),
-            self.phase.btm_inner.user_setpoint.set(value=value.btm_inner),
-            self.phase.btm_outer.user_setpoint.set(value=value.btm_outer),
-            self.gap.user_setpoint.set(value=value.gap),
+            self.phase().top_outer.user_setpoint.set(value=value.top_outer),
+            self.phase().top_inner.user_setpoint.set(value=value.top_inner),
+            self.phase().btm_inner.user_setpoint.set(value=value.btm_inner),
+            self.phase().btm_outer.user_setpoint.set(value=value.btm_outer),
+            self.gap().user_setpoint.set(value=value.gap),
         )
         timeout = np.max(
-            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
+            await asyncio.gather(self.gap().get_timeout(), self.phase().get_timeout())
         )
         LOGGER.info(
             f"Moving f{self.name} energy and polorisation to {energy}, {self.pol}"
@@ -454,10 +454,12 @@ class Apple2(StandardReadable, Movable):
         )
 
         await asyncio.gather(
-            self.gap.set_move.set(value=1, timeout=timeout),
-            self.phase.set_move.set(value=1, timeout=timeout),
+            self.gap().set_move.set(value=1, timeout=timeout),
+            self.phase().set_move.set(value=1, timeout=timeout),
+        )
+        await wait_for_value(
+            self.gap().gate, UndulatorGateStatus.close, timeout=timeout
         )
-        await wait_for_value(self.gap.gate, UndulatorGateStatus.close, timeout=timeout)
         self._energy_set(energy)  # Update energy for after move for readback.
 
     def _get_id_gap_phase(self, energy: float) -> tuple[float, float]:
@@ -522,12 +524,11 @@ class Apple2(StandardReadable, Movable):
         (May be for future one can use the inverse poly to work out the energy and try to match it with the current energy
         to workout the polarisation but during my test the inverse poly is too unstable for general use.)
         """
-        cur_loc = await self.read()
-        top_outer = cur_loc[self.phase.top_outer.user_setpoint_readback.name]["value"]
-        top_inner = cur_loc[self.phase.top_inner.user_setpoint_readback.name]["value"]
-        btm_inner = cur_loc[self.phase.btm_inner.user_setpoint_readback.name]["value"]
-        btm_outer = cur_loc[self.phase.btm_outer.user_setpoint_readback.name]["value"]
-        gap = cur_loc[self.gap.user_readback.name]["value"]
+        top_outer = await self.phase().top_outer.user_setpoint_readback.get_value()
+        top_inner = await self.phase().top_inner.user_setpoint_readback.get_value()
+        btm_inner = await self.phase().btm_inner.user_setpoint_readback.get_value()
+        btm_outer = await self.phase().btm_outer.user_setpoint_readback.get_value()
+        gap = await self.gap().user_readback.get_value()
         if gap > MAXIMUM_GAP_MOTOR_POSITION:
             raise RuntimeError(
                 f"{self.name} is not in use, close gap or set polarisation to use this ID"

dodal/devices/areadetector/plugins/CAM.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class ColorMode(str, Enum):
+class ColorMode(StrictEnum):
     """
     Enum to store the various color modes of the camera. We use RGB1.
     """

dodal/devices/areadetector/plugins/MJPG.py

@@ -6,7 +6,7 @@ import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from PIL import Image
 
 from dodal.log import LOGGER

dodal/devices/attenuator.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 from dodal.log import LOGGER
 

dodal/devices/backlight.py

@@ -1,17 +1,16 @@
 from asyncio import sleep
-from enum import Enum
 
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 
 
-class BacklightPower(str, Enum):
+class BacklightPower(StrictEnum):
     ON = "On"
     OFF = "Off"
 
 
-class BacklightPosition(str, Enum):
+class BacklightPosition(StrictEnum):
     IN = "In"
     OUT = "Out"
 

dodal/devices/cryostream.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class InOut(str, Enum):
+class InOut(StrictEnum):
     IN = "In"
     OUT = "Out"
 

dodal/devices/dcm.py

@@ -1,6 +1,14 @@
-from ophyd_async.core import StandardReadable
+import numpy as np
+from numpy.typing import NDArray
+from ophyd_async.core import StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
+
+from dodal.common.crystal_metadata import (
+    CrystalMetadata,
+    MaterialsEnum,
+    make_crystal_metadata_from_material,
+)
 
 
 class DCM(StandardReadable):
@@ -17,7 +25,11 @@ class DCM(StandardReadable):
         self,
         prefix: str,
         name: str = "",
+        crystal_metadata: CrystalMetadata | None = None,
     ) -> None:
+        cm = crystal_metadata or make_crystal_metadata_from_material(
+            MaterialsEnum.Si, (1, 1, 1)
+        )
         with self.add_children_as_readables():
             self.bragg_in_degrees = Motor(prefix + "BRAGG")
             self.roll_in_mrad = Motor(prefix + "ROLL")
@@ -36,4 +48,16 @@ class DCM(StandardReadable):
             self.perp_temp = epics_signal_r(float, prefix + "TEMP6")
             self.perp_sub_assembly_temp = epics_signal_r(float, prefix + "TEMP7")
 
+            self.crystal_metadata_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=cm.usage
+            )
+            self.crystal_metadata_type, _ = soft_signal_r_and_setter(
+                str, initial_value=cm.type
+            )
+            reflection_array = np.array(cm.reflection)
+            self.crystal_metadata_reflection, _ = soft_signal_r_and_setter(
+                NDArray[np.uint64],
+                initial_value=reflection_array,
+            )
+            self.crystal_metadata_d_spacing = epics_signal_r(float, "DSPACING:RBV")
         super().__init__(name)

dodal/devices/detector/detector_motion.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import Device
+from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
-class ShutterState(str, Enum):
+class ShutterState(StrictEnum):
     CLOSED = "Closed"
     OPEN = "Open"
 

dodal/devices/diamond_filter.py

@@ -1,12 +1,11 @@
-from enum import Enum
 from typing import Generic, TypeVar
 
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
-class _Filters(str, Enum):
+class _Filters(StrictEnum):
     pass
 
 

dodal/devices/eiger.py

@@ -1,4 +1,5 @@
 # type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
+from dataclasses import dataclass
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
@@ -14,6 +15,15 @@ from dodal.log import LOGGER
 FREE_RUN_MAX_IMAGES = 1000000
 
 
+@dataclass
+class EigerTimeouts:
+    stale_params_timeout: int = 60
+    general_status_timeout: int = 10
+    meta_file_ready_timeout: int = 30
+    all_frames_timeout: int = 120
+    arming_timeout: int = 60
+
+
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
     INTERNAL_ENABLE = 1
@@ -21,6 +31,17 @@ class InternalEigerTriggerMode(Enum):
     EXTERNAL_ENABLE = 3
 
 
+AVAILABLE_TIMEOUTS = {
+    "i03": EigerTimeouts(
+        stale_params_timeout=60,
+        general_status_timeout=10,
+        meta_file_ready_timeout=30,
+        all_frames_timeout=120,  # Long timeout for meta file to compensate for filesystem issues
+        arming_timeout=60,
+    )
+}
+
+
 class EigerDetector(Device):
     class ArmingSignal(Signal):
         def set(self, value, *, timeout=None, settle_time=None, **kwargs):
@@ -34,13 +55,6 @@ class EigerDetector(Device):
     stale_params = Component(EpicsSignalRO, "CAM:StaleParameters_RBV")
     bit_depth = Component(EpicsSignalRO, "CAM:BitDepthImage_RBV")
 
-    STALE_PARAMS_TIMEOUT = 60
-    GENERAL_STATUS_TIMEOUT = 10
-    # Long timeout for meta file to compensate for filesystem issues
-    META_FILE_READY_TIMEOUT = 30
-    ALL_FRAMES_TIMEOUT = 120
-    ARMING_TIMEOUT = 60
-
     filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
@@ -48,13 +62,20 @@ class EigerDetector(Device):
     arming_status = Status()
     arming_status.set_finished()
 
+    def __init__(self, beamline: str = "i03", *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.beamline = beamline
+        # using i03 timeouts as default
+        self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
+
     @classmethod
     def with_params(
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
+        beamline: str = "i03",
     ):
-        det = cls(name=name)
+        det = cls(name=name, beamline=beamline)
         det.set_detector_parameters(params)
         return det
 
@@ -82,7 +103,7 @@ class EigerDetector(Device):
     def async_stage(self):
         self.odin.nodes.clear_odin_errors()
         status_ok, error_message = self.odin.wait_for_odin_initialised(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
         if not status_ok:
             raise Exception(f"Odin not initialised: {error_message}")
@@ -96,14 +117,14 @@ class EigerDetector(Device):
     def wait_on_arming_if_started(self):
         if not self.arming_status.done:
             LOGGER.info("Waiting for arming to finish")
-            self.arming_status.wait(self.ARMING_TIMEOUT)
+            self.arming_status.wait(self.timeouts.arming_timeout)
 
     def stage(self):
         self.wait_on_arming_if_started()
         if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
-            self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
+            self.async_stage().wait(timeout=self.timeouts.arming_timeout)
 
     def stop_odin_when_all_frames_collected(self):
         LOGGER.info("Waiting on all frames")
@@ -111,7 +132,7 @@ class EigerDetector(Device):
             await_value(
                 self.odin.file_writer.num_captured,
                 self.detector_params.full_number_of_images,
-            ).wait(self.ALL_FRAMES_TIMEOUT)
+            ).wait(self.timeouts.all_frames_timeout)
         finally:
             LOGGER.info("Stopping Odin")
             self.odin.stop().wait(5)
@@ -124,7 +145,9 @@ class EigerDetector(Device):
                 # In free run mode we have to manually stop odin
                 self.stop_odin_when_all_frames_collected()
 
-            self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+            self.odin.file_writer.start_timeout.set(1).wait(
+                self.timeouts.general_status_timeout
+            )
             LOGGER.info("Waiting on filewriter to finish")
             self.filewriters_finished.wait(30)
 
@@ -132,7 +155,7 @@ class EigerDetector(Device):
         finally:
             self.disarm_detector()
             status_ok = self.odin.check_and_wait_for_odin_state(
-                self.GENERAL_STATUS_TIMEOUT
+                self.timeouts.general_status_timeout
             )
             self.disable_roi_mode()
         return status_ok
@@ -142,10 +165,12 @@ class EigerDetector(Device):
         LOGGER.info("Eiger stop() called - cleaning up...")
         self.wait_on_arming_if_started()
         stop_status = self.odin.stop()
-        self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.odin.file_writer.start_timeout.set(1).wait(
+            self.timeouts.general_status_timeout
+        )
         self.disarm_detector()
         stop_status &= self.disable_roi_mode()
-        stop_status.wait(self.GENERAL_STATUS_TIMEOUT)
+        stop_status.wait(self.timeouts.general_status_timeout)
         # See https://github.com/DiamondLightSource/hyperion/issues/1395
         LOGGER.info("Turning off Eiger dev/shm streaming")
         self.odin.fan.dev_shm_enable.set(0).wait()
@@ -166,19 +191,19 @@ class EigerDetector(Device):
         )
 
         status = self.cam.roi_mode.set(
-            1 if enable else 0, timeout=self.GENERAL_STATUS_TIMEOUT
+            1 if enable else 0, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_height.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_width.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_row_chunks.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_col_chunks.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
 
         return status
@@ -186,25 +211,29 @@ class EigerDetector(Device):
     def set_cam_pvs(self) -> AndStatus:
         assert self.detector_params is not None
         status = self.cam.acquire_time.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.acquire_period.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
+        )
+        status &= self.cam.num_exposures.set(
+            1, timeout=self.timeouts.general_status_timeout
         )
-        status &= self.cam.num_exposures.set(1, timeout=self.GENERAL_STATUS_TIMEOUT)
         status &= self.cam.image_mode.set(
-            self.cam.ImageMode.MULTIPLE, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.cam.ImageMode.MULTIPLE, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.trigger_mode.set(
             InternalEigerTriggerMode.EXTERNAL_SERIES.value,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
     def set_odin_number_of_frame_chunks(self) -> Status:
         assert self.detector_params is not None
         status = self.odin.file_writer.num_frames_chunks.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         return status
 
@@ -212,16 +241,20 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         file_prefix = self.detector_params.full_filename
         status = self.odin.file_writer.file_path.set(
-            self.detector_params.directory, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.directory, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.file_name.set(
-            file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            file_prefix, timeout=self.timeouts.general_status_timeout
         )
         status &= await_value(
-            self.odin.meta.file_name, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.meta.file_name,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= await_value(
-            self.odin.file_writer.id, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.file_writer.id,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -231,19 +264,22 @@ class EigerDetector(Device):
             self.detector_params.detector_distance
         )
         status = self.cam.beam_center_x.set(
-            beam_x_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_x_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.beam_center_y.set(
-            beam_y_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_y_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.det_distance.set(
-            self.detector_params.detector_distance, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.detector_distance,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_start.set(
-            self.detector_params.omega_start, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_start,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_incr.set(
-            self.detector_params.omega_increment, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_increment,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -259,7 +295,7 @@ class EigerDetector(Device):
         current_energy = self.cam.photon_energy.get()
         if abs(current_energy - energy) > tolerance:
             return self.cam.photon_energy.set(
-                energy, timeout=self.GENERAL_STATUS_TIMEOUT
+                energy, timeout=self.timeouts.general_status_timeout
             )
         else:
             status = Status()
@@ -275,45 +311,46 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         status = self.cam.num_images.set(
             self.detector_params.num_images_per_trigger,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         if self.detector_params.trigger_mode == TriggerMode.FREE_RUN:
             # The Eiger can't actually free run so we set a very large number of frames
             status &= self.cam.num_triggers.set(
-                FREE_RUN_MAX_IMAGES, timeout=self.GENERAL_STATUS_TIMEOUT
+                FREE_RUN_MAX_IMAGES, timeout=self.timeouts.general_status_timeout
             )
             # Setting Odin to write 0 frames tells it to write until externally stopped
             status &= self.odin.file_writer.num_capture.set(
-                0, timeout=self.GENERAL_STATUS_TIMEOUT
+                0, timeout=self.timeouts.general_status_timeout
             )
         elif self.detector_params.trigger_mode == TriggerMode.SET_FRAMES:
             status &= self.cam.num_triggers.set(
-                self.detector_params.num_triggers, timeout=self.GENERAL_STATUS_TIMEOUT
+                self.detector_params.num_triggers,
+                timeout=self.timeouts.general_status_timeout,
             )
             status &= self.odin.file_writer.num_capture.set(
                 self.detector_params.full_number_of_images,
-                timeout=self.GENERAL_STATUS_TIMEOUT,
+                timeout=self.timeouts.general_status_timeout,
             )
 
         return status
 
     def _wait_for_odin_status(self) -> StatusBase:
         self.forward_bit_depth_to_filewriter()
-        await_value(self.odin.meta.active, 1).wait(self.GENERAL_STATUS_TIMEOUT)
+        await_value(self.odin.meta.active, 1).wait(self.timeouts.general_status_timeout)
 
         status = self.odin.file_writer.capture.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         LOGGER.info("Eiger staging: awaiting odin metadata")
         status &= await_value(
-            self.odin.meta.ready, 1, timeout=self.META_FILE_READY_TIMEOUT
+            self.odin.meta.ready, 1, timeout=self.timeouts.meta_file_ready_timeout
         )
         return status
 
     def _wait_fan_ready(self) -> StatusBase:
         self.filewriters_finished = self.odin.create_finished_status()
         LOGGER.info("Eiger staging: awaiting odin fan ready")
-        return await_value(self.odin.fan.ready, 1, self.GENERAL_STATUS_TIMEOUT)
+        return await_value(self.odin.fan.ready, 1, self.timeouts.general_status_timeout)
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
@@ -324,7 +361,7 @@ class EigerDetector(Device):
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
         self.odin.file_writer.data_type.set(f"UInt{bit_depth}").wait(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
 
     def change_dev_shm(self, enable_dev_shm: bool):
@@ -332,7 +369,7 @@ class EigerDetector(Device):
         return self.odin.fan.dev_shm_enable.set(1 if enable_dev_shm else 0)
 
     def disarm_detector(self):
-        self.cam.acquire.set(0).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.cam.acquire.set(0).wait(self.timeouts.general_status_timeout)
 
     def do_arming_chain(self) -> Status:
         functions_to_do_arm = []
@@ -355,7 +392,9 @@ class EigerDetector(Device):
             self.set_num_triggers_and_captures,
             lambda: await_value(self.stale_params, 0, 60),
             self._wait_for_odin_status,
-            lambda: self.cam.acquire.set(1, timeout=self.GENERAL_STATUS_TIMEOUT),
+            lambda: self.cam.acquire.set(
+                1, timeout=self.timeouts.general_status_timeout
+            ),
             self._wait_fan_ready,
             self._finish_arm,
         ]

dodal/devices/fast_grid_scan.py

@@ -15,7 +15,7 @@ from ophyd_async.core import (
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,

dodal/devices/fluorescence_detector_motion.py

@@ -1,12 +1,10 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r
 
-
-class FluorescenceDetectorControlState(Enum):
-    OUT = 0
-    IN = 1
+class FluorescenceDetectorControlState(StrictEnum):
+    OUT = "Out"
+    IN = "In"
 
 
 class FluorescenceDetector(StandardReadable):