feat(allied-vision-camera): Add allied vision camera integration

csaxs_bec/bec_ipython_client/startup/post_startup.py

@@ -61,3 +61,25 @@ bec._beamline_mixin._bl_info_register(OperatorInfo)
 # SETUP PROMPTS
 bec._ip.prompts.session_name = _session_name
 bec._ip.prompts.status = 1
+
+# REGISTER BEAMLINE CHECKS
+from bec_lib.bl_conditions import (
+    FastOrbitFeedbackCondition,
+    LightAvailableCondition,
+    ShutterCondition,
+)
+
+if "sls_machine_status" in dev:
+    print("Registering light available condition for SLS machine status")
+    _light_available_condition = LightAvailableCondition(dev.sls_machine_status)
+    bec.bl_checks.register(_light_available_condition)
+
+if "x12sa_es1_shutter_status" in dev:
+    print("Registering shutter condition for X12SA ES1 shutter status")
+    _shutter_condition = ShutterCondition(dev.x12sa_es1_shutter_status)
+    bec.bl_checks.register(_shutter_condition)
+
+# if hasattr(dev, "sls_fast_orbit_feedback"):
+#     print("Registering fast orbit feedback condition for SLS fast orbit feedback")
+#     _fast_orbit_feedback_condition = FastOrbitFeedbackCondition(dev.sls_fast_orbit_feedback)
+#     bec.bl_checks.register(_fast_orbit_feedback_condition)

csaxs_bec/device_configs/bec_device_config_sastt.yaml

@@ -115,7 +115,7 @@ samy:
   softwareTrigger: false
 micfoc:
   description: Focusing motor of Microscope stage
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES06
     motor_resolution: 0.00125
@@ -133,7 +133,7 @@ micfoc:
   softwareTrigger: false
 owis_samx:
   description: Owis motor stage samx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES01
     motor_resolution: 0.00125
@@ -151,7 +151,7 @@ owis_samx:
   softwareTrigger: false
 owis_samy:
   description: Owis motor stage samx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES02
     motor_resolution: 0.00125
@@ -169,7 +169,7 @@ owis_samy:
   softwareTrigger: false
 rotx:
   description: Rotation stage rotx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES05
     motor_resolution: 0.0025
@@ -190,7 +190,7 @@ rotx:
   softwareTrigger: false
 roty:
   description: Rotation stage rotx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES04
     motor_resolution: 0.0025

csaxs_bec/device_configs/sastt.yaml

@@ -1,96 +0,0 @@
-samx:
-  description: Owis motor stage samx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
-  deviceConfig:
-    prefix: X12SA-ES2-ES01
-    motor_resolution: 0.00125
-    base_velocity: 0.0625
-    velocity: 10
-    backlash_distance: 0.125
-    acceleration: 0.2
-    user_offset_dir: 1
-  deviceTags:
-  - cSAXS
-  - owis_samx
-  onFailure: buffer
-  enabled: true
-  readoutPriority: baseline
-  softwareTrigger: false
-samy:
-  description: Owis motor stage samy
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
-  deviceConfig:
-    prefix: X12SA-ES2-ES02
-    motor_resolution: 0.00125
-    base_velocity: 0.0625
-    velocity: 10
-    backlash_distance: 0.125
-    acceleration: 0.2
-    user_offset_dir: 0
-  deviceTags:
-  - cSAXS
-  - owis_samx
-  onFailure: buffer
-  enabled: true
-  readoutPriority: baseline
-  softwareTrigger: false
-rotx:
-  description: Rotation stage rotx
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
-  deviceConfig:
-    prefix: X12SA-ES2-ES03
-    motor_resolution: 0.0025
-    base_velocity: 0.5
-    velocity: 7.5
-    backlash_distance: 0.25
-    acceleration: 0.2
-    user_offset_dir: 1
-    limits:
-    - -0.1
-    - 0.1
-  deviceTags:
-  - cSAXS
-  - rotx
-  onFailure: buffer
-  enabled: true
-  readoutPriority: baseline
-  softwareTrigger: false
-roty:
-  description: Rotation stage roty
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
-  deviceConfig:
-    prefix: X12SA-ES2-ES04
-    motor_resolution: 0.0025
-    base_velocity: 0.5
-    velocity: 7.5
-    backlash_distance: 0.25
-    acceleration: 0.2
-    user_offset_dir: 0
-    limits:
-    - -0.1
-    - 0.1
-  deviceTags:
-  - cSAXS
-  - roty
-  onFailure: buffer
-  enabled: true
-  readoutPriority: baseline
-  softwareTrigger: false
-micfoc:
-  description: Focusing motor of Microscope stage
-  deviceClass: ophyd_devices.devices.psi_motor.EpicsUserMotorVME
-  deviceConfig:
-    prefix: X12SA-ES2-ES05
-    motor_resolution: 0.00125
-    base_velocity: 0.25
-    velocity: 2.5
-    backlash_distance: 0.125
-    acceleration: 0.4
-    user_offset_dir: 0
-  deviceTags:
-  - cSAXS
-  - micfoc
-  onFailure: buffer
-  enabled: true
-  readoutPriority: baseline
-  softwareTrigger: false

csaxs_bec/devices/epics/allied_vision_camera.py

@@ -0,0 +1,129 @@
+"""Module for the EPICS integration of the AlliedVision Camera via Vimba SDK."""
+
+import threading
+import traceback
+from enum import IntEnum
+
+import numpy as np
+from bec_lib.logger import bec_logger
+from ophyd import Component as Cpt
+from ophyd.areadetector import ADComponent as ADCpt
+from ophyd.areadetector import DetectorBase
+from ophyd_devices import PreviewSignal
+from ophyd_devices.devices.areadetector.cam import VimbaDetectorCam
+from ophyd_devices.devices.areadetector.plugins import ImagePlugin_V35 as ImagePlugin
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+from typeguard import typechecked
+
+logger = bec_logger.logger
+
+
+class ACQUIRE_MODES(IntEnum):
+    """Acquiring enums for Allied Vision Camera"""
+
+    ACQUIRING = 1
+    DONE = 0
+
+
+class AlliedVisionCamera(PSIDeviceBase, DetectorBase):
+    """
+    Epics Area Detector interface for the Allied Vision Alvium G1-507m camera via Vimba SDK.
+    The IOC runs with under the prefix: 'X12SA-GIGECAM-AV1:'.
+    """
+
+    USER_ACCESS = ["start_live_mode", "stop_live_mode"]
+
+    cam = ADCpt(VimbaDetectorCam, "cam1:")
+    image = ADCpt(ImagePlugin, "image1:")
+
+    preview = Cpt(
+        PreviewSignal,
+        name="preview",
+        ndim=2,
+        num_rotation_90=0,
+        doc="Preview signal of the AlliedVision camera.",
+    )
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        prefix: str,
+        poll_rate: int = 5,
+        scan_info=None,
+        device_manager=None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name, prefix=prefix, scan_info=scan_info, device_manager=device_manager, **kwargs
+        )
+        self._poll_thread = threading.Thread(
+            target=self._poll_array_data, daemon=True, name=f"{self.name}_poll_thread"
+        )
+        self._poll_thread_kill_event = threading.Event()
+        self._poll_start_event = threading.Event()
+        if poll_rate > 10:
+            logger.warning(f"Poll rate too high for Camera {self.name}, setting to 10 Hz max.")
+            poll_rate = 10
+        self._poll_rate = poll_rate
+        self._unique_array_id = 0
+        self._pv_timeout = 2.0
+        self.r_lock = threading.RLock()
+        self.image: ImagePlugin
+
+    def start_live_mode(self) -> None:
+        """Start live mode."""
+        if not self._poll_start_event.is_set():
+            self._poll_start_event.set()
+            self.cam.acquire.put(ACQUIRE_MODES.ACQUIRING.value)  # Start acquisition
+        else:
+            logger.info(f"Live mode already started for {self.name}.")
+
+    def stop_live_mode(self) -> None:
+        """Stop live mode."""
+        if self._poll_start_event.is_set():
+            self._poll_start_event.clear()
+            self.cam.acquire.put(ACQUIRE_MODES.DONE.value)  # Stop acquisition
+        else:
+            logger.info(f"Live mode already stopped for {self.name}.")
+
+    def on_connected(self):
+        """Reset the unique array ID on connection."""
+        self.cam.array_counter.set(0).wait(timeout=self._pv_timeout)
+        self.cam.array_callbacks.set(1).wait(timeout=self._pv_timeout)
+        self._poll_thread.start()
+
+    def _poll_array_data(self):
+        """Poll the array data for preview updates."""
+        while not self._poll_thread_kill_event.wait(1 / self._poll_rate):
+            while self._poll_start_event.wait():
+                try:
+                    # First check if there is a new image
+                    if self.image.unique_id.get() != self._unique_array_id:
+                        self._unique_array_id = self.image.unique_id.get()
+                    else:
+                        continue  # No new image, skip update
+                    # Get new image data
+                    value = self.image.array_data.get()
+                    if value is None:
+                        logger.info(f"No image data available for preview of {self.name}")
+                        continue
+
+                    array_size = self.image.array_size.get()
+                    if array_size[0] == 0:  # 2D image, not color image
+                        array_size = array_size[1:]
+                    # Geometry correction for the image
+                    data = np.reshape(value, array_size)
+                    self.preview.put(data)
+                except Exception:  # pylint: disable=broad-except
+                    content = traceback.format_exc()
+                    logger.error(
+                        f"Error while polling array data for preview of {self.name}: {content}"
+                    )
+
+    def on_destroy(self):
+        """Stop the polling thread on destruction."""
+        self._poll_thread_kill_event.set()
+        self._poll_start_event.set()
+        if self._poll_thread.is_alive():
+            self._poll_thread.join(timeout=2)

csaxs_bec/devices/npoint/npoint.py

@@ -412,11 +412,10 @@ class NPointAxis(Device, PositionerBase):
         sign=1,
         socket_cls=SocketIO,
         tolerance: float = 0.05,
-        device_manager=None,
         **kwargs,
     ):
         self.controller = NPointController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.sign = sign

csaxs_bec/devices/omny/galil/fgalil_ophyd.py

@@ -175,7 +175,7 @@ class FlomniGalilMotor(Device, PositionerBase):
         **kwargs,
     ):
         self.controller = FlomniGalilController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
@@ -212,10 +212,6 @@ class FlomniGalilMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())
@@ -346,10 +342,10 @@ class FlomniGalilMotor(Device, PositionerBase):
         Drive an axis to the limit in a specified direction.
 
         Args:
-            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.
+            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.        
         """
         self.controller.drive_axis_to_limit(self.axis_Id_numeric, direction)
-        # now force position read to cache
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 

csaxs_bec/devices/omny/galil/fupr_ophyd.py

@@ -149,7 +149,7 @@ class FuprGalilMotor(Device, PositionerBase):
         **kwargs,
     ):
         self.controller = FuprGalilController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
@@ -185,10 +185,6 @@ class FuprGalilMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())

csaxs_bec/devices/omny/galil/galil_ophyd.py

@@ -59,12 +59,12 @@ class GalilController(Controller):
         "all_axes_referenced",
     ]
 
-    OKBLUE = "\033[94m"
-    OKCYAN = "\033[96m"
-    OKGREEN = "\033[92m"
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
 
     @threadlocked
     def socket_put(self, val: str) -> None:
@@ -115,29 +115,29 @@ class GalilController(Controller):
 
     def axis_is_referenced(self, axis_Id_numeric) -> bool:
         return bool(float(self.socket_put_and_receive(f"MG axisref[{axis_Id_numeric}]").strip()))
-
+    
     def folerr_status(self, axis_Id_numeric) -> bool:
         return bool(float(self.socket_put_and_receive(f"MG folaxerr[{axis_Id_numeric}]").strip()))
 
     def motor_temperature(self, axis_Id_numeric) -> float:
-        # this is only valid for omny. consider moving to ogalil
+        #this is only valid for omny. consider moving to ogalil
         voltage = float(self.socket_put_and_receive(f"MG @AN[{axis_Id_numeric+1}]").strip())
         voltage2 = float(self.socket_put_and_receive(f"MG @AN[{axis_Id_numeric+1}]").strip())
         if voltage2 < voltage:
             voltage = voltage2
         # convert from [-10,10]V to [0,300]degC
-        temperature_degC = round((voltage + 10.0) / 20.0 * 300.0, 1)
+        temperature_degC = round((voltage+10.0) / 20.0 * 300.0, 1)
 
-        # the motors of the parking station have a different offset
-        # the range is reduced, so if at the limit, we show an extreme value
+        #the motors of the parking station have a different offset
+        #the range is reduced, so if at the limit, we show an extreme value
         if self.sock.port == 8082:
-            # controller 2
+            #controller 2
             if axis_Id_numeric == 6:
-                temperature_degC = round((voltage + 10.0 - 11.4) / 20.0 * 300.0, 1)
+                temperature_degC = round((voltage+10.0-11.4) / 20.0 * 300.0, 1)
                 if voltage > 9.9:
                     temperature_degC = 300
             if axis_Id_numeric == 7:
-                temperature_degC = round((voltage + 0.0 - 12) / 20.0 * 300.0, 1)
+                temperature_degC = round((voltage+.0-12) / 20.0 * 300.0, 1)
                 if voltage > 9.9:
                     temperature_degC = 300
         return temperature_degC
@@ -147,15 +147,16 @@ class GalilController(Controller):
         Check if all axes are referenced.
         """
         return bool(float(self.socket_put_and_receive("MG allaxref").strip()))
-
-    def _omny_get_microstep_position(self, axis_Id):
+    
+    def _omny_get_microstep_position(self,axis_Id):
         return float(self.socket_put_and_receive(f"MG _TD{axis_Id}").strip())
-
-    def _omny_get_reference_limit(self, axis_Id):
+    
+    
+    def _omny_get_reference_limit(self,axis_Id):
         get_axis_no = float(self.socket_put_and_receive(f"MG frmmv").strip())
-        if get_axis_no > 0:
+        if(get_axis_no>0):
             reference_is_before = float(self.socket_put_and_receive(f"MG _FL{axis_Id}").strip())
-        elif get_axis_no < 0:
+        elif(get_axis_no<0):
             reference_is_before = float(self.socket_put_and_receive(f"MG _BL{axis_Id}").strip())
         else:
             reference_is_before = 0
@@ -186,11 +187,7 @@ class GalilController(Controller):
         while self.is_axis_moving(None, axis_Id_numeric):
             time.sleep(0.01)
             if verbose:
-                self.device_manager.connector.send_client_info(
-                    f"Current microstep position {self._omny_get_microstep_position(axis_Id):.0f}",
-                    scope="drive axis to limit",
-                    show_asap=True,
-                )
+                self.get_device_manager().connector.send_client_info(f"Current microstep position {self._omny_get_microstep_position(axis_Id):.0f}", scope="drive axis to limit", show_asap=True)
                 time.sleep(0.5)
 
         # check if we actually hit the limit
@@ -204,7 +201,13 @@ class GalilController(Controller):
         else:
             print("Limit reached.")
 
-    def find_reference(self, axis_Id_numeric: int, verbose=0, raise_error=1) -> None:
+    def get_device_manager(self):
+        for axis in self._axis:
+            if hasattr(axis, "device_manager") and axis.device_manager:
+                return axis.device_manager
+        raise BECConfigError("Could not access the device_manager")
+
+    def find_reference(self, axis_Id_numeric: int, verbose=0, raise_error = 1) -> None:
         """
         Find the reference of an axis.
 
@@ -221,11 +224,7 @@ class GalilController(Controller):
         while self.is_axis_moving(None, axis_Id_numeric):
             time.sleep(0.1)
             if verbose:
-                self.device_manager.connector.send_client_info(
-                    f"Current microstep position {self._omny_get_microstep_position(axis_Id):.0f} reference is before {self._omny_get_reference_limit(axis_Id)}",
-                    scope="find axis reference",
-                    show_asap=True,
-                )
+                self.get_device_manager().connector.send_client_info(f"Current microstep position {self._omny_get_microstep_position(axis_Id):.0f} reference is before {self._omny_get_reference_limit(axis_Id)}", scope="find axis reference", show_asap=True)
                 time.sleep(0.5)
 
         if not self.axis_is_referenced(axis_Id_numeric):
@@ -237,6 +236,7 @@ class GalilController(Controller):
             logger.info(f"Successfully found reference of axis {axis_Id_numeric}.")
             print(f"Successfully found reference of axis {axis_Id_numeric}.")
 
+        
     def show_running_threads(self) -> None:
         t = PrettyTable()
         t.title = f"Threads on {self.sock.host}:{self.sock.port}"
@@ -251,7 +251,7 @@ class GalilController(Controller):
 
     def is_motor_on(self, axis_Id) -> bool:
         return not bool(float(self.socket_put_and_receive(f"MG _MO{axis_Id}").strip()))
-
+    
     def get_motor_limit_switch(self, axis_Id) -> list:
         """
         Get the status of the motor limit switches.
@@ -269,7 +269,14 @@ class GalilController(Controller):
     def describe(self) -> None:
         t = PrettyTable()
         t.title = f"{self.__class__.__name__} on {self.sock.host}:{self.sock.port}"
-        field_names = ["Axis", "Name", "Referenced", "Motor On", "Limits", "Position"]
+        field_names = [
+            "Axis",
+            "Name",
+            "Referenced",
+            "Motor On",
+            "Limits",
+            "Position",
+        ]
         # in case of OMNY
         if self.sock.host == "mpc3217.psi.ch":
             field_names.append("Temperature")
@@ -279,7 +286,7 @@ class GalilController(Controller):
             axis = self._axis[ax]
             if axis is not None:
                 if self.sock.host == "mpc3217.psi.ch":
-                    # case of omny. possibly consider moving to ogalil
+                    #case of omny. possibly consider moving to ogalil
                     motor_on = self.is_motor_on(axis.axis_Id)
                     if motor_on == True:
                         motor_on = self.WARNING + "ON" + self.ENDC
@@ -292,7 +299,7 @@ class GalilController(Controller):
                     else:
                         folerr_status = "False"
                     position = axis.readback.read().get(axis.name).get("value")
-                    position = f"{position:.3f}"
+                    position = f'{position:.3f}'
                     t.add_row(
                         [
                             f"{axis.axis_Id_numeric}/{axis.axis_Id}",
@@ -323,6 +330,8 @@ class GalilController(Controller):
         self.show_running_threads()
         self.show_status_other()
 
+
+
     def show_status_other(self) -> None:
         """
         Show additional device-specific status information.
@@ -411,7 +420,7 @@ class GalilSetpointSignal(GalilSignalBase):
             while self.controller.is_thread_active(0):
                 time.sleep(0.1)
 
-            # in the case of lamni, consider moving to lgalil
+            #in the case of lamni, consider moving to lgalil
             if self.parent.axis_Id_numeric == 2 and self.controller.sock.host == "mpc2680.psi.ch":
                 try:
                     rt = self.parent.device_manager.devices[self.parent.rt]

csaxs_bec/devices/omny/galil/lgalil_ophyd.py

@@ -73,7 +73,6 @@ class LamniGalilController(GalilController):
         air_off = bool(self.socket_put_and_receive("MG@OUT[13]"))
         return rt_not_blocked_by_galil and air_off
 
-
 class LamniGalilReadbackSignal(GalilSignalRO):
     @retry_once
     @threadlocked
@@ -100,7 +99,6 @@ class LamniGalilReadbackSignal(GalilSignalRO):
                 logger.warning("Failed to set RT value during readback.")
         return val
 
-
 class LamniGalilMotor(Device, PositionerBase):
     USER_ACCESS = ["controller", "drive_axis_to_limit", "find_reference"]
     readback = Cpt(LamniGalilReadbackSignal, signal_name="readback", kind="hinted")
@@ -134,7 +132,7 @@ class LamniGalilMotor(Device, PositionerBase):
         **kwargs,
     ):
         self.controller = LamniGalilController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
@@ -170,10 +168,6 @@ class LamniGalilMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())
@@ -298,7 +292,7 @@ class LamniGalilMotor(Device, PositionerBase):
         Find the reference of the axis.
         """
         self.controller.find_reference(self.axis_Id_numeric)
-        # now force position read to cache
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 
@@ -307,10 +301,10 @@ class LamniGalilMotor(Device, PositionerBase):
         Drive an axis to the limit in a specified direction.
 
         Args:
-            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.
+            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.        
         """
         self.controller.drive_axis_to_limit(self.axis_Id_numeric, direction)
-        # now force position read to cache
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 

csaxs_bec/devices/omny/galil/ogalil_ophyd.py

@@ -46,7 +46,7 @@ class GalilMotorResolution(GalilSignalRO):
     @threadlocked
     def _socket_get(self):
         if self.controller.sock.port == 8083 and self.parent.axis_Id_numeric == 2:
-            # rotation stage
+        # rotation stage
             return 89565.8666667
         else:
             return 51200
@@ -69,43 +69,37 @@ class OMNYGalilReadbackSignal(GalilSignalRO):
         current_pos = float(self.controller.socket_put_and_receive(f"TP{self.parent.axis_Id}"))
         current_pos *= self.parent.sign
         step_mm = self.parent.motor_resolution.get()
-        # here we introduce an offset of 25 to the rotation axis
-        # when setting a position this is taken into account in the controller
-        # that way we just do tomography from 0 to 180 degrees
+        #here we introduce an offset of 25 to the rotation axis
+        #when setting a position this is taken into account in the controller
+        #that way we just do tomography from 0 to 180 degrees
         if self.parent.axis_Id_numeric == 2 and self.controller.sock.port == 8083:
-            return (current_pos / step_mm) + 25
+            return (current_pos / step_mm)+25
         else:
             return current_pos / step_mm
 
     def read(self):
         self._metadata["timestamp"] = time.time()
         val = super().read()
-
-        # if reading rotation stage angle
+       
+        #if reading rotation stage angle
         if self.parent.axis_Id_numeric == 2 and self.controller.sock.port == 8083:
             current_readback_value = val[self.parent.name]["value"]
-            # print (f"previous rotation angle {self.previous_rotation_angle}, current readback {current_readback_value}.")
+            #print (f"previous rotation angle {self.previous_rotation_angle}, current readback {current_readback_value}.")
 
-            if np.fabs((self.previous_rotation_angle - current_readback_value) > 10):
+            if np.fabs((self.previous_rotation_angle-current_readback_value)>10):
                 message = f"Glitch detected in rotation stage. Previous rotation angle {self.previous_rotation_angle}, current readback {current_readback_value}."
                 print(message)
-                self.parent.device_manager.connector.send_client_info(
-                    message, scope="glitch detector", show_asap=True
-                )
-
+                self.parent.device_manager.connector.send_client_info(message, scope="glitch detector", show_asap=True)
+            
             val = super().read()
             current_readback_value = val[self.parent.name]["value"]
 
-            if np.fabs((self.previous_rotation_angle - current_readback_value) > 10):
+            if np.fabs((self.previous_rotation_angle-current_readback_value)>10):
                 message = f"Glitch detected in rotation stage second read. Previous rotation angle {self.previous_rotation_angle}, current readback {current_readback_value}. Disabling the controller."
                 print(message)
-                self.parent.device_manager.connector.send_client_info(
-                    message, scope="glitch detector", show_asap=True
-                )
-
-                self.parent.device_manager.devices["osamroy"].obj.controller.socket_put_confirmed(
-                    "allaxref=0"
-                )
+                self.parent.device_manager.connector.send_client_info(message, scope="glitch detector", show_asap=True)
+            
+                self.parent.device_manager.devices["osamroy"].obj.controller.socket_put_confirmed("allaxref=0")
                 self.parent.device_manager.devices["osamroy"].obj.enabled = False
 
                 return val
@@ -114,12 +108,13 @@ class OMNYGalilReadbackSignal(GalilSignalRO):
             try:
                 rt = self.parent.device_manager.devices["rtx"]
                 if rt.enabled:
-                    rt.obj.controller.set_rotation_angle(val[self.parent.name]["value"] - 25 + 54)
+                    rt.obj.controller.set_rotation_angle(val[self.parent.name]["value"]-25+54)
             except KeyError:
-                logger.warning("Failed to set RT value during ogalil readback.")
+                logger.warning("Failed to set RT value during ogalil readback.")        
         return val
 
 
+
 class OMNYGalilController(GalilController):
     USER_ACCESS = [
         "describe",
@@ -137,18 +132,18 @@ class OMNYGalilController(GalilController):
         "_ogalil_folerr_not_ignore",
     ]
 
-    OKBLUE = "\033[94m"
-    OKCYAN = "\033[96m"
-    OKGREEN = "\033[92m"
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
-
-    def on(self, timeout: int = 10) -> None:
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    
+    def on(self) -> None:
         """Open a new socket connection to the controller"""
         self._ogalil_switchsocket_switch_all_on()
         time.sleep(0.3)
-        super().on(timeout=timeout)
+        super().on()
 
     def _ogalil_switchsocket(self, number: int, switch: bool):
         # number is socket number ranging from 1 to 4
@@ -190,16 +185,15 @@ class OMNYGalilController(GalilController):
         self.socket_put_confirmed("IgNoFol=1")
         self.socket_put_confirmed("XQ#STOP,1")
 
-    def _ogalil_set_axis_to_pos_wo_reference_search(
-        self, axis_id_numeric, axis_id, pos_mm, motor_resolution, motor_sign
-    ):
+
+    def _ogalil_set_axis_to_pos_wo_reference_search(self, axis_id_numeric, axis_id, pos_mm, motor_resolution, motor_sign):
 
         self.socket_put_confirmed("IgNoFol=1")
 
         # pos_mm = pos_encoder / motor_resolution
         pos_encoder = pos_mm * motor_resolution * motor_sign
-        # print(motor_resolution)
-
+        #print(motor_resolution)
+    
         self.socket_put_confirmed(f"DE{axis_id}={pos_encoder:.0f}")
         self.socket_put_confirmed(f"DP{axis_id}=_TP{axis_id}*ratio[{axis_id_numeric:.0f}]")
 
@@ -209,6 +203,7 @@ class OMNYGalilController(GalilController):
 
         self._ogalil_folerr_not_ignore()
 
+
     def _ogalil_folerr_not_ignore(self):
         self.socket_put_confirmed("IgNoFol=0")
 
@@ -245,18 +240,7 @@ class OMNYGalilController(GalilController):
 
 
 class OMNYGalilMotor(Device, PositionerBase):
-    USER_ACCESS = [
-        "controller",
-        "find_reference",
-        "omny_osamx_to_scan_center",
-        "drive_axis_to_limit",
-        "_ogalil_folerr_reset_and_ignore",
-        "_ogalil_set_axis_to_pos_wo_reference_search",
-        "get_motor_limit_switch",
-        "axis_is_referenced",
-        "get_motor_temperature",
-        "folerr_status",
-    ]
+    USER_ACCESS = ["controller", "find_reference", "omny_osamx_to_scan_center", "drive_axis_to_limit", "_ogalil_folerr_reset_and_ignore", "_ogalil_set_axis_to_pos_wo_reference_search", "get_motor_limit_switch", "axis_is_referenced", "get_motor_temperature", "folerr_status"]
     readback = Cpt(OMNYGalilReadbackSignal, signal_name="readback", kind="hinted")
     user_setpoint = Cpt(GalilSetpointSignal, signal_name="setpoint")
     motor_resolution = Cpt(GalilMotorResolution, signal_name="resolution", kind="config")
@@ -288,7 +272,7 @@ class OMNYGalilMotor(Device, PositionerBase):
         **kwargs,
     ):
         self.controller = OMNYGalilController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
@@ -324,10 +308,6 @@ class OMNYGalilMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())
@@ -453,10 +433,8 @@ class OMNYGalilMotor(Device, PositionerBase):
 
     def _ogalil_set_axis_to_pos_wo_reference_search(self, pos_mm):
         motor_resolution = self.motor_resolution.get()
-        self.controller._ogalil_set_axis_to_pos_wo_reference_search(
-            self.axis_Id_numeric, self.axis_Id, pos_mm, motor_resolution, self.sign
-        )
-        # now force position read to cache
+        self.controller._ogalil_set_axis_to_pos_wo_reference_search(self.axis_Id_numeric, self.axis_Id, pos_mm, motor_resolution, self.sign)
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 
@@ -464,9 +442,9 @@ class OMNYGalilMotor(Device, PositionerBase):
         """
         Find the reference of the axis.
         """
-        verbose = 1
+        verbose=1
         self.controller.find_reference(self.axis_Id_numeric, verbose, raise_error)
-        # now force position read to cache
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 
@@ -475,10 +453,10 @@ class OMNYGalilMotor(Device, PositionerBase):
         Drive an axis to the limit in a specified direction.
 
         Args:
-            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.
+            direction (str): Direction in which the axis should be driven to the limit. Either 'forward' or 'reverse'.        
         """
         self.controller.drive_axis_to_limit(self.axis_Id_numeric, direction, verbose=1)
-        # now force position read to cache
+        #now force position read to cache
         val = self.readback.read()
         self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
 
@@ -509,31 +487,29 @@ class OMNYGalilMotor(Device, PositionerBase):
     def omny_osamx_to_scan_center(self, cenx):
         if self.controller.sock.port == 8082 and self.axis_Id_numeric == 0:
             # get last setpoint
-            osamx = self.device_manager.devices["osamx"]
-            osamx_current_setpoint = osamx.obj.readback.get()
-            omny_samx_in = self._get_user_param_safe("osamx", "in")
-            if np.fabs(osamx_current_setpoint - (omny_samx_in + cenx / 1000)) > 0.025:
-                message = (
-                    f"Moving osamx to scan center. new osamx target {omny_samx_in+cenx/1000:.3f}."
-                )
-                logger.info(message)
+                osamx = self.device_manager.devices["osamx"]
+                osamx_current_setpoint = osamx.obj.readback.get()
+                omny_samx_in = self._get_user_param_safe("osamx","in")
+                if np.fabs(osamx_current_setpoint-(omny_samx_in+cenx/1000)) > 0.025:
+                    message=f"Moving osamx to scan center. new osamx target {omny_samx_in+cenx/1000:.3f}."
+                    logger.info(message)
 
-                osamx.read_only = False
-                # osamx.controller.("osamx", "controller.socket_put_confirmed('axspeed[0]=1000')")
-                osamx.set(omny_samx_in + cenx / 1000)
-                time.sleep(0.1)
-                while osamx.motor_is_moving.get():
-                    time.sleep(0.05)
-                osamx.read_only = True
-                time.sleep(2)
-                rt = self.device_manager.devices["rtx"]
-                if rt.enabled:
-                    rt.obj.controller.laser_tracker_on()
-                    rt.obj.controller.laser_tracker_check_and_wait_for_signalstrength()
+                    osamx.read_only = False
+                    #osamx.controller.("osamx", "controller.socket_put_confirmed('axspeed[0]=1000')")
+                    osamx.set(omny_samx_in+cenx/1000)
+                    time.sleep(0.1)
+                    while(osamx.motor_is_moving.get()):
+                        time.sleep(0.05)
+                    osamx.read_only = True
+                    time.sleep(2)
+                    rt = self.device_manager.devices["rtx"]
+                    if rt.enabled:
+                        rt.obj.controller.laser_tracker_on()
+                        rt.obj.controller.laser_tracker_check_and_wait_for_signalstrength()
 
     def folerr_status(self) -> bool:
         return self.controller.folerr_status(self.axis_Id_numeric)
-
+    
     def stop(self, *, success=False):
         self.controller.stop_all_axes()
         return super().stop(success=success)

csaxs_bec/devices/omny/galil/sgalil_ophyd.py

@@ -52,12 +52,33 @@ class GalilController(Controller):
         "fly_grid_scan",
         "read_encoder_position",
     ]
-    _axes_per_controller = 8
 
-    def on(self, timeout: int = 10) -> None:
+    def __init__(
+        self,
+        *,
+        name="GalilController",
+        kind=None,
+        parent=None,
+        socket=None,
+        attr_name="",
+        labels=None,
+    ):
+        if not hasattr(self, "_initialized") or not self._initialized:
+            self._galil_axis_per_controller = 8
+            self._axis = [None for axis_num in range(self._galil_axis_per_controller)]
+            super().__init__(
+                name=name,
+                socket=socket,
+                attr_name=attr_name,
+                parent=parent,
+                labels=labels,
+                kind=kind,
+            )
+
+    def on(self, controller_num=0) -> None:
         """Open a new socket connection to the controller"""
         if not self.connected:
-            self.sock.open(timeout=timeout)
+            self.sock.open()
             self.connected = True
         else:
             logger.info("The connection has already been established.")
@@ -144,11 +165,11 @@ class GalilController(Controller):
     def show_running_threads(self) -> None:
         t = PrettyTable()
         t.title = f"Threads on {self.sock.host}:{self.sock.port}"
-        t.field_names = [str(ax) for ax in range(self._axes_per_controller)]
+        t.field_names = [str(ax) for ax in range(self._galil_axis_per_controller)]
         t.add_row(
             [
                 "active" if self.is_thread_active(t) else "inactive"
-                for t in range(self._axes_per_controller)
+                for t in range(self._galil_axis_per_controller)
             ]
         )
         print(t)
@@ -178,7 +199,7 @@ class GalilController(Controller):
             "Limits",
             "Position",
         ]
-        for ax in range(self._axes_per_controller):
+        for ax in range(self._galil_axis_per_controller):
             axis = self._axis[ax]
             if axis is not None:
                 t.add_row(
@@ -495,9 +516,7 @@ class SGalilMotor(Device, PositionerBase):
     ):
         self.axis_Id = axis_Id
         self.sign = sign
-        self.controller = GalilController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
-        )
+        self.controller = GalilController(socket=socket_cls(host=host, port=port))
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
         self.tolerance = kwargs.pop("tolerance", 0.5)
         self.device_mapping = kwargs.pop("device_mapping", {})
@@ -530,10 +549,6 @@ class SGalilMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())

csaxs_bec/devices/omny/rt/rt_flomni_ophyd.py

@@ -57,7 +57,6 @@ class RtFlomniController(Controller):
         socket_cls=None,
         socket_host=None,
         socket_port=None,
-        device_manager=None,
         attr_name="",
         parent=None,
         labels=None,
@@ -68,7 +67,6 @@ class RtFlomniController(Controller):
             socket_cls=socket_cls,
             socket_host=socket_host,
             socket_port=socket_port,
-            device_manager=device_manager,
             attr_name=attr_name,
             parent=parent,
             labels=labels,
@@ -128,15 +126,15 @@ class RtFlomniController(Controller):
         while not self.slew_rate_limiters_on_target() or np.abs(self.pid_y()) > 0.1:
             time.sleep(0.05)
 
-        self.device_manager.devices.rty.update_user_parameter({"tomo_additional_offsety": 0})
+        self.get_device_manager().devices.rty.update_user_parameter({"tomo_additional_offsety": 0})
         self.clear_trajectory_generator()
 
         self.laser_tracker_on()
 
         # move to 0. FUPR will set the rotation angle during readout
-        self.device_manager.devices.fsamroy.obj.move(0, wait=True)
+        self.get_device_manager().devices.fsamroy.obj.move(0, wait=True)
 
-        fsamx = self.device_manager.devices.fsamx
+        fsamx = self.get_device_manager().devices.fsamx
 
         fsamx.obj.pid_x_correction = 0
         fsamx.obj.controller.socket_put_confirmed("axspeed[4]=0.1*stppermm[4]")
@@ -166,18 +164,18 @@ class RtFlomniController(Controller):
         self.show_cyclic_error_compensation()
 
         self.rt_pid_voltage = self.get_pid_x()
-        rtx = self.device_manager.devices.rtx
+        rtx = self.get_device_manager().devices.rtx
         rtx.update_user_parameter({"rt_pid_voltage": self.rt_pid_voltage})
 
-        self.set_device_read_write("fsamx", False)
-        self.set_device_read_write("fsamy", False)
-        self.set_device_read_write("foptx", False)
-        self.set_device_read_write("fopty", False)
+        self.set_device_enabled("fsamx", False)
+        self.set_device_enabled("fsamy", False)
+        self.set_device_enabled("foptx", False)
+        self.set_device_enabled("fopty", False)
 
     def move_samx_to_scan_region(self, fovx: float, cenx: float):
         time.sleep(0.05)
         if self.rt_pid_voltage is None:
-            rtx = self.device_manager.devices.rtx
+            rtx = self.get_device_manager().devices.rtx
             self.rt_pid_voltage = rtx.user_parameter.get("rt_pid_voltage")
             if self.rt_pid_voltage is None:
                 raise RtError(
@@ -194,7 +192,7 @@ class RtFlomniController(Controller):
                 break
             wait_on_exit = True
             self.socket_put("v0")
-            fsamx = self.device_manager.devices.fsamx
+            fsamx = self.get_device_manager().devices.fsamx
             fsamx.read_only = False
             fsamx.obj.controller.socket_put_confirmed("axspeed[4]=0.1*stppermm[4]")
             fsamx.obj.pid_x_correction -= (self.get_pid_x() - expected_voltage) * 0.007
@@ -225,22 +223,22 @@ class RtFlomniController(Controller):
             print("Feedback is not running; likely an error in the interferometer.")
             raise RtError("Feedback is not running; likely an error in the interferometer.")
 
-        self.set_device_read_write("fsamx", False)
-        self.set_device_read_write("fsamy", False)
-        self.set_device_read_write("foptx", False)
-        self.set_device_read_write("fopty", False)
+        self.set_device_enabled("fsamx", False)
+        self.set_device_enabled("fsamy", False)
+        self.set_device_enabled("foptx", False)
+        self.set_device_enabled("fopty", False)
 
     def feedback_disable(self):
         self.clear_trajectory_generator()
         self.move_to_zero()
         self.socket_put("l0")
 
-        self.set_device_read_write("fsamx", True)
-        self.set_device_read_write("fsamy", True)
-        self.set_device_read_write("foptx", True)
-        self.set_device_read_write("fopty", True)
+        self.set_device_enabled("fsamx", True)
+        self.set_device_enabled("fsamy", True)
+        self.set_device_enabled("foptx", True)
+        self.set_device_enabled("fopty", True)
 
-        fsamx = self.device_manager.devices.fsamx
+        fsamx = self.get_device_manager().devices.fsamx
         fsamx.obj.controller.socket_put_confirmed("axspeed[4]=025*stppermm[4]")
         print("rt feedback is now disalbed.")
 
@@ -291,8 +289,12 @@ class RtFlomniController(Controller):
             self.socket_put("T1")
             time.sleep(0.5)
 
-            self.device_manager.devices.ftrackz.obj.controller.socket_put_confirmed("trackyct=0")
-            self.device_manager.devices.ftrackz.obj.controller.socket_put_confirmed("trackzct=0")
+            self.get_device_manager().devices.ftrackz.obj.controller.socket_put_confirmed(
+                "trackyct=0"
+            )
+            self.get_device_manager().devices.ftrackz.obj.controller.socket_put_confirmed(
+                "trackzct=0"
+            )
 
         self.laser_tracker_wait_on_target()
         logger.info("Laser tracker running!")
@@ -339,7 +341,7 @@ class RtFlomniController(Controller):
         }
 
     def laser_tracker_galil_enable(self):
-        ftrackz_con = self.device_manager.devices.ftrackz.obj.controller
+        ftrackz_con = self.get_device_manager().devices.ftrackz.obj.controller
         ftrackz_con.socket_put_confirmed("tracken=1")
         ftrackz_con.socket_put_confirmed("trackyct=0")
         ftrackz_con.socket_put_confirmed("trackzct=0")
@@ -387,7 +389,7 @@ class RtFlomniController(Controller):
             self.laser_tracker_wait_on_target()
 
             signal = self.read_ssi_interferometer(1)
-            rtx = self.device_manager.devices.rtx
+            rtx = self.get_device_manager().devices.rtx
             min_signal = rtx.user_parameter.get("min_signal")
             low_signal = rtx.user_parameter.get("low_signal")
             print(f"low signal: {low_signal}")
@@ -476,6 +478,12 @@ class RtFlomniController(Controller):
         current_position_in_scan = int(float(return_table[2]))
         return (mode, number_of_positions_planned, current_position_in_scan)
 
+    def get_device_manager(self):
+        for axis in self._axis:
+            if hasattr(axis, "device_manager") and axis.device_manager:
+                return axis.device_manager
+        raise BECConfigError("Could not access the device_manager")
+
     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
@@ -490,7 +498,7 @@ class RtFlomniController(Controller):
 
         # if not (mode==2 or mode==3):
         #    error
-        self.device_manager.connector.set(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=1, metadata=self.readout_metadata
@@ -525,7 +533,7 @@ class RtFlomniController(Controller):
             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(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=0, metadata=self.readout_metadata
@@ -539,7 +547,7 @@ class RtFlomniController(Controller):
         )
 
     def publish_device_data(self, signals, point_id):
-        self.device_manager.connector.set_and_publish(
+        self.get_device_manager().connector.set_and_publish(
             MessageEndpoints.device_read("rt_flomni"),
             messages.DeviceMessage(
                 signals=signals, metadata={"point_id": point_id, **self.readout_metadata}
@@ -650,7 +658,7 @@ class RtFlomniMotor(Device, PositionerBase):
         self.axis_Id = axis_Id
         self.sign = sign
         self.controller = RtFlomniController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
         self.device_manager = device_manager
@@ -678,10 +686,6 @@ class RtFlomniMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())
@@ -809,7 +813,7 @@ class RtFlomniMotor(Device, PositionerBase):
 
 if __name__ == "__main__":
     rtcontroller = RtFlomniController(
-        socket_cls=SocketIO, socket_host="mpc2844.psi.ch", socket_port=2222, device_manager=None
+        socket_cls=SocketIO, socket_host="mpc2844.psi.ch", socket_port=2222
     )
     rtcontroller.on()
     rtcontroller.laser_tracker_on()

csaxs_bec/devices/omny/rt/rt_lamni_ophyd.py

@@ -71,7 +71,6 @@ class RtLamniController(Controller):
         socket_cls=None,
         socket_host=None,
         socket_port=None,
-        device_manager=None,
         attr_name="",
         parent=None,
         labels=None,
@@ -82,7 +81,6 @@ class RtLamniController(Controller):
             socket_cls=socket_cls,
             socket_host=socket_host,
             socket_port=socket_port,
-            device_manager=device_manager,
             attr_name=attr_name,
             parent=parent,
             labels=labels,
@@ -94,11 +92,11 @@ class RtLamniController(Controller):
     def feedback_disable(self):
         self.socket_put("J0")
         logger.info("LamNI Feedback disabled.")
-        self.set_device_read_write("lsamx", True)
-        self.set_device_read_write("lsamy", True)
-        self.set_device_read_write("loptx", True)
-        self.set_device_read_write("lopty", True)
-        self.set_device_read_write("loptz", True)
+        self.set_device_enabled("lsamx", True)
+        self.set_device_enabled("lsamy", True)
+        self.set_device_enabled("loptx", True)
+        self.set_device_enabled("lopty", True)
+        self.set_device_enabled("loptz", True)
 
     def is_axis_moving(self, axis_Id) -> bool:
         # this checks that axis is on target
@@ -152,25 +150,25 @@ class RtLamniController(Controller):
         # set these as closed loop target position
         self.socket_put(f"pa0,{x_curr:.4f}")
         self.socket_put(f"pa1,{y_curr:.4f}")
-        self.device_manager.devices.rtx.obj.user_setpoint.set_with_feedback_disabled(x_curr)
-        self.device_manager.devices.rty.obj.user_setpoint.set_with_feedback_disabled(y_curr)
+        self.get_device_manager().devices.rtx.obj.user_setpoint.set_with_feedback_disabled(x_curr)
+        self.get_device_manager().devices.rty.obj.user_setpoint.set_with_feedback_disabled(y_curr)
         self.socket_put("J5")
         logger.info("LamNI Feedback enabled (without reset).")
-        self.set_device_read_write("lsamx", False)
-        self.set_device_read_write("lsamy", False)
-        self.set_device_read_write("loptx", False)
-        self.set_device_read_write("lopty", False)
-        self.set_device_read_write("loptz", False)
+        self.set_device_enabled("lsamx", False)
+        self.set_device_enabled("lsamy", False)
+        self.set_device_enabled("loptx", False)
+        self.set_device_enabled("lopty", False)
+        self.set_device_enabled("loptz", False)
 
     @threadlocked
     def feedback_disable_and_even_reset_lamni_angle_interferometer(self):
         self.socket_put("J6")
         logger.info("LamNI Feedback disabled including the angular interferometer.")
-        self.set_device_read_write("lsamx", True)
-        self.set_device_read_write("lsamy", True)
-        self.set_device_read_write("loptx", True)
-        self.set_device_read_write("lopty", True)
-        self.set_device_read_write("loptz", True)
+        self.set_device_enabled("lsamx", True)
+        self.set_device_enabled("lsamy", True)
+        self.set_device_enabled("loptx", True)
+        self.set_device_enabled("lopty", True)
+        self.set_device_enabled("loptz", True)
 
     @threadlocked
     def clear_trajectory_generator(self):
@@ -286,7 +284,7 @@ class RtLamniController(Controller):
 
         # if not (mode==2 or mode==3):
         #    error
-        self.device_manager.connector.set(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=1, metadata=self.readout_metadata
@@ -321,7 +319,7 @@ class RtLamniController(Controller):
             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(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=0, metadata=self.readout_metadata
@@ -333,7 +331,7 @@ class RtLamniController(Controller):
         )
 
     def publish_device_data(self, signals, point_id):
-        self.device_manager.connector.set_and_publish(
+        self.get_device_manager().connector.set_and_publish(
             MessageEndpoints.device_read("rt_lamni"),
             messages.DeviceMessage(
                 signals=signals, metadata={"point_id": point_id, **self.readout_metadata}
@@ -368,10 +366,10 @@ class RtLamniController(Controller):
         )  # we set all three outputs of the traj. gen. although in LamNI case only 0,1 are used
         self.clear_trajectory_generator()
 
-        self.device_manager.devices.lsamrot.obj.move(0, wait=True)
+        self.get_device_manager().devices.lsamrot.obj.move(0, wait=True)
 
         galil_controller_rt_status = (
-            self.device_manager.devices.lsamx.obj.controller.lgalil_is_air_off_and_orchestra_enabled()
+            self.get_device_manager().devices.lsamx.obj.controller.lgalil_is_air_off_and_orchestra_enabled()
         )
 
         if galil_controller_rt_status == 0:
@@ -384,16 +382,16 @@ class RtLamniController(Controller):
 
         time.sleep(0.03)
 
-        lsamx_user_params = self.device_manager.devices.lsamx.user_parameter
+        lsamx_user_params = self.get_device_manager().devices.lsamx.user_parameter
         if lsamx_user_params is None or lsamx_user_params.get("center") is None:
             raise RuntimeError("lsamx center is not defined")
-        lsamy_user_params = self.device_manager.devices.lsamy.user_parameter
+        lsamy_user_params = self.get_device_manager().devices.lsamy.user_parameter
         if lsamy_user_params is None or lsamy_user_params.get("center") is None:
             raise RuntimeError("lsamy center is not defined")
         lsamx_center = lsamx_user_params.get("center")
         lsamy_center = lsamy_user_params.get("center")
-        self.device_manager.devices.lsamx.obj.move(lsamx_center, wait=True)
-        self.device_manager.devices.lsamy.obj.move(lsamy_center, wait=True)
+        self.get_device_manager().devices.lsamx.obj.move(lsamx_center, wait=True)
+        self.get_device_manager().devices.lsamy.obj.move(lsamy_center, wait=True)
         self.socket_put("J1")
 
         _waitforfeedbackctr = 0
@@ -407,11 +405,11 @@ class RtLamniController(Controller):
                 (self.socket_put_and_receive("J2")).split(",")[0]
             )
 
-        self.set_device_read_write("lsamx", False)
-        self.set_device_read_write("lsamy", False)
-        self.set_device_read_write("loptx", False)
-        self.set_device_read_write("lopty", False)
-        self.set_device_read_write("loptz", False)
+        self.set_device_enabled("lsamx", False)
+        self.set_device_enabled("lsamy", False)
+        self.set_device_enabled("loptx", False)
+        self.set_device_enabled("lopty", False)
+        self.set_device_enabled("loptz", False)
 
         if interferometer_feedback_not_running == 1:
             logger.error(
@@ -561,7 +559,7 @@ class RtLamniMotor(Device, PositionerBase):
         self.axis_Id = axis_Id
         self.sign = sign
         self.controller = RtLamniController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
         self.device_manager = device_manager
@@ -588,10 +586,6 @@ class RtLamniMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())

csaxs_bec/devices/omny/rt/rt_omny_ophyd.py

@@ -1,8 +1,8 @@
-import builtins
-import socket
 import threading
 import time
 from typing import List
+import builtins
+import socket
 
 import numpy as np
 from bec_lib import bec_logger, messages
@@ -34,15 +34,12 @@ from csaxs_bec.devices.omny.rt.rt_ophyd import (
 
 logger = bec_logger.logger
 
-
 class RtOMNY_mirror_switchbox_Error(Exception):
     pass
 
-
 class RtOMNY_Error(Exception):
     pass
 
-
 class RtOMNYController(Controller):
     _axes_per_controller = 3
     red = "\x1b[91m"
@@ -90,7 +87,6 @@ class RtOMNYController(Controller):
         socket_cls=None,
         socket_host=None,
         socket_port=None,
-        device_manager=None,
         attr_name="",
         parent=None,
         labels=None,
@@ -101,7 +97,6 @@ class RtOMNYController(Controller):
             socket_cls=socket_cls,
             socket_host=socket_host,
             socket_port=socket_port,
-            device_manager=device_manager,
             attr_name=attr_name,
             parent=parent,
             labels=labels,
@@ -239,7 +234,7 @@ class RtOMNYController(Controller):
                 "opt_amplitude1_neg": 3000,
                 "opt_amplitude2_pos": 3000,
                 "opt_amplitude2_neg": 3000,
-            },
+            }
         }
 
     # def is_axis_moving(self, axis_Id) -> bool:
@@ -266,60 +261,42 @@ class RtOMNYController(Controller):
 
         threading.Thread(target=send_positions, args=(self, positions), daemon=True).start()
 
-    def get_mirror_parameters(self, channel):
+    def get_mirror_parameters(self,channel):
         return self.mirror_parameters[channel]
+    
 
     def laser_tracker_check_and_wait_for_signalstrength(self):
-        self.device_manager.connector.send_client_info(
-            "Checking laser tracker...", scope="", show_asap=True
-        )
+        self.get_device_manager().connector.send_client_info("Checking laser tracker...", scope="", show_asap=True)
         if not self.laser_tracker_check_enabled():
-            print(
-                "laser_tracker_check_and_wait_for_signalstrength: The laser tracker is not even enabled."
-            )
+            print("laser_tracker_check_and_wait_for_signalstrength: The laser tracker is not even enabled.")
             return
-        # first check on target
+        #first check on target
         self.laser_tracker_wait_on_target()
-        # when on target, check interferometer signal
-        signal = self._omny_interferometer_get_signalsample("ssi_4", 0.1)
-        rtx = self.device_manager.devices.rtx
+        #when on target, check interferometer signal
+        signal = self._omny_interferometer_get_signalsample("ssi_4",0.1)
+        rtx = self.get_device_manager().devices.rtx
         min_signal = rtx.user_parameter.get("min_signal")
         low_signal = rtx.user_parameter.get("low_signal")
         wait_counter = 0
-        while signal < min_signal and wait_counter < 10:
-            self.device_manager.connector.send_client_info(
-                f"The signal of the tracker {signal} is below the minimum required signal of {min_signal}. Waiting...",
-                scope="laser_tracker_check_and_wait_for_signalstrength",
-                show_asap=True,
-            )
+        while signal < min_signal and wait_counter<10:
+            self.get_device_manager().connector.send_client_info(f"The signal of the tracker {signal} is below the minimum required signal of {min_signal}. Waiting...", scope="laser_tracker_check_and_wait_for_signalstrength", show_asap=True)
 
-            wait_counter += 1
+            wait_counter+=1
             time.sleep(0.2)
-            signal = self._omny_interferometer_get_signalsample("ssi_4", 0.1)
+            signal = self._omny_interferometer_get_signalsample("ssi_4",0.1)
 
         if signal < low_signal:
-            self.device_manager.connector.send_client_info(
-                f"\x1b[91mThe signal of the tracker {signal} is below the low limit of {low_signal}. Auto readjustment...\x1b[0m",
-                scope="laser_tracker_check_and_wait_for_signalstrength",
-                show_asap=True,
-            )
+            self.get_device_manager().connector.send_client_info(f"\x1b[91mThe signal of the tracker {signal} is below the low limit of {low_signal}. Auto readjustment...\x1b[0m", scope="laser_tracker_check_and_wait_for_signalstrength", show_asap=True)
 
-            self.omny_interferometer_align_tracking()
-        self.device_manager.connector.send_client_info(
-            "Checking laser tracker completed.", scope="", show_asap=True
-        )
+            self.omny_interferometer_align_tracking() 
+        self.get_device_manager().connector.send_client_info("Checking laser tracker completed.", scope="", show_asap=True)
 
     def omny_interferometer_align_tracking(self):
-        mirror_channel = 6
-        signal = self._omny_interferometer_get_signalsample(
-            self.mirror_parameters[mirror_channel]["opt_signalchannel"],
-            self.mirror_parameters[mirror_channel]["opt_averaging_time"],
-        )
+        mirror_channel=6
+        signal = self._omny_interferometer_get_signalsample(self.mirror_parameters[mirror_channel]["opt_signalchannel"], self.mirror_parameters[mirror_channel]["opt_averaging_time"])
 
         if signal > self.mirror_parameters[mirror_channel]["opt_signal_stop"]:
-            print(
-                f"Interferometer signal of axis {self.mirror_parameters[mirror_channel]['opt_mirrorname']} is good, no alignment needed."
-            )
+            print(f"Interferometer signal of axis {self.mirror_parameters[mirror_channel]['opt_mirrorname']} is good, no alignment needed.")
         else:
             self._omny_interferometer_switch_channel(mirror_channel)
             time.sleep(0.1)
@@ -330,19 +307,16 @@ class RtOMNYController(Controller):
             self._omny_interferometer_switch_alloff()
             self.show_signal_strength_interferometer()
 
-        mirror_channel = -1
+        mirror_channel=-1
+
+
 
     def omny_interferometer_align_incoupling_angle(self):
-        mirror_channel = 1
-        signal = self._omny_interferometer_get_signalsample(
-            self.mirror_parameters[mirror_channel]["opt_signalchannel"],
-            self.mirror_parameters[mirror_channel]["opt_averaging_time"],
-        )
+        mirror_channel=1
+        signal = self._omny_interferometer_get_signalsample(self.mirror_parameters[mirror_channel]["opt_signalchannel"], self.mirror_parameters[mirror_channel]["opt_averaging_time"])
 
         if signal > self.mirror_parameters[mirror_channel]["opt_signal_stop"]:
-            print(
-                f"Interferometer signal of axis {self.mirror_parameters[mirror_channel]['opt_mirrorname']} is good, no alignment needed."
-            )
+            print(f"Interferometer signal of axis {self.mirror_parameters[mirror_channel]['opt_mirrorname']} is good, no alignment needed.")
         else:
             self._omny_interferometer_switch_channel(mirror_channel)
             time.sleep(0.1)
@@ -353,18 +327,19 @@ class RtOMNYController(Controller):
             self._omny_interferometer_switch_alloff()
             self.show_signal_strength_interferometer()
 
-        mirror_channel = -1
+        mirror_channel=-1
+
 
     def _omny_interferometer_openloop_steps(self, channel, steps, amplitude):
-        if channel not in range(3, 5):
+        if channel not in range(3,5):
             raise RtOMNY_Error(f"invalid channel number {channel}.")
 
         if amplitude > 4090:
             amplitude = 4090
         elif amplitude < 10:
             amplitude = 10
-
-        oshield = self.device_manager.devices.oshield
+            
+        oshield = self.get_device_manager().devices.oshield
 
         oshield.obj.controller.move_open_loop_steps(
             channel, steps, amplitude=amplitude, frequency=500
@@ -376,7 +351,7 @@ class RtOMNYController(Controller):
     def _omny_interferometer_optimize(self, mirror_channel, channel):
         if mirror_channel == -1:
             raise RtOMNY_Error("no mirror channel selected")
-        # mirror channel is mirror number and channel is smaract channel, i.e. axis of the mirror
+        #mirror channel is mirror number and channel is smaract channel, i.e. axis of the mirror
         if channel == 3:
             steps_pos = self.mirror_parameters[mirror_channel]["opt_steps1_pos"]
             steps_neg = self.mirror_parameters[mirror_channel]["opt_steps1_neg"]
@@ -390,80 +365,67 @@ class RtOMNYController(Controller):
         else:
             raise RtOMNY_Error(f"invalid channel number {channel}.")
 
-        previous_signal = self._omny_interferometer_get_signalsample(
-            self.mirror_parameters[mirror_channel]["opt_signalchannel"],
-            self.mirror_parameters[mirror_channel]["opt_averaging_time"],
-        )
+        previous_signal = self._omny_interferometer_get_signalsample(self.mirror_parameters[mirror_channel]["opt_signalchannel"], self.mirror_parameters[mirror_channel]["opt_averaging_time"])
 
-        min_begin = self.mirror_parameters[mirror_channel]["opt_signal_min_begin"]
+        min_begin =  self.mirror_parameters[mirror_channel]["opt_signal_min_begin"]
         if previous_signal < min_begin:
-            # raise OMNY_rt_clientError("error1") #(f"Minimum signal of axis {self.mirror_parameters[mirror_channel]["opt_mirrorname"]} to start alignment not present.")
+            #raise OMNY_rt_clientError("error1") #(f"Minimum signal of axis {self.mirror_parameters[mirror_channel]["opt_mirrorname"]} to start alignment not present.")
             print(f"\rMinimum signal for auto alignment {min_begin} not reached.")
             return
         elif previous_signal > self.mirror_parameters[mirror_channel]["opt_signal_stop"]:
-            print(
-                f"\rInterferometer signal of axis is good"
-            )  # {self.mirror_parameters[mirror_channel]["opt_mirrorname"]} is good.")
-            return
+             print(f"\rInterferometer signal of axis is good")  # {self.mirror_parameters[mirror_channel]["opt_mirrorname"]} is good.")
+             return
         else:
             direction = 1
-            cycle_counter = 0
-            cycle_max = 20
-            reversal_counter = 0
-            reversal_max = 4
-            self.mirror_amplitutde_increase = 0
+            cycle_counter=0
+            cycle_max=20
+            reversal_counter=0
+            reversal_max=4
+            self.mirror_amplitutde_increase=0
 
-        current_sample = self._omny_interferometer_get_signalsample(
-            self.mirror_parameters[mirror_channel]["opt_signalchannel"],
-            self.mirror_parameters[mirror_channel]["opt_averaging_time"],
-        )
-        max = current_sample
+        current_sample = self._omny_interferometer_get_signalsample(self.mirror_parameters[mirror_channel]["opt_signalchannel"], self.mirror_parameters[mirror_channel]["opt_averaging_time"])
+        max=current_sample
 
-        while (
-            current_sample < self.mirror_parameters[mirror_channel]["opt_signal_stop"]
-            and cycle_counter < cycle_max
-            and reversal_counter < reversal_max
-        ):
+        while current_sample < self.mirror_parameters[mirror_channel]["opt_signal_stop"] and cycle_counter<cycle_max and reversal_counter < reversal_max:
             # if current_sample < self.mirror_parameters[mirror_channel]["opt_signal_min_begin"]:
             #     raise OMNY_rt_clientError("error2") #(f"Minimum signal of axis {self.mirror_parameters[mirror_channel]["opt_mirrorname"]} to start alignment not present.")
 
-            if direction > 0:
+            if direction>0:
                 self._omny_interferometer_openloop_steps(channel, steps_pos, opt_amplitude_pos)
                 verbose_str = f"channel {channel}, steps {steps_pos}"
             else:
                 self._omny_interferometer_openloop_steps(channel, -steps_neg, opt_amplitude_neg)
                 verbose_str = f"auto action {channel}, steps {-steps_pos}"
-            # print(f"Aligning axis ")   #{self.mirror_parameters[mirror_channel]["opt_mirrorname"]}. Target: {self.mirror_parameters[mirror_channel]["opt_signal_stop"]}, current {current_sample}")
+            #print(f"Aligning axis ")   #{self.mirror_parameters[mirror_channel]["opt_mirrorname"]}. Target: {self.mirror_parameters[mirror_channel]["opt_signal_stop"]}, current {current_sample}")
 
-            current_sample = self._omny_interferometer_get_signalsample(
-                self.mirror_parameters[mirror_channel]["opt_signalchannel"],
-                self.mirror_parameters[mirror_channel]["opt_averaging_time"],
-            )
+            current_sample = self._omny_interferometer_get_signalsample(self.mirror_parameters[mirror_channel]["opt_signalchannel"], self.mirror_parameters[mirror_channel]["opt_averaging_time"])
 
             opt_mirrorname = self.mirror_parameters[mirror_channel]["opt_mirrorname"]
 
             info_str = f"\rAuto aligning Channel {mirror_channel}, {opt_mirrorname}, Current signal: {current_sample:.0f}"
-            message = info_str + "   (q)uit   \r"
-            self.device_manager.connector.send_client_info(
-                message, scope="_omny_interferometer_optimize", show_asap=True
-            )
+            message=info_str +"   (q)uit   \r"
+            self.get_device_manager().connector.send_client_info(message, scope="_omny_interferometer_optimize", show_asap=True)
+
+
+
+            if previous_signal>current_sample:
+                if direction<0:
+                    steps_pos=int(steps_pos/2)
+                    steps_neg=int(steps_neg/2)
+                    if steps_pos<1:
+                        steps_pos=1
+                    if steps_neg<1:
+                        steps_neg=1 	
+                direction=direction*(-1)
+                reversal_counter+=1
+            previous_signal=current_sample
+            cycle_counter+=1
+        
+        print(f"\r\nFinished aligning channel {channel} of mirror {mirror_channel}\n\r")  # {self.mirror_parameters[mirror_channel]["opt_mirrorname"]}.  Target: {self.mirror_parameters[mirror_channel]["opt_signal_stop"]}, current {current_sample}")        
+
+
 
-            if previous_signal > current_sample:
-                if direction < 0:
-                    steps_pos = int(steps_pos / 2)
-                    steps_neg = int(steps_neg / 2)
-                    if steps_pos < 1:
-                        steps_pos = 1
-                    if steps_neg < 1:
-                        steps_neg = 1
-                direction = direction * (-1)
-                reversal_counter += 1
-            previous_signal = current_sample
-            cycle_counter += 1
 
-        print(
-            f"\r\nFinished aligning channel {channel} of mirror {mirror_channel}\n\r"
-        )  # {self.mirror_parameters[mirror_channel]["opt_mirrorname"]}.  Target: {self.mirror_parameters[mirror_channel]["opt_signal_stop"]}, current {current_sample}")
 
     def move_to_zero(self):
         self.socket_put("pa0,0")
@@ -495,7 +457,7 @@ class RtOMNYController(Controller):
         if ret == 1:
             return True
         return False
-
+    
     def feedback_is_running(self) -> bool:
         self.feedback_get_status_and_ssi()
         interferometer_feedback_not_running = int(self.ssi["feedback_error"])
@@ -504,9 +466,7 @@ class RtOMNYController(Controller):
         return True
 
     def feedback_enable_with_reset(self):
-        self.device_manager.connector.send_client_info(
-            f"Enabling the feedback...", scope="", show_asap=True
-        )
+        self.get_device_manager().connector.send_client_info(f"Enabling the feedback...", scope="", show_asap=True)
 
         self.socket_put("J0")  # disable feedback
         time.sleep(0.01)
@@ -525,16 +485,14 @@ class RtOMNYController(Controller):
         self.laser_tracker_on()
         time.sleep(0.01)
 
-        osamroy = self.device_manager.devices.osamroy
+        osamroy = self.get_device_manager().devices.osamroy
         # the following read will also upate the angle in rt during readout
         readback = osamroy.obj.readback.get()
-        if np.fabs(readback) > 0.1:
-            self.device_manager.connector.send_client_info(
-                f"Rotating to zero", scope="feedback enable", show_asap=True
-            )
+        if (np.fabs(readback) > 0.1):
+            self.get_device_manager().connector.send_client_info(f"Rotating to zero", scope="feedback enable", show_asap=True)
             osamroy.obj.move(0, wait=True)
 
-        osamx = self.device_manager.devices.osamx
+        osamx = self.get_device_manager().devices.osamx
 
         osamx_in = osamx.user_parameter.get("in")
         if not np.isclose(osamx.obj.readback.get(), osamx_in, atol=0.01):
@@ -556,15 +514,16 @@ class RtOMNYController(Controller):
 
         time.sleep(1.5)
 
-        self.set_device_read_write("osamx", False)
-        self.set_device_read_write("osamy", False)
-        self.set_device_read_write("ofzpx", False)
-        self.set_device_read_write("ofzpy", False)
-        self.set_device_read_write("oosax", False)
-        self.set_device_read_write("oosax", False)
+        self.set_device_enabled("osamx", False)
+        self.set_device_enabled("osamy", False)
+        self.set_device_enabled("ofzpx", False)
+        self.set_device_enabled("ofzpy", False)
+        self.set_device_enabled("oosax", False)
+        self.set_device_enabled("oosax", False)
 
         print("Feedback is running.")
 
+
     @threadlocked
     def clear_trajectory_generator(self):
         self.socket_put("sc")
@@ -575,15 +534,16 @@ class RtOMNYController(Controller):
         self.move_to_zero()
         self.socket_put("J0")
 
-        self.set_device_read_write("osamx", True)
-        self.set_device_read_write("osamy", True)
-        self.set_device_read_write("ofzpx", True)
-        self.set_device_read_write("ofzpy", True)
-        self.set_device_read_write("oosax", True)
-        self.set_device_read_write("oosax", True)
+        self.set_device_enabled("osamx", True)
+        self.set_device_enabled("osamy", True)
+        self.set_device_enabled("ofzpx", True)
+        self.set_device_enabled("ofzpy", True)
+        self.set_device_enabled("oosax", True)
+        self.set_device_enabled("oosax", True)
 
         print("rt feedback is now disabled.")
 
+
     def set_rotation_angle(self, val: float) -> None:
         self.socket_put(f"a{val/180*np.pi}")
 
@@ -618,13 +578,12 @@ class RtOMNYController(Controller):
             "enabled_z": bool(tracker_values[10]),
         }
 
+
     def laser_tracker_on(self):
-        # update variables and enable if not yet active
+        #update variables and enable if not yet active
         if not self.laser_tracker_check_enabled():
             logger.info("Enabling the laser tracker. Please wait...")
-            self.device_manager.connector.send_client_info(
-                f"Enabling the laser tracker. Please wait...", scope="", show_asap=True
-            )
+            self.get_device_manager().connector.send_client_info(f"Enabling the laser tracker. Please wait...", scope="", show_asap=True)
 
             tracker_intensity = self.tracker_info["tracker_intensity"]
             if (
@@ -639,13 +598,18 @@ class RtOMNYController(Controller):
             self.socket_put("T1")
             time.sleep(0.5)
 
-            self.device_manager.devices.otracky.obj.controller.socket_put_confirmed("trackyct=0")
-            self.device_manager.devices.otracky.obj.controller.socket_put_confirmed("trackzct=0")
+            self.get_device_manager().devices.otracky.obj.controller.socket_put_confirmed(
+                "trackyct=0"
+            )
+            self.get_device_manager().devices.otracky.obj.controller.socket_put_confirmed(
+                "trackzct=0"
+            )
 
         self.laser_tracker_wait_on_target()
         logger.info("Laser tracker running!")
         print("Laser tracker running!")
 
+
     def laser_tracker_check_enabled(self) -> bool:
         self.laser_update_tracker_info()
         if self.tracker_info["enabled_z"] and self.tracker_info["enabled_y"]:
@@ -664,10 +628,11 @@ class RtOMNYController(Controller):
             return True
         return False
 
+
     def laser_tracker_wait_on_target(self):
         max_repeat = 15
         count = 0
-        while not self.laser_tracker_check_on_target() and count < max_repeat:
+        while not self.laser_tracker_check_on_target() and count<max_repeat:
             logger.info("Waiting for laser tracker to reach target position.")
             time.sleep(0.5)
             count += 1
@@ -676,74 +641,75 @@ class RtOMNYController(Controller):
                 raise RtError("Failed to reach laser target position.")
 
     def laser_tracker_print_intensity_for_otrack_tweaking(self):
-        # self.laser_update_tracker_info()
-        # _laser_tracker_intensity = self.tracker_info["tracker_intensity"]
-        # print(f"\r PSD beam intensity:      {_laser_tracker_intensity:.2f}\r")
+        #self.laser_update_tracker_info()
+        #_laser_tracker_intensity = self.tracker_info["tracker_intensity"]
+        #print(f"\r PSD beam intensity:      {_laser_tracker_intensity:.2f}\r")
         self.laser_tracker_show_all(extra_endline="\r")
 
-    def laser_tracker_show_all(self, extra_endline=""):
+    def laser_tracker_show_all(self,extra_endline=""):
         self.laser_update_tracker_info()
         enabled_y = self.tracker_info["enabled_y"]
-        print(extra_endline + f"Tracker enabled:          {bool(enabled_y)}" + extra_endline)
+        print(extra_endline+f"Tracker enabled:          {bool(enabled_y)}"+extra_endline)
         if self.tracker_info["tracker_intensity"] < self.tracker_info["threshold_intensity_y"]:
-            print(self.red + " LOW INTENSITY" + self.white + extra_endline)
+            print(self.red+" LOW INTENSITY"+self.white+extra_endline)
         _laser_tracker_intensity = self.tracker_info["tracker_intensity"]
-        print(f" PSD beam intensity:      {_laser_tracker_intensity:.2f}" + extra_endline)
+        print(f" PSD beam intensity:      {_laser_tracker_intensity:.2f}"+extra_endline)
         _laser_tracker_y_beampos = self.tracker_info["beampos_y"]
-        print(f" Y beam position:         {_laser_tracker_y_beampos:.2f}" + extra_endline)
+        print(f" Y beam position:         {_laser_tracker_y_beampos:.2f}"+extra_endline)
         _laser_tracker_y_target = self.tracker_info["target_y"]
-        print(f"   target position:       {_laser_tracker_y_target:.2f}" + extra_endline)
+        print(f"   target position:       {_laser_tracker_y_target:.2f}"+extra_endline)
         _laser_tracker_y_threshold_intensity = self.tracker_info["threshold_intensity_y"]
-        print(
-            f"   threshold intensity:   {_laser_tracker_y_threshold_intensity:.2f}" + extra_endline
-        )
+        print(f"   threshold intensity:   {_laser_tracker_y_threshold_intensity:.2f}"+extra_endline)
         _laser_tracker_y_piezo_voltage = self.tracker_info["piezo_voltage_y"]
-        print(f"   Piezo voltage:         {_laser_tracker_y_piezo_voltage:.2f}" + extra_endline)
+        print(f"   Piezo voltage:         {_laser_tracker_y_piezo_voltage:.2f}"+extra_endline)
         _laser_tracker_z_beampos = self.tracker_info["beampos_z"]
-        print(f" Z beam position:         {_laser_tracker_z_beampos:.2f}" + extra_endline)
+        print(f" Z beam position:         {_laser_tracker_z_beampos:.2f}"+extra_endline)
         _laser_tracker_z_target = self.tracker_info["target_z"]
-        print(f"   target position:       {_laser_tracker_z_target:.2f}" + extra_endline)
+        print(f"   target position:       {_laser_tracker_z_target:.2f}"+extra_endline)
         _laser_tracker_z_threshold_intensity = self.tracker_info["threshold_intensity_z"]
-        print(
-            f"   threshold intensity:   {_laser_tracker_z_threshold_intensity:.2f}" + extra_endline
-        )
+        print(f"   threshold intensity:   {_laser_tracker_z_threshold_intensity:.2f}"+extra_endline)
         _laser_tracker_z_piezo_voltage = self.tracker_info["piezo_voltage_z"]
-        print(f"   Piezo voltage:         {_laser_tracker_z_piezo_voltage:.2f}" + extra_endline)
-        print(" Reminder - there is also an upper threshold active in rt\n" + extra_endline)
+        print(f"   Piezo voltage:         {_laser_tracker_z_piezo_voltage:.2f}"+extra_endline)
+        print(" Reminder - there is also an upper threshold active in rt\n"+extra_endline)
         if extra_endline == "":
             self.laser_tracker_galil_status()
 
+
+
     def laser_tracker_galil_enable(self):
-        otracky_con = self.device_manager.devices.otracky.obj.controller
+        otracky_con = self.get_device_manager().devices.otracky.obj.controller
         otracky_con.socket_put_confirmed("tracken=1")
         otracky_con.socket_put_confirmed("trackyct=0")
         otracky_con.socket_put_confirmed("trackzct=0")
 
+
+
     def laser_tracker_galil_disable(self):
-        otracky_con = self.device_manager.devices.otracky.obj.controller
+        otracky_con = self.get_device_manager().devices.otracky.obj.controller
         otracky_con.socket_put_confirmed("tracken=0")
 
+
     def laser_tracker_galil_status(self):
-        otracky_con = self.device_manager.devices.otracky.obj.controller
+        otracky_con = self.get_device_manager().devices.otracky.obj.controller
         if bool(float(otracky_con.socket_put_and_receive("MGtracken").strip())) == 0:
-            print(self.red + "Tracking in the Galil Controller is disabled." + self.white)
+            print(self.red+"Tracking in the Galil Controller is disabled."+self.white)
             print("Use dev.rtx.controller.laser_tracker_galil_enable to enable.\n")
-            return 0
+            return(0)
         else:
             print("Tracking in the Galil Controller is enabled.")
-            trackyct = int(float(otracky_con.socket_put_and_receive("MGtrackyct").strip()))
-            trackzct = int(float(otracky_con.socket_put_and_receive("MGtrackzct").strip()))
+            trackyct=int(float(otracky_con.socket_put_and_receive("MGtrackyct").strip()))
+            trackzct=int(float(otracky_con.socket_put_and_receive("MGtrackzct").strip()))
             print(f"Galil Trackcounters y={trackyct}, z={trackzct}")
 
     def show_signal_strength_interferometer(self):
-        channelnames = {1: "OSA FZP Y", 2: "ST OSA Y", 3: "OSA FZP X", 4: "ST OSA X", 5: "Angle"}
+        channelnames={1:"OSA FZP Y",2:"ST OSA Y",3:"OSA FZP X",4:"ST OSA X",5:"Angle"}
         self.feedback_get_status_and_ssi()
         t = PrettyTable()
         t.title = f"Interferometer signal strength"
         t.field_names = ["Channel", "Name", "Value"]
-        for i in range(1, 6):
+        for i in range(1,6):
             ssi = self.ssi[f"ssi_{i}"]
-            t.add_row([i, channelnames[i], ssi])
+            t.add_row([i,channelnames[i], ssi])
         print(t)
 
     def _omny_interferometer_switch_open_socket(self):
@@ -756,42 +722,44 @@ class RtOMNYController(Controller):
         self._omny_interferometer_switch_put_and_receive("?000\r")
         time.sleep(1)
 
+
+
     def _omny_interferometer_switch_channel(self, channel):
         self._omny_interferometer_switch_alloff()
         time.sleep(0.1)
-        if channel == 1:  # Relais 1 and 2
+        if channel == 1: #Relais 1 and 2
             rback = self._omny_interferometer_switch_put_and_receive("!0020003\r")
-            # if "|0003\r" != self._omny_interferometer_switch_put_and_receive("!0020003\r"):
+            #if "|0003\r" != self._omny_interferometer_switch_put_and_receive("!0020003\r"):
             #    raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 2:  # Relais 3 and 4
+        elif channel == 2: #Relais 3 and 4
             rback = self._omny_interferometer_switch_put_and_receive("!002000C\r")
             # if "|000C\r" != self._omny_interferometer_switch_put_and_receive("!002000C\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 3:  # Relais 5 and 6
+        elif channel == 3: #Relais 5 and 6
             rback = self._omny_interferometer_switch_put_and_receive("!0020030\r")
             # if "|0030\r" != self._omny_interferometer_switch_put_and_receive("!0020030\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 4:  # Relais 7 and 8
+        elif channel == 4: #Relais 7 and 8
             rback = self._omny_interferometer_switch_put_and_receive("!00200C0\r")
             # if "|00C0\r" != self._omny_interferometer_switch_put_and_receive("!00200C0\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 5:  # Relais 9 and 10
+        elif channel == 5: #Relais 9 and 10
             rback = self._omny_interferometer_switch_put_and_receive("!0020300\r")
             # if "|0300\r" != self._omny_interferometer_switch_put_and_receive("!0020300\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 6:  # Relais 11 and 12
+        elif channel == 6: #Relais 11 and 12
             rback = self._omny_interferometer_switch_put_and_receive("!0020C00\r")
             # if "|0C00\r" != self._omny_interferometer_switch_put_and_receive("!0020C00\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 7:  # Relais 13 and 14
+        elif channel == 7: #Relais 13 and 14
             rback = self._omny_interferometer_switch_put_and_receive("!0023000\r")
             # if "|3000\r" != self._omny_interferometer_switch_put_and_receive("!0023000\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 8:  # Relais 7 and 8 SPECIAL CASE use osafzp y signal to align osa y
+        elif channel == 8: #Relais 7 and 8 SPECIAL CASE use osafzp y signal to align osa y
             rback = self._omny_interferometer_switch_put_and_receive("!00200C0\r")
             # if "|00C0\r" != self._omny_interferometer_switch_put_and_receive("!00200C0\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
-        elif channel == 9:  # Relais 15 and 16
+        elif channel == 9: #Relais 15 and 16
             rback = self._omny_interferometer_switch_put_and_receive("!002C000\r")
             # if "|C000\r" != self._omny_interferometer_switch_put_and_receive("!002C000\r"):
             #     raise RtOMNY_mirror_switchbox_Error("Channel switching failed.")
@@ -817,14 +785,14 @@ class RtOMNYController(Controller):
         self._omny_interferometer_switch_put_and_receive("!00S01\r")
 
     def _omny_interferometer_switch_alloff(self):
-        # switch all off
+        #switch all off
         self._omny_interferometer_switch_put_and_receive("!0020000\r")
-        # LED OFF
+        #LED OFF
         time.sleep(0.1)
-        self._omny_interferometer_switch_put_and_receive("!00S00\r")
+        self._omny_interferometer_switch_put_and_receive("!00S00\r")   
         time.sleep(0.1)
-        alloff = self._omny_interferometer_switch_put_and_receive("?002\r")
-        # check all off
+        alloff = self._omny_interferometer_switch_put_and_receive("?002\r")   
+        #check all off
         if "00" not in alloff:
             raise RtOMNY_mirror_switchbox_Error("Not all channels switched off.")
 
@@ -832,16 +800,17 @@ class RtOMNYController(Controller):
         self.socket_put("J3")
 
     def _omny_interferometer_get_signalsample(self, channel, averaging_duration):
-        # channel is string, eg ssi_1
-        # ensure no averaging running currently
+        #channel is string, eg ssi_1
+        #ensure no averaging running currently
         self.feedback_is_running()
 
-        # measure first sample
+        #measure first sample
         self._rt_start_averaging_SSI()
         time.sleep(averaging_duration)
         self.feedback_is_running()
         return self.ssi[channel]
 
+
     def _get_signals_from_table(self, return_table) -> dict:
         self.average_stdeviations_x_st_fzp += float(return_table[16])
         self.average_stdeviations_y_st_fzp += float(return_table[18])
@@ -862,6 +831,7 @@ class RtOMNYController(Controller):
             "stdev_x_st_fzp": {"value": float(return_table[16])},
             "average_y_st_fzp": {"value": float(return_table[17])},
             "stdev_y_st_fzp": {"value": float(return_table[18])},
+
             "average_stdeviations_x_st_fzp": {
                 "value": self.average_stdeviations_x_st_fzp / (int(return_table[0]) + 1)
             },
@@ -870,7 +840,7 @@ class RtOMNYController(Controller):
             },
         }
         return signals
-
+    
     @threadlocked
     def start_scan(self):
         if not self.feedback_is_running():
@@ -892,6 +862,7 @@ class RtOMNYController(Controller):
         # start a point-by-point scan (for cont scan in flomni it would be "sa")
         self.socket_put_and_receive("sd")
 
+
     @retry_once
     @threadlocked
     def get_scan_status(self):
@@ -910,6 +881,13 @@ class RtOMNYController(Controller):
         current_position_in_scan = int(float(return_table[2]))
         return (mode, number_of_positions_planned, current_position_in_scan)
 
+
+    def get_device_manager(self):
+        for axis in self._axis:
+            if hasattr(axis, "device_manager") and axis.device_manager:
+                return axis.device_manager
+        raise BECConfigError("Could not access the device_manager")
+
     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
@@ -923,7 +901,7 @@ class RtOMNYController(Controller):
 
         # if not (mode==2 or mode==3):
         #    error
-        self.device_manager.connector.set(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=1, metadata=self.readout_metadata
@@ -958,7 +936,7 @@ class RtOMNYController(Controller):
             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(
+        self.get_device_manager().connector.set(
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=0, metadata=self.readout_metadata
@@ -971,16 +949,15 @@ class RtOMNYController(Controller):
             f" {self.average_stdeviations_y_st_fzp/read_counter*1000:.1f}."
         )
 
-        self.device_manager.connector.send_client_info(
+        self.get_device_manager().connector.send_client_info(
             "OMNY statistics: Average of all standard deviations [nm]: x"
             f" {self.average_stdeviations_x_st_fzp/read_counter*1000:.1f}, y"
             f" {self.average_stdeviations_y_st_fzp/read_counter*1000:.1f}.",
-            scope="",
-            show_asap=True,
-        )
+            scope="", show_asap=True)
+
 
     def publish_device_data(self, signals, point_id):
-        self.device_manager.connector.set_and_publish(
+        self.get_device_manager().connector.set_and_publish(
             MessageEndpoints.device_read("rt_omny"),
             messages.DeviceMessage(
                 signals=signals, metadata={"point_id": point_id, **self.readout_metadata}
@@ -1091,7 +1068,7 @@ class RtOMNYMotor(Device, PositionerBase):
         self.axis_Id = axis_Id
         self.sign = sign
         self.controller = RtOMNYController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
         self.device_manager = device_manager
@@ -1119,10 +1096,6 @@ class RtOMNYMotor(Device, PositionerBase):
             self.low_limit_travel.put(limits[0])
             self.high_limit_travel.put(limits[1])
 
-    def wait_for_connection(self, timeout: int = 30, **kwargs) -> None:
-        """Wait for the device to be connected."""
-        self.controller.on(timeout=timeout)
-
     @property
     def limits(self):
         return (self.low_limit_travel.get(), self.high_limit_travel.get())
@@ -1209,6 +1182,7 @@ class RtOMNYMotor(Device, PositionerBase):
 
         return status
 
+
     @property
     def axis_Id(self):
         return self._axis_Id_alpha
@@ -1253,7 +1227,7 @@ class RtOMNYMotor(Device, PositionerBase):
 
 if __name__ == "__main__":
     rtcontroller = RtOMNYController(
-        socket_cls=SocketIO, socket_host="mpc2844.psi.ch", socket_port=2222, device_manager=None
+        socket_cls=SocketIO, socket_host="mpc2844.psi.ch", socket_port=2222
     )
     rtcontroller.on()
     rtcontroller.laser_tracker_on()

csaxs_bec/devices/smaract/smaract_controller.py

@@ -93,7 +93,6 @@ class SmaractController(Controller):
         socket_cls=None,
         socket_host=None,
         socket_port=None,
-        device_manager=None,
         attr_name="",
         labels=None,
     ):
@@ -103,7 +102,6 @@ class SmaractController(Controller):
                 socket_cls=socket_cls,
                 socket_host=socket_host,
                 socket_port=socket_port,
-                device_manager=device_manager,
                 attr_name=attr_name,
                 parent=parent,
                 labels=labels,

csaxs_bec/devices/smaract/smaract_ophyd.py

@@ -123,11 +123,10 @@ class SmaractMotor(Device, PositionerBase):
         limits=None,
         sign=1,
         socket_cls=SocketIO,
-        device_manager=None,
         **kwargs,
     ):
         self.controller = SmaractController(
-            socket_cls=socket_cls, socket_host=host, socket_port=port, device_manager=device_manager
+            socket_cls=socket_cls, socket_host=host, socket_port=port
         )
         self.axis_Id = axis_Id
         self.sign = sign

tests/tests_devices/test_fupr_ophyd.py

@@ -7,15 +7,10 @@ from csaxs_bec.devices.omny.galil.fupr_ophyd import FuprGalilController, FuprGal
 
 
 @pytest.fixture
-def fsamroy(dm_with_devices):
+def fsamroy():
     FuprGalilController._reset_controller()
     fsamroy_motor = FuprGalilMotor(
-        "A",
-        name="fsamroy",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "A", name="fsamroy", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     fsamroy_motor.controller.on()
     assert isinstance(fsamroy_motor.controller, FuprGalilController)

tests/tests_devices/test_galil.py

@@ -8,15 +8,10 @@ from csaxs_bec.devices.omny.galil.lgalil_ophyd import LamniGalilController, Lamn
 
 
 @pytest.fixture(scope="function")
-def leyey(dm_with_devices):
+def leyey():
     LamniGalilController._reset_controller()
     leyey_motor = LamniGalilMotor(
-        "H",
-        name="leyey",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "H", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyey_motor.controller.on()
     yield leyey_motor
@@ -25,15 +20,10 @@ def leyey(dm_with_devices):
 
 
 @pytest.fixture(scope="function")
-def leyex(dm_with_devices):
+def leyex():
     LamniGalilController._reset_controller()
     leyex_motor = LamniGalilMotor(
-        "A",
-        name="leyey",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "A", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyex_motor.controller.on()
     yield leyex_motor

tests/tests_devices/test_galil_flomni.py

@@ -7,15 +7,10 @@ from csaxs_bec.devices.omny.galil.fgalil_ophyd import FlomniGalilController, Flo
 
 
 @pytest.fixture(scope="function")
-def leyey(dm_with_devices):
+def leyey():
     FlomniGalilController._reset_controller()
     leyey_motor = FlomniGalilMotor(
-        "H",
-        name="leyey",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "H", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyey_motor.controller.on()
     yield leyey_motor
@@ -24,15 +19,10 @@ def leyey(dm_with_devices):
 
 
 @pytest.fixture(scope="function")
-def leyex(dm_with_devices):
+def leyex():
     FlomniGalilController._reset_controller()
     leyex_motor = FlomniGalilMotor(
-        "H",
-        name="leyey",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "H", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyex_motor.controller.on()
     yield leyex_motor
@@ -167,16 +157,11 @@ def test_find_reference(leyex, axis_nr, socket_put_messages, socket_get_messages
     ],
 )
 def test_fosaz_light_curtain_is_triggered(
-    axis_Id, socket_put_messages, socket_get_messages, triggered, dm_with_devices
+    axis_Id, socket_put_messages, socket_get_messages, triggered
 ):
     """test that the light curtain is triggered"""
     fosaz = FlomniGalilMotor(
-        axis_Id,
-        name="fosaz",
-        host="mpc2680.psi.ch",
-        port=8081,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        axis_Id, name="fosaz", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     fosaz.controller.on()
     fosaz.controller.sock.flush_buffer()

tests/tests_devices/test_npoint_piezo.py

@@ -16,10 +16,7 @@ def controller():
     """
     with mock.patch("ophyd_devices.utils.socket.SocketIO") as socket_cls:
         controller = NPointController(
-            socket_cls=socket_cls,
-            socket_host="localhost",
-            socket_port=1234,
-            device_manager=mock.MagicMock(),
+            socket_cls=socket_cls, socket_host="localhost", socket_port=1234
         )
         controller.on()
         controller.sock.reset_mock()
@@ -28,18 +25,13 @@ def controller():
 
 
 @pytest.fixture
-def npointx(dm_with_devices):
+def npointx():
     """
     Fixture to create a NPointAxis object.
     """
     controller = mock.MagicMock()
     npointx = NPointAxis(
-        axis_Id="A",
-        name="npointx",
-        host="localhost",
-        port=1234,
-        socket_cls=controller,
-        device_manager=dm_with_devices,
+        axis_Id="A", name="npointx", host="localhost", port=1234, socket_cls=controller
     )
     npointx.controller.on()
     npointx.controller.sock.reset_mock()
@@ -115,18 +107,13 @@ def test_axis_get_in(npointx, axis, msg_in, msg_out):
     npointx.controller.sock.put.assert_called_once_with(msg_in)
 
 
-def test_axis_out_of_range(dm_with_devices):
+def test_axis_out_of_range(controller):
     """
     Test that an error is raised when trying to create an NPointAxis object with an invalid axis ID.
     """
     with pytest.raises(ValueError):
         npointx = NPointAxis(
-            axis_Id="G",
-            name="npointx",
-            host="localhost",
-            port=1234,
-            socket_cls=mock.MagicMock(),
-            device_manager=dm_with_devices,
+            axis_Id="G", name="npointx", host="localhost", port=1234, socket_cls=mock.MagicMock()
         )
 
 

tests/tests_devices/test_rt_flomni.py

@@ -11,29 +11,26 @@ from csaxs_bec.devices.omny.rt.rt_ophyd import RtError
 def rt_flomni():
     RtFlomniController._reset_controller()
     rt_flomni = RtFlomniController(
-        name="rt_flomni",
-        socket_cls=SocketMock,
-        socket_host="localhost",
-        socket_port=8081,
-        device_manager=mock.MagicMock(),
+        name="rt_flomni", socket_cls=SocketMock, socket_host="localhost", socket_port=8081
     )
-    with mock.patch.object(rt_flomni, "sock"):
-        rtx = mock.MagicMock(spec=RtFlomniMotor)
-        rtx.name = "rtx"
-        rtx.axis_Id = "A"
-        rtx.axis_Id_numeric = 0
-        rty = mock.MagicMock(spec=RtFlomniMotor)
-        rty.name = "rty"
-        rty.axis_Id = "B"
-        rty.axis_Id_numeric = 1
-        rtz = mock.MagicMock(spec=RtFlomniMotor)
-        rtz.name = "rtz"
-        rtz.axis_Id = "C"
-        rtz.axis_Id_numeric = 2
-        rt_flomni.set_axis(axis=rtx, axis_nr=0)
-        rt_flomni.set_axis(axis=rty, axis_nr=1)
-        rt_flomni.set_axis(axis=rtz, axis_nr=2)
-        yield rt_flomni
+    with mock.patch.object(rt_flomni, "get_device_manager"):
+        with mock.patch.object(rt_flomni, "sock"):
+            rtx = mock.MagicMock(spec=RtFlomniMotor)
+            rtx.name = "rtx"
+            rtx.axis_Id = "A"
+            rtx.axis_Id_numeric = 0
+            rty = mock.MagicMock(spec=RtFlomniMotor)
+            rty.name = "rty"
+            rty.axis_Id = "B"
+            rty.axis_Id_numeric = 1
+            rtz = mock.MagicMock(spec=RtFlomniMotor)
+            rtz.name = "rtz"
+            rtz.axis_Id = "C"
+            rtz.axis_Id_numeric = 2
+            rt_flomni.set_axis(axis=rtx, axis_nr=0)
+            rt_flomni.set_axis(axis=rty, axis_nr=1)
+            rt_flomni.set_axis(axis=rtz, axis_nr=2)
+            yield rt_flomni
     RtFlomniController._reset_controller()
 
 
@@ -55,7 +52,7 @@ def test_rt_flomni_feedback_is_running(rt_flomni, return_value, is_running):
 
 def test_feedback_enable_with_reset(rt_flomni):
 
-    device_manager = rt_flomni.device_manager
+    device_manager = rt_flomni.get_device_manager()
     device_manager.devices.fsamx.user_parameter.get.return_value = 0.05
     device_manager.devices.fsamx.obj.readback.get.return_value = 0.05
 
@@ -71,7 +68,7 @@ def test_feedback_enable_with_reset(rt_flomni):
 
 
 def test_move_samx_to_scan_region(rt_flomni):
-    device_manager = rt_flomni.device_manager
+    device_manager = rt_flomni.get_device_manager()
     device_manager.devices.rtx.user_parameter.get.return_value = 1
     rt_flomni.move_samx_to_scan_region(20, 2)
     assert mock.call(b"v0\n") not in rt_flomni.sock.put.mock_calls
@@ -79,16 +76,16 @@ def test_move_samx_to_scan_region(rt_flomni):
 
 
 def test_feedback_enable_without_reset(rt_flomni):
-    with mock.patch.object(rt_flomni, "set_device_read_write") as set_device_read_write:
+    with mock.patch.object(rt_flomni, "set_device_enabled") as set_device_enabled:
         with mock.patch.object(rt_flomni, "feedback_is_running", return_value=True):
             with mock.patch.object(rt_flomni, "laser_tracker_on") as laser_tracker_on:
                 rt_flomni.feedback_enable_without_reset()
                 laser_tracker_on.assert_called_once()
                 assert mock.call(b"l3\n") in rt_flomni.sock.put.mock_calls
-                assert mock.call("fsamx", False) in set_device_read_write.mock_calls
-                assert mock.call("fsamy", False) in set_device_read_write.mock_calls
-                assert mock.call("foptx", False) in set_device_read_write.mock_calls
-                assert mock.call("fopty", False) in set_device_read_write.mock_calls
+                assert mock.call("fsamx", False) in set_device_enabled.mock_calls
+                assert mock.call("fsamy", False) in set_device_enabled.mock_calls
+                assert mock.call("foptx", False) in set_device_enabled.mock_calls
+                assert mock.call("fopty", False) in set_device_enabled.mock_calls
 
 
 def test_feedback_enable_without_reset_raises(rt_flomni):

tests/tests_devices/test_smaract.py

@@ -10,27 +10,19 @@ from csaxs_bec.devices.smaract.smaract_ophyd import SmaractMotor
 
 
 @pytest.fixture
-def controller(dm_with_devices):
+def controller():
     SmaractController._reset_controller()
-    controller = SmaractController(
-        socket_cls=SocketMock, socket_host="dummy", socket_port=123, device_manager=dm_with_devices
-    )
+    controller = SmaractController(socket_cls=SocketMock, socket_host="dummy", socket_port=123)
     controller.on()
     controller.sock.flush_buffer()
     yield controller
 
 
 @pytest.fixture
-def lsmarA(dm_with_devices):
+def lsmarA():
     SmaractController._reset_controller()
     motor_a = SmaractMotor(
-        "A",
-        name="lsmarA",
-        host="mpc2680.psi.ch",
-        port=8085,
-        sign=1,
-        socket_cls=SocketMock,
-        device_manager=dm_with_devices,
+        "A", name="lsmarA", host="mpc2680.psi.ch", port=8085, sign=1, socket_cls=SocketMock
     )
     motor_a.controller.on()
     motor_a.controller.sock.flush_buffer()