dls-dodal 1.55.0__py3-none-any.whl → 1.56.0__py3-none-any.whl

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -48,9 +48,6 @@ class PinTipDetection(StandardReadable):
     INVALID_POSITION = np.array([np.iinfo(np.int32).min, np.iinfo(np.int32).min])
 
     def __init__(self, prefix: str, name: str = ""):
-        self._prefix: str = prefix
-        self._name = name
-
         self.triggered_tip, self._tip_setter = soft_signal_r_and_setter(
             Tip, name="triggered_tip"
         )

dodal/devices/p60/enums.py

@@ -16,11 +16,11 @@ class PsuMode(StrictEnum):
 
 
 class PassEnergy(StrictEnum):
-    E1 = 1
-    E2 = 2
-    E5 = 5
-    E10 = 10
-    E20 = 20
-    E50 = 50
-    E100 = 100
-    E200 = 200
+    E1 = "1"
+    E2 = "2"
+    E5 = "5"
+    E10 = "10"
+    E20 = "20"
+    E50 = "50"
+    E100 = "100"
+    E200 = "200"

dodal/devices/p60/lab_xray_source.py

@@ -1,11 +1,12 @@
+from enum import Enum
+
 from ophyd_async.core import (
     StandardReadable,
-    StrictEnum,
     soft_signal_r_and_setter,
 )
 
 
-class LabXraySource(StrictEnum):
+class LabXraySource(float, Enum):
     AL_KALPHA = 1486.6
     MG_KALPHA = 1253.6
 

dodal/devices/pressure_jump_cell.py

@@ -1,7 +1,8 @@
 import asyncio
-from dataclasses import dataclass
+from enum import IntEnum
+from typing import Generic, TypeVar
 
-from bluesky.protocols import HasName, Movable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
@@ -26,23 +27,23 @@ class StopState(StrictEnum):
     STOP = "STOP"
 
 
-class FastValveControlRequest(StrictEnum):
+class ValveControlRequest(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
     RESET = "Reset"
-    ARM = "Arm"
-    DISARM = "Disarm"
 
 
-class ValveControlRequest(StrictEnum):
-    OPEN = "Open"
-    CLOSE = "Close"
-    RESET = "Reset"
+class FastValveControlRequest(StrictEnum):
+    OPEN = ValveControlRequest.OPEN.value
+    CLOSE = ValveControlRequest.CLOSE.value
+    RESET = ValveControlRequest.RESET.value
+    ARM = "Arm"
+    DISARM = "Disarm"
 
 
-class ValveOpenSeqRequest(StrictEnum):
-    INACTIVE = "0"
-    OPEN_SEQ = "1"
+class ValveOpenSeqRequest(IntEnum):
+    INACTIVE = 0
+    OPEN_SEQ = 1
 
 
 class PumpMotorDirectionState(StrictEnum):
@@ -60,138 +61,89 @@ class ValveState(StrictEnum):
 
 
 class FastValveState(StrictEnum):
-    FAULT = "Fault"
-    OPEN = "Open"
+    FAULT = ValveState.FAULT.value
+    OPEN = ValveState.OPEN.value
     OPEN_ARMED = "Open Armed"
-    CLOSED = "Closed"
+    CLOSED = ValveState.CLOSED.value
     CLOSED_ARMED = "Closed Armed"
     NONE = "Unused"
 
 
-@dataclass
-class AllValvesControlState:
-    valve_1: ValveControlRequest | None = None
-    valve_3: ValveControlRequest | None = None
-    valve_5: FastValveControlRequest | None = None
-    valve_6: FastValveControlRequest | None = None
+TValveControlRequest = TypeVar(
+    "TValveControlRequest", bound=ValveControlRequest | FastValveControlRequest
+)
+
+
+class ValveControl(
+    StandardReadable, Movable[TValveControlRequest], Generic[TValveControlRequest]
+):
+    def __init__(
+        self,
+        prefix: str,
+        valve_control_type: type[TValveControlRequest],
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.control = epics_signal_rw(valve_control_type, prefix + ":CON")
+            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: TValveControlRequest):
+        if value.value == "Open":
+            await self.open.set(ValveOpenSeqRequest.OPEN_SEQ)
+            await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
+            await self.open.set(ValveOpenSeqRequest.INACTIVE)
+        else:
+            await self.control.set(value)
 
 
-class AllValvesControl(StandardReadable, Movable[AllValvesControlState]):
+class AllValvesControl(StandardReadable):
     """
-    valves 2, 4, 7, 8 are not controlled by the IOC,
-    as they are under manual control.
-    fast_valves: tuple[int, ...] = (5, 6)
-    slow_valves: tuple[int, ...] = (1, 3)
+    The default IOC for this device only controls
+    specific valves. Other valves are under manual
+    control.
     """
 
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        fast_valves: tuple[int, ...] = (5, 6),
-        slow_valves: tuple[int, ...] = (1, 3),
+        fast_valves_numbers: tuple[int, ...] = (5, 6),
+        slow_valves_numbers: tuple[int, ...] = (1, 3),
     ) -> None:
-        self.fast_valves = fast_valves
-        self.slow_valves = slow_valves
         with self.add_children_as_readables():
             self.valve_states: DeviceVector[SignalR[ValveState]] = DeviceVector(
                 {
                     i: epics_signal_r(ValveState, f"{prefix}V{i}:STA")
-                    for i in self.slow_valves
+                    for i in slow_valves_numbers
                 }
             )
             self.fast_valve_states: DeviceVector[SignalR[FastValveState]] = (
                 DeviceVector(
                     {
                         i: epics_signal_r(FastValveState, f"{prefix}V{i}:STA")
-                        for i in self.fast_valves
+                        for i in fast_valves_numbers
                     }
                 )
             )
 
-        self.fast_valve_control: DeviceVector[FastValveControl] = DeviceVector(
-            {i: FastValveControl(f"{prefix}V{i}") for i in self.fast_valves}
-        )
-
-        self.valve_control: DeviceVector[ValveControl] = DeviceVector(
-            {i: ValveControl(f"{prefix}V{i}") for i in self.slow_valves}
-        )
-
-        super().__init__(name)
-
-    async def set_valve(
-        self,
-        valve: int,
-        value: ValveControlRequest | FastValveControlRequest,
-    ):
-        if valve in self.slow_valves and (isinstance(value, ValveControlRequest)):
-            if value == ValveControlRequest.OPEN:
-                await self.valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
-                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
-                await self.valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
-            else:
-                await self.valve_control[valve].set(value)
-
-        elif valve in self.fast_valves and (isinstance(value, FastValveControlRequest)):
-            if value == FastValveControlRequest.OPEN:
-                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
-                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
-                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
-            else:
-                await self.fast_valve_control[valve].set(value)
-
-    @AsyncStatus.wrap
-    async def set(self, value: AllValvesControlState):
-        await asyncio.gather(
-            *(
-                self.set_valve(int(i[-1]), value)
-                for i, value in value.__dict__.items()
-                if value is not None
-            )
-        )
-
-
-class ValveControl(
-    StandardReadable, Movable[ValveControlRequest | ValveOpenSeqRequest]
-):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
-
-        super().__init__(name)
-
-    def set(self, value: ValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
-        set_status = None
-
-        if isinstance(value, ValveControlRequest):
-            set_status = self.close.set(value)
-        elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value.value)
+        self.fast_valve_control = {
+            i: ValveControl(f"{prefix}V{i}", FastValveControlRequest)
+            for i in fast_valves_numbers
+        }
 
-        return set_status
+        self.slow_valve_control = {
+            i: ValveControl(f"{prefix}V{i}", ValveControlRequest)
+            for i in slow_valves_numbers
+        }
 
+        all_valves = self.fast_valve_control | self.slow_valve_control
 
-class FastValveControl(
-    StandardReadable, Movable[FastValveControlRequest | ValveOpenSeqRequest]
-):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")
-            self.open = epics_signal_rw(int, prefix + ":OPENSEQ")
+        self.valve_control: DeviceVector[ValveControl] = DeviceVector(all_valves)
 
         super().__init__(name)
 
-    def set(self, value: FastValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
-        set_status = None
-
-        if isinstance(value, FastValveControlRequest):
-            set_status = self.close.set(value)
-        elif isinstance(value, ValveOpenSeqRequest):
-            set_status = self.open.set(value.value)
-
-        return set_status
-
 
 class Pump(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -249,25 +201,27 @@ class PressureTransducer(StandardReadable):
         super().__init__(name)
 
 
-class PressureJumpCellController(HasName):
+class PressureJumpCellController(StandardReadable):
+    """
+    Top-level control for a fixed pressure or pressure jumps.
+    """
+
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
+        with self.add_children_as_readables():
+            self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
 
-        self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
-        self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
-        self.go = epics_signal_rw(bool, f"{prefix}GO")
+            self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
+            self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
+            self.go = epics_signal_rw(bool, f"{prefix}GO")
 
-        ## Jump logic ##
-        self.start_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
-        self.target_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
-        self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
+            self.from_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
+            self.to_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
+            self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
 
-        self._name = name
-        super().__init__()
+            self.result = epics_signal_r(str, f"{prefix}RESULT")
 
-    @property
-    def name(self):
-        return self._name
+            self._name = name
+        super().__init__(name)
 
 
 class PressureJumpCell(StandardReadable):

dodal/devices/scintillator.py

@@ -1,10 +1,82 @@
-from ophyd_async.core import StandardReadable
+from math import isclose
+
+from ophyd_async.core import Reference, StandardReadable, StrictEnum, derived_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+
+
+class InOut(StrictEnum):
+    """Currently Hyperion only needs to move the scintillator out for data collection."""
+
+    OUT = "Out"
+    UNKNOWN = "Unknown"
+
 
 class Scintillator(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
+    """Moves a scintillator into and out of the beam.
+
+    The scintillator will light up when hit with xrays, this allows scientists to use it
+    in conjunction with the optical OAV camera to commission the beamline.
+
+    When moved out of the beam it is parked under the table. This parking has a potential
+    to collide with the aperture/scatterguard if that is not correctly parked already.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        aperture_scatterguard: Reference[ApertureScatterguard],
+        beamline_parameters: GDABeamlineParameters,
+        name: str = "",
+    ):
         with self.add_children_as_readables():
-            self.y = Motor(prefix + "-MO-SCIN-01:Y")
-            self.z = Motor(prefix + "-MO-SCIN-01:Z")
+            self.y_mm = Motor(f"{prefix}Y")
+            self.z_mm = Motor(f"{prefix}Z")
+            self.selected_pos = derived_signal_rw(
+                self._get_selected_position,
+                self._set_selected_position,
+                y=self.y_mm,
+                z=self.z_mm,
+            )
+
+        self._aperture_scatterguard = aperture_scatterguard
+        self._scintillator_out_yz_mm = [
+            float(beamline_parameters[f"scin_{axis}_SCIN_OUT"]) for axis in ("y", "z")
+        ]
+        self._yz_tolerance_mm = [
+            float(beamline_parameters[f"scin_{axis}_tolerance"]) for axis in ("y", "z")
+        ]
+
         super().__init__(name)
+
+    def _get_selected_position(self, y: float, z: float) -> InOut:
+        current_pos = [y, z]
+        if all(
+            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
+            for axis_pos, axis_in_beam, axis_tolerance in zip(
+                current_pos,
+                self._scintillator_out_yz_mm,
+                self._yz_tolerance_mm,
+                strict=False,
+            )
+        ):
+            return InOut.OUT
+        else:
+            return InOut.UNKNOWN
+
+    async def _set_selected_position(self, position: InOut) -> None:
+        match position:
+            case InOut.OUT:
+                if (
+                    self._aperture_scatterguard().selected_aperture.get_value()
+                    != ApertureValue.PARKED
+                ):
+                    raise ValueError(
+                        "Cannot move scintillator out if aperture/scatterguard is not parked"
+                    )
+                await self.y_mm.set(self._scintillator_out_yz_mm[0])
+                await self.z_mm.set(self._scintillator_out_yz_mm[1])
+            case _:
+                raise ValueError(f"Cannot set scintillator to position {position}")

dodal/devices/smargon.py

@@ -42,7 +42,7 @@ class StubOffsets(Device):
     set them so that the current position is zero or to pre-defined positions.
     """
 
-    def __init__(self, name: str = "", prefix: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         self.center_at_current_position = SetWhenEnabled(prefix=prefix + "CENTER_CS")
         self.to_robot_load = SetWhenEnabled(prefix=prefix + "SET_STUBS_TO_RL")
         super().__init__(name)
@@ -123,7 +123,7 @@ class Smargon(XYZStage, Movable):
     Robot loading can nudge these and lead to errors.
     """
 
-    def __init__(self, prefix: str = "", name: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")

dodal/devices/synchrotron.py

@@ -38,8 +38,7 @@ class SynchrotronMode(StrictEnum):
 class Synchrotron(StandardReadable):
     def __init__(
         self,
-        prefix: str = "",
-        name: str = "synchrotron",
+        name: str = "",
         *,
         signal_prefix=Prefix.SIGNAL,
         status_prefix=Prefix.STATUS,

dodal/devices/tetramm.py

@@ -116,6 +116,19 @@ class TetrammController(DetectorController):
             self.set_exposure(trigger_info.livetime),
         )
 
+        # raise an error if asked to trigger faster than the max.
+        # possible speed for a tetramm
+        self._validate_deadtime(trigger_info)
+
+    def _validate_deadtime(self, value: TriggerInfo) -> None:
+        minimum_deadtime = self.get_deadtime(value.livetime)
+        if minimum_deadtime > value.deadtime:
+            msg = (
+                f"Tetramm {self} needs at least {minimum_deadtime}s "
+                f"deadtime, but trigger logic provides only {value.deadtime}s"
+            )
+            raise ValueError(msg)
+
     async def arm(self):
         self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 

dodal/devices/thawer.py

@@ -4,10 +4,10 @@ from bluesky.protocols import Movable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     Device,
+    OnOff,
     Reference,
     SignalRW,
     StandardReadable,
-    StrictEnum,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
@@ -16,27 +16,22 @@ class ThawingException(Exception):
     pass
 
 
-class ThawerStates(StrictEnum):
-    OFF = "Off"
-    ON = "On"
-
-
 class ThawingTimer(Device, Stoppable, Movable[float]):
-    def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
+    def __init__(self, control_signal: SignalRW[OnOff]) -> None:
         self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
     async def set(self, value: float):
-        await self._control_signal_ref().set(ThawerStates.ON)
+        await self._control_signal_ref().set(OnOff.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
         self._thawing_task = create_task(sleep(value))
         try:
             await self._thawing_task
         finally:
-            await self._control_signal_ref().set(ThawerStates.OFF)
+            await self._control_signal_ref().set(OnOff.OFF)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):
@@ -46,11 +41,11 @@ class ThawingTimer(Device, Stoppable, Movable[float]):
 
 class Thawer(StandardReadable, Stoppable):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.control = epics_signal_rw(ThawerStates, prefix + ":CTRL")
+        self.control = epics_signal_rw(OnOff, prefix + ":CTRL")
         self.thaw_for_time_s = ThawingTimer(self.control)
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):
         await self.thaw_for_time_s.stop()
-        await self.control.set(ThawerStates.OFF)
+        await self.control.set(OnOff.OFF)

dodal/devices/undulator.py

@@ -7,12 +7,12 @@ from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
+from dodal.common.enums import EnabledDisabledUpper
 from dodal.log import LOGGER
 
 from .util.lookup_tables import energy_distance_table
@@ -33,11 +33,6 @@ UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
 STATUS_TIMEOUT_S: float = 10.0
 
 
-class UndulatorGapAccess(StrictEnum):
-    ENABLED = "ENABLED"
-    DISABLED = "DISABLED"
-
-
 def _get_gap_for_energy(
     dcm_energy_ev: float, energy_to_distance_table: ndarray
 ) -> float:
@@ -73,7 +68,7 @@ class Undulator(StandardReadable, Movable[float]):
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
-            self.gap_access = epics_signal_r(UndulatorGapAccess, prefix + "IDBLENA")
+            self.gap_access = epics_signal_r(EnabledDisabledUpper, prefix + "IDBLENA")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
@@ -110,7 +105,7 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def raise_if_not_enabled(self):
         access_level = await self.gap_access.get_value()
-        if access_level is UndulatorGapAccess.DISABLED and not TEST_MODE:
+        if access_level is EnabledDisabledUpper.DISABLED and not TEST_MODE:
             raise AccessError("Undulator gap access is disabled. Contact Control Room")
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:

dodal/devices/util/epics_util.py

@@ -117,7 +117,7 @@ def call_func(func: Callable[[], StatusBase]) -> StatusBase:
 class SetWhenEnabled(OphydAsyncDevice, Movable[int]):
     """A device that sets the proc field of a PV when it becomes enabled."""
 
-    def __init__(self, name: str = "", prefix: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         self.proc = epics_signal_rw(int, prefix + ".PROC")
         self.disp = epics_signal_r(int, prefix + ".DISP")
         super().__init__(name)

dodal/devices/util/test_utils.py

@@ -1,3 +1,6 @@
+from contextlib import ExitStack
+
+from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 from ophyd_async.testing import (
     callback_on_mock_put,
@@ -16,3 +19,19 @@ def patch_motor(motor: Motor, initial_position=0):
         motor.user_setpoint,
         lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
     )
+
+
+def patch_all_motors(parent_device: Device):
+    motors = []
+
+    def recursively_find_motors(device: Device):
+        for _, child_device in device.children():
+            if isinstance(child_device, Motor):
+                motors.append(child_device)
+            recursively_find_motors(child_device)
+
+    recursively_find_motors(parent_device)
+    motor_patch_stack = ExitStack()
+    for motor in motors:
+        motor_patch_stack.enter_context(patch_motor(motor))
+    return motor_patch_stack

dodal/devices/watsonmarlow323_pump.py

@@ -1,12 +1,12 @@
-from ophyd_async.core import StandardReadable, StandardReadableFormat, StrictEnum
+from ophyd_async.core import (
+    EnabledDisabled,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
 from ophyd_async.epics.core import epics_signal_rw
 
 
-class WatsonMarlow323PumpEnable(StrictEnum):
-    DISABLED = "Disabled"
-    ENABLED = "Enabled"
-
-
 class WatsonMarlow323PumpDirection(StrictEnum):
     CLOCKWISE = "CW"
     COUNTER_CLOCKWISE = "CCW"
@@ -38,7 +38,7 @@ class WatsonMarlow323Pump(StandardReadable):
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.enabled = epics_signal_rw(
-                WatsonMarlow323PumpEnable,
+                EnabledDisabled,
                 prefix + "DISABLE",
             )
 

dodal/devices/xbpm_feedback.py

@@ -14,12 +14,10 @@ class XBPMFeedback(Device, Triggerable):
     """The XBPM feedback device is an IOC that moves the DCM, HFM and VFM to automatically
     hold the beam into place, as measured by the XBPM sensor."""
 
-    def __init__(self, prefix: str = "", name: str = "xbpm_feedback") -> None:
-        self.pos_ok = epics_signal_r(float, prefix + "-EA-FDBK-01:XBPM2POSITION_OK")
-        self.pos_stable = epics_signal_r(float, prefix + "-EA-FDBK-01:XBPM2_STABLE")
-        self.pause_feedback = epics_signal_rw(Pause, prefix + "-EA-FDBK-01:FB_PAUSE")
-        self.x = epics_signal_r(float, prefix + "-EA-XBPM-02:PosX:MeanValue_RBV")
-        self.y = epics_signal_r(float, prefix + "-EA-XBPM-02:PosY:MeanValue_RBV")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.pos_ok = epics_signal_r(float, prefix + "XBPM2POSITION_OK")
+        self.pos_stable = epics_signal_r(float, prefix + "XBPM2_STABLE")
+        self.pause_feedback = epics_signal_rw(Pause, prefix + "FB_PAUSE")
         super().__init__(name=name)
 
     @AsyncStatus.wrap

dodal/devices/xspress3/xspress3.py

@@ -34,11 +34,6 @@ class TriggerMode(StrictEnum):
     LVDS_BOTH = "LVDS Both"
 
 
-class UpdateRBV(StrictEnum):
-    DISABLED = "Disabled"
-    ENABLED = "Enabled"
-
-
 class AcquireRBVState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquiring"