dls-dodal 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

dodal/devices/motors.py

@@ -1,61 +1,118 @@
+from abc import ABC
+
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
+_X, _Y, _Z = "X", "Y", "Z"
 
-class XYZPositioner(StandardReadable):
-    """
 
-    Standard ophyd_async xyz motor stage, by combining 3 Motors,
-    with added infix for extra flexibliy to allow different axes other than x,y,z.
+class Stage(StandardReadable, ABC):
+    """
+    For these devices, the following co-ordinates are typical but not enforced:
+    - z is horizontal & parallel to the direction of beam travel
+    - y is vertical and antiparallel to the force of gravity
+    - x is the cross product of y🞬z
 
     Parameters
     ----------
     prefix:
-        EPICS PV (Common part up to and including :).
+        Common part of the EPICS PV for all motors, including ":".
     name:
-        name for the stage.
-    infix:
-        EPICS PV, default is the ("X", "Y", "Z").
-    Notes
-    -----
-    Example usage::
-        async with init_devices():
-            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
-    Or::
-        with init_devices():
-            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", infix = ("A", "B", "C"))
-
+        Name of the stage, each child motor will be named "{name}-{field_name}"
+    *_infix:
+        Infix between the common prefix and the EPICS motor record fields for the field.
     """
 
+    ...
+
+
+class XThetaStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", x_infix: str = _X, theta_infix: str = "A"
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + x_infix)
+            self.theta = Motor(prefix + theta_infix)
+        super().__init__(name=name)
+
+
+class XYStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", x_infix: str = _X, y_infix: str = _Y
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + x_infix)
+            self.y = Motor(prefix + y_infix)
+        super().__init__(name=name)
+
+
+class XYZStage(XYStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        infix: tuple[str, str, str] = ("X", "Y", "Z"),
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
     ):
         with self.add_children_as_readables():
-            self.x = Motor(prefix + infix[0])
-            self.y = Motor(prefix + infix[1])
-            self.z = Motor(prefix + infix[2])
-        super().__init__(name=name)
+            self.z = Motor(prefix + z_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
 
 
-class SixAxisGonio(XYZPositioner):
+class XYZThetaStage(XYZStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        infix: tuple[str, str, str, str, str, str] = (
-            "X",
-            "Y",
-            "Z",
-            "KAPPA",
-            "PHI",
-            "OMEGA",
-        ),
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        theta_infix: str = _Z,
+    ) -> None:
+        with self.add_children_as_readables():
+            self.theta = Motor(prefix + theta_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
+class XYPitchStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        pitch_infix: str = "PITCH",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + pitch_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
+class SixAxisGonio(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        kappa_infix: str = "KAPPA",
+        phi_infix: str = "PHI",
+        omega_infix: str = "OMEGA",
     ):
         with self.add_children_as_readables():
-            self.kappa = Motor(prefix + infix[3])
-            self.phi = Motor(prefix + infix[4])
-            self.omega = Motor(prefix + infix[5])
-        super().__init__(name=name, prefix=prefix, infix=infix[0:3])
+            self.kappa = Motor(prefix + kappa_infix)
+            self.phi = Motor(prefix + phi_infix)
+            self.omega = Motor(prefix + omega_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
+class YZStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", y_infix: str = _Y, z_infix: str = _Z
+    ) -> None:
+        with self.add_children_as_readables():
+            self.y = Motor(prefix + y_infix)
+            self.z = Motor(prefix + z_infix)
+        super().__init__(name)

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -141,14 +141,16 @@ class PinTipDetection(StandardReadable):
 
     @AsyncStatus.wrap
     async def trigger(self):
-        async def _set_triggered_tip():
-            """Monitors the camera data and updates the triggered_tip signal.
-
-            If a tip is found it will update the signal and stop monitoring
-            If no tip is found it will retry with the next monitored value
-            This loop will serve as a good example of using 'observe_value' in the ophyd_async documentation
-            """
-            async for value in observe_value(self.array_data):
+        """Monitors the camera data and updates the triggered_tip signal.
+
+        * If a tip is found it will update the signal and stop monitoring
+        * If no tip is found it will retry with the next monitored value, if this
+            continues for {validity_timeout} seconds it will timeout.
+        """
+        try:
+            async for value in observe_value(
+                self.array_data, done_timeout=await self.validity_timeout.get_value()
+            ):
                 try:
                     location = await self._get_tip_and_edge_data(value)
                     self._set_triggered_values(location)
@@ -157,12 +159,7 @@ class PinTipDetection(StandardReadable):
                         f"Failed to detect pin-tip location, will retry with next image: {e}"
                     )
                 else:
-                    return
-
-        try:
-            await asyncio.wait_for(
-                _set_triggered_tip(), timeout=await self.validity_timeout.get_value()
-            )
+                    break
         except asyncio.exceptions.TimeoutError:
             LOGGER.error(
                 f"No tip found in {await self.validity_timeout.get_value()} seconds."

dodal/devices/p45.py

@@ -41,15 +41,3 @@ class TomoStageWithStretchAndSkew(StandardReadable):
             self.y = SampleY(prefix)
             self.theta = SampleTheta(prefix)
         super().__init__(name)
-
-
-class Choppers(StandardReadable):
-    """
-    Grouping for the P45 chopper motors
-    """
-
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables():
-            self.x = Motor(prefix + "ENDAT")
-            self.y = Motor(prefix + "BISS")
-        super().__init__(name)

dodal/devices/p60/__init__.py

@@ -0,0 +1,4 @@
+from .enums import LensMode
+from .lab_xray_source import LabXraySource, LabXraySourceReadable
+
+__all__ = ["LensMode", "LabXraySource", "LabXraySourceReadable"]

dodal/devices/p60/enums.py

@@ -0,0 +1,10 @@
+from ophyd_async.core import StrictEnum
+
+
+class LensMode(StrictEnum):
+    TRANSMISSION = "Transmission"
+    ANGULAR14 = "Angular14"
+    ANGULAR7NF = "Angular7NF"
+    ANGULAR30 = "Angular30"
+    ANGULAR30_SMALLSPOT = "Angular30_SmallSpot"
+    ANGULAR14_SMALLSPOT = "Angular14_SmallSpot"

dodal/devices/p60/lab_xray_source.py

@@ -0,0 +1,21 @@
+from ophyd_async.core import (
+    StandardReadable,
+    StrictEnum,
+    soft_signal_r_and_setter,
+)
+
+
+class LabXraySource(StrictEnum):
+    AL_KALPHA = 1486.6
+    MG_KALPHA = 1253.6
+
+
+class LabXraySourceReadable(StandardReadable):
+    """Simple device to get the laboratory x-ray tube energy reading"""
+
+    def __init__(self, xraysource: LabXraySource, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.energy_ev, _ = soft_signal_r_and_setter(
+                float, initial_value=xraysource.value, units="eV"
+            )
+        super().__init__(name)

dodal/devices/pgm.py

@@ -16,7 +16,7 @@ class PGM(StandardReadable):
         self,
         prefix: str,
         grating: type[StrictEnum],
-        gratingPv: str,
+        gratingPv: str = "GRATINGSELECT:SELECT",
         name: str = "",
     ) -> None:
         """

dodal/devices/robot.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     StandardReadable,
+    StandardReadableFormat,
     StrictEnum,
     set_and_wait_for_value,
     wait_for_value,
@@ -74,18 +75,21 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
     LOAD_TOLERANCE_MM = 0.02
 
     def __init__(self, name: str, prefix: str) -> None:
-        self.barcode = epics_signal_r(str, prefix + "BARCODE")
-        self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.barcode = epics_signal_r(str, prefix + "BARCODE")
+            self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+
+            self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
+            self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
-        self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
-        self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
-        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
         self.sample_id = epics_signal_r(int, prefix + "CURRENT_ID_RBV")
+        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
 
         self.load = epics_signal_x(prefix + "LOAD.PROC")
+        self.unload = epics_signal_x(prefix + "UNLD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
 
@@ -93,7 +97,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.controller_error = ErrorStatus(prefix + "CNTL")
 
         self.reset = epics_signal_x(prefix + "RESET.PROC")
-        self.stop = epics_signal_x(prefix + "ABORT.PROC")
+        self.abort = epics_signal_x(prefix + "ABORT.PROC")
         self.init = epics_signal_x(prefix + "INIT.PROC")
         self.soak = epics_signal_x(prefix + "SOAK.PROC")
         self.home = epics_signal_x(prefix + "GOHM.PROC")
@@ -173,7 +177,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
                 self._load_pin_and_puck(value),
                 timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
-        except (asyncio.TimeoutError, TimeoutError) as e:
+        except TimeoutError as e:
             # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)

dodal/devices/smargon.py

@@ -3,7 +3,7 @@ from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import TypedDict, cast
+from typing import NotRequired, TypedDict, cast
 
 from bluesky import plan_stubs as bps
 from bluesky.protocols import Movable
@@ -11,14 +11,13 @@ from bluesky.utils import Msg
 from ophyd_async.core import (
     AsyncStatus,
     Device,
-    StandardReadable,
     StrictEnum,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from typing_extensions import NotRequired
 
+from dodal.devices.motors import XYZStage
 from dodal.devices.util.epics_util import SetWhenEnabled
 
 
@@ -116,7 +115,7 @@ class CombinedMove(TypedDict):
     chi: NotRequired[float | None]
 
 
-class Smargon(StandardReadable, Movable):
+class Smargon(XYZStage, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -126,9 +125,6 @@ class Smargon(StandardReadable, Movable):
 
     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.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")
             self.omega = Motor(prefix + "OMEGA")
@@ -143,7 +139,7 @@ class Smargon(StandardReadable, Movable):
 
         self.defer_move = epics_signal_rw(DeferMoves, prefix + "CS1:DeferMoves")
 
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
         """Obtain a plan stub that returns the smargon XYZ axis limits
@@ -171,6 +167,9 @@ class Smargon(StandardReadable, Movable):
             for k, v in value.items():
                 if v is not None:
                     tasks.append(getattr(self, k).set(v))
-            await asyncio.gather(*tasks)
         finally:
             await self.defer_move.set(DeferMoves.OFF)
+        # The set() coroutines will not complete until after defer moves has been
+        # switched back off so we cannot wait for them until this point.
+        # see https://github.com/DiamondLightSource/dodal/issues/1315
+        await asyncio.gather(*tasks)