dls-dodal 1.36.1a0__py3-none-any.whl → 1.36.3__py3-none-any.whl

dodal/devices/aperturescatterguard.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Coroutine
-from typing import Any
 
-from bluesky.protocols import Movable, Triggerable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    Reference,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
 )
-from ophyd_async.epics.motor import Motor
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
@@ -111,157 +107,7 @@ def load_positions_from_beamline_parameters(
     }
 
 
-async def _safe_move_whilst_in_beam(
-    aperture: Aperture,
-    scatterguard: Scatterguard,
-    position: AperturePosition,
-    aperture_z_tolerance: float,
-):
-    """
-    Move the aperture and scatterguard combo safely to a new position.
-    See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
-    for why this is required. TLDR is that we have a collision at the top of y so we need
-    to make sure we move the assembly down before we move the scatterguard up.
-
-    We also check that the assembly has been moved into the correct z position
-    previously. If we try and move whilst in the incorrect Z position we will collide
-    with the table.
-    """
-    ap_z_in_position = await aperture.z.motor_done_move.get_value()
-    if not ap_z_in_position:
-        raise InvalidApertureMove(
-            "ApertureScatterguard z is still moving. Wait for it to finish "
-            "before triggering another move."
-        )
-
-    current_ap_z = await aperture.z.user_readback.get_value()
-    diff_on_z = abs(current_ap_z - position.aperture_z)
-    if diff_on_z > aperture_z_tolerance:
-        raise InvalidApertureMove(
-            f"Current aperture z ({current_ap_z}), outside of tolerance ({aperture_z_tolerance}) from target ({position.aperture_z})."
-        )
-
-    current_ap_y = await aperture.y.user_readback.get_value()
-
-    aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = position.values
-
-    if aperture_y > current_ap_y:
-        # Assembly needs to move up so move the scatterguard down first
-        await asyncio.gather(
-            scatterguard.x.set(scatterguard_x),
-            scatterguard.y.set(scatterguard_y),
-        )
-        await asyncio.gather(
-            aperture.x.set(aperture_x),
-            aperture.y.set(aperture_y),
-            aperture.z.set(aperture_z),
-        )
-    else:
-        await asyncio.gather(
-            aperture.x.set(aperture_x),
-            aperture.y.set(aperture_y),
-            aperture.z.set(aperture_z),
-        )
-
-        await asyncio.gather(
-            scatterguard.x.set(scatterguard_x),
-            scatterguard.y.set(scatterguard_y),
-        )
-
-
-class ApertureSelector(StandardReadable, Movable):
-    """Allows for moving all axes other than Y into the correct position, this means
-    that we can set up the aperture while it is out of the beam then move it in later."""
-
-    def __init__(
-        self,
-        aperture: Aperture,
-        scatterguard: Scatterguard,
-        out_of_beam: Callable[[], Coroutine[Any, Any, bool]],
-        loaded_positions: dict[ApertureValue, AperturePosition],
-        aperture_z_tolerance: float,
-    ):
-        self.aperture = Reference(aperture)
-        self.scatterguard = Reference(scatterguard)
-        self.loaded_positions = loaded_positions
-        self.get_is_out_of_beam = out_of_beam
-        self.aperture_z_tolerance = aperture_z_tolerance
-        super().__init__()
-
-    @AsyncStatus.wrap
-    async def set(self, value: ApertureValue):
-        """Moves the assembly to the position for the specified aperture, whilst keeping
-        it out of the beam if it already is so.
-
-        Moving the assembly whilst out of the beam has no collision risk so we can just
-        move all the motors together.
-        """
-        if await self.get_is_out_of_beam():
-            aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
-                self.loaded_positions[value].values
-            )
-
-            await asyncio.gather(
-                self.aperture().x.set(aperture_x),
-                self.aperture().z.set(aperture_z),
-                self.scatterguard().x.set(scatterguard_x),
-                self.scatterguard().y.set(scatterguard_y),
-            )
-        else:
-            await _safe_move_whilst_in_beam(
-                self.aperture(),
-                self.scatterguard(),
-                self.loaded_positions[value],
-                self.aperture_z_tolerance,
-            )
-
-
-class OutTrigger(StandardReadable, Triggerable):
-    """Allows for moving just the Y stage of the assembly out of the beam."""
-
-    def __init__(
-        self,
-        aperture_y: Motor,
-        out_y: float,
-    ):
-        self.aperture_y = Reference(aperture_y)
-        self.out_y = out_y
-        super().__init__()
-
-    @AsyncStatus.wrap
-    async def trigger(self):
-        """Moves the assembly out of the beam."""
-        await self.aperture_y().set(self.out_y)
-
-
 class ApertureScatterguard(StandardReadable, Movable):
-    """Move the aperture and scatterguard assembly in a safe way. There are two ways to
-    interact with the device depending on if you want simplicity or move flexibility.
-
-    The simple interface is using:
-
-        await aperture_scatterguard.set(ApertureValue.LARGE)
-
-    This will move the assembly so that the large aperture is in the beam, regardless
-    of where the assembly currently is.
-
-    However, the aperture Y axis is faster than the others. In some cases we may want to
-    move the assembly out of the beam with this axis without moving others:
-
-        await aperture_scatterguard.move_out.trigger()
-
-    We may then want to keep the assembly out of the beam whilst asynchronously preparing
-    the other axes for the aperture that's to follow:
-
-        await aperture_scatterguard.aperture_outside_beam.set(ApertureValue.LARGE)
-
-    Then, at a later time, move back into the beam:
-
-        await aperture_scatterguard.set(ApertureValue.LARGE)
-
-    This move will now be faster as only the y is left to move.
-    """
-
     def __init__(
         self,
         loaded_positions: dict[ApertureValue, AperturePosition],
@@ -269,8 +115,8 @@ class ApertureScatterguard(StandardReadable, Movable):
         prefix: str = "",
         name: str = "",
     ) -> None:
-        self._aperture = Aperture(prefix + "-MO-MAPT-01:")
-        self._scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self.aperture = Aperture(prefix + "-MO-MAPT-01:")
+        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
         self.radius = create_hardware_backed_soft_signal(
             float, self._get_current_radius, units="µm"
         )
@@ -278,43 +124,30 @@ class ApertureScatterguard(StandardReadable, Movable):
         self._tolerances = tolerances
         self.add_readables(
             [
-                self._aperture.x.user_readback,
-                self._aperture.y.user_readback,
-                self._aperture.z.user_readback,
-                self._scatterguard.x.user_readback,
-                self._scatterguard.y.user_readback,
+                self.aperture.x.user_readback,
+                self.aperture.y.user_readback,
+                self.aperture.z.user_readback,
+                self.scatterguard.x.user_readback,
+                self.scatterguard.y.user_readback,
                 self.radius,
             ],
         )
-
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
 
-        # Setting this will select the aperture but not move it into beam
-        self.aperture_outside_beam = ApertureSelector(
-            self._aperture,
-            self._scatterguard,
-            self._is_out_of_beam,
-            self._loaded_positions,
-            self._tolerances.aperture_z,
-        )
-
-        # Setting this will just move the assembly out of the beam
-        self.move_out = OutTrigger(
-            self._aperture.y, loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
-        )
-
         super().__init__(name)
 
+    def get_position_from_gda_aperture_name(
+        self, gda_aperture_name: str
+    ) -> ApertureValue:
+        return ApertureValue(gda_aperture_name)
+
     @AsyncStatus.wrap
     async def set(self, value: ApertureValue):
-        """This set will move the aperture into the beam or move to robot load"""
         position = self._loaded_positions[value]
-        await _safe_move_whilst_in_beam(
-            self._aperture, self._scatterguard, position, self._tolerances.aperture_z
-        )
+        await self._safe_move_within_datacollection_range(position, value)
 
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
@@ -324,18 +157,13 @@ class ApertureScatterguard(StandardReadable, Movable):
         )
 
         await asyncio.gather(
-            self._aperture.x.set(aperture_x),
-            self._aperture.y.set(aperture_y),
-            self._aperture.z.set(aperture_z),
-            self._scatterguard.x.set(scatterguard_x),
-            self._scatterguard.y.set(scatterguard_y),
+            self.aperture.x.set(aperture_x),
+            self.aperture.y.set(aperture_y),
+            self.aperture.z.set(aperture_z),
+            self.scatterguard.x.set(scatterguard_x),
+            self.scatterguard.y.set(scatterguard_y),
         )
 
-    async def _is_out_of_beam(self) -> bool:
-        current_ap_y = await self._aperture.y.user_readback.get_value()
-        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
-        return current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y
-
     async def _get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
@@ -343,13 +171,15 @@ class ApertureScatterguard(StandardReadable, Movable):
         mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
         If no position is found then raises InvalidApertureMove.
         """
-        if await self._aperture.large.get_value(cached=False) == 1:
+        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        if await self.aperture.large.get_value(cached=False) == 1:
             return ApertureValue.LARGE
-        elif await self._aperture.medium.get_value(cached=False) == 1:
+        elif await self.aperture.medium.get_value(cached=False) == 1:
             return ApertureValue.MEDIUM
-        elif await self._aperture.small.get_value(cached=False) == 1:
+        elif await self.aperture.small.get_value(cached=False) == 1:
             return ApertureValue.SMALL
-        elif await self._is_out_of_beam():
+        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
             return ApertureValue.ROBOT_LOAD
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
@@ -357,3 +187,57 @@ class ApertureScatterguard(StandardReadable, Movable):
     async def _get_current_radius(self) -> float:
         current_value = await self._get_current_aperture_position()
         return self._loaded_positions[current_value].radius
+
+    async def _safe_move_within_datacollection_range(
+        self, position: AperturePosition, value: ApertureValue
+    ):
+        """
+        Move the aperture and scatterguard combo safely to a new position.
+        See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
+        for why this is required.
+        """
+        assert self._loaded_positions is not None
+
+        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
+        if not ap_z_in_position:
+            raise InvalidApertureMove(
+                "ApertureScatterguard z is still moving. Wait for it to finish "
+                "before triggering another move."
+            )
+
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        diff_on_z = abs(current_ap_z - position.aperture_z)
+        if diff_on_z > self._tolerances.aperture_z:
+            raise InvalidApertureMove(
+                "ApertureScatterguard safe move is not yet defined for positions "
+                "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
+                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
+            )
+
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
+
+        if position.aperture_y > current_ap_y:
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )

dodal/devices/apple2_undulator.py

@@ -21,8 +21,8 @@ from dodal.log import LOGGER
 
 
 class UndulatorGateStatus(StrictEnum):
-    open = "Open"
-    close = "Closed"
+    OPEN = "Open"
+    CLOSE = "Closed"
 
 
 @dataclass
@@ -146,7 +146,7 @@ class UndulatorGap(StandardReadable, Movable):
         timeout = await self._cal_timeout()
         LOGGER.info(f"Moving {self.name} to {value} with timeout = {timeout}")
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         vel = await self.velocity.get_value()
@@ -157,7 +157,7 @@ class UndulatorGap(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -251,7 +251,7 @@ class UndulatorPhaseAxes(StandardReadable, Movable):
         )
         timeout = await self._cal_timeout()
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         """
@@ -283,7 +283,7 @@ class UndulatorPhaseAxes(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -325,7 +325,7 @@ class UndulatorJawPhase(StandardReadable, Movable):
         )
         timeout = await self._cal_timeout()
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         """
@@ -345,7 +345,7 @@ class UndulatorJawPhase(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -458,7 +458,7 @@ class Apple2(StandardReadable, Movable):
             self.phase().set_move.set(value=1, timeout=timeout),
         )
         await wait_for_value(
-            self.gap().gate, UndulatorGateStatus.close, timeout=timeout
+            self.gap().gate, UndulatorGateStatus.CLOSE, timeout=timeout
         )
         self._energy_set(energy)  # Update energy for after move for readback.
 

dodal/devices/attenuator.py

@@ -14,7 +14,20 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal
 from dodal.log import LOGGER
 
 
-class Attenuator(StandardReadable, Movable):
+class ReadOnlyAttenuator(StandardReadable):
+    """A read-only attenuator class with a minimum set of PVs for reading.
+
+    The actual_transmission will return a fractional transmission between 0-1.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
+
+        super().__init__(name)
+
+
+class Attenuator(ReadOnlyAttenuator, Movable):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
     This device should be set with:
@@ -42,10 +55,7 @@ class Attenuator(StandardReadable, Movable):
         self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
         self._change = epics_signal_x(prefix + "FANOUT")
 
-        with self.add_children_as_readables():
-            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
-
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     @AsyncStatus.wrap
     async def set(self, value: float):

dodal/devices/focusing_mirror.py

@@ -1,3 +1,5 @@
+from typing import TypedDict
+
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -36,6 +38,12 @@ class MirrorStripe(StrictEnum):
     PLATINUM = "Platinum"
 
 
+class MirrorStripeConfiguration(TypedDict):
+    stripe: MirrorStripe
+    yaw_mrad: float
+    lat_mm: float
+
+
 class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
@@ -173,9 +181,10 @@ class FocusingMirrorWithStripes(FocusingMirror):
 
         super().__init__(prefix, name, *args, **kwargs)
 
-    def energy_to_stripe(self, energy_kev) -> MirrorStripe:
+    def energy_to_stripe(self, energy_kev) -> MirrorStripeConfiguration:
+        """Return the stripe, yaw angle and lateral position for the specified energy"""
         # In future, this should be configurable per-mirror
         if energy_kev < 7:
-            return MirrorStripe.BARE
+            return {"stripe": MirrorStripe.BARE, "yaw_mrad": 6.2, "lat_mm": 0.0}
         else:
-            return MirrorStripe.RHODIUM
+            return {"stripe": MirrorStripe.RHODIUM, "yaw_mrad": 0.0, "lat_mm": 10.0}

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/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/oav/pin_image_recognition/__init__.py

@@ -61,7 +61,7 @@ class PinTipDetection(StandardReadable):
         self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
             Array1D[np.int32], name="triggered_bottom_edge"
         )
-        self.array_data = epics_signal_r(Array1D[np.uint8], f"pva://{prefix}PVA:ARRAY")
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
 
         # Soft parameters for pin-tip detection.
         self.preprocess_operation = soft_signal_rw(int, 10, name="preprocess")
@@ -99,9 +99,7 @@ class PinTipDetection(StandardReadable):
         self._top_edge_setter(results.edge_top)
         self._bottom_edge_setter(results.edge_bottom)
 
-    async def _get_tip_and_edge_data(
-        self, array_data: Array1D[np.uint8]
-    ) -> SampleLocation:
+    async def _get_tip_and_edge_data(self, array_data: np.ndarray) -> SampleLocation:
         """
         Gets the location of the pin tip and the top and bottom edges.
         """

dodal/devices/p99/sample_stage.py

@@ -12,22 +12,22 @@ class SampleAngleStage(StandardReadable):
 
 
 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"
+    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"
+    PT = "Pt (empty)"
+    USER = "User"
 
 
 class FilterMotor(StandardReadable):