dls-dodal 1.29.4__py3-none-any.whl → 1.30.0__py3-none-any.whl

dodal/devices/detector/detector_motion.py

@@ -1,37 +1,44 @@
-from enum import IntEnum
+from enum import Enum
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor, EpicsSignal, EpicsSignalRO
+from ophyd_async.core import Device
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
-class ShutterState(IntEnum):
-    CLOSED = 0
-    OPEN = 1
+class ShutterState(str, Enum):
+    CLOSED = "Closed"
+    OPEN = "Open"
 
 
 class DetectorMotion(Device):
-    """Physical motion and interlocks for detector travel"""
-
-    upstream_x = Cpt(EpicsMotor, "-MO-DET-01:UPSTREAMX")
-    downstream_x = Cpt(EpicsMotor, "-MO-DET-01:DOWNSTREAMX")
-    x = Cpt(EpicsMotor, "-MO-DET-01:X")
-    y = Cpt(EpicsMotor, "-MO-DET-01:Y")
-    z = Cpt(EpicsMotor, "-MO-DET-01:Z")
-    yaw = Cpt(EpicsMotor, "-MO-DET-01:YAW")
-    shutter = Cpt(EpicsSignal, "-MO-DET-01:SET_SHUTTER_STATE")  # 0=closed, 1=open
-    #   monitors
-    shutter_closed_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:CLOSE_LIMIT"
-    )  # on limit = 1, off = 0
-    shutter_open_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:OPEN_LIMIT"
-    )  # on limit = 1, off = 0
-    z_disabled = Cpt(
-        EpicsSignalRO, "-MO-DET-01:Z:DISABLED"
-    )  # robot interlock, 0=ok to move, 1=blocked
-    crate_power = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:CRATE2_HEALTHY"
-    )  # returns 0 if no power
-    in_robot_load_safe_position = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:GPIO_INP_BITS.B2"
-    )  # returns 1 if safe
+    def __init__(self, prefix: str, name: str = ""):
+        device_prefix = "-MO-DET-01:"
+        pmac_prefix = "-MO-PMAC-02:"
+
+        self.upstream_x = Motor(f"{prefix}{device_prefix}UPSTREAMX")
+        self.downstream_x = Motor(f"{prefix}{device_prefix}DOWNSTREAMX")
+        self.x = Motor(f"{prefix}{device_prefix}X")
+        self.y = Motor(f"{prefix}{device_prefix}Y")
+        self.z = Motor(f"{prefix}{device_prefix}Z")
+        self.yaw = Motor(f"{prefix}{device_prefix}YAW")
+
+        self.shutter = epics_signal_rw(
+            ShutterState, f"{prefix}{device_prefix}SET_SHUTTER_STATE"
+        )
+        self.shutter_closed_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}CLOSE_LIMIT"
+        )  # on limit = 1, off = 0
+        self.shutter_open_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}OPEN_LIMIT"
+        )  # on limit = 1, off = 0
+        self.z_disabled = epics_signal_r(
+            float, f"{prefix}{device_prefix}Z:DISABLED"
+        )  # robot interlock, 0=ok to move, 1=blocked
+        self.crate_power = epics_signal_r(
+            float, f"{prefix}{pmac_prefix}CRATE2_HEALTHY"
+        )  # returns 0 if no power
+        self.in_robot_load_safe_position = epics_signal_r(
+            int, f"{prefix}{pmac_prefix}GPIO_INP_BITS.B2"
+        )  # returns 1 if safe
+
+        super().__init__(name)

dodal/devices/eiger.py

@@ -1,3 +1,4 @@
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
@@ -12,10 +13,6 @@ from dodal.log import LOGGER
 
 FREE_RUN_MAX_IMAGES = 1000000
 
-# TODO present for testing purposes, remove
-TEST_1169_FIX = True
-TEST_1169_INJECT = False
-
 
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
@@ -56,17 +53,15 @@ class EigerDetector(Device):
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
-        *args,
-        **kwargs,
     ):
-        det = cls(name=name, *args, **kwargs)
+        det = cls(name=name)
         det.set_detector_parameters(params)
         return det
 
     def set_detector_parameters(self, detector_params: DetectorParams):
         self.detector_params = detector_params
         if self.detector_params is None:
-            raise Exception("Parameters for scan must be specified")
+            raise ValueError("Parameters for scan must be specified")
 
         to_check = [
             (
@@ -103,7 +98,7 @@ class EigerDetector(Device):
 
     def stage(self):
         self.wait_on_arming_if_started()
-        if TEST_1169_INJECT or not self.is_armed():
+        if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
             self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
@@ -318,7 +313,9 @@ class EigerDetector(Device):
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
-        return Status(done=True, success=True)
+        status = Status()
+        status.set_finished()
+        return status
 
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
@@ -341,6 +338,10 @@ class EigerDetector(Device):
             functions_to_do_arm.append(self.enable_roi_mode)
 
         arming_sequence_funcs = [
+            # If a beam dump occurs after arming the eiger but prior to eiger staging,
+            # the odin may timeout which will cause the arming sequence to be retried;
+            # if this previously completed successfully we must reset the odin first
+            self.odin.stop,
             lambda: self.change_dev_shm(detector_params.enable_dev_shm),
             lambda: self.set_detector_threshold(detector_params.expected_energy_ev),
             self.set_cam_pvs,
@@ -354,11 +355,6 @@ class EigerDetector(Device):
             self._wait_fan_ready,
             self._finish_arm,
         ]
-        if TEST_1169_FIX:
-            # If a beam dump occurs after arming the eiger but prior to eiger staging,
-            # the odin may timeout which will cause the arming sequence to be retried;
-            # if this previously completed successfully we must reset the odin first
-            arming_sequence_funcs.insert(0, self.odin.stop)
 
         functions_to_do_arm.extend(arming_sequence_funcs)
 

dodal/devices/eiger_odin.py

@@ -1,5 +1,4 @@
-from typing import List, Tuple
-
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from ophyd import Component, Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
 from ophyd.areadetector.plugins import HDF5Plugin_V22
 from ophyd.sim import NullStatus
@@ -59,12 +58,12 @@ class OdinNodesStatus(Device):
     node_3 = Component(OdinNode, "OD4:")
 
     @property
-    def nodes(self) -> List[OdinNode]:
+    def nodes(self) -> list[OdinNode]:
         return [self.node_0, self.node_1, self.node_2, self.node_3]
 
     def check_node_frames_from_attr(
         self, node_get_func, error_message_verb: str
-    ) -> Tuple[bool, str]:
+    ) -> tuple[bool, str]:
         nodes_frames_values = [0] * len(self.nodes)
         frames_details = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -75,17 +74,17 @@ class OdinNodesStatus(Device):
         bad_frames = any(v != 0 for v in nodes_frames_values)
         return bad_frames, "\n".join(frames_details)
 
-    def check_frames_timed_out(self) -> Tuple[bool, str]:
+    def check_frames_timed_out(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_timed_out.get(), "timed out"
         )
 
-    def check_frames_dropped(self) -> Tuple[bool, str]:
+    def check_frames_dropped(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_dropped.get(), "dropped"
         )
 
-    def get_error_state(self) -> Tuple[bool, str]:
+    def get_error_state(self) -> tuple[bool, str]:
         is_error = []
         error_messages = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -99,7 +98,7 @@ class OdinNodesStatus(Device):
 
     def get_init_state(self) -> bool:
         is_initialised = []
-        for node_number, node_pv in enumerate(self.nodes):
+        for node_pv in self.nodes:
             is_initialised.append(node_pv.fr_initialised.get())
             is_initialised.append(node_pv.fp_initialised.get())
         return all(is_initialised)
@@ -132,7 +131,7 @@ class EigerOdin(Device):
         frames_timed_out, frames_timed_out_details = self.nodes.check_frames_timed_out()
 
         if not is_initialised:
-            raise Exception(error_message)
+            raise RuntimeError(error_message)
         if frames_dropped:
             self.log.error(f"Frames dropped: {frames_dropped_details}")
         if frames_timed_out:
@@ -140,7 +139,7 @@ class EigerOdin(Device):
 
         return is_initialised and not frames_dropped and not frames_timed_out
 
-    def check_odin_initialised(self) -> Tuple[bool, str]:
+    def check_odin_initialised(self) -> tuple[bool, str]:
         is_error_state, error_messages = self.nodes.get_error_state()
         to_check = [
             (not self.fan.consumers_connected.get(), "EigerFan is not connected"),

dodal/devices/fast_grid_scan.py

@@ -126,7 +126,7 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         :return: The motor position this corresponds to.
         :raises: IndexError if the desired position is outside the grid."""
         for position, axis in zip(
-            grid_position, [self.x_axis, self.y_axis, self.z_axis]
+            grid_position, [self.x_axis, self.y_axis, self.z_axis], strict=False
         ):
             if not axis.is_within(position):
                 raise IndexError(f"{grid_position} is outside the bounds of the grid")
@@ -191,9 +191,10 @@ class MotionProgram(Device):
 class ExpectedImages(SignalR[int]):
     def __init__(self, parent: "FastGridScanCommon") -> None:
         super().__init__(SoftSignalBackend(int))
-        self.parent: "FastGridScanCommon" = parent
+        self.parent = parent
 
-    async def get_value(self):
+    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()

dodal/devices/fluorescence_detector_motion.py

@@ -1,9 +1,18 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal
+from enum import Enum
 
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
-class FluorescenceDetector(Device):
+
+class FluorescenceDetectorControlState(Enum):
     OUT = 0
     IN = 1
 
-    pos = Cpt(EpicsSignal, "-EA-FLU-01:CTRL")
+
+class FluorescenceDetector(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.pos = epics_signal_r(
+                FluorescenceDetectorControlState, prefix + "-EA-FLU-01:CTRL"
+            )
+        super().__init__(name)

dodal/devices/focusing_mirror.py

@@ -2,8 +2,10 @@ from enum import Enum
 
 from ophyd_async.core import (
     AsyncStatus,
+    ConfigSignal,
     Device,
     DeviceVector,
+    HintedSignal,
     StandardReadable,
     observe_value,
 )
@@ -144,10 +146,8 @@ class FocusingMirror(StandardReadable):
         # regardless of orientation of the mirror
         self.incident_angle = Motor(prefix + "PITCH")
 
-        self.set_readable_signals(
-            read=[self.incident_angle.user_readback],
-            config=[self.type],
-        )
+        self.add_readables([self.incident_angle.user_readback], wrapper=HintedSignal)
+        self.add_readables([self.type], wrapper=ConfigSignal)
         super().__init__(name)
 
 

dodal/devices/hutch_shutter.py

@@ -74,20 +74,20 @@ class HutchShutter(StandardReadable, Movable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position_demand: ShutterDemand):
+    async def set(self, value: ShutterDemand):
         interlock_state = await self.interlock.shutter_safe_to_operate()
         if not interlock_state:
             raise ShutterNotSafeToOperateError(
                 "The hutch has not been locked, not operating shutter."
             )
-        if position_demand == ShutterDemand.OPEN:
+        if value == ShutterDemand.OPEN:
             await self.control.set(ShutterDemand.RESET, wait=True)
-            await self.control.set(position_demand, 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(position_demand, wait=True)
+            await self.control.set(value, wait=True)
             return await wait_for_value(
                 self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
             )

dodal/devices/i22/dcm.py

@@ -1,6 +1,7 @@
 import time
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Dict, Literal, Sequence
+from typing import Literal
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
@@ -127,7 +128,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             f"{self.name}-wavelength": DataKey(
@@ -139,7 +140,7 @@ class DoubleCrystalMonochromator(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
         energy: float = default_reading[f"{self.name}-energy"]["value"]
         if energy > 0.0:

dodal/devices/i22/fswitch.py

@@ -1,9 +1,9 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Dict
 
-from bluesky.protocols import DataKey, Reading
+from bluesky.protocols import Reading
+from event_model import DataKey
 from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
 from ophyd_async.core.device import DeviceVector
 from ophyd_async.epics.signal import epics_signal_r
@@ -74,7 +74,7 @@ class FSwitch(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             FSwitch.NUM_LENSES_FIELD_NAME: DataKey(
@@ -83,7 +83,7 @@ class FSwitch(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         result = await asyncio.gather(
             *(filter.get_value() for filter in self.filters.values())
         )

dodal/devices/i22/nxsas.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, fields
-from typing import Dict
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
@@ -13,7 +12,7 @@ ValueAndUnits = tuple[float, str]
 @dataclass
 class MetadataHolder:
     # TODO: just in case this is useful more widely...
-    async def describe(self, parent_name: str) -> Dict[str, DataKey]:
+    async def describe(self, parent_name: str) -> dict[str, DataKey]:
         def datakey(value) -> DataKey:
             if isinstance(value, tuple):
                 return {"units": value[1], **datakey(value[0])}
@@ -40,8 +39,8 @@ class MetadataHolder:
             if getattr(self, field.name, None) is not None
         }
 
-    async def read(self, parent_name: str) -> Dict[str, Reading]:
-        def reading(value):
+    async def read(self, parent_name: str) -> dict[str, Reading]:
+        def reading(value) -> Reading:
             if isinstance(value, tuple):
                 return reading(value[0])
             return {"timestamp": -1, "value": value}
@@ -101,25 +100,21 @@ class NXSasPilatus(PilatusDetector):
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )
 
@@ -150,24 +145,20 @@ class NXSasOAV(AravisDetector):
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )

dodal/devices/i24/pmac.py

@@ -1,8 +1,9 @@
-from enum import Enum
+from enum import Enum, IntEnum
+from typing import SupportsFloat
 
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.core.signal import SignalRW
+from ophyd_async.core import AsyncStatus, StandardReadable, wait_for_value
+from ophyd_async.core.signal import CalculateTimeout, SignalR, SignalRW
 from ophyd_async.core.signal_backend import SignalBackend
 from ophyd_async.core.soft_signal_backend import SoftSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
@@ -13,6 +14,11 @@ HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
 
 
+class ScanState(IntEnum):
+    RUNNING = 1
+    DONE = 0
+
+
 class LaserSettings(str, Enum):
     """PMAC strings to switch laser on and off.
     Note. On the PMAC, M-variables usually have to do with position compare
@@ -73,26 +79,55 @@ class PMACStringLaser(SignalRW):
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, laser_setting: LaserSettings):
-        await self.signal.set(laser_setting.value, wait=True)
+    async def set(self, value: LaserSettings, wait=True, timeout=CalculateTimeout):
+        await self.signal.set(value.value, wait, timeout)
 
 
 class PMACStringEncReset(SignalRW):
-    """"""
+    """Set a pmac_string to control the encoder channels in the controller."""
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        backend: SignalBackend,
+        timeout: float | None = DEFAULT_TIMEOUT,
+        name: str = "",
+    ) -> None:
+        self.signal = pmac_str_sig
+        super().__init__(backend, timeout, name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: EncReset, wait=True, timeout=CalculateTimeout):
+        await self.signal.set(value.value, wait, timeout)
+
+
+class ProgramRunner(SignalRW):
+    """Trigger the collection by setting the program number on the PMAC string.
+
+    Once the program number has been set, wait for the collection to be complete.
+    This will only be true when the status becomes 0.
+    """
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
+        status_sig: SignalR,
         backend: SignalBackend,
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self.signal = pmac_str_sig
+        self.status = status_sig
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, enc_string: EncReset):
-        await self.signal.set(enc_string.value, wait=True)
+    async def set(self, value: int, wait=True, timeout=None):
+        prog_str = f"&2b{value}r"
+        assert isinstance(timeout, SupportsFloat) or (
+            timeout is None
+        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
+        await self.signal.set(prog_str, wait=wait)
+        await wait_for_value(self.status, ScanState.DONE, timeout)
 
 
 class PMAC(StandardReadable):
@@ -121,4 +156,8 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        self.run_program = ProgramRunner(
+            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+        )
+
         super().__init__(name)

dodal/devices/ipin.py

@@ -1,8 +1,11 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignalRO, Kind
+from ophyd_async.core import HintedSignal, StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
 
-class IPin(Device):
+class IPin(StandardReadable):
     """Simple device to get the ipin reading"""
 
-    reading = Cpt(EpicsSignalRO, "I", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(wrapper=HintedSignal):
+            self.pin_readback = epics_signal_r(float, prefix + "I")
+        super().__init__(name)

dodal/devices/linkam3.py

@@ -1,10 +1,15 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Optional
 
 from bluesky.protocols import Location
-from ophyd_async.core import StandardReadable, WatchableAsyncStatus, observe_value
+from ophyd_async.core import (
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    observe_value,
+)
 from ophyd_async.core.utils import WatcherUpdate
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
@@ -57,14 +62,15 @@ class Linkam3(StandardReadable):
         # status is a bitfield stored in a double?
         self.status = epics_signal_r(float, prefix + "STATUS:")
 
-        self.set_readable_signals(
-            read=(self.temp,), config=(self.ramp_rate, self.speed, self.set_point)
+        self.add_readables((self.temp,), wrapper=HintedSignal)
+        self.add_readables(
+            (self.ramp_rate, self.speed, self.set_point), wrapper=ConfigSignal
         )
 
         super().__init__(name=name)
 
     @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: Optional[float] = None):
+    async def set(self, new_position: float, timeout: float | None = None):
         # time.monotonic won't go backwards in case of NTP corrections
         start = time.monotonic()
         old_position = await self.set_point.get_value()

dodal/devices/logging_ophyd_device.py

@@ -3,7 +3,7 @@ from ophyd.log import logger as ophyd_logger
 
 
 class InfoLoggingDevice(Device):
-    def wait_for_connection(self, all_signals=False, timeout=2):
+    def wait_for_connection(self, all_signals=False, timeout=2.0):
         class_name = self.__class__.__name__
         ophyd_logger.info(
             f"{class_name} waiting for connection, {'not' if all_signals else ''} waiting for all signals, timeout = {timeout}s.",