Automatic backup triggered by new deployment

.gitea/workflows/rtd_deploy.yml

@@ -1,21 +0,0 @@
-name: Read the Docs Deploy Trigger
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-jobs:
-  trigger-rtd-webhook:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Trigger Read the Docs webhook
-        env:
-          RTD_TOKEN: ${{ secrets.RTD_TOKEN }}
-        run: |
-          curl --fail --show-error --silent \
-            -X POST \
-            -d "branches=${{ github.ref_name }}" \
-            -d "token=${RTD_TOKEN}" \
-            "https://readthedocs.org/api/v2/webhook/sls-csaxs/270162/"

.readthedocs.yaml

@@ -8,14 +8,15 @@ version: 2
 build:
   os: ubuntu-20.04
   tools:
-    python: "3.12"
+    python: "3.10"
   jobs:
     pre_install:
       - pip install .
 
+
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-  configuration: docs/conf.py
+   configuration: docs/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 # formats:
@@ -23,5 +24,6 @@ sphinx:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-  install:
-    - requirements: docs/requirements.txt
+   install:
+   - requirements: docs/requirements.txt
+

csaxs_bec/device_configs/main.yaml

@@ -10,8 +10,8 @@
 endstation:
   - !include ./bl_endstation.yaml
 
-detectors:
-  - !include ./bl_detectors.yaml
+# detectors:
+#   - !include ./bl_detectors.yaml
 
 #sastt:
 #  - !include ./sastt.yaml

csaxs_bec/device_configs/ptycho_flomni.yaml

@@ -395,16 +395,6 @@ rtz:
   readoutPriority: on_request
   connectionTimeout: 20
 
-rt_flyer:
-  deviceClass: csaxs_bec.devices.omny.rt.rt_flomni_ophyd.RtFlomniFlyer
-  deviceConfig:
-    host: mpc2844.psi.ch
-    port: 2222
-  readoutPriority: async
-  connectionTimeout: 20
-  enabled: true
-  readOnly: False
-
 ############################################################
 ####################### Cameras ############################
 ############################################################

csaxs_bec/device_configs/test_config.yaml

@@ -1,24 +0,0 @@
-galilrioesxbox:
-  description: Galil RIO for remote gain switching and slow reading ES XBox
-  deviceClass: csaxs_bec.devices.omny.galil.galil_rio.GalilRIO
-  deviceConfig:
-    host: galilrioesft.psi.ch
-  enabled: true
-  onFailure: raise
-  readOnly: false
-  readoutPriority: baseline
-  connectionTimeout: 20
-bpm1:
-  readoutPriority: baseline
-  deviceClass: csaxs_bec.devices.pseudo_devices.bpm.BPM
-  deviceConfig:
-    blade_t: galilrioesxbox.analog_in.ch0
-    blade_r: galilrioesxbox.analog_in.ch1
-    blade_b: galilrioesxbox.analog_in.ch2
-    blade_l: galilrioesxbox.analog_in.ch3
-  enabled: true
-  readOnly: false
-  softwareTrigger: true
-  needs:
-    - galilrioesxbox
-

csaxs_bec/devices/epics/mcs_card/mcs_card_csaxs.py

@@ -317,6 +317,8 @@ class MCSCardCSAXS(PSIDeviceBase, MCSCard):
         try:
             scan_done = bool(value == self._num_total_triggers)
             self.progress.put(value=value, max_value=self._num_total_triggers, done=scan_done)
+            if scan_done:
+                self._scan_done_event.set()
         except Exception:
             content = traceback.format_exc()
             logger.info(f"Device {self.name}  error: {content}")
@@ -391,7 +393,6 @@ class MCSCardCSAXS(PSIDeviceBase, MCSCard):
         self._current_data_index = 0
 
         # NOTE Make sure that the signal that omits mca callbacks is cleared
-        # DO NOT REMOVE!!
         self._omit_mca_callbacks.clear()
 
         # For a fly scan we need to start the mcs card ourselves
@@ -562,9 +563,8 @@ class MCSCardCSAXS(PSIDeviceBase, MCSCard):
 
     def on_stop(self) -> None:
         """Hook called when the device is stopped. In addition, any status that is registered through cancel_on_stop will be cancelled here."""
-        with suppress_mca_callbacks(self):
-            self.stop_all.put(1)
-            self.erase_all.put(1)
+        self.stop_all.put(1)
+        self.erase_all.put(1)
 
     def mcs_recovery(self, timeout: int = 1) -> None:
         """

csaxs_bec/devices/omny/rt/rt_flomni_ophyd.py

@@ -1,18 +1,20 @@
 import threading
 import time
+from typing import List
 
 import numpy as np
-from bec_lib import bec_logger
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from ophyd import Component as Cpt
 from ophyd import Device, PositionerBase, Signal
 from ophyd.status import wait as status_wait
 from ophyd.utils import LimitError
-from ophyd_devices import AsyncMultiSignal, DeviceStatus, ProgressSignal
 from ophyd_devices.utils.controller import Controller, threadlocked
 from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
 from prettytable import PrettyTable
 
 from csaxs_bec.devices.omny.rt.rt_ophyd import (
+    BECConfigError,
     RtCommunicationError,
     RtError,
     RtReadbackSignal,
@@ -430,6 +432,27 @@ class RtFlomniController(Controller):
             t.add_row([i, self.read_ssi_interferometer(i)])
         print(t)
 
+    def _get_signals_from_table(self, return_table) -> dict:
+        self.average_stdeviations_x_st_fzp += float(return_table[4])
+        self.average_stdeviations_y_st_fzp += float(return_table[7])
+        signals = {
+            "target_x": {"value": float(return_table[2])},
+            "average_x_st_fzp": {"value": float(return_table[3])},
+            "stdev_x_st_fzp": {"value": float(return_table[4])},
+            "target_y": {"value": float(return_table[5])},
+            "average_y_st_fzp": {"value": float(return_table[6])},
+            "stdev_y_st_fzp": {"value": float(return_table[7])},
+            "average_rotz": {"value": float(return_table[8])},
+            "stdev_rotz": {"value": float(return_table[9])},
+            "average_stdeviations_x_st_fzp": {
+                "value": self.average_stdeviations_x_st_fzp / (int(return_table[0]) + 1)
+            },
+            "average_stdeviations_y_st_fzp": {
+                "value": self.average_stdeviations_y_st_fzp / (int(return_table[0]) + 1)
+            },
+        }
+        return signals
+
     @threadlocked
     def start_scan(self):
         if not self.feedback_is_running():
@@ -469,6 +492,91 @@ class RtFlomniController(Controller):
         current_position_in_scan = int(float(return_table[2]))
         return (mode, number_of_positions_planned, current_position_in_scan)
 
+    def read_positions_from_sampler(self):
+        # this was for reading after the scan completed
+        number_of_samples_to_read = 1  # self.get_scan_status()[1]  #number of valid samples, will be updated upon first data read
+
+        read_counter = 0
+
+        self.average_stdeviations_x_st_fzp = 0
+        self.average_stdeviations_y_st_fzp = 0
+        self.average_lamni_angle = 0
+
+        mode, number_of_positions_planned, current_position_in_scan = self.get_scan_status()
+
+        # if not (mode==2 or mode==3):
+        #    error
+        self.device_manager.connector.set(
+            MessageEndpoints.device_status("rt_scan"),
+            messages.DeviceStatusMessage(
+                device="rt_scan", status=1, metadata=self.readout_metadata
+            ),
+        )
+        # while scan is running
+        while mode > 0:
+
+            # TODO here?: scan abortion if no progress in scan *raise error
+
+            # logger.info(f"Current scan position {current_position_in_scan} out of {number_of_positions_planned}")
+            mode, number_of_positions_planned, current_position_in_scan = self.get_scan_status()
+            time.sleep(0.01)
+            if current_position_in_scan > 5:
+                while current_position_in_scan > read_counter + 1:
+                    return_table = (self.socket_put_and_receive(f"r{read_counter}")).split(",")
+                    # logger.info(f"{return_table}")
+                    logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
+
+                    read_counter = read_counter + 1
+
+                    signals = self._get_signals_from_table(return_table)
+
+                    self.publish_device_data(signals=signals, point_id=int(return_table[0]))
+
+        time.sleep(0.05)
+
+        # read the last samples even though scan is finished already
+        while number_of_positions_planned > read_counter:
+            return_table = (self.socket_put_and_receive(f"r{read_counter}")).split(",")
+            logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
+            # logger.info(f"{return_table}")
+            read_counter = read_counter + 1
+
+            signals = self._get_signals_from_table(return_table)
+            self.publish_device_data(signals=signals, point_id=int(return_table[0]))
+
+        self.device_manager.connector.set(
+            MessageEndpoints.device_status("rt_scan"),
+            messages.DeviceStatusMessage(
+                device="rt_scan", status=0, metadata=self.readout_metadata
+            ),
+        )
+
+        logger.info(
+            "Flomni statistics: Average of all standard deviations: x"
+            f" {self.average_stdeviations_x_st_fzp/read_counter*1000:.1f}, y"
+            f" {self.average_stdeviations_y_st_fzp/read_counter*1000:.1f}"
+        )
+
+    def publish_device_data(self, signals, point_id):
+        self.device_manager.connector.set_and_publish(
+            MessageEndpoints.device_read("rt_flomni"),
+            messages.DeviceMessage(
+                signals=signals, metadata={"point_id": point_id, **self.readout_metadata}
+            ),
+        )
+
+    def start_readout(self):
+        readout = threading.Thread(target=self.read_positions_from_sampler)
+        readout.start()
+
+    def kickoff(self, metadata):
+        self.readout_metadata = metadata
+        while not self._min_scan_buffer_reached:
+            time.sleep(0.001)
+        self.start_scan()
+        time.sleep(0.1)
+        self.start_readout()
+
 
 class RtFlomniReadbackSignal(RtReadbackSignal):
     @retry_once
@@ -736,185 +844,6 @@ class RtFlomniMotor(Device, PositionerBase):
         return super().stop(success=success)
 
 
-class RtFlomniFlyer(Device):
-    USER_ACCESS = ["controller"]
-    data = Cpt(
-        AsyncMultiSignal,
-        name="data",
-        signals=[
-            "target_x",
-            "average_x_st_fzp",
-            "stdev_x_st_fzp",
-            "target_y",
-            "average_y_st_fzp",
-            "stdev_y_st_fzp",
-            "average_rotz",
-            "stdev_rotz",
-            "average_stdeviations_x_st_fzp",
-            "average_stdeviations_y_st_fzp",
-        ],
-        ndim=1,
-        async_update={"type": "add", "max_shape": [None]},
-        max_size=1000,
-    )
-    progress = Cpt(
-        ProgressSignal, doc="ProgressSignal indicating the progress of the device during a scan."
-    )
-
-    def __init__(
-        self,
-        prefix="",
-        *,
-        name,
-        kind=None,
-        read_attrs=None,
-        configuration_attrs=None,
-        parent=None,
-        host="mpc2844.psi.ch",
-        port=2222,
-        socket_cls=SocketIO,
-        device_manager=None,
-        **kwargs,
-    ):
-        super().__init__(prefix=prefix, name=name, parent=parent, **kwargs)
-        self.shutdown_event = threading.Event()
-        self.controller = RtFlomniController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
-        )
-        self.average_stdeviations_x_st_fzp = 0
-        self.average_stdeviations_y_st_fzp = 0
-        self.average_lamni_angle = 0
-        self.readout_thread = None
-        self.scan_done_event = threading.Event()
-        self.scan_done_event.set()
-
-    def read_positions_from_sampler(self, status: DeviceStatus):
-        """
-        Read the positions from the sampler and update the data signal.
-        This function runs in a separate thread and continuously checks the
-        scan status.
-
-        Args:
-            status (DeviceStatus): The status object to update when the readout is complete.
-        """
-        read_counter = 0
-        self.average_stdeviations_x_st_fzp = 0
-        self.average_stdeviations_y_st_fzp = 0
-        self.average_lamni_angle = 0
-
-        mode, number_of_positions_planned, current_position_in_scan = (
-            self.controller.get_scan_status()
-        )
-
-        # while scan is running
-        while mode > 0 and not self.shutdown_event.wait(0.01):
-            # logger.info(f"Current scan position {current_position_in_scan} out of {number_of_positions_planned}")
-            mode, number_of_positions_planned, current_position_in_scan = (
-                self.controller.get_scan_status()
-            )
-            if current_position_in_scan > 5:
-                while current_position_in_scan > read_counter + 1:
-                    return_table = (
-                        self.controller.socket_put_and_receive(f"r{read_counter}")
-                    ).split(",")
-                    logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
-                    self.progress.put(
-                        value=read_counter, max_value=number_of_positions_planned, done=False
-                    )
-                    read_counter = read_counter + 1
-                    signals = self._get_signals_from_table(return_table)
-                    self.data.set(signals)
-
-        if self.shutdown_event.wait(0.05):
-            logger.info("Shutdown event set, stopping readout.")
-            # if we are here, the shutdown_event is set. We can exit the readout loop.
-            status.set_finished()
-            return
-
-        # read the last samples even though scan is finished already
-        while number_of_positions_planned > read_counter and not self.shutdown_event.is_set():
-            return_table = (self.controller.socket_put_and_receive(f"r{read_counter}")).split(",")
-            logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
-            self.progress.put(value=read_counter, max_value=number_of_positions_planned, done=False)
-            read_counter = read_counter + 1
-
-            signals = self._get_signals_from_table(return_table)
-            self.data.set(signals)
-
-        # NOTE: No need to set the status to failed if the shutdown_event is set.
-        # The stop() method will take care of that.
-        status.set_finished()
-        self.progress.put(value=read_counter, max_value=number_of_positions_planned, done=True)
-
-        logger.info(
-            "Flomni statistics: Average of all standard deviations: x"
-            f" {self.average_stdeviations_x_st_fzp/read_counter*1000:.1f}, y"
-            f" {self.average_stdeviations_y_st_fzp/read_counter*1000:.1f}"
-        )
-
-    def _get_signals_from_table(self, return_table) -> dict:
-        self.average_stdeviations_x_st_fzp += float(return_table[4])
-        self.average_stdeviations_y_st_fzp += float(return_table[7])
-        signals = {
-            "target_x": {"value": float(return_table[2])},
-            "average_x_st_fzp": {"value": float(return_table[3])},
-            "stdev_x_st_fzp": {"value": float(return_table[4])},
-            "target_y": {"value": float(return_table[5])},
-            "average_y_st_fzp": {"value": float(return_table[6])},
-            "stdev_y_st_fzp": {"value": float(return_table[7])},
-            "average_rotz": {"value": float(return_table[8])},
-            "stdev_rotz": {"value": float(return_table[9])},
-            "average_stdeviations_x_st_fzp": {
-                "value": self.average_stdeviations_x_st_fzp / (int(return_table[0]) + 1)
-            },
-            "average_stdeviations_y_st_fzp": {
-                "value": self.average_stdeviations_y_st_fzp / (int(return_table[0]) + 1)
-            },
-        }
-        return signals
-
-    def stage(self):
-        self.shutdown_event.clear()
-        self.scan_done_event.set()
-        return super().stage()
-
-    def start_readout(self, status: DeviceStatus):
-        self.readout_thread = threading.Thread(
-            target=self.read_positions_from_sampler, args=(status,)
-        )
-        self.readout_thread.start()
-
-    def kickoff(self) -> DeviceStatus:
-        self.shutdown_event.clear()
-        self.scan_done_event.clear()
-        while not self.controller._min_scan_buffer_reached and not self.shutdown_event.wait(0.001):
-            ...
-        self.controller.start_scan()
-        self.shutdown_event.wait(0.1)
-        status = DeviceStatus(self)
-        status.set_finished()
-        return status
-
-    def complete(self) -> DeviceStatus:
-        """Wait until the flyer is done."""
-        if self.scan_done_event.is_set():
-            # if the scan_done_event is already set, we can return a finished status immediately
-            status = DeviceStatus(self)
-            status.set_finished()
-            return status
-        status = DeviceStatus(self)
-        self.start_readout(status)
-        status.add_callback(lambda *args, **kwargs: self.scan_done_event.set())
-        return status
-
-    def stop(self, *, success=False):
-        self.shutdown_event.set()
-        self.scan_done_event.set()
-        if self.readout_thread is not None:
-            self.readout_thread.join()
-        return super().stop(success=success)
-
-
 if __name__ == "__main__":
     rtcontroller = RtFlomniController(
         socket_cls=SocketIO, socket_host="mpc2844.psi.ch", socket_port=2222, device_manager=None

csaxs_bec/devices/omny/shutter.py

@@ -48,6 +48,7 @@ class OMNYFastShutter(PSIDeviceBase, Device):
     def fshopen(self):
         """Open the fast shutter."""
         if self._check_if_cSAXS_shutter_exists_in_config():
+            self.shutter.put(1)
             return self.device_manager.devices["fsh"].fshopen()
         else:
             self.shutter.put(1)
@@ -55,6 +56,7 @@ class OMNYFastShutter(PSIDeviceBase, Device):
     def fshclose(self):
         """Close the fast shutter."""
         if self._check_if_cSAXS_shutter_exists_in_config():
+            self.shutter.put(0)
             return self.device_manager.devices["fsh"].fshclose()
         else:
             self.shutter.put(0)

csaxs_bec/devices/pseudo_devices/bpm.py

@@ -1,117 +0,0 @@
-import time
-
-from ophyd import Component as Cpt
-from ophyd import Kind, Signal
-from ophyd_devices.interfaces.base_classes.psi_pseudo_device_base import PSIPseudoDeviceBase
-from ophyd_devices.utils.bec_processed_signal import BECProcessedSignal
-
-
-class BPM(PSIPseudoDeviceBase):
-    """BPM positioner pseudo device."""
-
-    # Blade signals, a,b,c,d
-    top = Cpt(
-        BECProcessedSignal, name="top", model_config=None, kind=Kind.config, doc="... top blade"
-    )
-    right = Cpt(
-        BECProcessedSignal, name="right", model_config=None, kind=Kind.config, doc="... right blade"
-    )
-    bot = Cpt(
-        BECProcessedSignal, name="bot", model_config=None, kind=Kind.config, doc="... bot blade"
-    )
-    left = Cpt(
-        BECProcessedSignal, name="left", model_config=None, kind=Kind.config, doc="... left blade"
-    )
-
-    # Virtual signals
-    pos_x = Cpt(
-        BECProcessedSignal, name="pos_x", model_config=None, kind=Kind.config, doc="... pos_x"
-    )
-    pos_y = Cpt(
-        BECProcessedSignal, name="pos_y", model_config=None, kind=Kind.config, doc="... pos_y"
-    )
-    diagonal = Cpt(
-        BECProcessedSignal, name="diagonal", model_config=None, kind=Kind.config, doc="... diagonal"
-    )
-    intensity = Cpt(
-        BECProcessedSignal,
-        name="intensity",
-        model_config=None,
-        kind=Kind.config,
-        doc="... intensity",
-    )
-
-    def __init__(
-        self,
-        name,
-        blade_t: str,
-        blade_r: str,
-        blade_b: str,
-        blade_l: str,
-        device_manager=None,
-        **kwargs,
-    ):
-        super().__init__(name=name, device_manager=device_manager, **kwargs)
-        # Get all blade signal objects from utility method
-        signal_t = self.top.get_device_object_from_bec(
-            object_name=blade_t, signal_name=self.name, device_manager=device_manager
-        )
-        signal_r = self.right.get_device_object_from_bec(
-            object_name=blade_r, signal_name=self.name, device_manager=device_manager
-        )
-        signal_b = self.bot.get_device_object_from_bec(
-            object_name=blade_b, signal_name=self.name, device_manager=device_manager
-        )
-        signal_l = self.left.get_device_object_from_bec(
-            object_name=blade_l, signal_name=self.name, device_manager=device_manager
-        )
-
-        # Set compute methods for blade signals and virtual signals
-        self.top.set_compute_method(self._compute_blade_signal, signal=signal_t)
-        self.right.set_compute_method(self._compute_blade_signal, signal=signal_r)
-        self.bot.set_compute_method(self._compute_blade_signal, signal=signal_b)
-        self.left.set_compute_method(self._compute_blade_signal, signal=signal_l)
-
-        self.intensity.set_compute_method(
-            self._compute_intensity, top=self.top, right=self.right, bot=self.bot, left=self.left
-        )
-        self.pos_x.set_compute_method(
-            self._compute_pos_x, left=self.left, top=self.top, right=self.right, bot=self.bot
-        )
-        self.pos_y.set_compute_method(
-            self._compute_pos_y, left=self.left, top=self.top, right=self.right, bot=self.bot
-        )
-        self.diagonal.set_compute_method(
-            self._compute_diagonal, left=self.left, top=self.top, right=self.right, bot=self.bot
-        )
-
-    def _compute_blade_signal(self, signal: Signal) -> float:
-        return signal.get()
-
-    def _compute_intensity(self, top: Signal, right: Signal, bot: Signal, left: Signal) -> float:
-        intensity = top.get() + right.get() + bot.get() + left.get()
-        return intensity
-
-    def _compute_pos_x(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
-        sum_left = left.get() + top.get()
-        sum_right = right.get() + bot.get()
-        sum_total = sum_left + sum_right
-        if sum_total == 0:
-            return 0.0
-        return (sum_left - sum_right) / sum_total
-
-    def _compute_pos_y(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
-        sum_top = top.get() + right.get()
-        sum_bot = bot.get() + left.get()
-        sum_total = sum_top + sum_bot
-        if sum_total == 0:
-            return 0.0
-        return (sum_top - sum_bot) / sum_total
-
-    def _compute_diagonal(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
-        sum_diag1 = left.get() + right.get()
-        sum_diag2 = top.get() + bot.get()
-        sum_total = sum_diag1 + sum_diag2
-        if sum_total == 0:
-            return 0.0
-        return (sum_diag1 - sum_diag2) / sum_total

csaxs_bec/devices/pseudo_devices/dlpca200_settings.py

@@ -1 +0,0 @@
-# from ophyd 

csaxs_bec/scans/flomni_fermat_scan.py

@@ -27,19 +27,20 @@ from bec_lib import bec_logger, messages
 from bec_lib.alarm_handler import Alarms
 from bec_lib.endpoints import MessageEndpoints
 from bec_server.scan_server.errors import ScanAbortion
-from bec_server.scan_server.scans import AsyncFlyScanBase
+from bec_server.scan_server.scans import SyncFlyScanBase
 
 from csaxs_bec.devices.epics.delay_generator_csaxs.delay_generator_csaxs import TRIGGERSOURCE
 
 logger = bec_logger.logger
 
 
-class FlomniFermatScan(AsyncFlyScanBase):
+class FlomniFermatScan(SyncFlyScanBase):
     scan_name = "flomni_fermat_scan"
     scan_type = "fly"
     required_kwargs = ["fovx", "fovy", "exp_time", "step", "angle"]
     arg_input = {}
     arg_bundle_size = {"bundle": len(arg_input), "min": None, "max": None}
+    use_scan_progress_report = True
 
     def __init__(
         self,
@@ -103,14 +104,6 @@ class FlomniFermatScan(AsyncFlyScanBase):
             self.zshift = -100
         self.flomni_rotation_status = None
 
-    def scan_report_instructions(self):
-        """Scan report instructions for the progress bar"""
-        yield from self.stubs.scan_report_instruction({"device_progress": ["rt_flyer"]})
-
-    @property
-    def monitor_sync(self) -> str:
-        return "rt_flyer"
-
     def initialize(self):
         self.scan_motors = []
         self.update_readout_priority()
@@ -120,6 +113,10 @@ class FlomniFermatScan(AsyncFlyScanBase):
             self.positions, corridor_size=self.optim_trajectory_corridor
         )
 
+    @property
+    def monitor_sync(self):
+        return "rt_flomni"
+
     def reverse_trajectory(self):
         """
         Reverse the trajectory. Every other scan should be reversed to
@@ -293,18 +290,26 @@ class FlomniFermatScan(AsyncFlyScanBase):
         return np.array(positions)
 
     def scan_core(self):
-        # send off the flyer
-        yield from self.stubs.kickoff(device="rt_flyer")
+        # use a device message to receive the scan number and
+        # scan ID before sending the message to the device server
+        yield from self.stubs.kickoff(device="rtx")
+        while True:
+            yield from self.stubs.read(group="monitored")
+            status = self.connector.get(MessageEndpoints.device_status("rt_scan"))
+            if status:
+                status_id = status.content.get("status", 1)
+                request_id = status.metadata.get("RID")
+                if status_id == 0 and self.metadata.get("RID") == request_id:
+                    break
+                if status_id == 2 and self.metadata.get("RID") == request_id:
+                    raise ScanAbortion(
+                        "An error occured during the flomni readout:"
+                        f" {status.metadata.get('error')}"
+                    )
 
-        # start the readout loop of the flyer
-        status = yield from self.stubs.complete(device="rt_flyer", wait=False)
-
-        # read the monitors until the flyer is done
-        while not status.done:
-            yield from self.stubs.read(group="monitored", point_id=self.point_id)
-            self.point_id += 1
             time.sleep(1)
             logger.debug("reading monitors")
+        # yield from self.device_rpc("rtx", "controller.kickoff")
 
     def move_to_start(self):
         """return to the start position"""
@@ -331,7 +336,6 @@ class FlomniFermatScan(AsyncFlyScanBase):
         yield from self.read_scan_motors()
         self.prepare_positions()
         yield from self._prepare_setup()
-        yield from self.scan_report_instructions()
         yield from self.open_scan()
         yield from self.stage()
         yield from self.run_baseline_reading()

tests/tests_devices/test_mcs_card.py

@@ -217,16 +217,6 @@ def test_mcs_card_csaxs_complete_and_stop(mock_mcs_csaxs: MCSCardCSAXS):
     assert not mcs._start_monitor_async_data_emission.is_set()
 
 
-def test_mcs_on_stop(mock_mcs_csaxs: MCSCardCSAXS):
-    """Test that on stop sets the omit_mca_callbacks flag. Also test that on stage clears the omit_mca_callbacks flag."""
-    mcs = mock_mcs_csaxs
-    assert mcs._omit_mca_callbacks.is_set() is False
-    mcs.stop()
-    assert mcs._omit_mca_callbacks.is_set() is True
-    mcs.stage()
-    assert mcs._omit_mca_callbacks.is_set() is False
-
-
 def test_mcs_recovery(mock_mcs_csaxs: MCSCardCSAXS):
     mcs = mock_mcs_csaxs
     # Simulate ongoing acquisition