dls-dodal 1.43.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

dodal/devices/current_amplifiers/current_amplifier.py

@@ -23,7 +23,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
         super().__init__(name)
 
     @abstractmethod
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         """Increase gain, increment by 1 by default.
 
@@ -31,7 +30,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def decrease_gain(self, value: int = 1) -> None:
         """Decrease gain, decrement by 1 by default.
@@ -40,21 +38,18 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
-    async def get_gain(self) -> type[Enum]:
+    async def get_gain(self) -> Enum:
         """Get the current gain setting
 
         Returns:
             Enum: The member name of the current gain setting in gain_conversion_table.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_upperlimit(self) -> float:
         """Get the upper limit of the current amplifier"""
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_lowerlimit(self) -> float:
         """Get the lower limit of the current amplifier"""

dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -92,8 +92,8 @@ class CurrentAmpDet(StandardReadable, Preparable):
             self.current_amp().get_gain(),
             self.counter().get_voltage_per_sec(),
         )
-        correction_factor = current_gain.value
-        corrected_current = voltage_per_sec / correction_factor
+        assert isinstance(current_gain.value, float)
+        corrected_current = voltage_per_sec / current_gain.value
         return corrected_current
 
     @AsyncStatus.wrap

dodal/devices/current_amplifiers/femto.py

@@ -114,7 +114,6 @@ class FemtoDDPCA(CurrentAmp):
         # wait for current amplifier's bandpass filter to settle.
         await asyncio.sleep(self.raise_timetable[SEN_setting].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -122,7 +121,6 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -130,14 +128,11 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         return self.gain_conversion_table[(await self.gain.get_value()).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/current_amplifiers/sr570.py

@@ -178,7 +178,6 @@ class SR570(CurrentAmp):
         )
         await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -189,7 +188,6 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -198,17 +196,14 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         result = await asyncio.gather(
             self.coarse_gain.get_value(), self.fine_gain.get_value()
         )
         return self.gain_conversion_table[self.combined_table(result).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/electron_analyser/base_region.py

@@ -0,0 +1,64 @@
+from enum import Enum
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class EnergyMode(str, Enum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"
+
+
+class BaseRegion(BaseModel):
+    """
+    Generic region model that holds the data. Specialised region models should inherit
+    this to extend functionality.
+    """
+
+    name: str = "New_region"
+    enabled: bool = False
+    slices: int = 1
+    iterations: int = 1
+    # These ones we need subclasses to provide default values
+    lensMode: str
+    passEnergy: int | float
+    acquisitionMode: str
+    lowEnergy: float
+    highEnergy: float
+    stepTime: float
+    energyStep: float
+    energyMode: EnergyMode = EnergyMode.KINETIC
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_energy_mode(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            # convert bindingEnergy to energyMode to make base region more generic
+            if "bindingEnergy" in data:
+                is_binding_energy = data["bindingEnergy"]
+                del data["bindingEnergy"]
+                data["energyMode"] = (
+                    EnergyMode.BINDING if is_binding_energy else EnergyMode.KINETIC
+                )
+        return data
+
+
+TBaseRegion = TypeVar("TBaseRegion", bound=BaseRegion)
+
+
+class BaseSequence(BaseModel, Generic[TBaseRegion]):
+    """
+    Generic sequence model that holds the list of region data. Specialised sequence models
+    should inherit this to extend functionality.
+    """
+
+    regions: list[TBaseRegion] = Field(default_factory=lambda: [])
+
+    def get_enabled_regions(self) -> list[BaseRegion]:
+        return [r for r in self.regions if r.enabled]
+
+    def get_region_names(self) -> list[str]:
+        return [r.name for r in self.regions]
+
+    def get_enabled_region_names(self) -> list[str]:
+        return [r.name for r in self.get_enabled_regions()]

dodal/devices/electron_analyser/specs/specs_region.py

@@ -0,0 +1,24 @@
+from pydantic import Field
+
+from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
+
+
+class SpecsRegion(BaseRegion):
+    # Override base class with defaults
+    lensMode: str = "SmallArea"
+    passEnergy: int | float = 5.0
+    acquisitionMode: str = "Fixed Transmission"
+    lowEnergy: float = Field(default=800, alias="startEnergy")
+    highEnergy: float = Field(default=850, alias="endEnergy")
+    stepTime: float = Field(default=1.0, alias="exposureTime")
+    energyStep: float = Field(default=0.1, alias="stepEnergy")
+    # Specific to this class
+    values: float = 1
+    centreEnergy: float = 0
+    psuMode: str = "1.5keV"
+    acquisitionMode: str = ""
+    estimatedTimeInMs: float = 0
+
+
+class SpecsSequence(BaseSequence):
+    regions: list[SpecsRegion] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/vgscienta/vgscienta_region.py

@@ -0,0 +1,77 @@
+import uuid
+from enum import Enum
+
+from ophyd_async.core import StrictEnum
+from pydantic import BaseModel, Field
+
+from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
+
+
+class Status(str, Enum):
+    READY = "Ready"
+    RUNNING = "Running"
+    COMPLETED = "Completed"
+    INVALID = "Invalid"
+    ABORTED = "Aborted"
+
+
+class DetectorMode(StrictEnum):
+    ADC = "ADC"
+    PULSE_COUNTING = "Pulse Counting"
+
+
+class AcquisitionMode(str, Enum):
+    SWEPT = "Swept"
+    FIXED = "Fixed"
+
+
+class VGScientaRegion(BaseRegion):
+    # Override defaults of base region class
+    lensMode: str = "Angular45"
+    passEnergy: int | float = 5
+    acquisitionMode: str = AcquisitionMode.SWEPT
+    lowEnergy: float = 8.0
+    highEnergy: float = 10.0
+    stepTime: float = 1.0
+    energyStep: float = Field(default=200.0)
+    # Specific to this class
+    regionId: str = Field(default=str(uuid.uuid4()))
+    excitationEnergySource: str = "source1"
+    fixEnergy: float = 9.0
+    totalSteps: float = 13.0
+    totalTime: float = 13.0
+    exposureTime: float = 1.0
+    firstXChannel: int = 1
+    lastXChannel: int = 1000
+    firstYChannel: int = 101
+    lastYChannel: int = 800
+    detectorMode: DetectorMode = DetectorMode.ADC
+    status: Status = Status.READY
+
+
+class VGScientaExcitationEnergySource(BaseModel):
+    name: str = "source1"
+    scannableName: str = ""
+    value: float = 0
+
+
+class VGScientaSequence(BaseSequence):
+    elementSet: str = Field(default="Unknown")
+    excitationEnergySources: list[VGScientaExcitationEnergySource] = Field(
+        default_factory=lambda: []
+    )
+    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
+
+    def get_excitation_energy_source_by_region(
+        self, region: VGScientaRegion
+    ) -> VGScientaExcitationEnergySource | None:
+        filtered_excitation_energy_sources = [
+            e
+            for e in self.excitationEnergySources
+            if e.name == region.excitationEnergySource
+        ]
+        return (
+            filtered_excitation_energy_sources[0]
+            if len(filtered_excitation_energy_sources) == 1
+            else None
+        )

dodal/devices/fast_grid_scan.py

@@ -23,7 +23,7 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,7 +203,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_hardware_backed_soft_signal(
+        self.expected_images = create_r_hardware_backed_soft_signal(
             float, self._calculate_expected_images
         )
 

dodal/devices/i03/beamstop.py

@@ -5,7 +5,7 @@ from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class BeamstopPositions(StrictEnum):
@@ -53,7 +53,7 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = create_hardware_backed_soft_signal(
+            self.selected_pos = create_r_hardware_backed_soft_signal(
                 BeamstopPositions, self._get_selected_position
             )
 

dodal/devices/i13_1/merlin.py

@@ -3,7 +3,6 @@ from ophyd_async.epics import adcore
 
 from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
 
 class Merlin(StandardDetector):
@@ -18,7 +17,7 @@ class Merlin(StandardDetector):
         fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
-        self.drv = MerlinDriverIO(prefix + drv_suffix)
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
         self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(

dodal/devices/i13_1/merlin_controller.py

@@ -6,17 +6,21 @@ from ophyd_async.core import (
     AsyncStatus,
     TriggerInfo,
 )
-from ophyd_async.epics import adcore
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
+from ophyd_async.epics.adcore import (
+    DEFAULT_GOOD_STATES,
+    ADBaseController,
+    ADBaseIO,
+    ADImageMode,
+    ADState,
+    stop_busy_record,
+)
 
 
 class MerlinController(ADBaseController):
     def __init__(
         self,
-        driver: MerlinDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        driver: ADBaseIO,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -34,7 +38,7 @@ class MerlinController(ADBaseController):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
+            self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
     async def wait_for_idle(self):
@@ -44,4 +48,4 @@ class MerlinController(ADBaseController):
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

dodal/devices/i19/beamstop.py

@@ -0,0 +1,30 @@
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_x
+from ophyd_async.epics.motor import Motor
+
+
+class HomeGroup(StrictEnum):
+    NONE = "none"
+    ALL = "All"
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+
+
+class HomingControl(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.homing_group = epics_signal_rw(HomeGroup, f"{prefix}:HMGRP")
+        self.home = epics_signal_x(f"{prefix}:HOME")
+        super().__init__(name)
+
+
+class BeamStop(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(f"{prefix}X")
+            self.y = Motor(f"{prefix}Y")
+            self.z = Motor(f"{prefix}Z")
+
+        self.homing = HomingControl(f"{prefix}HM", name)
+
+        super().__init__(name)

dodal/devices/i19/hutch_access.py

@@ -1,6 +1,8 @@
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
 
+ACCESS_DEVICE_NAME = "access_control"  # Device name in i19-blueapi
+
 
 class HutchAccessControl(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:

dodal/devices/i19/shutter.py

@@ -1,57 +1,79 @@
 from enum import Enum
 
+from aiohttp import ClientSession
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, StandardReadable, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
-from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
+from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME
 from dodal.log import LOGGER
 
-
-class HutchInvalidError(Exception):
-    pass
+OPTICS_BLUEAPI_URL = "https://i19-blueapi.diamond.ac.uk"
 
 
 class HutchState(str, Enum):
     EH1 = "EH1"
     EH2 = "EH2"
-    INVALID = "INVALID"
 
 
-class HutchConditionalShutter(StandardReadable, Movable[ShutterDemand]):
+class AccessControlledShutter(StandardReadable, Movable[ShutterDemand]):
     """ I19-specific device to operate the hutch shutter.
 
-    This device evaluates the hutch state value to work out which of the two I19 \
-    hutches is in use and then implements the HutchShutter device to operate the \
-    experimental shutter.
+    This device will send a REST call to the blueapi instance controlling the optics \
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    the hutch sending the request and decide if the plan will be run or not.
     As the two hutches are located in series, checking the hutch in use is necessary to \
     avoid accidentally operating the shutter from one hutch while the other has beamtime.
 
-    The hutch name should be passed to the device upon instantiation. If this does not \
-    coincide with the current hutch in use, a warning will be logged and the shutter \
-    will not be operated. This is to allow for testing of plans.
-    An error will instead be raised if the hutch state reads as "INVALID".
+    The name of the hutch that wants to operate the shutter should be passed to the \
+    device upon instantiation.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
     def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
-        self.shutter = HutchShutter(prefix=prefix, name=name)
-        bl_prefix = prefix.split("-")[0]
-        self.hutch_state = epics_signal_r(str, f"{bl_prefix}-OP-STAT-01:EHStatus.VALA")
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
         self.hutch_request = hutch
+        self.url = OPTICS_BLUEAPI_URL
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        hutch_in_use = await self.hutch_state.get_value()
-        LOGGER.info(f"Current hutch in use: {hutch_in_use}")
-        if hutch_in_use == HutchState.INVALID:
-            raise HutchInvalidError(
-                "The hutch state is invalid. Contact the beamline staff."
-            )
-        if hutch_in_use != self.hutch_request:
-            # NOTE Warn but don't fail
-            LOGGER.warning(
-                f"{self.hutch_request} is not the hutch in use. Shutter will not be operated."
-            )
-        else:
-            await self.shutter.set(value)
+        REQUEST_PARAMS = {
+            "name": "operate_shutter_plan",
+            "params": {
+                "experiment_hutch": self.hutch_request.value,
+                "access_device": ACCESS_DEVICE_NAME,
+                "shutter_demand": value,
+            },
+        }
+        async with ClientSession(base_url=self.url, raise_for_status=True) as session:
+            # First submit the plan to the worker
+            async with session.post("/tasks", data=REQUEST_PARAMS) as response:
+                LOGGER.debug(
+                    f"Task submitted to the worker, response status: {response.status}"
+                )
+
+                try:
+                    data = await response.json()
+                    task_id = data["task_id"]
+                except Exception as e:
+                    LOGGER.error(
+                        f"Failed to get task_id from {self.url}/tasks POST. ({e})"
+                    )
+                    raise
+            # Then set the task as active and run asap
+            async with session.put(
+                "/worker/tasks", data={"task_id": task_id}
+            ) as response:
+                if not response.ok:
+                    LOGGER.error(
+                        f"""Unable to operate the shutter.
+                        Session PUT responded with {response.status}: {response.reason}.
+                        """
+                    )
+                    return
+                LOGGER.debug(f"Run operate shutter plan, task_id: {task_id}")

dodal/devices/i22/nxsas.py

@@ -6,7 +6,7 @@ from typing import TypeVar
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
-from ophyd_async.epics.adaravis import AravisController, AravisDetector
+from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -149,7 +149,6 @@ class NXSasOAV(AravisDetector):
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
-        gpio_number: AravisController.GPIO_NUMBER = 1,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.
@@ -162,7 +161,6 @@ class NXSasOAV(AravisDetector):
             drv_suffix=drv_suffix,
             fileio_suffix=fileio_suffix,
             name=name,
-            gpio_number=gpio_number,
         )
         self._metadata_holder = metadata_holder
 

dodal/devices/i24/focus_mirrors.py

@@ -1,7 +1,7 @@
 from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class HFocusMode(StrictEnum):
@@ -40,10 +40,10 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_hardware_backed_soft_signal(
+            self.beam_size_x = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_x, units="um"
             )
-            self.beam_size_y = create_hardware_backed_soft_signal(
+            self.beam_size_y = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_y, units="um"
             )
 

dodal/devices/i24/pilatus_metadata.py

@@ -5,7 +5,7 @@ import re
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class PilatusMetadata(StandardReadable):
@@ -14,7 +14,7 @@ class PilatusMetadata(StandardReadable):
         self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
         self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
         with self.add_children_as_readables():
-            self.filename_template = create_hardware_backed_soft_signal(
+            self.filename_template = create_r_hardware_backed_soft_signal(
                 str, self._get_full_filename_template
             )
         super().__init__(name)

dodal/devices/oav/oav_detector.py

@@ -9,10 +9,10 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.areadetector.plugins.CAM import Cam
 from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
-from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
+from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
 
@@ -63,24 +63,22 @@ class OAV(StandardReadable):
 
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
-            self.microns_per_pixel_x = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_x = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.X),
             )
-            self.microns_per_pixel_y = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_y = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.Y),
             )
-            self.beam_centre_i = create_hardware_backed_soft_signal(
+            self.beam_centre_i = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.X)
             )
-            self.beam_centre_j = create_hardware_backed_soft_signal(
+            self.beam_centre_j = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.Y)
             )
-            self.snapshot = SnapshotWithBeamCentre(
+            self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
-                self.beam_centre_i,
-                self.beam_centre_j,
                 self._name,
             )