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

dodal/devices/i11/mythen.py

@@ -0,0 +1,165 @@
+import asyncio
+from typing import Annotated as A
+
+from ophyd_async.core import (
+    DetectorTrigger,
+    PathProvider,
+    SignalRW,
+    StrictEnum,
+    TriggerInfo,
+)
+from ophyd_async.epics.adcore import (
+    ADBaseController,
+    ADHDFWriter,
+    ADImageMode,
+    ADWriter,
+    AreaDetector,
+    NDArrayBaseIO,
+)
+from ophyd_async.epics.core import PvSuffix
+
+from dodal.common.beamlines.device_helpers import DET_SUFFIX
+
+
+class Mythen3TriggerMode(StrictEnum):
+    INTERNAL = "Internal"
+    EXTERNAL = "External"
+
+
+class Mythen3ModeSetting(StrictEnum):
+    STANDARD = "standard"
+    FAST = "fast"
+    HIGHGAIN = "highgain"
+
+
+class Mythen3DetectorState(StrictEnum):
+    """Default set of states of an  Mythen3 driver."""
+
+    IDLE = "Idle"
+    ERROR = "Error"
+    WAITING = "Waiting"
+    FINISHED = "Finished"
+    TRASMITTING = "Transmitting"
+    RUNNING = "Running"
+    STOPPED = "Stopped"
+    INITIALIZING = "Initializing"
+    DISCONNECTED = "Disconnected"
+    ABORTED = "Aborted"
+
+
+class Mythen3Driver(NDArrayBaseIO):
+    acquire_time: A[SignalRW[float], PvSuffix.rbv("AcquireTime")]
+    acquire_period: A[SignalRW[float], PvSuffix.rbv("AcquirePeriod")]
+    num_images: A[SignalRW[int], PvSuffix.rbv("NumImages")]
+    image_mode: A[SignalRW[ADImageMode], PvSuffix.rbv("ImageMode")]
+
+    # Non-specific PV's but with mythen3 specific values
+    detector_state: A[SignalRW[Mythen3DetectorState], PvSuffix("DetectorState_RBV")]
+    trigger_mode: A[SignalRW[Mythen3TriggerMode], PvSuffix.rbv("TriggerMode")]
+
+    # mythen3 specific PV's
+    mode_setting: A[SignalRW[Mythen3ModeSetting], PvSuffix.rbv("Setting")]
+    bit_depth: A[SignalRW[int], PvSuffix.rbv("BitDepth")]
+    beam_energy: A[SignalRW[int], PvSuffix.rbv("BeamEnergy")]
+    threshold: A[SignalRW[int], PvSuffix.rbv("Counter1Threshold")]
+    threshold2: A[SignalRW[int], PvSuffix.rbv("Counter2Threshold")]
+    threshold3: A[SignalRW[int], PvSuffix.rbv("Counter3Threshold")]
+    global_threshold: A[SignalRW[int], PvSuffix.rbv("ThresholdEnergy")]
+
+
+"""
+Re. _DEADTIMES
+
+see: https://doi.org/10.1107/S1600577525000438
+Journal of Synchrotron Radiation, Volume 32, Part 2, March 2025, Pages 365-377
+See Section 3.3, Table 2, Section 3.4 and Table 3
+
+Note: Maximum frame rate of MYTHEN III is a function of the number of counters and of
+the bit depth.
+
+These numbers neglect possible limitations arising from the DAQ computing and network
+system. Expect ~1 order of magnitude less
+
+Our mythen3 is currently set up to use 3 counters, and 32bit depth. The deadtimes are
+for 3 counters only. We can run faster with less counters/bit depth
+
+The maximum frame rate of the detector scales both with the number of counters being
+read out and with the bit depth, which can be configured to 24 (streamed out as 32 bit),
+16 or 8 bits see Table 3.
+
+"""
+_DEADTIMES = {
+    32: 1 / (30 * 1000),  # values reported in frame rate (kHz)
+    24: 1 / (40 * 1000),
+    16: 1 / (60 * 1000),
+    8: 1 / (120 * 1000),
+}
+
+_BIT_DEPTH = 24
+
+
+class Mythen3Controller(ADBaseController):
+    """ADBaseController` for a Mythen3"""
+
+    def __init__(self, driver: Mythen3Driver):
+        self._driver = driver
+        super().__init__(driver=self._driver)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return _DEADTIMES[_BIT_DEPTH]
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        if (exposure := trigger_info.livetime) is not None:
+            await self._driver.acquire_time.set(exposure)
+
+        if trigger_info.trigger is DetectorTrigger.INTERNAL:
+            await self._driver.trigger_mode.set(Mythen3TriggerMode.INTERNAL)
+        elif trigger_info.trigger in {
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.VARIABLE_GATE,
+        }:
+            await self._driver.trigger_mode.set(Mythen3TriggerMode.EXTERNAL)
+        else:
+            raise ValueError(f"Mythen3 does not support {trigger_info.trigger}")
+
+        if trigger_info.total_number_of_exposures == 0:
+            image_mode = ADImageMode.CONTINUOUS
+        else:
+            image_mode = ADImageMode.MULTIPLE
+        await asyncio.gather(
+            self._driver.num_images.set(trigger_info.total_number_of_exposures),
+            self._driver.image_mode.set(image_mode),
+        )
+
+
+class Mythen3(AreaDetector[Mythen3Controller]):
+    """
+    The detector may be configured for an external trigger on a GPIO port,
+    which must be done prior to preparing the detector
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix: str = DET_SUFFIX,
+        writer_cls: type[ADWriter] = ADHDFWriter,
+        fileio_suffix: str | None = "HDF:",
+        name: str = "",
+    ):
+        self.driver = Mythen3Driver(prefix + drv_suffix)
+        self.controller = Mythen3Controller(driver=self.driver)
+
+        self.writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=self.driver,
+            fileio_suffix=fileio_suffix,
+        )
+
+        super().__init__(
+            controller=self.controller,
+            writer=self.writer,
+            name=name,
+        )  # plugins=plugins # config_sigs=config_sigs

dodal/devices/i11/nx100robot.py

@@ -0,0 +1,153 @@
+import asyncio
+from enum import Enum
+
+from bluesky.protocols import Locatable, Location, Pausable, Stoppable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StrictEnum,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv, epics_signal_x
+
+from dodal.log import LOGGER
+
+
+class RobotJobs(StrictEnum):
+    RECOVER = "RECOVER"  # Recover from unknown state
+    PICK_CAROUSEL = "PICKC"  # Pick a sample from the carousel.
+    PLACE_CAROUSEL = "PLACEC"  # Place a sample onto the carousel
+    PICK_DIFFRACTOMETER = "PICKD"  # Pick a sample from the diffractometer.
+    PLACE_DIFFRACTOMETER = "PLACED"  # Place a sample onto the diffractometer.
+    GRIPO = "GRIPO"
+    GRIPC = "GRIPC"
+    TABLEIN = "TABLEIN"
+    TABLEOUT = "TABLEOUT"
+    UNLOAD = "UNLOAD"
+
+
+class RobotSampleState(float, Enum):
+    CAROUSEL = 0.0  # Sample is on carousel
+    ONGRIP = 1.0  # Sample is on the gripper
+    DIFFRACTOMETER = 2.0  # Sample is on the diffractometer
+    UNKNOWN = 3.0
+
+
+class NX100Robot(StandardReadable, Locatable[int], Stoppable, Pausable):
+    """
+    This is a Yaskawa Motoman that uses an NX100 controller. It consists of a robot arm
+    with a gripper and a carousel for sample handling. It can pick and place samples
+    from the carousel to the diffractometer and vice versa.
+
+    Has set, pause, resume, stop, locate, stage methods.
+    """
+
+    MAX_NUMBER_OF_SAMPLES = 200
+    MIN_NUMBER_OF_SAMPLES = 1
+
+    def __init__(self, prefix: str, name: str = ""):
+        self.start = epics_signal_x(prefix + "START")
+        self.hold = epics_signal_rw(bool, prefix + "HOLD")
+        self.job = epics_signal_rw(RobotJobs, prefix + "JOB")
+        self.servo_on = epics_signal_rw(bool, prefix + "SVON")  # Servo on/off
+        self.err = epics_signal_rw(int, prefix + "ERR")
+
+        self.robot_sample_state = epics_signal_rw(float, prefix + "D010")
+        self.next_sample_position = epics_signal_rw_rbv(
+            int, prefix + "D011", read_suffix=":RBV"
+        )
+        self.current_sample_position = epics_signal_rw_rbv(
+            int, prefix + "D012", read_suffix=":RBV"
+        )
+        self.door_latch_state = epics_signal_rw(int, prefix + "NEEDRECOVER")
+
+        super().__init__(name=name)
+
+    async def recover(self):
+        await asyncio.gather(
+            self.start.trigger(),
+            set_and_wait_for_value(self.job, RobotJobs.RECOVER),
+            set_and_wait_for_value(self.err, False),
+        )
+
+    async def clear_sample(self, table_in: bool = True):
+        """clears the sample from the diffractometer and places it on the carousel.
+        if table_in is True, it will also move the sample holder to the table in position."""
+
+        sample_state = await self.robot_sample_state.get_value()
+        if sample_state == RobotSampleState.DIFFRACTOMETER:
+            await asyncio.gather(
+                set_and_wait_for_value(self.job, RobotJobs.PICK_DIFFRACTOMETER),
+                set_and_wait_for_value(self.job, RobotJobs.PLACE_CAROUSEL),
+            )
+        elif sample_state == RobotSampleState.ONGRIP:
+            await set_and_wait_for_value(self.job, RobotJobs.PLACE_CAROUSEL)
+        elif sample_state == RobotSampleState.CAROUSEL:
+            pass
+        elif sample_state == RobotSampleState.UNKNOWN:
+            LOGGER.error("UNKNOWN sample state from robot, exit")
+        else:
+            raise ValueError(f"Unknown sample state: {sample_state}")
+
+        if table_in:
+            await set_and_wait_for_value(self.job, RobotJobs.TABLEIN)
+
+        LOGGER.info("Sample cleared from diffractometer")
+
+    async def load_sample(self, sample_location: int):
+        """Loads a sample from the carousel to the diffractometer."""
+        sample_state = await self.robot_sample_state.get_value()
+        if sample_state == RobotSampleState.CAROUSEL:
+            await set_and_wait_for_value(self.job, RobotJobs.PICK_CAROUSEL)
+            await set_and_wait_for_value(self.job, RobotJobs.PLACE_DIFFRACTOMETER)
+        elif sample_state == RobotSampleState.ONGRIP:
+            await set_and_wait_for_value(self.job, RobotJobs.PLACE_DIFFRACTOMETER)
+        elif sample_state == RobotSampleState.DIFFRACTOMETER:
+            pass
+        elif sample_state == RobotSampleState.UNKNOWN:
+            LOGGER.warning(f"No sample at sample holder position {sample_location}")
+            LOGGER.error("UNKNOWN sample state from robot, exit")
+        else:
+            raise ValueError(f"Unknown sample state: {sample_state}")
+
+    @AsyncStatus.wrap
+    async def set(self, sample_location: int) -> None:
+        if (
+            sample_location < self.MIN_NUMBER_OF_SAMPLES
+            or sample_location > self.MAX_NUMBER_OF_SAMPLES
+        ):
+            raise ValueError(
+                f"Sample location must be between {self.MIN_NUMBER_OF_SAMPLES} and {self.MAX_NUMBER_OF_SAMPLES}, got {sample_location}"
+            )
+        if await self.current_sample_position.get_value() == sample_location:
+            LOGGER.info(f"Robot already at position {sample_location}")
+        else:
+            await self.clear_sample(table_in=False)
+            await self.next_sample_position.set(sample_location, wait=True)
+            await self.load_sample(sample_location)
+            await self.current_sample_position.set(sample_location)
+
+    async def pause(self):
+        await set_and_wait_for_value(self.hold, True)
+
+    async def resume(self):
+        await set_and_wait_for_value(self.hold, False)
+
+    async def stop(self, success: bool = True):
+        await set_and_wait_for_value(self.hold, True)
+        if not success:
+            await set_and_wait_for_value(self.hold, False)
+            await self.clear_sample()
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        """Set up the device for acquisition."""
+        await asyncio.gather(
+            set_and_wait_for_value(self.servo_on, True),
+            set_and_wait_for_value(self.hold, False),
+            self.start.trigger(),
+        )
+
+    async def locate(self) -> Location[int]:
+        location = await self.current_sample_position.locate()
+        return location

dodal/devices/i11/spinner.py

@@ -0,0 +1,30 @@
+from bluesky.protocols import Pausable
+from ophyd_async.core import (
+    EnabledDisabled,
+    StandardReadable,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class Spinner(StandardReadable, Pausable):
+    """This is a simple sample spinner, that has enable and speed (%)"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        disable_suffix: str = "SPIN:DISABLE",
+        speed_suffix: str = "SPIN:SPEED",
+    ):
+        with self.add_children_as_readables():
+            self.enable = epics_signal_rw(EnabledDisabled, prefix + disable_suffix)
+            self.speed = epics_signal_rw(float, prefix + speed_suffix)
+
+        super().__init__(name=name)
+
+    async def pause(self):
+        await set_and_wait_for_value(self.enable, EnabledDisabled.DISABLED)
+
+    async def resume(self):
+        await set_and_wait_for_value(self.enable, EnabledDisabled.ENABLED)

dodal/devices/i13_1/merlin_controller.py

@@ -8,15 +8,16 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.adcore import (
     DEFAULT_GOOD_STATES,
-    ADBaseController,
     ADBaseIO,
     ADImageMode,
     ADState,
 )
 from ophyd_async.epics.core import stop_busy_record
 
+from dodal.devices.controllers import ConstantDeadTimeController
 
-class MerlinController(ADBaseController):
+
+class MerlinController(ConstantDeadTimeController):
     def __init__(
         self,
         driver: ADBaseIO,
@@ -29,8 +30,7 @@ class MerlinController(ADBaseController):
         for drv_child in self.driver.children():
             logging.debug(drv_child)
 
-    def get_deadtime(self, exposure: float | None) -> float:
-        return 0.002
+        super().__init__(driver, 0.002)
 
     async def prepare(self, trigger_info: TriggerInfo):
         self.frame_timeout = (

dodal/devices/i19/diffractometer.py

@@ -0,0 +1,34 @@
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import Stage, XYZStage
+
+CIRC = "-MO-CIRC-02:"  # for phi, kappa, omega, 2theta and det_z
+SAMP = "-MO-SAMP-02:"  # for x,y,z
+
+
+class DetectorMotion(Stage):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.det_z = Motor(f"{prefix}DET")
+            self.two_theta = Motor(f"{prefix}2THETA")
+        super().__init__(name=name)
+
+
+# Collision model needs to be included
+# See https://github.com/DiamondLightSource/dodal/issues/1073
+class FourCircleDiffractometer(XYZStage):
+    """Newport 4-circle diffractometer device."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        circ_infix: str = CIRC,
+        samp_infix: str = SAMP,
+    ):
+        with self.add_children_as_readables():
+            self.phi = Motor(f"{prefix}{circ_infix}SAM:PHI")
+            self.omega = Motor(f"{prefix}{circ_infix}SAM:OMEGA")
+            self.kappa = Motor(f"{prefix}{circ_infix}SAM:KAPPA")
+            self.det_stage = DetectorMotion(f"{prefix}{circ_infix}SAM:", name)
+        super().__init__(f"{prefix}{samp_infix}SAM:", name)

dodal/devices/i19/shutter.py

@@ -22,10 +22,19 @@ class AccessControlledShutter(OpticsBlueAPIDevice):
     https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
-    def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
+    def __init__(
+        self,
+        prefix: str,
+        hutch: HutchState,
+        instrument_session: str = "",
+        name: str = "",
+    ) -> None:
+        # For instrument session addition to request parameters
+        # see https://github.com/DiamondLightSource/blueapi/issues/1187
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
         self.hutch_request = hutch
+        self.instrument_session = instrument_session
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -37,5 +46,6 @@ class AccessControlledShutter(OpticsBlueAPIDevice):
                 "access_device": ACCESS_DEVICE_NAME,
                 "shutter_demand": value.value,
             },
+            "instrument_session": self.instrument_session,
         }
         await super().set(REQUEST_PARAMS)

dodal/devices/i22/dcm.py

@@ -38,7 +38,7 @@ class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
         temperature_prefix: str,
         crystal_1_metadata: CrystalMetadata,
         crystal_2_metadata: CrystalMetadata,
-        prefix: str = "",
+        prefix: str,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables():

dodal/devices/i22/fswitch.py

@@ -7,20 +7,11 @@ from ophyd_async.core import (
     DeviceVector,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.core import epics_signal_r
 
-
-class FilterState(StrictEnum):
-    """
-    Note that the in/out here refers to the internal rocker
-    position so a PV value of IN implies a filter OUT of beam
-    """
-
-    IN_BEAM = "OUT"
-    OUT_BEAM = "IN"
+from dodal.common.enums import InOutUpper
 
 
 class FSwitch(StandardReadable):
@@ -50,7 +41,7 @@ class FSwitch(StandardReadable):
     ) -> None:
         self.filters = DeviceVector(
             {
-                i: epics_signal_r(FilterState, f"{prefix}FILTER-{i:03}:STATUS_RBV")
+                i: epics_signal_r(InOutUpper, f"{prefix}FILTER-{i:03}:STATUS_RBV")
                 for i in range(FSwitch.NUM_FILTERS)
             }
         )
@@ -91,7 +82,7 @@ class FSwitch(StandardReadable):
         result = await asyncio.gather(
             *(filter.get_value() for filter in self.filters.values())
         )
-        num_in = sum(r.value == FilterState.IN_BEAM for r in result)
+        num_in = sum(r.value == InOutUpper.IN for r in result)
         default_reading = await super().read()
         return {
             FSwitch.NUM_LENSES_FIELD_NAME: Reading(value=num_in, timestamp=time.time()),

dodal/devices/i24/aperture.py

@@ -1,12 +1,12 @@
-from ophyd_async.core import StrictEnum
+from ophyd_async.core import InOut, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
 from dodal.devices.motors import XYStage
 
 
 class AperturePositions(StrictEnum):
-    IN = "In"
-    OUT = "Out"
+    IN = InOut.IN.value
+    OUT = InOut.OUT.value
     ROBOT = "Robot"
     MANUAL = "Manual Mounting"
 

dodal/devices/i24/dcm.py

@@ -12,22 +12,18 @@ class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
     A double crystal monocromator device, used to select the beam energy.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(self, prefix: str, motion_prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             # Temperatures
-            self.xtal1_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-1")
-            self.xtal1_heater_temp = epics_signal_r(
-                float, prefix + "-DI-DCM-01:PT100-2"
-            )
-            self.xtal2_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-4")
-            self.xtal2_heater_temp = epics_signal_r(
-                float, prefix + "-DI-DCM-01:PT100-5"
-            )
+            self.xtal1_temp = epics_signal_r(float, prefix + "PT100-1")
+            self.xtal1_heater_temp = epics_signal_r(float, prefix + "PT100-2")
+            self.xtal2_temp = epics_signal_r(float, prefix + "PT100-4")
+            self.xtal2_heater_temp = epics_signal_r(float, prefix + "PT100-5")
 
-            self.roll_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-3")
-            self.pitch_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-6")
-            self.backplate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
-            self.b1_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
-            self.gap_temp = epics_signal_r(float, prefix + "-DI-DCM-01:TC-1")
+            self.roll_plate_temp = epics_signal_r(float, prefix + "PT100-3")
+            self.pitch_plate_temp = epics_signal_r(float, prefix + "PT100-6")
+            self.backplate_temp = epics_signal_r(float, prefix + "PT100-7")
+            self.b1_plate_temp = epics_signal_r(float, prefix + "PT100-7")
+            self.gap_temp = epics_signal_r(float, prefix + "TC-1")
 
-        super().__init__(prefix + "-MO-DCM-01:", RollCrystal, PitchAndRollCrystal, name)
+        super().__init__(motion_prefix, RollCrystal, PitchAndRollCrystal, name)

dodal/devices/i24/dual_backlight.py

@@ -1,21 +1,18 @@
-from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.core import AsyncStatus, InOut, StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
+from dodal.common.enums import OnOffUpper
+
 
 class BacklightPositions(StrictEnum):
-    OUT = "Out"
-    IN = "In"
+    OUT = InOut.OUT.value
+    IN = InOut.IN.value
     LOAD_CHECK = "LoadCheck"
     OAV2 = "OAV2"
     DIODE = "Diode"
     WHITE_IN = "White In"
 
 
-class LEDStatus(StrictEnum):
-    OFF = "OFF"
-    ON = "ON"
-
-
 class BacklightPositioner(StandardReadable):
     """Device to control the backlight position."""
 
@@ -45,16 +42,18 @@ class DualBacklight(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.backlight_state = epics_signal_rw(LEDStatus, prefix + "-DI-LED-01:TOGGLE")
+        self.backlight_state = epics_signal_rw(OnOffUpper, prefix + "-DI-LED-01:TOGGLE")
         self.backlight_position = BacklightPositioner(prefix + "-MO-BL-01:", name)
 
-        self.frontlight_state = epics_signal_rw(LEDStatus, prefix + "-DI-LED-02:TOGGLE")
+        self.frontlight_state = epics_signal_rw(
+            OnOffUpper, prefix + "-DI-LED-02:TOGGLE"
+        )
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(self, value: BacklightPositions):
         await self.backlight_position.set(value)
         if value == BacklightPositions.OUT:
-            await self.backlight_state.set(LEDStatus.OFF, wait=True)
+            await self.backlight_state.set(OnOffUpper.OFF, wait=True)
         else:
-            await self.backlight_state.set(LEDStatus.ON, wait=True)
+            await self.backlight_state.set(OnOffUpper.ON, wait=True)

dodal/devices/i24/pmac.py

@@ -17,8 +17,9 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.motors import XYZStage
 
-HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
+HOME_STR = r"\#5hmz\#6hmz\#7hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
+CS_STR = "&2"
 
 
 class ScanState(IntEnum):
@@ -196,12 +197,12 @@ class PMAC(XYZStage):
     """Device to control the chip stage on I24."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.pmac_string = epics_signal_rw(str, prefix + "PMAC_STRING")
+        self.pmac_string = epics_signal_rw(str, f"{prefix}-MO-IOC-13:PMAC:console")
         self.home = PMACStringMove(
             self.pmac_string,
-            HOME_STR,
+            f"{CS_STR}{HOME_STR}",
         )
-        self.to_xyz_zero = PMACStringMove(self.pmac_string, ZERO_STR)
+        self.to_xyz_zero = PMACStringMove(self.pmac_string, f"{CS_STR}{ZERO_STR}")
 
         self.laser = PMACStringLaser(self.pmac_string)
 
@@ -211,8 +212,8 @@ class PMAC(XYZStage):
 
         # These next signals are readback values on PVARS which are set by the motion
         # program.
-        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.scanstatus = epics_signal_r(float, f"{prefix}-MO-STEP-13:pmac:read:P2401")
+        self.counter = epics_signal_r(float, f"{prefix}-MO-STEP-13:pmac:read:P2402")
 
         # A couple of soft signals for running a collection: program number to send to
         # the PMAC_STRING and expected collection time.
@@ -228,4 +229,4 @@ class PMAC(XYZStage):
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
-        super().__init__(prefix, name)
+        super().__init__(f"{prefix}-MO-CHIP-01:", name)

dodal/devices/mx_phase1/beamstop.py

@@ -18,9 +18,6 @@ class BeamstopPositions(StrictEnum):
     robot load however all 3 resolution positions are the same. We also
     do not use the robot load position in Hyperion.
 
-    Until we support moving the beamstop it is only necessary to check whether the
-    beamstop is in beam or not.
-
     See Also:
         https://github.com/DiamondLightSource/mx-bluesky/issues/484
 
@@ -86,11 +83,13 @@ class Beamstop(StandardReadable):
             return BeamstopPositions.UNKNOWN
 
     async def _set_selected_position(self, position: BeamstopPositions) -> None:
-        if position == BeamstopPositions.DATA_COLLECTION:
-            await asyncio.gather(
-                self.x_mm.set(self._in_beam_xyz_mm[0]),
-                self.y_mm.set(self._in_beam_xyz_mm[1]),
-                self.z_mm.set(self._in_beam_xyz_mm[2]),
-            )
-        elif position == BeamstopPositions.UNKNOWN:
-            raise ValueError(f"Cannot set beamstop to position {position}")
+        match position:
+            case BeamstopPositions.DATA_COLLECTION:
+                # Move z first as it could be under the table
+                await self.z_mm.set(self._in_beam_xyz_mm[2])
+                await asyncio.gather(
+                    self.x_mm.set(self._in_beam_xyz_mm[0]),
+                    self.y_mm.set(self._in_beam_xyz_mm[1]),
+                )
+            case _:
+                raise ValueError(f"Cannot set beamstop to position {position}")