dls-dodal 1.39.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)
@@ -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
 

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
 
@@ -170,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
 
@@ -217,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)
 
@@ -243,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/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

dodal/devices/i18/KBMirror.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class KBMirror(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        self._prefix = prefix
+        with self.add_children_as_readables():
+            self.x = epics_signal_rw(float, prefix + "X")
+            self.y = epics_signal_rw(float, prefix + "Y")
+            self.bend1 = epics_signal_rw(float, prefix + "BEND1")
+            self.bend2 = epics_signal_rw(float, prefix + "BEND2")
+            self.curve = epics_signal_rw(float, prefix + "CURVE")
+            self.ellip = epics_signal_rw(float, prefix + "ELLIP")
+        super().__init__(name=name)

dodal/devices/i18/diode.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_r
+
+
+class Diode(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        self._prefix = prefix
+        with self.add_children_as_readables():
+            self.signal = epics_signal_r(float, prefix + "B:DIODE:I")
+
+        super().__init__(name=name)

dodal/devices/i18/table.py

@@ -0,0 +1,14 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.motor import Motor
+
+
+class Table(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.z = Motor(prefix + "Z")
+            self.theta = Motor(prefix + "THETA")
+        super().__init__(name=name)

dodal/devices/i18/thor_labs_stage.py

@@ -0,0 +1,12 @@
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.motor import Motor
+
+
+class ThorLabsStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+        super().__init__(name=name)

dodal/devices/i19/shutter.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.epics.core import epics_signal_r
+
+from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.log import LOGGER
+
+
+class HutchInvalidError(Exception):
+    pass
+
+
+class HutchState(str, Enum):
+    EH1 = "EH1"
+    EH2 = "EH2"
+    INVALID = "INVALID"
+
+
+class HutchConditionalShutter(StandardReadable, Movable):
+    """ I19-specific device to operate the hutch shutter.
+
+    This device evaluates the hutch state value to work out which of the two I19 \
+    hutches is in use and then implements the HutchShutter device to operate the \
+    experimental shutter.
+    As the two hutches are located in series, checking the hutch in use is necessary to \
+    avoid accidentally operating the shutter from one hutch while the other has beamtime.
+
+    The hutch name should be passed to the device upon instantiation. If this does not \
+    coincide with the current hutch in use, a warning will be logged and the shutter \
+    will not be operated. This is to allow for testing of plans.
+    An error will instead be raised if the hutch state reads as "INVALID".
+    """
+
+    def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
+        self.shutter = HutchShutter(prefix=prefix, name=name)
+        bl_prefix = prefix.split("-")[0]
+        self.hutch_state = epics_signal_r(str, f"{bl_prefix}-OP-STAT-01:EHStatus.VALA")
+        self.hutch_request = hutch
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: ShutterDemand):
+        hutch_in_use = await self.hutch_state.get_value()
+        LOGGER.info(f"Current hutch in use: {hutch_in_use}")
+        if hutch_in_use == HutchState.INVALID:
+            raise HutchInvalidError(
+                "The hutch state is invalid. Contact the beamline staff."
+            )
+        if hutch_in_use != self.hutch_request:
+            # NOTE Warn but don't fail
+            LOGGER.warning(
+                f"{self.hutch_request} is not the hutch in use. Shutter will not be operated."
+            )
+        else:
+            await self.shutter.set(value)