dls-dodal 1.38.0__py3-none-any.whl → 1.40.0__py3-none-any.whl

dodal/devices/apple2_undulator.py

@@ -8,6 +8,8 @@ from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
+    SignalR,
+    SignalW,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
@@ -88,7 +90,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):
+    """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) -> 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) -> 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):
     """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 +164,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 +183,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)
-
-    @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
+        super().__init__(self.set_move, prefix, name)
 
-    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) -> 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 +234,7 @@ class UndulatorPhaseMotor(StandardReadable):
         super().__init__(name=name)
 
 
-class UndulatorPhaseAxes(StandardReadable, Movable):
+class UndulatorPhaseAxes(SafeUndulatorMover):
     """
     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 +261,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
-
-    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()
+        return np.max(timeouts)
 
 
-class UndulatorJawPhase(StandardReadable, Movable):
+class UndulatorJawPhase(SafeUndulatorMover):
     """
     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 +308,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}")
-
-        await self.check_id_status()
+        super().__init__(self.set_move, prefix, name)
 
-        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 +410,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/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)
@@ -62,6 +63,9 @@ class EigerDetector(Device):
     arming_status = Status()
     arming_status.set_finished()
 
+    disarming_status = Status()
+    disarming_status.set_finished()
+
     def __init__(self, beamline: str = "i03", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
@@ -140,6 +144,7 @@ class EigerDetector(Device):
     def unstage(self) -> bool:
         assert self.detector_params is not None
         try:
+            self.disarming_status = Status()
             self.wait_on_arming_if_started()
             if self.detector_params.trigger_mode == TriggerMode.FREE_RUN:
                 # In free run mode we have to manually stop odin
@@ -157,24 +162,29 @@ 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
 
     def stop(self, *args):
         """Emergency stop the device, mainly used to clean up after error."""
         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.timeouts.general_status_timeout
-        )
-        self.disarm_detector()
-        stop_status &= self.disable_roi_mode()
-        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()
-        LOGGER.info("Eiger has successfully been stopped")
+        if not self.disarming_status.done:
+            LOGGER.info("Eiger still disarming, waiting on disarm")
+            self.disarming_status.wait(self.timeouts.arming_timeout)
+        else:
+            self.wait_on_arming_if_started()
+            stop_status = self.odin.stop()
+            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.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()
+            LOGGER.info("Eiger has successfully been stopped")
 
     def disable_roi_mode(self):
         return self.change_roi_mode(False)

dodal/devices/fast_grid_scan.py

@@ -1,3 +1,4 @@
+import asyncio
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
@@ -9,9 +10,7 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     Signal,
-    SignalR,
     SignalRW,
-    SoftSignalBackend,
     StandardReadable,
     wait_for_value,
 )
@@ -24,6 +23,7 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -45,8 +45,19 @@ class GridAxis:
         # refering to the first position
         return self.steps_to_motor_position(self.full_steps - 1)
 
-    def is_within(self, steps):
-        return 0 <= steps <= self.full_steps
+    def is_within(self, steps: float):
+        """
+        Determine whether a single axis coordinate is within the grid.
+        The coordinate is from a continuous coordinate space based on the
+        XRC grid where the origin corresponds to the centre of the first grid box.
+
+        Args:
+            steps: The coordinate to check
+
+        Returns:
+            True if the coordinate falls within the grid.
+        """
+        return -0.5 <= steps <= self.full_steps - 0.5
 
 
 class GridScanParamsCommon(AbstractExperimentWithBeamParams):
@@ -159,21 +170,6 @@ class MotionProgram(Device):
         self.program_number = epics_signal_r(float, prefix + "CS1:PROG_NUM")
 
 
-class ExpectedImages(SignalR[int]):
-    def __init__(self, parent: "FastGridScanCommon") -> None:
-        super().__init__(SoftSignalBackend(int))
-        self.parent = parent
-
-    async def get_value(self, cached: bool | None = None):
-        assert isinstance(self.parent, FastGridScanCommon)
-        x = await self.parent.x_steps.get_value()
-        y = await self.parent.y_steps.get_value()
-        z = await self.parent.z_steps.get_value()
-        first_grid = x * y
-        second_grid = x * z
-        return first_grid + second_grid
-
-
 class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
     """Device for a general fast grid scan
 
@@ -206,7 +202,9 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.run_cmd = epics_signal_x(f"{prefix}RUN.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = ExpectedImages(parent=self)
+        self.expected_images = create_hardware_backed_soft_signal(
+            float, self._calculate_expected_images
+        )
 
         self.motion_program = MotionProgram(smargon_prefix)
 
@@ -232,6 +230,17 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
+    async def _calculate_expected_images(self):
+        x, y, z = await asyncio.gather(
+            self.x_steps.get_value(),
+            self.y_steps.get_value(),
+            self.z_steps.get_value(),
+        )
+        LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
+        first_grid = x * y
+        second_grid = x * z
+        return first_grid + second_grid
+
     @AsyncStatus.wrap
     async def kickoff(self):
         curr_prog = await self.motion_program.program_number.get_value()

dodal/devices/hutch_shutter.py

@@ -8,9 +8,16 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_w
 
+from dodal.log import LOGGER
+
 HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
 
 
+# Enable to allow testing when the beamline is down, do not change in production!
+TEST_MODE = False
+# will be made more generic in https://github.com/DiamondLightSource/dodal/issues/754
+
+
 class ShutterNotSafeToOperateError(Exception):
     pass
 
@@ -64,8 +71,8 @@ class HutchShutter(StandardReadable, Movable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.control = epics_signal_w(ShutterDemand, prefix + "CON")
-        self.status = epics_signal_r(ShutterState, prefix + "STA")
+        self.control = epics_signal_w(ShutterDemand, f"{prefix}CON")
+        self.status = epics_signal_r(ShutterState, f"{prefix}STA")
 
         bl_prefix = prefix.split("-")[0]
         self.interlock = HutchInterlock(bl_prefix)
@@ -75,18 +82,24 @@ class HutchShutter(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
         interlock_state = await self.interlock.shutter_safe_to_operate()
-        if not interlock_state:
+        if not interlock_state and not TEST_MODE:
+            # If not in test mode, fail. If in test mode, the optics hutch may be open.
             raise ShutterNotSafeToOperateError(
                 "The hutch has not been locked, not operating shutter."
             )
-        if value == ShutterDemand.OPEN:
-            await self.control.set(ShutterDemand.RESET, wait=True)
-            await self.control.set(value, wait=True)
-            return await wait_for_value(
-                self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
-            )
+        if not TEST_MODE:
+            if value == ShutterDemand.OPEN:
+                await self.control.set(ShutterDemand.RESET, wait=True)
+                await self.control.set(value, wait=True)
+                return await wait_for_value(
+                    self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
+                )
+            else:
+                await self.control.set(value, wait=True)
+                return await wait_for_value(
+                    self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
+                )
         else:
-            await self.control.set(value, wait=True)
-            return await wait_for_value(
-                self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
+            LOGGER.warning(
+                "Running in test mode, will not operate the experiment shutter."
             )

dodal/devices/i04/transfocator.py

@@ -37,32 +37,18 @@ class Transfocator(StandardReadable):
 
         super().__init__(name=name)
 
-    async def _observe_beamsize_microns(self):
-        is_set_filters_done = False
-
-        async def set_based_on_prediction(value: float):
-            if not math.isclose(
-                self.latest_pred_vertical_num_lenses, value, abs_tol=1e-8
-            ):
-                # We can only put an integer number of lenses in the beam but the
-                # calculation in the IOC returns the theoretical float number of lenses
-                nonlocal is_set_filters_done
-                value = round(value)
-                LOGGER.info(f"Transfocator setting {value} filters")
-                await self.number_filters_sp.set(value)
-                await self.start.set(1)
-                LOGGER.info("Waiting for start_rbv to change to 1")
-                await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
-                LOGGER.info("Waiting for start_rbv to change to 0")
-                await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
-                self.latest_pred_vertical_num_lenses = value
-                is_set_filters_done = True
-
-        # The value hasn't changed so assume the device is already set up correctly
-        async for value in observe_value(self.predicted_vertical_num_lenses):
-            await set_based_on_prediction(value)
-            if is_set_filters_done:
-                break
+    async def set_based_on_prediction(self, value: float):
+        # We can only put an integer number of lenses in the beam but the
+        # calculation in the IOC returns the theoretical float number of lenses
+        value = round(value)
+        LOGGER.info(f"Transfocator setting {value} filters")
+        await self.number_filters_sp.set(value)
+        await self.start.set(1)
+        LOGGER.info("Waiting for start_rbv to change to 1")
+        await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
+        LOGGER.info("Waiting for start_rbv to change to 0")
+        await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
+        self.latest_pred_vertical_num_lenses = value
 
     @AsyncStatus.wrap
     async def set(self, value: float):
@@ -81,10 +67,17 @@ class Transfocator(StandardReadable):
 
         if await self.beamsize_set_microns.get_value() != value:
             # Logic in the IOC calculates predicted_vertical_num_lenses when beam_set_microns changes
-            await asyncio.gather(
-                self.beamsize_set_microns.set(value),
-                self._observe_beamsize_microns(),
+
+            # Register an observer before setting beamsize_set_microns to ensure we don't miss changes
+            predicted_vertical_num_lenses_iterator = observe_value(
+                self.predicted_vertical_num_lenses, timeout=self.TIMEOUT
             )
+            # Keep initial prediction before setting to later compare with change after setting
+            current_prediction = await anext(predicted_vertical_num_lenses_iterator)
+            await self.beamsize_set_microns.set(value)
+            accepted_prediction = await anext(predicted_vertical_num_lenses_iterator)
+            if not math.isclose(current_prediction, accepted_prediction, abs_tol=1e-8):
+                await self.set_based_on_prediction(accepted_prediction)
 
         number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
             self.number_filters_sp.get_value(),

dodal/devices/i10/rasor/rasor_scaler_cards.py

@@ -5,8 +5,8 @@ from dodal.devices.current_amplifiers import StruckScaler
 
 class RasorScalerCard1(Device):
     def __init__(self, prefix, name: str = "") -> None:
-        self.mon = StruckScaler(prefix=prefix, suffix=".16")
-        self.det = StruckScaler(prefix=prefix, suffix=".17")
-        self.fluo = StruckScaler(prefix=prefix, suffix=".18")
-        self.drain = StruckScaler(prefix=prefix, suffix=".19")
+        self.mon = StruckScaler(prefix=prefix, suffix=".S17")
+        self.det = StruckScaler(prefix=prefix, suffix=".S18")
+        self.fluo = StruckScaler(prefix=prefix, suffix=".S19")
+        self.drain = StruckScaler(prefix=prefix, suffix=".S20")
         super().__init__(name)

dodal/devices/i13_1/merlin.py

@@ -1,6 +1,7 @@
 from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics import adcore
 
+from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
 from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
@@ -13,12 +14,12 @@ class Merlin(StandardDetector):
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="CAM:",
-        hdf_suffix="HDF:",
+        drv_suffix=CAM_SUFFIX,
+        fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
         self.drv = MerlinDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(
             MerlinController(self.drv),

dodal/devices/i13_1/merlin_controller.py

@@ -4,15 +4,15 @@ import logging
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    DetectorController,
     TriggerInfo,
 )
 from ophyd_async.epics import adcore
+from ophyd_async.epics.adcore import ADBaseController
 
 from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
 
 
-class MerlinController(DetectorController):
+class MerlinController(ADBaseController):
     def __init__(
         self,
         driver: MerlinDriverIO,
@@ -37,11 +37,6 @@ class MerlinController(DetectorController):
             self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
         )
 
-    async def arm(self):
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states, timeout=self.frame_timeout
-        )
-
     async def wait_for_idle(self):
         if self._arm_status:
             await self._arm_status