feat: first draft for jungfraujoch ophyd

.gitlab-ci.yml

@@ -4,4 +4,5 @@ include:
     inputs:
       name: "csaxs"
       target: "csaxs_bec"
+      branch: $CHILD_PIPELINE_BRANCH
 

bin/cbf_converter/cbf_converter.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import os
 import subprocess
 
-from bec_lib import MessageEndpoints, RedisConnector, bec_logger, messages
-from bec_lib.redis_connector import MessageObject
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import MessageObject, RedisConnector
 
 logger = bec_logger.logger
 
@@ -27,7 +28,7 @@ class PilatusConverter:
             message (MessageObject): Message object
             parent (PilatusConverter): Parent object
         """
-        msg = messages.MessageReader.loads(message.value)
+        msg = message.value
         print(msg)
         if not msg:
             return

csaxs_bec/bec_ipython_client/plugins/LamNI/lamni_optics_mixin.py

@@ -22,7 +22,7 @@ class LaMNIInitStagesMixin:
         user_input = input("Starting initialization of LamNI stages. OK? [y/n]")
         if user_input == "y":
             print("staring...")
-            dev.lsamrot.enabled=True
+            dev.lsamrot.enabled = True
         else:
             return
 
@@ -42,7 +42,7 @@ class LaMNIInitStagesMixin:
                 return
 
             self.drive_axis_to_limit(dev.lsamrot, "forward")
-            dev.lsamrot.enabled=False
+            dev.lsamrot.enabled = False
             print("Now hard reboot the controller and run the initialization routine again.")
             print("The controller will be disabled in bec. To enable dev.lsamrot.enabled=True")
             return
@@ -108,10 +108,10 @@ class LaMNIInitStagesMixin:
         time.sleep(1)
         dev.losax.controller.find_reference_mark(1, 0, 1000, 1)
         time.sleep(1)
-        #dev.losax.controller.find_reference_mark(3, 1, 1000, 1)
-        #time.sleep(1)
-        #dev.losax.controller.find_reference_mark(4, 1, 1000, 1)
-        #time.sleep(1)
+        # dev.losax.controller.find_reference_mark(3, 1, 1000, 1)
+        # time.sleep(1)
+        # dev.losax.controller.find_reference_mark(4, 1, 1000, 1)
+        # time.sleep(1)
 
         # set_lm losax -1.5 0.25
         # set_lm losay -2.5 4.1

csaxs_bec/bec_ipython_client/plugins/LamNI/x_ray_eye_align.py

@@ -16,8 +16,7 @@ from typeguard import typechecked
 
 from csaxs_bec.bec_ipython_client.plugins.cSAXS import epics_get, epics_put, fshopen
 
-from .lamni_optics_mixin import LamNIOpticsMixin
-from .lamni_optics_mixin import LaMNIInitStagesMixin
+from .lamni_optics_mixin import LaMNIInitStagesMixin, LamNIOpticsMixin
 
 logger = bec_logger.logger
 bec = builtins.__dict__.get("bec")
@@ -587,6 +586,27 @@ class LamNI(LamNIOpticsMixin):
     def tomo_circfov(self, val: float):
         self.client.set_global_var("tomo_circfov", val)
 
+    @property
+    def tomo_type(self):
+        val = self.client.get_global_var("tomo_type")
+        if val is None:
+            return 1
+        return val
+
+    @tomo_type.setter
+    def tomo_type(self, val: float):
+        if val == 1:
+            # equally spaced tomography with 8 sub tomograms
+            self.client.set_global_var("tomo_type", val)
+        # elif val == 2:
+        #    # golden ratio tomography (sorted bunches)
+        #    self.client.set_global_var("tomo_type", val)
+        # elif val == 3:
+        #    # equally spaced tomography with starting angles shifted by golden ratio
+        #    self.client.set_global_var("tomo_type", val)
+        else:
+            raise ValueError("Unknown tomo_type.")
+
     @property
     def tomo_countingtime(self):
         val = self.client.get_global_var("tomo_countingtime")
@@ -949,25 +969,63 @@ class LamNI(LamNIOpticsMixin):
         # _tomo_shift_angles (potential global variable)
         _tomo_shift_angles = 0
         angle_end = start_angle + 360
-        for angle in np.linspace(
+        angles = np.linspace(
             start_angle + _tomo_shift_angles,
             angle_end,
             num=int(360 / self.tomo_angle_stepsize) + 1,
             endpoint=True,
-        ):
-            successful = False
-            error_caught = False
-            if 0 <= angle < 360.05:
-                print(f"Starting LamNI scan for angle {angle}")
-                while not successful:
-                    self._start_beam_check()
-                    if not self.special_angles:
-                        self._current_special_angles = []
-                    if self._current_special_angles:
-                        next_special_angle = self._current_special_angles[0]
-                        if np.isclose(angle, next_special_angle, atol=0.5):
-                            self._current_special_angles.pop(0)
-                            num_repeats = self.special_angle_repeats
+        )
+
+        # reverse even sub-tomograms
+        if not (subtomo_number % 2):
+            angles = np.flip(angles)
+        for angle in angles:
+            self.progress["subtomo"] = subtomo_number
+            self.progress["subtomo_projection"] = angles.index(angle)
+            self.progress["subtomo_total_projections"] = 180 / self.tomo_angle_stepsize
+            self.progress["projection"] = (subtomo_number - 1) * self.progress[
+                "subtomo_total_projections"
+            ] + self.progress["subtomo_projection"]
+            self.progress["total_projections"] = 180 / self.tomo_angle_stepsize * 8
+            self.progress["angle"] = angle
+            self._tomo_scan_at_angle(angle, subtomo_number)
+
+    def _print_progress(self):
+        print("\x1b[95mProgress report:")
+        print(f"Tomo type: ....................... {self.progress['tomo_type']}")
+        print(f"Projection: ...................... {self.progress['projection']}")
+        print(f"Total projections expected ....... {self.progress['total_projections']}")
+        print(f"Angle: ........................... {self.progress['angle']}")
+        print(f"Current subtomo: ................. {self.progress['subtomo']}")
+        print(f"Current projection within subtomo: {self.progress['subtomo_projection']}\x1b[0m")
+
+    def _tomo_scan_at_angle(self, angle, subtomo_number):
+        successful = False
+        error_caught = False
+        if 0 <= angle < 360.05:
+            print(f"Starting LamNI scan for angle {angle} in subtomo {subtomo_number}")
+            self._print_progress()
+            while not successful:
+                self._start_beam_check()
+                if not self.special_angles:
+                    self._current_special_angles = []
+                if self._current_special_angles:
+                    next_special_angle = self._current_special_angles[0]
+                    if np.isclose(angle, next_special_angle, atol=0.5):
+                        self._current_special_angles.pop(0)
+                        num_repeats = self.special_angle_repeats
+                else:
+                    num_repeats = 1
+                try:
+                    start_scan_number = bec.queue.next_scan_number
+                    for i in range(num_repeats):
+                        self._at_each_angle(angle)
+                    error_caught = False
+                except AlarmBase as exc:
+                    if exc.alarm_type == "TimeoutError":
+                        bec.queue.request_queue_reset()
+                        time.sleep(2)
+                        error_caught = True
                     else:
                         num_repeats = 1
                     try:
@@ -1007,7 +1065,7 @@ class LamNI(LamNIOpticsMixin):
         scans = builtins.__dict__.get("scans")
         self._current_special_angles = self.special_angles.copy()
 
-        if subtomo_start == 1 and start_angle is None:
+        if self.tomo_type == 1 and subtomo_start == 1 and start_angle is None:
             # pylint: disable=undefined-variable
             self.tomo_id = self.add_sample_database(
                 self.sample_name,

csaxs_bec/bec_ipython_client/plugins/flomni/flomni.py

@@ -309,6 +309,7 @@ class FlomniInitStagesMixin:
         else:
             print("Stopping.")
             return
+        dev.rtx.controller.feedback_disable()
         # positions for optics out and 50 mm distance to sample
         umv(dev.ftrackz, 4.73, dev.ftracky, 2.5170, dev.foptx, -14.3, dev.fopty, 3.87)
 

csaxs_bec/device_configs/bec_device_config_sastt.yaml

@@ -17,7 +17,7 @@ bpm4i:
   softwareTrigger: false
 mokev:
   description: Monochromator energy in keV
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.EnergyKev
+  deviceClass: csaxs_bec.devices.epics.specMotors.EnergyKev
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX2
   deviceTags:
@@ -29,7 +29,7 @@ mokev:
   softwareTrigger: false
 mcs:
   description: Mcs scalar card for transmission readout
-  deviceClass: csaxs_bec.devices.epics.devices.MCScSAXS
+  deviceClass: csaxs_bec.devices.epics.mcs_csaxs.MCScSAXS
   deviceConfig:
     prefix: 'X12SA-MCS:'
     mcs_config:
@@ -43,7 +43,7 @@ mcs:
   softwareTrigger: false
 eiger9m:
   description: Eiger9m HPC area detector 9M
-  deviceClass: csaxs_bec.devices.epics.devices.Eiger9McSAXS
+  deviceClass: csaxs_bec.devices.epics.eiger9m_csaxs.Eiger9McSAXS
   deviceConfig:
     prefix: 'X12SA-ES-EIGER9M:'
   deviceTags:
@@ -55,7 +55,7 @@ eiger9m:
   softwareTrigger: false
 ddg_detectors:
   description: DelayGenerator for detector triggering
-  deviceClass: csaxs_bec.devices.epics.devices.DelayGeneratorcSAXS
+  deviceClass: csaxs_bec.devices.epics.delay_generator_csaxs.DelayGeneratorcSAXS
   deviceConfig:
     prefix: 'delaygen:DG1:'
     ddg_config:
@@ -82,7 +82,7 @@ ddg_detectors:
   softwareTrigger: false
 ddg_mcs:
   description: DelayGenerator for mcs triggering
-  deviceClass: csaxs_bec.devices.epics.devices.DelayGeneratorcSAXS
+  deviceClass: csaxs_bec.devices.epics.delay_generator_csaxs.DelayGeneratorcSAXS
   deviceConfig:
     prefix: 'delaygen:DG2:'
     ddg_config:
@@ -111,7 +111,7 @@ ddg_mcs:
   softwareTrigger: false
 ddg_fsh:
   description: DelayGenerator for fast shutter control
-  deviceClass: csaxs_bec.devices.epics.devices.DelayGeneratorcSAXS
+  deviceClass: csaxs_bec.devices.epics.delay_generator_csaxs.DelayGeneratorcSAXS
   deviceConfig:
     prefix: 'delaygen:DG3:'
     ddg_config:
@@ -138,7 +138,7 @@ ddg_fsh:
   softwareTrigger: false
 falcon:
   description: Falcon detector x-ray fluoresence 
-  deviceClass: csaxs_bec.devices.epics.devices.FalconcSAXS
+  deviceClass: csaxs_bec.devices.epics.falcon_csaxs.FalconcSAXS
   deviceConfig:
     prefix: 'X12SA-SITORO:'
   deviceTags:
@@ -150,7 +150,7 @@ falcon:
   softwareTrigger: false
 pilatus_2:
   description: Pilatus2 HPC area detector 300k 
-  deviceClass: csaxs_bec.devices.epics.devices.PilatuscSAXS
+  deviceClass: csaxs_bec.devices.epics.pilatus_csaxs.PilatuscSAXS
   deviceConfig:
     prefix: 'X12SA-ES-PILATUS300K:'
   deviceTags:
@@ -162,7 +162,7 @@ pilatus_2:
   softwareTrigger: false
 samx:
   description: SGalil motor stage
-  deviceClass: csaxs_bec.devices.galil.SGalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.SGalilMotor
   deviceConfig:
     axis_Id: "E"
     host: '129.129.122.26'
@@ -180,7 +180,7 @@ samx:
   softwareTrigger: false
 samy:
   description: SGalil motor stage
-  deviceClass: csaxs_bec.devices.galil.SGalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.SGalilMotor
   deviceConfig:
     axis_Id: "C"
     host: '129.129.122.26'
@@ -198,7 +198,7 @@ samy:
   softwareTrigger: false
 micfoc:
   description: Focusing motor of Microscope stage
-  deviceClass: ophyd_devices.epics.devices.EpicsMotorEx
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES06
     motor_resolution: 0.00125
@@ -216,7 +216,7 @@ micfoc:
   softwareTrigger: false
 owis_samx:
   description: Owis motor stage samx
-  deviceClass: ophyd_devices.epics.devices.EpicsMotorEx
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES01
     motor_resolution: 0.00125
@@ -234,7 +234,7 @@ owis_samx:
   softwareTrigger: false
 owis_samy:
   description: Owis motor stage samx
-  deviceClass: ophyd_devices.epics.devices.EpicsMotorEx
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES02
     motor_resolution: 0.00125
@@ -252,7 +252,7 @@ owis_samy:
   softwareTrigger: false
 rotx:
   description: Rotation stage rotx
-  deviceClass: ophyd_devices.epics.devices.EpicsMotorEx
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES05
     motor_resolution: 0.0025
@@ -273,7 +273,7 @@ rotx:
   softwareTrigger: false
 roty:
   description: Rotation stage rotx
-  deviceClass: ophyd_devices.epics.devices.EpicsMotorEx
+  deviceClass: ophyd_devices.devices.EpicsMotorEx
   deviceConfig:
     prefix: X12SA-ES2-ES04
     motor_resolution: 0.0025

csaxs_bec/device_configs/ddg_template.yaml

@@ -0,0 +1,46 @@
+ddg:
+  description: DelayGenerator for detector triggering
+  deviceClass: csaxs_bec.devices.epics.delay_generator_csaxs.DelayGeneratorcSAXS
+  deviceConfig:
+    prefix: 'X12SA-CPCL-DDG3:'
+    ddg_config:
+      delay_burst: 40.e-3
+      delta_width: 0
+      additional_triggers: 0
+      polarity:
+      - 1 # T0 
+      - 0 # eiger and LeCroy4
+      - 1 
+      - 1 
+      - 1
+      amplitude: 4.5
+      offset: 0
+      thres_trig_level: 2.5
+      set_high_on_exposure: False
+      set_high_on_stage: False
+  deviceTags:
+  - cSAXS
+  - ddg_detectors
+  onFailure: buffer
+  enabled: true
+  readoutPriority: async
+  softwareTrigger: True
+eiger_jfjoch:
+  description: DelayGenerator for detector triggering
+  deviceClass: csaxs_bec.devices.jungfraujoch.eiger_jungfrau_joch.Eiger9McSAXS
+  deviceConfig:
+  deviceTags:
+  - cSAXS
+  - eiger9m
+  onFailure: buffer
+  enabled: true
+  readoutPriority: async
+  softwareTrigger: False
+simulated_monitor:
+  readoutPriority: monitored
+  deviceClass: ophyd_devices.SimMonitor
+  deviceConfig:
+  deviceTags:
+    - beamline
+  enabled: true
+  readOnly: false

csaxs_bec/device_configs/e21125_lamni_config.yaml

@@ -3,7 +3,7 @@
 ############################################################
 leyex:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: G
     host: mpc2680.psi.ch
@@ -22,7 +22,7 @@ leyex:
     in: 14.117
 leyey:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: H
     host: mpc2680.psi.ch
@@ -42,7 +42,7 @@ leyey:
     out: 0.5
 loptx:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: E
     host: mpc2680.psi.ch
@@ -62,7 +62,7 @@ loptx:
     out: -0.699
 lopty:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: F
     host: mpc2680.psi.ch
@@ -82,7 +82,7 @@ lopty:
     out: 3.53
 loptz:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: D
     host: mpc2680.psi.ch
@@ -99,7 +99,7 @@ loptz:
   readoutPriority: baseline
 lsamrot:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: C
     host: mpc2680.psi.ch
@@ -116,7 +116,7 @@ lsamrot:
   readoutPriority: baseline
 lsamx:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: A
     host: mpc2680.psi.ch
@@ -135,7 +135,7 @@ lsamx:
     center: 8.768
 lsamy:
   description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.galil_ophyd.GalilMotor
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
   deviceConfig:
     axis_Id: B
     host: mpc2680.psi.ch
@@ -162,7 +162,7 @@ lsamy:
 ############################################################
 
 rtx:
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_lamni_ophyd.RtLamniMotor
+  deviceClass: csaxs_bec.devices.omny.rt.rt_lamni_ophyd.RtLamniMotor
   deviceConfig:
     axis_Id: A
     device_access: true
@@ -179,7 +179,7 @@ rtx:
   enabled: true
   readOnly: False
 rty:
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_lamni_ophyd.RtLamniMotor
+  deviceClass: csaxs_bec.devices.omny.rt.rt_lamni_ophyd.RtLamniMotor
   deviceConfig:
     axis_Id: B
     device_access: true
@@ -293,7 +293,7 @@ losaz:
 
 eiger1p5m:
   description: Eiger 1.5M in vacuum detector, in-house developed, PSI
-  deviceClass: csaxs_bec.devices.eiger1p5m_csaxs.eiger1p5m.Eiger1p5MDetector
+  deviceClass: csaxs_bec.devices.omny.eiger1p5m.Eiger1p5MDetector
   deviceConfig:
     device_access: true
   deviceTags:
@@ -504,7 +504,7 @@ sls_filling_pattern:
   readOnly: True
 sls_info:
   readoutPriority: on_request
-  deviceClass: ophyd_devices.sls_devices.sls_devices.SLSInfo
+  deviceClass: ophyd_devices.devices.sls_devices.SLSInfo
   deviceConfig:
   deviceTags:
   - SLS status
@@ -537,7 +537,7 @@ sls_machine_status:
   readOnly: True
 sls_operator:
   readoutPriority: on_request
-  deviceClass: ophyd_devices.sls_devices.sls_devices.SLSOperatorMessages
+  deviceClass: ophyd_devices.devices.sls_devices.SLSOperatorMessages
   deviceConfig:
     auto_monitor: true
     read_pv: ARIDI-BPM:OFB-MODE
@@ -802,7 +802,7 @@ bm5try:
   softwareTrigger: false
 bpm1:
   description: 'XBPM 1: Somewhere around mono (VME)'
-  deviceClass: csaxs_bec.devices.epics.devices.XbpmBase.XbpmCsaxsOp
+  deviceClass: csaxs_bec.devices.epics.XbpmBase.XbpmCsaxsOp
   deviceConfig:
     prefix: 'X12SA-OP-BPM2:'
   deviceTags:
@@ -824,7 +824,7 @@ bpm1i:
   softwareTrigger: false
 bpm2:
   description: 'XBPM 2: Somewhere around mono (VME)'
-  deviceClass: csaxs_bec.devices.epics.devices.XbpmBase.XbpmCsaxsOp
+  deviceClass: csaxs_bec.devices.epics.XbpmBase.XbpmCsaxsOp
   deviceConfig:
     prefix: 'X12SA-OP-BPM2:'
   deviceTags:
@@ -1187,7 +1187,7 @@ dtpush:
   softwareTrigger: false
 dtth:
   description: Detector tower tilt rotation
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.PmDetectorRotation
+  deviceClass: csaxs_bec.devices.epics.specMotors.PmDetectorRotation
   deviceConfig:
     prefix: X12SA-ES1-DETT:ROX1
   deviceTags:
@@ -1462,7 +1462,7 @@ fttrz:
   softwareTrigger: false
 idgap:
   description: Undulator gap size [mm]
-  deviceClass: csaxs_bec.devices.epics.devices.InsertionDevice
+  deviceClass: csaxs_bec.devices.epics.InsertionDevice.InsertionDevice
   deviceConfig:
     prefix: X12SA-ID
   deviceTags:
@@ -1561,7 +1561,7 @@ mitry3:
   softwareTrigger: false
 mobd:
   description: Monochromator bender virtual motor
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.PmMonoBender
+  deviceClass: csaxs_bec.devices.epics.specMotors.PmMonoBender
   deviceConfig:
     prefix: 'X12SA-OP-MO:'
   deviceTags:
@@ -1616,7 +1616,7 @@ mobddi:
   softwareTrigger: false
 mokev:
   description: Monochromator energy in keV
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.EnergyKev
+  deviceClass: csaxs_bec.devices.epics.specMotors.EnergyKev
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX2
   deviceTags:
@@ -1671,7 +1671,7 @@ moroll2:
   softwareTrigger: false
 moth1:
   description: Monochromator Theta 1
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.MonoTheta1
+  deviceClass: csaxs_bec.devices.epics.specMotors.MonoTheta1
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX1
   deviceTags:
@@ -1693,7 +1693,7 @@ moth1e:
   softwareTrigger: false
 moth2:
   description: Monochromator Theta 2
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.MonoTheta2
+  deviceClass: csaxs_bec.devices.epics.specMotors.MonoTheta2
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX2
   deviceTags:
@@ -1812,17 +1812,17 @@ sec:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl0h:
-  description: FrontEnd slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-FE-SH1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl0h:
+#   description: FrontEnd slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-FE-SH1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl0trxi:
   description: FrontEnd slit inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1845,17 +1845,17 @@ sl0trxo:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl1h:
-  description: OpticsHutch slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-OP-SH1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl1h:
+#   description: OpticsHutch slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SH1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl1trxi:
   description: OpticsHutch slit inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1900,28 +1900,28 @@ sl1tryt:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl1v:
-  description: OpticsHutch slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitV
-  deviceConfig:
-    prefix: 'X12SA-OP-SV1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sl2h:
-  description: OpticsHutch slit 2 virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-OP-SH2:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl1v:
+#   description: OpticsHutch slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitV
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SV1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sl2h:
+#   description: OpticsHutch slit 2 virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SH2:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl2trxi:
   description: OpticsHutch slit 2 inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1966,72 +1966,72 @@ sl2tryt:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl2v:
-  description: OpticsHutch slit 2 virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitV
-  deviceConfig:
-    prefix: 'X12SA-OP-SV2:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-strox:
-  description: Girder virtual pitch
-  deviceClass: ophyd_devices.epics.devices.GirderMotorPITCH
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-stroy:
-  description: Girder virtual yaw
-  deviceClass: ophyd_devices.epics.devices.GirderMotorYAW
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-stroz:
-  description: Girder virtual roll
-  deviceClass: ophyd_devices.epics.devices.GirderMotorROLL
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sttrx:
-  description: Girder X translation
-  deviceClass: ophyd_devices.epics.devices.GirderMotorX1
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sttry:
-  description: Girder Y translation
-  deviceClass: ophyd_devices.epics.devices.GirderMotorY1
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl2v:
+#   description: OpticsHutch slit 2 virtual movement
+#   deviceClass: ophyd_devices.devices.SlitV
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SV2:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# strox:
+#   description: Girder virtual pitch
+#   deviceClass: ophyd_devices.devices.GirderMotorPITCH
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# stroy:
+#   description: Girder virtual yaw
+#   deviceClass: ophyd_devices.devices.GirderMotorYAW
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# stroz:
+#   description: Girder virtual roll
+#   deviceClass: ophyd_devices.devices.GirderMotorROLL
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sttrx:
+#   description: Girder X translation
+#   deviceClass: ophyd_devices.devices.GirderMotorX1
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sttry:
+#   description: Girder Y translation
+#   deviceClass: ophyd_devices.devices.GirderMotorY1
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 transd:
   description: Transmission diode
   deviceClass: ophyd.EpicsSignalRO

csaxs_bec/device_configs/flomni_config.yaml

@@ -1,6 +1,10 @@
+############################################################
+#################### flOMNI Galil motors ###################
+############################################################
+
 feyex:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Xray eye X
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: D
     host: mpc2844.psi.ch
@@ -17,8 +21,8 @@ feyex:
     in: -16.267
     out: -1
 feyey:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Xray eye Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: E
     host: mpc2844.psi.ch
@@ -34,8 +38,8 @@ feyey:
   userParameter:
     in: -10.467
 fheater:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Heater Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: C
     host: mpc2844.psi.ch
@@ -48,17 +52,9 @@ fheater:
   onFailure: buffer
   readOnly: false
   readoutPriority: baseline
-flomni_samples:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.epics.devices.flomni_sample_storage.FlomniSampleStorage
-  deviceConfig: {}
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
 foptx:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Optics X
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: B
     host: mpc2844.psi.ch
@@ -74,8 +70,8 @@ foptx:
   userParameter:
     in: -13.761
 fopty:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Optics Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: F
     host: mpc2844.psi.ch
@@ -92,8 +88,8 @@ fopty:
     in: 0.552
     out: 0.752
 foptz:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
+  description: Optics Z
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
   deviceConfig:
     axis_Id: A
     host: mpc2844.psi.ch
@@ -108,8 +104,166 @@ foptz:
   readoutPriority: baseline
   userParameter:
     in: 23
+fsamroy:
+  description: Sample rotation
+  deviceClass: csaxs_bec.devices.omny.galil.fupr_ophyd.FuprGalilMotor
+  deviceConfig:
+    axis_Id: A
+    host: mpc2844.psi.ch
+    limits:
+    - -5
+    - 365
+    port: 8084
+    sign: -1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+fsamx:
+  description: Sample coarse X
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: E
+    host: mpc2844.psi.ch
+    limits:
+    - -162
+    - 0
+    port: 8081
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+  userParameter:
+    in: -1.1
+fsamy:
+  description: Sample coarse Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: F
+    host: mpc2844.psi.ch
+    limits:
+    - 2
+    - 3.1
+    port: 8081
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: true
+  readoutPriority: baseline
+  userParameter:
+    in: 2.75
+ftracky:
+  description: Laser Tracker coarse Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: H
+    host: mpc2844.psi.ch
+    limits:
+    - 2.2
+    - 2.8
+    port: 8082
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+ftrackz:
+  description: Laser Tracker coarse Z
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: G
+    host: mpc2844.psi.ch
+    limits:
+    - 4.5
+    - 5.5
+    port: 8082
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+ftransx:
+  description: Sample transer X
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: C
+    host: mpc2844.psi.ch
+    limits:
+    - 0
+    - 50
+    port: 8081
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+ftransy:
+  description: Sample transer Y
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: A
+    host: mpc2844.psi.ch
+    limits:
+    - -100
+    - 0
+    port: 8081
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+ftransz:
+  description: Sample transer Z
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: B
+    host: mpc2844.psi.ch
+    limits:
+    - 0
+    - 145
+    port: 8081
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+ftray:
+  description: Sample transfer tray
+  deviceClass: csaxs_bec.devices.omny.galil.fgalil_ophyd.FlomniGalilMotor
+  deviceConfig:
+    axis_Id: D
+    host: mpc2844.psi.ch
+    limits:
+    - -200
+    - 0
+    port: 8081
+    sign: -1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+
+
+############################################################
+#################### flOMNI Sample Names ###################
+############################################################
+
+flomni_samples:
+  description: Sample names and storage
+  deviceClass: csaxs_bec.devices.omny.flomni_sample_storage.FlomniSampleStorage
+  deviceConfig: {}
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+
+############################################################
+#################### flOMNI Smaract motors #################
+############################################################
+
 fosax:
-  description: phase plate angle
+  description: OSA X
   deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
   deviceConfig:
     axis_Id: A
@@ -127,7 +281,7 @@ fosax:
     in: 9.124
     out: 5.3
 fosay:
-  description: phase plate angle
+  description: OSA Y
   deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
   deviceConfig:
     axis_Id: B
@@ -144,7 +298,7 @@ fosay:
   userParameter:
     in: 0.367
 fosaz:
-  description: phase plate angle
+  description: OSA Z
   deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
   deviceConfig:
     axis_Id: C
@@ -161,148 +315,14 @@ fosaz:
   userParameter:
     in: 8.5
     out: 6
-fsamroy:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fupr_ophyd.FuprGalilMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - -5
-    - 365
-    port: 8084
-    sign: -1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-fsamx:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: E
-    host: mpc2844.psi.ch
-    limits:
-    - -162
-    - 0
-    port: 8081
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: true
-  readoutPriority: baseline
-  userParameter:
-    in: -1.1
-fsamy:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: F
-    host: mpc2844.psi.ch
-    limits:
-    - 2
-    - 3.1
-    port: 8081
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: true
-  readoutPriority: baseline
-  userParameter:
-    in: 2.75
-ftracky:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: H
-    host: mpc2844.psi.ch
-    limits:
-    - 2.2
-    - 2.8
-    port: 8082
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-ftrackz:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: G
-    host: mpc2844.psi.ch
-    limits:
-    - 4.5
-    - 5.5
-    port: 8082
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-ftransx:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: C
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 50
-    port: 8081
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-ftransy:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - -100
-    - 0
-    port: 8081
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-ftransz:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: B
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 145
-    port: 8081
-    sign: 1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
-ftray:
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: D
-    host: mpc2844.psi.ch
-    limits:
-    - -200
-    - 0
-    port: 8081
-    sign: -1
-  enabled: true
-  onFailure: buffer
-  readOnly: false
-  readoutPriority: baseline
+
+############################################################
+#################### flOMNI RT motors ######################
+############################################################
+  
 rtx:
   description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
+  deviceClass: csaxs_bec.devices.omny.rt.rt_flomni_ophyd.RtFlomniMotor
   deviceConfig:
     axis_Id: A
     host: mpc2844.psi.ch
@@ -318,7 +338,7 @@ rtx:
     rt_pid_voltage: -0.06219
 rty:
   description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
+  deviceClass: csaxs_bec.devices.omny.rt.rt_flomni_ophyd.RtFlomniMotor
   deviceConfig:
     axis_Id: B
     host: mpc2844.psi.ch
@@ -332,7 +352,7 @@ rty:
     tomo_additional_offsety: 0
 rtz:
   description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
+  deviceClass: csaxs_bec.devices.omny.rt.rt_flomni_ophyd.RtFlomniMotor
   deviceConfig:
     axis_Id: C
     host: mpc2844.psi.ch

csaxs_bec/device_configs/flomni_test_config.yaml

@@ -1,340 +0,0 @@
-fheater:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: C
-    host: mpc2844.psi.ch
-    limits:
-    - -15
-    - 0
-    port: 8082
-    sign: -1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-feyex:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: D
-    host: mpc2844.psi.ch
-    limits:
-    - -30
-    - -1
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: -16.267
-    out: -1
-  enabled: true
-  readOnly: false
-feyey:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: E
-    host: mpc2844.psi.ch
-    limits:
-    - -1
-    - -10
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: -10.467
-  enabled: true
-  readOnly: false
-foptx:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: B
-    host: mpc2844.psi.ch
-    limits:
-    - -17
-    - -12
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: -13.761
-  enabled: true
-  readOnly: false
-fopty:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: F
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 4
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: 0.552
-    out: 0.752
-  enabled: true
-  readOnly: false
-foptz:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 27
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: 23
-  enabled: true
-  readOnly: false
-fosax:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - 10.2
-    - 10.6
-    port: 3334
-    sign: -1
-  onFailure: buffer
-  userParameter:
-    in: 9.124
-    out: 5.3
-  enabled: true
-  readOnly: false
-fosay:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
-  deviceConfig:
-    axis_Id: B
-    host: mpc2844.psi.ch
-    limits:
-    - -3.1
-    - -2.9
-    port: 3334
-    sign: -1
-  onFailure: buffer
-  userParameter:
-    in: 0.367
-  enabled: true
-  readOnly: false
-fosaz:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
-  deviceConfig:
-    axis_Id: C
-    host: mpc2844.psi.ch
-    limits:
-    - -6
-    - -4
-    port: 3334
-    sign: 1
-  onFailure: buffer
-  userParameter:
-    in: 8.5
-    out: 6
-  enabled: true
-  readOnly: false
-fsamroy:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fupr_ophyd.FuprGalilMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - -5
-    - 365
-    port: 8084
-    sign: -1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-fsamx:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: E
-    host: mpc2844.psi.ch
-    limits:
-    - -162
-    - 0
-    port: 8081
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-  userParameter:
-    in: -1.1
-fsamy:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: F
-    host: mpc2844.psi.ch
-    limits:
-    - 2
-    - 3.1
-    port: 8081
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-  userParameter:
-    in: 2.75
-ftracky:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: H
-    host: mpc2844.psi.ch
-    limits:
-    - 2.2
-    - 2.8
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-ftrackz:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: G
-    host: mpc2844.psi.ch
-    limits:
-    - 4.5
-    - 5.5
-    port: 8082
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-ftransx:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: C
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 50
-    port: 8081
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-ftransy:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    limits:
-    - -100
-    - 0
-    port: 8081
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-ftransz:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: B
-    host: mpc2844.psi.ch
-    limits:
-    - 0
-    - 145
-    port: 8081
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-ftray:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.galil.fgalil_ophyd.FlomniGalilMotor
-  deviceConfig:
-    axis_Id: D
-    host: mpc2844.psi.ch
-    limits:
-    - -200
-    - 0
-    port: 8081
-    sign: -1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-
-flomni_samples:
-  readoutPriority: baseline
-  description: phase plate angle
-  deviceClass: csaxs_bec.devices.epics.devices.FlomniSampleStorage
-  deviceConfig:
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-
-rtx:
-  readoutPriority: on_request
-  description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
-  deviceConfig:
-    axis_Id: A
-    host: mpc2844.psi.ch
-    port: 2222
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-rty:
-  readoutPriority: on_request
-  description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
-  deviceConfig:
-    axis_Id: B
-    host: mpc2844.psi.ch
-    port: 2222
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false
-rtz:
-  readoutPriority: on_request
-  description: flomni rt
-  deviceClass: csaxs_bec.devices.rt_lamni.rt_flomni_ophyd.RtFlomniMotor
-  deviceConfig:
-    axis_Id: C
-    host: mpc2844.psi.ch
-    port: 2222
-    sign: 1
-  onFailure: buffer
-  enabled: true
-  readOnly: false

csaxs_bec/device_configs/lamni_config.yaml

@@ -0,0 +1,261 @@
+############################################################
+#################### LamNI Galil motors ####################
+############################################################
+
+leyex:
+  description: Xray eye X
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: G
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: 14.117
+leyey:
+  description: Xray eye Y
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: H
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: 48.069
+    out: 0.5
+loptx:
+  description: Optics X
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: E
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: 1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: -0.244
+    out: -0.699
+lopty:
+  description: Optics Y
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: F
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: 1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: 3.724
+    out: 3.53
+loptz:
+  description: Optics Z
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: D
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+lsamrot:
+  description: Sample rotation
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: C
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: 1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+lsamx:
+  description: Sample coarse X
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: A
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    center: 8.768
+lsamy:
+  description: Sample coarse Y
+  deviceClass: csaxs_bec.devices.omny.galil.lgalil_ophyd.LamniGalilMotor
+  deviceConfig:
+    axis_Id: B
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8081
+    sign: 1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    center: 10.041
+
+
+############################################################
+################ LamNI Smaract motors ######################
+############################################################
+
+losax:
+  description: OSA X
+  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
+  deviceConfig:
+    axis_Id: A
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8085
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: -1.442
+losay:
+  description: OSA Y
+  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
+  deviceConfig:
+    axis_Id: B
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8085
+    sign: -1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: -0.171
+    out: 3.8
+losaz:
+  description: OSA Z
+  deviceClass: csaxs_bec.devices.smaract.smaract_ophyd.SmaractMotor
+  deviceConfig:
+    axis_Id: C
+    host: mpc2680.psi.ch
+    limits:
+      - 0
+      - 0
+    port: 8085
+    sign: 1
+  deviceTags:
+  - lamni
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  userParameter:
+    in: -1
+    out: -3
+
+############################################################
+#################### flOMNI RT motors ######################
+############################################################
+
+rtx:
+  deviceClass: csaxs_bec.devices.omny.rt.rt_lamni_ophyd.RtLamniMotor
+  deviceConfig:
+    axis_Id: A
+    device_access: true
+    host: mpc2680.psi.ch
+    labels: rtx
+    limits:
+    - 0
+    - 0
+    port: 3333
+    sign: 1
+  deviceTags:
+  - lamni
+  readoutPriority: baseline
+  enabled: true
+  readOnly: False
+rty:
+  deviceClass: csaxs_bec.devices.omny.rt.rt_lamni_ophyd.RtLamniMotor
+  deviceConfig:
+    axis_Id: B
+    device_access: true
+    host: mpc2680.psi.ch
+    labels: rty
+    limits:
+    - 0
+    - 0
+    port: 3333
+    sign: 1
+  deviceTags:
+  - lamni
+  readoutPriority: baseline
+  enabled: true
+  readOnly: False
+
+

csaxs_bec/device_configs/npoint_template.yaml

@@ -0,0 +1,38 @@
+############################################################
+#################### npoint motors #########################
+############################################################
+
+npx:
+  description: nPoint x axis on the big npoint controller
+  deviceClass: csaxs_bec.devices.npoint.npoint.NPointAxis
+  deviceConfig:
+    axis_Id: A
+    host: "nPoint000003.psi.ch"
+    limits:
+    - -50
+    - 50
+    port: 23
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  deviceTags:
+  - npoint
+npy:
+  description: nPoint y axis on the big npoint controller
+  deviceClass: csaxs_bec.devices.npoint.npoint.NPointAxis
+  deviceConfig:
+    axis_Id: B
+    host: "nPoint000003.psi.ch"
+    limits:
+    - -50
+    - 50
+    port: 23
+    sign: 1
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline
+  deviceTags:
+  - npoint

csaxs_bec/device_configs/omny_config.yaml

@@ -0,0 +1,8 @@
+omny_samples:
+  description: OMNYSampleStorage
+  deviceClass: csaxs_bec.devices.omny.omny_sample_storage.OMNYSampleStorage 
+  deviceConfig: {}
+  enabled: true
+  onFailure: buffer
+  readOnly: false
+  readoutPriority: baseline

csaxs_bec/device_configs/x12sa_database.yml

@@ -220,7 +220,7 @@ bm5try:
   softwareTrigger: false
 bpm1:
   description: 'XBPM 1: Somewhere around mono (VME)'
-  deviceClass: csaxs_bec.devices.epics.devices.XbpmBase.XbpmCsaxsOp
+  deviceClass: csaxs_bec.devices.epics.XbpmBase.XbpmCsaxsOp
   deviceConfig:
     prefix: 'X12SA-OP-BPM2:'
   deviceTags:
@@ -242,7 +242,7 @@ bpm1i:
   softwareTrigger: false
 bpm2:
   description: 'XBPM 2: Somewhere around mono (VME)'
-  deviceClass: csaxs_bec.devices.epics.devices.XbpmBase.XbpmCsaxsOp
+  deviceClass: csaxs_bec.devices.epics.XbpmBase.XbpmCsaxsOp
   deviceConfig:
     prefix: 'X12SA-OP-BPM2:'
   deviceTags:
@@ -605,7 +605,7 @@ dtpush:
   softwareTrigger: false
 dtth:
   description: Detector tower tilt rotation
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.PmDetectorRotation
+  deviceClass: csaxs_bec.devices.epics.specMotors.PmDetectorRotation
   deviceConfig:
     prefix: X12SA-ES1-DETT:ROX1
   deviceTags:
@@ -880,7 +880,7 @@ fttrz:
   softwareTrigger: false
 idgap:
   description: Undulator gap size [mm]
-  deviceClass: csaxs_bec.devices.epics.devices.InsertionDevice.InsertionDevice
+  deviceClass: csaxs_bec.devices.epics.InsertionDevice.InsertionDevice
   deviceConfig:
     prefix: X12SA-ID
   deviceTags:
@@ -979,7 +979,7 @@ mitry3:
   softwareTrigger: false
 mobd:
   description: Monochromator bender virtual motor
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.PmMonoBender
+  deviceClass: csaxs_bec.devices.epics.specMotors.PmMonoBender
   deviceConfig:
     prefix: 'X12SA-OP-MO:'
   deviceTags:
@@ -1034,7 +1034,7 @@ mobddi:
   softwareTrigger: false
 mokev:
   description: Monochromator energy in keV
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.EnergyKev
+  deviceClass: csaxs_bec.devices.epics.specMotors.EnergyKev
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX2
   deviceTags:
@@ -1089,7 +1089,7 @@ moroll2:
   softwareTrigger: false
 moth1:
   description: Monochromator Theta 1
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.MonoTheta1
+  deviceClass: csaxs_bec.devices.epics.specMotors.MonoTheta1
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX1
   deviceTags:
@@ -1111,7 +1111,7 @@ moth1e:
   softwareTrigger: false
 moth2:
   description: Monochromator Theta 2
-  deviceClass: csaxs_bec.devices.epics.devices.specMotors.MonoTheta2
+  deviceClass: csaxs_bec.devices.epics.specMotors.MonoTheta2
   deviceConfig:
     read_pv: X12SA-OP-MO:ROX2
   deviceTags:
@@ -1230,17 +1230,17 @@ sec:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl0h:
-  description: FrontEnd slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-FE-SH1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl0h:
+#   description: FrontEnd slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-FE-SH1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl0trxi:
   description: FrontEnd slit inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1263,17 +1263,17 @@ sl0trxo:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl1h:
-  description: OpticsHutch slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-OP-SH1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl1h:
+#   description: OpticsHutch slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SH1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl1trxi:
   description: OpticsHutch slit inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1318,28 +1318,28 @@ sl1tryt:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl1v:
-  description: OpticsHutch slit virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitV
-  deviceConfig:
-    prefix: 'X12SA-OP-SV1:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sl2h:
-  description: OpticsHutch slit 2 virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitH
-  deviceConfig:
-    prefix: 'X12SA-OP-SH2:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl1v:
+#   description: OpticsHutch slit virtual movement
+#   deviceClass: ophyd_devices.devices.SlitV
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SV1:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sl2h:
+#   description: OpticsHutch slit 2 virtual movement
+#   deviceClass: ophyd_devices.devices.SlitH
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SH2:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 sl2trxi:
   description: OpticsHutch slit 2 inner blade movement
   deviceClass: ophyd.EpicsMotor
@@ -1384,72 +1384,72 @@ sl2tryt:
   onFailure: buffer
   readoutPriority: baseline
   softwareTrigger: false
-sl2v:
-  description: OpticsHutch slit 2 virtual movement
-  deviceClass: ophyd_devices.epics.devices.SlitV
-  deviceConfig:
-    prefix: 'X12SA-OP-SV2:'
-  deviceTags:
-  - epicsDevice
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-strox:
-  description: Girder virtual pitch
-  deviceClass: ophyd_devices.epics.devices.GirderMotorPITCH
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-stroy:
-  description: Girder virtual yaw
-  deviceClass: ophyd_devices.epics.devices.GirderMotorYAW
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-stroz:
-  description: Girder virtual roll
-  deviceClass: ophyd_devices.epics.devices.GirderMotorROLL
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sttrx:
-  description: Girder X translation
-  deviceClass: ophyd_devices.epics.devices.GirderMotorX1
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
-sttry:
-  description: Girder Y translation
-  deviceClass: ophyd_devices.epics.devices.GirderMotorY1
-  deviceConfig:
-    prefix: X12SA-HG
-  deviceTags:
-  - beamlineMotor
-  enabled: true
-  onFailure: buffer
-  readoutPriority: baseline
-  softwareTrigger: false
+# sl2v:
+#   description: OpticsHutch slit 2 virtual movement
+#   deviceClass: ophyd_devices.devices.SlitV
+#   deviceConfig:
+#     prefix: 'X12SA-OP-SV2:'
+#   deviceTags:
+#   - epicsDevice
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# strox:
+#   description: Girder virtual pitch
+#   deviceClass: ophyd_devices.devices.GirderMotorPITCH
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# stroy:
+#   description: Girder virtual yaw
+#   deviceClass: ophyd_devices.devices.GirderMotorYAW
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# stroz:
+#   description: Girder virtual roll
+#   deviceClass: ophyd_devices.devices.GirderMotorROLL
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sttrx:
+#   description: Girder X translation
+#   deviceClass: ophyd_devices.devices.GirderMotorX1
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
+# sttry:
+#   description: Girder Y translation
+#   deviceClass: ophyd_devices.devices.GirderMotorY1
+#   deviceConfig:
+#     prefix: X12SA-HG
+#   deviceTags:
+#   - beamlineMotor
+#   enabled: true
+#   onFailure: buffer
+#   readoutPriority: baseline
+#   softwareTrigger: false
 transd:
   description: Transmission diode
   deviceClass: ophyd.EpicsSignalRO

csaxs_bec/devices/device_list.md

@@ -0,0 +1,38 @@
+// This file was autogenerated. Do not edit it manually.
+## Device List
+### csaxs_bec 
+| Device | Documentation | Module |
+| :----- | :------------- | :------ |
+| Bpm4i |  | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| DelayGeneratorcSAXS | <br>    DG645 delay generator at cSAXS (multiple can be in use depending on the setup)<br><br>    Default values for setting up DDG.<br>    Note: checks of set calues are not (only partially) included, check manual for details on possible settings.<br>    https://www.thinksrs.com/downloads/pdfs/manuals/DG645m.pdf<br><br>    - delay_burst               : (float >=0) Delay between trigger and first pulse in burst mode<br>    - delta_width               : (float >= 0) Add width to fast shutter signal to make sure its open during acquisition<br>    - additional_triggers       : (int) add additional triggers to burst mode (mcs card needs +1 triggers per line)<br>    - polarity                  : (list of 0/1) polarity for different channels<br>    - amplitude                 : (float) amplitude voltage of TTLs<br>    - offset                    : (float) offset for ampltitude<br>    - thres_trig_level          : (float) threshold of trigger amplitude<br><br>    Custom signals for logic in different DDGs during scans (for custom_prepare.prepare_ddg):<br><br>    - set_high_on_exposure      : (bool): if True, then TTL signal should go high during the full acquisition time of a scan.<br>    # TODO trigger_width and fixed_ttl could be combined into single list.<br>    - fixed_ttl_width           : (list of either 1 or 0), one for each channel.<br>    - trigger_width             : (float) if fixed_ttl_width is True, then the width of the TTL pulse is set to this value.<br>    - set_trigger_source        : (TriggerSource) specifies the default trigger source for the DDG.<br>    - premove_trigger           : (bool) if True, then a trigger should be executed before the scan starts (to be implemented in on_pre_scan).<br>    - set_high_on_stage         : (bool) if True, then TTL signal should go high already on stage.<br>     | [csaxs_bec.devices.epics.delay_generator_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/delay_generator_csaxs.py) |
+| Eiger1p5MDetector |  | [csaxs_bec.devices.omny.eiger1p5m](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/eiger1p5m.py) |
+| Eiger9McSAXS | <br>    Eiger9M detector for CSAXS<br><br>    Parent class: PSIDetectorBase<br><br>    class attributes:<br>        custom_prepare_cls (FalconSetup)        : Custom detector setup class for cSAXS,<br>                                                  inherits from CustomDetectorMixin<br>        PSIDetectorBase.set_min_readout (float) : Minimum readout time for the detector<br>        Various EpicsPVs for controlling the detector<br>     | [csaxs_bec.devices.epics.eiger9m_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/eiger9m_csaxs.py) |
+| EpicsDXPFalcon | <br>    DXP parameters for Falcon detector<br><br>    Base class to map EPICS PVs from DXP parameters to ophyd signals.<br>     | [csaxs_bec.devices.epics.falcon_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/falcon_csaxs.py) |
+| FalconcSAXS | <br>    Falcon Sitoro detector for CSAXS<br><br>    Parent class: PSIDetectorBase<br><br>    class attributes:<br>        custom_prepare_cls (FalconSetup)        : Custom detector setup class for cSAXS,<br>                                                  inherits from CustomDetectorMixin<br>        PSIDetectorBase.set_min_readout (float) : Minimum readout time for the detector<br>        dxp (EpicsDXPFalcon)                    : DXP parameters for Falcon detector<br>        mca (EpicsMCARecord)                    : MCA parameters for Falcon detector<br>        hdf5 (FalconHDF5Plugins)                : HDF5 parameters for Falcon detector<br>        MIN_READOUT (float)                     : Minimum readout time for the detector<br>     | [csaxs_bec.devices.epics.falcon_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/falcon_csaxs.py) |
+| FalconHDF5Plugins | <br>    HDF5 parameters for Falcon detector<br><br>    Base class to map EPICS PVs from HDF5 Plugin to ophyd signals.<br>     | [csaxs_bec.devices.epics.falcon_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/falcon_csaxs.py) |
+| FlomniGalilMotor |  | [csaxs_bec.devices.omny.galil.fgalil_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/galil/fgalil_ophyd.py) |
+| FlomniSampleStorage |  | [csaxs_bec.devices.omny.flomni_sample_storage](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/flomni_sample_storage.py) |
+| FuprGalilMotor |  | [csaxs_bec.devices.omny.galil.fupr_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/galil/fupr_ophyd.py) |
+| GirderMotorPITCH | Girder YAW pseudo motor | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| GirderMotorROLL | Girder ROLL pseudo motor | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| GirderMotorX1 | Girder X translation pseudo motor | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| GirderMotorY1 | Girder Y translation pseudo motor | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| GirderMotorYAW | Girder YAW pseudo motor | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| InsertionDevice | Python wrapper for the CSAXS insertion device control<br><br>    This wrapper provides a positioner interface for the ID control.<br>    is completely custom XBPM with templates directly in the<br>    VME repo. Thus it needs a custom ophyd template as well...<br><br>    WARN: The x and y are not updated by the IOC<br>     | [csaxs_bec.devices.epics.InsertionDevice](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/InsertionDevice.py) |
+| LamniGalilMotor |  | [csaxs_bec.devices.omny.galil.lgalil_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/galil/lgalil_ophyd.py) |
+| MCScSAXS | MCS card for cSAXS for implementation at cSAXS beamline | [csaxs_bec.devices.epics.mcs_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/mcs_csaxs.py) |
+| NPointAxis | <br>    NPointAxis class, which inherits from Device and PositionerBase. This class<br>    represents an axis of an nPoint piezo stage and provides the necessary<br>    functionality to move the axis and read its current position.<br>     | [csaxs_bec.devices.npoint.npoint](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/npoint/npoint.py) |
+| OMNYSampleStorage |  | [csaxs_bec.devices.omny.omny_sample_storage](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/omny_sample_storage.py) |
+| PilatuscSAXS | Pilatus_2 300k detector for CSAXS<br><br>    Parent class: PSIDetectorBase<br><br>    class attributes:<br>        custom_prepare_cls (Eiger9MSetup)   : Custom detector setup class for cSAXS,<br>                                              inherits from CustomDetectorMixin<br>        cam (SLSDetectorCam)                : Detector camera<br>        MIN_READOUT (float)                 : Minimum readout time for the detector<br><br>     | [csaxs_bec.devices.epics.pilatus_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/pilatus_csaxs.py) |
+| PmDetectorRotation | Detector rotation pseudo motor<br><br>    Small wrapper to convert detector pusher position to rotation angle.<br>     | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| PmMonoBender | Monochromator bender<br><br>    Small wrapper to combine the four monochromator bender motors.<br>     | [csaxs_bec.devices.epics.specMotors](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/specMotors.py) |
+| RtFlomniMotor |  | [csaxs_bec.devices.omny.rt.rt_flomni_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/rt/rt_flomni_ophyd.py) |
+| RtLamniMotor |  | [csaxs_bec.devices.omny.rt.rt_lamni_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/rt/rt_lamni_ophyd.py) |
+| SGalilMotor |  "SGalil Motors at cSAXS have a<br>    DC motor (y axis - vertical) - implemented as C<br>    and a step motor (x-axis horizontal) - implemented as E<br>    that require different communication for control<br>     | [csaxs_bec.devices.omny.galil.sgalil_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/omny/galil/sgalil_ophyd.py) |
+| SIS38XX | SIS38XX card for access to EPICs PVs at cSAXS beamline | [csaxs_bec.devices.epics.mcs_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/mcs_csaxs.py) |
+| SLSDetectorCam | SLS Detector Camera - Pilatus<br><br>    Base class to map EPICS PVs to ophyd signals.<br>     | [csaxs_bec.devices.epics.pilatus_csaxs](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/pilatus_csaxs.py) |
+| SmaractMotor |  | [csaxs_bec.devices.smaract.smaract_ophyd](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/smaract/smaract_ophyd.py) |
+| XbpmBase | Python wrapper for X-ray Beam Position Monitors<br><br>    XBPM's consist of a metal-coated diamond window that ejects<br>    photoelectrons from the incoming X-ray beam. These electons<br>    are collected and their current is measured. Effectively<br>    they act as four quadrant photodiodes and are used as BPMs<br>    at the undulator beamlines of SLS.<br><br>    Note: EPICS provided signals are read only, but the user can<br>    change the beam position offset.<br>     | [csaxs_bec.devices.epics.XbpmBase](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/XbpmBase.py) |
+| XbpmCsaxsOp | Python wrapper for custom XBPMs in the cSAXS optics hutch<br><br>    This is  completely custom XBPM with templates directly in the<br>    VME repo. Thus it needs a custom ophyd template as well...<br><br>    WARN: The x and y are not updated by the IOC<br>     | [csaxs_bec.devices.epics.XbpmBase](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/XbpmBase.py) |
+| XbpmSim | Python wrapper for simulated X-ray Beam Position Monitors<br><br>    XBPM's consist of a metal-coated diamond window that ejects<br>    photoelectrons from the incoming X-ray beam. These electons<br>    are collected and their current is measured. Effectively<br>    they act as four quadrant photodiodes and are used as BPMs<br>    at the undulator beamlines of SLS.<br><br>    Note: EPICS provided signals are read only, but the user can<br>       change the beam position offset.<br><br>    This simulation device extends the basic proxy with a script that<br>    fills signals with quasi-randomized values.<br>     | [csaxs_bec.devices.epics.XbpmBase](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/epics/XbpmBase.py) |
+| Xeye |  | [csaxs_bec.devices.sls_devices.cSAXS.xeye](https://gitlab.psi.ch/bec/csaxs_bec/-/blob/main/csaxs_bec/devices/sls_devices/cSAXS/xeye.py) |

csaxs_bec/devices/epics/__init__.py

@@ -1,8 +1 @@
-# Standard ophyd classes
-from ophyd import EpicsMotor, EpicsSignal, EpicsSignalRO
-from ophyd.quadem import QuadEM
-from ophyd.sim import SynAxis, SynPeriodicSignal, SynSignal
 
-from .devices.delay_generator_csaxs import DelayGeneratorcSAXS
-from .devices.flomni_sample_storage import FlomniSampleStorage
-from .devices.InsertionDevice import InsertionDevice

csaxs_bec/devices/epics/cSaxsVirtualMotors.py

@@ -0,0 +1,32 @@
+""" TODO This class seems to be missing various imports and appears to have not been tested in motion yet."""
+
+# TABLES_DT_PUSH_DIST_MM = 890
+
+
+# class DetectorTableTheta(PseudoPositioner):
+#     """Detector table tilt motor
+
+#     Small wrapper to adjust the detector table tilt as angle.
+#     The table is pushed from one side by a single vertical motor.
+
+#     Note: Rarely used!
+#     """
+
+#     # Real axis (in degrees)
+#     pusher = Component(EpicsMotor, "", name="pusher")
+#     # Virtual axis
+#     theta = Component(PseudoSingle, name="theta")
+
+#     _real = ["pusher"]
+
+#     @pseudo_position_argument
+#     def forward(self, pseudo_pos):
+#         return self.RealPosition(
+#             pusher=tan(pseudo_pos.theta * 3.141592 / 180.0) * TABLES_DT_PUSH_DIST_MM
+#         )
+
+#     @real_position_argument
+#     def inverse(self, real_pos):
+#         return self.PseudoPosition(
+#             theta=-180 * atan(real_pos.pusher / TABLES_DT_PUSH_DIST_MM) / 3.141592
+#         )

csaxs_bec/devices/epics/delay_generator_csaxs.py

@@ -0,0 +1,529 @@
+import time
+
+from bec_lib import bec_logger
+from ophyd import Component, DeviceStatus
+
+from ophyd_devices.interfaces.base_classes.psi_delay_generator_base import (
+    DDGCustomMixin,
+    PSIDelayGeneratorBase,
+    TriggerSource,
+)
+from ophyd_devices.utils import bec_utils
+
+logger = bec_logger.logger
+
+
+class DelayGeneratorError(Exception):
+    """Exception raised for errors."""
+
+
+# class DDGSetup(DDGCustomMixin):
+#     """
+#     Mixin class for DelayGenerator logic at cSAXS.
+
+#     At cSAXS, multiple DDGs were operated at the same time. There different behaviour is
+#         implemented in the ddg_config signals that are passed via the device config.
+#     """
+
+#     def initialize_default_parameter(self) -> None:
+#         """Method to initialize default parameters."""
+#         for ii, channel in enumerate(self.parent.all_channels):
+#             self.parent.set_channels("polarity", self.parent.polarity.get()[ii], [channel])
+
+#         self.parent.set_channels("amplitude", self.parent.amplitude.get())
+#         self.parent.set_channels("offset", self.parent.offset.get())
+#         # Setup reference
+#         self.parent.set_channels(
+#             "reference", 0, [f"channel{pair}.ch1" for pair in self.parent.all_delay_pairs]
+#         )
+#         self.parent.set_channels(
+#             "reference", 0, [f"channel{pair}.ch2" for pair in self.parent.all_delay_pairs]
+#         )
+#         self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
+#         # Set threshold level for ext. pulses
+#         self.parent.level.put(self.parent.thres_trig_level.get())
+
+#     def prepare_ddg(self) -> None:
+#         """
+#         Method to prepare scan logic of cSAXS
+
+#         Two scantypes are supported: "step" and "fly":
+#         - step: Scan is performed by stepping the motor and acquiring data at each step
+#         - fly: Scan is performed by moving the motor with a constant velocity and acquiring data
+
+#         Custom logic for different DDG behaviour during scans.
+
+#         - set_high_on_exposure      : If True, then TTL signal is high during
+#                                     the full exposure time of the scan (all frames).
+#                                     E.g. Keep shutter open for the full scan.
+#         - fixed_ttl_width           : fixed_ttl_width is a list of 5 values, one for each channel.
+#                                     If the value is 0, then the width of the TTL pulse is determined,
+#                                     no matter which parameters are passed from the scaninfo for exposure time
+#         - set_trigger_source        : Specifies the default trigger source for the DDG. For cSAXS, relevant ones
+#                                     were: SINGLE_SHOT, EXT_RISING_EDGE
+#         """
+#         self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
+#         # scantype "step"
+#         if self.parent.scaninfo.scan_type == "step":
+#             # High on exposure means that the signal
+#             if self.parent.set_high_on_exposure.get():
+#                 # caluculate parameters
+#                 num_burst_cycle = 1 + self.parent.additional_triggers.get()
+
+#                 exp_time = (
+#                     self.parent.delta_width.get()
+#                     + self.parent.scaninfo.frames_per_trigger
+#                     * (self.parent.scaninfo.exp_time + self.parent.scaninfo.readout_time)
+#                 )
+#                 total_exposure = exp_time
+#                 delay_burst = self.parent.delay_burst.get()
+
+#                 # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
+#                 if not self.parent.trigger_width.get():
+#                     self.parent.set_channels("width", exp_time)
+#                 else:
+#                     self.parent.set_channels("width", self.parent.trigger_width.get())
+#                 for value, channel in zip(
+#                     self.parent.fixed_ttl_width.get(), self.parent.all_channels
+#                 ):
+#                     logger.debug(f"Trying to set DDG {channel} to {value}")
+#                     if value != 0:
+#                         self.parent.set_channels("width", value, channels=[channel])
+#             else:
+#                 # caluculate parameters
+#                 exp_time = self.parent.delta_width.get() + self.parent.scaninfo.exp_time
+#                 total_exposure = exp_time + self.parent.scaninfo.readout_time
+#                 delay_burst = self.parent.delay_burst.get()
+#                 num_burst_cycle = (
+#                     self.parent.scaninfo.frames_per_trigger + self.parent.additional_triggers.get()
+#                 )
+
+#                 # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
+#                 if not self.parent.trigger_width.get():
+#                     self.parent.set_channels("width", exp_time)
+#                 else:
+#                     self.parent.set_channels("width", self.parent.trigger_width.get())
+#         # scantype "fly"
+#         elif self.parent.scaninfo.scan_type == "fly":
+#             if self.parent.set_high_on_exposure.get():
+#                 # caluculate parameters
+#                 exp_time = (
+#                     self.parent.delta_width.get()
+#                     + self.parent.scaninfo.exp_time * self.parent.scaninfo.num_points
+#                     + self.parent.scaninfo.readout_time * (self.parent.scaninfo.num_points - 1)
+#                 )
+#                 total_exposure = exp_time
+#                 delay_burst = self.parent.delay_burst.get()
+#                 num_burst_cycle = 1 + self.parent.additional_triggers.get()
+
+#                 # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
+#                 if not self.parent.trigger_width.get():
+#                     self.parent.set_channels("width", exp_time)
+#                 else:
+#                     self.parent.set_channels("width", self.parent.trigger_width.get())
+#                 for value, channel in zip(
+#                     self.parent.fixed_ttl_width.get(), self.parent.all_channels
+#                 ):
+#                     logger.debug(f"Trying to set DDG {channel} to {value}")
+#                     if value != 0:
+#                         self.parent.set_channels("width", value, channels=[channel])
+#             else:
+#                 # caluculate parameters
+#                 exp_time = self.parent.delta_width.get() + self.parent.scaninfo.exp_time
+#                 total_exposure = exp_time + self.parent.scaninfo.readout_time
+#                 delay_burst = self.parent.delay_burst.get()
+#                 num_burst_cycle = (
+#                     self.parent.scaninfo.num_points + self.parent.additional_triggers.get()
+#                 )
+
+#                 # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
+#                 if not self.parent.trigger_width.get():
+#                     self.parent.set_channels("width", exp_time)
+#                 else:
+#                     self.parent.set_channels("width", self.parent.trigger_width.get())
+
+#         else:
+#             raise Exception(f"Unknown scan type {self.parent.scaninfo.scan_type}")
+#         # Set common DDG parameters
+#         self.parent.burst_enable(num_burst_cycle, delay_burst, total_exposure, config="first")
+#         self.parent.set_channels("delay", 0.0)
+
+#     def on_trigger(self) -> None:
+#         """Method to be executed upon trigger"""
+#         if self.parent.source.read()[self.parent.source.name]["value"] == TriggerSource.SINGLE_SHOT:
+#             self.parent.trigger_shot.put(1)
+
+#     def check_scan_id(self) -> None:
+#         """
+#         Method to check if scan_id has changed.
+
+#         If yes, then it changes parent.stopped to True, which will stop further actions.
+#         """
+#         old_scan_id = self.parent.scaninfo.scan_id
+#         self.parent.scaninfo.load_scan_metadata()
+#         if self.parent.scaninfo.scan_id != old_scan_id:
+#             self.parent.stopped = True
+
+#     def finished(self) -> None:
+#         """Method checks if DDG finished acquisition"""
+
+#     def on_pre_scan(self) -> None:
+#         """
+#         Method called by pre_scan hook in parent class.
+
+#         Executes trigger if premove_trigger is Trus.
+#         """
+#         if self.parent.premove_trigger.get() is True:
+#             self.parent.trigger_shot.put(1)
+
+class DDGSetup(DDGCustomMixin):
+    """
+    Mixin class for DelayGenerator logic at cSAXS.
+
+    At cSAXS, multiple DDGs were operated at the same time. There different behaviour is
+        implemented in the ddg_config signals that are passed via the device config.
+    """
+
+    def initialize_default_parameter(self) -> None:
+        """Method to initialize default parameters."""
+        for ii, channel in enumerate(self.parent.all_channels):
+            self.parent.set_channels("polarity", self.parent.polarity.get()[ii], [channel])
+
+        self.parent.set_channels("amplitude", self.parent.amplitude.get())
+        self.parent.set_channels("offset", self.parent.offset.get())
+        # Setup reference
+        self.parent.set_channels(
+            "reference", 0, [f"channel{pair}.ch1" for pair in self.parent.all_delay_pairs]
+        )
+        self.parent.set_channels(
+            "reference", 0, [f"channel{pair}.ch2" for pair in self.parent.all_delay_pairs]
+        )
+        self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
+        # Set threshold level for ext. pulses
+        self.parent.level.put(self.parent.thres_trig_level.get())
+
+    def prepare_ddg(self) -> None:
+        self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
+        # scantype "jjf_test"
+        scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        if scan_name ==  "jjf_test":
+            # exp_time = self.parent.scaninfo.exp_time
+            # readout = self.parent.scaninfo.readout_time
+            # num_burst_cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["num_points"]
+            # total_exposure = exp_time+readout
+            exp_time = 480e-6#self.parent.scaninfo.exp_time
+            readout = 20e-6#self.parent.scaninfo.readout_time
+            total_exposure = exp_time+readout
+            num_burst_cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["num_points"]
+            num_burst_cycle = int(num_burst_cycle * self.parent.scaninfo.exp_time/total_exposure)
+            delay = 0 
+            delay_burst = self.parent.delay_burst.get()
+            
+            self.parent.set_trigger(trigger_source=TriggerSource.SINGLE_SHOT)
+            
+            self.parent.set_channels(signal='width', value=exp_time)
+            self.parent.set_channels(signal='delay', value=delay)
+            self.parent.burst_enable(count=num_burst_cycle, delay=delay_burst, period=total_exposure, config="first")
+            logger.info(f"{self.parent.name}: On stage with n_burst: {num_burst_cycle} and total_exp {total_exposure}")
+
+    def on_stage(self) -> None:
+        scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        if scan_name == "jjf_test":
+            exp_time = 480e-6#self.parent.scaninfo.exp_time
+            readout = 20e-6#self.parent.scaninfo.readout_time
+            total_exposure = exp_time+readout
+            num_burst_cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["num_points"]
+            num_burst_cycle = int(num_burst_cycle * self.parent.scaninfo.exp_time/total_exposure)
+            self.parent.set_channels("width", exp_time)
+            self.parent.set_channels("delay", 0.0)
+            logger.info(f"{self.parent.name}: On stage with n_burst: {num_burst_cycle} and total_exp {total_exposure}")
+            self.parent.burst_enable(num_burst_cycle, 0, total_exposure, config="first")     
+
+    def on_trigger(self) -> None:
+        """Method to be executed upon trigger"""
+        if self.parent.source.read()[self.parent.source.name]["value"] == TriggerSource.SINGLE_SHOT:
+            self.parent.trigger_shot.put(1)
+        scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        if scan_name == "jjf_test":
+            exp_time = 480e-6#self.parent.scaninfo.exp_time
+            readout = 20e-6#self.parent.scaninfo.readout_time
+            total_exposure = exp_time+readout
+            num_burst_cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["num_points"]
+            num_burst_cycle = int(num_burst_cycle * self.parent.scaninfo.exp_time/total_exposure)
+            cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["cycles"]
+            #time.sleep(num_burst_cycle*total_exposure)
+            def check_ddg()->int:
+                self.parent.trigger_burst_readout.put(1)
+                return self.parent.burst_cycle_finished.get()
+            status = self.wait_with_status(signal_conditions=[(check_ddg, 1)], 
+                                            timeout=num_burst_cycle*total_exposure+1,
+                                            check_stopped=True, 
+                                            exception_on_timeout=DelayGeneratorError(f"{self.parent.name} run into timeout in complete call.")
+                                            )
+            logger.info(f"Return status {self.parent.name}")
+            return status
+            # timer = 0
+            # while True:
+            #     self.parent.trigger_burst_readout.put(1)
+            #     state = self.parent.burst_cycle_finished.get()
+            #     if state == 1:
+            #         break
+            #     time.sleep(0.05)
+            #     timer +=0.05
+            #     if timer>3:
+            #         raise TimeoutError(f"{self.parent.name} did not return. Bit state for end_burst_cycle is {state} for state")
+
+
+    def on_complete(self) -> DeviceStatus:
+        pass
+        # logger.info(f"On complete started for {self.parent.name}")
+        # scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        # if scan_name != "jjf_test":
+        #     return None
+        # def check_ddg()->int:
+        #     lambda r : self.parent.trigger_burst_readout.put(1)
+        #     return lambda r: self.parent.burst_cycle_finished.get()
+        # status = self.wait_with_status(signal_conditions=[(check_ddg, 1)], 
+        #                                 timeout=3,
+        #                                 check_stopped=True, 
+        #                                 exception_on_timeout=DelayGeneratorError(f"{self.parent.name} run into timeout in complete call.")
+        #                                 )
+        # logger.info(f"Return status {self.parent.name}")
+        # return status
+
+    def check_scan_id(self) -> None:
+        """
+        Method to check if scan_id has changed.
+
+        If yes, then it changes parent.stopped to True, which will stop further actions.
+        """
+        old_scan_id = self.parent.scaninfo.scan_id
+        self.parent.scaninfo.load_scan_metadata()
+        if self.parent.scaninfo.scan_id != old_scan_id:
+            self.parent.stopped = True
+
+    def finished(self) -> None:
+        """Method checks if DDG finished acquisition"""
+
+    def on_pre_scan(self) -> None:
+        """
+        Method called by pre_scan hook in parent class.
+
+        Executes trigger if premove_trigger is Trus.
+        """
+        if self.parent.premove_trigger.get() is True:
+            self.parent.trigger_shot.put(1)
+
+
+class DelayGeneratorcSAXS(PSIDelayGeneratorBase):
+    """
+    DG645 delay generator at cSAXS (multiple can be in use depending on the setup)
+
+    Default values for setting up DDG.
+    Note: checks of set calues are not (only partially) included, check manual for details on possible settings.
+    https://www.thinksrs.com/downloads/pdfs/manuals/DG645m.pdf
+
+    - delay_burst               : (float >=0) Delay between trigger and first pulse in burst mode
+    - delta_width               : (float >= 0) Add width to fast shutter signal to make sure its open during acquisition
+    - additional_triggers       : (int) add additional triggers to burst mode (mcs card needs +1 triggers per line)
+    - polarity                  : (list of 0/1) polarity for different channels
+    - amplitude                 : (float) amplitude voltage of TTLs
+    - offset                    : (float) offset for ampltitude
+    - thres_trig_level          : (float) threshold of trigger amplitude
+
+    Custom signals for logic in different DDGs during scans (for custom_prepare.prepare_ddg):
+
+    - set_high_on_exposure      : (bool): if True, then TTL signal should go high during the full acquisition time of a scan.
+    # TODO trigger_width and fixed_ttl could be combined into single list.
+    - fixed_ttl_width           : (list of either 1 or 0), one for each channel.
+    - trigger_width             : (float) if fixed_ttl_width is True, then the width of the TTL pulse is set to this value.
+    - set_trigger_source        : (TriggerSource) specifies the default trigger source for the DDG.
+    - premove_trigger           : (bool) if True, then a trigger should be executed before the scan starts (to be implemented in on_pre_scan).
+    - set_high_on_stage         : (bool) if True, then TTL signal should go high already on stage.
+    """
+
+    custom_prepare_cls = DDGSetup
+
+
+    delay_burst = Component(
+        bec_utils.ConfigSignal, name="delay_burst", kind="config", config_storage_name="ddg_config"
+    )
+
+    delta_width = Component(
+        bec_utils.ConfigSignal, name="delta_width", kind="config", config_storage_name="ddg_config"
+    )
+
+    additional_triggers = Component(
+        bec_utils.ConfigSignal,
+        name="additional_triggers",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    polarity = Component(
+        bec_utils.ConfigSignal, name="polarity", kind="config", config_storage_name="ddg_config"
+    )
+
+    fixed_ttl_width = Component(
+        bec_utils.ConfigSignal,
+        name="fixed_ttl_width",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    amplitude = Component(
+        bec_utils.ConfigSignal, name="amplitude", kind="config", config_storage_name="ddg_config"
+    )
+
+    offset = Component(
+        bec_utils.ConfigSignal, name="offset", kind="config", config_storage_name="ddg_config"
+    )
+
+    thres_trig_level = Component(
+        bec_utils.ConfigSignal,
+        name="thres_trig_level",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    set_high_on_exposure = Component(
+        bec_utils.ConfigSignal,
+        name="set_high_on_exposure",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    set_high_on_stage = Component(
+        bec_utils.ConfigSignal,
+        name="set_high_on_stage",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    set_trigger_source = Component(
+        bec_utils.ConfigSignal,
+        name="set_trigger_source",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    trigger_width = Component(
+        bec_utils.ConfigSignal,
+        name="trigger_width",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+    premove_trigger = Component(
+        bec_utils.ConfigSignal,
+        name="premove_trigger",
+        kind="config",
+        config_storage_name="ddg_config",
+    )
+
+    def __init__(
+        self,
+        prefix="",
+        *,
+        name,
+        kind=None,
+        read_attrs=None,
+        configuration_attrs=None,
+        parent=None,
+        device_manager=None,
+        ddg_config=None,
+        **kwargs,
+    ):
+        """
+        Args:
+            prefix (str, optional): Prefix of the device. Defaults to "".
+            name (str): Name of the device.
+            kind (str, optional): Kind of the device. Defaults to None.
+            read_attrs (list, optional): List of attributes to read. Defaults to None.
+            configuration_attrs (list, optional): List of attributes to configure. Defaults to None.
+            parent (Device, optional): Parent device. Defaults to None.
+            device_manager (DeviceManagerBase, optional): DeviceManagerBase object. Defaults to None.
+            sim_mode (bool, optional): Simulation mode flag. Defaults to False.
+            ddg_config (dict, optional): Dictionary of ddg_config signals. Defaults to None.
+
+        """
+        # Default values for ddg_config signals
+        self.ddg_config = {
+            # Setup default values
+            f"{name}_delay_burst": 0,
+            f"{name}_delta_width": 0,
+            f"{name}_additional_triggers": 0,
+            f"{name}_polarity": [1, 1, 1, 1, 1],
+            f"{name}_amplitude": 4.5,
+            f"{name}_offset": 0,
+            f"{name}_thres_trig_level": 2.5,
+            # Values for different behaviour during scans
+            f"{name}_fixed_ttl_width": [0, 0, 0, 0, 0],
+            f"{name}_trigger_width": None,
+            f"{name}_set_high_on_exposure": False,
+            f"{name}_set_high_on_stage": False,
+            f"{name}_set_trigger_source": "SINGLE_SHOT",
+            f"{name}_premove_trigger": False,
+        }
+        if ddg_config is not None:
+            # pylint: disable=expression-not-assigned
+            [self.ddg_config.update({f"{name}_{key}": value}) for key, value in ddg_config.items()]
+        super().__init__(
+            prefix=prefix,
+            name=name,
+            kind=kind,
+            read_attrs=read_attrs,
+            configuration_attrs=configuration_attrs,
+            parent=parent,
+            device_manager=device_manager,
+            **kwargs,
+        )
+
+
+if __name__ == "__main__":
+    # Start delay generator in simulation mode.
+    # Note: To run, access to Epics must be available.
+    import time
+    config = {
+        "delay_burst": 40.0e-3,
+        "delta_width": 0,
+        "additional_triggers": 0,
+        "polarity": [1, 0, 1, 1, 1],  # T0  # to eiger and lecroy4
+        "amplitude": 4.5,
+        "offset": 0,
+        "thres_trig_level": 2.5,
+        "set_high_on_exposure": False,
+        "set_high_on_stage": False,
+    }
+    start = time.time()
+    print(f"Start with init of DDG3 with config: {config}")
+    dgen = DelayGeneratorcSAXS("X12SA-CPCL-DDG3:", name="dgen", ddg_config=config)
+    print(f"Finished init after: {time.time()-start}s")
+    start = time.time()
+    print(f"Start setting up DDG3")
+    exp_time = 1/(2e3) # 2 kHz
+    readout = exp_time/10
+    delay = 0 
+    num_burst_cycle = 1e4 # N triggers
+    total_exposure = exp_time+readout
+    delay_burst = dgen.delay_burst.get()
+    dgen.set_trigger(trigger_source=TriggerSource.SINGLE_SHOT)
+    
+    dgen.set_channels(signal='width', value=exp_time)
+    dgen.set_channels(signal='delay', value=0)
+    dgen.burst_enable(count=num_burst_cycle, delay=delay_burst, period=total_exposure, config="first")
+    print(f"Start sending {num_burst_cycle} triggers after {time.time()-start}s, ETA {num_burst_cycle*total_exposure}s")
+    break_time = time.time()
+    dgen.trigger()
+    # Wait here briefly for status to finish, whether this is realiable has to be tested
+    time.sleep(num_burst_cycle*total_exposure)
+    timer = 0
+    while True:
+        dgen.trigger_burst_readout.put(1)
+        state = dgen.burst_cycle_finished.get()
+        if state == 1:
+            break
+        time.sleep(0.05)
+        timer +=0.05
+        if timer>3:
+            raise TimeoutError(f"dgen.name did not return with value {state} for state")
+    print(f"Finished trigger cascade of {num_burst_cycle} with {exp_time}s -> {num_burst_cycle*exp_time}s after {time.time()-start}s in total, {break_time} for sending triggers.")

csaxs_bec/devices/epics/devices/__init__.py

@@ -1,14 +0,0 @@
-# Standard ophyd classes
-from ophyd import EpicsMotor, EpicsSignal, EpicsSignalRO
-from ophyd.quadem import QuadEM
-from ophyd.sim import SynAxis, SynPeriodicSignal, SynSignal
-
-from .delay_generator_csaxs import DelayGeneratorcSAXS
-from .eiger9m_csaxs import Eiger9McSAXS
-
-# cSAXS
-from .falcon_csaxs import FalconcSAXS
-from .flomni_sample_storage import FlomniSampleStorage
-from .InsertionDevice import InsertionDevice
-from .mcs_csaxs import MCScSAXS
-from .pilatus_csaxs import PilatuscSAXS

csaxs_bec/devices/epics/devices/cSaxsVirtualMotors.py

@@ -1,32 +0,0 @@
-""" TODO This class seems to be missing various imports and appears to have not been tested in motion yet."""
-
-TABLES_DT_PUSH_DIST_MM = 890
-
-
-class DetectorTableTheta(PseudoPositioner):
-    """Detector table tilt motor
-
-    Small wrapper to adjust the detector table tilt as angle.
-    The table is pushed from one side by a single vertical motor.
-
-    Note: Rarely used!
-    """
-
-    # Real axis (in degrees)
-    pusher = Component(EpicsMotor, "", name="pusher")
-    # Virtual axis
-    theta = Component(PseudoSingle, name="theta")
-
-    _real = ["pusher"]
-
-    @pseudo_position_argument
-    def forward(self, pseudo_pos):
-        return self.RealPosition(
-            pusher=tan(pseudo_pos.theta * 3.141592 / 180.0) * TABLES_DT_PUSH_DIST_MM
-        )
-
-    @real_position_argument
-    def inverse(self, real_pos):
-        return self.PseudoPosition(
-            theta=-180 * atan(real_pos.pusher / TABLES_DT_PUSH_DIST_MM) / 3.141592
-        )

csaxs_bec/devices/epics/devices/delay_generator_csaxs.py

@@ -1,345 +0,0 @@
-from bec_lib import bec_logger
-from ophyd import Component
-from ophyd_devices.epics.devices.psi_delay_generator_base import (
-    DDGCustomMixin,
-    PSIDelayGeneratorBase,
-    TriggerSource,
-)
-from ophyd_devices.utils import bec_utils
-
-logger = bec_logger.logger
-
-
-class DelayGeneratorError(Exception):
-    """Exception raised for errors."""
-
-
-class DDGSetup(DDGCustomMixin):
-    """
-    Mixin class for DelayGenerator logic at cSAXS.
-
-    At cSAXS, multiple DDGs were operated at the same time. There different behaviour is
-        implemented in the ddg_config signals that are passed via the device config.
-    """
-
-    def initialize_default_parameter(self) -> None:
-        """Method to initialize default parameters."""
-        for ii, channel in enumerate(self.parent.all_channels):
-            self.parent.set_channels("polarity", self.parent.polarity.get()[ii], [channel])
-
-        self.parent.set_channels("amplitude", self.parent.amplitude.get())
-        self.parent.set_channels("offset", self.parent.offset.get())
-        # Setup reference
-        self.parent.set_channels(
-            "reference", 0, [f"channel{pair}.ch1" for pair in self.parent.all_delay_pairs]
-        )
-        self.parent.set_channels(
-            "reference", 0, [f"channel{pair}.ch2" for pair in self.parent.all_delay_pairs]
-        )
-        self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
-        # Set threshold level for ext. pulses
-        self.parent.level.put(self.parent.thres_trig_level.get())
-
-    def prepare_ddg(self) -> None:
-        """
-        Method to prepare scan logic of cSAXS
-
-        Two scantypes are supported: "step" and "fly":
-        - step: Scan is performed by stepping the motor and acquiring data at each step
-        - fly: Scan is performed by moving the motor with a constant velocity and acquiring data
-
-        Custom logic for different DDG behaviour during scans.
-
-        - set_high_on_exposure      : If True, then TTL signal is high during
-                                    the full exposure time of the scan (all frames).
-                                    E.g. Keep shutter open for the full scan.
-        - fixed_ttl_width           : fixed_ttl_width is a list of 5 values, one for each channel.
-                                    If the value is 0, then the width of the TTL pulse is determined,
-                                    no matter which parameters are passed from the scaninfo for exposure time
-        - set_trigger_source        : Specifies the default trigger source for the DDG. For cSAXS, relevant ones
-                                    were: SINGLE_SHOT, EXT_RISING_EDGE
-        """
-        self.parent.set_trigger(getattr(TriggerSource, self.parent.set_trigger_source.get()))
-        # scantype "step"
-        if self.parent.scaninfo.scan_type == "step":
-            # High on exposure means that the signal
-            if self.parent.set_high_on_exposure.get():
-                # caluculate parameters
-                num_burst_cycle = 1 + self.parent.additional_triggers.get()
-
-                exp_time = (
-                    self.parent.delta_width.get()
-                    + self.parent.scaninfo.frames_per_trigger
-                    * (self.parent.scaninfo.exp_time + self.parent.scaninfo.readout_time)
-                )
-                total_exposure = exp_time
-                delay_burst = self.parent.delay_burst.get()
-
-                # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
-                if not self.parent.trigger_width.get():
-                    self.parent.set_channels("width", exp_time)
-                else:
-                    self.parent.set_channels("width", self.parent.trigger_width.get())
-                for value, channel in zip(
-                    self.parent.fixed_ttl_width.get(), self.parent.all_channels
-                ):
-                    logger.debug(f"Trying to set DDG {channel} to {value}")
-                    if value != 0:
-                        self.parent.set_channels("width", value, channels=[channel])
-            else:
-                # caluculate parameters
-                exp_time = self.parent.delta_width.get() + self.parent.scaninfo.exp_time
-                total_exposure = exp_time + self.parent.scaninfo.readout_time
-                delay_burst = self.parent.delay_burst.get()
-                num_burst_cycle = (
-                    self.parent.scaninfo.frames_per_trigger + self.parent.additional_triggers.get()
-                )
-
-                # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
-                if not self.parent.trigger_width.get():
-                    self.parent.set_channels("width", exp_time)
-                else:
-                    self.parent.set_channels("width", self.parent.trigger_width.get())
-        # scantype "fly"
-        elif self.parent.scaninfo.scan_type == "fly":
-            if self.parent.set_high_on_exposure.get():
-                # caluculate parameters
-                exp_time = (
-                    self.parent.delta_width.get()
-                    + self.parent.scaninfo.exp_time * self.parent.scaninfo.num_points
-                    + self.parent.scaninfo.readout_time * (self.parent.scaninfo.num_points - 1)
-                )
-                total_exposure = exp_time
-                delay_burst = self.parent.delay_burst.get()
-                num_burst_cycle = 1 + self.parent.additional_triggers.get()
-
-                # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
-                if not self.parent.trigger_width.get():
-                    self.parent.set_channels("width", exp_time)
-                else:
-                    self.parent.set_channels("width", self.parent.trigger_width.get())
-                for value, channel in zip(
-                    self.parent.fixed_ttl_width.get(), self.parent.all_channels
-                ):
-                    logger.debug(f"Trying to set DDG {channel} to {value}")
-                    if value != 0:
-                        self.parent.set_channels("width", value, channels=[channel])
-            else:
-                # caluculate parameters
-                exp_time = self.parent.delta_width.get() + self.parent.scaninfo.exp_time
-                total_exposure = exp_time + self.parent.scaninfo.readout_time
-                delay_burst = self.parent.delay_burst.get()
-                num_burst_cycle = (
-                    self.parent.scaninfo.num_points + self.parent.additional_triggers.get()
-                )
-
-                # Set individual channel widths, if fixed_ttl_width and trigger_width are combined, this can be a common call too
-                if not self.parent.trigger_width.get():
-                    self.parent.set_channels("width", exp_time)
-                else:
-                    self.parent.set_channels("width", self.parent.trigger_width.get())
-
-        else:
-            raise Exception(f"Unknown scan type {self.parent.scaninfo.scan_type}")
-        # Set common DDG parameters
-        self.parent.burst_enable(num_burst_cycle, delay_burst, total_exposure, config="first")
-        self.parent.set_channels("delay", 0.0)
-
-    def on_trigger(self) -> None:
-        """Method to be executed upon trigger"""
-        if self.parent.source.read()[self.parent.source.name]["value"] == TriggerSource.SINGLE_SHOT:
-            self.parent.trigger_shot.put(1)
-
-    def check_scan_id(self) -> None:
-        """
-        Method to check if scan_id has changed.
-
-        If yes, then it changes parent.stopped to True, which will stop further actions.
-        """
-        old_scan_id = self.parent.scaninfo.scan_id
-        self.parent.scaninfo.load_scan_metadata()
-        if self.parent.scaninfo.scan_id != old_scan_id:
-            self.parent.stopped = True
-
-    def finished(self) -> None:
-        """Method checks if DDG finished acquisition"""
-
-    def on_pre_scan(self) -> None:
-        """
-        Method called by pre_scan hook in parent class.
-
-        Executes trigger if premove_trigger is Trus.
-        """
-        if self.parent.premove_trigger.get() is True:
-            self.parent.trigger_shot.put(1)
-
-
-class DelayGeneratorcSAXS(PSIDelayGeneratorBase):
-    """
-    DG645 delay generator at cSAXS (multiple can be in use depending on the setup)
-
-    Default values for setting up DDG.
-    Note: checks of set calues are not (only partially) included, check manual for details on possible settings.
-    https://www.thinksrs.com/downloads/pdfs/manuals/DG645m.pdf
-
-    - delay_burst               : (float >=0) Delay between trigger and first pulse in burst mode
-    - delta_width               : (float >= 0) Add width to fast shutter signal to make sure its open during acquisition
-    - additional_triggers       : (int) add additional triggers to burst mode (mcs card needs +1 triggers per line)
-    - polarity                  : (list of 0/1) polarity for different channels
-    - amplitude                 : (float) amplitude voltage of TTLs
-    - offset                    : (float) offset for ampltitude
-    - thres_trig_level          : (float) threshold of trigger amplitude
-
-    Custom signals for logic in different DDGs during scans (for custom_prepare.prepare_ddg):
-
-    - set_high_on_exposure      : (bool): if True, then TTL signal should go high during the full acquisition time of a scan.
-    # TODO trigger_width and fixed_ttl could be combined into single list.
-    - fixed_ttl_width           : (list of either 1 or 0), one for each channel.
-    - trigger_width             : (float) if fixed_ttl_width is True, then the width of the TTL pulse is set to this value.
-    - set_trigger_source        : (TriggerSource) specifies the default trigger source for the DDG.
-    - premove_trigger           : (bool) if True, then a trigger should be executed before the scan starts (to be implemented in on_pre_scan).
-    - set_high_on_stage         : (bool) if True, then TTL signal should go high already on stage.
-    """
-
-    custom_prepare_cls = DDGSetup
-
-    delay_burst = Component(
-        bec_utils.ConfigSignal, name="delay_burst", kind="config", config_storage_name="ddg_config"
-    )
-
-    delta_width = Component(
-        bec_utils.ConfigSignal, name="delta_width", kind="config", config_storage_name="ddg_config"
-    )
-
-    additional_triggers = Component(
-        bec_utils.ConfigSignal,
-        name="additional_triggers",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    polarity = Component(
-        bec_utils.ConfigSignal, name="polarity", kind="config", config_storage_name="ddg_config"
-    )
-
-    fixed_ttl_width = Component(
-        bec_utils.ConfigSignal,
-        name="fixed_ttl_width",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    amplitude = Component(
-        bec_utils.ConfigSignal, name="amplitude", kind="config", config_storage_name="ddg_config"
-    )
-
-    offset = Component(
-        bec_utils.ConfigSignal, name="offset", kind="config", config_storage_name="ddg_config"
-    )
-
-    thres_trig_level = Component(
-        bec_utils.ConfigSignal,
-        name="thres_trig_level",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    set_high_on_exposure = Component(
-        bec_utils.ConfigSignal,
-        name="set_high_on_exposure",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    set_high_on_stage = Component(
-        bec_utils.ConfigSignal,
-        name="set_high_on_stage",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    set_trigger_source = Component(
-        bec_utils.ConfigSignal,
-        name="set_trigger_source",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    trigger_width = Component(
-        bec_utils.ConfigSignal,
-        name="trigger_width",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-    premove_trigger = Component(
-        bec_utils.ConfigSignal,
-        name="premove_trigger",
-        kind="config",
-        config_storage_name="ddg_config",
-    )
-
-    def __init__(
-        self,
-        prefix="",
-        *,
-        name,
-        kind=None,
-        read_attrs=None,
-        configuration_attrs=None,
-        parent=None,
-        device_manager=None,
-        sim_mode=False,
-        ddg_config=None,
-        **kwargs,
-    ):
-        """
-        Args:
-            prefix (str, optional): Prefix of the device. Defaults to "".
-            name (str): Name of the device.
-            kind (str, optional): Kind of the device. Defaults to None.
-            read_attrs (list, optional): List of attributes to read. Defaults to None.
-            configuration_attrs (list, optional): List of attributes to configure. Defaults to None.
-            parent (Device, optional): Parent device. Defaults to None.
-            device_manager (DeviceManagerBase, optional): DeviceManagerBase object. Defaults to None.
-            sim_mode (bool, optional): Simulation mode flag. Defaults to False.
-            ddg_config (dict, optional): Dictionary of ddg_config signals. Defaults to None.
-
-        """
-        # Default values for ddg_config signals
-        self.ddg_config = {
-            # Setup default values
-            f"{name}_delay_burst": 0,
-            f"{name}_delta_width": 0,
-            f"{name}_additional_triggers": 0,
-            f"{name}_polarity": [1, 1, 1, 1, 1],
-            f"{name}_amplitude": 4.5,
-            f"{name}_offset": 0,
-            f"{name}_thres_trig_level": 2.5,
-            # Values for different behaviour during scans
-            f"{name}_fixed_ttl_width": [0, 0, 0, 0, 0],
-            f"{name}_trigger_width": None,
-            f"{name}_set_high_on_exposure": False,
-            f"{name}_set_high_on_stage": False,
-            f"{name}_set_trigger_source": "SINGLE_SHOT",
-            f"{name}_premove_trigger": False,
-        }
-        if ddg_config is not None:
-            # pylint: disable=expression-not-assigned
-            [self.ddg_config.update({f"{name}_{key}": value}) for key, value in ddg_config.items()]
-        super().__init__(
-            prefix=prefix,
-            name=name,
-            kind=kind,
-            read_attrs=read_attrs,
-            configuration_attrs=configuration_attrs,
-            parent=parent,
-            device_manager=device_manager,
-            sim_mode=sim_mode,
-            **kwargs,
-        )
-
-
-if __name__ == "__main__":
-    # Start delay generator in simulation mode.
-    # Note: To run, access to Epics must be available.
-    dgen = DelayGeneratorcSAXS("delaygen:DG1:", name="dgen", sim_mode=True)

csaxs_bec/devices/epics/eiger9m_csaxs.py

@@ -5,12 +5,13 @@ import time
 from typing import Any
 
 import numpy as np
-from bec_lib import messages, threadlocked
-from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from ophyd import ADComponent as ADCpt
 from ophyd import Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
-from ophyd_devices.epics.devices.psi_detector_base import CustomDetectorMixin, PSIDetectorBase
+from ophyd_devices.interfaces.base_classes.psi_detector_base import (
+    CustomDetectorMixin,
+    PSIDetectorBase,
+)
 from std_daq_client import StdDaqClient
 
 logger = bec_logger.logger
@@ -39,6 +40,17 @@ class Eiger9MSetup(CustomDetectorMixin):
         self.std_client = None
         self._lock = threading.RLock()
 
+    def on_init(self) -> None:
+        """Initialize the detector"""
+        self.initialize_default_parameter()
+        self.initialize_detector()
+        self.initialize_detector_backend()
+
+    def initialize_detector(self) -> None:
+        """Initialize detector"""
+        self.stop_detector()
+        self.parent.cam.trigger_mode.put(TriggerSource.GATING)
+
     def initialize_default_parameter(self) -> None:
         """Set default parameters for Eiger9M detector"""
         self.update_readout_time()
@@ -52,29 +64,19 @@ class Eiger9MSetup(CustomDetectorMixin):
         )
         self.parent.readout_time = max(readout_time, self.parent.MIN_READOUT)
 
-    def initialize_detector(self) -> None:
-        """Initialize detector"""
-        # Stops the detector
-        self.stop_detector()
-        # Sets the trigger source to GATING
-        self.parent.set_trigger(TriggerSource.GATING)
-
     def initialize_detector_backend(self) -> None:
         """Initialize detector backend"""
 
-        # Std client
         self.std_client = StdDaqClient(url_base=self.std_rest_server_url)
-
-        # Stop writer
         self.std_client.stop_writer()
-
-        # Change e-account
         eacc = self.parent.scaninfo.username
         self.update_std_cfg("writer_user_id", int(eacc.strip(" e")))
 
         signal_conditions = [(lambda: self.std_client.get_status()["state"], "READY")]
         if not self.wait_for_signals(
-            signal_conditions=signal_conditions, timeout=self.parent.timeout, all_signals=True
+            signal_conditions=signal_conditions,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS,
+            all_signals=True,
         ):
             raise EigerTimeoutError(
                 f"Std client not in READY state, returns: {self.std_client.get_status()}"
@@ -95,7 +97,6 @@ class Eiger9MSetup(CustomDetectorMixin):
 
         """
 
-        # Load config from client and check old value
         cfg = self.std_client.get_config()
         old_value = cfg.get(cfg_key)
         if old_value is None:
@@ -108,19 +109,112 @@ class Eiger9MSetup(CustomDetectorMixin):
                 f" {type(old_value)}:{old_value}"
             )
 
-        # Update config with new value and send back to client
         cfg.update({cfg_key: value})
         logger.debug(cfg)
         self.std_client.set_config(cfg)
         logger.debug(f"Updated std_daq config for key {cfg_key} from {old_value} to {value}")
 
+    def on_stage(self) -> None:
+        """Prepare the detector for scan"""
+        self.prepare_detector()
+        self.prepare_data_backend()
+        self.publish_file_location(done=False, successful=False)
+        self.arm_acquisition()
+
+    def prepare_detector(self) -> None:
+        """Prepare detector for scan"""
+        self.set_detector_threshold()
+        self.set_acquisition_params()
+        self.parent.cam.trigger_mode.put(TriggerSource.GATING)
+
+    def set_detector_threshold(self) -> None:
+        """
+        Set the detector threshold
+
+        The function sets the detector threshold automatically to 1/2 of the beam energy.
+        """
+        mokev = self.parent.device_manager.devices.mokev.obj.read()[
+            self.parent.device_manager.devices.mokev.name
+        ]["value"]
+        factor = 1
+        unit = getattr(self.parent.cam.threshold_energy, "units", None)
+
+        if unit is not None and unit == "eV":
+            factor = 1000
+        setpoint = int(mokev * factor)
+        energy = self.parent.cam.beam_energy.read()[self.parent.cam.beam_energy.name]["value"]
+
+        if setpoint != energy:
+            self.parent.cam.beam_energy.set(setpoint)
+
+        threshold = self.parent.cam.threshold_energy.read()[self.parent.cam.threshold_energy.name][
+            "value"
+        ]
+        if not np.isclose(setpoint / 2, threshold, rtol=0.05):
+            self.parent.cam.threshold_energy.set(setpoint / 2)
+
+    def set_acquisition_params(self) -> None:
+        """Set acquisition parameters for the detector"""
+        self.parent.cam.num_images.put(
+            int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger)
+        )
+        self.parent.cam.num_frames.put(1)
+        self.update_readout_time()
+
+    def prepare_data_backend(self) -> None:
+        """Prepare the data backend for the scan"""
+        self.parent.filepath.set(
+            self.parent.filewriter.compile_full_filename(f"{self.parent.name}.h5")
+        ).wait()
+        self.filepath_exists(self.parent.filepath.get())
+        self.stop_detector_backend()
+        try:
+            self.std_client.start_writer_async(
+                {
+                    "output_file": self.parent.filepath.get(),
+                    "n_images": int(
+                        self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger
+                    ),
+                }
+            )
+        except Exception as exc:
+            time.sleep(5)
+            if self.std_client.get_status()["state"] == "READY":
+                raise EigerTimeoutError(f"Timeout of start_writer_async with {exc}") from exc
+
+        signal_conditions = [
+            (lambda: self.std_client.get_status()["acquisition"]["state"], "WAITING_IMAGES")
+        ]
+        if not self.wait_for_signals(
+            signal_conditions=signal_conditions,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS,
+            check_stopped=False,
+            all_signals=True,
+        ):
+            raise EigerTimeoutError(
+                "Timeout of 5s reached for std_daq start_writer_async with std_daq client status"
+                f" {self.std_client.get_status()}"
+            )
+
+    def on_unstage(self) -> None:
+        """Unstage the detector"""
+        pass
+
+    def on_complete(self) -> None:
+        """Complete the detector"""
+        self.finished(timeout=self.parent.TIMEOUT_FOR_SIGNALS)
+        self.publish_file_location(done=True, successful=True)
+
+    def on_stop(self) -> None:
+        """Stop the detector"""
+        self.stop_detector()
+        self.stop_detector_backend()
+
     def stop_detector(self) -> None:
         """Stop the detector"""
 
         # Stop detector
         self.parent.cam.acquire.put(0)
-
-        # Check if detector returned in idle state
         signal_conditions = [
             (
                 lambda: self.parent.cam.detector_state.read()[self.parent.cam.detector_state.name][
@@ -132,7 +226,7 @@ class Eiger9MSetup(CustomDetectorMixin):
 
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout - self.parent.timeout // 2,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS - self.parent.TIMEOUT_FOR_SIGNALS // 2,
             check_stopped=True,
             all_signals=False,
         ):
@@ -140,7 +234,7 @@ class Eiger9MSetup(CustomDetectorMixin):
             self.parent.cam.acquire.put(0)
             if not self.wait_for_signals(
                 signal_conditions=signal_conditions,
-                timeout=self.parent.timeout - self.parent.timeout // 2,
+                timeout=self.parent.TIMEOUT_FOR_SIGNALS - self.parent.TIMEOUT_FOR_SIGNALS // 2,
                 check_stopped=True,
                 all_signals=False,
             ):
@@ -152,97 +246,12 @@ class Eiger9MSetup(CustomDetectorMixin):
         """Close file writer"""
         self.std_client.stop_writer()
 
-    def prepare_detector(self) -> None:
-        """Prepare detector for scan"""
-        self.set_detector_threshold()
-        self.set_acquisition_params()
-        self.parent.set_trigger(TriggerSource.GATING)
-
-    def set_detector_threshold(self) -> None:
-        """
-        Set the detector threshold
-
-        The function sets the detector threshold automatically to 1/2 of the beam energy.
-        """
-
-        # get current beam energy from device manageer
-        mokev = self.parent.device_manager.devices.mokev.obj.read()[
-            self.parent.device_manager.devices.mokev.name
-        ]["value"]
-        factor = 1
-
-        # Check if energies are eV or keV, assume keV as the default
-        unit = getattr(self.parent.cam.threshold_energy, "units", None)
-        if unit is not None and unit == "eV":
-            factor = 1000
-
-        # set energy on detector
-        setpoint = int(mokev * factor)
-        energy = self.parent.cam.beam_energy.read()[self.parent.cam.beam_energy.name]["value"]
-        if setpoint != energy:
-            self.parent.cam.beam_energy.set(setpoint)
-
-        # set threshold on detector
-        threshold = self.parent.cam.threshold_energy.read()[self.parent.cam.threshold_energy.name][
-            "value"
-        ]
-        if not np.isclose(setpoint / 2, threshold, rtol=0.05):
-            self.parent.cam.threshold_energy.set(setpoint / 2)
-
-    def set_acquisition_params(self) -> None:
-        """Set acquisition parameters for the detector"""
-
-        # Set number of images and frames (frames is for internal burst of detector)
-        self.parent.cam.num_images.put(
-            int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger)
-        )
-        self.parent.cam.num_frames.put(1)
-
-        # Update the readout time of the detector
-        self.update_readout_time()
-
-    def prepare_data_backend(self) -> None:
-        """Prepare the data backend for the scan"""
-        self.parent.filepath = self.parent.filewriter.compile_full_filename(
-            f"{self.parent.name}.h5"
-        )
-        self.filepath_exists(self.parent.filepath)
-        self.stop_detector_backend()
-        try:
-            self.std_client.start_writer_async(
-                {
-                    "output_file": self.parent.filepath,
-                    "n_images": int(
-                        self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger
-                    ),
-                }
-            )
-        except Exception as exc:
-            time.sleep(5)
-            if self.std_client.get_status()["state"] == "READY":
-                raise EigerTimeoutError(f"Timeout of start_writer_async with {exc}") from exc
-
-        # Check status of std_daq
-        signal_conditions = [
-            (lambda: self.std_client.get_status()["acquisition"]["state"], "WAITING_IMAGES")
-        ]
-        if not self.wait_for_signals(
-            signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
-            check_stopped=False,
-            all_signals=True,
-        ):
-            raise EigerTimeoutError(
-                "Timeout of 5s reached for std_daq start_writer_async with std_daq client status"
-                f" {self.std_client.get_status()}"
-            )
-
     def filepath_exists(self, filepath: str) -> None:
         """Check if filepath exists"""
         signal_conditions = [(lambda: os.path.exists(os.path.dirname(filepath)), True)]
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS,
             check_stopped=False,
             all_signals=True,
         ):
@@ -261,7 +270,7 @@ class Eiger9MSetup(CustomDetectorMixin):
         ]
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS,
             check_stopped=True,
             all_signals=False,
         ):
@@ -269,69 +278,35 @@ class Eiger9MSetup(CustomDetectorMixin):
                 f"Failed to arm the acquisition. Detector state {signal_conditions[0][0]}"
             )
 
-    def check_scan_id(self) -> None:
-        """Checks if scan_id has changed and stops the scan if it has"""
-        old_scan_id = self.parent.scaninfo.scan_id
-        self.parent.scaninfo.load_scan_metadata()
-        if self.parent.scaninfo.scan_id != old_scan_id:
-            self.parent.stopped = True
-
-    def publish_file_location(self, done: bool = False, successful: bool = None) -> None:
-        """
-        Publish the filepath to REDIS.
-
-        We publish two events here:
-        - file_event: event for the filewriter
-        - public_file: event for any secondary service (e.g. radial integ code)
-
-        Args:
-            done (bool): True if scan is finished
-            successful (bool): True if scan was successful
-        """
-        pipe = self.parent.connector.pipeline()
-        if successful is None:
-            msg = messages.FileMessage(file_path=self.parent.filepath, done=done)
-        else:
-            msg = messages.FileMessage(
-                file_path=self.parent.filepath, done=done, successful=successful
-            )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.public_file(self.parent.scaninfo.scan_id, self.parent.name),
-            msg,
-            pipe=pipe,
-        )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.file_event(self.parent.name), msg, pipe=pipe
-        )
-        pipe.execute()
-
-    @threadlocked
-    def finished(self):
+    def finished(self, timeout: int = 5) -> None:
         """Check if acquisition is finished."""
-        signal_conditions = [
-            (
-                lambda: self.parent.cam.acquire.read()[self.parent.cam.acquire.name]["value"],
-                DetectorState.IDLE,
-            ),
-            (lambda: self.std_client.get_status()["acquisition"]["state"], "FINISHED"),
-            (
-                lambda: self.std_client.get_status()["acquisition"]["stats"]["n_write_completed"],
-                int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger),
-            ),
-        ]
-        if not self.wait_for_signals(
-            signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
-            check_stopped=True,
-            all_signals=True,
-        ):
-            raise EigerTimeoutError(
-                f"Reached timeout with detector state {signal_conditions[0][0]}, std_daq state"
-                f" {signal_conditions[1][0]} and received frames of {signal_conditions[2][0]} for"
-                " the file writer"
-            )
-        self.stop_detector()
-        self.stop_detector_backend()
+        with self._lock:
+            signal_conditions = [
+                (
+                    lambda: self.parent.cam.acquire.read()[self.parent.cam.acquire.name]["value"],
+                    DetectorState.IDLE,
+                ),
+                (lambda: self.std_client.get_status()["acquisition"]["state"], "FINISHED"),
+                (
+                    lambda: self.std_client.get_status()["acquisition"]["stats"][
+                        "n_write_completed"
+                    ],
+                    int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger),
+                ),
+            ]
+            if not self.wait_for_signals(
+                signal_conditions=signal_conditions,
+                timeout=timeout,
+                check_stopped=True,
+                all_signals=True,
+            ):
+                raise EigerTimeoutError(
+                    f"Reached timeout with detector state {signal_conditions[0][0]}, std_daq state"
+                    f" {signal_conditions[1][0]} and received frames of {signal_conditions[2][0]} for"
+                    " the file writer"
+                )
+            self.stop_detector()
+            self.stop_detector_backend()
 
 
 class SLSDetectorCam(Device):
@@ -352,7 +327,7 @@ class SLSDetectorCam(Device):
     detector_state = ADCpt(EpicsSignalRO, "DetectorState_RBV")
 
 
-class TriggerSource(enum.IntEnum):
+class TriggerSource(int, enum.Enum):
     """Trigger signals for Eiger9M detector"""
 
     AUTO = 0
@@ -361,7 +336,7 @@ class TriggerSource(enum.IntEnum):
     BURST_TRIGGER = 3
 
 
-class DetectorState(enum.IntEnum):
+class DetectorState(int, enum.Enum):
     """Detector states for Eiger9M detector"""
 
     IDLE = 0
@@ -391,37 +366,16 @@ class Eiger9McSAXS(PSIDetectorBase):
     """
 
     # Specify which functions are revealed to the user in BEC client
-    USER_ACCESS = ["describe"]
+    USER_ACCESS = []
 
     # specify Setup class
     custom_prepare_cls = Eiger9MSetup
-    # specify minimum readout time for detector
+    # specify minimum readout time for detector and timeout for checks after unstage
     MIN_READOUT = 3e-3
+    TIMEOUT_FOR_SIGNALS = 5
     # specify class attributes
     cam = ADCpt(SLSDetectorCam, "cam1:")
 
-    def set_trigger(self, trigger_source: TriggerSource) -> None:
-        """Set trigger source for the detector.
-        Check the TriggerSource enum for possible values
-
-        Args:
-            trigger_source (TriggerSource): Trigger source for the detector
-
-        """
-        value = trigger_source
-        self.cam.trigger_mode.put(value)
-
-    def stage(self) -> list[object]:
-        """
-        Add functionality to stage, and arm the detector
-
-        Additional call to:
-        - custom_prepare.arm_acquisition()
-        """
-        rtr = super().stage()
-        self.custom_prepare.arm_acquisition()
-        return rtr
-
 
 if __name__ == "__main__":
     eiger = Eiger9McSAXS(name="eiger", prefix="X12SA-ES-EIGER9M:", sim_mode=True)

csaxs_bec/devices/epics/falcon_csaxs.py

@@ -1,13 +1,15 @@
 import enum
 import os
+import threading
 
-from bec_lib import messages
-from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from ophyd import Component as Cpt
 from ophyd import Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
 from ophyd.mca import EpicsMCARecord
-from ophyd_devices.epics.devices.psi_detector_base import CustomDetectorMixin, PSIDetectorBase
+from ophyd_devices.interfaces.base_classes.psi_detector_base import (
+    CustomDetectorMixin,
+    PSIDetectorBase,
+)
 
 logger = bec_logger.logger
 
@@ -96,6 +98,16 @@ class FalconSetup(CustomDetectorMixin):
 
     """
 
+    def __init__(self, *args, parent: Device = None, **kwargs) -> None:
+        super().__init__(*args, parent=parent, **kwargs)
+        self._lock = threading.RLock()
+
+    def on_init(self) -> None:
+        """Initialize Falcon detector"""
+        self.initialize_default_parameter()
+        self.initialize_detector()
+        self.initialize_detector_backend()
+
     def initialize_default_parameter(self) -> None:
         """
         Set default parameters for Falcon
@@ -121,7 +133,7 @@ class FalconSetup(CustomDetectorMixin):
         """Initialize Falcon detector"""
         self.stop_detector()
         self.stop_detector_backend()
-        self.parent.set_trigger(
+        self.set_trigger(
             mapping_mode=MappingSource.MAPPING, trigger_source=TriggerSource.GATE, ignore_gate=0
         )
         # 1 Realtime
@@ -133,30 +145,6 @@ class FalconSetup(CustomDetectorMixin):
         # Sets the number of pixels/spectra in the buffer
         self.parent.pixels_per_buffer.put(self.parent.value_pixel_per_buffer)
 
-    def stop_detector(self) -> None:
-        """Stops detector"""
-
-        self.parent.stop_all.put(1)
-        self.parent.erase_all.put(1)
-
-        signal_conditions = [
-            (lambda: self.parent.state.read()[self.parent.state.name]["value"], DetectorState.DONE)
-        ]
-
-        if not self.wait_for_signals(
-            signal_conditions=signal_conditions,
-            timeout=self.parent.timeout - self.parent.timeout // 2,
-            all_signals=False,
-        ):
-            # Retry stop detector and wait for remaining time
-            raise FalconTimeoutError(
-                f"Failed to stop detector, timeout with state {signal_conditions[0][0]}"
-            )
-
-    def stop_detector_backend(self) -> None:
-        """Stop the detector backend"""
-        self.parent.hdf5.capture.put(0)
-
     def initialize_detector_backend(self) -> None:
         """Initialize the detector backend for Falcon."""
         self.parent.hdf5.enable.put(1)
@@ -170,9 +158,16 @@ class FalconSetup(CustomDetectorMixin):
         # Segmentation into Spectra within EPICS, 1 is activate, 0 is deactivate
         self.parent.nd_array_mode.put(1)
 
+    def on_stage(self) -> None:
+        """Prepare detector and backend for acquisition"""
+        self.prepare_detector()
+        self.prepare_data_backend()
+        self.publish_file_location(done=False, successful=False)
+        self.arm_acquisition()
+
     def prepare_detector(self) -> None:
         """Prepare detector for acquisition"""
-        self.parent.set_trigger(
+        self.set_trigger(
             mapping_mode=MappingSource.MAPPING, trigger_source=TriggerSource.GATE, ignore_gate=0
         )
         self.parent.preset_real.put(self.parent.scaninfo.exp_time)
@@ -182,10 +177,10 @@ class FalconSetup(CustomDetectorMixin):
 
     def prepare_data_backend(self) -> None:
         """Prepare data backend for acquisition"""
-        self.parent.filepath = self.parent.filewriter.compile_full_filename(
-            f"{self.parent.name}.h5"
-        )
-        file_path, file_name = os.path.split(self.parent.filepath)
+        self.parent.filepath.set(
+            self.parent.filewriter.compile_full_filename(f"{self.parent.name}.h5")
+        ).wait()
+        file_path, file_name = os.path.split(self.parent.filepath.get())
         self.parent.hdf5.file_path.put(file_path)
         self.parent.hdf5.file_name.put(file_name)
         self.parent.hdf5.file_template.put("%s%s")
@@ -209,7 +204,7 @@ class FalconSetup(CustomDetectorMixin):
         ]
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS,
             check_stopped=True,
             all_signals=False,
         ):
@@ -217,65 +212,86 @@ class FalconSetup(CustomDetectorMixin):
                 f"Failed to arm the acquisition. Detector state {signal_conditions[0][0]}"
             )
 
-    def check_scan_id(self) -> None:
-        """Checks if scan_id has changed and stops the scan if it has"""
-        old_scan_id = self.parent.scaninfo.scan_id
-        self.parent.scaninfo.load_scan_metadata()
-        if self.parent.scaninfo.scan_id != old_scan_id:
-            self.parent.stopped = True
+    def on_unstage(self) -> None:
+        """Unstage detector and backend"""
+        pass
 
-    def publish_file_location(self, done: bool = False, successful: bool = None) -> None:
-        """
-        Publish the filepath to REDIS.
+    def on_complete(self) -> None:
+        """Complete detector and backend"""
+        self.finished(timeout=self.parent.TIMEOUT_FOR_SIGNALS)
+        self.publish_file_location(done=True, successful=True)
 
-        We publish two events here:
-        - file_event: event for the filewriter
-        - public_file: event for any secondary service (e.g. radial integ code)
-
-        Args:
-            done (bool): True if scan is finished
-            successful (bool): True if scan was successful
-        """
-        pipe = self.parent.connector.pipeline()
-        if successful is None:
-            msg = messages.FileMessage(file_path=self.parent.filepath, done=done)
-        else:
-            msg = messages.FileMessage(
-                file_path=self.parent.filepath, done=done, successful=successful
-            )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.public_file(self.parent.scaninfo.scan_id, self.parent.name),
-            msg,
-            pipe=pipe,
-        )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.file_event(self.parent.name), msg, pipe=pipe
-        )
-        pipe.execute()
-
-    def finished(self) -> None:
-        """Check if scan finished succesfully"""
-        total_frames = int(
-            self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger
-        )
-        signal_conditions = [
-            (self.parent.dxp.current_pixel.get, total_frames),
-            (self.parent.hdf5.array_counter.get, total_frames),
-        ]
-        if not self.wait_for_signals(
-            signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
-            check_stopped=True,
-            all_signals=True,
-        ):
-            logger.debug(
-                f"Falcon missed a trigger: received trigger {self.parent.dxp.current_pixel.get()},"
-                f" send data {self.parent.hdf5.array_counter.get()} from total_frames"
-                f" {total_frames}"
-            )
+    def on_stop(self) -> None:
+        """Stop detector and backend"""
         self.stop_detector()
         self.stop_detector_backend()
 
+    def stop_detector(self) -> None:
+        """Stops detector"""
+
+        self.parent.stop_all.put(1)
+        self.parent.erase_all.put(1)
+
+        signal_conditions = [
+            (lambda: self.parent.state.read()[self.parent.state.name]["value"], DetectorState.DONE)
+        ]
+
+        if not self.wait_for_signals(
+            signal_conditions=signal_conditions,
+            timeout=self.parent.TIMEOUT_FOR_SIGNALS - self.parent.TIMEOUT_FOR_SIGNALS // 2,
+            all_signals=False,
+        ):
+            # Retry stop detector and wait for remaining time
+            raise FalconTimeoutError(
+                f"Failed to stop detector, timeout with state {signal_conditions[0][0]}"
+            )
+
+    def stop_detector_backend(self) -> None:
+        """Stop the detector backend"""
+        self.parent.hdf5.capture.put(0)
+
+    def finished(self, timeout: int = 5) -> None:
+        """Check if scan finished succesfully"""
+        with self._lock:
+            total_frames = int(
+                self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger
+            )
+            signal_conditions = [
+                (self.parent.dxp.current_pixel.get, total_frames),
+                (self.parent.hdf5.array_counter.get, total_frames),
+            ]
+            if not self.wait_for_signals(
+                signal_conditions=signal_conditions,
+                timeout=timeout,
+                check_stopped=True,
+                all_signals=True,
+            ):
+                logger.debug(
+                    f"Falcon missed a trigger: received trigger {self.parent.dxp.current_pixel.get()},"
+                    f" send data {self.parent.hdf5.array_counter.get()} from total_frames"
+                    f" {total_frames}"
+                )
+            self.stop_detector()
+            self.stop_detector_backend()
+
+    def set_trigger(
+        self, mapping_mode: MappingSource, trigger_source: TriggerSource, ignore_gate: int = 0
+    ) -> None:
+        """
+        Set triggering mode for detector
+
+        Args:
+            mapping_mode (MappingSource): Mapping mode for the detector
+            trigger_source (TriggerSource): Trigger source for the detector, pixel_advance_signal
+            ignore_gate (int): Ignore gate from TTL signal; defaults to 0
+
+        """
+        mapping = int(mapping_mode)
+        trigger = trigger_source
+        self.parent.collect_mode.put(mapping)
+        self.parent.pixel_advance_mode.put(trigger)
+        self.parent.ignore_gate.put(ignore_gate)
+
 
 class FalconcSAXS(PSIDetectorBase):
     """
@@ -300,6 +316,7 @@ class FalconcSAXS(PSIDetectorBase):
     custom_prepare_cls = FalconSetup
     # specify minimum readout time for detector
     MIN_READOUT = 3e-3
+    TIMEOUT_FOR_SIGNALS = 5
 
     # specify class attributes
     dxp = Cpt(EpicsDXPFalcon, "dxp1:")
@@ -327,30 +344,6 @@ class FalconcSAXS(PSIDetectorBase):
     pixels_per_run = Cpt(EpicsSignal, "PixelsPerRun")
     nd_array_mode = Cpt(EpicsSignal, "NDArrayMode")
 
-    def set_trigger(
-        self, mapping_mode: MappingSource, trigger_source: TriggerSource, ignore_gate: int = 0
-    ) -> None:
-        """
-        Set triggering mode for detector
-
-        Args:
-            mapping_mode (MappingSource): Mapping mode for the detector
-            trigger_source (TriggerSource): Trigger source for the detector, pixel_advance_signal
-            ignore_gate (int): Ignore gate from TTL signal; defaults to 0
-
-        """
-        mapping = int(mapping_mode)
-        trigger = trigger_source
-        self.collect_mode.put(mapping)
-        self.pixel_advance_mode.put(trigger)
-        self.ignore_gate.put(ignore_gate)
-
-    def stage(self) -> list[object]:
-        """Stage"""
-        rtr = super().stage()
-        self.custom_prepare.arm_acquisition()
-        return rtr
-
 
 if __name__ == "__main__":
     falcon = FalconcSAXS(name="falcon", prefix="X12SA-SITORO:", sim_mode=True)

csaxs_bec/devices/epics/mcs_csaxs.py

@@ -3,10 +3,14 @@ import threading
 from collections import defaultdict
 
 import numpy as np
-from bec_lib import MessageEndpoints, bec_logger, messages, threadlocked
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from ophyd import Component as Cpt
 from ophyd import Device, EpicsSignal, EpicsSignalRO
-from ophyd_devices.epics.devices.psi_detector_base import CustomDetectorMixin, PSIDetectorBase
+from ophyd_devices.interfaces.base_classes.psi_detector_base import (
+    CustomDetectorMixin,
+    PSIDetectorBase,
+)
 from ophyd_devices.utils import bec_utils
 
 logger = bec_logger.logger
@@ -70,6 +74,11 @@ class MCSSetup(CustomDetectorMixin):
         ]
         self.mca_data = defaultdict(lambda: [])
 
+    def on_init(self) -> None:
+        """Init sequence for the detector"""
+        self.initialize_detector()
+        self.initialize_detector_backend()
+
     def initialize_detector(self) -> None:
         """Initialize detector"""
         # External trigger for pixel advance
@@ -80,7 +89,7 @@ class MCSSetup(CustomDetectorMixin):
         # Set number of channels to 5
         self.parent.mux_output.set(5)
         # Trigger Mode used for cSAXS
-        self.parent.set_trigger(TriggerSource.MODE3)
+        self.parent.input_mode.set(TriggerSource.MODE3)
         # specify polarity of trigger signals
         self.parent.input_polarity.set(0)
         self.parent.output_polarity.set(1)
@@ -109,17 +118,17 @@ class MCSSetup(CustomDetectorMixin):
             done=bool(max_value == value),  # == self.counter),
         )
 
-    @threadlocked
     def _on_mca_data(self, *args, obj=None, value=None, **kwargs) -> None:
         """Callback function for scan progress"""
-        if not isinstance(value, (list, np.ndarray)):
-            return
-        self.mca_data[obj.attr_name] = value
-        if len(self.mca_names) != len(self.mca_data):
-            return
-        self.acquisition_done = True
-        self._send_data_to_bec()
-        self.mca_data = defaultdict(lambda: [])
+        with self._lock:
+            if not isinstance(value, (list, np.ndarray)):
+                return
+            self.mca_data[obj.attr_name] = value
+            if len(self.mca_names) != len(self.mca_data):
+                return
+            self.acquisition_done = True
+            self._send_data_to_bec()
+            self.mca_data = defaultdict(lambda: [])
 
     def _send_data_to_bec(self) -> None:
         """Sends bundled data to BEC"""
@@ -138,10 +147,15 @@ class MCSSetup(CustomDetectorMixin):
             expire=self._stream_ttl,
         )
 
+    def on_stage(self) -> None:
+        """Stage detector"""
+        self.prepare_detector()
+        self.prepare_detector_backend()
+
     def prepare_detector(self) -> None:
         """Prepare detector for scan"""
         self.set_acquisition_params()
-        self.parent.set_trigger(TriggerSource.MODE3)
+        self.parent.input_mode.set(TriggerSource.MODE3)
 
     def set_acquisition_params(self) -> None:
         """Set acquisition parameters for scan"""
@@ -171,7 +185,15 @@ class MCSSetup(CustomDetectorMixin):
         self.counter = 0
         self.parent.erase_start.set(1)
 
-    def finished(self) -> None:
+    def on_unstage(self) -> None:
+        """Unstage detector"""
+        pass
+
+    def on_complete(self) -> None:
+        """Complete detector"""
+        self.finished(timeout=self.parent.TIMEOUT_FOR_SIGNALS)
+
+    def finished(self, timeout: int = 5) -> None:
         """Check if acquisition is finished, if not successful, rais MCSTimeoutError"""
         signal_conditions = [
             (lambda: self.acquisition_done, True),
@@ -179,7 +201,7 @@ class MCSSetup(CustomDetectorMixin):
         ]
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
+            timeout=timeout,
             check_stopped=True,
             all_signals=True,
         ):
@@ -191,12 +213,15 @@ class MCSSetup(CustomDetectorMixin):
                 f" {total_frames} frames arriving at the mcs card"
             )
 
+    def on_stop(self) -> None:
+        """Stop detector"""
+        self.stop_detector()
+        self.stop_detector_backend()
+
     def stop_detector(self) -> None:
         """Stop detector"""
         self.parent.stop_all.set(1)
 
-        return super().stop_detector()
-
     def stop_detector_backend(self) -> None:
         """Stop acquisition of data"""
         self.acquisition_done = True
@@ -209,7 +234,7 @@ class SIS38XX(Device):
 class MCScSAXS(PSIDetectorBase):
     """MCS card for cSAXS for implementation at cSAXS beamline"""
 
-    USER_ACCESS = ["describe", "_init_mcs"]
+    USER_ACCESS = []
     SUB_PROGRESS = "progress"
     SUB_VALUE = "value"
     _default_sub = SUB_VALUE
@@ -218,6 +243,7 @@ class MCScSAXS(PSIDetectorBase):
     custom_prepare_cls = MCSSetup
     # specify minimum readout time for detector
     MIN_READOUT = 0
+    TIMEOUT_FOR_SIGNALS = 5
 
     # PV access to SISS38XX card
     # Acquisition
@@ -268,11 +294,8 @@ class MCScSAXS(PSIDetectorBase):
         *,
         name,
         kind=None,
-        read_attrs=None,
-        configuration_attrs=None,
         parent=None,
         device_manager=None,
-        sim_mode=False,
         mcs_config=None,
         **kwargs,
     ):
@@ -285,25 +308,11 @@ class MCScSAXS(PSIDetectorBase):
             prefix=prefix,
             name=name,
             kind=kind,
-            read_attrs=read_attrs,
-            configuration_attrs=configuration_attrs,
             parent=parent,
             device_manager=device_manager,
-            sim_mode=sim_mode,
             **kwargs,
         )
 
-    def set_trigger(self, trigger_source: TriggerSource) -> None:
-        """Set trigger mode from TriggerSource"""
-        value = int(trigger_source)
-        self.input_mode.set(value)
-
-    def stage(self) -> list[object]:
-        """stage the detector for upcoming acquisition"""
-        rtr = super().stage()
-        self.custom_prepare.arm_acquisition()
-        return rtr
-
 
 # Automatically connect to test environmenr if directly invoked
 if __name__ == "__main__":

csaxs_bec/devices/epics/pilatus_csaxs.py

@@ -1,19 +1,21 @@
 import enum
 import json
 import os
+import threading
 import time
 
 import numpy as np
 import requests
-from bec_lib import MessageEndpoints, bec_logger, messages
+from bec_lib import bec_logger
 from ophyd import ADComponent as ADCpt
 from ophyd import Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV, Staged
-from ophyd_devices.epics.devices.psi_detector_base import CustomDetectorMixin, PSIDetectorBase
+from ophyd_devices.interfaces.base_classes.psi_detector_base import (
+    CustomDetectorMixin,
+    PSIDetectorBase,
+)
 
 logger = bec_logger.logger
 
-MIN_READOUT = 3e-3
-
 
 class PilatusError(Exception):
     """Base class for exceptions in this module."""
@@ -68,6 +70,15 @@ class PilatusSetup(CustomDetectorMixin):
 
     """
 
+    def __init__(self, *args, parent: Device = None, **kwargs) -> None:
+        super().__init__(*args, parent=parent, **kwargs)
+        self._lock = threading.RLock()
+
+    def on_init(self) -> None:
+        """Initialize the detector"""
+        self.initialize_default_parameter()
+        self.initialize_detector()
+
     def initialize_default_parameter(self) -> None:
         """Set default parameters for Eiger9M detector"""
         self.update_readout_time()
@@ -86,7 +97,15 @@ class PilatusSetup(CustomDetectorMixin):
         # Stops the detector
         self.stop_detector()
         # Sets the trigger source to GATING
-        self.parent.set_trigger(TriggerSource.EXT_ENABLE)
+        self.parent.cam.trigger_mode.put(TriggerSource.EXT_ENABLE)
+
+    def on_stage(self) -> None:
+        """Stage the detector for scan"""
+        self.prepare_detector()
+        self.prepare_data_backend()
+        self.publish_file_location(
+            done=False, successful=False, metadata={"input_path": self.parent.filepath_raw}
+        )
 
     def prepare_detector(self) -> None:
         """
@@ -97,84 +116,7 @@ class PilatusSetup(CustomDetectorMixin):
         """
         self.set_detector_threshold()
         self.set_acquisition_params()
-        self.parent.set_trigger(TriggerSource.EXT_ENABLE)
-
-    def set_detector_threshold(self) -> None:
-        """
-        Set correct detector threshold to 1/2 of current X-ray energy, allow 5% tolerance
-
-        Threshold might be in ev or keV
-        """
-
-        # get current beam energy from device manageer
-        mokev = self.parent.device_manager.devices.mokev.obj.read()[
-            self.parent.device_manager.devices.mokev.name
-        ]["value"]
-        factor = 1
-
-        # Check if energies are eV or keV, assume keV as the default
-        unit = getattr(self.parent.cam.threshold_energy, "units", None)
-        if unit is not None and unit == "eV":
-            factor = 1000
-
-        # set energy on detector
-        setpoint = int(mokev * factor)
-
-        # set threshold on detector
-        threshold = self.parent.cam.threshold_energy.read()[self.parent.cam.threshold_energy.name][
-            "value"
-        ]
-        if not np.isclose(setpoint / 2, threshold, rtol=0.05):
-            self.parent.cam.threshold_energy.set(setpoint / 2)
-
-    def set_acquisition_params(self) -> None:
-        """Set acquisition parameters for the detector"""
-
-        # Set number of images and frames (frames is for internal burst of detector)
-        self.parent.cam.num_images.put(
-            int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger)
-        )
-        self.parent.cam.num_frames.put(1)
-
-        # Update the readout time of the detector
-        self.update_readout_time()
-
-    def create_directory(self, filepath: str) -> None:
-        """Create directory if it does not exist"""
-        os.makedirs(filepath, exist_ok=True)
-
-    def stop_detector_backend(self) -> None:
-        """Stop the file writer zmq service for pilatus_2"""
-        self.close_file_writer()
-        time.sleep(0.1)
-        self.stop_file_writer()
-        time.sleep(0.1)
-
-    def close_file_writer(self) -> None:
-        """
-        Close the file writer for pilatus_2
-
-        Delete the data from x12sa-pd-2
-
-        """
-        url = "http://x12sa-pd-2:8080/stream/pilatus_2"
-        try:
-            res = self.send_requests_delete(url=url)
-            if not res.ok:
-                res.raise_for_status()
-        except Exception as exc:
-            logger.info(f"Pilatus2 close threw Exception: {exc}")
-
-    def stop_file_writer(self) -> None:
-        """
-        Stop the file writer for pilatus_2
-
-        Runs on xbl-daq-34
-        """
-        url = "http://xbl-daq-34:8091/pilatus_2/stop"
-        res = self.send_requests_put(url=url)
-        if not res.ok:
-            res.raise_for_status()
+        self.parent.cam.trigger_mode.put(TriggerSource.EXT_ENABLE)
 
     def prepare_data_backend(self) -> None:
         """
@@ -187,7 +129,9 @@ class PilatusSetup(CustomDetectorMixin):
 
         self.stop_detector_backend()
 
-        self.parent.filepath = self.parent.filewriter.compile_full_filename("pilatus_2.h5")
+        self.parent.filepath.set(
+            self.parent.filewriter.compile_full_filename("pilatus_2.h5")
+        ).wait()
         self.parent.cam.file_path.put("/dev/shm/zmq/")
         self.parent.cam.file_name.put(
             f"{self.parent.scaninfo.username}_2_{self.parent.scaninfo.scan_number:05d}"
@@ -271,6 +215,76 @@ class PilatusSetup(CustomDetectorMixin):
         except Exception as exc:
             logger.info(f"Pilatus2 wait threw Exception: {exc}")
 
+    def set_detector_threshold(self) -> None:
+        """
+        Set correct detector threshold to 1/2 of current X-ray energy, allow 5% tolerance
+
+        Threshold might be in ev or keV
+        """
+
+        # get current beam energy from device manageer
+        mokev = self.parent.device_manager.devices.mokev.obj.read()[
+            self.parent.device_manager.devices.mokev.name
+        ]["value"]
+        factor = 1
+
+        # Check if energies are eV or keV, assume keV as the default
+        unit = getattr(self.parent.cam.threshold_energy, "units", None)
+        if unit is not None and unit == "eV":
+            factor = 1000
+
+        # set energy on detector
+        setpoint = int(mokev * factor)
+
+        # set threshold on detector
+        threshold = self.parent.cam.threshold_energy.read()[self.parent.cam.threshold_energy.name][
+            "value"
+        ]
+        if not np.isclose(setpoint / 2, threshold, rtol=0.05):
+            self.parent.cam.threshold_energy.set(setpoint / 2)
+
+    def set_acquisition_params(self) -> None:
+        """Set acquisition parameters for the detector"""
+
+        # Set number of images and frames (frames is for internal burst of detector)
+        self.parent.cam.num_images.put(
+            int(self.parent.scaninfo.num_points * self.parent.scaninfo.frames_per_trigger)
+        )
+        self.parent.cam.num_frames.put(1)
+
+        # Update the readout time of the detector
+        self.update_readout_time()
+
+    def create_directory(self, filepath: str) -> None:
+        """Create directory if it does not exist"""
+        os.makedirs(filepath, exist_ok=True)
+
+    def close_file_writer(self) -> None:
+        """
+        Close the file writer for pilatus_2
+
+        Delete the data from x12sa-pd-2
+
+        """
+        url = "http://x12sa-pd-2:8080/stream/pilatus_2"
+        try:
+            res = self.send_requests_delete(url=url)
+            if not res.ok:
+                res.raise_for_status()
+        except Exception as exc:
+            logger.info(f"Pilatus2 close threw Exception: {exc}")
+
+    def stop_file_writer(self) -> None:
+        """
+        Stop the file writer for pilatus_2
+
+        Runs on xbl-daq-34
+        """
+        url = "http://xbl-daq-34:8091/pilatus_2/stop"
+        res = self.send_requests_put(url=url)
+        if not res.ok:
+            res.raise_for_status()
+
     def send_requests_put(self, url: str, data: list = None, headers: dict = None) -> object:
         """
         Send a put request to the given url
@@ -298,14 +312,8 @@ class PilatusSetup(CustomDetectorMixin):
         """
         return requests.delete(url=url, headers=headers, timeout=5)
 
-    def pre_scan(self) -> None:
-        """
-        Pre_scan function call
-
-        This function is called just before the scan core.
-        Here it is used to arm the detector for the acquisition
-
-        """
+    def on_pre_scan(self) -> None:
+        """Prepare detector for scan"""
         self.arm_acquisition()
 
     def arm_acquisition(self) -> None:
@@ -314,43 +322,18 @@ class PilatusSetup(CustomDetectorMixin):
         # TODO is this sleep needed? to be tested with detector and for how long
         time.sleep(0.5)
 
-    def publish_file_location(self, done: bool = False, successful: bool = None) -> None:
-        """
-        Publish the filepath to REDIS and publish the event for the h5_converter
+    def on_unstage(self) -> None:
+        """Unstage the detector"""
+        pass
 
-        We publish two events here:
-        - file_event: event for the filewriter
-        - public_file: event for any secondary service (e.g. radial integ code)
-
-        Args:
-            done (bool): True if scan is finished
-            successful (bool): True if scan was successful
-        """
-        pipe = self.parent.connector.pipeline()
-        if successful is None:
-            msg = messages.FileMessage(
-                file_path=self.parent.filepath,
-                done=done,
-                metadata={"input_path": self.parent.filepath_raw},
-            )
-        else:
-            msg = messages.FileMessage(
-                file_path=self.parent.filepath,
-                done=done,
-                successful=successful,
-                metadata={"input_path": self.parent.filepath_raw},
-            )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.public_file(self.parent.scaninfo.scan_id, self.parent.name),
-            msg,
-            pipe=pipe,
+    def on_complete(self) -> None:
+        """Complete the scan"""
+        self.finished(timeout=self.parent.TIMEOUT_FOR_SIGNALS)
+        self.publish_file_location(
+            done=True, successful=True, metadata={"input_path": self.parent.filepath_raw}
         )
-        self.parent.connector.set_and_publish(
-            MessageEndpoints.file_event(self.parent.name), msg, pipe=pipe
-        )
-        pipe.execute()
 
-    def finished(self) -> None:
+    def finished(self, timeout: int = 5) -> None:
         """Check if acquisition is finished."""
         # pylint: disable=protected-access
         # TODO: at the moment this relies on device.mcs.obj._staged attribute
@@ -359,7 +342,7 @@ class PilatusSetup(CustomDetectorMixin):
         ]
         if not self.wait_for_signals(
             signal_conditions=signal_conditions,
-            timeout=self.parent.timeout,
+            timeout=timeout,
             check_stopped=True,
             all_signals=True,
         ):
@@ -371,16 +354,21 @@ class PilatusSetup(CustomDetectorMixin):
         self.stop_detector()
         self.stop_detector_backend()
 
+    def on_stop(self) -> None:
+        """Stop detector"""
+        self.stop_detector()
+        self.stop_detector_backend()
+
     def stop_detector(self) -> None:
         """Stop detector"""
         self.parent.cam.acquire.put(0)
 
-    def check_scan_id(self) -> None:
-        """Checks if scan_id has changed and stops the scan if it has"""
-        old_scan_id = self.parent.scaninfo.scan_id
-        self.parent.scaninfo.load_scan_metadata()
-        if self.parent.scaninfo.scan_id != old_scan_id:
-            self.parent.stopped = True
+    def stop_detector_backend(self) -> None:
+        """Stop the file writer zmq service for pilatus_2"""
+        self.close_file_writer()
+        time.sleep(0.1)
+        self.stop_file_writer()
+        time.sleep(0.1)
 
 
 class PilatuscSAXS(PSIDetectorBase):
@@ -397,20 +385,16 @@ class PilatuscSAXS(PSIDetectorBase):
     """
 
     # Specify which functions are revealed to the user in BEC client
-    USER_ACCESS = ["describe"]
+    USER_ACCESS = []
 
     # specify Setup class
     custom_prepare_cls = PilatusSetup
     # specify minimum readout time for detector
     MIN_READOUT = 3e-3
+    TIMEOUT_FOR_SIGNALS = 5
     # specify class attributes
     cam = ADCpt(SLSDetectorCam, "cam1:")
 
-    def set_trigger(self, trigger_source: TriggerSource) -> None:
-        """Set trigger source for the detector"""
-        value = trigger_source
-        self.cam.trigger_mode.put(value)
-
 
 if __name__ == "__main__":
     pilatus_2 = PilatuscSAXS(name="pilatus_2", prefix="X12SA-ES-PILATUS300K:", sim_mode=True)

csaxs_bec/devices/jungfraujoch/eiger_jungfrau_joch.py

@@ -0,0 +1,166 @@
+import enum
+import os
+import threading
+import time
+from typing import Any
+
+import numpy as np
+import openapi_client
+from bec_lib.logger import bec_logger
+from openapi_client.models.dataset_settings import DatasetSettings
+from ophyd import ADComponent as ADCpt
+from ophyd import Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
+from std_daq_client import StdDaqClient
+
+from ophyd_devices.interfaces.base_classes.psi_detector_base import (
+    CustomDetectorMixin,
+    PSIDetectorBase,
+)
+
+logger = bec_logger.logger
+
+
+class EigerError(Exception):
+    """Base class for exceptions in this module."""
+
+
+class EigerTimeoutError(EigerError):
+    """Raised when the Eiger does not respond in time."""
+
+class DetectorState(str, enum.Enum):
+    """Detector states for Eiger9M detector"""
+
+    IDLE = "idle"
+
+class ErrorState(int, enum.Enum):
+    """ Error State in the detector"""
+    ERROR_STATUS_WAITING = 504
+
+class Eiger9MJungfrauJochSetup(CustomDetectorMixin):
+    """Eiger setup class
+
+    Parent class: CustomDetectorMixin
+
+    """
+
+    def __init__(self, *args, parent: Device = None, **kwargs) -> None:
+        super().__init__(*args, parent=parent, **kwargs)
+        # kwargs["host"] = 
+        # kwargs["port"] = 
+        configuration = openapi_client.Configuration(host="http://sls-jfjoch-001:8080")
+        api_client = openapi_client.ApiClient(configuration)
+        self.api = openapi_client.DefaultApi(api_client)
+
+        self.actually_init()
+
+
+    def actually_init(self):
+        status = self.get_daq_status()
+        if status != DetectorState.IDLE:
+            self.api.initialize_post()
+            self.actually_wait_till_done()
+
+    def actually_wait_till_done(self):
+        while True:
+            try:
+                done = self.api.wait_till_done_post()
+            except Exception as e: #TODO: be more specific
+                if e.status != ErrorState.ERROR_STATUS_WAITING:
+                    print(e)
+                    raise e
+            else:
+                #TODO: use number_of_triggers_left for progress...
+                if done is None: # seems we get None instead of: status == 200
+                    return
+            time.sleep(0.1) #TODO
+
+    def get_daq_status(self):
+        return self.api.status_get().state
+    
+
+    def on_stage(self):
+        scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        if scan_name != "jjf_test":
+            return
+        
+        exp_time = self.parent.scaninfo.exp_time
+        readout = self.parent.scaninfo.readout_time
+        num_burst_cycle = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["num_points"]
+        cycles = self.parent.scaninfo.scan_msg.content["info"]["kwargs"]["cycles"]
+        total_points = num_burst_cycle * cycles
+        dataset_settings = DatasetSettings(
+            image_time_us = int(exp_time*1e6),
+            ntrigger=total_points,
+            beam_x_pxl = 0,
+            beam_y_pxl = 0,
+            detector_distance_mm = 100,
+            incident_energy_ke_v = 10.00,
+        )
+        self.api.start_post(dataset_settings=dataset_settings)
+
+    def on_unstage(self):
+        pass
+
+    def on_complete(self):
+        logger.info("Starting complete for {self.parent.name}")
+        scan_name = self.parent.scaninfo.scan_msg.content["info"].get("scan_name", "")
+        if scan_name != "jjf_test":
+            return
+
+        def wait_till_done_post():
+            try:
+                done = self.api.wait_till_done_post(timeout=1)
+            except Exception as e: #TODO: be more specific
+                return False
+            else:
+                #TODO: use number_of_triggers_left for progress...
+                if done is None: # seems we get None instead of: status == 200
+                    return True
+            return True
+                
+
+        status = self.wait_with_status(signal_conditions=[(wait_till_done_post, True)], check_stopped=True,timeout=10)
+        return status
+    
+    def on_stop(self):
+        self.api.cancel_post()
+
+class TriggerSource(int, enum.Enum):
+    """Trigger signals for Eiger9M detector"""
+
+    AUTO = 0
+    TRIGGER = 1
+    GATING = 2
+    BURST_TRIGGER = 3
+
+
+
+
+
+class Eiger9McSAXS(PSIDetectorBase):
+    """
+    Eiger9M detector for CSAXS
+
+    Parent class: PSIDetectorBase
+
+    class attributes:
+        custom_prepare_cls (FalconSetup)        : Custom detector setup class for cSAXS,
+                                                  inherits from CustomDetectorMixin
+        PSIDetectorBase.set_min_readout (float) : Minimum readout time for the detector
+        Various EpicsPVs for controlling the detector
+    """
+
+    # Specify which functions are revealed to the user in BEC client
+    USER_ACCESS = []
+
+    # specify Setup class
+    custom_prepare_cls = Eiger9MJungfrauJochSetup
+    # specify minimum readout time for detector and timeout for checks after unstage
+    MIN_READOUT = 20e-6
+    TIMEOUT_FOR_SIGNALS = 5
+    # specify class attributes
+
+
+if __name__ == "__main__":
+    eiger = Eiger9McSAXS(name="eiger", prefix="X12SA-ES-EIGER9M:")
+    eiger.custom_prepare.client.init()

csaxs_bec/devices/jungfraujoch/jungfraujoch_client.py

@@ -0,0 +1,84 @@
+import string
+from time import sleep
+
+import openapi_client
+
+ERROR_STATUS_WAITING = 504
+STATUS_IDLE = "Idle"
+
+# allow / to enable creation of subfolders
+ALLOWED_CHARS = set(
+    string.ascii_letters + string.digits + "_-+/"
+)
+
+
+def character_cleanup(s, default="_", allowed=ALLOWED_CHARS):
+    return "".join(i if i in allowed else default for i in s)
+
+
+
+class JFJClient:
+
+    def __init__(self, host):
+        configuration = openapi_client.Configuration(host=host)
+        api_client = openapi_client.ApiClient(configuration)
+        self.api = openapi_client.DefaultApi(api_client)
+
+        self.actually_init()
+
+
+    def actually_init(self):
+        status = self.get_daq_status()
+        if status != STATUS_IDLE:
+            self.api.initialize_post()
+            self.actually_wait_till_done()
+
+        status = self.get_daq_status()
+        if status != STATUS_IDLE:
+            raise RuntimeError(f"status is not {STATUS_IDLE} but: {status}")
+
+
+    def actually_wait_till_done(self):
+        while True:
+            try:
+                done = self.api.wait_till_done_post()
+            except Exception as e: #TODO: be more specific
+                if e.status != ERROR_STATUS_WAITING:
+                    print(e)
+                    raise e
+            else:
+                #TODO: use number_of_triggers_left for progress...
+                if done is None: # seems we get None instead of: status == 200
+                    return
+            sleep(0.1) #TODO
+
+
+    def get_daq_status(self):
+        return self.api.status_get().state
+
+    def get_detector_status(self):
+        return self.api.detector_status_get()#.state #TODO
+
+    def get_detectors(self):
+        return self.api.config_select_detector_get()
+
+    def get_detector_config(self):
+        return self.api.config_detector_get()
+
+
+    def acquire(self, file_prefix, **kwargs):
+        status = self.get_daq_status()
+        if status != STATUS_IDLE:
+            raise RuntimeError(f"status is not {STATUS_IDLE} but: {status}")
+
+        file_prefix = character_cleanup(file_prefix)
+        dataset_settings = openapi_client.DatasetSettings(file_prefix=file_prefix, **kwargs)
+
+        self.api.start_post(dataset_settings=dataset_settings)
+        self.actually_wait_till_done()
+
+
+    def take_pedestal(self):
+        self.api.pedestal_post()
+        self.actually_wait_till_done()
+

csaxs_bec/devices/npoint/npoint.py

@@ -1,12 +1,15 @@
 import functools
-import socket
 import threading
 import time
 
-from ophyd_devices.utils.controller import threadlocked
-from ophyd_devices.utils.socket import raise_if_disconnected
+import numpy as np
+from ophyd import Component as Cpt
+from ophyd import Device, PositionerBase, Signal, SignalRO
+from ophyd.status import wait as status_wait
+from ophyd.utils import LimitError, ReadOnlyError
+from ophyd_devices.utils.controller import Controller, threadlocked
+from ophyd_devices.utils.socket import SocketIO, SocketSignal, raise_if_disconnected
 from prettytable import PrettyTable
-from typeguard import typechecked
 
 
 def channel_checked(fcn):
@@ -14,81 +17,32 @@ def channel_checked(fcn):
 
     @functools.wraps(fcn)
     def wrapper(self, *args, **kwargs):
+        # pylint: disable=protected-access
         self._check_channel(args[0])
         return fcn(self, *args, **kwargs)
 
     return wrapper
 
 
-class SocketIO:
-    """SocketIO helper class for TCP IP connections"""
-
-    def __init__(self, sock=None):
-        self.is_open = False
-        if sock is None:
-            self.open()
-        else:
-            self.sock = sock
-
-    def connect(self, host, port):
-        print(f"connecting to {host} port {port}")
-        # self.sock.create_connection((host, port))
-        self.sock.connect((host, port))
-
-    def _put(self, msg_bytes):
-        return self.sock.send(msg_bytes)
-
-    def _recv(self, buffer_length=1024):
-        return self.sock.recv(buffer_length)
-
-    def _initialize_socket(self):
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.sock.settimeout(5)
-
-    def put(self, msg):
-        return self._put(msg)
-
-    def receive(self, buffer_length=1024):
-        return self._recv(buffer_length=buffer_length)
-
-    def open(self):
-        self._initialize_socket()
-        self.is_open = True
-
-    def close(self):
-        self.sock.close()
-        self.sock = None
-        self.is_open = False
+class NpointError(Exception):
+    """
+    Base class for Npoint errors.
+    """
 
 
-class NPointController:
-    _controller_instance = None
+class NPointController(Controller):
+    """
+    Controller for nPoint piezo stages. This class inherits from the Controller class
+    and provides a singleton interface to the nPoint controller.
+    """
 
-    NUM_CHANNELS = 3
+    _axes_per_controller = 3
     _read_single_loc_bit = "A0"
     _write_single_loc_bit = "A2"
     _trailing_bit = "55"
     _range_offset = "78"
     _channel_base = ["11", "83"]
 
-    def __init__(
-        self, comm_socket: SocketIO, server_ip: str = "129.129.99.87", server_port: int = 23
-    ) -> None:
-        self._lock = threading.RLock()
-        super().__init__()
-        self._server_and_port_name = (server_ip, server_port)
-        self.socket = comm_socket
-        self.connected = False
-
-    def __new__(cls, *args, **kwargs):
-        if not NPointController._controller_instance:
-            NPointController._controller_instance = object.__new__(cls)
-        return NPointController._controller_instance
-
-    @classmethod
-    def create(cls):
-        return cls(SocketIO())
-
     def show_all(self) -> None:
         """Display current status of all channels
 
@@ -98,54 +52,13 @@ class NPointController:
         if not self.connected:
             print("npoint controller is currently disabled.")
             return
-        print(f"Connected to controller at {self._server_and_port_name}")
+        print(f"Connected to controller at {self._socket_host}:{self._socket_port}")
         t = PrettyTable()
         t.field_names = ["Channel", "Range", "Position", "Target"]
-        for ii in range(self.NUM_CHANNELS):
-            t.add_row(
-                [ii, self._get_range(ii), self._get_current_pos(ii), self._get_target_pos(ii)]
-            )
+        for ii in range(self._axes_per_controller):
+            t.add_row([ii, self._get_range(ii), self.get_current_pos(ii), self.get_target_pos(ii)])
         print(t)
 
-    @threadlocked
-    def on(self) -> None:
-        """Enable the NPoint controller and open a new socket.
-
-        Raises:
-            TimeoutError: Raised if the socket connection raises a timeout.
-
-        Returns:
-            None
-        """
-        if self.connected:
-            print("You are already connected to the NPoint controller.")
-            return
-        if not self.socket.is_open:
-            self.socket.open()
-        try:
-            self.socket.connect(self._server_and_port_name[0], self._server_and_port_name[1])
-        except socket.timeout:
-            raise TimeoutError(
-                f"Failed to connect to the specified server and port {self._server_and_port_name}."
-            )
-        except OSError:
-            print("ERROR while connecting. Let's try again")
-            self.socket.close()
-            time.sleep(0.5)
-            self.socket.open()
-            self.socket.connect(self._server_and_port_name[0], self._server_and_port_name[1])
-        self.connected = True
-
-    @threadlocked
-    def off(self) -> None:
-        """Disable the controller and close the socket.
-
-        Returns:
-            None
-        """
-        self.socket.close()
-        self.connected = False
-
     @channel_checked
     def _get_range(self, channel: int) -> int:
         """Get the range of the specified channel axis.
@@ -174,7 +87,7 @@ class NPointController:
         return device_range
 
     @channel_checked
-    def _get_current_pos(self, channel: int) -> float:
+    def get_current_pos(self, channel: int) -> float:
         # for first channel: 0x11 83 13 34
         addr = self._channel_base.copy()
         addr.extend([f"{19 + 16 * channel:x}", "34"])
@@ -187,7 +100,7 @@ class NPointController:
         return pos
 
     @channel_checked
-    def _set_target_pos(self, channel: int, pos: float) -> None:
+    def set_target_pos(self, channel: int, pos: float) -> None:
         # for first channel: 0x11 83 12 18 00 00 00 00
         addr = self._channel_base.copy()
         addr.extend([f"{18 + channel * 16:x}", "18"])
@@ -199,7 +112,7 @@ class NPointController:
         self._put(send_buffer)
 
     @channel_checked
-    def _get_target_pos(self, channel: int) -> float:
+    def get_target_pos(self, channel: int) -> float:
         # for first channel: 0x11 83 12 18
         addr = self._channel_base.copy()
         addr.extend([f"{18 + channel * 16:x}", "18"])
@@ -214,17 +127,17 @@ class NPointController:
     def _set_servo(self, channel: int, enable: bool) -> None:
         print("Not tested")
         return
-        # for first channel: 0x11 83 10 84 00 00 00 00
-        addr = self._channel_base.copy()
-        addr.extend([f"{16 + channel * 16:x}", "84"])
+        # # for first channel: 0x11 83 10 84 00 00 00 00
+        # addr = self._channel_base.copy()
+        # addr.extend([f"{16 + channel * 16:x}", "84"])
 
-        if enable:
-            data = ["00"] * 3 + ["01"]
-        else:
-            data = ["00"] * 4
-        send_buffer = self.__write_single_location_buffer(addr, data)
+        # if enable:
+        #     data = ["00"] * 3 + ["01"]
+        # else:
+        #     data = ["00"] * 4
+        # send_buffer = self.__write_single_location_buffer(addr, data)
 
-        self._put(send_buffer)
+        # self._put(send_buffer)
 
     @channel_checked
     def _get_servo(self, channel: int) -> int:
@@ -250,7 +163,7 @@ class NPointController:
         """
 
         buffer = b"".join([bytes.fromhex(m) for m in buffer])
-        self.socket.put(buffer)
+        self.sock.put(buffer)
 
     @threadlocked
     def _put_and_receive(self, msg_hex_list: list) -> list:
@@ -264,8 +177,8 @@ class NPointController:
         """
 
         buffer = b"".join([bytes.fromhex(m) for m in msg_hex_list])
-        self.socket.put(buffer)
-        recv_msg = self.socket.receive()
+        self.sock.put(buffer)
+        recv_msg = self.sock.receive()
         recv_hex_list = [hex(m) for m in recv_msg]
         self._verify_received_msg(msg_hex_list, recv_hex_list)
         return recv_hex_list
@@ -293,9 +206,9 @@ class NPointController:
             raise RuntimeError("Connection failure. Please restart the controller.")
 
     def _check_channel(self, channel: int) -> None:
-        if channel >= self.NUM_CHANNELS:
+        if channel >= self._axes_per_controller:
             raise ValueError(
-                f"Channel {channel+1} exceeds the available number of channels ({self.NUM_CHANNELS})"
+                f"Channel {channel+1} exceeds the available number of channels ({self._axes_per_controller})"
             )
 
     @staticmethod
@@ -391,155 +304,285 @@ class NPointController:
             self.off()
 
 
-class NPointAxis:
-    def __init__(self, controller: NPointController, channel: int, name: str) -> None:
-        super().__init__()
-        self._axis_range = 100
-        self.controller = controller
-        self.channel = channel
-        self.name = name
-        self.controller._check_channel(channel)
-        self._settling_time = 0.1
+class NpointSignalBase(SocketSignal):
+    """
+    Base class for nPoint signals.
+    """
 
-        if self.settling_time == 0:
-            self.settling_time = 0.1
-            print(f"Setting the npoint settling time to {self.settling_time:.2f} s.")
-            print(
-                "You can set the settling time depending on the stage tuning\nusing the settling_time property."
-            )
-            print("This is the waiting time before the counting is done.")
+    def __init__(self, signal_name, **kwargs):
+        self.signal_name = signal_name
+        super().__init__(**kwargs)
+        self.controller: NPointController = self.parent.controller
+        self.sock = self.parent.controller.sock
 
-    def show_all(self) -> None:
-        self.controller.show_all()
 
-    @raise_if_disconnected
-    def get(self) -> float:
-        """Get current position for this channel.
+class NpointSignalRO(NpointSignalBase):
+    """
+    Base class for read-only signals.
+    """
 
-        Raises:
-            RuntimeError: Raised if channel is not connected.
+    def __init__(self, signal_name, **kwargs):
+        super().__init__(signal_name, **kwargs)
+        self._metadata["write_access"] = False
 
-        Returns:
-            float: position
+    @threadlocked
+    def _socket_set(self, val):
+        raise ReadOnlyError("Read-only signals cannot be set")
+
+
+class NpointReadbackSignal(NpointSignalRO):
+    """
+    Signal to read the current position of an nPoint piezo stage.
+    """
+
+    @threadlocked
+    def _socket_get(self):
+
+        return self.controller.get_current_pos(self.parent.axis_Id_numeric) * self.parent.sign
+
+
+class NpointSetpointSignal(NpointSignalBase):
+    """
+    Signal to set the target position of an nPoint piezo stage.
+    """
+
+    setpoint = 0
+
+    @threadlocked
+    def _socket_get(self):
+        return self.controller.get_target_pos(self.parent.axis_Id_numeric) * self.parent.sign
+
+    @threadlocked
+    def _socket_set(self, val):
+        target_val = val * self.parent.sign
+        self.setpoint = target_val
+        return self.controller.set_target_pos(
+            self.parent.axis_Id_numeric, target_val * self.parent.sign
+        )
+
+
+class NpointMotorIsMoving(SignalRO):
+    """
+    Signal to indicate whether the motor is currently moving or not.
+    """
+
+    def set_motor_is_moving(self, value: int) -> None:
         """
-        return self.controller._get_current_pos(self.channel)
-
-    @raise_if_disconnected
-    def get_target_pos(self) -> float:
-        """Get target position for this channel.
-
-        Raises:
-            RuntimeError: Raised if channel is not connected.
-
-        Returns:
-            float: position
-        """
-        return self.controller._get_target_pos(self.channel)
-
-    @raise_if_disconnected
-    @typechecked
-    def set(self, pos: float) -> None:
-        """Set a new target position and wait until settled (settling_time).
+        Set the motor_is_moving signal to the specified value.
 
         Args:
-            pos (float): New target position
-
-        Raises:
-            RuntimeError: Raised if channel is not connected.
-
-        Returns:
-            None
+            value (int): 1 if the motor is moving, 0 otherwise.
         """
-        self.controller._set_target_pos(self.channel, pos)
-        time.sleep(self.settling_time)
+        self._readback = value
+
+
+class NPointAxis(Device, PositionerBase):
+    """
+    NPointAxis class, which inherits from Device and PositionerBase. This class
+    represents an axis of an nPoint piezo stage and provides the necessary
+    functionality to move the axis and read its current position.
+    """
+
+    USER_ACCESS = ["controller"]
+    readback = Cpt(NpointReadbackSignal, signal_name="readback", kind="hinted")
+    user_setpoint = Cpt(NpointSetpointSignal, signal_name="setpoint")
+
+    motor_is_moving = Cpt(NpointMotorIsMoving, value=0, kind="normal")
+    settling_time = Cpt(Signal, value=0.1, kind="config")
+    high_limit_travel = Cpt(Signal, value=0, kind="omitted")
+    low_limit_travel = Cpt(Signal, value=0, kind="omitted")
+
+    SUB_READBACK = "readback"
+    SUB_CONNECTION_CHANGE = "connection_change"
+    _default_sub = SUB_READBACK
+
+    def __init__(
+        self,
+        axis_Id,
+        prefix="",
+        *,
+        name,
+        kind=None,
+        read_attrs=None,
+        configuration_attrs=None,
+        parent=None,
+        host="mpc2680.psi.ch",
+        port=8085,
+        limits=None,
+        sign=1,
+        socket_cls=SocketIO,
+        tolerance: float = 0.05,
+        **kwargs,
+    ):
+        self.controller = NPointController(
+            socket_cls=socket_cls, socket_host=host, socket_port=port
+        )
+        self.axis_Id = axis_Id
+        self.sign = sign
+        self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
+        self.tolerance = tolerance
+
+        super().__init__(
+            prefix,
+            name=name,
+            kind=kind,
+            read_attrs=read_attrs,
+            configuration_attrs=configuration_attrs,
+            parent=parent,
+            **kwargs,
+        )
+        self.readback.name = self.name
+        self.controller.subscribe(
+            self._update_connection_state, event_type=self.SUB_CONNECTION_CHANGE
+        )
+        self._update_connection_state()
+        if limits is not None:
+            assert len(limits) == 2
+            self.low_limit_travel.put(limits[0])
+            self.high_limit_travel.put(limits[1])
 
     @property
-    def connected(self) -> bool:
-        return self.controller.connected
+    def limits(self):
+        return (self.low_limit_travel.get(), self.high_limit_travel.get())
 
     @property
+    def low_limit(self):
+        return self.limits[0]
+
+    @property
+    def high_limit(self):
+        return self.limits[1]
+
+    def check_value(self, pos):
+        """Check that the position is within the soft limits"""
+        low_limit, high_limit = self.limits
+
+        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
+            raise LimitError(f"position={pos} not within limits {self.limits}")
+
+    def _update_connection_state(self, **kwargs):
+        for walk in self.walk_signals():
+            walk.item._metadata["connected"] = self.controller.connected
+
     @raise_if_disconnected
-    def servo(self) -> int:
-        """Get servo status
+    def move(self, position, wait=True, **kwargs):
+        """Move to a specified position, optionally waiting for motion to
+        complete.
 
-        Raises:
-            RuntimeError: Raised if channel is not connected.
+        Parameters
+        ----------
+        position
+            Position to move to
+        moved_cb : callable
+            Call this callback when movement has finished. This callback must
+            accept one keyword argument: 'obj' which will be set to this
+            positioner instance.
+        timeout : float, optional
+            Maximum time to wait for the motion. If None, the default timeout
+            for this positioner is used.
 
-        Returns:
-            int: Servo status
+        Returns
+        -------
+        status : MoveStatus
+
+        Raises
+        ------
+        TimeoutError
+            When motion takes longer than `timeout`
+        ValueError
+            On invalid positions
+        RuntimeError
+            If motion fails other than timing out
         """
-        return self.controller._get_servo(self.channel)
+        self._started_moving = False
+        timeout = kwargs.pop("timeout", 10)
+        status = super().move(position, timeout=timeout, **kwargs)
+        self.user_setpoint.put(position, wait=False)
 
-    @servo.setter
-    @raise_if_disconnected
-    @typechecked
-    def servo(self, val: bool) -> None:
-        """Set servo status
+        def move_and_finish():
+            self.motor_is_moving.set_motor_is_moving(1)
+            val = self.readback.read()
+            self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
+            time.sleep(self.settling_time.get())
+            self.motor_is_moving.set_motor_is_moving(0)
+            val = self.readback.read()
+            self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
+            success = np.isclose(val[self.name]["value"], position, atol=self.tolerance)
+            self._done_moving(success=success)
+
+        threading.Thread(target=move_and_finish, daemon=True).start()
+        try:
+            if wait:
+                status_wait(status)
+        except KeyboardInterrupt:
+            self.stop()
+            raise
+
+        return status
+
+    @property
+    def axis_Id(self):
+        """
+        Return the axis_Id_alpha.
+        """
+        return self._axis_Id_alpha
+
+    @axis_Id.setter
+    def axis_Id(self, val: str):
+        """
+        Set the axis_Id_alpha and axis_Id_numeric based on the alpha value.
 
         Args:
-            val (bool): Servo status
-
-        Raises:
-            RuntimeError: Raised if channel is not connected.
-
-        Returns:
-            None
+            val (str): Single-character axis identifier.
         """
-        self.controller._set_servo(self.channel, val)
-
-    @property
-    def settling_time(self) -> float:
-        return self._settling_time
-
-    @settling_time.setter
-    @typechecked
-    def settling_time(self, val: float) -> None:
-        self._settling_time = val
-        print(f"Setting the npoint settling time to {val:.2f} s.")
-
-
-class NPointEpics(NPointAxis):
-    def __init__(self, controller: NPointController, channel: int, name: str) -> None:
-        super().__init__(controller, channel, name)
-        self.low_limit = -50
-        self.high_limit = 50
-        self._prefix = name
-
-    def get_pv(self) -> str:
-        return self.name
-
-    def get_position(self, readback=True) -> float:
-        if readback:
-            return self.get()
+        if isinstance(val, str):
+            if len(val) != 1:
+                raise ValueError("Only single-character axis_Ids are supported.")
+            self._axis_Id_alpha = val
+            self._axis_Id_numeric = ord(val.lower()) - 97
         else:
-            return self.get_target_pos()
+            raise TypeError(f"Expected value of type str but received {type(val)}")
 
-    def within_limits(self, pos: float) -> bool:
-        return pos > self.low_limit and pos < self.high_limit
+    @property
+    def axis_Id_numeric(self):
+        """
+        Return the numeric value of the axis_Id.
+        """
+        return self._axis_Id_numeric
 
-    def move(self, position: float, wait=True) -> None:
-        self.set(position)
+    @axis_Id_numeric.setter
+    def axis_Id_numeric(self, val: int):
+        """
+        Set the axis_Id_numeric and axis_Id_alpha based on the numeric value.
+
+        Args:
+            val (int): Numeric axis identifier.
+        """
+        if isinstance(val, int):
+            if val > 26:
+                raise ValueError("Numeric value exceeds supported range.")
+            self._axis_Id_alpha = val
+            self._axis_Id_numeric = (chr(val + 97)).capitalize()
+        else:
+            raise TypeError(f"Expected value of type int but received {type(val)}")
+
+    @property
+    def egu(self):
+        """The engineering units (EGU) for positions"""
+        return "um"
+
+    def stage(self) -> list[object]:
+        return super().stage()
+
+    def unstage(self) -> list[object]:
+        return super().unstage()
 
 
 if __name__ == "__main__":
-    ## EXAMPLES ##
-    #
-    # Create controller and socket instance explicitly:
-    #     controller = NPointController(SocketIO())
-    #     npointx = NPointAxis(controller, 0, "nx")
-    #     npointy = NPointAxis(controller, 1, "ny")
-
-    # Create controller instance explicitly
-    #     controller = NPointController.create()
-    #     npointx = NPointAxis(controller, 0, "nx")
-    #     npointy = NPointAxis(controller, 1, "ny")
-
-    # Single-line axis:
-    #     npointx = NPointAxis(NPointController.create(), 0, "nx")
-    #
-    # EPICS wrapper:
-    #     nx = NPointEpics(NPointController.create(), 0, "nx")
-
-    controller = NPointController.create()
-    npointx = NPointAxis(NPointController.create(), 0, "nx")
-    npointy = NPointAxis(NPointController.create(), 0, "ny")
+    npx = NPointAxis(axis_Id="A", name="npx", host="nPoint000003.psi.ch", port=23)
+    npy = NPointAxis(axis_Id="B", name="npy", host="nPoint000003.psi.ch", port=23)
+    npx.controller.on()
+    print("socket is open, axis is ready!")
+    npx.move(10)
+    print(npx.read())
+    npx.controller.off()

csaxs_bec/devices/omny/eiger1p5m.py

@@ -1,9 +1,10 @@
 import os
 import time
 
-from bec_lib import MessageEndpoints, bec_logger, messages
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from ophyd import Component as Cpt
-from ophyd import Device, DeviceStatus, EpicsSignal, EpicsSignalRO, Signal
+from ophyd import Device, EpicsSignal, EpicsSignalRO, Signal
 
 logger = bec_logger.logger
 

csaxs_bec/devices/omny/galil/__init__.py

@@ -1,4 +1,4 @@
 from .fgalil_ophyd import FlomniGalilController, FlomniGalilMotor
 from .fupr_ophyd import FuprGalilController, FuprGalilMotor
-from .galil_ophyd import GalilController, GalilMotor
+from .lgalil_ophyd import LamniGalilController, LamniGalilMotor
 from .sgalil_ophyd import SGalilMotor

csaxs_bec/devices/omny/galil/fgalil_ophyd.py

@@ -10,7 +10,7 @@ from ophyd.utils import LimitError
 from ophyd_devices.utils.controller import threadlocked
 from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
 
-from csaxs_bec.devices.galil.galil_ophyd import (
+from csaxs_bec.devices.omny.galil.galil_ophyd import (
     BECConfigError,
     GalilAxesReferenced,
     GalilController,

csaxs_bec/devices/omny/galil/fupr_ophyd.py

@@ -1,4 +1,3 @@
-import functools
 import threading
 import time
 
@@ -7,15 +6,13 @@ from bec_lib import bec_logger
 from ophyd import Component as Cpt
 from ophyd import Device, PositionerBase, Signal
 from ophyd.status import wait as status_wait
-from ophyd.utils import LimitError, ReadOnlyError
-from ophyd_devices.utils.controller import Controller, threadlocked
-from ophyd_devices.utils.socket import SocketIO, SocketSignal, raise_if_disconnected
-from prettytable import PrettyTable
+from ophyd.utils import LimitError
+from ophyd_devices.utils.controller import threadlocked
+from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
 
-from csaxs_bec.devices.galil.galil_ophyd import (
+from csaxs_bec.devices.omny.galil.galil_ophyd import (
     BECConfigError,
     GalilAxesReferenced,
-    GalilCommunicationError,
     GalilController,
     GalilError,
     GalilMotorIsMoving,

csaxs_bec/devices/omny/galil/galil_ophyd.py

@@ -1,15 +1,14 @@
+"""
+This module contains the base class for Galil controllers as well as the signals used for Galil devices.
+"""
+
 import functools
-import threading
 import time
 
-import numpy as np
 from bec_lib import bec_logger
-from ophyd import Component as Cpt
-from ophyd import Device, PositionerBase, Signal
-from ophyd.status import wait as status_wait
-from ophyd.utils import LimitError, ReadOnlyError
+from ophyd.utils import ReadOnlyError
 from ophyd_devices.utils.controller import Controller, threadlocked
-from ophyd_devices.utils.socket import SocketIO, SocketSignal, raise_if_disconnected
+from ophyd_devices.utils.socket import SocketSignal
 from prettytable import PrettyTable
 
 logger = bec_logger.logger
@@ -42,6 +41,10 @@ def retry_once(fcn):
 
 
 class GalilController(Controller):
+    """
+    Base class for Galil controllers. This class provides the basic functionality for Galil controllers and should be subclassed for specific devices.
+    """
+
     _axes_per_controller = 8
     USER_ACCESS = [
         "describe",
@@ -49,7 +52,6 @@ class GalilController(Controller):
         "galil_show_all",
         "socket_put_and_receive",
         "socket_put_confirmed",
-        "lgalil_is_air_off_and_orchestra_enabled",
         "drive_axis_to_limit",
         "find_reference",
         "get_motor_limit_switch",
@@ -61,18 +63,6 @@ class GalilController(Controller):
     def socket_put(self, val: str) -> None:
         self.sock.put(f"{val}\r".encode())
 
-    @threadlocked
-    def socket_get(self) -> str:
-        return self.sock.receive().decode()
-
-    @retry_once
-    @threadlocked
-    def socket_put_and_receive(self, val: str, remove_trailing_chars=True) -> str:
-        self.socket_put(val)
-        if remove_trailing_chars:
-            return self._remove_trailing_characters(self.sock.receive().decode())
-        return self.socket_get()
-
     @retry_once
     def socket_put_confirmed(self, val: str) -> None:
         """Send message to controller and ensure that it is received by checking that the socket receives a colon.
@@ -94,7 +84,9 @@ class GalilController(Controller):
         if axis_Id is None and axis_Id_numeric is not None:
             axis_Id = self.axis_Id_numeric_to_alpha(axis_Id_numeric)
         is_moving = bool(float(self.socket_put_and_receive(f"MG_BG{axis_Id}")) != 0)
-        backlash_is_active = bool(float(self.socket_put_and_receive(f"MGbcklact[{axis_Id_numeric}]")) != 0)
+        backlash_is_active = bool(
+            float(self.socket_put_and_receive(f"MGbcklact[{axis_Id_numeric}]")) != 0
+        )
         return bool(
             is_moving or backlash_is_active or self.is_thread_active(0) or self.is_thread_active(2)
         )
@@ -105,21 +97,10 @@ class GalilController(Controller):
             return False
         return True
 
-    def _remove_trailing_characters(self, var) -> str:
-        if len(var) > 1:
-            return var.split("\r\n")[0]
-        return var
-
     def stop_all_axes(self) -> str:
-        return self.socket_put_and_receive(f"XQ#STOP,1")
+        return self.socket_put_and_receive("XQ#STOP,1")
 
-    def lgalil_is_air_off_and_orchestra_enabled(self) -> bool:
-        # TODO: move this to the LamNI-specific controller
-        rt_not_blocked_by_galil = bool(self.socket_put_and_receive(f"MG@OUT[9]"))
-        air_off = bool(self.socket_put_and_receive(f"MG@OUT[13]"))
-        return rt_not_blocked_by_galil and air_off
-    
-    def get_digital_input(self,channel):
+    def get_digital_input(self, channel):
         return bool(float(self.socket_put_and_receive(f"MG @IN[{channel}]").strip()))
 
     def axis_is_referenced(self, axis_Id_numeric) -> bool:
@@ -248,40 +229,17 @@ class GalilController(Controller):
         self.show_running_threads()
         self.show_status_other()
 
-    def show_status_other(self):
-        #Todo: move to lgalil specific section
-        if(self.get_digital_input(5)):
-            print("Emergency stop is not pushed.")
-        else:
-            print("Emergency stop is pushed.")
-        if(self.get_digital_input(6)):
-            print("Driver axis 2 error.")
-        if(self.get_digital_input(13)):
-            print("No air pressure at inner rotation.")
-        else:
-            print("There is air pressure at the inner rotation.")
-        if(self.get_digital_input(14)):
-            print("No air pressure at outer rotation axial.")
-        else:
-            print("There is air pressure at the outer rotation axial.")
-        if(self.get_digital_input(15)):
-            print("No air pressure at outer rotation radial.")
-        else:
-            print("There is air pressure at the outer rotation radial.")
-        swver = float(self.socket_put_and_receive("MGswver"))
-        print(f"Lgalil LAMNI firmware version {swver:2.0f}.")
+    def show_status_other(self) -> None:
+        """
+        Show additional device-specific status information.
+        Override in subclasses.
+        """
 
     def galil_show_all(self) -> None:
         for controller in self._controller_instances.values():
             if isinstance(controller, GalilController):
                 controller.describe()
 
-    def lamni_lights_off(self):
-        self.socket_put_confirmed("SB1")
-
-    def lamni_lights_on(self):
-        self.socket_put_confirmed("CB1")
-
     @staticmethod
     def axis_Id_to_numeric(axis_Id: str) -> int:
         return ord(axis_Id.lower()) - 97
@@ -378,7 +336,9 @@ class GalilSetpointSignal(GalilSignalBase):
                         if angle_status:
                             self.controller.socket_put_confirmed("angintf=1")
                 except KeyError:
-                    logger.warning("RT is disabled. Failed to update RT angle interferometer status to galil.")
+                    logger.warning(
+                        "RT is disabled. Failed to update RT angle interferometer status to galil."
+                    )
 
             self.controller.socket_put_confirmed(f"naxis={self.parent.axis_Id_numeric}")
             self.controller.socket_put_confirmed(f"ntarget={target_val:.3f}")
@@ -415,229 +375,3 @@ class GalilAxesReferenced(GalilSignalRO):
     @threadlocked
     def _socket_get(self):
         return self.controller.all_axes_referenced()
-
-
-class GalilMotor(Device, PositionerBase):
-    USER_ACCESS = ["controller"]
-    readback = Cpt(GalilReadbackSignal, signal_name="readback", kind="hinted")
-    user_setpoint = Cpt(GalilSetpointSignal, signal_name="setpoint")
-    motor_resolution = Cpt(GalilMotorResolution, signal_name="resolution", kind="config")
-    motor_is_moving = Cpt(GalilMotorIsMoving, signal_name="motor_is_moving", kind="normal")
-    all_axes_referenced = Cpt(GalilAxesReferenced, signal_name="all_axes_referenced", kind="config")
-    high_limit_travel = Cpt(Signal, value=0, kind="omitted")
-    low_limit_travel = Cpt(Signal, value=0, kind="omitted")
-
-    SUB_READBACK = "readback"
-    SUB_CONNECTION_CHANGE = "connection_change"
-    _default_sub = SUB_READBACK
-
-    def __init__(
-        self,
-        axis_Id,
-        prefix="",
-        *,
-        name,
-        kind=None,
-        read_attrs=None,
-        configuration_attrs=None,
-        parent=None,
-        host="mpc2680.psi.ch",
-        port=8081,
-        limits=None,
-        sign=1,
-        socket_cls=SocketIO,
-        device_manager=None,
-        **kwargs,
-    ):
-        self.controller = GalilController(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)
-        self.sign = sign
-        self.tolerance = kwargs.pop("tolerance", 0.5)
-        self.device_mapping = kwargs.pop("device_mapping", {})
-        self.device_manager = device_manager
-
-        if len(self.device_mapping) > 0 and self.device_manager is None:
-            raise BECConfigError(
-                "device_mapping has been specified but the device_manager cannot be accessed."
-            )
-        self.rt = self.device_mapping.get("rt")
-
-        super().__init__(
-            prefix,
-            name=name,
-            kind=kind,
-            read_attrs=read_attrs,
-            configuration_attrs=configuration_attrs,
-            parent=parent,
-            **kwargs,
-        )
-        self.readback.name = self.name
-        self.controller.subscribe(
-            self._update_connection_state, event_type=self.SUB_CONNECTION_CHANGE
-        )
-        self._update_connection_state()
-        # self.readback.subscribe(self._forward_readback, event_type=self.readback.SUB_VALUE)
-
-        if limits is not None:
-            assert len(limits) == 2
-            self.low_limit_travel.put(limits[0])
-            self.high_limit_travel.put(limits[1])
-
-    @property
-    def limits(self):
-        return (self.low_limit_travel.get(), self.high_limit_travel.get())
-
-    @property
-    def low_limit(self):
-        return self.limits[0]
-
-    @property
-    def high_limit(self):
-        return self.limits[1]
-
-    def check_value(self, pos):
-        """Check that the position is within the soft limits"""
-        low_limit, high_limit = self.limits
-
-        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
-            raise LimitError(f"position={pos} not within limits {self.limits}")
-
-    def _update_connection_state(self, **kwargs):
-        for walk in self.walk_signals():
-            walk.item._metadata["connected"] = self.controller.connected
-
-    def _forward_readback(self, **kwargs):
-        kwargs.pop("sub_type")
-        self._run_subs(sub_type="readback", **kwargs)
-
-    @raise_if_disconnected
-    def move(self, position, wait=True, **kwargs):
-        """Move to a specified position, optionally waiting for motion to
-        complete.
-
-        Parameters
-        ----------
-        position
-            Position to move to
-        moved_cb : callable
-            Call this callback when movement has finished. This callback must
-            accept one keyword argument: 'obj' which will be set to this
-            positioner instance.
-        timeout : float, optional
-            Maximum time to wait for the motion. If None, the default timeout
-            for this positioner is used.
-
-        Returns
-        -------
-        status : MoveStatus
-
-        Raises
-        ------
-        TimeoutError
-            When motion takes longer than `timeout`
-        ValueError
-            On invalid positions
-        RuntimeError
-            If motion fails other than timing out
-        """
-        self._started_moving = False
-        timeout = kwargs.pop("timeout", 100)
-        status = super().move(position, timeout=timeout, **kwargs)
-        self.user_setpoint.put(position, wait=False)
-
-        def move_and_finish():
-            while self.motor_is_moving.get():
-                logger.info("motor is moving")
-                val = self.readback.read()
-                self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
-                time.sleep(0.1)
-            val = self.readback.read()
-            success = np.isclose(val[self.name]["value"], position, atol=self.tolerance)
-
-            if not success:
-                print(" stop")
-            self._done_moving(success=success)
-            logger.info("Move finished")
-
-        threading.Thread(target=move_and_finish, daemon=True).start()
-        try:
-            if wait:
-                status_wait(status)
-        except KeyboardInterrupt:
-            self.stop()
-            raise
-
-        return status
-
-    @property
-    def axis_Id(self):
-        return self._axis_Id_alpha
-
-    @axis_Id.setter
-    def axis_Id(self, val):
-        if isinstance(val, str):
-            if len(val) != 1:
-                raise ValueError(f"Only single-character axis_Ids are supported.")
-            self._axis_Id_alpha = val
-            self._axis_Id_numeric = self.controller.axis_Id_to_numeric(val)
-        else:
-            raise TypeError(f"Expected value of type str but received {type(val)}")
-
-    @property
-    def axis_Id_numeric(self):
-        return self._axis_Id_numeric
-
-    @axis_Id_numeric.setter
-    def axis_Id_numeric(self, val):
-        if isinstance(val, int):
-            if val > 26:
-                raise ValueError(f"Numeric value exceeds supported range.")
-            self._axis_Id_alpha = self.controller.axis_Id_numeric_to_alpha(val)
-            self._axis_Id_numeric = val
-        else:
-            raise TypeError(f"Expected value of type int but received {type(val)}")
-
-    @property
-    def egu(self):
-        """The engineering units (EGU) for positions"""
-        return "mm"
-
-    def stage(self) -> list[object]:
-        return super().stage()
-
-    def unstage(self) -> list[object]:
-        return super().unstage()
-
-    def stop(self, *, success=False):
-        self.controller.stop_all_axes()
-        return super().stop(success=success)
-
-
-if __name__ == "__main__":
-    # pytest: skip-file
-    mock = False
-    if not mock:
-        leyey = GalilMotor("H", name="leyey", host="mpc2680.psi.ch", port=8081, sign=-1)
-        leyey.stage()
-        status = leyey.move(0, wait=True)
-        status = leyey.move(10, wait=True)
-        leyey.read()
-
-        leyey.get()
-        leyey.describe()
-
-        leyey.unstage()
-    else:
-        from ophyd_devices.utils.socket import SocketMock
-
-        leyex = GalilMotor(
-            "G", name="leyex", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
-        )
-        leyey = GalilMotor(
-            "H", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
-        )
-        leyex.stage()
-        # leyey.stage()
-
-        leyex.controller.galil_show_all()

csaxs_bec/devices/omny/galil/lgalil_ophyd.py

@@ -0,0 +1,265 @@
+import threading
+import time
+
+import numpy as np
+from bec_lib.logger import bec_logger
+from ophyd import Component as Cpt
+from ophyd import Device, PositionerBase, Signal
+from ophyd.status import wait as status_wait
+from ophyd.utils import LimitError
+from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
+
+from csaxs_bec.devices.omny.galil.galil_ophyd import (
+    BECConfigError,
+    GalilAxesReferenced,
+    GalilController,
+    GalilMotorIsMoving,
+    GalilMotorResolution,
+    GalilReadbackSignal,
+    GalilSetpointSignal,
+)
+
+logger = bec_logger.logger
+
+
+class LamniGalilController(GalilController):
+    USER_ACCESS = [
+        "describe",
+        "show_running_threads",
+        "galil_show_all",
+        "socket_put_and_receive",
+        "socket_put_confirmed",
+        "lgalil_is_air_off_and_orchestra_enabled",
+        "drive_axis_to_limit",
+        "find_reference",
+        "get_motor_limit_switch",
+        "is_motor_on",
+        "all_axes_referenced",
+    ]
+
+    def show_status_other(self):
+        if self.get_digital_input(5):
+            print("Emergency stop is not pushed.")
+        else:
+            print("Emergency stop is pushed.")
+        if self.get_digital_input(6):
+            print("Driver axis 2 error.")
+        if self.get_digital_input(13):
+            print("No air pressure at inner rotation.")
+        else:
+            print("There is air pressure at the inner rotation.")
+        if self.get_digital_input(14):
+            print("No air pressure at outer rotation axial.")
+        else:
+            print("There is air pressure at the outer rotation axial.")
+        if self.get_digital_input(15):
+            print("No air pressure at outer rotation radial.")
+        else:
+            print("There is air pressure at the outer rotation radial.")
+        swver = float(self.socket_put_and_receive("MGswver"))
+        print(f"Lgalil LAMNI firmware version {swver:2.0f}.")
+
+    def lamni_lights_off(self):
+        self.socket_put_confirmed("SB1")
+
+    def lamni_lights_on(self):
+        self.socket_put_confirmed("CB1")
+
+    def lgalil_is_air_off_and_orchestra_enabled(self) -> bool:
+        # TODO: move this to the LamNI-specific controller
+        rt_not_blocked_by_galil = bool(self.socket_put_and_receive("MG@OUT[9]"))
+        air_off = bool(self.socket_put_and_receive("MG@OUT[13]"))
+        return rt_not_blocked_by_galil and air_off
+
+
+class LamniGalilMotor(Device, PositionerBase):
+    USER_ACCESS = ["controller"]
+    readback = Cpt(GalilReadbackSignal, signal_name="readback", kind="hinted")
+    user_setpoint = Cpt(GalilSetpointSignal, signal_name="setpoint")
+    motor_resolution = Cpt(GalilMotorResolution, signal_name="resolution", kind="config")
+    motor_is_moving = Cpt(GalilMotorIsMoving, signal_name="motor_is_moving", kind="normal")
+    all_axes_referenced = Cpt(GalilAxesReferenced, signal_name="all_axes_referenced", kind="config")
+    high_limit_travel = Cpt(Signal, value=0, kind="omitted")
+    low_limit_travel = Cpt(Signal, value=0, kind="omitted")
+
+    SUB_READBACK = "readback"
+    SUB_CONNECTION_CHANGE = "connection_change"
+    _default_sub = SUB_READBACK
+
+    def __init__(
+        self,
+        axis_Id,
+        prefix="",
+        *,
+        name,
+        kind=None,
+        read_attrs=None,
+        configuration_attrs=None,
+        parent=None,
+        host="mpc2680.psi.ch",
+        port=8081,
+        limits=None,
+        sign=1,
+        socket_cls=SocketIO,
+        device_manager=None,
+        **kwargs,
+    ):
+        self.controller = LamniGalilController(
+            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)
+        self.sign = sign
+        self.tolerance = kwargs.pop("tolerance", 0.5)
+        self.device_mapping = kwargs.pop("device_mapping", {})
+        self.device_manager = device_manager
+
+        if len(self.device_mapping) > 0 and self.device_manager is None:
+            raise BECConfigError(
+                "device_mapping has been specified but the device_manager cannot be accessed."
+            )
+        self.rt = self.device_mapping.get("rt")
+
+        super().__init__(
+            prefix,
+            name=name,
+            kind=kind,
+            read_attrs=read_attrs,
+            configuration_attrs=configuration_attrs,
+            parent=parent,
+            **kwargs,
+        )
+        self.readback.name = self.name
+        self.controller.subscribe(
+            self._update_connection_state, event_type=self.SUB_CONNECTION_CHANGE
+        )
+        self._update_connection_state()
+        # self.readback.subscribe(self._forward_readback, event_type=self.readback.SUB_VALUE)
+
+        if limits is not None:
+            assert len(limits) == 2
+            self.low_limit_travel.put(limits[0])
+            self.high_limit_travel.put(limits[1])
+
+    @property
+    def limits(self):
+        return (self.low_limit_travel.get(), self.high_limit_travel.get())
+
+    @property
+    def low_limit(self):
+        return self.limits[0]
+
+    @property
+    def high_limit(self):
+        return self.limits[1]
+
+    def check_value(self, pos):
+        """Check that the position is within the soft limits"""
+        low_limit, high_limit = self.limits
+
+        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
+            raise LimitError(f"position={pos} not within limits {self.limits}")
+
+    def _update_connection_state(self, **kwargs):
+        for walk in self.walk_signals():
+            walk.item._metadata["connected"] = self.controller.connected
+
+    def _forward_readback(self, **kwargs):
+        kwargs.pop("sub_type")
+        self._run_subs(sub_type="readback", **kwargs)
+
+    @raise_if_disconnected
+    def move(self, position, wait=True, **kwargs):
+        """Move to a specified position, optionally waiting for motion to
+        complete.
+
+        Parameters
+        ----------
+        position
+            Position to move to
+        moved_cb : callable
+            Call this callback when movement has finished. This callback must
+            accept one keyword argument: 'obj' which will be set to this
+            positioner instance.
+        timeout : float, optional
+            Maximum time to wait for the motion. If None, the default timeout
+            for this positioner is used.
+
+        Returns
+        -------
+        status : MoveStatus
+
+        Raises
+        ------
+        TimeoutError
+            When motion takes longer than `timeout`
+        ValueError
+            On invalid positions
+        RuntimeError
+            If motion fails other than timing out
+        """
+        self._started_moving = False
+        timeout = kwargs.pop("timeout", 100)
+        status = super().move(position, timeout=timeout, **kwargs)
+        self.user_setpoint.put(position, wait=False)
+
+        def move_and_finish():
+            while self.motor_is_moving.get():
+                logger.info("motor is moving")
+                val = self.readback.read()
+                self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
+                time.sleep(0.1)
+            val = self.readback.read()
+            success = np.isclose(val[self.name]["value"], position, atol=self.tolerance)
+
+            if not success:
+                print(" stop")
+            self._done_moving(success=success)
+            logger.info("Move finished")
+
+        threading.Thread(target=move_and_finish, daemon=True).start()
+        try:
+            if wait:
+                status_wait(status)
+        except KeyboardInterrupt:
+            self.stop()
+            raise
+
+        return status
+
+    @property
+    def axis_Id(self):
+        return self._axis_Id_alpha
+
+    @axis_Id.setter
+    def axis_Id(self, val):
+        if isinstance(val, str):
+            if len(val) != 1:
+                raise ValueError("Only single-character axis_Ids are supported.")
+            self._axis_Id_alpha = val
+            self._axis_Id_numeric = self.controller.axis_Id_to_numeric(val)
+        else:
+            raise TypeError(f"Expected value of type str but received {type(val)}")
+
+    @property
+    def axis_Id_numeric(self):
+        return self._axis_Id_numeric
+
+    @axis_Id_numeric.setter
+    def axis_Id_numeric(self, val):
+        if isinstance(val, int):
+            if val > 26:
+                raise ValueError("Numeric value exceeds supported range.")
+            self._axis_Id_alpha = self.controller.axis_Id_numeric_to_alpha(val)
+            self._axis_Id_numeric = val
+        else:
+            raise TypeError(f"Expected value of type int but received {type(val)}")
+
+    @property
+    def egu(self):
+        """The engineering units (EGU) for positions"""
+        return "mm"
+
+    def stop(self, *, success=False):
+        self.controller.stop_all_axes()
+        return super().stop(success=success)

csaxs_bec/devices/omny/galil/sgalil_readme.md

@@ -4,7 +4,7 @@ Ophyd wrapper for the SGalil controller and stages.
 ## Integration of the device in IPython kernel
 BEC needs to be able to reach the host TCP to initiate a connection to the device.
 ```Python
-from csaxs_bec.devices.galil.sgalil_ophyd import SGalilMotor
+from csaxs_bec.devices.omny.galil.sgalil_ophyd import SGalilMotor
 samx = SGalilMotor("E", name="samx", host="129.129.122.26", port=23, sign=-1)
 samy = SGalilMotor("C", name="samy", host="129.129.122.26", port=23, sign=-1)
 # connect to the controller

csaxs_bec/devices/omny/omny_sample_storage.py

@@ -4,7 +4,7 @@ from ophyd import Component as Cpt
 from ophyd import Device
 from ophyd import DynamicDeviceComponent as Dcpt
 from ophyd import EpicsSignal
-from prettytable import PrettyTable, FRAME
+from prettytable import FRAME, PrettyTable
 
 
 class OMNYSampleStorageError(Exception):

csaxs_bec/devices/omny/rt/rt_flomni_ophyd.py

@@ -3,29 +3,31 @@ import time
 from typing import List
 
 import numpy as np
-from bec_lib import MessageEndpoints, bec_logger, messages
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from ophyd import Component as Cpt
 from ophyd import Device, PositionerBase, Signal
 from ophyd.status import wait as status_wait
 from ophyd.utils import LimitError
-from csaxs_bec.devices.rt_lamni.rt_ophyd import (
+from ophyd_devices.utils.controller import Controller, threadlocked
+from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
+from prettytable import PrettyTable
+
+from csaxs_bec.devices.omny.rt.rt_ophyd import (
     BECConfigError,
     RtCommunicationError,
-    RtController,
     RtError,
     RtReadbackSignal,
     RtSetpointSignal,
     RtSignalRO,
     retry_once,
 )
-from ophyd_devices.utils.controller import threadlocked
-from ophyd_devices.utils.socket import SocketIO, raise_if_disconnected
-from prettytable import PrettyTable
 
 logger = bec_logger.logger
 
 
-class RtFlomniController(RtController):
+class RtFlomniController(Controller):
+    _axes_per_controller = 3
     USER_ACCESS = [
         "socket_put_and_receive",
         "set_rotation_angle",
@@ -50,7 +52,7 @@ class RtFlomniController(RtController):
     def __init__(
         self,
         *,
-        name=None,
+        name="RtFlomniController",
         socket_cls=None,
         socket_host=None,
         socket_port=None,
@@ -73,6 +75,15 @@ class RtFlomniController(RtController):
         self._min_scan_buffer_reached = False
         self.rt_pid_voltage = None
 
+    def is_axis_moving(self, axis_Id) -> bool:
+        # this checks that axis is on target
+        axis_is_on_target = bool(float(self.socket_put_and_receive("o")))
+        return not axis_is_on_target
+
+    @threadlocked
+    def stop_all_axes(self):
+        self.socket_put("sc")
+
     def add_pos_to_scan(self, positions) -> None:
         def send_positions(parent, positions):
             parent._min_scan_buffer_reached = False
@@ -487,7 +498,7 @@ class RtFlomniController(RtController):
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=1, metadata=self.readout_metadata
-            ).dumps(),
+            ),
         )
         # while scan is running
         while mode > 0:
@@ -522,7 +533,7 @@ class RtFlomniController(RtController):
             MessageEndpoints.device_status("rt_scan"),
             messages.DeviceStatusMessage(
                 device="rt_scan", status=0, metadata=self.readout_metadata
-            ).dumps(),
+            ),
         )
 
         logger.info(
@@ -536,7 +547,7 @@ class RtFlomniController(RtController):
             MessageEndpoints.device_read("rt_flomni"),
             messages.DeviceMessage(
                 signals=signals, metadata={"point_id": point_id, **self.readout_metadata}
-            ).dumps(),
+            ),
         )
 
     def start_readout(self):
@@ -683,15 +694,16 @@ class RtFlomniMotor(Device, PositionerBase):
     def high_limit(self):
         return self.limits[1]
 
-    def check_value(self, pos):
+    def check_value(self, value, **kwargs):
         """Check that the position is within the soft limits"""
         low_limit, high_limit = self.limits
 
-        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
-            raise LimitError(f"position={pos} not within limits {self.limits}")
+        if low_limit < high_limit and not (low_limit <= value <= high_limit):
+            raise LimitError(f"position={value} not within limits {self.limits}")
 
     def _update_connection_state(self, **kwargs):
         for walk in self.walk_signals():
+            # pylint: disable=protected-access
             walk.item._metadata["connected"] = self.controller.connected
 
     def _forward_readback(self, **kwargs):
@@ -761,7 +773,7 @@ class RtFlomniMotor(Device, PositionerBase):
     def axis_Id(self, val):
         if isinstance(val, str):
             if len(val) != 1:
-                raise ValueError(f"Only single-character axis_Ids are supported.")
+                raise ValueError("Only single-character axis_Ids are supported.")
             self._axis_Id_alpha = val
             self._axis_Id_numeric = ord(val.lower()) - 97
         else:
@@ -775,7 +787,7 @@ class RtFlomniMotor(Device, PositionerBase):
     def axis_Id_numeric(self, val):
         if isinstance(val, int):
             if val > 26:
-                raise ValueError(f"Numeric value exceeds supported range.")
+                raise ValueError("Numeric value exceeds supported range.")
             self._axis_Id_alpha = val
             self._axis_Id_numeric = (chr(val + 97)).capitalize()
         else:
@@ -789,14 +801,6 @@ class RtFlomniMotor(Device, PositionerBase):
         """The engineering units (EGU) for positions"""
         return "um"
 
-    # how is this used later?
-
-    def stage(self) -> List[object]:
-        return super().stage()
-
-    def unstage(self) -> List[object]:
-        return super().unstage()
-
     def stop(self, *, success=False):
         self.controller.stop_all_axes()
         self._stopped = True

csaxs_bec/devices/omny/rt/rt_lamni_ophyd.py

@@ -3,7 +3,8 @@ import threading
 import time
 
 import numpy as np
-from bec_lib import MessageEndpoints, bec_logger, messages
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from ophyd import Component as Cpt
 from ophyd import Device, PositionerBase, Signal
 from ophyd.status import wait as status_wait
@@ -11,6 +12,8 @@ from ophyd.utils import LimitError, ReadOnlyError
 from ophyd_devices.utils.controller import Controller, threadlocked
 from ophyd_devices.utils.socket import SocketIO, SocketSignal, raise_if_disconnected
 
+from csaxs_bec.devices.omny.rt.rt_ophyd import RtCommunicationError, RtError
+
 logger = bec_logger.logger
 
 
@@ -41,6 +44,11 @@ def retry_once(fcn):
 
 
 class RtLamniController(Controller):
+    """
+    RT-Lamni controller class for all rt devices.
+    """
+
+    _axes_per_controller = 3
     USER_ACCESS = [
         "socket_put_and_receive",
         "set_rotation_angle",
@@ -60,110 +68,25 @@ class RtLamniController(Controller):
         self,
         *,
         name="RtLamniController",
-        kind=None,
-        parent=None,
-        socket=None,
+        socket_cls=None,
+        socket_host=None,
+        socket_port=None,
         attr_name="",
+        parent=None,
         labels=None,
+        kind=None,
     ):
-        if not hasattr(self, "_initialized") or not self._initialized:
-            self._rtlamni_axis_per_controller = 3
-            self._axis = [None for axis_num in range(self._rtlamni_axis_per_controller)]
-            self._min_scan_buffer_reached = False
-            super().__init__(
-                name=name,
-                socket=socket,
-                attr_name=attr_name,
-                parent=parent,
-                labels=labels,
-                kind=kind,
-            )
-        self.readout_metadata = {}
-
-    def on(self, controller_num=0) -> None:
-        """Open a new socket connection to the controller"""
-        if not self.connected:
-            try:
-                self.sock.open()
-                # discuss - after disconnect takes a while for the server to be ready again
-                max_retries = 10
-                tries = 0
-                while not self.connected:
-                    try:
-                        welcome_message = self.sock.receive()
-                        self.connected = True
-                    except ConnectionResetError as conn_reset:
-                        if tries > max_retries:
-                            raise conn_reset
-                        tries += 1
-                        time.sleep(2)
-            except ConnectionRefusedError as conn_error:
-                logger.error("Failed to open a connection to RTLamNI.")
-                raise RtLamniCommunicationError from conn_error
-
-        else:
-            logger.info("The connection has already been established.")
-            # warnings.warn(f"The connection has already been established.", stacklevel=2)
-
-        self._update_flyer_device_info()
-
-    def off(self) -> None:
-        """Close the socket connection to the controller"""
-        if self.connected:
-            self.sock.close()
-            self.connected = False
-        else:
-            logger.info("The connection is already closed.")
-
-    def set_axis(self, axis: Device, axis_nr: int) -> None:
-        """Assign an axis to a device instance.
-
-        Args:
-            axis (Device): Device instance (e.g. GalilMotor)
-            axis_nr (int): Controller axis number
-
-        """
-        self._axis[axis_nr] = axis
-
-    @threadlocked
-    def socket_put(self, val: str) -> None:
-        self.sock.put(f"{val}\n".encode())
-
-    @threadlocked
-    def socket_get(self) -> str:
-        return self.sock.receive().decode()
-
-    @retry_once
-    @threadlocked
-    def socket_put_and_receive(self, val: str, remove_trailing_chars=True) -> str:
-        self.socket_put(val)
-        if remove_trailing_chars:
-            return self._remove_trailing_characters(self.sock.receive().decode())
-        return self.socket_get()
-
-    def is_axis_moving(self, axis_Id) -> bool:
-        # this checks that axis is on target
-        axis_is_on_target = bool(float(self.socket_put_and_receive(f"o")))
-        return not axis_is_on_target
-
-    #    def is_thread_active(self, thread_id: int) -> bool:
-    #        val = float(self.socket_put_and_receive(f"MG_XQ{thread_id}"))
-    #        if val == -1:
-    #            return False
-    #        return True
-
-    def _remove_trailing_characters(self, var) -> str:
-        if len(var) > 1:
-            return var.split("\r\n")[0]
-        return var
-
-    @threadlocked
-    def set_rotation_angle(self, val: float):
-        self.socket_put(f"a{(val-300+30.538)/180*np.pi}")
-
-    @threadlocked
-    def stop_all_axes(self):
-        self.socket_put("sc")
+        super().__init__(
+            name=name,
+            socket_cls=socket_cls,
+            socket_host=socket_host,
+            socket_port=socket_port,
+            attr_name=attr_name,
+            parent=parent,
+            labels=labels,
+            kind=kind,
+        )
+        self._min_scan_buffer_reached = False
 
     @threadlocked
     def feedback_disable(self):
@@ -175,6 +98,19 @@ class RtLamniController(Controller):
         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
+        axis_is_on_target = bool(float(self.socket_put_and_receive("o")))
+        return not axis_is_on_target
+
+    @threadlocked
+    def stop_all_axes(self):
+        self.socket_put("sc")
+
+    @threadlocked
+    def set_rotation_angle(self, val: float):
+        self.socket_put(f"a{(val-300+30.538)/180*np.pi}")
+
     @threadlocked
     def _set_axis_velocity(self, um_per_s):
         self.socket_put(f"V{um_per_s}")
@@ -234,19 +170,6 @@ class RtLamniController(Controller):
         self.set_device_enabled("lopty", True)
         self.set_device_enabled("loptz", True)
 
-    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 get_axis_by_name(self, name):
-        for axis in self._axis:
-            if axis:
-                if axis.name == name:
-                    return axis
-        raise RuntimeError(f"Could not find an axis with name {name}")
-
     @threadlocked
     def clear_trajectory_generator(self):
         self.socket_put("sc")
@@ -256,7 +179,7 @@ class RtLamniController(Controller):
         def send_positions(parent, positions):
             parent._min_scan_buffer_reached = False
             for pos_index, pos in enumerate(positions):
-                parent.socket_put_and_receive(f"s{pos[0]:.05f},{pos[1]:05f},0")
+                parent.socket_put_and_receive(f"s{pos[0]:.05f},{pos[1]:.05f},0")
                 if pos_index > 100:
                     parent._min_scan_buffer_reached = True
             parent._min_scan_buffer_reached = True
@@ -268,7 +191,7 @@ class RtLamniController(Controller):
     def get_scan_status(self):
         return_table = (self.socket_put_and_receive(f"sr")).split(",")
         if len(return_table) != 3:
-            raise RtLamniCommunicationError(
+            raise RtCommunicationError(
                 f"Expected to receive 3 return values. Instead received {return_table}"
             )
         mode = int(return_table[0])
@@ -288,7 +211,7 @@ class RtLamniController(Controller):
             logger.error(
                 "Cannot start scan because feedback loop is not running or there is an interferometer error."
             )
-            raise RtLamniError(
+            raise RtError(
                 "Cannot start scan because feedback loop is not running or there is an interferometer error."
             )
             # here exception
@@ -296,7 +219,7 @@ class RtLamniController(Controller):
 
         if number_of_positions_planned == 0:
             logger.error("Cannot start scan because no target positions are planned.")
-            raise RtLamniError("Cannot start scan because no target positions are planned.")
+            raise RtError("Cannot start scan because no target positions are planned.")
             # hier exception
         # start a point-by-point scan (for cont scan in flomni it would be "sa")
         self.socket_put_and_receive("sd")
@@ -305,29 +228,6 @@ class RtLamniController(Controller):
         readout = threading.Thread(target=self.read_positions_from_sampler)
         readout.start()
 
-    def _update_flyer_device_info(self):
-        flyer_info = self._get_flyer_device_info()
-        self.get_device_manager().connector.set(
-            MessageEndpoints.device_info("rt_scan"),
-            messages.DeviceInfoMessage(device="rt_scan", info=flyer_info),
-        )
-
-    def _get_flyer_device_info(self) -> dict:
-        return {
-            "device_name": self.name,
-            "device_attr_name": getattr(self, "attr_name", ""),
-            "device_dotted_name": getattr(self, "dotted_name", ""),
-            "device_info": {
-                "device_base_class": "ophydobject",
-                "signals": [],
-                "hints": {"fields": ["average_x_st_fzp", "average_y_st_fzp"]},
-                "describe": {},
-                "describe_configuration": {},
-                "sub_devices": [],
-                "custom_user_access": [],
-            },
-        }
-
     def kickoff(self, metadata):
         self.readout_metadata = metadata
         while not self._min_scan_buffer_reached:
@@ -439,7 +339,7 @@ class RtLamniController(Controller):
         )
 
     def feedback_status_angle_lamni(self) -> bool:
-        return_table = (self.socket_put_and_receive(f"J7")).split(",")
+        return_table = (self.socket_put_and_receive("J7")).split(",")
         logger.debug(
             f"LamNI angle interferomter status {bool(return_table[0])}, position {float(return_table[1])}, signal {float(return_table[2])}"
         )
@@ -448,21 +348,21 @@ class RtLamniController(Controller):
     def feedback_enable_with_reset(self):
         if not self.feedback_status_angle_lamni():
             self.feedback_disable_and_even_reset_lamni_angle_interferometer()
-            logger.info(f"LamNI resetting interferometer inclusive angular interferomter.")
+            logger.info("LamNI resetting interferometer inclusive angular interferomter.")
         else:
             self.feedback_disable()
             logger.info(
-                f"LamNI resetting interferomter except angular interferometer which is already running."
+                "LamNI resetting interferomter except angular interferometer which is already running."
             )
 
         # set these as closed loop target position
 
-        self.socket_put(f"pa0,0")
+        self.socket_put("pa0,0")
         self.get_axis_by_name("rtx").user_setpoint.setpoint = 0
-        self.socket_put(f"pa1,0")
+        self.socket_put("pa1,0")
         self.get_axis_by_name("rty").user_setpoint.setpoint = 0
         self.socket_put(
-            f"pa2,0"
+            "pa2,0"
         )  # we set all three outputs of the traj. gen. although in LamNI case only 0,1 are used
         self.clear_trajectory_generator()
 
@@ -476,7 +376,7 @@ class RtLamniController(Controller):
             logger.error(
                 "Cannot enable feedback. The small rotation air is on and/or orchestra disabled by the motor controller."
             )
-            raise RtLamniError(
+            raise RtError(
                 "Cannot enable feedback. The small rotation air is on and/or orchestra disabled by the motor controller."
             )
 
@@ -515,7 +415,7 @@ class RtLamniController(Controller):
             logger.error(
                 "Cannot start scan because feedback loop is not running or there is an interferometer error."
             )
-            raise RtLamniError(
+            raise RtError(
                 "Cannot start scan because feedback loop is not running or there is an interferometer error."
             )
 
@@ -523,15 +423,6 @@ class RtLamniController(Controller):
 
         # ptychography_alignment_done = 0
 
-    def set_device_enabled(self, device_name: str, enabled: bool) -> None:
-        """enable / disable a device"""
-        if device_name not in self.get_device_manager().devices:
-            logger.warning(
-                f"Device {device_name} is not configured and cannot be enabled/disabled."
-            )
-            return
-        self.get_device_manager().devices[device_name].read_only = not enabled
-
 
 class RtLamniSignalBase(SocketSignal):
     def __init__(self, signal_name, **kwargs):
@@ -567,7 +458,7 @@ class RtLamniReadbackSignal(RtLamniSignalRO):
             readback_index = 1
         else:
             raise RtLamniError("Currently, only two axes are supported.")
-
+        print(return_table)
         current_pos = float(return_table[readback_index])
 
         current_pos *= self.parent.sign
@@ -667,7 +558,9 @@ class RtLamniMotor(Device, PositionerBase):
     ):
         self.axis_Id = axis_Id
         self.sign = sign
-        self.controller = RtLamniController(socket=socket_cls(host=host, port=port))
+        self.controller = RtLamniController(
+            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
         self.tolerance = kwargs.pop("tolerance", 0.5)
@@ -705,15 +598,16 @@ class RtLamniMotor(Device, PositionerBase):
     def high_limit(self):
         return self.limits[1]
 
-    def check_value(self, pos):
+    def check_value(self, value, **kwargs):
         """Check that the position is within the soft limits"""
         low_limit, high_limit = self.limits
 
-        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
-            raise LimitError(f"position={pos} not within limits {self.limits}")
+        if low_limit < high_limit and not (low_limit <= value <= high_limit):
+            raise LimitError(f"position={value} not within limits {self.limits}")
 
     def _update_connection_state(self, **kwargs):
         for walk in self.walk_signals():
+            # pylint: disable=protected-access
             walk.item._metadata["connected"] = self.controller.connected
 
     def _forward_readback(self, **kwargs):
@@ -782,7 +676,7 @@ class RtLamniMotor(Device, PositionerBase):
     def axis_Id(self, val):
         if isinstance(val, str):
             if len(val) != 1:
-                raise ValueError(f"Only single-character axis_Ids are supported.")
+                raise ValueError("Only single-character axis_Ids are supported.")
             self._axis_Id_alpha = val
             self._axis_Id_numeric = ord(val.lower()) - 97
         else:
@@ -796,7 +690,7 @@ class RtLamniMotor(Device, PositionerBase):
     def axis_Id_numeric(self, val):
         if isinstance(val, int):
             if val > 26:
-                raise ValueError(f"Numeric value exceeds supported range.")
+                raise ValueError("Numeric value exceeds supported range.")
             self._axis_Id_alpha = val
             self._axis_Id_numeric = (chr(val + 97)).capitalize()
         else:
@@ -823,9 +717,7 @@ class RtLamniMotor(Device, PositionerBase):
         return super().stop(success=success)
 
 
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG)
-
+if __name__ == "__main__":  # pragma: no cover
     mock = False
     if not mock:
         rty = RtLamniMotor("B", name="rty", host="mpc2680.psi.ch", port=3333, sign=1)

csaxs_bec/devices/omny/rt/rt_ophyd.py

@@ -0,0 +1,140 @@
+"""
+This module contains base signals for RT devices. Controller and motors are implemented in the 
+bespoke modules such as `rt_flomni_ophyd.py` or `rt_lamni_ophyd.py`.
+"""
+
+import functools
+import time
+
+from bec_lib import bec_logger
+from ophyd.utils import ReadOnlyError
+from ophyd_devices.utils.controller import ControllerCommunicationError, threadlocked
+from ophyd_devices.utils.socket import SocketSignal
+
+logger = bec_logger.logger
+
+
+class RtCommunicationError(ControllerCommunicationError):
+    pass
+
+
+class RtError(ControllerCommunicationError):
+    pass
+
+
+class BECConfigError(Exception):
+    pass
+
+
+def retry_once(fcn):
+    """Decorator to rerun a function in case a CommunicationError was raised. This may happen if the buffer was not empty."""
+
+    @functools.wraps(fcn)
+    def wrapper(self, *args, **kwargs):
+        try:
+            val = fcn(self, *args, **kwargs)
+        except (RtCommunicationError, RtError):
+            val = fcn(self, *args, **kwargs)
+        return val
+
+    return wrapper
+
+
+class RtSignalBase(SocketSignal):
+    def __init__(self, signal_name, **kwargs):
+        self.signal_name = signal_name
+        super().__init__(**kwargs)
+        self.controller = self.parent.controller
+        self.sock = self.parent.controller.sock
+
+
+class RtSignalRO(RtSignalBase):
+    def __init__(self, signal_name, **kwargs):
+        super().__init__(signal_name, **kwargs)
+        self._metadata["write_access"] = False
+
+    def _socket_set(self, val):
+        raise ReadOnlyError("Read-only signals cannot be set")
+
+
+class RtReadbackSignal(RtSignalRO):
+    @retry_once
+    @threadlocked
+    def _socket_get(self) -> float:
+        """Get command for the readback signal
+
+        Returns:
+        float: Readback value after adjusting for sign and motor resolution.
+        """
+        return_table = (self.controller.socket_put_and_receive("J4")).split(",")
+        if self.parent.axis_Id_numeric == 0:
+            readback_index = 2
+        elif self.parent.axis_Id_numeric == 1:
+            readback_index = 1
+        else:
+            raise RtError("Currently, only two axes are supported.")
+
+        current_pos = float(return_table[readback_index])
+
+        current_pos *= self.parent.sign
+        return current_pos
+
+
+class RtSetpointSignal(RtSignalBase):
+    setpoint = 0
+
+    def _socket_get(self) -> float:
+        """Get command for receiving the setpoint / target value.
+        The value is not pulled from the controller but instead just the last setpoint used.
+
+        Returns:
+            float: setpoint / target value
+        """
+        return self.setpoint
+
+    @retry_once
+    @threadlocked
+    def _socket_set(self, val: float) -> None:
+        """Set a new target value / setpoint value. Before submission, the target value is adjusted for the axis' sign.
+        Furthermore, it is ensured that all axes are referenced before a new setpoint is submitted.
+
+        Args:
+            val (float): Target value / setpoint value
+
+        Raises:
+            RtError: Raised if interferometer feedback is disabled.
+
+        """
+        interferometer_feedback_not_running = int(
+            (self.controller.socket_put_and_receive("J2")).split(",")[0]
+        )
+        if interferometer_feedback_not_running != 0:
+            raise RtError(
+                "The interferometer feedback is not running. Either it is turned off or and interferometer error occured."
+            )
+        self.set_with_feedback_disabled(val)
+
+    def set_with_feedback_disabled(self, val):
+        target_val = val * self.parent.sign
+        self.setpoint = target_val
+        self.controller.socket_put(f"pa{self.parent.axis_Id_numeric},{target_val:.4f}")
+
+
+class RtMotorIsMoving(RtSignalRO):
+    def _socket_get(self):
+        return self.controller.is_axis_moving(self.parent.axis_Id_numeric)
+
+    def get(self):
+        val = super().get()
+        if val is not None:
+            self._run_subs(sub_type=self.SUB_VALUE, value=val, timestamp=time.time())
+        return val
+
+
+class RtFeedbackRunning(RtSignalRO):
+    @threadlocked
+    def _socket_get(self):
+        if int((self.controller.socket_put_and_receive("J2")).split(",")[0]) == 0:
+            return 1
+        else:
+            return 0

csaxs_bec/devices/rt_lamni/rt_ophyd.py

@@ -1,817 +0,0 @@
-import functools
-import threading
-import time
-from typing import List
-
-import numpy as np
-from bec_lib import MessageEndpoints, bec_logger, messages
-from ophyd import Component as Cpt
-from ophyd import Device, PositionerBase, Signal
-from ophyd.status import wait as status_wait
-from ophyd.utils import LimitError, ReadOnlyError
-from ophyd_devices.utils.controller import Controller, threadlocked
-from ophyd_devices.utils.socket import SocketIO, SocketSignal, raise_if_disconnected
-
-logger = bec_logger.logger
-
-
-class RtCommunicationError(Exception):
-    pass
-
-
-class RtError(Exception):
-    pass
-
-
-class BECConfigError(Exception):
-    pass
-
-
-def retry_once(fcn):
-    """Decorator to rerun a function in case a CommunicationError was raised. This may happen if the buffer was not empty."""
-
-    @functools.wraps(fcn)
-    def wrapper(self, *args, **kwargs):
-        try:
-            val = fcn(self, *args, **kwargs)
-        except (RtCommunicationError, RtError):
-            val = fcn(self, *args, **kwargs)
-        return val
-
-    return wrapper
-
-
-class RtController(Controller):
-    _axes_per_controller = 3
-    USER_ACCESS = [
-        "socket_put_and_receive",
-        "set_rotation_angle",
-        "feedback_disable",
-        "feedback_enable_without_reset",
-        "feedback_disable_and_even_reset_lamni_angle_interferometer",
-        "feedback_enable_with_reset",
-        "add_pos_to_scan",
-        "clear_trajectory_generator",
-        "_set_axis_velocity",
-        "_set_axis_velocity_maximum_speed",
-        "_position_sampling_single_read",
-        "_position_sampling_single_reset_and_start_sampling",
-    ]
-
-    def on(self, controller_num=0) -> None:
-        """Open a new socket connection to the controller"""
-        # if not self.connected:
-        #     try:
-        #         self.sock.open()
-        #         # discuss - after disconnect takes a while for the server to be ready again
-        #         max_retries = 10
-        #         tries = 0
-        #         while not self.connected:
-        #             try:
-        #                 welcome_message = self.sock.receive()
-        #                 self.connected = True
-        #             except ConnectionResetError as conn_reset:
-        #                 if tries > max_retries:
-        #                     raise conn_reset
-        #                 tries += 1
-        #                 time.sleep(2)
-        #     except ConnectionRefusedError as conn_error:
-        #         logger.error("Failed to open a connection to RTLamNI.")
-        #         raise RtCommunicationError from conn_error
-
-        # else:
-        #     logger.info("The connection has already been established.")
-        #     # warnings.warn(f"The connection has already been established.", stacklevel=2)
-        super().on()
-        # self._update_flyer_device_info()
-
-    def set_axis(self, axis: Device, axis_nr: int) -> None:
-        """Assign an axis to a device instance.
-
-        Args:
-            axis (Device): Device instance (e.g. GalilMotor)
-            axis_nr (int): Controller axis number
-
-        """
-        self._axis[axis_nr] = axis
-
-    @threadlocked
-    def socket_put(self, val: str) -> None:
-        self.sock.put(f"{val}\n".encode())
-
-    @threadlocked
-    def socket_get(self) -> str:
-        return self.sock.receive().decode()
-
-    @retry_once
-    @threadlocked
-    def socket_put_and_receive(self, val: str, remove_trailing_chars=True) -> str:
-        self.socket_put(val)
-        if remove_trailing_chars:
-            return self._remove_trailing_characters(self.sock.receive().decode())
-        return self.socket_get()
-
-    def is_axis_moving(self, axis_Id) -> bool:
-        # this checks that axis is on target
-        axis_is_on_target = bool(float(self.socket_put_and_receive(f"o")))
-        return not axis_is_on_target
-
-    #    def is_thread_active(self, thread_id: int) -> bool:
-    #        val = float(self.socket_put_and_receive(f"MG_XQ{thread_id}"))
-    #        if val == -1:
-    #            return False
-    #        return True
-
-    def _remove_trailing_characters(self, var) -> str:
-        if len(var) > 1:
-            return var.split("\r\n")[0]
-        return var
-
-    @threadlocked
-    def set_rotation_angle(self, val: float):
-        self.socket_put(f"a{(val-300+30.538)/180*np.pi}")
-
-    @threadlocked
-    def stop_all_axes(self):
-        self.socket_put("sc")
-
-    @threadlocked
-    def feedback_disable(self):
-        self.socket_put("J0")
-        logger.info("LamNI Feedback disabled.")
-        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 _set_axis_velocity(self, um_per_s):
-        self.socket_put(f"V{um_per_s}")
-
-    @threadlocked
-    def _set_axis_velocity_maximum_speed(self):
-        self.socket_put(f"V0")
-
-    # for developement of soft continuous scanning
-    @threadlocked
-    def _position_sampling_single_reset_and_start_sampling(self):
-        self.socket_put(f"Ss")
-
-    @threadlocked
-    def _position_sampling_single_read(self):
-        (number_of_samples, sum0, sum0_2, sum1, sum1_2, sum2, sum2_2) = self.socket_put_and_receive(
-            f"Sr"
-        ).split(",")
-        avg_x = float(sum1) / int(number_of_samples)
-        avg_y = float(sum0) / int(number_of_samples)
-        stdev_x = np.sqrt(
-            float(sum1_2) / int(number_of_samples)
-            - np.power(float(sum1) / int(number_of_samples), 2)
-        )
-        stdev_y = np.sqrt(
-            float(sum0_2) / int(number_of_samples)
-            - np.power(float(sum0) / int(number_of_samples), 2)
-        )
-        return (avg_x, avg_y, stdev_x, stdev_y)
-
-    @threadlocked
-    def feedback_enable_without_reset(self):
-        # read current interferometer position
-        return_table = (self.socket_put_and_receive(f"J4")).split(",")
-        x_curr = float(return_table[2])
-        y_curr = float(return_table[1])
-        # set these as closed loop target position
-        self.socket_put(f"pa0,{x_curr:.4f}")
-        self.socket_put(f"pa1,{y_curr:.4f}")
-        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_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_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 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 get_axis_by_name(self, name):
-        for axis in self._axis:
-            if axis:
-                if axis.name == name:
-                    return axis
-        raise RuntimeError(f"Could not find an axis with name {name}")
-
-    @threadlocked
-    def clear_trajectory_generator(self):
-        self.socket_put("sc")
-        logger.info("LamNI scan stopped and deleted, moving to start position")
-
-    def add_pos_to_scan(self, positions) -> None:
-        def send_positions(parent, positions):
-            parent._min_scan_buffer_reached = False
-            for pos_index, pos in enumerate(positions):
-                parent.socket_put_and_receive(f"s{pos[0]},{pos[1]},0")
-                if pos_index > 100:
-                    parent._min_scan_buffer_reached = True
-            parent._min_scan_buffer_reached = True
-
-        threading.Thread(target=send_positions, args=(self, positions), daemon=True).start()
-
-    @retry_once
-    @threadlocked
-    def get_scan_status(self):
-        return_table = (self.socket_put_and_receive(f"sr")).split(",")
-        if len(return_table) != 3:
-            raise RtCommunicationError(
-                f"Expected to receive 3 return values. Instead received {return_table}"
-            )
-        mode = int(return_table[0])
-        # mode 0: direct positioning
-        # mode 1: running internal timer (not tested/used anymore)
-        # mode 2: rt point scan running
-        # mode 3: rt point scan starting
-        # mode 5/6: rt continuous scanning (not available in LamNI)
-        number_of_positions_planned = int(return_table[1])
-        current_position_in_scan = int(return_table[2])
-        return (mode, number_of_positions_planned, current_position_in_scan)
-
-    @threadlocked
-    def start_scan(self):
-        interferometer_feedback_not_running = int((self.socket_put_and_receive("J2")).split(",")[0])
-        if interferometer_feedback_not_running == 1:
-            logger.error(
-                "Cannot start scan because feedback loop is not running or there is an interferometer error."
-            )
-            raise RtError(
-                "Cannot start scan because feedback loop is not running or there is an interferometer error."
-            )
-            # here exception
-        (mode, number_of_positions_planned, current_position_in_scan) = self.get_scan_status()
-
-        if number_of_positions_planned == 0:
-            logger.error("Cannot start scan because no target positions are planned.")
-            raise RtError("Cannot start scan because no target positions are planned.")
-            # hier exception
-        # start a point-by-point scan (for cont scan in flomni it would be "sa")
-        self.socket_put_and_receive("sd")
-
-    def start_readout(self):
-        readout = threading.Thread(target=self.read_positions_from_sampler)
-        readout.start()
-
-    def _update_flyer_device_info(self):
-        flyer_info = self._get_flyer_device_info()
-        self.get_device_manager().connector.set(
-            MessageEndpoints.device_info("rt_scan"),
-            messages.DeviceInfoMessage(device="rt_scan", info=flyer_info).dumps(),
-        )
-
-    def _get_flyer_device_info(self) -> dict:
-        return {
-            "device_name": self.name,
-            "device_attr_name": getattr(self, "attr_name", ""),
-            "device_dotted_name": getattr(self, "dotted_name", ""),
-            "device_info": {
-                "device_base_class": "ophydobject",
-                "signals": [],
-                "hints": {"fields": ["average_x_st_fzp", "average_y_st_fzp"]},
-                "describe": {},
-                "describe_configuration": {},
-                "sub_devices": [],
-                "custom_user_access": [],
-            },
-        }
-
-    def kickoff(self, metadata):
-        self.readout_metadata = metadata
-        while not self._min_scan_buffer_reached:
-            time.sleep(0.001)
-        self.start_scan()
-        time.sleep(0.1)
-        self.start_readout()
-
-    def _get_signals_from_table(self, return_table) -> dict:
-        self.average_stdeviations_x_st_fzp += float(return_table[5])
-        self.average_stdeviations_y_st_fzp += float(return_table[8])
-        self.average_lamni_angle += float(return_table[19])
-        signals = {
-            "target_x": {"value": float(return_table[3])},
-            "average_x_st_fzp": {"value": float(return_table[4])},
-            "stdev_x_st_fzp": {"value": float(return_table[5])},
-            "target_y": {"value": float(return_table[6])},
-            "average_y_st_fzp": {"value": float(return_table[7])},
-            "stdev_y_st_fzp": {"value": float(return_table[8])},
-            "average_cap1": {"value": float(return_table[9])},
-            "stdev_cap1": {"value": float(return_table[10])},
-            "average_cap2": {"value": float(return_table[11])},
-            "stdev_cap2": {"value": float(return_table[12])},
-            "average_cap3": {"value": float(return_table[13])},
-            "stdev_cap3": {"value": float(return_table[14])},
-            "average_cap4": {"value": float(return_table[15])},
-            "stdev_cap4": {"value": float(return_table[16])},
-            "average_cap5": {"value": float(return_table[17])},
-            "stdev_cap5": {"value": float(return_table[18])},
-            "average_angle_interf_ST": {"value": float(return_table[19])},
-            "stdev_angle_interf_ST": {"value": float(return_table[20])},
-            "average_stdeviations_x_st_fzp": {
-                "value": self.average_stdeviations_x_st_fzp / (int(return_table[0]) + 1)
-            },
-            "average_stdeviations_y_st_fzp": {
-                "value": self.average_stdeviations_y_st_fzp / (int(return_table[0]) + 1)
-            },
-            "average_lamni_angle": {"value": self.average_lamni_angle / (int(return_table[0]) + 1)},
-        }
-        return signals
-
-    def read_positions_from_sampler(self):
-        # this was for reading after the scan completed
-        number_of_samples_to_read = 1  # self.get_scan_status()[1]  #number of valid samples, will be updated upon first data read
-
-        read_counter = 0
-        previous_point_in_scan = 0
-
-        self.average_stdeviations_x_st_fzp = 0
-        self.average_stdeviations_y_st_fzp = 0
-        self.average_lamni_angle = 0
-
-        mode, number_of_positions_planned, current_position_in_scan = self.get_scan_status()
-
-        # if not (mode==2 or mode==3):
-        #    error
-        self.get_device_manager().connector.set(
-            MessageEndpoints.device_status("rt_scan"),
-            messages.DeviceStatusMessage(
-                device="rt_scan", status=1, metadata=self.readout_metadata
-            ).dumps(),
-        )
-        # while scan is running
-        while mode > 0:
-            # logger.info(f"Current scan position {current_position_in_scan} out of {number_of_positions_planned}")
-            mode, number_of_positions_planned, current_position_in_scan = self.get_scan_status()
-            time.sleep(0.01)
-            if current_position_in_scan > 5:
-                while current_position_in_scan > read_counter + 1:
-                    return_table = (self.socket_put_and_receive(f"r{read_counter}")).split(",")
-                    # logger.info(f"{return_table}")
-                    logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
-
-                    read_counter = read_counter + 1
-
-                    signals = self._get_signals_from_table(return_table)
-
-                    self.publish_device_data(signals=signals, point_id=int(return_table[0]))
-
-        time.sleep(0.05)
-
-        # read the last samples even though scan is finished already
-        while number_of_positions_planned > read_counter:
-            return_table = (self.socket_put_and_receive(f"r{read_counter}")).split(",")
-            logger.info(f"Read {read_counter} out of {number_of_positions_planned}")
-            # logger.info(f"{return_table}")
-            read_counter = read_counter + 1
-
-            signals = self._get_signals_from_table(return_table)
-            self.publish_device_data(signals=signals, point_id=int(return_table[0]))
-
-        self.get_device_manager().connector.set(
-            MessageEndpoints.device_status("rt_scan"),
-            messages.DeviceStatusMessage(
-                device="rt_scan", status=0, metadata=self.readout_metadata
-            ).dumps(),
-        )
-
-        logger.info(
-            f"LamNI statistics: Average of all standard deviations: x {self.average_stdeviations_x_st_fzp/number_of_samples_to_read}, y {self.average_stdeviations_y_st_fzp/number_of_samples_to_read}, angle {self.average_lamni_angle/number_of_samples_to_read}."
-        )
-
-    def publish_device_data(self, signals, point_id):
-        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}
-            ).dumps(),
-        )
-
-    def feedback_status_angle_lamni(self) -> bool:
-        return_table = (self.socket_put_and_receive(f"J7")).split(",")
-        logger.debug(
-            f"LamNI angle interferomter status {bool(return_table[0])}, position {float(return_table[1])}, signal {float(return_table[2])}"
-        )
-        return bool(return_table[0])
-
-    def feedback_enable_with_reset(self):
-        if not self.feedback_status_angle_lamni():
-            self.feedback_disable_and_even_reset_lamni_angle_interferometer()
-            logger.info(f"LamNI resetting interferometer inclusive angular interferomter.")
-        else:
-            self.feedback_disable()
-            logger.info(
-                f"LamNI resetting interferomter except angular interferometer which is already running."
-            )
-
-        # set these as closed loop target position
-
-        self.socket_put(f"pa0,0")
-        self.get_axis_by_name("rtx").user_setpoint.setpoint = 0
-        self.socket_put(f"pa1,0")
-        self.get_axis_by_name("rty").user_setpoint.setpoint = 0
-        self.socket_put(
-            f"pa2,0"
-        )  # we set all three outputs of the traj. gen. although in LamNI case only 0,1 are used
-        self.clear_trajectory_generator()
-
-        self.get_device_manager().devices.lsamrot.obj.move(0, wait=True)
-
-        galil_controller_rt_status = (
-            self.get_device_manager().devices.lsamx.obj.controller.lgalil_is_air_off_and_orchestra_enabled()
-        )
-
-        if galil_controller_rt_status == 0:
-            logger.error(
-                "Cannot enable feedback. The small rotation air is on and/or orchestra disabled by the motor controller."
-            )
-            raise RtError(
-                "Cannot enable feedback. The small rotation air is on and/or orchestra disabled by the motor controller."
-            )
-
-        time.sleep(0.03)
-
-        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.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.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
-
-        interferometer_feedback_not_running = int((self.socket_put_and_receive("J2")).split(",")[0])
-
-        while interferometer_feedback_not_running == 1 and _waitforfeedbackctr < 100:
-            time.sleep(0.01)
-            _waitforfeedbackctr = _waitforfeedbackctr + 1
-            interferometer_feedback_not_running = int(
-                (self.socket_put_and_receive("J2")).split(",")[0]
-            )
-
-        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(
-                "Cannot start scan because feedback loop is not running or there is an interferometer error."
-            )
-            raise RtError(
-                "Cannot start scan because feedback loop is not running or there is an interferometer error."
-            )
-
-        time.sleep(0.01)
-
-        # ptychography_alignment_done = 0
-
-    def set_device_enabled(self, device_name: str, enabled: bool) -> None:
-        """enable / disable a device"""
-        if device_name not in self.get_device_manager().devices:
-            logger.warning(
-                f"Device {device_name} is not configured and cannot be enabled/disabled."
-            )
-            return
-        self.get_device_manager().devices[device_name].read_only = not enabled
-
-
-class RtSignalBase(SocketSignal):
-    def __init__(self, signal_name, **kwargs):
-        self.signal_name = signal_name
-        super().__init__(**kwargs)
-        self.controller = self.parent.controller
-        self.sock = self.parent.controller.sock
-
-
-class RtSignalRO(RtSignalBase):
-    def __init__(self, signal_name, **kwargs):
-        super().__init__(signal_name, **kwargs)
-        self._metadata["write_access"] = False
-
-    def _socket_set(self, val):
-        raise ReadOnlyError("Read-only signals cannot be set")
-
-
-class RtReadbackSignal(RtSignalRO):
-    @retry_once
-    @threadlocked
-    def _socket_get(self) -> float:
-        """Get command for the readback signal
-
-        Returns:
-        float: Readback value after adjusting for sign and motor resolution.
-        """
-        return_table = (self.controller.socket_put_and_receive(f"J4")).split(",")
-        print(return_table)
-        if self.parent.axis_Id_numeric == 0:
-            readback_index = 2
-        elif self.parent.axis_Id_numeric == 1:
-            readback_index = 1
-        else:
-            raise RtError("Currently, only two axes are supported.")
-
-        current_pos = float(return_table[readback_index])
-
-        current_pos *= self.parent.sign
-        return current_pos
-
-
-class RtSetpointSignal(RtSignalBase):
-    setpoint = 0
-
-    def _socket_get(self) -> float:
-        """Get command for receiving the setpoint / target value.
-        The value is not pulled from the controller but instead just the last setpoint used.
-
-        Returns:
-            float: setpoint / target value
-        """
-        return self.setpoint
-
-    @retry_once
-    @threadlocked
-    def _socket_set(self, val: float) -> None:
-        """Set a new target value / setpoint value. Before submission, the target value is adjusted for the axis' sign.
-        Furthermore, it is ensured that all axes are referenced before a new setpoint is submitted.
-
-        Args:
-            val (float): Target value / setpoint value
-
-        Raises:
-            RtError: Raised if interferometer feedback is disabled.
-
-        """
-        interferometer_feedback_not_running = int(
-            (self.controller.socket_put_and_receive("J2")).split(",")[0]
-        )
-        if interferometer_feedback_not_running != 0:
-            raise RtError(
-                "The interferometer feedback is not running. Either it is turned off or and interferometer error occured."
-            )
-        self.set_with_feedback_disabled(val)
-
-    def set_with_feedback_disabled(self, val):
-        target_val = val * self.parent.sign
-        self.setpoint = target_val
-        self.controller.socket_put(f"pa{self.parent.axis_Id_numeric},{target_val:.4f}")
-
-
-class RtMotorIsMoving(RtSignalRO):
-    def _socket_get(self):
-        return self.controller.is_axis_moving(self.parent.axis_Id_numeric)
-
-    def get(self):
-        val = super().get()
-        if val is not None:
-            self._run_subs(sub_type=self.SUB_VALUE, value=val, timestamp=time.time())
-        return val
-
-
-class RtFeedbackRunning(RtSignalRO):
-    @threadlocked
-    def _socket_get(self):
-        if int((self.controller.socket_put_and_receive("J2")).split(",")[0]) == 0:
-            return 1
-        else:
-            return 0
-
-
-class RtMotor(Device, PositionerBase):
-    USER_ACCESS = ["controller"]
-    readback = Cpt(RtReadbackSignal, signal_name="readback", kind="hinted")
-    user_setpoint = Cpt(RtSetpointSignal, signal_name="setpoint")
-
-    motor_is_moving = Cpt(RtMotorIsMoving, signal_name="motor_is_moving", kind="normal")
-    high_limit_travel = Cpt(Signal, value=0, kind="omitted")
-    low_limit_travel = Cpt(Signal, value=0, kind="omitted")
-
-    SUB_READBACK = "readback"
-    SUB_CONNECTION_CHANGE = "connection_change"
-    _default_sub = SUB_READBACK
-
-    def __init__(
-        self,
-        axis_Id,
-        prefix="",
-        *,
-        name,
-        kind=None,
-        read_attrs=None,
-        configuration_attrs=None,
-        parent=None,
-        host="mpc2680.psi.ch",
-        port=3333,
-        sign=1,
-        socket_cls=SocketIO,
-        device_manager=None,
-        limits=None,
-        **kwargs,
-    ):
-        self.axis_Id = axis_Id
-        self.sign = sign
-        self.controller = RtController(socket=socket_cls(host=host, port=port))
-        self.controller.set_axis(axis=self, axis_nr=self.axis_Id_numeric)
-        self.device_manager = device_manager
-        self.tolerance = kwargs.pop("tolerance", 0.5)
-
-        super().__init__(
-            prefix,
-            name=name,
-            kind=kind,
-            read_attrs=read_attrs,
-            configuration_attrs=configuration_attrs,
-            parent=parent,
-            **kwargs,
-        )
-        self.readback.name = self.name
-        self.controller.subscribe(
-            self._update_connection_state, event_type=self.SUB_CONNECTION_CHANGE
-        )
-        self._update_connection_state()
-
-        # self.readback.subscribe(self._forward_readback, event_type=self.readback.SUB_VALUE)
-        if limits is not None:
-            assert len(limits) == 2
-            self.low_limit_travel.put(limits[0])
-            self.high_limit_travel.put(limits[1])
-
-    @property
-    def limits(self):
-        return (self.low_limit_travel.get(), self.high_limit_travel.get())
-
-    @property
-    def low_limit(self):
-        return self.limits[0]
-
-    @property
-    def high_limit(self):
-        return self.limits[1]
-
-    def check_value(self, pos):
-        """Check that the position is within the soft limits"""
-        low_limit, high_limit = self.limits
-
-        if low_limit < high_limit and not (low_limit <= pos <= high_limit):
-            raise LimitError(f"position={pos} not within limits {self.limits}")
-
-    def _update_connection_state(self, **kwargs):
-        for walk in self.walk_signals():
-            walk.item._metadata["connected"] = self.controller.connected
-
-    def _forward_readback(self, **kwargs):
-        kwargs.pop("sub_type")
-        self._run_subs(sub_type="readback", **kwargs)
-
-    @raise_if_disconnected
-    def move(self, position, wait=True, **kwargs):
-        """Move to a specified position, optionally waiting for motion to
-        complete.
-
-        Parameters
-        ----------
-        position
-            Position to move to
-        moved_cb : callable
-            Call this callback when movement has finished. This callback must
-            accept one keyword argument: 'obj' which will be set to this
-            positioner instance.
-        timeout : float, optional
-            Maximum time to wait for the motion. If None, the default timeout
-            for this positioner is used.
-
-        Returns
-        -------
-        status : MoveStatus
-
-        Raises
-        ------
-        TimeoutError
-            When motion takes longer than `timeout`
-        ValueError
-            On invalid positions
-        RuntimeError
-            If motion fails other than timing out
-        """
-        self._started_moving = False
-        timeout = kwargs.pop("timeout", 100)
-        status = super().move(position, timeout=timeout, **kwargs)
-        self.user_setpoint.put(position, wait=False)
-
-        def move_and_finish():
-            while self.motor_is_moving.get():
-                print("motor is moving")
-                val = self.readback.read()
-                self._run_subs(sub_type=self.SUB_READBACK, value=val, timestamp=time.time())
-                time.sleep(0.01)
-            print("Move finished")
-            self._done_moving()
-
-        threading.Thread(target=move_and_finish, daemon=True).start()
-        try:
-            if wait:
-                status_wait(status)
-        except KeyboardInterrupt:
-            self.stop()
-            raise
-
-        return status
-
-    @property
-    def axis_Id(self):
-        return self._axis_Id_alpha
-
-    @axis_Id.setter
-    def axis_Id(self, val):
-        if isinstance(val, str):
-            if len(val) != 1:
-                raise ValueError(f"Only single-character axis_Ids are supported.")
-            self._axis_Id_alpha = val
-            self._axis_Id_numeric = ord(val.lower()) - 97
-        else:
-            raise TypeError(f"Expected value of type str but received {type(val)}")
-
-    @property
-    def axis_Id_numeric(self):
-        return self._axis_Id_numeric
-
-    @axis_Id_numeric.setter
-    def axis_Id_numeric(self, val):
-        if isinstance(val, int):
-            if val > 26:
-                raise ValueError(f"Numeric value exceeds supported range.")
-            self._axis_Id_alpha = val
-            self._axis_Id_numeric = (chr(val + 97)).capitalize()
-        else:
-            raise TypeError(f"Expected value of type int but received {type(val)}")
-
-    def kickoff(self, metadata, **kwargs) -> None:
-        self.controller.kickoff(metadata)
-
-    @property
-    def egu(self):
-        """The engineering units (EGU) for positions"""
-        return "um"
-
-    # how is this used later?
-
-    def stage(self) -> List[object]:
-        return super().stage()
-
-    def unstage(self) -> List[object]:
-        return super().unstage()
-
-    def stop(self, *, success=False):
-        self.controller.stop_all_axes()
-        return super().stop(success=success)
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG)
-
-    mock = False
-    if not mock:
-        rty = RtLamniMotor("B", name="rty", host="mpc2680.psi.ch", port=3333, sign=1)
-        rty.stage()
-        status = rty.move(0, wait=True)
-        status = rty.move(10, wait=True)
-        rty.read()
-
-        rty.get()
-        rty.describe()
-
-        rty.unstage()
-    else:
-        from ophyd_devices.utils.socket import SocketMock
-
-        rtx = RtLamniMotor("A", name="rtx", host="mpc2680.psi.ch", port=3333, socket_cls=SocketMock)
-        rty = RtLamniMotor("B", name="rty", host="mpc2680.psi.ch", port=3333, socket_cls=SocketMock)
-        rtx.stage()
-        # rty.stage()

csaxs_bec/devices/smaract/smaract_controller.py

@@ -111,10 +111,6 @@ class SmaractController(Controller):
     def socket_put(self, val: str):
         self.sock.put(f":{val}\n".encode())
 
-    @threadlocked
-    def socket_get(self):
-        return self.sock.receive().decode()
-
     @threadlocked
     def socket_put_and_receive(
         self, val: str, remove_trailing_chars=True, check_for_errors=True, raise_if_not_status=False

csaxs_bec/devices/tests_utils/utils.py

@@ -0,0 +1,9 @@
+def patch_dual_pvs(device):
+    device.wait_for_connection(all_signals=True)
+    for walk in device.walk_signals():
+        if not hasattr(walk.item, "_read_pv"):
+            continue
+        if not hasattr(walk.item, "_write_pv"):
+            continue
+        if walk.item._read_pv.pvname.endswith("_RBV"):
+            walk.item._read_pv = walk.item._write_pv

csaxs_bec/file_writer/csaxs_nexus.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any
 import numpy as np
 
 if TYPE_CHECKING:
-    from bec_lib import DeviceManagerBase
+    from bec_lib.devicemanager import DeviceManagerBase
     from bec_server.file_writer.file_writer import HDF5Storage
 
 

csaxs_bec/scans/LamNIFermatScan.py

@@ -23,7 +23,8 @@ but they are executed in a specific order:
 import time
 
 import numpy as np
-from bec_lib import MessageEndpoints, bec_logger
+from bec_lib import bec_logger
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.scan_server.errors import ScanAbortion
 from bec_server.scan_server.scans import RequestBase, ScanArgType, ScanBase
 

csaxs_bec/scans/__init__.py

@@ -1,4 +1,5 @@
 from .flomni_fermat_scan import FlomniFermatScan
+from .jungfrau_joch_scan import JungfrauJochTest
 from .LamNIFermatScan import LamNIFermatScan, LamNIMoveToScanCenter
 from .owis_grid import OwisGrid
 from .sgalil_grid import SgalilGrid

csaxs_bec/scans/flomni_fermat_scan.py

@@ -23,7 +23,8 @@ but they are executed in a specific order:
 import time
 
 import numpy as np
-from bec_lib import MessageEndpoints, bec_logger, messages
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.scan_server.errors import ScanAbortion
 from bec_server.scan_server.scans import SyncFlyScanBase
 

csaxs_bec/scans/jungfrau_joch_scan.py

@@ -0,0 +1,70 @@
+import time
+
+from bec_lib import bec_logger
+from bec_lib.device import DeviceBase
+from bec_lib.endpoints import MessageEndpoints
+from bec_server.scan_server.scans import AsyncFlyScanBase, ScanAbortion
+
+logger = bec_logger.logger
+
+
+class JungfrauJochTest(AsyncFlyScanBase):
+    """Owis-based grid scan."""
+
+    scan_name = "jjf_test"
+    #scan_report_hint = "device_progress"
+    required_kwargs = ["points", "exp_time", "readout_time"]
+    arg_input = {}
+    arg_bundle_size = {"bundle": len(arg_input), "min": None, "max": None}
+    gui_config = {
+        "Acquisition Parameters": ["num_points",  "cycles"],
+        "Exposure Parameters" : ["exp_time", "readout_time"]
+    }
+
+    def __init__(
+        self,
+        num_points:int,
+        exp_time: float,
+        readout_time: float,
+        cycles:int =1,
+        **kwargs,
+    ):
+        """
+        JungfrauJoch Test scan.
+
+        Args:
+            device (DeviceBase) : The device to be triggered, currently only for delaygenerator csaxs
+            num_points (int) : Number of points per burst
+            exp_time (float) : exposure time.
+            readout_time (float): readout time of detector
+            cycles (int) : number of cycles, default is 1
+
+        Example:
+           scans.jjf_test(points = 100, exp_time= 1e-3, readout_time=1e-3, cycles = 2)
+        """
+        if readout_time <=0:
+            raise ScanAbortion(f"Readout time must be larger than 0, provided value {readout_time}")
+        super().__init__(exp_time=exp_time, readout_time=readout_time,**kwargs)
+        self.device = "ddg"
+        self.num_points = num_points
+        self.cycles = cycles
+        self.primary_readout_cycle = 0.2
+
+    def scan_core(self):
+        logger.info(f"Starting with Scan Core")
+        total_exposure = self.num_points * (self.exp_time + self.readout_time)
+        for i in range(self.cycles):
+            logger.info(f"Beginning cycle {i} of {self.cycles}")
+
+            yield from self.stubs.trigger(group="trigger", point_id=self.point_id)
+            yield from self.stubs.read_and_wait(
+                group="primary",
+                wait_group="readout_primary",
+                point_id=self.point_id,
+            )
+
+            yield from self.stubs.wait(wait_type="trigger", group="trigger", wait_time=total_exposure)
+            self.point_id +=1
+            logger.info(f"Finished cycle {i} of {self.cycles}")
+        logger.info(f"Finished scan")
+        self.num_pos = self.point_id + 1 

csaxs_bec/scans/owis_grid.py

@@ -22,7 +22,8 @@ but they are executed in a specific order:
 
 import time
 
-from bec_lib import MessageEndpoints, bec_logger
+from bec_lib import bec_logger
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.scan_server.scans import AsyncFlyScanBase, ScanAbortion
 
 logger = bec_logger.logger
@@ -32,7 +33,7 @@ class OwisGrid(AsyncFlyScanBase):
     """Owis-based grid scan."""
 
     scan_name = "owis_grid"
-    scan_report_hint = "scan_progress"
+    scan_report_hint = "device_progress"
     required_kwargs = []
     arg_input = {}
     arg_bundle_size = {"bundle": len(arg_input), "min": None, "max": None}
@@ -153,11 +154,11 @@ class OwisGrid(AsyncFlyScanBase):
         if not self.scan_report_hint:
             yield None
             return
-        yield from self.stubs.scan_report_instruction({"scan_progress": ["mcs"]})
+        yield from self.stubs.scan_report_instruction({"device_progress": ["mcs"]})
 
     def pre_scan(self):
         """Pre scan instructions, move to start position"""
-        yield from self._move_and_wait([self.start_x, self.start_y])
+        yield from self._move_scan_motors_and_wait([self.start_x, self.start_y])
         yield from self.stubs.pre_scan()
 
     def scan_progress(self) -> int:
@@ -307,3 +308,11 @@ class OwisGrid(AsyncFlyScanBase):
         yield from self.stubs.send_rpc_and_wait("samy", "velocity.put", self.high_velocity)
         yield from self.stubs.send_rpc_and_wait("samy", "acceleration.put", self.high_acc_time)
         super().finalize()
+
+    def _move_scan_motors_and_wait(self, pos):
+        # TODO: remove this method once BEC MR 637 is merged
+        # pylint: disable=no-member
+        if hasattr(super(), "_move_scan_motors_and_wait"):
+            yield from super()._move_scan_motors_and_wait(pos)
+        else:
+            yield from self._move_and_wait(pos)

csaxs_bec/scans/scan_plugin_template.py

@@ -25,7 +25,8 @@ but they are executed in a specific order:
 
 # import numpy as np
 
-# from bec_lib import MessageEndpoints, bec_logger, messages
+# from bec_lib import bec_logger, messages
+# from bec_lib.endpoints import MessageEndpoints
 # from bec_server.scan_server.errors import ScanAbortion
 # from bec_server.scan_server.scans import FlyScanBase, RequestBase, ScanArgType, ScanBase
 

csaxs_bec/scans/sgalil_grid.py

@@ -22,7 +22,8 @@ but they are executed in a specific order:
 
 import time
 
-from bec_lib import MessageEndpoints, bec_logger
+from bec_lib import bec_logger
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.scan_server.scans import AsyncFlyScanBase
 
 logger = bec_logger.logger
@@ -30,7 +31,7 @@ logger = bec_logger.logger
 
 class SgalilGrid(AsyncFlyScanBase):
     scan_name = "sgalil_grid"
-    scan_report_hint = "scan_progress"
+    scan_report_hint = "device_progress"
     required_kwargs = []
     arg_input = {}
     arg_bundle_size = {"bundle": len(arg_input), "min": None, "max": None}
@@ -96,10 +97,10 @@ class SgalilGrid(AsyncFlyScanBase):
         if not self.scan_report_hint:
             yield None
             return
-        yield from self.stubs.scan_report_instruction({"scan_progress": ["mcs"]})
+        yield from self.stubs.scan_report_instruction({"device_progress": ["mcs"]})
 
     def pre_scan(self):
-        yield from self._move_and_wait([self.start_x, self.start_y])
+        yield from self._move_scan_motors_and_wait([self.start_x, self.start_y])
         yield from self.stubs.pre_scan()
         # TODO move to start position
 
@@ -214,3 +215,11 @@ class SgalilGrid(AsyncFlyScanBase):
             #         logger.info('Testing Scan abortion, would have raised here!')
             # except Exception as exc:
             #     logger.info(f'{exc}')
+
+    def _move_scan_motors_and_wait(self, pos):
+        # TODO: remove this method once BEC MR 637 is merged
+        # pylint: disable=no-member
+        if hasattr(super(), "_move_scan_motors_and_wait"):
+            yield from super()._move_scan_motors_and_wait(pos)
+        else:
+            yield from self._move_and_wait(pos)

tests/tests_devices/test_delay_generator_csaxs.py

@@ -2,19 +2,9 @@
 from unittest import mock
 
 import pytest
-from ophyd_devices.epics.devices.psi_delay_generator_base import TriggerSource
+from ophyd_devices.interfaces.base_classes.psi_delay_generator_base import TriggerSource
 
-from csaxs_bec.devices.epics.devices.delay_generator_csaxs import DDGSetup
-
-
-def patch_dual_pvs(device):
-    for walk in device.walk_signals():
-        if not hasattr(walk.item, "_read_pv"):
-            continue
-        if not hasattr(walk.item, "_write_pv"):
-            continue
-        if walk.item._read_pv.pvname.endswith("_RBV"):
-            walk.item._read_pv = walk.item._write_pv
+from csaxs_bec.devices.epics.delay_generator_csaxs import DDGSetup
 
 
 @pytest.fixture(scope="function")

tests/tests_devices/test_eiger9m_csaxs.py

@@ -4,44 +4,34 @@ from unittest import mock
 
 import ophyd
 import pytest
-from bec_lib import MessageEndpoints, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.device_server.tests.utils import DMMock
 from ophyd_devices.tests.utils import MockPV
 
-from csaxs_bec.devices.epics.devices.eiger9m_csaxs import Eiger9McSAXS
-
-
-def patch_dual_pvs(device):
-    for walk in device.walk_signals():
-        if not hasattr(walk.item, "_read_pv"):
-            continue
-        if not hasattr(walk.item, "_write_pv"):
-            continue
-        if walk.item._read_pv.pvname.endswith("_RBV"):
-            walk.item._read_pv = walk.item._write_pv
+from csaxs_bec.devices.epics.eiger9m_csaxs import Eiger9McSAXS
+from csaxs_bec.devices.tests_utils.utils import patch_dual_pvs
 
 
 @pytest.fixture(scope="function")
 def mock_det():
     name = "eiger"
     prefix = "X12SA-ES-EIGER9M:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter"),
+            mock.patch("ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"),
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ),
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 mock_cl.thread_class = threading.Thread
                 with mock.patch.object(Eiger9McSAXS, "_init"):
-                    det = Eiger9McSAXS(
-                        name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode
-                    )
+                    det = Eiger9McSAXS(name=name, prefix=prefix, device_manager=dm)
                     patch_dual_pvs(det)
+                    det.TIMEOUT_FOR_SIGNALS = 0.1
                     yield det
 
 
@@ -49,29 +39,28 @@ def test_init():
     """Test the _init function:"""
     name = "eiger"
     prefix = "X12SA-ES-EIGER9M:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter"),
+            mock.patch("ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"),
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ),
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 with (
                     mock.patch(
-                        "csaxs_bec.devices.epics.devices.eiger9m_csaxs.Eiger9MSetup.initialize_default_parameter"
+                        "csaxs_bec.devices.epics.eiger9m_csaxs.Eiger9MSetup.initialize_default_parameter"
                     ) as mock_default,
                     mock.patch(
-                        "csaxs_bec.devices.epics.devices.eiger9m_csaxs.Eiger9MSetup.initialize_detector"
+                        "csaxs_bec.devices.epics.eiger9m_csaxs.Eiger9MSetup.initialize_detector"
                     ) as mock_init_det,
                     mock.patch(
-                        "csaxs_bec.devices.epics.devices.eiger9m_csaxs.Eiger9MSetup.initialize_detector_backend"
+                        "csaxs_bec.devices.epics.eiger9m_csaxs.Eiger9MSetup.initialize_detector_backend"
                     ) as mock_init_backend,
                 ):
-                    Eiger9McSAXS(name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode)
+                    Eiger9McSAXS(name=name, prefix=prefix, device_manager=dm)
                     mock_default.assert_called_once()
                     mock_init_det.assert_called_once()
                     mock_init_backend.assert_called_once()
@@ -146,7 +135,7 @@ def test_initialize_detector_backend(
 
     Validation upon checking set values in mocked std_daq instance
     """
-    with mock.patch("csaxs_bec.devices.epics.devices.eiger9m_csaxs.StdDaqClient") as mock_std_daq:
+    with mock.patch("csaxs_bec.devices.epics.eiger9m_csaxs.StdDaqClient") as mock_std_daq:
         instance = mock_std_daq.return_value
         instance.stop_writer.return_value = None
         instance.get_status.return_value = daq_status
@@ -235,8 +224,8 @@ def test_stage(
         mock_det.cam.beam_energy.put(scaninfo["mokev"])
         mock_det.stopped = stopped
         mock_det.cam.detector_state._read_pv.mock_data = detector_state
-        with mock.patch.object(mock_det.custom_prepare, "prepare_detector_backend") as mock_prep_fw:
-            mock_det.filepath = scaninfo["filepath"]
+        with mock.patch.object(mock_det.custom_prepare, "prepare_data_backend") as mock_prep_fw:
+            mock_det.filepath.set(scaninfo["filepath"]).wait()
             if expected_exception:
                 with pytest.raises(Exception):
                     mock_det.timeout = 0.1
@@ -250,7 +239,7 @@ def test_stage(
                 )
                 assert mock_det.cam.num_frames.get() == 1
 
-                mock_publish_file_location.assert_called_with(done=False)
+                mock_publish_file_location.assert_called_with(done=False, successful=False)
                 assert mock_det.cam.acquire.get() == 1
 
 
@@ -325,7 +314,7 @@ def test_prepare_detector_backend(mock_det, scaninfo, daq_status, expected_excep
 
 
 @pytest.mark.parametrize("stopped, expected_exception", [(False, False), (True, True)])
-def test_unstage(mock_det, stopped, expected_exception):
+def test_complete(mock_det, stopped, expected_exception):
     with (
         mock.patch.object(mock_det.custom_prepare, "finished") as mock_finished,
         mock.patch.object(
@@ -334,10 +323,10 @@ def test_unstage(mock_det, stopped, expected_exception):
     ):
         mock_det.stopped = stopped
         if expected_exception:
-            mock_det.unstage()
+            mock_det.complete()
             assert mock_det.stopped is True
         else:
-            mock_det.unstage()
+            mock_det.complete()
             mock_finished.assert_called_once()
             mock_publish_file_location.assert_called_with(done=True, successful=True)
             assert mock_det.stopped is False
@@ -356,12 +345,11 @@ def test_stop_detector_backend(mock_det):
     [
         ({"filepath": "test.h5", "successful": True, "done": False, "scan_id": "123"}),
         ({"filepath": "test.h5", "successful": False, "done": True, "scan_id": "123"}),
-        ({"filepath": "test.h5", "successful": None, "done": True, "scan_id": "123"}),
     ],
 )
 def test_publish_file_location(mock_det, scaninfo):
     mock_det.scaninfo.scan_id = scaninfo["scan_id"]
-    mock_det.filepath = scaninfo["filepath"]
+    mock_det.filepath.set(scaninfo["filepath"]).wait()
     mock_det.custom_prepare.publish_file_location(
         done=scaninfo["done"], successful=scaninfo["successful"]
     )

tests/tests_devices/test_falcon_csaxs.py

@@ -5,44 +5,36 @@ from unittest import mock
 
 import ophyd
 import pytest
-from bec_lib import MessageEndpoints, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.device_server.tests.utils import DMMock
 from ophyd_devices.tests.utils import MockPV
 
-from csaxs_bec.devices.epics.devices.falcon_csaxs import FalconcSAXS, FalconTimeoutError
-
-
-def patch_dual_pvs(device):
-    for walk in device.walk_signals():
-        if not hasattr(walk.item, "_read_pv"):
-            continue
-        if not hasattr(walk.item, "_write_pv"):
-            continue
-        if walk.item._read_pv.pvname.endswith("_RBV"):
-            walk.item._read_pv = walk.item._write_pv
+from csaxs_bec.devices.epics.falcon_csaxs import FalconcSAXS, FalconTimeoutError
+from csaxs_bec.devices.tests_utils.utils import patch_dual_pvs
 
 
 @pytest.fixture(scope="function")
 def mock_det():
     name = "falcon"
     prefix = "X12SA-SITORO:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter") as filemixin,
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"
+            ) as filemixin,
+            mock.patch(
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ) as mock_service_config,
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 mock_cl.thread_class = threading.Thread
                 with mock.patch.object(FalconcSAXS, "_init"):
-                    det = FalconcSAXS(
-                        name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode
-                    )
+                    det = FalconcSAXS(name=name, prefix=prefix, device_manager=dm)
                     patch_dual_pvs(det)
+                    det.TIMEOUT_FOR_SIGNALS = 0.1
                     yield det
 
 
@@ -136,9 +128,9 @@ def test_stage(mock_det, scaninfo):
     This includes testing _prep_det
     """
     with (
-        mock.patch.object(mock_det, "set_trigger") as mock_set_trigger,
+        mock.patch.object(mock_det.custom_prepare, "set_trigger") as mock_set_trigger,
         mock.patch.object(
-            mock_det.custom_prepare, "prepare_detector_backend"
+            mock_det.custom_prepare, "prepare_data_backend"
         ) as mock_prep_data_backend,
         mock.patch.object(
             mock_det.custom_prepare, "publish_file_location"
@@ -155,7 +147,7 @@ def test_stage(mock_det, scaninfo):
             scaninfo["num_points"] * scaninfo["frames_per_trigger"]
         )
         mock_prep_data_backend.assert_called_once()
-        mock_publish_file_location.assert_called_once_with(done=False)
+        mock_publish_file_location.assert_called_once_with(done=False, successful=False)
         mock_arm_acquisition.assert_called_once()
 
 
@@ -201,12 +193,11 @@ def test_prepare_data_backend(mock_det, scaninfo):
     [
         ({"filepath": "test.h5", "successful": True, "done": False, "scan_id": "123"}),
         ({"filepath": "test.h5", "successful": False, "done": True, "scan_id": "123"}),
-        ({"filepath": "test.h5", "successful": None, "done": True, "scan_id": "123"}),
     ],
 )
 def test_publish_file_location(mock_det, scaninfo):
     mock_det.scaninfo.scan_id = scaninfo["scan_id"]
-    mock_det.filepath = scaninfo["filepath"]
+    mock_det.filepath.set(scaninfo["filepath"]).wait()
     mock_det.custom_prepare.publish_file_location(
         done=scaninfo["done"], successful=scaninfo["successful"]
     )
@@ -251,24 +242,18 @@ def test_trigger(mock_det):
         mock_on_trigger.assert_called_once()
 
 
-@pytest.mark.parametrize("stopped, expected_abort", [(False, False), (True, True)])
-def test_unstage(mock_det, stopped, expected_abort):
+def test_complete(mock_det):
     with (
         mock.patch.object(mock_det.custom_prepare, "finished") as mock_finished,
         mock.patch.object(
             mock_det.custom_prepare, "publish_file_location"
         ) as mock_publish_file_location,
     ):
-        mock_det.stopped = stopped
-        if expected_abort:
-            mock_det.unstage()
-            assert mock_det.stopped is stopped
-            assert mock_publish_file_location.call_count == 0
-        else:
-            mock_det.unstage()
-            mock_finished.assert_called_once()
-            mock_publish_file_location.assert_called_with(done=True, successful=True)
-            assert mock_det.stopped is stopped
+        mock_det.stopped = False
+        mock_det.complete()
+        assert mock_finished.call_count == 1
+        call = mock.call(done=True, successful=True)
+        assert mock_publish_file_location.call_args == call
 
 
 def test_stop(mock_det):

tests/tests_devices/test_fupr_ophyd.py

@@ -3,7 +3,7 @@ from unittest import mock
 import pytest
 from ophyd_devices.tests.utils import SocketMock
 
-from csaxs_bec.devices.galil.fupr_ophyd import FuprGalilController, FuprGalilMotor
+from csaxs_bec.devices.omny.galil.fupr_ophyd import FuprGalilController, FuprGalilMotor
 
 
 @pytest.fixture

tests/tests_devices/test_galil.py

@@ -1,15 +1,16 @@
+import copy
 from unittest import mock
 
 import pytest
 from ophyd_devices.tests.utils import SocketMock
 
-from csaxs_bec.devices.galil.galil_ophyd import GalilController, GalilMotor
+from csaxs_bec.devices.omny.galil.lgalil_ophyd import LamniGalilController, LamniGalilMotor
 
 
 @pytest.fixture(scope="function")
 def leyey():
-    GalilController._reset_controller()
-    leyey_motor = GalilMotor(
+    LamniGalilController._reset_controller()
+    leyey_motor = LamniGalilMotor(
         "H", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyey_motor.controller.on()
@@ -20,8 +21,8 @@ def leyey():
 
 @pytest.fixture(scope="function")
 def leyex():
-    GalilController._reset_controller()
-    leyex_motor = GalilMotor(
+    LamniGalilController._reset_controller()
+    leyex_motor = LamniGalilMotor(
         "A", name="leyey", host="mpc2680.psi.ch", port=8081, socket_cls=SocketMock
     )
     leyex_motor.controller.on()
@@ -60,7 +61,7 @@ def test_axis_get(leyey, pos, msg, sign):
 )
 def test_axis_put(leyey, target_pos, socket_put_messages, socket_get_messages):
     leyey.controller.sock.flush_buffer()
-    leyey.controller.sock.buffer_recv = socket_get_messages
+    leyey.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     leyey.user_setpoint.put(target_pos)
     assert leyey.controller.sock.buffer_put == socket_put_messages
 
@@ -104,7 +105,7 @@ def test_axis_put(leyey, target_pos, socket_put_messages, socket_get_messages):
 )
 def test_drive_axis_to_limit(leyex, axis_nr, direction, socket_put_messages, socket_get_messages):
     leyex.controller.sock.flush_buffer()
-    leyex.controller.sock.buffer_recv = socket_get_messages
+    leyex.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     leyex.controller.drive_axis_to_limit(axis_nr, direction)
     assert leyex.controller.sock.buffer_put == socket_put_messages
 
@@ -144,6 +145,9 @@ def test_drive_axis_to_limit(leyex, axis_nr, direction, socket_put_messages, soc
 )
 def test_find_reference(leyex, axis_nr, socket_put_messages, socket_get_messages):
     leyex.controller.sock.flush_buffer()
-    leyex.controller.sock.buffer_recv = socket_get_messages
-    leyex.controller.find_reference(axis_nr)
+    leyex.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
+    try:
+        leyex.controller.find_reference(axis_nr)
+    except Exception as e:
+        print(e)
     assert leyex.controller.sock.buffer_put == socket_put_messages

tests/tests_devices/test_galil_flomni.py

@@ -1,9 +1,9 @@
-from unittest import mock
+import copy
 
 import pytest
 from ophyd_devices.tests.utils import SocketMock
 
-from csaxs_bec.devices.galil.fgalil_ophyd import FlomniGalilController, FlomniGalilMotor
+from csaxs_bec.devices.omny.galil.fgalil_ophyd import FlomniGalilController, FlomniGalilMotor
 
 
 @pytest.fixture(scope="function")
@@ -60,7 +60,7 @@ def test_axis_get(leyey, pos, msg, sign):
 )
 def test_axis_put(leyey, target_pos, socket_put_messages, socket_get_messages):
     leyey.controller.sock.flush_buffer()
-    leyey.controller.sock.buffer_recv = socket_get_messages
+    leyey.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     leyey.user_setpoint.put(target_pos)
     assert leyey.controller.sock.buffer_put == socket_put_messages
 
@@ -104,7 +104,7 @@ def test_axis_put(leyey, target_pos, socket_put_messages, socket_get_messages):
 )
 def test_drive_axis_to_limit(leyex, axis_nr, direction, socket_put_messages, socket_get_messages):
     leyex.controller.sock.flush_buffer()
-    leyex.controller.sock.buffer_recv = socket_get_messages
+    leyex.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     leyex.controller.drive_axis_to_limit(axis_nr, direction)
     assert leyex.controller.sock.buffer_put == socket_put_messages
 
@@ -144,7 +144,7 @@ def test_drive_axis_to_limit(leyex, axis_nr, direction, socket_put_messages, soc
 )
 def test_find_reference(leyex, axis_nr, socket_put_messages, socket_get_messages):
     leyex.controller.sock.flush_buffer()
-    leyex.controller.sock.buffer_recv = socket_get_messages
+    leyex.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     leyex.controller.find_reference(axis_nr)
     assert leyex.controller.sock.buffer_put == socket_put_messages
 
@@ -165,7 +165,7 @@ def test_fosaz_light_curtain_is_triggered(
     )
     fosaz.controller.on()
     fosaz.controller.sock.flush_buffer()
-    fosaz.controller.sock.buffer_recv = socket_get_messages
+    fosaz.controller.sock.buffer_recv = copy.deepcopy(socket_get_messages)
     assert fosaz.controller.fosaz_light_curtain_is_triggered() == triggered
     assert fosaz.controller.sock.buffer_put == socket_put_messages
     fosaz.controller.off()

tests/tests_devices/test_mcs_card.py

@@ -4,48 +4,42 @@ from unittest import mock
 
 import ophyd
 import pytest
-from bec_lib import MessageEndpoints, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.device_server.tests.utils import DMMock
 from ophyd_devices.tests.utils import MockPV
 
-from csaxs_bec.devices.epics.devices.mcs_csaxs import (
+from csaxs_bec.devices.epics.mcs_csaxs import (
     MCScSAXS,
     MCSError,
     MCSTimeoutError,
     ReadoutMode,
     TriggerSource,
 )
-
-
-def patch_dual_pvs(device):
-    for walk in device.walk_signals():
-        if not hasattr(walk.item, "_read_pv"):
-            continue
-        if not hasattr(walk.item, "_write_pv"):
-            continue
-        if walk.item._read_pv.pvname.endswith("_RBV"):
-            walk.item._read_pv = walk.item._write_pv
+from csaxs_bec.devices.tests_utils.utils import patch_dual_pvs
 
 
 @pytest.fixture(scope="function")
 def mock_det():
     name = "mcs"
     prefix = "X12SA-MCS:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter") as filemixin,
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"
+            ) as filemixin,
+            mock.patch(
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ) as mock_service_config,
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 mock_cl.thread_class = threading.Thread
                 with mock.patch.object(MCScSAXS, "_init"):
-                    det = MCScSAXS(name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode)
+                    det = MCScSAXS(name=name, prefix=prefix, device_manager=dm)
                     patch_dual_pvs(det)
+                    det.TIMEOUT_FOR_SIGNALS = 0.1
                     yield det
 
 
@@ -53,30 +47,25 @@ def test_init():
     """Test the _init function:"""
     name = "eiger"
     prefix = "X12SA-ES-EIGER9M:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter"),
+            mock.patch("ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"),
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ),
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 with (
                     mock.patch(
-                        "csaxs_bec.devices.epics.devices.mcs_csaxs.MCSSetup.initialize_default_parameter"
-                    ) as mock_default,
-                    mock.patch(
-                        "csaxs_bec.devices.epics.devices.mcs_csaxs.MCSSetup.initialize_detector"
+                        "csaxs_bec.devices.epics.mcs_csaxs.MCSSetup.initialize_detector"
                     ) as mock_init_det,
                     mock.patch(
-                        "csaxs_bec.devices.epics.devices.mcs_csaxs.MCSSetup.initialize_detector_backend"
+                        "csaxs_bec.devices.epics.mcs_csaxs.MCSSetup.initialize_detector_backend"
                     ) as mock_init_backend,
                 ):
-                    MCScSAXS(name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode)
-                    mock_default.assert_called_once()
+                    MCScSAXS(name=name, prefix=prefix, device_manager=dm)
                     mock_init_det.assert_called_once()
                     mock_init_backend.assert_called_once()
 
@@ -272,23 +261,10 @@ def test_prepare_detector_backend(mock_det):
     assert mock_det.read_mode.get() == ReadoutMode.EVENT
 
 
-@pytest.mark.parametrize("stopped, expected_exception", [(False, False), (True, True)])
-def test_unstage(mock_det, stopped, expected_exception):
-    with (
-        mock.patch.object(mock_det.custom_prepare, "finished") as mock_finished,
-        mock.patch.object(
-            mock_det.custom_prepare, "publish_file_location"
-        ) as mock_publish_file_location,
-    ):
-        mock_det.stopped = stopped
-        if expected_exception:
-            mock_det.unstage()
-            assert mock_det.stopped is True
-        else:
-            mock_det.unstage()
-            mock_finished.assert_called_once()
-            mock_publish_file_location.assert_called_with(done=True, successful=True)
-            assert mock_det.stopped is False
+def test_complete(mock_det):
+    with (mock.patch.object(mock_det.custom_prepare, "finished") as mock_finished,):
+        mock_det.complete()
+        assert mock_finished.call_count == 1
 
 
 def test_stop_detector_backend(mock_det):

tests/tests_devices/test_npoint_piezo.py

@@ -1,47 +1,43 @@
+import copy
+from unittest import mock
+
 import pytest
 
 from csaxs_bec.devices.npoint import NPointAxis, NPointController
 
+# pylint: disable=protected-access
+# pylint: disable=redefined-outer-name
 
-class SocketMock:
-    def __init__(self, sock=None):
-        self.buffer_put = ""
-        self.buffer_recv = ""
-        self.is_open = False
-        if sock is None:
-            self.open()
-        else:
-            self.sock = sock
 
-    def connect(self, host, port):
-        print(f"connecting to {host} port {port}")
-        # self.sock.create_connection((host, port))
-        # self.sock.connect((host, port))
+@pytest.fixture
+def controller():
+    """
+    Fixture to create a NPointController object.
+    """
+    with mock.patch("ophyd_devices.utils.socket.SocketIO") as socket_cls:
+        controller = NPointController(
+            socket_cls=socket_cls, socket_host="localhost", socket_port=1234
+        )
+        controller.on()
+        controller.sock.reset_mock()
+        yield controller
+        controller.off()
 
-    def _put(self, msg_bytes):
-        self.buffer_put = msg_bytes
-        print(self.buffer_put)
 
-    def _recv(self, buffer_length=1024):
-        print(self.buffer_recv)
-        return self.buffer_recv
-
-    def _initialize_socket(self):
-        pass
-
-    def put(self, msg):
-        return self._put(msg)
-
-    def receive(self, buffer_length=1024):
-        return self._recv(buffer_length=buffer_length)
-
-    def open(self):
-        self._initialize_socket()
-        self.is_open = True
-
-    def close(self):
-        self.sock = None
-        self.is_open = False
+@pytest.fixture
+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
+    )
+    npointx.controller.on()
+    npointx.controller.sock.reset_mock()
+    npointx.controller.sock.receive.reset_mock()
+    yield npointx
+    npointx.controller.off()
 
 
 @pytest.mark.parametrize(
@@ -52,12 +48,29 @@ class SocketMock:
         (-5, b"\xa2\x18\x12\x83\x1133\xff\xffU"),
     ],
 )
-def test_axis_put(pos, msg):
-    controller = NPointController(SocketMock())
-    npointx = NPointAxis(controller, 0, "nx")
-    controller.on()
-    npointx.set(pos)
-    assert npointx.controller.socket.buffer_put == msg
+def test_axis_put(npointx, pos, msg):
+    """
+    Test that the set target position sends the correct message to the controller.
+    """
+    npointx.controller.set_target_pos(npointx.axis_Id_numeric, pos)
+    npointx.controller.sock.put.assert_called_with(msg)
+
+
+def test_npoint_axis_move(npointx):
+    """
+    Test that the move method sends the correct messages to the controller.
+    It should send the set target position, followed by 2 get current position messages.
+    """
+    npointx.controller.sock.receive.side_effect = [
+        b"\xa0\x34\x13\x83\x11\x00\x00\x00\x00U",  # pos 0
+        b"\xa0\x34\x13\x83\x11\xcd\xcc\x00\x00U",  # pos 5
+    ]
+    npointx.move(5)
+    assert (
+        mock.call(b"\xa2\x18\x12\x83\x11\xcd\xcc\x00\x00U")
+        in npointx.controller.sock.put.mock_calls
+    )
+    assert len(npointx.controller.sock.put.mock_calls) == 3
 
 
 @pytest.mark.parametrize(
@@ -68,13 +81,12 @@ def test_axis_put(pos, msg):
         (-5, b"\xa04\x13\x83\x11U", b"\xa0\x34\x13\x83\x1133\xff\xffU"),
     ],
 )
-def test_axis_get_out(pos, msg_in, msg_out):
-    controller = NPointController(SocketMock())
-    npointx = NPointAxis(controller, 0, "nx")
-    controller.on()
-    npointx.controller.socket.buffer_recv = msg_out
-    assert pytest.approx(npointx.get(), rel=0.01) == pos
-    # assert controller.socket.buffer_put == msg_in
+def test_axis_get_out(npointx, pos, msg_in, msg_out):
+    """
+    Test that the readback value is correctly read from the controller.
+    """
+    npointx.controller.sock.receive.side_effect = [msg_out]
+    assert pytest.approx(npointx.readback.get(), rel=0.01) == pos
 
 
 @pytest.mark.parametrize(
@@ -85,31 +97,40 @@ def test_axis_get_out(pos, msg_in, msg_out):
         (2, b"\xa043\x83\x11U", b"\xa0\x34\x13\x83\x1133\xff\xffU"),
     ],
 )
-def test_axis_get_in(axis, msg_in, msg_out):
-    controller = NPointController(SocketMock())
-    npointx = NPointAxis(controller, 0, "nx")
-    controller.on()
-    controller.socket.buffer_recv = msg_out
-    controller._get_current_pos(axis)
-    assert controller.socket.buffer_put == msg_in
+def test_axis_get_in(npointx, axis, msg_in, msg_out):
+    """
+    Test that the readback value is correctly read from the controller by directly calling the
+    controller's method.
+    """
+    npointx.controller.sock.receive.side_effect = [msg_out]
+    npointx.controller.get_current_pos(axis)
+    npointx.controller.sock.put.assert_called_once_with(msg_in)
 
 
-def test_axis_out_of_range():
-    controller = NPointController(SocketMock())
+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(controller, 3, "nx")
+        npointx = NPointAxis(
+            axis_Id="G", name="npointx", host="localhost", port=1234, socket_cls=mock.MagicMock()
+        )
 
 
-def test_get_axis_out_of_range():
-    controller = NPointController(SocketMock())
+def test_get_axis_out_of_range(controller):
+    """
+    Test that an error is raised when trying to get the current position of an invalid axis.
+    """
     with pytest.raises(ValueError):
-        controller._get_current_pos(3)
+        controller.get_current_pos(3)
 
 
-def test_set_axis_out_of_range():
-    controller = NPointController(SocketMock())
+def test_set_axis_out_of_range(controller):
+    """
+    Test that an error is raised when trying to set the target position of an invalid axis.
+    """
     with pytest.raises(ValueError):
-        controller._set_target_pos(3, 5)
+        controller.set_target_pos(3, 5)
 
 
 @pytest.mark.parametrize(
@@ -121,7 +142,15 @@ def test_set_axis_out_of_range():
     ],
 )
 def test_hex_list_to_int(in_buffer, byteorder, signed, val):
-    assert NPointController._hex_list_to_int(in_buffer, byteorder=byteorder, signed=signed) == val
+    """
+    Test that the hex list is correctly converted to an integer
+    """
+    assert (
+        NPointController._hex_list_to_int(
+            copy.deepcopy(in_buffer), byteorder=byteorder, signed=signed
+        )
+        == val
+    )
 
 
 @pytest.mark.parametrize(
@@ -132,10 +161,12 @@ def test_hex_list_to_int(in_buffer, byteorder, signed, val):
         (2, b"\xa0x0\x83\x11U", b"\xa0\x78\x13\x83\x11\x64\x00\x00\x00U"),
     ],
 )
-def test_get_range(axis, msg_in, msg_out):
-    controller = NPointController(SocketMock())
-    npointx = NPointAxis(controller, 0, "nx")
-    controller.on()
-    controller.socket.buffer_recv = msg_out
-    val = controller._get_range(axis)
-    assert controller.socket.buffer_put == msg_in and val == 100
+def test_get_range(npointx, axis, msg_in, msg_out):
+    """
+    Test that the range is correctly read from the controller by directly calling the
+    controller's method.
+    """
+    npointx.controller.sock.receive.side_effect = [msg_out]
+    val = npointx.controller._get_range(axis)
+    npointx.controller.sock.put.assert_called_once_with(msg_in)
+    assert val == 100

tests/tests_devices/test_pilatus_csaxs.py

@@ -5,43 +5,32 @@ from unittest import mock
 
 import ophyd
 import pytest
-from bec_lib import MessageEndpoints, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_server.device_server.tests.utils import DMMock
 from ophyd_devices.tests.utils import MockPV
 
-from csaxs_bec.devices.epics.devices.pilatus_csaxs import PilatuscSAXS
-
-
-def patch_dual_pvs(device):
-    for walk in device.walk_signals():
-        if not hasattr(walk.item, "_read_pv"):
-            continue
-        if not hasattr(walk.item, "_write_pv"):
-            continue
-        if walk.item._read_pv.pvname.endswith("_RBV"):
-            walk.item._read_pv = walk.item._write_pv
+from csaxs_bec.devices.epics.pilatus_csaxs import PilatuscSAXS
+from csaxs_bec.devices.tests_utils.utils import patch_dual_pvs
 
 
 @pytest.fixture(scope="function")
 def mock_det():
     name = "pilatus"
     prefix = "X12SA-ES-PILATUS300K:"
-    sim_mode = False
     dm = DMMock()
     with mock.patch.object(dm, "connector"):
         with (
-            mock.patch("ophyd_devices.epics.devices.psi_detector_base.FileWriter"),
+            mock.patch("ophyd_devices.interfaces.base_classes.psi_detector_base.FileWriter"),
             mock.patch(
-                "ophyd_devices.epics.devices.psi_detector_base.PSIDetectorBase._update_service_config"
+                "ophyd_devices.interfaces.base_classes.psi_detector_base.PSIDetectorBase._update_service_config"
             ),
         ):
             with mock.patch.object(ophyd, "cl") as mock_cl:
                 mock_cl.get_pv = MockPV
                 mock_cl.thread_class = threading.Thread
                 with mock.patch.object(PilatuscSAXS, "_init"):
-                    det = PilatuscSAXS(
-                        name=name, prefix=prefix, device_manager=dm, sim_mode=sim_mode
-                    )
+                    det = PilatuscSAXS(name=name, prefix=prefix, device_manager=dm)
                     patch_dual_pvs(det)
                     yield det
 
@@ -60,7 +49,7 @@ def test_init_detector(mock_det, trigger_source, detector_state):
     Validation upon setting the correct PVs
 
     """
-    mock_det.custom_prepare.initialize_detector()  # call the method you want to test
+    mock_det.custom_prepare.on_init()  # call the method you want to test
     assert mock_det.cam.acquire.get() == detector_state
     assert mock_det.cam.trigger_mode.get() == trigger_source
 
@@ -95,6 +84,8 @@ def test_init_detector(mock_det, trigger_source, detector_state):
     ],
 )
 def test_stage(mock_det, scaninfo, stopped, expected_exception):
+    path = "tmp"
+    mock_det.filepath_raw = path
     with mock.patch.object(
         mock_det.custom_prepare, "publish_file_location"
     ) as mock_publish_file_location:
@@ -104,14 +95,12 @@ def test_stage(mock_det, scaninfo, stopped, expected_exception):
         mock_det.device_manager.add_device("mokev", value=12.4)
         mock_det.stopped = stopped
         with (
-            mock.patch.object(
-                mock_det.custom_prepare, "prepare_detector_backend"
-            ) as mock_data_backend,
+            mock.patch.object(mock_det.custom_prepare, "prepare_data_backend") as mock_data_backend,
             mock.patch.object(
                 mock_det.custom_prepare, "update_readout_time"
             ) as mock_update_readout_time,
         ):
-            mock_det.filepath = scaninfo["filepath"]
+            mock_det.filepath.set(scaninfo["filepath"]).wait()
             if expected_exception:
                 with pytest.raises(Exception):
                     mock_det.timeout = 0.1
@@ -126,11 +115,13 @@ def test_stage(mock_det, scaninfo, stopped, expected_exception):
                 )
                 assert mock_det.cam.num_frames.get() == 1
 
-                mock_publish_file_location.assert_called_with(done=False)
+                mock_publish_file_location.assert_called_once_with(
+                    done=False, successful=False, metadata={"input_path": path}
+                )
 
 
 def test_pre_scan(mock_det):
-    mock_det.custom_prepare.pre_scan()
+    mock_det.custom_prepare.on_pre_scan()
     assert mock_det.cam.acquire.get() == 1
 
 
@@ -168,23 +159,16 @@ def test_update_readout_time(mock_det, readout_time, expected_value):
                 "scan_id": "123",
             }
         ),
-        (
-            {
-                "filepath": "test.h5",
-                "filepath_raw": "test5_raw.h5",
-                "successful": None,
-                "done": True,
-                "scan_id": "123",
-            }
-        ),
     ],
 )
 def test_publish_file_location(mock_det, scaninfo):
     mock_det.scaninfo.scan_id = scaninfo["scan_id"]
-    mock_det.filepath = scaninfo["filepath"]
+    mock_det.filepath.set(scaninfo["filepath"]).wait()
     mock_det.filepath_raw = scaninfo["filepath_raw"]
     mock_det.custom_prepare.publish_file_location(
-        done=scaninfo["done"], successful=scaninfo["successful"]
+        done=scaninfo["done"],
+        successful=scaninfo["successful"],
+        metadata={"input_path": scaninfo["filepath_raw"]},
     )
     if scaninfo["successful"] is None:
         msg = messages.FileMessage(
@@ -402,23 +386,19 @@ def test_prep_file_writer(mock_det, scaninfo, data_msgs, urls, requests_state, e
                 assert call == mock_call
 
 
-@pytest.mark.parametrize("stopped, expected_exception", [(False, False), (True, True)])
-def test_unstage(mock_det, stopped, expected_exception):
+def test_complete(mock_det):
+    path = "tmp"
+    mock_det.filepath_raw = path
     with (
         mock.patch.object(mock_det.custom_prepare, "finished") as mock_finished,
         mock.patch.object(
             mock_det.custom_prepare, "publish_file_location"
         ) as mock_publish_file_location,
     ):
-        mock_det.stopped = stopped
-        if expected_exception:
-            mock_det.unstage()
-            assert mock_det.stopped is True
-        else:
-            mock_det.unstage()
-            mock_finished.assert_called_once()
-            mock_publish_file_location.assert_called_with(done=True, successful=True)
-            assert mock_det.stopped is False
+        mock_det.complete()
+        assert mock_finished.call_count == 1
+        call = mock.call(done=True, successful=True, metadata={"input_path": path})
+        assert mock_publish_file_location.call_args == call
 
 
 def test_stop(mock_det):

tests/tests_devices/test_rt_flomni.py

@@ -3,12 +3,13 @@ from unittest import mock
 import pytest
 from ophyd_devices.tests.utils import SocketMock
 
-from csaxs_bec.devices.rt_lamni import RtFlomniController, RtFlomniMotor
-from csaxs_bec.devices.rt_lamni.rt_ophyd import RtError
+from csaxs_bec.devices.omny.rt import RtFlomniController, RtFlomniMotor
+from csaxs_bec.devices.omny.rt.rt_ophyd import RtError
 
 
 @pytest.fixture()
 def rt_flomni():
+    RtFlomniController._reset_controller()
     rt_flomni = RtFlomniController(
         name="rt_flomni", socket_cls=SocketMock, socket_host="localhost", socket_port=8081
     )
@@ -16,14 +17,21 @@ def rt_flomni():
         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"
-            rt_flomni.set_axis(rtx, 0)
-            rt_flomni.set_axis(rty, 1)
-            rt_flomni.set_axis(rtz, 2)
+            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()
 
 
 def test_rt_flomni_move_to_zero(rt_flomni):

tests/tests_scans/test_lamni_fermat_scan.py

@@ -373,6 +373,7 @@ def test_LamNIFermatScan(scan_msg, reference_scan_list):
                 reference_scan_list[ii].content["parameter"]["rpc_id"] = scan_instructions[
                     ii
                 ].content["parameter"]["rpc_id"]
+                reference_scan_list[ii].metadata["RID"] = scan_instructions[ii].metadata.get("RID")
             if instr.content["parameter"].get("value"):
                 assert np.isclose(
                     instr.content["parameter"].get("value"),