Merge branch 'developer' of github.com:slsdetectorgroup/slsDetectorPackage into developer

python/CMakeLists.txt

@@ -47,3 +47,6 @@ endforeach(FILE ${PYTHON_FILES})
 configure_file( scripts/basic.py  
     ${CMAKE_BINARY_DIR}/basic.py 
 )
+configure_file( scripts/test_virtual.py  
+    ${CMAKE_BINARY_DIR}/test_virtual.py 
+)

python/scripts/basic.py

@@ -2,7 +2,7 @@ import os
 import sys
 import numpy as np
 sys.path.append(os.path.join(os.getcwd(), 'bin'))
-from sls_detector import Eiger, Detector
+from sls_detector import Eiger, Detector, defs
 from sls_detector import ExperimentalDetector
 
 from _sls_detector.io import read_my302_file

python/scripts/generate_enums.py

@@ -0,0 +1,63 @@
+import re
+
+def comment_remover(text):
+    def replacer(match):
+        s = match.group(0)
+        if s.startswith('/'):
+            return " " # note: a space and not an empty string
+        else:
+            return s
+    pattern = re.compile(
+        r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
+        re.DOTALL | re.MULTILINE
+    )
+    return re.sub(pattern, replacer, text)
+
+def extract_enums(lines):
+    line_iter = iter(lines)
+    enums = {}
+    for line in line_iter:
+        m = re.search("(?<=enum )\w+(?= {)", line)
+        if m:
+            enum_name = m.group()
+            # print(enum_name)
+            fields = []
+            while True:
+                l  = next(line_iter)
+                if '};' in l:
+                    break
+                m = re.search("\w+", l)
+                try:
+                    # print('\t', m.group())
+                    fields.append(m.group())
+
+                except:
+                    pass
+            enums[enum_name] = fields
+    return enums
+
+def generate_enum_string(enums):
+    data = []
+    for key, value in enums.items():
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
+        for v in value:
+            data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
+        data.append('.export_values();\n\n')
+    return ''.join(data)
+
+with open('../../slsSupportLib/include/sls_detector_defs.h') as f:
+    data = f.read()
+
+data = comment_remover(data)
+data = data.splitlines()
+enums = extract_enums(data)
+s = generate_enum_string(enums)
+
+with open('../src/enums_in.cpp') as f:
+    data = f.read()
+
+text = data.replace('[[ENUMS]]', s)
+warning = '/* WARINING This file is auto generated any edits might be overwritten without warning */\n\n'
+with open('../src/enums.cpp', 'w') as f:
+    f.write(warning)
+    f.write(text)

python/scripts/test_virtual.py

@@ -0,0 +1,164 @@
+import pytest
+import subprocess
+import os
+import sys
+import time
+import datetime as dt
+
+sys.path.append(os.path.join(os.getcwd(), "bin"))
+from sls_detector import ExperimentalDetector, detectorSettings
+
+n_detectors = 3
+start_port = 1952
+port_step = 3
+
+
+@pytest.fixture(scope="module")
+def virtual_jf_detectors(request):
+    """
+    Fixture that is run once for the module
+    will launch virtual servers and clean up
+    after
+    """
+    print("Setting up virtual detectors")
+
+    # Ensure that no detector servers are running
+    subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
+
+    # Ensure no shared memory exists before tests start
+    d = ExperimentalDetector()
+    d.free()
+
+    # Start servers
+    virtual_jf_detectors = [
+        subprocess.Popen(
+            [
+                "bin/jungfrauDetectorServer_virtual",
+                "--port",
+                f"{start_port+port_step*i}",
+            ]
+        )
+        for i in range(n_detectors)
+    ]
+
+    # Allow server startup to complete
+    time.sleep(3)
+
+    def fin():
+        print("Cleaning up virtual detectors")
+        d = ExperimentalDetector()
+        d.free()
+        subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
+
+    request.addfinalizer(fin)
+    return virtual_jf_detectors  # provide the fixture value
+
+
+def test_shmid(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    assert d.getShmId() == 0
+    d.free()
+
+    d = ExperimentalDetector(73)
+    assert d.getShmId() == 73
+    d.free()
+
+
+def test_hostname(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    d.hostname = "localhost"
+    assert d.hostname == ["localhost"]
+
+    d.hostname = [f"localhost:{start_port+i*port_step}" for i in range(n_detectors)]
+    assert d.hostname == ["localhost"] * n_detectors
+
+
+def test_fwversion(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    assert d.detectorversion == 0  # Firmware of virtual detector
+    assert d.getFirmwareVersion() == [0] * n_detectors
+
+
+def test_len(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    assert len(d) == n_detectors
+    assert d.size() == n_detectors
+
+
+def test_module_geometry(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    geo = d.module_geometry
+    assert geo.x == 1
+    assert geo.y == 3
+
+
+def test_module_size(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    geo = d.module_size
+    assert geo.x == 1024
+    assert geo.y == 512
+
+
+def test_settings(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    assert d.settings == detectorSettings.DYNAMICGAIN
+
+    gain_list = [
+        detectorSettings.FIXGAIN1,
+        detectorSettings.FIXGAIN2,
+        detectorSettings.FORCESWITCHG1,
+        detectorSettings.FORCESWITCHG2,
+        detectorSettings.DYNAMICHG0,
+        detectorSettings.DYNAMICGAIN,
+    ]
+
+    # Set all viable gain for Jungfrau to make sure nothing is crashing
+    for gain in gain_list:
+        d.settings = gain
+        assert d.settings == gain
+
+    d.setSettings(detectorSettings.FORCESWITCHG1, [1])
+    assert d.settings == [
+        detectorSettings.DYNAMICGAIN,
+        detectorSettings.FORCESWITCHG1,
+        detectorSettings.DYNAMICGAIN,
+    ]
+
+    d.settings = detectorSettings.DYNAMICGAIN
+    assert d.settings == detectorSettings.DYNAMICGAIN
+
+def test_frames(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    d.frames = 10
+    assert d.frames == 10
+
+# def test_triggers(virtual_jf_detectors):
+
+def test_exptime(virtual_jf_detectors):
+    d = ExperimentalDetector()
+
+    #default value
+    assert d.exptime == 1e-5
+
+    d.exptime = 1.5
+    assert d.exptime == 1.5
+
+    t = dt.timedelta(microseconds=10)
+    d.exptime  = t
+    assert d.exptime == 10e-6
+
+def test_period(virtual_jf_detectors):
+    d = ExperimentalDetector()
+
+    #default value
+    d.period = 0
+    assert d.period == 0
+
+    d.period = 1.5
+    assert d.period == 1.5
+
+    t = dt.timedelta(microseconds=10)
+    d.period  = t
+    assert d.period == 10e-6
+
+    

python/sls_detector/__init__.py

@@ -6,4 +6,8 @@ from .jungfrau_ctb import JungfrauCTB
 from _sls_detector import DetectorApi
 
 import _sls_detector
+
+defs = _sls_detector.slsDetectorDefs
 runStatus = _sls_detector.slsDetectorDefs.runStatus
+detectorType = _sls_detector.slsDetectorDefs.detectorType
+detectorSettings = _sls_detector.slsDetectorDefs.detectorSettings

python/sls_detector/experimental.py

@@ -1,11 +1,13 @@
-from _sls_detector import multiDetectorApi
+from _sls_detector import CppDetectorApi
 from _sls_detector import slsDetectorDefs
 
 runStatus = slsDetectorDefs.runStatus
 from .utils import element_if_equal, all_equal
+from .utils import Geometry, to_geo
 import datetime as dt
 
 from functools import wraps
+from collections import namedtuple
 
 
 def freeze(cls):
@@ -35,13 +37,14 @@ def freeze(cls):
 
 
 @freeze
-class ExperimentalDetector(multiDetectorApi):
+class ExperimentalDetector(CppDetectorApi):
     """
     This class is the base for detector specific 
     interfaces. Most functions exists in two versions
     like the getExptime() function that uses the 
     C++ API directly and the simplified exptime property. 
     """
+
     def __init__(self, multi_id=0):
         """
         multi_id refers to the shared memory id of the 
@@ -49,6 +52,64 @@ class ExperimentalDetector(multiDetectorApi):
         """
         super().__init__(multi_id)
 
+    # CONFIGURATION
+
+    def __len__(self):
+        return self.size()
+
+    def free(self):
+        self.freeSharedMemory()
+
+    @property
+    def hostname(self):
+        return self.getHostname()
+
+    @hostname.setter
+    def hostname(self, hostnames):
+        if isinstance(hostnames, str):
+            hostnames = [hostnames]
+        if isinstance(hostnames, list):
+            self.setHostname(hostnames)
+        else:
+            raise ValueError("hostname needs to be string or list of strings")
+
+    @property
+    def detectorversion(self):
+        return element_if_equal(self.getFirmwareVersion())
+
+    @property
+    def detector_type(self):
+        return element_if_equal(self.getDetectorType())
+
+    @property
+    def module_geometry(self):
+        return to_geo(self.getModuleGeometry())
+
+    @property
+    def module_size(self):
+        ms = [to_geo(item) for item in self.getModuleSize()]
+        return element_if_equal(ms)
+
+    @property
+    def detector_size(self):
+        return to_geo(self.getDetectorSize())
+
+    @property
+    def settings(self):
+        return element_if_equal(self.getSettings())
+
+    @settings.setter
+    def settings(self, value):
+        self.setSettings(value)
+
+    @property
+    def frames(self):
+        return element_if_equal(self.getNumberOfFrames())
+
+    @frames.setter
+    def frames(self, n_frames):
+        self.setNumberOfFrames(n_frames)
+
     # Acq
     @property
     def rx_status(self):
@@ -158,6 +219,9 @@ class ExperimentalDetector(multiDetectorApi):
 
     @exptime.setter
     def exptime(self, t):
+        if isinstance(t, dt.timedelta):
+            self.setExptime(t)
+        else:
             self.setExptime(dt.timedelta(seconds=t))
 
     @property
@@ -167,6 +231,9 @@ class ExperimentalDetector(multiDetectorApi):
 
     @subexptime.setter
     def subexptime(self, t):
+        if isinstance(t, dt.timedelta):
+            self.setSubExptime(t)
+        else:
             self.setSubExptime(dt.timedelta(seconds=t))
 
     @property
@@ -176,5 +243,8 @@ class ExperimentalDetector(multiDetectorApi):
 
     @period.setter
     def period(self, t):
+        if isinstance(t, dt.timedelta):
+            self.setPeriod(t)
+        else:
             self.setPeriod(dt.timedelta(seconds=t))
 

python/sls_detector/utils.py

@@ -2,7 +2,16 @@
 Utility functions that are useful for testing and troubleshooting
 but not directly used in controlling the detector
 """
+from collections import namedtuple
+import _sls_detector #C++ lib
 
+Geometry = namedtuple('Geometry', ['x', 'y'])
+
+def to_geo(value):
+    if isinstance(value, _sls_detector.xy):
+        return Geometry(x = value.x, y = value.y)
+    else:
+        raise ValueError("Can only convert sls_detector.xy")
 
 def all_equal(mylist):
     """If all elements are equal return true otherwise false"""

python/src/enums.cpp

@@ -1,3 +1,6 @@
+/* WARINING This file is auto generated any edits might be overwritten without
+ * warning */
+
 #include <pybind11/chrono.h>
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
@@ -7,6 +10,55 @@
 namespace py = pybind11;
 void init_enums(py::module &m) {
     py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
+    py::class_<slsDetectorDefs::xy> xy(m, "xy");
+    xy.def_readwrite("x", &slsDetectorDefs::xy::x);
+    xy.def_readwrite("y", &slsDetectorDefs::xy::y);
+
+    py::enum_<slsDetectorDefs::detectorType>(Defs, "detectorType")
+        .value("GET_DETECTOR_TYPE",
+               slsDetectorDefs::detectorType::GET_DETECTOR_TYPE)
+        .value("GENERIC", slsDetectorDefs::detectorType::GENERIC)
+        .value("EIGER", slsDetectorDefs::detectorType::EIGER)
+        .value("GOTTHARD", slsDetectorDefs::detectorType::GOTTHARD)
+        .value("JUNGFRAU", slsDetectorDefs::detectorType::JUNGFRAU)
+        .value("CHIPTESTBOARD", slsDetectorDefs::detectorType::CHIPTESTBOARD)
+        .value("MOENCH", slsDetectorDefs::detectorType::MOENCH)
+        .value("MYTHEN3", slsDetectorDefs::detectorType::MYTHEN3)
+        .value("GOTTHARD2", slsDetectorDefs::detectorType::GOTTHARD2)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::timerIndex>(Defs, "timerIndex")
+        .value("FRAME_NUMBER", slsDetectorDefs::timerIndex::FRAME_NUMBER)
+        .value("ACQUISITION_TIME",
+               slsDetectorDefs::timerIndex::ACQUISITION_TIME)
+        .value("FRAME_PERIOD", slsDetectorDefs::timerIndex::FRAME_PERIOD)
+        .value("DELAY_AFTER_TRIGGER",
+               slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER)
+        .value("CYCLES_NUMBER", slsDetectorDefs::timerIndex::CYCLES_NUMBER)
+        .value("ACTUAL_TIME", slsDetectorDefs::timerIndex::ACTUAL_TIME)
+        .value("MEASUREMENT_TIME",
+               slsDetectorDefs::timerIndex::MEASUREMENT_TIME)
+        .value("PROGRESS", slsDetectorDefs::timerIndex::PROGRESS)
+        .value("FRAMES_FROM_START",
+               slsDetectorDefs::timerIndex::FRAMES_FROM_START)
+        .value("FRAMES_FROM_START_PG",
+               slsDetectorDefs::timerIndex::FRAMES_FROM_START_PG)
+        .value("ANALOG_SAMPLES", slsDetectorDefs::timerIndex::ANALOG_SAMPLES)
+        .value("DIGITAL_SAMPLES", slsDetectorDefs::timerIndex::DIGITAL_SAMPLES)
+        .value("SUBFRAME_ACQUISITION_TIME",
+               slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME)
+        .value("STORAGE_CELL_NUMBER",
+               slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER)
+        .value("SUBFRAME_DEADTIME",
+               slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME)
+        .value("MEASURED_PERIOD", slsDetectorDefs::timerIndex::MEASURED_PERIOD)
+        .value("MEASURED_SUBPERIOD",
+               slsDetectorDefs::timerIndex::MEASURED_SUBPERIOD)
+        .value("STORAGE_CELL_DELAY",
+               slsDetectorDefs::timerIndex::STORAGE_CELL_DELAY)
+        .value("MAX_TIMERS", slsDetectorDefs::timerIndex::MAX_TIMERS)
+        .export_values();
+
     py::enum_<slsDetectorDefs::runStatus>(Defs, "runStatus")
         .value("IDLE", slsDetectorDefs::runStatus::IDLE)
         .value("ERROR", slsDetectorDefs::runStatus::ERROR)
@@ -16,4 +68,320 @@ void init_enums(py::module &m) {
         .value("RUNNING", slsDetectorDefs::runStatus::RUNNING)
         .value("STOPPED", slsDetectorDefs::runStatus::STOPPED)
         .export_values();
+
+    py::enum_<slsDetectorDefs::frameDiscardPolicy>(Defs, "frameDiscardPolicy")
+        .value("GET_FRAME_DISCARD_POLICY",
+               slsDetectorDefs::frameDiscardPolicy::GET_FRAME_DISCARD_POLICY)
+        .value("NO_DISCARD", slsDetectorDefs::frameDiscardPolicy::NO_DISCARD)
+        .value("DISCARD_EMPTY_FRAMES",
+               slsDetectorDefs::frameDiscardPolicy::DISCARD_EMPTY_FRAMES)
+        .value("DISCARD_PARTIAL_FRAMES",
+               slsDetectorDefs::frameDiscardPolicy::DISCARD_PARTIAL_FRAMES)
+        .value("NUM_DISCARD_POLICIES",
+               slsDetectorDefs::frameDiscardPolicy::NUM_DISCARD_POLICIES)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::fileFormat>(Defs, "fileFormat")
+        .value("GET_FILE_FORMAT", slsDetectorDefs::fileFormat::GET_FILE_FORMAT)
+        .value("BINARY", slsDetectorDefs::fileFormat::BINARY)
+        .value("HDF5", slsDetectorDefs::fileFormat::HDF5)
+        .value("NUM_FILE_FORMATS",
+               slsDetectorDefs::fileFormat::NUM_FILE_FORMATS)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::networkParameter>(Defs, "networkParameter")
+        .value("DETECTOR_MAC", slsDetectorDefs::networkParameter::DETECTOR_MAC)
+        .value("DETECTOR_IP", slsDetectorDefs::networkParameter::DETECTOR_IP)
+        .value("RECEIVER_HOSTNAME",
+               slsDetectorDefs::networkParameter::RECEIVER_HOSTNAME)
+        .value("RECEIVER_UDP_IP",
+               slsDetectorDefs::networkParameter::RECEIVER_UDP_IP)
+        .value("RECEIVER_UDP_PORT",
+               slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT)
+        .value("RECEIVER_UDP_MAC",
+               slsDetectorDefs::networkParameter::RECEIVER_UDP_MAC)
+        .value("RECEIVER_UDP_PORT2",
+               slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT2)
+        .value("DETECTOR_TXN_DELAY_LEFT",
+               slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT)
+        .value("DETECTOR_TXN_DELAY_RIGHT",
+               slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT)
+        .value("DETECTOR_TXN_DELAY_FRAME",
+               slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME)
+        .value("FLOW_CONTROL_10G",
+               slsDetectorDefs::networkParameter::FLOW_CONTROL_10G)
+        .value("FLOW_CONTROL_WR_PTR",
+               slsDetectorDefs::networkParameter::FLOW_CONTROL_WR_PTR)
+        .value("FLOW_CONTROL_RD_PTR",
+               slsDetectorDefs::networkParameter::FLOW_CONTROL_RD_PTR)
+        .value("RECEIVER_STREAMING_PORT",
+               slsDetectorDefs::networkParameter::RECEIVER_STREAMING_PORT)
+        .value("CLIENT_STREAMING_PORT",
+               slsDetectorDefs::networkParameter::CLIENT_STREAMING_PORT)
+        .value("RECEIVER_STREAMING_SRC_IP",
+               slsDetectorDefs::networkParameter::RECEIVER_STREAMING_SRC_IP)
+        .value("CLIENT_STREAMING_SRC_IP",
+               slsDetectorDefs::networkParameter::CLIENT_STREAMING_SRC_IP)
+        .value("ADDITIONAL_JSON_HEADER",
+               slsDetectorDefs::networkParameter::ADDITIONAL_JSON_HEADER)
+        .value("RECEIVER_UDP_SCKT_BUF_SIZE",
+               slsDetectorDefs::networkParameter::RECEIVER_UDP_SCKT_BUF_SIZE)
+        .value(
+            "RECEIVER_REAL_UDP_SCKT_BUF_SIZE",
+            slsDetectorDefs::networkParameter::RECEIVER_REAL_UDP_SCKT_BUF_SIZE)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::numberOf>(Defs, "numberOf")
+        .value("MAXMODX", slsDetectorDefs::numberOf::MAXMODX)
+        .value("MAXMODY", slsDetectorDefs::numberOf::MAXMODY)
+        .value("NMODX", slsDetectorDefs::numberOf::NMODX)
+        .value("NMODY", slsDetectorDefs::numberOf::NMODY)
+        .value("NCHANSX", slsDetectorDefs::numberOf::NCHANSX)
+        .value("NCHANSY", slsDetectorDefs::numberOf::NCHANSY)
+        .value("NCHIPSX", slsDetectorDefs::numberOf::NCHIPSX)
+        .value("NCHIPSY", slsDetectorDefs::numberOf::NCHIPSY)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::dimension>(Defs, "dimension")
+        .value("X", slsDetectorDefs::dimension::X)
+        .value("Y", slsDetectorDefs::dimension::Y)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::externalSignalFlag>(Defs, "externalSignalFlag")
+        .value("GET_EXTERNAL_SIGNAL_FLAG",
+               slsDetectorDefs::externalSignalFlag::GET_EXTERNAL_SIGNAL_FLAG)
+        .value("SIGNAL_OFF", slsDetectorDefs::externalSignalFlag::SIGNAL_OFF)
+        .value("GATE_IN_ACTIVE_HIGH",
+               slsDetectorDefs::externalSignalFlag::GATE_IN_ACTIVE_HIGH)
+        .value("GATE_IN_ACTIVE_LOW",
+               slsDetectorDefs::externalSignalFlag::GATE_IN_ACTIVE_LOW)
+        .value("TRIGGER_IN_RISING_EDGE",
+               slsDetectorDefs::externalSignalFlag::TRIGGER_IN_RISING_EDGE)
+        .value("TRIGGER_IN_FALLING_EDGE",
+               slsDetectorDefs::externalSignalFlag::TRIGGER_IN_FALLING_EDGE)
+        .value("RO_TRIGGER_IN_RISING_EDGE",
+               slsDetectorDefs::externalSignalFlag::RO_TRIGGER_IN_RISING_EDGE)
+        .value("RO_TRIGGER_IN_FALLING_EDGE",
+               slsDetectorDefs::externalSignalFlag::RO_TRIGGER_IN_FALLING_EDGE)
+        .value("GATE_OUT_ACTIVE_HIGH",
+               slsDetectorDefs::externalSignalFlag::GATE_OUT_ACTIVE_HIGH)
+        .value("GATE_OUT_ACTIVE_LOW",
+               slsDetectorDefs::externalSignalFlag::GATE_OUT_ACTIVE_LOW)
+        .value("TRIGGER_OUT_RISING_EDGE",
+               slsDetectorDefs::externalSignalFlag::TRIGGER_OUT_RISING_EDGE)
+        .value("TRIGGER_OUT_FALLING_EDGE",
+               slsDetectorDefs::externalSignalFlag::TRIGGER_OUT_FALLING_EDGE)
+        .value("RO_TRIGGER_OUT_RISING_EDGE",
+               slsDetectorDefs::externalSignalFlag::RO_TRIGGER_OUT_RISING_EDGE)
+        .value("RO_TRIGGER_OUT_FALLING_EDGE",
+               slsDetectorDefs::externalSignalFlag::RO_TRIGGER_OUT_FALLING_EDGE)
+        .value("OUTPUT_LOW", slsDetectorDefs::externalSignalFlag::OUTPUT_LOW)
+        .value("OUTPUT_HIGH", slsDetectorDefs::externalSignalFlag::OUTPUT_HIGH)
+        .value(
+            "MASTER_SLAVE_SYNCHRONIZATION",
+            slsDetectorDefs::externalSignalFlag::MASTER_SLAVE_SYNCHRONIZATION)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::timingMode>(Defs, "timingMode")
+        .value("GET_TIMING_MODE", slsDetectorDefs::timingMode::GET_TIMING_MODE)
+        .value("AUTO_TIMING", slsDetectorDefs::timingMode::AUTO_TIMING)
+        .value("TRIGGER_EXPOSURE",
+               slsDetectorDefs::timingMode::TRIGGER_EXPOSURE)
+        .value("GATED", slsDetectorDefs::timingMode::GATED)
+        .value("BURST_TRIGGER", slsDetectorDefs::timingMode::BURST_TRIGGER)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::idMode>(Defs, "idMode")
+        .value("DETECTOR_SERIAL_NUMBER",
+               slsDetectorDefs::idMode::DETECTOR_SERIAL_NUMBER)
+        .value("DETECTOR_FIRMWARE_VERSION",
+               slsDetectorDefs::idMode::DETECTOR_FIRMWARE_VERSION)
+        .value("DETECTOR_SOFTWARE_VERSION",
+               slsDetectorDefs::idMode::DETECTOR_SOFTWARE_VERSION)
+        .value("THIS_SOFTWARE_VERSION",
+               slsDetectorDefs::idMode::THIS_SOFTWARE_VERSION)
+        .value("RECEIVER_VERSION", slsDetectorDefs::idMode::RECEIVER_VERSION)
+        .value("SOFTWARE_FIRMWARE_API_VERSION",
+               slsDetectorDefs::idMode::SOFTWARE_FIRMWARE_API_VERSION)
+        .value("CLIENT_SOFTWARE_API_VERSION",
+               slsDetectorDefs::idMode::CLIENT_SOFTWARE_API_VERSION)
+        .value("CLIENT_RECEIVER_API_VERSION",
+               slsDetectorDefs::idMode::CLIENT_RECEIVER_API_VERSION)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::digitalTestMode>(Defs, "digitalTestMode")
+        .value("DETECTOR_FIRMWARE_TEST",
+               slsDetectorDefs::digitalTestMode::DETECTOR_FIRMWARE_TEST)
+        .value("DETECTOR_BUS_TEST",
+               slsDetectorDefs::digitalTestMode::DETECTOR_BUS_TEST)
+        .value("IMAGE_TEST", slsDetectorDefs::digitalTestMode::IMAGE_TEST)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::dacIndex>(Defs, "dacIndex")
+        .value("THRESHOLD", slsDetectorDefs::dacIndex::THRESHOLD)
+        .value("CALIBRATION_PULSE",
+               slsDetectorDefs::dacIndex::CALIBRATION_PULSE)
+        .value("TRIMBIT_SIZE", slsDetectorDefs::dacIndex::TRIMBIT_SIZE)
+        .value("PREAMP", slsDetectorDefs::dacIndex::PREAMP)
+        .value("SHAPER1", slsDetectorDefs::dacIndex::SHAPER1)
+        .value("SHAPER2", slsDetectorDefs::dacIndex::SHAPER2)
+        .value("TEMPERATURE_ADC", slsDetectorDefs::dacIndex::TEMPERATURE_ADC)
+        .value("TEMPERATURE_FPGA", slsDetectorDefs::dacIndex::TEMPERATURE_FPGA)
+        .value("HUMIDITY", slsDetectorDefs::dacIndex::HUMIDITY)
+        .value("DETECTOR_BIAS", slsDetectorDefs::dacIndex::DETECTOR_BIAS)
+        .value("VA_POT", slsDetectorDefs::dacIndex::VA_POT)
+        .value("VDD_POT", slsDetectorDefs::dacIndex::VDD_POT)
+        .value("VSH_POT", slsDetectorDefs::dacIndex::VSH_POT)
+        .value("VIO_POT", slsDetectorDefs::dacIndex::VIO_POT)
+        .value("G_VREF_DS", slsDetectorDefs::dacIndex::G_VREF_DS)
+        .value("G_VCASCN_PB", slsDetectorDefs::dacIndex::G_VCASCN_PB)
+        .value("G_VCASCP_PB", slsDetectorDefs::dacIndex::G_VCASCP_PB)
+        .value("G_VOUT_CM", slsDetectorDefs::dacIndex::G_VOUT_CM)
+        .value("G_VCASC_OUT", slsDetectorDefs::dacIndex::G_VCASC_OUT)
+        .value("G_VIN_CM", slsDetectorDefs::dacIndex::G_VIN_CM)
+        .value("G_VREF_COMP", slsDetectorDefs::dacIndex::G_VREF_COMP)
+        .value("G_IB_TESTC", slsDetectorDefs::dacIndex::G_IB_TESTC)
+        .value("E_SvP", slsDetectorDefs::dacIndex::E_SvP)
+        .value("E_SvN", slsDetectorDefs::dacIndex::E_SvN)
+        .value("E_Vtr", slsDetectorDefs::dacIndex::E_Vtr)
+        .value("E_Vrf", slsDetectorDefs::dacIndex::E_Vrf)
+        .value("E_Vrs", slsDetectorDefs::dacIndex::E_Vrs)
+        .value("E_Vtgstv", slsDetectorDefs::dacIndex::E_Vtgstv)
+        .value("E_Vcmp_ll", slsDetectorDefs::dacIndex::E_Vcmp_ll)
+        .value("E_Vcmp_lr", slsDetectorDefs::dacIndex::E_Vcmp_lr)
+        .value("E_cal", slsDetectorDefs::dacIndex::E_cal)
+        .value("E_Vcmp_rl", slsDetectorDefs::dacIndex::E_Vcmp_rl)
+        .value("E_Vcmp_rr", slsDetectorDefs::dacIndex::E_Vcmp_rr)
+        .value("E_rxb_rb", slsDetectorDefs::dacIndex::E_rxb_rb)
+        .value("E_rxb_lb", slsDetectorDefs::dacIndex::E_rxb_lb)
+        .value("E_Vcp", slsDetectorDefs::dacIndex::E_Vcp)
+        .value("E_Vcn", slsDetectorDefs::dacIndex::E_Vcn)
+        .value("E_Vis", slsDetectorDefs::dacIndex::E_Vis)
+        .value("IO_DELAY", slsDetectorDefs::dacIndex::IO_DELAY)
+        .value("ADC_VPP", slsDetectorDefs::dacIndex::ADC_VPP)
+        .value("HIGH_VOLTAGE", slsDetectorDefs::dacIndex::HIGH_VOLTAGE)
+        .value("TEMPERATURE_FPGAEXT",
+               slsDetectorDefs::dacIndex::TEMPERATURE_FPGAEXT)
+        .value("TEMPERATURE_10GE", slsDetectorDefs::dacIndex::TEMPERATURE_10GE)
+        .value("TEMPERATURE_DCDC", slsDetectorDefs::dacIndex::TEMPERATURE_DCDC)
+        .value("TEMPERATURE_SODL", slsDetectorDefs::dacIndex::TEMPERATURE_SODL)
+        .value("TEMPERATURE_SODR", slsDetectorDefs::dacIndex::TEMPERATURE_SODR)
+        .value("TEMPERATURE_FPGA2",
+               slsDetectorDefs::dacIndex::TEMPERATURE_FPGA2)
+        .value("TEMPERATURE_FPGA3",
+               slsDetectorDefs::dacIndex::TEMPERATURE_FPGA3)
+        .value("M_vIpre", slsDetectorDefs::dacIndex::M_vIpre)
+        .value("M_vIbias", slsDetectorDefs::dacIndex::M_vIbias)
+        .value("M_vIinSh", slsDetectorDefs::dacIndex::M_vIinSh)
+        .value("M_VdcSh", slsDetectorDefs::dacIndex::M_VdcSh)
+        .value("M_Vth2", slsDetectorDefs::dacIndex::M_Vth2)
+        .value("M_VPL", slsDetectorDefs::dacIndex::M_VPL)
+        .value("M_Vth3", slsDetectorDefs::dacIndex::M_Vth3)
+        .value("M_casSh", slsDetectorDefs::dacIndex::M_casSh)
+        .value("M_cas", slsDetectorDefs::dacIndex::M_cas)
+        .value("M_vIbiasSh", slsDetectorDefs::dacIndex::M_vIbiasSh)
+        .value("M_vIcin", slsDetectorDefs::dacIndex::M_vIcin)
+        .value("M_vIpreOut", slsDetectorDefs::dacIndex::M_vIpreOut)
+        .value("V_POWER_A", slsDetectorDefs::dacIndex::V_POWER_A)
+        .value("V_POWER_B", slsDetectorDefs::dacIndex::V_POWER_B)
+        .value("V_POWER_C", slsDetectorDefs::dacIndex::V_POWER_C)
+        .value("V_POWER_D", slsDetectorDefs::dacIndex::V_POWER_D)
+        .value("V_POWER_IO", slsDetectorDefs::dacIndex::V_POWER_IO)
+        .value("V_POWER_CHIP", slsDetectorDefs::dacIndex::V_POWER_CHIP)
+        .value("I_POWER_A", slsDetectorDefs::dacIndex::I_POWER_A)
+        .value("I_POWER_B", slsDetectorDefs::dacIndex::I_POWER_B)
+        .value("I_POWER_C", slsDetectorDefs::dacIndex::I_POWER_C)
+        .value("I_POWER_D", slsDetectorDefs::dacIndex::I_POWER_D)
+        .value("I_POWER_IO", slsDetectorDefs::dacIndex::I_POWER_IO)
+        .value("V_LIMIT", slsDetectorDefs::dacIndex::V_LIMIT)
+        .value("SLOW_ADC0", slsDetectorDefs::dacIndex::SLOW_ADC0)
+        .value("SLOW_ADC1", slsDetectorDefs::dacIndex::SLOW_ADC1)
+        .value("SLOW_ADC2", slsDetectorDefs::dacIndex::SLOW_ADC2)
+        .value("SLOW_ADC3", slsDetectorDefs::dacIndex::SLOW_ADC3)
+        .value("SLOW_ADC4", slsDetectorDefs::dacIndex::SLOW_ADC4)
+        .value("SLOW_ADC5", slsDetectorDefs::dacIndex::SLOW_ADC5)
+        .value("SLOW_ADC6", slsDetectorDefs::dacIndex::SLOW_ADC6)
+        .value("SLOW_ADC7", slsDetectorDefs::dacIndex::SLOW_ADC7)
+        .value("SLOW_ADC_TEMP", slsDetectorDefs::dacIndex::SLOW_ADC_TEMP)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::detectorSettings>(Defs, "detectorSettings")
+        .value("GET_SETTINGS", slsDetectorDefs::detectorSettings::GET_SETTINGS)
+        .value("STANDARD", slsDetectorDefs::detectorSettings::STANDARD)
+        .value("FAST", slsDetectorDefs::detectorSettings::FAST)
+        .value("HIGHGAIN", slsDetectorDefs::detectorSettings::HIGHGAIN)
+        .value("DYNAMICGAIN", slsDetectorDefs::detectorSettings::DYNAMICGAIN)
+        .value("LOWGAIN", slsDetectorDefs::detectorSettings::LOWGAIN)
+        .value("MEDIUMGAIN", slsDetectorDefs::detectorSettings::MEDIUMGAIN)
+        .value("VERYHIGHGAIN", slsDetectorDefs::detectorSettings::VERYHIGHGAIN)
+        .value("DYNAMICHG0", slsDetectorDefs::detectorSettings::DYNAMICHG0)
+        .value("FIXGAIN1", slsDetectorDefs::detectorSettings::FIXGAIN1)
+        .value("FIXGAIN2", slsDetectorDefs::detectorSettings::FIXGAIN2)
+        .value("FORCESWITCHG1",
+               slsDetectorDefs::detectorSettings::FORCESWITCHG1)
+        .value("FORCESWITCHG2",
+               slsDetectorDefs::detectorSettings::FORCESWITCHG2)
+        .value("VERYLOWGAIN", slsDetectorDefs::detectorSettings::VERYLOWGAIN)
+        .value("UNDEFINED", slsDetectorDefs::detectorSettings::UNDEFINED)
+        .value("UNINITIALIZED",
+               slsDetectorDefs::detectorSettings::UNINITIALIZED)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::speedVariable>(Defs, "speedVariable")
+        .value("CLOCK_DIVIDER", slsDetectorDefs::speedVariable::CLOCK_DIVIDER)
+        .value("ADC_CLOCK", slsDetectorDefs::speedVariable::ADC_CLOCK)
+        .value("ADC_PHASE", slsDetectorDefs::speedVariable::ADC_PHASE)
+        .value("ADC_PIPELINE", slsDetectorDefs::speedVariable::ADC_PIPELINE)
+        .value("DBIT_CLOCK", slsDetectorDefs::speedVariable::DBIT_CLOCK)
+        .value("DBIT_PHASE", slsDetectorDefs::speedVariable::DBIT_PHASE)
+        .value("DBIT_PIPELINE", slsDetectorDefs::speedVariable::DBIT_PIPELINE)
+        .value("MAX_ADC_PHASE_SHIFT",
+               slsDetectorDefs::speedVariable::MAX_ADC_PHASE_SHIFT)
+        .value("MAX_DBIT_PHASE_SHIFT",
+               slsDetectorDefs::speedVariable::MAX_DBIT_PHASE_SHIFT)
+        .value("SYNC_CLOCK", slsDetectorDefs::speedVariable::SYNC_CLOCK)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::readoutMode>(Defs, "readoutMode")
+        .value("ANALOG_ONLY", slsDetectorDefs::readoutMode::ANALOG_ONLY)
+        .value("DIGITAL_ONLY", slsDetectorDefs::readoutMode::DIGITAL_ONLY)
+        .value("ANALOG_AND_DIGITAL",
+               slsDetectorDefs::readoutMode::ANALOG_AND_DIGITAL)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::speedLevel>(Defs, "speedLevel")
+        .value("FULL_SPEED", slsDetectorDefs::speedLevel::FULL_SPEED)
+        .value("HALF_SPEED", slsDetectorDefs::speedLevel::HALF_SPEED)
+        .value("QUARTER_SPEED", slsDetectorDefs::speedLevel::QUARTER_SPEED)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::portType>(Defs, "portType")
+        .value("CONTROL_PORT", slsDetectorDefs::portType::CONTROL_PORT)
+        .value("STOP_PORT", slsDetectorDefs::portType::STOP_PORT)
+        .value("DATA_PORT", slsDetectorDefs::portType::DATA_PORT)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::masterFlags>(Defs, "masterFlags")
+        .value("GET_MASTER", slsDetectorDefs::masterFlags::GET_MASTER)
+        .value("NO_MASTER", slsDetectorDefs::masterFlags::NO_MASTER)
+        .value("IS_MASTER", slsDetectorDefs::masterFlags::IS_MASTER)
+        .value("IS_SLAVE", slsDetectorDefs::masterFlags::IS_SLAVE)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::frameModeType>(Defs, "frameModeType")
+        .value("GET_FRAME_MODE", slsDetectorDefs::frameModeType::GET_FRAME_MODE)
+        .value("PEDESTAL", slsDetectorDefs::frameModeType::PEDESTAL)
+        .value("NEW_PEDESTAL", slsDetectorDefs::frameModeType::NEW_PEDESTAL)
+        .value("FLATFIELD", slsDetectorDefs::frameModeType::FLATFIELD)
+        .value("NEW_FLATFIELD", slsDetectorDefs::frameModeType::NEW_FLATFIELD)
+        .export_values();
+
+    py::enum_<slsDetectorDefs::detectorModeType>(Defs, "detectorModeType")
+        .value("GET_DETECTOR_MODE",
+               slsDetectorDefs::detectorModeType::GET_DETECTOR_MODE)
+        .value("COUNTING", slsDetectorDefs::detectorModeType::COUNTING)
+        .value("INTERPOLATING",
+               slsDetectorDefs::detectorModeType::INTERPOLATING)
+        .value("ANALOG", slsDetectorDefs::detectorModeType::ANALOG)
+        .export_values();
 }

python/src/enums_in.cpp

@@ -0,0 +1,16 @@
+#include <pybind11/chrono.h>
+#include <pybind11/operators.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "sls_detector_defs.h"
+namespace py = pybind11;
+void init_enums(py::module &m) {
+    py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
+    py::class_<slsDetectorDefs::xy> xy(m, "xy");
+    xy.def_readwrite("x", &slsDetectorDefs::xy::x);
+    xy.def_readwrite("y", &slsDetectorDefs::xy::y);
+
+[[ENUMS]]
+
+}

python/src/experimental.cpp

@@ -4,28 +4,247 @@
 #include <pybind11/stl.h>
 
 #include "Detector.h"
+#include "ToString.h"
+#include "network_utils.h"
 #include "sls_detector_defs.h"
 #include "typecaster.h"
 namespace py = pybind11;
 void init_experimental(py::module &m) {
-    // Experimental API to use the multi directly and inherit from to reduce
-    // code duplication need to investigate how to handle documentation
     using sls::Detector;
     using sls::Positions;
-    py::class_<Detector> multiDetectorApi(m, "multiDetectorApi");
+
-    multiDetectorApi
+    py::class_<Detector> CppDetectorApi(m, "CppDetectorApi");
+    CppDetectorApi
         .def(py::init<int>())
 
-        // Acq related
+        // Configuration
+        .def("freeSharedMemory", &Detector::freeSharedMemory)
+        .def("loadConfig", &Detector::loadConfig)
+        .def("loadParameters", &Detector::loadParameters)
+        .def("setHostname", &Detector::setHostname)
+        .def("getHostname", &Detector::getHostname, py::arg() = Positions{})
+        .def("getShmId", &Detector::getShmId)
+        .def("getFirmwareVersion", &Detector::getFirmwareVersion,
+             py::arg() = Positions{})
+        .def("getDetectorServerVersion", &Detector::getDetectorServerVersion,
+             py::arg() = Positions{})
+        .def("getSerialNumber", &Detector::getSerialNumber,
+             py::arg() = Positions{})
+        .def("getClientVersion", &Detector::getClientVersion)
+        .def("getReceiverVersion", &Detector::getReceiverVersion,
+             py::arg() = Positions{})
+        .def("getDetectorType", &Detector::getDetectorType,
+             py::arg() = Positions{})
+        .def("size", &Detector::size)
+        .def("getModuleGeometry", &Detector::getModuleGeometry)
+        .def("getModuleSize", &Detector::getModuleSize, py::arg() = Positions{})
+        .def("getDetectorSize", &Detector::getDetectorSize)
+        .def("setDetectorSize", &Detector::setDetectorSize)
+        .def("getSettings", &Detector::getSettings, py::arg() = Positions{})
+        .def("setSettings", &Detector::setSettings, py::arg(),
+             py::arg() = Positions{})
+
+        // TODO! Python funcs for callbacks?
+
+        // Acquisition Parameters
+        .def("getNumberOfFrames", &Detector::getNumberOfFrames)
+        .def("setNumberOfFrames", &Detector::setNumberOfFrames)
+        .def("getNumberOfTriggers", &Detector::getNumberOfTriggers)
+        .def("setNumberOfTriggers", &Detector::setNumberOfTriggers)
+        .def("setExptime", &Detector::setExptime, py::arg(),
+             py::arg() = Positions{})
+        .def("getExptime", &Detector::getExptime, py::arg() = Positions{})
+        .def("setPeriod", &Detector::setPeriod, py::arg(),
+             py::arg() = Positions{})
+        .def("getPeriod", &Detector::getPeriod, py::arg() = Positions{})
+        .def("getDelayAfterTrigger", &Detector::getDelayAfterTrigger,
+             py::arg() = Positions{})
+        .def("setDelayAfterTrigger", &Detector::setDelayAfterTrigger, py::arg(),
+             py::arg() = Positions{})
+        .def("getNumberOfFramesLeft", &Detector::getNumberOfFramesLeft,
+             py::arg() = Positions{})
+        .def("getNumberOfTriggersLeft", &Detector::getNumberOfTriggersLeft,
+             py::arg() = Positions{})
+        .def("getDelayAfterTriggerLeft", &Detector::getDelayAfterTriggerLeft,
+             py::arg() = Positions{})
+        .def("getSpeed", &Detector::getSpeed, py::arg() = Positions{})
+        .def("setSpeed", &Detector::setSpeed, py::arg(),
+             py::arg() = Positions{})
+        .def("getADCPhase", &Detector::getADCPhase, py::arg() = Positions{})
+
+        .def("setADCPhase", &Detector::setADCPhase, py::arg(),
+             py::arg() = Positions{})
+        .def("getADCPhaseInDegrees", &Detector::getADCPhaseInDegrees,
+             py::arg() = Positions{})
+        .def("setADCPhaseInDegrees", &Detector::setADCPhaseInDegrees, py::arg(),
+             py::arg() = Positions{})
+        .def("getHighVoltage", &Detector::getHighVoltage,
+             py::arg() = Positions{})
+        .def("setHighVoltage", &Detector::setHighVoltage, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getTemperature", &Detector::getTemperature, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getDAC", &Detector::getDAC, py::arg(), py::arg(),
+             py::arg() = Positions{})
+        .def("setDAC", &Detector::setDAC, py::arg(), py::arg(), py::arg(),
+             py::arg() = Positions{})
+
+        .def("getTimingMode", &Detector::getTimingMode, py::arg() = Positions{})
+
+        .def("setTimingMode", &Detector::setTimingMode, py::arg(),
+             py::arg() = Positions{})
+
+        // ACQUISITION
         .def("acquire", &Detector::acquire)
+        .def("startAcquisition", &Detector::startAcquisition)
+        .def("stopAcquisition", &Detector::stopAcquisition)
         .def("clearAcquiringFlag", &Detector::clearAcquiringFlag)
+        .def("getDetectorStatus", &Detector::getDetectorStatus,
+             py::arg() = Positions{})
         .def("getReceiverStatus", &Detector::getReceiverStatus,
              py::arg() = Positions{})
 
-        // Configuration
+        .def("getFramesCaught", &Detector::getFramesCaught,
-        .def("free", &Detector::freeSharedMemory)
+             py::arg() = Positions{})
-        .def("loadConfig", &Detector::loadConfig)
+
-        .def("getHostname", &Detector::getHostname, py::arg() = Positions{})
+        .def("getStartingFrameNumber", &Detector::getStartingFrameNumber,
+             py::arg() = Positions{})
+        .def("setStartingFrameNumber", &Detector::setStartingFrameNumber,
+             py::arg(), py::arg() = Positions{})
+
+        .def("sendSoftwareTrigger", &Detector::sendSoftwareTrigger,
+             py::arg() = Positions{})
+
+        // Network Configuration (Detector<->Receiver)
+        .def("configureMAC", &Detector::configureMAC, py::arg() = Positions{})
+        .def("getNumberofUDPInterfaces", &Detector::getNumberofUDPInterfaces,
+             py::arg() = Positions{})
+
+        .def("setNumberofUDPInterfaces", &Detector::setNumberofUDPInterfaces,
+             py::arg(), py::arg() = Positions{})
+        .def("getSelectedUDPInterface", &Detector::getSelectedUDPInterface,
+             py::arg() = Positions{})
+
+        .def("selectUDPInterface", &Detector::selectUDPInterface, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getSourceUDPIP",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getSourceUDPIP())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setSourceUDPIP", &Detector::setSourceUDPIP, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getSourceUDPIP2",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getSourceUDPIP2())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setSourceUDPIP2", &Detector::setSourceUDPIP2, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getSourceUDPMAC",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getSourceUDPMAC())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setSourceUDPMAC", &Detector::setSourceUDPMAC, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getSourceUDPMAC2",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getSourceUDPMAC2())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setSourceUDPMAC2", &Detector::setSourceUDPMAC2, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getDestinationUDPIP",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getDestinationUDPIP())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setDestinationUDPIP", &Detector::setDestinationUDPIP, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getDestinationUDPIP2",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getDestinationUDPIP2())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setDestinationUDPIP2", &Detector::setDestinationUDPIP2, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getDestinationUDPMAC",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getDestinationUDPMAC())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setDestinationUDPMAC", &Detector::setDestinationUDPMAC, py::arg(),
+             py::arg() = Positions{})
+
+        .def("getDestinationUDPMAC2",
+             [](const Detector &d) {
+                 std::vector<std::string> res;
+                 for (const auto &s : d.getDestinationUDPMAC2())
+                     res.push_back(s.str());
+                 return res;
+             })
+        .def("setDestinationUDPMAC2", &Detector::setDestinationUDPMAC2,
+             py::arg(), py::arg() = Positions{})
+
+        .def("getDestinationUDPPort", &Detector::getDestinationUDPPort,
+             py::arg() = Positions{})
+        .def("setDestinationUDPPort", &Detector::setDestinationUDPPort,
+             py::arg(), py::arg() = Positions{})
+        .def("getDestinationUDPPort2", &Detector::getDestinationUDPPort2,
+             py::arg() = Positions{})
+        .def("setDestinationUDPPort2", &Detector::setDestinationUDPPort2,
+             py::arg(), py::arg() = Positions{})
+
+        .def("printRxConfiguration", &Detector::printRxConfiguration,
+             py::arg() = Positions{})
+
+        .def("getTenGiga", &Detector::getTenGiga, py::arg() = Positions{})
+        .def("setTenGiga", &Detector::setTenGiga, py::arg(),
+             py::arg() = Positions{})
+        .def("getTenGigaFlowControl", &Detector::getTenGigaFlowControl,
+             py::arg() = Positions{})
+        .def("setTenGigaFlowControl", &Detector::setTenGigaFlowControl,
+             py::arg(), py::arg() = Positions{})
+        .def("getTransmissionDelayFrame", &Detector::getTransmissionDelayFrame,
+             py::arg() = Positions{})
+        .def("setTransmissionDelayFrame", &Detector::setTransmissionDelayFrame,
+             py::arg(), py::arg() = Positions{})
+
+        .def("getTransmissionDelayLeft", &Detector::getTransmissionDelayLeft,
+             py::arg() = Positions{})
+        .def("setTransmissionDelayLeft", &Detector::setTransmissionDelayLeft,
+             py::arg(), py::arg() = Positions{})
+        .def("getTransmissionDelayRight", &Detector::getTransmissionDelayRight,
+             py::arg() = Positions{})
+        .def("setTransmissionDelayRight", &Detector::setTransmissionDelayRight,
+             py::arg(), py::arg() = Positions{})
+
+
+
 
         // Bits and registers
         .def("setBit", &Detector::setBit, py::arg(), py::arg(),
@@ -42,9 +261,11 @@ void init_experimental(py::module &m) {
 
         // File
         .def("getFileNamePrefix", &Detector::getFileNamePrefix)
-        .def("setFileNamePrefix", &Detector::setFileNamePrefix, py::arg(),py::arg() = Positions{})
+        .def("setFileNamePrefix", &Detector::setFileNamePrefix, py::arg(),
+             py::arg() = Positions{})
         .def("getFilePath", &Detector::getFilePath)
-        .def("setFilePath", &Detector::setFilePath, py::arg(),py::arg() = Positions{})
+        .def("setFilePath", &Detector::setFilePath, py::arg(),
+             py::arg() = Positions{})
         .def("setFileWrite", &Detector::setFileWrite, py::arg(),
              py::arg() = Positions{})
         .def("getFileWrite", &Detector::getFileWrite, py::arg() = Positions{})
@@ -54,12 +275,7 @@ void init_experimental(py::module &m) {
              py::arg() = Positions{})
 
         // Time
-        .def("setExptime", &Detector::setExptime, py::arg(),
+
-             py::arg() = Positions{})
-        .def("getExptime", &Detector::getExptime, py::arg() = Positions{})
-        .def("setPeriod", &Detector::setPeriod, py::arg(),
-             py::arg() = Positions{})
-        .def("getPeriod", &Detector::getPeriod, py::arg() = Positions{})
         .def("setSubExptime", &Detector::setSubExptime, py::arg(),
              py::arg() = Positions{})
         .def("getSubExptime", &Detector::getSubExptime,

sample/time.cpp

@@ -0,0 +1,46 @@
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <memory>
+
+#include "Result.h"
+#include "Detector.h"
+#include "container_utils.h"
+#include "ToString.h"
+#include <algorithm>
+
+std::chrono::nanoseconds to_nano(double val, const std::string &unit) {
+    if (unit == "us")
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::duration<double, std::micro>(val));
+    else if (unit == "ms")
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::duration<double, std::milli>(val));
+    else if (unit == "s")
+        return std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::duration<double>(val));
+}
+
+int main() {
+
+    // std::cout << "5.8 us is " << to_nano(5.8, "us").count() << " ns\n";
+    // std::cout << "7 ms is " << to_nano(7, "ms").count() << " ns\n";
+    // std::cout << "3.123 s is " << to_nano(3.123, "s").count() << " ns\n";
+
+    // sls::Result<int> res{1,0,6,4,0,4};
+
+    
+    // std::unique_ptr<sls::Detector> 
+    auto d = sls::make_unique<sls::Detector>(0);
+
+    std::cout << d->getHostname() << "\n";
+
+    auto s= sls::ToString(d->getHostname());
+    std::cout << s << "\n";
+
+    std::string str;
+    for (const auto& s : d->getHostname())
+        str += s;
+    std::cout << str << "\n";
+
+}

slsDetectorServers/mythen3DetectorServer/CMakeLists.txt

@@ -3,8 +3,11 @@ add_executable(mythen3DetectorServer_virtual
     ../slsDetectorServer/src/slsDetectorServer.c
     ../slsDetectorServer/src/slsDetectorServer_funcs.c
     ../slsDetectorServer/src/communication_funcs.c
-    ../slsDetectorServer/src/blackfin.c    
+    # ../slsDetectorServer/src/blackfin.c    
     ../slsDetectorServer/src/communication_funcs_UDP.c  
+    ../slsDetectorServer/src/DAC6571.c      
+    ../slsDetectorServer/src/common.c 
+    ../slsDetectorServer/src/nios.c  
 )
 
 include_directories(

slsDetectorSoftware/include/Detector.h

@@ -365,10 +365,10 @@ class Detector {
     void setTenGiga(bool enable, Positions pos = {});
 
     /** [Eiger, Jungfrau] */
-    Result<bool> getTenGigaGFlowControl(Positions pos = {}) const;
+    Result<bool> getTenGigaFlowControl(Positions pos = {}) const;
 
     /** [Eiger, Jungfrau] */
-    void setTenGigaGFlowControl(bool enable, Positions pos = {});
+    void setTenGigaFlowControl(bool enable, Positions pos = {});
 
     /** [Eiger, Jungfrau] */
     Result<int> getTransmissionDelayFrame(Positions pos = {}) const;

slsDetectorSoftware/src/Detector.cpp

@@ -443,12 +443,12 @@ void Detector::setTenGiga(bool value, Positions pos) {
                     static_cast<int>(value));
 }
 
-Result<bool> Detector::getTenGigaGFlowControl(Positions pos) const {
+Result<bool> Detector::getTenGigaFlowControl(Positions pos) const {
     return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
                            defs::FLOW_CONTROL_10G, -1);
 }
 
-void Detector::setTenGigaGFlowControl(bool enable, Positions pos) {
+void Detector::setTenGigaFlowControl(bool enable, Positions pos) {
     pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
                     defs::FLOW_CONTROL_10G, static_cast<int>(enable));
 }

slsSupportLib/include/sls_detector_defs.h

@@ -360,7 +360,7 @@ format
         THIS_SOFTWARE_VERSION,     /**<return this software version */
         RECEIVER_VERSION,          /**<return receiver software version */
         SOFTWARE_FIRMWARE_API_VERSION, /** return software firmware API version
-                                          **/
+                                          */
         CLIENT_SOFTWARE_API_VERSION, /** return detector software and client api
                                         version */
         CLIENT_RECEIVER_API_VERSION  /** return client and  receiver api version