diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 93b70120b..ee5a58c7e 100755 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -46,4 +46,7 @@ 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 ) \ No newline at end of file diff --git a/python/scripts/basic.py b/python/scripts/basic.py index 2536d91ff..f61e472d2 100755 --- a/python/scripts/basic.py +++ b/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 diff --git a/python/scripts/generate_enums.py b/python/scripts/generate_enums.py new file mode 100644 index 000000000..3b7f3c3cc --- /dev/null +++ b/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_(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) diff --git a/python/scripts/test_virtual.py b/python/scripts/test_virtual.py new file mode 100644 index 000000000..e58d1c958 --- /dev/null +++ b/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 + + \ No newline at end of file diff --git a/python/sls_detector/__init__.py b/python/sls_detector/__init__.py index dc5202f13..e3070281e 100755 --- a/python/sls_detector/__init__.py +++ b/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 diff --git a/python/sls_detector/experimental.py b/python/sls_detector/experimental.py index 82a591219..a814ef54b 100755 --- a/python/sls_detector/experimental.py +++ b/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,20 +37,79 @@ 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 + + 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): @@ -95,7 +156,7 @@ class ExperimentalDetector(multiDetectorApi): """ return self.getAcquiringFlag() - + @busy.setter def busy(self, value): self.setAcquiringFlag(value) @@ -129,7 +190,7 @@ class ExperimentalDetector(multiDetectorApi): @property def fpath(self): return element_if_equal(self.getFilePath()) - + @fpath.setter def fpath(self, path): self.setFilePath(path) @@ -158,7 +219,10 @@ class ExperimentalDetector(multiDetectorApi): @exptime.setter def exptime(self, t): - self.setExptime(dt.timedelta(seconds=t)) + if isinstance(t, dt.timedelta): + self.setExptime(t) + else: + self.setExptime(dt.timedelta(seconds=t)) @property def subexptime(self): @@ -167,7 +231,10 @@ class ExperimentalDetector(multiDetectorApi): @subexptime.setter def subexptime(self, t): - self.setSubExptime(dt.timedelta(seconds=t)) + if isinstance(t, dt.timedelta): + self.setSubExptime(t) + else: + self.setSubExptime(dt.timedelta(seconds=t)) @property def period(self): @@ -176,5 +243,8 @@ class ExperimentalDetector(multiDetectorApi): @period.setter def period(self, t): - self.setPeriod(dt.timedelta(seconds=t)) + if isinstance(t, dt.timedelta): + self.setPeriod(t) + else: + self.setPeriod(dt.timedelta(seconds=t)) diff --git a/python/sls_detector/utils.py b/python/sls_detector/utils.py index b4f93fb12..fc0c6537a 100755 --- a/python/sls_detector/utils.py +++ b/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""" diff --git a/python/src/enums.cpp b/python/src/enums.cpp index 054690c59..0f5c15704 100644 --- a/python/src/enums.cpp +++ b/python/src/enums.cpp @@ -1,3 +1,6 @@ +/* WARINING This file is auto generated any edits might be overwritten without + * warning */ + #include #include #include @@ -7,6 +10,55 @@ namespace py = pybind11; void init_enums(py::module &m) { py::class_ Defs(m, "slsDetectorDefs"); + py::class_ xy(m, "xy"); + xy.def_readwrite("x", &slsDetectorDefs::xy::x); + xy.def_readwrite("y", &slsDetectorDefs::xy::y); + + py::enum_(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_(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_(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_(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_(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_(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_(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_(Defs, "dimension") + .value("X", slsDetectorDefs::dimension::X) + .value("Y", slsDetectorDefs::dimension::Y) + .export_values(); + + py::enum_(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_(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_(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_(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_(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_(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_(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_(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_(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_(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_(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_(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_(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(); } diff --git a/python/src/enums_in.cpp b/python/src/enums_in.cpp new file mode 100644 index 000000000..14657b462 --- /dev/null +++ b/python/src/enums_in.cpp @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +#include "sls_detector_defs.h" +namespace py = pybind11; +void init_enums(py::module &m) { + py::class_ Defs(m, "slsDetectorDefs"); + py::class_ xy(m, "xy"); + xy.def_readwrite("x", &slsDetectorDefs::xy::x); + xy.def_readwrite("y", &slsDetectorDefs::xy::y); + +[[ENUMS]] + +} diff --git a/python/src/experimental.cpp b/python/src/experimental.cpp index 7f7168876..f105c0da9 100644 --- a/python/src/experimental.cpp +++ b/python/src/experimental.cpp @@ -4,28 +4,247 @@ #include #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_ multiDetectorApi(m, "multiDetectorApi"); - multiDetectorApi + + py::class_ CppDetectorApi(m, "CppDetectorApi"); + CppDetectorApi .def(py::init()) - // 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("free", &Detector::freeSharedMemory) - .def("loadConfig", &Detector::loadConfig) - .def("getHostname", &Detector::getHostname, py::arg() = Positions{}) + .def("getFramesCaught", &Detector::getFramesCaught, + 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 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 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 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 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 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 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 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 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, diff --git a/sample/time.cpp b/sample/time.cpp new file mode 100644 index 000000000..20e7c4e6e --- /dev/null +++ b/sample/time.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include + +#include "Result.h" +#include "Detector.h" +#include "container_utils.h" +#include "ToString.h" +#include + +std::chrono::nanoseconds to_nano(double val, const std::string &unit) { + if (unit == "us") + return std::chrono::duration_cast( + std::chrono::duration(val)); + else if (unit == "ms") + return std::chrono::duration_cast( + std::chrono::duration(val)); + else if (unit == "s") + return std::chrono::duration_cast( + std::chrono::duration(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 res{1,0,6,4,0,4}; + + + // std::unique_ptr + auto d = sls::make_unique(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"; + +} \ No newline at end of file diff --git a/slsDetectorServers/mythen3DetectorServer/CMakeLists.txt b/slsDetectorServers/mythen3DetectorServer/CMakeLists.txt index de29c1221..faa66a8dc 100644 --- a/slsDetectorServers/mythen3DetectorServer/CMakeLists.txt +++ b/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/communication_funcs_UDP.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( diff --git a/slsDetectorSoftware/include/Detector.h b/slsDetectorSoftware/include/Detector.h index 55e341197..ff02f2456 100644 --- a/slsDetectorSoftware/include/Detector.h +++ b/slsDetectorSoftware/include/Detector.h @@ -365,10 +365,10 @@ class Detector { void setTenGiga(bool enable, Positions pos = {}); /** [Eiger, Jungfrau] */ - Result getTenGigaGFlowControl(Positions pos = {}) const; + Result getTenGigaFlowControl(Positions pos = {}) const; /** [Eiger, Jungfrau] */ - void setTenGigaGFlowControl(bool enable, Positions pos = {}); + void setTenGigaFlowControl(bool enable, Positions pos = {}); /** [Eiger, Jungfrau] */ Result getTransmissionDelayFrame(Positions pos = {}) const; diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp index ce4de21cd..0291c1ef6 100644 --- a/slsDetectorSoftware/src/Detector.cpp +++ b/slsDetectorSoftware/src/Detector.cpp @@ -443,12 +443,12 @@ void Detector::setTenGiga(bool value, Positions pos) { static_cast(value)); } -Result Detector::getTenGigaGFlowControl(Positions pos) const { +Result 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(enable)); } diff --git a/slsSupportLib/include/sls_detector_defs.h b/slsSupportLib/include/sls_detector_defs.h index 0492032da..1722c2ebe 100755 --- a/slsSupportLib/include/sls_detector_defs.h +++ b/slsSupportLib/include/sls_detector_defs.h @@ -360,7 +360,7 @@ format THIS_SOFTWARE_VERSION, /**