fix: formatting

fix fests after update of trigger settings on IOC

.git_hooks/post-commit

@@ -0,0 +1,3 @@
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+semantic-release changelog -D version_variable=$SCRIPT_DIR/../../semantic_release/__init__.py:__version__
+semantic-release version -D version_variable=$SCRIPT_DIR/../../semantic_release/__init__.py:__version__

.git_hooks/pre-commit

@@ -0,0 +1,3 @@
+black --line-length=100 $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+isort --line-length=100 --profile=black --multi-line=3 --trailing-comma $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+git add $(git diff --cached --name-only --diff-filter=ACM -- '*.py')

.gitignore

@@ -8,6 +8,9 @@
 **/.pytest_cache
 **/*.egg*
 
+# recovery_config files
+recovery_config_*
+
 # file writer data
 **.h5
 

.gitlab-ci.yml

@@ -1,40 +1,7 @@
-# This file is a template, and might need editing before it works on your project.
-# Official language image. Look for the different tagged releases at:
-# https://hub.docker.com/r/library/python/tags/
-image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
-
-#commands to run in the Docker container before starting each job.
-before_script:
-  - pip install -e .[dev]
-
-# different stages in the pipeline
-stages:
-  - Formatter
-  - Test
-  - AdditionalTests
-  - Deploy
-
-formatter:
-  stage: Formatter
-  script:
-    - pip install black
-    - black --check --diff --color --line-length=100 ./
-
-pytest:
-  stage: Test
-  script:
-    - pytest -v --random-order ./tests
-
-tests-3.11:
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
-  needs: ["pytest"]
-  script:
-    - pytest -v --random-order ./tests
-  allow_failure: true
-
-tests-3.12:
-  extends: "tests-3.11"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
-  allow_failure: true
+include:
+  - project: bec/awi_utils
+    file: /templates/plugin-repo-template.yml
+    inputs:
+      name: "debye"
+      target: "debye_bec"
+      branch: $CHILD_PIPELINE_BRANCH

LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Paul Scherrer Institute
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,3 +1,65 @@
 # Debye BEC
 
-Debye-specific plugins and configs for BEC
+Debye-specific plugins and configs for BEC
+
+## How to
+
+### Visual studio code
+To open
+```
+ssh x01da-bec-001
+cd /data/test/x01da-test-bec/bec_deployment
+code
+```
+To run tests directly in vs code terminal
+```
+. /data/test/x01da-test-bec/bec_deployment/bec_venv/bin/activate
+cd /data/test/x01da-test-bec/bec_deployment/debye_bec
+pytest -vv ./tests
+```
+### Git
+```
+git pull
+git push origin feat/add_advanced_scan_modes
+git status
+```
+If git claims to not know the author identity
+```
+git config --global user.email "you@example.com"
+git config --global user.name "gac-x01da"
+```
+
+### BEC Server
+```
+ssh x01da-bec-001
+cd /data/test/x01da-test-bec/bec_deployment
+. /data/test/x01da-test-bec/bec_deployment/bec_venv/bin/activate
+
+bec-server start
+bec-server restart
+bec-server stop
+bec-server attach
+```
+
+To restart individual server modules:
+- ctrl-c + ctrl-c to stop for example scan server or device server module
+- restart server module(s)
+
+### BEC Client
+```
+ssh x01da-bec-001
+cd /data/test/x01da-test-bec/bec_deployment
+bec
+```
+
+#### Useful commands in bec
+Update Session with specific config:
+```
+bec.config.update_session_with_file("debye_bec/debye_bec/device_configs/x01da_test_config.yaml")
+```
+
+Define folder and sample name for written files:
+```
+bec.system_config.file_directory="test"
+bec.system_config.file_suffix ="sampleA"
+```

bec_plugins/__init__.py

@@ -1 +0,0 @@
-from .bec_client import *

bec_plugins/bec_client/__init__.py

@@ -1 +0,0 @@
-from .plugins import *

bec_plugins/bec_client/hli/spec_hli.py

@@ -1,245 +0,0 @@
-from bec_lib.devicemanager import Device
-from bec_lib.scan_report import ScanReport
-
-# pylint:disable=undefined-variable
-# pylint: disable=too-many-arguments
-
-
-def dscan(
-    motor1: Device, m1_from: float, m1_to: float, steps: int, exp_time: float, **kwargs
-) -> ScanReport:
-    """Relative line scan with one device.
-
-    Args:
-        motor1 (Device): Device that should be scanned.
-        m1_from (float): Start position relative to the current position.
-        m1_to (float): End position relative to the current position.
-        steps (int): Number of steps.
-        exp_time (float): Exposure time.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> dscan(dev.motor1, -5, 5, 10, 0.1)
-    """
-    return scans.line_scan(
-        motor1, m1_from, m1_to, steps=steps, exp_time=exp_time, relative=True, **kwargs
-    )
-
-
-def d2scan(
-    motor1: Device,
-    m1_from: float,
-    m1_to: float,
-    motor2: Device,
-    m2_from: float,
-    m2_to: float,
-    steps: int,
-    exp_time: float,
-    **kwargs
-) -> ScanReport:
-    """Relative line scan with two devices.
-
-    Args:
-        motor1 (Device): First device that should be scanned.
-        m1_from (float): Start position of the first device relative to its current position.
-        m1_to (float): End position of the first device relative to its current position.
-        motor2 (Device): Second device that should be scanned.
-        m2_from (float): Start position of the second device relative to its current position.
-        m2_to (float): End position of the second device relative to its current position.
-        steps (int): Number of steps.
-        exp_time (float): Exposure time
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> d2scan(dev.motor1, -5, 5, dev.motor2, -8, 8, 10, 0.1)
-    """
-    return scans.line_scan(
-        motor1,
-        m1_from,
-        m1_to,
-        motor2,
-        m2_from,
-        m2_to,
-        steps=steps,
-        exp_time=exp_time,
-        relative=True,
-        **kwargs
-    )
-
-
-def ascan(motor1, m1_from, m1_to, steps, exp_time, **kwargs):
-    """Absolute line scan with one device.
-
-    Args:
-        motor1 (Device): Device that should be scanned.
-        m1_from (float): Start position.
-        m1_to (float): End position.
-        steps (int): Number of steps.
-        exp_time (float): Exposure time.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> ascan(dev.motor1, -5, 5, 10, 0.1)
-    """
-    return scans.line_scan(
-        motor1, m1_from, m1_to, steps=steps, exp_time=exp_time, relative=False, **kwargs
-    )
-
-
-def a2scan(motor1, m1_from, m1_to, motor2, m2_from, m2_to, steps, exp_time, **kwargs):
-    """Absolute line scan with two devices.
-
-    Args:
-        motor1 (Device): First device that should be scanned.
-        m1_from (float): Start position of the first device.
-        m1_to (float): End position of the first device.
-        motor2 (Device): Second device that should be scanned.
-        m2_from (float): Start position of the second device.
-        m2_to (float): End position of the second device.
-        steps (int): Number of steps.
-        exp_time (float): Exposure time
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> a2scan(dev.motor1, -5, 5, dev.motor2, -8, 8, 10, 0.1)
-    """
-    return scans.line_scan(
-        motor1,
-        m1_from,
-        m1_to,
-        motor2,
-        m2_from,
-        m2_to,
-        steps=steps,
-        exp_time=exp_time,
-        relative=False,
-        **kwargs
-    )
-
-
-def dmesh(motor1, m1_from, m1_to, m1_steps, motor2, m2_from, m2_to, m2_steps, exp_time, **kwargs):
-    """Relative mesh scan (grid scan) with two devices.
-
-    Args:
-        motor1 (Device): First device that should be scanned.
-        m1_from (float): Start position of the first device relative to its current position.
-        m1_to (float): End position of the first device relative to its current position.
-        m1_steps (int): Number of steps for motor1.
-        motor2 (Device): Second device that should be scanned.
-        m2_from (float): Start position of the second device relative to its current position.
-        m2_to (float): End position of the second device relative to its current position.
-        m2_steps (int): Number of steps for motor2.
-        exp_time (float): Exposure time
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> dmesh(dev.motor1, -5, 5, 10, dev.motor2, -8, 8, 10, 0.1)
-    """
-    return scans.grid_scan(
-        motor1,
-        m1_from,
-        m1_to,
-        m1_steps,
-        motor2,
-        m2_from,
-        m2_to,
-        m2_steps,
-        exp_time=exp_time,
-        relative=True,
-    )
-
-
-def amesh(motor1, m1_from, m1_to, m1_steps, motor2, m2_from, m2_to, m2_steps, exp_time, **kwargs):
-    """Absolute mesh scan (grid scan) with two devices.
-
-    Args:
-        motor1 (Device): First device that should be scanned.
-        m1_from (float): Start position of the first device.
-        m1_to (float): End position of the first device.
-        m1_steps (int): Number of steps for motor1.
-        motor2 (Device): Second device that should be scanned.
-        m2_from (float): Start position of the second device.
-        m2_to (float): End position of the second device.
-        m2_steps (int): Number of steps for motor2.
-        exp_time (float): Exposure time
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> amesh(dev.motor1, -5, 5, 10, dev.motor2, -8, 8, 10, 0.1)
-    """
-    return scans.grid_scan(
-        motor1,
-        m1_from,
-        m1_to,
-        m1_steps,
-        motor2,
-        m2_from,
-        m2_to,
-        m2_steps,
-        exp_time=exp_time,
-        relative=False,
-    )
-
-
-def umv(*args) -> ScanReport:
-    """Updated absolute move (i.e. blocking) for one or more devices.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> umv(dev.samx, 1)
-        >>> umv(dev.samx, 1, dev.samy, 2)
-    """
-    return scans.umv(*args, relative=False)
-
-
-def umvr(*args) -> ScanReport:
-    """Updated relative move (i.e. blocking) for one or more devices.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> umvr(dev.samx, 1)
-        >>> umvr(dev.samx, 1, dev.samy, 2)
-    """
-    return scans.umv(*args, relative=True)
-
-
-def mv(*args) -> ScanReport:
-    """Absolute move for one or more devices.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> mv(dev.samx, 1)
-        >>> mv(dev.samx, 1, dev.samy, 2)
-    """
-    return scans.mv(*args, relative=False)
-
-
-def mvr(*args) -> ScanReport:
-    """Relative move for one or more devices.
-
-    Returns:
-        ScanReport: Status object.
-
-    Examples:
-        >>> mvr(dev.samx, 1)
-        >>> mvr(dev.samx, 1, dev.samy, 2)
-    """
-    return scans.mv(*args, relative=True)

bec_plugins/bec_client/plugins/__init__.py

@@ -1 +0,0 @@
-

bec_plugins/bec_client/startup/post_startup.py

@@ -1,46 +0,0 @@
-"""
-Post startup script for the BEC client. This script is executed after the
-IPython shell is started. It is used to load the beamline specific
-information and to setup the prompts.
-
-The script is executed in the global namespace of the IPython shell. This
-means that all variables defined here are available in the shell.
-
-If needed, bec command-line arguments can be parsed here. For example, to
-parse the --session argument, add the following lines to the script:
-
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--session", help="Session name", type=str, default="my_default_session")
-    args = parser.parse_args()
-
-    if args.session == "my_session":
-        print("Loading my_session session")
-        from bec_plugins.bec_client.plugins.my_session import *
-    else:
-        print("Loading default session")
-        from bec_plugins.bec_client.plugins.default_session import *
-"""
-
-# pylint: disable=invalid-name, unused-import, import-error, undefined-variable, unused-variable, unused-argument, no-name-in-module
-import argparse
-
-from bec_lib import bec_logger
-
-logger = bec_logger.logger
-
-logger.info("Using the Debye startup script.")
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--session", help="Session name", type=str, default="Debye")
-args = parser.parse_args()
-
-# SETUP BEAMLINE INFO
-from bec_client.plugins.SLS.sls_info import OperatorInfo, SLSInfo
-
-bec._beamline_mixin._bl_info_register(SLSInfo)
-bec._beamline_mixin._bl_info_register(OperatorInfo)
-
-# SETUP PROMPTS
-bec._ip.prompts.username = "Debye"
-bec._ip.prompts.status = 1

bec_plugins/bec_client/startup/pre_startup.py

@@ -1,25 +0,0 @@
-"""
-Pre-startup script for BEC client. This script is executed before the BEC client
-is started. It can be used to set up the BEC client configuration. The script is
-executed in the global namespace of the BEC client. This means that all
-variables defined here are available in the BEC client.
-
-To set up the BEC client configuration, use the ServiceConfig class. For example,
-to set the configuration file path, add the following lines to the script:
-
-    import pathlib
-    from bec_lib import ServiceConfig
-
-    current_path = pathlib.Path(__file__).parent.resolve()
-    CONFIG_PATH = f"{current_path}/<path_to_my_config_file.yaml>"
-
-    config = ServiceConfig(CONFIG_PATH)
-
-If this startup script defined a ServiceConfig object, the BEC client will use
-it to configure itself. Otherwise, the BEC client will use the default config.
-"""
-
-# example:
-# current_path = pathlib.Path(__file__).parent.resolve()
-# CONFIG_PATH = f"{current_path}/../../../bec_config.yaml"
-# config = ServiceConfig(CONFIG_PATH)

debye_bec/bec_ipython_client/startup/post_startup.py

@@ -0,0 +1,36 @@
+"""
+Post startup script for the BEC client. This script is executed after the
+IPython shell is started. It is used to load the beamline specific
+information and to setup the prompts.
+
+The script is executed in the global namespace of the IPython shell. This
+means that all variables defined here are available in the shell.
+
+While command-line arguments have to be set in the pre-startup script, the
+post-startup script can be used to load beamline specific information and
+to setup the prompts.
+
+    from bec_lib import bec_logger
+
+    logger = bec_logger.logger
+
+    # pylint: disable=import-error
+    _args = _main_dict["args"]
+
+    _session_name = "cSAXS"
+    if _args.session.lower() == "lamni":
+        from csaxs_bec.bec_ipython_client.plugins.cSAXS import *
+        from csaxs_bec.bec_ipython_client.plugins.LamNI import *
+
+        _session_name = "LamNI"
+        lamni = LamNI(bec)
+        logger.success("LamNI session loaded.")
+
+    elif _args.session.lower() == "csaxs":
+        print("Loading cSAXS session")
+        from csaxs_bec.bec_ipython_client.plugins.cSAXS import *
+
+        logger.success("cSAXS session loaded.")
+"""
+
+# pylint: disable=invalid-name, unused-import, import-error, undefined-variable, unused-variable, unused-argument, no-name-in-module

debye_bec/bec_ipython_client/startup/pre_startup.py

@@ -0,0 +1,23 @@
+"""
+Pre-startup script for BEC client. This script is executed before the BEC client
+is started. It can be used to add additional command line arguments. 
+"""
+
+from bec_lib.service_config import ServiceConfig
+
+
+def extend_command_line_args(parser):
+    """
+    Extend the command line arguments of the BEC client.
+    """
+
+    # parser.add_argument("--session", help="Session name", type=str, default="cSAXS")
+
+    return parser
+
+
+def get_config() -> ServiceConfig:
+    """
+    Create and return the service configuration.
+    """
+    return ServiceConfig(redis={"host": "x01da-bec-001", "port": 6379})

debye_bec/deployments/device_server/startup.py

@@ -0,0 +1,11 @@
+import os
+
+
+def setup_epics_ca():
+    # os.environ["EPICS_CA_AUTO_ADDR_LIST"] = "NO"
+    # os.environ["EPICS_CA_ADDR_LIST"] = "129.129.122.255 sls-x12sa-cagw.psi.ch:5836"
+    os.environ["PYTHONIOENCODING"] = "latin1"
+
+
+def run():
+    setup_epics_ca()

debye_bec/device_configs/x01da_database.yaml

@@ -0,0 +1,875 @@
+###################
+#### FRONT END ####
+###################
+
+## Slit Diaphragm -- Physical positioners
+sldi_trxr:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm X-translation Ring-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:TRXR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_trxw:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm X-translation Wall-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:TRXW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_tryb:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm Y-translation Bottom-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:TRYB
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_tryt:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm X-translation Top-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:TRYT
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Slit Diaphragm -- Virtual positioners
+
+sldi_centerx:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm X-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:CENTERX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_gapx:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm X-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:GAPX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_centery:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm Y-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:CENTERY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sldi_gapy:
+  readoutPriority: baseline
+  description: Front-end slit diaphragm Y-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-SLDI:GAPY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Collimating Mirror -- Physical Positioners
+
+cm_trxu:
+  readoutPriority: baseline
+  description: Collimating Mirror X-translation upstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:TRXU
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_trxd:
+  readoutPriority: baseline
+  description: Collimating Mirror X-translation downstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:TRXD
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_tryu:
+  readoutPriority: baseline
+  description: Collimating Mirror Y-translation upstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:TRYU
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_trydr:
+  readoutPriority: baseline
+  description: Collimating Mirror Y-translation downstream ring
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:TRYDR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_trydw:
+  readoutPriority: baseline
+  description: Collimating Mirror Y-translation downstream wall
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:TRYDW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_bnd:
+  readoutPriority: baseline
+  description: Collimating Mirror bender
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:BND
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Collimating Mirror -- Virtual Positioners
+
+cm_rotx:
+  readoutPriority: baseline
+  description: Collimating Morror Pitch
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:ROTX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_roty:
+  readoutPriority: baseline
+  description: Collimating Morror Yaw
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_rotz:
+  readoutPriority: baseline
+  description: Collimating Morror Roll
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:ROTZ
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_xctp:
+  readoutPriority: baseline
+  description: Collimating Morror Center Point X
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:XTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_ytcp:
+  readoutPriority: baseline
+  description: Collimating Morror Center Point Y
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:YTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_ztcp:
+  readoutPriority: baseline
+  description: Collimating Morror Center Point Z
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:ZTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+cm_xstripe:
+  readoutPriority: baseline
+  description: Collimating Morror X Stripe
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-FE-CM:XSTRIPE
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+###################
+###### OPTICS #####
+###################
+
+## Bragg Monochromator
+mo1_bragg:
+  readoutPriority: baseline
+  description: Positioner for the Monochromator
+  deviceClass: debye_bec.devices.mo1_bragg.mo1.bragg.Mo1Bragg
+  deviceConfig:
+    prefix: "X01DA-OP-MO1:BRAGG:"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Monochromator -- Physical Positioners
+
+mo_try:
+  readoutPriority: baseline
+  description: Monochromator Y Translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-MO1:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+mo_trx:
+  readoutPriority: baseline
+  description: Monochromator X Translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-MO1:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+mo_roty:
+  readoutPriority: baseline
+  description: Monochromator Yaw
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-MO1:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Focusing Mirror -- Physical Positioners
+
+fm_trxu:
+  readoutPriority: baseline
+  description: Focusing Mirror X-translation upstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:TRXU
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_trxd:
+  readoutPriority: baseline
+  description: Focusing Mirror X-translation downstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:TRXD
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_tryd:
+  readoutPriority: baseline
+  description: Focusing Mirror Y-translation downstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:TRYD
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_tryur:
+  readoutPriority: baseline
+  description: Focusing Mirror Y-translation upstream ring
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:TRYUR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_tryuw:
+  readoutPriority: baseline
+  description: Focusing Mirror Y-translation upstream wall
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:TRYUW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_bnd:
+  readoutPriority: baseline
+  description: Focusing Mirror bender
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:BND
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Focusing Mirror -- Virtual Positioners
+
+fm_rotx:
+  readoutPriority: baseline
+  description: Focusing Morror Pitch
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:ROTX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_roty:
+  readoutPriority: baseline
+  description: Focusing Morror Yaw
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_rotz:
+  readoutPriority: baseline
+  description: Focusing Morror Roll
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:ROTZ
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_xctp:
+  readoutPriority: baseline
+  description: Focusing Morror Center Point X
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:XTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_ytcp:
+  readoutPriority: baseline
+  description: Focusing Morror Center Point Y
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:YTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+fm_ztcp:
+  readoutPriority: baseline
+  description: Focusing Morror Center Point Z
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-FM:ZTCP
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+# fm_xstripe:
+#   readoutPriority: baseline
+#   description: Focusing Morror X Stripe
+#   deviceClass: ophyd.EpicsMotor
+#   deviceConfig:
+#     prefix: X01DA-OP-FM:XSTRIPE
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+## Optics Slits 1 -- Physical positioners
+
+sl1_trxr:
+  readoutPriority: baseline
+  description: Optics slits 1 X-translation Ring-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:TRXR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_trxw:
+  readoutPriority: baseline
+  description: Optics slits 1 X-translation Wall-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:TRXW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_tryb:
+  readoutPriority: baseline
+  description: Optics slits 1 Y-translation Bottom-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:TRYB
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_tryt:
+  readoutPriority: baseline
+  description: Optics slits 1 X-translation Top-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:TRYT
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+bm1_try:
+  readoutPriority: baseline
+  description: Beam Monitor 1 Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-BM1:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Optics Slits 1 -- Virtual positioners
+
+sl1_centerx:
+  readoutPriority: baseline
+  description: Optics slits 1 X-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:CENTERX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_gapx:
+  readoutPriority: baseline
+  description: Optics slits 1 X-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:GAPX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_centery:
+  readoutPriority: baseline
+  description: Optics slits 1 Y-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:CENTERY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl1_gapy:
+  readoutPriority: baseline
+  description: Optics slits 1 Y-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL1:GAPY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Optics Slits 2 -- Physical positioners
+
+sl2_trxr:
+  readoutPriority: baseline
+  description: Optics slits 2 X-translation Ring-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:TRXR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_trxw:
+  readoutPriority: baseline
+  description: Optics slits 2 X-translation Wall-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:TRXW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_tryb:
+  readoutPriority: baseline
+  description: Optics slits 2 Y-translation Bottom-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:TRYB
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_tryt:
+  readoutPriority: baseline
+  description: Optics slits 2 X-translation Top-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:TRYT
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+bm2_try:
+  readoutPriority: baseline
+  description: Beam Monitor 2 Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-BM2:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+## Optics Slits 2 -- Virtual positioners
+
+sl2_centerx:
+  readoutPriority: baseline
+  description: Optics slits 2 X-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:CENTERX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_gapx:
+  readoutPriority: baseline
+  description: Optics slits 2 X-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:GAPX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_centery:
+  readoutPriority: baseline
+  description: Optics slits 2 Y-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:CENTERY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+sl2_gapy:
+  readoutPriority: baseline
+  description: Optics slits 2 Y-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-OP-SL2:GAPY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+  
+###############################
+###### EXPERIMENTAL HUTCH #####
+###############################
+
+###########################################
+## Optical Table -- Physical Positioners ##
+###########################################
+
+ot_tryu:
+  readoutPriority: baseline
+  description: Optical Table Y-Translation Upstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES-OT:TRYU
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+ot_tryd:
+  readoutPriority: baseline
+  description: Optical Table Y-Translation Downstream
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES-OT:TRYD
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+############################################
+## Optical Table -- Virtual Positioners ###
+############################################
+
+ot_try:
+  readoutPriority: baseline
+  description: Optical Table Y-Translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES-OT:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+ot_pitch:
+  readoutPriority: baseline
+  description: Optical Table Pitch
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES-OT:ROTX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#########################################
+## Exit Window -- Physical Positioners ##
+#########################################
+
+es0wi_try:
+  readoutPriority: baseline
+  description: End Station 0 Exit Window Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-WI:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+###############################################
+## End Station Slits -- Physical Positioners ##
+###############################################
+
+es0sl_trxr:
+  readoutPriority: baseline
+  description: End Station slits X-translation Ring-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:TRXR
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_trxw:
+  readoutPriority: baseline
+  description: End Station slits X-translation Wall-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:TRXW
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_tryb:
+  readoutPriority: baseline
+  description: End Station slits Y-translation Bottom-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:TRYB
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_tryt:
+  readoutPriority: baseline
+  description: End Station slits X-translation Top-edge
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:TRYT
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+##############################################
+## End Station Slits -- Virtual positioners ##
+##############################################
+
+es0sl_center:
+  readoutPriority: baseline
+  description: End Station slits X-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:CENTERX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_gapx:
+  readoutPriority: baseline
+  description: End Station slits X-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:GAPX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_centery:
+  readoutPriority: baseline
+  description: End Station slits Y-center
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:CENTERY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es0sl_gapy:
+  readoutPriority: baseline
+  description: End Station slits Y-gap
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES0-SL:GAPY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#########################################################
+## Pinhole and alignment laser -- Physical Positioners ##
+#########################################################
+
+es1pin_try:
+  readoutPriority: baseline
+  description: End Station pinhole and alignment laser Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-PIN1:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1pin_trx:
+  readoutPriority: baseline
+  description: End Station pinhole and alignment laser X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-PIN1:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1pin_rotx:
+  readoutPriority: baseline
+  description: End Station pinhole and alignment laser X-rotation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-PIN1:ROTX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1pin_roty:
+  readoutPriority: baseline
+  description: End Station pinhole and alignment laser Y-rotation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-PIN1:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+
+################################################
+## Sample Manipulator -- Physical Positioners ##
+################################################
+
+es1man_trx:
+  readoutPriority: baseline
+  description: End Station sample manipulator X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-MAN1:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1man_try:
+  readoutPriority: baseline
+  description: End Station sample manipulator Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-MAN1:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1man_trz:
+  readoutPriority: baseline
+  description: End Station sample manipulator Z-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-MAN1:TRZ
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1man_roty:
+  readoutPriority: baseline
+  description: End Station sample manipulator Y-rotation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-MAN1:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+############################################
+## Segemented Arc -- Physical Positioners ##
+############################################
+
+es1arc_roty:
+  readoutPriority: baseline
+  description: End Station segmented arc Y-rotation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-ARC:ROTY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1det1_trx:
+  readoutPriority: baseline
+  description: End Station SDD 1 X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-DET1:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1bm1_trx:
+  readoutPriority: baseline
+  description: End Station X-ray Eye X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-BM1:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es1det2_trx:
+  readoutPriority: baseline
+  description: End Station SDD 2 X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES1-DET2:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#######################################
+## Beam Stop -- Physical Positioners ##
+#######################################
+
+es2bs_trx:
+  readoutPriority: baseline
+  description: End Station beamstop X-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES2-BS:TRX
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es2bs_try:
+  readoutPriority: baseline
+  description: End Station beamstop Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES2-BS:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+##############################################
+## IC12 Manipulator -- Physical Positioners ##
+##############################################
+
+es2ma2_try:
+  readoutPriority: baseline
+  description: End Station ionization chamber 1+2 Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES2-MA2:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+es2ma2_trz:
+  readoutPriority: baseline
+  description: End Station ionization chamber 1+2 Z-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES2-MA2:TRZ
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#######################################################
+## XRD Detector  Manipulator -- Physical Positioners ##
+#######################################################
+
+es2ma3_try:
+  readoutPriority: baseline
+  description: End Station XRD detector Y-translation
+  deviceClass: ophyd.EpicsMotor
+  deviceConfig:
+    prefix: X01DA-ES2-MA3:TRY
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false

debye_bec/device_configs/x01da_test_config.yaml

@@ -0,0 +1,230 @@
+## Bragg Monochromator
+mo1_bragg:
+  readoutPriority: baseline
+  description: Positioner for the Monochromator
+  deviceClass: debye_bec.devices.mo1_bragg.mo1_bragg.Mo1Bragg
+  deviceConfig:
+    prefix: "X01DA-OP-MO1:BRAGG:"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+dummy_pv:
+  readoutPriority: monitored
+  description: Heartbeat of Bragg
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-OP-MO1:BRAGG:heartbeat_RBV"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+# NIDAQ
+nidaq:
+  readoutPriority: monitored
+  description: NIDAQ backend for data reading for debye scans
+  deviceClass: debye_bec.devices.nidaq.nidaq.Nidaq
+  deviceConfig:
+    prefix: "X01DA-PC-SCANSERVER:"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+# Ionization Chambers
+
+# ic0:
+#   readoutPriority: baseline
+#   description: Ionization chamber 0
+#   deviceClass: debye_bec.devices.ionization_chambers.ionization_chamber.IonizationChamber0
+#   deviceConfig:
+#     prefix: "X01DA-"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+# ic1:
+#   readoutPriority: baseline
+#   description: Ionization chamber 1
+#   deviceClass: debye_bec.devices.ionization_chambers.ionization_chamber.IonizationChamber1
+#   deviceConfig:
+#     prefix: "X01DA-"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+# ic2:
+#   readoutPriority: baseline
+#   description: Ionization chamber 2
+#   deviceClass: debye_bec.devices.ionization_chambers.ionization_chamber.IonizationChamber2
+#   deviceConfig:
+#     prefix: "X01DA-"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+# ES0 Filter
+
+es0filter:
+  readoutPriority: baseline
+  description: ES0 filter station
+  deviceClass: debye_bec.devices.es0filter.ES0Filter
+  deviceConfig:
+    prefix: "X01DA-ES0-FI:"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+# Beam Monitors
+
+# beam_monitor_1:
+#   readoutPriority: async
+#   description: Beam monitor 1
+#   deviceClass: debye_bec.devices.cameras.prosilica_cam.ProsilicaCam
+#   deviceConfig:
+#     prefix: "X01DA-OP-GIGE01:"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+# beam_monitor_2:
+#   readoutPriority: async
+#   description: Beam monitor 2
+#   deviceClass: debye_bec.devices.cameras.prosilica_cam.ProsilicaCam
+#   deviceConfig:
+#     prefix: "X01DA-OP-GIGE02:"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+# xray_eye:
+#   readoutPriority: async
+#   description: X-ray eye
+#   deviceClass: debye_bec.devices.cameras.basler_cam.BaslerCam
+#   deviceConfig:
+#     prefix: "X01DA-ES-XRAYEYE:"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+# Pilatus Curtain
+# pilatus_curtain:
+#   readoutPriority: baseline
+#   description: Pilatus Curtain
+#   deviceClass: debye_bec.devices.pilatus_curtain.PilatusCurtain
+#   deviceConfig:
+#     prefix: "X01DA-ES2-DET3:TRY-"
+#   onFailure: retry
+#   enabled: true
+#   softwareTrigger: false
+
+
+################################
+## ES Hutch Sensors and Light ##
+################################
+
+es_temperature1:
+  readoutPriority: baseline
+  description: ES temperature sensor 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH1:TEMP"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_humidity1:
+  readoutPriority: baseline
+  description: ES humidity sensor 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH1:HUMIREL"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_pressure1:
+  readoutPriority: baseline
+  description: ES ambient pressure sensor 1
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH1:PRES"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_temperature2:
+  readoutPriority: baseline
+  description: ES temperature sensor 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH2:TEMP"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_humidity2:
+  readoutPriority: baseline
+  description: ES humidity sensor 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH2:HUMIREL"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_pressure2:
+  readoutPriority: baseline
+  description: ES ambient pressure sensor 2
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-PC-I2C:_CH2:PRES"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+es_light_toggle:
+  readoutPriority: baseline
+  description: ES light toggle
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    read_pv: "X01DA-EH-LIGHT:TOGGLE"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#################
+## SDD sensors ##
+#################
+
+sdd1_temperature:
+  readoutPriority: baseline
+  description: SDD1 temperature sensor
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-ES1-DET1:Temperature"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+sdd1_humidity:
+  readoutPriority: baseline
+  description: SDD1 humidity sensor
+  deviceClass: ophyd.EpicsSignalRO
+  deviceConfig:
+    read_pv: "X01DA-ES1-DET1:Humidity"
+    kind: "config"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+
+#####################
+## Alignment Laser ##
+#####################
+
+es1_alignment_laser:
+  readoutPriority: baseline
+  description: ES1 alignment laser
+  deviceClass: ophyd.EpicsSignal
+  deviceConfig:
+    read_pv: "X01DA-ES1-LAS:Relay"
+  onFailure: retry
+  enabled: true
+  softwareTrigger: false
+  

debye_bec/devices/cameras/basler_cam.py

@@ -0,0 +1,29 @@
+# from ophyd_devices.sim.sim_signals import SetableSignal
+# from ophyd_devices.utils.psi_component import PSIComponent, SignalType
+import numpy as np
+from ophyd import ADBase
+from ophyd import ADComponent as ADCpt
+from ophyd import Kind
+from ophyd_devices.devices.areadetector.cam import AravisDetectorCam
+from ophyd_devices.devices.areadetector.plugins import ImagePlugin_V35
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+
+
+class BaslerCamBase(ADBase):
+    cam1 = ADCpt(AravisDetectorCam, "cam1:")
+    image1 = ADCpt(ImagePlugin_V35, "image1:")
+
+
+class BaslerCam(PSIDeviceBase, BaslerCamBase):
+
+    # preview_2d = PSIComponent(SetableSignal, signal_type=SignalType.PREVIEW, ndim=2, kind=Kind.omitted)
+
+    def emit_to_bec(self, *args, obj=None, old_value=None, value=None, **kwargs):
+        width = self.image1.array_size.width.get()
+        height = self.image1.array_size.height.get()
+        data = np.reshape(value, (height, width))
+        # self.preview_2d.put(data)
+        self._run_subs(sub_type=self.SUB_DEVICE_MONITOR_2D, value=data)
+
+    def on_connected(self):
+        self.image1.array_data.subscribe(self.emit_to_bec, run=False)

debye_bec/devices/cameras/prosilica_cam.py

@@ -0,0 +1,25 @@
+import numpy as np
+from ophyd import ADBase
+from ophyd import ADComponent as ADCpt
+from ophyd import Component as Cpt
+from ophyd import Device
+from ophyd_devices.devices.areadetector.cam import ProsilicaDetectorCam
+from ophyd_devices.devices.areadetector.plugins import ImagePlugin_V35
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+
+
+class ProsilicaCamBase(ADBase):
+    cam1 = ADCpt(ProsilicaDetectorCam, "cam1:")
+    image1 = ADCpt(ImagePlugin_V35, "image1:")
+
+
+class ProsilicaCam(PSIDeviceBase, ProsilicaCamBase):
+
+    def emit_to_bec(self, *args, obj=None, old_value=None, value=None, **kwargs):
+        width = self.image1.array_size.width.get()
+        height = self.image1.array_size.height.get()
+        data = np.reshape(value, (height, width))
+        self._run_subs(sub_type=self.SUB_DEVICE_MONITOR_2D, value=data)
+
+    def on_connected(self):
+        self.image1.array_data.subscribe(self.emit_to_bec, run=False)

debye_bec/devices/device_list.md

@@ -0,0 +1,17 @@
+// This file was autogenerated. Do not edit it manually.
+## Device List
+### debye_bec 
+| Device | Documentation | Module |
+| :----- | :------------- | :------ |
+| Amplifiers | Class for the ES HV power supplies | [debye_bec.devices.hv_supplies](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/hv_supplies.py) |
+| ES0Filter | Class for the ES0 filter station | [debye_bec.devices.es0filter](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/es0filter.py) |
+| GasMixSetup | Class for the ES2 Pilatus Curtain | [debye_bec.devices.pilatus_curtain](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/pilatus_curtain.py) |
+| Mo1Bragg | Class for the Mo1 Bragg positioner of the Debye beamline.<br>    The prefix to connect to the soft IOC is X01DA-OP-MO1:BRAGG: which is connected to<br>    the NI motor controller via web sockets.<br>     | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggCalculator | Mo1 Bragg PVs to convert angle to energy or vice-versa. | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggCrystal | Mo1 Bragg PVs to set the crystal parameters | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggEncoder | Mo1 Bragg PVs to communicate with the encoder | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggScanControl | Mo1 Bragg PVs to control the scan after setting the parameters. | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggScanSettings | Mo1 Bragg PVs to set the scan setttings | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1BraggStatus | Mo1 Bragg PVs for status monitoring | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| Mo1TriggerSettings | Mo1 Trigger settings | [debye_bec.devices.mo1_bragg](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/mo1_bragg.py) |
+| NIDAQ |  NIDAQ ophyd wrapper around the NIDAQ backend currently running at x01da-cons-05<br>    <br>    Args:<br>        prefix (str)    : Prefix to the NIDAQ soft ioc, currently X01DA-PC-SCANSERVER:<br>        name (str)      : Name of the device<br>        kind (Kind)     : Ophyd Kind of the device<br>        parent (Device) : Parent clas<br>        device_manager  : device manager as forwarded by BEC<br>     | [debye_bec.devices.nidaq](https://gitlab.psi.ch/bec/debye_bec/-/blob/main/debye_bec/devices/nidaq.py) |

debye_bec/devices/es0filter.py

@@ -0,0 +1,54 @@
+"""ES0 Filter Station"""
+
+from typing import Literal
+
+from ophyd import Component as Cpt
+from ophyd import Device, EpicsSignal, Kind
+from ophyd_devices.utils import bec_utils
+from typeguard import typechecked
+
+
+class EpicsSignalWithRBVBit(EpicsSignal):
+
+    def __init__(self, prefix, *, bit: int, **kwargs):
+        super().__init__(prefix, **kwargs)
+        self.bit = bit
+
+    @typechecked
+    def put(self, value: Literal[0, 1], **kwargs):
+        bit_value = super().get()
+        # convert to int
+        bit_value = int(bit_value)
+        if value == 1:
+            new_value = bit_value | (1 << self.bit)
+        else:
+            new_value = bit_value & ~(1 << self.bit)
+        super().put(new_value, **kwargs)
+
+    def get(self, **kwargs) -> Literal[0, 1]:
+        bit_value = super().get()
+        # convert to int
+        bit_value = int(bit_value)
+        if (bit_value & (1 << self.bit)) == 0:
+            return 0
+        return 1
+
+
+class ES0Filter(Device):
+    """Class for the ES0 filter station X01DA-ES0-FI:"""
+
+    Mo400 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=1, kind="config", doc="Mo400 filter")
+    Mo300 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=2, kind="config", doc="Mo300 filter")
+    Mo200 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=3, kind="config", doc="Mo200 filter")
+    Zn500 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=4, kind="config", doc="Zn500 filter")
+    Zn250 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=5, kind="config", doc="Zn250 filter")
+    Zn125 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=6, kind="config", doc="Zn125 filter")
+    Zn50 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=7, kind="config", doc="Zn50 filter")
+    Zn25 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=8, kind="config", doc="Zn25 filter")
+    Al500 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=9, kind="config", doc="Al500 filter")
+    Al320 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=10, kind="config", doc="Al320 filter")
+    Al200 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=11, kind="config", doc="Al200 filter")
+    Al100 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=12, kind="config", doc="Al100 filter")
+    Al50 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=13, kind="config", doc="Al50 filter")
+    Al20 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=14, kind="config", doc="Al20 filter")
+    Al10 = Cpt(EpicsSignalWithRBVBit, suffix="BIO", bit=15, kind="config", doc="Al10 filter")

debye_bec/devices/ionization_chambers/ionization_chamber.py

@@ -0,0 +1,356 @@
+from typing import Literal
+
+import numpy as np
+from ophyd import Component as Cpt
+from ophyd import Device
+from ophyd import DynamicDeviceComponent as Dcpt
+from ophyd import EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV, Kind
+from ophyd.status import DeviceStatus, SubscriptionStatus
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+from typeguard import typechecked
+
+from debye_bec.devices.ionization_chambers.ionization_chamber_enums import (
+    AmplifierEnable,
+    AmplifierFilter,
+    AmplifierGain,
+)
+
+
+class EpicsSignalSplit(EpicsSignal):
+    """Wrapper around EpicsSignal with different read and write pv"""
+
+    def __init__(self, prefix, **kwargs):
+        super().__init__(prefix + "-RB", write_pv=prefix + "Set", **kwargs)
+
+
+class GasMixSetupControl(Device):
+    """GasMixSetup Control for Inonization Chamber 0"""
+
+    gas1_req = Cpt(EpicsSignalWithRBV, suffix="Gas1Req", kind="config", doc="Gas 1 requirement")
+    conc1_req = Cpt(
+        EpicsSignalWithRBV, suffix="Conc1Req", kind="config", doc="Concentration 1 requirement"
+    )
+    gas2_req = Cpt(EpicsSignalWithRBV, suffix="Gas2Req", kind="config", doc="Gas 2 requirement")
+    conc2_req = Cpt(
+        EpicsSignalWithRBV, suffix="Conc2Req", kind="config", doc="Concentration 2 requirement"
+    )
+    press_req = Cpt(
+        EpicsSignalWithRBV, suffix="PressReq", kind="config", doc="Pressure requirement"
+    )
+    fill = Cpt(EpicsSignal, suffix="Fill", kind="config", doc="Fill the chamber")
+    status = Cpt(EpicsSignalRO, suffix="Status", kind="config", doc="Status")
+    gas1 = Cpt(EpicsSignalRO, suffix="Gas1", kind="config", doc="Gas 1")
+    conc1 = Cpt(EpicsSignalRO, suffix="Conc1", kind="config", doc="Concentration 1")
+    gas2 = Cpt(EpicsSignalRO, suffix="Gas2", kind="config", doc="Gas 2")
+    conc2 = Cpt(EpicsSignalRO, suffix="Conc2", kind="config", doc="Concentration 2")
+    press = Cpt(EpicsSignalRO, suffix="PressTransm", kind="config", doc="Current Pressure")
+    status_msg = Cpt(EpicsSignalRO, suffix="StatusMsg0", kind="config", doc="Status")
+
+
+class HighVoltageSuppliesControl(Device):
+    """HighVoltage Supplies Control for Ionization Chamber 0"""
+
+    hv_v = Cpt(EpicsSignalSplit, suffix="HV1-V", kind="config", doc="HV voltage")
+    hv_i = Cpt(EpicsSignalSplit, suffix="HV1-I", kind="config", doc="HV current")
+    grid_v = Cpt(EpicsSignalSplit, suffix="HV2-V", kind="config", doc="Grid voltage")
+    grid_i = Cpt(EpicsSignalSplit, suffix="HV2-I", kind="config", doc="Grid current")
+
+
+class IonizationChamber0(PSIDeviceBase):
+    """Ionization Chamber 0, prefix should be 'X01DA-'."""
+
+    num = 1
+    amp_signals = {
+        "cOnOff": (
+            EpicsSignal,
+            (f"ES:AMP5004.cOnOff{num}"),
+            {"kind": "config", "doc": f"Enable ch{num} -> IC{num-1}"},
+        ),
+        "cGain_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cGain{num}_ENUM"),
+            {"kind": "config", "doc": f"Gain of ch{num} -> IC{num-1}"},
+        ),
+        "cFilter_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cFilter{num}_ENUM"),
+            {"kind": "config", "doc": f"Filter of ch{num} -> IC{num-1}"},
+        ),
+    }
+    amp = Dcpt(amp_signals)
+    gmes = Cpt(GasMixSetupControl, suffix=f"ES-GMES:IC{num-1}")
+    hv = Cpt(HighVoltageSuppliesControl, suffix=f"ES1-IC{num-1}:")
+    hv_en_signals = {
+        "ext_ena": (
+            EpicsSignalRO,
+            "ES1-IC0:HV-Ext-Ena",
+            {"kind": "config", "doc": "External enable signal of HV"},
+        ),
+        "ena": (EpicsSignalRO, "ES1-IC0:HV-Ena", {"kind": "config", "doc": "Enable signal of HV"}),
+    }
+    hv_en = Dcpt(hv_en_signals)
+
+    def __init__(self, name: str, scan_info=None, **kwargs):
+        self.timeout_for_pvwait = 2.5
+        super().__init__(name=name, scan_info=scan_info, **kwargs)
+
+    @typechecked
+    def set_gain(self, gain: Literal["1e6", "1e7", "5e7", "1e8", "1e9"] | AmplifierGain) -> None:
+        """Configure the gain setting of the specified channel
+
+        Args:
+            gain (Literal['1e6', '1e7', '5e7', '1e8', '1e9']) : Desired gain
+        """
+
+        if self.amp.cOnOff.get() == AmplifierEnable.OFF:
+            self.amp.cOnOff.put(AmplifierEnable.ON)
+
+        # Wait until channel is switched on
+        def _wait_enabled():
+            return self.amp.cOnOff.get() == AmplifierEnable.ON
+
+        if not self.wait_for_condition(
+            _wait_enabled, check_stopped=True, timeout=self.timeout_for_pvwait
+        ):
+            raise TimeoutError(
+                f"Enabling channel run into timeout after {self.timeout_for_pvwait} seconds"
+            )
+
+        match gain:
+            case "1e6":
+                self.amp.cGain_ENUM.put(AmplifierGain.G1E6)
+            case "1e7":
+                self.amp.cGain_ENUM.put(AmplifierGain.G1E7)
+            case "5e7":
+                self.amp.cGain_ENUM.put(AmplifierGain.G5E7)
+            case "1e8":
+                self.amp.cGain_ENUM.put(AmplifierGain.G1E8)
+            case "1e9":
+                self.amp.cGain_ENUM.put(AmplifierGain.G1E9)
+
+    def set_filter(
+        self,
+        value: (
+            Literal["1us", "3us", "10us", "30us", "100us", "300us", "1ms", "3ms"] | AmplifierFilter
+        ),
+    ) -> None:
+        """Configure the filter setting of the specified channel
+
+        Args:
+            value (Literal['1us', '3us', '10us', '30us', '100us', '300us', '1ms', '3ms']) : Desired filter
+        """
+        if self.amp.cOnOff.get() == AmplifierEnable.OFF:
+            self.amp.cOnOff.put(AmplifierEnable.ON)
+
+        # Wait until channel is switched on
+        def _wait_enabled():
+            return self.amp.cOnOff.get() == AmplifierEnable.ON
+
+        if not self.wait_for_condition(
+            _wait_enabled, check_stopped=True, timeout=self.timeout_for_pvwait
+        ):
+            raise TimeoutError(
+                f"Enabling channel run into timeout after {self.timeout_for_pvwait} seconds"
+            )
+
+        match value:
+            case "1us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F1US)
+            case "3us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F3US)
+            case "10us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F10US)
+            case "30us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F30US)
+            case "100us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F100US)
+            case "300us":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F300US)
+            case "1ms":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F1MS)
+            case "3ms":
+                self.amp.cFilter_ENUM.put(AmplifierFilter.F3MS)
+
+    @typechecked
+    def set_hv(self, hv: float) -> None:
+        """Configure the high voltage settings , this will
+        enable the high voltage (if external enable is active)!
+
+        Args:
+            hv (float) : Desired voltage for the 'HV' terminal. Voltage has to be between 0...3000
+        """
+
+        if not 0 < hv < 3000:
+            raise ValueError(f"specified HV {hv} not within range [0 .. 3000]")
+        if self.hv.grid_v.get() > hv:
+            raise ValueError(f"Grid {self.hv.grid_v.get()} must not be higher than HV {hv}!")
+
+        if not self.hv_en.ena.get() == 1:
+
+            def check_ch_ena(*, old_value, value, **kwargs):
+                return value == 1
+
+            status = SubscriptionStatus(device=self.hv_en.ena, callback=check_ch_ena)
+            self.hv_en.ena.put(1)
+            # Wait after setting ena to 1
+            status.wait(timeout=2)
+
+        # Set current fixed to 3 mA (max)
+        self.hv.hv_i.put(3)
+        self.hv.hv_v.put(hv)
+
+    @typechecked
+    def set_grid(self, grid: float) -> None:
+        """Configure the high voltage settings , this will
+        enable the high voltage (if external enable is active)!
+
+        Args:
+            grid (float) : Desired voltage for the 'Grid' terminal, Grid Voltage has to be between 0...3000
+        """
+
+        if not 0 < grid < 3000:
+            raise ValueError(f"specified Grid {grid} not within range [0 .. 3000]")
+        if grid > self.hv.hv_v.get():
+            raise ValueError(f"Grid {grid} must not be higher than HV {self.hv.hv_v.get()}!")
+
+        if not self.hv_en.ena.get() == 1:
+
+            def check_ch_ena(*, old_value, value, **kwargs):
+                return value == 1
+
+            status = SubscriptionStatus(device=self.hv_en.ena, callback=check_ch_ena)
+            self.hv_en.ena.put(1)
+            # Wait after setting ena to 1
+            status.wait(timeout=2)
+
+        # Set current fixed to 3 mA (max)
+        self.hv.grid_i.put(3)
+        self.hv.grid_v.put(grid)
+
+    @typechecked
+    def fill(
+        self,
+        gas1: Literal["He", "N2", "Ar", "Kr"],
+        conc1: float,
+        gas2: Literal["He", "N2", "Ar", "Kr"],
+        conc2: float,
+        pressure: float,
+        *,
+        wait: bool = False,
+    ) -> DeviceStatus:
+        """Fill an ionization chamber with the specified gas mixture.
+
+        Args:
+            gas1 (Literal['He', 'N2', 'Ar', 'Kr']) : Gas 1 requirement,
+            conc1 (float) : Concentration 1 requirement in %,
+            gas2 (Literal['He', 'N2', 'Ar', 'Kr']) : Gas 2 requirement,
+            conc2 (float) : Concentration 2 requirement in %,
+            pressure (float) : Required pressure in bar abs,
+            wait (bool): If you like to wait for the filling to finish.
+        """
+
+        if 100 < conc1 < 0:
+            raise ValueError(f"Concentration 1 {conc1} out of range [0 .. 100 %]")
+        if 100 < conc2 < 0:
+            raise ValueError(f"Concentration 2 {conc2} out of range [0 .. 100 %]")
+        if not np.isclose((conc1 + conc2), 100, atol=0.1):
+            raise ValueError(f"Conc1 {conc1} and conc2 {conc2} must sum to 100 +- 0.1")
+        if 3 < pressure < 0:
+            raise ValueError(f"Pressure {pressure} out of range [0 .. 3 bar abs]")
+
+        self.gmes.gas1_req.set(gas1).wait(timeout=3)
+        self.gmes.conc1_req.set(conc1).wait(timeout=3)
+        self.gmes.gas2_req.set(gas2).wait(timeout=3)
+        self.gmes.conc2_req.set(conc2).wait(timeout=3)
+
+        self.gmes.fill.put(1)
+
+        def wait_for_status():
+            return self.gmes.status.get() == 0
+
+        timeout = 3
+        if not self.wait_for_condition(wait_for_status, timeout=timeout, check_stopped=True):
+            raise TimeoutError(
+                f"Ionization chamber filling process did not start after {timeout}s. Last log message {self.gmes.status_msg.get()}"
+            )
+
+        def wait_for_filling_finished():
+            return self.gmes.status.get() == 1
+
+        # Wait until ionization chamber is filled successfully
+        status = self.task_handler.submit_task(
+            task=self.wait_for_condition, task_args=(wait_for_filling_finished, 360, True)
+        )
+        if wait:
+            status.wait()
+        return status
+
+
+class IonizationChamber1(PSIDeviceBase):
+    """Ionization Chamber 0, prefix should be 'X01DA-'."""
+
+    num = 2
+    amp_signals = {
+        "cOnOff": (
+            EpicsSignal,
+            (f"ES:AMP5004.cOnOff{num}"),
+            {"kind": "config", "doc": f"Enable ch{num} -> IC{num-1}"},
+        ),
+        "cGain_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cGain{num}_ENUM"),
+            {"kind": "config", "doc": f"Gain of ch{num} -> IC{num-1}"},
+        ),
+        "cFilter_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cFilter{num}_ENUM"),
+            {"kind": "config", "doc": f"Filter of ch{num} -> IC{num-1}"},
+        ),
+    }
+    amp = Dcpt(amp_signals)
+    gmes = Cpt(GasMixSetupControl, suffix=f"ES-GMES:IC{num-1}")
+    hv = Cpt(HighVoltageSuppliesControl, suffix=f"ES2-IC{num-1}:")
+    hv_en_signals = {
+        "ext_ena": (
+            EpicsSignalRO,
+            "ES2-IC12:HV-Ext-Ena",
+            {"kind": "config", "doc": "External enable signal of HV"},
+        ),
+        "ena": (EpicsSignalRO, "ES2-IC12:HV-Ena", {"kind": "config", "doc": "Enable signal of HV"}),
+    }
+    hv_en = Dcpt(hv_en_signals)
+
+
+class IonizationChamber2(PSIDeviceBase):
+    """Ionization Chamber 0, prefix should be 'X01DA-'."""
+
+    num = 3
+    amp_signals = {
+        "cOnOff": (
+            EpicsSignal,
+            (f"ES:AMP5004.cOnOff{num}"),
+            {"kind": "config", "doc": f"Enable ch{num} -> IC{num-1}"},
+        ),
+        "cGain_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cGain{num}_ENUM"),
+            {"kind": "config", "doc": f"Gain of ch{num} -> IC{num-1}"},
+        ),
+        "cFilter_ENUM": (
+            EpicsSignalWithRBV,
+            (f"ES:AMP5004:cFilter{num}_ENUM"),
+            {"kind": "config", "doc": f"Filter of ch{num} -> IC{num-1}"},
+        ),
+    }
+    amp = Dcpt(amp_signals)
+    gmes = Cpt(GasMixSetupControl, suffix=f"ES-GMES:IC{num-1}")
+    hv = Cpt(HighVoltageSuppliesControl, suffix=f"ES2-IC{num-1}:")
+    hv_en_signals = {
+        "ext_ena": (
+            EpicsSignalRO,
+            "ES2-IC12:HV-Ext-Ena",
+            {"kind": "config", "doc": "External enable signal of HV"},
+        ),
+        "ena": (EpicsSignalRO, "ES2-IC12:HV-Ena", {"kind": "config", "doc": "Enable signal of HV"}),
+    }
+    hv_en = Dcpt(hv_en_signals)

debye_bec/devices/ionization_chambers/ionization_chamber_enums.py

@@ -0,0 +1,32 @@
+import enum
+
+
+class AmplifierEnable(int, enum.Enum):
+    """Enum class for the enable signal of the channel"""
+
+    OFF = 0
+    STARTUP = 1
+    ON = 2
+
+
+class AmplifierGain(int, enum.Enum):
+    """Enum class for the gain of the channel"""
+
+    G1E6 = 0
+    G1E7 = 1
+    G5E7 = 2
+    G1E8 = 3
+    G1E9 = 4
+
+
+class AmplifierFilter(int, enum.Enum):
+    """Enum class for the filter of the channel"""
+
+    F1US = 0
+    F3US = 1
+    F10US = 2
+    F30US = 3
+    F100US = 4
+    F300US = 5
+    F1MS = 6
+    F3MS = 7

debye_bec/devices/mo1_bragg/mo1_bragg.py

@@ -0,0 +1,473 @@
+"""Module for the Mo1 Bragg positioner of the Debye beamline.
+The softIOC is reachable via the EPICS prefix X01DA-OP-MO1:BRAGG: and connected
+to a motor controller via web sockets. The Mo1 Bragg positioner is not only a
+positioner, but also a scan controller to setup XAS and XRD scans. A few scan modes
+are programmed in the controller, e.g. simple and advanced XAS scans + XRD triggering mode.
+
+Note: For some of the Epics PVs, in particular action buttons, the put_complete=True is
+used to ensure that the action is executed completely. This is believed
+to allow for a more stable execution of the action."""
+
+import time
+from typing import Any, Literal
+
+from bec_lib.devicemanager import ScanInfo
+from bec_lib.logger import bec_logger
+from ophyd import Component as Cpt
+from ophyd import DeviceStatus, StatusBase
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+from ophyd_devices.utils.errors import DeviceStopError
+from pydantic import BaseModel, Field
+from typeguard import typechecked
+
+from debye_bec.devices.mo1_bragg.mo1_bragg_devices import Mo1BraggPositioner
+
+# pylint: disable=unused-import
+from debye_bec.devices.mo1_bragg.mo1_bragg_enums import (
+    MoveType,
+    ScanControlLoadMessage,
+    ScanControlMode,
+    ScanControlScanStatus,
+    TriggerControlMode,
+    TriggerControlSource,
+)
+from debye_bec.devices.mo1_bragg.mo1_bragg_utils import compute_spline
+
+# Initialise logger
+logger = bec_logger.logger
+
+########### Exceptions ###########
+
+
+class Mo1BraggError(Exception):
+    """Exception for the Mo1 Bragg positioner"""
+
+
+########## Scan Parameter Model  ##########
+
+
+class ScanParameter(BaseModel):
+    """Dataclass to store the scan parameters for the Mo1 Bragg positioner.
+    This needs to be in sync with the kwargs of the MO1 Bragg scans from Debye, to
+    ensure that the scan parameters are correctly set. Any changes in the scan kwargs,
+    i.e. renaming or adding new parameters, need to be represented here as well."""
+
+    scan_time: float | None = Field(None, description="Scan time for a half oscillation")
+    scan_duration: float | None = Field(None, description="Duration of the scan")
+    xrd_enable_low: bool | None = Field(
+        None, description="XRD enabled for low, should be PV trig_ena_lo_enum"
+    )  # trig_enable_low: bool = None
+    xrd_enable_high: bool | None = Field(
+        None, description="XRD enabled for high, should be PV trig_ena_hi_enum"
+    )  # trig_enable_high: bool = None
+    exp_time_low: float | None = Field(None, description="Exposure time low energy/angle")
+    exp_time_high: float | None = Field(None, description="Exposure time high energy/angle")
+    cycle_low: int | None = Field(None, description="Cycle for low energy/angle")
+    cycle_high: int | None = Field(None, description="Cycle for high energy/angle")
+    start: float | None = Field(None, description="Start value for energy/angle")
+    stop: float | None = Field(None, description="Stop value for energy/angle")
+    p_kink: float | None = Field(None, description="P Kink")
+    e_kink: float | None = Field(None, description="Energy Kink")
+    model_config: dict = {"validate_assignment": True}
+
+
+########### Mo1 Bragg Motor Class ###########
+
+
+class Mo1Bragg(PSIDeviceBase, Mo1BraggPositioner):
+    """Mo1 Bragg motor for the Debye beamline.
+
+    The prefix to connect to the soft IOC is X01DA-OP-MO1:BRAGG:
+    """
+
+    USER_ACCESS = ["set_advanced_xas_settings"]
+
+    def __init__(self, name: str, prefix: str = "", scan_info: ScanInfo | None = None, **kwargs):  # type: ignore
+        """
+        Initialize the PSI Device Base class.
+
+        Args:
+            name (str) : Name of the device
+            scan_info (ScanInfo): The scan info to use.
+        """
+        super().__init__(name=name, scan_info=scan_info, prefix=prefix, **kwargs)
+        self.scan_parameter = ScanParameter()
+        self.timeout_for_pvwait = 2.5
+
+    ########################################
+    #  Beamline Specific Implementations   #
+    ########################################
+
+    def on_init(self) -> None:
+        """
+        Called when the device is initialized.
+
+        No signals are connected at this point. If you like to
+        set default values on signals, please use on_connected instead.
+        """
+
+    def on_connected(self) -> None:
+        """
+        Called after the device is connected and its signals are connected.
+        Default values for signals should be set here.
+        """
+        self.scan_control.scan_progress.subscribe(self._progress_update, run=False)
+
+    def on_stage(self) -> DeviceStatus | StatusBase | None:
+        """
+        Called while staging the device.
+
+        Information about the upcoming scan can be accessed from the scan_info (self.scan_info.msg) object.
+        """
+        self._check_scan_msg(ScanControlLoadMessage.PENDING)
+
+        scan_name = self.scan_info.msg.scan_name
+        self._update_scan_parameter()
+        if scan_name == "xas_simple_scan":
+            self.set_xas_settings(
+                low=self.scan_parameter.start,
+                high=self.scan_parameter.stop,
+                scan_time=self.scan_parameter.scan_time,
+            )
+            self.set_trig_settings(
+                enable_low=False,
+                enable_high=False,
+                exp_time_low=0,
+                exp_time_high=0,
+                cycle_low=0,
+                cycle_high=0,
+            )
+            self.set_scan_control_settings(
+                mode=ScanControlMode.SIMPLE, scan_duration=self.scan_parameter.scan_duration
+            )
+        elif scan_name == "xas_simple_scan_with_xrd":
+            self.set_xas_settings(
+                low=self.scan_parameter.start,
+                high=self.scan_parameter.stop,
+                scan_time=self.scan_parameter.scan_time,
+            )
+            self.set_trig_settings(
+                enable_low=self.scan_parameter.xrd_enable_low,  # enable_low=self.scan_parameter.trig_enable_low,
+                enable_high=self.scan_parameter.xrd_enable_high,  # enable_high=self.scan_parameter.trig_enable_high,
+                exp_time_low=self.scan_parameter.exp_time_low,
+                exp_time_high=self.scan_parameter.exp_time_high,
+                cycle_low=self.scan_parameter.cycle_low,
+                cycle_high=self.scan_parameter.cycle_high,
+            )
+            self.set_scan_control_settings(
+                mode=ScanControlMode.SIMPLE, scan_duration=self.scan_parameter.scan_duration
+            )
+        elif scan_name == "xas_advanced_scan":
+            self.set_advanced_xas_settings(
+                low=self.scan_parameter.start,
+                high=self.scan_parameter.stop,
+                scan_time=self.scan_parameter.scan_time,
+                p_kink=self.scan_parameter.p_kink,
+                e_kink=self.scan_parameter.e_kink,
+            )
+            self.set_trig_settings(
+                enable_low=False,
+                enable_high=False,
+                exp_time_low=0,
+                exp_time_high=0,
+                cycle_low=0,
+                cycle_high=0,
+            )
+            self.set_scan_control_settings(
+                mode=ScanControlMode.ADVANCED, scan_duration=self.scan_parameter.scan_duration
+            )
+        elif scan_name == "xas_advanced_scan_with_xrd":
+            self.set_advanced_xas_settings(
+                low=self.scan_parameter.start,
+                high=self.scan_parameter.stop,
+                scan_time=self.scan_parameter.scan_time,
+                p_kink=self.scan_parameter.p_kink,
+                e_kink=self.scan_parameter.e_kink,
+            )
+            self.set_trig_settings(
+                enable_low=self.scan_parameter.xrd_enable_low,  # enable_low=self.scan_parameter.trig_enable_low,
+                enable_high=self.scan_parameter.xrd_enable_high,  # enable_high=self.scan_parameter.trig_enable_high,
+                exp_time_low=self.scan_parameter.exp_time_low,
+                exp_time_high=self.scan_parameter.exp_time_high,
+                cycle_low=self.scan_parameter.cycle_low,
+                cycle_high=self.scan_parameter.cycle_high,
+            )
+            self.set_scan_control_settings(
+                mode=ScanControlMode.ADVANCED, scan_duration=self.scan_parameter.scan_duration
+            )
+        else:
+            return
+        # Load the scan parameters to the controller
+        self.scan_control.scan_load.put(1)
+        # Wait for params to be checked from controller
+        status = self.task_handler.submit_task(
+            task=self.wait_for_signal,
+            task_args=(self.scan_control.scan_msg, ScanControlLoadMessage.SUCCESS),
+        )
+        return status
+
+    def on_unstage(self) -> DeviceStatus | StatusBase | None:
+        """Called while unstaging the device."""
+
+        def unstage_procedure():
+            try:
+                self.wait_for_signal(
+                    self.scan_control.scan_msg,
+                    ScanControlLoadMessage.PENDING,
+                    timeout=self.timeout_for_pvwait / 2,
+                )
+                return
+            except TimeoutError:
+                logger.warning(
+                    f"Timeout after {self.timeout_for_pvwait} while waiting for scan validation"
+                )
+            time.sleep(0.25)
+            start_time = time.time()
+            while time.time() - start_time < self.timeout_for_pvwait / 2:
+                if not self.scan_control.scan_msg.get() == ScanControlLoadMessage.PENDING:
+                    break
+                time.sleep(0.1)
+            raise TimeoutError(
+                f"Device {self.name} run into timeout after {self.timeout_for_pvwait} while waiting for scan validation"
+            )
+
+        status = self.task_handler.submit_task(unstage_procedure)
+        status.wait()
+        return None
+
+    def on_pre_scan(self) -> DeviceStatus | StatusBase | None:
+        """Called right before the scan starts on all devices automatically."""
+
+    def on_trigger(self) -> DeviceStatus | StatusBase | None:
+        """Called when the device is triggered."""
+
+    def on_complete(self) -> DeviceStatus | StatusBase | None:
+        """Called to inquire if a device has completed a scans."""
+
+        def wait_for_complete():
+            """Wait for the scan to complete. No timeout is set."""
+            start_time = time.time()
+            while True:
+                if self.stopped is True:
+                    raise DeviceStopError(
+                        f"Device {self.name} was stopped while waiting for scan to complete"
+                    )
+                if self.scan_control.scan_done.get() == 1:
+                    return
+                time.sleep(0.1)
+
+        status = self.task_handler.submit_task(wait_for_complete)
+        return status
+
+    def on_kickoff(self) -> DeviceStatus | StatusBase | None:
+        """Called to kickoff a device for a fly scan. Has to be called explicitly."""
+        scan_duration = self.scan_control.scan_duration.get()
+        # TODO implement better logic for infinite scans, at least bring it up with Debye
+        start_func = (
+            self.scan_control.scan_start_infinite.put
+            if scan_duration < 0.1
+            else self.scan_control.scan_start_timer.put
+        )
+        start_func(1)
+        status = self.task_handler.submit_task(
+            task=self.wait_for_signal,
+            task_args=(self.scan_control.scan_status, ScanControlScanStatus.RUNNING),
+        )
+        return status
+
+    def on_stop(self) -> None:
+        """Called when the device is stopped."""
+        self.stopped = True  # Needs to be set to stop motion
+
+    ######### Utility Methods #########
+
+    # FIXME this should become the ProgressSignal
+    # pylint: disable=unused-argument
+    def _progress_update(self, value, **kwargs) -> None:
+        """Callback method to update the scan progress, runs a callback
+        to SUB_PROGRESS subscribers, i.e. BEC.
+
+        Args:
+            value (int) : current progress value
+        """
+        max_value = 100
+        self._run_subs(
+            sub_type=self.SUB_PROGRESS,
+            value=value,
+            max_value=max_value,
+            done=bool(max_value == value),
+        )
+
+    def set_xas_settings(self, low: float, high: float, scan_time: float) -> None:
+        """Set XAS parameters for upcoming scan.
+
+        Args:
+            low (float): Low energy/angle value of the scan
+            high (float): High energy/angle value of the scan
+            scan_time (float): Time for a half oscillation
+        """
+        move_type = self.move_type.get()
+        if move_type == MoveType.ENERGY:
+            self.scan_settings.s_scan_energy_lo.put(low)
+            self.scan_settings.s_scan_energy_hi.put(high)
+        else:
+            self.scan_settings.s_scan_angle_lo.put(low)
+            self.scan_settings.s_scan_angle_hi.put(high)
+        self.scan_settings.s_scan_scantime.put(scan_time)
+
+    def wait_for_signal(self, signal: Cpt, value: Any, timeout: float | None = None) -> None:
+        """Wait for a signal to reach a certain value."""
+        if timeout is None:
+            timeout = self.timeout_for_pvwait
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if signal.get() == value:
+                return None
+            if self.stopped is True:  # Should this check be optional or configurable?!
+                raise DeviceStopError(f"Device {self.name} was stopped while waiting for signal")
+            time.sleep(0.1)
+        # If we end up here, the status did not resolve
+        raise TimeoutError(
+            f"Device {self.name} run into timeout after {timeout}s while waiting for scan to start"
+        )
+
+    @typechecked
+    def convert_angle_energy(
+        self, mode: Literal["AngleToEnergy", "EnergyToAngle"], inp: float
+    ) -> float:
+        """Calculate energy to angle or vice versa
+
+        Args:
+            mode (Literal["AngleToEnergy", "EnergyToAngle"]): Mode of calculation
+            input (float): Either angle or energy
+
+        Returns:
+            output (float): Converted angle or energy
+        """
+        self.calculator.calc_reset.put(0)
+        self.calculator.calc_reset.put(1)
+        self.wait_for_signal(self.calculator.calc_done, 0)
+
+        if mode == "AngleToEnergy":
+            self.calculator.calc_angle.put(inp)
+        elif mode == "EnergyToAngle":
+            self.calculator.calc_energy.put(inp)
+
+        self.wait_for_signal(self.calculator.calc_done, 1)
+        time.sleep(0.25)  # Needed due to update frequency of softIOC
+        if mode == "AngleToEnergy":
+            return self.calculator.calc_energy.get()
+        elif mode == "EnergyToAngle":
+            return self.calculator.calc_angle.get()
+
+    def set_advanced_xas_settings(
+        self, low: float, high: float, scan_time: float, p_kink: float, e_kink: float
+    ) -> None:
+        """Set Advanced XAS parameters for upcoming scan.
+
+        Args:
+            low (float): Low angle value of the scan in eV
+            high (float): High angle value of the scan in eV
+            scan_time (float): Time for a half oscillation in s
+            p_kink (float): Position of kink in %
+            e_kink (float): Energy of kink in eV
+        """
+        # TODO Add fallback solution for automatic testing, otherwise test will fail
+        #      because no monochromator will calculate the angle
+        #      Unsure how to implement this
+
+        move_type = self.move_type.get()
+        if move_type == MoveType.ENERGY:
+            e_kink_deg = self.convert_angle_energy(mode="EnergyToAngle", inp=e_kink)
+            # Angle and Energy are inverse proportional!
+            high_deg = self.convert_angle_energy(mode="EnergyToAngle", inp=low)
+            low_deg = self.convert_angle_energy(mode="EnergyToAngle", inp=high)
+        else:
+            raise Mo1BraggError("MoveType Angle not implemented for advanced scans, use Energy")
+
+        pos, vel, dt = compute_spline(
+            low_deg=low_deg,
+            high_deg=high_deg,
+            p_kink=p_kink,
+            e_kink_deg=e_kink_deg,
+            scan_time=scan_time,
+        )
+
+        self.scan_settings.a_scan_pos.set(pos)
+        self.scan_settings.a_scan_vel.set(vel)
+        self.scan_settings.a_scan_time.set(dt)
+
+    def set_trig_settings(
+        self,
+        enable_low: bool,
+        enable_high: bool,
+        exp_time_low: int,
+        exp_time_high: int,
+        cycle_low: int,
+        cycle_high: int,
+    ) -> None:
+        """Set TRIG settings for the upcoming scan.
+
+        Args:
+            enable_low (bool): Enable TRIG for low energy/angle
+            enable_high (bool): Enable TRIG for high energy/angle
+            num_trigger_low (int): Number of triggers for low energy/angle
+            num_trigger_high (int): Number of triggers for high energy/angle
+            exp_time_low (int): Exposure time for low energy/angle
+            exp_time_high (int): Exposure time for high energy/angle
+            cycle_low (int): Cycle for low energy/angle
+            cycle_high (int): Cycle for high energy/angle
+        """
+        self.scan_settings.trig_ena_hi_enum.put(int(enable_high))
+        self.scan_settings.trig_ena_lo_enum.put(int(enable_low))
+        self.scan_settings.trig_time_hi.put(exp_time_high)
+        self.scan_settings.trig_time_lo.put(exp_time_low)
+        self.scan_settings.trig_every_n_hi.put(cycle_high)
+        self.scan_settings.trig_every_n_lo.put(cycle_low)
+
+    def set_scan_control_settings(self, mode: ScanControlMode, scan_duration: float) -> None:
+        """Set the scan control settings for the upcoming scan.
+
+        Args:
+            mode (ScanControlMode): Mode for the scan, either simple or advanced
+            scan_duration (float): Duration of the scan
+        """
+        val = ScanControlMode(mode).value
+        self.scan_control.scan_mode_enum.put(val)
+        self.scan_control.scan_duration.put(scan_duration)
+
+    def _update_scan_parameter(self):
+        """Get the scan_info parameters for the scan."""
+        for key, value in self.scan_info.msg.request_inputs["inputs"].items():
+            if hasattr(self.scan_parameter, key):
+                setattr(self.scan_parameter, key, value)
+        for key, value in self.scan_info.msg.request_inputs["kwargs"].items():
+            if hasattr(self.scan_parameter, key):
+                setattr(self.scan_parameter, key, value)
+
+    def _check_scan_msg(self, target_state: ScanControlLoadMessage) -> None:
+        """Check if the scan message is gettting available
+
+        Args:
+            target_state (ScanControlLoadMessage): Target state to check for
+
+        Raises:
+            TimeoutError: If the scan message is not available after the timeout
+        """
+        state = self.scan_control.scan_msg.get()
+        if state != target_state:
+            logger.warning(
+                f"Resetting scan validation in stage for state: {ScanControlLoadMessage(state)}, "
+                f"retry .get() on scan_control: {ScanControlLoadMessage(self.scan_control.scan_msg.get())} and sleeping 1s"
+            )
+            self.scan_control.scan_val_reset.put(1)
+            # Sleep to ensure the reset is done
+            time.sleep(1)
+
+        try:
+            self.wait_for_signal(self.scan_control.scan_msg, target_state)
+        except TimeoutError as exc:
+            raise TimeoutError(
+                f"Timeout after {self.timeout_for_pvwait} while waiting for scan status,"
+                f" current state: {ScanControlScanStatus(self.scan_control.scan_msg.get())}"
+            ) from exc

debye_bec/devices/mo1_bragg/mo1_bragg_devices.py

@@ -0,0 +1,436 @@
+"""Module for the Mo1 Bragg positioner"""
+
+import threading
+import time
+import traceback
+from typing import Literal
+
+from bec_lib.logger import bec_logger
+from ophyd import Component as Cpt
+from ophyd import (
+    Device,
+    DeviceStatus,
+    EpicsSignal,
+    EpicsSignalRO,
+    EpicsSignalWithRBV,
+    PositionerBase,
+    Signal,
+)
+from ophyd.utils import LimitError
+
+from debye_bec.devices.mo1_bragg.mo1_bragg_enums import MoveType
+
+# Initialise logger
+logger = bec_logger.logger
+
+############# Exceptions #############
+
+
+class Mo1BraggStoppedError(Exception):
+    """Exception to raise when the Bragg positioner is stopped."""
+
+
+############# Signal classes #############
+
+
+class MoveTypeSignal(Signal):
+    """Custom Signal to set the move type of the Bragg positioner"""
+
+    # pylint: disable=arguments-differ
+    def set(self, value: str | MoveType) -> None:
+        """Returns currently active move method
+
+        Args:
+            value (str | MoveType) : Can be either 'energy' or 'angle'
+        """
+
+        value = MoveType(value.lower())
+        self._readback = value.value
+
+
+############# Utility devices to separate the namespace #############
+
+
+class Mo1BraggStatus(Device):
+    """Mo1 Bragg PVs for status monitoring"""
+
+    error_status = Cpt(EpicsSignalRO, suffix="error_status_RBV", kind="config", auto_monitor=True)
+    brake_enabled = Cpt(EpicsSignalRO, suffix="brake_enabled_RBV", kind="config", auto_monitor=True)
+    mot_commutated = Cpt(
+        EpicsSignalRO, suffix="mot_commutated_RBV", kind="config", auto_monitor=True
+    )
+    axis_enabled = Cpt(EpicsSignalRO, suffix="axis_enabled_RBV", kind="config", auto_monitor=True)
+    enc_initialized = Cpt(
+        EpicsSignalRO, suffix="enc_initialized_RBV", kind="config", auto_monitor=True
+    )
+    heartbeat = Cpt(EpicsSignalRO, suffix="heartbeat_RBV", kind="config", auto_monitor=True)
+
+
+class Mo1BraggEncoder(Device):
+    """Mo1 Bragg PVs to communicate with the encoder"""
+
+    enc_reinit = Cpt(EpicsSignal, suffix="enc_reinit", kind="config")
+    enc_reinit_done = Cpt(EpicsSignalRO, suffix="enc_reinit_done_RBV", kind="config")
+
+
+class Mo1BraggCrystal(Device):
+    """Mo1 Bragg PVs to set the crystal parameters"""
+
+    offset_si111 = Cpt(EpicsSignalWithRBV, suffix="offset_si111", kind="config")
+    offset_si311 = Cpt(EpicsSignalWithRBV, suffix="offset_si311", kind="config")
+    xtal_enum = Cpt(EpicsSignalWithRBV, suffix="xtal_ENUM", kind="config")
+    d_spacing_si111 = Cpt(EpicsSignalWithRBV, suffix="d_spacing_si111", kind="config")
+    d_spacing_si311 = Cpt(EpicsSignalWithRBV, suffix="d_spacing_si311", kind="config")
+    set_offset = Cpt(EpicsSignal, suffix="set_offset", kind="config", put_complete=True)
+    current_xtal = Cpt(
+        EpicsSignalRO, suffix="current_xtal_ENUM_RBV", kind="normal", auto_monitor=True
+    )
+
+
+class Mo1BraggScanSettings(Device):
+    """Mo1 Bragg PVs to set the scan setttings"""
+
+    # TRIG settings
+    trig_select_ref_enum = Cpt(EpicsSignalWithRBV, suffix="trig_select_ref_ENUM", kind="config")
+
+    trig_ena_hi_enum = Cpt(EpicsSignalWithRBV, suffix="trig_ena_hi_ENUM", kind="config")
+    trig_time_hi = Cpt(EpicsSignalWithRBV, suffix="trig_time_hi", kind="config")
+    trig_every_n_hi = Cpt(EpicsSignalWithRBV, suffix="trig_every_n_hi", kind="config")
+
+    trig_ena_lo_enum = Cpt(EpicsSignalWithRBV, suffix="trig_ena_lo_ENUM", kind="config")
+    trig_time_lo = Cpt(EpicsSignalWithRBV, suffix="trig_time_lo", kind="config")
+    trig_every_n_lo = Cpt(EpicsSignalWithRBV, suffix="trig_every_n_lo", kind="config")
+
+    # XAS simple scan settings
+    s_scan_angle_hi = Cpt(EpicsSignalWithRBV, suffix="s_scan_angle_hi", kind="config")
+    s_scan_angle_lo = Cpt(EpicsSignalWithRBV, suffix="s_scan_angle_lo", kind="config")
+    s_scan_energy_lo = Cpt(
+        EpicsSignalWithRBV, suffix="s_scan_energy_lo", kind="config", auto_monitor=True
+    )
+    s_scan_energy_hi = Cpt(
+        EpicsSignalWithRBV, suffix="s_scan_energy_hi", kind="config", auto_monitor=True
+    )
+    s_scan_scantime = Cpt(
+        EpicsSignalWithRBV, suffix="s_scan_scantime", kind="config", auto_monitor=True
+    )
+
+    # XAS advanced scan settings
+    a_scan_pos = Cpt(EpicsSignalWithRBV, suffix="a_scan_pos", kind="config", auto_monitor=True)
+    a_scan_vel = Cpt(EpicsSignalWithRBV, suffix="a_scan_vel", kind="config", auto_monitor=True)
+    a_scan_time = Cpt(EpicsSignalWithRBV, suffix="a_scan_time", kind="config", auto_monitor=True)
+
+
+class Mo1TriggerSettings(Device):
+    """Mo1 Trigger settings"""
+
+    settle_time = Cpt(EpicsSignalWithRBV, suffix="settle_time", kind="config")
+    max_dev = Cpt(EpicsSignalWithRBV, suffix="max_dev", kind="config")
+
+    xrd_trig_src_enum = Cpt(EpicsSignalWithRBV, suffix="xrd_trig_src_ENUM", kind="config")
+    xrd_trig_mode_enum = Cpt(EpicsSignalWithRBV, suffix="xrd_trig_mode_ENUM", kind="config")
+    xrd_trig_len = Cpt(EpicsSignalWithRBV, suffix="xrd_trig_len", kind="config")
+    xrd_trig_req = Cpt(EpicsSignal, suffix="xrd_trig_req", kind="config")
+
+    falcon_trig_src_enum = Cpt(EpicsSignalWithRBV, suffix="falcon_trig_src_ENUM", kind="config")
+    falcon_trig_mode_enum = Cpt(EpicsSignalWithRBV, suffix="falcon_trig_mode_ENUM", kind="config")
+    falcon_trig_len = Cpt(EpicsSignalWithRBV, suffix="falcon_trig_len", kind="config")
+    falcon_trig_req = Cpt(EpicsSignal, suffix="falcon_trig_req", kind="config")
+
+    univ1_trig_src_enum = Cpt(EpicsSignalWithRBV, suffix="univ1_trig_src_ENUM", kind="config")
+    univ1_trig_mode_enum = Cpt(EpicsSignalWithRBV, suffix="univ1_trig_mode_ENUM", kind="config")
+    univ1_trig_len = Cpt(EpicsSignalWithRBV, suffix="univ1_trig_len", kind="config")
+    univ1_trig_req = Cpt(EpicsSignal, suffix="univ1_trig_req", kind="config")
+
+    univ2_trig_src_enum = Cpt(EpicsSignalWithRBV, suffix="univ2_trig_src_ENUM", kind="config")
+    univ2_trig_mode_enum = Cpt(EpicsSignalWithRBV, suffix="univ2_trig_mode_ENUM", kind="config")
+    univ2_trig_len = Cpt(EpicsSignalWithRBV, suffix="univ2_trig_len", kind="config")
+    univ2_trig_req = Cpt(EpicsSignal, suffix="univ2_trig_req", kind="config")
+
+
+class Mo1BraggCalculator(Device):
+    """Mo1 Bragg PVs to convert angle to energy or vice-versa."""
+
+    calc_reset = Cpt(EpicsSignal, suffix="calc_reset", kind="config", put_complete=True)
+    calc_done = Cpt(EpicsSignalRO, suffix="calc_done_RBV", kind="config")
+    calc_energy = Cpt(EpicsSignalWithRBV, suffix="calc_energy", kind="config")
+    calc_angle = Cpt(EpicsSignalWithRBV, suffix="calc_angle", kind="config")
+
+
+class Mo1BraggScanControl(Device):
+    """Mo1 Bragg PVs to control the scan after setting the parameters."""
+
+    scan_mode_enum = Cpt(EpicsSignalWithRBV, suffix="scan_mode_ENUM", kind="config")
+    scan_duration = Cpt(
+        EpicsSignalWithRBV, suffix="scan_duration", kind="config", auto_monitor=True
+    )
+    scan_load = Cpt(EpicsSignal, suffix="scan_load", kind="config", put_complete=True)
+    scan_msg = Cpt(EpicsSignalRO, suffix="scan_msg_ENUM_RBV", kind="config", auto_monitor=True)
+    scan_start_infinite = Cpt(
+        EpicsSignal, suffix="scan_start_infinite", kind="config", put_complete=True
+    )
+    scan_start_timer = Cpt(EpicsSignal, suffix="scan_start_timer", kind="config", put_complete=True)
+    scan_stop = Cpt(EpicsSignal, suffix="scan_stop", kind="config", put_complete=True)
+    scan_status = Cpt(
+        EpicsSignalRO, suffix="scan_status_ENUM_RBV", kind="config", auto_monitor=True
+    )
+    scan_time_left = Cpt(
+        EpicsSignalRO, suffix="scan_time_left_RBV", kind="config", auto_monitor=True
+    )
+    scan_done = Cpt(EpicsSignalRO, suffix="scan_done_RBV", kind="config", auto_monitor=True)
+    scan_val_reset = Cpt(EpicsSignal, suffix="scan_val_reset", kind="config", put_complete=True)
+    scan_progress = Cpt(EpicsSignalRO, suffix="scan_progress_RBV", kind="config", auto_monitor=True)
+    scan_spectra_done = Cpt(
+        EpicsSignalRO, suffix="scan_n_osc_RBV", kind="config", auto_monitor=True
+    )
+    scan_spectra_left = Cpt(
+        EpicsSignalRO, suffix="scan_n_osc_left_RBV", kind="config", auto_monitor=True
+    )
+
+
+class Mo1BraggPositioner(Device, PositionerBase):
+    """
+    Positioner implementation of the MO1 Bragg positioner.
+
+    The prefix to connect to the soft IOC is X01DA-OP-MO1:BRAGG:
+    This soft IOC connects to the NI motor and its control loop.
+    """
+
+    USER_ACCESS = ["set_advanced_xas_settings"]
+
+    ####### Sub-components ########
+    # Namespace is cleaner and easier to maintain
+    crystal = Cpt(Mo1BraggCrystal, "")
+    encoder = Cpt(Mo1BraggEncoder, "")
+    scan_settings = Cpt(Mo1BraggScanSettings, "")
+    trigger_settings = Cpt(Mo1TriggerSettings, "")
+    calculator = Cpt(Mo1BraggCalculator, "")
+    scan_control = Cpt(Mo1BraggScanControl, "")
+    status = Cpt(Mo1BraggStatus, "")
+
+    ############# switch between energy and angle #############
+    # TODO should be removed/replaced once decision about pseudo motor is made
+    move_type = Cpt(MoveTypeSignal, value=MoveType.ENERGY, kind="config")
+
+    ############# Energy PVs    #############
+
+    readback = Cpt(
+        EpicsSignalRO, suffix="feedback_pos_energy_RBV", kind="hinted", auto_monitor=True
+    )
+    setpoint = Cpt(
+        EpicsSignalWithRBV, suffix="set_abs_pos_energy", kind="normal", auto_monitor=True
+    )
+    motor_is_moving = Cpt(
+        EpicsSignalRO, suffix="move_abs_done_RBV", kind="normal", auto_monitor=True
+    )
+    low_lim = Cpt(EpicsSignalRO, suffix="lo_lim_pos_energy_RBV", kind="config", auto_monitor=True)
+    high_lim = Cpt(EpicsSignalRO, suffix="hi_lim_pos_energy_RBV", kind="config", auto_monitor=True)
+    velocity = Cpt(EpicsSignalWithRBV, suffix="move_velocity", kind="config", auto_monitor=True)
+
+    ########### Angle PVs   #############
+
+    # TODO Pseudo motor for angle?
+    feedback_pos_angle = Cpt(
+        EpicsSignalRO, suffix="feedback_pos_angle_RBV", kind="normal", auto_monitor=True
+    )
+    setpoint_abs_angle = Cpt(
+        EpicsSignalWithRBV, suffix="set_abs_pos_angle", kind="normal", auto_monitor=True
+    )
+    low_limit_angle = Cpt(
+        EpicsSignalRO, suffix="lo_lim_pos_angle_RBV", kind="config", auto_monitor=True
+    )
+    high_limit_angle = Cpt(
+        EpicsSignalRO, suffix="hi_lim_pos_angle_RBV", kind="config", auto_monitor=True
+    )
+
+    ########## Move Command PVs   ##########
+
+    move_abs = Cpt(EpicsSignal, suffix="move_abs", kind="config", put_complete=True)
+    move_stop = Cpt(EpicsSignal, suffix="move_stop", kind="config", put_complete=True)
+
+    SUB_READBACK = "readback"
+    _default_sub = SUB_READBACK
+    SUB_PROGRESS = "progress"
+
+    def __init__(self, prefix="", *, name: str, **kwargs):
+        """Initialize the Mo1 Bragg positioner.
+
+        Args:
+            prefix (str): EPICS prefix for the device
+            name (str): Name of the device
+            kwargs: Additional keyword arguments
+        """
+        super().__init__(prefix, name=name, **kwargs)
+        self._move_thread = None
+        self._stopped = False
+        self.readback.name = self.name
+
+    def stop(self, *, success=False) -> None:
+        """Stop any motion on the positioner
+
+        Args:
+            success (bool) : Flag to indicate if the motion was successful
+        """
+        self.move_stop.put(1)
+        if self._move_thread is not None:
+            self._move_thread.join()
+            self._move_thread = None
+        super().stop(success=success)
+
+    def stop_scan(self) -> None:
+        """Stop the currently running scan gracefully, this finishes the running oscillation."""
+        self.scan_control.scan_stop.put(1)
+
+    @property
+    def stopped(self) -> bool:
+        """Return the status of the positioner"""
+        return self._stopped
+
+    ######### Positioner specific methods #########
+
+    @property
+    def limits(self) -> tuple:
+        """Return limits of the Bragg positioner"""
+        if self.move_type.get() == MoveType.ENERGY:
+            return (self.low_lim.get(), self.high_lim.get())
+        return (self.low_limit_angle.get(), self.high_limit_angle.get())
+
+    @property
+    def low_limit(self) -> float:
+        """Return low limit of axis"""
+        return self.limits[0]
+
+    @property
+    def high_limit(self) -> float:
+        """Return high limit of axis"""
+        return self.limits[1]
+
+    @property
+    def egu(self) -> str:
+        """Return the engineering units of the positioner"""
+        if self.move_type.get() == MoveType.ENERGY:
+            return "eV"
+        return "deg"
+
+    @property
+    def position(self) -> float:
+        """Return the current position of Mo1Bragg, considering the move type"""
+        move_type = self.move_type.get()
+        move_cpt = self.readback if move_type == MoveType.ENERGY else self.feedback_pos_angle
+        return move_cpt.get()
+
+    # pylint: disable=arguments-differ
+    def check_value(self, value: float) -> None:
+        """Method to check if a value is within limits of the positioner.
+        Called by PositionerBase.move()
+
+        Args:
+            value (float) : value to move axis to.
+        """
+        low_limit, high_limit = 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 _move_and_finish(
+        self, target_pos: float, move_cpt: Cpt, status: DeviceStatus, update_frequency: float = 0.1
+    ) -> None:
+        """
+        Method to be called in the move thread to move the Bragg positioner
+        to the target position.
+
+        Args:
+            target_pos (float)      : target position for the motion
+            move_cpt (Cpt)          : component to set the target position on the IOC,
+                                      either setpoint or setpoint_abs_angle depending
+                                      on the move type
+            read_cpt (Cpt)          : component to read the current position of the motion,
+                                      readback or feedback_pos_angle
+            status (DeviceStatus)   : status object to set the status of the motion
+            update_frequency (float): Optional, frequency to update the current position of
+                                      the motion, defaults to 0.1s
+        """
+        try:
+            # Set the target position on IOC
+            move_cpt.put(target_pos)
+            self.move_abs.put(1)
+            # Currently sleep is needed due to delay in updates on PVs, maybe time can be reduced
+            time.sleep(0.5)
+            while self.motor_is_moving.get() == 0:
+                if self.stopped:
+                    raise Mo1BraggStoppedError(f"Device {self.name} was stopped")
+                time.sleep(update_frequency)
+            # pylint: disable=protected-access
+            status.set_finished()
+        # pylint: disable=broad-except
+        except Exception as exc:
+            content = traceback.format_exc()
+            logger.error(f"Error in move thread of device {self.name}: {content}")
+            status.set_exception(exc=exc)
+
+    def move(self, value: float, move_type: str | MoveType = None, **kwargs) -> DeviceStatus:
+        """
+        Move the Bragg positioner to the specified value, allows to
+        switch between move types angle and energy.
+
+        Args:
+            value (float) : target value for the motion
+            move_type (str | MoveType) : Optional, specify the type of move,
+                                         either 'energy' or 'angle'
+
+        Returns:
+            DeviceStatus : status object to track the motion
+        """
+        self._stopped = False
+        if move_type is not None:
+            self.move_type.put(move_type)
+        move_type = self.move_type.get()
+        move_cpt = self.setpoint if move_type == MoveType.ENERGY else self.setpoint_abs_angle
+
+        self.check_value(value)
+        status = DeviceStatus(device=self)
+
+        self._move_thread = threading.Thread(
+            target=self._move_and_finish, args=(value, move_cpt, status, 0.1)
+        )
+        self._move_thread.start()
+        return status
+
+    # -------------- End of Positioner specific methods -----------------#
+
+    # -------------- MO1 Bragg specific methods -----------------#
+
+    def set_xtal(
+        self,
+        xtal_enum: Literal["111", "311"],
+        offset_si111: float = None,
+        offset_si311: float = None,
+        d_spacing_si111: float = None,
+        d_spacing_si311: float = None,
+    ) -> None:
+        """Method to set the crystal parameters of the Bragg positioner
+
+        Args:
+            xtal_enum (Literal["111", "311"]) : Enum to set the crystal orientation
+            offset_si111 (float) : Offset for the 111 crystal
+            offset_si311 (float) : Offset for the 311 crystal
+            d_spacing_si111 (float) : d-spacing for the 111 crystal
+            d_spacing_si311 (float) : d-spacing for the 311 crystal
+        """
+        if offset_si111 is not None:
+            self.crystal.offset_si111.put(offset_si111)
+        if offset_si311 is not None:
+            self.crystal.offset_si311.put(offset_si311)
+        if d_spacing_si111 is not None:
+            self.crystal.d_spacing_si111.put(d_spacing_si111)
+        if d_spacing_si311 is not None:
+            self.crystal.d_spacing_si311.put(d_spacing_si311)
+        if xtal_enum == "111":
+            crystal_set = 0
+        elif xtal_enum == "311":
+            crystal_set = 1
+        else:
+            raise ValueError(
+                f"Invalid argument for xtal_enum : {xtal_enum}, choose from '111' or '311'"
+            )
+        self.crystal.xtal_enum.put(crystal_set)
+        self.crystal.set_offset.put(1)

debye_bec/devices/mo1_bragg/mo1_bragg_enums.py

@@ -0,0 +1,61 @@
+"""Enums for the Bragg positioner and trigger generator"""
+
+import enum
+
+
+class TriggerControlSource(int, enum.Enum):
+    """Enum class for the trigger control source of the trigger generator"""
+
+    EPICS = 0
+    INPOS = 1
+
+
+class TriggerControlMode(int, enum.Enum):
+    """Enum class for the trigger control mode of the trigger generator"""
+
+    PULSE = 0
+    CONDITION = 1
+
+
+class ScanControlScanStatus(int, enum.Enum):
+    """Enum class for the scan status of the Bragg positioner"""
+
+    PARAMETER_WRONG = 0
+    VALIDATION_PENDING = 1
+    READY = 2
+    RUNNING = 3
+
+
+class ScanControlLoadMessage(int, enum.Enum):
+    """Enum for validating messages for load message of the Bragg positioner"""
+
+    PENDING = 0
+    STARTED = 1
+    SUCCESS = 2
+    ERR_TRIG_MEAS_LEN_LOW = 3
+    ERR_TRIG_N_TRIGGERS_LOW = 4
+    ERR_TRIG_TRIGS_EVERY_N_LOW = 5
+    ERR_TRIG_MEAS_LEN_HI = 6
+    ERR_TRIG_N_TRIGGERS_HI = 7
+    ERR_TRIG_TRIGS_EVERY_N_HI = 8
+    ERR_SCAN_HI_ANGLE_LIMIT = 9
+    ERR_SCAN_LOW_ANGLE_LIMITS = 10
+    ERR_SCAN_TIME = 11
+    ERR_SCAN_VEL_TOO_HI = 12
+    ERR_SCAN_ANGLE_OUT_OF_LIM = 13
+    ERR_SCAN_HIGH_VEL_LAR_42 = 14
+    ERR_SCAN_MODE_INVALID = 15
+
+
+class MoveType(str, enum.Enum):
+    """Enum class to switch between move types energy and angle for the Bragg positioner"""
+
+    ENERGY = "energy"
+    ANGLE = "angle"
+
+
+class ScanControlMode(int, enum.Enum):
+    """Enum class for the scan control mode of the Bragg positioner"""
+
+    SIMPLE = 0
+    ADVANCED = 1

debye_bec/devices/mo1_bragg/mo1_bragg_utils.py

@@ -0,0 +1,93 @@
+"""Module for additional utils of the Mo1 Bragg Positioner"""
+
+import numpy as np
+from scipy.interpolate import BSpline
+
+################ Define Constants ############
+SAFETY_FACTOR = 0.025  # safety factor to limit acceleration -> NEVER SET TO ZERO !
+N_SAMPLES = 41  # number of samples to generate -> Always choose uneven number,
+#    otherwise peak value will not be included
+DEGREE_SPLINE = 3  # DEGREE_SPLINE of spline, 3 works good
+TIME_COMPENSATE_SPLINE = 0.0062  # time to be compensated each spline in s
+POSITION_COMPONSATION = 0.02  # angle to add at both limits, must be same values
+#    as used on ACS controller for simple scans
+
+
+class Mo1UtilsSplineError(Exception):
+    """Exception for spline computation"""
+
+
+def compute_spline(
+    low_deg: float, high_deg: float, p_kink: float, e_kink_deg: float, scan_time: float
+) -> tuple[float, float, float]:
+    """Spline computation for the advanced scan mode
+
+    Args:
+        low_deg (float): Low angle value of the scan in deg
+        high_deg (float): High angle value of the scan in deg
+        scan_time (float): Time for a half oscillation in s
+        p_kink (float): Position of kink in %
+        e_kink_deg (float): Position of kink in degree
+
+    Returns:
+        tuple[float,float,float] : Position, Velocity and delta T arrays for the spline
+    """
+
+    # increase motion range slightly so that xas trigger signals will occur at defined energy limits
+    low_deg = low_deg - POSITION_COMPONSATION
+    high_deg = high_deg + POSITION_COMPONSATION
+
+    if p_kink < 0 or p_kink > 100:
+        raise Mo1UtilsSplineError(
+            "Kink position not within range of [0..100%]" + f"for p_kink: {p_kink}"
+        )
+
+    if e_kink_deg < low_deg or e_kink_deg > high_deg:
+        raise Mo1UtilsSplineError(
+            "Kink energy not within selected energy range of scan,"
+            + f"for e_kink_deg {e_kink_deg}, low_deg {low_deg} and"
+            + f"high_deg {high_deg}."
+        )
+
+    tc1 = SAFETY_FACTOR / scan_time * TIME_COMPENSATE_SPLINE
+    t_kink = (scan_time - TIME_COMPENSATE_SPLINE - 2 * (SAFETY_FACTOR - tc1)) * p_kink / 100 + (
+        SAFETY_FACTOR - tc1
+    )
+
+    t_input = [
+        0,
+        SAFETY_FACTOR - tc1,
+        t_kink,
+        scan_time - TIME_COMPENSATE_SPLINE - SAFETY_FACTOR + tc1,
+        scan_time - TIME_COMPENSATE_SPLINE,
+    ]
+    p_input = [0, 0, e_kink_deg - low_deg, high_deg - low_deg, high_deg - low_deg]
+
+    cv = np.stack((t_input, p_input)).T  # spline coefficients
+    max_param = len(cv) - DEGREE_SPLINE
+    kv = np.clip(np.arange(len(cv) + DEGREE_SPLINE + 1) - DEGREE_SPLINE, 0, max_param)  # knots
+    spl = BSpline(kv, cv, DEGREE_SPLINE)  # get spline function
+    p = spl(np.linspace(0, max_param, N_SAMPLES))
+    v = spl(np.linspace(0, max_param, N_SAMPLES), 1)
+    a = spl(np.linspace(0, max_param, N_SAMPLES), 2)
+    j = spl(np.linspace(0, max_param, N_SAMPLES), 3)
+
+    tim, pos = p.T
+    pos = pos + low_deg
+    vel = v[:, 1] / v[:, 0]
+
+    acc = []
+    for item in a:
+        acc.append(0) if item[1] == 0 else acc.append(item[1] / item[0])
+    jerk = []
+    for item in j:
+        jerk.append(0) if item[1] == 0 else jerk.append(item[1] / item[0])
+
+    dt = np.zeros(len(tim))
+    for i in np.arange(len(tim)):
+        if i == 0:
+            dt[i] = 0
+        else:
+            dt[i] = 1000 * (tim[i] - tim[i - 1])
+
+    return pos, vel, dt

debye_bec/devices/nidaq/nidaq.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+from typing import Literal, TYPE_CHECKING, cast
+
+from ophyd_devices.interfaces.base_classes.psi_device_base import PSIDeviceBase
+from ophyd import Device, Kind, DeviceStatus, Component as Cpt
+from ophyd import EpicsSignal, EpicsSignalRO, StatusBase
+from ophyd_devices.sim.sim_signals import SetableSignal
+from bec_lib.logger import bec_logger
+from debye_bec.devices.nidaq.nidaq_enums import (
+    NIDAQCompression,
+    ScanType,
+    NidaqState,
+    ScanRates,
+    ReadoutRange,
+    EncoderTypes,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_lib.devicemanager import ScanInfo
+
+logger = bec_logger.logger
+
+
+class NidaqError(Exception):
+    """Nidaq specific error"""
+
+
+class NidaqControl(Device):
+    """Nidaq control class with all PVs"""
+
+    ### Readback PVs for EpicsEmitter ###
+    ai0 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI0", kind=Kind.normal, doc="EPICS analog input 0",auto_monitor=True)
+    ai1 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI1", kind=Kind.normal, doc="EPICS analog input 1",auto_monitor=True)
+    ai2 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI2", kind=Kind.normal, doc="EPICS analog input 2",auto_monitor=True)
+    ai3 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI3", kind=Kind.normal, doc="EPICS analog input 3",auto_monitor=True)
+    ai4 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI4", kind=Kind.normal, doc="EPICS analog input 4",auto_monitor=True)
+    ai5 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI5", kind=Kind.normal, doc="EPICS analog input 5",auto_monitor=True)
+    ai6 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI6", kind=Kind.normal, doc="EPICS analog input 6",auto_monitor=True)
+    ai7 = Cpt(EpicsSignalRO, suffix="NIDAQ-AI7", kind=Kind.normal, doc="EPICS analog input 7",auto_monitor=True)
+
+    ci0 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI0", kind=Kind.normal, doc="EPICS counter input 0", auto_monitor=True)
+    ci1 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI1", kind=Kind.normal, doc="EPICS counter input 1", auto_monitor=True)
+    ci2 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI2", kind=Kind.normal, doc="EPICS counter input 2", auto_monitor=True)
+    ci3 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI3", kind=Kind.normal, doc="EPICS counter input 3", auto_monitor=True)
+    ci4 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI4", kind=Kind.normal, doc="EPICS counter input 4", auto_monitor=True)
+    ci5 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI5", kind=Kind.normal, doc="EPICS counter input 5", auto_monitor=True)
+    ci6 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI6", kind=Kind.normal, doc="EPICS counter input 6", auto_monitor=True)
+    ci7 = Cpt(EpicsSignalRO, suffix="NIDAQ-CI7", kind=Kind.normal, doc="EPICS counter input 7", auto_monitor=True)
+
+    di0 = Cpt(EpicsSignalRO, suffix="NIDAQ-DI0", kind=Kind.normal, doc="EPICS digital input 0", auto_monitor=True)
+    di1 = Cpt(EpicsSignalRO, suffix="NIDAQ-DI1", kind=Kind.normal, doc="EPICS digital input 1", auto_monitor=True)
+    di2 = Cpt(EpicsSignalRO, suffix="NIDAQ-DI2", kind=Kind.normal, doc="EPICS digital input 2", auto_monitor=True)
+    di3 = Cpt(EpicsSignalRO, suffix="NIDAQ-DI3", kind=Kind.normal, doc="EPICS digital input 3", auto_monitor=True)
+    di4 = Cpt(EpicsSignalRO, suffix="NIDAQ-DI4", kind=Kind.normal, doc="EPICS digital input 4", auto_monitor=True)
+
+    enc_epics = Cpt(EpicsSignalRO, suffix="NIDAQ-ENC", kind=Kind.normal, doc="EPICS Encoder reading", auto_monitor=True)
+    
+    ### Readback for BEC emitter ###
+
+    ai0_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 0, MEAN")
+    ai1_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 1, MEAN")
+    ai2_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 2, MEAN")
+    ai3_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 3, MEAN")
+    ai4_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 4, MEAN")
+    ai5_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 5, MEAN")
+    ai6_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 6, MEAN")
+    ai7_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 7, MEAN")
+
+    ai0_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 0, STD")
+    ai1_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 1, STD")
+    ai2_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 2, STD")
+    ai3_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 3, STD")
+    ai4_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 4, STD")
+    ai5_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 5, STD")
+    ai6_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 6, STD")
+    ai7_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream analog input 7, STD")
+
+    ci0_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 0, MEAN")
+    ci1_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 1, MEAN")
+    ci2_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 2, MEAN")
+    ci3_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 3, MEAN")
+    ci4_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 4, MEAN")
+    ci5_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 5, MEAN")
+    ci6_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 6, MEAN")
+    ci7_mean = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 7, MEAN")
+
+    ci0_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 0. STD")
+    ci1_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 1. STD")
+    ci2_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 2. STD")
+    ci3_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 3. STD")
+    ci4_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 4. STD")
+    ci5_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 5. STD")
+    ci6_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 6. STD")
+    ci7_std_dev = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream counter input 7. STD")
+
+    di0_max = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream digital input 0, MAX")
+    di1_max = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream digital input 1, MAX")
+    di2_max = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream digital input 2, MAX")
+    di3_max = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream digital input 3, MAX")
+    di4_max = Cpt(SetableSignal, value=0, kind=Kind.normal, doc="NIDAQ stream digital input 4, MAX")
+
+    enc = Cpt(SetableSignal, value=0, kind=Kind.normal)
+
+    ### Control PVs ###
+
+    enable_compression = Cpt(EpicsSignal, suffix="NIDAQ-EnableRLE", kind=Kind.config)
+    kickoff_call = Cpt(EpicsSignal, suffix="NIDAQ-Kickoff", kind=Kind.config)
+    stage_call = Cpt(EpicsSignal, suffix="NIDAQ-Stage", kind=Kind.config)
+    state = Cpt(EpicsSignal, suffix="NIDAQ-FSMState", kind=Kind.config, auto_monitor=True)
+    server_status = Cpt(EpicsSignalRO, suffix="NIDAQ-ServerStatus", kind=Kind.config)
+    compression_ratio = Cpt(EpicsSignalRO, suffix="NIDAQ-CompressionRatio", kind=Kind.config)
+    scan_type = Cpt(EpicsSignal, suffix="NIDAQ-ScanType", kind=Kind.config)
+    sampling_rate = Cpt(EpicsSignal, suffix="NIDAQ-SamplingRateRequested", kind=Kind.config)
+    scan_duration = Cpt(EpicsSignal, suffix="NIDAQ-SamplingDuration", kind=Kind.config)
+    readout_range = Cpt(EpicsSignal, suffix="NIDAQ-ReadoutRange", kind=Kind.config)
+    encoder_type = Cpt(EpicsSignal, suffix="NIDAQ-EncoderType", kind=Kind.config)
+    stop_call = Cpt(EpicsSignal, suffix="NIDAQ-Stop", kind=Kind.config)
+
+    ai_chans = Cpt(EpicsSignal, suffix="NIDAQ-AIChans", kind=Kind.config)
+    ci_chans = Cpt(EpicsSignal, suffix="NIDAQ-CIChans6614", kind=Kind.config)
+    di_chans = Cpt(EpicsSignal, suffix="NIDAQ-DIChans", kind=Kind.config)
+
+
+class Nidaq(PSIDeviceBase, NidaqControl):
+    """NIDAQ ophyd wrapper around the NIDAQ backend currently running at x01da-cons-05
+
+    Args:
+        prefix (str)    : Prefix to the NIDAQ soft ioc, currently X01DA-PC-SCANSERVER:
+        name (str)      : Name of the device
+        scan_info (ScanInfo) : ScanInfo object passed by BEC's devicemanager.
+    """
+
+    USER_ACCESS = ["set_config"]
+
+    def __init__(self, prefix: str = "", *, name: str, scan_info: ScanInfo = None, **kwargs):
+        super().__init__(name=name, prefix=prefix, scan_info=scan_info, **kwargs)
+        self.timeout_wait_for_signal = 5  # put 5s firsts
+        self.valid_scan_names = [
+            "xas_simple_scan",
+            "xas_simple_scan_with_xrd",
+            "xas_advanced_scan",
+            "xas_advanced_scan_with_xrd",
+        ]
+
+    ########################################
+    #           Beamline Methods           #
+    ########################################
+
+    def _check_if_scan_name_is_valid(self) -> bool:
+        """Check if the scan is within the list of scans for which the backend is working"""
+        scan_name = self.scan_info.msg.scan_name
+        if scan_name in self.valid_scan_names:
+            return True
+        return False
+
+    def set_config(
+        self,
+        sampling_rate: Literal[
+            100000, 500000, 1000000, 2000000, 4000000, 5000000, 10000000, 14286000
+        ],
+        ai: list,
+        ci: list,
+        di: list,
+        scan_type: Literal["continuous", "triggered"] = "triggered",
+        scan_duration: float = 0,
+        readout_range: Literal[1, 2, 5, 10] = 10,
+        encoder_type: Literal["X_1", "X_2", "X_4"] = "X_4",
+        enable_compression: bool = True,
+    ) -> None:
+        """Method to configure the NIDAQ
+
+        Args:
+            sampling_rate(Literal[100000, 500000, 1000000, 2000000, 4000000, 5000000,
+              10000000, 14286000]): Sampling rate in Hz
+            ai(list): List of analog input channel numbers to add, i.e. [0, 1, 2] for
+              input 0, 1 and 2
+            ci(list): List of counter input channel numbers to add, i.e. [0, 1, 2] for
+              input 0, 1 and 2
+            di(list): List of digital input channel numbers to add, i.e. [0, 1, 2] for
+              input 0, 1 and 2
+            scan_type(Literal['continuous', 'triggered']): Triggered to use with monochromator,
+              otherwise continuous, default 'triggered'
+            scan_duration(float): Scan duration in seconds, use 0 for infinite scan, default 0
+            readout_range(Literal[1, 2, 5, 10]): Readout range in +- Volts, default +-10V
+            encoder_type(Literal['X_1', 'X_2', 'X_4']): Encoder readout type, default 'X_4'
+            enable_compression(bool): Enable or disable compression of data, default True
+
+        """
+        if sampling_rate == 100000:
+            self.sampling_rate.put(ScanRates.HUNDRED_KHZ)
+        elif sampling_rate == 500000:
+            self.sampling_rate.put(ScanRates.FIVE_HUNDRED_KHZ)
+        elif sampling_rate == 1000000:
+            self.sampling_rate.put(ScanRates.ONE_MHZ)
+        elif sampling_rate == 2000000:
+            self.sampling_rate.put(ScanRates.TWO_MHZ)
+        elif sampling_rate == 4000000:
+            self.sampling_rate.put(ScanRates.FOUR_MHZ)
+        elif sampling_rate == 5000000:
+            self.sampling_rate.put(ScanRates.FIVE_MHZ)
+        elif sampling_rate == 10000000:
+            self.sampling_rate.put(ScanRates.TEN_MHZ)
+        elif sampling_rate == 14286000:
+            self.sampling_rate.put(ScanRates.FOURTEEN_THREE_MHZ)
+
+        ai_chans = 0
+        if isinstance(ai, list):
+            for ch in ai:
+                if isinstance(ch, int):
+                    if ch >= 0 and ch <= 7:
+                        ai_chans = ai_chans | (1 << ch)
+        self.ai_chans.put(ai_chans)
+
+        ci_chans = 0
+        if isinstance(ci, list):
+            for ch in ci:
+                if isinstance(ch, int):
+                    if ch >= 0 and ch <= 7:
+                        ci_chans = ci_chans | (1 << ch)
+        self.ci_chans.put(ci_chans)
+
+        di_chans = 0
+        if isinstance(di, list):
+            for ch in di:
+                if isinstance(ch, int):
+                    if ch >= 0 and ch <= 4:
+                        di_chans = di_chans | (1 << ch)
+        self.di_chans.put(di_chans)
+
+        if scan_type in "continuous":
+            self.scan_type.put(ScanType.CONTINUOUS)
+        elif scan_type in "triggered":
+            self.scan_type.put(ScanType.TRIGGERED)
+
+        if scan_duration >= 0:
+            self.scan_duration.put(scan_duration)
+
+        if readout_range == 1:
+            self.readout_range.put(ReadoutRange.ONE_V)
+        elif readout_range == 2:
+            self.readout_range.put(ReadoutRange.TWO_V)
+        elif readout_range == 5:
+            self.readout_range.put(ReadoutRange.FIVE_V)
+        elif readout_range == 10:
+            self.readout_range.put(ReadoutRange.TEN_V)
+
+        if encoder_type in "X_1":
+            self.encoder_type.put(EncoderTypes.X_1)
+        elif encoder_type in "X_2":
+            self.encoder_type.put(EncoderTypes.X_2)
+        elif encoder_type in "X_4":
+            self.encoder_type.put(EncoderTypes.X_4)
+
+        if enable_compression is True:
+            self.enable_compression.put(NIDAQCompression.ON)
+        elif enable_compression is False:
+            self.enable_compression.put(NIDAQCompression.OFF)
+
+    ########################################
+    #  Beamline Specific Implementations   #
+    ########################################
+
+    def on_init(self) -> None:
+        """
+        Called when the device is initialized.
+
+        No signals are connected at this point. If you like to
+        set default values on signals, please use on_connected instead.
+        """
+
+    def on_connected(self) -> None:
+        """
+        Called after the device is connected and its signals are connected.
+        Default values for signals should be set here.
+        """
+        if not self.wait_for_condition(
+            condition= lambda: self.state.get() == NidaqState.STANDBY,
+            timeout = self.timeout_wait_for_signal,
+            check_stopped=True):
+            raise NidaqError(f"Device {self.name} has not been reached in state STANDBY, current state {NidaqState(self.state.get())}")
+        self.scan_duration.set(0).wait()
+
+    def on_stage(self) -> DeviceStatus | StatusBase | None:
+        """
+        Called while staging the device.
+
+        Information about the upcoming scan can be accessed from the scan_info (self.scan_info.msg) object.
+        If the upcoming scan is not in the list of valid scans, return immediately.
+        """
+        if not self._check_if_scan_name_is_valid():
+            return None
+
+        if not self.wait_for_condition(
+            condition=lambda: self.state.get() == NidaqState.STANDBY, timeout=self.timeout_wait_for_signal, check_stopped=True
+        ):
+            raise NidaqError(
+                f"Device {self.name} has not been reached in state STANDBY, current state {NidaqState(self.state.get())}"
+            )
+        self.scan_type.set(ScanType.TRIGGERED).wait()
+        self.scan_duration.set(0).wait()
+        self.stage_call.set(1).wait()
+
+        if not self.wait_for_condition(
+            condition=lambda: self.state.get() == NidaqState.STAGE, timeout=self.timeout_wait_for_signal, check_stopped=True
+        ):
+            raise NidaqError(
+                f"Device {self.name} has not been reached in state STAGE, current state {NidaqState(self.state.get())}"
+            )
+        self.kickoff_call.set(1).wait()
+        logger.info(f"Device {self.name} was staged: {NidaqState(self.state.get())}")
+
+    def on_unstage(self) -> DeviceStatus | StatusBase | None:
+        """Called while unstaging the device. Check that the Nidaq goes into Standby"""
+
+        def _get_state():
+            return self.state.get() == NidaqState.STANDBY
+
+        if not self.wait_for_condition(
+            condition=_get_state, timeout=self.timeout_wait_for_signal, check_stopped=False
+        ):
+            raise NidaqError(
+                f"Device {self.name} has not been reached in state STANDBY, current state {NidaqState(self.state.get())}"
+            )
+        logger.info(f"Device {self.name} was unstaged: {NidaqState(self.state.get())}")
+
+    def on_pre_scan(self) -> DeviceStatus | StatusBase | None:
+        """
+        Called right before the scan starts on all devices automatically.
+
+        Here we ensure that the NIDAQ master task is running
+        before the motor starts its oscillation. This is needed for being properly homed.
+        The NIDAQ should go into Acquiring mode.
+        """
+        if not self._check_if_scan_name_is_valid():
+            return None
+
+        def _wait_for_state():
+            return self.state.get() == NidaqState.KICKOFF
+
+        if not self.wait_for_condition(
+            _wait_for_state, timeout=self.timeout_wait_for_signal, check_stopped=True
+        ):
+            raise NidaqError(
+                f"Device {self.name} failed to reach state KICKOFF during pre scan, current state {NidaqState(self.state.get())}"
+            )
+        logger.info(
+            f"Device {self.name} ready to take data after pre_scan: {NidaqState(self.state.get())}"
+        )
+
+    def on_trigger(self) -> DeviceStatus | StatusBase | None:
+        """Called when the device is triggered."""
+
+    def on_complete(self) -> DeviceStatus | StatusBase | None:
+        """
+        Called to inquire if a device has completed a scans.
+
+        For the NIDAQ we use this method to stop the backend since it
+        would not stop by itself in its current implementation since the number of points are not predefined.
+        """
+        if not self._check_if_scan_name_is_valid():
+            return None
+        self.on_stop()
+        #TODO check if this wait can be removed. We are waiting in unstage anyways which will always be called afterwards
+        # Wait for device to be stopped
+        status = self.wait_for_condition(
+            condition = lambda: self.state.get() == NidaqState.STANDBY,
+            check_stopped=True,
+            timeout=self.timeout_wait_for_signal,
+        )
+        return status
+
+    def on_kickoff(self) -> DeviceStatus | StatusBase | None:
+        """Called to kickoff a device for a fly scan. Has to be called explicitly."""
+
+    def on_stop(self) -> None:
+        """Called when the device is stopped."""
+        self.stop_call.set(1).wait()

debye_bec/devices/nidaq/nidaq_enums.py

@@ -0,0 +1,45 @@
+import enum
+
+
+class NIDAQCompression(str, enum.Enum):
+    """ Options for Compression"""
+    OFF = 0
+    ON = 1
+
+class ScanType(int, enum.Enum):
+    """ Triggering options of the backend"""
+    TRIGGERED = 0
+    CONTINUOUS = 1
+
+class NidaqState(int, enum.Enum):
+    """ Possible States of the NIDAQ backend"""
+    DISABLED = 0
+    STANDBY = 1
+    STAGE = 2
+    KICKOFF = 3
+    ACQUIRE = 4
+    UNSTAGE = 5
+
+class ScanRates(int, enum.Enum):
+    """ Sampling Rate options for the backend, in kHZ and MHz"""
+    HUNDRED_KHZ = 0
+    FIVE_HUNDRED_KHZ = 1
+    ONE_MHZ = 2
+    TWO_MHZ = 3
+    FOUR_MHZ = 4
+    FIVE_MHZ = 5
+    TEN_MHZ = 6
+    FOURTEEN_THREE_MHZ = 7
+
+class ReadoutRange(int, enum.Enum):
+    """ReadoutRange in +-V"""
+    ONE_V = 0
+    TWO_V = 1
+    FIVE_V = 2
+    TEN_V = 3
+
+class EncoderTypes(int, enum.Enum):
+    """ Encoder Types"""
+    X_1 = 0
+    X_2 = 1
+    X_4 = 2

debye_bec/devices/pilatus_curtain.py

@@ -0,0 +1,75 @@
+"""ES2 Pilatus Curtain"""
+
+import time
+
+from ophyd import Component as Cpt
+from ophyd import Device, EpicsSignal, EpicsSignalRO, Kind
+from ophyd_devices.utils import bec_utils
+
+
+class GasMixSetup(Device):
+    """Class for the ES2 Pilatus Curtain"""
+
+    USER_ACCESS = ["open", "close"]
+
+    open_cover = Cpt(EpicsSignal, suffix="OpenCover", kind="config", doc="Open Cover")
+    close_cover = Cpt(EpicsSignal, suffix="CloseCover", kind="config", doc="Close Cover")
+    cover_is_closed = Cpt(
+        EpicsSignalRO, suffix="CoverIsClosed", kind="config", doc="Cover is closed"
+    )
+    cover_is_open = Cpt(EpicsSignalRO, suffix="CoverIsOpen", kind="config", doc="Cover is open")
+    cover_is_moving = Cpt(
+        EpicsSignalRO, suffix="CoverIsMoving", kind="config", doc="Cover is moving"
+    )
+    cover_error = Cpt(EpicsSignalRO, suffix="CoverError", kind="config", doc="Cover error")
+
+    def __init__(
+        self, prefix="", *, name: str, kind: Kind = None, device_manager=None, parent=None, **kwargs
+    ):
+        """Initialize the Pilatus Curtain.
+
+        Args:
+            prefix (str): EPICS prefix for the device
+            name (str): Name of the device
+            kind (Kind): Kind of the device
+            device_manager (DeviceManager): Device manager instance
+            parent (Device): Parent device
+            kwargs: Additional keyword arguments
+        """
+        super().__init__(prefix, name=name, kind=kind, parent=parent, **kwargs)
+        self.device_manager = device_manager
+        self.service_cfg = None
+
+        self.timeout_for_pvwait = 30
+        self.readback.name = self.name
+        # Wait for connection on all components, ensure IOC is connected
+        self.wait_for_connection(all_signals=True, timeout=5)
+
+        if device_manager:
+            self.device_manager = device_manager
+        else:
+            self.device_manager = bec_utils.DMMock()
+
+        self.connector = self.device_manager.connector
+
+    def open(self) -> None:
+        """Open the cover"""
+
+        self.open_cover.put(1)
+
+        while not self.cover_is_open.get():
+            time.sleep(0.1)
+            if self.cover_error.get():
+                raise TimeoutError("Curtain did not open successfully and is now in an error state")
+
+    def close(self) -> None:
+        """Close the cover"""
+
+        self.close_cover.put(1)
+
+        while not self.cover_is_closed.get():
+            time.sleep(0.1)
+            if self.cover_error.get():
+                raise TimeoutError(
+                    "Curtain did not close successfully and is now in an error state"
+                )

debye_bec/devices/test_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

debye_bec/scans/__init__.py

@@ -0,0 +1 @@
+from .mono_bragg_scans import XASSimpleScan, XASSimpleScanWithXRD, XASAdvancedScan, XASAdvancedScanWithXRD

debye_bec/scans/mono_bragg_scans.py

@@ -0,0 +1,312 @@
+"""This module contains the scan classes for the mono bragg motor of the Debye beamline."""
+
+import time
+from typing import Literal
+
+import numpy as np
+from bec_lib.device import DeviceBase
+from bec_lib.logger import bec_logger
+from bec_server.scan_server.scans import AsyncFlyScanBase
+
+logger = bec_logger.logger
+
+
+class XASSimpleScan(AsyncFlyScanBase):
+    """Class for the XAS simple scan"""
+
+    scan_name = "xas_simple_scan"
+    scan_type = "fly"
+    scan_report_hint = "device_progress"
+    required_kwargs = []
+    use_scan_progress_report = False
+    pre_move = False
+    gui_config = {
+        "Movement Parameters": ["start", "stop"],
+        "Scan Parameters": ["scan_time", "scan_duration"],
+    }
+
+    def __init__(
+        self,
+        start: float,
+        stop: float,
+        scan_time: float,
+        scan_duration: float,
+        motor: DeviceBase = "mo1_bragg",
+        **kwargs,
+    ):
+        """The xas_simple_scan is used to start a simple oscillating scan on the mono bragg motor.
+        Start and Stop define the energy range for the scan, scan_time is the time for one scan
+        cycle and scan_duration is the duration of the scan. If scan duration is set to 0, the
+        scan will run infinitely.
+
+        Args:
+            start (float): Start energy for the scan.
+            stop (float): Stop energy for the scan.
+            scan_time (float): Time for one scan cycle.
+            scan_duration (float): Duration of the scan.
+            motor (DeviceBase, optional): Motor device to be used for the scan.
+                                          Defaults to "mo1_bragg".
+        Examples:
+            >>> scans.xas_simple_scan(start=8000, stop=9000, scan_time=1, scan_duration=10)
+        """
+        super().__init__(**kwargs)
+        self.motor = motor
+        self.start = start
+        self.stop = stop
+        self.scan_time = scan_time
+        self.scan_duration = scan_duration
+        self.primary_readout_cycle = 1
+
+    def update_readout_priority(self):
+        """Ensure that NIDAQ is not monitored for any quick EXAFS."""
+        super().update_readout_priority()
+        self.readout_priority["async"].append("nidaq")
+
+    def prepare_positions(self):
+        """Prepare the positions for the scan.
+
+        Use here only start and end energy defining the range for the scan.
+        """
+        self.positions = np.array([self.start, self.stop], dtype=float)
+        self.num_pos = None
+        yield None
+
+    def pre_scan(self):
+        """Pre Scan action. Ensure the motor movetype is set to energy, then check
+        limits for start/end energy.
+        #TODO Remove once the motor movetype is removed and ANGLE motion is a pseudo motor.
+        """
+        yield from self.stubs.send_rpc_and_wait(self.motor, "move_type.set", "energy")
+
+        self._check_limits()
+        # Ensure parent class pre_scan actions to be called.
+        yield from super().pre_scan()
+
+    def scan_report_instructions(self):
+        """
+        Return the instructions for the scan report.
+        """
+        yield from self.stubs.scan_report_instruction({"device_progress": [self.motor]})
+
+    def scan_core(self):
+        """Run the scan core.
+        Kickoff the oscillation on the Bragg motor and wait for the completion of the motion.
+        """
+        # Start the oscillation on the Bragg motor.
+        yield from self.stubs.kickoff(device=self.motor)
+        complete_status = yield from self.stubs.complete(device=self.motor, wait=False)
+
+        while not complete_status.done:
+            # Readout monitored devices
+            yield from self.stubs.read(group="monitored", point_id=self.point_id)
+            time.sleep(self.primary_readout_cycle)
+            self.point_id += 1
+
+        self.num_pos = self.point_id
+
+
+class XASSimpleScanWithXRD(XASSimpleScan):
+    """Class for the XAS simple scan with XRD"""
+
+    scan_name = "xas_simple_scan_with_xrd"
+    gui_config = {
+        "Movement Parameters": ["start", "stop"],
+        "Scan Parameters": ["scan_time", "scan_duration"],
+        "Low Energy Range": ["xrd_enable_low", "num_trigger_low", "exp_time_low", "cycle_low"],
+        "High Energy Range": ["xrd_enable_high", "num_trigger_high", "exp_time_high", "cycle_high"],
+    }
+
+    def __init__(
+        self,
+        start: float,
+        stop: float,
+        scan_time: float,
+        scan_duration: float,
+        xrd_enable_low: bool,
+        num_trigger_low: int,
+        exp_time_low: float,
+        cycle_low: int,
+        xrd_enable_high: bool,
+        num_trigger_high: int,
+        exp_time_high: float,
+        cycle_high: float,
+        motor: DeviceBase = "mo1_bragg",
+        **kwargs,
+    ):
+        """The xas_simple_scan_with_xrd is an oscillation motion on the mono motor
+        with XRD triggering at low and high energy ranges.
+        If scan duration is set to 0, the scan will run infinitely.
+
+        Args:
+            start (float): Start energy for the scan.
+            stop (float): Stop energy for the scan.
+            scan_time (float): Time for one oscillation .
+            scan_duration (float): Total duration of the scan.
+            xrd_enable_low (bool): Enable XRD triggering for the low energy range.
+            num_trigger_low (int): Number of triggers for the low energy range.
+            exp_time_low (float): Exposure time for the low energy range.
+            cycle_low (int): Specify how often the triggers should be considered,
+                             every nth cycle for low
+            xrd_enable_high (bool): Enable XRD triggering for the high energy range.
+            num_trigger_high (int): Number of triggers for the high energy range.
+            exp_time_high (float): Exposure time for the high energy range.
+            cycle_high (int): Specify how often the triggers should be considered,
+                              every nth cycle for high
+            motor (DeviceBase, optional): Motor device to be used for the scan.
+                                          Defaults to "mo1_bragg".
+
+        Examples:
+            >>> scans.xas_simple_scan_with_xrd(start=8000, stop=9000, scan_time=1, scan_duration=10, xrd_enable_low=True, num_trigger_low=5, cycle_low=2, exp_time_low=100, xrd_enable_high=False, num_trigger_high=3, cycle_high=1, exp_time_high=1000)
+        """
+        super().__init__(
+            start=start,
+            stop=stop,
+            scan_time=scan_time,
+            scan_duration=scan_duration,
+            motor=motor,
+            **kwargs,
+        )
+        self.xrd_enable_low = xrd_enable_low
+        self.num_trigger_low = num_trigger_low
+        self.exp_time_low = exp_time_low
+        self.cycle_low = cycle_low
+        self.xrd_enable_high = xrd_enable_high
+        self.num_trigger_high = num_trigger_high
+        self.exp_time_high = exp_time_high
+        self.cycle_high = cycle_high
+
+
+class XASAdvancedScan(XASSimpleScan):
+    """Class for the XAS advanced scan"""
+
+    scan_name = "xas_advanced_scan"
+    gui_config = {
+        "Movement Parameters": ["start", "stop"],
+        "Scan Parameters": ["scan_time", "scan_duration"],
+        "Spline Parameters": ["p_kink", "e_kink"],
+    }
+
+    def __init__(
+        self,
+        start: float,
+        stop: float,
+        scan_time: float,
+        scan_duration: float,
+        p_kink: float,
+        e_kink: float,
+        motor: DeviceBase = "mo1_bragg",
+        **kwargs,
+    ):
+        """The xas_advanced_scan is an oscillation motion on the mono motor.
+        Start and Stop define the energy range for the scan, scan_time is the
+        time for one scan cycle and scan_duration is the duration of the scan.
+        If scan duration is set to 0, the scan will run infinitely.
+        p_kink and e_kink add a kink to the motion profile to slow down in the
+        exafs region of the scan.
+
+        Args:
+            start (float): Start angle for the scan.
+            stop (float): Stop angle for the scan.
+            scan_time (float): Time for one oscillation .
+            scan_duration (float): Total duration of the scan.
+            p_kink (float): Position of the kink.
+            e_kink (float): Energy of the kink.
+            motor (DeviceBase, optional): Motor device to be used for the scan.
+                                          Defaults to "mo1_bragg".
+
+        Examples:
+            >>> scans.xas_advanced_scan(start=10000, stop=12000, scan_time=0.5, scan_duration=10, p_kink=50, e_kink=10500)
+        """
+        super().__init__(
+            start=start,
+            stop=stop,
+            scan_time=scan_time,
+            scan_duration=scan_duration,
+            motor=motor,
+            **kwargs,
+        )
+        self.p_kink = p_kink
+        self.e_kink = e_kink
+
+
+class XASAdvancedScanWithXRD(XASAdvancedScan):
+    """Class for the XAS advanced scan with XRD"""
+
+    scan_name = "xas_advanced_scan_with_xrd"
+    gui_config = {
+        "Movement Parameters": ["start", "stop"],
+        "Scan Parameters": ["scan_time", "scan_duration"],
+        "Spline Parameters": ["p_kink", "e_kink"],
+        "Low Energy Range": ["xrd_enable_low", "num_trigger_low", "exp_time_low", "cycle_low"],
+        "High Energy Range": ["xrd_enable_high", "num_trigger_high", "exp_time_high", "cycle_high"],
+    }
+
+    def __init__(
+        self,
+        start: float,
+        stop: float,
+        scan_time: float,
+        scan_duration: float,
+        p_kink: float,
+        e_kink: float,
+        xrd_enable_low: bool,
+        num_trigger_low: int,
+        exp_time_low: float,
+        cycle_low: int,
+        xrd_enable_high: bool,
+        num_trigger_high: int,
+        exp_time_high: float,
+        cycle_high: float,
+        motor: DeviceBase = "mo1_bragg",
+        **kwargs,
+    ):
+        """The xas_advanced_scan is an oscillation motion on the mono motor
+        with XRD triggering at low and high energy ranges.
+        Start and Stop define the energy range for the scan, scan_time is the time for
+        one scan cycle and scan_duration is the duration of the scan. If scan duration
+        is set to 0, the scan will run infinitely. p_kink and e_kink add a kink to the
+        motion profile to slow down in the exafs region of the scan.
+
+        Args:
+            start (float): Start angle for the scan.
+            stop (float): Stop angle for the scan.
+            scan_time (float): Time for one oscillation .
+            scan_duration (float): Total duration of the scan.
+            p_kink (float): Position of kink.
+            e_kink (float): Energy of the kink.
+            xrd_enable_low (bool): Enable XRD triggering for the low energy range.
+            num_trigger_low (int): Number of triggers for the low energy range.
+            exp_time_low (float): Exposure time for the low energy range.
+            cycle_low (int): Specify how often the triggers should be considered,
+                             every nth cycle for low
+            xrd_enable_high (bool): Enable XRD triggering for the high energy range.
+            num_trigger_high (int): Number of triggers for the high energy range.
+            exp_time_high (float): Exposure time for the high energy range.
+            cycle_high (int): Specify how often the triggers should be considered,
+                              every nth cycle for high
+            motor (DeviceBase, optional): Motor device to be used for the scan.
+                                          Defaults to "mo1_bragg".
+
+        Examples:
+            >>> scans.xas_advanced_scan_with_xrd(start=10000, stop=12000, scan_time=0.5, scan_duration=10, p_kink=50, e_kink=10500, xrd_enable_low=True, num_trigger_low=5, cycle_low=2, exp_time_low=100, xrd_enable_high=False, num_trigger_high=3, cycle_high=1, exp_time_high=1000)
+        """
+        super().__init__(
+            start=start,
+            stop=stop,
+            scan_time=scan_time,
+            scan_duration=scan_duration,
+            p_kink=p_kink,
+            e_kink=e_kink,
+            motor=motor,
+            **kwargs,
+        )
+        self.p_kink = p_kink
+        self.e_kink = e_kink
+        self.xrd_enable_low = xrd_enable_low
+        self.num_trigger_low = num_trigger_low
+        self.exp_time_low = exp_time_low
+        self.cycle_low = cycle_low
+        self.xrd_enable_high = xrd_enable_high
+        self.num_trigger_high = num_trigger_high
+        self.exp_time_high = exp_time_high
+        self.cycle_high = cycle_high

debye_bec/scans/scan_plugin_template.py

@@ -0,0 +1,33 @@
+"""
+SCAN PLUGINS
+
+All new scans should be derived from ScanBase. ScanBase provides various methods that can be customized and overriden
+but they are executed in a specific order:
+
+- self.initialize                        # initialize the class if needed
+- self.read_scan_motors                  # used to retrieve the start position (and the relative position shift if needed)
+- self.prepare_positions                 # prepare the positions for the scan. The preparation is split into multiple sub fuctions:
+    - self._calculate_positions          # calculate the positions
+    - self._set_positions_offset         # apply the previously retrieved scan position shift (if needed)
+    - self._check_limits                 # tests to ensure the limits won't be reached
+- self.open_scan                         # send an open_scan message including the scan name, the number of points and the scan motor names
+- self.stage                             # stage all devices for the upcoming acquisiton
+- self.run_baseline_readings             # read all devices to get a baseline for the upcoming scan
+- self.pre_scan                          # perform additional actions before the scan starts
+- self.scan_core                         # run a loop over all position
+    - self._at_each_point(ind, pos)      # called at each position with the current index and the target positions as arguments
+- self.finalize                          # clean up the scan, e.g. move back to the start position; wait everything to finish
+- self.unstage                           # unstage all devices that have been staged before
+- self.cleanup                           # send a close scan message and perform additional cleanups if needed
+"""
+
+# import time
+
+# import numpy as np
+
+# 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
+
+# logger = bec_logger.logger

debye_bec/services/NIDAQ_writer/NIDAQ_writer.py

@@ -7,10 +7,12 @@ import traceback
 
 import h5py
 import numpy as np
-from bec_lib import MessageEndpoints, RedisConnector, ServiceConfig, bec_logger, messages
+from bec_lib import bec_logger, messages
 from bec_lib.bec_service import BECService
-from bec_lib.file_utils import FileWriterMixin
-from bec_lib.redis_connector import MessageObject
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.file_utils import FileWriter
+from bec_lib.redis_connector import MessageObject, RedisConnector
+from bec_lib.service_config import ServiceConfig
 
 logger = bec_logger.logger
 
@@ -27,7 +29,7 @@ class NIDAQWriterService(BECService):
         super().__init__(config=config, connector_cls=connector_cls, unique_service=True)
         self.queue = queue.Queue()
         config = self._service_config.service_config.get("file_writer")
-        self.writer_mixin = FileWriterMixin(config)
+        self.writer_mixin = FileWriter(service_config=config)
         self._scan_status_consumer = None
         self._ni_data_consumer = None
         self._ni_data_event = None
@@ -159,7 +161,7 @@ class NIDAQWriterService(BECService):
         signals = {}
 
         for key in msgs[0].content["signals"]:
-            signals[key] = np.concatenate([msg.content["signals"][key] for msg in msgs])
+            signals[key] = np.concatenate([msg.content["signals"][key]["value"] for msg in msgs])
 
         # write data to queue
         self.queue.put(signals)

debye_bec/services/NIDAQ_writer/scan_status.py

@@ -1,4 +1,6 @@
-from bec_lib import MessageEndpoints, RedisConnector, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import RedisConnector
 
 
 def send_scan_status(scan_number, status):
@@ -24,19 +26,9 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Scan status helper")
     command = parser.add_subparsers(dest="command")
     start = command.add_parser("start", help="Start a new scan")
-    start.add_argument(
-        "--scan_number",
-        type=int,
-        required=True,
-        help="Scan number",
-    )
+    start.add_argument("--scan_number", type=int, required=True, help="Scan number")
     stop = command.add_parser("stop", help="Stop the scan")
-    stop.add_argument(
-        "--scan_number",
-        type=int,
-        required=True,
-        help="Scan number",
-    )
+    stop.add_argument("--scan_number", type=int, required=True, help="Scan number")
 
     args = parser.parse_args()
     send_scan_status(args.scan_number, args.command)

debye_bec/services/NIDAQ_writer/utils/nidaq_sim.py

@@ -2,7 +2,8 @@ import threading
 import time
 
 import numpy as np
-from bec_lib import MessageEndpoints, RedisConnector, ServiceConfig, bec_logger, messages
+from bec_lib import messages
+from bec_lib.redis_connector import RedisConnector
 
 
 class NIDAQSim(threading.Thread):
@@ -13,10 +14,7 @@ class NIDAQSim(threading.Thread):
         index = 0
         producer = RedisConnector(["localhost:6379"]).producer()
         signal = np.asarray(range(index, index + 600000))
-        signals = {
-            "signal1": signal,
-            "signal2": signal,
-        }
+        signals = {"signal1": signal, "signal2": signal}
 
         msg = messages.DeviceMessage(signals=signals)
         msg = msg.dumps()
@@ -40,9 +38,6 @@ class NIDAQSim(threading.Thread):
 
             time.sleep(0.5)
             print(f"Elapsed time: {time.time() - start}")
-        print(f"Total time: {time.time() - total_time}")
-        print(f"FPS: {index / (time.time() - total_time)}")
-        print(f"Signal size: {signal.nbytes/1e6*2} MB")
 
 
 if __name__ == "__main__":

debye_bec/services/launch_writer.py

@@ -1,15 +1,14 @@
 import argparse
 import threading
 
-from bec_lib import RedisConnector, ServiceConfig, bec_logger
-from NIDAQ_writer import NIDAQWriterService
+from bec_lib import bec_logger
+from bec_lib.redis_connector import RedisConnector
+from bec_lib.service_config import ServiceConfig
+
+from debye_bec.services.NIDAQ_writer import NIDAQWriterService
 
 parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-parser.add_argument(
-    "--config",
-    default="",
-    help="path to the config file",
-)
+parser.add_argument("--config", default="", help="path to the config file")
 clargs = parser.parse_args()
 config_path = clargs.config
 
@@ -17,10 +16,7 @@ config = ServiceConfig(config_path)
 bec_logger.level = bec_logger.LOGLEVEL.INFO
 logger = bec_logger.logger
 
-bec_server = NIDAQWriterService(
-    config=config,
-    connector_cls=RedisConnector,
-)
+bec_server = NIDAQWriterService(config=config, connector_cls=RedisConnector)
 try:
     event = threading.Event()
     # pylint: disable=E1102

pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "debye_bec"
+version = "0.0.0"
+description = "Custom device implementations based on the ophyd hardware abstraction layer"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = ["numpy", "scipy", "bec_lib", "h5py", "ophyd_devices"]
+
+[project.optional-dependencies]
+dev = [
+    "bec_server",
+    "black ~= 24.0",
+    "isort",
+    "coverage",
+    "pylint",
+    "pytest",
+    "pytest-random-order",
+]
+
+[project.entry-points."bec"]
+plugin_bec = "debye_bec"
+
+[project.entry-points."bec.deployment.device_server"]
+plugin_ds_startup = "debye_bec.deployments.device_server.startup:run"
+
+[project.entry-points."bec.file_writer"]
+plugin_file_writer = "debye_bec.file_writer"
+
+[project.entry-points."bec.scans"]
+plugin_scans = "debye_bec.scans"
+
+[project.entry-points."bec.ipython_client_startup"]
+plugin_ipython_client_pre = "debye_bec.bec_ipython_client.startup.pre_startup"
+plugin_ipython_client_post = "debye_bec.bec_ipython_client.startup"
+
+[project.entry-points."bec.widgets"]
+plugin_widgets = "debye_bec.bec_widgets"
+
+[tool.hatch.build.targets.wheel]
+include = ["*"]
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 3
+include_trailing_comma = true
+
+[tool.black]
+line-length = 100
+skip-magic-trailing-comma = true
+
+[tool.pylint.basic]
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs = [
+    ".*scanID.*",
+    ".*RID.*",
+    ".*pointID.*",
+    ".*ID.*",
+    ".*_2D.*",
+    ".*_1D.*",
+]

setup.cfg

@@ -1,21 +0,0 @@
-[metadata]
-name = bec_plugins
-description = BEC plugins to modify the behaviour of services within the BEC framework
-long_description = file: README.md
-long_description_content_type = text/markdown
-url = https://gitlab.psi.ch/bec/bec
-project_urls =
-    Bug Tracker = https://gitlab.psi.ch/bec/bec/issues
-classifiers =
-    Programming Language :: Python :: 3
-    Development Status :: 3 - Alpha
-    Topic :: Scientific/Engineering
-
-[options]
-package_dir =
-    = .
-packages = find:
-python_requires = >=3.10
-
-[options.packages.find]
-where = .

setup.py

@@ -1,7 +0,0 @@
-from setuptools import setup
-
-if __name__ == "__main__":
-    setup(
-        install_requires=["numpy", "h5py", "bec-lib"],
-        extras_require={"dev": ["pytest", "pytest-random-order", "pytest-redis", "coverage"]},
-    )

tests/tests_bec_ipython_client/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_bec_widgets/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_devices/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_devices/test_mo1_bragg.py

@@ -0,0 +1,704 @@
+# pylint: skip-file
+import os
+import threading
+import time
+from dataclasses import fields
+from unittest import mock
+
+import ophyd
+import pytest
+from bec_lib.messages import ScanQueueMessage, ScanStatusMessage
+from bec_server.scan_server.scan_assembler import ScanAssembler
+from bec_server.scan_server.scan_queue import RequestBlock
+from bec_server.scan_server.scan_worker import ScanWorker
+from bec_server.scan_server.tests.fixtures import scan_server_mock
+from ophyd.utils import LimitError
+from ophyd_devices.tests.utils import MockPV
+
+# from bec_server.device_server.tests.utils import DMMock
+from debye_bec.devices.mo1_bragg.mo1_bragg import (
+    Mo1Bragg,
+    Mo1BraggError,
+    ScanControlLoadMessage,
+    ScanControlMode,
+    ScanControlScanStatus,
+)
+from debye_bec.devices.mo1_bragg.mo1_bragg_devices import MoveType
+
+# TODO move this function to ophyd_devices, it is duplicated in csaxs_bec and needed for other pluging repositories
+from debye_bec.devices.test_utils.utils import patch_dual_pvs
+
+
+@pytest.fixture(scope="function")
+def scan_worker_mock(scan_server_mock):
+    scan_server_mock.device_manager.connector = mock.MagicMock()
+    scan_worker = ScanWorker(parent=scan_server_mock)
+    yield scan_worker
+
+
+@pytest.fixture(scope="function")
+def mock_bragg():
+    name = "bragg"
+    prefix = "X01DA-OP-MO1:BRAGG:"
+    with mock.patch.object(ophyd, "cl") as mock_cl:
+        mock_cl.get_pv = MockPV
+        mock_cl.thread_class = threading.Thread
+        dev = Mo1Bragg(name=name, prefix=prefix)
+        patch_dual_pvs(dev)
+        yield dev
+
+
+def test_init(mock_bragg):
+    dev = mock_bragg
+    assert dev.name == "bragg"
+    assert dev.prefix == "X01DA-OP-MO1:BRAGG:"
+    assert dev.move_type.get() == MoveType.ENERGY
+    assert dev.crystal.offset_si111._read_pvname == "X01DA-OP-MO1:BRAGG:offset_si111_RBV"
+    assert dev.move_abs._read_pvname == "X01DA-OP-MO1:BRAGG:move_abs"
+
+
+def test_check_value(mock_bragg):
+    dev = mock_bragg
+    dev.low_lim._read_pv.mock_data = 0
+    dev.high_lim._read_pv.mock_data = 1
+    dev.low_limit_angle._read_pv.mock_data = 10
+    dev.high_limit_angle._read_pv.mock_data = 20
+    # Check that limits are taken correctly from angle or energy
+    # Energy first
+    move_type = MoveType.ENERGY
+    dev.move_type.set(move_type)
+    # nothing happens
+    dev.check_value(0.5)
+    with pytest.raises(LimitError):
+        dev.check_value(15)
+    # Angle next
+    move_type = MoveType.ANGLE
+    dev.move_type.set(move_type)
+    dev.check_value(15)
+    with pytest.raises(LimitError):
+        dev.check_value(0.5)
+
+
+def test_egu(mock_bragg):
+    dev = mock_bragg
+    assert dev.egu == "eV"
+    dev.move_type.set(MoveType.ANGLE)
+    assert dev.egu == "deg"
+
+
+def test_move_succeeds(mock_bragg):
+    dev = mock_bragg
+    dev.move_abs._read_pv.mock_data = 0
+    # Move succeeds
+    with mock.patch.object(dev.motor_is_moving._read_pv, "mock_data", side_effect=[0, 1]):
+        status = dev.move(0.5)
+        # Sleep needed to allow thread to resolive in _move_and_finish, i.e. and the 0.25s sleep inside the function
+        time.sleep(1)
+        assert status.done is True
+        assert status.success is True
+        assert dev.setpoint.get() == 0.5
+        assert dev.move_abs.get() == 1
+
+
+def test_stop_move(mock_bragg):
+    dev = mock_bragg
+    dev.move_abs._read_pv.mock_data = 0
+    dev.motor_is_moving._read_pv.mock_data = 0
+    # Move fails
+    status = dev.move(0.5)
+    time.sleep(1)
+    assert status.done is False
+    assert dev._stopped == False
+    dev.stop()
+    time.sleep(0.5)
+    assert dev._stopped == True
+    assert status.done is True
+    assert status.success is False
+
+
+def test_set_xtal(mock_bragg):
+    dev = mock_bragg
+    dev.set_xtal("111")
+    # Default values for mock
+    assert dev.crystal.offset_si111.get() == 0
+    assert dev.crystal.offset_si311.get() == 0
+    assert dev.crystal.d_spacing_si111.get() == 0
+    assert dev.crystal.d_spacing_si311.get() == 0
+    assert dev.crystal.xtal_enum.get() == 0
+    dev.set_xtal("311", offset_si111=1, offset_si311=2, d_spacing_si111=3, d_spacing_si311=4)
+    assert dev.crystal.offset_si111.get() == 1
+    assert dev.crystal.offset_si311.get() == 2
+    assert dev.crystal.d_spacing_si111.get() == 3
+    assert dev.crystal.d_spacing_si311.get() == 4
+    assert dev.crystal.xtal_enum.get() == 1
+
+
+def test_set_xas_settings(mock_bragg):
+    dev = mock_bragg
+    dev.move_type.set(MoveType.ENERGY)
+    dev.set_xas_settings(low=0.5, high=1, scan_time=0.1)
+    assert dev.scan_settings.s_scan_energy_lo.get() == 0.5
+    assert dev.scan_settings.s_scan_energy_hi.get() == 1
+    assert dev.scan_settings.s_scan_scantime.get() == 0.1
+    dev.move_type.set(MoveType.ANGLE)
+    dev.set_xas_settings(low=10, high=20, scan_time=1)
+    assert dev.scan_settings.s_scan_angle_lo.get() == 10
+    assert dev.scan_settings.s_scan_angle_hi.get() == 20
+    assert dev.scan_settings.s_scan_scantime.get() == 1
+
+
+def test_set_trig_settings(mock_bragg):
+    dev = mock_bragg
+    dev.set_trig_settings(
+        enable_low=True,
+        enable_high=False,
+        exp_time_high=0.1,
+        exp_time_low=0.01,
+        cycle_low=1,
+        cycle_high=3,
+    )
+    assert dev.scan_settings.trig_ena_lo_enum.get() == True
+    assert dev.scan_settings.trig_ena_hi_enum.get() == False
+    assert dev.scan_settings.trig_every_n_lo.get() == 1
+    assert dev.scan_settings.trig_every_n_hi.get() == 3
+    assert dev.scan_settings.trig_time_lo.get() == 0.01
+    assert dev.scan_settings.trig_time_hi.get() == 0.1
+
+
+def test_set_control_settings(mock_bragg):
+    dev = mock_bragg
+    dev.set_scan_control_settings(mode=ScanControlMode.SIMPLE, scan_duration=10)
+    assert dev.scan_control.scan_mode_enum.get() == ScanControlMode.SIMPLE
+    assert dev.scan_control.scan_duration.get() == 10
+    dev.set_scan_control_settings(mode=ScanControlMode.ADVANCED, scan_duration=5)
+    assert dev.scan_control.scan_mode_enum.get() == ScanControlMode.ADVANCED
+    assert dev.scan_control.scan_duration.get() == 5
+
+
+def test_update_scan_parameters(mock_bragg):
+    dev = mock_bragg
+    msg = ScanStatusMessage(
+        scan_id="my_scan_id",
+        status="closed",
+        request_inputs={
+            "kwargs": {
+                "start": 0,
+                "stop": 5,
+                "scan_time": 1,
+                "scan_duration": 10,
+                "xrd_enable_low": True,
+                "xrd_enable_high": False,
+                "num_trigger_low": 1,
+                "num_trigger_high": 7,
+                "exp_time_low": 1,
+                "exp_time_high": 3,
+                "cycle_low": 1,
+                "cycle_high": 5,
+                "p_kink": 50,
+                "e_kink": 8000,
+            }
+        },
+        info={
+            "kwargs": {
+                "start": 0,
+                "stop": 5,
+                "scan_time": 1,
+                "scan_duration": 10,
+                "xrd_enable_low": True,
+                "xrd_enable_high": False,
+                "num_trigger_low": 1,
+                "num_trigger_high": 7,
+                "exp_time_low": 1,
+                "exp_time_high": 3,
+                "cycle_low": 1,
+                "cycle_high": 5,
+                "p_kink": 50,
+                "e_kink": 8000,
+            }
+        },
+        metadata={},
+    )
+    mock_bragg.scan_info.msg = msg
+    scan_param = dev.scan_parameter.model_dump()
+    for _, v in scan_param.items():
+        assert v == None
+    dev._update_scan_parameter()
+    scan_param = dev.scan_parameter.model_dump()
+    for k, v in scan_param.items():
+        assert v == msg.content["request_inputs"]["kwargs"].get(k, None)
+
+
+def test_kickoff_scan(mock_bragg):
+    dev = mock_bragg
+    dev.scan_control.scan_status._read_pv.mock_data = ScanControlScanStatus.READY
+    dev.scan_control.scan_duration._read_pv.mock_data = 1
+    dev.scan_control.scan_start_timer._read_pv.mock_data = 0
+    dev.scan_control.scan_start_infinite._read_pv.mock_data = 0
+    status = dev.kickoff()
+    assert status.done is False
+    dev.scan_control.scan_status._read_pv.mock_data = ScanControlScanStatus.RUNNING
+    time.sleep(0.2)
+    assert status.done is True
+    assert dev.scan_control.scan_start_timer.get() == 1
+
+    dev.scan_control.scan_duration._read_pv.mock_data = 0
+    dev.scan_control.scan_start_timer._read_pv.mock_data = 0
+    dev.scan_control.scan_start_infinite._read_pv.mock_data = 0
+    dev.scan_control.scan_start_infinite._read_pv.mock_data = 0
+    status = dev.kickoff()
+    dev.kickoff()
+    assert dev.scan_control.scan_start_infinite.get() == 1
+
+
+def test_complete(mock_bragg):
+    dev = mock_bragg
+    dev.scan_control.scan_done._read_pv.mock_data = 0
+    # Normal case
+    status = dev.complete()
+    assert status.done is False
+    assert status.success is False
+    dev.scan_control.scan_done._read_pv.mock_data = 1
+    status.wait()
+    # time.sleep(0.2)
+    assert status.done is True
+    assert status.success is True
+
+    # Stop called case
+    dev.scan_control.scan_done._read_pv.mock_data = 0
+    status = dev.complete()
+    assert status.done is False
+    assert status.success is False
+    dev.stop()
+    time.sleep(0.2)
+    assert status.done is True
+    assert status.success is False
+
+
+def test_unstage(mock_bragg):
+    mock_bragg.timeout_for_pvwait = 0.5
+    mock_bragg.scan_control.scan_val_reset._read_pv.mock_data = 0
+    mock_bragg.scan_control.scan_msg._read_pv.mock_data = ScanControlLoadMessage.PENDING
+
+    with mock.patch.object(mock_bragg.scan_control.scan_val_reset, "put") as mock_put:
+        status = mock_bragg.unstage()
+        assert mock_put.call_count == 0
+        mock_bragg.scan_control.scan_msg._read_pv.mock_data = ScanControlLoadMessage.SUCCESS
+        with pytest.raises(TimeoutError):
+            mock_bragg.unstage()
+            assert mock_put.call_count == 1
+
+
+# TODO reimplement the test for stage method
+# @pytest.mark.parametrize(
+#     "msg",
+#     [
+#         ScanQueueMessage(
+#             scan_type="monitor_scan",
+#             parameter={
+#                 "args": {},
+#                 "kwargs": {
+#                     "device": "mo1_bragg",
+#                     "start": 0,
+#                     "stop": 10,
+#                     "relative": True,
+#                     "system_config": {"file_suffix": None, "file_directory": None},
+#                 },
+#                 "num_points": 100,
+#             },
+#             queue="primary",
+#             metadata={"RID": "test1234"},
+#         ),
+#         ScanQueueMessage(
+#             scan_type="xas_simple_scan",
+#             parameter={
+#                 "args": {},
+#                 "kwargs": {
+#                     "motor": "mo1_bragg",
+#                     "start": 0,
+#                     "stop": 10,
+#                     "scan_time": 1,
+#                     "scan_duration": 10,
+#                     "system_config": {"file_suffix": None, "file_directory": None},
+#                 },
+#                 "num_points": 100,
+#             },
+#             queue="primary",
+#             metadata={"RID": "test1234"},
+#         ),
+#         ScanQueueMessage(
+#             scan_type="xas_simple_scan_with_xrd",
+#             parameter={
+#                 "args": {},
+#                 "kwargs": {
+#                     "motor": "mo1_bragg",
+#                     "start": 0,
+#                     "stop": 10,
+#                     "scan_time": 1,
+#                     "scan_duration": 10,
+#                     "xrd_enable_low": True,
+#                     "xrd_enable_high": False,
+#                     "num_trigger_low": 1,
+#                     "num_trigger_high": 7,
+#                     "exp_time_low": 1,
+#                     "exp_time_high": 3,
+#                     "cycle_low": 1,
+#                     "cycle_high": 5,
+#                     "system_config": {"file_suffix": None, "file_directory": None},
+#                 },
+#                 "num_points": 10,
+#             },
+#             queue="primary",
+#             metadata={"RID": "test1234"},
+#         ),
+#         ScanQueueMessage(
+#             scan_type="xas_advanced_scan",
+#             parameter={
+#                 "args": {},
+#                 "kwargs": {
+#                     "motor": "mo1_bragg",
+#                     "start": 8000,
+#                     "stop": 9000,
+#                     "scan_time": 1,
+#                     "scan_duration": 10,
+#                     "p_kink": 50,
+#                     "e_kink": 8500,
+#                     "system_config": {"file_suffix": None, "file_directory": None},
+#                 },
+#                 "num_points": 100,
+#             },
+#             queue="primary",
+#             metadata={"RID": "test1234"},
+#         ),
+#         ScanQueueMessage(
+#             scan_type="xas_advanced_scan_with_xrd",
+#             parameter={
+#                 "args": {},
+#                 "kwargs": {
+#                     "motor": "mo1_bragg",
+#                     "start": 8000,
+#                     "stop": 9000,
+#                     "scan_time": 1,
+#                     "scan_duration": 10,
+#                     "p_kink": 50,
+#                     "e_kink": 8500,
+#                     "xrd_enable_low": True,
+#                     "xrd_enable_high": False,
+#                     "num_trigger_low": 1,
+#                     "num_trigger_high": 7,
+#                     "exp_time_low": 1,
+#                     "exp_time_high": 3,
+#                     "cycle_low": 1,
+#                     "cycle_high": 5,
+#                     "system_config": {"file_suffix": None, "file_directory": None},
+#                 },
+#                 "num_points": 10,
+#             },
+#             queue="primary",
+#             metadata={"RID": "test1234"},
+#         ),
+#     ],
+# )
+# def test_stage(mock_bragg, scan_worker_mock, msg):
+#     """This test is important to check that the stage method of the device is working correctly.
+#     Changing the kwargs names in the scans is tightly linked to the logic on the device, thus
+#     it is important to check that the stage method is working correctly for the current implementation.
+
+#     Therefor, this test creates a scaninfo message using the scan.open_scan() method to always check
+#     agains the currently implemented scans vs. the logic on the device"""
+#     # Create a scaninfo message using scans the ScanQueueMessages above, 3 cases of fly scan; for the general case the procedure is not defined yet
+#     worker = scan_worker_mock
+#     scan_server = worker.parent
+#     rb = RequestBlock(msg, assembler=ScanAssembler(parent=scan_server))
+#     with mock.patch.object(worker, "current_instruction_queue_item"):
+#         worker.scan_motors = []
+#         worker.readout_priority = {
+#             "monitored": [],
+#             "baseline": [],
+#             "async": [],
+#             "continuous": [],
+#             "on_request": [],
+#         }
+#         open_scan_msg = list(rb.scan.open_scan())[0]
+#         worker._initialize_scan_info(
+#             rb, open_scan_msg, msg.content["parameter"].get("num_points", 1)
+#         )
+#         # TODO find a better solution to this...
+#         scan_status_msg = ScanStatusMessage(
+#             scan_id=worker.current_scan_id,
+#             status="open",
+#             scan_name=worker.current_scan_info.get("scan_name"),
+#             scan_number=worker.current_scan_info.get("scan_number"),
+#             session_id=worker.current_scan_info.get("session_id"),
+#             dataset_number=worker.current_scan_info.get("dataset_number"),
+#             num_points=worker.current_scan_info.get("num_points"),
+#             scan_type=worker.current_scan_info.get("scan_type"),
+#             scan_report_devices=worker.current_scan_info.get("scan_report_devices"),
+#             user_metadata=worker.current_scan_info.get("user_metadata"),
+#             readout_priority=worker.current_scan_info.get("readout_priority"),
+#             scan_parameters=worker.current_scan_info.get("scan_parameters"),
+#             request_inputs=worker.current_scan_info.get("request_inputs"),
+#             info=worker.current_scan_info,
+#         )
+#         mock_bragg.scan_info.msg = scan_status_msg
+
+<<<<<<< Updated upstream
+        # Ensure that ScanControlLoadMessage is set to SUCCESS
+        mock_bragg.scan_control.scan_msg._read_pv.mock_data = ScanControlLoadMessage.SUCCESS
+        with (
+            mock.patch.object(mock_bragg.scaninfo, "load_scan_metadata") as mock_load_scan_metadata,
+            mock.patch.object(mock_bragg, "_check_scan_msg") as mock_check_scan_msg,
+            mock.patch.object(mock_bragg, "on_unstage"),
+        ):
+            scan_name = scan_status_msg.content["info"].get("scan_name", "")
+            # Chek the not implemented fly scan first, should raise Mo1BraggError
+            if scan_name not in [
+                "xas_simple_scan",
+                "xas_simple_scan_with_xrd",
+                "xas_advanced_scan",
+                "xas_advanced_scan_with_xrd",
+            ]:
+                with pytest.raises(Mo1BraggError):
+                    mock_bragg.stage()
+                assert mock_check_scan_msg.call_count == 1
+                assert mock_load_scan_metadata.call_count == 1
+            else:
+                with (
+                    mock.patch.object(mock_bragg, "set_xas_settings") as mock_xas_settings,
+                    mock.patch.object(
+                        mock_bragg, "set_advanced_xas_settings"
+                    ) as mock_advanced_xas_settings,
+                    mock.patch.object(mock_bragg, "set_trig_settings") as mock_trig_settings,
+                    mock.patch.object(
+                        mock_bragg, "set_scan_control_settings"
+                    ) as mock_set_scan_control_settings,
+                ):
+                    # Check xas_simple_scan
+                    if scan_name == "xas_simple_scan":
+                        mock_bragg.stage()
+                        assert mock_xas_settings.call_args == mock.call(
+                            low=scan_status_msg.content["info"]["kwargs"]["start"],
+                            high=scan_status_msg.content["info"]["kwargs"]["stop"],
+                            scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+                        )
+                        assert mock_trig_settings.call_args == mock.call(
+                            enable_low=False,
+                            enable_high=False,
+                            exp_time_low=0,
+                            exp_time_high=0,
+                            cycle_low=0,
+                            cycle_high=0,
+                        )
+                        assert mock_set_scan_control_settings.call_args == mock.call(
+                            mode=ScanControlMode.SIMPLE,
+                            scan_duration=scan_status_msg.content["info"]["kwargs"][
+                                "scan_duration"
+                            ],
+                        )
+                    # Check xas_simple_scan_with_xrd
+                    elif scan_name == "xas_simple_scan_with_xrd":
+                        mock_bragg.stage()
+                        assert mock_xas_settings.call_args == mock.call(
+                            low=scan_status_msg.content["info"]["kwargs"]["start"],
+                            high=scan_status_msg.content["info"]["kwargs"]["stop"],
+                            scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+                        )
+                        assert mock_trig_settings.call_args == mock.call(
+                            enable_low=scan_status_msg.content["info"]["kwargs"]["xrd_enable_low"],
+                            enable_high=scan_status_msg.content["info"]["kwargs"][
+                                "xrd_enable_high"
+                            ],
+                            exp_time_low=scan_status_msg.content["info"]["kwargs"]["exp_time_low"],
+                            exp_time_high=scan_status_msg.content["info"]["kwargs"][
+                                "exp_time_high"
+                            ],
+                            cycle_low=scan_status_msg.content["info"]["kwargs"]["cycle_low"],
+                            cycle_high=scan_status_msg.content["info"]["kwargs"]["cycle_high"],
+                        )
+                        assert mock_set_scan_control_settings.call_args == mock.call(
+                            mode=ScanControlMode.SIMPLE,
+                            scan_duration=scan_status_msg.content["info"]["kwargs"][
+                                "scan_duration"
+                            ],
+                        )
+                    # Check xas_advanced_scan
+                    elif scan_name == "xas_advanced_scan":
+                        mock_bragg.stage()
+                        assert mock_advanced_xas_settings.call_args == mock.call(
+                            low=scan_status_msg.content["info"]["kwargs"]["start"],
+                            high=scan_status_msg.content["info"]["kwargs"]["stop"],
+                            scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+                            p_kink=scan_status_msg.content["info"]["kwargs"]["p_kink"],
+                            e_kink=scan_status_msg.content["info"]["kwargs"]["e_kink"],
+                        )
+                        assert mock_trig_settings.call_args == mock.call(
+                            enable_low=False,
+                            enable_high=False,
+                            exp_time_low=0,
+                            exp_time_high=0,
+                            cycle_low=0,
+                            cycle_high=0,
+                        )
+                        assert mock_set_scan_control_settings.call_args == mock.call(
+                            mode=ScanControlMode.ADVANCED,
+                            scan_duration=scan_status_msg.content["info"]["kwargs"][
+                                "scan_duration"
+                            ],
+                        )
+                    # Check xas_advanced_scan_with_xrd
+                    elif scan_name == "xas_advanced_scan_with_xrd":
+                        mock_bragg.stage()
+                        assert mock_advanced_xas_settings.call_args == mock.call(
+                            low=scan_status_msg.content["info"]["kwargs"]["start"],
+                            high=scan_status_msg.content["info"]["kwargs"]["stop"],
+                            scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+                            p_kink=scan_status_msg.content["info"]["kwargs"]["p_kink"],
+                            e_kink=scan_status_msg.content["info"]["kwargs"]["e_kink"],
+                        )
+                        assert mock_trig_settings.call_args == mock.call(
+                            enable_low=scan_status_msg.content["info"]["kwargs"]["xrd_enable_low"],
+                            enable_high=scan_status_msg.content["info"]["kwargs"][
+                                "xrd_enable_high"
+                            ],
+                            exp_time_low=scan_status_msg.content["info"]["kwargs"]["exp_time_low"],
+                            exp_time_high=scan_status_msg.content["info"]["kwargs"][
+                                "exp_time_high"
+                            ],
+                            cycle_low=scan_status_msg.content["info"]["kwargs"]["cycle_low"],
+                            cycle_high=scan_status_msg.content["info"]["kwargs"]["cycle_high"],
+                        )
+                        assert mock_set_scan_control_settings.call_args == mock.call(
+                            mode=ScanControlMode.ADVANCED,
+                            scan_duration=scan_status_msg.content["info"]["kwargs"][
+                                "scan_duration"
+                            ],
+                        )
+=======
+#         # Ensure that ScanControlLoadMessage is set to SUCCESS
+#         mock_bragg.scan_control.scan_msg._read_pv.mock_data = ScanControlLoadMessage.SUCCESS
+#         with (
+#             mock.patch.object(mock_bragg, "_check_scan_msg") as mock_check_scan_msg,
+#             mock.patch.object(mock_bragg, "on_unstage"),
+#         ):
+#             scan_name = scan_status_msg.content["info"].get("scan_name", "")
+#             # Chek the not implemented fly scan first, should raise Mo1BraggError
+#             if scan_name not in [
+#                 "xas_simple_scan",
+#                 "xas_simple_scan_with_xrd",
+#                 "xas_advanced_scan",
+#                 "xas_advanced_scan_with_xrd",
+#             ]:
+#                 with pytest.raises(Mo1BraggError):
+#                     mock_bragg.stage()
+#                 assert mock_check_scan_msg.call_count == 1
+#             else:
+#                 with (
+#                     mock.patch.object(mock_bragg, "set_xas_settings") as mock_xas_settings,
+#                     mock.patch.object(
+#                         mock_bragg, "set_advanced_xas_settings"
+#                     ) as mock_advanced_xas_settings,
+#                     mock.patch.object(mock_bragg, "set_trig_settings") as mock_trig_settings,
+#                     mock.patch.object(
+#                         mock_bragg, "set_scan_control_settings"
+#                     ) as mock_set_scan_control_settings,
+#                 ):
+#                     # Check xas_simple_scan
+#                     if scan_name == "xas_simple_scan":
+#                         mock_bragg.stage()
+#                         assert mock_xas_settings.call_args == mock.call(
+#                             low=scan_status_msg.content["info"]["kwargs"]["start"],
+#                             high=scan_status_msg.content["info"]["kwargs"]["stop"],
+#                             scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+#                         )
+#                         assert mock_trig_settings.call_args == mock.call(
+#                             enable_low=False,
+#                             enable_high=False,
+#                             exp_time_low=0,
+#                             exp_time_high=0,
+#                             cycle_low=0,
+#                             cycle_high=0,
+#                         )
+#                         assert mock_set_scan_control_settings.call_args == mock.call(
+#                             mode=ScanControlMode.SIMPLE,
+#                             scan_duration=scan_status_msg.content["info"]["kwargs"][
+#                                 "scan_duration"
+#                             ],
+#                         )
+#                     # Check xas_simple_scan_with_xrd
+#                     elif scan_name == "xas_simple_scan_with_xrd":
+#                         mock_bragg.stage()
+#                         assert mock_xas_settings.call_args == mock.call(
+#                             low=scan_status_msg.content["info"]["kwargs"]["start"],
+#                             high=scan_status_msg.content["info"]["kwargs"]["stop"],
+#                             scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+#                         )
+#                         assert mock_trig_settings.call_args == mock.call(
+#                             enable_low=scan_status_msg.content["info"]["kwargs"]["xrd_enable_low"],
+#                             enable_high=scan_status_msg.content["info"]["kwargs"][
+#                                 "xrd_enable_high"
+#                             ],
+#                             exp_time_low=scan_status_msg.content["info"]["kwargs"]["exp_time_low"],
+#                             exp_time_high=scan_status_msg.content["info"]["kwargs"][
+#                                 "exp_time_high"
+#                             ],
+#                             cycle_low=scan_status_msg.content["info"]["kwargs"]["cycle_low"],
+#                             cycle_high=scan_status_msg.content["info"]["kwargs"]["cycle_high"],
+#                         )
+#                         assert mock_set_scan_control_settings.call_args == mock.call(
+#                             mode=ScanControlMode.SIMPLE,
+#                             scan_duration=scan_status_msg.content["info"]["kwargs"][
+#                                 "scan_duration"
+#                             ],
+#                         )
+#                     # Check xas_advanced_scan
+#                     elif scan_name == "xas_advanced_scan":
+#                         mock_bragg.stage()
+#                         assert mock_advanced_xas_settings.call_args == mock.call(
+#                             low=scan_status_msg.content["info"]["kwargs"]["start"],
+#                             high=scan_status_msg.content["info"]["kwargs"]["stop"],
+#                             scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+#                             p_kink=scan_status_msg.content["info"]["kwargs"]["p_kink"],
+#                             e_kink=scan_status_msg.content["info"]["kwargs"]["e_kink"],
+#                         )
+#                         assert mock_trig_settings.call_args == mock.call(
+#                             enable_low=False,
+#                             enable_high=False,
+#                             exp_time_low=0,
+#                             exp_time_high=0,
+#                             cycle_low=0,
+#                             cycle_high=0,
+#                         )
+#                         assert mock_set_scan_control_settings.call_args == mock.call(
+#                             mode=ScanControlMode.ADVANCED,
+#                             scan_duration=scan_status_msg.content["info"]["kwargs"][
+#                                 "scan_duration"
+#                             ],
+#                         )
+#                     # Check xas_advanced_scan_with_xrd
+#                     elif scan_name == "xas_advanced_scan_with_xrd":
+#                         mock_bragg.stage()
+#                         assert mock_advanced_xas_settings.call_args == mock.call(
+#                             low=scan_status_msg.content["info"]["kwargs"]["start"],
+#                             high=scan_status_msg.content["info"]["kwargs"]["stop"],
+#                             scan_time=scan_status_msg.content["info"]["kwargs"]["scan_time"],
+#                             p_kink=scan_status_msg.content["info"]["kwargs"]["p_kink"],
+#                             e_kink=scan_status_msg.content["info"]["kwargs"]["e_kink"],
+#                         )
+#                         assert mock_trig_settings.call_args == mock.call(
+#                             enable_low=scan_status_msg.content["info"]["kwargs"]["xrd_enable_low"],
+#                             enable_high=scan_status_msg.content["info"]["kwargs"][
+#                                 "xrd_enable_high"
+#                             ],
+#                             exp_time_low=scan_status_msg.content["info"]["kwargs"]["exp_time_low"],
+#                             exp_time_high=scan_status_msg.content["info"]["kwargs"][
+#                                 "exp_time_high"
+#                             ],
+#                             cycle_low=scan_status_msg.content["info"]["kwargs"]["cycle_low"],
+#                             cycle_high=scan_status_msg.content["info"]["kwargs"]["cycle_high"],
+#                         )
+#                         assert mock_set_scan_control_settings.call_args == mock.call(
+#                             mode=ScanControlMode.ADVANCED,
+#                             scan_duration=scan_status_msg.content["info"]["kwargs"][
+#                                 "scan_duration"
+#                             ],
+#                         )
+>>>>>>> Stashed changes

tests/tests_devices/test_mo1_bragg_utils.py

@@ -0,0 +1,152 @@
+# pylint: skip-file
+import numpy as np
+
+import debye_bec.devices.mo1_bragg.mo1_bragg_utils as utils
+
+
+def test_compute_spline():
+    p, v, dt = utils.compute_spline(
+        low_deg=10, high_deg=12, p_kink=50, e_kink_deg=11, scan_time=0.5
+    )
+
+    rtol = 1e-6
+    atol = 1e-3
+    p_desired = [
+        9.98,
+        9.98376125,
+        9.99479,
+        10.01270375,
+        10.03712,
+        10.06765625,
+        10.10393,
+        10.14555875,
+        10.19216,
+        10.24335125,
+        10.29875,
+        10.35797375,
+        10.42064,
+        10.48636625,
+        10.55477,
+        10.62546875,
+        10.69808,
+        10.77222125,
+        10.84751,
+        10.92356375,
+        11.0,
+        11.07643625,
+        11.15249,
+        11.22777875,
+        11.30192,
+        11.37453125,
+        11.44523,
+        11.51363375,
+        11.57936,
+        11.64202625,
+        11.70125,
+        11.75664875,
+        11.80784,
+        11.85444125,
+        11.89607,
+        11.93234375,
+        11.96288,
+        11.98729625,
+        12.00521,
+        12.01623875,
+        12.02,
+    ]
+    v_desired = [
+        0.0,
+        1.50156441,
+        2.35715667,
+        2.90783907,
+        3.29035796,
+        3.57019636,
+        3.78263174,
+        3.9483388,
+        4.08022441,
+        4.18675043,
+        4.27368333,
+        4.34507577,
+        4.40384627,
+        4.45213618,
+        4.49153736,
+        4.52324148,
+        4.54814006,
+        4.5668924,
+        4.57997194,
+        4.58769736,
+        4.59025246,
+        4.58769736,
+        4.57997194,
+        4.5668924,
+        4.54814006,
+        4.52324148,
+        4.49153736,
+        4.45213618,
+        4.40384627,
+        4.34507577,
+        4.27368333,
+        4.18675043,
+        4.08022441,
+        3.9483388,
+        3.78263174,
+        3.57019636,
+        3.29035796,
+        2.90783907,
+        2.35715667,
+        1.50156441,
+        0.0,
+    ]
+    dt_desired = [
+        0.0,
+        4.34081063,
+        5.57222438,
+        6.73882688,
+        7.84061813,
+        8.87759812,
+        9.84976688,
+        10.75712437,
+        11.59967063,
+        12.37740563,
+        13.09032937,
+        13.73844188,
+        14.32174313,
+        14.84023312,
+        15.29391188,
+        15.68277937,
+        16.00683562,
+        16.26608063,
+        16.46051438,
+        16.59013687,
+        16.65494813,
+        16.65494813,
+        16.59013687,
+        16.46051438,
+        16.26608063,
+        16.00683562,
+        15.68277938,
+        15.29391188,
+        14.84023312,
+        14.32174313,
+        13.73844187,
+        13.09032938,
+        12.37740562,
+        11.59967063,
+        10.75712437,
+        9.84976687,
+        8.87759813,
+        7.84061812,
+        6.73882688,
+        5.57222437,
+        4.34081063,
+    ]
+
+    np.testing.assert_allclose(p, p_desired, rtol, atol)
+    np.testing.assert_allclose(v, v_desired, rtol, atol)
+    np.testing.assert_allclose(dt, dt_desired, rtol, atol)
+
+    assert utils.SAFETY_FACTOR == 0.025
+    assert utils.N_SAMPLES == 41
+    assert utils.DEGREE_SPLINE == 3
+    assert utils.TIME_COMPENSATE_SPLINE == 0.0062
+    assert utils.POSITION_COMPONSATION == 0.02

tests/tests_file_writer/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_scans/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_scans/conftest.py

@@ -0,0 +1,36 @@
+# pylint: skip-file
+from functools import partial
+
+import pytest
+from bec_server.device_server.tests.utils import DeviceMockType, DMMock
+from bec_server.scan_server.tests.fixtures import (
+    ScanStubStatusMock,
+    connector_mock,
+    instruction_handler_mock,
+)
+
+
+@pytest.fixture
+def device_manager_mock():
+    device_manager = DMMock()
+    device_manager.add_device(
+        "mo1_bragg", dev_type=DeviceMockType.POSITIONER, readout_priority="monitored"
+    )
+    device_manager.add_device("samx")
+    device_manager.add_device(
+        "eiger", dev_type=DeviceMockType.SIGNAL, readout_priority="monitored", software_trigger=True
+    )
+    device_manager.add_device("bpm4i", dev_type=DeviceMockType.SIGNAL, readout_priority="monitored")
+    yield device_manager
+
+
+@pytest.fixture
+def scan_assembler(instruction_handler_mock, device_manager_mock):
+    def _assemble_scan(scan_class, *args, **kwargs):
+        return scan_class(*args, **kwargs)
+
+    return partial(
+        _assemble_scan,
+        instruction_handler=instruction_handler_mock,
+        device_manager=device_manager_mock,
+    )

tests/tests_scans/test_mono_bragg_scans.py

@@ -0,0 +1,472 @@
+# pylint: skip-file
+from unittest import mock
+
+from bec_lib.messages import DeviceInstructionMessage
+from bec_server.device_server.tests.utils import DMMock
+
+from debye_bec.scans import (
+    XASAdvancedScan,
+    XASAdvancedScanWithXRD,
+    XASSimpleScan,
+    XASSimpleScanWithXRD,
+)
+
+
+def get_instructions(request, ScanStubStatusMock):
+    request.metadata["RID"] = "my_test_request_id"
+
+    def fake_done():
+        """
+        Fake done function for ScanStubStatusMock. Upon each call, it returns the next value from the generator.
+        This is used to simulate the completion of the scan.
+        """
+        yield False
+        yield False
+        yield True
+
+    def fake_complete(*args, **kwargs):
+        yield "fake_complete"
+        return ScanStubStatusMock(done_func=fake_done)
+
+    with (
+        mock.patch.object(request.stubs, "complete", side_effect=fake_complete),
+        mock.patch.object(request.stubs, "_get_result_from_status", return_value=None),
+    ):
+        reference_commands = list(request.run())
+
+        for cmd in reference_commands:
+            if not cmd or isinstance(cmd, str):
+                continue
+            if "RID" in cmd.metadata:
+                cmd.metadata["RID"] = "my_test_request_id"
+            if "rpc_id" in cmd.parameter:
+                cmd.parameter["rpc_id"] = "my_test_rpc_id"
+            cmd.metadata.pop("device_instr_id", None)
+
+        return reference_commands
+
+
+def test_xas_simple_scan(scan_assembler, ScanStubStatusMock):
+
+    request = scan_assembler(XASSimpleScan, start=0, stop=5, scan_time=1, scan_duration=10)
+    reference_commands = get_instructions(request, ScanStubStatusMock)
+
+    assert reference_commands == [
+        None,
+        None,
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="scan_report_instruction",
+            parameter={"device_progress": ["mo1_bragg"]},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="open_scan",
+            parameter={
+                "scan_motors": [],
+                "readout_priority": {
+                    "monitored": [],
+                    "baseline": [],
+                    "on_request": [],
+                    "async": [],
+                },
+                "num_points": None,
+                "positions": [0.0, 5.0],
+                "scan_name": "xas_simple_scan",
+                "scan_type": "fly",
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="stage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "baseline", "RID": "my_test_request_id"},
+            device=["samx"],
+            action="read",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="rpc",
+            parameter={
+                "device": "mo1_bragg",
+                "func": "move_type.set",
+                "rpc_id": "my_test_rpc_id",
+                "args": ("energy",),
+                "kwargs": {},
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="pre_scan",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="kickoff",
+            parameter={"configure": {}},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 0},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 1},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="unstage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="close_scan",
+            parameter={},
+        ),
+    ]
+
+
+def test_xas_simple_scan_with_xrd(scan_assembler, ScanStubStatusMock):
+
+    request = scan_assembler(
+        XASSimpleScanWithXRD,
+        start=0,
+        stop=5,
+        scan_time=1,
+        scan_duration=10,
+        xrd_enable_low=True,
+        num_trigger_low=1,
+        exp_time_low=1,
+        cycle_low=1,
+        xrd_enable_high=True,
+        num_trigger_high=2,
+        exp_time_high=3,
+        cycle_high=4,
+    )
+    reference_commands = get_instructions(request, ScanStubStatusMock)
+
+    assert reference_commands == [
+        None,
+        None,
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="scan_report_instruction",
+            parameter={"device_progress": ["mo1_bragg"]},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="open_scan",
+            parameter={
+                "scan_motors": [],
+                "readout_priority": {
+                    "monitored": [],
+                    "baseline": [],
+                    "on_request": [],
+                    "async": [],
+                },
+                "num_points": None,
+                "positions": [0.0, 5.0],
+                "scan_name": "xas_simple_scan_with_xrd",
+                "scan_type": "fly",
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="stage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "baseline", "RID": "my_test_request_id"},
+            device=["samx"],
+            action="read",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="rpc",
+            parameter={
+                "device": "mo1_bragg",
+                "func": "move_type.set",
+                "rpc_id": "my_test_rpc_id",
+                "args": ("energy",),
+                "kwargs": {},
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="pre_scan",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="kickoff",
+            parameter={"configure": {}},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 0},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 1},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="unstage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="close_scan",
+            parameter={},
+        ),
+    ]
+
+
+def test_xas_advanced_scan(scan_assembler, ScanStubStatusMock):
+
+    request = scan_assembler(
+        XASAdvancedScan,
+        start=8000,
+        stop=9000,
+        scan_time=1,
+        scan_duration=10,
+        p_kink=50,
+        e_kink=8500,
+    )
+    reference_commands = get_instructions(request, ScanStubStatusMock)
+
+    assert reference_commands == [
+        None,
+        None,
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="scan_report_instruction",
+            parameter={"device_progress": ["mo1_bragg"]},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="open_scan",
+            parameter={
+                "scan_motors": [],
+                "readout_priority": {
+                    "monitored": [],
+                    "baseline": [],
+                    "on_request": [],
+                    "async": [],
+                },
+                "num_points": None,
+                "positions": [8000.0, 9000.0],
+                "scan_name": "xas_advanced_scan",
+                "scan_type": "fly",
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="stage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "baseline", "RID": "my_test_request_id"},
+            device=["samx"],
+            action="read",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="rpc",
+            parameter={
+                "device": "mo1_bragg",
+                "func": "move_type.set",
+                "rpc_id": "my_test_rpc_id",
+                "args": ("energy",),
+                "kwargs": {},
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="pre_scan",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="kickoff",
+            parameter={"configure": {}},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 0},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 1},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="unstage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="close_scan",
+            parameter={},
+        ),
+    ]
+
+
+def test_xas_advanced_scan_with_xrd(scan_assembler, ScanStubStatusMock):
+
+    request = scan_assembler(
+        XASAdvancedScanWithXRD,
+        start=8000,
+        stop=9000,
+        scan_time=1,
+        scan_duration=10,
+        p_kink=50,
+        e_kink=8500,
+        xrd_enable_low=True,
+        num_trigger_low=1,
+        exp_time_low=1,
+        cycle_low=1,
+        xrd_enable_high=True,
+        num_trigger_high=2,
+        exp_time_high=3,
+        cycle_high=4,
+    )
+    reference_commands = get_instructions(request, ScanStubStatusMock)
+
+    assert reference_commands == [
+        None,
+        None,
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="scan_report_instruction",
+            parameter={"device_progress": ["mo1_bragg"]},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="open_scan",
+            parameter={
+                "scan_motors": [],
+                "readout_priority": {
+                    "monitored": [],
+                    "baseline": [],
+                    "on_request": [],
+                    "async": [],
+                },
+                "num_points": None,
+                "positions": [8000.0, 9000.0],
+                "scan_name": "xas_advanced_scan_with_xrd",
+                "scan_type": "fly",
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="stage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "baseline", "RID": "my_test_request_id"},
+            device=["samx"],
+            action="read",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="rpc",
+            parameter={
+                "device": "mo1_bragg",
+                "func": "move_type.set",
+                "rpc_id": "my_test_rpc_id",
+                "args": ("energy",),
+                "kwargs": {},
+            },
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="pre_scan",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device="mo1_bragg",
+            action="kickoff",
+            parameter={"configure": {}},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 0},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id", "point_id": 1},
+            device=["bpm4i", "eiger", "mo1_bragg"],
+            action="read",
+            parameter={"group": "monitored"},
+        ),
+        "fake_complete",
+        DeviceInstructionMessage(
+            metadata={},
+            device=["bpm4i", "eiger", "mo1_bragg", "samx"],
+            action="unstage",
+            parameter={},
+        ),
+        DeviceInstructionMessage(
+            metadata={"readout_priority": "monitored", "RID": "my_test_request_id"},
+            device=None,
+            action="close_scan",
+            parameter={},
+        ),
+    ]

tests/tests_services/README.md

@@ -0,0 +1,31 @@
+# Getting Started with Testing using pytest
+
+BEC is using the [pytest](https://docs.pytest.org/en/8.0.x/) framework. 
+It can be install via 
+``` bash
+pip install pytest
+```
+in your *python environment*. 
+We note that pytest is part of the optional-dependencies `[dev]` of the plugin package.
+
+## Introduction
+
+Tests in this package should be stored in the `tests` directory.
+We suggest to sort tests of different submodules, i.e. `scans` or `devices` in the respective folder structure, and to folow a naming convention of `<test_module_name.py>`.
+
+To run all tests, navigate to the directory of the plugin from the command line, and run the command 
+
+``` bash
+pytest -v --random-order ./tests
+```
+Note, the python environment needs to be active.
+The additional arg `-v` allows pytest to run in verbose mode which provides more detailed information about the tests being run.
+The argument `--random-order` instructs pytest to run the tests in random order, which is the default in the CI pipelines. 
+
+## Test examples
+
+Writing tests can be quite specific for the given function. 
+We recommend writing tests as isolated as possible, i.e. try to test single functions instead of full classes.
+A very useful class to enable isolated testing is [MagicMock](https://docs.python.org/3/library/unittest.mock.html).
+In addition, we also recommend to take a look at the [How-to guides from pytest](https://docs.pytest.org/en/8.0.x/how-to/index.html).
+

tests/tests_services/test_file_writer_service.py

@@ -2,10 +2,12 @@ from unittest import mock
 
 import numpy as np
 import pytest
-from bec_lib import MessageEndpoints, ServiceConfig, messages
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
 from bec_lib.redis_connector import MessageObject
+from bec_lib.service_config import ServiceConfig
 
-from bec_plugins.services.NIDAQ_writer import NIDAQWriterService
+from debye_bec.services.NIDAQ_writer import NIDAQWriterService
 
 
 def test_nidaq_starts_consumers():
@@ -32,8 +34,7 @@ class NIWriterMock(NIDAQWriterService):
 @pytest.fixture(scope="function")
 def nidaq():
     service = NIWriterMock(
-        config=ServiceConfig(redis={"host": "test", "port": 6379}),
-        connector_cls=mock.MagicMock(),
+        config=ServiceConfig(redis={"host": "test", "port": 6379}), connector_cls=mock.MagicMock()
     )
     yield service
 
@@ -46,11 +47,8 @@ def test_nidaq_scan_status_consumer(nidaq):
 
 
 def test_scan_status_callback(nidaq):
-    scan_status_msg = messages.ScanStatusMessage(scanID="test", status="open", info={})
-    msg_obj = MessageObject(
-        topic="test",
-        value=scan_status_msg.dumps(),
-    )
+    scan_status_msg = messages.ScanStatusMessage(scan_id="test", status="open", info={})
+    msg_obj = MessageObject(topic="test", value=scan_status_msg.dumps())
     with mock.patch.object(nidaq, "handle_scan_status") as mock_handle:
         nidaq._scan_status_callback(msg_obj, nidaq)
         mock_handle.assert_called_once_with(scan_status_msg)
@@ -83,10 +81,10 @@ def test_nidaq_reads_data_from_strea(nidaq):
             mock_handle.assert_called_once()
 
 
-@pytest.mark.parametrize("scan_status", ["open", "closed", "aborted", "halted", None])
+@pytest.mark.parametrize("scan_status", ["open", "closed", "aborted", "halted"])
 def test_nidaq_handle_scan_status(nidaq, scan_status):
     scan_status_msg = messages.ScanStatusMessage(
-        scanID="test", status=scan_status, info={"scan_number": 5}
+        scan_id="test", status=scan_status, info={"scan_number": 5}
     )
     nidaq.handle_scan_status(scan_status_msg)
     if scan_status == "open":
@@ -99,9 +97,14 @@ def test_nidaq_handle_scan_status(nidaq, scan_status):
 
 def test_nidaq_handle_ni_data(nidaq):
     data = [
-        messages.DeviceMessage(signals={"signal1": list(range(10)), "signal2": list(range(10))}),
         messages.DeviceMessage(
-            signals={"signal1": list(range(10, 20)), "signal2": list(range(10, 20))}
+            signals={"signal1": {"value": list(range(10))}, "signal2": {"value": list(range(10))}}
+        ),
+        messages.DeviceMessage(
+            signals={
+                "signal1": {"value": list(range(10, 20))},
+                "signal2": {"value": list(range(10, 20))},
+            }
         ),
     ]
 
@@ -114,7 +117,7 @@ def test_nidaq_handle_ni_data(nidaq):
 def test_nidaq_write_data_without_filename(nidaq):
     signal = {"signal1": np.asarray(range(20)), "signal2": np.asarray(range(20))}
 
-    with mock.patch("bec_plugins.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
+    with mock.patch("debye_bec.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
         nidaq.write_data(signal)
         mock_h5py.File.assert_not_called()
 
@@ -122,7 +125,7 @@ def test_nidaq_write_data_without_filename(nidaq):
 def test_nidaq_write_data_with_filename(nidaq):
     signal = {"signal1": np.asarray(range(20)), "signal2": np.asarray(range(20))}
     nidaq.filename = "test.h5"
-    with mock.patch("bec_plugins.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
+    with mock.patch("debye_bec.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
         nidaq.write_data(signal)
         mock_h5py.File.assert_called_once_with("test.h5", "a")
 
@@ -131,7 +134,7 @@ def test_nidaq_write_data_reshape(nidaq):
     signal = {"signal1": np.asarray(range(20)), "signal2": np.asarray(range(20))}
     nidaq.filename = "test.h5"
     nidaq.reshape_dataset = True
-    with mock.patch("bec_plugins.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
+    with mock.patch("debye_bec.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
         nidaq.write_data(signal)
         mock_h5py.File.assert_called_once_with("test.h5", "a")
 
@@ -140,7 +143,7 @@ def test_nidaq_write_data_without_reshape(nidaq):
     signal = {"signal1": np.asarray(range(20)), "signal2": np.asarray(range(20))}
     nidaq.filename = "test.h5"
     nidaq.reshape_dataset = False
-    with mock.patch("bec_plugins.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
+    with mock.patch("debye_bec.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
         nidaq.write_data(signal)
         mock_h5py.File.assert_called_once_with("test.h5", "a")
         file_handle = mock_h5py.File().__enter__()
@@ -161,7 +164,7 @@ def test_nidaq_write_data_reshapes_data(nidaq):
     signal = {"signal1": np.asarray(range(20)), "signal2": np.asarray(range(20))}
     nidaq.filename = "test.h5"
     nidaq.reshape_dataset = True
-    with mock.patch("bec_plugins.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
+    with mock.patch("debye_bec.services.NIDAQ_writer.NIDAQ_writer.h5py") as mock_h5py:
         file_handle = mock_h5py.File().__enter__()
         file_handle.__contains__.side_effect = signal.__contains__
         nidaq.write_data(signal)