mx-bluesky 1.2.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

mx_bluesky/common/utils/log.py

@@ -0,0 +1,118 @@
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from os import environ
+from pathlib import Path
+
+from dodal.log import (
+    ERROR_LOG_BUFFER_LINES,
+    CircularMemoryHandler,
+    DodalLogHandlers,
+    integrate_bluesky_and_ophyd_logging,
+    set_up_all_logging_handlers,
+)
+from dodal.log import LOGGER as dodal_logger
+
+LOGGER = logging.getLogger("mx-bluesky")
+
+__logger_handlers: DodalLogHandlers | None = None
+
+
+class ExperimentMetadataTagFilter(logging.Filter):
+    """When an instance of this custom filter is added to a logging handler, dc_group_id
+    and run_id will be tagged in that handlers' log messages."""
+
+    dc_group_id: str | None = None
+    run_uid: str | None = None
+
+    def filter(self, record):
+        if self.dc_group_id:
+            record.dc_group_id = self.dc_group_id
+        if self.run_uid:
+            record.run_uid = self.run_uid
+        return True
+
+
+tag_filter = ExperimentMetadataTagFilter()
+
+
+def set_dcgid_tag(dcgid):
+    """Set the datacollection group id as a tag on all subsequent log messages.
+    Setting to None will remove the tag."""
+    tag_filter.dc_group_id = dcgid
+
+
+def set_uid_tag(uid):
+    """Set the unique id as a tag on all subsequent log messages.
+    Setting to None will remove the tag."""
+    tag_filter.run_uid = uid
+
+
+def do_default_logging_setup(
+    file_name: str,
+    graylog_port: int,
+    dev_mode: bool = False,
+    integrate_all_logs: bool = True,
+):
+    """Configures dodal logger so that separate debug and info log files are created,
+    info logs are sent to Graylog, info logs are streamed to sys.sterr, and logs from ophyd
+    and bluesky and ophyd-async are optionally included."""
+
+    handlers = set_up_all_logging_handlers(
+        dodal_logger,
+        _get_logging_dir(),
+        file_name,
+        dev_mode,
+        ERROR_LOG_BUFFER_LINES,
+        graylog_port,
+    )
+
+    if integrate_all_logs:
+        integrate_bluesky_and_ophyd_logging(dodal_logger)
+
+    handlers["graylog_handler"].addFilter(tag_filter)
+
+    global __logger_handlers
+    __logger_handlers = handlers
+
+
+def _get_debug_handler() -> CircularMemoryHandler:
+    assert (
+        __logger_handlers is not None
+    ), "You can only use this after running the default logging setup"
+    return __logger_handlers["debug_memory_handler"]
+
+
+def flush_debug_handler() -> str:
+    """Writes the contents of the circular debug log buffer to disk and returns the written filename"""
+    handler = _get_debug_handler()
+    assert isinstance(
+        handler.target, TimedRotatingFileHandler
+    ), "Circular memory handler doesn't have an appropriate fileHandler target"
+    handler.flush()
+    return handler.target.baseFilename
+
+
+def _get_logging_dir() -> Path:
+    """Get the path to write the mx_bluesky log files to.
+
+    Log location can be specified in the LOG_DIR environment variable, otherwise MX bluesky logs are written to 'dls_sw/ixx/logs/bluesky'.
+    This directory will be created if it is not found
+
+    Logs are written to ./tmp/logs/bluesky if BEAMLINE environment variable is not found
+
+    Returns:
+        logging_path (Path): Path to the log file for the file handler to write to.
+    """
+
+    logging_str = environ.get("LOG_DIR")
+    if logging_str:
+        logging_path = Path(logging_str)
+    else:
+        beamline = environ.get("BEAMLINE")
+        logging_path = (
+            Path(f"/dls_sw/{beamline}/logs/bluesky/")
+            if beamline
+            else Path("/tmp/logs/bluesky")
+        )
+    Path.mkdir(logging_path, exist_ok=True, parents=True)
+    return logging_path

mx_bluesky/{hyperion → common/utils}/tracing.py

@@ -8,8 +8,8 @@ from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
 
-def setup_tracing():
-    resource = Resource(attributes={SERVICE_NAME: "Hyperion"})
+def setup_tracing(service_name: str = "Hyperion"):
+    resource = Resource(attributes={SERVICE_NAME: service_name})
 
     traceProvider = TracerProvider(resource=resource)
     processor = BatchSpanProcessor(

mx_bluesky/hyperion/__main__.py

@@ -7,13 +7,18 @@ from queue import Queue
 from traceback import format_exception
 from typing import Any
 
-from blueapi.core import BlueskyContext, MsgGenerator
+from blueapi.core import BlueskyContext
 from bluesky.callbacks.zmq import Publisher
 from bluesky.run_engine import RunEngine
+from bluesky.utils import MsgGenerator
 from flask import Flask, request
 from flask_restful import Api, Resource
 from pydantic.dataclasses import dataclass
 
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
+from mx_bluesky.common.parameters.constants import Actions, Status
+from mx_bluesky.common.utils.log import do_default_logging_setup, flush_debug_handler
+from mx_bluesky.common.utils.tracing import TRACER
 from mx_bluesky.hyperion.exceptions import WarningException
 from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
@@ -36,13 +41,9 @@ from mx_bluesky.hyperion.external_interaction.callbacks.logging_callback import
 )
 from mx_bluesky.hyperion.log import (
     LOGGER,
-    do_default_logging_setup,
-    flush_debug_handler,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_cli_args
-from mx_bluesky.hyperion.parameters.components import HyperionParameters
-from mx_bluesky.hyperion.parameters.constants import CONST, Actions, Status
-from mx_bluesky.hyperion.tracing import TRACER
+from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.utils.context import setup_context
 
 VERBOSE_EVENT_LOGGING: bool | None = None
@@ -53,7 +54,7 @@ class Command:
     action: Actions
     devices: Any | None = None
     experiment: Callable[[Any, Any], MsgGenerator] | None = None
-    parameters: HyperionParameters | None = None
+    parameters: MxBlueskyParameters | None = None
     callbacks: CallbacksFactory | None = None
 
 
@@ -119,7 +120,7 @@ class BlueskyRunner:
     def start(
         self,
         experiment: Callable,
-        parameters: HyperionParameters,
+        parameters: MxBlueskyParameters,
         plan_name: str,
         callbacks: CallbacksFactory | None,
     ) -> StatusAndMessage:
@@ -239,7 +240,7 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
             raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
     except Exception as e:
         raise ValueError(
-            f"Supplied parameters don't match the plan for this endpoint {request.data}"
+            f"Supplied parameters don't match the plan for this endpoint {request.data}, for plan {plan_name}"
         ) from e
     return plan, parameters, plan_name, callback_type
 
@@ -345,7 +346,9 @@ def create_app(
 def create_targets():
     hyperion_port = 5005
     args = parse_cli_args()
-    do_default_logging_setup(dev_mode=args.dev_mode)
+    do_default_logging_setup(
+        CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
+    )
     if not args.use_external_callbacks:
         setup_callback_logging(args.dev_mode)
     app, runner = create_app(

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -4,7 +4,7 @@ import bluesky.plan_stubs as bps
 from dodal.devices.focusing_mirror import (
     FocusingMirrorWithStripes,
     MirrorStripe,
-    VFMMirrorVoltages,
+    MirrorVoltages,
 )
 from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.util.adjuster_plans import lookup_table_adjuster
@@ -13,79 +13,96 @@ from dodal.devices.util.lookup_tables import (
 )
 
 from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.hyperion.utils.utils import (
+    energy_to_bragg_angle,
+)
 
 MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
 DCM_GROUP = "DCM_GROUP"
+YAW_LAT_TIMEOUT_S = 30
 
 
 def _apply_and_wait_for_voltages_to_settle(
     stripe: MirrorStripe,
-    mirror: FocusingMirrorWithStripes,
-    mirror_voltages: VFMMirrorVoltages,
+    mirror_voltages: MirrorVoltages,
 ):
     with open(mirror_voltages.voltage_lookup_table_path) as lut_file:
         json_obj = json.load(lut_file)
 
     # sample mode is the only mode supported
     sample_data = json_obj["sample"]
-    mirror_key = mirror.name.lower()
     if stripe == MirrorStripe.BARE:
         stripe_key = "bare"
     elif stripe == MirrorStripe.RHODIUM:
         stripe_key = "rh"
     elif stripe == MirrorStripe.PLATINUM:
         stripe_key = "pt"
-    else:
-        raise ValueError(f"Unsupported stripe '{stripe}'")
 
-    required_voltages = sample_data[stripe_key][mirror_key]
-    for voltage_channel, required_voltage in zip(
-        mirror_voltages.voltage_channels.values(), required_voltages, strict=False
-    ):
-        LOGGER.debug(
-            f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
-        )
-        yield from bps.abs_set(
-            voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP
-        )
+    for mirror_key, channels in {
+        "hfm": mirror_voltages.horizontal_voltages,
+        "vfm": mirror_voltages.vertical_voltages,
+    }.items():
+        required_voltages = sample_data[stripe_key][mirror_key]
 
-    yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
+        for voltage_channel, required_voltage in zip(
+            channels.values(), required_voltages, strict=True
+        ):
+            LOGGER.info(
+                f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
+            )
+            yield from bps.abs_set(
+                voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP, wait=True
+            )
 
 
 def adjust_mirror_stripe(
-    energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: VFMMirrorVoltages
+    energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: MirrorVoltages
 ):
     """Feedback should be OFF prior to entry, in order to prevent
     feedback from making unnecessary corrections while beam is being adjusted."""
-    stripe = mirror.energy_to_stripe(energy_kev)
+    mirror_config = mirror.energy_to_stripe(energy_kev)
 
     LOGGER.info(
-        f"Adjusting mirror stripe for {energy_kev}keV selecting {stripe} stripe"
+        f"Adjusting mirror stripe for {energy_kev}keV selecting {mirror_config['stripe']} stripe"
     )
-    yield from bps.abs_set(mirror.stripe, stripe, wait=True)
+    yield from bps.abs_set(mirror.stripe, mirror_config["stripe"], wait=True)
     yield from bps.trigger(mirror.apply_stripe)
 
+    # yaw, lat cannot be done simultaneously
+    LOGGER.info(f"Adjusting {mirror.name} lat to {mirror_config['lat_mm']}")
+    yield from bps.abs_set(
+        mirror.x_mm, mirror_config["lat_mm"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
+    LOGGER.info(f"Adjusting {mirror.name} yaw to {mirror_config['yaw_mrad']}")
+    yield from bps.abs_set(
+        mirror.yaw_mrad, mirror_config["yaw_mrad"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
     LOGGER.info("Adjusting mirror voltages...")
-    yield from _apply_and_wait_for_voltages_to_settle(stripe, mirror, mirror_voltages)
+    yield from _apply_and_wait_for_voltages_to_settle(
+        mirror_config["stripe"], mirror_voltages
+    )
 
 
 def adjust_dcm_pitch_roll_vfm_from_lut(
     undulator_dcm: UndulatorDCM,
     vfm: FocusingMirrorWithStripes,
-    vfm_mirror_voltages: VFMMirrorVoltages,
+    mirror_voltages: MirrorVoltages,
     energy_kev,
 ):
     """Beamline energy-change post-adjustments : Adjust DCM and VFM directly from lookup tables.
-    Lookups are performed against the Bragg angle which will have been automatically set by EPICS as a side-effect of the
-    energy change prior to calling this function.
+    Lookups are performed against the Bragg angle which is computed directly from the target energy
+    rather than waiting for the EPICS controls PV to reach it.
     Feedback should be OFF prior to entry, in order to prevent
     feedback from making unnecessary corrections while beam is being adjusted."""
 
-    # DCM Pitch
+    # Adjust DCM Pitch
     dcm = undulator_dcm.dcm
     LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
-    bragg_deg = yield from bps.rd(dcm.bragg_in_degrees.user_readback)
-    LOGGER.info(f"Read Bragg angle = {bragg_deg} degrees")
+    d_spacing_a: float = yield from bps.rd(undulator_dcm.dcm.crystal_metadata_d_spacing)
+    bragg_deg = energy_to_bragg_angle(energy_kev, d_spacing_a)
+    LOGGER.info(f"Target Bragg angle = {bragg_deg} degrees")
     dcm_pitch_adjuster = lookup_table_adjuster(
         linear_interpolation_lut(undulator_dcm.pitch_energy_table_path),
         dcm.pitch_in_mrad,
@@ -104,31 +121,9 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     yield from dcm_roll_adjuster(DCM_GROUP)
     LOGGER.info("Waiting for DCM roll adjust to complete...")
 
-    # DCM Perp pitch
-    offset_mm = undulator_dcm.dcm_fixed_offset_mm
-    LOGGER.info(f"Adjusting DCM offset to {offset_mm} mm")
-    yield from bps.abs_set(dcm.offset_in_mm, offset_mm, group=DCM_GROUP)
-
     #
-    # Adjust mirrors
+    # Adjust vfm mirror stripe and mirror voltages
     #
 
-    # No need to change HFM
-
-    # Assumption is focus mode is already set to "sample"
-    # not sure how we check this
-
     # VFM Stripe selection
-    yield from adjust_mirror_stripe(energy_kev, vfm, vfm_mirror_voltages)
-    yield from bps.wait(DCM_GROUP)
-
-    # VFM Adjust - for I03 this table always returns the same value
-    vfm_lut = vfm.bragg_to_lat_lookup_table_path
-    assert vfm_lut is not None
-    vfm_x_adjuster = lookup_table_adjuster(
-        linear_interpolation_lut(vfm_lut),
-        vfm.x_mm,
-        bragg_deg,
-    )
-    LOGGER.info("Waiting for VFM Lat (Horizontal Translation) to complete...")
-    yield from vfm_x_adjuster()
+    yield from adjust_mirror_stripe(energy_kev, vfm, mirror_voltages)

mx_bluesky/hyperion/device_setup_plans/read_hardware_for_setup.py

@@ -6,7 +6,6 @@ from dodal.devices.attenuator import Attenuator
 from dodal.devices.dcm import DCM
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
-from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
@@ -20,7 +19,7 @@ def read_hardware_pre_collection(
     undulator: Undulator,
     synchrotron: Synchrotron,
     s4_slit_gaps: S4SlitGaps,
-    robot: BartRobot,
+    dcm: DCM,
     smargon: Smargon,
 ):
     LOGGER.info("Reading status of beamline for callbacks, pre collection.")
@@ -29,11 +28,12 @@ def read_hardware_pre_collection(
     )  # gives name to event *descriptor* document
     yield from bps.read(undulator.current_gap)
     yield from bps.read(synchrotron.synchrotron_mode)
-    yield from bps.read(s4_slit_gaps.xgap)
-    yield from bps.read(s4_slit_gaps.ygap)
+    yield from bps.read(s4_slit_gaps.xgap)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.read(s4_slit_gaps.ygap)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.read(smargon.x)
     yield from bps.read(smargon.y)
     yield from bps.read(smargon.z)
+    yield from bps.read(dcm.energy_in_kev)
     yield from bps.save()
 
 
@@ -48,13 +48,7 @@ def read_hardware_during_collection(
     yield from bps.create(name=CONST.DESCRIPTORS.HARDWARE_READ_DURING)
     yield from bps.read(aperture_scatterguard)
     yield from bps.read(attenuator.actual_transmission)
-    yield from bps.read(flux.flux_reading)
+    yield from bps.read(flux.flux_reading)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.read(dcm.energy_in_kev)
-    yield from bps.read(detector.bit_depth)
-    yield from bps.save()
-
-
-def read_hardware_for_zocalo(detector: EigerDetector):
-    yield from bps.create(name=CONST.DESCRIPTORS.ZOCALO_HW_READ)
-    yield from bps.read(detector.odin.file_writer.id)
+    yield from bps.read(detector.bit_depth)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.save()

mx_bluesky/hyperion/device_setup_plans/setup_oav.py

@@ -1,11 +1,10 @@
 from functools import partial
 
 import bluesky.plan_stubs as bps
+from dodal.devices.areadetector.plugins.CAM import ColorMode
 from dodal.devices.oav.oav_detector import OAV
-from dodal.devices.oav.oav_errors import OAVError_ZoomLevelNotFound
 from dodal.devices.oav.oav_parameters import OAVParameters
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
-from dodal.devices.oav.utils import ColorMode
 
 from mx_bluesky.hyperion.parameters.constants import CONST
 
@@ -56,19 +55,14 @@ def setup_pin_tip_detection_params(
 
 
 def setup_general_oav_params(oav: OAV, parameters: OAVParameters):
-    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)
-    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)
-    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)
-    yield from set_using_group(oav.cam.gain, parameters.gain)
+    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from set_using_group(oav.cam.gain, parameters.gain)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
     zoom_level_str = f"{float(parameters.zoom)}x"
-    if zoom_level_str not in oav.zoom_controller.allowed_zoom_levels:
-        raise OAVError_ZoomLevelNotFound(
-            f"Found {zoom_level_str} as a zoom level but expected one of {oav.zoom_controller.allowed_zoom_levels}"
-        )
-
     yield from bps.abs_set(
-        oav.zoom_controller,
+        oav.zoom_controller,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         zoom_level_str,
         wait=True,
     )

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -4,7 +4,7 @@ from importlib import resources
 from pathlib import Path
 
 import bluesky.plan_stubs as bps
-from blueapi.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
 from ophyd_async.core import load_device
@@ -20,6 +20,7 @@ from mx_bluesky.hyperion.log import LOGGER
 MM_TO_ENCODER_COUNTS = 200000
 GENERAL_TIMEOUT = 60
 TICKS_PER_MS = 1000  # Panda sequencer prescaler will be set to us
+PULSE_WIDTH_US = 50
 
 
 class Enabled(Enum):
@@ -62,12 +63,12 @@ def _get_seq_table(
         An instance of SeqTable describing the panda sequencer table
     """
 
-    start_of_grid_x_counts = int(parameters.x_start * MM_TO_ENCODER_COUNTS)
+    start_of_grid_x_counts = int(parameters.x_start_mm * MM_TO_ENCODER_COUNTS)
 
     # x_start is the first trigger point, so we need to travel to x_steps-1 for the final trigger point
     end_of_grid_x_counts = int(
         start_of_grid_x_counts
-        + (parameters.x_step_size * (parameters.x_steps - 1) * MM_TO_ENCODER_COUNTS)
+        + (parameters.x_step_size_mm * (parameters.x_steps - 1) * MM_TO_ENCODER_COUNTS)
     )
 
     exposure_distance_x_counts = int(exposure_distance_mm * MM_TO_ENCODER_COUNTS)
@@ -76,8 +77,6 @@ def _get_seq_table(
 
     delay_between_pulses = time_between_steps_ms * TICKS_PER_MS
 
-    PULSE_WIDTH_US = 1
-
     assert delay_between_pulses > PULSE_WIDTH_US
 
     # BITA_1 trigger wired from TTLIN1, this is the trigger input
@@ -141,7 +140,7 @@ def setup_panda_for_flyscan(
     """
     assert parameters.x_steps > 0
     assert time_between_x_steps_ms * 1000 >= exposure_time_s
-    assert sample_velocity_mm_per_s * exposure_time_s < parameters.x_step_size
+    assert sample_velocity_mm_per_s * exposure_time_s < parameters.x_step_size_mm
 
     yield from bps.stage(panda, group="panda-config")
 

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -3,16 +3,18 @@ from functools import wraps
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from blueapi.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.devices.zebra import (
     AUTO_SHUTTER_GATE,
-    AUTO_SHUTTER_INPUT,
+    AUTO_SHUTTER_INPUT_1,
+    AUTO_SHUTTER_INPUT_2,
     DISCONNECT,
     IN1_TTL,
     IN3_TTL,
     IN4_TTL,
     PC_GATE,
     PC_PULSE,
+    SOFT_IN1,
     TTL_DETECTOR,
     TTL_PANDA,
     TTL_XSPRESS3,
@@ -55,7 +57,7 @@ def bluesky_retry(func: Callable):
 
 
 def arm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
 def tidy_up_zebra_after_rotation_scan(
@@ -64,7 +66,7 @@ def tidy_up_zebra_after_rotation_scan(
     group="tidy_up_zebra_after_rotation",
     wait=True,
 ):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, group=group)
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, group=group)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.abs_set(
         zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
     )
@@ -73,15 +75,45 @@ def tidy_up_zebra_after_rotation_scan(
 
 
 def set_shutter_auto_input(zebra: Zebra, input: int, group="set_shutter_trigger"):
-    """Set the input that the shutter uses when set to auto.
+    """Set the signal that controls the shutter. We use the second input to the
+    Zebra's AND2 gate for this input. ZebraShutter control mode must be in auto for this input to take control
 
     For more details see the ZebraShutter device."""
     auto_shutter_control = zebra.logic_gates.and_gates[AUTO_SHUTTER_GATE]
     yield from bps.abs_set(
-        auto_shutter_control.sources[AUTO_SHUTTER_INPUT], input, group
+        auto_shutter_control.sources[AUTO_SHUTTER_INPUT_2], input, group
     )
 
 
+def configure_zebra_and_shutter_for_auto_shutter(
+    zebra: Zebra, zebra_shutter: ZebraShutter, input: int, group="use_automatic_shutter"
+):
+    """Set the shutter to auto mode, and configure the zebra to trigger the shutter on
+    an input source. For the input, use one of the source constants in zebra.py
+
+    When the shutter is in auto/manual, logic in EPICS sets the Zebra's
+    SOFT_IN1 to low/high respectively. The Zebra's AND2 gate should be used to control the shutter while in auto mode.
+    To do this, we need (AND2 = SOFT_IN1 AND input), where input is the zebra signal we want to control the shutter when in auto mode.
+    """
+    # See https://github.com/DiamondLightSource/dodal/issues/813 for better typing here.
+
+    # Set shutter to auto mode
+    yield from bps.abs_set(
+        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
+    )
+
+    # Set first input of AND2 gate to SOFT_IN1, which is high when shutter is in auto mode
+    # Note the Zebra should ALWAYS be setup this way. See https://github.com/DiamondLightSource/mx-bluesky/issues/551
+    yield from bps.abs_set(
+        zebra.logic_gates.and_gates[AUTO_SHUTTER_GATE].sources[AUTO_SHUTTER_INPUT_1],
+        SOFT_IN1,
+        group=group,
+    )
+
+    # Set the second input of AND2 gate to the requested zebra input source
+    yield from set_shutter_auto_input(zebra, input, group=group)
+
+
 @bluesky_retry
 def setup_zebra_for_rotation(
     zebra: Zebra,
@@ -137,11 +169,10 @@ def setup_zebra_for_rotation(
     yield from bps.abs_set(zebra.pc.pulse_start, abs(shutter_opening_s), group=group)
     # Set gate position to be angle of interest
     yield from bps.abs_set(zebra.pc.gate_trigger, axis.value, group=group)
-    # Trigger the shutter with the gate
-    yield from bps.abs_set(
-        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
+    # Set shutter to automatic and to trigger via PC_GATE
+    yield from configure_zebra_and_shutter_for_auto_shutter(
+        zebra, zebra_shutter, PC_GATE, group=group
     )
-    yield from set_shutter_auto_input(zebra, PC_GATE, group=group)
     # Trigger the detector with a pulse
     yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], PC_PULSE, group=group)
     # Don't use the fluorescence detector
@@ -159,11 +190,12 @@ def setup_zebra_for_gridscan(
     group="setup_zebra_for_gridscan",
     wait=True,
 ):
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], IN3_TTL, group=group)
-    yield from bps.abs_set(
-        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
+    # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
+    yield from configure_zebra_and_shutter_for_auto_shutter(
+        zebra, zebra_shutter, IN4_TTL, group=group
     )
-    yield from set_shutter_auto_input(zebra, IN4_TTL, group=group)
+
+    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], IN3_TTL, group=group)
     yield from bps.abs_set(zebra.output.out_pvs[TTL_XSPRESS3], DISCONNECT, group=group)
     yield from bps.abs_set(zebra.output.pulse_1.input, DISCONNECT, group=group)
 
@@ -198,11 +230,10 @@ def setup_zebra_for_panda_flyscan(
     # Forwards eiger trigger signal from panda
     yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], IN1_TTL, group=group)
 
-    # Forwards signal from PPMAC to fast shutter. High while panda PLC is running
-    yield from bps.abs_set(
-        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
+    # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
+    yield from configure_zebra_and_shutter_for_auto_shutter(
+        zebra, zebra_shutter, IN4_TTL, group=group
     )
-    yield from set_shutter_auto_input(zebra, IN4_TTL, group=group)
 
     yield from bps.abs_set(zebra.output.out_pvs[TTL_XSPRESS3], DISCONNECT, group=group)
 

mx_bluesky/hyperion/device_setup_plans/smargon.py

@@ -2,24 +2,24 @@ import numpy as np
 from bluesky import plan_stubs as bps
 from dodal.devices.smargon import Smargon
 
-from mx_bluesky.hyperion.exceptions import WarningException
+from mx_bluesky.hyperion.exceptions import SampleException
 
 
 def move_smargon_warn_on_out_of_range(
     smargon: Smargon, position: np.ndarray | list[float] | tuple[float, float, float]
 ):
-    """Throws a WarningException if the specified position is out of range for the
+    """Throws a SampleException if the specified position is out of range for the
     smargon. Otherwise moves to that position."""
     limits = yield from smargon.get_xyz_limits()
     if not limits.position_valid(position):
-        raise WarningException(
+        raise SampleException(
             "Pin tip centring failed - pin too long/short/bent and out of range"
         )
     yield from bps.mv(
-        smargon.x,
-        position[0],
-        smargon.y,
-        position[1],
-        smargon.z,
-        position[2],
+        smargon.x,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        position[0],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.y,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        position[1],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.z,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        position[2],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     )