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

dodal/beamlines/i24.py

@@ -100,7 +100,8 @@ def dcm() -> DCM:
     If this is called when already instantiated in i24, it will return the existing object.
     """
     return DCM(
-        prefix=PREFIX.beamline_prefix,
+        prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01",
+        motion_prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01",
     )
 
 
@@ -136,10 +137,7 @@ def pmac() -> PMAC:
     """Get the i24 PMAC device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i24, it will return the existing object.
     """
-    # prefix not BL but ME14E
-    return PMAC(
-        "ME14E-MO-CHIP-01:",
-    )
+    return PMAC(PREFIX.beamline_prefix)
 
 
 @device_factory()
@@ -155,9 +153,7 @@ def vgonio() -> VerticalGoniometer:
     """Get the i24 vertical goniometer device, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
-    return VerticalGoniometer(
-        f"{PREFIX.beamline_prefix}-MO-VGON-01:",
-    )
+    return VerticalGoniometer(f"{PREFIX.beamline_prefix}-MO-VGON-01:")
 
 
 @device_factory()
@@ -176,17 +172,13 @@ def shutter() -> HutchShutter:
     """Get the i24 hutch shutter device, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
-    return HutchShutter(
-        f"{PREFIX.beamline_prefix}-PS-SHTR-01:",
-    )
+    return HutchShutter(f"{PREFIX.beamline_prefix}-PS-SHTR-01:")
 
 
 @device_factory()
 def focus_mirrors() -> FocusMirrorsMode:
     """Get the i24 focus mirror devise to find the beam size."""
-    return FocusMirrorsMode(
-        f"{PREFIX.beamline_prefix}-OP-MFM-01:",
-    )
+    return FocusMirrorsMode(f"{PREFIX.beamline_prefix}-OP-MFM-01:")
 
 
 @device_factory()

dodal/beamlines/p38.py

@@ -145,6 +145,7 @@ def hfm() -> FocusingMirror:
 @device_factory(mock=True)
 def dcm() -> DCM:
     return DCM(
+        prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01:",
         temperature_prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=make_crystal_metadata_from_material(
             MaterialsEnum.Si, (1, 1, 1)

dodal/beamlines/p60.py

@@ -2,6 +2,7 @@ from dodal.common.beamlines.beamline_utils import (
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.electron_analyser import SelectedSource
 from dodal.devices.electron_analyser.vgscienta import VGScientaAnalyserDriverIO
 from dodal.devices.p60 import (
     LabXraySource,
@@ -34,8 +35,8 @@ def mg_kalpha_source() -> LabXraySourceReadable:
 @device_factory()
 def analyser_driver() -> VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy]:
     energy_sources = {
-        "source1": al_kalpha_source().energy_ev,
-        "source2": mg_kalpha_source().energy_ev,
+        SelectedSource.SOURCE1: al_kalpha_source().energy_ev,
+        SelectedSource.SOURCE2: mg_kalpha_source().energy_ev,
     }
     return VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy](
         prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:",

dodal/cli.py

@@ -1,12 +1,14 @@
 import os
 from collections.abc import Mapping
+from pathlib import Path
 
 import click
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import NotConnected
+from ophyd_async.core import NotConnected, StaticPathProvider, UUIDFilenameProvider
 from ophyd_async.plan_stubs import ensure_connected
 
 from dodal.beamlines import all_beamline_names, module_name_for_beamline
+from dodal.common.beamlines.beamline_utils import set_path_provider
 from dodal.utils import AnyDevice, filter_ophyd_devices, make_all_devices
 
 from . import __version__
@@ -47,6 +49,10 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
 
     os.environ["BEAMLINE"] = beamline
 
+    # We need to make a fake path provider for any detectors that need one,
+    # it is not used in dodal connect
+    _spoof_path_provider()
+
     module_name = module_name_for_beamline(beamline)
     full_module_path = f"dodal.beamlines.{module_name}"
 
@@ -115,3 +121,7 @@ def _connect_devices(
         name: device for name, device in devices.items() if name not in exceptions
     }
     return successful_devices, exceptions
+
+
+def _spoof_path_provider() -> None:
+    set_path_provider(StaticPathProvider(UUIDFilenameProvider(), Path("/tmp")))

dodal/common/__init__.py

@@ -1,10 +1,14 @@
 from .coordination import group_uuid, inject
+from .enums import EnabledDisabledUpper, InOutUpper, OnOffUpper
 from .maths import in_micros, step_to_num
 from .types import MsgGenerator, PlanGenerator
 
 __all__ = [
     "group_uuid",
     "inject",
+    "EnabledDisabledUpper",
+    "InOutUpper",
+    "OnOffUpper",
     "in_micros",
     "MsgGenerator",
     "PlanGenerator",

dodal/common/beamlines/beamline_parameters.py

@@ -8,7 +8,7 @@ BEAMLINE_PARAMETER_KEYWORDS = ["FB", "FULL", "deadtime"]
 
 BEAMLINE_PARAMETER_PATHS = {
     "i03": "/dls_sw/i03/software/daq_configuration/domain/beamlineParameters",
-    "i04": "/dls_sw/i04/software/gda_versions/gda_9_37/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
+    "i04": "/dls_sw/i04/software/daq_configuration/domain/beamlineParameters",
 }
 
 

dodal/common/beamlines/beamline_utils.py

@@ -169,4 +169,8 @@ def get_path_provider() -> PathProvider:
 
 def clear_path_provider() -> None:
     global PATH_PROVIDER
-    del PATH_PROVIDER
+    try:
+        del PATH_PROVIDER
+    except NameError:
+        # In this case the path provider was never set so we can do nothing
+        pass

dodal/common/enums.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StrictEnum
+
+# Any capitalised enums needs to be removed and replaced with ones from ophyd-async.core
+# https://github.com/DiamondLightSource/dodal/issues/1416
+
+
+class OnOffUpper(StrictEnum):
+    ON = "ON"
+    OFF = "OFF"
+
+
+class EnabledDisabledUpper(StrictEnum):
+    ENABLED = "ENABLED"
+    DISABLED = "DISABLED"
+
+
+class InOutUpper(StrictEnum):
+    IN = "IN"
+    OUT = "OUT"

dodal/common/watcher_utils.py

@@ -0,0 +1,83 @@
+from ophyd_async.core import WatchableAsyncStatus, Watcher
+
+from dodal.log import LOGGER
+
+Number = int | float
+
+
+class _LogOnPercentageProgressWatcher(Watcher[Number]):
+    def __init__(
+        self,
+        status: WatchableAsyncStatus[Number],
+        message_prefix: str,
+        percent_interval: Number = 25,
+    ):
+        status.watch(self)
+        self.percent_interval = percent_interval
+        self._current_percent_interval = 0
+        self.message_prefix = message_prefix
+        if self.percent_interval <= 0:
+            raise ValueError(
+                f"Percent interval on class _LogOnPercentageProgressWatcher must be a positive number, but received {self.percent_interval}"
+            )
+
+    def __call__(
+        self,
+        current: Number | None = None,
+        initial: Number | None = None,
+        target: Number | None = None,
+        name: str | None = None,
+        unit: str | None = None,
+        precision: int | None = None,
+        fraction: float | None = None,
+        time_elapsed: float | None = None,
+        time_remaining: float | None = None,
+    ):
+        if (
+            isinstance(current, Number)
+            and isinstance(target, Number)
+            and isinstance(initial, Number)
+            and target != initial
+        ):
+            current_percent = int(((current - initial) / (target - initial)) * 100)
+            if (
+                current_percent
+                >= (self._current_percent_interval + 1) * self.percent_interval
+            ):
+                LOGGER.info(f"{self.message_prefix}: {current_percent}%")
+                self._current_percent_interval = (
+                    current_percent // self.percent_interval
+                )
+
+
+def log_on_percentage_complete(
+    status: WatchableAsyncStatus[int | float],
+    message_prefix: str,
+    percent_interval: int = 25,
+):
+    """
+    Add watcher to a WatchableAsyncStatus status which will periodically log a message based on percentage completion
+
+    Args:
+        status: A WatchableAsyncStatus. For example, Ophyd-async produces this status from a Motor.set method
+
+        message_prefix: The string at the start of each of the produced logging messages
+
+        percent_interval: How often to produce logging message, in terms of percentage completion
+        of the status.
+
+    Note that when using with Bluesky plan stubs you will need to cast the status (as of
+    Bluesky v1.14.2), since a Bluesky status doesn't use generics - see https://github.com/bluesky/bluesky/issues/1948.
+
+    When running Bluesky plans using an interactive terminal, it is better to use the standard bluesky progress
+    bar instead of this function. See https://blueskyproject.io/bluesky/main/progress-bar.html#progress-bar
+
+    Example usage within a Bluesky plan:
+    yield from bps.kickoff(my_detector)
+    status = yield from bps.complete(my_detector, group="collection complete")
+    status = cast(WatchableAsyncStatus, status)
+    log_on_percentage_complete(status, "Data collection triggers received", 10)
+    yield from bps.wait("collection complete")
+
+    """
+    _LogOnPercentageProgressWatcher(status, message_prefix, percent_interval)

dodal/devices/aithre_lasershaping/laser_robot.py

@@ -1,24 +1,19 @@
-from ophyd_async.core import StrictEnum
+from ophyd_async.core import EnabledDisabled, OnOff, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
 from dodal.devices.robot import BartRobot
 
 
 class ForceBit(StrictEnum):
-    ON = "On"
+    ON = OnOff.ON.value
     NO = "No"
-    OFF = "Off"
-
-
-class LidHeatEnable(StrictEnum):
-    ENABLED = "Enabled"
-    DISABLED = "Disabled"
+    OFF = OnOff.OFF.value
 
 
 class LaserRobot(BartRobot):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.dewar_lid_heater = epics_signal_rw(
-            LidHeatEnable, prefix + "DW_1_ENABLED", prefix + "DW_1_CTRL"
+            EnabledDisabled, prefix + "DW_1_ENABLED", prefix + "DW_1_CTRL"
         )
         self.cryojet_retract = epics_signal_rw(ForceBit, prefix + "OP_24_FORCE_OPTION")
         self.set_beamline_safe = epics_signal_rw(

dodal/devices/aperturescatterguard.py

@@ -29,6 +29,7 @@ class _GDAParamApertureValue(StrictEnum):
     SMALL = "SMALL_APERTURE"
     MEDIUM = "MEDIUM_APERTURE"
     LARGE = "LARGE_APERTURE"
+    MANUAL_LOAD = "MANUAL_LOAD"
 
 
 class AperturePosition(BaseModel):
@@ -92,7 +93,7 @@ class AperturePosition(BaseModel):
 class ApertureValue(StrictEnum):
     """The possible apertures that can be selected.
 
-    Changing these means changing the external paramter model of Hyperion.
+    Changing these means changing the external parameter model of Hyperion.
     See https://github.com/DiamondLightSource/mx-bluesky/issues/760
     """
 
@@ -100,6 +101,7 @@ class ApertureValue(StrictEnum):
     MEDIUM = "MEDIUM_APERTURE"
     LARGE = "LARGE_APERTURE"
     OUT_OF_BEAM = "Out of beam"
+    PARKED = "Parked"  # Parked under the collimation table for manual load
 
     def __str__(self):
         return self.name.capitalize()
@@ -121,6 +123,9 @@ def load_positions_from_beamline_parameters(
         ApertureValue.LARGE: AperturePosition.from_gda_params(
             _GDAParamApertureValue.LARGE, 100, params
         ),
+        ApertureValue.PARKED: AperturePosition.from_gda_params(
+            _GDAParamApertureValue.MANUAL_LOAD, 0, params
+        ),
     }
 
 
@@ -158,13 +163,14 @@ class ApertureScatterguard(StandardReadable, Preparable):
 
     def __init__(
         self,
+        aperture_prefix: str,
+        scatterguard_prefix: str,
         loaded_positions: dict[ApertureValue, AperturePosition],
         tolerances: AperturePosition,
-        prefix: str = "",
         name: str = "",
     ) -> None:
-        self.aperture = Aperture(prefix + "-MO-MAPT-01:")
-        self.scatterguard = XYStage(prefix + "-MO-SCAT-01:")
+        self.aperture = Aperture(aperture_prefix)
+        self.scatterguard = XYStage(scatterguard_prefix)
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
@@ -175,6 +181,7 @@ class ApertureScatterguard(StandardReadable, Preparable):
                 medium=self.aperture.medium,
                 small=self.aperture.small,
                 current_ap_y=self.aperture.y.user_readback,
+                current_ap_z=self.aperture.z.user_readback,
             )
 
         self.radius = derived_signal_r(
@@ -196,13 +203,30 @@ class ApertureScatterguard(StandardReadable, Preparable):
 
         super().__init__(name)
 
+    async def _unpark(self, position_to_move_to: ApertureValue):
+        """When the aperture is parked it is under the collimation table. It needs to be
+        moved out from under the table before it is moved up to beam height.
+        """
+        position = self._loaded_positions[position_to_move_to]
+        await self.aperture.z.set(position.aperture_z)
+
     async def _set_current_aperture_position(self, value: ApertureValue) -> None:
+        if value == ApertureValue.PARKED:
+            raise NotImplementedError(
+                "Currently not able to park aperture/scatterguard, see https://github.com/DiamondLightSource/mx-bluesky/issues/1197"
+            )
+
         position = self._loaded_positions[value]
+
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        if self._is_in_position(ApertureValue.PARKED, current_ap_y, current_ap_z):
+            await self._unpark(value)
+
         await self._check_safe_to_move(position.aperture_z)
 
         if value == ApertureValue.OUT_OF_BEAM:
-            out_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
-            await self.aperture.y.set(out_y)
+            await self.aperture.y.set(position.aperture_y)
         else:
             await self._safe_move_whilst_in_beam(position)
 
@@ -240,12 +264,22 @@ class ApertureScatterguard(StandardReadable, Preparable):
     def _get_current_radius(self, current_aperture: ApertureValue) -> float:
         return self._loaded_positions[current_aperture].radius
 
-    def _is_out_of_beam(self, current_ap_y: float) -> bool:
-        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
-        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
+    def _is_in_position(
+        self, position: ApertureValue, current_ap_y: float, current_ap_z: float
+    ) -> bool:
+        position_y = self._loaded_positions[position].aperture_y
+        position_z = self._loaded_positions[position].aperture_z
+        y_matches = abs(current_ap_y - position_y) <= self._tolerances.aperture_y
+        z_matches = abs(current_ap_z - position_z) <= self._tolerances.aperture_z
+        return y_matches and z_matches
 
     def _get_current_aperture_position(
-        self, large: float, medium: float, small: float, current_ap_y: float
+        self,
+        large: float,
+        medium: float,
+        small: float,
+        current_ap_y: float,
+        current_ap_z: float,
     ) -> ApertureValue:
         if large == 1:
             return ApertureValue.LARGE
@@ -253,7 +287,11 @@ class ApertureScatterguard(StandardReadable, Preparable):
             return ApertureValue.MEDIUM
         elif small == 1:
             return ApertureValue.SMALL
-        elif self._is_out_of_beam(current_ap_y):
+        elif self._is_in_position(ApertureValue.PARKED, current_ap_y, current_ap_z):
+            return ApertureValue.PARKED
+        elif self._is_in_position(
+            ApertureValue.OUT_OF_BEAM, current_ap_y, current_ap_z
+        ):
             return ApertureValue.OUT_OF_BEAM
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
@@ -317,7 +355,9 @@ class ApertureScatterguard(StandardReadable, Preparable):
         Moving the assembly whilst out of the beam has no collision risk so we can just
         move all the motors together.
         """
-        if self._is_out_of_beam(await self.aperture.y.user_readback.get_value()):
+        current_y = await self.aperture.y.user_readback.get_value()
+        current_z = await self.aperture.z.user_readback.get_value()
+        if self._is_in_position(ApertureValue.OUT_OF_BEAM, current_y, current_z):
             aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
                 self._loaded_positions[value].values
             )

dodal/devices/apple2_undulator.py

@@ -406,7 +406,6 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self,
         id_gap: UndulatorGap,
         id_phase: UndulatorPhaseAxes,
-        prefix: str = "",
         name: str = "",
     ) -> None:
         """

dodal/devices/b16/detector.py

@@ -1,5 +1,4 @@
 from ophyd_async.epics.adcore import (
-    ADBaseController,
     ADBaseIO,
     ADTIFFWriter,
     AreaDetector,
@@ -7,15 +6,7 @@ from ophyd_async.epics.adcore import (
 
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.common.beamlines.device_helpers import CAM_SUFFIX, TIFF_SUFFIX
-
-
-class ConstantDeadTimeController(ADBaseController):
-    def __init__(self, driver: ADBaseIO, deadtime: float):
-        super().__init__(driver)
-        self.deadtime = deadtime
-
-    def get_deadtime(self, exposure: float | None) -> float:
-        return self.deadtime
+from dodal.devices.controllers import ConstantDeadTimeController
 
 
 def software_triggered_tiff_area_detector(prefix: str, deadtime: float = 0.0):

dodal/devices/backlight.py

@@ -1,35 +1,23 @@
 from asyncio import sleep
 
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.core import AsyncStatus, InOut, OnOff, StandardReadable
 from ophyd_async.epics.core import epics_signal_rw
 
 
-class BacklightPower(StrictEnum):
-    ON = "On"
-    OFF = "Off"
-
-
-class BacklightPosition(StrictEnum):
-    IN = "In"
-    OUT = "Out"
-
-
-class Backlight(StandardReadable, Movable[BacklightPosition]):
+class Backlight(StandardReadable, Movable[InOut]):
     """Simple device to trigger the pneumatic in/out."""
 
     TIME_TO_MOVE_S = 1.0  # Tested using a stopwatch on the beamline 09/2024
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.power = epics_signal_rw(BacklightPower, prefix + "-EA-BLIT-01:TOGGLE")
-            self.position = epics_signal_rw(
-                BacklightPosition, prefix + "-EA-BL-01:CTRL"
-            )
+            self.power = epics_signal_rw(OnOff, prefix + "-EA-BLIT-01:TOGGLE")
+            self.position = epics_signal_rw(InOut, prefix + "-EA-BL-01:CTRL")
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, value: BacklightPosition):
+    async def set(self, value: InOut):
         """This setter will turn the backlight on when we move it in to the beam and off
         when we move it out.
 
@@ -39,9 +27,9 @@ class Backlight(StandardReadable, Movable[BacklightPosition]):
         """
         old_position = await self.position.get_value()
         await self.position.set(value)
-        if value == BacklightPosition.OUT:
-            await self.power.set(BacklightPower.OFF)
+        if value == InOut.OUT:
+            await self.power.set(OnOff.OFF)
         else:
-            await self.power.set(BacklightPower.ON)
+            await self.power.set(OnOff.ON)
         if old_position != value:
             await sleep(self.TIME_TO_MOVE_S)

dodal/devices/bimorph_mirror.py

@@ -22,12 +22,9 @@ from ophyd_async.epics.core import (
     epics_signal_x,
 )
 
-DEFAULT_TIMEOUT = 60
-
+from dodal.common.enums import OnOffUpper
 
-class BimorphMirrorOnOff(StrictEnum):
-    ON = "ON"
-    OFF = "OFF"
+DEFAULT_TIMEOUT = 60
 
 
 class BimorphMirrorMode(StrictEnum):
@@ -54,7 +51,7 @@ class BimorphMirrorChannel(StandardReadable, EpicsDevice):
 
     target_voltage: A[SignalRW[float], PvSuffix.rbv("VTRGT"), Format.CONFIG_SIGNAL]
     output_voltage: A[SignalRW[float], PvSuffix.rbv("VOUT"), Format.HINTED_SIGNAL]
-    status: A[SignalR[BimorphMirrorOnOff], PvSuffix("STATUS"), Format.CONFIG_SIGNAL]
+    status: A[SignalR[OnOffUpper], PvSuffix("STATUS"), Format.CONFIG_SIGNAL]
     shift: A[SignalW[float], PvSuffix("SHIFT")]
 
 
@@ -87,7 +84,7 @@ class BimorphMirror(StandardReadable, Movable[list[float]]):
                     for i in range(1, number_of_channels + 1)
                 }
             )
-        self.enabled = epics_signal_w(BimorphMirrorOnOff, f"{prefix}ONOFF")
+        self.enabled = epics_signal_w(OnOffUpper, f"{prefix}ONOFF")
         self.commit_target_voltages = epics_signal_x(f"{prefix}ALLTRGT.PROC")
         self.status = epics_signal_r(BimorphMirrorStatus, f"{prefix}STATUS")
         self.err = epics_signal_r(str, f"{prefix}ERR")

dodal/devices/collimation_table.py

@@ -0,0 +1,36 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class CollimationTable(StandardReadable):
+    """Basic collimation table device for motion plus the motion disable signal
+    when laser curtain triggered and hutch not locked.
+
+    The table has 3 physical vertical motors, the jacks. 1 upstream and 2 downstream.
+    The two downstream jacks are labelled as outboard (away from the ring) and
+    inboard (towards the ring).
+    Together these 3 jacks provide compound motion for vertical motion and pitch/roll.
+    There are 2 physical horizontal motors 1 upstream, 1 downstream. These provide yaw.
+
+    Table motion is disabled by an object being within the laser curtain area and can be
+    overridden by use of the dead man's handle device or locking the hutch. The effect of
+    these disabling systems is to cut power to the motors - signal for this is crate_power
+    """
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.inboard_y = Motor(f"{prefix}:INBOARDY")
+            self.outboard_y = Motor(f"{prefix}:OUTBOARDY")
+            self.upstream_y = Motor(f"{prefix}:UPSTREAMY")
+            self.combined_downstream_y = Motor(f"{prefix}:DOWNSTREAMY")
+            self.combined_all_y = Motor(f"{prefix}:Y")
+
+            self.downstream_x = Motor(f"{prefix}:DOWNSTREAMX")
+            self.upstream_x = Motor(f"{prefix}:UPSTREAMX")
+            self.combined_all_x = Motor(f"{prefix}:X")
+
+            self.pitch = Motor(f"{prefix}:PITCH")
+            self.roll = Motor(f"{prefix}:ROLL")
+            self.yaw = Motor(f"{prefix}:YAW")
+
+            super().__init__(name)

dodal/devices/controllers.py

@@ -0,0 +1,21 @@
+from typing import TypeVar
+
+from ophyd_async.epics.adcore import (
+    ADBaseController,
+    ADBaseIO,
+)
+
+ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
+
+
+class ConstantDeadTimeController(ADBaseController[ADBaseIOT]):
+    """
+    ADBaseController with a configured constant deadtime for a driver of type ADBaseIO.
+    """
+
+    def __init__(self, driver: ADBaseIOT, deadtime: float):
+        super().__init__(driver)
+        self.deadtime = deadtime
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return self.deadtime