testing

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/test_virtual.py

@@ -0,0 +1,33 @@
+import pytest
+import subprocess
+import os
+import sys
+import time
+sys.path.append(os.path.join(os.getcwd(), 'bin'))
+from sls_detector import ExperimentalDetector
+
+@pytest.fixture(scope="module")
+def virtual_jf_detectors(request):
+    print('Setting up virtual detectors')
+    subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
+    virtual_jf_detectors = []
+    virtual_jf_detectors.append(subprocess.Popen('bin/jungfrauDetectorServer_virtual'))
+    time.sleep(5)
+    def fin():
+        print("Cleaning up virtual detectors")
+        subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
+        
+        
+
+    request.addfinalizer(fin)
+    return virtual_jf_detectors  # provide the fixture value
+
+
+def test_hostname(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    d.hostname = 'localhost'
+    assert d.hostname == 'localhost'
+
+def test_fwversion(virtual_jf_detectors):
+    d = ExperimentalDetector()
+    assert d.detectorversion == 0 #Firmware of virtual detector

python/sls_detector/experimental.py

@@ -1,4 +1,4 @@
-from _sls_detector import multiDetectorApi
+from _sls_detector import CppDetectorApi
 from _sls_detector import slsDetectorDefs
 
 runStatus = slsDetectorDefs.runStatus
@@ -35,20 +35,40 @@ 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):
+
+    def __init__(self, multi_id=0):
         """
         multi_id refers to the shared memory id of the 
         slsDetectorPackage. Default value is 0. 
         """
         super().__init__(multi_id)
 
+    # CONFIGURATION
+
+    @property
+    def hostname(self):
+        return element_if_equal(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())
+
     # Acq
     @property
     def rx_status(self):

python/src/experimental.cpp

@@ -8,25 +8,40 @@
 #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");
+    py::class_<Detector> CppDetectorApi(m, "CppDetectorApi");
-    multiDetectorApi
+    CppDetectorApi
         .def(py::init<int>())
 
+        // Configuration
+        .def("free", &Detector::freeSharedMemory)
+        .def("freeSharedMemory", &Detector::freeSharedMemory)
+        .def("loadConfig", &Detector::loadConfig)
+        .def("loadParameters", &Detector::loadParameters)
+        .def("getHostname", &Detector::getHostname, py::arg() = Positions{})
+        .def("setHostname", &Detector::setHostname)
+        .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)
+
+
         // Acq related
         .def("acquire", &Detector::acquire)
         .def("clearAcquiringFlag", &Detector::clearAcquiringFlag)
         .def("getReceiverStatus", &Detector::getReceiverStatus,
              py::arg() = Positions{})
 
-        // Configuration
-        .def("free", &Detector::freeSharedMemory)
-        .def("loadConfig", &Detector::loadConfig)
-        .def("getHostname", &Detector::getHostname, py::arg() = Positions{})
-
         // Bits and registers
         .def("setBit", &Detector::setBit, py::arg(), py::arg(),
              py::arg() = Positions{})
@@ -42,9 +57,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{})

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(