dls-dodal 1.36.2__py3-none-any.whl → 1.37.0__py3-none-any.whl

dodal/devices/i04/transfocator.py

@@ -1,14 +1,18 @@
+import asyncio
 import math
-from time import sleep, time
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal, EpicsSignalRO, Kind
-from ophyd.status import DeviceStatus
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.log import LOGGER
 
 
-class Transfocator(Device):
+class Transfocator(StandardReadable):
     """The transfocator is a device that puts a number of lenses in the beam to change
     its shape.
 
@@ -18,34 +22,50 @@ class Transfocator(Device):
         my_transfocator.set(vert_beamsize_microns)
     """
 
-    beamsize_set_microns = Cpt(EpicsSignal, "VERT_REQ", kind=Kind.hinted)
-    predicted_vertical_num_lenses = Cpt(EpicsSignal, "LENS_PRED")
-
-    number_filters_sp = Cpt(EpicsSignal, "NUM_FILTERS")
-
-    start = Cpt(EpicsSignal, "START.PROC")
-    start_rbv = Cpt(EpicsSignalRO, "START_RBV")
-
-    vertical_lens_rbv = Cpt(EpicsSignalRO, "VER", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.beamsize_set_microns = epics_signal_rw(float, prefix + "VERT_REQ")
+            self.predicted_vertical_num_lenses = epics_signal_rw(
+                float, prefix + "LENS_PRED"
+            )
+            self.number_filters_sp = epics_signal_rw(int, prefix + "NUM_FILTERS")
+            self.start = epics_signal_rw(int, prefix + "START.PROC")
+            self.start_rbv = epics_signal_r(int, prefix + "START_RBV")
+            self.vertical_lens_rbv = epics_signal_r(float, prefix + "VER")
 
-    TIMEOUT = 120
-    _POLLING_WAIT = 0.01
+        self.TIMEOUT = 120
 
-    def polling_wait_on_start_rbv(self, for_value):
-        # For some reason couldn't get monitors working on START_RBV
-        # (See https://github.com/DiamondLightSource/dodal/issues/152)
-        start_time = time()
-        while time() < start_time + self.TIMEOUT:
-            RBV_value = self.start_rbv.get()
-            if RBV_value == for_value:
-                return
-            sleep(self._POLLING_WAIT)
+        super().__init__(name=name)
 
-        # last try
-        if self.start_rbv.get() != for_value:
-            raise TimeoutError()
+    async def _observe_beamsize_microns(self):
+        is_set_filters_done = False
 
-    def set(self, beamsize_microns: float) -> DeviceStatus:
+        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
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
         """To set the beamsize on the transfocator we must:
         1. Set the beamsize in the calculator part of the transfocator
         2. Get the predicted number of lenses needed from this calculator
@@ -53,30 +73,24 @@ class Transfocator(Device):
         4. Start the device moving
         5. Wait for the start_rbv goes high and low again
         """
-        subscriber: int
-        status = DeviceStatus(self, timeout=self.TIMEOUT)
+        self.latest_pred_vertical_num_lenses = (
+            await self.predicted_vertical_num_lenses.get_value()
+        )
 
-        def set_based_on_predicition(old_value, value, *args, **kwargs):
-            if not math.isclose(old_value, value, abs_tol=1e-8):
-                self.predicted_vertical_num_lenses.unsubscribe(subscriber)
+        LOGGER.info(f"Transfocator setting {value} beamsize")
 
-                # 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")
-                self.number_filters_sp.set(value).wait()
-                self.start.set(1).wait()
-                self.polling_wait_on_start_rbv(1)
-                self.polling_wait_on_start_rbv(0)
-            # The value hasn't changed so assume the device is already set up correctly
-            status.set_finished()
-
-        LOGGER.info(f"Transfocator setting {beamsize_microns} beamsize")
-        if self.beamsize_set_microns.get() != beamsize_microns:
-            subscriber = self.predicted_vertical_num_lenses.subscribe(
-                set_based_on_predicition, run=False
+        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(),
             )
-            self.beamsize_set_microns.set(beamsize_microns)
-        else:
-            status.set_finished()
-        return status
+
+        number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
+            self.number_filters_sp.get_value(),
+            self.vertical_lens_rbv.get_value(),
+        )
+
+        LOGGER.info(
+            f"Transfocator set complete. Number of filters is: {number_filters_rbv} and Vertical beam size is: {vertical_lens_size_rbv}"
+        )

dodal/devices/i10/i10_setting_data.py

@@ -2,6 +2,6 @@ from ophyd_async.core import StrictEnum
 
 
 class I10Grating(StrictEnum):
-    Au400 = "400 line/mm Au"
-    Si400 = "400 line/mm Si"
-    Au1200 = "1200 line/mm Au"
+    AU_400 = "400 line/mm Au"
+    SI_400 = "400 line/mm Si"
+    AU_1200 = "1200 line/mm Au"

dodal/devices/i10/mirrors.py

@@ -0,0 +1,24 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.epics.motor import Motor
+
+
+class PiezoMirror(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.z = Motor(prefix + "Z")
+            self.yaw = Motor(prefix + "YAW")
+            self.pitch = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.fine_pitch = epics_signal_rw(
+                float,
+                read_pv=prefix + "FPITCH:RBV:AI",
+                write_pv=prefix + "FPITCH:DMD:AO",
+            )
+        super().__init__(name=name)

dodal/devices/i10/rasor/rasor_current_amp.py

@@ -0,0 +1,72 @@
+from ophyd_async.core import Device
+
+from dodal.devices.current_amplifiers import (
+    SR570,
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+    SR570FineGainTable,
+    SR570FullGainTable,
+    SR570GainTable,
+    SR570GainToCurrentTable,
+    SR570RaiseTimeTable,
+)
+
+
+class RasorFemto(Device):
+    def __init__(self, prefix: str, suffix: str = "GAIN", name: str = "") -> None:
+        self.ca1 = FemtoDDPCA(
+            prefix + "-01:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca2 = FemtoDDPCA(
+            prefix + "-02:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca3 = FemtoDDPCA(
+            prefix + "-03:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        super().__init__(name)
+
+
+class RasorSR570(Device):
+    def __init__(self, prefix: str, suffix: str = "SENS:SEL", name: str = "") -> None:
+        self.ca1 = SR570(
+            prefix + "-04:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca2 = SR570(
+            prefix + "-05:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca3 = SR570(
+            prefix + "-06:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        super().__init__(name)

dodal/devices/i10/rasor/rasor_motors.py

@@ -0,0 +1,62 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class PinHole(StandardReadable):
+    "Two motors stage for rasor pinhole"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+        super().__init__(name=name)
+
+
+class Diffractometer(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.tth = Motor(prefix + "TWOTHETA")
+            self.th = Motor(prefix + "THETA")
+            self.chi = Motor(prefix + "CHI")
+            self.chamber_x = Motor(prefix + "X")
+            self.alpha = Motor(prefix + "ALPHA")
+        super().__init__(name=name)
+
+
+class DetSlits(StandardReadable):
+    "Detector slits"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.upstream = Motor(prefix + "1:TRANS")
+            self.downstream = Motor(prefix + "2:TRANS")
+        super().__init__(name=name)
+
+
+class PaStage(StandardReadable):
+    "Rasor detector stage"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.ttp = Motor(prefix + "TWOTHETA")
+            self.thp = Motor(prefix + "THETA")
+            self.py = Motor(prefix + "Y")
+            self.pz = Motor(prefix + "Z")
+            self.eta = Motor(prefix + "ETA")
+        super().__init__(name=name)

dodal/devices/i10/rasor/rasor_scaler_cards.py

@@ -0,0 +1,12 @@
+from ophyd_async.core import Device
+
+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")
+        super().__init__(name)

dodal/devices/i10/slits.py

@@ -0,0 +1,37 @@
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.slits import Slits
+
+
+class I10Slits(Slits):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x_ring_blade = Motor(prefix + "XRING")
+            self.x_hall_blade = Motor(prefix + "XHALL")
+            self.y_top_blade = Motor(prefix + "YPLUS")
+            self.y_bot_blade = Motor(prefix + "YMINUS")
+        super().__init__(
+            prefix=prefix,
+            x_gap="XSIZE",
+            x_centre="XCENTRE",
+            y_gap="YSIZE",
+            y_centre="YCENTRE",
+            name=name,
+        )
+
+
+class I10PrimarySlits(Slits):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x_aptr_1 = Motor(prefix + "APTR1:X")
+            self.x_aptr_2 = Motor(prefix + "APTR2:X")
+            self.y_aptr_1 = Motor(prefix + "APTR1:Y")
+            self.y_aptr_1 = Motor(prefix + "APTR2:Y")
+        super().__init__(
+            prefix=prefix,
+            x_gap="XSIZE",
+            x_centre="XCENTRE",
+            y_gap="YSIZE",
+            y_centre="YCENTRE",
+            name=name,
+        )

dodal/devices/i24/dual_backlight.py

@@ -8,6 +8,7 @@ class BacklightPositions(StrictEnum):
     LOAD_CHECK = "LoadCheck"
     OAV2 = "OAV2"
     DIODE = "Diode"
+    WHITE_IN = "White In"
 
 
 class LEDStatus(StrictEnum):

dodal/devices/i24/focus_mirrors.py

@@ -5,21 +5,21 @@ from dodal.common.signal_utils import create_hardware_backed_soft_signal
 
 
 class HFocusMode(StrictEnum):
-    focus10 = "HMFMfocus10"
-    focus20d = "HMFMfocus20d"
-    focus30d = "HMFMfocus30d"
-    focus50d = "HMFMfocus50d"
-    focus1050d = "HMFMfocus1030d"
-    focus3010d = "HMFMfocus3010d"
+    FOCUS_10 = "HMFMfocus10"
+    FOCUS_20D = "HMFMfocus20d"
+    FOCUS_30D = "HMFMfocus30d"
+    FOCUS_50D = "HMFMfocus50d"
+    FOCUS_1050D = "HMFMfocus1030d"
+    FOCUS_3010D = "HMFMfocus3010d"
 
 
 class VFocusMode(StrictEnum):
-    focus10 = "VMFMfocus10"
-    focus20d = "VMFMfocus20d"
-    focus30d = "VMFMfocus30d"
-    focus50d = "VMFMfocus50d"
-    focus1030d = "VMFMfocus1030d"
-    focus3010d = "VMFMfocus3010d"
+    FOCUS_10 = "VMFMfocus10"
+    FOCUS_20D = "VMFMfocus20d"
+    FOCUS_30D = "VMFMfocus30d"
+    FOCUS_50D = "VMFMfocus50d"
+    FOCUS_1030D = "VMFMfocus1030d"
+    FOCUS_3010D = "VMFMfocus3010d"
 
 
 BEAM_SIZES = {

dodal/devices/linkam3.py

@@ -14,8 +14,8 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
 class PumpControl(StrictEnum):
-    Manual = "Manual"
-    Auto = "Auto"
+    MANUAL = "Manual"
+    AUTO = "Auto"
 
 
 class Linkam3(StandardReadable):

dodal/devices/p99/sample_stage.py

@@ -1,5 +1,5 @@
-from ophyd_async.core import StandardReadable, SubsetEnum
-from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class SampleAngleStage(StandardReadable):
@@ -9,29 +9,3 @@ class SampleAngleStage(StandardReadable):
             self.roll = epics_signal_rw_rbv(float, prefix + "WRITEROLL", ":RBV")
             self.pitch = epics_signal_rw_rbv(float, prefix + "WRITEPITCH", ":RBV")
         super().__init__(name=name)
-
-
-class p99StageSelections(SubsetEnum):
-    Empty = "Empty"
-    Mn5um = "Mn 5um"
-    Fe = "Fe (empty)"
-    Co5um = "Co 5um"
-    Ni5um = "Ni 5um"
-    Cu5um = "Cu 5um"
-    Zn5um = "Zn 5um"
-    Zr = "Zr (empty)"
-    Mo = "Mo (empty)"
-    Rh = "Rh (empty)"
-    Pd = "Pd (empty)"
-    Ag = "Ag (empty)"
-    Cd25um = "Cd 25um"
-    W = "W (empty)"
-    Pt = "Pt (empty)"
-    User = "User"
-
-
-class FilterMotor(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables():
-            self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
-        super().__init__(name=name)

dodal/devices/robot.py

@@ -70,8 +70,8 @@ class BartRobot(StandardReadable, Movable):
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
         self.error_str = epics_signal_r(str, prefix + "PRG_ERR_MSG")
-        # Change error_code to int type when https://github.com/bluesky/ophyd-async/issues/280 released
-        self.error_code = epics_signal_r(float, prefix + "PRG_ERR_CODE")
+        self.error_code = epics_signal_r(int, prefix + "PRG_ERR_CODE")
+        self.reset = epics_signal_x(prefix + "RESET.PROC")
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):

dodal/devices/slits.py

@@ -2,16 +2,38 @@ from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class Slits(StandardReadable):
+class MinimalSlits(StandardReadable):
+    """Gap only X Y slits."""
+
+    def __init__(
+        self,
+        prefix: str,
+        x_gap: str = "X:SIZE",
+        y_gap: str = "Y:SIZE",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.x_gap = Motor(prefix + x_gap)
+            self.y_gap = Motor(prefix + y_gap)
+        super().__init__(name=name)
+
+
+class Slits(MinimalSlits):
     """
     Representation of a 4-blade set of slits. Allows control/readout of the gap
     between each pair of blades.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self,
+        prefix: str,
+        x_gap: str = "X:SIZE",
+        y_gap: str = "Y:SIZE",
+        x_centre: str = "X:CENTRE",
+        y_centre: str = "Y:CENTRE",
+        name: str = "",
+    ) -> None:
         with self.add_children_as_readables():
-            self.x_gap = Motor(prefix + "X:SIZE")
-            self.y_gap = Motor(prefix + "Y:SIZE")
-            self.x_centre = Motor(prefix + "X:CENTRE")
-            self.y_centre = Motor(prefix + "Y:CENTRE")
-        super().__init__(name)
+            self.x_centre = Motor(prefix + x_centre)
+            self.y_centre = Motor(prefix + y_centre)
+        super().__init__(prefix=prefix, x_gap=x_gap, y_gap=y_gap, name=name)

dodal/devices/tetramm.py

@@ -22,31 +22,31 @@ from ophyd_async.epics.core import (
 
 
 class TetrammRange(StrictEnum):
-    uA = "+- 120 uA"
-    nA = "+- 120 nA"
+    UA = "+- 120 uA"
+    NA = "+- 120 nA"
 
 
 class TetrammTrigger(StrictEnum):
-    FreeRun = "Free run"
-    ExtTrigger = "Ext. trig."
-    ExtBulb = "Ext. bulb"
-    ExtGate = "Ext. gate"
+    FREE_RUN = "Free run"
+    EXT_TRIGGER = "Ext. trig."
+    EXT_BULB = "Ext. bulb"
+    EXT_GATE = "Ext. gate"
 
 
 class TetrammChannels(StrictEnum):
-    One = "1"
-    Two = "2"
-    Four = "4"
+    ONE = "1"
+    TWO = "2"
+    FOUR = "4"
 
 
 class TetrammResolution(StrictEnum):
-    SixteenBits = "16 bits"
-    TwentyFourBits = "24 bits"
+    SIXTEEN_BITS = "16 bits"
+    TWENTY_FOUR_BITS = "24 bits"
 
 
 class TetrammGeometry(StrictEnum):
-    Diamond = "Diamond"
-    Square = "Square"
+    DIAMOND = "Diamond"
+    SQUARE = "Square"
 
 
 class TetrammDriver(Device):
@@ -118,7 +118,7 @@ class TetrammController(DetectorController):
         assert trigger_info.livetime is not None
 
         # trigger mode must be set first and on its own!
-        await self._drv.trigger_mode.set(TetrammTrigger.ExtTrigger)
+        await self._drv.trigger_mode.set(TetrammTrigger.EXT_TRIGGER)
 
         await asyncio.gather(
             self._drv.averaging_time.set(trigger_info.livetime),
@@ -134,8 +134,8 @@ class TetrammController(DetectorController):
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {
-            DetectorTrigger.edge_trigger,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.CONSTANT_GATE,
         }
 
         if trigger not in supported_trigger_types:

dodal/devices/undulator_dcm.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
@@ -33,12 +33,8 @@ class UndulatorDCM(StandardReadable, Movable):
         prefix: str = "",
         name: str = "",
     ):
-        super().__init__(name)
-
-        # Attributes are set after super call so they are not renamed to
-        # <name>-undulator, etc.
-        self.undulator = undulator
-        self.dcm = dcm
+        self.undulator_ref = Reference(undulator)
+        self.dcm_ref = Reference(dcm)
 
         # These attributes are just used by hyperion for lookup purposes
         self.pitch_energy_table_path = (
@@ -53,13 +49,15 @@ class UndulatorDCM(StandardReadable, Movable):
             daq_configuration_path + "/domain/beamlineParameters"
         )["DCM_Perp_Offset_FIXED"]
 
+        super().__init__(name)
+
     @AsyncStatus.wrap
     async def set(self, value: float):
-        await self.undulator.raise_if_not_enabled()
+        await self.undulator_ref().raise_if_not_enabled()
         await asyncio.gather(
-            self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
-            self.undulator.set(value),
+            self.dcm_ref().energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
+            self.undulator_ref().set(value),
         )
         # DCM Perp pitch
         LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
-        await self.dcm.offset_in_mm.set(self.dcm_fixed_offset_mm)
+        await self.dcm_ref().offset_in_mm.set(self.dcm_fixed_offset_mm)

dodal/devices/util/test_utils.py

@@ -1,8 +1,8 @@
-from ophyd_async.core import (
+from ophyd_async.epics.motor import Motor
+from ophyd_async.testing import (
     callback_on_mock_put,
     set_mock_value,
 )
-from ophyd_async.epics.motor import Motor
 
 
 def patch_motor(motor: Motor, initial_position=0):

dodal/devices/xspress3/xspress3.py

@@ -26,12 +26,12 @@ class TriggerMode(StrictEnum):
     SOFTWARE = "Software"
     HARDWARE = "Hardware"
     BURST = "Burst"
-    TTL_Veto_Only = "TTL Veto Only"
+    TTL_VETO_ONLY = "TTL Veto Only"
     IDC = "IDC"
     SOTWARE_START_STOP = "Software Start/Stop"
     TTL_BOTH = "TTL Both"
     LVDS_VETO_ONLY = "LVDS Veto Only"
-    LVDS_both = "LVDS Both"
+    LVDS_BOTH = "LVDS Both"
 
 
 class UpdateRBV(StrictEnum):
@@ -49,7 +49,7 @@ class DetectorState(StrictEnum):
     ACQUIRE = "Acquire"
     READOUT = "Readout"
     CORRECT = "Correct"
-    Saving = "Saving"
+    SAVING = "Saving"
     ABORTING = "Aborting"
     ERROR = "Error"
     WAITING = "Waiting"