dls-dodal 1.39.0__py3-none-any.whl → 1.41.0__py3-none-any.whl

dodal/devices/aperturescatterguard.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 
-from bluesky.protocols import Movable
+from bluesky.protocols import Movable, Preparable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
@@ -21,6 +21,15 @@ class InvalidApertureMove(Exception):
     pass
 
 
+class _GDAParamApertureValue(StrictEnum):
+    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
+
+    ROBOT_LOAD = "ROBOT_LOAD"
+    SMALL = "SMALL_APERTURE"
+    MEDIUM = "MEDIUM_APERTURE"
+    LARGE = "LARGE_APERTURE"
+
+
 class AperturePosition(BaseModel):
     """
     Represents one of the available positions for the Aperture-Scatterguard.
@@ -65,7 +74,7 @@ class AperturePosition(BaseModel):
 
     @staticmethod
     def from_gda_params(
-        name: ApertureValue,
+        name: _GDAParamApertureValue,
         radius: float,
         params: GDABeamlineParameters,
     ) -> AperturePosition:
@@ -80,12 +89,16 @@ class AperturePosition(BaseModel):
 
 
 class ApertureValue(StrictEnum):
-    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
+    """The possible apertures that can be selected.
+
+    Changing these means changing the external paramter model of Hyperion.
+    See https://github.com/DiamondLightSource/mx-bluesky/issues/760
+    """
 
-    ROBOT_LOAD = "ROBOT_LOAD"
     SMALL = "SMALL_APERTURE"
     MEDIUM = "MEDIUM_APERTURE"
     LARGE = "LARGE_APERTURE"
+    OUT_OF_BEAM = "Out of beam"
 
     def __str__(self):
         return self.name.capitalize()
@@ -95,22 +108,53 @@ def load_positions_from_beamline_parameters(
     params: GDABeamlineParameters,
 ) -> dict[ApertureValue, AperturePosition]:
     return {
-        ApertureValue.ROBOT_LOAD: AperturePosition.from_gda_params(
-            ApertureValue.ROBOT_LOAD, 0, params
+        ApertureValue.OUT_OF_BEAM: AperturePosition.from_gda_params(
+            _GDAParamApertureValue.ROBOT_LOAD, 0, params
         ),
         ApertureValue.SMALL: AperturePosition.from_gda_params(
-            ApertureValue.SMALL, 20, params
+            _GDAParamApertureValue.SMALL, 20, params
         ),
         ApertureValue.MEDIUM: AperturePosition.from_gda_params(
-            ApertureValue.MEDIUM, 50, params
+            _GDAParamApertureValue.MEDIUM, 50, params
         ),
         ApertureValue.LARGE: AperturePosition.from_gda_params(
-            ApertureValue.LARGE, 100, params
+            _GDAParamApertureValue.LARGE, 100, params
         ),
     }
 
 
-class ApertureScatterguard(StandardReadable, Movable):
+class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable):
+    """Move the aperture and scatterguard assembly in a safe way. There are two ways to
+    interact with the device depending on if you want simplicity or move flexibility.
+
+    Examples:
+        The simple interface is using::
+
+            await aperture_scatterguard.set(ApertureValue.LARGE)
+
+        This will move the assembly so that the large aperture is in the beam, regardless
+        of where the assembly currently is.
+
+        We may also want to move the assembly out of the beam with::
+
+            await aperture_scatterguard.set(ApertureValue.OUT_OF_BEAM)
+
+        Note, to make sure we do this as quickly as possible, the scatterguard will stay
+        in the same position relative to the aperture.
+
+        We may then want to keep the assembly out of the beam whilst asynchronously preparing
+        the other axes for the aperture that's to follow::
+
+            await aperture_scatterguard.prepare(ApertureValue.LARGE)
+
+        Then, at a later time, move back into the beam::
+
+            await aperture_scatterguard.set(ApertureValue.LARGE)
+
+        Given the prepare has been done this move will now be faster as only the y is
+        left to move.
+    """
+
     def __init__(
         self,
         loaded_positions: dict[ApertureValue, AperturePosition],
@@ -135,6 +179,7 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.radius,
             ],
         )
+
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
@@ -142,15 +187,85 @@ class ApertureScatterguard(StandardReadable, Movable):
 
         super().__init__(name)
 
-    def get_position_from_gda_aperture_name(
-        self, gda_aperture_name: str
-    ) -> ApertureValue:
-        return ApertureValue(gda_aperture_name)
-
     @AsyncStatus.wrap
     async def set(self, value: ApertureValue):
+        """This set will move the aperture into the beam or move the whole assembly out"""
+
         position = self._loaded_positions[value]
-        await self._safe_move_within_datacollection_range(position, value)
+        await self._check_safe_to_move(position.aperture_z)
+
+        if value == ApertureValue.OUT_OF_BEAM:
+            out_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
+            await self.aperture.y.set(out_y)
+        else:
+            await self._safe_move_whilst_in_beam(position)
+
+    async def _check_safe_to_move(self, expected_z_position: float):
+        """The assembly is moved (in z) to be under the table when the beamline is not
+        in use. If we try and move whilst in the incorrect Z position we will collide
+        with the table.
+
+        Additionally, because there are so many collision possibilities in the device we
+        throw an error if any of the axes are already moving.
+        """
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        diff_on_z = abs(current_ap_z - expected_z_position)
+        aperture_z_tolerance = self._tolerances.aperture_z
+        if diff_on_z > aperture_z_tolerance:
+            raise InvalidApertureMove(
+                f"Current aperture z ({current_ap_z}), outside of tolerance ({aperture_z_tolerance}) from target ({expected_z_position})."
+            )
+
+        all_axes = [
+            self.aperture.x,
+            self.aperture.y,
+            self.aperture.z,
+            self.scatterguard.x,
+            self.scatterguard.y,
+        ]
+        for axis in all_axes:
+            axis_stationary = await axis.motor_done_move.get_value()
+            if not axis_stationary:
+                raise InvalidApertureMove(
+                    f"{axis.name} is still moving. Wait for it to finish before"
+                    "triggering another move."
+                )
+
+    async def _safe_move_whilst_in_beam(self, position: AperturePosition):
+        """
+        Move the aperture and scatterguard combo safely to a new position.
+        See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
+        for why this is required. TLDR is that we have a collision at the top of y so we need
+        to make sure we move the assembly down before we move the scatterguard up.
+        """
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
+
+        if aperture_y > current_ap_y:
+            # Assembly needs to move up so move the scatterguard down first
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
 
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
@@ -167,6 +282,11 @@ class ApertureScatterguard(StandardReadable, Movable):
             self.scatterguard.y.set(scatterguard_y),
         )
 
+    async def _is_out_of_beam(self) -> bool:
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
+        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
+
     async def _get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
@@ -174,16 +294,14 @@ class ApertureScatterguard(StandardReadable, Movable):
         mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
         If no position is found then raises InvalidApertureMove.
         """
-        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
-        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
         if await self.aperture.large.get_value(cached=False) == 1:
             return ApertureValue.LARGE
         elif await self.aperture.medium.get_value(cached=False) == 1:
             return ApertureValue.MEDIUM
         elif await self.aperture.small.get_value(cached=False) == 1:
             return ApertureValue.SMALL
-        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
-            return ApertureValue.ROBOT_LOAD
+        elif await self._is_out_of_beam():
+            return ApertureValue.OUT_OF_BEAM
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
 
@@ -191,56 +309,24 @@ class ApertureScatterguard(StandardReadable, Movable):
         current_value = await self._get_current_aperture_position()
         return self._loaded_positions[current_value].radius
 
-    async def _safe_move_within_datacollection_range(
-        self, position: AperturePosition, value: ApertureValue
-    ):
-        """
-        Move the aperture and scatterguard combo safely to a new position.
-        See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
-        for why this is required.
-        """
-        assert self._loaded_positions is not None
-
-        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
-        if not ap_z_in_position:
-            raise InvalidApertureMove(
-                "ApertureScatterguard z is still moving. Wait for it to finish "
-                "before triggering another move."
-            )
+    @AsyncStatus.wrap
+    async def prepare(self, value: ApertureValue):
+        """Moves the assembly to the position for the specified aperture, whilst keeping
+        it out of the beam if it already is so.
 
-        current_ap_z = await self.aperture.z.user_readback.get_value()
-        diff_on_z = abs(current_ap_z - position.aperture_z)
-        if diff_on_z > self._tolerances.aperture_z:
-            raise InvalidApertureMove(
-                "ApertureScatterguard safe move is not yet defined for positions "
-                "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
-                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
+        Moving the assembly whilst out of the beam has no collision risk so we can just
+        move all the motors together.
+        """
+        if await self._is_out_of_beam():
+            aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
+                self._loaded_positions[value].values
             )
 
-        current_ap_y = await self.aperture.y.user_readback.get_value()
-
-        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
-            position.values
-        )
-
-        if position.aperture_y > current_ap_y:
-            await asyncio.gather(
-                self.scatterguard.x.set(scatterguard_x),
-                self.scatterguard.y.set(scatterguard_y),
-            )
-            await asyncio.gather(
-                self.aperture.x.set(aperture_x),
-                self.aperture.y.set(aperture_y),
-                self.aperture.z.set(aperture_z),
-            )
-        else:
             await asyncio.gather(
                 self.aperture.x.set(aperture_x),
-                self.aperture.y.set(aperture_y),
                 self.aperture.z.set(aperture_z),
-            )
-
-            await asyncio.gather(
                 self.scatterguard.x.set(scatterguard_x),
                 self.scatterguard.y.set(scatterguard_y),
             )
+        else:
+            await self.set(value)

dodal/devices/apple2_undulator.py

@@ -1,13 +1,15 @@
 import abc
 import asyncio
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
+    SignalR,
+    SignalW,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
@@ -19,6 +21,8 @@ from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
 
+T = TypeVar("T")
+
 
 class UndulatorGateStatus(StrictEnum):
     OPEN = "Open"
@@ -88,7 +92,56 @@ MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
 MAXIMUM_GAP_MOTOR_POSITION = 100
 
 
-class UndulatorGap(StandardReadable, Movable):
+async def estimate_motor_timeout(
+    setpoint: SignalR, curr_pos: SignalR, velocity: SignalR
+):
+    vel = await velocity.get_value()
+    cur_pos = await curr_pos.get_value()
+    target_pos = float(await setpoint.get_value())
+    return abs((target_pos - cur_pos) * 2.0 / vel) + 1
+
+
+class SafeUndulatorMover(StandardReadable, Movable[T], Generic[T]):
+    """A device that will check it's safe to move the undulator before moving it and
+    wait for the undulator to be safe again before calling the move complete.
+    """
+
+    def __init__(self, set_move: SignalW, prefix: str, name: str = ""):
+        # Gate keeper open when move is requested, closed when move is completed
+        self.gate = epics_signal_r(UndulatorGateStatus, prefix + "BLGATE")
+
+        split_pv = prefix.split("-")
+        fault_pv = f"{split_pv[0]}-{split_pv[1]}-STAT-{split_pv[3]}ANYFAULT"
+        self.fault = epics_signal_r(float, fault_pv)
+        self.set_move = set_move
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: T) -> None:
+        LOGGER.info(f"Setting {self.name} to {value}")
+        await self.raise_if_cannot_move()
+        await self._set_demand_positions(value)
+        timeout = await self.get_timeout()
+        LOGGER.info(f"Moving {self.name} to {value} with timeout = {timeout}")
+        await self.set_move.set(value=1, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
+
+    @abc.abstractmethod
+    async def _set_demand_positions(self, value: T) -> None:
+        """Set the demand positions on the device without actually hitting move."""
+
+    @abc.abstractmethod
+    async def get_timeout(self) -> float:
+        """Get the timeout for the move based on an estimate of how long it will take."""
+
+    async def raise_if_cannot_move(self) -> None:
+        if await self.fault.get_value() != 0:
+            raise RuntimeError(f"{self.name} is in fault state")
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
+            raise RuntimeError(f"{self.name} is already in motion.")
+
+
+class UndulatorGap(SafeUndulatorMover[float]):
     """A device with a collection of epics signals to set Apple 2 undulator gap motion.
     Only PV used by beamline are added the full list is here:
     /dls_sw/work/R3.14.12.7/support/insertionDevice/db/IDGapVelocityControl.template
@@ -113,21 +166,17 @@ class UndulatorGap(StandardReadable, Movable):
         )
         # Nothing move until this is set to 1 and it will return to 0 when done
         self.set_move = epics_signal_rw(int, prefix + "BLGSETP")
-        # Gate keeper open when move is requested, closed when move is completed
-        self.gate = epics_signal_r(UndulatorGateStatus, prefix + "BLGATE")
+
         # These are gap velocity limit.
         self.max_velocity = epics_signal_r(float, prefix + "BLGSETVEL.HOPR")
         self.min_velocity = epics_signal_r(float, prefix + "BLGSETVEL.LOPR")
         # These are gap limit.
         self.high_limit_travel = epics_signal_r(float, prefix + "BLGAPMTR.HLM")
         self.low_limit_travel = epics_signal_r(float, prefix + "BLGAPMTR.LLM")
-        split_pv = prefix.split("-")
-        self.fault = epics_signal_r(
-            float,
-            f"{split_pv[0]}-{split_pv[1]}-STAT-{split_pv[3]}ANYFAULT",
-        )
+
         # This is calculated acceleration from speed
         self.acceleration_time = epics_signal_r(float, prefix + "IDGSETACC")
+
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Unit
             self.motor_egu = epics_signal_r(str, prefix + "BLGAPMTR.EGU")
@@ -136,32 +185,15 @@ class UndulatorGap(StandardReadable, Movable):
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Gap readback value
             self.user_readback = epics_signal_r(float, prefix + "CURRGAPD")
-        super().__init__(name)
+        super().__init__(self.set_move, prefix, name)
 
-    @AsyncStatus.wrap
-    async def set(self, value) -> None:
-        LOGGER.info(f"Setting {self.name} to {value}")
-        await self.check_id_status()
-        await self.user_setpoint.set(value=str(value))
-        timeout = await self._cal_timeout()
-        LOGGER.info(f"Moving {self.name} to {value} with timeout = {timeout}")
-        await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
-
-    async def _cal_timeout(self) -> float:
-        vel = await self.velocity.get_value()
-        cur_pos = await self.user_readback.get_value()
-        target_pos = float(await self.user_setpoint.get_value())
-        return abs((target_pos - cur_pos) * 2.0 / vel) + 1
-
-    async def check_id_status(self) -> None:
-        if await self.fault.get_value() != 0:
-            raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
-            raise RuntimeError(f"{self.name} is already in motion.")
+    async def _set_demand_positions(self, value: float) -> None:
+        await self.user_setpoint.set(str(value))
 
     async def get_timeout(self) -> float:
-        return await self._cal_timeout()
+        return await estimate_motor_timeout(
+            self.user_setpoint, self.user_readback, self.velocity
+        )
 
 
 class UndulatorPhaseMotor(StandardReadable):
@@ -204,7 +236,7 @@ class UndulatorPhaseMotor(StandardReadable):
         super().__init__(name=name)
 
 
-class UndulatorPhaseAxes(StandardReadable, Movable):
+class UndulatorPhaseAxes(SafeUndulatorMover[Apple2PhasesVal]):
     """
     A collection of 4 phase Motor to make up the full id phase motion. We are using the diamond pv convention.
     e.g. top_outer == Q1
@@ -231,66 +263,36 @@ class UndulatorPhaseAxes(StandardReadable, Movable):
             self.btm_outer = UndulatorPhaseMotor(prefix=prefix, infix=btm_outer)
         # Nothing move until this is set to 1 and it will return to 0 when done.
         self.set_move = epics_signal_rw(int, f"{prefix}BL{top_outer}" + "MOVE")
-        self.gate = epics_signal_r(UndulatorGateStatus, prefix + "BLGATE")
-        split_pv = prefix.split("-")
-        temp_pv = f"{split_pv[0]}-{split_pv[1]}-STAT-{split_pv[3]}ANYFAULT"
-        self.fault = epics_signal_r(float, temp_pv)
-        super().__init__(name=name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: Apple2PhasesVal) -> None:
-        LOGGER.info(f"Setting {self.name} to {value}")
-
-        await self.check_id_status()
+        super().__init__(self.set_move, prefix, name)
 
+    async def _set_demand_positions(self, value: Apple2PhasesVal) -> None:
         await asyncio.gather(
             self.top_outer.user_setpoint.set(value=value.top_outer),
             self.top_inner.user_setpoint.set(value=value.top_inner),
             self.btm_inner.user_setpoint.set(value=value.btm_inner),
             self.btm_outer.user_setpoint.set(value=value.btm_outer),
         )
-        timeout = await self._cal_timeout()
-        await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
-    async def _cal_timeout(self) -> float:
+    async def get_timeout(self) -> float:
         """
         Get all four motor speed, current positions and target positions to calculate required timeout.
         """
-        velos = await asyncio.gather(
-            self.top_outer.velocity.get_value(),
-            self.top_inner.velocity.get_value(),
-            self.btm_inner.velocity.get_value(),
-            self.btm_outer.velocity.get_value(),
-        )
-        target_pos = await asyncio.gather(
-            self.top_outer.user_setpoint_demand_readback.get_value(),
-            self.top_inner.user_setpoint_demand_readback.get_value(),
-            self.btm_inner.user_setpoint_demand_readback.get_value(),
-            self.btm_outer.user_setpoint_demand_readback.get_value(),
-        )
-        cur_pos = await asyncio.gather(
-            self.top_outer.user_setpoint_readback.get_value(),
-            self.top_inner.user_setpoint_readback.get_value(),
-            self.btm_inner.user_setpoint_readback.get_value(),
-            self.btm_outer.user_setpoint_readback.get_value(),
+        axes = [self.top_outer, self.top_inner, self.btm_inner, self.btm_outer]
+        timeouts = await asyncio.gather(
+            *[
+                estimate_motor_timeout(
+                    axis.user_setpoint_demand_readback,
+                    axis.user_setpoint_readback,
+                    axis.velocity,
+                )
+                for axis in axes
+            ]
         )
-        move_distances = tuple(np.subtract(target_pos, cur_pos))
-        move_times = np.abs(np.divide(move_distances, velos))
-        longest_move_time = np.max(move_times)
-        return longest_move_time * 2 + 1
+        return np.max(timeouts)
 
-    async def check_id_status(self) -> None:
-        if await self.fault.get_value() != 0:
-            raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
-            raise RuntimeError(f"{self.name} is already in motion.")
-
-    async def get_timeout(self) -> float:
-        return await self._cal_timeout()
 
-
-class UndulatorJawPhase(StandardReadable, Movable):
+class UndulatorJawPhase(SafeUndulatorMover[float]):
     """
     A JawPhase movable, this is use for moving the jaw phase which is use to control the
     linear arbitrary polarisation but only one some of the beamline.
@@ -308,49 +310,22 @@ class UndulatorJawPhase(StandardReadable, Movable):
             self.jaw_phase = UndulatorPhaseMotor(prefix=prefix, infix=jaw_phase)
         # Nothing move until this is set to 1 and it will return to 0 when done
         self.set_move = epics_signal_rw(int, f"{prefix}BL{move_pv}" + "MOVE")
-        self.gate = epics_signal_r(UndulatorGateStatus, prefix + "BLGATE")
-        split_pv = prefix.split("-")
-        temp_pv = f"{split_pv[0]}-{split_pv[1]}-STAT-{split_pv[3]}ANYFAULT"
-        self.fault = epics_signal_r(float, temp_pv)
-        super().__init__(name=name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
-        LOGGER.info(f"Setting {self.name} to {value}")
+        super().__init__(self.set_move, prefix, name)
 
-        await self.check_id_status()
-
-        await asyncio.gather(
-            self.jaw_phase.user_setpoint.set(value=str(value)),
-        )
-        timeout = await self._cal_timeout()
-        await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
+    async def _set_demand_positions(self, value: float) -> None:
+        await self.jaw_phase.user_setpoint.set(value=str(value))
 
-    async def _cal_timeout(self) -> float:
+    async def get_timeout(self) -> float:
         """
         Get motor speed, current position and target position to calculate required timeout.
         """
-        velo, target_pos, cur_pos = await asyncio.gather(
-            self.jaw_phase.velocity.get_value(),
-            self.jaw_phase.user_setpoint_demand_readback.get_value(),
-            self.jaw_phase.user_setpoint_readback.get_value(),
+        return await estimate_motor_timeout(
+            self.jaw_phase.user_setpoint_demand_readback,
+            self.jaw_phase.user_setpoint_readback,
+            self.jaw_phase.velocity,
         )
 
-        move_distances = target_pos - cur_pos
-        move_times = np.abs(move_distances / velo)
-
-        return move_times * 2 + 1
-
-    async def check_id_status(self) -> None:
-        if await self.fault.get_value() != 0:
-            raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
-            raise RuntimeError(f"{self.name} is already in motion.")
-
-    async def get_timeout(self) -> float:
-        return await self._cal_timeout()
-
 
 class Apple2(StandardReadable, Movable):
     """
@@ -437,7 +412,7 @@ 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().raise_if_cannot_move()
         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),

dodal/devices/attenuator/attenuator.py

@@ -29,7 +29,7 @@ class ReadOnlyAttenuator(StandardReadable):
         super().__init__(name)
 
 
-class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable):
+class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
     In this attenuator, each filter can be in one of two states: IN or OUT
 

dodal/devices/backlight.py

@@ -15,7 +15,7 @@ class BacklightPosition(StrictEnum):
     OUT = "Out"
 
 
-class Backlight(StandardReadable, Movable):
+class Backlight(StandardReadable, Movable[BacklightPosition]):
     """Simple device to trigger the pneumatic in/out."""
 
     TIME_TO_MOVE_S = 1.0  # Tested using a stopwatch on the beamline 09/2024

dodal/devices/bimorph_mirror.py

@@ -41,7 +41,7 @@ class BimorphMirrorStatus(StrictEnum):
     ERROR = "Error"
 
 
-class BimorphMirrorChannel(StandardReadable, Movable, EpicsDevice):
+class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
     """Collection of PVs comprising a single bimorph channel.
 
     Attributes:
@@ -66,7 +66,7 @@ class BimorphMirrorChannel(StandardReadable, Movable, EpicsDevice):
         await self.output_voltage.set(value)
 
 
-class BimorphMirror(StandardReadable, Movable):
+class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
     """Class to represent CAENels Bimorph Mirrors.
 
     Attributes:

dodal/devices/eiger.py

@@ -2,6 +2,7 @@
 from dataclasses import dataclass
 from enum import Enum
 
+from bluesky.protocols import Stageable
 from ophyd import Component, Device, EpicsSignalRO, Signal
 from ophyd.areadetector.cam import EigerDetectorCam
 from ophyd.status import AndStatus, Status, StatusBase
@@ -42,7 +43,7 @@ AVAILABLE_TIMEOUTS = {
 }
 
 
-class EigerDetector(Device):
+class EigerDetector(Device, Stageable):
     class ArmingSignal(Signal):
         def set(self, value, *, timeout=None, settle_time=None, **kwargs):
             assert isinstance(self.parent, EigerDetector)
@@ -161,7 +162,7 @@ class EigerDetector(Device):
             status_ok = self.odin.check_and_wait_for_odin_state(
                 self.timeouts.general_status_timeout
             )
-            self.disable_roi_mode()
+            self.disable_roi_mode().wait(self.timeouts.general_status_timeout)
         self.disarming_status.set_finished()
         return status_ok