mx-bluesky 1.1.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

mx_bluesky/common/utils/log.py

@@ -0,0 +1,116 @@
+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_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

@@ -14,6 +14,10 @@ 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 +40,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 +53,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 +119,7 @@ class BlueskyRunner:
     def start(
         self,
         experiment: Callable,
-        parameters: HyperionParameters,
+        parameters: MxBlueskyParameters,
         plan_name: str,
         callbacks: CallbacksFactory | None,
     ) -> StatusAndMessage:
@@ -239,7 +239,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 +345,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,6 +13,9 @@ 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"
@@ -20,40 +23,41 @@ DCM_GROUP = "DCM_GROUP"
 
 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]
+
+        for voltage_channel, required_voltage in zip(
+            channels.values(), required_voltages, strict=True
+        ):
+            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
+            )
 
     yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
 
 
 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."""
@@ -66,26 +70,27 @@ def adjust_mirror_stripe(
     yield from bps.trigger(mirror.apply_stripe)
 
     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(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,
@@ -119,7 +124,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     # not sure how we check this
 
     # VFM Stripe selection
-    yield from adjust_mirror_stripe(energy_kev, vfm, vfm_mirror_voltages)
+    yield from adjust_mirror_stripe(energy_kev, vfm, mirror_voltages)
     yield from bps.wait(DCM_GROUP)
 
     # VFM Adjust - for I03 this table always returns the same value

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

@@ -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):
@@ -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

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -6,13 +6,15 @@ import bluesky.preprocessors as bpp
 from blueapi.core 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

@@ -16,10 +16,10 @@ def move_smargon_warn_on_out_of_range(
             "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
     )

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -3,6 +3,10 @@ from collections.abc import Generator
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import Msg
+from dodal.devices.dcm import DCM
+from dodal.devices.detector import (
+    DetectorParams,
+)
 from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.eiger import EigerDetector
 
@@ -12,6 +16,13 @@ from mx_bluesky.hyperion.device_setup_plans.position_detector import (
 )
 
 
+def fill_in_energy_if_not_supplied(dcm: DCM, detector_params: DetectorParams):
+    if not detector_params.expected_energy_ev:
+        actual_energy_ev = 1000 * (yield from bps.rd(dcm.energy_in_kev))
+        detector_params.expected_energy_ev = actual_energy_ev
+    return detector_params
+
+
 def start_preparing_data_collection_then_do_plan(
     eiger: EigerDetector,
     detector_motion: DetectorMotion,
@@ -30,7 +41,7 @@ def start_preparing_data_collection_then_do_plan(
     """
 
     def wrapped_plan():
-        yield from bps.abs_set(eiger.do_arm, 1, group=group)
+        yield from bps.abs_set(eiger.do_arm, 1, group=group)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         if detector_distance_mm:
             yield from set_detector_z_position(
                 detector_motion, detector_distance_mm, group
@@ -40,5 +51,5 @@ def start_preparing_data_collection_then_do_plan(
 
     yield from bpp.contingency_wrapper(
         wrapped_plan(),
-        except_plan=lambda e: (yield from bps.stop(eiger)),
+        except_plan=lambda e: (yield from bps.stop(eiger)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     )

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -23,14 +23,14 @@ def _check_and_pause_feedback(
                                                turning XBPM feedback off.
 
     """
-    yield from bps.mv(attenuator, 1.0)
+    yield from bps.mv(attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     LOGGER.info("Waiting for XBPM feedback to be stable")
     yield from bps.trigger(xbpm_feedback, wait=True)
     LOGGER.info(
         f"XPBM feedback in position, pausing and setting transmission to {desired_transmission_fraction}"
     )
-    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)
-    yield from bps.mv(attenuator, desired_transmission_fraction)
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(attenuator, desired_transmission_fraction)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
 def _unpause_xbpm_feedback_and_set_transmission_to_1(
@@ -44,7 +44,7 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
                                       the beam in position
         attenuator (Attenuator): The attenuator used to set transmission
     """
-    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
 def transmission_and_xbpm_feedback_for_collection_wrapper(