dls-dodal 1.57.0__py3-none-any.whl → 1.59.1__py3-none-any.whl

dodal/devices/i19/backlight.py

@@ -0,0 +1,17 @@
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.common.enums import InOutUpper
+
+
+class BacklightPosition(StandardReadable, Movable[InOutUpper]):
+    """Device moves backlight to the IN or OUT position since controls side manages switching the light on/off"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.position = epics_signal_rw(InOutUpper, f"{prefix}AD1:choiceButton")
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: InOutUpper):
+        await self.position.set(value, wait=True)

dodal/devices/i21/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.i21.enums import Grating
+
+__all__ = ["Grating"]

dodal/devices/i21/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class Grating(StrictEnum):
+    VPG1 = "VPG1"
+    VPG2 = "VPG2"
+    VPG3 = "VPG3"
+    VPG4 = "VPG4"

dodal/devices/i22/nxsas.py

@@ -7,6 +7,7 @@ from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
 from ophyd_async.epics.adaravis import AravisDetector
+from ophyd_async.epics.adcore import NDPluginBaseIO
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -106,6 +107,7 @@ class NXSasPilatus(PilatusDetector):
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.

dodal/devices/i24/commissioning_jungfrau.py

@@ -0,0 +1,114 @@
+import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
+from pathlib import Path
+
+from bluesky.protocols import StreamAsset
+from event_model import DataKey  # type: ignore
+from ophyd_async.core import (
+    AutoIncrementingPathProvider,
+    DetectorWriter,
+    StandardDetector,
+    StandardReadable,
+    StaticPathProvider,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ophyd_async.fastcs.jungfrau._controller import JungfrauController
+from ophyd_async.fastcs.jungfrau._signals import JungfrauDriverIO
+
+from dodal.log import LOGGER
+
+
+class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
+    """Implementation of the temporary filewriter used for Jungfrau commissioning on i24.
+
+    The PVs on this device are responsible for writing files of a specified name
+    to a specified path, marking itself as "ready to write", and having a counter of
+    frames written, which must be zero'd at the ophyd level
+    """
+
+    def __init__(
+        self,
+        prefix,
+        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        name="",
+    ) -> None:
+        with self.add_children_as_readables():
+            self._path_info = path_provider
+            self.frame_counter = epics_signal_rw(int, f"{prefix}NumCaptured")
+            self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
+            self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
+            self.writer_ready = epics_signal_r(int, f"{prefix}Ready_RBV")
+        super().__init__(name)
+
+    async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
+        self._exposures_per_event = exposures_per_event
+        _path_info = self._path_info()
+
+        # Commissioning Jungfrau plans allow you to override path, so check to see if file exists
+        requested_filepath = Path(_path_info.directory_path) / _path_info.filename
+        if requested_filepath.exists():
+            raise FileExistsError(
+                f"Jungfrau was requested to write to {requested_filepath}, but this file already exists!"
+            )
+
+        await asyncio.gather(
+            self.file_name.set(_path_info.filename),
+            self.file_path.set(str(_path_info.directory_path)),
+            self.frame_counter.set(0),
+        )
+        LOGGER.info(
+            f"Jungfrau writing to folder {_path_info.directory_path} with filename {_path_info.filename}"
+        )
+        await wait_for_value(self.writer_ready, 1, timeout=10)
+        return await self._describe()
+
+    async def _describe(self) -> dict[str, DataKey]:
+        # Dummy function, doesn't actually describe the dataset
+
+        return {
+            "data": DataKey(
+                source="Commissioning writer",
+                shape=[-1],
+                dtype="array",
+                dtype_numpy="<u2",
+                external="STREAM:",
+            )
+        }
+
+    async def observe_indices_written(
+        self, timeout: float
+    ) -> AsyncGenerator[int, None]:
+        timeout = timeout * 2  # This filewriter is slow
+        async for num_captured in observe_value(self.frame_counter, timeout):
+            yield num_captured // (self._exposures_per_event)
+
+    async def get_indices_written(self) -> int:
+        return await self.frame_counter.get_value() // self._exposures_per_event
+
+    def collect_stream_docs(
+        self, name: str, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        raise NotImplementedError()
+
+    async def close(self) -> None: ...
+
+
+class CommissioningJungfrau(
+    StandardDetector[JungfrauController, JunfrauCommissioningWriter]
+):
+    """Ophyd-async implementation of a Jungfrau 9M Detector, using a temporary
+    filewriter in place of Odin"""
+
+    def __init__(
+        self,
+        prefix: str,
+        writer_prefix: str,
+        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        name="",
+    ):
+        self.drv = JungfrauDriverIO(prefix)
+        writer = JunfrauCommissioningWriter(writer_prefix, path_provider)
+        controller = JungfrauController(self.drv)
+        super().__init__(controller, writer, name=name)

dodal/devices/smargon.py

@@ -1,13 +1,9 @@
 import asyncio
-from collections.abc import Collection, Generator
-from dataclasses import dataclass
 from enum import Enum
 from math import isclose
 from typing import TypedDict, cast
 
-from bluesky import plan_stubs as bps
 from bluesky.protocols import Movable
-from bluesky.utils import Msg
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -66,40 +62,6 @@ class StubOffsets(Device):
             await self.to_robot_load.set(1)
 
 
-@dataclass
-class AxisLimit:
-    """Represents the minimum and maximum allowable values on an axis"""
-
-    min_value: float
-    max_value: float
-
-    def contains(self, pos: float):
-        """Determine if the specified value is within limits.
-
-        Args:
-            pos: the value to check
-
-        Returns:
-            True if the value does not exceed the limits
-        """
-        return self.min_value <= pos <= self.max_value
-
-
-@dataclass
-class XYZLimits:
-    """The limits of the smargon x, y, z axes."""
-
-    x: AxisLimit
-    y: AxisLimit
-    z: AxisLimit
-
-    def position_valid(self, pos: Collection[float]) -> bool:
-        return all(
-            axis_limits.contains(value)
-            for axis_limits, value in zip([self.x, self.y, self.z], pos, strict=False)
-        )
-
-
 class DeferMoves(StrictEnum):
     ON = "Defer On"
     OFF = "Defer Off"
@@ -144,24 +106,6 @@ class Smargon(XYZStage, Movable):
 
         super().__init__(prefix, name)
 
-    def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
-        """Obtain a plan stub that returns the smargon XYZ axis limits
-
-        Yields:
-            Bluesky messages
-
-        Returns:
-            the axis limits
-        """
-        limits = {}
-        for name, pv in [
-            (attr_name, getattr(self, attr_name)) for attr_name in ["x", "y", "z"]
-        ]:
-            min_value = yield from bps.rd(pv.low_limit_travel)
-            max_value = yield from bps.rd(pv.high_limit_travel)
-            limits[name] = AxisLimit(min_value, max_value)
-        return XYZLimits(**limits)
-
     @AsyncStatus.wrap
     async def set(self, value: CombinedMove):
         """This will move all motion together in a deferred move.

dodal/devices/temperture_controller/__init__.py

@@ -0,0 +1,3 @@
+from .lakeshore.lakeshore import Lakeshore, Lakeshore336, Lakeshore340
+
+__all__ = ["Lakeshore336", "Lakeshore340", "Lakeshore"]

dodal/devices/temperture_controller/lakeshore/lakeshore.py

@@ -0,0 +1,204 @@
+from asyncio import gather
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    SignalDatatypeT,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+    derived_signal_rw,
+    soft_signal_rw,
+)
+
+from .lakeshore_io import (
+    LakeshoreBaseIO,
+)
+
+
+class Heater336Settings(StrictEnum):
+    OFF = "Off"
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+
+
+class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
+    """
+    Device for controlling and reading from a Lakeshore temperature controller.
+    It supports multiple channels and PID control.
+
+    Attributes
+    ----------
+    temperature : LakeshoreBaseIO
+        Temperature IO interface.
+    PID : PIDBaseIO
+        PID IO interface.
+    control_channel : derived_signal_rw
+        Signal for selecting the control channel,
+        optional readback as hinted signal
+        (default readback channel is the same as control channel).
+
+    temperature_high_limit: soft_signal_rw
+        Signal to store the soft high temperature limit.
+    temperature_low_limit: soft_signal_rw
+        Signal to store the soft low temperature limit.
+
+
+    Methods
+    -------
+    set(value: float)
+        Set the temperature setpoint for the selected control channel.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        num_readback_channel: int,
+        heater_setting: type[SignalDatatypeT],
+        control_channel: int = 1,
+        single_control_channel: bool = False,
+        name: str = "",
+    ):
+        """
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        no_channels : int
+            Number of temperature channels.
+        heater_setting : type[SignalDatatypeT]
+            Enum type for heater settings.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        single_control_channel : bool, optional
+            Whether to use a single control channel (default is False).
+        name : str, optional
+            Name of the device.
+        """
+        self._control_channel = soft_signal_rw(int, initial_value=control_channel)
+        self.temperature_high_limit = soft_signal_rw(float, initial_value=400)
+        self.temperature_low_limit = soft_signal_rw(float, initial_value=0)
+
+        self.control_channel = derived_signal_rw(
+            raw_to_derived=self._get_control_channel,
+            set_derived=self._set_control_channel,
+            current_channel=self._control_channel,
+        )
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=num_readback_channel,
+            heater_setting=heater_setting,
+            name=name,
+            single_control_channel=single_control_channel,
+        )
+
+        self.add_readables(
+            [setpoint.user_setpoint for setpoint in self.control_channels.values()]
+        )
+        self.add_readables(
+            list(self.readback.values()), format=StandardReadableFormat.HINTED_SIGNAL
+        )
+
+        self.add_readables(
+            [
+                self._control_channel,
+                self.control_channels[control_channel].p,
+                self.control_channels[control_channel].i,
+                self.control_channels[control_channel].d,
+                self.control_channels[control_channel].heater_output_range,
+            ],
+            StandardReadableFormat.CONFIG_SIGNAL,
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        """
+        Set the temperature setpoint for the active control channel.
+        """
+        high, low = await gather(
+            self.temperature_high_limit.get_value(),
+            self.temperature_low_limit.get_value(),
+        )
+        if high >= value >= low:
+            await self.control_channels[
+                await self.control_channel.get_value()
+            ].user_setpoint.set(value)
+        else:
+            raise ValueError(
+                f"{self.name} requested temperature {value} is outside limits: {low}, {high}"
+            )
+
+    def _get_control_channel(self, current_channel: int) -> int:
+        return current_channel
+
+    async def _set_control_channel(self, value: int) -> None:
+        if value < 1 or value > len(self.control_channels):
+            raise ValueError(
+                f"Control channel must be between 1 and {len(self.control_channels)}."
+            )
+        await self._control_channel.set(value)
+        self._read_config_funcs = (
+            self._control_channel.read,
+            self.control_channels[value].user_setpoint.read,
+            self.control_channels[value].p.read,
+            self.control_channels[value].i.read,
+            self.control_channels[value].d.read,
+            self.control_channels[value].heater_output_range.read,
+        )
+
+
+class Lakeshore336(Lakeshore):
+    def __init__(
+        self,
+        prefix: str,
+        control_channel: int = 1,
+        name: str = "",
+    ):
+        """
+        Lakeshore 336 temperature controller. With 4 readback and control channels.
+        Heater settings are: Off, Low, Medium, High.
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        """
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=4,
+            heater_setting=Heater336Settings,
+            control_channel=control_channel,
+            single_control_channel=False,
+            name=name,
+        )
+
+
+class Lakeshore340(Lakeshore):
+    def __init__(
+        self,
+        prefix: str,
+        control_channel: int = 1,
+        name: str = "",
+    ):
+        """Lakeshore 340 temperature controller. With 4 readback channels and a single
+        control channel.
+        Heater settings are in power from 0 to 5. 0 is 0 watt, 5 is 50 watt.
+
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        """
+
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=4,
+            heater_setting=float,
+            control_channel=control_channel,
+            single_control_channel=True,
+            name=name,
+        )

dodal/devices/temperture_controller/lakeshore/lakeshore_io.py

@@ -0,0 +1,112 @@
+from ophyd_async.core import Device, DeviceVector, SignalDatatypeT
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class LakeshoreControlChannel(Device):
+    """
+    Single control channel for a Lakeshore temperature controller.
+
+    Provides access to setpoint, ramp rate, ramp enable, heater output, heater output range,
+    PID parameters (P, I, D), and manual output for the channel.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix: str,
+        heater_type: type[SignalDatatypeT],
+        name: str = "",
+    ):
+        """Initialize the LakeshoreControlChannel device.
+        Parameters
+        ----------
+            prefix: str
+                The EPICS prefix for the Lakeshore device.
+            suffix: str
+                Suffix for the channel, used to differentiate multiple channels.
+            heater_type: SignalDatatypeT
+                Type of the heater output range.
+            name: str
+                Optional name for the device.
+        """
+
+        def channel_rw(channel_type, pv_name):
+            return epics_signal_rw(
+                channel_type,
+                f"{prefix}{pv_name}{suffix}",
+                f"{prefix}{pv_name}_S{suffix}",
+            )
+
+        self.user_setpoint = channel_rw(channel_type=float, pv_name="SETP")
+        self.ramp_rate = channel_rw(channel_type=float, pv_name="RAMP")
+        self.ramp_enable = channel_rw(channel_type=int, pv_name="RAMPST")
+        self.heater_output_range = channel_rw(channel_type=heater_type, pv_name="RANGE")
+        self.p = channel_rw(channel_type=float, pv_name="P")
+        self.i = channel_rw(channel_type=float, pv_name="I")
+        self.d = channel_rw(channel_type=float, pv_name="D")
+        self.manual_output = channel_rw(channel_type=float, pv_name="MOUT")
+        self.heater_output = epics_signal_r(float, f"{prefix}{'HTR'}{suffix}")
+
+        super().__init__(name=name)
+
+
+class LakeshoreBaseIO(Device):
+    """Base class for Lakeshore temperature controller IO.
+
+    Provides access to control channels and readback channels for setpoint, ramp rate, heater output,
+    and PID parameters. Supports both single and multiple control channel configurations.
+    Note:
+        Almost all models have a controller for each readback channel but some models
+            only has a single controller for multiple readback channels.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        num_readback_channel: int,
+        heater_setting: type[SignalDatatypeT],
+        name: str = "",
+        single_control_channel: bool = False,
+    ):
+        """Initialize the LakeshoreBaseIO device.
+
+        Parameters
+        -----------
+            prefix: str
+                The EPICS prefix for the Lakeshore device.
+            num_readback_channel: int
+                Number of readback channels to create.
+            heater_setting: SignalDatatypeT
+                Type of the heater setting.
+            name: str
+                Optional name for the device.
+            single_control_channel: bool
+                If True, use a single control channel for all readback.
+        """
+
+        suffixes = (
+            [""]
+            if single_control_channel
+            else map(str, range(1, num_readback_channel + 1))
+        )
+        self.control_channels = DeviceVector(
+            {
+                i: LakeshoreControlChannel(
+                    prefix=prefix, suffix=suffix, heater_type=heater_setting
+                )
+                for i, suffix in enumerate(suffixes, start=1)
+            }
+        )
+
+        self.readback = DeviceVector(
+            {
+                i: epics_signal_r(
+                    float,
+                    read_pv=f"{prefix}KRDG{i - 1}",
+                )
+                for i in range(1, num_readback_channel + 1)
+            }
+        )
+        super().__init__(
+            name=name,
+        )

dodal/devices/tetramm.py

@@ -16,6 +16,7 @@ from ophyd_async.core import (
     TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
+    wait_for_value,
 )
 from ophyd_async.epics.adcore import (
     ADHDFWriter,
@@ -23,7 +24,7 @@ from ophyd_async.epics.adcore import (
     NDFileHDFIO,
     NDPluginBaseIO,
 )
-from ophyd_async.epics.core import PvSuffix, stop_busy_record
+from ophyd_async.epics.core import PvSuffix, epics_signal_r
 
 
 class TetrammRange(StrictEnum):
@@ -77,6 +78,7 @@ class TetrammController(DetectorController):
     _supported_trigger_types = {
         DetectorTrigger.EDGE_TRIGGER: TetrammTrigger.EXT_TRIGGER,
         DetectorTrigger.CONSTANT_GATE: TetrammTrigger.EXT_TRIGGER,
+        DetectorTrigger.VARIABLE_GATE: TetrammTrigger.EXT_TRIGGER,
     }
     """"On the TetrAMM ASCII mode requires a minimum value of ValuesPerRead of 500,
     [...] binary mode the minimum value of ValuesPerRead is 5."
@@ -86,11 +88,9 @@ class TetrammController(DetectorController):
     """The TetrAMM always digitizes at 100 kHz"""
     _base_sample_rate: int = 100_000
 
-    def __init__(
-        self,
-        driver: TetrammDriver,
-    ) -> None:
+    def __init__(self, driver: TetrammDriver, file_io: NDFileHDFIO) -> None:
         self.driver = driver
+        self._file_io = file_io
         self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
@@ -107,13 +107,19 @@ class TetrammController(DetectorController):
         if trigger_info.livetime is None:
             raise ValueError(f"{self.__class__.__name__} requires that livetime is set")
 
+        current_trig_status = await self.driver.trigger_mode.get_value()
+
+        if current_trig_status == TetrammTrigger.FREE_RUN:  # if freerun turn off first
+            await self.disarm()
+
         # trigger mode must be set first and on its own!
         await self.driver.trigger_mode.set(
             self._supported_trigger_types[trigger_info.trigger]
         )
+
         await asyncio.gather(
-            self.driver.averaging_time.set(trigger_info.livetime),
             self.set_exposure(trigger_info.livetime),
+            self._file_io.num_capture.set(trigger_info.total_number_of_exposures),
         )
 
         # raise an error if asked to trigger faster than the max.
@@ -133,14 +139,18 @@ class TetrammController(DetectorController):
         self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 
     async def wait_for_idle(self):
-        if self._arm_status and not self._arm_status.done:
-            await self._arm_status
-        self._arm_status = None
+        # tetramm never goes idle really, actually it is always acquiring
+        # so need to wait for the capture to finish instead
+        await wait_for_value(self._file_io.acquire, False, timeout=None)
+
+    async def unstage(self):
+        await self.disarm()
+        await self._file_io.acquire.set(False)
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await set_and_wait_for_value(self.driver.acquire, False, timeout=1)
 
     async def set_exposure(self, exposure: float) -> None:
         """Set the exposure time and acquire period.
@@ -164,7 +174,9 @@ class TetrammController(DetectorController):
                 "Tetramm exposure time must be at least "
                 f"{minimum_samples * sample_time}s, asked to set it to {exposure}s"
             )
-        await self.driver.averaging_time.set(samples_per_reading * sample_time)
+        await self.driver.averaging_time.set(
+            samples_per_reading * sample_time
+        )  # correct
 
     async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
         """Start acquiring driver, raising ValueError if the detector is in a bad state.
@@ -202,10 +214,7 @@ class TetrammDatasetDescriber(DatasetDescriber):
     async def shape(self) -> tuple[int, int]:
         return (
             int(await self._driver.num_channels.get_value()),
-            int(
-                await self._driver.averaging_time.get_value()
-                / await self._driver.sample_time.get_value(),
-            ),
+            int(await self._driver.to_average.get_value()),
         )
 
 
@@ -223,7 +232,20 @@ class TetrammDetector(StandardDetector):
     ):
         self.driver = TetrammDriver(prefix + drv_suffix)
         self.file_io = NDFileHDFIO(prefix + fileio_suffix)
-        controller = TetrammController(self.driver)
+        controller = TetrammController(self.driver, self.file_io)
+
+        self.current1 = epics_signal_r(float, prefix + "Cur1:MeanValue_RBV")
+        self.current2 = epics_signal_r(float, prefix + "Cur2:MeanValue_RBV")
+        self.current3 = epics_signal_r(float, prefix + "Cur3:MeanValue_RBV")
+        self.current4 = epics_signal_r(float, prefix + "Cur4:MeanValue_RBV")
+
+        self.sum_x = epics_signal_r(float, prefix + "SumX:MeanValue_RBV")
+        self.sum_y = epics_signal_r(float, prefix + "SumY:MeanValue_RBV")
+        self.sum_all = epics_signal_r(float, prefix + "SumAll:MeanValue_RBV")
+        self.diff_x = epics_signal_r(float, prefix + "DiffX:MeanValue_RBV")
+        self.diff_y = epics_signal_r(float, prefix + "DiffY:MeanValue_RBV")
+        self.pos_x = epics_signal_r(float, prefix + "PosX:MeanValue_RBV")
+        self.pos_y = epics_signal_r(float, prefix + "PosY:MeanValue_RBV")
 
         writer = ADHDFWriter(
             fileio=self.file_io,